text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Сравнение AutoMapper и Mapster
Когда мы читаем/записываем/обрабатываем данные в приложении, то часто нужно переместить информацию между разными слоями приложения (прочитать из БД entity, преобразовать её в модель для api и отдать пользователю) или преобразовать данные в формат системы (при интеграциях). Всё это сводится к преобразованию объектов одного (исходного) типа в объекты другого (целевого) типа.
Для этого нужно сопоставлять наборы свойств, а часто и сложных объектов, содержащих другие объекты в качестве свойств. По мере роста приложения таких типов и преобразований становится всё больше, а код конвертации растекается по всему проекту и становится сложным в поддержке.
Использование автоматизированных инструментов преобразования объектов (object-object mapping) может помочь в организации кода и отделении ответственности за преобразования в отдельный изолированный уровень приложения.
[AutoMapper](https://automapper.org/) — самая популярная библиотека для маппинга объектов в dotnet — [NuGet-пакет](https://www.nuget.org/packages/AutoMapper) скачали больше 313 миллионов раз за 11 лет существования библиотеки.
[Mapster](https://github.com/MapsterMapper/Mapster) появился на 4 года позже AutoMapper и имеет 8.2 миллионов загрузок на nuget.org. Популярность отличается больше, чем на порядок, так зачем бы вообще смотреть на альтернативу AutoMapper? Дело в том, что Mapster обещает лучшую производительность и меньший объем памяти по сравнению с другими библиотеками маппинга объектов, поэтому стоит по крайней мере рассмотреть использование этой библиотеки и понять возможности для замены автомаппера на мапстер.
### Маппинг простых моделей
Давайте проверим сценарий, когда исходный и целевой типы имеют одинаковый набор свойств с одинаковыми именами, но различаются по типу свойств. Исходный тип User:
```
public class User
{
public int Id { get; set; }
public string Name { get; set; } = null!;
public bool IsActive { get; set; }
public string Email { get; set; } = null!;
public DateTime CreatedAt { get; set; }
}
```
Тип, в который мы будем преобразовывать юзера — UserDto:
```
public class UserDto
{
public int Id { get; set; }
public string Name { get; set; } = null!;
public bool IsActive { get; set; }
public string Email { get; set; } = null!;
public string CreatedAt { get; set; } = null!;
}
```
Мы видим, что единственное различие типов свойств в том, что `CreatedAt` для `User` имеет тип `DateTime`, а для `UserDto` тип `string`. В подобных ситуациях библиотеки маппинга выполняют неявное приведение типов.
Чтобы использовать AutoMapper, нам сначала нужно создать объект `IMapper`. Существует несколько способов его создания, например, можно использовать класс `MapperConfiguration`. Для этого достатчно указать исходный и целевой типы в качестве generic-параметров в методе `CreateMap()`. В нашем случае это `User` и `UserDto`:
```
var mapper = new MapperConfiguration(cfg => cfg.CreateMap())
.CreateMapper();
```
> В продакшен-коде, скорее всего, вы будете использовать [профили Автомаппера](https://docs.automapper.org/en/stable/Configuration.html#profile-instances) чтобы лучше организовать код и разделить ответственности, но для примера нам достаточно упрощенного механизма создания.
>
>
Создадим объект исхоного типа и преобразуем его в объект целевого типа с помощью `IMapper`:
```
var source = new User
{
Id = 1,
Name = "User 1",
Email = "test@example.com",
IsActive = true,
CreatedAt = DateTime.Now
};
UserDto destination = mapper.Map(source);
```
Чтобы смаппить объект в новый тип в AutoMapper нам нужно передать исходный объект в качестве параметра метода `Map`, а generic-параметром указать целевой тип для преобразования.
Если мы проверим значения переменной `destination`, то все значения свойств исходного объекта будут совпадать с значениями свойств объекта целевого типа и значение свойства `CreatedAt` будет неявно преобразовано к типу `string`:
```
{
"Id": 1,
"Name": "User 1",
"IsActive": true,
"Email": "test@example.com",
"CreatedAt": "14-10-2022 21:53:57"
}
```
В Mapster всё ещё проще. Для типов с совпадающими свойствами, где возможно неявное преобразование типов свойств, мы можем напрямую вызвать extension-метод `Adapt(this object source)` для объекта исходного типа с generic-параметром целевого типа:
```
var source = new User
{
Id = 1,
Name = "User 1",
Email = "test@example.com",
IsActive = true,
CreatedAt = DateTime.Now
};
UserDto destination = source.Adapt();
```
Ещё с помощью Mapster мы можем заполнить поля существующего объекта целевого типа из объекта исходного типа:
```
var destination = new UserDto();
source.Adapt(destination);
```
> Mapster предоставляет и другие способы для преобразования: `collection.ProjectToType()` для преобразования `IQueryable` коллекций, экземпляр `IMapper` для DI, source generator для явной реализации мапперов.
>
>
В этом примере значения объекта целевого типа будут совпадать с теми, что получены с помощью AutoMapper.
Маппинг сложных моделей
-----------------------
Чаще всего польза маппинга раскрывается, когда мы начинаем преобразовывать сложные объекты, свойства которых содержат другие объекты, которые тоже нужно преобразовывать. Чтобы проиллюстрировать такой пример добавим ещё один тип для адреса:
```
public class Address
{
public string AddressLine1 { get; set; } = null!;
public string AddressLine2 { get; set; } = null!;
public string City { get; set; } = null!;
public string State { get; set; } = null!;
public string Country { get; set; } = null!;
public string ZipCode { get; set; } = null!;
}
```
И добавим свойство с типом `Address` в тип `User`:
```
public class User
{
public int Id { get; set; }
public string FirstName { get; set; } = null!;
public string LastName { get; set; } = null!;
public string Email { get; set; } = null!;
public Address Address { get; set; } = null!;
}
```
Для простоты примера типы `UserDto` и `AddessDto` будут содержать аналогичный набор свойств.
Библиотеки маппинга должны преобразовывать все типы на любом уровне на своем пути (в том числе приводить типы неявно, если такое преобразование существует). В нашем случае необходимо сопоставить и `User`, и `Address` с соответствующими целевыми типами.
В AutoMapper нам понадобится при создании `MapperConfiguration` задать преобразование для всех типов, которые будут участвовать в маппинге:
```
var mapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap();
cfg.CreateMap();
})
.CreateMapper();
```
Код самого преобразования останется без изменений:
```
UserDto destination = mapper.Map(source);
```
В Mapster предварительная конфигурация всё ещё не нужна — поскольку исходный и целевой типы имеют одинаковые свойства, а свойство `Address` в целевом типе имеет тип `AddressDto`, который имеет набор свойств аналогичный (или неявно преобразуемый) типу `Address`. Поэтому всё ещё достаточно вызывать метод-расширение `Adapt`:
```
UserDto destination = source.Adapt();
```
Маппинг коллекций
-----------------
Часто нам нужно маппить список или массив одного типа в другой. Для этого нам просто нужно указать в качестве generic-параметра метода маппинга `List`, `TDestination[]` или что-то подобное. Каких-то других специальных настроек для работы этой функции не требуется.
В AutoMapper нам все еще нужно указать конфигурацию маппинга для типов элеметов коллекций:
```
var mapper = new MapperConfiguration(cfg => cfg.CreateMap())
.CreateMapper();
var sourceList = new List() { ... };
List destinationList = mapper.Map>(sourceList);
```
В Mapster мы можем напрямую вызвать метод `Adapt`, указав в качестве generic-параметра `List`:
```
var sourceList = new List() { ... };
List destinationList = sourceList.Adapt>();
```
Настройка маппинга свойств
--------------------------
Перейдём к более сложным сценариям — например, когда набор свойств исходного и целевого типов не совпадают и нам нужно настроить пользовательское преобразование. Для примера сделаем тип пользователя с именем и фамилией и целевой тип с одним свойством полного имени:
```
public class User
{
public string FirstName { get; set; } = null!;
public string LastName { get; set; } = null!;
}
public class UserDto
{
public string FullName { get; set; } = null!;
}
```
Библиотеки маппинга не могут неявно вывести правила для отображения свойств, поэтому нам нужно задать это отображение явно.
Для этого в AutoMapper метод `CreateMap` позволяет с помощью fluent interface задать дополнительные настройки маппинга свойств методом `ForMember`:
```
var mapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap()
.ForMember(
dest => dest.FullName,
config => config.MapFrom(src => $"{src.FirstName} {src.LastName}"
));
});
```
В Mapster можно использовать статический класс `TypeAdapterConfig` для задания правил маппинга свойств. Указываем исходный и целевой типы generic-параметрами, создаем новую конфигурацию с помощью метода `NewConfig()` и используем похожий на Автомаппер fluent-интерфейс для задания маппинга свойств:
```
TypeAdapterConfig
.NewConfig()
.Map(dest => dest.FullName, src => $"{src.FirstName} {src.LastName}");
```
Разворачиваем сложные модели (object flattening)
------------------------------------------------
Мы можем сопоставить свойства вложенных объектов со свойствами верхнего уровня, используя простое соглашение об именовании. Например, вложенное свойство `Address.ZipCode` из исходного типа `User` может быть отображено на свойство `AddressZipCode` в целевом типе `UserDto`. Это позволит сделать плоскую модель из сложного исходного объекта.
```
public class User
{
public Address Address { get; set; } = null!;
}
public class Address
{
public string ZipCode { get; set; } = null!;
}
public class UserDto
{
public string AddressZipCode { get; set; } = null!;
}
```
Такой же результат можно получить, если в исходном типе есть метод с именем `Get(DestinationPropertyName)`. Например, метод GetFullName() будет сопоставлен со свойством FullName:
```
public class User
{
public string FirstName { get; set; } = null!;
public string LastName { get; set; } = null!;
public string GetFullName() => $"{FirstName} {LastName}";
}
public class UserDto
{
public string FullName { get; set; } = null!;
}
```
Такие соглашения об именовании по-умолчанию работают и в AutoMapper, и в Mapster.
Двухсторонний маппинг в сложные модели (unflattening)
-----------------------------------------------------
Библиотеки маппинга имеют функциональность настройки двухстороннего маппинга, когда из объекта целевого типа мы хотим получить объект исходного. В случае прямого преобразования из сложного объекта в плоский (flattening), обратное преобразование (Reverse Mapping) подразумевает получение сложной модели из плоского представления.
В AutoMapper это можно сделать с помощью метода `ReverseMap()` в конфигурации маппера:
```
var mapper = new MapperConfiguration(cfg => cfg
.CreateMap()
.ReverseMap())
.CreateMapper();
```
В Mapster из-за конфигурации по-умолчанию при совпадении свойств типов задавать возможность обратного преобразования не нужно. Если свойства типов отличаются и нужно [задать двухстороннее преобразование явно](https://github.com/MapsterMapper/Mapster/wiki/Two-ways), то можно использовать в конфигурации метод `TwoWay()`. Этот метод так же включает преобразование плоских моделей в сложные, которое не работает по-умолчанию:
```
TypeAdapterConfig
.NewConfig()
.TwoWays()
.Map(dest => dest.EmailAddress, src => src.Email);
```
Конфигурация с помощью атрибутов
--------------------------------
До сих пор мы рассматривали fluent-конфигурацию в коде для разных сценариев. Чаще всего используется именно этот способ, он позволяет отделить логику маппинга между типами от самих типов. Но AutoMapper и Mapster предоставляют ещё один способ конфигурирования преобразований — атрибуты для задания параметров маппинга.
В AutoMapper есть [целый набор атрибутов](https://docs.automapper.org/en/stable/Attribute-mapping.html) для разных сценариев: `AutoMap`, `Ignore`, `ReverseMap`, `SourceMember` и другие:
```
public class User
{
public DateTime CreatedAt { get; set; }
}
[AutoMap(typeof(User))]
public class UserDto
{
[SourceMember("CreatedAt")]
public string CreatedDate { get; set; } = null!;
}
```
Кроме разметки типов атрибутами AutoMapper требует явно добавить маппинги из атрибутов с помощью метода AddMaps(), который принимает на вход сборку, в которой будет идти поиск типов с атрибутами для маппинга:
```
var mapper = new MapperConfiguration(cfg => cfg.AddMaps(typeof(User).Assembly))
.CreateMapper();
```
Mapster предоставляет [свой набор аналогичных атрибутов](https://github.com/MapsterMapper/Mapster/wiki/Setting-by-attributes): `AdaptTo`, `AdaptFrom`, `AdaptTwoWays`, `AdaptMember` и другие. Аналогичный предыдущему примеру код будет выгядеть так:
```
public class User
{
public DateTime CreatedAt { get; set; }
}
public class UserDto
{
[AdaptMember("CreatedAt")]
public string CreatedDate { get; set; } = null!;
}
```
### Dependency Injection
AutoMapper предоставляет NuGet-пакет [AutoMapper.Extensions.Microsoft.DependencyInjection](https://www.nuget.org/packages/AutoMapper.Extensions.Microsoft.DependencyInjection/), который позволяет добавить `IMapper` в `IServiceCollection` и сконфигурировать его с помощью метода `AddAutoMapper`. Есть много перегрузок, позволяющих добавить конфигурацию явно или подтянуть все настройки по сборкам.
```
serviceCollection.AddAutoMapper(c =>
{
c.AddProfile(typeof(UserProfile));
c.AddProfile(typeof(AddressProfile));
c.CreateMap();
});
// или так
serviceCollection.AddAutoMapper(typeof(User).Assembly);
```
У Mapster похожий способ подключения — нужно добавить NuGet-пакет [Mapster.DependencyInjection](https://www.nuget.org/packages/Mapster.DependencyInjection/) и зарегистрировать в контейнере типы `TypeAdapterConfig` и `ServiceMapper`:
```
var config = new TypeAdapterConfig();
// или
// var config = TypeAdapterConfig.GlobalSettings;
// ...
services.AddSingleton(config);
services.AddScoped();
```
После этого мы можем использовать интерфейс `IMapper` в качестве зависимости:
```
public class SampleService
{
private readonly IMapper mapper;
public SampleService(IMapper mapper)
{
this.mapper = mapper;
}
}
```
Сравнение производительности AutoMapper и Mapster
-------------------------------------------------
Для тестов производительности будем использовать [BenchmarkDotNet](https://benchmarkdotnet.org/). Исходный код бенчмарка и результаты есть на [github](https://github.com/RndDotNet/ObjectMapping).
Для подготовки данных используется NuGet-пакет [Bogus](https://github.com/bchavez/Bogus), который умеет генерить данные подходящих типов:
```
var faker = new Faker()
.Rules((f, o) =>
{
o.Id = f.Random.Number();
o.Name = f.Name.FullName();
o.Email = f.Person.Email;
o.IsActive = f.Random.Bool();
o.CreatedAt = DateTime.Now;
});
return faker.Generate(count);
```
Почти все бенчмарки устроены одинаково — для подготовленного списка из 1000 элементов исходного типа они поэлементно маппят объекты на целевой тип:
```
[Benchmark(Description = "AutoMapper_SimpleMapping")]
public void AutoMapperSimpleObjectMapping()
{
for (var i = 0; i < Size; i++)
{
var destination = Mapper.Map(Source[i]);
}
}
[Benchmark(Description = "Mapster\_SimpleMapping")]
public void MapsterSimpleObjectMapping()
{
for (var i = 0; i < Size; i++)
{
var destination = Source[i].Adapt();
}
}
```
Есть тесты на простые модели, маппинг списков, сложные модели с вложенностью, flattening и unflattening, модели с настройкой маппера для определенных свойств, модели с разметкой атрибутами. Результаты бенчмарка для dotnet 7:
```
| Method | Mean | Error | StdDev | Ratio | Allocated |
|--------------------------------- |----------:|---------:|----------:|-------:|----------:|
| AutoMapper_SimpleMapping | 304.29 us | 0.855 us | 11.594 us | 1.290 | 109.38 KB |
| Mapster_SimpleMapping | 235.87 us | 0.628 us | 8.492 us | 1.000 | 109.38 KB |
| AutoMapper_ListMapping | 208.90 us | 0.234 us | 2.949 us | 1.021 | 125.59 KB |
| Mapster_ListMapping | 204.54 us | 0.357 us | 4.846 us | 1.000 | 117.24 KB |
| AutoMapper_NestedMapping | 128.83 us | 0.285 us | 6.069 us | 2.079 | 117.19 KB |
| Mapster_NestedMapping | 61.94 us | 0.262 us | 2.914 us | 1.000 | 117.19 KB |
| AutoMapper_FlattenedMapping | 88.15 us | 0.197 us | 2.666 us | 2.862 | 23.44 KB |
| Mapster_FlattenedMapping | 30.79 us | 0.054 us | 0.735 us | 1.000 | 23.44 KB |
| AutoMapper_CustomPropertyMapping | 175.77 us | 0.517 us | 6.859 us | 1.551 | 73.96 KB |
| Mapster_CustomPropertyMapping | 113.29 us | 0.291 us | 3.951 us | 1.000 | 73.78 KB |
| AutoMapper_ReverseMapping | 118.53 us | 0.244 us | 3.495 us | 2.576 | 46.88 KB |
| Mapster_ReverseMapping | 46.00 us | 0.140 us | 1.595 us | 1.000 | 46.88 KB |
| AutoMapper_AttributeMapping | 301.95 us | 0.698 us | 9.207 us | 1.296 | 85.94 KB |
| Mapster_AttributeMapping | 232.81 us | 0.543 us | 7.349 us | 1.000 | 85.94 KB |
```
Mapster превосходит AutoMapper по скорости работы во всех сценариях, на большинстве сценариев на 30-50%, а в некоторых сценариях больше, чем в 2 раза. При этом потребление памяти или не изменяется, или уменьшается.
Выводы
------
Mapster — зрелая библиотека, которая имеет функциональность сопоставимую с AutoMapper. Во многих сценариях Mapster проще в настройке из-за того, что нет необходимости явно задавать исходный и целевой типы для моделей до тех пор, пока не требуется дополнительных настроек маппинга свойств. По производительности Mapster превосходит AutoMapper во всех сценариях, а в некоторых дает и выигрыш в количестве потребляемой памяти. Библиотека существует уже 7 лет, имеет много пользователей и продолжает развиваться. В [разных бенчмарках](https://github.com/ChokriHadiri/Benchmark-Dotnet-Mappers) Mapster занимает первое место по производительности среди библиотек object-object маппинга.
Это не значит, что нужно обязательно заменять AutoMapper на Mapster во всех своих проектах. Mapster — хорошая альтернатива, о которой полезно знать и уметь с ней работать.
* [Mapster Github](https://github.com/MapsterMapper/Mapster)
* [Mapster wiki](https://github.com/MapsterMapper/Mapster/wiki/)
* [Оригинал статьи на CodeMaze](https://code-maze.com/automapper-vs-mapster-dotnet/) | https://habr.com/ru/post/693828/ | null | ru | null |
# Работа с буфером обмена в Linux: теория и практика
#### Совсем немного теории
Исторически сложилось так, что в X Window System (X11, — оконная система для Linux, UNIX) существует два буфера обмена.
Один из них (clipboard) похож на буфер обмена в Windows — при нажатии на Ctrl+Insert или Ctrl+C выделенный фрагмент (текст, картинка, файл) копируется в буфер обмена, а при нажатии на Shift+Insert (или Ctrl+V) — вставляется из него. Следует заметить, что во многих программах эти сочетания зарезервированы для иных целей и приходится пользоваться другими — например, в терминале сочетание Ctrl+C используется для завершения процесса, а для работы с буфером обмена используются сочетания Ctrl+Shift+C для копирования и Ctrl+Shift+V для вставки.
Второй буфер (primary) является специфичным для оконной системы X11. Выделенный текст незамедлительно попадает в буфер primary, и для того, чтобы вставить скопированный текст, достаточно лишь нажать среднюю кнопку мышки (колёсико). У кого в наличии не имеется трёхкнопочной мышки, а так же владельцам ноутбуков с тачпадами следует одновременно нажать левую и правую кнопки мышки для вставки текста.
Обычно эти буферы не связаны друг с другом (некоторые программы некорректно их обрабатывают и считают, что это один и тот же буфер обмена). Следовательно, хранящиеся в них данные не влияют друг на друга, что, несомненно, крайне удобно. Следует заметить, что при закрытии программы, из которой были скопированы данные, содержимое буфера обмена теряется.
#### Практика
Для решения проблемы утери данных из буфера обмена при закрытии программы существует сторонний софт. Например, [Clipboard Daemon](http://members.chello.nl/~h.lai/gnome-clipboard-daemon/). Этот маленький демон держит содержимое буфера обмена в памяти независимо от того, было ли закрыто приложение, из которого скопированы данные.
Для более комфортной работы с буфером обмена существует целый ряд программ:* [Parcellite](http://parcellite.sourceforge.net/) — многообещаюший менеджер буфера обмена на GTK
* [glipper](http://glipper.sourceforge.net/) — для Gnome
* [klipper](http://dir.filewatcher.com/d/Debian/m68k/kde/klipper_3.3.2-1_m68k.deb.211188.html) — для KDE
* [wmcliphist](http://linux.nawebu.cz/wmcliphist/) — для Window Maker
* и куча других (в том числе для Windows, Mac OS и прочего).
Эти программы позволяют существенно облегчить работу — они хранят историю содержимого буферов обмена — в любой момент можно вернуться к любому из предыдущих состояний (в пределах разумного, конечно, — этот предел, как водится, устанавливается в настройках) и воспользоваться им =)
Существует так же весьма и весьма полезная в умелых руках утилита под названием [xclip](http://sourceforge.net/projects/xclip), предназначенная для работы с буферами обмена из командной строки. Копирование и вставка текста осуществляется простыми командами, что позволяет использовать её в различного рода вспомогательных скриптах, примеры которых я продемонстрирую ниже.
К сожалению, официальная версия xclip у меня с кириллицей корректно не заработала, несмотря на то, что я собирал последнюю версию. Поэтому я предлагаю скачать и собрать [версию xclip для дистрибутива Alt Linux](http://sisyphus.ru/cgi-bin/srpm.pl/Sisyphus/xclip/getsource/0).
#### Скрипты
Я предлагаю два скрипта, которые смогут облегчить вашу повседневную работу. Первый скрипт:
> `xclip -o | sed -r '2~1d;s/(^\s+|\s+$)//g;s/%/%25/g;s/#/%23/g;s/\$/%24/g;s/&/%26/g;s/\+/%2B/;s/,/%2C/g;s/:/%3A/g;s/;/%3B/g;s/=/%3D/g;s/\?/%3F/g;s/@/%40/g;s/\s/+/g' | awk '{print "http://www.google.ru/search?hl=ru&q=" $1}' | xargs firefox -new-tab`
Он открывает вкладку в Firefox, переходит на страничку google с поисковой фразой, являющейся содержимым вашего буфера обмена. Для работы со скриптом достаточно выделить любое слово, словосочетание или предложение и запустить скрипт (я рекомендую назначить выполнение этого скрипта на горячие клавиши — например, у меня это сочетание Win+G). Рассмотрим его чуть подробнее:1. Программа xclip выводит содержимое буфера обмена (параметр «-o»).
2. Далее это содержимое передаётся текстовому редактору sed, который удаляет все строки, кроме первой (в случае, если они были) и заменяет все специальные символы на их безопасный для адресной строки вариант (urlencode).
3. Обработанная строка передаётся программе awk, которая, в свою очередь, добавляет полученную поисковую фразу к ссылке google.
4. Ссылка открывается в новой вкладке Firefox. Всё =)
Второй скрипт чуть проще, и логически следует из первого:
> `xclip -o | sed -n 1p | xargs firefox -new-tab`
Он открывает новую вкладку в Firefox с адресом, который находится в буфере обмена (очень часто нужно открыть ссылку в виде простого текста — например, если ссылка встретилась в текстовом редакторе — приходится её копировать, открывать вкладку в браузере и вставлять скопированный адрес. Скрипт делает всё за вас ;). Я назначил его на сочетание Win+F.
Благодаря тому, что буфер обмена является универсальной для ОС сущностью, эти скрипты будет работать везде — от терминала и текстового редактора до самого Firefox'а (впрочем, желающие могут настроить этот же скрипт и для альтернативных браузеров. Назначить скриптам сочетание кнопок можно как с помощью вашего windows manager'а (например, gconf-editor для Gnome), так и с помощью сторонних программ, таких как xmodmap или actkbd.
#### Что дальше?
Да что угодно =) Можно переводить фразы, выделенные мышкой, можно копировать их в программу для заметок — всё зависит от вашей фантазии и потребностей. Конечно, для таких вещей могут существовать отдельные программы, но такие вот самописные скрипты, на мой взгляд, для любого пользователя окажутся удобнее всего — linux тем и хорош, что можно всё, абсолютно всё настроить под себя и для себя.
**Update**: добавлена ссылка на менеджер буфера обмена Parcellite — спасибо хабрапользователю [drujebober](https://habrahabr.ru/users/drujebober/)
**Update 2**: по просьбе хабраюзера [dimaka](https://habrahabr.ru/users/dimaka/) добавил скрипты для перевода:
Lingvo.yandex.ru:
> `xclip -o | sed -r '2~1d;s/(^\s+|\s+$)//g;s/%/%25/g;s/#/%23/g;s/\$/%24/g;s/&/%26/g;s/\+/%2B/;s/,/%2C/g;s/:/%3A/g;s/;/%3B/g;s/=/%3D/g;s/\?/%3F/g;s/@/%40/g;s/\s/+/g' | awk '{print "lingvo.yandex.ru/en?st_translate=on&text=" $1}' | xargs firefox -new-tab`
Google translate (перевод с английского на русский):
> `xclip -o | sed -r '2~1d;s/(^\s+|\s+$)//g;s/%/%25/g;s/#/%23/g;s/\$/%24/g;s/&/%26/g;s/\+/%2B/;s/,/%2C/g;s/:/%3A/g;s/;/%3B/g;s/=/%3D/g;s/\?/%3F/g;s/@/%40/g;s/\s/+/g' | awk '{print "translate.google.com/translate_t?hl=ru#en|ru|" $1}' | xargs firefox -new-tab`
**Update 3**: Добавление пункта «копировать полный путь текущего файла» в меню Midnight Commander (Добавить в файл ~/.mc/menu):
> `+ ! t t
> f Copy full filename into clipboard
> echo -n %d/%f | xclip` | https://habr.com/ru/post/48954/ | null | ru | null |
# Расширяем возможности Asterisk, используя PHP
Все слышали про мини-АТС нового поколения имя которой Asterisk. Так уж случилось что я заинтересовался этой системой и даже успел сделать пару коммерческих проектов.
В этой статье я хочу немного расказать об интеграции звездочки с языком программирования php. При этом мы будем использовать класс [phpagi](http://phpagi.sourceforge.net/).
Под катом я приведу примеры использования нескольких методов этого класса которые помогли мне.
Первым делом качаем последнюю версию phpagi и подключаем его в наш проект, а так же правим файл /etc/asterisk/manager.conf
```
;
; Asterisk Call Management support
;
[general]
enabled = yes ; Включаем asterisk manager interface (AMI)
port = 5038
bindaddr = 127.0.0.1 ; Доступ только с локалхоста для безопастности
webenabled = no
; Each user has a section labeled with the username
; so this is the section for the user named "mark"
[user] ; имя пользователя для конекта
secret = qwerty ; пароль
deny=0.0.0.0/0.0.0.0 ; еще запреты на коннект
permit=127.0.0.1/255.255.255.0
read = system,call,log,verbose,command,agent,user,originate ; Права пользователя на выполнение комманд
write = system,call,log,verbose,command,agent,user,originate
```
В архиве с phpagi есть файл phpagi.conf, его нужно скопировать в */etc/asterisk* и естественно исправить логин и пароль.
Теперь мы можем смело подключатся к AMI из php скрипта, например так:
```
include('phpagi.php');
$manager = new AGI_AsteriskManager();
$manager->connect(); // если нет файла phpagi.conf то тут можно указать хост, логин, пароль.
```
Первым делом я хотел бы расказать о написании простейшего монитора событий asterisk на php.
Как мне кажется это самая полезная функция класса phpagi.
Вот такой у меня вышел монитор событий:
```
function dump_events($ecode,$data,$server,$port) {
$date_now = date('Y-m-d');
$time_now = date('H:i:s');
echo "$time_now : received event '$ecode' from $server:$port\n";
print_r($data);
}
include('phpagi.php');
$manager = new AGI_AsteriskManager();
$manager->connect();
$manager->add_event_handler('*', 'dump_events'); // цепляем хендлер на все события которые
// поступают из AMI и передаем управление
// функции описанной выше
$manager->wait_response(); // очень полезная вещь, благодаря этой функции скрипт будет
// ждать событий и не стопится в отличии от sleep()
$manager->disconnect();
```
Используя этот хендлер можно выполнять какие нибудь действия в зависимости от полученного эвента, например проверять баланс на sim-карте вставленной в модем huawei и подключенной через chan\_dongle.
Приведу пример своей реализации используя метод **Command**:
Первый скрипт ловит событие newussd
```
function donglenewussd($ecode, $data) {
if($model = Trunk::model()->find('value = :value', array(
':value' => $data['Device']))){
if(!empty($data['MessageLine0'])){
$balance = explode(' ', $data['MessageLine0']);
switch($model->carrier){
case '0':
break;
case '1':
$model->balance = $balance[0];
$model->save();
echo $balance[0]."\n";
break;
case '2':
$model->balance = $balance[2];
$model->save();
echo $balance[2]."\n";
break;
case '3':
preg_match('/[+-]?\d+\.?\d*/', $balance[1], $match);
$model->balance = $match[0];
$model->save();
echo $match[0]."\n";
break;
}
}
}
}
$manager = new AGI_AsteriskManager();
$manager->connect();
$manager->add_event_handler('donglenewussd', 'donglenewussd');
$manager->wait_response();
$manager->disconnect();
```
Этот скрипт получает событие donglenewussd в котором нам приходит ответ от оператора на основе которого мы заносим в базу информацию о состоянии баланса.
Следующий скрипт будет по крону скажем раз в час отправлять ussd запрос на проверку баланса.
```
$manager = new AGI_AsteriskManager();
$manager->connect();
$trunks =Trunk::model()->findAll();
foreach($trunks as $trunk){
switch($trunk->carrier){
case '1':
$manager->Command('dongle ussd '.$trunk->value.' *101#');
break;
case '2':
$manager->Command('dongle ussd '.$trunk->value.' *111#');
break;
case '3':
$manager->Command('dongle ussd '.$trunk->value.' *111#');
break;
}
}
$manager->disconnect();
```
Как вы могли заметить я испоьзую yii framework для своих проектов, у меня есть модель в которой хранятся настройки модема (системное имя, оператор, баланс, состояние и т.д.)
Данный пример работает с Украинскими операторами (МТС, Киевстар и Life)
И на десерт я хочу Вам расказать про метод **Originate**. Вы еще используете call файлы? тогда мы идем к Вам.
Очень полезная функция которая инициирует звонок используя AMI, а не старый дедовский способ путем копирования call файла в директорию */var/spool/asterisk/outgoing*
Все параметры передаваемые в функцию почти такие же как и параметры call файла:
```
$manager->Originate(
'Канал для вызова, например SIP/1001',
'Экстеншн для диалплана',
'Контекст диалплана',
'Приоритет контекста диалплана',
'Или приложение астериска для запуска, например playback',
'параметры приложения, например путь к аудиофайлу',
'таймаут',
'Номер абонента от которого идет вызов или имя',
'переменные для диалплана',
'account - незнаю зачем, не использовал еще',
'Синхронный или асинхронный запрос (ждет или не ждет ответа о состоянии запроса)',
'actionid - тоже пока не использовал'
);
```
Ну а что делать с этой функцией я думаю Вы придумаете сами, а если совместить ее с менеджером событий то можно еще и получить отчет о выполнении исходящего звонка.
Надеюсь моя статья окажется кому нибудь полезной, так как я не нашел упоминание phpagi на хабре, да и вообще с трудом нашел хоть какие нибудь примеры использования кроме тех что идут в архиве с библиотекой.
Если у кого то есть другие методы работы с этой библиотекой очень буду рад почитать о них в коментариях. | https://habr.com/ru/post/155111/ | null | ru | null |
# «Конкурс параллельного программирования Accelerate 2012» или «6 ультрабуков и 10 SSD хватит всем!»
[](http://software.intel.com/ru-ru/articles/contest-accelerate-2012-main/)
Всем привет!
Последняя неделя на Хабре ознаменовалась серией хакерских постов — взламывали как [VoIP](http://habrahabr.ru/post/141966/), так и [онлайн-пробки](http://habrahabr.ru/company/dsec/blog/142166/).
Предлагаю продолжить неделю более созидательно — решить [задачу мирового масштаба](http://software.intel.com/ru-ru/articles/contest-accelerate-2012-problem/) ~~по генетике~~ по параллельному программированию.
Сделать за месяц надо всего ничего: **найти в двух строках, состоящих из ~~нуклеотидов~~ символов A, T, G и C, максимально длинную общую подстроку**.
Призы по сравнению с предыдущим разом подросли и окрепли — сегодня на кону **6 ультрабуков** [Asus Zenbook UX31E](http://www.asus.com/Notebooks/Superior_Mobility/ASUS_ZENBOOK_UX31E/) и **10 SSD-дисков** суммарной емкостью 800 гигов.
Заманчиво?
#### О чем речь?
Вам дана reference-строка (например, такая: `GATGAGCATGTGTTGAATCCTCA`) и много длинных input-строк (вот одна из них: `GTCCTCCAGTTTGTAGCATGTGTATTTATGTCCTCCAGTTTGTAGCATGTGTATTTAT`). Нужно для каждый пары из reference- и input-строк найти максимально длинные общие подстроки и вернуть их «координаты». В примере ответом будет `(5 13 15 23)` и `(5 13 44 52)`, то есть найдены две подстроки:
```
#код на Питоне, строки в ответе должны нумероваться от единицы, поэтому '-1'
ref = 'GATGAGCATGTGTTGAATCCTCA'
input = 'GTCCTCCAGTTTGTAGCATGTGTATTTATGTCCTCCAGTTTGTAGCATGTGTATTTAT'
ref[(5 - 1):13] == input[(15 - 1):23] #True
ref[(5 - 1):13] == input[(44 - 1):52] #True
```
В вашем распоряжении есть [референсный код](http://intel-software-academic-program.com/contests/ayc/early2012/ayc.zip), который правильно, но очень медленно решает данную задачу брутфорсом.
Звучит просто?
#### Как решать?
Здесь начинается самое интересное. Предложу несколько вариантов, которые могут быть полезны:
* Самый простой способ: распараллелить референсный код по данным, например, используя OpenMP и поделив работу над входными тестами между потоками. Но делить работу можно по-разному. Только входные строки? Фрагменты референсной строки? Это сильно зависит от их размеров и количества — решать вам.
* Более интересный способ: взять референсный код, прогнать его через [Intel VTune Amplifier XE](http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/) и распараллелить по-умному сам алгоритм
* Более умный подход: взять [один из более чем 9000 алгоритмов поиска подстроки в строке](http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8#.D0.90.D0.BB.D0.B3.D0.BE.D1.80.D0.B8.D1.82.D0.BC.D1.8B) и попытаться найти лучше всего подходящий под эту задачу
* Самый продвинутый подход: объединить предыдущие пункты, взяв умный алгоритм и распараллелить его как по инструкциям, так и по данным
#### Что же выбрать? Хочу подсказку!
Что вам выбрать, мы посоветовать не можем. Кому-то нравится писать на pthreads, кому-то на OpenMP, а кто-то любит использовать параллельные функции из TBB и может быть даже MKL.
Одно известно наверняка — на нашем [форуме](http://software.intel.com/ru-ru/forums/accelerate-2012/) часто обсуждаются очень умные идеи и мысли. Например, стоит посмотреть на инструкции в SSE4.2.
#### На чем можно писать?
К сожалению, наша автоматическая система тестирования слишком молода для поддержи всех языков программирования.
В этот раз мы научили ее понимать C++ (несмотря на мою искреннюю любовь к питону и Java Script), поэтому писать придется на старом добром C++.
Платформа разработки может быть любой, но собираться и тестироваться код будет на машине с Linux (Debian stable — kernel 2.6.32) с установленным gcc (версия 4.6.2 для любителей pthreads) и Intel Parallel Studio XE 2011 (для тех, кто выбирает Intel Compiler, оптимизирующий код под наши процессоры).
#### А что с призами? Я хочу ультрабук!
Первым трем командам, написавшим самый быстрый код и отправившим решение до 16 мая, мы подарим по [Asus Zenbook UX31E](http://software.intel.com/ru-ru/articles/contest-accelerate-2012-main/#prize) на участника.
Вторым трем командам — по [SSD 320 Series 80Gb](http://software.intel.com/ru-ru/articles/contest-accelerate-2012-main/#prize).
Еще 4 участникам, которые напишут нам самые интересные посты в [блоги Intel Software Network](http://software.intel.com/ru-ru/blogs/), также достанутся SSD.
Итак, еще раз: [одна задача](http://software.intel.com/ru-ru/articles/contest-accelerate-2012-problem/), один месяц, [6 ультрабуков и 10 SSD](http://software.intel.com/ru-ru/articles/contest-accelerate-2012-main/#prize) для лучших участников из России и СНГ.
Всем, кто [решит поучаствовать](http://software.intel.com/ru-ru/articles/contest-accelerate-2012-registration/), желаем удачи!
Организаторы и судьи конкурса готовы ответить на любые ваши вопросы в комментариях. | https://habr.com/ru/post/142312/ | null | ru | null |
# Python: потоки по-другому
Введение
--------
Знаете, почему я решил написать эту статью? Я писал программу, где использовал потоки. Во время работы с ними в *Python* всё больше убеждаешь себя, что тут с ними всё плохо. Нет, не то, чтобы они плохо работали. Просто использовать их, мягко говоря, неудобно. Я решил написать простую, но более удобную библиотеку, и здесь поделюсь процессом.
P.S.: В конце оставлю ссылку на *GitHub*
Первые шаги
-----------
Первое, с чего я решил начать - это удобное создание потоков из функций. Для этого я написал простенький декоратор, выглядит он так:
```
# thr.py
from threading import Thread as thrd
__all__ = ['Thr']
# Класс для всего содержимого либы
class Thr:
# Собственно, декоратор
def thread(fn):
def thr(*args, **kwargs):
thrd(target = fn, args = (*args,), kwargs={**kwargs,}).start()
pass
return thr
pass
# конец файла
```
Вот и всё. Теперь можно очень удобно создавать потоки:
```
from thr import Thr
# пример использования
@Thr.thread
def func1(a, b, c):
if a+b > c:
if a+c > b:
if b+c > a:
print("треугольник существует")
pass
pass
pass
print("треугольник не существует")
pass # возвращение значений пока не предусмотрено
for a, b, c in zip(range(1, 10), range(6, 15), range(11, 20)):
func1(a, b, c)
pass
```
Удобнее чем было, так ведь? Но мне стало мало.
Среды для потоков
-----------------
Мне стало не удобно обеспечивать верное взаимодействий потоков. Например, мне надо чтобы 2 цикла решали последовательности чисел для *3n+1*. Тогда, мне приходилось мучить *Python* глобальными переменными. И я нашел выход!
P.S.: Возможно, это и есть *ThreadPoolExecutor*, которым я никогда не пользовался. Если это так, то, возможно, просто кому-то мой метод покажется удобнее.
Давайте объясню. Вы создаёте среду для потоков(можно несколько) и **немного** адаптируете потоковые функции под себя. код библиотеки:
```
# thr.py
from curses.ascii import isalnum
from threading import Thread as thrd
from random import randrange
from sys import exit as exitall
__all__ = ['Thr']
# f-str не позволяет использовать "\" напрямую,
# пришлось выкручиваться =)
nl = "\n"
bs = "\b"
tb = "\t"
rt = "\r"
# просто полезная функция
def strcleanup(s: str = ""):
while s[0] == ' ': s = s[1:]
while s[-1] == ' ': s = s[:-1]
if not isalnum(s[0]): s = '_' + s
s = s.replace(' ', '_')
for i in range(len(s)):
if not isalnum(s[i]):
s = s.replace(s[i], '_')
pass
pass
s += f"{randrange(100, 999)}"
return s
# Класс для всего содержимого либы
class Thr:
# класс для сред потоков
class Env(object):
# поля
# потоки
thrs: list = None
# возвращаемые значения
rets: dict = None
# название среды
name: str = None
# методы
# инициализация
def __init__(self, name):
self.thrs = []
self.rets = {}
self.__name__ = self.name = name
# self.name на всякий случай.
# __name__ - магическая переменная, вдруг поменяется.
pass
# в строку
__str__ = lambda self:\
f"""ThreadSpace "{self.name}": {len(self.thrs)} threads"""
# тоже в строку, но скорее для дебага, чем для печати юзеру
__repr__ = lambda self:\
f"""ThreadSpace "{self.name}"
threads:
{(nl+" ").join(self.thrs)}
total: {len(self.thrs)}
"""
def __add__(self, other):
self.thrs = {**self.thrs, **other.thrs}
pass
# Декоратор/метод для добавления в список потоков.
def append(self, fn):
# функции нужен docstring
ID = strcleanup(fn.__doc__.casefold())
self.thrs += [ID]
self.rets[ID] = None
#
class Thrd(object):
ID = None
space = None
fn = None
thr = None
runned = None
ret = None
def __init__(slf, ID, self, fn):
slf.ID = ID
slf.space = self
slf.fn = fn
slf.thr = None
slf.runned = False
slf.ret = False
pass
def run(slf, *args):
if slf.runned:
print(f"Exception: Thread \"{slf.ID[:-3]}\" of threadspace \"{slf.space.name}\" already started")
exitall(1)
pass
slf.thr = thrd(target = slf.fn, args = (slf, slf.space, slf.ID, *args,))
slf.thr.start()
slf.runned = True
pass
def join(slf):
if not slf.runned:
print(f"Exception: Thread \"{slf.ID[:-3]}\" of threadspace \"{slf.space.name}\" not started yet")
exitall(1)
pass
slf.thr.join()
slf.runned = False
pass
def get(slf):
if not slf.ret:
print(f"Exception: Thread \"{slf.ID[:-3]}\" of threadspace \"{slf.space.name}\" didn`t return anything yet")
exitall(1)
pass
slf.runned = False
return slf.space.rets[slf.ID]
def getrun(slf, *args):
slf.run(*args)
slf.join()
return slf.get()
pass
return Thrd(ID, self, fn)
pass
# Декоратор для "голого" потока
def thread(fn):
def thr(*args, **kwargs):
thrd(target = fn, args = (*args,), kwargs={**kwargs,}).start()
pass
return thr
pass
# конец файла
```
Пример вывода об ошибке:
```
Traceback (most recent call last):
File "test.py", line 37, in
loop.run()
File "thr.py", line 93, in run
raise Exception(...)
Exception: Thread "3n\_1\_mainloop" of threadspace "3n+1" already started
```
Как быстро вырос объём кода по сравнению с предыдущим вариантом! Итак, пример использования:
```
from random import randint
from thr import Thr
Space = Thr.Env("3n+1")
@Space.append
def hdl(t, spc, ID, num):
"""3n+1_handle"""
if num % 2 == 0:
# значения возвращать так
t.ret = True
spc.rets[ID] = num/2
return
# значения возвращать так
t.ret = True
spc.rets[ID] = 3*num+1
return
@Space.append
def loop(t, spc, ID, num):
"""3n+1_mainloop"""
steps = 0
while num not in (4, 2, 1):
num = hdl.getrun(num)
steps += 1
pass
# значения возвращать так
t.ret = True
spc.rets[ID] = steps
return
print()
print(Space)
print()
print(repr(Space))
ticks = 0
num = randint(5, 100)
loop.run(num)
while not loop.ret:
ticks += 1
pass
print(f"loop reached 4 -> 2 -> 1 trap,\n"
f"time has passed (loop ticks):\n"
f"{ticks}, steps has passed: {loop.get()}, start number: {num}")
```
Вывод:
```
ThreadSpace "3n+1": 2 threads
ThreadSpace "3n+1"
threads:
3n_1_handle840
3n_1_mainloop515
total: 2
loop reached 4 -> 2 -> 1 trap,
time has passed (loop ticks):
13606839, steps has passed: 33, start number: 78
```
Итак, на этом и завершу эту статью. Спасибо за внимание!
[GitHub](https://github.com/vanosoft/ModernThreading) | https://habr.com/ru/post/659935/ | null | ru | null |
# Пайплайн для Spring REST приложения. Часть 2
### Стадия для сборки артефакта на сервере
Следующие три стадии уже непосредственно используют подключенный к проекту shell gitlab-runner, поэтому в них блок tags уже носит не декоративный характер, а действительно используется gitlab для выбора, на каком именно runner запускать текущую стадию.
Прежде чем продолжать, следует привести файл build.gradle приложения. Так будет удобнее делать пояснения к отдельным стадиям.
```
plugins {
id 'org.springframework.boot' version '2.7.4'
id 'io.spring.dependency-management' version '1.0.12.RELEASE'
id 'java'
id "com.dorongold.task-tree" version '2.1.0'
id 'nebula.integtest' version '9.6.2'
id 'com.google.cloud.tools.jib' version '3.3.0'
id 'org.sonarqube' version '3.4.0.2513'
id 'jacoco'
}
jacocoTestReport {
reports {
xml.enabled true
}
}
test.finalizedBy jacocoTestReport
tasks.named('sonarqube').configure {
dependsOn test
}
sonarqube {
properties {
property "sonar.projectKey", "your project key"
property "sonar.qualitygate.wait", true
property 'sonar.organization', 'your organization'
property 'sonar.login', 'your sonar login'
}
}
group = 'com.yamangulov'
version = '0.0.1'
sourceCompatibility = '11'
repositories {
mavenCentral()
}
ext {
set('testcontainersVersion', "1.17.3")
}
configurations {
compileOnly {
extendsFrom annotationProcessor
}
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-actuator'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'io.springfox:springfox-boot-starter:3.0.0'
implementation 'org.liquibase:liquibase-core:4.14.0'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
runtimeOnly 'org.postgresql:postgresql'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.testcontainers:junit-jupiter'
testCompileOnly 'org.projectlombok:lombok'
testAnnotationProcessor 'org.projectlombok:lombok'
integTestImplementation 'org.springframework.cloud:spring-cloud-contract-wiremock:2.1.3.RELEASE'
integTestImplementation 'org.testcontainers:postgresql'
implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.13.4'
implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.13.4'
}
dependencyManagement {
imports {
mavenBom "org.testcontainers:testcontainers-bom:${testcontainersVersion}"
}
}
tasks.named('test') {
useJUnitPlatform()
}
tasks.named('integrationTest') {
useJUnitPlatform()
}
tasks.named('bootJar') {
launchScript()
}
```
Конкретно на данной стадии нас интересуют строка `id 'com.google.cloud.tools.jib' version '3.3.0'`
Это ничто иное, как подключение специального плагина, который позволяет создать из проекта docker-образ вашего приложения и поместить его в локальное хранилище. После установки плагина у вас появятся новые таски в gradle, одна из которых используется для этой операции:
Разумеется, вы можете воспользоваться этой таской для того, чтобы локально вручную запускать сборку образа в локальное хранилище, причем при каждом запуске будет собираться новая версия образа, что можно увидеть по изменению хэша образа с одним и тем же именем, под которым вы его собираете. Но для нас это будет разрыв пайплайна для одной ручной операции, в то время как вполне можно запустить любую таску gradle прямо из пайплайна, оформив это, как отдельную стадию. Вот пример того, как это можно сделать (добавим новую стадию к предыдущей):
```
stages:
- feature
- feature-artefact
feature development:
tags:
- feature
stage: feature
image: gradle:7.5.0-jdk11
script:
- cd rest-service
- ./gradlew assemble
feature docker image:
tags:
- feature
stage: feature-artefact
script:
- cd rest-service
- ./gradlew jibDockerBuild
```
Обратите внимание, что во второй стадии отсутствует секция image - в этом случае gitlab не будет создавать среду исполнения стадии "у себя", а обратится к зарегистрированным для этого проекта runner и выберет из них именно тот, который имеет тэг feature, и попытается запустить стадию на нем. Если это shell runner, то стадия будет выполняться в терминале сервера, на котором runner зарегистрирован, под специальной учетной записью gitlab-runner, автоматически создаваемой при регистрации. Здесь следует отметить, что нужно внимательно следить за тем, чтобы не возникало конфликтов runner, зарегистрированных для проекта - а именно, советую делать так, чтобы тэги не пересекались, то есть каждый уникальный тэг имелся только у одного runner (что не запрещает одному runner иметь несколько разных тегов, если это зачем-то нужно), если пересекающихся по тэгам раннеров больше одного, насколько мне известно, gitlab пайплайн вполне может запуститься, но выберет тэг для исполнения стадии случайным образом. Поэтому лучше не экспериментируйте, и следите за этим моментом строго.
### Стадия развертывания стенда для тестирования фичи и очистка кубера после тестирования
Для настройки следующей стадии нам потребуется helm chart для того, чтобы было удобно развертывать и, при необходимости, уничтожать тестовые стенды в kubernetes всякий раз, когда нам это нужно. Хотя это и уводит немного в сторону, сделаем краткое отступление о том, как я это делал. Очень часто java-разработчики (и не только) в процессе работы создают для удобства файл docker-compose.yml с набором взаимосвязанных сервисов, необходимых для отладки и тестирования приложения. Например, нужна база данных, нужно поднять миграции в приложении для нее, нужно провести после этого модульное тестирование и так далее. Затем может потребоваться перенести всю эту конструкцию в kubernetes. Кто-то имеет большой опыт и пишет деплойменты "на лету". Для меня же удобнее оказалось воспользоваться helm, а деплойменты сконвертировать из docker-compose.yml файла при помощи удобного средства kompose <https://kompose.io/getting-started/>. В частности, я воспользовался командой:
`kompose -f docker-compose.yml convert -c`
После создания чарта helm можно воспользоваться им для развертывания стендов - хоть тестировочных, хоть продуктовых, как вам угодно. И разумеется, поскольку это все выполняется консольными командами, почему бы не использовать их в очередной стадии, что я и сделал. Вот как это выглядит:
```
stages:
- feature
- feature-artefact
- feature-install-stand
feature development:
tags:
- feature
stage: feature
image: gradle:7.5.0-jdk11
script:
- cd rest-service
- ./gradlew assemble
feature docker image:
tags:
- feature
stage: feature-artefact
script:
- cd rest-service
- ./gradlew jibDockerBuild
feature install stand:
tags:
- feature
stage: feature-install-stand
script:
- cd rest-service/.chart/
- helm install docker-compose-feature docker-compose --namespace=yamangulov-feature --values=docker-compose/values-yamangulov-feature.yaml
```
Чтобы было понятнее содержание скрипта, приведу скриншот структуры моего helm чарта:
Не углубляясь в детали, скажу, что в нем используются шаблоны с подстановками, которые позволяют создавать отдельные конфигурации в разных namespace, если задать соответствующие входные параметры для команды helm. Например, на этой стадии мы создаем отдельный набор подов для моего приложения командой:
`helm install docker-compose-feature docker-compose --namespace=yamangulov-feature --values=docker-compose/values-yamangulov-feature.yaml`
То есть в данном случае мы создаем чарт с именем docker-compose-feature из шаблона чарта docker-compose в пространстве имен yamangulov-feature, подгружая при этом дополнительный файл values-yamangulov-feature.yaml, содержащий дополнительные значения переменных для шаблона именно в этом namespace. Поскольку содержание шаблона чарта и чартов может быть интересным и полезным для многих, а также для изложения некоторых планируемых стадий пайплайна, приведу его содержание [полностью](https://disk.yandex.ru/d/l2adv3hgJ2a9Rg).
Теперь, если мы запустим пайплайн (для этого достаточно внести какое-то изменение в проект и запушить его в gitlab), мы увидим, как выполняются все стадии одна за другой. Выглядит это примерно так:
зеленым цветом отмечаются успешно пройденные стадии пайплайна, красным - ошибки, после чего пайплайн останавливается, коричневый цвет с восклицательным знаком - особые стадии с некритическими ошибками, в которых пайплайн не останавливается, а переходит в выполнению следующей стадии несмотря на возникновение ошибок (это нам пригодится чуть позже)
Теперь, если мы проверим kubernetes, мы увидим наш развернутый в нужном namespace чарт:
Ну вот, казалось бы, все нормально, стенд для тестирования фичи развернут, и его можно предоставить тестировщикам для проверки развернутого приложения. И действительно это так, но только на первый взгляд все в порядке. А теперь давайте представим себе, что тестирование показало какие-то недостатки и проект возвращен на доработку. Разработчик исправил недостатки и снова запушил проект в gitlab. Пайплайн запустился на выполнение снова, и тут вы увидите, что он вываливается с ошибкой! В логе ошибки кубер сообщает вам что такой чарт уже существует и отказывается создавать его заново. Ага, вы меняете команду следующим образом:
`helm upgrade docker-compose-feature docker-compose --install --namespace=yamangulov-feature --values=docker-compose/values-yamangulov-feature.yaml`
то есть вы указываете helm обновить чарт, если он существует и создать заново, если он не существует. Должно работать, но в данном случае не работает. Вы снова получите ошибку, и содержание ее расскажет вам, что при выполнении команды helm upgrade не удается пересоздать уже созданные ingress хосты с определенными именами в предыдущем запуске чарта. Существует вот такая особенность helm и мы ее обнаружили. Чтобы решить эту проблему, самый простой и очевидный способ - вставить перед стадией развертывания стадию удаления нашего чарта при условии, если чарт существует и был ранее установлен - вот тогда гарантированно удаляются созданные ingress хосты вместе с остальными элементами чарта, то есть чарт удаляется абсолютно полностью начисто, что нам и нужно для чистоты свежего развертывания, чтобы не осталось никаких следов от предыдущего. Вот так теперь будет выглядеть наш исправленный пайплайн:
```
stages:
- feature
- feature-artefact
- feature-clean-stand
- feature-install-stand
feature development:
tags:
- feature
stage: feature
image: gradle:7.5.0-jdk11
script:
- cd rest-service
- ./gradlew assemble
feature docker image:
tags:
- feature
stage: feature-artefact
script:
- cd rest-service
- ./gradlew jibDockerBuild
feature clean stand:
tags:
- feature
stage: feature-clean-stand
allow_failure: true
script:
- cd rest-service/.chart
- helm uninstall docker-compose-feature --namespace=yamangulov-feature
feature install stand:
tags:
- feature
stage: feature-install-stand
script:
- cd rest-service/.chart/
- helm install docker-compose-feature docker-compose --namespace=yamangulov-feature --values=docker-compose/values-yamangulov-feature.yaml
```
Здесь команда `helm uninstall docker-compose-feature --namespace=yamangulov-feature` как раз и служит для полного предварительного удаления чарта перед его новой установкой, если он уже существовал. В стадии feature-clean-stand есть еще одна особенность - если стенд НЕ существовал на момент ее выполнения, то уже УДАЛЕНИЕ стенда вываливается с ошибкой, в результате чего обычная стадия остановит весь пайплайн, что нам совсем не нужно. Поэтому в стадию добавлена опция
`allow_failure: true`
которая как раз и заставит стадию работать так, как нам нужно. Если стенд уже был удален ранее (например, DevOps "пошалил" и удалил его вручную, либо же пайплайн запускается в самой первой итерации при разработке фичи, когда стенд вообще еще ни разу не создавался), при ошибке мы увидим в пайплайне как раз тот самый коричневый цвет с восклицательным знаком, и пайплайн спокойно перейдет к следующей стадии без остановки.
В продолжении статьи будет рассказано о том, как я делал стадии для выполнения тестов в sonarqube, smoke и регрессионного тестирования
Также рекомендую к посещению два бесплатных урока от OTUS, которые пройдут уже совсем скоро:
* 2 ноября. **"Scope бинов в Spring"**. Расскажем, какие бывают Scope и для чего они могут понадобится. На примере проследим как работает Scope "Request", и, если успеем, разберем создание своего собственного Scope. [Зарегистрироваться](https://otus.ru/lessons/javaspring/?utm_source=habr&utm_medium=affilate&utm_campaign=java_spring&utm_term=28.10.2022#event-2417).
* 9 ноября. **"Spring Actuator"**. В процессе занятия пройдёмся по метрикам и конечным точкам для работы с приложением. Ощутим мощь актуатора и даже напишем свой "индикатор здоровья". [Зарегистрироваться](https://otus.pw/LHqu/). | https://habr.com/ru/post/695040/ | null | ru | null |
# Использование Selenium WebDriver для автоматического тестирования веб-интерфейса Яндекс.Почты
Без качественного тестирования невозможно разрабатывать и поддерживать крупный веб-сервис. На ранних этапах его развития часто можно обходиться только ручным тестированием по заданному тест-плану, но с появлением новых фич и увеличением количества тест-кейсов довольствоваться только им становится все сложнее и сложнее. В этой статье мы расскажем о том, как автоматизируем функциональное тестирование веб-интерфейса Яндекс.Почты с помощью Selenium WebDriver и Node.js.
Помимо [Selenium WebDriver](https://code.google.com/p/selenium) существует ещё несколько решений для автоматического тестирования веб-интерфейсов, среди которых [Watir](http://watir.com), [Zombie.js](http://zombie.labnotes.org), [PhantomJS](http://phantomjs.org). Но именно он стал практически стандартом. Во-первых, он имеет хорошую функциональность. А во-вторых, для него есть драйверы подо все распространённые браузеры — в том числе и мобильные — и платформы, чего не скажешь о headless-инструментах (Zombie.js, PhantomJS).
А почему именно Node.js? Потому что все фронтенд-разработчики Яндекс.Почты знают JavaScript, а именно они разрабатывают интерфейс и понимают, где и что в нём меняется от релиза к релизу.
#### Установка и настройка
Для установки и настройки Selenium WebDriver на локальной машине понадобятся:
1. Java (<http://www.java.com/en/download>).
2. Selenium server (скачать standalone версию можно тут — [https://code.google.com/p/selenium/downloads/lis](https://code.google.com/p/selenium/downloads/list)).
3. Node.js + npm (<http://nodejs.org/download>).
4. ChromeDriver (для тестирования в Google Chrome). Качается отсюда: [code.google.com/p/chromedriver/downloads/list](http://code.google.com/p/chromedriver/downloads/list).
После установки всех зависимостей нужно:
1. Установить selenium-webdriver для Node.js:
```
npm install selenium-webdriver -g
```
2. Запустить selenium server:
```
java -jar selenium-server-standalone-{VERSION}.jar
```
#### Первый тест
Для примера, напишем простой тест (test.js):
```
var wd = require('selenium-webdriver');
var assert = require('assert');
var SELENIUM_HOST = 'http://localhost:4444/wd/hub';
var URL = 'http://www.yandex.ru';
var client = new wd.Builder()
.usingServer(SELENIUM_HOST)
.withCapabilities({ browserName: 'firefox' })
.build();
client.get(URL).then(function() {
client.findElement({ name: 'text' }).sendKeys('test');
client.findElement({ css: '.b-form-button__input' }).click();
client.getTitle().then(function(title) {
assert.ok(title.indexOf('test — Яндекс: нашлось') > -1, 'Ничего не нашлось :(');
});
client.quit();
});
```
По коду все довольно просто:
1. Подключаем selenium-webdriver;
2. Инициализируем клиент с указанием нужного браузера и передачей хоста, на котором у нас висит selenium-server;
3. Открываем [www.yandex.ru;](http://www.yandex.ru;)
4. После загрузки вводим в поисковой строке (`) посимвольно “test” и кликаем на кнопку (она будет найдена по CSS-селектору ‘.b-form-button__input');`
Получаем тайтл страницы результатов поиска и ищем в нем подстроку 'test — Яндекс: нашлось'.
[docs.seleniumhq.org](http://docs.seleniumhq.org) — документация по Selenium.
[code.google.com/p/selenium/wiki/WebDriverJs](https://code.google.com/p/selenium/wiki/WebDriverJs) — документация по WebDriver.js.
[dvcs.w3.org/hg/webdriver/raw-file/default/webdriver-spec.html](https://dvcs.w3.org/hg/webdriver/raw-file/default/webdriver-spec.html) — черновик спецификации WebDriver API. | https://habr.com/ru/post/173769/ | null | ru | null |
# Оптимизация для начинающих, или о пользе профилирования
Попалась мне задача написать на PHP оптимальный алгоритм вставки нового значения в упорядоченный массив. Причем аргументировано доказать, что именно этот алгоритм лучший. Для этого предлагалось написать три варианта и выбрать из них лучший. Конечно же я знаю, что лучший метод поиска — бинарный, но раз сказали доказать, что он лучший, так и быть, напишу еще два. С таким настроем и уверенностью в будущем результате я и принялся кодить.
Что из этого получилось приглашаю начинающих программистов почитать, а опытных обсудить.
Задача
------
Есть достаточно большой (10 тыс. элементов) упорядоченный массив с числами. Надо оптимальным образом вставить в него новое значение сохранив упорядоченность.
Варианты решения
----------------
Самый простой способ — вставить в конец и пересортировать встроенной функцией. Но изначально стояло условие так не делать.
Что же надо сделать, чтобы вставить новое значение? Для начала найти нужную позицию. С учетом размера массива, вероятно, это будет самая ресурсоемкая часть. А затем вставить это значение в найденную позицию. Значит надо написать 3 варианта поиска этой самой позиции. В качестве подопытных кроликов берем: перебор, бинарный поиск, поиск с интерполяцией (похож на бинарный, только делим не пополам, а пытаемся более точно угадать позицию).
Кому не интересно, программный код функций поиска можно пропустить.
#### Поиск перебором
```
function insertBruteForce(&$array, $value)
{
function insertBruteForce(&$array, $value)
{
foreach($array as $position => $test) {
if ($test >= $value) {
break;
}
}
insertTo($array, $position, $value);
}
```
#### Бинарный поиск
```
function insertBinary(&$array, $value)
{
$begin = 0;
$end = count($array) - 1;
while ($end - $begin > 1) {
$position = round(($begin + $end) / 2);
if ($array[$position] > $value) {
$end = $position;
} elseif ($array[$position] < $value) {
$begin = $position;
} else {
break;
}
}
if ($array[$position] < $value) {
++$position;
}
insertTo($array, $position, $value);
}
```
Он имеет несколько странный вид из-за того, что ищем не точное значение, а позицию между элементами.
#### Поиск с интерполяцией
```
function insertInterpolation(&$array, $value)
{
$begin = 0;
$end = count($array) - 1;
while ($end - $begin > 1) {
$range = $array[$end] - $array[$begin];
$percentPosition = ($value - $array[$begin]) / $range;
$position = $begin + round(($end - $begin) * $percentPosition);
$position = min($position, $end);
if($array[$position] <= $value && (!isset($array[$position+1]) || $array[$position+1] >= $value)) {
break;
} elseif ($array[$position] > $value) {
$end = $end != $position ? $position : $position - 1;
} elseif ($array[$position] < $value) {
$begin = $begin != $position ? $position : $position + 1;
}
}
if ($array[$position] < $value) {
++$position;
}
insertTo($array, $position, $value);
}
```
#### Вставка значения в найденную позицию
Ну это должно быть просто (как я тогда думал). Однако в PHP нет встроенной функции вставки нового значения в заданную позицию, есть только замещение значения. Не страшно, воспользуется тем, что есть — разрежем, вставим значение и склеим. Это же не перебор массива, сделать надо только раз, используем встроенные функции, они же быстро работают.
```
function insertTo(&$array, $position, $value)
{
$array = array_merge(array_slice($array, 0, $position), array($value), array_slice($array, $position));
}
```
***Как оказалось позже, так делать не следует.***
Результаты тестирования
-----------------------
Быстренько пишу код для генерации случайного массива с данными, тест для многократного запуска и сбора статистики. И вот тут случилось нечто странное. Результат был примерно таким:
> insertBruteForce: 0.0088
>
> insertBinary: 0.0088
>
> insertInterpolation: 0.0087
>
>
Отсутствие разницы между бинарным поиском и интерполяцией еще можно объяснить. Но почему простой перебор дает такой же результат? Увеличение массива соотношение сил не меняет.
Профайлинг спешит на помощь
---------------------------
Стало понятно, что обычный замер времени на эти вопросы не ответит. Что ж, Xdebug уже установлен и настроен, осталось только включить в нем профилирование и посмотреть, что же происходит.
И тут меня снова ждал сюрприз. Основную часть времени занимал не поиск позиции, а вставка нового элемента в найденную позицию. При этом время выполнения самого поиска уже мало влияло не результат.
Значит надо переписать функцию вставки. Вместо разрезать и склеить пробую раздвинуть и вставить.
```
function insertDown(&$array, $value)
{
$i = count($array);
for ($i = $i - 1; $i >= 0 && $array[$i] < $value; --$i) {
$array[$i+1] = $array[$i];
}
$array[$i] = $value;
}
```
***Уже лучше, но все еще не правильно.***
Такой вариант работает на 40% быстрее да и памяти расходует меньше. И результат получился таким:
> insertBruteForce: 0.0052
>
> insertBinary: 0.0053
>
> insertInterpolation: 0.0053
>
>
А теперь еще раз смотрим на последнюю функцию. Что она делает? Она отодвигает элементы пока не дойдет до нужной позиции. А действительно ли ей заранее надо знать позицию?
#### Поиск и вставка в одном флаконе
```
function insertDown(&$array, $value)
{
$i = count($array);
for ($i = $i - 1; $i >= 0 && $array[$i] >= $value; --$i) {
$array[$i+1] = $array[$i];
}
$array[$i] = $value;
}
```
Результат: всего одна простая функция (да, с перебором) и время прохождения тестов за 0.0049 сек., пока что лучший результат.
О пользе коллективного разума
-----------------------------
**Добавлено на следующий день**
В результате обсуждения здесь товарищами и мной самим в коде были выявлены ошибки, которые я допустил во время его правок (начальный вариант я протестировал, но затем начал эксперименты). Уже исправил и вставил в текст обновленные результаты.
[PQR](http://habrahabr.ru/users/pqr/) подсказал заменить функцию вставки значения такой:
```
function insertTo(&$array, $position, $value)
{
array_splice($array, $position, 0, $value);
}
```
Оказывается функция вставки в PHP есть, но она является частью более универсальной. Результат теста:
> insertBruteForce: 0.0035
>
> insertBinary: 0.0036
>
> insertInterpolation: 0.0037
>
> insertDown: 0.0047
>
>
Еще лучше, но все еще странно.
[SerafimArts](http://habrahabr.ru/users/serafimarts/) предложил использовать класс SplFixedArray вместо обычного массива. Пробую. Функцию вставки пришлось правда снова сделать «ручной»:
```
function insertTo($array, $position, $value)
{
$size = $array->count();
$array->setSize($size + 1);
for ($i = $size - 1; $i >= $position; --$i) {
$array[$i+1] = $array[$i];
}
$array[$position] = $value;
}
```
Рузультат:
> insertBruteForce: 0.0033
>
> insertBinary: 0.0019
>
> insertInterpolation: 0.0018
>
> insertDown: 0.0026
>
>
У всех вариантов время выполнения уменьшилось. И что самое интересное, результат именно тот, что ожидался изначально и именно такой как нас учили в универе.
Эпилог
------
Знания и предположения — это хорошо, но надо проверять, что же происходит на практике. Правильный инструмент для этого не общепринятый:
```
$start = microtime(true);
<какой-то код>
$time = microtime(true) - $start;
```
а профайлинг. Хотя и вышеприведенный метод может быть полезен, все же профилирование дает более подробную информацию и собирает статистику не только там где вы это явно указали (хотя так тоже можно).
Во время экспериментов с кодом надо ~~быть очень внимательным~~ писать автоматические тесты. В моем случае это бы исключило ряд допущенных во время его правок ошибок.
**Всем комментаторам большое спасибо за подсказки и высказанные предположения.** | https://habr.com/ru/post/242309/ | null | ru | null |
# Современное SEO: AMP-истории
Да, вот такой гибридный, русско-английский заголовок получился… Поэтому давайте сразу кое-что проясним. Итак, если *SEO* широко известный (в узких кругах) термин, то *AMP* — ещё не столь. *Accelerated Mobile Pages* был анонсирован *Google* в 2015 г. (см. статью в [*Википедии*](https://ru.wikipedia.org/wiki/Accelerated_mobile_pages)), как инструмент, позволяющий быстро просматривать веб-страницы на мобильных телефонах. Со временем [*AMP*](https://amp.dev/) превратился в фреймворк, позволяющий создавать страницы для любых сайтов (не только для мобильных устройств), и расширил свою «номенклатуру»: собственно сайты ([*AMP Websites*](https://amp.dev/about/websites/)), истории ([*AMP Stories*](https://amp.dev/about/stories/); тема этой статьи), рекламные блоки ([*AMP Ads*](https://amp.dev/about/ads/)), и электронные письма ([*AMP email*](https://amp.dev/about/email/)). За всем этим, как было сказано выше, стоит *Google*, и если вас интересует продвижение сайтов в этой поисковой машине — полезно будет отнестись к теме *AMP* с должным вниманием. Но давайте сначала посмотрим как выглядят эти самые *AMP-истории* (**UPD**: с 1 мая 2020 [*AMP Stories* переименованы в *Web Stories*](https://blog.amp.dev/2020/05/01/web-stories-powered-by-amp/), поэтому теперь по-русски их лучше называть *Веб-истории*), затем решим нужны ли они нам, и, если окажется, что нужны — рассмотрим как это сделать.
Пример AMP-истории
------------------
Кликните по QR-коду, чтобы посмотреть как выглядит *AMP-история* на реальном сайте с настольного компьютера или ноутбука, или сосканируйте его, чтобы просмотрите эту же страницу с мобильного устройства (смартфона и/или планшета):
[](https://olegovpohod.ru/stories/nizkie-zvezdi-leta/)
**Это не реклама**
*Прошу не относится к этому фрагменту статьи как к рекламе. Просто я посчитал необходимым показать использование AMP-историй на «продакшн» сайте. Хотя, если вам понравится, и вы запишитесь в поход — будет хорошо и для вас, и для маленького бизнеса моего доброго знакомого Олега Самотолкова — энтузиаста и пассионария походов, путешествий и Крыма.*
На компьютере или ноутбуке вы должны увидеть такую «историю»:
А на планшете и смартфоне такую:
Кому это подходит
-----------------
Использовать *AMP-истории* хорошо там, где несколькими кадрами (рекомендуется от 7 до 20, но это не строгое правило) можно передать смысл и красоту услуги или продукта. Например, тот же туризм и путешествия, отели (покажите номера, зоны отдыха, SPA), мода (покажите коллекцию одежды), рестораны и кафе (покажите интерьеры и блюда), салоны красоты (покажите… красоту). В общем смысл должен быть понятен, а каждый владелец бизнеса лучше меня знает, что ему следует показывать.
Как это влияет на поисковую оптимизацию (SEO)
---------------------------------------------
Тенденция поисковых алгоритмов по моему мнению сегодня такова, что на ранжирование сайта всё меньше влияют ссылки с других сайтов (хотя, да, по-прежнему влияют), а всё больше следующие факторы (не обязательно в перечисленном порядке):
* Скорость загрузки страниц
* Адаптация к мобильным устройствам
* Наличие структурированных данных
* Наличие обильного контента
* Долгая история сайта
Первые три пункта из этого списка доступны для быстрой оптимизации, поэтому давайте рассмотрим их подробнее.
### Скорость загрузки страниц
Взгляните на этот скриншот из документации *Google*, и прочитайте подчёркнутое (или кликните на изображение, чтобы перейти к этому документу):
[](https://developers.google.com/search/docs/guides/about-amp)
Технология *AMP* с самого начала была разработана именно для увеличение скорости загрузки страниц на мобильных устройствах. Для этих целей, на мобильные устройства *Google* загружает *AMP-страницы* не с вашего сервера, а из своего кеша (*Google AMP Cache*). То есть *Google* предварительно сохраняет вашу *AMP-страницу* (в данном случае *AMP-историю*) у себя, и затем быстро отдаёт её пользователям мобильных устройств с помощью своей мощной глобальной сети серверов, т.н. *CDN* — *Content Delivery Network*.
Правда, это справедливо лишь для страниц, открываемых на мобильных устройствах (страницы, открываемые с компьютера, по-прежнему будут грузиться с вашего сервера), но мы знаем, что адаптация к мобильным устройствам очень важна, поскольку сегодня пользователи заходят на сайты с мобильных устройств чаще, чем с традиционных компьютеров и ноутбуков. Итак, с помощью технологии *AMP* мы решаем проблему скорости загрузки страниц (по крайней мере на мобильных устройствах), которая удовлетворяет жёстким требованиям *Google*. И это уже не мало! Но в документации также сказано и про: "*иллюстрированные статьи **в результатах Google поиска***", коими, очевидно, названы *AMP-истории* (взгляните на первое предложение на скриншоте, или кликните на изображение, чтобы перейти к этому документу):
[](https://developers.google.com/search/docs/guides/about-amp)
Из данного контекста можно сделать вывод, что *Google* в своём поиске выделяет им (т.е. "*иллюстрированным статьям*") специальное место в поисковой выдаче! Так почему бы не занять это место и вашим историям? Но технология *AMP-историй* ещё достаточно новая, и *Google* не раз объявлял о поэтапном её внедрении в результаты поисковой выдачи — по регионам планеты и темам самих историй. Но, я знаю, что вы знаете, когда лучше всего готовить сани… Кроме того, наличие на вашем сайте в качестве контента *AMP-историй* со структурированными данными просто не может остаться незамеченным (если мы всё правильно сделаем; об этом читайте далее) алгоритмами *Google*, и, очень даже вероятно, что это благотворно повлияет на позиции всего сайта в его поисковой выдаче.
А пока давайте проверим на [*Валидаторе AMP страниц от Google*](https://search.google.com/test/amp) можно ли считать нашу историю корректной *AMP-страницей* с точки зрения самого *Google*:
Да, всё ОК. Обратите внимание, что внизу на данном скриншоте сказано и о том что "*На странице найдены действительные структурированные данные*". К ним мы ещё вернёмся, но сначала давайте проверим, адаптирована ли наша *AMP-история* к мобильным устройствам.
### Адаптация к мобильным устройствам
Для этой проверки есть ещё один инструмент от *Google* — [*Проверка оптимизации для мобильных устройств*](https://search.google.com/test/mobile-friendly). Проверяем:
Всё ОК. И, честно сказать, я почему-то это знал заранее.
### Наличие структурированных данных
Если посмотреть в документацию *Google*, то там можно обнаружить довольно большой раздел, посвящённый структурированным данным (кликните на изображение, чтобы перейти к этому документу):
[](https://developers.google.com/search/docs/guides/intro-structured-data)
Очевидно, что *Google* придаёт им существенное значение. Поскольку мы заинтересованы в *Google* не менее чем он в нас, давайте не будем отказывать ему в таких пустяках, и сделаем как он хочет. Если посмотреть на код нашей *AMP-истории*, то там, в разделе *head*, можно найти следующий фрагмент:
Как видите — ничего сложного. В документации *Google* сказано, что предпочитаемый формат *JSON-LD* — хорошо, делаем `type="application/ld+json"`.
Далее документация говорит, что предпочтительный стандарт `http://schema.org` — принимаем и это.
А дальше всё очевидно и интуитивно понятно. Поясню только что:
— пути к файлам здесь можно указывать как относительные так и абсолютные;
— *datePublished* и *dateModified* при первой публикации совпадают, а в случае изменении контента — меняем только значение поля *dateModified*;
— формат полей *datePublished* и *dateModified* именно такой как показано, причём *+3* — это смещение времени в часах от Гринвича (*GMT — Greenwich Mean Time*), в данном случае имеется в виду московское время;
— в качестве *image* (здесь это файл *poster.jpg*) рекомендуется использовать изображение с соотношениями сторон (ширина/длина) 3:4, размером не менее 696 x 928 пикселей, рекомендуется: 960 x 1200 или 1200 x 1600;
— в качестве *logo* (здесь это файл *thumb.png*) рекомендуется постоянно использовать одно и то-же (для конкретного сайта или бренда) квадратное изображение, размером не менее 112 x 112 пикселей (думаю, что 200 x 200 или 256 x 256 будет ОК).
При проверки валидности *AMP* мы уже видели что: "*На странице найдены действительные структурированные данные*", но давайте проверим это с помощью специального инструмента от *Google* [*Проверка структурированных данных*](https://search.google.com/structured-data/testing-tool/u/0/):
Как видим, в правом верхнем углу заглавными буквами написано: *НЕТ ОШИБОК*, *НЕТ ПРЕДУПРЕЖДЕНИЙ* — похоже, что *Google* довольный. Значит и мы тоже.
#### Дополнительно: данные для социальных сетей
Хотя к поисковым технологиям это не имеет отношения, но поскольку мы хорошо осознаём роль социальных сетей, давайте сделаем кое-что полезное и для них (но мы-то знаем — в конечном итоге это всё обернётся в нашу пользу). Итак, в разделе *head AMP-истории* (впрочем, как и любой другой страницы сайта) также можно разместить разметку, сообщающую социальным сетям таким как *Facebook, Twitter, Pinterest, ВКонтакте* дополнительную информацию о нашей *AMP-истории*. Теперь если пользователь одной из соцсетей поделится ссылкой на нашу страницу — «подтянется» ещё изображение и заголовок (а иногда ещё и описание), как на примере с *ВКонтакте* на этом скриншоте:
А вот как эта разметка выглядит в коде страницы:
Здесь, думаю, тоже всё интуитивно понятно. Но поясню следующее.
Разметка пустыми строками разделена на три секции.
*Facebook* (использует пространство имён *og — [Open Graph](https://ogp.me/)*), Twitter (использует пространство имён *twitter*), и ВКонтакте (использует пространство имён *vk*).
Надо сказать что *Open Graph* де-факто является стандартом для подобной разметки, и другие социальные сети также используют её. Более того, если вы не укажите отдельно для Twitter и ВКонтакте — они также будут пытаться использовать *Open Graph*. Но мы указали для более контролируемого результата.
Надо также отметить, что пути к ресурсам здесь надо прописывать абсолютные, за исключением *ВКонтакте* — здесь путь к изображению можно прописать как абсолютный, так и относительный (в примере выше — относительный: `content="./hero_vk.jpg"`).
Кроме того, *Facebook* требует создать т.н. веб-приложение, и использовать его идентификатор (`property="fb:app_id"`, см. первую строку), вероятно, чтобы контролировать распространение стороннего контента через свою сеть (и иметь возможность в любой момент прикрыть эту лавочку, если ему что-то не понравится).
Чтобы создать такое приложение перейдите на страницу приложений аккаунта разработчика (который надо создать, если ещё не создан) [*Facebook for Developers*](https://developers.facebook.com/apps/) и нажмите плитку: "*Добавьте новое приложение*". Дайте своему приложению любое имя (своё я назвал «Визуальные Истории»), и сразу после создания вы увидите идентификатор вашего приложения, как показано на скриншоте ниже:
Дальнейшие настройки легки для понимания, и для наших целей — не обязательны.
**Не используйте показанный здесь идентификатор**
*Пожалуйста, не пользуйтесь идентификатором Facebook-приложения, показанном на скриншотах — в любой момент я могу это приложение отключить! Создайте своё собственное приложение, как описано выше.*
Теперь давайте проверим валидность нашей разметки для социальных сетей.
[*Отладчик репостов Facebook*](https://developers.facebook.com/tools/debug/):
Кажется с *Facebook* всё ОК.
Теперь [*Twitter Card validator*](https://cards-dev.twitter.com/validator):
И с ним, похоже всё хорошо.
Проверим теперь в *Pinterest*, в т.н. [*Rich Pins Validator*](https://developers.pinterest.com/tools/url-debugger/):
Кроме приятных зелёных галочек, внизу ещё и написано: *AMP Valid? True*. Но главное, обратите внимание здесь на то, что *Canonical URL* — это адрес самой *AMP-истории*. Это критично для индексации в *Google*, и мы ещё вернёмся к этому в конце статьи.
Что касается *ВКонтакте*, насколько мне известно, у них нет подобного валидатора (или скажем так: мне неизвестно о том, что *ВКонтакте* имеется подобный валидатор), но мы проверили их в самом начале на практике — всё работает и там.
Как сделать
-----------
*AMP-историю* можно создать… вручную. Хотя у некоторых *CMS* есть расширения для создания *AMP-страниц*, но именно *AMP-истории*, насколько мне известно, ещё не поддерживаются. Есть также несколько онлайн сервисов для создания именно *AMP-историй*, например, [*MakeStories*](https://makestories.io/), но я их не тестировал, поскольку не люблю подобные зависимости от третьих лиц, в смысле чистоты кода, полноты функционала и своевременности обновлений. Поэтому, вот [***ссылка на шаблон в моём GitHub-репозитории***](https://github.com/stmike/amp-story-template-ru.git), содержащий базовый функционал (изображения, видео, анимация — всё как в *AMP-истории «Низкие звёзды лета»*), которого вполне достаточно для большинства случаев, но и его можно легко расширить пользуясь [*официальным каталогом компонентов*](https://amp.dev/documentation/components/?format=stories). Шаблон также можно склонировать:
`git clone https://github.com/stmike/amp-story-template-ru.git
cd amp-story-template-ru`
Но код будет работать некорректно, если его запускать непосредственно из файловой системы. Для целей разработки и тестирования сначала надо запустить локальный сервер. Если у вас нет своего проверенного, надёжного и привычного, и у вас браузер *Chrome* — могу порекомендовать [*Web Server for Chrome*](https://chrome.google.com/webstore/detail/web-server-for-chrome/ofhbbkphhbklhfoeikjpcbhemlocgigb/). Просто запустите, выберите папку с файлами (*amp-story-template-ru*) и откройте локальный адрес — всё как показано на скриншоте:
Поскольку мы уже говорим о браузере *Chrome*, могу порекомендовать ещё и расширение от разработчиков *AMP* — [*AMP Validator*](https://chrome.google.com/webstore/detail/amp-validator/nmoffdblmcmgeicmolmhobpoocbbmknc). Пользоваться им невероятно просто: если вы на валидной *AMP-странице* — на панели *Chrome* горит зелёный значок; если нет — красный, и при клике показывает номера строк с ошибками.
Код шаблона хорошо прокомментирован — поэтому можете читать его как сказку Андерсена, но всё же хочу обратить внимание на несколько нюансов.
**1.** Поисковая система *Google* будет считать *AMP-историю* (как и любую *AMP-страницу*) валидной, только если для доступа к ней используется безопасный протокол *HTTPS* (не *HTTP*).
**2.** В *GitHub-репозитории* наряду с привычным *index.html* файлом вы найдёте и файл *bookend.json*. В *AMP-историях* он отвечает за изящное окончание истории: повторить, поделиться через соцсети, полезные ссылки. Всё, как показано на скриншоте:
Пути к ресурсам в файле *bookend.json* могут быть как абсолютными, так и относительными.
**3.** *AMP-истории* в теге `должны ссылаться на самих себя. Другие страницы сайта на них указывать не должны. Это отличает их (с точки зрения *SEO*) от обычных *AMP-страниц*. Вот что об этом пишет *Google*:
После индексации на вашем сайте хотя бы одной *AMP-страницы* (включая *AMP-истории*) в меню (раздел *Улучшения*) [*Google Search Console*](https://search.google.com/search-console/about) появится пункт: *Страница AMP*. Там ошибок быть не должно:
Заключение
----------
На сегодня всё. Другие материалы следуют. Кому подобное читать интересно — подписывайтесь на уведомления о новых публикациях. Подписаться можно на этом сайте (кнопка ***Подписаться*** внизу), или на *Telegram-канал* [***IT Туториал Захар***](https://t.me/it_tutorial_zahar), или на одноимённое [***сообщество в VK***](https://vk.com/it_tutorial_zahar), или *Twitter* [***@mikezaharov***](https://twitter.com/mikezaharov).` | https://habr.com/ru/post/499692/ | null | ru | null |
# Beego — это уже не Go
Любой хайп весьма забавен, когда смотришь на него со стороны. Менее забавен, когда оказываешься в него вовлечен напрямую.
Хайп Go пришелся где-то на 2014ый год, когда авторы приложений имевших от силы 1000RPM (requests per minute) вдруг как один решили, что им срочно нужен concurrency, потому что вот-вот их 1000RPM превратиться в 1000RPS (что тоже не так много, на самом деле).
Результатом хайпа стало то, что к Go приобщилось много людей, привыкших к MVC архитектуре приложения, буть то Spring, Django или Ruby on Rails. И эту архитектуру, как сову на глобус, они стали натягивать на Go. Так появились кадавры вроде Beego и [Revel](https://github.com/revel/revel). Revel благополучно сдох, хотя его и пытаются все еще откачать. А вот о Beego хочется поговорить отдельно.
Немалый вклад в продвижение Beego среди масс вложил Richard Eng своим циклом статей [«A word the Beegoist»](https://medium.com/@richardeng/a-word-from-the-beegoist-d562ff8589d7). Практически «Евангелие от Ричарда». Иронично, что не смотря на то, что Ричард оголтело продвигает Go, сам он на нем не пишет.
В свою очередь я с Go, а еще хуже, с Beego, проработал не мало. И могу сказать, что это явно не тот путь, которым должна идти разработка на Go.
Давайте разберем несколько основных аспектов Beego, и почему они противоречат различным best practices в Go, да и в индустрии в целом.
#### Структура папок
Robert C. Martin, более известный как [Uncle Bob](http://blog.cleancoder.com/), неоднократно озвучивал идею, что структура приложения должна передавать его суть. Он крайне любит приводить пример с кафедральным собором, на который можно посмотреть сверху, и сразу понять, что это кафедральный собор.
Роберт неоднократно критиковал Ruby on Rails за его структуру папок — controllers, models, views, вот этого всего. Проблема такого подхода заключается в том, что приложение по продаже носков «сверху» будет выглядеть точно так же, как приложение для заказа еды. И для того, чтобы понять суть приложения, нужно будет забраться в какую-нибудь папку models, и посмотреть, а с какими же сущностями мы в итоге имеем дело.
Именно это больное поведение Beego и копирует. В то время как тот же Spring ушел в сторону Domain Driven Design и структуры папок передающей суть, Beego навязывает использование структуры, ставшей уже antipattern'ом.
Но проблема даже серьезней. Для Go нет разделения между структурой папок и структурой пакетов (package'ей). Потому в Beego и UsersController и OrdersController будут под одним package'ем — controllers. А если у вас controller'ы двух типов, те, что сервят UI и те, что используются для API, причем последние в приличном обществе принято версионировать? Тогда будьте готовы к уродцам вроде apiv1.
#### ORM
Довольно странно, что Beego, будучи неудачным клоном Ruby on Rails, при этом не использует ActiveRecord pattern. Его ORM представляет собой крайне странное зрелище. Если для совсем базовых операций, вроде прочесть строку/записать строку, он еще годится, то вот, к примеру, как выглядит простенькая выборка (здесь и далее примеры взяты напрямую из документации):
```
qs.Filter("profile__age__gte", 18) // WHERE profile.age >= 18
```
Но основная проблема с Beego ORM даже не в том, что нужно бороться с proprietary языком, а в том, что он использует все худшие практики Go, будь то import sideffect'ов:
```
import (
_ "github.com/go-sql-driver/mysql"
_ "github.com/lib/pq"
_ "github.com/mattn/go-sqlite3"
)
```
Или регистрация моделей в init():
```
func init(){
orm.RegisterModel(new(User))
}
```
Сделайте себе одолжение, даже если вы все же решите по какой-то необъяснимой причине работать с Beego, не используйте Beego ORM. Если вам без ORM жизнь не мила (а что вы делаете в мире Go, милейший?), пользуйтесь [GORM](https://github.com/jinzhu/gorm). Он хотя бы поддерживается. Иначе, [«database/sql»](https://golang.org/pkg/database/sql/) вам в помощь.
#### Bee tool
Из Ruby on Rails скопирован так же command line tool, который зовется просто [Bee](https://github.com/beego/bee). Вот только если в мире RoR был rails и был rake, то bee — это такая мусорка для всего. Он и MVC приложение за'boostrap'ит, и миграции прогонит, и file watcher запустит. В последнем и кроется еще одна проблема. Ведь в чем одно из основных достоинств Go? То, что запускается локально, максимально близко к тому, что запустится в production'е. Если вы не используете bee, конечно.
#### Automatic routing
Go — строго типизированный язык, который при этом не поддерживает ни generics, ни annotations. Как на таком слепить MVC фреймворк? Путем чтения комментов и генерации файлов, конечно.
Выглядит это примерно так:
```
// @Param body body models.Object true "The object content"
// @Success 200 {string} models.Object.Id
// @Failure 403 body is empty
// @router / [post]
func (this *ObjectController) Post() {
var ob models.Object
json.Unmarshal(this.Ctx.Input.RequestBody, &ob)
objectid := models.AddOne(ob)
this.Data["json"] = map[string]string{"ObjectId": objectid}
this.ServeJson()
}
```
Очевидность, как можно видеть, — нулевая. Функция Post() вообще ничего не получает и не возвращает. http.Request? Нет, не слышали.
Ну, а как работает весь routing? При запуске пресловутого bee генерируется еще один файл, commentsRouter\_controllers.go, который содержит пример такого замечательного кода:
```
func init() {
beego.GlobalControllerRouter["github.com/../../controllers:ObjectController"] = append(beego.GlobalControllerRouter["github.com/../../controllers:ObjectController"],
beego.ControllerComments{
Method: "Post",
Router: `/`,
AllowHTTPMethods: []string{"post"},
MethodParams: param.Make(),
Filters: nil,
Params: nil})
...
}
```
Смотрите, не забудьте перегенерировать и за'commit'ить этот файл после каждого изменения. До последнего времени ситуация была еще печальней, и во время тестов этот файл генерировался автоматически, так что о проблемах вы узнавали уже в production'е. Кажется в последних версиях это странное поведение было исправлено.
#### Component testing
И так мы подходим к теме тестирования. Go, в отличие от большинства других языков программирования, приходит с тестовым фреймворком «из коробки». В целом, философия Go в том, что тест должен сидеть рядом с тестируемым файлом. Но мы же в мире MVC, плевать на философию Go, верно? Потому будьте добры все свои тесты разместить в папочке /test, как завещал нам [DHH](https://twitter.com/dhh).
И это не такая уж мелочь, потому что, напомню, в Go package == folder. И если тест находящийся в том же package'е может вызвать private method, то тест находящийся в другом package — уже нет.
Но ладно бы все ограничивалось структурой папок. Код Beego в принципе очень сложно тестировать, поскольку в нем все на свете — это side effect.
Вот так Beego запрашивает routers:
```
import (
_ "github.com/../../routers"
)
```
Та же история и с middleware'ами, и с controller'ами, которые я уже упоминал раньше.
#### Документация
Это для меня как software architect'а вишенка на торте. Документация в BeeGo хороша настолько, насколько хорош ваш китайский. Нет, от комментов на китайском внутри кода за последние года два уже вроде избавились.
Теперь на китайском остались только некоторые pull request'ы:
И в особенности в issues:
### Вместо заключения
Если у вас есть команда написателей кода на Ruby/PHP/Python, и вы срочно хотите перевести их на Go, худшее, что вы можете для них сделать — это заставить их перейти на MVC фреймворк на Go. MVC в целом так себе архитектурный паттерн, а в Go он вообще не к месту. Либо, если вы уж совсем уверены, что ничто кроме Go вас не спасет, пусть переучиваются и пишут так, как в Go принято — максимально плоско и explicit. Либо, быть может им видней, при помощи какого инструмента решать поставленные им задачи? | https://habr.com/ru/post/444022/ | null | ru | null |
# Сокращаем использование Redux кода с помощью React Apollo
**Всем привет!** Хочу поделиться своим переводом интересной статьи [Reducing our Redux code with React Apollo](https://dev-blog.apollodata.com/reducing-our-redux-code-with-react-apollo-5091b9de9c2a) автора [Peggy Rayzis](https://dev-blog.apollodata.com/@peggyrayzis). Статья о том, как автор и её команда внедряли технологию GraphQL в их проект. Перевод публикуется с разрешения автора.
*Переключаемся на декларативный подход в Высшей Футбольной Лиге*
Я твёрдо убеждена, что лучший код — это отсутствие кода. Чем больше кода, тем больше вероятности для появления багов и тем больше тратится времени на поддержку такого кода. В Высшей Футбольной Лиге у нас совсем небольшая команда, поэтому мы принимаем этот принцип близко к сердцу. Мы стараемся оптимизировать всё, что нам по силам, либо путём увеличения переиспользуемости кода, либо просто перестав обслуживать определённую часть кода.
В данной статье вы узнаете о том, как мы передали контроль над получением данных в Apollo, что позволило нам избавиться от почти **5,000 строчек кода**. К тому же, после перехода на Apollo наше приложение стало не только намного меньше по объёму, оно также стало более **декларативным**, поскольку теперь наши компоненты запрашивают только те данные, которые им нужны.
Что я подразумеваю под декларативным и почему это так здорово? Декларативное программирование фокусируется на конечной цели, в то время как императивное программирование сосредоточено на шагах, которые требуются для её достижения. React же сам по себе декларативный.
Получение данных с помощью Redux
--------------------------------
Давайте взглянем на простой компонент Article:
Предположим, мы хотим отрендерить в подключённом представлении, который получает ID матча в качестве props. Если бы мы выполняли это без GraphQL клиента, наш процесс получения данных, необходимых для рендеринга мог бы быть таким:
1. Когда монтируется, вызываем action creator для получения данных матча по ID. Action creator диспатчит action, чтобы сообщить Redux о начале процесса получения данных.
2. Мы достигли точки назначения и возвращаемся с данными назад. Мы нормализуем данные в удобную нам структуру.
3. После того, как данные нормализованы, мы диспатчим ещё один action, чтобы сообщить Redux о завершении процесса получения данных.
4. Redux обрабатывает action в нашем reducer и обновляет state приложения.
5. получает все необходимые данные матча через props и отфильтровывает их для рендеринга статьи.
Так много шагов, чтобы просто получить данные для ! Без клиента GraphQL наш код становится намного более императивным, поскольку нам приходится концентрироваться на том, *как* мы получаем данные. Но что, если мы не хотим передавать все данные матча для простого рендеринга ? Вы могли бы построить другой endpoint и создать отдельный набор action creators для получения от него данных, но такой вариант очень легко может стать неподдерживаемым.
Давайте сравним, как бы мы могли сделать то же самое с помощью GraphQL:
1. подключён к компоненту высшего порядка, который выполняет следующий запрос:
```
query Article($id: Float!) {
match(id: $id) {
article {
title
body
}
}
}
```
… и это всё! Как только клиент получает данные, он передаёт их в props, которые могут быть далее переданы в . Это намного более *декларативно*, поскольку мы фокусируемся только на том, *какие* данные нам нужны для рендеринга компонента.
В этом вся прелесть делегирования получения данных GraphQL клиенту, будь то Relay или Apollo. Когда вы начнёте "[думать в концепциях GraphQL](https://facebook.github.io/relay/docs/thinking-in-graphql.html)", вы станете заботиться только о том, в *каких* props нуждается компонент для рендеринга, вместо того, чтобы беспокоиться о том, *как* получить эти данные.
В какой то момент вам придётся подумать об этом "*как*", но это уже забота серверной части, и, соответственно, сложность для front-end резко снижается. Если вы новичок в серверной архитектуре GraphQL, то попробуйте [`graphql-tools, библиотеку Apollo, которая поможет вам более модульно структурировать вашу схему. Для краткости мы сегодня остановимся только на front-end части.
И хотя этот пост о том, как сократить использование вашего Redux кода, вы не избавитесь от него полностью! Apollo использует Redux под капотом, поэтому вы всё ещё сможете извлекать выгоду из иммутабельности и все клёвые возможности Redux Dev Tools, типа time-travel debugging, так же будут работать. Во время [конфигурирования](http://dev.apollodata.com/react/redux.html) вы можете подключить Apollo к существующему store в Redux, чтобы поддерживать единый "источник правды". Как только ваш store сконфигурирован, вы передаёте его в компонент, который оборачивает всё ваше приложение. Звучит знакомо? Этот компонент является полной заменой вашего существующего из Redux, за исключением того, что вам потребуется передать ему экземпляр `ApolloClient` через свойство client.
Прежде, чем мы начнём резать наш Redux код, я бы хотела назвать одну из лучших фукнциональных особенностей GraphQL: **поэтапная настройка** (**incremental adoption**). Вам не обязательно совершать рефакторинг всего приложения сразу. После интеграции Apollo с вашим существующим Redux store, вы можете переключаться с ваших reducers *постепенно*. То же самое применимо и к серверной части — если вы работаете над большим масштабным приложением, вы можете использовать GraphQL бок о бок с вашим текущим REST API, до того момента, пока вы не будете готовы для полного перехода. Справедливое предупреждение: как только вы попробуете GraphQL, вы можете влюбиться в эту технологию и захотить переделать всё ваше приложение.
Наши требования
---------------
Перед переходом от Redux к Apollo, мы тщательно подумали о том, отвечает ли Apollo нашим потребностям. Вот на что мы обратили внимание перед тем, как принять решение:
* **Агрегирование данных из множественных источников:** Матч состоит из данных, получаемых из 4-х различных источников: контент — из нашего REST API, статистика — из нашей MySQL базы данных, медиа-данные — из нашего video API и социальные данные — из нашего Redis хранилища. Первоначально, мы использовали серверный плагин для сбора всех данных в один объект матча перед отправкой на клиент. Надо сказать, он функционирует почти также, как GraphQL! Когда мы поняли это, то стало очевидным, что GraphQL станет идеальным кандидатом для нашего приложения.
* **Оперативные обновления, близкие к реальному времени:** Во время матча в прямом эфире мы обычно получаем обновления каждую минуту. До Apollo мы обрабатывали обновления с помощью сокетов и диспатчили их в наш reducer матча. Это не было самым ужасным решением, но также и не было самым элегантным, поскольку мы отправляли весь объект матча, чтобы избежать сложных последовательностей. С Apollo же мы запросто можем кастомизировать интервал поллинга (*polling*) для каждого компонента в зависимости от статуса игры.
* **Простая пагинация:** Поскольку мы создавали страницу расписания с бесконечной прокруткой списка матчей, то нам нужна была соответствующая обработка подобного рода пагинации без лишней головной боли. Разумеется, мы могли бы создать отдельный собственный reducer. Но зачем писать его самим, когда в Apollo есть функция `fetchMore`, которая проделывает за нас всю тяжёлую работу?
Надо сказать, что Apollo удовлетворял не только всем нашим текущим требованиям, он также охватывал и некоторые наши будущие потребности, особенно учитывая то, что в наш roadmap включена расширенная персонализация. И хотя наш сервер в настоящее время доступен "только для чтения", нам в будущем может потребоваться ввести **мутации** (*mutations*) для сохранения пользователями их любимых команд. На случай, если мы решим добавить комментирование в режиме реального времени или взаимодействия с фанатами, которые не могут быть решены с помощью поллинга (*polling*), то в Apollo есть поддержка **подписок** (*subscriptions*).
От Redux к Apollo
-----------------
Момент, которого все ждали! Изначально, когда я только задумалась о написании этой статьи, я собиралась лишь привести примеры кода до и после, но я думаю, что было бы трудно сравнивать вот так напрямую эти два подхода, особенно для новичков в Apollo. Вместо этого я собираюсь подсчитать количество удалённого кода в целом и провести вас через знакомые вам концепции Redux, которые вы сможете применить при создании контейнерных компонентов с помощью Apollo.
### Что мы удалили
* reducers матчей (~300 строчек кода)
* action creators & epics, отвечающие за получение данных (~800 строчек кода)
* action creators и бизнес логику, отвечающие за группировку и получение обновлений прямого эфира матчей через сокет (~750 строчек кода)
* actions creators & epics, отвечающие за local storage (~1000 строчек кода). На самом деле, не совсем справедливо включать в общий список этот пункт, так как offline поддержка пока что отложена в нашем проекте, но если мы захотим добавить её снова, то это вполне достижимо с помощью кастомизации функции `fetchPolicy` из Apollo и использования `redux-persist` в reducer.
* Контейнерные компоненты Redux, которые отделяли логику Redux от презентационных компонентов (~1000 строчек кода)
* Тесты, связанные со всем вышеперечисленным (~1000 строчек кода)
### connect() → graphql()
Если вы умеете пользоваться `connect`, тогда компонент высшего порядка `graphql` из Apollo вам покажется очень знакомым! Точно так же, как `connect` возвращает функцию, которая принимает компонент и подключает его к вашему Redux store, также и `graphql` возвращает функцию, которая принимает компонент и "подключает" его к клиенту Apollo. Давайте посмотрим на это в действии!
Первый аргумент, переданный в `graphql` это `MatchSummaryQuery`. Это данные, которые мы хотим получить от сервера. Мы используем [загрузчик Webpack](https://github.com/apollographql/graphql-tag) для парсинга нашего запроса в GraphQL AST, но если вы не используете Webpack, то вам нужно обернуть ваш запрос в шаблонные строки (*template string*) и передать его в функцию [`gql`](http://dev.apollodata.com/react/api.html#gql), экспортированную из Apollo. Вот пример запроса на получение данных, необходимых для нашего компонента:
Отлично, у нас есть запрос! Чтобы корректно его выполнить, нам нужно передать в него две переменные `$id` и `$season`. Но откуда мы возьмём эти переменные? Вот здесь то и вступает в игру второй аргумент функции `graphql`, представленный в виде объекта конфигурации.
Этот объект имеет несколько свойств, которые вы может указать для настройки поведения компонента высшего порядка (HOC). Одно из самых важных свойств — это `options`, принимающее функцию, которая получает props вашего контейнера. Эта функция возвращает объект со свойствами типа `variables`, что позволяет вам передавать ваши переменные в запрос, и `pollInterval`, который позволяет настраивать поведение поллинга (*polling*) у компонента. Обратите внимание, как мы используем props нашего контейнера для передачи `id` и `season` в наш `MatchSummaryQuery`. Если эта функция становится слишком длинной, чтобы писать её прямо в декораторе, то мы разбиваем её на отдельную функцию под названием `mapPropsToOptions`.
### mapStateToProps() → mapResultsToProps()
Наверняка вы использовали функцию `mapStateToProps` в ваших Redux контейнерах, передавая эту функцию в `connect` для передачи данных из state приложения в props данного контейнера. Apollo позволяет вам определять похожую функцию. Помните конфигурационный объект, который ранее мы передавали в функцию `graphql`? У этого объекта есть ещё одно свойство — `props`, которое принимает функцию, получающую на вход props и обрабатывающую их перед передачей в контейнер. Вы, конечно, можете определить её прямо в `graphql`, но нам нравится определять её как отдельную функцию `mapResultsToProps`.
Зачем вам переопределять ваши props? Результат запроса GraphQL всегда присваивается к свойству `data`. Иногда вам может потребоваться подкорректировать эти данные перед тем, как отправить их в компонент. Вот один из примеров:
Теперь объект с данными содержит не только результат запроса, но также и свойства типа `data.loading`, чтобы дать вам знать, что запрос ещё не возвратил ответ. Это может быть полезным, если в подобной ситуации вы хотите отобразить другой компонент вашим пользователям, как мы сделали это с .
### compose()
Compose это функция, использующаяся не только в Redux, но я всё же хочу обратить ваше внимание, что Apollo содержит её. Она очень удобна, если вы хотите скомпоновать несколько `graphql` функций для использования в одном контейнере. В ней вы даже можете использвать функцию `connect` из Redux вместе с `graphql`! Вот как мы используем `compose` для отображения различных состояний матча:
`compose` отлично помогает, когда ваш контейнер содержит множественные состояния. Но что, если вам нужно выполнять отдельный запрос только в зависимости от его состояния? Здесь нам поможет `skip`, который вы можете увидеть в конфигурационном объекте выше. Свойство `skip` принимает функцию, которая получает props и позволяет вам пропустить выполнение запроса, если он не соответствует необходимым критериям.
Все эти примеры демонстрируют, что если вы знаете Redux, то вы быстро вольётесь в разработку на Apollo! Его API вобрало в себя многое из концепций Redux, при этом уменьшая количество кода, которое вам нужно написать для достижения такого же результата.
---
Я надеюсь, что опыт перехода Высшей Футбольной Лиги на Apollo поможет вам! Как и в случае с любыми решениями относительно различных библиотек, лучшее решение по контролю над получением данных в вашем приложении будет зависеть от конкретных требований вашего проекта. Если у вас есть какие-либо вопросы касательно нашего опыта, пожалуйста, оставляйте комментарии [здесь](https://dev-blog.apollodata.com/reducing-our-redux-code-with-react-apollo-5091b9de9c2a) или стучитесь ко мне в [Twitter](https://twitter.com/peggyrayzis)!
*Спасибо за прочтение!*`](http://dev.apollodata.com/tools/graphql-tools/index.html) | https://habr.com/ru/post/331088/ | null | ru | null |
# Экспортируем избранные закладки с хабрахабры в другие сервисы социальных закладок
Кажется, ни для кого не секрет, что хабр является прямо таки кладезем информации для русскоязычных ИТ-шников. И многие хабрапользователи используют закладки хабра, для ссылок на интересные материалы.
Я написал скрипт на php, который умеет брать ваши закладки из избранного с хабрахабры и автоматически экспортировать их в другие сервисы.
На текущий момент написана поддержка только одного сервиса социальных закладок — del.icio.us, так как именно им я постоянно пользуюсь. Если у вас появится желание реализовать поддержку других сервисов, пожалуйста напишите мне.
Экспортировать свои закладки с хабры, вы можете на моей страничке [http://floscoeli.com/ukko/habrabookmarks/](http://floscoeli.com/ukko/habrabookmarks/ "экспорт хабразакладок") или же со своего компьютера, предварительно [скачав исходные файлы](http://floscoeli.com/ukko/habrabookmarks/habrabookmarks.tar.gz "Скрипт и библиотеки для экспорта хабразакладок").
### Установка скриптов к себе на сервер
Если вы решили сами разобраться со скриптами, то вам просто будут просто необходима следующие программы веб-сервер и **php5** или **php5-cli** c поддержкой:
* [DOM](http://ru2.php.net/manual/en/book.dom.php "DOM")
* [Multibyte String](http://ru2.php.net/manual/en/book.mbstring.php "mb_string")
* [Client URL Library](http://ru2.php.net/manual/en/book.curl.php)
### Для запуска экспорта через веб-сервер
Распакуйте архив в нужный каталог и наберите адрес до скрипта index.php, например `localhost/index.php`
### Для экспорта закладок через терминал
Распакуйте архив и отредактируйте файл start.bin.php. Права доступа на этот файл должны быть 755. После того как вы отредактировали файл, можете его смело запускать `./start.bin.php`
PS Пожалуйста, пишите свои замечания и мысли в комментариях или присылайте патчи :)
PSPS И прошу прощения за дизайн странички-экспорта, я совсем не силён в вёрстке и дизайне.
PSPSPS Конечно же скриптами вы пользуйтесь на свой страх и риск, но я могу гарантировать что никакие пользовательские данные не собираются и ни куда не записываются.
upd: Исходники теперь постоянно будут доступны по адресу [code.google.com/p/habrabookmarks](http://code.google.com/p/habrabookmarks/) | https://habr.com/ru/post/48673/ | null | ru | null |
# Разбор одного таска или как найти сайт по favicon.ico?
На написание данной статьи меня подтолкнуло участие в соревнованиях по информационной безопасности - *Capture the Flag (CTF)*. Это был [*MCTF 2021*](https://ctftime.org/event/1439) , проводимый Московским Техническим Университетом Связи и Информатики.
Логотип MCTFТаск - Next Level Recon
-----------------------
### Описание
Описание таскаNext Level Recon относится к категории *MISC (разное)* и имеет сложность *"Easy",* что как бы намекает нам, что таск будет легкий. Помимо описания содержит прикрепленный файл с расширением `.pcap`
### Решение
#### Первый взгляд
Учитывая, что нам дан *pcap*-файл - это без сомнения дамп сетевого трафика. Рассмотрим его подробнее в анализаторе сетевого трафика - *WireShark.*
Содержимое дампа сетевого трафикаВ дампе всего 26 пакетов, присутствуют только протоколы *TCP* и *HTTP*. Причем отправитель и получатель - это **один и тот же** IP-адрес.
#### Восстановление трафика
Попробуем собрать поток HTTP-трафика. Для этого щелкаем правой кнопкой мыши на HTTP-пакете и выбираем "*Follow -> HTTP Stream*".
 Сбор потока HTTP-трафикаПосле сбора потока HTTP-трафика, мы наблюдаем картину обычного *GET-запроса* *HTTP* и ответа ему.
GET-запрос HTTP и ответ ему Судя по содержимому, ничего особенного здесь не происходит:
* Скачивается иконка сайта (*favicon.ico*)
* Выводится строка "*Site in development...*"
Так как в описании задания говорится, что нужно найти какой-то сайт, то можно попробовать "пихать" в поисковики специальные поисковые запросы с определенными строками и параметрами, но заранее скажу, что данный способ здесь не поможет. Поэтому под наш прицел попадает именно *favicon.ico*. Попробуем вытащить его из дампа.
#### Экспорт объектов из HTTP-трафика
На самом деле здесь все просто - *WireShark* сделает все за нас. Нужно только нажать "*File -> Export Objects -> HTTP...*"
Экспорт файловДалее просто нажать "*Save All*" и указать путь куда файлы будут сохранены.
Выбор и сохранение файловОткрыв для просмотра файл "*favicon.ico*" можно предположить, что он такой же, как и у самого сайта [https://mctf.online](https://mctf.online/), на котором и проходили соревнования. Судя по описанию таска, наши предположения должны быть верными. Проверить это на практике можно путем расчета контрольных сумм двух иконок ~~(они совпадают)~~.
#### Поиск по хешу
По заданию нам необходимо найти сайт, на который переехал сайт из дампа. Первое что приходит на ум - это искать в [Shodan](https://www.shodan.io/). У нас из исходных данных - файл *favicon.ico*. Продолжая верить в то, что это такая же иконка, как и у основного сайта соревнований, посчитаем [MurmurHash](https://en.wikipedia.org/wiki/MurmurHash) от него.
Для этого на GitHub есть даже за нас написанный [скрипт](https://gist.github.com/yehgdotnet/b9dfc618108d2f05845c4d8e28c5fc6a). Модифицируем его под наши исходные данные и получим следующее:
```
import mmh3
import requests
import codecs
response = requests.get('https://mctf.online/favicon.ico')
favicon = codecs.encode(response.content,"base64")
hash = mmh3.hash(favicon)
print(hash)
```
Скормив этот скрипт питону, получим хеш: `-535199269`
Остается скормить этот хеш в *Shodan*, применив специальный фильтр *http.favicon.hash:*
Результат выполнения запроса в ShodanКак видно из результата запроса - найдено 3 совпадения, одно из которых это сам сайт [https://mctf.online](https://mctf.online/), а второй с говорящим названием "*Flags are here!*". Наша теория подтвердилась! Зайдем на страницу по IP-адресу, на который указывает "*Flags are here!*", чтобы забрать наш флаг:
Вывод
-----
Таким образом можно искать любые сайты в Интернете - просто узнав [MurmurHash](https://en.wikipedia.org/wiki/MurmurHash) соответствующего *favicon.ico*. Это может быть полезно, если сайт переехал на другое доменное имя, либо вы вообще не знаете ни доменное имя, ни IP-адрес, либо просто хотите посмотреть какие еще сайты хостятся с данным фавиконом. | https://habr.com/ru/post/589433/ | null | ru | null |
# Мониторинг позиций своими руками
### Делаем мониторинг позиций запросов в поисковой системе, начало.
Обычно мы заинтересованны в увеличении клиентов.
А что-бы увеличить что-то, нужно это сначало оценить.
А так уж исторически сложилось, что часть клиентов на интернет-магазины приходит с поисковых систем.
*( Про работу с контекстной рекламой и прайс-агрегаторами напишу в следующих статьях, если кому будет интересно. )*
А для оценики своего состояния в поисковиках, обычно нужно собрать с них статистику по положению запросов в выдаче.
Наш инструмент будет состоять из 2-х частей:
* скрипт для парсинга поисковой выдачи, с помощью Curl и lxml
* веб-интерфейс для управления и отображения, на Django
#### Узнаем у yandex.ru нашу позицию по запросу.
*Хочу сразу уточнить, в данной статье будет описаны самые азы и сделаем самый простой вариант, который в дальнейшем будем усовершенствовать.*
##### Для начала сделаем функцию которая по урлу возвращает html.
Загружать страницу будем c помощью pycurl.
```
import pycurl
c = pycurl.Curl()
```
Установим url который будем загружать
```
url = 'ya.ru'
c.setopt(pycurl.URL, url)
```
Для возврата тела страницы curl использует callback функцию, которой передает строку с html.
Воспользуемся строковым буфером StringIO, на вход у него есть функция write(), а забирать все содержимое из него мы сможем через getvalue()
```
from StringIO import StringIO
c.bodyio = StringIO()
c.setopt(pycurl.WRITEFUNCTION, c.bodyio.write)
c.get_body = c.bodyio.getvalue
```
На всякий случай сделаем наш curl похожим на броузер, пропишем таймауты, юзерагента, заголовки и т.д.
```
c.setopt(pycurl.FOLLOWLOCATION, 1)
c.setopt(pycurl.MAXREDIRS, 5)
c.setopt(pycurl.CONNECTTIMEOUT, 60)
c.setopt(pycurl.TIMEOUT, 120)
c.setopt(pycurl.NOSIGNAL, 1)
c.setopt(pycurl.USERAGENT, 'Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:13.0) Gecko/20100101 Firefox/13.0')
httpheader = [
'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language: ru-ru,ru;q=0.8,en-us;q=0.5,en;q=0.3',
'Accept-Charset:utf-8;q=0.7,*;q=0.5',
'Connection: keep-alive',
]
c.setopt(pycurl.HTTPHEADER, httpheader)
```
Теперь загружаем страницу
```
c.perform()
```
Вот и все, страница у нас, мы можем прочитать html страницы
```
print c.get_body()
```
Так-же можем прочитать заголовки
```
print c.getinfo(pycurl.HTTP_CODE)
```
И если получили получили какой-то отличный от 200 ответ сервера, то сможем его обработать. Сейчас мы просто выкинем исключение, обрабатывать исключения будем в следующих статьях
```
if c.getinfo(pycurl.HTTP_CODE) != 200:
raise Exception('HTTP code is %s' % c.getinfo(pycurl.HTTP_CODE))
```
Обернем все что получилось в функцию, в итоге у нас получилось
```
import pycurl
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
def get_page(url, *args, **kargs):
c = pycurl.Curl()
c.setopt(pycurl.URL, url)
c.bodyio = StringIO()
c.setopt(pycurl.WRITEFUNCTION, c.bodyio.write)
c.get_body = c.bodyio.getvalue
c.headio = StringIO()
c.setopt(pycurl.HEADERFUNCTION, c.headio.write)
c.get_head = c.headio.getvalue
c.setopt(pycurl.FOLLOWLOCATION, 1)
c.setopt(pycurl.MAXREDIRS, 5)
c.setopt(pycurl.CONNECTTIMEOUT, 60)
c.setopt(pycurl.TIMEOUT, 120)
c.setopt(pycurl.NOSIGNAL, 1)
c.setopt(pycurl.USERAGENT, 'Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:13.0) Gecko/20100101 Firefox/13.0')
httpheader = [
'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language: ru-ru,ru;q=0.8,en-us;q=0.5,en;q=0.3',
'Accept-Charset:utf-8;q=0.7,*;q=0.5',
'Connection: keep-alive',
]
c.setopt(pycurl.HTTPHEADER, httpheader)
c.perform()
if c.getinfo(pycurl.HTTP_CODE) != 200:
raise Exception('HTTP code is %s' % c.getinfo(pycurl.HTTP_CODE))
return c.get_body()
```
Проверим функцию
```
print get_page('ya.ru')
```
##### Выберем из страницы поисковой выдачи список сайтов с позициями
Сконструируем поисковый запрос,
на [yandex.ru/yandsearch](http://yandex.ru/yandsearch) нам нужно послать 3 GET параметра,
'text'-запрос, 'lr'-регион поиска, 'p'-страница выдачи
```
import urllib
import urlparse
key='кирпич'
region=213
page=1
params = ['http', 'yandex.ru', '/yandsearch', '', '', '']
params[4] = urllib.urlencode({
'text':key,
'lr':region,
'p':page-1,
})
url = urlparse.urlunparse(params)
```
Выведем url и проверим в броузере
```
print url
```
Получим через предыдущую функцию страницу с выдачей
```
html = get_page(url)
```
Теперь будем ее разбирать по dom модели с помощью lxml
```
import lxml.html
site_list = []
for h2 in lxml.html.fromstring(html).find_class('b-serp-item__title'):
b = h2.find_class('b-serp-item__number')
if len(b):
num = b[0].text.strip()
url = h2.find_class('b-serp-item__title-link')[0].attrib['href']
site = urlparse.urlparse(url).hostname
site_list.append((num, site, url))
```
Поподробнее напишу что тут происходит
lxml.html.fromstring(html) — из html строки мы делаем обьект html документа
.find\_class('b-serp-item\_\_title') — ищем по документу все теги, которые содержат класс 'b-serp-item\_\_title', получаем список элементов H2 которые содержат интерсующую нас информацию по позициям, и проходим по ним циклом
b = h2.find\_class('b-serp-item\_\_number') — ищем внутри найденого тега H2 элемент b, кторый содержит номер позиции сайта, если нашли то дальше собираем позицию b[0].text.strip() сайта и строчку c url сайта
urlparse.urlparse(url).hostname — получаем доменное имя
Проверим получившийся список
```
print site_list
```
И соберем все получившееся в функцию
```
def site_list(key, region=213, page=1):
params = ['http', 'yandex.ru', '/yandsearch', '', '', '']
params[4] = urllib.urlencode({
'text':key,
'lr':region,
'p':page-1,
})
url = urlparse.urlunparse(params)
html = get_page(url)
site_list = []
for h2 in lxml.html.fromstring(html).find_class('b-serp-item__title'):
b = h2.find_class('b-serp-item__number')
if len(b):
num = b[0].text.strip()
url = h2.find_class('b-serp-item__title-link')[0].attrib['href']
site = urlparse.urlparse(url).hostname
site_list.append((num, site, url))
return site_list
```
Проверим функцию
```
print site_list('кирпич', 213, 2)
```
##### Найдем наш сайт в списке сайтов
Нам потребуется вспомогательная функция, которая отрезает 'www.' в начале сайта
```
def cut_www(site):
if site.startswith('www.'):
site = site[4:]
return site
```
Получим список сайтов и сравним с нашим сайтом
```
site = 'habrahabr.ru'
for pos, s, url in site_list('python', 213, 1):
if cut_www(s) == site:
print pos, url
```
Хм, на первой стрнице выдачи по 'python' хабра нету, попробуем пройти выдачу в цикле в глубину,
но нам нужно поставить ограничение, max\_position — до какой позиции мы будем проверять,
заодно и обернем в функцию, а на случай, если ничего не найдется будем возвращать None, None
```
def site_position(site, key, region=213, max_position=10):
for page in range(1,int(math.ceil(max_position/10.0))+1):
site = cut_www(site)
for pos, s, url in site_list(key, region, page):
if cut_www(s) == site:
return pos, url
return None, None
```
Проверяем
```
print site_position('habrahabr.ru', 'python', 213, 100)
```
Вот собственно мы и получили нашу позицию.
Напишите пожалста, интересна ли данная тема и нужно-ли продолжать?
Про что написать в следующей статье?
— сделать вебинтерфейс к этой функции с табличками и графиками и повесить скрипт на cron
— сделать обработку капчи для этой функции, и вручную и через специальные api
— сделать скрипт мониторинга чего-нить с многопоточностью
— описать работу с директом на примере генерации и заливки обьявлений через api или управления ценами | https://habr.com/ru/post/146258/ | null | ru | null |
# auto git bisect на примере ядра Linux
Данная заметка имеет собой цель продемонстрировать автоматический **git bisect** на примере ядра Linux. С последующим поиском официальной версии начиная с которой всё поломалось и последней хорошей версии.
Описание инструментария
=======================
Инструментарий[^7] представляет собой простой проект для сборки ядра и модулей с минимальным конфигом достаточным для запуска в qemu, минимального busybox, конфигурационных файлов и небольшого количества скриптов.
* gcc ;)
* binutils
* make
* qemu
* expect (только если вы собрались запускать bisect из примера)
Ядро вместе с образом **initramsfs** запускается с помощью **qemu**:
```
$ qemu-system-x86_64 -cpu host \
-kernel build-linux/arch/x86/boot/bzImage \
-initrd initramfs.cpio.xz \
-nographic -append "nokaslr console=ttyS0 root=/dev/ram" \
-enable-kvm -serial mon:stdio
```
Пароля нет и нас сразу выбрасывает в консоль.
С помощью этого проекта может быть проведен простой bisect [^1].
> Внимание! Если вы планируете повторить манипуляции представленные ниже, или будете использовать как основу для своего проекта, имейте ввиду:
>
> 1. ядро сильно зависит от версии **gcc** и **binutils**, некоторые ядра
>
> могут собраться только с определенной версией gcc, могут собраться с
>
> небольшими правками или подавлением ошибок или не собраться вообще
> 2. с новой версией binutils (начиная с версии 2.31) могут быть проблемы с
>
> загрузкой модулей на версиях ядра до v4.16-rc3
>
>
>
>
>
> Версии gcc 7.3.0 и binutils 2.30 позволили мне без проблем собрать и
>
> запустить версии ядра с v4.14 по v5.3-rc2.
Постановка задачи
=================
Собственно здесь представлена дополнительная задача, решенная в рамках основной, которую было решено взять за основу для примера.
В какой-то момент путь в **debugfs** поменял своё значение с изначально реализованного в версии **v4.14**:
```
# ls /sys/kernel/debug/
gpio-mockup-event
# ls /sys/kernel/debug/gpio-mockup-event
gpio-mockup-A
```
На (замечено на версии **v5.3-rc2**):
```
# ls /sys/kernel/debug/
gpio-mockup
# ls /sys/kernel/debug/gpio-mockup
gpiochip1
```
Что сломало мне тесты для моей программы, и задача состоит в том что бы найти когда, где и кто, в том числе определить <<хорошую>> и <<плохую>> официальные версии ядра.
Решение с помощью git bisect run
================================
В случае повторения данного опыта не забудьте выполнить:
```
$ git submodule update --init
```
**bisect.sh** запускаем через **git bisect run**, сам же скрипт очень прост и состоит из трёх действий:
1. очистить всё
2. собрать всё
3. запустить **tests/bisect.expect** (скрипт для expect)
Тест запускает qemu, ждёт промта, загружает модуль **gpio-mockup** и проверяет наличие директорий в **/sys/debug/kernel**.
Запускаем процесс (он такой же как и для ручного bisect за исключением последнего шага) :
```
$ git -C linux bisect start
$ git -C linux bisect good v4.14 # указываем любой хороший коммит
$ git -C linux bisect bad v5.3-rc2 # указываем любой плохой коммит
Bisecting: 73727 revisions left to test after this (roughly 16 steps)
[798bba01b44b0ddf8cd6e542635b37cc9a9b739c]
RDMA/core: Fail early if unsupported QP is provided
```
Запускаем **git bisect run**:
```
$ time git -C linux bisect run ../bisect.sh # запускаем наш простой скрипт
```
Ждем… Ждем… Ждем… В общем даже не смотря на попытку экономии времени сборки у меня одна сборка занимает:
```
$ time ../bisec.sh
real 2m1.695s
user 11m7.409s
sys 2m0.751s
```
По предварительной оценке **git bisect** должен справиться за 16 шагов.
И вот наконец-то результат:
```
d51ee07a8de7d6d3f7738a5e74861133fd2d46a0 is the first bad commit
commit d51ee07a8de7d6d3f7738a5e74861133fd2d46a0
Author: Bartosz Golaszewski
Date: Thu Jan 17 15:04:23 2019 +0100
gpio: mockup: don't create the debugfs link named after the label
User-space tests no longer use it and we're breaking the interface
anyway.
Signed-off-by: Bartosz Golaszewski
:040000 040000 c1a1873f4cfcecace123b72fb036c3861151c9b9 61917a273f4f1f078639463a29acb8a103d50b41 M drivers
bisect run success
real 42m6.873s
user 192m39.291s
sys 33m55.932s
```
Чтож результат дал нам номер коммита в котором всё пропало:
**d51ee07a8de7d6d3f7738a5e74861133fd2d46a0**.
Теперь можно посмотреть на список всех проделанных **git bisect** шагов:
**git bisect log**
```
$ git bisect log
git bisect start
# good: [bebc6082da0a9f5d47a1ea2edc099bf671058bd4]
Linux 4.14
git bisect good bebc6082da0a9f5d47a1ea2edc099bf671058bd4
# bad: [609488bc979f99f805f34e9a32c1e3b71179d10b]
Linux 5.3-rc2
git bisect bad 609488bc979f99f805f34e9a32c1e3b71179d10b
# good: [798bba01b44b0ddf8cd6e542635b37cc9a9b739c]
RDMA/core: Fail early if unsupported QP is provided
git bisect good 798bba01b44b0ddf8cd6e542635b37cc9a9b739c
# good: [e266ca36da7de45b64b05698e98e04b578a88888]
Merge tag 'staging-5.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging
git bisect good e266ca36da7de45b64b05698e98e04b578a88888
# bad: [318222a35bfb0ae9b5ff3e359a583463e6cfcd94]
Merge branch 'akpm' (patches from Andrew)
git bisect bad 318222a35bfb0ae9b5ff3e359a583463e6cfcd94
# bad: [962d5ecca101e65175a8cdb1b91da8e1b8434d96]
Merge tag 'regmap-v5.2' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap
git bisect bad 962d5ecca101e65175a8cdb1b91da8e1b8434d96
# bad: [f47d633134f7033e3d0c667419d9f8afd69e308d]
Merge tag 'tag-chrome-platform-for-v5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/chrome-platform/linux
git bisect bad f47d633134f7033e3d0c667419d9f8afd69e308d
# good: [6c3f98faddc7f07981c5365ba2f45905ad75fcaa]
Merge branch 'i2c/for-5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux
git bisect good 6c3f98faddc7f07981c5365ba2f45905ad75fcaa
# bad: [2901752c14b8e1b7dd898d2e5245c93e531aa624]
Merge tag 'pci-v5.1-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci
git bisect bad 2901752c14b8e1b7dd898d2e5245c93e531aa624
# bad: [1a29e857507046e413ca7a4a7c9cd32fed9ea255]
Merge tag 'docs-5.1' of git://git.lwn.net/linux
git bisect bad 1a29e857507046e413ca7a4a7c9cd32fed9ea255
# bad: [3601fe43e8164f67a8de3de8e988bfcb3a94af46]
Merge tag 'gpio-v5.1-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio
git bisect bad 3601fe43e8164f67a8de3de8e988bfcb3a94af46
# good: [cf2e8c544cd3b33e9e403b7b72404c221bf888d1]
Merge tag 'mfd-next-5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd
git bisect good cf2e8c544cd3b33e9e403b7b72404c221bf888d1
# good: [8fab3d713ca36bf4ad4dadec0bf38f5e70b8999d]
Merge tag 'gpio-v5.1-updates-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux into devel
git bisect good 8fab3d713ca36bf4ad4dadec0bf38f5e70b8999d
# bad: [9aac1e336c3ab3824f646224f4b2309b63c51668]
Documentation: gpio: legacy: Don't use POLLERR for poll(2)
git bisect bad 9aac1e336c3ab3824f646224f4b2309b63c51668
# good: [0248baca03b8f188eccbb991bda2caec4c330975]
Merge tag 'intel-gpio-v5.1-1' of git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-gpio-intel into devel
git bisect good 0248baca03b8f188eccbb991bda2caec4c330975
# bad: [e09313ce7ea1706d1642c7d5af103915e69fc6d0]
gpio: mockup: change the signature of unlocked get/set helpers
git bisect bad e09313ce7ea1706d1642c7d5af103915e69fc6d0
# good: [cbf1e092f2d86e6d7cdb7f9ff8a333f52c826232]
gpio: mockup: implement get_multiple()
git bisect good cbf1e092f2d86e6d7cdb7f9ff8a333f52c826232
# bad: [83336668b94eb44ecd78a0b7840e43f0859e05cb]
gpio: mockup: change the type of 'offset' to unsigned int
git bisect bad 83336668b94eb44ecd78a0b7840e43f0859e05cb
# bad: [d51ee07a8de7d6d3f7738a5e74861133fd2d46a0]
gpio: mockup: don't create the debugfs link named after the label
git bisect bad d51ee07a8de7d6d3f7738a5e74861133fd2d46a0
# first bad commit: [d51ee07a8de7d6d3f7738a5e74861133fd2d46a0] gpio: mockup: don't create the debugfs link named after the label
```
На самом деле это провал первой проверки (да — в тесте их две):
```
send "ls /sys/kernel/debug/\r"
expect {
"gpio-mockup-event" {}
timeout { puts "gpio-mockup-event not found"; exit 1 }
}
```
Другая проверка ломается коммитом **2a9e27408e12de455b9fcf66b5d0166f2129579e** (конечно было бы их разделить но ленив, поэтому я просто посмотрел коммиты <<рядом>>):
```
send "ls /sys/kernel/debug/gpio-mockup-event/\r"
expect {
"gpio-mockup-A" { puts "gpio-mockup-A found" }
timeout { puts "gpio-mockup-A not found"; exit 1 }
}
```
Что ж давайте выясним когда коммит **d51ee07a8de7** попал в основную ветку к Линусу и с какой официальной версии ядра он присутствует[^6].
Посмотрим все коммиты до **d51ee07a8de7** фильтруя только merge коммиты[^3] (merge commits) и имеющие прямой путь[^4] (ancestry chain) :
```
$ git log --pretty=oneline d51ee07a8de7d6d3f7738a5e74861133fd2d46a0..master --ancestry-path --merges
```
Это даёт нам все merge коммиты между **d51ee07a8de7** и master. Давайте глянем в конец списка (показаны только три последнии записи) :
```
3601fe43e8164f67a8de3de8e988bfcb3a94af46 Merge tag 'gpio-v5.1-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio
3dda927fdbaac926c50b550ccb51ed18c184468b Merge branch 'ib-qcom-ssbi' into devel
2f7db3c70fdfb22480a1b0aa734664fc256532f2 Merge tag 'gpio-v5.1-updates-for-linus-part-2' of git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux into devel
```
Как мы видим последний коммит это поглощение ветки из **git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux** в **git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio** devel, а первый в списке это уже поглощение ветки товарища Linus Walleij (<<начальника>> подсистемы GPIO) товарищем Linus Torvalds в ветку master.
Есть очень хороший скрипт[^2], который сразу приведёт к результату без ручной работы:
```
# это сразу даст нам нам коммит 3601fe43e816 и ничего более
$ git-find-merge d51ee07a8de7d6d3f7738a5e74861133fd2d46a0 master
```
Найдем первую версию после коммита **3601fe43e816**:
```
$ git name-rev --name-only 3601fe43e816
tags/v5.1-rc1~102
```
Число **102** здесь это расстояние от **3601fe43e816** до **v5.1-rc1**, давайте проверим его используя опцию first-parent[^5]:
```
$ git -P log --pretty --oneline --first-parent \
--graph 3601fe43e816..v5.1-rc1 | wc -l
102
```
Похоже, что все в порядке. Я могу заявить, что первая официальная версия ядра в которой всё <<сломалось>> **v5.1-rc1**, а в версии **v5.0** всё было в порядке:
```
$ git describe 3601fe43e816
v5.0-8748-g3601fe43e816
```
Заключение
==========
Ни для кого не секрет, что делать подобные вещи автоматически гораздо веселее. Такое количество шагов вручную cделать очень тяжело, учитывая долгое время сборки, можно элементарно забыть чем занимался.
Собственно при сформулированных требованиях можно выполнять любые манипуляции, сделать специальную программу и добавлять в **initramfs**, или проверять что-то своё и иметь под рукой bisect.
Тесты могут быть в любом удобном виде пока они выполняют требования **git bisect run**. Более того c помощью прикладных программ (например того же самого expect) можно огранизовать прошивку платы с нужной вам архитектурой и выполнять проверки непосредственно на ней.
[^1]:[Christian Couder. *Fully automated bisecting with "git bisect run"*.](https://lwn.net/Articles/317154/)
[^2]:[rmandvikar. *Git hooks system (global, local hooks), utility shell scripts, configuration for HOME dir*.](https://github.com/rmandvikar/git-shell-setup/blob/next/bin/git-find-merge/)
[^3]:[Scott Chacon and Ben Straub. *Pro Git book*.](https://github.com/rmandvikar/git-shell-setup/blob/next/bin/git-find-merge/)
[^4]:[void.pointer. *How does ancestry path work with git log?*.](https://stackoverflow.com/questions/36433572/how-does-ancestry-path-work-with-git-log/)
[^5]:[Marc G Gauthier. *Git Log’s –first-parent Option*.](https://marcgg.com/blog/2015/08/04/git-first-parent-log/)
[^6]:[Guillaume Morin. *Find merge commit which include a specific commit*.](https://stackoverflow.com/questions/8475448/find-merge-commit-which-include-a-specific-commit/)
[^7]:[Linux kernel git bisect template](https://github.com/maquefel/kernel-bisect-template)
Оригинал использованной в заголовке картинки: <https://xkcd.com/1597/>. | https://habr.com/ru/post/462245/ | null | ru | null |
# База GeoIP – страны и города
При разработке одного проекта встала задача – определить по IP-адресу посетителя его страну и город, на русском языке. Поиск готового решения оказался безуспешным – русскоязычные базы стран можно найти (например, [wipmania.com](http://www.wipmania.com/)), но баз городов нет. Помощь пришла из-за границы, в лице англоязычного [maxmind.com](http://www.maxmind.com/app/geolitecity). База была приведена к нормальному состоянию (MySQL) и частично переведена на русский язык с помощью нескольких справочников (~6,000 названий, с учетом городов-тезок ~15,500). Результат этой работы доступен для свободного скачивания.
База доступна в двух модификациях: «[Страны и города](http://www.gogototour.com/geoip/net_city.zip)» (17Mb, после установки ~85Mb) и «[Только страны](http://www.gogototour.com/geoip/net_country.zip)» (2Mb, после установки ~11Mb). Также в архивах находится небольшой пример использования базы данных на php.
Точность определения страны ~99%, точность определения городов России ~90%. Много это или мало – зависит от задач, которые собираетесь решать с помощью этой базы.
Тестовое демо – [определение вашей страны и города по IP-адресу](http://netload.biz/ip.php)
Рабочее демо — [определение города по IP в форме поиска билетов](http://www.gogototour.com/ru/city/golden-sands/)
Для установки базы рекомендую воспользоваться программами типа **mysqldumper** или через ssh выполнить
`mysql –p –uюзер база_данных < файл.sql`
Не рекомендую устанавливать базу городов на виртуальный хостинг, не выдержит нагрузки.
Планирую делать периодические обновления и дополнения. Остались непереведенными ~180 тысяч названий, если кто-то поделится хорошими географическими англо-русскими или русско-английскими словарями – приму с благодарностью. | https://habr.com/ru/post/108541/ | null | ru | null |
# Как использовать PHP для создания микросервиса?
В этой статье рассказывается, как использовать PHP для построения архитектуры микросервисов. Так как PHP идет в ногу со временем, он способен поддерживать микросервисные архитектуры для больших систем.
### Проблема сервитизации
При использовании traditional framework (laravel, yii, symfony) для реализации микросервисов на Php эффекта очень мало.
Почему?
В режиме разработки fpm, поскольку резидентная память не может быть предоставлена, каждый запрос должен начинаться с нуля, начиная с загрузки процесса, чтобы потом выйти из него, добавляя много бесполезных накладных расходов.
Кроме того, соединение с базой данных не может быть использовано повторно и не защищается, потому что fpm является процессно-ориентированным, и количество процессов fpm также определяет и число параллельных процессов. Таковы проблемы, с которыми мы столкнулись при обычной разработке fpm.
Он недостаточно дружелюбен к микросервисным инструментам, таким как docker, и полагается на nginx для предоставления услуг.
Таким образом, вот причины, по которым Java сейчас более популярна как интернет-платформа по сравнению с PHP. Помимо PHP non-memory resident, существует множество других проблем, требующих решения.
Теперь давайте посмотрим, как Swoft имплементирует микросервис.
### Что такое Swoft?
Swoft — это фреймворк корутин для микросервисов PHP, основанный на расширении Swoole. Как и Go, Swoft имеет встроенный веб-сервер и общий клиент для корутин, и является резидентным в памяти, независимым от традиционного PHP-FPM.
Здесь есть Go-подобные языковые операции, гибкие аннотации, аналогичные фреймворку Spring Cloud, мощный контейнер для внедрения глобальных зависимостей, комплексное управление сервисами, гибкое и мощное AOP (Aspect Oriented Programming), стандартная реализация спецификации PSR (PHP Standards Recommendations) и так далее.
### Swoft Github
* [swoft-cloud/swoft: PHP Microservice Full Coroutine Framework](https://github.com/swoft-cloud/swoft)
### Что нам нужно для создания микросервиса?
* Высокопроизводительный фреймворк для приложений
* Регистрация и обнаружение услуг
* Автоматическое переключение услуг
* Ограничение услуг
* Конфигурационный центр
Да, в Swoft все уже готово
### Высокая производительность Swoft
Вы можете представить, какие преимущества дает нам резидентная память.
* **Фреймворк инициализируется только один раз**; мы можем сосредоточиться на обработке запросов, потому что фреймворк инициализируется в памяти только один раз при запуске для резидентной памяти
* **Мультиплексирование соединений**; если мы не используем пул соединений, тогда к чему приводит создание соединений для каждого запроса, этого не могут понять некоторые инженеры. Это приводит к чрезмерному использованию ресурсов бэкенда. Для некоторых основных сервисов, таких как Redis, базы данных, соединения оказываются дорогостоящим расходом ресурсов.
Итак, есть ли подходящее решение? Ответ — да, и многие используют фреймворк под названием Swoft. Swoft — это [RPC](https://en.swoft.org/docs/2.x/en/rpc-server/index.html) (Remote Procedure Call)-фреймворк с функциональностью Service Governance. Swoft — это первый фулл-стек PHP-фреймворк, резидентный в памяти, корутинный, базирующийся на основной концепции Spring Boot согласно которой соглашение важнее чем конфигурация.
Swoft обеспечивает более элегантный способ использования RPC-сервисов, таких как Dubbo, имеет отличную производительность, схожую с Golang. Вот результат стресс-теста производительности Swoft на моем PC.
Скорость обработки данных в стресс-тесте ab очень впечатляет. С процессором i7 generation 8 и памятью 16GB на 100000 запросов уходит всего 5s. Такого быстродействия практически невозможно достичь в режиме разработки fpm.
Данного теста также достаточно, чтобы продемонстрировать высокую производительность и стабильность Swoft.
[**Регистрация и обнаружение сервисов**](https://en.swoft.org/docs/2.x/en/ms/govern/register-discovery.html)
В процессе управления микросервисами часто требуется регистрация сервисов, инициированных на сторонних кластерах, таких как consul/etcd. В этой главе для осуществления регистрации и обнаружения сервисов используется компонент swoft-consul в составе фреймворка Swoft.
Логика реализации
```
php declare(strict_types=1);
namespace App\Common;
use ReflectionException;
use Swoft\Bean\Annotation\Mapping\Bean;
use Swoft\Bean\Annotation\Mapping\Inject;
use Swoft\Bean\Exception\ContainerException;
use Swoft\Consul\Agent;
use Swoft\Consul\Exception\ClientException;
use Swoft\Consul\Exception\ServerException;
use Swoft\Rpc\Client\Client;
use Swoft\Rpc\Client\Contract\ProviderInterface;
/**
* Class RpcProvider
*
* @since 2.0
*
* @Bean()
*/
class RpcProvider implements ProviderInterface
{
/**
* @Inject()
*
* @var Agent
*/
private $agent;
/**
* @param Client $client
*
* @return array
* @throws ReflectionException
* @throws ContainerException
* @throws ClientException
* @throws ServerException
* @example
* [
* 'host:port',
* 'host:port',
* 'host:port',
* ]
*/
public function getList(Client $client): array
{
// Get health service from consul
$services = $this-agent->services();
$services = [
];
return $services;
}
}
```
[**Сервисный автоматический выключатель**](https://en.swoft.org/docs/2.x/en/ms/govern/breaker.html)
В базовом режиме автоматический выключатель гарантирует, что поставщик не будет вызван, когда он находится в разомкнутом состоянии, однако нам также необходим дополнительный метод сброса автоматического выключателя после возобновления обслуживания поставщиком.
Одно из возможных решений заключается в том, что автоматический выключатель периодически определяет, возобновлено ли обслуживание. Как только оно возобновляется, он устанавливается в закрытое положение. При повторной попытке состояние становится полуоткрытым.
Использование предохранителя является простым и мощным. Он может быть аннотирован с помощью `@Breaker`. Предохранитель Swoft может быть использован в любом сценарии, например, при вызове службы. Он может быть понижен или не вызываться при запросе сторонней службы.
```
php declare(strict_types=1);
namespace App\Model\Logic;
use Exception;
use Swoft\Bean\Annotation\Mapping\Bean;
use Swoft\Breaker\Annotation\Mapping\Breaker;
/**
* Class BreakerLogic
*
* @since 2.0
*
* @Bean()
*/
class BreakerLogic
{
/**
* @Breaker(fallback="loopFallback")
*
* @return string
* @throws Exception
*/
public function loop(): string
{
// Do something
throw new Exception('Breaker exception');
}
/**
* @return string
* @throws Exception
*/
public function loopFallback(): string
{
// Do something
}
}</code
```
[**Ограничение обслуживания**](https://en.swoft.org/docs/2.x/en/ms/govern/limiter.html)
Ограничение потока, автоматический выключатель, понижение уровня обслуживания Это можно подчеркивать неоднократно, потому что они действительно важны. Когда услуга не работает, она должна быть прекращена. Ограничение потока — это инструмент самозащиты. Если нет механизма самозащиты и соединения принимаются независимо от их количества, то при очень большом трафике фронтенд обязательно зависнет, а бэкенд не сможет обработать все соединения.
Ограничение потока — это ограничение числа одновременных запросов и количества запросов при доступе к дефицитным ресурсам, таким как товары на флэш-распродаже, чтобы эффективно срезать пиковые нагрузки и сгладить кривую потока.
Цель ограничения потока — ограничить скорость одновременного доступа и одновременных запросов, или ограничить скорость запроса в пределах временного окна для защиты системы. Как только предел скорости достигнут или превышен, запросы могут быть отклонены или поставлены в очередь.
Нижний слой ограничения потока Swoft использует алгоритм `token bucket`, а основной слой опирается на Redis для реализации распределенного ограничения потока.
Ограничение потока Swoft не только ограничивает контроллеры, оно также ограничивает методы в любом бине и контролирует скорость доступа к методам. Ниже приводится пример с подробным объяснением.
```
php declare(strict_types=1);
namespace App\Model\Logic;
use Swoft\Bean\Annotation\Mapping\Bean;
use Swoft\Limiter\Annotation\Mapping\RateLimiter;
/**
* Class LimiterLogic
*
* @since 2.0
*
* @Bean()
*/
class LimiterLogic
{
/**
* @RequestMapping()
* @RateLimiter(rate=20, fallback="limiterFallback")
*
* @param Request $request
*
* @return array
*/
public function requestLimiter2(Request $request): array
{
$uri = $request-getUriPath();
return ['requestLimiter2', $uri];
}
/**
* @param Request $request
*
* @return array
*/
public function limiterFallback(Request $request): array
{
$uri = $request->getUriPath();
return ['limiterFallback', $uri];
}
}
```
Здесь поддерживается выражение symfony/expression-language. Если скорость ограничена, будет вызван метод `limiterFallback`, определенный в `fallback`.
[**Центр конфигурации**](https://en.swoft.org/docs/2.x/en/ms/govern/config.html)
Прежде чем перейти к обсуждению центра конфигурации, давайте поговорим о конфигурационном файле. Он нам хорошо знаком. С его помощью мы можем динамически изменять программу. Вот чья-то цитата об этом:
> Динамическая регулировка полета системы во время выполнения
>
>
Для автономной версии мы называем его конфигурацией (файлом); для распределенной кластерной системы мы называем его центром конфигурации (системой);
В этой главе в качестве примера используется Apollo для извлечения сервисов конфигурации и безопасного перезапуска из удаленного центра конфигурации. Если вы не знакомы с Apollo, вы можете сначала посмотреть на компонент [Apollo](https://en.swoft.org/docs/2.x/en/extra/apollo.html) расширения Swoft и прочитать официальную документацию Apollo.
В этой главе в качестве примера используется Apollo в Swoft. При изменении конфигурации Apollo перезапустите службу (`http-server` / `rpc-server` / `ws-server`). Ниже приведен пример агента:
```
php declare(strict_types=1);
namespace App\Model\Logic;
use Swoft\Apollo\Config;
use Swoft\Apollo\Exception\ApolloException;
use Swoft\Bean\Annotation\Mapping\Bean;
use Swoft\Bean\Annotation\Mapping\Inject;
/**
* Class ApolloLogic
*
* @since 2.0
*
* @Bean()
*/
class ApolloLogic
{
/**
* @Inject()
*
* @var Config
*/
private $config;
/**
* @throws ApolloException
*/
public function pull(): void
{
$data = $this-config->pull('application');
// Print data
var_dump($data);
}
}
```
Выше приведен обычный способ настройки Apollo, в дополнение к этому методу [Swoft-Apollo](https://en.swoft.org/docs/2.x/en/extra/apollo.html) предоставляет больше способов использования.
### Заключение
В данный момент наш простой фреймворк микросервисов был построен. Если использовать традиционный PHP-фреймворк, этого достичь очень сложно. Но с помощью Swoft все гораздо проще.
GitHub - swoft-cloud/swoft: 🚀 PHP Microservice Full Coroutine Framework[github.com](https://github.com/swoft-cloud/swoft)
---
> Материал подготовлен в рамках курса [«PHP Developer. Professional»](https://otus.pw/yEL6/).
>
> Всех желающих приглашаем на двухдневный онлайн-интенсив **«Пишем микросервисный бэкенд на PHP»**. На занятии:
> - Познакомимся с понятием контейнеризации на примере Docker и принципами в работе с контейнерами;
> - Сложим понимание термина микросервис и построим инфраструктуру для приложения, состоящего из двух микросервисов;
> - Узнаем как работают Nginx и PHP-FPM в связке и внедрим их в созданные микросервисы.
> [>> РЕГИСТРАЦИЯ](https://otus.pw/9kJiT/)
>
> | https://habr.com/ru/post/580264/ | null | ru | null |
# Менеджер качества, или как не спалить лоу-энд девайсы ультра-графикой
Всем привет, сегодня мы расскажем о том, как мы делим качества и какие инструменты для этого используем в проекте War Robots.
Релиз War Robots состоялся еще в 2014 году, и за 7 лет существования проекта графическая часть в нем постоянно развивалась. Но в то же время команда постоянно сталкивалась с ограничениями из-за минимальных требований к девайсам. Оперируя таким большим проектом, у которого немало устройств входит в low-end сегмент, нельзя просто взять и запилить крутой современный графен, не потеряв при этом часть аудитории.
Так у нас появилась задача: сделать всем красиво и хорошо. Поэтому мы решили делать War Robots Remastered — с блэк-джеком, обновлением графического пайплайна и разделением ассетов на разные качества.
Первое и самое очевидное, что от нас требовалось, — для разных групп девайсов сделать контент, удовлетворяющий требованиям по картинке и производительности.
На тот момент билд War Robots под Android со всеми ресурсам весил порядка 700 МБ и включал сотни единиц контента. У нас было 13 карт, 81 мех, более ста пушек, десяток дронов и еще куча всякой мелочи. Не то, чтобы все это было категорически необходимо в проекте, но если уж начал пилить контент, то иди в своем увлечении до конца.
И второе — нам нужно этими качествами как-то управлять и предоставлять пользователю то качество, которое будет оптимально для его девайса.
У нас уже был менеджер качества, состоящий из динамических пресетов и представляющий собой ScriptableObject с кастомным InspectorGUI. Это была длиннющая портянка с настройками и пресетами, почти полностью завязанная на логику «Роботов», и каждое поле в настройке рисовалось кодом. Хочешь добавить параметр в настройку — не забудь отрисовать это в InspectorGUI. Выглядело это монструозно, так как из-за большого количества настроек число фолдаутов в инспекторе достигало более 9000.
Динамический скейлинг параметров игры давал свои преимущества, но у него также было и несколько минусов, из-за которых нам пришлось от него отказаться. В первую очередь — из-за количества пресетов. Со временем из-за разной архитектуры поддерживаемых устройств количество пресетов качества накапливалось, пока не достигло 15 штук. В реальности мало кто обращал на это внимание и, конечно, никто не тестировал все 15 пресетов на каждом устройстве в продакшене. К тому же, поддерживать такое количество пресетов довольно сложно и с точки зрения разработки: никогда не знаешь, когда старый Quality Manager возьмет и переключит параметры внутри текущего качества — и какие именно. Вдобавок, когда мы начали работу над новым кастомным рендер-движком и на основе него запрофилировали все 15 качеств, оказалось, что разброс по производительности между ними не превышает 15-20%.
Все это нас не устраивало, так что мы решили изменить подход к формированию пресетов и запилить новый Quality Manager. А задачу эту передали нашему отделу кросс-проектной разработки, именуемому Platform Team.
Теперь поговорим о том, что же такое новый Quality Manager в War Robots, какие задачи он решает и как устроен.
Так что это за менеджер качества такой
======================================
Основная задача заключалась в том, чтобы создать инструмент, с помощью которого можно с минимальным временными затратами добавлять в проект настройки качества, формировать из них пресеты и задавать параметры, на основе которых пользователю будет выбран оптимальный для его устройства пресет.
Главными сущностями у нас являются:
* QualitySetting — набор параметров, объединенных в общую группу;
* Preset, состоящий из выбранных уровней QualitySetting разного типа.
Quality Manager состоит из двух частей: runtime-часть с API для инициализации и переключения качеств и editor-часть с GUI, которые позволяют все это конфигурировать.
Editor
======
Начнем с editor-части. Ее задача — предоставление интерфейса для конфигурации настроек качества и пресетов и минимизация количества кода, необходимого со стороны клиента. В идеале мы хотели заставить клиентщиков описывать только структуры настроек качества, а всю работу по отрисовке оставить на стороне Quality Manager.
Вот так выглядит наше окно, разделенное на три вкладки: настройки качества, пресеты, группы устройств:
Давайте подробнее разберемся, как с этим работать, и начнем с вкладки Quality Settings.
Так выглядят классы «базовых настроек» и «настроек кэша пререндеров» в War Robots. Эти же классы затем используются в рантайме:
**Посмотреть код**
```
public class CommonQualitySettings : WRQualitySetting
{
[IntSliderView(0, 72)]
public int CorpsesCount { get; private set; }
[FloatSliderView(5, 600)]
public float UnloadPeriodImGameplay { get; set; }
[FloatSliderView(0, 300)]
public float UnloadPeriodInMenu { get; private set; }
public bool UseMechCacheInHangar { get; set; }
public bool HSEnabled { get; private set; }
public bool BattleAmbientSoundEnabled { get; private set; }
public HangarCacheSettings CacheSettings { get; private set; }
public CommonQualitySettings()
{
CorpsesCount = 12;
UseMechCacheInHangar = true;
HSEnabled = true;
BattleAmbientSoundEnabled = true;
}
}
public class ImageCacheSettings : WRQualitySetting
{
[IntSliderView(0, 1000)]
public int MinCacheSize { get; private set; }
[IntSliderView(0, 1000)]
public int MaxCacheSize { get; private set; }
[IntPopupView(new[] { 128, 256, 512, 1024 })]
public int RenderSize { get; private set; }
public string Info
{
get { return $"Cache takes from {(int) (MinCacheSize * 0.1f)} to {(int) (MaxCacheSize * 0.1f)} Mb"; }
}
public ImageCacheSettings()
{
MinCacheSize = 150;
MaxCacheSize = 200;
RenderSize = 512;
}
}
```
А вот так это выглядит в окне Quality Manager:
Получается достаточно простая схема. Клиентские разработчики создают класс с набором полей и настраивают уровни качества для него в окне Quality Manager. Он, в свою очередь, «из коробки» умеет отрисовывать примитивные типы, Enum, Nullable, массивы, списки, интерфейсы и собственные классы c полями вышеперечисленных типов, включая другие классы. На случай, когда необходимо отрисовывать для поля кастомный GUI, в QM предусмотрена возможность помечать поля атрибутом, в классе которого реализована отрисовка этого поля.
Так, например, выглядит код класса, меняющего отрисовку для int значения c IntFiled на Slider с параметрами шага, минимального и максимального значений:
**Посмотреть код**
```
[Conditional("UNITY_EDITOR")]
public class IntSliderViewAttribute : CustomPropertyViewAttribute
{
public int MinValue { get; private set; }
public int MaxValue { get; private set; }
public int Step { get; private set; }
public new int Value
{
get { return (int) base.Value; }
set { base.Value = value; }
}
public IntSliderViewAttribute(int minValue, int maxValue, int step = 1)
{
MinValue = minValue;
MaxValue = maxValue;
Step = step;
}
#if UNITY_EDITOR
public override void OnGUI()
{
Value = Step * UnityEditor.EditorGUILayout.IntSlider(Value / Step, MinValue / Step, MaxValue / Step);
}
#endif
}
```
А так — поле с этим атрибутом:
```
[IntSliderView(0, 72)]
public int CorpsesCount { get; private set; }
```
В QM сразу включен ряд реализаций для кастомной отрисовки полей: IntSliderView, FloatSliderView, IntPopupView, PresetIndexView, PresetNameView, QualitySettingIndexView, QualitySettingNameView. Этого скромного набора нам хватило для интеграции QM в War Robots и переезда со старого QM на новый. Кода в проекте стало ощутимо меньше, а тот, который остался, стал заметно проще, понятнее и описывал именно то, что он и должен был описывать — данные и логику работы с ними.
У нас уже есть классы настроек качества и данные для их уровней, так что пора формировать из них пресеты. Для этого отправляемся на первую вкладку окна QM — Presets.
Тут все достаточно тривиально: мы заводим необходимое количество пресетов, задаем им имена и выставляем для них уровни настроек качества. Готово.
Теперь, когда у нас есть пресеты, осталось задать параметры, по которым будет определяться, какой пресет использовать на девайсе.
Третья вкладка — Device Groups.
На этой вкладке мы формируем группы девайсов. Для этого мы используем несколько параметров: объем ОП, частоту процессора, модель GPU и модель девайса для совсем точного попадания. Все параметры не являются обязательными, и можно для группы указать только часть из них. Так, например, для устройств на iOS самый простой вариант — составить карту по модели устройств. На Android же большую часть покроют группы, объеденные по популярным моделям GPU, а в остальных случаях можно указать минимальные требования по объему оперативной памяти и частоте процессора.
Для группы — помимо пресета, который будет выбран по умолчанию — мы также задаем список доступных этой группе устройств пресетов для того, чтобы пользователь на low-end девайсе не смог поменять настройки на ultra high, что может привести к крешам по OOM на старте приложения и блокировать тем самым возможность изменить настройки обратно.
Итак, конфиг QM готов. Сериализуется он в JSON, что дает возможность его легко читать и править без окна QM, а также доставлять на клиент с сервера.
Помимо описанного функционала, QM позволяет:
* работать с несколькими конфигурациями;
* добавлять к пресетам кастомные данные, не относящиеся к уровню настроек качеств (мало ли);
* конфигурировать базовые настройки, не относящиеся к пресетам (раздел Custom Data).
Runtime
=======
API рантайм-части достаточно простой и включает основные методы для работы с QM:
* инициализация (в том числе и обновление текущего инстанса QM из нового конфига);
* выбор пресета (по индексу, имени, объекту пресета из конфига);
* выбор уровня настройки качества (по индексу, имени, объекту настройки качества из конфига);
* сброс пресета на дефолтное значение;
* сохранение/удаление данных о выбранном пресете и уровне настроек качества (стейта).
Так инициализируется инстанс QM:
```
var exampleStateController = new ExampleStateController();
var qualityManager = QualityManager.Initialize(exampleStateController);
```
Помимо основных методов, инстанс содержит ивенты о смене пресета и уровня настройки качества. Логика применения настроек качества лежит на клиентской стороне — для этого у класса QualitySetting есть виртуальный метод Apply, который вызывается при смене уровня настройки качества.
Помимо базовых методов API, в QM есть набор методов для «мягкого» переключения уровней качества. В случае, когда в рантайме мы сталкиваемся с ситуацией, при которой девайс должен тянуть заданный ему пресет, но при этом происходит падение FPS из-за посторонних факторов, можно ослабить нагрузку, понизив одну из настроек качества, или наоборот. Для этого в QM есть отдельный тип настроек качества, у которого есть виртуальный метод CanBeSwitchedTo, позволяющий определить, можно ли сменить текущий уровень настройки на новый. Так мы можем в рантайме поэтапно даунскейлить качество, чтобы стабилизировать FPS, или наоборот — попробовать дать девайсу нарисовать лучшую картинку, пока не начнем ловить падение FPS.
Для этого API QM содержит набор методов для попытки даунгрейда или апгрейда уровня настроек качества. При этом можно задать как конкретный тип настройки качества, так и предоставить системе самой решать, какую из них менять. В этом случае система выберет настройку, приводящую к минимальному изменению общего качества, и будет выбирать настройки с большим количеством уровней качества.
При смене пресета/уровня настройки качества QM сохраняет стейт и при последующей инициализации использует уже его. По умолчанию данные сохраняются в PrefsManager, и сохраненный стейт используется до тех пор, пока не будет изменена версия конфига QM. При необходимости можно реализовать свой вариант IStateController и использовать эту реализацию при инициализации QM, чтобы определить, когда можно использовать стейт от старой версии конфига, а когда смена конфига должна приводить к сбросу пресета на дефолтный.
Конфиг для QM лежит в папке ресурсов и по умолчанию грузится из билда. Дополнительно к этому мы предусмотрели механизм удаленного обновления конфига с CDN. Для этого файл конфигурации выкладывается на CDN, а на клиент приходит ссылка на него с указанием хеша конфига. По хешу система определяет, нужно ли ей обновить конфиг перед инициализацией или на девайсе уже есть актуальная версия конфига. Так мы в любой момент при необходимости можем поменять настройки QM у всех пользователей.
С QM разобрались. Давайте теперь более предметно рассмотрим, как мы сформировали список настроек качества, пресетов и групп устройств на проекте War Robots.
Как все это работает в игре
===========================
Мы решили зафиксировать несколько четко установленных пресетов, а динамики достигать так же, как и в консольных играх, — за счет скейлинга картинки. Современные девайсы обладают экранами с высоким разрешением, однако GPU в них стоят, конечно, далеко не RTX 3090, так что было бы наивно полагать, что они будут справляться с 60 FPS в нативных Quad HD или даже 4k. Собственно, мы сразу ограничили плотность пикселей сверху, проитерировавшись до значения в 350 ppi.
Изначально при работе над ремастером мы фокусировались на двух качествах — HD (high definition) и LD (low definition). Весь контент, который мы переделывали, основывался на них, и все инструменты по автоматической генерации исходили тоже из них. Однако вскоре мы поняли, что нам понадобится дополнительный уровень качества, который будет нацелен на устройства с небольшим, по нашим меркам, объемом RAM. Так родился еще один пресет качества — ULD (ultra low definition).
Так выглядит игра в качестве HD:
Так — в LD:
А так — в ULD:
Каждый пресет мы разграничили не только по качеству, но и по максимально возможному FPS. Сейчас мы позволяем выбирать некоторым устройствам 60 FPS, что достигается благодаря отдельной настройке внутри нового QM:
Как мы видим, каждый пресет имеет настройку TargetFPSQualitySettings и внутри нее два уровня, отвечающие за максимально возможный FPS на устройстве. Затем «глобальные» пресеты качеств также разделяются: например, есть качество LD, а есть LD60. Это значит, что пользователи, устройства которых попадают в группу LD60 (по названию устройства — на iOS или по GPU — на Android), получают возможность в настройках включить 60 FPS:
Какое-то время мы рассуждали, нужно ли включать пользователям 60 FPS по умолчанию, но пришли к тому, что не стоит: это значительно повысит использование батареи мобильного устройства, а по нашим внутренним данным на разных проектах на такую частоту кадров переключаются 5-15% аудитории (у которой эта настройка вообще доступна).
Также внутри QM содержится важнейший параметр — с каким «тэгом» ресурсной системы работать:
Так, для ULD качества используется тег LD\_ULD, который содержит набор ресурсов, упакованных нашей ресурсной системой для этих качеств. Объединение этих двух качеств дало нам большую экономию на дубликатах ресурсов, которые складываются в Asset Bundles — но это, я думаю, мы расскажем в наших следующих статьях.
Таким вот образом «собирается» каждое качество: это всего лишь набор уровней настроек.
Для того, чтобы применить настройки в рантайме, используется система наследования классов QM. Разберем пример применения настроек рендера:
Как пример, для ULD настройки рендера используется MasterTextureLimit = 1. Давайте посмотрим, как мы можем применить его к нашей игре.
Каждая настройка должна переопределять абстрактный класс WRQualitySetting, что и делает наш пользовательский класс RenderingQualitySetting:
```
public class RenderingQualitySettings : WRQualitySetting
{
public RenderingPipelineAssetType RenderingPipelineAssetType { get; private set; }
public RenderingPipelineSetting RenderingPipelineSetting { get; private set; }
public int MasterTextureLimit { get; set; }
public MsaaQuality MSAA { get; set; }
// … some code … //
}
```
Благодаря этому наш класс может перегружать метод Apply:
```
public override void Apply()
{
base.Apply();
// … some code … //
// We don't want to switch MasterTextureQuality when it is set to 0 and the new quality is
// also using 0 (so i.e. HD -> LD or LD -> HD)
// So effectively we are only doing the switch when the MasterTextureQuality really changes.
// If MasterTextureLimit is > 0 then we switch in any way
if (MasterTextureLimit > 0)
{
UnityEngine.QualitySettings.masterTextureLimit = MasterTextureLimit;
}
// … some code … //
}
```
Собственно, при вызове этого метода мы можем делать что угодно. В этот момент мы знаем, что наши ресурсы загружены, а рендер-пайплайн уже готов к работе.
Вызов метода Apply происходит в двух случаях:
* инициализация игры — в этот момент мы поднимаем с диска пресет качества, который использует клиент, и применяем его;
* переключение качества в настройках проекта — в этом случае после ряда проверок контроллер окна вызывает незамысловатый код:
```
private void OnConfirmPopupButtonClick()
{
var supportedPresetData = _supportedPresetsData.Find(x => x.IndexInUiPresetsLists == _selectedPresetIndex.Value);
AnalyticsUtils.QualityPresetChanged(supportedPresetData.QmPreset.Name);
ApplicationContext.QualityService.QualityManager.SetCurrentPreset(supportedPresetData.QmPreset);
// ... reload game … //
}
```
Вызов API QualityManager ApplicationContext.QualityService.QualityManager.SetCurrentPreset вызовет, в свою очередь, череду изменений внутри конфигураций и в конце переключит и применит все настройки, которые были зарегистрированы в QM.
Наверное, один из самых важных этапов, который был произведен перед переходом на новый QM — это чистка старых параметров качества.
За долгий срок разработки проекта скопилось приличное количество давно неиспользуемых полей или тех, которые имеют минимальное значение для производительности, а также пресетов качества, которые были созданы под устройства, которые мы давно не поддерживаем.
Мы смогли выделить основные необходимые для нас параметры, которыми хотелось управлять, а также разделили их на условные группы:
Стоит отметить также, как раньше происходил выбор качества, которое нужно выставить на устройстве. Был большой CS-файл, в котором кодом описывались характеристики нужных устройств. На первый взгляд, такой подход может показаться наивным и не гибким, однако у него есть свои плюсы.
На практике довольно сложно законфигурировать все устройства идеально, и бывают ситуации, когда на разных устройствах с одинаковым, казалось бы, SoC, игра ведет себя совершенно по-разному. Могут быть некачественные детали (например, дешевая память с низкими характеристиками) или некорректно написанные драйверы. В этом случае девайс всегда можно выделить отдельно и подобрать настройки под него. При создании QM мы учли подобные случаи, и мы можем производить конфигурацию пресетов не только per-GPU но и per-device (это активно используется, например, на Apple-устройствах).
Отдельно стоит отметить, что у нас имеется возможность как хранить манифест QM внутри игры, так и на CDN, и доставлять его в клиент динамически на старте. Определение наиболее актуального происходит простым определением наличия ссылки на нашем мета сервере. Если она есть, то конфиг всегда берется с сервера. Также на мета-сервере имеется возможность разделять конфиги по версиям клиента, поскольку у нас бесшовные обновления, и несколько версий клиента живут в проде одновременно.
Вместо заключения
=================
Новый Quality Manager дал нам довольно большие возможности: это и мощность управления конфигурациями из старой системы, и простота тестирования, и возможность менять параметры буквально на лету через сервер, и упрощение разработки графического пайплайна. Также QM удобным образом позволил нам разделить настройки качества и выдать хорошую графику на телефонах, которые ее поддерживают, при этом сохранив приближенную к старой на слабеньких устройствах в таком же FPS, как в оригинальной игре.
Авторы материала: Дмитрий Самсонов, Senior Platform Developer, [Павел Зинов](https://habr.com/ru/users/mrguardian/), Head of Client Department | https://habr.com/ru/post/565400/ | null | ru | null |
# Высокоэффективная генерация изображений на KerasCV с помощью Stable Diffusion
[](https://habr.com/ru/company/skillfactory/blog/693322/)
Сегодня покажем, как генерировать новые изображения по текстовому описанию при помощи KerasCV, [stability.ai](https://stability.ai/) и [Stable Diffusion](https://github.com/CompVis/stable-diffusion). Материал подготовлен к старту нашего [флагманского курса по Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_141022&utm_term=lead).
Stable Diffusion — это мощная модель генерации изображений по текстовым описаниям с открытым исходным кодом. Решений с открытым кодом для генерации изображений по описаниям немало, но KerasCV выделяется из них рядом преимуществ, в том числе [компилляцией XLA (ускоренной линейной алгебры)](https://www.tensorflow.org/xla) и поддержкой [«смешанной точности»](https://www.tensorflow.org/guide/mixed_precision). Вместе они позволяют достичь очень высокой скорости генерации.
Сегодня мы разберём реализацию Stable Diffusion от KerasCV, покажем, как использовать эти мощные средства повышения производительности, и изучим преимущества, которые они дают.
Сначала установим пакеты зависимости и разберёмся с модулями:
```
!pip install --upgrade keras-cv
```
```
import time
import keras_cv
from tensorflow import keras
import matplotlib.pyplot as plt
```
Введение
--------
В отличие от других обучающих материалов, здесь вначале объясняется, как происходит внедрение. В случае генерации изображений по текстовым описаниям это проще показать, чем рассказать.
Посмотрим, насколько сильна `keras_cv.models.StableDiffusion()`.
Сначала построим модель:
```
model = keras_cv.models.StableDiffusion(img_width=512, img_height=512)
```
Затем создадим текстовое описание. Например, «фото астронавта верхом на коне» (оригинальный запрос — «photograph of an astronaut riding a horse»):
```
images = model.text_to_image("photograph of an astronaut riding a horse", batch_size=3)
def plot_images(images):
plt.figure(figsize=(20, 20))
for i in range(len(images)):
ax = plt.subplot(1, len(images), i + 1)
plt.imshow(images[i])
plt.axis("off")
plot_images(images)
```
```
25/25 [==============================] - 19s 317ms/step
```
Просто невероятно!
Но это ещё не все возможности модели. Попробуем ввести запрос посложнее. Например, «симпатичная волшебная летающая собака, фэнтези-арт», «золотого цвета, высокое качество, высокая детализация, изящная форма, чёткая фокусировка», «концептуальный дизайн, концепция персонажа, цифровая живопись, тайна, приключение»:
```
images = model.text_to_image(
"cute magical flying dog, fantasy art, "
"golden color, high quality, highly detailed, elegant, sharp focus, "
"concept art, character concepts, digital painting, mystery, adventure",
batch_size=3,
)
plot_images(images)
```
```
25/25 [==============================] - 8s 316ms/step
```
Возможностям просто нет предела (как минимум они раскрывают всё скрытое многообразие Stable Diffusion).
Стоп, как это вообще работает?
------------------------------
Что бы вы сейчас себе ни вообразили, ничего волшебного в Stable Diffusion нет. Это что-то вроде «латентной диффузионной модели». Давайте докопаемся до смысла этого термина. Возможно, вам знаком принцип *сверхвысокого разрешения* (super-resolution): можно обучить модель глубокого обучения *удалению шума* на исходном изображении. Тем самым мы превратим изображение в версию с высоким разрешением. Модель глубокого обучения не может по волшебству «вытащить» утраченную информацию из шума на фото с низким разрешением. Вместо этого она дорисовывает полученные при обучении данные так, чтобы создать иллюзию наиболее вероятных деталей. Подробнее о сверхвысоком разрешении — в следующих материалах Keras.io:
* [Image Super-Resolution using an Efficient Sub-Pixel CNN](https://keras.io/examples/vision/super_resolution_sub_pixel/);
* [Enhanced Deep Residual Networks for single-image super-resolution](https://keras.io/examples/vision/edsr/).
И, если вы выжали из этой идеи всё, то спросите себя: а что, если запустить модель на «чистом шуме»? Тогда ей придётся «удалить шум у шума» и создать полностью новое изображение. Повторим это много раз, и маленький фрагмент шума будет превращаться в удивительно чёткое искусственное изображение с высоким разрешением.
Ключевая мысль латентной диффузии изложена в [High-Resolution Image Synthesis with Latent Diffusion Models](https://arxiv.org/abs/2112.10752) в 2020 году. Чтобы лучше понять принципы диффузии, можно посмотреть обучающий материал на Keras.io [Неявные модели диффузии для удаления шума (Denoising Diffusion Implicit Models)](https://keras.io/examples/generative/ddim/).
Для перехода от латентной диффузии к системе создания изображения по текстовому описанию нужно добавить всего одно ключевое свойство: управление генерируемыми изображениями через ключевые слова текстового описания. В этом поможет «стабилизация» (conditioning) — классический метод, который состоит в привязке к фрагменту шума вектора, представляющего собой кусочек текста, а затем обучения модели на наборе данных пар изображений и описаний `{image: caption}`.
Это даёт начало архитектуре Stable Diffusion, которая состоит из трёх блоков:
* кодер текста. Блок преобразует текстовое описание в латентный вектор (latent vector);
* диффузионная модель. Она многократно удаляет шум с фрагмента изображения 64x64 в латентном состоянии;
* декодер превращает фрагмент конечного изображения 64x64 в изображение с разрешением 512x512.
Сначала текстовое описание проектируется в предварительно изученное пространство собственных векторов, языковую модель с «замороженными весами». Затем такой собственный вектор связывается со случайно генерируемым фрагментом шума, который проходит итерации «удаления шума» в декодере. По умолчанию их 50. И чем больше, тем красивее и чётче конечное изображение. По умолчанию фрагмент проходит 50 итераций.
Наконец, скрытое изображение 64x64 проходит через декодер, что даёт корректную визуализацию высокого разрешения.
*Архитектура Stable Diffusion*
Это очень простая система: для реализации Keras достаточно четырёх файлов на 500 строк в общей сложности:
* [text\_encoder.py](https://github.com/keras-team/keras-cv/blob/master/keras_cv/models/generative/stable_diffusion/text_encoder.py): 87 LOC;
* [diffusion\_model.py](https://github.com/keras-team/keras-cv/blob/master/keras_cv/models/generative/stable_diffusion/diffusion_model.py): 181 LOC;
* [decoder.py](https://github.com/keras-team/keras-cv/blob/master/keras_cv/models/generative/stable_diffusion/decoder.py): 86 LOC;
* [stable\_diffusion.py](https://github.com/keras-team/keras-cv/blob/master/keras_cv/models/generative/stable_diffusion/stable_diffusion.py): 106 LOC.
Однако после изучения миллиардов изображений и их текстовых описаний работа этой простой системы кажется волшебством. Фейнман о Вселенной сказал: *«Она не сложна, её просто много!»*
«Плюшки» KerasCV
----------------
Почему из нескольких общедоступных реализаций Stable Diffusion стоит использовать именно [keras\_cv.models.StableDiffusion](https://keras.io/api/keras_cv/models/stable_diffusion#stablediffusion-class)?
Помимо простого API модель Stable Diffusion от KerasCV даёт важные преимущества:
* реализацию в графовом режиме;
* компиляцию XLA при помощи jit\_compile=True;
* поддержку вычислений со смешанной точностью.
Объединяя все эти преимущества, модель Stable Diffusion от KerasCV работает на порядки быстрее наивных реализаций. В этом разделе описываются активация всех этих функций и повышение эффективности при их использовании.
Ради интереса мы сравнили по времени реализации Stable Diffusion для «диффузоров» от [HuggingFace](https://github.com/huggingface/diffusers) и от KerasCV. В обоих случаях поставили задачу сгенерировать 3 изображения с 50 итерациями для каждого. Тестирование проводилось на Tesla T4.
[Исходный код](https://github.com/LukeWood/stable-diffusion-performance-benchmarks) сравнительных тестов находится в открытом доступе на GitHub, его можно перезапускать на Colab и воспроизвести результаты[.](https://github.com/LukeWood/stable-diffusion-performance-benchmarks) Вот результаты тестов на время генерации:
| Графический процессор | Модель | Время генерации |
| --- | --- | --- |
| Tesla T4 | KerasCV (при тёплом старте) | 28.97s |
| Tesla T4 | diffusers (при тёплом старте) | 41.33s |
| Tesla V100 | KerasCV (при тёплом старте) | 12.45 |
| Tesla V100 | diffusers (при тёплом старте) | 12.72 |
На Tesla T4 генерация ускоряется на 30%! Хотя улучшение результата на V100 не столь впечатляет, в целом мы ожидаем, что результаты таких тестов на всех графических процессорах NVIDIA всегда будут в пользу KerasCV.
Ради полноты картины мы привели время генерации при холодном и при прогретом старте. Время холодного старта включает единовременные затраты на создание и компиляцию модели, поэтому в производственной среде, где вы будете много раз использовать один и тот же экземпляр модели, оно ничтожно мало. Тем не менее приводим цифры для холодного старта:
| Графический процессор | Модель | Время генерации |
| --- | --- | --- |
| Tesla T4 | KerasCV (при холодном старте) | 83.47s |
| Tesla T4 | diffusers (при холодном старте) | 46.27s |
| Tesla V100 | KerasCV (при холодном старте) | 76.43 |
| Tesla V100 | diffusers (при холодном старте) | 13.90 |
Хотя результаты выполнения задач из этого руководства могут быть разными, у нас в тесте реализация Stable Diffusion на KerasCV оказалась гораздо быстрее, чем на PyTorch. В значительной степени это может быть связано с компиляцией XLA.
> Эффективность улучшается при каждой оптимизации и может заметно меняться от одной конфигурации «железа» к другой.
Для начала давайте испытаем нашу неоптимизированную модель с текстовым описанием «Симпатичная выдра держит ракушки в радужном водовороте. Акварель»:
```
benchmark_result = []
start = time.time()
images = model.text_to_image(
"A cute otter in a rainbow whirlpool holding shells, watercolor",
batch_size=3,
)
end = time.time()
benchmark_result.append(["Standard", end - start])
plot_images(images)
print(f"Standard model: {(end - start):.2f} seconds")
keras.backend.clear_session() # Clear session to preserve memory.
```
```
25/25 [==============================] - 8s 316ms/step
Standard model: 8.17 seconds
```
### Смешанная точность
«Смешанная точность» использует вычисления с точностью float16, храня при этом веса в формате float32. Благодаря этому операции float16 поддерживаются гораздо более быстрыми ядрами, чем аналоги для float32 на современных графических процессорах NVIDIA.
Использовать смешанную точность в Keras (в том числе для [keras\_cv.models.StableDiffusion](https://keras.io/api/keras_cv/models/stable_diffusion#stablediffusion-class)) просто:
```
keras.mixed_precision.set_global_policy("mixed_float16")
```
```
INFO:tensorflow:Mixed precision compatibility check (mixed_float16): OK
Your GPU will likely run quickly with dtype policy mixed_float16 as it has compute capability of at least 7.0. Your GPU: NVIDIA A100-SXM4-40GB, compute capability 8.0
```
Просто работает.
```
odel = keras_cv.models.StableDiffusion()
print("Compute dtype:", model.diffusion_model.compute_dtype)
print(
"Variable dtype:",
model.diffusion_model.variable_dtype,
)
```
```
Compute dtype: float16
Variable dtype: float32
```
Как видите, собранная выше модель использует расчёты со смешанной точностью. А мы используем скорость операции float16 при хранении переменных с точностью float32.
```
# Warm up model to run graph tracing before benchmarking.
model.text_to_image("warming up the model", batch_size=3)
start = time.time()
images = model.text_to_image(
"a cute magical flying dog, fantasy art, "
"golden color, high quality, highly detailed, elegant, sharp focus, "
"concept art, character concepts, digital painting, mystery, adventure",
batch_size=3,
)
end = time.time()
benchmark_result.append(["Mixed Precision", end - start])
plot_images(images)
print(f"Mixed precision model: {(end - start):.2f} seconds")
keras.backend.clear_session()
```
```
25/25 [==============================] - 15s 226ms/step
25/25 [==============================] - 6s 226ms/step
Mixed precision model: 6.02 seconds
```
### Компиляция XLA
TensorFlow включает встроенный компиллятор XLA [XLA: Accelerated Linear Algebra — ускоренная линейная алгебра](https://www.tensorflow.org/xla). [keras\_cv.models.StableDiffusion](https://keras.io/api/keras_cv/models/stable_diffusion#stablediffusion-class) поддерживает работу аргумента jit\_compile «из коробки». Значение True активирует компиляцию XLA для этого аргумента, что приводит к значительному ускорению.
Воспользуемся этим в примере с «креслом цвета авокадо»:
```
# Set back to the default for benchmarking purposes.
keras.mixed_precision.set_global_policy("float32")
model = keras_cv.models.StableDiffusion(jit_compile=True)
# Before we benchmark the model, we run inference once to make sure the TensorFlow
# graph has already been traced.
images = model.text_to_image("An avocado armchair", batch_size=3)
plot_images(images)
```
```
25/25 [==============================] - 36s 245ms/step
```
Оценим эффективность нашей модели XLA:
```
start = time.time()
images = model.text_to_image(
"A cute otter in a rainbow whirlpool holding shells, watercolor",
batch_size=3,
)
end = time.time()
benchmark_result.append(["XLA", end - start])
plot_images(images)
print(f"With XLA: {(end - start):.2f} seconds")
keras.backend.clear_session()
```
```
25/25 [==============================] - 6s 245ms/step
With XLA: 6.27 seconds
```
На графическом процессоре A100 получилось примерно двукратное ускорение. Чудеса!
Соберём всё воедино
-------------------
И как же собрать самый производительный в мире (по состоянию на сентябрь 2022 года) стабильный конвейер диффузионного вывода?
С помощью двух строк кода:
```
keras.mixed_precision.set_global_policy("mixed_float16")
model = keras_cv.models.StableDiffusion(jit_compile=True)
```
и текстового описания «Плюшевые мишки ведут исследования в области машинного обучения»:
```
# Let's make sure to warm up the model
images = model.text_to_image(
"Teddy bears conducting machine learning research",
batch_size=3,
)
plot_images(images)
```
```
25/25 [==============================] - 39s 157ms/step
```
Насколько быстро это работает? Сейчас разберёмся! Пусть теперь у нас «Таинственный тёмный незнакомец посещает египетские пирамиды», «высокое качество, высокая детализация, изящная форма, чёткая фокусировка», «концептуальный дизайн, концепция персонажа, цифровая живопись»:
```
start = time.time()
images = model.text_to_image(
"A mysterious dark stranger visits the great pyramids of egypt, "
"high quality, highly detailed, elegant, sharp focus, "
"concept art, character concepts, digital painting",
batch_size=3,
)
end = time.time()
benchmark_result.append(["XLA + Mixed Precision", end - start])
plot_images(images)
print(f"XLA + mixed precision: {(end - start):.2f} seconds")
```
```
25/25 [==============================] - 4s 158ms/step
XLA + mixed precision: 4.25 seconds
```
Оценим результаты:
```
print("{:<20} {:<20}".format("Model", "Runtime"))
for result in benchmark_result:
name, runtime = result
print("{:<20} {:<20}".format(name, runtime))
```
```
Model Runtime
Standard 8.17177152633667
Mixed Precision 6.022329568862915
XLA 6.265935659408569
XLA + Mixed Precision 4.252242088317871
```
Полностью оптимизированной модели хватило четырёх секунд, чтобы сгенерировать три новых изображения из текстового запроса на графическом процессоре A100.
Заключение
----------
Благодаря XLA KerasCV позволяет создать Stable Diffusion нового поколения. А благодаря смешанной точности и XLA мы получаем самый быстрый конвейер Stable Diffusion на сентябрь 2022 года.
В конце руководств по keras.io мы обычно рекомендуем несколько тем для дальнейшего изучения. На этот раз мы лишь ограничимся одним призывом:
Прогоните свои описания через эту модель! Это просто бомба!
Если у вас графический процессор от NVIDIA GPU или же M1 MacBookPro, можно запустить генерацию на своей машине. (Отметим, что при старте на M1 MacBookPro активировать смешанную точность не нужно: эппловский Metal пока не очень хорошо поддерживает её).
* [**Colab**](https://colab.research.google.com/github/keras-team/keras-io/blob/master/guides/ipynb/keras_cv/generate_images_with_stable_diffusion.ipynb)
* [**GitHub**](https://github.com/keras-team/keras-io/blob/master/guides/keras_cv/generate_images_with_stable_diffusion.py)
Научим разрабатывать генеративные сети, работать с данными, чтобы вы прокачали карьеру или стали востребованным IT-специалистом:
* [Профессия Data Analyst (12 месяцев)](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_141022&utm_term=conc)
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_141022&utm_term=conc)
Чтобы посмотреть все курсы, кликните по баннеру:
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_141022&utm_term=banner)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_141022&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_141022&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_141022&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_141022&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_141022&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_141022&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_141022&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_141022&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_141022&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_141022&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_141022&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_141022&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_141022&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_141022&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_141022&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_141022&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_141022&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_141022&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_141022&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_141022&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_141022&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_141022&utm_term=cat) | https://habr.com/ru/post/693322/ | null | ru | null |
# Linux-дистрибутив from scratch для сборки Docker-образов — наш опыт с dappdeps
Сборка образов для Docker на основе базового образа, как правило, предполагает вызов команд в окружении этого базового образа. Например — вызов команды apt-get, которая есть в базовом образе, для установки новых пакетов.
Часто возникает необходимость доустановить в базовую систему некоторый набор утилит, с помощью которых происходит установка или сборка некоторых файлов, которые требуются в итоговом образе. Например, чтобы собрать Go-приложение, надо установить компилятор Go, положить все исходные коды приложения в базовом образе, скомпилировать требуемую программу. Однако в итоговом образе требуется лишь скомпилированная программа без всего набора утилит, который использовался для компиляции этой программы.
Проблема известная: одним из путей её решения может быть сборка вспомогательного образа и перенос файлов из вспомогательного образа в результирующий. Для этого появились [Docker multi-stage builds](https://docs.docker.com/develop/develop-images/multistage-build/) или [образы-артефакты в dapp](https://werf.io/documentation/configuration/stapel_artifact.html) (**Обновлено 13 августа 2019 г.:** в настоящее время проект dapp переименован в **[werf](https://werf.io)**, его код переписан на Go, а документация значительно улучшена). И данный подход идеально решает проблему подобную переносу результатов компиляции исходных кодов в итоговый образ. Однако он не решает все возможные проблемы…
Вот другой пример: для сборки образа используется Chef в локальном режиме. Для этого в базовый образ ставится chefdk, монтируются или добавляются рецепты, запускаются эти рецепты, которые настраивают образ, устанавливают новые компоненты, пакеты, файлы-конфиги и прочее. Аналогично может быть использована другая система управления конфигурациями — например, Ansible. Однако установленный chefdk занимает около 500 Мб и существенно увеличивает размеры итогового образа — оставлять его там нет смысла.
Но multi-stage builds в Docker **уже не решат эту проблему**. Что, если пользователю не хочется знать о том, каков побочный эффект работы программы — в частности, какие файлы она создает? Например, чтобы не держать лишние явные описания всех экспортируемых путей из образа. Хочется просто запустить программу, получить какой-то результат в образе, но чтобы программа и все окружение, нужное для ее работы, **осталось вне итогового образа**.
В случае с chefdk можно было бы монтировать директорию с этим chefdk в сборочный образ на время сборки. Но с этим решением есть проблемы:
1. Не любая программа, нужная для сборки, устанавливается в отдельный каталог, который легко примонтировать в сборочный образ. В случае с Ansible надо монтировать Python в нестандартное место, чтобы не конфликтовать с системным Python, что уже может вызывать проблемы.
2. Примонтированная программа будет зависеть от используемого базового образа. Если программа собрана для Ubuntu, то она может не запуститься в не предусмотренном для нее окружении — например, в Alpine. Даже chefdk, который является omnibus-пакетом со всеми своими зависимостями, все равно зависит от системного glibc и не будет работать в Alpine, где используется musl libc.
А что, если мы сможем подготовить некий статичный неизменный набор всех возможных полезных утилит, который будет так хитро слинкован, что **будет работать в любом базовом образе**, даже scratch? После подключения такого/таких образов в базовый, в итоговом образе останется лишь пустая директория mount-point, в которую были подключены эти утилиты.
В поисках приключений
---------------------
### Теория
Необходимо получить образ, в котором содержится набор программ в некоторой статически определенной нестандартной директории — например, `/myutils`. Любая программа в `/myutils` должна зависеть только от библиотек в `/myutils`.
Динамически скомпилированная программа в Linux зависит от местоположения линкера [ld-linux](https://linux.die.net/man/8/ld-linux) в системе. Например, бинарник `bash` в `ubuntu:16.04` скомпилирован так, что зависит от линкера `/lib64/ld-linux-x86-64.so.2`:
```
$ ldd /bin/bash
linux-vdso.so.1 => (0x00007ffca67d8000)
libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007fd8505a6000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007fd8503a2000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fd84ffd8000)
/lib64/ld-linux-x86-64.so.2 (0x00007fd8507cf000)
```
Причем эта зависимость является статической и вкомпилирована в сам бинарник:
```
$ grep "/lib64/ld-linux-x86-64.so.2" /bin/bash
Binary file /bin/bash matches
```
Таким образом, надо: а) скомпилировать условный `/myutils/bin/bash` так, чтобы он использовал линкер `/myutils/lib64/ld-linux-x86-64.so.2`; б) чтобы линкер `/myutils/lib64/ld-linux-x86-64.so.2` был настроен на динамическую линковку библиотек из `/myutils/{lib64,lib}`.
Первым шагом будет сборка образа `toolchain`, который будет содержать всё, что необходимо для сборки и последующей работы других программ в нестандартной root-директории. Для этого нам как нельзя кстати придутся инструкции проекта [**Linux From Scratch**](http://www.linuxfromscratch.org/lfs/view/stable/).
### Собираем дистрибутив dappdeps
Почему набор образов нашего «дистрибутива» называется **dappdeps**? Потому что эти образы использует сборщик **dapp** — они собираются под нужды этого проекта.
Итак, наша **конечная цель**:
* Образ [**dappdeps/toolchain**](https://github.com/flant/dappdeps-toolchain) с компилятором GCC для сборки других приложений и библиотекой glibc.
* Образ [**dappdeps/base**](https://github.com/flant/dappdeps-base) с набором программ и всех зависимых библиотек: bash, gtar, sudo, coreutils, findutils, diffutils, sed, rsync, shadow, termcap.
* Образ [**dappdeps/gitartifact**](https://github.com/flant/dappdeps-gitartifact) с утилитой Git и всеми зависимостями.
* Образ [**dappdeps/chefdk**](https://github.com/flant/dappdeps-chefdk) с omnibus-пакетом chefdk, который содержит все зависимости Chef, в т.ч. интерпретатор Ruby.
* Образ [**dappdeps/ansible**](https://github.com/flant/dappdeps-ansible) с утилитой Ansible, который содержит все зависимости, в т.ч. интерпретатор Python.
Образы dappdeps могут **зависеть друг от друга**. Например, при сборке dappdeps/base требуется toolchain и glibc из образа dappdeps/toolchain. После компиляции всех утилит в dappdeps/base для их работы в runtime будут требоваться файлы из dappdeps/toolchain.
Главное условие заключается в том, чтобы утилиты из этих образов **располагались в нестандартном месте**, а именно — в `/.dapp/deps/`, и **не зависели ни от каких утилит или библиотек** в стандартных системных путях. Также в dappdeps-образах не должно быть никаких других файлов, кроме `/.dapp/deps`.
Такие образы позволят создавать на их основе контейнеры с томами, где содержатся утилиты, и монтировать их в другие контейнеры с использованием опции `--volumes-from` для Docker.
### Собираем dappdeps/toolchain
[Глава 5 «Constructing a Temporary System»](http://www.linuxfromscratch.org/lfs/view/stable/chapter05/chapter05.html) руководства Linux From Scratch как раз описывает процесс построения временного chroot-окружения в `/tools` с некоторым набором утилит, которым затем собирается главный целевой дистрибутив.
В нашем случае немного переиначим директорию chroot-окружения. В параметре `--prefix` при компиляции будем указывать `/.dapp/deps/toolchain/0.1.1`. Это та директория, которая будет появляться в сборочном контейнере, при монтировании в него dappdeps/toolchain — в ней содержатся все нужные утилиты и библиотеки. Нам требуются лишь GNU binutils, GCC и glibc.
Собирается образ с использованием Docker multi-stage builds. В образе на основе `ubuntu:16.04` подготавливается все окружение и производится компиляция и установка программ в `/.dapp/deps/toolchain/0.1.1`. Затем эта директория копируется в scratch-образ dappdeps/toolchain:0.1.1. *Dockerfile можно найти [здесь](https://github.com/flant/dappdeps-toolchain/blob/master/Dockerfile).*
**Итоговый образ dappdeps/toolchain** — это и есть «temporary system» в терминологии LFS. GCC в данной системе все еще завязан на системные пути к библиотекам, однако мы не будем добиваться того, чтобы GCC работал в любом базовом образе. Образ dappdeps/toolchain — вспомогательный, он будет использоваться далее, в т.ч. для сборки уже реально независимых от общих системных библиотек программ.
### Используем Omnibus вместе с dappdeps/toolchain
Для сборки таких проектов, как [chefdk](https://github.com/chef/chef-dk) или [GitLab](https://gitlab.com/gitlab-org/omnibus-gitlab), используется [**Omnibus**](https://github.com/chef/omnibus). Он позволяет создать самодостаточные наборы (self-contained bundle) с программой и всеми зависимыми библиотеками, кроме системного линкера и libc. Все инструкции описываются читаемыми удобными Ruby-рецептами. Также у проекта Omnibus есть библиотека уже написанных рецептов [omnibus-software](https://github.com/chef/omnibus-software/).
Итак, попробуем описать **сборку остальных dappdeps-дистрибутивов с использованием Omnibus**. Однако, чтобы избавиться от зависимости от системного линкера и libc, будем собирать все программы в Omnibus с использованием компилятора из dappdeps/toolchain. В этом случае программы окажутся завязаны на glibc, который тоже есть в dappdeps/toolchain.
Для этого сохраним содержимое dappdeps/toolchain как архив:
```
$ docker pull dappdeps/toolchain:0.1.1
$ docker save dappdeps/toolchain:0.1.1 -o dappdeps-toolchain.tar
```
Добавим этот архив через директиву `Dockerfile ADD` и распакуем содержимое архива в корень сборочного контейнера:
```
ADD ./dappdeps-toolchain.tar /dappdeps-toolchain
RUN tar xf /dappdeps-toolchain/**/layer.tar -C /
```
Перед запуском сборки через omnibus добавляем в переменную `PATH` путь `/.dapp/deps/toolchain/0.1.1/bin` в качестве приоритетного, чтобы использовался GCC из dappdeps/toolchain.
**Результат работы** Omnibus — это пакет (в нашем случае — DEB), содержимое которого распаковывается и переносится в `/.dapp/deps/{base|gitartifact|...}` с помощью Docker multi-stage builds аналогично dappdeps/toolchain.
### Собираем dappdeps/base
Проект для Omnibus описывается с помощью файла проекта [`omnibus/config/projects/dappdeps-base.rb`](https://github.com/flant/dappdeps-base/blob/master/omnibus/config/projects/dappdeps-base.rb):
```
name 'dappdeps-base'
license 'MIT'
license_file 'LICENSE.txt'
DOCKER_IMAGE_VERSION = "0.2.3"
install_dir "/.dapp/deps/base/#{DOCKER_IMAGE_VERSION}"
build_version DOCKER_IMAGE_VERSION
build_iteration 1
dependency "dappdeps-base"
```
В этом файле указаны все зависимости Omnibus-пакета dappdeps-base и целевая директория для установки. Зависимости могут располагаться либо в отдельном репозитории (например, [omnibus-software](https://github.com/chef/omnibus-software/)), либо в директории `omnibus/config/software`. Каждый файл в этой директории описывает инструкции по установке какого-то пакета/компонента. Для dappdeps-base в Omnibus написаны software-рецепты, отсутствующие в стандартном репозитории omnibus-software: `acl`, `attr`, `coreutils`, `diffutils`, `findutils`, `gtar`, `rsync`, `sed`, `shadow`, `sudo`, `termcap`.
Рассмотрим на примере `rsync`, как выглядит software-рецепт для Omnibus:
```
name 'rsync'
default_version '3.1.2'
license 'GPL-3.0'
license_file 'COPYING'
version('3.1.2') { source md5: '0f758d7e000c0f7f7d3792610fad70cb' }
source url: "https://download.samba.org/pub/rsync/src/rsync-#{version}.tar.gz"
dependency 'attr'
dependency 'acl'
dependency 'popt'
relative_path "rsync-#{version}"
build do
env = with_standard_compiler_flags(with_embedded_path)
command "./configure --prefix=#{install_dir}/embedded", env: env
command "make -j #{workers}", env: env
command 'make install', env: env
end
```
Директивой `source` указывается URL, откуда надо скачать исходные коды. Зависимости от других компонентов указаны директивой `dependency` по имени. Имя собираемого компонента задано директивой `name`. Каждый software-рецепт в свою очередь может указывать зависимости от других компонентов. Внутри блока `build` указаны стандартные команды сборки из исходных кодов.
*Проект Omnibus и Dockerfile для dappdeps/base можно найти [здесь](https://github.com/flant/dappdeps-base).*
### Собираем dappdeps/gitartifact
В случае с dappdeps-gitartifact необходим лишь рецепт сборки Git, а он уже есть в omnibus-software — остается только подключить его в текущий Omnibus. В остальном все аналогично.
*Проект Omnibus и Dockerfile для dappdeps/gitartifact можно найти [здесь](https://github.com/flant/dappdeps-gitartifact).*
### Собираем dappdeps/chefdk
Для chefdk тоже уже есть готовый [проект Omnibus](https://github.com/chef/chef-dk). Остается лишь добавить его в сборочный контейнер через Dockerfile и заменить стандартные пути установки chefdk `/opt/chefdk` на `/.dapp/deps/chefdk/2.3.17-2` (наш путь установки будет включать в себя версию Chef).
*Dockerfile для сборки dappdeps/chefdk можно найти [здесь](https://github.com/flant/dappdeps-chefdk/blob/master/Dockerfile).*
### Собираем dappdeps/ansible
Для сборки Ansible также заводим Omnibus-проект, в котором устанавливаем интерпретатор Python, pip и описываем software-рецепт для Ansible:
```
name "ansible"
ANSIBLE_GIT_TAG = "v2.4.4.0+dapp-6"
dependency "python"
dependency "pip"
build do
command "#{install_dir}/embedded/bin/pip install https://github.com/flant/ansible/archive/#{ANSIBLE_GIT_TAG}.tar.gz"
command "#{install_dir}/embedded/bin/pip install pyopenssl"
end
```
Как видно, образ с Ansible представляет собой встроенный Python, pip и установленный через pip Ansible с зависимостями.
*Проект Omnibus и Dockerfile для dappdeps/ansible можно найти [здесь](https://github.com/flant/dappdeps-ansible).*
Как использовать дистрибутив dappdeps?
--------------------------------------
Чтобы пользоваться образами dappdeps через монтирование томов, **предварительно для каждого образа необходимо создать контейнер** и указать, какой том хранится в этом контейнере. Этого требует Docker на данный момент.
```
$ docker create --name dappdeps-toolchain --volume /.dapp/deps/toolchain/0.1.1 dappdeps/toolchain:0.1.1 no-such-cmd
13edda732176a44d7d822202d8327565b78f4a2190368bb1df46cdad1e127b6e
$ docker ps -a | grep dappdeps-toolchain
13edda732176 dappdeps/toolchain:0.1.1 "no-such-cmd" About a minute ago Created dappdeps-toolchain
```
Контейнер называется `dappdeps-toolchain`: по этому имени все объявленные томы этого контейнера можно использовать для монтирования в другие контейнеры с помощью `--volumes-from`. Параметр-команду с произвольным текстом `no-such-cmd` требуется указать для Docker, но данный контейнер никогда не будет запущен — он так и останется в состоянии `Created`.
Создаем остальные контейнеры:
```
$ docker create --name dappdeps-base --volume /.dapp/deps/base/0.2.3 dappdeps/base:0.2.3 no-such-cmd
20f524c5b8b4a59112b4b7cb85e47eee660c7906fb72a4935a767a215c89964e
$ docker create --name dappdeps-ansible --volume /.dapp/deps/ansible/2.4.4.0-10 dappdeps/ansible:2.4.4.0-10 no-such-cmd
cd01ae8b69cd68e0611bb6c323040ce202e8e7e6456a3f03a4d0a3ffbbf2c510
$ docker create --name dappdeps-gitartifact --volume /.dapp/deps/gitartifact/0.2.1 dappdeps/gitartifact:0.2.1 no-such-cmd
2c12a8743c2b238d90debaf066e29685b41b138c10f2b893a815931df866576d
$ docker create --name dappdeps-chefdk --volume /.dapp/deps/chefdk/2.3.17-2 dappdeps/chefdk:2.3.17-2 no-such-cmd
4dffe74c49c8e4cdf9d749177ae9efec3bdae6e37c8b6df41b6eb527a5c1d891
```
Вот мы и дошли до кульминации, ради которой задумывался весь этот сыр-бор. Итак, в качестве демонстрации возможностей **установим в образ Alpine пакеты `nginx` и `tree`, запустив Ansible из dappdeps/ansible через Bash из dappdeps/base**:
```
$ docker run -ti --name mycontainer --volumes-from dappdeps-toolchain --volumes-from dappdeps-base --volumes-from dappdeps-gitartifact --volumes-from dappdeps-ansible --volumes-from dappdeps-chefdk alpine:latest /.dapp/deps/base/0.2.3/embedded/bin/bash -lc '/.dapp/deps/ansible/2.4.4.0-10/embedded/bin/ansible localhost -m apk -a "name=nginx,tree update_cache=yes"'
[WARNING]: Unable to parse /etc/ansible/hosts as an inventory source
[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that the implicit localhost does not match 'all'
localhost | SUCCESS => {
"changed": true,
"failed": false,
"msg": "installed nginx tree package(s)",
"packages": [
"pcre",
"nginx",
"tree"
],
"stderr": "",
"stderr_lines": [],
"stdout": "(1/3) Installing pcre (8.41-r1)\n(2/3) Installing nginx (1.12.2-r3)\nExecuting nginx-1.12.2-r3.pre-install\n(3/3) Installing tree (1.7.0-r1)\nExecuting busybox-1.27.2-r7.trigger\nOK: 6 MiB in 14 packages\n",
"stdout_lines": [
"(1/3) Installing pcre (8.41-r1)",
"(2/3) Installing nginx (1.12.2-r3)",
"Executing nginx-1.12.2-r3.pre-install",
"(3/3) Installing tree (1.7.0-r1)",
"Executing busybox-1.27.2-r7.trigger",
"OK: 6 MiB in 14 packages"
]
}
```
Финальный аккорд — создаем образ из получившегося контейнера и… видим, что **от dappdeps в нем остались лишь пустые директории mount-point'ов!**
```
$ docker commit mycontainer myimage
sha256:9646be723b91daeaf538b7d92bb8844578abc7acd3028394f543e883eeb382bb
$ docker run -ti --rm myimage tree /.dapp
/.dapp
└── deps
├── ansible
│ └── 2.4.4.0-10
├── base
│ └── 0.2.3
├── chefdk
│ └── 2.3.17-2
├── gitartifact
│ └── 0.2.1
└── toolchain
└── 0.1.1
11 directories, 0 files
```
Казалось бы, о чем еще можно мечтать?..
Дальнейшие работы и проблемы
----------------------------
### Какие проблемы с dappdeps?
Необходимо провести работу по уменьшению размеров dappdeps/toolchain. Для этого надо разделить toolchain на 2 части: часть, необходимая для сборки новых утилит в dappdeps, и часть с базовыми библиотеками типа glibc, которые необходимо монтировать в runtime уже для запуска этих утилит.
Для работы модуля Ansible apt в dappdeps/ansible пришлось добавить содержимое пакета python-apt в Ubuntu прямо в образ без пересборки. В этом случае модуль apt работает без проблем в базовых образах на основе DEB, но требуется наличие glibc определенной версии. Поскольку сам apt — это дистрибутиво-специфичный модуль, то такое допустимо.
### Чего не хватает в Dockerfile?
Для использования тома из образа dappdeps/toolchain приходится сначала создавать архив этого образа, а затем добавлять его в другой образ через директиву `Dockerfile ADD` (см. раздел «Используем Omnibus вместе с dappdeps/toolchain»). Со стороны Dockerfile не хватает функционала, который бы позволял просто подключать директорию другого образа на время сборки как `VOLUME`, т.е. аналог опции `--volumes-from` для Dockerfile.
Выводы
------
Мы убедились, что идея работает и позволяет использовать в сборочных инструкциях GNU- и другие CLI-утилиты, запускать интерпретатор Python или Ruby, запускать даже Ansible или Chef в Alpine или scratch-образах. При этом писателю сборочных инструкций не требуется знать побочный эффект выполнения запускаемых команд и явно перечислять, какие файлы необходимо импортировать, как в случае с Docker multi-stage builds.
Результаты данной работы **применяются и на практике**: dapp использует dappdeps-образы в сборочных контейнерах. Например, Git из dappdeps/gitartifact используется для работы с патчами, и утилита Git с некоторой гарантией ведет себя одинаково во всех базовых образах. Однако то, как dapp использует dappdeps, выходит за рамки данной статьи.
Целью данной статьи было донести саму идею и показать на реальном практическом примере возможность ее применения.
P.S. Все описанные dappdeps-образы **доступны на hub.docker.com**: `dappdeps/toolchain:0.1.1`, `dappdeps/base:0.2.3`, `dappdeps/gitartifact0.2.1`, `dappdeps/ansible:2.4.4.0-10`, `dappdeps/chefdk:2.3.17-2` — ими можно пользоваться. | https://habr.com/ru/post/352432/ | null | ru | null |
# Как запустить программу без операционной системы: часть 2
[В первой части нашей](http://habrahabr.ru/company/neobit/blog/173263/) статьи мы рассказали о том, каким образом можно получить простую программу “Hello World”, которая запускается без операционной системы и печатает сообщение на экран.
В этой части статьи, хочется развить *получившийся в первой части код* таким образом, чтобы он мог быть отлажен через GDB, компилировался через оболочку Visual Studio и печатал на экран список PCI устройств.
**! ВАЖНО!**: Все дальнейшие действия могут успешно осуществляться только после успешного прохождения всех 6-ти шагов описанных в первой части статьи).
#### Учимся отлаживать программу
**Основная статья**: [Использование отладчика GDB по максимуму](http://habrahabr.ru/company/neobit/blog/141067/)
Как отладить код kernel.bin? Для этого нужно добавить в kernel.bin симовлы для отладки и запустить отладчик:
1. Добавим опцию компилятора в файле makefile, чтобы он генерировал отладочные символы:
```
CFLAGS = -Wall -fno-builtin -nostdinc -nostdlib -ggdb3
```
2. Добавим пару строк на этапе сборки, чтобы на диск записывался kernel.bin без символов (такой файл можно сделать при помощи утилиты strip). Для этого нужно исправить цель kernel.bin в makefile:
```
kernel.bin: $(OBJFILES)
$(LD) -T linker.ld -o $@ $^
cp $@ $@.dbg
strip $@
```
тогда:
**kernel.bin** – не содержит символы – его можно запускать;
**kernel.bin.dbg** – содержит и символы и код – его можно скормить отладчику.
3. Установим отладчик:
```
sudo apt-get install cgdb
```
4. Перекомпилируем программу:
```
make clean
make all
sudo make image
```
5. Запустим qemu с опцией ожидания отладчика:
```
sudo qemu-system-i386 -s -S -hda hdd.img &
```
6. Запустим отладчик c указанием файла с символами:
```
cgdb kernel.bin.dbg
```
7. В отладчике подключимся к qemu и поставим breakpoint сразу на функции main:
```
(gdb) target remote localhost:1234
(gdb) break main
```
8. Попадаем в main и отлаживаем ее:
```
(gdb) c
(gdb) n
(gdb) n
```
Таким образом, получается мощный инструмент отладки. Этот способ будет работать для QEMU, а для того, чтобы отладить программу непосредственно на железе, необходимо подключить модуль отладчика к нашей программе – это мы рассмотрим в одной из следующих статей.
#### Компиляция из Visual Studio
**Основная статья**: [Использование оболочки Visual Studio 2010 для компиляции проектов с помощью gcc в Linux](http://habrahabr.ru/company/neobit/blog/151712/)
Как работать с полученным кодом из Visual Studio? Следуя инструкциям в статье собираем проект Visual Studio, не создавая проект на Linux – он уже есть.
1. Установим в системе ssh:
```
sudo apt-get install ssh
```
2. Располагаем исходники проекта с **kernel.bin** на **shared directory** для виртуальной машины.
3. Устанавливаем утилиту **plink** в папку **tools** и проверяем ее работу.
4. Создаем проект Visual Studio следуя инструкциям и получаем такое дерево:
**\proj\kernel.c
\proj\loader.s
\proj\common\printf.c
\proj\common\screen.c
\proj\include\printf.h
\proj\include\stdarg.h
\proj\include\screen.h
\proj\include\types.h
\proj\makefile
\proj\linker.ld
\proj\tools\plink.exe
\proj\kernel\kernel.sln
\proj\kernel\kernel.suo
\proj\kernel\kernel.sdf
\proj\kernel\vs\kernel.vcxproj
\proj\kernel\vs\kernel.vcxproj.filters
\proj\kernel\vs\make\_vs.props**
5. Формируем файл ”\proj\kernel\vs\make\_vs.props” так же по инструкции:
```
xml version="1.0" encoding="utf-8"?
proj
$(SolutionDir)\include\
sudo make image; sudo qemu-system-i386 -hda hdd.img
192.168.1.8
user
123456
~/Desktop/\_habr
-pw $(RbPassword) $(RbUser)%40$(RbHost) cd $(RbRoot); cd $(RblFolder);
$(SolutionDir)tools\plink -batch $(RbToolArgs)
$(RbToolExe) make all
$(RbToolExe) make rebuild
$(RbToolExe) make cleanall
$(RbToolArgs) $(RblExecute)
$(RblIncludePath)
$(RbBuildCmd)
$(RbRebuildAllCmd)
$(RbCleanCmd)
$(RbIncludePath)
$(SolutionDir) tools\plink
$(RbExecuteCmd)
$(RbBuildCmd)
$(RbRebuildAllCmd)
$(RbCleanCmd)
$(RbIncludePath)
$(SolutionDir)tools\plink
$(RbExecuteCmd)
```
6. Меняем файл ”\proj\kernel\vs\kernel.vcxproj ” так же по инструкции:
```
```
7. В итоге должно получиться примерно следующее:
8. Проверяем, что все работает:
Таким образом, для дельнейшей разработки нашей программы можно использовать оболочку Visual Studio, хоть и компилятор GCC на Linux.
#### Сканирование устройств PCI
**Основная статья**: [Как найти PCI устройства без операционной системы](http://habrahabr.ru/company/neobit/blog/162769/)
Как теперь просканировать системную шину PCI на наличие устройств? Следуя инструкциям в статье выполняем следующие действия (загрузочный образ уже готов, поэтому только добавляем код сканирования PCI):
1. Добавляем в файл **include\types.h**, следующее определение типа:
```
typedef unsigned long u32;
typedef unsigned short u16;
typedef unsigned char u8;
```
2. Добавляем файл **include\io.h**, который без изменений можно взять из проекта bitvisor из каталога (include\io.h).
3. Добавляем файл **include\pci.h,** который содержит основные определения для функций работы с PCI. Он имеет следующее содержимое:
```
#ifndef _PCI_H
#define _PCI_H
#include "types.h"
#define PCI_CONFIG_PORT 0x0CF8
#define PCI_DATA_PORT 0x0CFC
#define PCI_MAX_BUSES 255
#define PCI_MAX_DEVICES 32
#define PCI_MAX_FUNCTIONS 8
#define PCI_HEADERTYPE_NORMAL 0
#define PCI_HEADERTYPE_BRIDGE 1
#define PCI_HEADERTYPE_CARDBUS 2
#define PCI_HEADERTYPE_MULTIFUNC 0x80
typedef union
{
struct
{
u16 vendorID;
u16 deviceID;
u16 commandReg;
u16 statusReg;
u8 revisionID;
u8 progIF;
u8 subClassCode;
u8 classCode;
u8 cachelineSize;
u8 latency;
u8 headerType;
u8 BIST;
} __attribute__((packed)) option;
u32 header[4];
} __attribute__((packed)) PCIDevHeader;
void ReadConfig32(u32 bus, u32 dev, u32 func, u32 reg, u32 *data);
char *GetPCIDevClassName(u32 class_code);
void PCIScan();
#endif
```
4. Добавляем файл **pci.c** в корень проекта, со следующим содержимым (мы немного улучшили этот код по сравнению с основной статьей):
```
#include "types.h"
#include "printf.h"
#include "io.h"
#include "pci.h"
typedef struct
{
u32 class_code;
char name[32];
} PCIClassName;
static PCIClassName g_PCIClassNames[] =
{
{ 0x00, "before PCI 2.0"},
{ 0x01, "disk controller"},
{ 0x02, "network interface"},
{ 0x03, "graphics adapter"},
{ 0x04, "multimedia controller"},
{ 0x05, "memory controller"},
{ 0x06, "bridge device"},
{ 0x07, "communication controller"},
{ 0x08, "system device"},
{ 0x09, "input device"},
{ 0x0a, "docking station"},
{ 0x0b, "CPU"},
{ 0x0c, "serial bus"},
{ 0x0d, "wireless controller"},
{ 0x0e, "intelligent I/O controller"},
{ 0x0f, "satellite controller"},
{ 0x10, "encryption controller"},
{ 0x11, "signal processing controller"},
{ 0xFF, "proprietary device"}
};
typedef union
{
struct
{
u32 zero : 2;
u32 reg_num : 6;
u32 func_num : 3;
u32 dev_num : 5;
u32 bus_num : 8;
u32 reserved : 7;
u32 enable_bit : 1;
};
u32 val;
} PCIConfigAddres;
void ReadConfig32(u32 bus, u32 dev, u32 func, u32 reg, u32 *data)
{
PCIConfigAddres addr;
addr.val = 0;
addr.enable_bit = 1;
addr.reg_num = reg;
addr.func_num = func;
addr.dev_num = dev;
addr.bus_num = bus;
out32(PCI_CONFIG_PORT, addr.val);
in32(PCI_DATA_PORT, data);
return;
}
char *GetPCIDevClassName(u32 class_code)
{
int i;
for (i = 0; i < sizeof(g_PCIClassNames)/sizeof(g_PCIClassNames[0]); i++)
{
if (g_PCIClassNames[i].class_code == class_code)
return g_PCIClassNames[i].name;
}
return NULL;
}
int ReadPCIDevHeader(u32 bus, u32 dev, u32 func, PCIDevHeader *p_pciDevice)
{
int i;
if (p_pciDevice == 0)
return 1;
for (i = 0; i < sizeof(p_pciDevice->header)/sizeof(p_pciDevice->header[0]); i++)
ReadConfig32(bus, dev, func, i, &p_pciDevice->header[i]);
if (p_pciDevice->option.vendorID == 0x0000 ||
p_pciDevice->option.vendorID == 0xffff ||
p_pciDevice->option.deviceID == 0xffff)
return 1;
return 0;
}
void PrintPCIDevHeader(u32 bus, u32 dev, u32 func, PCIDevHeader *p_pciDevice)
{
char *class_name;
printf("bus=0x%x dev=0x%x func=0x%x venID=0x%x devID=0x%x",
bus, dev, func, p_pciDevice->option.vendorID, p_pciDevice->option.deviceID);
class_name = GetPCIDevClassName(p_pciDevice->option.classCode);
if (class_name)
printf(" class_name=%s", class_name);
printf("\n");
}
void PCIScan(void)
{
int bus;
int dev;
for (bus = 0; bus < PCI_MAX_BUSES; bus++)
for (dev = 0; dev < PCI_MAX_DEVICES; dev++)
{
u32 func = 0;
PCIDevHeader pci_device;
if (ReadPCIDevHeader(bus, dev, func, &pci_device))
continue;
PrintPCIDevHeader(bus, dev, func, &pci_device);
if (pci_device.option.headerType & PCI_HEADERTYPE_MULTIFUNC)
{
for (func = 1; func < PCI_MAX_FUNCTIONS; func++)
{
if (ReadPCIDevHeader(bus, dev, func, &pci_device))
continue;
PrintPCIDevHeader(bus, dev, func, &pci_device);
}
}
}
}
```
5. Добавляем запуск сканирования PCI устройств в kernel.c:
```
#include "printf.h"
#include "screen.h"
#include "types.h"
#include "pci.h"
void main()
{
clear_screen();
printf("\n>>> Hello World!\n");
PCIScan();
}
```
6. Вносим необходимые изменения в makefile:
```
OBJFILES = \
loader.o \
common/printf.o \
common/screen.o \
pci.o \
kernel.o
```
7. Теперь можно пересобрать проект:
```
make rebuild
sudo make image
```
8. Запускаем проект, чтобы убедиться, что все работает:
```
sudo qemu-system-i386 -hda hdd.img
```
Так мы получили список PCI устройств на компьютере. Это так же будет работать и на обычном компьютере, загрузившись с флешки.
Пройдя все шаги в этой статье вы можете собственноручно разобраться во всем и увидеть работающую программу, которую можно полноценно отлаживать.
Ссылки на следующие статьи цикла:
"**Как запустить программу без операционной системы: [часть 3: Графика](http://habrahabr.ru/company/neobit/blog/176707/#first_unread)**"
"**Как запустить программу без операционной системы: [часть 4. Параллельные вычисления](http://habrahabr.ru/company/neobit/blog/181626/#first_unread)**"
"**Как запустить программу без операционной системы: [часть 5. Обращение к BIOS из ОС](http://habrahabr.ru/company/neobit/blog/211470/#first_unread)**"
"**Как запустить программу без операционной системы: [часть 6. Поддержка работы с дисками с файловой системой FAT](http://habrahabr.ru/company/neobit/blog/203706/#first_unread)**" | https://habr.com/ru/post/174157/ | null | ru | null |
# Android Development Tutorial. Часть 2/?
Ларс Вогель — евангелист Eclipse.
Под катом Вы обнаружите продолжение перевода его статьи, которая описывает процесс создания Android-приложений с помощью Eclipse. Используется Eclipse 3.6, Java 1.6 и Android 2.3 (Gingerbread).
[Часть 1](http://habrahabr.ru/blogs/android_development/115022/)
##### 1.7. Активити и жизненный цикл
Операционная система контролирует жизненный цикл Вашего приложения. В любое время Android может остановить или уничтожить процесс Вашего приложения, например, из-за входящего звонка. Android определяет жизненный цикл активити с помощью предопределенных методов. Наиболее важные методы:
* onSaveInstanceState() — вызывает, если активити остановлено. Используется для сохранения данных при восстановлении состояния активити, если активити возобновлено
* onPause() — всегда вызывается, если активити завершилось, может быть использовано, для освобождения ресурсов или сохранения данных
* onResume() — вызвано, если активити возобновлено, может быть использовано для инициализации полей
##### 1.8. Контекст
Класс android.content.Context представляет связи с системой Android. Это интерфейс для глобальной информации про окружение приложения. Контекст также предоставляет метод getSystemService, позволяющий получить объект управления для различных частей оборудования. Так как Activities и Services расширяют класс «Context», вы можете получить прямой доступ к контексту с помощью «this».
#### 2. Установка
Допустим, Вы уже установили Eclipse.
##### 2.1. Android SDK
Скачайте Android SDK со страницы Android по ссылке [Android SDK](http://developer.android.com/sdk/index.html).
Скачанный zip-архив вы можете распаковать в любое место своей файловой системы, автор, например, распаковал в «c:\android-sdk-windows».
##### 2.2. Eclipse
Используйте менеджер обновлений Eclipse для установки всех доступных плагинов для Android Development Tools (ADT) по ссылке [dl-ssl.google.com/android/eclipse](https://dl-ssl.google.com/android/eclipse/).
##### 2.3. Configuration
В Eclipse откройте диалог Preferences через Windows -> Preferences. Выберите Android и укажите путь установки Android SDK.
*Если Вам каждый раз или просто часто предлагается заново выбрать расположение плагина Android, присоединяйтесь к автору в решении бага [Bug 3210](http://code.google.com/p/android/issues/detail?id=3210)*
Теперь выберите из меню Window -> Android SDK и AVD Manager.
Выберите доступные пакеты и выберите свежайшую версию SDK.
Нажмите «Install selected» и согласитесь с лицензиями всех пакетов. После установки перезапустите Eclipse.
##### 2.4. Device
Android tools включает в себя эмулятор. Этот эмулятор ведет себя как реальное Android-устройства в большинстве случаев и позволит Вам тестировать свое приложение без физически реального устройства. Вы можете эмулировать несколько устройств с разными конфигурациями. Каждая конфигурация определяется с помощью «Android Virtual Device» (AVD).
Для определения AVD нажмите кнопку менеджера устройств (device manager), нажмите «New» и совершите следующее.
Нажмите «Create AVD». Это создаст устройство. Для проверки корректности настройки, выберите ваше устройство и нажмите «Start».
После (спустя долгое время) ваше устройство будет запущено.
##### 2.5. Android Source Code
Следующий шаг опционален.
Во время разработки Android-приложений полезно иметь под рукой исходные коды Android, доступные с множеством умолчаний.
Haris Peco поддерживает плагины, предоставляющие доступ к исходникам Android. Воспользуйтесь менеджером обновлений Eclipse для установки двух плагинов. Сайты с обновлений: «[adt-addons.googlecode.com/svn/trunk/source/com.android.ide.eclipse.source.update](http://adt-addons.googlecode.com/svn/trunk/source/com.android.ide.eclipse.source.update)» и «[adt-addons.googlecode.com/svn/trunk/binedit/com.android.ide.eclipse.binedit.update](http://adt-addons.googlecode.com/svn/trunk/binedit/com.android.ide.eclipse.binedit.update)».
#### 3. Обработка ошибок
Вещи не всегда работают, как должны. Несколько отчетов пользователей описывают следующие ошибки:
1. Project… is missing required source folder: 'gen'
2. The project could not be built until build path errors are resolved.
3. Unable to open class file R.java.
Для решения этих проблем выберите меню Project -> Clean.
Если у вас проблемы с собственным кодом, можете использвать LogCat viewer, описанный далее (в третьей или четвертой части перевода).
#### 4. Ваш первый Android-проект
##### 4.1. Создание проекта
*Это приложение также доступно в Android Marketplace. Введите в поле поиска «vogella» для поиска этого примера.*
Выберите File -> New -> Other -> Android -> Android Project и создайте Android-проект «de.vogella.android.temperature».
Придерживайтесь следующего:
Нажмите «Finish». Это создаст следующую структуру каталогов.
В платформе Android структурированные значения, которые содержит каталог «res», умеет так же хранить и каталог «assets», предназначенный для хранения любых данных. В Java Вы можете получить доступ к этим данным через AssetsManager и метод getAssets().
##### 4.2. Две стороны вещей
Android SDK позволяет создавать точно определенные объекты, например, строки и пользовательские интерфейсы, двумя путями, с помощью тяжелого редактора, или прямо на XML. Постараемся использовать не только пользовательский интерфейс, но также и XML для проверки списков. Можете переключаться между этими двумя режимами вкладкой на нижней части экрана. Пример:
##### 4.3. Создание атрибутов
Android позволяет создавать атрибуты ресурсов, например строки и/или цвета. Эти атрибуты могут быть использованы в определении UI с помощью XML или Java-кода.
Выберите файл «res/values/string.xml» а нажмите «Add». Выберите «Color» и сохраните с именем «myColor» и значением "#3399CC".
Добавьте также следующие атрибуты строки, они позже позволят переводить приложение.
###### Таблица 1. Атрибуты строки
| Name | Value |
| --- | --- |
| myClickHandler | myClickHandler |
| celsius | to Celsius |
| fahrenheit | to Fahrenheit |
| calc | Calculate |
Переключитесь в режим работы с XMLи проверьте корректность заданных вами значений.
```
xml version="1.0" encoding="utf-8"?
Hello World, Convert!
Temperature Converter
#3399CC
myClickHandler
to Celsius
to Fahrenheit
Calculate
```
##### 4.4. Добавление элементов UI
Выберите «res/layout/main.xml» и откройте двойным кликом в Android editor. Этот редактор позволит задавать UI путем drag and drop, или напрямую в XML-коде. Вы можете переключаться между этими двумя вкладками кнопкой внизу редактора. Для изменения позиции и группировки элементов вы можете использовать просмотр эскиза.
Удалите «Hello World, Hello!» правым кликом. Перетяните «EditText» с панели «Views». Добавьте на макет «RadioGroup» с двумя переключателями RadioButtons (Вы можете удалить один RadioButton), добавьте одну «Button». Результат будет похожим на следующий скриншот, и соответствующий XML, написанный ниже.
Переключитесь на «main.xml» и проверьте, что XML-код похож на нижеприведенный.
```
xml version="1.0" encoding="utf-8"?
```
##### 4.5. Поддерржка свойств UI
Если Вы выберите элемент UI, то можете изменять его свойства через просмотр свойств. Большинство свойств могут также изменяться через меню, вызываемое правым кликом. Выберите EditText и удалите это свойство текста. Выберите поле, сделайте по нему правый клик, выберите Properties-> Text и удалите содержимое. Это значит, что никакого текста не будет показано в текстовом поле.
Удаление свойства текста в EditText ()
Назначьте строковый атрибут «celsius» Вашему свойству «text» первого переключателя и «fahrenheit» второго.
С этого момента автор предполагает, что вы можете использовать меню свойств на элементы UI. Установите свойство «Checked» в «true» для первого переключателя RadioButton. Назначить «calc» текстовому свойству Вашей кнопки и назначить «myClickHandler» свойству «onClick». Задать свойству «Input type» параметры «numberSigned» и «numberDecimal» в Вашем EditText.
Выберите фон (Ваш ViewGroup / LinearLayout) и задайте свойству «Background» атрибут цвета "@color/myColor".
Переключитесь во вкладку «main.xml», чтобы проверить, что XML-код правилен.
```
xml version="1.0" encoding="utf-8"?
```
##### 4.6. Код вашего приложения
Измените Ваш код в «Convert.java» на следующий. Обратите внимание, что вызов «myClickHandler» будет основан на свойстве «OnClick» Вашей кнопки.
```
package de.vogella.android.temperature;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.RadioButton;
import android.widget.Toast;
public class Convert extends Activity {
private EditText text;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
text = (EditText) findViewById(R.id.editText1);
}
// This method is called at button click because we assigned the name to the
// "On Click property" of the button
public void myClickHandler(View view) {
switch (view.getId()) {
case R.id.button1:
RadioButton celsiusButton = (RadioButton) findViewById(R.id.radio0);
RadioButton fahrenheitButton = (RadioButton) findViewById(R.id.radio1);
if (text.getText().length() == 0) {
Toast.makeText(this, "Please enter a valid number",
Toast.LENGTH_LONG).show();
return;
}
float inputValue = Float.parseFloat(text.getText().toString());
if (celsiusButton.isChecked()) {
text.setText(String
.valueOf(convertFahrenheitToCelsius(inputValue)));
} else {
text.setText(String
.valueOf(convertCelsiusToFahrenheit(inputValue)));
}
// Switch to the other button
if (fahrenheitButton.isChecked()) {
fahrenheitButton.setChecked(false);
celsiusButton.setChecked(true);
} else {
fahrenheitButton.setChecked(true);
celsiusButton.setChecked(false);
}
break;
}
}
// Converts to celsius
private float convertFahrenheitToCelsius(float fahrenheit) {
return ((fahrenheit - 32) * 5 / 9);
}
// Converts to fahrenheit
private float convertCelsiusToFahrenheit(float celsius) {
return ((celsius * 9) / 5) + 32;
}
}
```
##### 4.7. Запуск Проекта
Для запуска Android-приложения, Выберите Ваш проект, сделайте по нему правый клик, Run-As-> Android Application. Будьте терпеливы, эмулятор запускается очень медленно. Вы должны получить следующий результат.
Введите число, выберите Ваше преобразование и нажмите кнопку. Должен отобразиться результат и выбраться другой вариант.
##### 4.8. Использование «домашнего» меню
Если вы нажмете кнопку Home, вы также можете выбрать свое приложение.
#### 5. Меню, Настройки и Интенты
##### 5.1. Меню
Для использования меню Android предоставляет два пути. Первый — меню вариантов, которое может быть открыто через кнопку меню. Меню вариантов Ваших действий наполняется методом onCreateOptionsMenu() Ваших активити. Вы можете зарегистрировать здесь меню через Ваш Java-код или используя ресурсы меню в XML, которое Вы наполняете через «MenuInflator». Вы получите MenuInflator через действия с методом getMenuInflator().
onCreateContextMenu() вызывается единожды. Если Вы хотите воздействовать на меню позже — используйте метод onPrepareOptionsMenu().
Второй вариант отображения меню использует контекстное меню для виджетов UI (Вид). Контекстное меню активируется, если пользователь «долго нажимает» на Виде.
Контекстное меню для Вида регистрируется через метод registerForContextMenu(view). Метод onCreateContextMenu() вызывает каждый раз активированное контекстное меню, как контекстное меню, сброшенное после использования. Платформа Android может также добавлять варианты к Вашему Виду, например, «EditText» предоставляет контекстные варианты для выбора текста, и прочее.
##### 5.2. Проект
Эта часть покажет, как создать и определить количество вариантов меню, как определять настройки и как пермещаться между активити через интенты. Создайте проект «de.vogella.android.preferences» с активити «HelloPreferences». Измените UI в файле "/res/layout/main.xml" на следующее:
```
xml version="1.0" encoding="utf-8"?
```
##### 5.3. Добавление меню в XML-ресурсах
Меню могут быть определены через XML-файлы. Выберите Ваш проект, сделайте правый клик на нем и выберите New -> Other -> Android -> «Android XML File». Выберите опцию «Menu», введите как файл «menu.xml» и нажмите кнопку «Finish».
Нажмите Add и выберите «Item». Задайте следующее значение. Это определяет записи в Вашем меню. У нас будет одна запись.
Измените Ваш класс «HelloPreferences» на следующий. Метод OnCreateOptionsMenu используют для создания меню. Поведение в «onOptionsItemSelected» в настоящий момент жестко закодировано для показа Тостов (Toast — уведомление, сообщение, которое всплывает на поверхности окна), чтобы вызывать настройки параметров. В случае, если вы хотите отключить или скрыть объекты меню, Вы можете использовать метод «onPrepareOptionsMenu», который вызывает каждый раз ранее вызванное меню.
```
package de.vogella.android.preferences;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.widget.Toast;
public class HelloPreferences extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.menu, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
Toast.makeText(this, "Just a test", Toast.LENGTH_SHORT).show();
return true;
}
}
```
Запустите Ваше приложение и нажмите «Menu» в эмуляторе. Должно отобразиться Ваше меню. Если Вы выберите запись меню — то Вы должны увидеть небольшое информационное сообщение.
##### 5.4. Использование настроек
Значения настроек могут также быть сортированы как XML-ресурсы. Создайте другой Android XML-файл «preferences.xml» на этот раз, типа «Preference».
Нажмите Add, добавьте категорию, и две настройки «EditTextPreferences» в эту категорию: «User» и «Password».
Для поддержки настроек Вы можете определить Активити с расширениями PreferenceActivity. Это активити может загружать определение ресурсов настройки через метод addPreferencesFromResource(). Создайте класс «Preferences», который будет загружать «preference.xml».
```
package de.vogella.android.preferences;
import android.os.Bundle;
import android.preference.PreferenceActivity;
public class Preferences extends PreferenceActivity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.preferences);
}
}
```
Для того, чтобы сделать этот класс доступным как активити для Android, Вам нужно зарегистрировать его в Вашем файле «AndroidManifest.xml». Выберите «AndroidManifest.xml» и вкладку «Application». Добавьте активити «Preferences».
Мы обновим метод onOptionsItemSelected() для открытия активити «Preferences», единожды выбрав опцию меню. Хотя у нас сейчас есть только один вариант в нашем меню, мы используем переключение для готовности к нескольким новым записям меню. Чтобы увидеть поддерживаемые параметры, мы также определяем кнопку и используем класс «PreferenceManager» для получения sharedPreferences.
Первая кнопка покажет поддерживаемые сейчас параметры через Toast, а вторая кнопка вернет поддерживаемое имя пользователя для показа, как вы сможете изменить параметры через Java-код.
```
package de.vogella.android.preferences;
import android.app.Activity;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;
public class HelloPreferences extends Activity {
SharedPreferences preferences;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Button button = (Button) findViewById(R.id.Button01);
// Initialize preferences
preferences = PreferenceManager.getDefaultSharedPreferences(this);
button.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
String username = preferences.getString("username", "n/a");
String password = preferences.getString("password", "n/a");
Toast.makeText(
HelloPreferences.this,
"You entered user: " + username + " and password: "
+ password, Toast.LENGTH_LONG).show();
}
});
Button buttonChangePerferences = (Button) findViewById(R.id.Button02);
buttonChangePerferences.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
Editor edit = preferences.edit();
String username = preferences.getString("username", "n/a");
// We will just revert the current user name and save again
StringBuffer buffer = new StringBuffer();
for (int i = username.length() - 1; i >= 0; i--) {
buffer.append(username.charAt(i));
}
edit.putString("username", buffer.toString());
edit.commit();
// A toast is a view containing a quick little message for the
// user. We give a little feedback
Toast.makeText(HelloPreferences.this,
"Reverted string sequence of user name.",
Toast.LENGTH_LONG).show();
}
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.menu, menu);
return true;
}
// This method is called once the menu is selected
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
// We have only one menu option
case R.id.preferences:
// Launch Preference activity
Intent i = new Intent(HelloPreferences.this, Preferences.class);
startActivity(i);
// Some feedback to the user
Toast.makeText(HelloPreferences.this,
"Here you can maintain your user credentials.",
Toast.LENGTH_LONG).show();
break;
}
return true;
}
}
```
##### 5.5. Запуск
Запустите Ваше приложение. Нажмите аппаратную кнопку «menu», затем выберите пункт меню «Preferences». Вам должен быть доступен ввод Ваших пользовательских настроек, затем нажмите аппаратную кнопку «Назад» для возврата в Ваше главное активити. Сохраненные значения должны быть отображены в небольших окнах сообщениях (Toast), если вы нажмете Вашу первую кнопку. Если Вы нажмете вторую кнопку, будет возвращено имя пользователя.
#### 6. Диалоги через AlertDialog
На сегодня я остановился здесь. Буду рад критике. | https://habr.com/ru/post/115122/ | null | ru | null |
# Как устроены каналы в Go
*Перевод познавательной статьи ["Golang: channels implementation"](http://dmitryvorobev.blogspot.com.es/2016/08/golang-channels-implementation.html) о том, как устроены каналы в Go.*
Go становится всё популярнее и популярнее, и одна из причин этого — великолепная поддержка конкурентного программирования. Каналы и горутины сильно упрощают разработку конкурентных программ. Есть несколько хороших статей о том, как реализованы различные структуры данных в Go — к примеру, [слайсы](https://blog.golang.org/go-slices-usage-and-internals), [карты](https://www.goinggo.net/2013/12/macro-view-of-map-internals-in-go.html), [интерфейсы](http://research.swtch.com/interfaces) — но про внутреннюю реализацию каналов написано довольно мало. В этой статье мы изучим, как работают каналы и как они реализованы изнутри. (Если вы никогда не использовали каналы в Go, рекомендую сначала прочитать [эту статью](https://golang.org/doc/effective_go.html#channels).)
Устройство канала
-----------------
Давайте начнём с разбора структуры канала:
* qcount — количество элементов в буфере
* dataqsiz — размерность буфера
* buf — указатель на буфер для элементов канала
* closed — флаг, указывающий, закрыт канал или нет
* recvq — указатель на связанный список горутин, ожидающих чтения из канала
* sendq -указатель на связанный список горутин, ожидающих запись в канал
* lock — мьютекс для безопасного доступа к каналу
В общем случае, горутина захватывает мьютекс, когда совершает какое-либо действие с каналом, кроме случаев lock-free проверок при неблокирующих вызовах (я объясню это подробнее чуть ниже). Closed — это флаг, который устанавливается в 1, если канал закрыт, и в 0, если не закрыт. Эти поля далее будут исключены из общей картины, для большей ясности.
Канал может быть синхронным (небуферизированным) или асинхронным (буферезированным). Давайте вначале посмотрим, как работают синхронные каналы.
Синхронные каналы
=================
Допустим, у нас есть следующий код:
```
package main
func main() {
ch := make(chan bool)
go func() {
ch <- true
}()
<-ch
}
```
Вначале создается новый канал и он выглядит вот так:
Go не выделяет буфер для синхронных каналов, поэтому указатель на буфер равен nil и `dataqsiz` равен нулю. В приведённом коде нет гарантии, что случится первее — чтение из канала или запись, поэтому допустим, что первым действием будет чтение из канала (обратный пример, когда вначале идёт запись, будет рассмотрена ниже в примере с буферизированным каналами). Вначале, текущая горутина произведёт некоторые проверки, такие как: закрыт ли канал, буферизирован он или нет, содержит ли гоуртины в send-очереди. В нашем примере у канала нет ни буфера, ни ожидающих отправки горутин, поэтому горутина добавит сама себя в `recvq` и заблокируется. На этом шаге наш канал будет выглядеть следующим образом:
Теперь у нас осталась только одна работающая горутина, которая пытается записать данные в канал. Все проверки повторяются снова, и когда горутина проверяет `recvq` очередь, она находит ожидающую чтение горутину, удаляет её из очереди, записывает данные в её стек и снимает блокировку. Это единственное место во всём рантайме Go, когда одна горутина пишет напрямую в стек другой горутины. После этого шага, канал выглядит точно так же, как сразу после инициализации. Обе горутины завершаются и программа выходит.
Так устроены синхронные каналы. Сейчас же, давайте посмотрим на буферизированные каналы.
Буферезированные каналы
=======================
Рассмотрим следующий пример:
```
package main
func main() {
ch := make(chan bool, 1)
ch <- true
go func() {
<-ch
}()
ch <- true
}
```
Опять же, порядок исполнения неизвестен, пример с первой читающей горутиной мы разобрали выше, поэтому сейчас допустим, что два значения были записаны в канал, и после этого один из элементов вычитан. И первым шагом идёт создание канала, который будет выглядеть вот так:
Разница в сравнении с синхронным каналом в том, что тут Go выделяет буфер и устанавливает значение `dataqsiz` в единицу.
Следующим шагом будет отправка первого значения в канал. Чтобы сделать это, горутина сначала производит несколько проверок: пуста ли очередь `recvq`, пуст ли буфер, достаточно ли места в буфере.
В нашем случае в буфере достаточно места и в очереди ожидания чтения нет горутин, поэтому горутина просто записывает элемент в буфер, увеличивает значение `qcount` и продолжает исполнение далее. Канал в этот момент выглядит так:
На следующем шаге, горутина main отправляет следующее значение в канал. Когда буфер полон, буферизированный канал будет вести себя точно так же, как синхронный (небуферизированный) канал, тоесть горутина добавит себя в очередь ожидания и заблокируется, в результате чего, канал будет выглядеть следующим образом:
Сейчас горутина main заблокирована и Go запустил одну анонимную горутину, которая пытается прочесть значение из канала. И вот тут начинается хитрая часть. Go гарантирует, что канал работает по принципу FIFO очереди ([спецификация](https://golang.org/ref/spec#Channel_types)), но горутина не может просто взять значение из буфера и продолжить исполнение. В этом случае горутина main заблокируется навсегда. Для решения этой ситуации, текущая горутина читает данные из буфера, затем добавляет значение из заблокированной горутины в буфер, разблокирует ожидающую горутину и удаляет её из очереди ожидания. (В случае же, если нет ожидающих горутину, она просто читает первое значение из буфера)
Select
======
Но постойте, Go же ещё поддерживает select с дефолтным поведением, и если канал заблокирован, как горутина сможет обработать default? Хороший вопрос, давайте быстро посмотрим на приватное API каналов. Когда вы запускаете следующий кусок кода:
```
select {
case <-ch:
foo()
default:
bar()
}
```
Go запускает функцию со следующей сигнатурой:
```
func chanrecv(t *chantype, c *hchan, ep unsafe.Pointer, block bool)
```
`chantype` это тип канала (например, bool в случае make(chan bool)), `hchan` — указатель на структуру канала, `ep` — указатель на сегмент памяти, куда должны быть записаны данные из канала, и последний, но самый интересный для нас — это аргумент `block`. Если он установлен в `false`, то функция будет работать в неблокирующем режиме. В этом режиме горутина проверяет буфер и очередь, возвращает `true` и пишет данные в `ep` или возвращает `false`, если нет данных в буфере или нет отправителей в очереди. Проверки буфера и очереди реализованы как атомарные операции, и не требуют блокировки мьютекса.
Также есть функция для записи данных в очередь с аналогичной сигнатурой.
Мы разобрались как работают запись и чтение из канала, давайте теперь взглянём, что происходит при закрытии канала.
Закрытие канала
===============
Закрытие канала это простая операция. Go проходит по всем ожидающим на чтение или запись горутинам и разблокирует их. Все получатели получают дефолтные значение переменных того типа данных канала, а все отправители паникуют.
Заключение
==========
В этой статье мы рассмотрели, как каналы реализованы и как работают. Я постарался описать их как можно проще, поэтому упустил некоторые детали. Задача статьи — предоставить базовое понимание внутреннего устройства каналов и подтолкнуть вас к чтениею исходных кодов Go, если вы хотите получить более глубокое понимание. Просто почитайте [код реализации каналов](https://golang.org/src/runtime/chan.go). Мне он кажется очень простым, хорошо документированным и довольно коротким, всего около 700 строк кода.
Ссылки
------
[Исходный код](https://golang.org/src/runtime/chan.go)
[Каналы в спецификации Go](https://golang.org/ref/spec#Channel_types)
[Каналы Go на стероидах](https://docs.google.com/document/d/1yIAYmbvL3JxOKOjuCyon7JhW4cSv1wy5hC0ApeGMV9s/pub) | https://habr.com/ru/post/308070/ | null | ru | null |
# Detox и Appium: автоматизированный тест интерфейса в React Native
### Незнакомая мобильная среда
Я, возможно, также как и вы, пришел к React Native как разработчик JavaScript нежели как разработчик нативных мобильных приложений. Абсолютно новый мир со своими нюансами и хитростями.
Одной из самых важных тем для изучения станет тестирование. Когда все более или менее понятно с модульными тестами (unit), что делать с тестами интерфейса и сквозными тестами (end-to-end)? iOS. Android. На рынке смесь разных типов устройств.
Несмотря на то, что сама технология сравнительно новая, это все еще мобильная среда и многому приходится заимствовать и учиться у нативной стороны.
Я вкратце рассмотрю два фрэймворка, на которые стоит обратить внимания, чтобы облегчить себе жизнь как разработчику.
### Appium
Использующая за кулисами Selenium WebDriver, Appium это мощный фреймворк с огромным сообществом разработчиков нативных мобильных приложений. Вышедший еще до React.js, это лидер и равных ему нет.
Начать работу с Appium довольно легко. С помощью npm устанавливаем пакеты “appium” и “appium-doctor”, можем глобально, можем как часть проекта. Команда “appium-doctor” расскажет нам, что еще нужно установить и настроить прежде чем приступать к работе, и, если возможно, поможет исправить недочеты. Когда все решено, пакеты установлены и конфигурация Jest на месте, можем запускать сервер Appium и тесты.
Не буду углубляться в подробности настройки, но вот как выглядит простой тест с конфигурацией (добавлены комментарии):
```
/* клиент selenium webdriver для node
*/
import wd from 'wd'
/* 60 секунд таймаут, после которых тест остановится, если застрянет
*/
jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000
/* адрес сервера Appium. Запускаем с нашего компьютера, поэтому localhost
*/
const URL = 'localhost'
const PORT = 4723
/* создаем объект webdriver
*/
const driver = wd.promiseChainRemote(URL, PORT)
/* Вожможности сервера.
* инструкция для сервера Appium,
* как запускать тесты, другими словами настройки.
*/
const capabilities = {
platformName: 'iOS', // или Android
platformVersion: '12.1', // версия ОС
deviceName: 'iPhone 8', // или “Android Emulator” или точное название устройства
automationName: 'XCUITest', // фреймворк платформы (UIAutomator2 для Android)
app: '/path/to/.app' // расположение файла .app (для Android это .apk)
}
beforeAll(async () => {
try { // до того, как запустить тест
await driver.init(capabilities) // запускаем драйвер
await driver.sleep(4000) // да уж, вручную ставим таймер и ждем загрузку приложения, вот она хрупкость!
} catch(err) {
console.log(err) // если что, мы хотим знать, что не так
}
})
afterAll(async () => {
try {
await driver.quit() // конец сессии
} catch(err) {
console.error(err)
}
});
/* Jest, делаем что хотим, что позволяет Appium!
* в данном примере мы проверяем, соответствует ли текст
* 'topLabel' и 'subLabel' заданному
* Рекомендую ознакомиться с документацией на сайте Appium
*/
describe("Home Screen landing", () => {
test("render search screen", async () => {
let topLabel = await driver.elementById('topLabel')
let subLabel = await driver.elementById('subLabel')
expect(await topLabel.text()).toBe("OK")
expect(await subLabel.text()).toBe("главный экран")
})
})
```
Сам тест, это последние несколько строк, которые проверяют, если на экране текст “OK” и “главный экран”. Как видите, в тесте ничего особенного, тот же самый Jest. Документация на сайте Appium описывает все возможности фреймворка включая также примеры на JavaScript.
Неприязнь только к строке `await driver.sleep(4000)`. К сожалению, тесты понятия не имеют, что происходит в приложении. Так называемый “черный ящик” или Blackbox. Представьте, если бы вы писали код на Node, и перед запросом http, вы бы ставили таймер вместо использования promise или callback. Вот она, хрупкость UI тестов.
В этом простом тесте мы ждем 4 секунды для запуска приложения. Со временем и с увеличением количества тестов, мы будем устанавливать таймеры чаще — запросы http, анимация, сам React Native — мост между нативным кодом и JavaScript только усложняет ситуацию.
*«Черный ящик», у нас есть сборка приложения без доступа к внутренним структурам.*
**Что нравится в Appium**
* 7+ лет в индустрии.
* Широкие возможности API.
* Легко найти помощь (это также минус, список ниже)
* Поддержка разных языком, в том числе JavaScript.
* Знакомая для разработчика JavaScript среда Jest.
* Используется для сквозных тестов в MS AppCenter, BrowserStack и AWS DeviceFarm.
* Возможность теста на настоящих устройствах.
**Что не нравится в Appium**
* Поиск в сети выдает результаты для разных языков программирования, большинство из них это Java.
* Тестирование “чёрного ящика” (тесты не знают о процессах внутри приложения).
* Нет синхронности с приложением, хрупкость, еще больше проблем создает React Native.
* testID по какой-то причине не работает на Android.
*Заметьте три таба: логи сервера Appium, пакет metro bundler и сам тест.*
### Detox
Detox от компании Wix работает схоже с Appium. Главное отличие, это тестирование по стратегии «серого ящика». Одной из задач разработчиков Detox было решение проблем с хрупкостью — задача в приложении не будет начата, пока не закончилась предыдущая и пока приложение не будет свободно. Это стало возможно благодаря другому фреймворку созданному под названием EarlGrey.
Так же как и с Appium, устанавливаем настройки.
```
/* Дополнительная настройка в файле package.json, ниже пример
*/
const detox = require("detox");
const config = require("./package.json").detox;
/* адаптер Jest
*/
const adapter = require("detox/runners/jest/adapter");
/* Таймаут,
* использование адаптера Jest
*/
jest.setTimeout(120000);
jasmine.getEnv().addReporter(adapter);
beforeAll(async () => {
/* Запускаем сервер
*/
await detox.init(config);
});
/* beforeEach и afterEach для тестов Detox,
* используем от Jest
* чистим после тестов
*/
beforeEach(async function() {
await adapter.beforeEach();
});
afterAll(async () => {
await adapter.afterAll();
await detox.cleanup();
});
```
И настройка в package.json:
```
"detox": {
"configurations": {
"ios.detox": { // настройки для iOS (запускается командой detox test -c ios.detox)
"binaryPath": "path/to/.app",
"build": "xcodebuild -workspace ios/app.xcworkspace -scheme scheme -configuration Debug -sdk iphonesimulator -derivedDataPath ios/build", // файл workspace или project. В данном случае создаем пакет debug вместо production (release).
"type": "ios.simulator",
"name": "iPhone 8" // название симулятора
},
"android.detox": { // настройки для Android (запускается командой detox test -c android.detox)
"binaryPath": "path/to/.apk",
"build": "cd android && ./gradlew assembleDebug assembleAndroidTest -DtestBuildType=debug && cd ..", // В данном случае создаем пакет debug вместо production (release).
"type": "android.emulator",
"name": "Pixel_2_API_28" // название симулятора. “adb devices” покажет список доступных устройств Android
}
},
"test-runner": "jest",
"runner-config": {
"setupTestFrameworkScriptFile" : "./detox.init.js", // пример выше
"testEnvironment": "node",
"testRegex": "(.*|\\.(ui))\\.(ts|tsx)$" // регулярное выражение, где искать тесты интерфейса
}
"specs": "./__tests__/" // расположение тестов интерфейса
}
```
Тесты писать также легко, как и для Appium, но с использованием возможностей и ограничений Detox.
*«Серый ящик», у нас есть сборка приложения и доступ к внутренним структурам.*
**Что мне нравится в Detox**
* Создан Wix для React Native.
* Сфокусирован на JavaScript.
* Тест по стратегии «серого ящика».
* Работает синхронно с приложением.
**Что не нравится в Detox**
* Возможности не такие широкие как у Appium.
* Маленькое сообщество.
### Хрупкость
Несмотря на то, что Detox использует принцип «серого ящика», хрупкость все еще присутствует. Тест с вводом текста и свайпом не срабатывал как надо в 1 случае из 10. Нельзя быть уверенным на 100% в тестах интерфейса.
### Скорость
Appium “тормозит” таймеры “.sleep” установленные в ручную, Detox в этом случае выигрывает, так как все синхронно. В целом я бы не делал еще каких-либо выводов со своей стороны, так как не писал большого кол-ва одинаковых тестов на обеих платформах. В 30-секундных тестах и простом тесте созданном для этой статьи, Detox справился на секунды быстрее. Если смотреть на две разные платформы, iOS и Android, тесты заняли +- одно и то же время. Главное, следует помнить, что тесты интерфейса занимают значительно больше времени модульных тестов.
### Что выбрать
Я по прежнему изучаю оба фреймворка и понадобится какое-то время, чтобы понять все их преимущества, но на данный момент, как разработчик JavaScript, я выбираю Detox.
Испробуйте оба, к счастью, их только два. Все зависит от приложения, над которым вы работаете, и команды.
Тесты интерфейса в команде разработчиков — для разработчиков, пробуйте Detox. Более сложные сквозные тесты — возможно, лучше присмотреться к Appium с его богатыми возможностями API и поддержкой на платформах BrowserStack, MS AppCenter и AWS DeviceFarm.
### Ссылки
Есть много полезных ресурсов и статей, но, к сожалению, на английском. Первым делом я рекомендую оф. сайты.
[Appium](http://appium.io)
[Detox](https://github.com/wix/Detox) | https://habr.com/ru/post/434816/ | null | ru | null |
# Игра «угадай аниме по кадру» – защита от читерства
Наверное, многие участвовали в играх, где нужно было угадать фильм или сериал по кадру из него. Очень часто такие топики-игры встречаются на форумах. А недавно мне показали сайт, целиком посвящённый угадыванию аниме по кадру. С автоматизированной игрой: с учётом очков, с вариантами ответов.
После нескольких игр мой интерес как анимешника был удовлетворён, и во мне проснулся айтишник. Стало интересно, а какая есть на сайте защита от читерства. В ходе короткого анализа, оказалось, что с защитой от читерства всё печально, взломать игру можно даже с начальными знаниями JS. Тут бы и погаснуть моему айтишному интересу, но нет, я задумался, а что нужно вообще сделать, чтобы защитить от читеров подобную игру. Так и появилась эта статья.
(картинка для привлечения внимания)
Дальше я расскажу о найденных в игре слабых местах и о методах защиты от читерства для подобных игр, которые мне удалось придумать.
#### Суть игры
На каждом шаге игроку демонстрируется кадр из аниме и 4 варианта ответа, из которых 1 правильный. Игра идёт до первого неверно угаданного кадра. На каждый кадр игроку даётся 15 секунд. Также по одному разу можно пропустить кадр или воспользоваться подсказкой «50 на 50».
#### Технические детали и «взлом» игры
Посмотрев на урлы страниц сайта, я легко обнаружил, что он работает на PHP. А тот факт, что игра проходила без перезагрузки страницы, говорил об использовании AJAX. Клиентский функционал находился в единственном подключённом скрипте game.js.
Первое, что меня разочаровало в безопасности игры – то, что game.js не обфусцирован. Там удалены лишние пробелы, но, не считая этого, код находится в первозданном виде.
Но всё было ещё печальнее. Запустив Firebug и посмотрев содержимое ответов AJAX, я обнаружил один очень интересный параметр.
Да, этот параметр содержал не что иное, как индекс верного ответа, от 0 до 3. Я никак не ожидал, что всё будет так просто, что даже не интересно. Надежды, что надо будет подключать Google Images для отгадывания, рухнули.
Дальше было дело техники. Первым делом я пропустил код из game.js через JS Beautifier, получив читаемый код. Код оказался довольно простым и без всякой защиты. Ответы AJAX обрабатывались в функции startGame. Оставалось всего лишь переопределить эту функцию. Для этого я подключил небольшой greasemonkey-скрипт.
В скрипте я просто по полученному из XML номеру ответа подсвечивал нужную кнопку. Впоследствии сделал автоматическое нажатие её через 2 секунды. Код приводить не буду, чтобы не потакать читерам, пусть сами хоть чуть-чуть подумают при желании. Там буквально 3 строчки. Но я был удивлён, что при такой защите в топе не засветился никто с максимальным количеством очков.
#### Слабые места игры и защита от читерства
Передачу верного ответа вместе с вариантами и загадкой сложно даже слабым местом назвать, авторы вообще, скорее всего, не задумывались о читерах. Номер верного ответа, конечно, следует сохранять в сессию и проверять на стороне сервера, что легко сделать средствами PHP.
Первым, что я рассмотрю, будет защита на клиентской стороне. Игра имеет два ограничения в JS: она автоматом завершается, если истекло время на угадывание кадра, или в случае переключения на другое окно. Мне не совсем понятно, зачем запрещать переключение на другое окно, тогда как время и так ограничено. Только если чтобы игрок быстро не загуглил кадр. Но так решили создатели сайта.
**Защита от переключения на другое окно.**
Слабое место её в том, что JS полностью подконтролен клиенту. Полностью решить проблему нельзя, можно лишь затруднить злоумышленнику взлом. Чтобы хоть как-то защитить игру от изменений JS, его, конечно же, нужно обфусцировать. Совсем хорошо бы было генерировать и обфусцировать js-файл на лету при каждой загрузке страницы, помещая туда разные функции вычисления некого токена, который бы проверялся через AJAX. Так злоумышленнику было бы сложно подменить JS. Сложно, да не совсем.
В конце концов, чтобы отключить защиту от переключения на другое окно, нужно всего лишь переопределить window.onblur. Но и это решаемо, если периодически проверять, не переопределён ли обработчик данного события.
```
var onblur_handler = function() {
alert('game over');
};
window.onblur = onblur_handler;
var check_onblur = function() {
if (window.onblur !== onblur_handler) {
alert('Попался, читер! Мы вычислили тебя по IP. Братва уже выехала!');
window.onblur = onblur_handler;
}
}
setInterval(check_onblur, 2000);
// evil code
setTimeout(function() {
window.onblur = function() {
console.log('cheating');
};
}, 2500);
```
Злоумышленник, конечно, может вообще не выполнять наш JS, но если он будет обфусцирован, да ещё содержать какие-нибудь токены для AJAX-запроса, это доставит хлопот.
Таким образом, получается, что наше приложение должно будет посылать на сервер номер ответа и токен, полученный из JS; а принимать с сервера ссылку на следующее изображение и варианты ответа.
**Ограничение по времени.**
С ограничением по времени можно поступить аналогично, оставив защиту на стороне клиента. Но можно и подстраховаться, проверяя время и на сервере. Но стоит учесть, что картинка отображается у клиента не мгновенно, и после нажатия на кнопку запрос на сервер приходит тоже не сразу. Поэтому нужно дать клиенту некоторую фору по сравнению с сервером. Идеально было бы анализировать «отставание» клиента, и принимать меры, только если оно значительно.
**Повторение кадров.**
Эта проблема относится не совсем к безопасности, но я её тоже рассмотрю. Суть в том, что раз кадры выбираются случайно, то в рамках одной игры два кадра могут совпасть. Это не правильно. Решить проблему можно довольно просто. Учитывая, что общее количество кадров не очень велико, можно при старте игры загружать все кадры (а точнее их идентификаторы) в массив, сортировать его случайным образом, сохранять массив в сессию, и по очереди выдавать кадры игроку. В PHP для сортировки в случайном порядке как раз есть функция.
```
shuffle($screenshots);
```
**Ссылки на скриншоты.**
Ещё одно слабое место игры – ссылки на скриншоты. На сайте игры все они имеют формат вида /web/ANIME\_ID/SCREENSHOT\_INDEX.jpg, то есть ответ засвечивается уже в адресе картинки. Поэтому не стоит вообще отдавать прямые постоянные ссылки на скриншоты. Можно отдавать скриншот средствами PHP всегда по одному и тому же адресу. Просто перед каждой новой загадкой нужно сохранять в сессию идентификатор выбранного кадра и отправлять этот кадр при обращении к определённому php-скрипту.
**Проблема конечного количества скриншотов.**
Наконец, самая сложная проблема. Дело в том, что количество кадров ограничено, поэтому в новых играх они будут повторяться. Злоумышленник может просто написать программу, собирающую все кадры и соответствующие им аниме. После чего останется только с помощью другой программы сравнивать текущий кадр со всем наборов сохранённых. Замечу, что если бы проблема ссылок не была бы решена, злоумышленнику достаточно было бы сравнивать лишь ссылки.
На самом деле, любой игрок со временем может запомнить кадры, которые будут повторяться. Но в отличие от читеров, он сделает это своими силами. Для борьбы с читерами остаётся только усложнить им процесс программного сравнения кадров.
Для достижения цели потребуется каждый раз при передаче пользователю кадра вносить изменения в него. Если этого не делать, найти два одинаковых файла одного кадра злоумышленнику будет просто. Изменять картинки можно с помощью библиотеки GD, входящей в комплект PHP.
Самое простое – случайно менять качество JPEG, передаваемого клиенту.
```
function open_screenshot($filename)
{
return imagecreatefromjpeg($filename);
}
function echo_screenshot($image)
{
$quality = rand(60, 100);
ob_start();
imagejpeg($image, null, $quality);
$buffer = ob_get_clean();
header('Content-Type: image/jpeg');
header('Content-Length: '.strlen($buffer));
echo $buffer;
}
$image = open_screenshot(dirname(__FILE__).'/1.jpg');
echo_screenshot($image);
```
Если этого недостаточно, то можно поиграть с яркостью и контрастностью или другими фильтрами.
```
function filter_image($image)
{
$brightness = rand(-10, 10);
$contrast = rand(-10, 10);
imagefilter($image, IMG_FILTER_BRIGHTNESS, $brightness);
imagefilter($image, IMG_FILTER_CONTRAST, $contrast);
return $image;
}
```
Однако все эти манипуляции только слегка искажают цвета, но оставляют возможность простого попиксельно сравнения. Чтобы усложнить задачу, можно обрезать кадр по горизонтали и вертикали, сохраняя пропорции и затем увеличивая до исходного размера.
```
function cut_image($image)
{
$k = rand(98000, 100000) * 0.00001;
$w1 = imagesx($image);
$h1 = imagesy($image);
$w2 = round($k * $w1);
$h2 = round($k * $h1);
$x = rand(0, $w1 - $w2);
$y = rand(0, $h1 - $h2);
$result = imagecreatetruecolor($w1, $h1);
imagecopyresampled ($result, $image, 0, 0, $x, $y, $w1, $h1, $w2, $h2);
return $result;
}
```
Теперь, если кадров в игре достаточно много, задача сравнения станет не такой уж тривиальной. Хотя если в распоряжении злоумышленника есть алгоритмы сравнения как в Google Images, то и это не будет помехой. А также эффект от обрезания меньше, если сравнивать уменьшенные версии кадров.
Картинка состоит из 6 вариантов кадра, полученных вышеприведённым способом. Как видите, везде разные значения яркости и контрастности. Если приглядеться, можно обнаружить, что в некоторых кадрах изображение обрезано по краям больше, чем в других.
Кстати, от банального гугленья скриншота я защиты не придумал. Разве что искажать его ещё сильнее, но это может повлиять и на узнаваемость человеком.
Пожалуй, это всё, что я могу сказать о технической стороне защиты от читеров в данном случае. Я думаю, подобные идеи рано или поздно пришли бы в голову любому разработчику, озаботившемуся защитой подобных игр.
#### Заключение
Заниматься читерством на сайте я всё-таки пока не стал даже из айтишного интереса, потому что взлом защиты подобного уровня – не большой повод похвастаться.
На самом деле, отсутствие защиты от читерства – тоже защита. Читерство ведь в данном случае ничего не даёт, а лёгкость нечестной игры убивает всякий интерес в нём. Конечно, если сайт хотел бы поддерживать реальные рейтинги, то ему стоило бы позаботиться о защите.
Кстати, хочу заметить, что кое-что описанное в данной статье можно применить не только к такого рода играм, а к чему-то более серьёзному. Например, онлайн-тестам.
##### P.S.
Адрес сайта я до сих пор не писал, чтобы не было похоже на рекламу. Но играть с вами в «угадай сайт по скриншоту» я не буду. Сайт, о котором идёт речь, – [guessanime.com](http://guessanime.com).
Я никакого отношения к сайту не имею. Если статья как-то заденет владельцев, мне очень жаль. | https://habr.com/ru/post/184260/ | null | ru | null |
# Хуки — это просто (часть 2)
Некоторое время назад я писал [вводную статью](http://habrahabr.ru/company/infopulse/blog/140456/) о хуках (что это, зачем нужно, Hello world). Статья задумывалась простой, минималистичной и, вроде бы, такой и получилась. Единственный упрёк, который я услышал в комментариях — «Зачем же брать библиотеку Microsoft Detours, которая для коммерческого использования стоит 10 000$ ?». Замечание справедливое. В этой статье я приведу тот же пример с использованием другой библиотеки ценой примерно в 20 раз меньше (что уже вполне себе в рамках разумного) — [madCodeHook](http://madshi.net/madCodeHookDescription.htm).
Для лучшего понимания данной статьи рекомендуется сначала прочитать [первую часть](http://habrahabr.ru/company/infopulse/blog/140456/).
#### madCodeHook
Библиотека с богатым прошлым. Первая её версия вышла в далёком 2000-ом году, предназначалась для использования под Delphi и мало что умела. Тем ни менее за последующие годы автор весьма неплохо её развивал: сделал SDK для С++, внедрил поддержку 64-битных систем, всех версий Windows от 9х до Win 8.1, реализовал драйвер для внедрения хуков во все новосозданные процессы, ну и вообще достаточно активно работал над проектом (апдейты и сейчас выходят регулярно). По ходу дела из-из нежелания быть подмогой вирусописателям библиотека [потеряла](http://forum.madshi.net/viewtopic.php?f=7&t=4210&sid=6f1b7a677b164ba2a2446a49b4c2bcbd) бесплатную версию, однако цены, начинающиеся от 349 евро делают её реальной альтернативой и нереально дорогой [Microsoft Detours](http://research.microsoft.com/en-us/projects/detours/), и малоудобной [mhook](http://codefromthe70s.org/mhook22.aspx), и нестабильной (по моему опыту) [EasyHook](http://easyhook.codeplex.com/).
#### Ограничения evaluation-версии
* Нет исходников
* Нет возможности статической линковки
* Должно быть вручную запущено входящее в комплект приложение mchEvaluation.exe
* Библиотека madCHook.dll должна быть предварительно скопирована в System32
В общем, для изучения — ничего критически мешающего. Для коммерческого продукта в любом случае нужно покупать лицензию.
#### Вспоминаем нашу задачу
В первой части статьи мы использовали хуки для того, чтобы заставить браузер Mozilla Firefox при заходе на Хабр писать в своём заголовке «Привет, Хабр!». Во-первых, мне лень придумывать новую задачу, а во-вторых даже правильнее будет реализовать снова тоже самое на базе другой библиотеки — можно сравнить скорость разработки, объём и сложность кода. Кроме того, в первой части мы уже разобрались куда и какие хуки нужно вешать, так что сэкономим на этом немного времени.
#### Практика
**1.** [Качаем](http://madshi.net/madCollection.exe) последнюю версию madCodeHook, устанавливаем.
**2.** Создаём в Visual Studio (я использую VS 2010, но вы можете взять и другую) solution c двумя проектами. Первый — библиотека с кодом хука, которую мы будем инжектить в процесс браузера. Второй — приложение инжектора, его задача — забросить библиотеку в адресное пространство браузера.
* Для создания первого проекта: File->New->Project. Тип Visual C++ -> Win32 -> Win32 Project. В диалоге создания проекта указываем тип «Dll»
* Для создания второго проекта: File->Add->New Project. Тип Visual C++ -> Win32 -> Win32 Console Application.
**4.** Подкидываем в наши проекты заголовочный файл и lib-файл из SDK madCodeHook. При установке библиотеки по-умолчанию они находятся по адресу C:\Program Files (x86)\madCollection\madCodeHook\Dll. В evaluation-версии нам доступна только динамическая линковка, так что забираем файлы madCHook — dynamic.h и madCHook — dynamic — microsoft.lib, можно их для краткости переименовать в madCHook.h и madCHook.lib.
**5.** Пишем код. Ключевые моменты:
**Код инжектора**
```
#include "stdafx.h"
#include
#include "windows.h"
#include "madCHook.h"
#include
HANDLE GetProcessByName(PCWSTR name)
{
DWORD pid = 0;
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS\_SNAPPROCESS, 0);
PROCESSENTRY32 process;
ZeroMemory(&process, sizeof(process));
process.dwSize = sizeof(process);
if (Process32First(snapshot, &process))
{
do
{
if (\_wcsicmp(process.szExeFile, name) == 0)
{
pid = process.th32ProcessID;
break;
}
} while(Process32Next(snapshot, &process));
}
CloseHandle(snapshot);
if (pid != 0)
return OpenProcess(PROCESS\_ALL\_ACCESS, FALSE, pid);
return NULL;
}
int \_tmain(int argc, \_TCHAR\* argv[])
{
InjectLibraryW((DWORD)GetProcessByName(L"firefox.exe"), L"HookLib.dll");
\_getch();
UninjectLibraryW((DWORD)GetProcessByName(L"firefox.exe"), L"HookLib.dll");
}
```
**Код библиотеки с хуком**
```
#include "stdafx.h"
#include "madCHook.h"
LRESULT (WINAPI * TrueSendMessageW)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) = SendMessageW;
__declspec(dllexport) LRESULT WINAPI MySendMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
if (Msg == WM_SETTEXT && wcsstr((LPCTSTR)lParam, L"Хабрахабр"NULL)
return TrueSendMessageW(hWnd, Msg, wParam, (LPARAM)L"Привет, Хабр!");
return TrueSendMessageW(hWnd, Msg, wParam, lParam);
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
HookAPI("User32.dll", "SendMessageW", MySendMessageW, (PVOID*) &TrueSendMessageW);
}
return TRUE;
}
```
[Готовый проект на Гитхабе](https://github.com/ezhikus/MadCodeHook_HelloWorld)
**6.** Компилируем, запускаем Firefox, запускаем mchEvaluation.exe, запускаем инжектор, в браузере переходим на Хабр. Результат:
#### Выводы
В плане удобства работы с evaluation-версией madCodeHook немного проигрывает Microsoft Detours, полнофункциональные версии в этом плане примерно равны. Кода писать madCodeHook требует даже меньше. В составе madCodeHook есть драйвер для внедрения библиотек на общесистемном уровне (во все существующие и новые процессы), в Detours эту задачу нужно решать собственным сервисом или драйвером. По скорости и стабильности библиотеки показались мне аналогичными. madCodeHook не вызывает ощущения «энтерпрайзности», как продукт Microsoft, что одновременно и хорошо и плохо: автора легко можно поймать на форуме (что хорошо), но там же написано «я могу уйти в отпуск на 6 недель в любое время года» (что плохо). Сообщество madCodeHook сосредоточено на их [форуме](http://forum.madshi.net/viewforum.php?f=7), сообщество Microsoft Detours как-то раскидано по Stackoverflow, wasm.ru, форумам MSDN и ощущения целостности не создаёт.
В общем, библиотека madCodeHook оставляет хорошее впечатление, можно пользоваться. | https://habr.com/ru/post/213309/ | null | ru | null |
# Личный веб-сервер на Wolfram Language
Иногда людям хочется быстро сделать веб-сервер, корневая логика которого будет на Wolfram Language. Существует правильный и долгий путь. Наградой будет красота решения и производительность. И существует второй путь. О нем мы и поговорим.
Я начал активно изучать Mathematica и Wolfram Language где-то полгода назад и сразу возникло желание использовать его как “повседневный” язык для разных бытовых и околорабочих задач. Знаете, у каждого есть язык, который первым приходит на ум, если нужно, скажем, проанализировать какую-то коллекцию данных или связать друг с другом несколько систем. Обычно это какой-то достаточно высокоуровневый скриптовый язык. В моем случае в этой роли выступал Python, но тут у него появился серьезный конкурент.
Однако не все можно решить, запустив блокнот Mathematica и разово выполнив код из него. Некоторые задачи требуют периодического исполнения либо запуска по какому-то событию. Нужен сервер. Для начала посмотрим, какие варианты развертывания и исполнения предлагает [сама компания](http://www.wolfram.com/universal-deployment-system/). Насколько я могу судить, опции следующие:
1) Старый добрый Mathematica Notebook. Иными словами, разовая рабочая сессия в GUI.
2) [Wolfram Cloud](http://www.wolfram.com/cloud/). И это замечательная опция, которую использую в том числе и я. Однако есть масса причин, по которым вариант с облаком может не подойти. Назову лишь одну из них — каждый вызов стоит ненулевое количество денег. Для множества мелких периодических операций это может быть неоправданно затратно, особенно когда под рукой есть простаивающие мощности.
3) Wolfram Private Cloud. Звучит как какая-то грядущая возможность запустить собственное облако. Подробности мне неизвестны.
4) Использовать [Wolfram Symbolic Transfer Protocol](http://reference.wolfram.com/language/tutorial/IntroductionToWSTP.html). Выглядит как самый основательный и универсальный способ интеграции Wolfram Language в вашу систему. Сервер здесь — лишь один из частных случаев применения. Тот самый “правильный и долгий путь”.
5) [Wolfram Script](http://reference.wolfram.com/language/tutorial/WolframLanguageScripts.html). Все просто — вызываем код на Wolfram Language как любой другой скрипт, без непосредственного участия графического интерфейса. Cron, pipeline и все остальные замечательные механизмы в нашем распоряжении. Этот способ мы и используем для быстрого создания сервера.
Непосредственно сервером мы можем выбрать что угодно, в моем случае это Tornado. Напишем простейший handler, который будет отправлять аргументы, заголовки и тело запроса в наш скрипт и считывать результаты его работы.
```
import tornado.ioloop
import tornado.web
import os, subprocess
import json
WOLFRAM_EXECUTABLE = "wolfram"
def execute(arguments):
def run_program(arguments):
p = subprocess.Popen(arguments,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
return iter(p.stdout.readline, b'')
res = ''
for line in run_program(arguments):
res+=line
return res
class MainHandler(tornado.web.RequestHandler):
def get(self):
out = execute([WOLFRAM_EXECUTABLE,"-script", "main.m",
str(self.request.method),
str(json.dumps(self.request.arguments)),
str(json.dumps(self.request.headers)),
str(self.request.body)])
self.write(out)
application = tornado.web.Application([
(r"/", MainHandler),
])
application.listen(8888)
```
Собственно, “main.m” — это и есть наш скрипт на Wolfram Language. В нем нам нужно получить и интерпретировать переданные аргументы, а также вернуть результат.
```
method = $CommandLine[[4]]
arguments = Association @ ImportString[$CommandLine[[5]], "JSON"]
headers = Association @ ImportString[$CommandLine[[6]], "JSON"]
body = If[Length[$CommandLine] >= 7,$CommandLine[[7]], ""]
Print["Hello world"]
```
Наш скрипт выводит “Hello world”. Часть на питоне, в свою очередь, честно возвращает эти данные клиенту.
В принципе, в этом вся суть метода.
В таком виде наш сервер сможет принимать и возвращать только строковые данные с кодом результата 200. Хочется немного больше гибкости. Для этого данные из скрипта должны передаваться не просто в виде строки, а в каком-то структурированном виде. Так у нас появляется еще одно преобразование в JSON и обратно. Формат будет таким:
```
{
“code”: 200,
“reason”: OK,
“body”: “Hello world"
}
```
Теперь его нужно корректно обработать на другой стороне.
```
outJson = json.loads(out)
self.set_status(outJson["code"], outJson["reason"])
if(outJson["body"] != None):
self.write(str(outJson["body"]))
```
Следующим шагом будет добавление возможности возвращать не только текст, но и другие данные. Возможно, два двойных преобразования JSON казались кому-то недостаточно медленным решением… Добавим в наш JSON поля “file” и “contentType”. Если поле “file” непустое, то вместо записи в поток вывода содержимого поля “body” мы считываем указанный файл.
```
outJson = json.loads(out)
self.set_status(outJson["code"], outJson["reason"])
if(outJson["file"] != None):
self.add_header("Content-Type", outJson["contentType"])
with open(outJson["file"], 'rb') as f:
while True:
data = f.read(16384)
if not data: break
self.write(data)
self.finish()
os.remove(outJson["file"])
elif(outJson["body"] != None):
self.write(str(outJson["body"]))
```
Взглянем на это все со стороны вызываемого скрипта. Пара методов для генерации ответа:
```
AsJson[input_] := ExportString[Normal @ input, "JSON"]
HTTPOut[code_, body_, reason_] :=
<|"code"->code, "body"->body, "reason"->reason, "file"->Null|>
HTTPOutFile[expression_, exportType_, contentType_] :=
Module[{filePath = FileNameJoin[{$TemporaryDirectory, "httpOutFile"}]},
Export[filePath, expression, exportType];
<|"code"->200,
"body"->Null,
"reason"->Null,
"file"->filePath,
"contentType"->contentType|>
]
```
Наконец, напишем обработчики конкретных методов.
```
HTTPGet[arguments_, headers_] := AsJson[...]
Switch[method,
"GET", HTTPGet[arguments, headers],
"POST", HTTPPost[arguments, headers, body]]
```
Таким образом, появляются методы HTTPGet, HTTPost и аналогичные. Настало время для создания бизнес-логики. Можно создать обработчики для различных путей (“/“, “/SomeEndpoint” и т.д.), но вместо этого мы добавим к вызову аргумент, который будет определять вызываемую функцию: “/?op=MyFunction”.
Осталось только добавить логику выбора и вызова этой функции в нашем скрипте. Используем [ToExpression[]](http://reference.wolfram.com/language/ref/ToExpression.html?q=ToExpression).
```
HTTPGet[arguments_, headers_] :=
Module[{methodName = "GET"<>arguments["op"]},
AsJson[ToExpression[methodName][arguments, headers]]
]
```
Теперь можно просто добавить функцию GETMyFuction и первая единица бизнес-логики готова. Пусть эта функция выводит текущее время:
```
GETMyFuction[arguments_, headers_] :=
HTTPOut[ToString[Now]]
```
Осталось привести пример вывода картинки. И раз уж мы не используем входные параметры, обозначим их безымянным [паттерном](http://reference.wolfram.com/language/guide/Patterns.html), который соответствует любому количеству элементов.
```
GETTestGraph[___] :=
Module[{},
out = Graph[{a -> e, a -> c, b -> c, a -> d, b->d, c->a}];
HTTPOutFile[out, "PNG", "image/png"]
]
```
Теперь, при открытии в браузере “.../?op=TestGraph” можно увидеть вот такую картинку:
На этом всё и удачного дня! | https://habr.com/ru/post/262983/ | null | ru | null |
# Мега-Учебник Flask, Часть 5: Вход пользователей
***Предисловие от переводчика.**
Переводом предыдущих частей этого руководства занимался [wiygn](https://habr.com/ru/users/wiygn/). С его согласия я продолжаю это дело.*
Это пятая статья в серии, где я описываю свой опыт написания веб-приложения на Python с использованием микрофреймворка Flask.
Цель данного руководства — разработать довольно функциональное приложение-микроблог, которое я за полным отсутствием оригинальности решил назвать microblog.
**Оглавление** [Часть 2: Шаблоны](http://habrahabr.ru/post/193260/)
[Часть 3: Формы](http://habrahabr.ru/post/194062/)
[Часть 4: База данных](http://habrahabr.ru/post/196810/)
[Часть 5: Вход пользователей](http://habrahabr.ru/post/222983/) *(данная статья)*
[Часть 6: Страница профиля и аватары](http://habrahabr.ru/post/223375/)
[Часть 7: Unit-тестирование](http://habrahabr.ru/post/223783/)
[Часть 8: Подписчики, контакты и друзья](http://habrahabr.ru/post/230643/)
[Часть 9: Пагинация](http://habrahabr.ru/post/230897/)
[Часть 10: Полнотекстовый поиск](http://habrahabr.ru/post/234613/)
[Часть 11: Поддержка e-mail](http://habrahabr.ru/post/234737/)
[Часть 12: Реконструкция](http://habrahabr.ru/post/234785/)
[Часть 13: Дата и время](http://habrahabr.ru/post/236753/)
[Часть 14: I18n and L10n](http://habrahabr.ru/post/236861/)
[Часть 15: Ajax](http://habrahabr.ru/post/237065/)
[Часть 16: Отладка, тестирование и профилирование](http://habrahabr.ru/post/237317/)
[Часть 17: Развертывание на Linux (и даже на Raspberry Pi!)](http://habrahabr.ru/post/237489/)
[Часть 18: Развертывание на Heroku Cloud](http://habrahabr.ru/post/237517/)
#### Краткое повторение
В предыдущей части мы создали базу данных и научились заполнять её пользователями и постами, однако этот функционал еще не реализован в нашем приложении. Две главы назад мы узнали, как создавать веб-формы и создали форму для авторизации.
В этой статье мы объединим наши знания о веб-формах и базах данных и напишем свою систему для входа пользователей. В конце данного руководства наше небольшое приложение будет регистрировать новых пользователей и проводить их авторизацию.
Для работы с этой главой ваше приложение должно быть таким, каким мы оставили его в конце предыдущей главы. Пожалуйста, убедитесь, что приложение установлено и работает.
#### Конфигурация
Как и в предыдущих главах, мы начнём с настройки расширений, которые будем использовать. Для авторизации нам понадобятся два расширения — Flask-Login и Flask-OpenID. Настроим их следующим образом *(файл `app/__init__.py`)*:
```
import os
from flask.ext.login import LoginManager
from flask.ext.openid import OpenID
from config import basedir
lm = LoginManager()
lm.init_app(app)
oid = OpenID(app, os.path.join(basedir, 'tmp'))
```
Расширению Flask-OpenID нужно где-то хранить свои временные файлы, для этого при инициализации ему передаётся путь до папки `tmp`.
#### Функция представления авторизации
Давайте обновим нашу функцию представления *(файл `app/views.py`*):
```
from flask import render_template, flash, redirect, session, url_for, request, g
from flask.ext.login import login_user, logout_user, current_user, login_required
from app import app, db, lm, oid
from forms import LoginForm
from models import User, ROLE_USER, ROLE_ADMIN
@app.route('/login', methods = ['GET', 'POST'])
@oid.loginhandler
def login():
if g.user is not None and g.user.is_authenticated():
return redirect(url_for('index'))
form = LoginForm()
if form.validate_on_submit():
session['remember_me'] = form.remember_me.data
return oid.try_login(form.openid.data, ask_for = ['nickname', 'email'])
return render_template('login.html',
title = 'Sign In',
form = form,
providers = app.config['OPENID_PROVIDERS'])
```
Обратите внимание, мы импортировали несколько новых модулей, некоторые из которых будут использованы позднее.
Отличий от предыдущей версии немного. Мы добавили новый декоратор для функции отображения. Благодаря `oid.loginhandler Flask-OpenID` теперь знает, что это — функция для авторизации.
`g` — это глобальный объект Flask, предназначенный для хранения и обмена данными во время жизни запроса. Именно в нём мы будем хранить данные о текущем пользователе. В верхней части тела функции мы проверяем значение `g.user`. Если пользователь уже авторизован, мы перенаправляем его на главную страницу. Бессмысленно пытаться еще раз проводить авторизацию в этом случае.
Функция `url_for`, которую мы использовали при вызове `redirect`, предоставляет возможность получения `URL` для переданного ей имени функции представления. Вы, конечно же, можете использовать `redirect('/index')`, однако есть [весьма веские причины](http://flask.pocoo.org/docs/quickstart/#url-building) поручить построение `URL` специально предназначенной для этого функции.
Мы также обновили код, обрабатывающий данные полученные из формы авторизации. Здесь мы делаем две вещи. Во-первых, мы сохраняем значение поля `remember_me` в *сессии* Flask (не путайте с `db.session` — сессией, предоставленной расширением Flask-SQLAlchemy). Как было сказано выше, объект `flask.g` может хранить данные только во время жизни запроса. В то время как `flask.session` является более сложным хранилищем. Данные, сохраненные в сессии, будут также доступны во время всех последующих запросов *от одного клиента*. Информация хранится до тех пор, пока не будет явно удалена. Такое поведение возможно благодаря тому, что Flask хранит отдельные сессии для *каждого* клиента.
Вызов `oid.try_login` запускает процесс авторизации с помощью Flask-OpenID. Эта функция принимает два аргумента: `openid`, полученный из веб-формы и список полей, которые мы хотели бы получить от провайдера OpenID. Так как наша модель `User` имеет атрибуты `nickname` и `email`, именно эти данные мы и будем запрашивать.
Аутентификация через OpenID проводится асинхронно. Если получен положительный ответ от провайдера, Flask-OpenID вызовет функцию, объявленную с помощью декоратора `oid.after_login`. В противном случае пользователь снова вернётся на страницу авторизации.
#### Обработка ответа от провайдера OpenID
Так выглядит реализация функции `after_login` *(файл `app/views.py`)*:
```
@oid.after_login
def after_login(resp):
if resp.email is None or resp.email == "":
flash('Invalid login. Please try again.')
return redirect(url_for('login'))
user = User.query.filter_by(email = resp.email).first()
if user is None:
nickname = resp.nickname
if nickname is None or nickname == "":
nickname = resp.email.split('@')[0]
user = User(nickname = nickname, email = resp.email, role = ROLE_USER)
db.session.add(user)
db.session.commit()
remember_me = False
if 'remember_me' in session:
remember_me = session['remember_me']
session.pop('remember_me', None)
login_user(user, remember = remember_me)
return redirect(request.args.get('next') or url_for('index'))
```
Аргумент `resp`, переданный функции `after_login` содержит в себе данные, полученные от провайдера OpenID.
В первую очередь нам необходимо проверить, что в ответе от сервера содержится email пользователя, в противном случае мы не можем его авторизовать. Проверяем, содержится ли полученный email в нашей базе данных. Если ничего не найдено, добавляем нового пользователя в базу. Стоит отметить, что некоторые провайдеры OpenID не предоставляют `nickname`, но для нас это не является проблемой, мы можем использовать имя из почты.
После этого мы пытаемся получить значение `remember_me` из сессии Flask, это то самое значение, которое мы сохранили в функции представления `login`.
Затем мы вызываем функцию `login_user` из модуля Flask-Login, чтобы наконец авторизовать пользователя в нашем приложении.
В конце концов мы перенаправляем пользователя по адресу, переданному в атрибуте `next`, или же на главную страницу, если такой параметр в запросе отсутствует. Идея параметра `next` весьма проста. Допустим, вы хотите сделать некоторые страницы доступными для просмотра только авторизованным пользователям. С помощью Flask-Login такие страницы могут быть обозначены с помощью декоратора `login_required`. Если анонимный пользователь попытается открыть такую страницу, он будет автоматически перенаправлен на страницу авторизации, при этом Flask-Login сохранит `URL` исходной страницы в параметре `next`. Нам останется только отправить пользователя по этому адресу после того, как авторизация будет пройдена.
Для того, чтобы Flask-Login знал куда отправлять пользователей для авторизации, мы должны сообщить ему об этом при инициализации *(файл `app/__init__.py`)*:
```
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
```
#### Глобальный объект g.user
В функции представления `login` мы проверяли состояние `g.user`, для того, чтобы определить, не является ли текущий пользователь *уже* авторизованным. Чтобы это работало, мы используем событие Flask `before_request`. Все функции, объявленные с помощью декоратора `before_request` будут запущены непосредственно перед вызовом функции отображения каждый раз, когда получен запрос. Таким образом, вполне логичным будет устанавливать значение `g.user` именно здесь *(файл `app/views.py`)*:
```
@app.before_request
def before_request():
g.user = current_user
```
Это всё, что нам нужно. Flask-Login предоставляет нам доступ к переменной `current_user`, мы просто копируем в `g` ссылку на это значение, для удобства дальнейшего использования. Теперь текущий пользователь будет доступен везде, даже внутри шаблонов.
#### Отображение главной страницы
В предыдущей главе мы использовали в функции `index` объекты-заглушки, так как у нас еще не было настоящих пользователей и постов. Теперь у нас есть пользователи, самое время это использовать:
```
@app.route('/')
@app.route('/index')
@login_required
def index():
user = g.user
posts = [
{
'author': { 'nickname': 'John' },
'body': 'Beautiful day in Portland!'
},
{
'author': { 'nickname': 'Susan' },
'body': 'The Avengers movie was so cool!'
}
]
return render_template('index.html',
title = 'Home',
user = user,
posts = posts)
```
Мы сделали всего два изменения в этой функции. Во-первых, был добавлен декоратор `login_required`. Отныне мы можем быть уверены, что эту страницу увидят только зарегистрированные пользователи.
Во-вторых, мы передаём в шаблон непосредственно объект `g.user` вместо заглушки, используемой ранее.
Самое время запустить приложение.
Когда вы перейдете по адресу `http://localhost:5000`, вместо главной страницы вы увидите страницу для входа. Авторизация с помощью OpenID проходит с помощью `URL`, предоставляемого провайдером. Чтобы не вводить адрес вручную, можно использовать одну из ссылок под текстовым полем.
В процессе авторизации вы будете перенаправлены на сайт провайдера, на котором будет необходимо войти в систему и дать своё разрешение на передачу некоторой информации вашему приложению. При этом будут переданы только те параметры, которые мы запросили, т.е. адрес почты и ник. Никакую приватную информацию, включая пароли, провайдеры OpenID не сообщают.
После этого вы окажетесь на главной странице, теперь уже в качестве авторизованного пользователя.
Можете также поэкспериментировать с флагом `remember_me`. Если его включить, вы будете оставаться в системе даже после того, как закроете браузер и откроете его снова.
#### Выход из системы
Мы реализовали вход, самое время добавить возможность выхода из системы. Это делается очень просто *(файл `app/views.py`)*:
```
@app.route('/logout')
def logout():
logout_user()
return redirect(url_for('index'))
```
Помимо этого нам необходимо добавить соответствующую ссылку в шаблон. Расположим её вверху страницы, рядом с другими навигационными ссылками *(файл `app/templates/base.html`)*:
```
{% if title %}
{{title}} - microblog
{% else %}
microblog
{% endif %}
Microblog:
[Home]({{ url_for('index') }})
{% if g.user.is\_authenticated() %}
| [Logout]({{ url_for('logout') }})
{% endif %}
---
{% with messages = get\_flashed\_messages() %}
{% if messages %}
{% for message in messages %}
* {{ message }}
{% endfor %}
{% endif %}
{% endwith %}
{% block content %}{% endblock %}
```
Видите, насколько это просто! Нам всего лишь надо проверить содержимое `g.user`, и если текущий пользователь авторизован, добавить ссылку для выхода. Не забывайте, что вместо прямых адресов лучше использовать `url_for` в таких случаях..
#### Заключительные слова
Теперь у нас есть полноценная система для авторизации пользователей. В следующей главе мы создадим страницу профиля пользователя, и добавим возможность использования аватаров.
Для экономии времени вы можете воспользоваться ссылкой и скачать код приложения, включающий в себя все изменения из данной статьи:
Скачать [microblog-0.5.zip](https://github.com/miguelgrinberg/microblog/archive/v0.5.zip)
До новых встреч!
Мигель | https://habr.com/ru/post/222983/ | null | ru | null |
# Django и особенности использования транзакций в MySQL
Наверное всем известно, что Django является одним из самых популярных фреймворков для web-разработки на python-е. И даже если в основе web-проекта лежит сторонний код, то зачастую при разработке используют отдельные части этого фреймворка — например ORM. В данной статье я хотел бы рассказать об особенностях использования Django ORM при работе с базой данных MySQL, а именно про транзакции и подводные камни, связанные с ними. Так, например, если в какой-то момент вы осознаёте, что вместо ожидаемых данных, возвращается совершенно другой результат, то возможно, данная статья поможет разобраться что к чему.
Далее речь пойдет про InnoDB, поскольку это единственный движок, идущий в составе MySQL и полноценно поддерживающий транзакции (BDB не в счёт, так как давно уже не поддерживается).
Стоит отметить ряд особенностей:
**1.** В Django в качестве интерфейса к MySQL используется расширение **MySQLdb**, а оно в свою очередь при каждом подключении к базе [устанавливает](http://mysql-python.sourceforge.net/FAQ.html#my-data-disappeared-or-won-t-go-away):
```
AUTOCOMMIT=0
```
То есть каждая операция изменения данных должна завершаться COMMIT/ROLLBACK для фиксации или отката изменений. Если вы раньше использовали расширения PHP (PDO, Mysqli) или Ruby для доступа к MySQL, то наверное будете немного удивлены, поскольку практически во всех драйверах доступа к БД при подключении значение **AUTOCOMMIT** не меняется (а по умолчанию в MySQL оно задано как **AUTOCOMMIT=1**).
**2.** MySQL использует уровень изоляции транзакций **REPEATABLE-READ**, в отличии, например, от PosgreSQL или Oracle, в которых уровень изоляции транзакий по умолчанию **READ-COMMITTED**.
Что это значит? Рассмотрим на конкретном примере:
```
CREATE TABLE IF NOT EXISTS `test` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`value` varchar(255) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO `test` VALUES (NULL, 'a');
```
###### REPEATABLE-READ
| 1ая транзакция: | 2ая транзакция: |
| --- | --- |
| SET AUTOCOMMIT=0; | SET AUTOCOMMIT=0; |
| SELECT \* FROM `test`;
```
+----+-------+
| id | value |
+----+-------+
| 1 | a |
+----+-------+
```
| |
| | INSERT INTO `test` VALUES (NULL, 'b');
SELECT \* FROM `test`;
```
+----+-------+
| id | value |
+----+-------+
| 1 | a |
| 2 | b |
+----+-------+
```
COMMIT; |
| INSERT INTO `test` VALUES (NULL, 'c');
SELECT \* FROM `test`;
```
+----+-------+
| id | value |
+----+-------+
| 1 | a |
| 3 | c |
+----+-------+
```
COMMIT; | |
Как видно из примера, в первой транзакции после первого чтения данных все последующие чтения будут возвращать точно такой же результат до того момента, пока не произойдет **COMMIT**, независимо от того что происходит в других транзакциях.
###### READ-COMMITTED
| 1ая транзакция: | 2ая транзакция: |
| --- | --- |
| SET SESSION tx\_isolation='READ-COMMITTED';
SET AUTOCOMMIT=0; | SET SESSION tx\_isolation='READ-COMMITTED';
SET AUTOCOMMIT=0; |
| SELECT \* FROM `test`;
```
+----+-------+
| id | value |
+----+-------+
| 1 | a |
+----+-------+
```
| |
| | INSERT INTO `test` VALUES (NULL, 'b'); |
| SELECT \* FROM `test`;
```
+----+-------+
| id | value |
+----+-------+
| 1 | a |
+----+-------+
```
| |
| | SELECT \* FROM `test`;
```
+----+-------+
| id | value |
+----+-------+
| 1 | a |
| 2 | b |
+----+-------+
```
COMMIT; |
| INSERT INTO `test` VALUES (NULL, 'c');
SELECT \* FROM `test`;
```
+----+-------+
| id | value |
+----+-------+
| 1 | a |
| 2 | b |
| 3 | c |
+----+-------+
```
COMMIT; | |
В случае READ-COMMITTED выборка SELECT всегда возвращает последнюю закоммиченную версию данных.
Возвращаясь к теме Django — подвох в использовании Django ORM состоит в том, что судя по всему READ-COMMITTED единственный уровень изоляции транзакций, на который ориентировались разработчики. Так, например, если мы обратимся к коду Django, а именно к реализации метода **get\_or\_create()** в классе **QuerySet**:
```
def get_or_create(self, **kwargs):
"""
Looks up an object with the given kwargs, creating one if necessary.
Returns a tuple of (object, created), where created is a boolean
specifying whether an object was created.
"""
assert kwargs, \
'get_or_create() must be passed at least one keyword argument'
defaults = kwargs.pop('defaults', {})
lookup = kwargs.copy()
for f in self.model._meta.fields:
if f.attname in lookup:
lookup[f.name] = lookup.pop(f.attname)
try:
self._for_write = True
return self.get(**lookup), False
except self.model.DoesNotExist:
try:
params = dict([(k, v) for k, v in kwargs.items() if '__' not in k])
params.update(defaults)
obj = self.model(**params)
sid = transaction.savepoint(using=self.db)
obj.save(force_insert=True, using=self.db)
transaction.savepoint_commit(sid, using=self.db)
return obj, True
except IntegrityError, e:
transaction.savepoint_rollback(sid, using=self.db)
exc_info = sys.exc_info()
try:
return self.get(**lookup), False
except self.model.DoesNotExist:
# Re-raise the IntegrityError with its original traceback.
raise exc_info[1], None, exc_info[2]
```
то вторая попытка извлечения объекта:
```
return self.get(**lookup), False
```
всегда будет завершаться с ошибкой.
Попытаюсь пояснить — вот, например, два процесса одновременно вызывают метод **get\_or\_create()** некой модели. 1ый процесс пытается прочитать данные — данных нет, генерируется исключение **DoesNotExist**. 2ой процесс аналогично пытается прочитать данные и аналогично генерирует исключение **DoesNotExist**. Далее, поскольку в рамках соединения используется AUTOCOMMIT=0 и уровень изоляции транзакций REPEATABLE-READ, оба процесса «замораживают» прочитанные данные. Допустим, пусть первый процесс успешно создает запись и возвращает объект созданной записи. Но при этом второй процесс не может ничего создать, так как это будет нарушать ограничение уникальности. Забавно то, что он не видит объект, созданный в первом процессе, в связи с тем, что при повторном чтении данных возвращается «замороженный» результат.
Конечно, в экспериментальных условиях данную ошибку воспроизвести довольно проблематично, но при многочисленных конкурентных запросах, данный код будет работать нестабильно, периодически генерируя исключение **DoesNotExist**.
Как с этим бороться?
**1.** В случае использования метода **get\_or\_create()** — написать свой метод, выполняющий принудительный COMMIT перед повторным чтением данных:
```
@transaction.commit_manually()
def custom_get_or_create(...):
try:
obj = SomeModel.objects.create(...)
except IntegrityError:
transaction.commit()
obj = SomeModel.objects.get(...)
return obj
```
**2.** В настройках MySQL ( /etc/mysql/my.cnf ) использовать принудительно уровень изоляции транзакций READ-COMMITTED:
```
transaction-isolation = READ-COMMITTED
```
**3.** При использовании Django >= 1.2 версии использовать в settings.py в опциях подключения к базе следующий код:
```
DATABASE_OPTIONS = {
"init_command": "SET storage_engine=INNODB, SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED",
}
```
Данный баг [опубликован на багтрекере](http://code.djangoproject.com/ticket/13906) Django достаточно давно, но до сих пор тикет не закрыт и проблема по-прежнему актуальна.
Или вот ещё пример — допустим Django ORM используется отдельно от веб-сервера, в рамках некоего демона, который постоянно висит в памяти, и периодически считывает новые данные из таблицы MySQL. Данный эксперимент можно провести используя встроенный shell в Django:
```
python manage.py shell
>>> from test_module.models import *
>>> len(SomeModel.objects.all())
10
```
Далее используя второй терминал добавим несколько записей:
```
>>> SomeModel(name='test1').save()
>>> SomeModel(name='test2').save()
>>> len(SomeModel.objects.all())
12
```
И хотя во втором терминале изменения налицо, но эти новодобавленные записи в первом терминале по прежнему будут недоступны, т.к. начатая транзакция не завершена, и после первого чтения данных все последующие чтения будут возвращать один и и тот же результат до тех пор, пока принудительно не будет вызван COMMIT.
Что с этим делать? Менять уровень изоляции транзакций в настройках mysql (my.cnf) или же в параметрах подключения к базе данных в settings.py в Django. Ну или же принудительно коммитить данные после каждого чтения:
```
>>> from django.db import connection, transaction
>>> len(Param_Type.objects.all())
10
>>> transaction.commit_unless_managed()
>>> len(Param_Type.objects.all())
12
```
Почему все так происходит? Возможно это связано с тем, что Django изначально проектировался для работы с использованием PostgreSQL в качестве базы данных, в котором, как писалось выше, «из коробки» используется READ-COMMITTED. В общем, данное не совсем стандартное поведение Django ORM применительно к MySQL InnoDB может привести к довольно-таки трудноотлавливаемым багам. Поэтому в большинстве мест, где обсуждается описанная проблема (в различных блогах и на stackoverflow), настойчиво рекомендуют использовать READ-COMMITTED как уровень изоляции транзакций по умолчанию, аргументируя этот выбор ещё и тем, что READ-COMMITTED [«производительнее»](http://www.mysqlperformanceblog.com/2010/02/11/read-commited-vs-repetable-read-in-tpcc-like-load/) чем REPEATABLE-READ. | https://habr.com/ru/post/144161/ | null | ru | null |
# Multiprocessing и реконсиляция данных из различных источников
Привет, Хабр!
В условиях многообразия распределенных систем, наличие выверенной информации в целевом хранилище является важным критерием непротиворечивости данных.
На этот счет существует немало подходов и методик, а мы остановимся на реконсиляции, теоретические аспекты которой были затронуты [вот в этой статье.](https://habr.com/ru/post/428443/) Предлагаю рассмотреть практическую реализацию данной системы, масштабируемой и адаптированной под большой объем данных.
Как реализовать этот кейс на старом-добром Python — читаем под катом! Поехали!
[(Источник картинки)](https://www.megapixl.com/alexdobysh-stock-images-videos-portfolio)
Введение
--------
Давайте представим, что финансовая организация имеет несколько распределенных систем и перед нами стоит задача сверить транзакции в этих системах и загрузить сверенные данные в целевое хранилище.
В качестве источника данных возьмем большой текстовый файл и таблицу в базе данных PostgreSQL. Предположим, что данные, находящиеся в этих источниках, имеют одни и те же транзакции, но при этом могут иметь различия, и поэтому их необходимо сверить и записать выверенные данные в конечное хранилище для анализа.
Дополнительно необходимо предусмотреть параллельный запуск нескольких реконсиляций на одной базе данных и адаптировать систему под большой объем, применив multiprocessing.
Модуль [multiprocessing](https://docs.python.org/dev/library/multiprocessing.html) отлично подходит для распараллеливания операций в Python и позволяет в некотором смысле обходить определенные недостатки GIL. Возможностями данной библиотеки воспользуемся далее.
Архитектура разрабатываемой системы
-----------------------------------
Используемые компоненты:
* **Генератор случайных данных** – Python-скрипт, формирующий CSV файл и на его основе заполняющий таблицу в базе данных;
* **Источники данных** – CSV-файл и таблица в БД PostgreSQL;
* **Адаптеры** – в данном случае используем два адаптера, которые будут извлекать данные из своих источников (CSV или БД) и заносить информацию в промежуточную БД;
* **Базы данных** – в количестве трех штук: сырые данные, промежуточная БД, хранящая информацию снятую адаптерами, и «чистая» база данных, содержащая в себе сверенные транзакции из обоих источников.
Начальная подготовка
--------------------
В качестве инструмента хранения данных будем использовать [БД PostgreSQL в Docker-контейнере](https://hub.docker.com/_/postgres) и взаимодействовать с нашей базой данных через [pgAdmin, запущенном в контейнере](https://hub.docker.com/r/dpage/pgadmin4/):
```
docker run --name pg -d -e "POSTGRES_USER=my_user" -e "POSTGRES_PASSWORD=my_password" postgres
```
Запуск pgAdmin:
```
docker run -p 80:80 -e "PGADMIN_DEFAULT_EMAIL=user@domain.com" -e "PGADMIN_DEFAULT_PASSWORD=12345" -d dpage/pgadmin4
```
После того, как все запустилось, не забудем указать в конфигурационном файле (conf/db.ini) строку подключения к БД (для учебного примера так можно!):
```
[POSTGRESQL]
db_url=postgresql://my_user:my_password@172.17.0.2:5432/my_user
```
В принципе, использование контейнера не является обязательным и Вы можете использовать свой сервер БД.
Генерация входных данных
------------------------
За генерацию тестовых данных отвечает Python-скрипт **generate\_test\_data**, который принимает на вход желаемое количество записей для генерации. Последовательность операции легко проследить по основной функции класса **GenerateTestData**:
```
@m.timing
def run(self, num_rows):
""" Run the process """
m.info('START!')
self.create_db_schema()
self.create_folder('data')
self.create_csv_file(num_rows)
self.bulk_copy_to_db()
self.random_delete_rows()
self.random_update_rows()
m.info('END!')
```
Итак, функция выполняет следующие шаги:
* Создание схем в БД (создаем все основные схемы и таблицы);
* Создание папки для хранения тестового файла;
* Генерация тестового файла с заданным количеством строк;
* Bulk-insert данных в целевую таблицу transaction\_db\_raw.transaction\_log;
* Случайное удаление нескольких строк в этой таблице;
* Случайное обновление нескольких строк в этой таблице.
Удаление и внесение изменений необходимо для того, чтобы сравниваемые объекты имели хоть какое-то расхождение. Важно уметь искать эти расхождения!
```
@m.timing
@m.wrapper(m.entering, m.exiting)
def random_delete_rows(self):
""" Random deleting some rows from the table """
sql_command = sql.SQL("""
delete from {0}.{1}
where ctid = any(array(
select ctid
from {0}.{1}
tablesample bernoulli (1)
))""").format(sql.Identifier(self.schema_raw),
sql.Identifier(self.raw_table_name))
try:
rows = self.database.execute(sql_command)
m.info('Has been deleted [%s rows] from table %s' % (rows, self.raw_table_name))
except psycopg2.Error as err:
m.error('Oops! Delete random rows has been FAILED. Reason: %s' % err.pgerror)
@m.timing
@m.wrapper(m.entering, m.exiting)
def random_update_rows(self):
""" Random update some rows from the table """
sql_command = sql.SQL("""
update {0}.{1}
set transaction_amount = round(random()::numeric, 2)
where ctid = any(array(
select ctid
from {0}.{1}
tablesample bernoulli (1) ))""").format(sql.Identifier(self.schema_raw),
sql.Identifier(self.raw_table_name))
try:
rows = self.database.execute(sql_command)
m.info('Has been updated [%s rows] from table %s' % (rows, self.raw_table_name))
except psycopg2.Error as err:
m.error('Oops! Delete random rows has been FAILED. Reason: %s' % err.pgerror)
```
Генерация тестового набора данных и последующая запись в текстовой файл формате CSV происходит следующим образом:
* Создается случайный UID транзакции;
* Создается случайный UID номер счета (по умолчанию, берем десять уникальных счетов, но это значение можно изменить с помощью конфигурационного файла, поменяв параметр «random\_accounts»);
* Дата транзакции – рандомная дата от заданной в конфиге даты (initial\_date);
* Тип операции (сделка / комиссия);
* Сумма транзакции;
* Основную работу в генерации данных выполняет метод *generate\_test\_data\_by\_chunk* класса **TestDataCreator**:
```
@m.timing
def generate_test_data_by_chunk(self, chunk_start, chunk_end):
""" Generating and saving to the file """
num_rows_mp = chunk_end - chunk_start
new_rows = []
for _ in range(num_rows_mp):
transaction_uid = uuid.uuid4()
account_uid = choice(self.list_acc)
transaction_date = (self.get_random_date(self.date_in, 0)
.__next__()
.strftime('%Y-%m-%d %H:%M:%S'))
type_deal = choice(self.list_type_deal)
transaction_amount = randint(-1000, 1000)
new_rows.append([transaction_uid,
account_uid,
transaction_date,
type_deal,
transaction_amount])
self.write_in_file(new_rows, chunk_start, chunk_end)
```
> Особенность данной функции — запуск в нескольких распараллеленных асинхронных процессах, каждый из которых генерит свою порцию из 50К записей. Эта «фишка» позволит формировать файл на несколько миллионов строк достаточно быстро
```
def run_csv_writing(self):
""" Writing the test data into csv file """
pool = mp.Pool(mp.cpu_count())
jobs = []
for chunk_start, chunk_end in self.divide_into_chunks(0, self.num_rows):
jobs.append(pool.apply_async(self.generate_test_data_by_chunk,
(chunk_start, chunk_end)))
# wait for all jobs to finish
for job in jobs:
job.get()
# clean up
pool.close()
pool.join()
```
После того, как завершится заполнение текстового файла, отрабатывается команда bulk\_insert и все данные из этого файла попадают в таблицу **transaction\_db\_raw.transaction\_log.**
Далее, в двух источниках будут содержаться совершенно одинаковые данные и реконсиляция не найдет ничего интересного, поэтому удаляем и изменяем несколько случайных строк в базе данных.
Запускаем скрипт и генерим тестовый CSV-файл с транзакциями на 10К строк:
```
./generate_test_data.py 10000
```
На скриншоте видно, что получен файл на 10К строк, в БД загружено 10К, но затем из базы данных было удалено 112 строк и изменено еще 108. Итог: файл и таблица в БД отличаются между собой на 220 записей.
«Ну и где тут мультипроцессинг?», — спросите вы.
А его работу можно увидеть, когда будете генерить файл побольше, не на 10К записей, а, к примеру, на 1M. Попробуем?
```
./generate_test_data.py 1000000
```
После загрузки данных, удаления и изменения случайных записей, видим отличия текстового файла от таблицы: 19 939 строки (из них 10 022 удалено случайным образом, а 9 917 изменено).
> На картинке видно, что генерация записей шла асинхронно, непоследовательно. Это означает, что следующий процесс может начаться без учета порядка запуска как только предыдущий завершится. Нет гарантии, что результат окажется в том же порядке, что и входные данные.
**А это точно быстрее?**Один миллион строк не на самой быстрой виртуальной машине был «придуман» за 15.5 секунд — и это достойный вариант. Запустив эту же генерацию последовательно, без использования мультипроцессинга, я получил результат: генерация файла шла медленнее более чем в три раза (свыше 52 секунд вместо 15,5):
Адаптер для CSV
---------------
Этот адаптер хэширует строку, оставляя без изменения только первый столбец – идентификатор транзакции и сохраняет полученные данные в файл *data/ transaction\_hashed.csv*. Финальным шагом его работы является загрузка этого файла при помощи команды COPY во временную таблицу схемы **reconciliation\_db.**
Оптимальное чтение файла выполняется несколькими параллельными процессами. Читаем построчно, кусками по 5 мегабайт каждый. Цифра «5 мегабайт» была получена эмпирическим методом. Именно при таком размере одного фрагмента текста, удалось получить наименьшее время чтения больших файлов на своей виртуальной машине. Можно поэкспериментировать на своем окружении с данным параметром и посмотреть, как будет меняться время работы:
```
@m.timing
def process_wrapper(self, chunk_start, chunk_size):
""" Read a particular chunk """
with open(self.file_name_raw, newline='\n') as file:
file.seek(chunk_start)
lines = file.read(chunk_size).splitlines()
for line in lines:
self.process(line)
def chunkify(self, size=1024*1024*5):
""" Return a new chunk """
with open(self.file_name_raw, 'rb') as file:
chunk_end = file.tell()
while True:
chunk_start = chunk_end
file.seek(size, 1)
file.readline()
chunk_end = file.tell()
if chunk_end > self.file_end:
chunk_end = self.file_end
yield chunk_start, chunk_end - chunk_start
break
else:
yield chunk_start, chunk_end - chunk_start
@m.timing
def run_reading(self):
""" The main method for the reading """
# init objects
pool = mp.Pool(mp.cpu_count())
jobs = []
m.info('Run csv reading...')
# create jobs
for chunk_start, chunk_size in self.chunkify():
jobs.append(pool.apply_async(self.process_wrapper,
(chunk_start, chunk_size)))
# wait for all jobs to finish
for job in jobs:
job.get()
# clean up
pool.close()
pool.join()
m.info('CSV file reading has been completed')
```
Пример чтения созданного ранее файла на 1М записей:
На скриншоте показано создание временной таблицы с уникальным именем для текущего запуска реконсиляции. Далее идет асинхронное чтение файла по частям и взятие хэша каждой строки. Вставка данных от адаптера в целевую таблицу завершает работу с данным адаптером.
> Использование временной таблицы с уникальным именем для каждого процесса реконсиляции позволяет дополнительно распараллеливать процесс сверки в одной базе данных.
Адаптер для PostgreSQL
----------------------
Адаптер для обработки данных, хранящихся в таблице работает примерно по той же логике, что и адаптер для файла:
* чтение по частям таблицы (если она большая, свыше 100К записей) и взятие хэша по всем столбцам, кроме идентификатора транзакции;
* затем идет вставка обработанных данных в таблицу **reconciliation\_db. storage\_$(int(time.time())**.
Интересной особенностью данного адаптера является то, что он использует пул коннектов к базе данных, которые будут искать по индексу необходимые данные в таблице и обрабатывать их.
Исходя из размеров таблицы, происходит вычисление количества процессов, необходимых для обработки и внутри каждого процесса идет деление на 10 задач.
```
def read_data(self):
"""
Read the data from the postgres and shared those records with each
processor to perform their operation using threads
"""
threads_array = self.get_threads(0,
self.max_id_num_row,
self.pid_max)
for pid in range(1, len(threads_array) + 1):
m.info('Process %s' % pid)
# Getting connection from the connection pool
select_conn = self._select_conn_pool.getconn()
select_conn.autocommit = 1
# Creating 10 process to perform the operation
process = Process(target=self.process_data,
args=(self.data_queque,
pid,
threads_array[pid-1][0],
threads_array[pid-1][1],
select_conn))
process.daemon = True
process.start()
process.join()
select_conn.close()
```
Поиск расхождений
-----------------
Переходим к сверке данных, полученных от двух адаптеров.
Сверка (или получение отчета о расхождениях) происходит на стороне сервера баз данных, используя всю мощь языка SQL.
SQL-запрос совсем нехитрый – это всего лишь джойн таблицы с данными от адаптеров самой на себя по идентификатору транзакции:
```
sql_command = sql.SQL("""
select
s1.adapter_name,
count(s1.transaction_uid) as tran_count
from {0}.{1} s1
full join {0}.{1} s2
on s2.transaction_uid = s1.transaction_uid
and s2.adapter_name != s1.adapter_name
and s2.hash = s1.hash
where s2.transaction_uid is null
group by s1.adapter_name;""").format(sql.Identifier(self.schema_target),
sql.Identifier(self.storage_table))
```
На выходе получаем отчет:
Проверим, все ли правильно на картинке выше. Мы помним, что из таблицы в БД было удалено 9917 и изменено 10 022 строк. Итого 19939 строк, что и видно в отчете.
Итоговая таблица
----------------
Осталось только вставить в таблицу-хранилище «чистые» транзакции, которые совпадают по всем параметрам (по хэшу) в разных адаптерах. Этот процесс выполним следующим SQL-запросом:
```
sql_command = sql.SQL("""
with reconcil_data as (
select
s1.transaction_uid
from {0}.{1} s1
join {0}.{1} s2
on s2.transaction_uid = s1.transaction_uid
and s2.adapter_name != s1.adapter_name
where s2.hash = s1.hash
and s1.adapter_name = 'postresql_adapter'
)
insert into {2}.transaction_log
select
t.transaction_uid,
t.account_uid,
t.transaction_date,
t.type_deal,
t.transaction_amount
from {3}.transaction_log t
join reconcil_data r
on t.transaction_uid = r.transaction_uid
where not exists
(
select 1
from {2}.transaction_log tl
where tl.transaction_uid = t.transaction_uid
)
""").format(sql.Identifier(self.schema_target),
sql.Identifier(self.storage_table),
sql.Identifier(self.schema_db_clean),
sql.Identifier(self.schema_raw))
```
Временную таблицу, которую мы использовали в качестве промежуточного хранения данных от адаптеров, можно удалить.
Заключение
----------
В ходе проделанной работы была разработана система реконсиляции данных из разных источников: текстовый файл и таблица в базе данных. Использовали минимум дополнительных инструментов.
Возможно, искушенный читатель может заметить, что использование фреймворков типа Apache Spark вкупе с приведением исходных данных к паркетному формату, может значительно ускорить данный процесс, особенно для огромных объемов. Но основная цель данной работы – написание системы на «голом» Python и изучение мультипроцессинговой обработки данных. С чем мы, на мой взгляд, справились.
Исходный код всего проекта лежит [в моем репозитории на GitHub](https://github.com/igorgorbenko/transact_reconciliation), предлагаю с ним ознакомиться.
С удовольствием отвечу на все вопросы и ознакомлюсь с вашими замечаниями.
Желаю успехов! | https://habr.com/ru/post/480076/ | null | ru | null |
# UNIX-подобные системы содержат кучу костылей. Крах «философии UNIX»
**UPD** от 2017-03-04: кто-то выполнил [английский перевод](https://kukuruku.co/post/the-collapse-of-the-unix-philosophy). [Обсуждение на Hacker News](https://news.ycombinator.com/item?id=13777077).
В первой части статьи перечислю кучу костылей UNIX, и вообще разных недостатков. Во второй — про «философию UNIX». Статья написана наскоро, «полировать» дальше не хочу, скажите спасибо, что написал. Поэтому многие факты привожу без ссылок.
Костыли в UNIX начали возникать ещё с момента появления UNIX, а это было ещё раньше появления не только Windows, но даже вроде бы Microsoft DOS (вроде бы, мне лень проверять, проверяйте сами). Если лень читать, хотя бы просмотрите все пункты, что-нибудь интересное найдёте. Это далеко не полный список, это просто те косяки, который я захотел упомянуть.
* В самом начале make был программой, которую один человек написал для себя и нескольких своих знакомых. Тогда он, недолго думая, сделал так, что командами воспринимаются строки, которые начинаются с Tab. Т. е. Tab воспринимался отлично от пробела, что крайне некрасиво и нетипично ни для UNIX, ни за его пределами. Он так сделал, потому что не думал, что make будет ещё кто-то использовать кроме этой небольшой группы. Потом появилась мысль, что make — хорошая вещь и неплохо бы включить его в стандартный комплект UNIX. И тогда *чтобы не сломать уже написанные мейкфайлы, т. е. написанные вот этими вот десятью людьми, он не стал ничего менять*. Ну вот так и живём… Из-за тех десятерых страдаем мы все.
* Почти в самом начале в UNIX не было папки /usr. Все бинарники размещались в /bin и /sbin. Но потом вся инфа перестала помещаться на тот диск, который был в распоряжении авторов UNIX (Томпсон, Ритчи). Поэтому они достали ещё один диск, создали папку /usr, а в ней — ещё один bin и ещё один sbin. И смонтировали новый диск в /usr. Оттуда и пошло. Так появилась «вторая иерархия» /usr, а потом в какой-то момент ещё и «третья иерархия» /usr/local, а потом ещё и /opt. Как пишет рассказчик этой истории: «Не удивлюсь, если когда-нибудь ещё появится /opt/local». **UPD** от 2017-02-12: я нашёл ссылку, где я почерпнул [эту историю](http://lists.busybox.net/pipermail/busybox/2010-December/074114.html). Читайте, там более точная версия произошедшего.
* sbin изначально означало «static bin», а не «superuser bin», как можно было бы подумать. И содержал sbin статические бинарники. Но потом sbin стал содержать динамические бинарники, его название потеряло смысл.
* Windows часто ругают за наличие реестра и сообщают при этом, что подход UNIX-подобных систем (куча конфигов) якобы лучше. А между прочим однажды в ext4 появилась особенность (является ли это багом, вопрос спорный), из-за которой при резком выключении компа Gnome потерял все свои конфиги в рабочей папке юзера. И разработчик этой ext4 сказал в обсуждении баг репорта, что Gnome'у надо было использовать что-то вроде реестра для хранения инфы.
**UPD** от 2017-02-12: источники: [раз](https://lwn.net/Articles/322823) и [два](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/317781). Имя отписавшегося maintainer'а ext4: Theodore Ts'o. Вот его слова:
> If you really care about making sure something is on disk, you have to use fsync or fdatasync. If you are about the performance overhead of fsync(), fdatasync() is much less heavyweight, if you can arrange to make sure that the size of the file doesn't change often. You can do that via a binary database, that is grown in chunks, and rarely truncated.
>
>
>
> I'll note that I use the GNOME desktop (which means the gnome panel, but I'm not a very major desktop user), and «find .[a-zA-Z]\* -mtime 0» doesn't show a large number of files. I'm guessing it's certain badly written applications which are creating the «hundreds of dot files» that people are reporting become zero lengh, and if they are seeing it happen a lot, it must be because the dot files are getting updated very frequently. I don't know what the bad applications are, but the people who complained about large number of state files disappearing should check into which application were involved, and try to figure out how often they are getting modified. As I said, if large number of files are getting frequently modified, it's going to be bad for SSD's as well, there are multiple reasons to fix badly written applications, even if 2.6.30 will have a fix for the most common cases. (Although some server folks may mount with a flag to disable it, since it will cost performance.)
>
>
И это не говоря уж о том, что критичные файлы UNIX (такие как /etc/passwd), которые читаются при каждом (!) вызове, скажем, ⟦`ls -l`⟧, записаны в виде простого текста. И эти файлы надо заново читать и заново парсить при каждом вызове ⟦`ls -l`⟧! Было бы гораздо лучше использовать бинарный формат. Или БД. Или некий аналог реестра. Как минимум, для вот таких вот критичных для производительности ОС файлов.
* > Two famous people, one from MIT and another from Berkeley (but working on Unix) once met to discuss operating system issues. The person from MIT was knowledgeable about ITS (the MIT AI Lab operating system) and had been reading the Unix sources. He was interested in how Unix solved the PC loser-ing problem. The PC loser-ing problem occurs when a user program invokes a system routine to perform a lengthy operation that might have significant state, such as IO buffers. If an interrupt occurs during the operation, the state of the user program must be saved. Because the invocation of the system routine is usually a single instruction, the PC of the user program does not adequately capture the state of the process. The system routine must either back out or press forward. The right thing is to back out and restore the user program PC to the instruction that invoked the system routine so that resumption of the user program after the interrupt, for example, re-enters the system routine. It is called «PC loser-ing» because the PC is being coerced into «loser mode,» where «loser» is the affectionate name for «user» at MIT.
>
>
>
> The MIT guy did not see any code that handled this case and asked the New Jersey guy how the problem was handled. The New Jersey guy said that the Unix folks were aware of the problem, but the solution was for the system routine to always finish, but sometimes an error code would be returned that signaled that the system routine had failed to complete its action. A correct user program, then, had to check the error code to determine whether to simply try the system routine again. The MIT guy did not like this solution because it was not the right thing.
>
>
>
> — [The Rise of «Worse is Better» By Richard Gabriel](http://doc.cat-v.org/programming/worse_is_better)
>
>
Если кратко и своими словами, то в начале разработки UNIX авторы UNIX решили попросту выдавать ошибку из ядра пользовательской программе, если пользовательская программа прервана по сигналу, и на этот сигнал повешен обработчик. Иными словами, если вы перехватили Ctrl-C (т. е. поставили на него обработчик) в своей программе, а юзер за терминалом нажал этот самый Ctrl-C, то ОС выполнит обработчик, а потом вместо простого продолжения того сисвызова, который выполнялся в момент Ctrl-C, просто прервёт его, вернув из ядра в пользовательскую программу EINTR. В результате программисту, пишущему эту программу придётся эту EINTR предусмотреть. А это усложняет этот userspace код. Ценой упрощения кода ядра. Да, нужно было сделать по-другому. Усложнить код ядра и упростить userspace код, который придётся писать всем программистам. Но тому человеку из Беркли из цитаты выше было пофигу. Он фактически сказал: «Да мне пофиг, что все будут страдать, главное, чтоб код ядра попроще был».
Дальше — больше. Позже в UNIX-системах всё же пофиксили упомянутую особенность, добавив так называемый SA\_RESTART. То есть вместо того, чтобы просто всё пофиксить, они добавили специальный флаг. Так мало того, что они это сделали, этот SA\_RESTART ещё и не всегда работает! В частности, в GNU/Linux select, poll, nanosleep и др. не продолжают свою работу после перехваченного прерывания даже в случае SA\_RESTART!
* Вообще, конкретные обстоятельства, возникшие во время разработки оригинальной UNIX, сильно оказали на неё влияние. Скажем, читал где-то, что команда cp названа именно так, а не copy, потому что UNIX разрабатывали с использованием терминалов, которые очень медленно выдавали буквы. А потому набрать cp было быстрее, чем copy. **UPD** от 2017-02-12: найти именно ту ссылку, которую я видел когда-то давно, и в которой приводился пример с cp и copy, мне не удалось. Но есть, например, вот [эта ссылка](http://catalogue.pearsoned.co.uk/samplechapter/0130213446.pdf).
> Commands — Are These Real Words?
>
>
>
> The basic AIX commands (and all UNIX system commands) are, for the most
>
> part, very short, cryptic, two-letter command names. Imagine back years ago,
>
> when computers had only very slow teletype keyboards and paper “displays.”
>
> (Some of us aren’t imagining, we’re remembering!) Imagine also, people who
>
> didn’t like typing long commands because there was such a long delay between
>
> commands and the computer response. If there were any mistakes, the user had
>
> to retype the whole thing (especially aggravating for folks that type with only
>
> two fingers!).
>
>
>
> Also, some UNIX commands came from university students and researchers who
>
> weren’t bound by usability standards (no rules, merely peer pressure). They
>
> could write a very useful, clever command and name it anything—their own initials,
>
> for example (awk by Aho, Weinberger, and Kernighan), or an acronym
>
> (yacc, Yet Another Compiler-Compiler).
>
>
* Вообще, названия утилит UNIX — это отдельная история. Скажем, название grep идёт от команды g/re/p в текстовом редакторе ed. (Ну а cat — от concatenation, я надеюсь, это все и так знали :) Ну и для кучи: vmlinuz — gZipped LINUx with Virtual Memory support).
* printf **внезапно** является далеко не самым быстрым способом вывода информации на экран или в файл. Не знали, да? А дело в том, что printf, как и сама UNIX в целом, был придуман не для оптимизации времени, а для оптимизации памяти. printf каждый раз парсит в рантайме строку формата. Именно поэтому в веб сервере H2O был придуман специальный препроцессор, который переносит парсинг строки формата на этап компиляции.
**UPD** от 2017-02-12: [источник](http://blog.kazuhooku.com/2014/10/announcing-qrintf-and-qrintf-gcc.html).
* Когда Кена Томпсона, автора UNIX (вместе с Деннисом Ритчи) спросили, что бы он поменял в UNIX, он сказал, что назвал бы функцию creat (sic!) как create. **UPD** от 2017-02-12: источников полно, например [этот](https://en.wikiquote.org/wiki/Ken_Thompson). No comments. Замечу, что позже этот же Кен Томпсон вместе с другими разработчиками оригинальной UNIX создал систему Plan 9, исправляющую многие недостатки UNIX. И в ней эта функция называется create :) Он смог :)
* Ещё одна цитата:
> A child which dies but is never waited for is not really gone in that it still consumes disk swap and system table space. This can make it impossible to create new processes. The bug can be noticed whenseveral & separators are given to the shell not followed by ancommand without an ampersand. Ordinarily things clean themselves upwhen an ordinary command is typed, but it is possible to get into asituation in which no commands are accepted, so no waits are done;the system is then hung.The fix, probably, is to have a new kind of fork which creates aprocess for which no wait is necessary (or possible); also to limit the number of active or inactive descendants allowed to a process.
>
>
>
> — [Источник](http://cm.bell-labs.com/cm/cs/who/dmr/man22.pdf)
>
>
Это цитата из очень раннего мануала UNIX. Уже тогда существование зомби-процессов признавалось багом. Но потом на этот баг попросту забили. Понятное дело, что гораздо позже эта проблема всё же была решена. Т. е. в современном GNU/Linux инструменты для убивания зомби-процессов всё же существуют. Но о них мало кто знает. Обычным kill'ом зомби не убиваются. Про существование зомби-процессов все говорят: «It's for design».
* Ещё немного про уже упомянутый язык C. Вообще язык C разрабатывался одновременно с UNIX, поэтому критикуя UNIX, нужно покритиковать и C тоже. То, что C очень плох, написано много, я не буду повторять все эти аргументы. Там, синтаксис типов плохой, препроцессор ужасен, легко выстрелить себе в ногу, всякие ⟦`4["string"]`⟧, всякие ⟦`sizeof ('a') != sizeof (char)`⟧ (в C, не в C++!), всякие ⟦`i++ + ++i`⟧, всякие ⟦`while (*p++ = *q++);`⟧ (пример из Страуструпа, второе дополненное издание) и так далее и тому подобное.
Скажу лишь вот что. В C до сих пор не научились удобно работать со строками. Неудобство работы со строками постоянно приводит к разнообразным проблемам безопасности. И эту проблему до сих пор не решили! [Вот относительно свежий документ от комитета C](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1969.htm). В нём обсуждается весьма сомнительный способ решения проблемы со строками. И делается вывод, что этот способ плох. Год публикации: 2015. То есть даже к 2015-му году окончательного решения ещё нет!
И это не говоря об отсутствии простой, удобной и мультиплатформенной системы сборки (а не этого монстра autotools, который ещё и не поддерживает винду, и другого монстра cmake, который поддерживает винду, но всё равно монстр), стандартного менеджера пакетов, удобного как npm (js) или cargo (rust), нормальной portability library, с помощью которой можно было кроссплатформенно хотя бы прочитать содержимое папки и хотя бы даже *главного сайта C*, который был бы главной точкой входа для всех новичков и содержал бы в себе не только документацию, но и краткую инструкцию по установке инструментов C на любую платформу, по созданию простого проекта на C, а также содержал бы удобный поиск по пакетам C (которые должны быть размещены в стандартном репозитории) и, главное, был бы точкой сбора *user community*. Я даже зарегал домен *c-language.org* в надежде, что когда-нибудь я создам там такой сайт. Эх, мечты, мечты. (У меня ещё *cpp-language.org* заныкан, бугога :)) Но всего этого нет. Хоть это и есть у всех популярных языков, кроме C и C++. И даже у Haskell всё это есть. И у Rust.
У Rust, у этого выскочки, который, кстати говоря, метит в ту же нишу, что и C. Есть единый конфиг, который одновременно является конфигом проекта, конфигом сборки и конфигом для менеджера пакетов (собственно, cargo — это менеджер проектов и система сборки одновременно). Есть возможность указания в качестве зависимости для данного пакета другого пакета, размещённого где-то в **\*GIT\***, в том числе указание в качестве зависимости напрямую программы на **\*GITHUB\***. Генерация из коробки документации из сорцов, записанной в комментах на **\*MARKDOWN\***. И пакетный менеджер, использующий для версий **\*SEMVER\***. Итак, **\*GIT\***, **\*GITHUB\***, **\*MARKDOWN\***, **\*SEMVER\***, короче говоря **\*BUZZWORDS\***, **\*BUZZWORDS\*** и ещё раз **\*HIPSTERS' BUZZWORDS\***. И всё сразу из коробки. Прямо вот заходишь на их главный сайт, и вот на тебе на блюдечке с голубой каёмочкой. И работает всё одинаково на всех платформах. Несмотря на то, что Rust — это вроде как язык системного программирования, а не какой-нибудь там javascript. Несмотря на то, что в Rust можно байты гонять. И арифметика указателей там есть. Так почему же у них, у этих выскочек-растовцев, эти хипстерские баззворды есть, а у нас, сишников, их нет? Обыдно.
Я помню, один знакомый спрашивает у меня, где посмотреть список пакетов для C/C++. Пришлось сказать ему, что такого единого места нет. Он: «Программисты на C/C++ должны страдать?» Мне нечего было ему ответить.
Ах да, забыл ещё одну вещь. Посмотрите, пожалуйста, на прототип функции signal в том виде, в котором он дан в стандарте C: ⟦`void (*signal(int sig, void (*func)(int)))(int);`⟧ и попытайтесь его понять.
* [Терминал в UNIX — жуткое legacy](http://catern.com/posts/terminal_quirks.html).
* Имена файлов в файловых системах UNIX (ext2 и пр.) есть просто поток байтов без кодировки. В какой кодировке они будут интерпретированы, зависит от локали. То есть если создать файл на ОС в одной локали, а потом пытаться посмотреть его имя в ОС в другой локали, будет плохо. В виндовом NTFS такой проблемы нет.
* UNIX shell хуже PHP! Да, да, а вы что, не знали? Сейчас модно ругать PHP. Но ведь UNIX shell ещё хуже :) Особенно плохим он становится, если пытаться на нём программировать, ведь полноценным языком программирования он не является. Но даже для своей ниши (скриптинг типичных задач по администрированию) он годится плохо. Виной тому примитивность shell, непродуманность, legacy, куча частных случаев, костылей, бардак с кавычками, бекслешами, специальными символами и повёрнутость shell'а (как и всего UNIX) на простом тексте.
+ Начнём с затравки. Как рекурсивно найти в папке foo все файлы с именем ⟦`\`⟧? Правильный ответ таков: ⟦`find foo -name '\\'`⟧. Ну или так: ⟦`find foo -name \\\\`⟧. Последний вариант вызовет особенно много вопросов. Попробуйте объяснить человеку, плохо разбираемущемуся в UNIX shell, почему здесь нужно именно четыре бекслеша, а не два и не восемь (грамотеи, подскажите, как правильно написать это предложение, пишите в личку). А написать здесь нужно четыре бекслеша, потому что UNIX shell делает backslash expanding, и find тоже его делает.
+ Как touch'нуть все файлы в папке foo (и во вложенных)? На первый взгляд, один из способ таков: ⟦`find foo | while read A; do touch $A; done`⟧. Ну, на первый взгляд. На самом деле здесь можно придумать аж 5 нюансов, которые могут испортить нам малину (и привести к проблемам с безопасностью):
- Имя файла может содержать бекслеш, поэтому нужно писать не ⟦`read A`⟧, а ⟦`read -r A`⟧.
- Имя файла может содержать пробел, поэтому нужно писать не ⟦`touch $A`⟧, а ⟦`touch "$A"`⟧.
- Имя файла может не только содержать пробел, но и начинаться с пробела, поэтому нужно писать не ⟦`read -r A`⟧, а ⟦`IFS="" read -r A`⟧.
- Имя файла может содержать перевод строки, поэтому вместо ⟦`find foo`⟧ нужно использовать ⟦`find foo -print0`⟧, а вместо ⟦`IFS="" read -r A`⟧ нужно использовать ⟦`IFS="" read -rd "" A`⟧ (тут я не совсем уверен).
- Имя файла может начинаться с дефиса, поэтому вместо ⟦`touch "$A"`⟧ нужно писать ⟦`touch -- "$A"`⟧.
Итоговый вариант выглядит так: ⟦`find foo -print0 | while IFS="" read -rd "" A; do touch -- "$A"; done`⟧. Круто, да? И здесь мы, кстати, не учли, что POSIX не гарантирует (я не совсем в этом уверен), что touch поддерживает опцию ⟦`--`⟧. Если учитывать ещё и это, то придётся для каждого файла проверять, что он начинается с дефиса (или что не начинается со слеша) и добавлять в начало ⟦`./`⟧. Теперь вы поняли, почему скрипты configure, генерируемые autoconf'ом такие большие и трудночитаемые? Потому что этому configure нужно учитывать всю эту муть, включая совместимость с разными shell'ами. (В данном примере для демонстрации я использовал решение с пайпом и циклом. Можно было использовать решение с -exec или xargs, но это было бы не так эффектно). (Ладно, хорошо, мы знаем, что имя файла начинается с foo, поэтому оно не может начинаться с пробела или дефиса).
+ В переменной A лежит имя файла, нужно удалить его на хосте a@a. Как это сделать? Может быть так: ⟦`ssh a@a rm -- "$A"`⟧? (Как вы уже заметили, мы тут уже учли, что имя файла может содержать пробелы и начинаться с дефиса.) Ни в коем случае! ssh — это вам не chroot, не setsid, не nohup, не sudo и не какая-нибудь ещё команда, которая получает *exec-команду* (т. е. команду для непосредственной передачи функциям семейства execve). ssh (как и su) принимает *shell-команду*, т. е. команду для обработки shell'ом (термины exec-команда и shell-команда — мои). ssh соединяет все аргументы в строку, передаёт строку на удалённую сторону и там выполняет shell'ом. Окей, может быть так: ⟦`ssh a@a 'rm -- "$A"'`⟧? Нет, эта команда попытается найти переменную A на удалённой стороне. А её там нет, потому что переменные через ssh не передаются. Может, так: ⟦`ssh a@a "rm -- '$A'"`⟧? Нет, это не сработает, если имя файла содержит одинарную кавычку. В общем, не буду вас мучать, правильный ответ таков: ⟦`ssh a@a "rm -- $(printf '%q\n' "$A")"`⟧. Согласитесь, удобно?
+ Как зайти на хост a@a, с него — на b@b, с него — на c@c, с него — на d@d, а с него удалить файл /foo? Ну, это легко:
```
ssh a@a "ssh b@b \"ssh c@c \\\"ssh d@d \\\\\\\"rm /foo\\\\\\\"\\\"\""
```
Слишком много бекслешей, да? Ну, не нравится так, давайте чередовать одинарные и двойные кавычки, будет не так скучно:
```
ssh a@a 'ssh b@b "ssh c@c '\''ssh d@d \"rm /foo\"'\''"'
```
А между прочим, если бы вместо shell'а был Lisp, и там функция ssh передавала бы на удалённую сторону не строку (вот она, повёрнутость UNIX на тексте!), а уже распарсенный AST (abstract syntax tree), то такого ада бекслешей не было бы:
```
(ssh "a@a" '(ssh "b@b" '(ssh "c@c" '(ssh "d@d" '(rm "foo")))))
```
«А? Что? Lisp? Что за Lisp?» Интересно, да? На, [читайте](http://paulgraham.com/avg.html). И другие статьи Грэма. На русском тоже можно найти.
+ Совместим предыдущие два пункта. Имя файла лежит в переменной A. Нужно зайти на a@a, с него — на b@b, далее на c@c, d@d и удалить файл, лежащий в переменной A. Это я оставляю вам в качестве упражнения :) (Сам я не знаю, как это сделать :) Ну, может, придумаю, если подумаю).
+ echo вроде как предназначен, чтобы печатать на экран строки. Вот только использовать его для этой цели, если строчка чуть сложнее, чем «Hello, world!», нельзя (но см. **UPD** от 2017-08-01). Единственно верный способ вывести произвольную строку (скажем, из переменной A) таков: ⟦`printf '%s\n' "$A"`⟧.
+ Допустим, нужно направить stdout и stderr команды cmd в /dev/null. Загадка: какие из этих шести команд выполняют поставленную задачу, а какие — нет?
```
cmd > /dev/null 2>&1
cmd 2>&1 > /dev/null
{ cmd > /dev/null; } 2>&1
{ cmd 2>&1; } > /dev/null
( cmd > /dev/null ) 2>&1
( cmd 2>&1 ) > /dev/null
```
Оказывается, правильный ответ — 1-я, 4-я и 6-я выполняют, 2-я, 3-я и 5-я — не выполняют. Опять-таки, выяснение причин этого оставляется в качестве упражения :)
* Вообще, этот пост появился в ответ на [вот этот пост](https://geektimes.ru/post/285682). Там говорилось, что в винде специальная дата используется как признак драйвера от Microsoft. Вместо ввода специального аттрибута или проверки производителя. Особенностей такого рода в UNIX полно. Является ли файл скрытым, выясняется на основе наличия точки в начале файла вместо специального аттрибута. Когда я сам впервые об этом узнал (да, да, в те далёкие времена, когда я впервые поставил Ubuntu), я был шокирован. Я подумал, вот идиоты. А сейчас привык. Но если вдуматься, это жуткий костыль. Далее, shell выясняет, является ли он login shell'ом на основе дефиса, переданного первым символом в argv[0] (?!). Это *abuses* (ну или *misuses*, неправильно использует, не знаю, как по-русски сказать) argv[0]. argv[0] не для этого предназначен. Вместо какого-нибудь другого способа. Любой другой способ был бы красивее. Как угодно, любым другим аргументом, переменной окружения.
* В BSD sockets юзер вынужден сам менять порядок байт у номера порта. А всё потому, что когда-то давно кто-то допустил в коде ядра UNIX ошибку, не предусмотрев смену порядка байт. И в качестве временного хака исправил user space код вместо кода ядра. Так и живём. Оттуда это и в Windows перешло (вместе с файлом /etc/hosts, он же C:\windows\system32\drivers\etc\hosts).
**UPD** от 2017-02-12: [источник](http://blog.erratasec.com/2013/02/unlearning-college.html).
«Философия UNIX». Есть мнение, что якобы UNIX прекрасна и идеальна. Что все её основные идеи («всё есть файл», «всё есть текст» и т. д.) прекрасны и составляют так называемую прекрасную «философию UNIX». Так вот, как вы уже начали догадываться, это не совсем так. Давайте разберём эту «философию UNIX» по пунктам. Сразу скажу: я не хочу сказать, что все пункты нужно отменить, просто я указываю на их неуниверсальность.
* «Всё есть текст». Как мы с вами уже выяснили на примере /etc/passwd, повсеместное использование простого текста может привести к проблемам с производительностью. И вообще, авторы UNIX фактически придумали для каждого системного конфига (passwd, fstab и так далее) свой формат. Со своими правилами экранирования специальных символов. Да, а вы что думали? /etc/fstab использует пробелы и переносы строк как разделители. Но что если имена папок содержат, скажем, пробелы? На этот случай формат fstab'а предусматривает специальное экранирование имён папок. Так что любой скрипт, читающий fstab, оказывается, должен это экранирование интерпретировать. Например, с помощью специально предназначенной для этого утилиты fstab-decode (запускать от рута). Не знали, да? Идите исправляйте свои скрипты :) В результате для каждого системного конфига нужен свой парсер. И было бы гораздо проще, если бы для системных конфигов использовался вместо этого какой-нибудь JSON или XML. А может быть даже некий бинарный формат. Особенно для тех конфигов, которые постоянно читаются разными программами. И для которых, как следствие, нужна хорошая скорость чтения (а у бинарных форматов она выше).
Я не закончил по поводу «всё есть текст». Стандартные утилиты выдают вывод в виде простого текста. Для каждой утилиты фактически нужен свой парсер. Часто приходится парсить вывод той или иной утилиты при помощи sed, grep, awk и т. д. У каждой утилиты свои опции для того, чтобы установить, какие именно столбцы нужно выдавать, по каким столбцам нужно сортировать вывод и т. д. Было бы лучше, если бы утилиты выдавали вывод в виде XML, JSON, некоего бинарного формата или ещё чего-нибудь. А для удобного вывода этой информации на экран и для дальнейшей работы с ней можно было бы пайпить результат в дополнительные утилиты, которые убирают те или иные столбцы, сортируют по тому или иному столбцу, выбирают нужные строки и т. д. И либо выводят результат в виде красивой таблички на экран, либо передают его куда-то дальше. И всё это универсальным способом, не зависящим от исходной утилиты, которая сгенерировала вывод. И без необходимости парсить что-либо регексами. Да, UNIX shell плохо работает с JSON и XML. Но ведь у UNIX shell полно других недостатков. Нужно выкинуть его вовсе и заменить на некий другой язык, который помимо всего прочего может удобно работать со всякими JSON.
Вы только представьте! Вот допустим, нужно удалить все файлы в текущей папке с размером, большим 1 килобайта. Да, я знаю, что такое надо делать find'ом. Но давайте предположим, что это нужно сделать непременно ls'ом (и без xargs). Как это сделать? Вот так: ⟦`LC_ALL=C ls -l | while read -r MODE LINKS USER GROUP SIZE M D Y FILE; do if [ "$SIZE" -gt 1024 ]; then rm -- "$FILE"; fi; done`⟧. (LC\_ALL здесь нужен был, чтобы быть уверенным, что дата будет занимать именно три слова в выводе ls). Мало того, что это решение выглядит некрасиво, оно ещё страдает рядом недостатков. Во-первых, оно не будет работать, если имя файла содержит перевод строки или начинается с пробела. Далее, нам нужно явно перечислить названия всех столбцов ls, ну или как минимум помнить, на каком месте находятся интересующие нас (т. е. SIZE и FILE). Если мы ошибёмся в порядке столбцов, то ошибка выяснится лишь на этапе выполнения. Когда мы удалим не те файлы :)
А как бы выглядело решение в идеальном мире, который я предлагаю? Как-то так: ⟦`ls | grep 'size > 1kb' | rm`⟧. Кратко, а главное, смысл виден из кода, и невозможно ошибиться. Смотрите. ls в моём мире всегда выдаёт всю инфу. Специальная опция ⟦`-l`⟧ для этого не нужна. Если нужно убрать все столбцы и оставить только имя файла, то это делается специальной утилитой, в которую нужно направить вывод ls. Итак, ls выдаёт список файлов. В некоем структурированном виде, скажем, JSON. Это представление «знает» названия столбцов и их типы, т. е. что это, строка, число или что-то ещё. Далее этот вывод направляется в grep, который в моём мире выбирает нужные строки из этого JSON. JSON «знает» названия полей, поэтому grep «понимает», что здесь означает «size». Более того, JSON содержит инфу о типе поля size. Он содержит инфу о том, что это число, и даже что это не просто число, а размер файла. Поэтому можно сравнить его с 1kb. Далее grep направляет вывод в rm. rm «видит», что он получил файлы. Да, да, JSON ещё и хранит инфу о типе этих строк, о том, что это — файлы. И rm их удаляет. А ещё JSON отвечает за правильное экранирование специальных символов. Поэтому файлы со спецсимволами «просто работают». Круто? Идею я взял [отсюда](https://www.opennet.ru/opennews/art.shtml?num=34591) (там ещё есть ссылка на более подробный английский оригинал), посмотрите. Ещё замечу, что в Windows Powershell реализовано как раз что-то похожее на эту идею.
* UNIX shell. Ещё одна базовая идея UNIX. Причём о мелких недостатках UNIX shell я уже поговорил в первой части статьи. Сейчас будут крупные. В чём «крутость» UNIX shell? В том, что *на момент своего появления* (это было очень давно) UNIX shell был гораздо мощнее командных интерпретаторов, встроенных в другие ОС. И позволял писать более мощные скрипты. Да и вообще, на момент своего появления UNIX shell был, видимо, самым мощным из скриптовых языков вообще. Потому что *нормальных* скриптовых языков, т. е. таких, которые бы позволяли полноценное программирование, а не только скриптинг, тогда, видимо, вообще не существовало. Это потом уже в один прекрасный день один программист по имени Larry Wall заметил, что UNIX shell всё-таки недостаёт до нормального языка программирования. И он захотел соединить краткость UNIX shell'а с возможностью полноценного программирования из C. И создал Perl. Да, Perl и другие последующие скриптовые языки программирования фактически заменили UNIX shell. Это константирует даже Роб Пайк, один из авторов (как я считаю) той самой «философии UNIX» (про него мы ещё поговорим). [Вот здесь](https://interviews.slashdot.org/story/04/10/18/1153211/rob-pike-responds) на вопрос об «одной утилите для одной вещи» он сказал: «Those days are dead and gone and the eulogy was delivered by Perl». Причём я считаю, что эта его фраза относилась к типичному использованию UNIX shell, т. е. к ситуации связывания большого количества маленьких утилит в shell-скрипте. Нет, говорит Пайк, просто используйте Perl.
Я не закончил про UNIX shell. Рассмотрим ещё раз пример кода на shell, который я уже приводил: ⟦`find foo -print0 | while IFS="" read -rd "" A; do touch -- "$A"; done`⟧. Здесь в цикле вызывается touch (да, я знаю, что этот код можно переписать на xargs, причём так, чтобы touch вызывался только один раз; но давайте пока забьём на это, хорошо?). В цикле вызывается touch! То есть для каждого файла будет запущен новый процесс! Это нереально неэффективно. Код на любом другом языке программирования будет работать быстрее этого. Просто на момент появления UNIX shell он был одним из немногих языков, которые позволяют написать это действие в одну строчку.
Короче говоря, вместо UNIX shell нужно использовать любой другой скриптовый язык программирования. Который подходит не только для скриптинга, но и для реального программирования. Который не запускает новый процесс каждый раз, когда нужно «touch'нуть» файл. Возможно, понадобится «доложить» в этот скриптовый язык средства для простого выполнения вещей, которые есть в shell, скажем, для создания пайпов.
* Простота. Здесь я говорю не конкретно про shell и про связывание кучи простых утилит из shell'а (про это был предыдущий пункт), а про простоту вообще. Использование простых инструментов. Скажем, редактирование картинки sed'ом. Да, да. Конвертим jpg в ppm при помощи командной строки. Затем при помощи текстового редактора, grep, sed и такой-то матери редактируем картинку. А потом обратно в jpg. Да, так можно. Но часто photoshop'ом или gimp'ом всё-таки лучше. Хоть это и большие, интегрированные программы. Не в стиле UNIX.
На этом я закончу эти пункты. Да, хватит. Есть идеи в UNIX, которые мне реально нравятся. Скажем, «программа должна делать одну вещь и делать её хорошо». Но не в контексте shell. Вы уже поняли, что я не люблю shell. (Ещё раз повторю, я считаю, что в приведённом выше интервью Пайка он воспринял принцип «программа должна делать одну вещь и делать её хорошо» именно в контексте shell и потому отверг его). Нет, я говорю про этот принцип в своей сути. Скажем, консольный почтовый клиент не должен иметь встроенный текстовый редактор, он должен просто запустить некий внешний редактор. Или вот принцип, по которому нужно писать консольное ядро для программы и потом графическую оболочку для этого ядра.
Теперь общая картина. Однажды появился UNIX. На момент появления он был прорывом. И он был во многом лучше своих конкурентов. UNIX имел много идей. И, как и любая ОС, UNIX требовал от программистов соблюдения некоторых принципов при написании прикладных программ. Идеи, лежащие в основе UNIX, стали называться «философией UNIX». Одним из тех людей, которые сформулировали философию UNIX, был уже упомянутый Роб Пайк. Он это сделал в своей презентации [«UNIX Style, or cat -v Considered Harmful»](http://harmful.cat-v.org/cat-v). После презентации он вместе с Керниганом опубликовал [статью по мотивам презентации](http://harmful.cat-v.org/cat-v/unix_prog_design.pdf). В ней авторы рассказали о том, что, скажем, предназначение cat — это только конкатенация и ничего больше (ну то есть «склеивание» файлов, мы с вами помним, как расшифровывается cat, так ведь?). Возможно, что это Пайк как раз и придумал «философию UNIX». В честь этой презентации был назван сайт [cat-v.org](http://cat-v.org), почитайте его, очень интересный сайт.
Но потом, через много лет, этот же Пайк сделал ещё две презентации, в которых, как я считаю, отменил свою философию обратно. Поняли, фанатики, да? Ваш кумир отказался от своей же философии. Можете расходиться по домам. В первой презентации [«Systems Software Research is Irrelevant»](http://doc.cat-v.org/bell_labs/utah2000/) Пайк сетует на то, что никто больше не пишет новых ОС. А даже если и пишут, то просто ещё один UNIX (который подразумевается в этой презентации уже чем-то неинтересным): «New operating systems today tend to be just ways of reimplementing Unix. If they have a novel architecture — and some do — the first thing to build is the Unix emulation layer. How can operating systems research be relevant when the resulting operating systems are all indistinguishable?»
Вторую презентацию Пайк прямо называет: [«The Good, the Bad, and the Ugly: The Unix Legacy»](http://doc.cat-v.org/bell_labs/good_bad_ugly/). Пайк говорит, что простой текст не универсален, он хорош, но работает не всегда: «What makes the system good at what it's good at is also what makes it bad at what it's bad at. Its strengths are also its weaknesses. A simple example: flat text files. Amazing expressive power, huge convenience, but serious problems in pushing past a prototype level of performance or packaging. Compare the famous spell pipeline with an interactive spell-checker». Далее: «C hasn't changed much since the 1970s… And — let's face it — it's ugly». Дальше Пайк признаёт ограниченность пайпов, соединяющих простые утилиты, ограниченность регексов.
UNIX был гениальным на момент своего появления. Особенно, если учесть, какие инструменты были в распоряжении у авторов UNIX. У них не было уже готового UNIX, чтобы на нём можно было разрабатывать UNIX. У них не было IDE. И программировали они вообще на ассемблере изначально. У них, видимо, был только ассемблер и текстовый редактор.
Люди, стоящие у истоков UNIX, в определённый момент начали писать новую ОС: Plan 9. В том числе упомянутые Томпсон, Ритчи и Пайк. Учитывая многие ошибки UNIX. Но и Plan 9 никто не возводит в абсолют. В «Systems Software Research is Irrelevant» Пайк упоминает Plan 9, но несмотря на это всё равно призывает писать новые ОС.
James Hague, ветеран программирования (занимается программированием с восьмидесятых) пишет: «What I was trying to get across is that if you romanticize Unix, if you view it as a thing of perfection, then you lose your ability to imagine better alternatives and become blind to potentially dramatic shifts in thinking» ([ссылка](http://prog21.dadgum.com/128.html)). Прочитайте эту статью и его же статью [«Free Your Technical Aesthetic from the 1970s»](http://prog21.dadgum.com/74.html), на которую он ссылается. (Вообще, если вам понравилась моя статья, то и его блог тоже, наверное, понравится, погуляйте там по ссылкам).
Итак, я не хочу сказать, что UNIX — плохая система. Просто обращаю ваше внимание на то, что у неё есть полно недостатков, как и у других систем. И «философию UNIX» я не отменяю, просто обращаю внимание, что она не абсолют. Мой текст обращён скорее к фанатикам UNIX и GNU/Linux. Провокационный тон просто чтобы привлечь ваше внимание.
**UPD** от 2017-02-14: комментаторы указывают, что сравнивать UNIX shell с PHP некорректно. Конечно, некорректно! Потому что UNIX shell не претендует на то, чтобы быть полноценным языком программирования, он предназначен для скриптинга системы. Вот только я в одно время этого не знал. И вдобавок считал UNIX shell прекрасным. Вот для людей в таком же положении я всё это и говорю. Ещё как минимум один комментатор говорит, что сравнивать UNIX shell нужно с cmd. Я бы сказал, что сравнивать надо с Windows Powershell. Последний, как я уже говорил, в чём-то превосходит UNIX shell.
**UPD** от 2017-02-14: мне понравился [вот этот коммент](https://habrahabr.ru/post/321652/#comment_10065532) от [sshikov](https://habr.com/ru/users/sshikov/):
> Но я скажу за автора — к сожалению, прямо сегодня можно найти сколько угодно восторженных статей типа «А вот есть такая замечательная фигня, как bash, щас я вам про нее расскажу...» — где unix way откровенно перехваливается неофитами. Это не помешает иногда компенсировать долей скепсиса.
>
>
Да, в этом-то и всё дело! Достало, что хвалят UNIX way. Что считают UNIX красивым и ещё и других учат. А использовать-то UNIX можно.
**UPD** от 2017-02-14: как минимум один комментатор сказал, что пересел с Windows на UNIX-подобные ОС и счастилив. Что поначалу он плевался от UNIX, но потом решил, что программировать под UNIX гораздо проще, чем под Windows. Так вот, я тоже сперва использовал и программировал на Windows. Потом пересел на UNIX. И сперва, конечно, было очень непривычно. Потом прочувствовал «философию UNIX», ощутил всю её мощь. Программировать под UNIX стало легко. Но позже пришло ещё одно озарение. Что UNIX неидеальна, а «философия UNIX» неабсолютна. Что программирование на «голом UNIX», с использованием C и Shell сильно уступает, скажем, Web-программированию. И далеко не только потому, что в Web-программировании используются языки, в которых трудно выстрелить себе в ногу, в отличие от C (тут языку C предъявить нечего, он намеренно является низкоуровневым). Но ещё и из-за всех этих quirks мейкфайлов, шела, языка C. Отсутствия удобных инструментов, систем сборки, менеджеров пакетов. Всё это, в принципе, можно было бы исправить. Вот я написал эту статью, чтобы открыть на это глаза тем, кто об этом не знает. У Windows тоже полно недостатков (я разве где-то говорил, что Windows лучше UNIX?). Но в чём-то Windows лучше UNIX (как минимум в некоторых особенностях Powershell). Сейчас я продолжаю использовать и программировать под UNIX. UNIX меня устраивает, мне достаточно удобно, хотя теперь уже я вижу многие его недостатки. Я не призываю бросать UNIX. Используйте UNIX дальше, просто не считайте его идеалом.
**UPD** от 2017-02-15: [habrahabr.ru/post/321652/#comment\_10070776](https://habrahabr.ru/post/321652/#comment_10070776).
**UPD** от 2017-02-15: [habrahabr.ru/post/321652/#comment\_10071096](https://habrahabr.ru/post/321652/#comment_10071096).
**UPD** от 2017-02-15: [habrahabr.ru/post/321652/#comment\_10071714](https://habrahabr.ru/post/321652/#comment_10071714).
**UPD** от 2017-02-16: понравился этот коммент: [habrahabr.ru/post/321652/#comment\_10066240](https://habrahabr.ru/post/321652/#comment_10066240).
**UPD** от 2017-02-16: многие комментаторы рассказывают, как же полезны и удобны UNIX системы. Что они есть уже десятки лет, на них работает весь интернет. Что они стабильны и прекрасно справляются с возложенными на них задачами. И даже удалённо переустановить GNU/Linux можно :) А я и не спорю. Я не призываю отказываться от UNIX. Я просто хочу, чтобы вы видели недостатки UNIX. UNIX работает, используйте его. Процитирую James Hague, на которого я уже ссылался:
> Enough time has passed since the silly days of crazed Linux advocacy that I'm comfortable pointing out the three reasons Unix makes sense:
>
>
>
> 1. It works.
>
> 2. It's reliable.
>
> 3. It stays constant.
>
>
>
> But don't--do not--ever, make the mistake of those benefits being a reason to use Unix as a basis for your technical or design aesthetic. Yes, there are some textbook cases where pipelining commands together is impressive, but that's a minor point. Yes, having a small tool for a specific job sometimes works, but it just as often doesn't.
>
>
Одно время я тоже, как и многие из вас, повёлся на эту «философию UNIX». Думал, что она прекрасна. А потом понял, что это не так. И вот этим своим открытием я хочу с вами поделиться. Мои мысли не новы. Они уже есть в приведённых мною ссылках. Я просто хочу сообщить эти мысли аудитории Хабра. Мой пост написан наскоро, ночью. Читайте скорее не его, а ссылки, которые я привожу. В первую очередь две презентации Пайка, в которых он «отменяет философию UNIX» и два поста от James Hague. Мой пост фактически написан, чтобы привлечь внимание к этим ссылкам.
Как минимум один из комментаторов сказал, что многие из названных мной «недостатков» UNIX недостатками не являются. Например, слишком короткие имена команд. Ну да. Это не недостаток. Но это пример необдуманного решения. Сиюминутного решения, принятого под влиянием обстоятельств, имевших важность тогда. Как и с тем примером с /usr или make. Я показываю, что UNIX была непродумана. Да и вообще, вглядитесь в историю UNIX! Сотрудникам Bell Labs не понравилась сложность проекта Multics. Они сказали: «Да ну этот Multics, давайте по-быстрому напишем свою ОС, запростецкую». И написали. Понимаете? ОС получилась довольно хорошей. Но не идеальной. UNIX — это хак. Успешный хак, который выполнил свою миссию и продолжает её выполнять.
В комментариях была мысль, что заголовок поста не соответствует содержанию, и что я критикую не самую суть, философию UNIX, а просто привожу некий список недостатков. Возможно даже не всего класса UNIX-подобных систем, а конкретных реализаций. Так вот, это не так. Да, статья начинается с перечисления мелких недостатков. Этим я обращаю внимание на то, что в UNIX полно костылей, как и в других системах. В том числе очень старых, оставшихся во всех UNIX системах и попавших во все стандарты. Но я критикую и саму философию UNIX. Основные принципы (но не все!). Язык C, UNIX shell, идею конвееров, «всё есть текст». Замечу, что компилятор C и make, хоть и являются по идее отдельными программами, всегда рассматриваются как неотъемлемая часть экосистемы UNIX. И входят в POSIX. Некоторые комментаторы пишут: «А я сижу в IDE и не использую этот ваш make». Ну окей, хорошо, мой пост предназначен скорее как раз для тех фанатиков, которые считают, что всякие IDE — это не труъ и что программировать нужно непременно используя голый C, make и shell.
И я не говорю, что философия UNIX (даже в тех местах, которые мне не нравятся) всегда не верна. Часто конвееры и shell-скрипты — это именно то, что нужно. Но не всегда.
Некоторые комментаторы указывают, что голый shell, make и прочее часто скрыты от глаз юзера всякими обёртками, всякими IDE, сложными системами сборки, GUI-интерфейсами и пр. Ну да. Так ведь это и есть признак кривости системы :) Когда что-то уродское покрывают слоем красоты. А ещё [абстракции протекают](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions). А потому использовать, скажем, autotools ещё сложнее, чем голый make. Потому что чтобы использовать autotools, нужно знать ещё и m4, make и shell. Да, да, всю эту цепочку языков, используемых при генерации окончательного мейкфайла.
Один комментатор приводит следующие принципы UNIX:
> Write programs that do one thing and do it well.
>
> Write programs to work together.
>
> Write programs to handle text streams, because that is a universal interface.
>
>
С первыми двумя я согласен при условии, что они понимаются в отрыве от UNIX shell и конвееров. Их можно перенести даже на новомодные микросервисы, общающиеся с помощью REST. С третьим я не согласен (как я понимаю, подразумевается именно придумывание простого кастомного текстового формата для каждого случая вместо единого формата наподобие JSON). Часто текст — это именно то, что нужно. Но пихать его везде как universal interface глупо. На эту роль скорее претендует JSON или XML. Или, может, какой-нибудь формат для структурированных данных, который ещё не изобрели.
Многие указали на искусственность некоторых примеров на shell. Ну да, я знаю, что их можно было бы переписать на find -exec или xargs. Ну что вы хотите, наскоро написанная статья. Можно было привести примеры получше, просто мне не хотелось. Это не отменяет того, что в shell'е постоянно возникают проблемы со специальными символами. Которые нужно по-особому обходить. И вообще у shell'а полно quirks, которые нужно постоянно держать в голове. И он запускает новые программы на каждый чих.
Я вам ещё покушать принёс. Вот вам [цитата от безусловно ещё одного вашего кумира Линуса Торвальдса](https://www.opennet.ru/opennews/art.shtml?num=40622):
> iTWire: Systemd seems to depart to a large extent from the original idea of simplicity that was a hallmark of UNIX systems. Would you agree? And is this a good or a bad thing?
>
>
>
> Linus Torvalds: So I think many of the «original ideals» of UNIX are these days more of a mindset issue than necessarily reflecting reality of the situation.
>
>
>
> There's still value in understanding the traditional UNIX «do one thing and do it well» model where many workflows can be done as a pipeline of simple tools each adding their own value, but let's face it, it's not how complex systems really work, and it's not how major applications have been working or been designed for a long time. It's a useful simplification, and it's still true at \*some\* level, but I think it's also clear that it doesn't really describe most of reality.
>
>
>
> It might describe some particular case, though, and I do think it's a useful teaching tool. People obviously still do those traditional pipelines of processes and file descriptors that UNIX is perhaps associated with, but there's a \*lot\* of cases where you have big complex unified systems.
>
>
>
> And systemd is in no way the piece that breaks with old UNIX legacy. Graphical applications seldom worked that way (there are certainly \_echoes\_ of it in things like «LyX», but I think it's the exception rather than the rule), and then there's obviously the traditional counter-example of GNU emacs, where it really was not about the «simple UNIX model», but a whole new big infrastructure thing. Like systemd.
>
>
>
> Now, I'm still old-fashioned enough that I like my log-files in text, not binary, so I think sometimes systemd hasn't necessarily had the best of taste, but hey, details…
>
>
**UPD** от 2017-02-18: ещё по поводу надуманных примеров на shell. Вы говорите, примеры надуманные, что можно сделать find -exec или xargs. Да, можно. Но как минимум сам факт того, что нужно постоянно держать в голове, что, мол, цикл нельзя и нужен -exec и xargs — это уже костыль. Проистекающий из принципа «всё есть текст», ну или из слишком тупой реализации этого принципа в UNIX shell.
Итак, сейчас я приведу такую задачу, в которой любое решение будет уродским, даже с использованием find -exec и xargs.
Вернёмся к моему примеру с touch'ем. «Как touch'нуть все файлы в папке foo (и во вложенных)?» Допустим, что нужно не touch'нуть их, а grep'нуть из них все строки со словом bar и положить результат туда же. Т. е. для каждого файла file сделать ⟦`grep bar file > tmp; mv tmp file`⟧. Как быть? Если делать решение с циклом, то мы упираемся в те пять хаков, которые нужно сделать, чтобы не выстрелить себе в ногу. Результат будет таким, со всеми пятью хаками:
```
find foo -print0 | while IFS="" read -rd "" A; do
grep -- bar "$A" > tmp
mv -- tmp "$A"
done
```
Ладно, хорошо, мы знаем, что имя файла начинается на foo, а потому не может начинаться с дефиса и пробела. Но оно может *заканчиваться* на пробел, а потому тот трюк с IFS всё равно нужен. Так что единственный хак, от которого можно избавиться, зная, что имя начинается с foo — это написание ⟦`--`⟧. Но даже от этого хака я бы не советовал избавляться, т. к. постоянное использование ⟦`--`⟧ даёт понять читающему: «Да, я подумал об этом». Это как [условия Йоды](https://ru.wikipedia.org/wiki/%D0%A3%D1%81%D0%BB%D0%BE%D0%B2%D0%B8%D1%8F_%D0%99%D0%BE%D0%B4%D1%8B).
Окей, можно ли этот пример написать проще с использованием xargs или find -exec? Если бы каждый файл нужно было всего лишь touch'нуть, то да, можно было бы написать существенно проще. Но если нужно выполнить *два* действия: grep и переименование, то существенного упрощения мы уже не получим. Два действия означают, что нам уже нужно запихивать эти два действия в вызов shell'а, в ⟦`sh -c`⟧. Как будет выглядеть результат? Может быть, так?
```
find foo -exec sh -c "grep -- bar '{}' > tmp; mv -- tmp '{}'" ';'
```
Нет, неправильно! Это не будет работать, если имя содержит одинарную кавычку. Правильный вариант таков:
```
find foo -exec sh -c 'grep -- bar "$1" > tmp; mv -- tmp "$1"' dummy '{}' ';'
```
Видите? Опять хак. Нам пришлось передать имя файла через $1. И по-прежнему нужно помнить, что нам нужны двойные кавычки вокруг $1. То же самое было бы с xargs. Опять нужен ⟦`sh -c`⟧ и опять нужно передавать аргументы через $1.
Всё это сделать *можно*, если надо, но сам факт того, что нужно постоянно держать это в голове и обходить грабли, говорит о том, что здесь что-то не то.
Теперь по поводу другого примера. Где нужно удалить все файлы определённого размера. Да, всё это можно сделать одним вызовом find. Там есть опции и для проверки размера, и для удаления. Да. Вот только я вижу здесь хак. Хак в том, что find имеет фактически в себе целый sublanguage, подъязык. Язык вот этих вот опций. Почитайте хорошенько ман find'а. Вы узнаете, что, оказывается, порядок опций find'а имеет значение. Что каждая опция имеет truth value, т. е. булевское значение. Что можно по-хитрому комбинировать эти опции. Что в зависимости от порядка опции, от их truth value find принимает решение, в какой момент нужно остановить обработку опций для данного файла и нужно ли descend в данный каталог (т. е. нужно ли искать внутри этого каталога).
Я помню, как однажды жутко оплошался, не зная этих тонкостей. Я набрал ⟦`find -delete -name '*~'`⟧ вместо ⟦`find -name '*~' -delete`⟧ или что-то такое. Ну подумаешь, думал я, опции не в том порядке. Смысл же тот же. И find удалил всё. Снёс мои важные файлы. Потом я восстановил из бекапа, так что всё ок. Это потом уже я понял, что -name имеет truth value *true* в случае, если файл соответствует маске. И если -name вернул true, то обработка опций продолжается.
Что тут плохого? Плохо то, что find имеет свой sublanguage. Что это ещё один язык в дополнение к shell. (А sed, кстати говоря — это ещё один язык, а awk — это ещё один язык и так далее, авторы UNIX'а любили создавать по языку на каждый чих.) Нужно было вместо этого сделать так, чтобы find только умел искать файлы. А всю остальную функциональность нужно вынести из него. Проверки на размер файла должны быть снаружи. А если find'у нужно принять решение, нужно ли descend в данный каталог, то он должен вызывать внешний callback. Да, в UNIX shell так вряд ли получится. На то он и UNIX shell.
**UPD** от 2017-08-01.
> echo вроде как предназначен, чтобы печатать на экран строки. Вот только использовать его для этой цели, если строчка чуть сложнее, чем «Hello, world!», нельзя.
>
>
И даже для этой цели echo использовать можно не всегда. Недавно прочитал, что в интерактивном старом bash нельзя писать ⟦`echo "Hello, world!"`⟧. [Вот несколько абзацев текста, объясняющих суть проблемы и пути обхода](http://mywiki.wooledge.org/BashPitfalls#echo_.22Hello_World.21.22). В новых bash такого нет, на моей системе не воспроизводится.
**UPD** от 2018-05-31. Возвращаясь к тем пяти хакам. Сейчас вдруг дошло, что есть ещё один хак: имя файла может быть ⟦`-`⟧, этот случай нужно учитывать отдельно. К счастью, в примерах выше это не проявляется, т. к. путь всё равно начинается с foo. | https://habr.com/ru/post/321652/ | null | ru | null |
# P<0.05, и откуда оно (иногда) берётся
Зарабатывать продажей лекарств, которые заведомо не работают, не только аморально, но и не особо легко. Люди всё-таки обычно не хотят покупать препараты, неэффективность которых была доказана. А вот если вы сумели выдавить заветное p < 0.05 в пользу того, что акупунктура таки работает [из данных, которые явно утверждают обратное](http://www.dcscience.net/2011/05/31/acupuncturists-show-that-acupuncture-doesnt-work-but-conclude-the-opposite-journal-fails/), — то серия публикаций, успех в карьере и вечная благодарность всех акупунктурщиков вам гарантированы.
Со ставками на спорт история такая же: чтобы выигрывать деньги у букмекера, нужно уметь считать коэффициенты лучше него. А вот чтобы заработать на продаже *советов, на кого ставить,* — достаточно считать лучше своих читателей. Например, [Винс Экинс давал своим читателям следующий совет](http://www.vegasinsider.com/nfl/story.cfm/story/1815888):
> Philadelphia Eagles выиграли 10 предыдущих игр, если они не были фаворитом, играли на собственном поле и в предыдущем матче прошли более 150 ярдов в наступлении.
>
>
10 игр! Это подразумевает, что вероятность поражения в аналогичных условиях 1/(2^10) = 1/1024 = 0.0009. Такая степень уверенности не каждый день встречается даже в серьёзных исследованиях. И это, разумеется, не потому что Eagles действительно так уж хороши, а потому что анализ был проведён неправильно. Иногда так получается [просто потому, что авторы не умеют нормально анализировать данные](http://www.stat.columbia.edu/~gelman/research/unpublished/p_hacking.pdf), и в результате [целые области науки](http://journals.plos.org/plosmedicine/article?id=10.1371/journal.pmed.0020124) оказываются под вопросом. А иногда так поступают откровенные мошенники (что в академической науке, что за её пределами).
#### Как получить p<0.05
По определению, p-значение в 0.05 — это вероятность в 5%, что результат будет получен, *если верна нулевая гипотеза*, то есть если лекарство не работает, исследуемые феномены не взаимосвязаны и вообще ничего интересного тут нет. Так что основная идея проста: если взять два десятка гипотез, то, скорее всего, одна из них будет иметь p≈0.05.
Получить много гипотез для проверки можно двумя основными способами. Если изначально разбить рассматриваемую выборку на множество подгрупп, то, скорее всего, хоть в одной из них да получится статистически значимый результат. Этот метод прекрасно иллюстрирует xkcd: мармеладки вообще прыщи не вызывают (p>0.05), и красные мармеладки, в частности, тоже не вызывают (p>0.05). И жёлтые не вызывают, и сиреневые, и оранжевые, и коричневые, и ещё два десятка цветов не вызывают — а вот для зелёных p<0.05.
Второй метод (он же метод [Латиноамериканской Бабушки](http://slatestarcodex.com/2014/01/02/two-dark-side-statistics-papers/)) подразумевает деление исходной выборки на любые произвольные подгруппы до тех пор, пока не найдётся комбинация условий, при которой p<0.05. Допустим, в вымышленной стране существует вымышленное заболевание, от которого сама собой излечивается ровно половина больных. Вторая половина умирает. На первый взгляд, ваше чудо-лекарство, повышающее долю выживших аж до 50%, выглядит так себе даже по меркам [British Journal of General Practice](http://www.dcscience.net/paterson-acu-BJGP-2011.pdf). Но всегда можно взглянуть поподробнее.
Допустим, по чистой случайности удачно вылечившиеся распределены по полам слегка неравномерно: выздоровело 49% мужчин и 51% женщин. А среди женщин старше 60 лет препарат помог аж 55%. И, допустим, 13 пожилых женщин, участвовавших в исследовании, родом из Мексики. Вполне может оказаться, что препарат помог 10 из них. Это уже не 50%, а 77%, и к тому же вполне приличное p-значение в 0.046. Можно наслаждаться репутацией спасителя латиноамериканских бабушек (а если бы с ними не прокатило — можно было бы проверить еврейских мальчиков, девочек-негритянок, белых среднего возраста и все остальные комбинации).
Надеюсь, всем и так очевидно, что 10 человек из 13 — это несерьёзно. Но тем не менее я повторю: если [выборка слишком маленькая](https://putanumonit.com/2016/04/17/022-power_skeptic/), то любой полученный на ней результат [почти наверняка ничего не стоит](http://andrewgelman.com/2014/11/17/power-06-looks-like-get-used/).
Но что, если бабушек было не 13, а 90, и препарат помог аж 61? Даже если всем остальным он не помог, две трети выздоровевших и p-значение в 0.0005 выглядят впечатляюще, а 90 человек — это уже вполне приличная выборка. Давайте посчитаем, но для начала немного теории.
P-значения в общем-то довольно плохой инструмент. Сама идея “обнаруживать то, чего нет, не чаще, чем в 1 эксперименте из 20” звучит не очень впечатляюще, а к тому же даже в теории [5%-ный порог p-значения обманывает экспериментатора в 30% случаев](http://www.dcscience.net/2014/03/24/on-the-hazards-of-significance-testing-part-2-the-false-discovery-rate-or-how-not-to-make-a-fool-of-yourself-with-p-values/). Но вот что они делают хорошо — так это конвертируют любое распределение в равномерное. Например, если взять несколько значений из нормального распределения, то они в основном лягут примерно по центру. А вот их p-значения равномерно распределятся между 0 и 1.
В статье вы чаще всего увидите p-значения только для лучшей гипотезы (что прыщи возникают от зелёных мармеладок, а лекарство прекрасно помогает пожилым женщинам латиноамериканского происхождения). Первый шаг к нормальному анализу — это [поправка Бонферрони](https://en.wikipedia.org/wiki/Bonferroni_correction):
> **Правило Бонферрони:** Порог P-значения в α для одной гипотезы эквивалентен порогу в α/N для лучшей из N гипотез.
>
>
Обычно её интерпретируют как верхнюю границу: порог в α/N для N гипотез заставляет принять нулевую гипотезу не чаще, чем порог в α для единственной протестированной гипотезы. Но, на самом деле, это неплохая аппроксимация: пусть h1,…,hN — это N p-значений для N независимых нулевых гипотез, и все они находятся в диапазоне от 0 до 1. Тогда вероятность того, что хотя бы одно из них ниже *α/N* = P(min(h1,…,hN) < α/N) = 1 – (1 – α/N)^N ≈ 1 – e^-α ≈ 1 – (1-α) = α. Последние шаги основываются на [линейной аппроксимации](http://www.drcruzan.com/DerivativesII.html) e^x ≈1+x, которая работает при близких к нулю x.
Но это доказательство работает для независимых гипотез. В случае мармеладок так оно и есть, а вот для мексиканских бабушек гипотезы взаимосвязаны. Шанс выздоровления, например, белых мужчин положительно коррелирует и с шансом выздоровления белых людей вообще (т.е. более широкой категории), и с шансом выздоровления белых пожилых мужчин (подмножества белых мужчин). Чтобы проверить применимость правила Бонферрони в такой ситуации, я прогнал симуляцию ([код доступен на Github](https://github.com/yashkaf/oldhispanic/blob/master/Multy.R)).
Пусть в нашей стране живут люди трёх возрастов (молодые, среднего возраста и старые), двух полов и четырёх рас. В каждой из 2\*3\*4=24 подгрупп по пятьсот человек, общее население — 12 000. По условиям задачи болезнь убивает 50% больных, так что в среднем ожидается 12 000/2=6 000 выживших. Для всей выборки мы получим p=0.05, если выздоровеет 50.75% (90 дополнительных выздоровевших) и p=0.0005, если вылечится 51.5%.
> **Правило больших выборок:** при достаточно большой выборке статистическая значимость не обязательно обозначает практическую значимость. Можно получить копеечный эффект с очень низким p-значением.
>
>
P-значения не особенно помогают *добраться до истины*. Но они повсюду, с ними легко работать, и они неплохо *отсекают откровенную чепуху*. Поскольку статья именно про это, я не буду влезать в байесовскую статистику и ограничусь обсуждением возможных манипуляций с p-значениями.
Вернёмся к нашей симуляции. Я прогнал её 1 000 раз для трёх лекарств: плацебо, вылечивающее 50%; статистически значимое лекарство, вылечивающее 50.75%; и хорошее лекарство, вылечивающее 51.5% (да, вот такие вот у нас критерии “хорошего”). Для каждого из лекарств я искал подгруппу, в которой оно выдаст лучшее p-значение:
```
13 hispanic 1 0.122530416511473
14 female hispanic 2 0.180797304026783
15 young hispanic 2 0.25172233581543
16 young female hispanic 3 0.171875
17 white 1 0.0462304905364621
18 female white 2 0.572232224047184
19 young white 2 0.25172233581543
20 young female white 3 0.9453125
21 adult 1 0.368777154492162
22 female adult 2 0.785204746078306
23 asian 1 0.953769509463538
24 female asian 2 0.819202695973217
```
Второе число — это глубина выбранной подгруппы (вся выборка — 0, “азиаты” — 1, “азиатские женщины среднего возраста” — 3). В нашем случае возможно 60 групп: 1 полная выборка, 9 групп глубины 1, 26 — глубины 2, 24 —- глубины 3. Так что поправка Бонферрони требует порога p-значения в 0.05/60=0.00083
В каждой из 1000 симуляций я выбрал самую удачную группу и построил график. Цветами показана глубина подгруппы, вертикальные линии соответствуют нескорректированному значению в 0.05 и скорректированному 0.00083. По горизонтальной оси — логарифм p-значения, по вертикальной — сколько симуляций (из 1000) имеют значение не ниже данного.
Безо всякого мошенничества плацебо получает p<0.05 в 5% случаев (что очевидно из определения), значимое лекарство — в 50% случаев, а хорошее — в 95. Но если мы применим поправку Бонферрони, то работающие лекарства пройдут проверку всего в 23% и 72% случаев соответственно. У плацебо дела ещё хуже, но всё-таки получается, что в таких случаях поправка оказывается чересчур агрессивной.
#### Как заметить подвох
Что всё это даёт на практике? Давайте соберём воедино все имеющиеся у нас советы.
1. [**Мощность**](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B0%D1%82%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BC%D0%BE%D1%89%D0%BD%D0%BE%D1%81%D1%82%D1%8C) **превыше всего**: если результат получен на крошечной выборке (и особенно если в исходных данных много шума) — дальше можно не читать.
2. **Считайте категории**: если вы видите результат только для одной подгруппы, посчитайте, сколько аналогичных категорий можно выделить из тех же данных.
3. **Применяйте поправку:** разделите исходный порог p-значения на то, что получилось в предыдущем пункте (или, что эквивалентно, умножьте на него само p-значение). Если полученный результат вас устраивает, хорошо.
4. **Сохраняйте скептицизм**: даже со всеми поправками сомнительный результат есть сомнительный результат, а статистическая значимость необязательно подразумевает реальную значимость. Сколь угодно низкое p-значение ещё ничего не гарантирует.
Существует [мета-анализ](https://f1000research.com/articles/4-1188/v2), подтверждающий с p=0.00000000012 способность некоторых людей предсказывать будущее. Цифра потрясающая, но она имеет смысл, только если нет ни малейших сомнений в том, что это исследование (и все предыдущие работы, на которые оно опирается) было проведено безупречно. Если есть причины считать, что это не так, то на самом деле p-значение намного выше полученного.
Можно предположить, что как минимум одна психологическая статья из тысячи выполнена некорректно, а то и вовсе [написана по сфабрикованным результатам](http://www.nytimes.com/2011/11/03/health/research/noted-dutch-psychologist-stapel-accused-of-research-fraud.html). Соответственно, любое полученное в психологии p-значение ниже 1/1000 ничем не лучше p-значения ровно в 1e-3. Вероятность получить результат в отсутствие изучаемого феномена равна собственно p-значению *плюс вероятность того, что исследование в целом некорректно.*
Посмотрим, что этот метод говорит нам насчёт ставки на Eagles. Во-первых, раз речь идёт о 10 выигранных играх, то 11-ю игру (в смысле 11-ю с конца, предшествующую этим 10) в аналогичных условиях они проиграли, иначе обсуждалась бы серия из 11 побед. Во-вторых, 10 игр — это не так чтоб очень большая выборка, но зато нет никакой погрешности измерения. Мы знаем со стопроцентной вероятностью, выиграли ли они ту или иную игру или проиграли. К мощности эксперимента формальных претензий нет.
А вот со вторым пунктом некоторые проблемы . Даже если Eagles действительно неплохо играют как не-фаворит на своём поле после удачного наступления в предыдущем матче, тот же самый матч может быть описан как “Игра сиэтлской команды после победы на выезде против команды, которая плохо пасует” (*прим. пер.: речь об описании матча с точки зрения их противников, Seattle Seahawks*), или как “Матч команды восточного дивизиона на западе против команды, выигравшей предыдущий матч”, или ещё несколькими тысячами способов. Число возможных параметров сложно даже посчитать, но попробуем прикинуть:
1. Описание одной команды: дивизион, родной город, история в этом сезоне, результат предыдущей игры, качество атаки и защиты, статистика отдельных игроков — итого не меньше 20 параметров.
2. Столько же для другой команды.
3. Обстоятельства игры: домашний / выездной матч, погода, время года, состояние поля, история игр между конкретными двумя командами — итого не меньше 10 параметров.
Даже если выбрать в каждой категории всего по 1 параметру, получится 4000 моделей. Что это означает для Eagles? Вероятность поражения, *согласно данной модели,* 1/1024, но поправка Бонферрони для 4000 гипотез говорит нам, что примерно 4 гипотезы аналогичной сложности должны оказаться верными по чистому совпадению. Разумеется, Экинс не перебрал их все; он просто порылся в данных, нашёл интересное совпадение и опубликовал его. Но при таком количестве возможных гипотез единственное совпадение ничего не стоит. В обсуждаемом матче Eagles проиграли со счётом 15:26.
Тот же критерий нужно применять каждый раз, когда кто-то хвастается превосходством в неожиданно узкой категории. На этой рекламе коллектив Тринити-Университета признан лучшим в Техасе (и 6-м в стране) среди “преподавателей, занимающихся исследованиями и читающих лекции”. При виде этой фразы сразу нужно задуматься, сколько ещё категорий было в цитируемом исследовании, сколько вообще существует рейтингов, и в скольких из них Тринити никаких мест не занял. Университет №1 *в общем рейтинге,* скорее всего, действительно хорош в преподавании; про университет №1 *в данной узкой категории* мы знаем только то, что они умеют перебирать все возможные рейтинги и подкатегории. | https://habr.com/ru/post/563600/ | null | ru | null |
# Пересаживаем NXP-шный пример для Teensy 4.1 на язык C++
В предыдущих статьях мы освоили внедрение примеров из NXP-шной среды разработки MCUXpresso в плату Teensy 4.1. Однако у тех примеров, с которыми мне довелось повозиться (а я работал с USB-примерами), есть один существенный (с моей точки зрения, разумеется) недостаток. Все они написаны на языке Си. Ну, то есть, «на чистых Сях», если на жаргоне. А вот оригинальная библиотека от Teensy была написана на С++. И я являюсь сторонником именно этого языка. Не могу жить без честных классов, виртуальных функций и некоторых других средств, которых нет в чистых Сях.
Когда я программирую в среде разработки Keil, чтобы сменить язык, достаточно переключить его в свойствах конкретного исходного файла. В цикле статей про NIOS II я просто переключал язык, изменив расширение файла с \*.c на \*.cpp. (Со всеми деталями это показано [тут](https://habr.com/ru/post/453682/) ; не как новинка, а как рутина — [тут](https://habr.com/ru/post/462253/)). Увы, в нашем случае так не получится. И количество действий, которое следует совершить, тянет на небольшую статью. Вот её я сейчас и напишу. Итак, давайте разбираться, что там к чему…
**Предыдущие статьи цикла**
1. [Запускаем программу созданную в NXP MCUXpresso на плате Teensy 4.1](https://habr.com/ru/post/564464/)
2. [Teensy 4.1 через MCUXpresso. Часть 2. Осваиваем GPIO и UART](https://habr.com/ru/post/569222/)
3. [Настраиваем сильносвязанные шины контроллера на плате Teensy 4.1](https://habr.com/ru/post/573900/)
4. [Оптимизируем производительность Teensy 4.1 при разработке в NXP MCUXpresso](https://habr.com/ru/post/574878/)
В целом, существует замечательная англоязычная статья, которая красиво расписывает все необходимые действия. Вот она [From C to C++: Converting Eclipse C Projects — DZone IoT](https://dzone.com/articles/from-c-to-c-converting-eclipse-c-projects). Как я уже привык, представленного в ней объёма данных для нашего конкретного случая недостаточно. Нам придётся сделать чуть больше. Но зато будет весело!
Раз — Добавляем натуру
----------------------
Почему у нас ничего не работает после смены расширения файла – USB-шные примеры от NXP не используют «натуру C++». Идём сюда:
И нажимаем Add. В реальной жизни вам потребуется перед этим кое-что сохранить, но я оставлю эту фразу для случая, когда вы зайдёте сюда уже как в справочник. Вы её увидите и всё вспомните. А сейчас, когда вы читаете текст как повествование, просто нажимайте Add и добавляйте натуру С++.
Дальше автор англоязычной статьи велит переименовать startup-код из startup\_mimxrt1062.c в startup\_mimxrt1062.cpp. Для этого наводимся на файл:
Дальше правая кнопка «мыши» и пункт меню Rename. Это надо, для того чтобы в нашем С++ коде вызывались конструкторы у всех глобально объявленных объектов, что обеспечивается следующими строками:
```
#if defined (__cplusplus)
//
// Call C++ library initialisation
//
__libc_init_array();
#endif
```
Всё! Мы выполнили указания из оригинальной статьи! Пробуем собрать код… Сначала фальстарт:
Тут всё просто. Делаем Clean Project и снова пытаемся собрать код…
Два — Восстанавливаем автоматику для формирования скрипта компоновщика
----------------------------------------------------------------------
Нам вываливают вот такую простыню с ошибками:
Видно, что дело происходит на этапе компоновки. Почему он не видит эти функции – я не знаю до сих пор. Некогда разбираться было. Нет, я честно порыскал по Гуглю, узнал, что проблемы возникают у многих, но в совершенно разных случаях. Дальше идут дебаты, ещё дальше – невнятное лечение. Когда мне надоело разбираться, я промотал список в конец, в надежде найти что-то более осмысленное, чтобы не просто сидеть и пялиться в экран. И нашёл более-менее понятные строки.
Константа \_\_baseNCACHE\_REGION соответствует скрипту компоновщика, причём автоматически формируемой его части. Ну и прекрасно, идём в настройки… И видим удивительную вещь:
Ещё три дня назад мне бы это ничего не сказало, но я слишком много экспериментировал со скриптом компоновщика, работая над [предыдущей статьёй](https://habr.com/ru/post/574878/). Я точно помню, что должна стоять галка Manage Linker Script. Ставим её. Опытный глаз говорит, что надо ещё вручную вбить размер кучи и стека, чтобы всё стало, как раньше. Ещё там были Extra Linker Script input sections. Можно и их вбить по образу и подобию того, что было раньше, но сегодняшняя статья заработает и без них. А правок нам предстоит ещё много, не буду прямо сейчас тратить силы.
Ну что, собираем?
Три — Переименовываем файл с функцией main()
--------------------------------------------
Собирается без ошибок. Но и не работает. Я решил переименовать файл virtual\_com.c в virtual\_com.cpp – именно в этом файле лежит функция main():
Собираем…
Четыре — Копируем настройки из сишной натуры в плюсовую
-------------------------------------------------------
Получаем ошибки такого вида:
Но ведь раньше-то всё находилось! Идём в настройки каталогов поиска заголовочных файлов, и видим:
А где всё? Смотрим вариант для Сишной культуры:
В общем, все-все-все списки, которые в сишной культуре заполнены – в плюсовой пусты. Ну, разве что в одном сиротливо болтаются три строчки вместо кучи. И наша задача – выделить в сишном списке первую строчку, потом – с шифтом последнюю:
Дальше – Ctrl+C, после чего – Ctrl+V в плюсовом списке. И так – для всех списков, что встретятся… Странно, сегодня встретилось всего два списка. Когда осваивал – казалось, что их много. Ну, тем лучше… Собираем!
Пять — Добавляем extern “C”, где следует
----------------------------------------
И снова ошибка компоновщика:
Но приятно, что нам сообщают, в каком файле был вызов. Сколько мне крови попила Visual Studio, которая говорила, какой символ не найден, но не говорила, какой файл его хочет!
Очевидно, что перед нами несовместимость именования. Большинство заголовочных файлов примера содержат такие строки:
```
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
…
#if defined(__cplusplus)
}
#endif /* __cplusplus */
```
А в файле usb\_device\_descriptor.h, где объявлена та проблемная функция USB\_DeviceSetSpeed(), разработчики из NXP такое добавить забыли. И вот результат! Так что добавим подобное и в него. Первые три строки – почти в начало, последние – почти в конец. Собираем!!!
Шесть — Добавляем секретный блок
--------------------------------
Запускаем – строчки в терминал выводятся:
Но виртуальный COM-порт в менеджере устройств не появляется. То есть чего-то не хватает. Разглядывая настройки, я заметил вот такой сиротливый блок:
Причём блока MCU C Linker нет, скопировать неоткуда! Придётся скопировать из любого другого проекта, в котором плюсовая культура не добавлялась.
> **Кстати, именно про этот подготовительный этап я и говорил на первом шаге. Можно было скопировать и из текущего проекта, но до этапа добавления культуры!**
Собираем, запускаем…
Семь — Нужно больше extern “C”
------------------------------
Та же картинка. Не работает! И ведь возможности отладки нет, потому что на плате отсутствует разъём JTAG! Как найти, кто виноват? Только из прошлого своего опыта я понял, что надо смотреть вектора прерываний внутри cpp-файла. И они нашлись:
Переписываем так:
```
extern "C"
void USB_OTG1_IRQHandler(void)
{
USB_DeviceEhciIsrFunction(s_cdcVcom.deviceHandle);
}
extern "C"
void USB_OTG2_IRQHandler(void)
{
USB_DeviceEhciIsrFunction(s_cdcVcom.deviceHandle);
}
```
Собираем, прошиваем…
РАБОТАЕТ! С примерами от MCUXPresso – всё. Но на всякий случай, сделаю ещё один исключительно справочный раздел для более серьёзной работы.
Проблемы одновременной работы С++ и сильносвязанных шин
-------------------------------------------------------
Если вы попробуете применить знания, почерпнутые из предыдущих статей, чтобы разместить полученный код на языке C++ в ОЗУ, доступном через сильносвязанную шину, вас ждёт разочарование. Компилятор отработает без проблем, а вот компоновщик выкатит море ошибок примерно такого вида:
Черновик статьи был написан весной и долго пролежал в столе. Проблема была найдена летом, когда уже стало ясно, что тема не вызывает особого интереса у читателей. Поэтому я не буду рассказывать обо всём в подробностях, а только опишу выводы для тех, кто будет пользоваться полученными знаниями на практике.
Причина бед в том, что часть библиотек поставляется не в виде исходных кодов, а в виде объектных файлов. Поэтому если там применены команды CALL и/или JMP, заменить их ни на что уже нельзя. А область ПЗУ для XIP отстоит от области ОЗУ для сильносвязанной шины инструкций ой как сильно:
Применённым в объектных файлах командам не хватает допустимой длины для перехода…
Первое, что надо сделать – отключить функционал RTTI и обработки исключений. Это пишут на многих форумах. Сам я этим функционалом никогда не пользуюсь, мне его лишиться не страшно. На всякий случай я провёл опрос среди коллег, сильно ли они расстроятся от его потери. Все они в один голос заявили, что при работе с микроконтроллерами, его отключать просто необходимо, потому что он расходует память программ и стек так, как можно позволить себе только в больших системах! В общем, добавляем в опции компилятора следующие:
**-fno-exceptions -fno-rtti**
В свойствах проекта эти магические заклинания надо вставить сюда:
Ошибок станет меньше, но они не исчезнут вовсе. Гипнотизируя оставшиеся сообщения об ошибках и проводя массу экспериментов, мне удалось выявить, что надо добавить ещё один шаблон для скрипта компоновщика (рядом с теми, которые мы создавали в [предыдущей статье](https://habr.com/ru/post/574878/)). Имя файла: exdata.ldt, его соджержимое:
```
/*
* for exception handling/unwind - some Newlib functions (in common
* with C++ and STDC++) use this.
*/
.ARM.extab : ALIGN(${text_align})
{
*(.ARM.extab* .gnu.linkonce.armextab.*)
} > SRAM_ITC AT> ${CODE}
.ARM.exidx : ALIGN(${text_align})
{
__exidx_start = .;
*(.ARM.exidx* .gnu.linkonce.armexidx.*)
__exidx_end = .;
} > SRAM_ITC AT> ${CODE}
```
Заключение
----------
Мы научились перетаскивать реальные примеры от NXP с языка Си на возможность вставки модулей на языке С++. Для этого нам пришлось пройти семь шагов. Многовато! Но вполне терпимо. Я уверен, что можно написать программу, которая выполнит самую неприятную часть шагов за нас, автоматически дорабатывая файл проекта, так как это обычный XML-файл. Но Заказчик не проявил особого интереса к работе с C++, поэтому тема автоматической правки не была включена в задачи по проекту. А потом меня засосали другие работы.
Так или иначе, а теперь мы можем вставлять в наш проект как минимум какие-то наработки из оригинальной библиотеки Teensy 4.1, а как максимум – свои удобные классы, которые наверняка напишем в будущем.
Послесловие
-----------
Первые шесть статей для цикла были написаны в апреле-мае, одновременно с освоением новой техники и созданием официальных отчётов. Потом было отвлечение на другие задачи, дальше – небольшой затык с переносом GDB Stub с Ардуиновской идеологии на рельсы MCUXPresso. А потом первая из заготовок была опубликована, и стало ясно, что вообще тема Teensy 4.1 для штатных библиотек NXP мало кому интересна.
Как говаривал мой научный руководитель: «Ненужная работа хуже пьянства», поэтому дальше я просто перестал делать русскоязычные развёрнутые описания. Заказчику было достаточно коротких англоязычных отчётов. Так что тема обрывается из-за отсутствия спроса.
Но в целом, я уже показал, что Teensy 4.1 содержит достаточно мощный контроллер. А малое количество штатных библиотек Teensyduino – не беда. С этой платой вполне можно использовать всю мощь фирменных библиотек от NXP. Как ими пользоваться – в целом ясно из уже описанных примеров. Но ещё раз отмечаю, что у этой платы нет JTAG-разъёма. Соответствующие ножки у контроллера есть, они даже по плате идут для внутренних целей, но на разъём – не выходят. Так что покупать или нет такую плату – каждый решает сам. JTAGа нет, но контроллер о-о-о-о-о-о-очень мощный! И библиотеки от NXP – классные! | https://habr.com/ru/post/577914/ | null | ru | null |
# Faker API для .NET — генерация случайных имен и других данных
Помню, недавно выполнял задание на вакансию масленка **после технического собеседования**.
**Формулировка следующая:**
> `- Необходимо сгенерировать список случайных объектов по предоставленным моделям, сериализовать их в json, после загрузить их из файла в обратно память.`
>
>
В общем, простое задание на **джуна**, хоть не аналог авито писать, и на том спасибо.
**Оригинальная формулировка задания:**
```
Create a program which will execute the next steps:
1) Create collection of randomly generated objects in memory by provided models, number of ofjects 10000;
2) Serialyze it to JSON format;
3) Write the serialization result to the current user desktop directory, the text file name should be "Persons.json";
4) Clear the in memory collection;
5) Read objects from file;
6) Display in console persons count, persons credit card count, the average value of child age.
Use POSIX format for dates.
Use lowerCamelCase JSON notation in result file.
```
```
// Data models
class Person
{
public Int32 Id { get; set; }
public Guid TransportId { get; set; }
public String FirstName { get; set; }
public String LastName { get; set; }
public Int32 SequenceId { get; set; }
public String[] CreditCardNumbers { get; set; }
public Int32 Age { get; set; }
public String[] Phones { get; set; }
public Int64 BirthDate { get; set; }
public Double Salary { get; set; }
public Boolean IsMarred { get; set; }
public Gender Gender { get; set; }
public Child[] Children { get; set; }
}
class Child
{
public Int32 Id { get; set; }
public String FirstName { get; set; }
public String LastName { get; set; }
public Int64 BirthDate { get; set; }
public Gender Gender { get; set; }
}
enum Gender
{
Male,
Female
}
```
Я если честно не понимаю, почему нельзя просто использовать псевдонимы системных типов, подскажите в комментариях.
### Подключаем Faker
**Faker** можно добавить в проект через менеджер пакетов **NuGet**.
У данного пространства есть целая куча классов, с помощью которым можно генерировать те или иные **данные**:
`Faker.Address` - `генерация адресов`
`Faker.Boolean`- `генерация логических данных`
`Faker.Company`- `генерация компаний`
`Faker.Identification`- `генерация идентификационных данных`
`Faker.Finance`- `генерация финансовых значений`
`Faker.Name`- `генерация имен`
Подключаем нужное **пространство имен** и начинаем пользоваться:
```
using Faker;
using Collection.Data;
namespace Collection.Generator
{
internal class PersonsGenerator
{
public List persons = new List();
Random random = new Random();
DateTimeGeneration birthdayDate = new DateTimeGeneration();
PhonesGenerator phones = new PhonesGenerator();
ChildGenerator children = new ChildGenerator();
CreditCardsGeneration creditCards = new CreditCardsGeneration();
public PersonsGenerator(int count)
{
for (int i = 0; i < count; ++i)
{
persons.Add(new Person
{
Id = i,
TransportId = Guid.NewGuid(),
// Случайная генерация имен
FirstName = Faker.Name.First(),
LastName = Faker.Name.Last(),
SequenceId = i,
CreditCardNumbers = creditCards.CreateCreditCards(),
// Числа тоже можно генерировать
Age = Faker.RandomNumber.Next(18, 100),
Phones = phones.CreatePhones(),
BirthDate = ((DateTimeOffset)birthdayDate.CreateBirthdayDate()).ToUnixTimeSeconds(),
Salary = (double)Faker.RandomNumber.Next(10000, 100000),
IsMarred = Faker.Boolean.Random(),
// Можно рандомизировать константы из перечислений
Gender = Faker.Enum.Random(),
Children = children.CreateChildren(out childrenCount)
});
}
}
}
}
```
Теперь можно попробовать вывести все это в консоль, я написал небольшой класс с рефлексией, который выводит **данные в консоль:**
```
internal class ConsoleWriter where T: class
{
public ConsoleWriter(List collection)
{
Type type = typeof(T);
PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var o in collection)
{
for (int i = 0; i < properties.Length; i++)
{
Console.WriteLine($"{properties[i].Name}:\t{properties[i].GetValue(o)}");
// Не обращаем внимание, так, для себя сделал
if (properties[i].PropertyType.IsArray)
{
Console.WriteLine("Array!");
}
}
Console.WriteLine();
}
}
}
```
```
static void Main(string[] args)
{
// Здесь генерация объектов
PersonsGenerator generator = new PersonsGenerator(5);
JsonWriter jsonWriter = new JsonWriter();
JsonReader jsonReader = new JsonReader();
// Вот здесь вывод данных в консоль после генерации
ConsoleWriter debuger = new ConsoleWriter(generator.persons);
Console.WriteLine("Reflection is end. Push ENTER to continue...");
// Запись данных в JSON
jsonWriter.WriteToFile(generator.persons);
Console.WriteLine("Serialization is complete!");
// Очистка после подтверждения
Console.ReadLine();
generator.persons.Clear();
generator.Dispose();
// Чтение из файла
var persons = jsonReader.ReadFromFile();
// Вывод данных
ValueCounter counter = new ValueCounter();
Console.WriteLine($"Persons count is {persons.Count}");
Console.WriteLine($"Average children age is {counter.AverageChildAge(persons)}");
Console.WriteLine($"Credit cards count is {counter.CreditCardCount(persons)}");
Console.ReadKey();
}
```
**Результат** в консоли следующий:
Имена конечно иногда странные, но, как мне кажется для тестов вполне сойдет.
### Итоги
В конечном итоге, меня не взяли на работу масленком, дав следующий ответ:
> **HR:** *Даниил, здравствуйте!
> Мы благодарим Вас за проявленный интерес к нашей компании и желание с нами сотрудничать.
> На позицию, которую мы Вас рассматривали, мы пока не готовы Вам сделать предложение о работе. С Вашего позволения мы хотели бы Ваше резюме добавить в кадровый резерв, чтобы в случае, если у нас появится подходящая вакансия, связаться с Вами.
> Также мы желаем Вам успехов в поисках работы!*
>
> **Я:** *Опишите пожалуйста более точно причину отказа.*
>
> **HR:** *Уточнила, тимлид обещал ответить сегодня вечером или завтра до обеда*
>
> *---"Через 3 часа"---*
>
> **HR:** *Даниил, по поводу обратной связи: самое основное - недостаточно теоретических знаний и отсутствие опыта работы с asp net.*
>
>
Как мне сказали люди, скорее всего они нашли кандидата лучше, но ничего страшного, может в другой раз повезет. Зато я познакомился с новым интересным инструментом, надеюсь, что в дальнейшем.
Было бы интересно почитать ваши советы и отзывы по поводу статьи, так как пишу первый раз что-то подобное. Спасибо!
 | https://habr.com/ru/post/673674/ | null | ru | null |
# Понимание итераторов в Python
Python — особенный язык в плане итераций и их реализации, в этой статье мы подробно разберём устройство итерируемых объектов и пресловутого цикла `for`.
Особенности, с которыми вы часто можете столкнуться в повседневной деятельности
-------------------------------------------------------------------------------
### 1. Использование генератора дважды
```
>>> numbers = [1,2,3,4,5]
>>> squared_numbers = (number**2 for number in numbers)
>>> list(squared_numbers)
[1, 4, 9, 16, 25]
>>> list(squared_numbers)
[]
```
Как мы видим в этом примере, использование переменной `squared_numbers` дважды, дало ожидаемый результат в первом случае, и, для людей незнакомых с Python в достаточной мере, неожиданный результат во втором.
### 2. Проверка вхождения элемента в генератор
Возьмём всё те же переменные:
```
>>> numbers = [1,2,3,4,5]
>>> squared_numbers = (number**2 for number in numbers)
```
А теперь, дважды проверим, входит ли элемент в последовательность:
```
>>> 4 in squared_numbers
True
>>> 4 in squared_numbers
False
```
Получившийся результат также может ввести в заблуждение некоторых программистов и привести к ошибкам в коде.
### 3. Распаковка словаря
Для примера используем простой словарь с двумя элементами:
```
>>> fruits_amount = {'apples': 2, 'bananas': 5}
```
Распаковываем его:
```
>>> x, y = fruits_amount
```
Результат будет также неочевиден, для людей, не понимающих устройство Python, "под капотом":
```
>>> x
'apples'
>>> y
'bananas'
```
Последовательности и итерируемые объекты
----------------------------------------
По-сути, вся разница, между последовательностями и итерируемымыи объектами, заключается в том, что в последовательностях элементы упорядочены.
Так, последовательностями являются: списки, кортежи и даже строки.
```
>>> numbers = [1,2,3,4,5]
>>> letters = ('a','b','c')
>>> characters = 'habristhebestsiteever'
>>> numbers[1]
2
>>> letters[2]
'c'
>>> characters[11]
's'
>>> characters[0:4]
'habr'
```
Итерируемые объекты же, напротив, не упорядочены, но, тем не менее, могут быть использованы там, где требуется итерация: цикл `for`, генераторные выражения, списковые включения — как примеры.
```
# Can't be indexed
>>> unordered_numbers = {1,2,3}
>>> unordered_numbers[1]
Traceback (most recent call last):
File "", line 1, in
TypeError: 'set' object is not subscriptable
>>> users = {'males': 23, 'females': 32}
>>> users[1]
Traceback (most recent call last):
File "", line 1, in
KeyError: 1
# Can be used as sequence
>>> [number\*\*2 for number in unordered\_numbers]
[1, 4, 9]
>>>
>>> for user in users:
... print(user)
...
males
females
```
Отличия цикла `for` в Python от других языков
---------------------------------------------
Стоит отдельно остановиться на том, что цикл `for`, в Python, устроен несколько иначе, чем в большинстве других языков. Он больше похож на `for...each`, или же `for...of`.
Если же, мы перепишем цикл `for` с помощью цикла `while`, используя индексы, то работать такой подход будет только с последовательностями:
```
>>> list_of_numbers = [1,2,3]
>>> index = 0
>>> while index < len(list_of_numbers):
... print(list_of_numbers[index])
... index += 1
...
1
2
3
```
А с итерируемыми объектами, последовательностями не являющимися, не будет:
```
>>> set_of_numbers = {1,2,3}
>>> index = 0
>>> while index < len(set_of_numbers):
... print(set_of_numbers[index])
... index += 1
...
Traceback (most recent call last):
File "", line 2, in
TypeError: 'set' object is not subscriptable
```
Если же вам нужен `index`, то следует использовать встроенную функцию `enumerate`:
```
>>> set_of_numbers = {1,2,3}
>>> for index, number in enumerate(set_of_numbers):
... print(number, index)
...
1 0
2 1
3 2
```
### Цикл `for` использует итераторы
Как мы могли убедиться, цикл `for` не использует индексы. Вместо этого он использует так называемые **итераторы**.
Итераторы — это такие штуки, которые, очевидно, можно итерировать :)
Получить итератор мы можем из любого итерируемого объекта.
Для этого нужно передать итерируемый объект во встроенную функцию `iter`:
```
>>> set_of_numbers = {1,2,3}
>>> list_of_numbers = [1,2,3]
>>> string_of_numbers = '123'
>>>
>>> iter(set_of_numbers)
>>> iter(list\_of\_numbers)
>>> iter(string\_of\_numbers)
```
После того, как мы получили итератор, мы можем передать его встроенной функции `next`.
```
>>> set_of_numbers = {1,2,3}
>>>
>>> numbers_iterator = iter(set_of_numbers)
>>> next(numbers_iterator)
1
>>> next(numbers_iterator)
2
```
При каждом новом вызове, функция отдаёт один элемент. Если же в итераторе элементов больше не осталось, то функция `next` породит исключение `StopIteration`.
```
>>> next(numbers_iterator)
3
>>> next(numbers_iterator)
Traceback (most recent call last):
File "", line 1, in
StopIteration
```
По-сути, это единственное, что мы может сделать с итератором: передать его функции `next`.
Как только итератор становится пустым и порождается исключение `StopIteration`, он становится совершенно бесполезным.
Реализация цикла `for` с помощью функции и цикла `while`
--------------------------------------------------------
Используя полученные знания, мы можем написать цикл `for`, не пользуясь самим циклом `for`. :)
Чтобы сделать это, нам нужно:
1. Получить итератор из итерируемого объекта.
2. Вызвать функцию `next`.
3. Выполнить 'тело цикла'.
4. Закончить цикл, когда будет получено исключение `StopIteration`.
```
def for_loop(iterable, loop_body_func):
iterator = iter(iterable)
next_element_exist = True
while next_element_exist:
try:
element_from_iterator = next(iterator)
except StopIteration:
next_element_exist = False
else:
loop_body_func(element_from_iterator)
```
Стоит заметить, что здесь мы использовали конструкцию `try-else`. Многие о ней не знают. Она позволяет выполнять код, если исключения не возникло, и код был выполнен успешно.
Теперь мы знакомы с **протоколом итератора**.
А, говоря простым языком — с тем, как работает итерация в Python.
Функции `iter` и `next` этот протокол формализуют. Механизм везде один и тот же. Будь то пресловутый цикл `for` или генераторное выражение. Даже распаковка и "звёздочка" используют **протокол итератора**:
```
coordinates = [1,2,3]
x, y, z = coordinates
numbers = [1,2,3,4,5]
a,b, *rest = numbers
print(*numbers)
```
### Генераторы — это тоже итераторы
Генераторы тоже реализуют протокол итератора:
```
>>> def custom_range(number):
... index = 0
... while index < number:
... yield index
... index += 1
...
>>> range_of_four = custom_range(4)
>>> next(range_of_four)
0
>>> next(range_of_four)
1
>>> next(range_of_four)
2
>>> next(range_of_four)
3
>>> next(range_of_four)
Traceback (most recent call last):
File "", line 1, in
StopIteration
```
### В случае, если мы передаём в `iter` итератор, то получаем тот же самый итератор
```
>>> numbers = [1,2,3,4,5]
>>> iter1 = iter(numbers)
>>> iter2 = iter(iter1)
>>> next(iter1)
1
>>> next(iter2)
2
>>> iter1 is iter2
True
```
Подытожим.
**Итерируемый объект** — это что-то, что можно итерировать.
**Итератор** — это сущность порождаемая функцией `iter`, с помощью которой происходит итерирование **итерируемого объекта**.
Итератор не имеет индексов и может быть использован только один раз.
Протокол итератора
------------------
Теперь формализуем протокол итератора целиком:
1. Чтобы получить итератор мы должны передать функции `iter` итерируемый объект.
2. Далее мы передаём итератор функции `next`.
3. Когда элементы в итераторе закончились, порождается исключение `StopIteration`.
Особенности:
1. Любой объект, передаваемый функции `iter` без исключения `TypeError` — итерируемый объект.
2. Любой объект, передаваемый функции `next` без исключения `TypeError` — итератор.
3. Любой объект, передаваемый функции `iter` и возвращающий сам себя — итератор.
Плюсы итераторов:
1. Итераторы работают "лениво" (en. **lazy**). А это значит, что они не выполняют какой-либо работы, до тех пор, пока мы их об этом не попросим.
2. Таким образом, мы можем **оптимизировать потребление ресурсов ОЗУ и CPU**, а так же **создавать бесконечные последовательности**.
Итераторы повсюду
-----------------
Мы уже видели много итераторов в Python.
Я уже упоминал о том, что генераторы — это тоже итераторы.
Многие встроенные функции является итераторами.
Так, например, `enumerate`:
```
>>> numbers = [1,2,3]
>>> enumerate_var = enumerate(numbers)
>>> enumerate_var
>>> next(enumerate\_var)
(0, 1)
```
А так же `zip`:
```
>>> letters = ['a','b','c']
>>> z = zip(letters, numbers)
>>> z
>>> next(z)
('a', 1)
```
И даже `open`:
```
>>> f = open('foo.txt')
>>> next(f)
'bar\n'
>>> next(f)
'baz\n'
>>>
```
В Python очень много итераторов, и, как уже упоминалось выше, они откладывают выполнение работы до того момента, как мы запрашиваем следующий элемент с помощью `next`. Так называемое, "ленивое" выполнение.
Создание собственного итератора
-------------------------------
Так же, в некоторых случаях, может пригодится знание того, как написать свой собственный итератор и **ленивый** итерируемый объект.
В моей карьере этот пункт был ключевым, так как вопрос был задан на собеседовании, которое, как вы могли догадаться, я успешно прошёл и получил свою первую работу:)
```
class InfiniteSquaring:
"""Класс обеспечивает бесконечное последовательное возведение в квадрат заданного числа."""
def __init__(self, initial_number):
# Здесь хранится промежуточное значение
self.number_to_square = initial_number
def __next__(self):
# Здесь мы обновляем значение и возвращаем результат
self.number_to_square = self.number_to_square ** 2
return self.number_to_square
def __iter__(self):
"""Этот метод позволяет при передаче объекта функции iter возвращать самого себя, тем самым в точности реализуя протокол итератора."""
return self
```
```
>>> squaring_of_six = InfiniteSquaring(6)
>>> next(squaring_of_six)
36
>>> next(squaring_of_six)
1296
>>> next(squaring_of_six)
1679616
>>> next(squaring_of_six)
2821109907456
>>> next(squaring_of_six)
7958661109946400884391936
>>> # И так до бесконечности...
```
Так же:
```
>>>iter(squaring_of_six) is squaring_of_six
True
```
Таким образом мы написали **бесконечный** и **ленивый** итератор.
А это значит, что ресурсы он будет потреблять только при вызове.
Не говоря уже о том, что без собственного итератора имлементация бесконечной последовательности была бы невозможна.
А теперь вернёмся к тем особенностям, которые были изложены в начале статьи
---------------------------------------------------------------------------
### 1. Использование генератора дважды
```
>>> numbers = [1,2,3,4,5]
>>> squared_numbers = (number**2 for number in numbers)
>>> list(squared_numbers)
[1, 4, 9, 16, 25]
>>> list(squared_numbers)
[]
```
В данном примере, список будет содержать элементы только в первом случае, потому что генераторное выражение — это итератор, а итераторы, как мы уже знаем — сущности одноразовые. И при повторном использовании не будут отдавать никаких элементов.
### 2. Проверка вхождения элемента в генератор
```
>>> numbers = [1,2,3,4,5]
>>> squared_numbers = (number**2 for number in numbers)
```
А теперь дважды проверим, входит ли элемент в последовательность:
```
>>> 4 in squared_numbers
True
>>> 4 in squared_numbers
False
```
В данном примере, элемент будет входить в последовательность только 1 раз, по причине того, что проверка на вхождение проверяется путем перебора всех элементов последовательности последовательно, и как только элемент обнаружен, поиск прекращается. Для наглядности приведу пример:
```
>>> 4 in squared_numbers
True
>>> list(squared_numbers)
[9, 16, 25]
>>> list(squared_numbers)
[]
```
Как мы видим, при создании списка из генераторного выражения, в нём оказываются все элементы, после искомого. При повторном же создании, вполне ожидаемо, список оказывается пуст.
### 3. Распаковка словаря
При использовании в цикле `for`, словарь будет отдавать ключи:
```
>>> fruits_amount = {'apples': 2, 'bananas': 5}
>>> for fruit_name in fruits_amount:
... print(fruit_name)
...
apples
bananas
```
Так как распаковка опирается на тот же протокол итератора, то и в переменных оказываются именно ключи:
```
>>> x, y = fruits_amount
>>> x
'apples'
>>> y
'bananas'
```
Выводы
------
Последовательности — итерируемые объекты, но не все итерируемые объекты — последовательности.
Итераторы — самая простая форма итерируемых объектов в Python.
Любой итерируемый объект реализует протокол итератора. Понимание этого протокола — ключ к пониманию любых итераций в Python. | https://habr.com/ru/post/488112/ | null | ru | null |
# Приключение на 5 минут: как мы переводили все зависимости на SPM
Привет, Хабр!
Меня зовут Вильян Яумбаев, в этой статье я расскажу вам про наши приключения на пути к SPM.
В 2015 ПСБ начал разрабатывать проект для бизнеса. Для него, в свою очередь, было нужно приложение. Сперва всё находилось в одном репозитории одного проекта в одном воркспейсе. Первые авторы подключали сторонние зависимости через CocoaPods, поскольку проприетарного менеджера зависимостей ещё не существовало. Но в тот же год в Apple началась работа над Swift Package Manager. Им предстояло встретиться в нашем проекте.
В этой статье расскажу, через что мы прошли, переводя зависимости на SPM, и поделюсь нашими наработками.
Пора меняться
-------------
Изначально код проекта состоял из Objective-C. Затем разработчики перешли на Swift, но древний код атлантов никто не переписывал, ибо работает — не трогай. Количество разработчиков увеличивалось с каждым годом.
Пришло время, и к проекту присоединился автор этого текста. «Пора меняться», — вот что вспыхнуло в моей голове, когда я взглянул на проект. Тогда я увидел его ужасное будущее, уготованное ему историей Git’а, конфликтами слияния и ежесекундным обновлением мастер-ветки. Оставался лишь один путь избежать этой участи — взять курс на модульность.
Первый модуль
-------------
Главными вопросами стали «С чего начать?» и «Где взять время?». У всех нас были в работе собственные бизнес-юниты. Нужно было договориться о времени на такого рода задачи. В итоге решили, что на технические задачи уйдёт 20% времени каждый спринт, два дня в спринт.
Чтобы определиться, собрался совет верховных магов iOS-технологий. Ответ был взвешенным и давал надежду на дальнейшую жизнь проекта: начнём с простого и постепенно будем переходить к сложному.
Мы сформировали стратегию. Она подразумевала, что у нас будут общие модули утилит, а также основные продуктовые модули, относящиеся к конкретному бизнес-функционалу. Но для того, чтобы разделить проект на такие фреймворки, нужно сначала вынести все их зависимости.
Мы начинали с xcodeproj для отдельных модулей, чтобы со временем перейти на менеджер зависимостей. Первым стал CoreNetwork как самостоятельная единица — пример того, что проект ещё можно спасти, если двигаться в этом направлении. Тогда, 19 ноября 2019, был взят курс на перестройку монолитного проекта ПСБ в модульную систему. Мы представляли, какой объём работ нас ожидает, но не страшились его: если не преодолевать трудности, то зачем вообще писать код?
При выносе первого модуля без проблем не обошлось: проект был написан на Swift и на Objective-C. И если с первым было всё просто, то со вторым пришлось изрядно попотеть.
После выноса первого модуля мы выработали определённые прикладные практики по выносу модулей, по разделению функционала, по решению проблем, связанных с выносом. Модули полились рекой — или ручейком, маленьким и узким — и спустя год мы уже имели восемь общих и одиннадцать продуктовых фреймворков. Мы создали иерархию модулей по уровням L0, L1, L2 и так далее, установив такое правило: модуль может иметь зависимость только на модули уровнями ниже, чтобы граф зависимостей не был цикличен. Чтобы удобно просматривать их, в Xcode workspace завели группы: L0, L1, L2 и так далее.
Менеджер зависимостей для мультирепозитория
-------------------------------------------
Ещё в начале процесса мы поставили цель: разнести все модули в отдельные репозитории. Когда количество модулей более-менее устаканилось, начали думать в эту сторону. Вариантов было немного:
***Git Submodules***: до боли простой в использовании, но не совсем удобен в разработке, да и особой практики в использовании нет.
***Carthage***: у нас не было практики использования в проекте и казалось переходить на него будет не просто. Опять же, не было практики.
***CocoaPods***: хороший кандидат, но есть сложности с версионированием. Наши модули находятся в приватных репозиториях, а для того, чтобы устроить нормальное версионирование приватных репозиториев, нужно завести приватный репозиторий со спеками. Это и есть проблема: при выходе новой версии модуля мало отправить новую версию в репозиторий самого фреймворка, нужно ещё обновить её в репозитории со спеками. А ещё есть сложность с отладкой монолита приложения, когда надо проверить локальные изменения кода на лету. Для этого придётся изменять Podfile, проводить pod install и потом не забыть вернуть всё обратно.
***SPM***: наш вариант, на который хотелось бы перейти, «пока не поздно». Те же преимущества, что и у CocoaPods, и нет проблем с выпуском: очень простая отладка мультирепозиторного приложения и всё версионирование идёт по тегам в Git'е. Для проверки локальных изменений достаточно папку с модулем переместить в workspace приложения, и можно редактировать модуль и отлаживать его на лету. Так же просто вернуть всё как было — удалить модуль из воркспейса, и подтянется версия из Git’а.
Из этих менеджеров зависимостей мы очень хотим перейти именно на SPM. О нём задумывались ещё в начале 2020 года, но у него были сложности с поддержкой Objective-C кода и ресурсов. Со временем SPM решил их.
SPM vs CocoaPods
----------------
В начале 2021 года по заверениям команды SPM и по опыту других компаний, проблема с Objective-C решена, и даже можно включить ресурсы в содержимое пакета. Эта фича нам необходима для модуля дизайн-системы, так как в ней находятся переиспользуемые картинки. Представим, что SPM — это бутерброд в прозрачном контейнере, и попробуем его на вкус.
Начинаем с небольшого модуля с утилитными объектами, которые используются по всему проекту. Называем его PSBCore (или просто корой). Пробуем его перевести на SPM. Для перевода модуля xcodeproj в SPM получился небольшой shell сниппет:
```
module="PSBCore"; \
swift package init; \
rm -rf "Sources/$module/$module.swift"; \
rm -rf "Sources/${module}Tests/${module}Tests.swift"; \
cp -rf $module Sources; \
rm -rf $module; \
cp -rf ${module}Tests Tests; \
rm -rf ${module}Tests;
```
Пробуем собрать сам пакет — всё ок, компилируется. У нас модули были пролинкованы вручную, поэтому с новым SPM-пакетом надо проделать то же самое — вручную пролинковать во все модули, в которых используется PSBCore.
Собираем монолит — не работает. Пишет про ошибки «*Module ‘PSBCore' not found*», при этом ошибка указывает на генерируемые файлы Module-Swift.h — там, где в строчках идёт импорт библиотеки `@import PSBCore`. Module-Swift.h нам нужны, поскольку в проекте Swift + ObjC.
Неужели проблема с Objective-C не решена? И почему он жалуется именно на импорт PSBCore?
На руках имеем такую картину: SPM на 100% работает с кодом ObjC, так как у коллег из розничного приложения ПСБ есть целый SPM-пакет на ObjC. Но у них полноценный пакет на ObjC и там нет смешивания Swift + ObjC. Значит, SPM может в ObjC — это выяснили.
Следующий момент: в одном из продуктовых модулей приложения для юридических лиц одна из внутрибанковских библиотек через SPM уже подключена, при этом компилятор на неё не жалуется. Хм. Значит, проблема не в SPM и не в Objective-C.
На скорую руку делаем вывод, что SPM не работает в проектах со смешанными языками, и убеждаемся в этом, погуглив свои проблемы, правда ссылки не первой свежести, но и не протухшие. Обижаемся на SPM, бросаем его и держим в голове мысль о том, чтобы написать гневную статью про то, какие Apple плохие.
Возвращаемся к CocoaPods
------------------------
Роем в сторону приватного репозитория с подспеками. Вроде ничего сверхъестественного.
* Да, нужно каждую версию деплоить в репозиторий со спеками.
* Да, это сложнее, чем просто поставить тег на мастер-ветку, как в SPM.
* Да, придётся повозиться с удалением или перезаписью версии, если что-то пошло не так.
Есть перечень минусов CocoaPods, в которых он проигрывает SPM по удобству, но мы уже выяснили, что SPM не работает в проектах со смешанными языками (спойлер — это не так). Уже смирились, что возвращаемся в каменный век, где описание зависимостей проводится на Ruby в CocoaPods, и тут сталкиваемся с ещё одной проблемой, которая важна для нас — версионирование подов для разных релизов. Перед этим рассмотрим, как проходит контроль версий.
Про версионирование в релизном цикле
------------------------------------
Начнём с простого примера. Когда мы просто выпускаем версию приложения в релиз, у нас проект разбит на модули, и модули находятся в своих отдельных репозиториях. Каждый модуль следует правилам [семантического версионирования](https://semver.org/lang/ru/): разработчики повышают мажорную версию, если ломается обратная совместимость модуля. Когда мы фиксируем версию приложения, нам нужно в том числе зафиксировать версии всех модулей, потому что если этого не сделать и версия какого-то модуля обновится, то в релиз может уйти код, не предназначенный для текущего релиза.
В ведении мультирепозиторных модулей есть нюанс: если мы переходим на новую мажорную версию для модуля нижнего ранга, то нужно обновить до новой версии все модули вплоть до самого верхнего. Представим такую ситуацию:
В такой диаграмме зависимостей, если номер версии в модуле А подняли до 2.0.0, нам придётся все связи ***upToNextMajor\**** тоже поднять до 2.0.0 — для каждой связи. Даже если мы внесли изменения в модуль А, которые хотели использовать в модуле С, а для модуля В они не нужны.
***\* upToNextMajor*** *обозначает правило связи между модулями. upToNextMajor 1.0.0 от модуля B к модулю A обозначает, что модуль B может использовать все версии модуля A до следующей мажорной версии 2.0.0.*
Иначе граф не скомпилируется, так как в конечном итоге приложение не может использовать одновременно две версии модуля. Соответственно нам необходимо в модуле В теперь тоже поддержать новую версию 2.0.0. Теперь, поскольку мы используем новую, обратно несовместимую версию, для модуля В мы тоже поднимаем номер версии — и так до самой вершины графа, до приложения.
В конечном итоге для того, чтобы внести мажорные изменения в модули нижнего порядка, нам нужно пройтись по всему графу и использовать новую версию везде.
Это не плохо, а даже наоборот хорошо, потому что в любой момент времени наше приложение будет компилироваться. Например, версии наших модулей уже дошли до 10.0.0. И если мы захотим вернуться к старой версии приложения, построенной на старых модулях, оно у нас без проблем соберётся: граф всегда будет валиден. Этим и прекрасно семантическое версионирование.
Контроль кода, уходящего в релиз
--------------------------------
Представим, что у нас есть те же модули А, В, С и приложение. Мы провели фиксацию приложения по всем модулям, и связи изменились. Назовём этот релиз Alpha.
При фиксации релиза нам нужно закрепить версии пакетов, используемые в проекте. Делать это лучше напрямую в зависимостях приложения. Какие связи мы установим в приложении, такие и будут использоваться во всём проекте. Мы указали версию модуля А ***exact 1.0.0*** — значит, даже если в нём будет повышена версия, модули С и В тоже будут использовать 1.0.0.
Теперь разработчики в своих модулях могут продолжать работу, поднимать версии, добавлять фичи для следующего релиза. Назовём его Beta. Затем в модуле А добавили крупные правки; номер его версии подняли до 2.0.0. Граф для обоих релизов корректный, для Alpha у нас используется модуль А 1.0.0, а для Beta — 2.0.0.
А теперь представим ситуацию, когда нам прилетел баг с регресс-тестирования Alpha. Нужны изменения в модуле А, но там небольшой фикс, который не ломает обратную совместимость. Нужно только поднять патчевую версию до 1.0.1. По [GitLabFlow](https://docs.gitlab.com/ee/topics/gitlab_flow.html) все изменения сначала делаются на мастер-ветке, и дальше фикс доносится до релизных веток.
Делаем изменения в мастер-ветке модуля А, поднимаем версию до 2.0.1 (в мастер-ветке модуля уже была версия 2.0.0, а мы внесли наш багфикс). Но т.к. багфикс относится к релизу Alpha в котором нам не нужны изменения в коде из следующего релиза Beta, нам остаётся только создать новую ветку *regress\_Alpha* в модуле А от версии 1.0.0 и уже на ней сделать багфикс. Ставить версию 1.0.1 на ветку *regress\_Alpha* нельзя — в дальнейшем это приведёт к путанице. Нужно относится к версионированию как к [Стеку](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA), мы можем добавлять версии поверх последней, мы не можем добавлять версии в середину стека. Теперь расстановка версий выглядит примерно таким образом:
Повторяем то же самое во всех модулях, где понадобятся хотфиксы в релизе Alpha. Версии контролируются, функционал из Beta не попадает в Alpha.
Возвращаемся к CocoaPods
------------------------
У нас двухнедельные релизы, и пока тестируется зафиксированный релиз, мы всегда работаем над следующим. Иногда бывает, что для разграничения функционала нужны дополнительные релизные ветки. Пример подобного — в предыдущем разделе статьи.
В таком случае в SPM можно ставить разные связи для разных репозиториев. То есть для модуля А поставили ветку, для других модулей просто зафиксировали конкретную версию. У SPM-пакетов есть особенность: в их описании можно ставить зависимости не только по версиям, но и по веткам и отдельным тегам. То есть в описании самого пакета мы можем устанавливать зависимости на конкретные ветки. В CocoaPods спеках так нельзя, в нём можно использовать только версии.
```
Pod::Spec.new do |s|
# package requirements
# Валидный вариант
s.dependency 'ModuleA', '~> 1.0'
# Невалидный вариант
s.dependency 'ModuleA', :branch => 'regress_Alpha', :git => 'https://link-to-git/modulea.git' end
end
```
На самом деле такая запись и не нужна. В SPM-пакетах её тоже стоит избегать и всегда основываться на версиях, потому что и в SPM, и в CocoaPods мы задаём правила в самом приложении.
Для SPM это делается в настройках проекта в разделе Swift Packages, в CocoaPods же — внутри Podfile.
```
target 'Application' do
pod 'ModuleA', :branch => 'regress_Alpha', :git => 'https://link-to-git/modulea.git' pod 'ModuleB', '1.0'
pod 'ModuleC', '1.0'
end
```
Мирное соглашение SPM and CocoaPods
-----------------------------------
В качестве менеджеров зависимостей рассматриваем два варианта. CocoaPods нужен, потому что он был в проекте изначально. При этом SPM нам тоже совершенно необходимо поддерживать, потому что наши коллеги из приложения розничного банка используют только его. У нас есть два пути:
1. Поддерживать и SPM, и CocoaPods для общих репозиториев.
2. Переводить существующие зависимости на SPM.
Первый путь сложнее в поддержке и увеличивает нагрузку на разработчиков при внесении кода в пакеты: нужно проследить, что модуль работает в обоих менеджерах. Второй путь казался нам нерабочим, потому что не удавалось запустить SPM-пакеты из-за плохой работы в проектах со смешанными языками Swift + ObjC. Взглянем на второй путь пристальнее.
У нас уже есть выделенные продуктовые модули и общие модули сетевого слоя и дизайн-системой. Все эти модули организованы как проекты Xcode в виде динамических библиотек, и их как-то нужно перевести на SPM. Чтобы организовать рабочие модули в SPM, надо перевести на него все зависимые библиотеки: как наши локальные, так и внешние библиотеки свободного ПО. Если в них это не сделано, конечно же.
Вернёмся к PSBCore и его оформлению в виде SPM. В прошлый раз мы видели ошибки «*Module ‘PSBCore' not found*» и подумали, что проекты со смешанными языками не будут работать.
Создав тестовый проект для воспроизведения ошибки и перебрав варианты, я нашел, что проблема возникает, когда есть как минимум три модуля. Модуль A — SPM-пакет. Модуль B — Xcodeproj модуль с зависимостью на модуля А и приложение, которое использует модули А и B одновременно.
И если в модуле А есть типы, которые могут быть доступны в ObjC (например, наследники NSObject, протоколы или enum’ы @objc), а в модуле B идёт наследование от этих типов из модуля А, мы получаем ошибку. Пример можно посмотреть в [репозитории](https://github.com/Willianlike/RoadToSPMArticle/tree/07713812756190cb3f985149252174082c8784ef/RoadToSPMModuleNotFound).
Ок, проблему поняли. Начинаем избавляться от наследования ObjC-классов. Но это непросто, потому что все базовые UIKit сущности — наследники NSObject, а в DSKit таких сущностей пруд пруди.
Наследование с некоторыми ухищрениями можно заменить композицией — таким путём мы и пошли, создав себе кучу задач по избавлению от наследования из-за ObjC. Но тут наш руководитель нашёл корень проблемы: если убрать публичный заголовок ObjC в модуле B, то проблема с наследованием уходит и можно спокойно переходить на SPM. В [этом коммите](https://github.com/Willianlike/RoadToSPMArticle/commit/63f2abeb82ec6be68f23287c6167d9bfa4597b0b) можно посмотреть проделанные изменения.
Потом мы поймали другой баг, связанный с использованием смешанных языков. Например, у нас есть тип в модуле А или B, попадающий в ObjC. При использовании forward declaration в хедере ObjC-класса мы можем указать там этот тип. Например, в модуле А будет swift класс *SwiftClassA* наследник NSObject, в приложении будет ObjC-класс и в его заголовке будет объявлено `@property SwiftClassA *swiftclass;` .
Тогда в коде ObjC это свойство будет видно в полной мере, все другие классы ObjC смогут к нему обратиться, но в Swift оно будет недоступно. Я не понял, с чем это связано, и завел вопросы на [Stack Overflow](https://stackoverflow.com/questions/70958437/objc-interop-type) и [Swift Forum](https://forums.swift.org/t/objc%20interop-issue-type-objcprotocolimpl-cannot-conform-to-protocol-objcprotocol-because-it-has%20requirements-that-cannot-be-satisfied/55068). В [этом коммите](https://github.com/Willianlike/RoadToSPMArticle/commit/b4cbb38518b159a18d4fbd2cabbbf101843e61c9) можно посмотреть, как выглядит ошибка.
Может быть, ко времени, когда вы это прочтёте, вопрос будет решён. Но я сомневаюсь: учитывая актуальность проблемы, а точнее её отсутсвие, в большинстве проектов, проще переписать на Swift, либо оставаться в монолите. Эту проблему удалось решить только смекалкой и переписыванием таких классов с ObjC на Swift.
Лайфхак такой: если у класса ObjC есть такие свойства, то их можно перенести в сущность Swift. Тогда они будут доступны как в ObjC, так и в Swift. Пример действий в [этом коммите](https://github.com/Willianlike/RoadToSPMArticle/commit/b2980c62581ed44e8c948264eed44aa3733ae518). Так же можно поступить с объявленными функциями ObjC, или поступить более радикально и переписать на Swift весь класс.
Мы засучили рукава и переписали все такие случаи. Было непросто: проект сыпал тысячами ошибок неясного происхождения, приходилось переписывать код и компилировать заново — не стало ли меньше ошибок. Справившись с этим, пошли дальше.
AFNetworking
------------
Казалось, можно идти дальше, все беды позади, а дальше — радужные пони, смузи и все модули на SPM. Но эти мечты разбились об айсберг <https://github.com/apple/swift/issues/57137> — linker error when code coverage is turned on for Swift Package with Objective-C code.
Пример, где добавляется Objc библиотека с выключенным ковераджем, в [этом коммите](https://github.com/Willianlike/RoadToSPMArticle/commit/b8ab172ae0b68058cc82873190faea47ae7c0102). В нем все запускается и тестируется. А вот в [этом коммите](https://github.com/Willianlike/RoadToSPMArticle/commit/10af2fcf74b4e16042c3925c0a7e3e9dbbcb4384) включаем коверадж для таргета тестов, и у нас появляется ошибка компиляции.
Ошибка выглядит таким образом:
```
Undefined symbols for architecture x86_64:
"___llvm_profile_runtime", referenced from:
___llvm_profile_runtime_user in ObjcPackage.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
```
Мы пишем тесты, учитываем их покрытие и на мердж реквестах учитываем это самое покрытие. Если привнесённый код ухудшает покрытие, то сливать ветки нельзя. Исключения бывают, но они редки. Основной поток задачи такой: пишешь код, потом пишешь тесты, пайплайн проверяет, что покрытие не ухудшилось, и пускает тебя в мастер-ветку.
Так вот, соль этого бага SPM: тесты не работают с включенным учётом покрытия, если одна из зависимостей — модуль на ObjC. Понятно, что код ObjC можно оборачивать в SPM-пакеты, но придётся отказаться от проверки покрытия. Это нас не устраивает. Что остаётся?
1. Отключить учёт покрытия.
2. Остановиться и бросить SPM.
3. Отказаться от AFNetworking.
Первый неприемлем: теряем представление о покрытии тестами. Второй проигрышный априори, сдаться проще всего. Третий вариант непрост в реализации. У нас используется древняя версия AFNetworking 2.7.0, поэтому просто отказаться не получится, нужно перейти с него на что-то другое.
Идём сложным — третьим — путём и отказываемся от AFNetworking. Вы можете сказать, что это затратное решение, потому что сетевой слой пронизывает всё приложение. Но наши славные предки не просто подключили AFNetworking в проект, а сделали свою обёртку над сетевым слоем в виде CoreNetwork. Значит, мы сможем избавиться от него с большими усилиями: подменим реализацию работы с сетью внутри самого CoreNetwork.
Спойлер про \_\_\_llvm\_profile\_runtimeКак позже выяснилось, можно использовать Objc библиотеки с подсчетом ковераджа. Нагуглив [похожую проблему](https://github.com/stripe/stripe-ios/issues/1651), мы попробовали реализовать у себя этот подход на других Objc библиотеках, и у нас получилось. Что конкретно меняется — можно увидеть в [этом коммите](https://github.com/Willianlike/RoadToSPMArticle/commit/2eae64fda96bb08c5db21fce840f8565bf50ac75), в уже знакомом репозитории. Но переход от AFNetworking к своей реализации был обусловлен не только ошибкой компиляции при коверадже, поэтому переход все равно состоялся.
Можно было обратиться к готовым решениям, таким как Alamofire — или написать своё на URLSession. Выбрали второе. Про процесс переписывания и что нужно учитывать при разработке своего сетевого слоя, напишу позже в отдельной статье.
Мы уже переписали сетевой слой на свою реализацию. Кажется, дальше у нас карт-бланш на SPM во всём проекте.
Хотелось бы верить, но верится с трудом. Никогда не знаешь, что тебя ждёт в будущем: вдруг уже на следующем модуле появится новая проблема, которая всё сломает, и мы опять вернёмся на CocoaPods. Надеюсь, такого не случится. А отбросить эти сомнения мне помогает моя команда **ПСБ**. | https://habr.com/ru/post/674406/ | null | ru | null |
# Еще один способ оптимизации docker-образов для Java приложений
История по оптимизации образов для java приложений началась с выхода статьи в блоге спринга — [Spring Boot in a Container](https://spring.io/blog/2018/11/08/spring-boot-in-a-container). В ней обсуждались различные аспекты по созданию docker образов для spring boot приложений, в том числе и такой интересный вопрос, как уменьшение размеров образов. Для наших команд это было актуально в силу ряда причин, поэтому мы решили применить это решение к нашим приложениям.
Как это часто бывает, не все взлетело с первого раза, возникли нюансы с многомодульными проектами и попыткой гонять все это на CI системе, так что в данной статье вы найдете решение этих проблем.
Целью оптимизации является сокращение *разницы* между получаемыми образами от сборки к сборке, что дает хороший результат в процессе непрерывной поставки, так что если вас интересует минимизация размера образа как такового, можете обратиться к [другим](https://habr.com/ru/company/ruvds/blog/440658/) [статьям](https://habr.com/ru/post/457476/) на хабре.
Если причины, зачем вообще что-то делать с многометровым бутовым приложением перед помещением его в образ, вам объяснять не надо, можете сразу перейти к [описанию подхода по оптимизации](#optimizing). Если вы успели ознакомиться со статьей из спрингового блога, можете перейти к [решению найденных проблем](#improvements).
Зачем это все, или Обратная сторона fat jar'а
=============================================
По умолчанию jar, который производит Spring Boot, представляет собой исполняемый jar-файл, содержащий код приложения и всех его зависимостей.
Плюс такого подхода очевиден: с одним файлом удобно работать, в нем есть все необходимое для запуска через `java -jar .jar`. Dockerfile тривиален и не представляет интереса.
Минус — неэффективное хранение. В классическом бутовом приложении соотношение кода и библиотек явно не в пользу нашего кода. Например, пустое приложение с web-частью и библиотеками для работы с базой, которое можно сгенерировать через [start.spring.io](https://start.spring.io), займет 20mb, из которых 98% будут библиотеками. И это соотношение в процессе разработки меняется не сильно.
А ведь приложение мы собираем не один раз, а регулярно на CI-сервере, и потом деплоим по цепочке сред. Таким образом 10 сборок вырастают в 200mb, а 100 — уже в 2gb, из которых модификации займут очень мало.
Можно возразить, что для текущей стоимости хранения это смешные цифры и можно не тратить время на такие оптимизации, но все зависит от масштаба организации и числа приложений, образы которых нужно хранить. Условия деплоймента тоже могут сильно мотивировать: когда реестр и сервер находятся рядом, разница даже в 100мб не сильно заметна, но в распределенных системах это может иметь гораздо большее значение, особенно когда вам нужно деплоиться в такие специфичные страны как Китай с его файерволом и нестабильными каналами во внешний мир.
Итак, с причинами разобрались, пора оптимизировать.
Оптимизируем сборку, или Что можно почерпнуть из спрингового блога
===================================================================
Статья предлагает разумное решение: вместо одного слоя, порождаемого командой `COPY my-jar.jar app.jar`, нам нужно сделать несколько слоев.
Один слой будет содержать библиотеки, второй — наш собственный код. Для этого jar-файл нужно распаковать и скопировать содержимое в разные слои образа.
Скрипт для подготовки jar-файла выглядит так:
```
#!/bin/sh
set -e
path_to_jar=$1
dir=$(dirname "${path_to_jar}")
jar_name=$(basename "${path_to_jar}")
mkdir -p "${dir}/docker-dist" && cd "${dir}/docker-dist"
jar -xf ../"${jar_name}"
```
Dockerfile с использованием multi-stage сборки может выглядеть так
```
FROM openjdk:8-jdk-alpine as build
WORKDIR /wd
COPY prepare_for_docker.sh /usr/local/bin/prepare_for_docker
COPY target/demo.jar /wd/app.jar
RUN prepare_for_docker /wd/app.jar
FROM openjdk:8-jdk-alpine
COPY --from=build /wd/docker-dist/BOOT-INF/lib /app/lib
COPY --from=build /wd/docker-dist/META-INF /app/META-INF
COPY --from=build /wd/docker-dist/BOOT-INF/classes /app
ENTRYPOINT ["java","-cp","app:app/lib/*","com.example.demo.DemoApplication"]
```
На первой стадии мы копируем все необходимое, запускаем наш скрипт для распаковки jar-файла, а на второй уже по слоям раскладываем отдельно библиотеки и отдельно наш код.
Убедиться в работоспособности легко:
1. Собираем в первый раз
2. Вносим любое изменение в наш код
3. Запускаем `docker build` еще раз и видим заветные строчки `Using cache` при копировании всей директории lib
```
...
Step 5/10 : RUN prepare_for_docker app.jar
---> Running in c8e422491eb2
Removing intermediate container c8e422491eb2
---> c7dcec4ae18a
Step 6/10 : FROM openjdk:8-jdk-alpine
---> a3562aa0b991
Step 7/10 : COPY --from=build /wd/docker-dist/BOOT-INF/lib /app/lib
---> Using cache
---> 01b600d7e350
Step 8/10 : COPY --from=build /wd/docker-dist/META-INF /app/META-INF
---> Using cache
---> 5c0c03a3c8f1
Step 9/10 : COPY --from=build /wd/docker-dist/BOOT-INF/classes /app
---> 5ffed6ee5696
Step 10/10 : ENTRYPOINT ["java","-cp","app:app/lib/*","com.example.demo.DemoApplication"]
---> Running in 99957250fe5d
Removing intermediate container 99957250fe5d
---> 6735799d9f32
Successfully built 6735799d9f32
Successfully tagged boot2-sample:latest
```
Очевидный способ улучшения данного подхода — сборка маленького [базового образа](https://hub.docker.com/r/zeldigas/java-layered-builder) со скриптом, чтобы не таскать его из проекта в проект. Таким образом первый слой становится более лаконичным.
```
FROM zeldigas/java-layered-builder as build
COPY target/demo.jar app.jar
RUN prepare_for_docker app.jar
```
Дорабатываем решение
====================
Как уже говорилось в начале статьи, решение рабочее, но в процессе эксплуатации были обнаружены пару проблем о решении которых и пойдет речь далее.
Не все файлы в `lib` одинаково библиотечны
------------------------------------------
Если ваш проект многомодульный (как минимум есть модуль А, от которого зависит модуль B, собираемый как spring fat jar), применив к нему оригинальное решение, вы обнаружите, что никакого кэширования слоя не происходит. Что же пошло не так?
Дело как раз в дополнительных модулях: они являются источниками постоянных изменений для слоя, даже если вы не вносите в код модуля никаких правок. Это связано с особенностью создания jar-файлов maven'ом (с gradle'ом ситуация чуть лучше, но не уверен). Задача получения воспроизводимых артефактов не является темой этой статьи (хотя, безусловно, интересна и достижима), поэтому перейдем к достаточно простому решению.
Разнесем содержимое `lib` на 2 директории, после распаковки отделив модули проекты от других библиотек. Доработаем скрипт распаковки fat jar'а:
```
#!/bin/sh
set -e
path_to_jar=$1
shift #(1)
app_modules=$* #(2)
dir=$(dirname "${path_to_jar}")
jar_name=$(basename "${path_to_jar}")
mkdir -p "${dir}/docker-dist" && cd "${dir}/docker-dist"
jar -xf ../"${jar_name}"
if [ -n "${app_modules}" ]; then #(3)
mkdir app-lib
for i in $app_modules; do
mv "BOOT-INF/lib/$i"* app-lib #(4)
done
fi
```
В результате скрипт начал поддерживать передачу дополнительных параметров (см. 1 и 2). Если переданы дополнительные аргументы (3), каждый из них рассматривается как префикс названия файла, который мы перемещаем (4) в отдельную директорию.
Пример Dockerfile'а для сценария с одним доп. модулем `shared-module` и версией `1.0-SNAPSHOT`
```
FROM openjdk:8-jdk-alpine as build
COPY target/demo.jar /wd/app.jar
RUN prepare_for_docker /wd/app.jar shared-module-1.0
FROM openjdk:8-jdk-alpine
COPY --from=build /wd/docker-dist/BOOT-INF/lib /app/lib
COPY --from=build /wd/docker-dist/app-lib /app/lib
COPY --from=build /wd/docker-dist/META-INF /app/META-INF
COPY --from=build /wd/docker-dist/BOOT-INF/classes /app
ENTRYPOINT ["java","-cp","app:app/lib/*","com.example.demo.DemoApplication"]
```
Запускаем на CI-сервере
-----------------------
Отладив все локально, довольные результатом мы перешли к запуску на CI-сервере и из логов сборки обнаружили, что чуда не происходит, точнее результаты были не постоянными: в одних случаях кэширование выполнялось, а при следующем запуске все слои получались новые.
В итоге виновник был обнаружен — docker cache, вернее его отсутствие в случае с разными агентами (у нас сборка не прибита к конкретному агенту CI-системы). Как оказалось, если в кэше докера нет подходящих слоев, то из того же самого набора файлов получаются слои с другой контрольной суммой. Проверить это можно и локально, запустив сборку с опцией `--no-cache`, или собрать второй раз, предварительно удалив образ и все промежуточные слои. В результате вы получите абсолютно другую контрольную сумму слоя, что сводит на нет все предыдущие усилия.
Решить проблему можно разными способами:
1. Если ваша CI-система поддерживает это из коробки (например у Circle CI [в части планов](https://circleci.com/docs/2.0/docker-layer-caching/) есть встроенная поддержка шареного кэша при сборках)
2. [Шарить раздел](https://runnable.com/blog/distributing-docker-cache-across-hosts) с кэшом докера между агентами
3. Воспользоваться встроенными средствами докера по управлению кэшем ([`--cache-from`](https://andrewlock.net/caching-docker-layers-on-serverless-build-hosts-with-multi-stage-builds---target,-and---cache-from/))
Мы пошли третьим путем, так как в нашем случае он был самым простым. Опция позволяет указать докер-демону, какие образы он должен учитывать и пытаться использовать для кэширования при сборке. Указать можно столько образов, сколько вы считаете нужным, главное, чтобы они были на файловой системе. Если указанного образа нет, он будет просто проигнорирован, поэтому нужно сделать pull перед сборкой.
Вот как выглядит сборка контейнера при таком подходе:
```
set -e
version=...
# забираем последнюю версию нашего образа
docker pull registy.example.com/my-image:latest || true
#собираем новый используя только слои из последнего для кэша
docker build -t registry.example.com/my-image:$version --cache-from registry.example.com/my-image:latest .
# пушим в registry конкретную версию и latest
docker tag registry.example.com/my-image:$version registry.example.com/my-image:latest
docker push registry.example.com/my-image:$version
docker push registry.example.com/my-image:latest
```
Мы пытаемся переиспользовать слои только с самого последнего образа, чего зачастую достаточно, но никто не мешает накрутить более сложной логики и отступать на несколько версий назад или опираться на id коммитов vcs.
Адаптируем этот подход под возможности вашего CI и получаем надежное переиспользование слоев с библиотеками.
Итого
=====
Решение показывает хорошие результаты, особенно когда применяется в проектах с активной стадией разработки и настроенным CD пайплайном. На графике ниже показан результат применения оптимизации к одному из приложений. Хорошо видно, что линейный рост сменился на скачкообразный начиная с 70-й сборки (провалы в 60-х связаны как раз с отладкой работы на билд агентах). Выбросы после связаны с обновлением базового образа (высокие) и библиотек (пониже)
Оптимизация хранения в нашем случае является приятным, но скорее вторичным бонусом. Ускорение деплоя новой версии поверх старой в несколько регионов радует куда сильнее.
Хочется отметить, что данная техника вполне совместима с другими подходами, ориентированными на уменьшение размера отдельного образа (alpine и прочие легковесные базовые образы, custom runtime для приложения). Главное следовать общим правилам сборки образа в плане кэширования и убедиться, что получаемый результат является воспроизводимым. | https://habr.com/ru/post/458260/ | null | ru | null |
# Механизм подсчета нейронной сети в PL/SQL для распознавания рукописных цифр
*Дорогие коллеги, спешим порадовать всех, кто неравнодушен к наукоемким задачам. Сегодня мы приготовили для вас перевод любопытной публикации от экспертов по базам данных из CERN, посвященный обучению и эксплуатации нейронных сетей с помощью Python и инструментария на базе Oracle PL/SQL.*
В этой статье вы найдете пример построения и развертывания базового механизма подсчета искусственной нейронной сети с использованием **PL/SQL**. Статья предназначена для учебных целей, в частности для практиков Oracle, которые хотят на конкретном примере познакомиться с **нейронными сетями**.
В настоящее время **машинное обучение** и **нейронные сети** являются актуальными темами в обработке данных. Для работы и экспериментов с нейронными сетями и **глубинного обучения** (deep learning) сейчас доступны многие инструменты и платформы (см. ссылки в конце этой статьи). Распознавание рукописных цифр, в частности, с использованием базы данных [MNIST](http://yann.lecun.com/exdb/mnist/), [Яна Лекуна](https://twitter.com/ylecun) и др., сейчас является вводным примером для ознакомления с нейронными сетями.
В этой статье вы увидите, как построить и развернуть простой **механизм подсчета** нейронных сетей, чтобы распознавать рукописные цифры, используя **Oracle** и PL/SQL. Конечным результатом является небольшой пакет **PL/SQL** с точностью около 98%. Нейронная сеть создается и обучается с помощью [TensorFlow](https://www.tensorflow.org/), а затем передается в Oracle для ее обслуживания.
Одна из идей, которые эта статья призвана проиллюстрировать, заключается в том, что подсчет нейронных сетей намного проще, чем их обучение: операции, необходимые **для обслуживания обученной сети**, могут быть реализованы относительно легко на многих языках/средах программирования. Обсуждения по этим темам обычно сосредоточены вокруг платформ для «Big data» (например, [Spark](https://databricks.com/blog/2016/01/25/deep-learning-with-apache-spark-and-tensorflow.html) и [MLlib](http://spark.apache.org/docs/latest/mllib-guide.html)). Интересно, что нейронные сети также могут быть с успехом применены в мире РСУБД. Это может быть полезно, поскольку большое количество ценных данных в настоящее время хранится в **реляционных базах данных**. В случае Oracle реализация механизма подсчета также упрощается благодаря наличию зрелой среды PL/SQL с пакетом для **линейной алгебры**: [UTL\_NLA](http://docs.oracle.com/cd/E11882_01/appdev.112/e40758/u_nla.htm).
**Давайте начнем с конца: как развернуть пакет PL/SQL MNIST и распознать рукописные цифры в Oracle**
Один короткий пакет PL/SQL и две таблицы — это всё, что вам нужно для воспроизведения следующего примера (вы можете найти подробный код на [Github](https://github.com/LucaCanali/Miscellaneous/blob/master/PLSQL_Neural_Network/MNIST_oracle_plsql.ipynb)). Таблицы:
* **TENSORS\_ARRAY**: эта таблица содержит числовые значения для векторов и матриц (тензоров), которые составляют нейронную сеть. Существует всего 79510 чисел с плавающей запятой, закодированных в четырех тензорах с использованием типа данных UTL\_NLA\_ARRAY\_FLT.
* **TESTDATA\_ARRAY**: эта таблица содержит тестовые изображения. Есть 10K изображений, каждое из которых состоит из 28 \* 28 = 784 пикселей. Изображения также кодируются с использованием типа данных **UTL\_NLA\_ARRAY\_FLT**.
Механизм для подсчета нейронной сети из примера находится в пакете под названием **MNIST**. В нём есть процедура **INIT**, которая загружает компоненты нейронной сети из таблицы tensors\_array в переменные PL/SQL и функцию **SCORE**, которая принимает изображение в качестве входных данных и возвращает число — прогнозируемое значение цифры.
Вот пример его использования, где первая картинка в таблице testdata\_array проверяется и правильно распознается как изображение числа 7 (метка изображения согласуется с предсказанием MNIST.SCORE):
```
SQL> exec mnist.init
PL/SQL procedure successfully completed.
SQL> select mnist.score(image_array), label from testdata_array where rownum=1;
MNIST.SCORE(IMAGE_ARRAY) LABEL
------------------------ ----------
7 7
```
**Рисунок 1**: Это растровое отображение тестовой картинки, используемой в примере. Оно подтверждает, что прогноз MNIST.SCORE корректен и действительно картинка представляет собой изображение числа 7, написанного от руки и закодированного в сетке 28x28 gray-scale пикселей.
Обработка всех тестовых изображений также выполняется простой командой SQL. В примере на рис. 2 для обработки 10000 тестовых изображений требуется 2 минуты, то есть в среднем около 12 мс на изображение. **Точность функции оценки составляет около 98%**. Она рассчитывается следующим образом: согласно меткам данных, 9787 из 10000 изображений оцениваются правильно. Отметим также, что набор тестовых изображений не пересекается с изображениями, используемыми для обучения нейронной сети. Поэтому мы можем ожидать, что пакет MNIST имеет точность распознавания цифр около 98% в том числе и при использовании на общем вводе.
Полный код PL/SQL и **dump-файл** datapump с соответствующими таблицами [можно найти на Github](https://github.com/LucaCanali/Miscellaneous/tree/master/PLSQL_Neural_Network). В следующих абзацах я расскажу, как построить и обучить нейронную сеть.
**Рисунок 2**: Точность функции оценки PL/SQL MNIST.SCORE на тестовом наборе из 10K изображений составляет около 98%. Обработка занимает около 12 мс на изображение.
**Нейронная сеть**
Нейронная сеть, используемая в этой статье, состоит из трех слоев (см. Рис. 3): один слой ввода, один скрытый слой и один слой вывода. Если эта тема для вас нова, я рекомендую почитать дополнительную литературу (см. Ссылки) и, в частности, книгу [«Neural Networks and Deep Learning»](http://neuralnetworksanddeeplearning.com/) [Майкла Нильсена](https://twitter.com/michael_nielsen), которая обеспечит отличное введение в тему и серию пошаговых примеров, касающихся проблемы распознавания рукописных цифр.
**Рисунок 3**: Искусственная нейронная сеть, используемая в этой статье, состоит из трех слоев. Слой ввода содержит 784 нейрона, по одному на пиксель входящего изображения. Чтобы повысить точность, добавлен скрытый слой из 100 нейронов. Слой вывода имеет 10 нейронов, по одному на каждое возможное выходное значение (то есть, цифры от 0 до 9).
**Получите учебные и тестовые данные, постройте и обучите нейронную сеть**
Ещё одним важным шагом для развертывания нейронных сетей является **обучение**. Для этого вам нужны **данные**, по возможности много. Вам также нужен движок для выполнения необходимых вычислений. К счастью, существует множество доступных платформ для работы с нейронными сетями, которые являются бесплатными и относительно используемыми для развертывания (см. Ссылки). В этой статье вы увидите, как использовать [TensorFlow от Google](https://www.tensorflow.org/) и среду Python. TensorFlow поставляется с [инструкцией](https://www.tensorflow.org/versions/r0.7/tutorials/mnist/beginners/index.html) для распознавания рукописных цифр в базе данных [MNIST](http://yann.lecun.com/exdb/mnist/). В инструкцию включены учебные и тестовые **данные с метками**, а также примеры кода.
Вы можете найти код, который я использовал для обучения нейронной сети, на [Github](https://github.com/LucaCanali/Miscellaneous/blob/master/PLSQL_Neural_Network/MNIST_tensorflow_exp_to_oracle.ipynb). Некоторые основные моменты и фрагменты кода обсуждаются ниже.
**Импорт данных**: Пример набора данных, который поставляется с TensorFlow, включает 55000 изображений для обучения и 10000 изображений для тестирования. Они изначально исходят из работы [Яна Лекуна](https://twitter.com/ylecun) и коллег. Наличие большого количества высококачественных данных очень важно для успеха процесса. Кроме того, на изображениях имеются **ярлыки**: на них указывается, какое число изображено на картинке, и эта информация очень важна, поскольку упражнение заключается в осуществлении [контролируемого обучения](https://en.wikipedia.org/wiki/Supervised_learning).
**Определение нейронной сети**: в сети есть четыре тензора (в данном случае — вектор и матрицы): W0, W1, b0 и b1. Они определены в следующем фрагменте кода. Чтобы лучше понять их роль, а также значение перекрестной энтропии и оптимизатора градиентного спуска для обучения нейронной сети, см. ссылки, а именно [«Neural Networks and Deep Learning»](http://neuralnetworksanddeeplearning.com/) и инструкцию [TensorFlow](https://www.tensorflow.org/get_started/mnist/beginners).
**Обучение нейронной сети**: обучение проходит с несколькими этапами оптимизации. Оно проводится с использованием 55000 изображений с метками. Выполняется более 30000 итераций, с использованием «мини-порций» размером 100 изображений. На каждом шаге алгоритм градиентного спуска (gradient descent) вычисляет обновление весов и смещений (W0, W1, bo и b1) с целью минимизации функции потерь (cross\_entropy). Соответствующий фрагмент кода:
**Результат**: в результате обученная сеть имеет **точность около 98%** в прогнозировании изображений в тестовом наборе. Обратите внимание, что тестовый набор состоит из 10000 изображений и не совпадает с набором изображений, используемых для обучения (учебный набор содержит 55000 изображений).
Можно получить более высокую точность при более сложных конфигурациях нейронной сети (подробности см. в Ссылках), но это выходит за рамки данной статьи.
**Ручной подсчет нейронной сети, пример на языке Python**
Основной результат обучающих операций состоит в том, что тензоры (в данном случае матрицы и векторы), которые составляют нейронную сеть, теперь заполнены полезными значениями. Я считаю, что хороший способ понять, как все это работает, — «запустить сеть вручную», то есть запустить в качестве примера переход от изображения рукописной цифры к предсказанию ее значения обученной нейронной сетью. В качестве первого шага мы **извлекаем значения** обученных тензоров из нашей модели в массивы [numpy](http://www.numpy.org/) для последующей обработки:
Пример **«ручного» управления сетью** в Python выглядит следующим образом:
W0\_matrix, b0\_array, W1\_matrix и b1\_array являются тензорами, которые составляют нейронную сеть после обучения, *testimage* — слой ввода, [*sigmoid*](https://en.wikipedia.org/wiki/Sigmoid_function)() используется как функция активации, *hidden\_layer* представляет скрытый слой сети, *predicted* — это слой вывода, а [*softmax*](https://en.wikipedia.org/wiki/Softmax_function)() — это функция, используемая для нормализации вывода как распределения вероятностей. В конце вычисления массив *predicted[n]* содержит предсказание, что входное изображение представляет цифру «n». Функция *argmax()* находит значение «n», для которого **predicted[n]** максимально.
Код, показанный выше, прогнозирует значение 7 для тестового изображения. Прогноз подтверждается как правильный значением метки, а также может быть визуально подтвержден растровым отображением тестового изображения (см. Рис. 1).
**Перенос тестовых данных и сети в Oracle**
Пример из предыдущего параграфа о том, как вручную запустить механизм подсчета, показывает, что **обслуживание** нейронной сети может быть прямолинейным, в некоторых случаях это просто вопрос выполнения некоторых базовых вычислений с матрицами. Это контрастирует со сложностью обучения нейросетевых моделей, где часто требуется специализированный движок, высокое качество обучающих данных, а в более сложных случаях еще и специализированное оборудование, такое как GPU карты.
Тема предыдущего параграфа также подготовила почву для следующей разработки: это перемещение тензоров нейронной сети и тестовых данных в Oracle и внедрение обслуживающего механизма там.
Существует множество способов экспорта numpy массивов Python. Один из них — [сохранить массивы в текстовом формате](http://docs.scipy.org/doc/numpy/reference/generated/numpy.savetxt.html). Здесь же вы увидите метод, предназначенный для прямого экспорта в Oracle с помощью cx\_Oracle, библиотеки Python для взаимодействия с Oracle. Для получения дополнительных примеров и ссылок о том, как использовать cx\_Oracle советую ознакомиться с заметками [«Oracle и Python и cx\_Oracle»](https://github.com/LucaCanali/Miscellaneous/blob/master/Oracle_Jupyter/Oracle_IPython_cx_Oracle_pandas.ipynb).
Код можно найти на [Github](https://github.com/LucaCanali/Miscellaneous/blob/master/PLSQL_Neural_Network/MNIST_tensorflow_exp_to_oracle.ipynb), вот некоторые релевантные фрагменты:
— **Создайте таблицы** для размещения определений тензоров и тестовых данных:
```
SQL> create table tensors (name varchar2(20), val_id number, val binary_float, primary key(name, val_id));
SQL> create table testdata (image_id number, label number, val_id number, val binary_float, primary key(image_id, val_id));
```
— Из Python откройте соединение с Oracle:
```
import cx_Oracle
ora_conn = cx_Oracle.connect('mnist/<mnist@ORCL>')
cursor = ora_conn.cursor()
```
— Пример того, как **перенести матрицу** W0 в таблицу Oracle *tensors*:
```
i=0
sql="insert into tensors values ('W0', :val_id, :val)"
for column in W0_matrix:
array_values = []
for element in column:
array_values.append((i, float(element)))
i += 1
cursor.executemany(sql, array_values)
ora_conn.commit()
```
Наконец, вы можете экспортировать таблицы *testdata* и *tensors* для последующего использования. В [репозитории Github](https://github.com/LucaCanali/Miscellaneous/tree/master/PLSQL_Neural_Network) вы можете найти dump-файл, полученный с помощью следующей команды (запустить как Oracle):
```
$ expdp mnist/mnist tables=testdata,tensors directory=DATA_PUMP_DIR dumpfile=MNIST_tables.dmp
```
**Оптимизации Oracle для линейной алгебры**
Из документации Oracle: «Пакет [UTL\_NLA](http://docs.oracle.com/cd/E11882_01/appdev.112/e40758/u_nla.htm) предоставляет подмножество операций **BLAS** и LAPACK (версия 3.0) для векторов и матриц, представленных как VARRAYS». Это очень полезно для выполнения **вычислений**, необходимых для обслуживания нейронной сети из этой статьи.
Ниже приведен фрагмент кода MNIST, чтобы понять, как это работает на практике. Код выполняет вычисление *v\_Y0 = v\_Y0 + g\_W0\_matrix \* p\_testimage\_array*, где *g\_W0\_matrix* — матрица 784x100, *p\_testimage\_array* — вектор из 784 элементов (кодирует изображения 28x28), *а v\_Y0* — вектор из 100 элементов.
```
utl_nla.blas_gemv(
trans => 'N',
m => 100,
n => 784,
alpha => 1.0,
a => g_W0_matrix,
lda => 100,
x => p_testimage_array,
incx => 1,
beta => 1.0,
y => v_Y0,
incy => 1,
pack => 'C'
);
```
Чтобы использовать UTL\_NLA, тензоры, которые делают нейронную сеть и тестовые изображения, должны храниться в varrays из binary\_float или, скорее, быть объявлены типом данных UTL\_NLA\_ARRAY.
По этой причине также удобно проводить пост-обработку таблиц *tensors* и *testdata* следующим образом:
```
SQL> create table testdata_array as
select a.image_id, a.label,
cast(multiset(select val from testdata where image_id=a.image_id order by val_id) as utl_nla_array_flt) image_array
from (select distinct image_id, label from testdata) a order by image_id;
SQL> create table tensors_array as
select a.name, cast(multiset(select val from tensors where name=a.name order by val_id) as utl_nla_array_flt) tensor_vals
from (select distinct name from tensors) a;
```
**Последний шаг**, возвращающий вас к обсуждению в разделе «Давайте начнем с конца: как развернуть пакет PL/SQL MNIST и распознать рукописные цифры в Oracle», — это создать пакет PL/ SQL MNIST, который загружает тензоры и выполняет операции, необходимые для подсчета нейронной сети, подробный код можно посмотреть на [Github](https://github.com/LucaCanali/Miscellaneous/blob/master/PLSQL_Neural_Network/MNIST_oracle_plsql.ipynb).
**Заключение и комментарии**
Эта статья описывает пример внедрения механизма **подсчета** для искусственной **нейронной сети** с использованием реляционной СУБД **Oracle** и PL/SQL. Речь идет о простой реализации примера для ознакомления с нейронными сетями: распознавание рукописных цифр в [базе данных MNIST](https://twitter.com/ylecun). Сеть обучается с помощью [TensorFlow](https://www.tensorflow.org/), а затем экспортируется в Oracle. Конечным результатом является небольшой пакет PL/SQL, который обеспечивает распознавание цифр с точностью около **98%**.
В ближайшем будущем мы можем ожидать **рост** развертывания **нейронных сетей вблизи источников и хранилищ данных**. Пример в этой статье того, как реализовать механизм **обслуживания** нейронной сети в базе данных **Oracle**, показывает, что это не только возможно, но и **легко реализовать**.
**Обслуживание** нейронных сетей намного **проще** их обучения. Хотя для обучения требуется специализированное программное обеспечение/платформы, знание предметной области и большое количество учебных данных, обученные сети можно импортировать и запускать в целевых системах, что во многих случаях требует низкого использования вычислительных ресурсов.
Эта статья была задумана как **учебный материал**: вместо более производительной сверточной сети используется простая нейронная [сеть прямого распространения](https://en.wikipedia.org/wiki/Convolutional_neural_network) (см. Ссылки). Более того, перемещение данных из TensorFlow в Oracle и реализация обслуживающего движка в **PL/SQL** — это своего рода “костыль” в текущем состоянии, и он не предназначен для использования в production.
Код, сопровождающий эту статью, доступен на [Github](https://github.com/LucaCanali/Miscellaneous/tree/master/PLSQL_Neural_Network).
**Примечания о том, как создать тестовую среду**
Основными компонентами и инструментами для тестирования скриптов в этой статье являются:
среда **Python** (на Linux с CentOS 7), установленная с помощью [Anaconda](https://www.continuum.io/downloads) 4.1: Python 2.7, Jupyter Ipython notebook.
**TensorFlow**, версия 0.9 (последняя на момент написания статьи), установленная в соответствии с инструкциями <https://www.tensorflow.org/versions/r0.9/get_started/os_setup.html>
**Реляционная СУБД Oracle**, работающая на Linux. Скрипты Oracle были протестированы на Oracle 11.2.0.4 и 12.1.0.2
**Ссылки и благодарности**
Отличным введением в нейронные сети и вдохновением для этой статьи послужила книга [Майкла Нильсена](https://twitter.com/michael_nielsen) (Michael Nielsen) [«Neural Networks and Deep Learning»](http://neuralnetworksanddeeplearning.com/).
Код для обучения нейронной сети, используемый в этой статье, является расширением [инструкции](https://www.tensorflow.org/versions/r0.7/tutorials/mnist/beginners/index.html) [TensorFlow](https://www.tensorflow.org/) MNIST от Google.
Также рекомендую: [учебник по TensorFlow Нартина Гордона](https://docs.google.com/presentation/d/1TVixw6ItiZ8igjp6U17tcgoFrLSaHWQmMOwjlgQY9co/pub?slide=id.g110257a6da_0_579) (Nartin Gorner),
[«Базовые техники для TensorFlow»](https://www.oreilly.com/learning/hello-tensorflow) Аарона Шумахера (Aaron Schumacher),
[«Базы данных MNIST» Яна Лекуна](https://twitter.com/ylecun) (Yann LeCun),
[«Визуализация MNIST»](http://colah.github.io/posts/2014-10-Visualizing-MNIST/) Кристофера Олаха (Christopher Olah),
[«Машинное обучение Python»](https://github.com/rasbt/python-machine-learning-book) Себастиана Ращка (Sebastian Raschka).
Другие популярные фреймворки для работы с нейронными сетями и глубокого обучения, помимо [TensorFlow](https://www.tensorflow.org/), включают [Theano](http://deeplearning.net/software/theano/) и [Torch](http://torch.ch/) среди многих прочих, смотрите также эту страницу на [Википедии](https://en.wikipedia.org/wiki/Comparison_of_deep_learning_software).
Всех любителей наукоемких задач и computer science приглашаем летом [посетить](http://pgday.ru/ru/2017/request/registration?utm_source=habr&utm_medium=post&utm_campaign=neiron) одноименную секцию [**базы данных и computer science**](http://pgday.ru/ru/2017/papers?utm_source=habr&utm_medium=post&utm_campaign=neiron#section5) на **PG Day'17 Russia**. Будем обсуждать блокчейны, моделирование и визуализацию данных, теорию профилирования СУБД, data mining и еще несколько интересных тем :)
Ну и не забывайте, что в этом году в рамках PG Day состоится секция для специалистов, работающих с Oracle и другими коммерческими базами данных. Ожидаются первоклассные доклады от экспертов из крупнейших технологических компаний и полноценный мастер-класс, посвященный [диагностике производительности Oracle Database](http://pgday.ru/ru/2017/papers/125?utm_source=habr&utm_medium=post&utm_campaign=neiron). | https://habr.com/ru/post/328824/ | null | ru | null |
# Новичок или опытный? Как нанять мобильного разработчика под iOS, который что-то действительно умеет
Мобильная разработка — это особая кухня, и в ней есть свои нюансы. Именно поэтому собеседования с кандидатами в отдел разработки под iOS должны проходить с определенным уклоном. Сегодня мы расскажем, как проходит прием в штат мобильных разработчиков Acronis, и какие курьезы бывают на собеседованиях, когда соискатель считает, что достаточно запомнить несколько умных слов, а потом «разберемся на месте».
[](https://habr.com/company/acronis/blog/415655/)
Начнем с того, что буквально два года назад мобильная разработка под iOS приобрела свой неповторимый вкус, и это связано с появлением такого языка как Swift. Новый и современный язык с хорошей парадигмой, а также с очень сильной командой разработчиков сразу был оценен наиболее инициативными разработчиками. Но главный его плюс заключается в том, что именно на Swift будет делать ставку Apple, и это подтверждают утверждения Тима Кука, сделанные им публично. Поэтому проводить собеседование с учетом специфики знания Swift кажется логичным шагом.
Тем не менее, далеко не во всех компаниях вообще задают вопросы про Swift на собеседованиях. До прихода в Acronis я сам проходил собеседования в разных компаниях, и про Swift не спрашивал практически никто. Мне это показалось очень странным, так как, очевидно, мобильная разработка движется именно в этом направлении.
Возможно, проблема в том, что многие разработчики прошлого поколения «сидят» на Objective-C и не хотят уходить от знакомых парадигм. Но данный язык отстал от современных методов разработки, Apple его не развивает, а также он отличается наличием большого количества устаревших правил, таких как отсылка сообщений nil-объектам и динамическая система типов. Их сложно учитывать при написании кода и во время отладки. С переходом на Swift можно было бы избежать многих сложностей.
Несколько слов о Swift
----------------------
Apple представила этот язык в 2014 году, как противовес Objective-C. У новичка обнаружилось сразу несколько плюсов. Например, Swift не требует наличия двух файлов, отлично реализована безопасность языка, уникальная работа с дженериками, проработанная модель типов данных и method dispatch. Этот язык можно смело назвать более читаемым за счет упрощенного и удобного синтаксиса.
В процессе разработки на Swift очень помогает наличие специальной среды для экспериментов под названием Playground, о пользе которой на собеседованиях мы расскажем чуть ниже.
Наконец, новый язык перспективен потому, что скорость разработки значительно выше, чем на Objective-C и C++. Он позволяет проще устранять баги и, вообще, разработка на Swift оказывается дешевле, эффективнее и перспективнее, чем на Objective-C. Поэтому сознательно ищем специалистов, которые имеют опыт «общения» на этом языке.
Разработчики и имитаторы
------------------------
Конечно, можно нанять на работу выпускника вуза или даже стажера, обучив его в процессе прохождения практики. Но если вы ищете уже имеющего опыт специалиста, очень странным выглядит несоответствие заявленного опыта и реальных знаний. Например, соискатель утверждает, что «разрабатывал на Swift три года», и при этом не знает основ языка. Наверное, это объясняется желанием получить высокооплачиваемую работу, ведь сегодня спрос на разработчиков под iOS достаточно высок. Чтобы отсеять таких кандидатов мы проводим специально продуманные интервью, на которых уже попадались «специалисты», которые:
* пишут код в точности по видео-примерам с YouTube;
* копируют код с GitHub вообще без изменений;
* пишут другу в Telegram и спрашивают, как решить элементарную задачу;
* «выходят в туалет» или «срочно позвонить» после того, как объявлены условия задачи.
Факт недостаточной компетенции можно обнаружить, если использовать написание кода непосредственно во время интервью. В разных компаниях принято задавать вопросы с записями на доске, на листочке, на обрубке бумаге, или просто на слух. Но ведь в конечном счете разработчик пишет код на компьютере, и почему бы не посмотреть, как он выполняет свои непосредственные задачи вживую?
Например, наш специалист берет ноутбук и предлагает соискателю начать творить в Playground — в той самой специальной среде языка Swift. В Playground можно просто запустить код «как есть» и посмотреть на результаты его работы. Это удобно, и экономит время (ведь на техническое интервью выделяется максимум часа 2). Тогда как на С++ нужно создать проект, куда-то его сохранить, настроить, Playground позволяет исполнить код без дополнительных заморочек. Поэтому Playground прекрасно зарекомендовал себя как инструмент для собеседования, по крайней мере в Acronis.
Пять кругов…собеседования
-------------------------
Чтобы выяснить, может ли соискатель приступить к работе сразу после собеседования, мы задаем следующие пять практических вопросов:
### 1. Различия между reference type и value type
Мобильные разработчики под iOS прекрасно знают, что в языке есть разные типы переменных. Они делятся на два основных вида. А именно, одни передаются по ссылке — reference type (ссылочный тип), а другие — по значению — value type (тип значений). На интервью мы спрашиваем, в чем разница между (struct) структурой и (class) классом. Структура является value type, а класс — reference type. Увы, на такой вопрос отвечают далеко не все, а некоторая часть кандидатов даже интересуется, «почему такой странный вопрос в самом начале?». Но если задуматься, вопрос-то совсем не странный, особенно если вы планируете разрабатывать на Swift.
Экземпляры reference type при инициализации и присвоении начинают ссылаться на одну и ту же область в памяти и, как следствие, делят одно и то же значение между собой, а в случае с value type происходит копирование данных, и объекты начинают ссылаться на разные области памяти, и значения между собой они не делят. Строго говоря, в случае с value type работает принцип copy-on-write. То есть, до момента попытки изменения значения экземпляры value type будут ссылаться на один и тот же адрес, а при первом же изменении произойдёт копирование. Очевидно, что понимание этого необходимо разработчику. Код может вести себя абсолютно различно для классов и структур. Но просто знать отличия — мало. Второй уровень осознанности — разница в написании кода. Оказывается, что написать в Playground и продемонстрировать отличия в работе с reference type и value type не так-то просто, если вы не имели опыта программирования в Swift. У нас только 1 из 3 кандидатов проходит этот тест.
Для любопытствующих, различия хорошо были показаны на конференции [WWDC](https://developer.apple.com/videos/play/wwdc2015/414/), а также подробно рассмотрены в [документации](https://docs.swift.org/swift-book/LanguageGuide/ClassesAndStructures.html) и [блоге](https://developer.apple.com/swift/blog/?id=10).
### 2. Что такое Protocol Oriented Programming?
В программировании невозможно обойтись без интерфейсов. Apple в своих языках использует термин protocol. Протоколы позволяют решить проблему множественного наследования. Protocol Oriented Programming Apple представила общественности несколько лет назад на конференции [WWDC](https://developer.apple.com/videos/play/wwdc2015/408/) вместе со Swift, сделав упор на их важности для языка. Например, важным показателем для использования протоколов является тот факт, что в языке нет protected уровень доступа к полям.
Подразумевается, что полиморфизм должен достигаться с использованием протоколов, а не наследования. И хотя на самом деле Protocol Oriented Programming — это скорее маркетинг, в ответе на такой вопрос мы ждем, что программист начнет рассказывать об особенностях протоколов и сможет создать протокол в Playground. В сущности, чтобы описать протокол нужно три строчки. Увы, в мобильной разработке люди часто не понимают назначения протоколов, и не могут даже этого. А мы ждем чего-то простого, например:
```
protocol Developer {
func readManual()
var name: String { get }
}
```
К тому же бывают обычные протоколы, а бывают generic-протоколы, которые работают с ассоциативными типами (Associated Type). И, по сути, являются близкими к шаблонам (templates) в C++. Generic-протоколы представляют собой абстрактные и специфичные вещи, которые очень редко применяются в обычном программировании. Они нужны для написания внутренних библиотек (и именно для этого используется самой Apple) или библиотек, где нужно использовать высокую степень абстракции. Хорошо если соискатель знает и об этом. [Раз](https://docs.swift.org/swift-book/LanguageGuide/Protocols.html) ссылка и [два](https://docs.swift.org/swift-book/LanguageGuide/Generics.html).
### 3. Работа с памятью
В iOS своя система работы с памятью, в которой используется подсчёт ссылок. Есть два подхода в Swift. Это ручной подсчёт ссылок (Manual Reference Counting, MRC) и автоматический подсчёт ссылок (Automatic Reference Counting, ARC). Manual Reference Counting используется при прямой работе с памятью, но обычно всё же используется ARC. В частности, разработчику важно понимать, чем отличаются сильные ссылки (strong) от слабых (weak). Это важный момент для тех языков, где нет сборщика мусора (Garbage Collector). Вот [интересное письмо](https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160208/009405.html) на тему, почему в Swift не используется Garbage Collector.
На самом деле тут все не так сложно — нужно рассказать про счетчик ссылок, о том, что объект удаляется, когда значение счетчика достигает 0 (нуля), и так далее. Но нам опять же нужно, чтобы человек показал пример в Playground. И тут у части соискателей возникает ступор. Даже если пара фраз о сильных и слабых ссылках была успешно выучена, на данном этапе становится очевидно, если у человека не было нормальной практики кодинга на Swift.
```
// Инициализировать
var slimer: Ghost? = Ghost(name: "Slimer")
// Создать слабую ссылку, не увеличивая счётчик
weak var weakSlimer = slimer
// Создать сильную ссылку, увеличивая счётчик
let strongSlimer = slimer
// Уменьшить счётчик ссылок
slimer = nil
```
### 4. Работа с замыканиями
В Java, С++ есть лямбды, в Objective-C есть блоки, во многих языках есть свои конструкции, соответствующие понятию замыканий (closure) в Swift. Но соискатели часто не могут объяснить, как обращаться с замыканием, ведь для этого нужно понимать, как работать с памятью и системой взаимосвязей внутренних и внешних переменных. А значит — нужно хорошо знать стандартные форматы данных, управление памятью и прочие связанные моменты. Если создать замыкание в коде не представляет для соискателя особой сложности:
```
let completionHanlder: () -> Void = {
print("Success")
}
```
То, например, сказать, каким типом — value или reference — является замыкание, уже достаточно сложная задача. На деле замыкание — это reference type. И именно отсюда появляются известные конструкции *[weak self] in*.
```
let completionHanlder: () -> Void = { [weak self] in
self?.close()
}
```
Чтобы проверить умения соискателей, мы заготовили шаблон в Playground. Ниже вы можете видеть массив, который изменяется по-разному в двух потоках. И нужно ответить, какой эффект это создаст в приложении. Понимание процесса в данном случае отражает умение работать с переменными и передавать их между разными объектами.
```
//: Playground — noun: a place where people can play
import Foundation
import PlaygroundSupport
let queue = DispatchQueue.global()
var employees = ["Bill", "Bob", "Joe"]
queue.async {
let count = employees.count
for index in 0 ..< count {
print("\(employees[index])")
Thread.sleep(forTimeInterval: 1)
}
}
queue.async {
Thread.sleep(forTimeInterval: 0.5)
print("remove")
employees.remove(at: 0)
}
PlaygroundPage.current.needsIndefiniteExecution = true
```
Пример взят [отсюда](https://stackoverflow.com/a/41351166/1979882).
### 5. Написать простое приложение
Любой разработчик должен уметь запустить проект. Мы даем для этого простую задачу — разработать приложение под iOS, которое просто показывает сайт Acronis. Для программиста, который действительно что-то делал на Swift, такая задача потребует 10-15 минут, которые в основном уходят на выставление настроек и проверку.
Если этот этап пройден, происходит усложнение задачи, как обычно это бывает в жизни: «приходит product-manager, который меняет условия и срочно требует доработки». Ведь именно так строится ежедневная практика любого программиста. Интересно посмотреть, как человек меняет код согласно новым условиям. В нашем простом тестовом задании мы проходим несколько итераций, например:
* Добавить навигацию в приложении
* Сделать выбор между несколькими сайтам
* Добавить архитектуру
* Написать более абстрактно
Наблюдая за такой работой в интерактивном режиме, можно узнать, как человек пользуется документацией, GitHub и другими ресурсами.
Безусловно, это далеко не все вопросы, которые задаются на собеседовании, но наши кандидаты должны справиться, в первую очередь, с решением этих базовых задач.
Заключение
----------
Интерактивное собеседование позволяет увидеть реальное поведение разработчика, включая его soft-skills и умение общаться с менеджерами. И далеко не все специалисты, которые приходят к нам, проходят даже часть испытаний.
Мы [открыты к сотрудничеству](https://www.acronis.com/en-us/careers/) и ждем в нашу команду талантливых разработчиков.
Если вы хотите работать в мобильной разработке Acronis, рекомендую вам попрактиковаться с программированием на Swift.
А мы, тем временем, подготовим серию постов о своем опыте работы с этим языком программирования.
Подписывайтесь на наш блог, чтобы ничего не пропустить.
Конкурс
-------
Приложение, [исходники](https://github.com/VyacheslavAcronis/acronis-for-habr-test-ios) которого хранятся на Github, падает при запуске.
**Задача:** необходимо создать pull request с исправлением причины падения.
Первый, кто сделает этот запрос с исправлением ошибки, получит приз — Power Bank и годовую лицензию [Acronis True Image 2018](https://www.acronis.com/ru-ru/personal/whats-new/) с 1 Тб облачного хранилища. | https://habr.com/ru/post/415655/ | null | ru | null |
# Доступна Android Studio 1.4
Несколько дней назад стала [доступна](http://tools.android.com/recent/androidstudio14available) *Android Studio 1.4* на Stable Channel, привнёсшая ряд удобных новшеств в инструментарий Android разработчика. Тех, кто еще не успел ознакомиться с нововведениями, прошу под кат.
Обновлены шаблоны проектов
--------------------------
Первое, что бросается в глаза, это обновленные шаблоны типовых лэйаутов, доступных в New Project Wizard: Android Studio 1.4 привносит полноценную поддержку Material Design уже на этапе создания нового проекта:
Создадим демо приложение на базе Navigation Drawer Activity. Смотрим *build.gradle* для модуля приложения:
```
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
testCompile 'junit:junit:4.12'
compile 'com.android.support:appcompat-v7:23.0.1'
compile 'com.android.support:design:23.0.1'
}
```
Студия любезно позаботилась о нас, добавив библиотеки обратной совместимости [Android Design Support Library](http://android-developers.blogspot.com/2015/05/android-design-support-library.html) и [AppCompat Support library](http://android-developers.blogspot.com/2015/04/android-support-library-221.html). Больше не нужно тащить в проект сторонние реализации Floating Action Button, Material Dialogs или Snackbar — все необходимые визульные компоненты доступны в подключённых support libraries. Также нам добавили JUnit 4-ой версии, чтобы мы не забыли написать юнит-тесты.
> Примечание: напомню, что юнит-тесты живут в директориях `src\test\`, а не в `src\androidTest\`. Также стоит помнить, что тесты на JUnit 4 используют аннотацию `@Test` взамен `extends TestCase`.
В проекте у нас уже есть [DrawerLayout](https://developer.android.com/intl/ru/reference/android/support/v4/widget/DrawerLayout.html), [NavigationView](https://developer.android.com/intl/ru/reference/android/support/design/widget/NavigationView.html), [FloatingActionButton](https://developer.android.com/intl/ru/reference/android/support/design/widget/FloatingActionButton.html) и даже [CoordinatorLayout](https://developer.android.com/intl/ru/reference/android/support/design/widget/CoordinatorLayout.html) ([подробней](http://habrahabr.ru/post/265119/)), который позаботится о том, чтобы приподнять FAB при появлении ~~Toast~~ Snackbar.
**app\_bar\_mail.xml**
```
xml version="1.0" encoding="utf-8"?
```
Добавлен Theme Editor
---------------------
Появился визуальный редактор тем, позволяющий за пару минут поправить внешний вид приложения с учётом специфики Material Design. Вызвать его можно через *Tools → Android → Theme Editor* или по кнопке *Open Editor* для уже открытого *styles.xml*:
> Примечание: для полноценной работы Theme Editor с возможностью preview необходимо наличие SDK Platform для API 23.
Больше не нужно часами выгугливать нужные свойства темы, подбирать Primary/PrimaryDark/Accent цвета — Theme Editor любезно подскажет/сгенерирует нужную палитру. Так, PrimaryDark будет подобран на основе Primary цвета — удобно.
Инструмент Vector Assets, поддержка Vector Drawable
---------------------------------------------------
Если Вы еще не слышали про [*Vector Drawable*](https://developer.android.com/intl/ru/reference/android/graphics/drawable/VectorDrawable.html), то рекомендую прочитать [эту](http://habrahabr.ru/company/rambler-co/blog/267073/) отличную статью. В Android Studio 1.4 появился визуальный интрумент под названием *Vector Assets*, который позволит с ~~легкостью~~ перейти на векторный формат графики в Вашем приложении как на Lollipop/Marshmallow, так и на предыдущих версиях API. Для этого необходимо воспользоваться обновленной версией Android Gradle плагина (на момент выхода статьи он в бете, но обещали «как только, так сразу»), поправив *build.gradle* для проекта:
```
dependencies {
classpath 'com.android.tools.build:gradle:1.4.0-beta3'
}
```
Вызвать инструмент можно через диалог *Android Project → New → Vector Assets*:
Здесь нам предлагают выбрать векторную иконку из Material Design Icons Pack или импортировать сторонний *\*.svg* файл.
> Внимание: импорт находится в стадии разработки и не поддерживает всю спецификацию SVG. Проблемные элементы будут выведены в список, придётся вносить правки.
После этого Vector Assets сгенерирует xml ресурсы VectorDrawable и положит в `res\drawable`. Для обеспечения обратной совестимости с pre-Lollipop устройствами в момент билда android gradle plugin сгенерирует *\*.png* под все плотности экранов в директории `app\build\generated\res\pngs`
> Ограничения обратной совместимости:
>
>
>
> *minSdkVersion >= 21 (Lollipop)*
>
> * Полная поддержка VectorDrawable API
>
>
>
> *minSdkVersion < 21*
>
> * Автогенерация png взамен sml в момент билда
> * Урезанный VectorDrawable API
> * Не поддерживаются элементы ``и``
>
> Использование `BitmapDrawable` вместо `VectorDrawable` в Java коде.
>
>
>
> ### Два новых монитора: GPU Rendering, Network
>
>
>
> Для анализа производительности приложения разработчику доступны два новых монитора: [GPU Rendering Monitor](https://developer.android.com/intl/ru/tools/performance/profile-gpu-rendering/index.html?utm_campaign=android-studio-1-4-929&utm_source=dac&utm_medium=blog) и *Network Monitor*:
>
>
>
> 
>
> 
>
>
>
>
> > Чтобы заработал GPU Rendering монитор, его нужно включать на устройстве или эмуляторе: *Setting → Developer Options → Profile GPU rendering → In adb shell dumpsys gfxinfo*
> >
> >
>
>
>
> На этом всё, приятно видеть, что любимый инструмент Android разработчиков развивается, спасибо за внимание.
>
>
>
> Использованы материалы:
>
> [Блог Android Studio](http://android-developers.blogspot.ru/2015/09/android-studio-14.html?linkId=17483266)
>
> [Vector Drawable API. Возможности применения](http://habrahabr.ru/company/rambler-co/blog/267073/)
>
> [Легко переходим на векторный формат картинок вместо нарезки под разные плотности экранов в Android 4.0+. Часть 1 из 2](http://habrahabr.ru/post/265601/) | https://habr.com/ru/post/268143/ | null | ru | null |
# Доработки шаблонизатора DoT.js
Время зоопарка шаблонизаторов миновало, теперь вокруг бегают динозаврики MVC, а в них используются встроенные шаблонизаторы и билдеры компонентов. Но для замены старых менее удобных шаблонизаторов в Knockout и Backbone иногда нужны они, в основном, остановившиеся в развитии на уровне около 2014 года.
Так случилось и с [DoT.js](https://github.com/olado/doT). Поначалу заброшенный авторами примерно на год в 2013-м, он получил их внимание ненадолго, поднявшись с версии 1.0.1 до 1.1.1, и снова был заброшен (или стабилизирован, смотря как рассуждать). В связи с этим ещё в 2013 году понадобилось ([делать клон DoT.js](https://github.com/spmbt/doT/blob/9e2520b4f53b6b957a8436178f76c46a5666b5d6/doT.js)), а теперь — и апгрейдить его.
Он — такой же быстрый, как и встроенный `_.template()` в Underscore/Lodash, но с улучшенным синтаксисом, при котором необходимость писать JS в шаблонах встречается нечасто, а в Underscor-овском — нужна всегда. Этим скобкам со скриптами даже придумали специальный термин: javascript encapulated sections (JES), и от них, в основном, избавились.
### Что получаем дополнительно?
1. Структура шаблонизатора [была переработана (в 2013-м, ссылка оттуда)](https://github.com/spmbt/doT/blob/9e2520b4f53b6b957a8436178f76c46a5666b5d6/doT.js), чтобы лучше читалась и уменьшилось число декодирований функций;
2. [Тесты показали](https://habrahabr.ru/post/201592/), что быстродействие в среднем не изменилось (колебания -3% — +10% в зависимости от параметров);
3. Добавлена команда работы по структуре, аналогично работе по массиву;
4. 4-й параметр — фильтр элементов структуры или массива;
5. Кое-где замедления вследствие обхода багов скомпенсированы оптимизацией кода и регекспов;
6. Глобальное имя «doT» способно меняться на другое в настройках (у оригинала — нет);
7. Наведён порядок в нумерации версий и версионировании глобальных функций encodeHTML() — инстансов, принятых здесь для оптимизации.
*#### Для справки по нумерации версий
В npm копия версии 1.1.1 один-в-один в package.json названа как 1.1.2, но в файле — остался номер 1.1.1; в ветке 2.0 в репо — то же самое с необновлением номера 1.1.1 и есть всего 1 отличие в `var rw = unescape(...)`. В общем, всё сделано для неразберихи. Поэтому считаем, что самая новая версия — 1.1.1, в которой учтём отличие из ветки 2.0. Ветка 2.0 своего звания не заслуживает.*
По случаю, удобно сделать документацию (есть [от авторов](http://olado.github.io/doT/index.html)), с инструментом для её проверки. (Что в Сети нашлось читабельного — ссылки внизу.) Если кратко:
• он сохранил «исконный» синтаксис Underscore `_.template()`, в котором внутри скобок "`{{ ... }}`" можем писать любой JS-код, включая незакрытые фигурные и операторные скобки, а снаружи скобок — HTML-фрагменты текста.
• скобки переопределить можно, переопределив в настройках все регекспы с ними (обычно не нужно);
• имя старшего элемента структуры `'it'` тоже переопределить можно, как и 4 логических настройки поведения;
• поддерживается AMD, commonJS и просто глобальное имя его (`'doT'`);
• кроме базового универсального синтаксиса, имеет ряд команд, подобных стилю Mustache/Handelbars;
• как и они, и `_.template()`, имеет 2 этапа шаблонизации (каррирования параметров) — в функцию и затем в HTML (или другой) код;
• не заточен строго под HTML, но привязан к JS, поэтому его сфера — браузеры и NodeJS;
• не намного больше по объёму, чем исходный код `_.template()` — 3.3 К в сжатом не зипованном виде.
*(Для экспериментов с кодом нового или старого шаблонизатора можно воспользоваться старым примером в <http://jsfiddle.net/6KU9Y/2/> (но далее есть js-фиддл лучше). Построена и в репозитории удобная страница тестирования 2 движков на общем шаблоне и данных — в `test/index.html`. По умолчанию она сравнивает одинаковость результатов в развёрнутой и минифицированной версиях файлов. И второй движок может работать лишь с клоном, т.к. у него возможно глобальное имя, отличное от `'doT'`. Вместо минифицированной можно поставить клон, а на первом месте, например, оригинальный DoT.js 1.1.1 и смотреть различия в парсинге.)*
В файле второго движка нужно перед открытием страницы установить имя `globalName:'doTmin'`.
Впрочем, и в онлайне то же самое несложно: <https://jsfiddle.net/spmbt/v3yvpbsu/26/embedded/#Result> или с фреймами и редактированием кода, у кого большие экраны: <https://jsfiddle.net/spmbt/v3yvpbsu/26/>. Файлы подключать не надо, лишь копипастить содержимое 2 версий DoT.js, а во второй, удобнее это делать в клоне — подправить имя `doT` на `doTmin` (даже если не minimized). По умолчанию выставлены DoT.js 1.1.1 оригинал и DoT12.js 1.2.1 — клон.
Бенчмарк (3-я кнопка) устроен по короткому промежутку времени, поэтому зависит от параллельных процессов, и о скорости синхронных алгоритмов можно судить при усреденении по большому числу измерений (среднее накапливается и позволяет немного судить о скоростях). Встроенный в проект бенчмарк есть, но он сложный, через Ноду, а делает то же самое (по группе тестовых файлов).
В страницу тестов встроены чекбокс автообновления и перехват ошибок, что позволяет проводить тесты по той версии, которая останется исправной. Так, легко сравнить скорости команд `'~'` и `'@'` по массиву. Вторая тоже работать может, но значительно медленнее — на 10-15% (проверяется кнопкой «Bench»). Это связано с необходимостью использовать более медленный цикл for-in во втором случае. Тем не менее, без for-in для структур не обойтись, чтобы не иметь необходимости подготовки массивов из структур для оригинальной версии, не имеющей команды `'@'`.
Сразу традиционно заметим, что 2-е вычисление (расчёт **по компилированному шаблону**) идёт в сотню раз **быстрее (для коротких выражений), чем полная компиляция** каждый раз (1-е число, по в 100 раз меньшему числу измерений). На скриншоте "`Comp1e3: 99.22ms`" означает: «1000 полных компиляций проведены за время 99.22ms». "`Run5e5: 69.08 ms`" в 5-й строчке означает: «50 тысяч быстрых генераций HTML по шаблону проведены за усреднённое время 69.08ms на каждые 10 тысяч генераций».
Добавлен **спадающий список примеров**, из которого можно извлечь типичные примеры применения команд DoT.js и протестировать их в 2 версиях скрипта. Изменения примеров временно сохраняются и к ним можно вернуться, повторно выбрав прежний пункт примера, если страница браузера не была перезагружена.
О командах — подробнее
======================
В начале пункта в кавычках будет приведено имя, которым в коде `DoT12.js` названо регулярное выражение, отвечающее за данную функцию (команду) шаблонизации.
#### Команда "**valEncEval**"
Один регексп под этим именем объединяет 3 прежних команды, имеющие сходный синтаксис.
```
{{ часть выражения и операторов JS }}
```
Универсальное наследие Underscore. Больше ничего не надо, оно самодостаточно, чтобы описать всё (пробелы у скобок не обязательны). Но читать… Читать больше 40 строк строго не рекомендуется. Незакрытые скобки JS перемежаются с закрытыми такими же фигурными скобками шаблонизатора. За ними идут незакрытые теги HTML. Это — нормальная практика, работает отлично, машина понимает. В то же время, Mustache/Handlebars уже читабельны.
```
{{= выражение JS }}
```
Значение выражения выкладывается в окружающий поток HTML, с сохранением тегов HTML и невзирая на незакрытые теговые скобки. Так, встретившийся `"
"` в значении выражения, если будет выложен в страницу браузера, будет вести себя не как текст, а как тег — приведёт к переносу строки по правилам HTML. | https://habr.com/ru/post/333662/ | null | ru | null |
# Разработка и тестирование веб сервисов на PHP/SoapUi
Веб сервисы достаточно удобный метод организовать клиент-серверное общение, особенно если обе стороны используют разные платформы. Формализация общения позволяет однозначно определить словарь сообщений и применить огромное количество уже существующих библиотек и методик. Enterprise платформы (.net, jee) включают множество утилит для дизайна, разработки и тестирования веб сервисов, и многие из этих утилит вполне применимы на небольших проектах.
Эта статья описывает создание простого веб сервиса на php и его автоматизированное тестирование.
Веб сервис будет реализовывать три операции: реверс строки, суммирование и эхо.
#### План
Наш план: сначала планируем и объявляем, потом реализовываем. Таким образом у мы последовательно пройдем три этапа:
1. WSDL first — объявим наш словарь, или создадим контракт
2. Реализуем контракт на PHP
3. Автоматизируем процесс тестирования
#### Требования
Все инструменты open source
PHP 5+
NUSOAP — php библиотека для работы с WS (http://sf.net/projects/nusoap)
Eclipse от eclipse.org, версия for EE developers — мы воспользуемся только WSDL редактором.
SoapUI — soapui.org. Пакет для тестирования веб сервис ориентированных приложений
#### WSDL first
WSDL это контракт, т.е. соглашение по которому сервер обязуется обслуживать клиента и указывает параметры этого процесса. По сути это XML документ, который описывает методы, типы данных и другие параметры.
Существует два подхода к написанию веб сервисов:
1. Разработчик пишет программный код и средства платформы реализуют WSDL автоматически
2. Дизайнер или архитектор описывает интерфейсы в WSDL и под них имплементируют логику.
Многие разработчики идут по первому пути, т.е. они пишут код (java, c# и тп) м не задумываются о веб сервисах. С точки зрения разработчика это явный плюс.
Но эта стратегия сильно проигрывает в крупных проектах, с несколькими распределенными командами. В идеале, мы бы хотели стабилизировать интерфейсы и, например, позволить команде пишущей клиента не ждать релизов от команды пишущей сервер. И QA тоже должны начать писать тесты как можно раньше.
Таким образом мы приходим к необходимости написания WSDL в первую очередь.
**Создадим WSDL с помощью Eclipse:**
После запуска эклипса, создайте проект New->Other->Web services->WSDL
Имя файла укажите «ws.wsdl», namespace: «[sample](http://sample)»
*(namespace не имеет отношения к WS, так как является обычной практикой работы с XML)*
После создания вы получите новый WSDL с одной операцией «NewOperation».
Удалите ее и создайте новую с именем «reverse». Клики по стрелкам позволяют просмотреть все параметры, но менять их не обязательно.
Сама операция revers будет получать строку от клиента и возвращать ее в обратном порядке следования символов, т.е. нужен один IN параметр String и результат String. Добавьте их в вашу операцию.
Вы можете сами добавить операции ping и sum с необходимыми параметрами *(или откройте wsdl из архива, см линк в конце)*
Сохраните ваши изменения как 'ws.wsdl'
Теперь у вас есть контракт, и вы можете отдать его разработчикам клиента, сервера, QA и тд. Все они могут начинать работу независимо друг от друга.
#### Реализуем WS на PHP
Создайте директорию soap в вашей public\_html и скопируйте ws.wsdl (соответственно файл доступен как [yourserver/soap/ws.wsdl](http://yourserver/soap/ws.wsdl))
Серверный код мы поместим в ws.php, и [localhost/soap/ws.php](http://localhost/soap/ws.php) будет линком вашего веб сервиса.
Дополнительно распакуйте nusoap в 'soap'.
Перейдем к непосредственной реализации логики:
Первые строки вашего ws.php:
`require('lib/nusoap.php');
$server = new soap_server('ws.wsdl');`
Эта конструкция сообщает скрипту, что надо реализовать указанный контракт. Сам вызов будет обработан:
`$server->service($HTTP_RAW_POST_DATA);`
Это все, что необходимо для поддержки WS, остальное это ваша логика — бизнес методы.
Для каждой операции из контракта надо создать php функция с эквивалентным именем.
Вот пример всего файла:
`php<br/
require('lib/nusoap.php');
$server = new soap_server('ws.xml');
function reverse($in){
return strrev($in);
}
function ping() {
return time();
}
function sum($a, $b) {
return ($a + $b);
}
$server->service($HTTP_RAW_POST_DATA);
?>`
Если вы откроете в браузере: [localhost/soap/ws.php](http://localhost/soap/ws.php) — вы увидите все доступные операции.
Теперь ваш сервер готов обслуживать клиентов! Но к вас нет клиента… и мы не будем его писать, так как применим автоматизированное тестирование…
*(не забудьте, что мы будем тестировать веб сервис, что является интеграционным тестированием, и не отменяет написания юнит тестов на бизнес методы)*
#### Тестируем с SoapUI
SoapUI это великолепное средство для тестирования и разработки систем на основе веб сервисов. Эта утилита достойна отдельной статьи, поэтому мы воспользуемся лишь одной из опций — протестируем наш сервер, эмулируя клиента.
Для этого нам понадобятся несколько кликов…
Запустите soapUi и создайте новый проект, в качестве wsdl укажите наш ws.wsdl. Не меняйте другие параметры.
Это создаст проект и вы уведете все операции в дереве. Кликнете правой кнопкой на сервисе и выберите 'Generate TestSuite'. Установите стиль на 'Singe suite ...'.
Результатом будет test suit в дереве и окно пакета (его можно закрыть.)
Сам тестовый пакет содержит ряд шагов, по одному на каждую операцию. Как вы уже догадались, это и есть элементы для проверки вашего сервиса. Вы можете запустить их все разом, или по одному, в зависимости от ваших целей.
Мы попробуем запускать их по одному, предварительно настроив.
Кликните на шаге reverse, вы увидете две панели, панель запроса и панель ответа. Контент запроса генерируется автоматически на основе контракта с знаками вопроса на месте данных. В нашем случае у нас есть один placeholder для строки, введем значение 123456789
Проверьте что target url наверху панели указывает на ваш сервис и вы можете запустить шаг на выполнение использую зеленый треугольник на панели.
Запрос уйдет на сервер и вторая панель отобразит ответ, который должен содержать 987654321 — входной параметр в обратном порядке.
Визуально мы можем убедится, что наша система работает корректно, но есть минус — мы видим это визуально. В идеале мы бы хотели это автоматизировать для регрессивного тестирования.
Обратите внимание на иконку сразу за 'Run'. Здесь собраны условия для проверки ответа и вы можете добавить условие наличие строки 987654321 в ответе.
Теперь у вас есть автоматизированный тест, который может выполняться как вручную, так и сервером сборки.
#### Пример
Пример в архиве содержит
ws.php имплементация веб сервиса
ws.wsdl контракт
WS-soapui-project.xml — soap ui проект
lib nusoap библиотеки
Скачать можно тут [romanenco.com/sites/default/files/phpws.zip](http://romanenco.com/sites/default/files/phpws.zip)
English version [romanenco.com/phpws](http://romanenco.com/phpws)
Andrew Romanenco | https://habr.com/ru/post/61270/ | null | ru | null |
# MODx — архив новостей в виде календаря (упрощенный вариант)
Итак, начнем с того, что многие, кто работает с MODx, рано или поздно сталкиваются с тем, что каким бы не был удобным Ditto, но, все же, он не может делать многих вещей, одна из которых, по моему, должна быть вообще в базовых возможностях — архив новостей в виде календаря, например такого:
На данным момент, к сожалению, есть только упрощенный вариант решения данной проблемы: DittoCal. Его всегда можно скачать [здесь](http://modxcms.com/extras/package/99).
Почему упрощенный? Да потому что сниппет не умеет показывать сразу несколько новостей за одну и ту же дату, а выводит самую первую, однако для кого-то большего и не надо, поэтому приступим.
Скачав архив мы увидим в нем 2 фала: JSON.php и snippet.DittoCal.php, заходим в MODx и создаем новый сниппет «DittoCal», в него копируем содержание файла snippet.DittoCal.php. Открываем наш фтп и создаем новую папку «DittoCal» в assets/snippets, после чего закачиваем в нее файл JSON.php.
Теперь самое интересное: как вообще все это работает.
1. Создаем новый документ с такими параметрами:
Заголовок: blog json output
Псевдоним: blog-json-output
Шаблон: blank
Показывать в меню: нет
Публиковать: да
Доступен для поиска: нет
Тип содержимого: text/plain
2. В контенте пишем:
`[!Ditto? startID=`id_нашей_папки_с_новостями` &summarize=`100` &format=`json` &dateFormat=`%d-%m-%Y` &sortDir=`desc`!]`
3. Сохраняем документ
4. Вставляем куда-нибудь вызов нашего календарика:
`[!DittoCal? &calSource=`наш_сайт.ру/blog-json-output` &dayNameLength=`1`!]`
Все, можно наслаждаться нашим календариком:
Но, на картинке-то он русский, а у меня нет! Это бывает, хоть у сниппета и есть функция отвечающая за региональные настройки календарика, но далеко не всегда он работает, поэтому **следующий момент: русификация**.
1. Открываем в MODx сниппет DittoCal.
2. Ищем строчку
`$title = htmlentities(ucfirst($month_name)).' '.$year; #note that some locales don't capitalize month and day names`
И добавляем после нее
`switch(ucfirst($month_name))
{
case "January": $title="Январь"; break;
case "February": $title="Февраль"; break;
case "March": $title="Март"; break;
case "April": $title="Апрель"; break;
case "May": $title="Май"; break;
case "June": $title="Июнь"; break;
case "July": $title="Июль"; break;
case "August": $title="Август"; break;
case "September": $title="Сентябрь"; break;
case "October": $title="Октябрь"; break;
case "November": $title="Ноябрь"; break;
case "December": $title="Декабрь"; break;
}
$title.=' '.$year;`
3. Ищем:
`foreach($day_names as $d)
$calendar .= ''.htmlentities($day_name_length < 4 ? substr($d,0,$day_name_length) : $d).'';`
и заменяем на
`$calendar .= 'П';
$calendar .= 'В';
$calendar .= 'С';
$calendar .= 'Ч';
$calendar .= 'П';
$calendar .= 'С';
$calendar .= 'В';`
Все. Теперь календарь русифицирован.
Для тех, кто делает все как написано, но все равно все на английской или вообще не работает, то я приведу здесь ссылку на полный код сниппета уже русифицированного: [DittoCalRus](http://narod.ru/disk/19605634000/DittoCalRus.txt.html)
Теперь хорошо бы его стилизовать, что ж, здесь вообще нет ничего сложного, что бы сохранить вам время, я предлагаю уже **готовый вариант CSS**:
`/*********************************************
**CSS для календаря**
*********************************************/
table.calendar {
width: 182px;
padding: 0px;
margin: 0px auto;
margin-bottom: 5px;
border-left: 1px solid #A2ADBC;
font: bold 12px/20px;
text-align: center;
background-color: #EEE;
color: #888888;
}
.calendar-prev, .calendar-prev a, .calendar-next, .calendar-next a {
font-size: 24px;
text-align: center;
text-decoration: none;
}
caption.calendar-month {
margin: 0px auto;
margin-top: 5px;
padding: 5px 0px;
width: 182px;
color: #8e2c3a;
font-size: 18px;
text-align: center;
}
table.calendar th {
font-size: 16px;
color: #616B76;
width: 26px;
height: 25px;
border-right: 1px solid #A2ADBC;
border-bottom: 1px solid #A2ADBC;
border-top: 1px solid #A2ADBC;
text-align: center;
}
table.calendar td {
border-right: 1px solid #A2ADBC;
border-bottom: 1px solid #A2ADBC;
width: 26px;
height: 25px;
text-align: center;
}
table.calendar td a {
text-decoration: none;
font-weight: bold;
display: block;
font-size:100%;
}
table.calendar td a:link, table.calendar td a:visited {
color: #000;
}
table.calendar td a:hover, table.calendar td a:active {
color: #8e2c3a;
}`
Итак, получим вот это:
По просьбам пользователей добавлю пример использования, для того, что бы была ясна работа архива:
[Пример на сайте muddydogpaws.com](http://www.muddydogpaws.com/notebook/?calmonth=03&calyear=2009)
Все, приятного пользования, спасибо!
З.Ы: может быть появится время на днях, тогда попробую посмотреть, что можно сделать с выводом нескольких новостей за одну дату.
Приложение — Парамеры DittoCal
`**&calSource**
по умолчанию: нет, но обязателен
значение: [ URI ]
описание: Ссылка на страничку, откуда календарь будет брать новости в специальном формате (т.о. это и есть та ссылка: www.mysite.ru/blog-json-output)
**&linkClass**
по умолчанию: cal_link
значение: [ string ]
описание: Класс для ячеек таблицы (td), которые будут ссылками.
**&dayNameLength**
по умолчанию: 3
значение: [ 0 | 1 | 2 | 3 | 4 ]
описание: Сколько символов отображать для дней (4 - отображать все имя полностью).
**&firstDay**
по умолчанию: 0
значение: [ 0 | 1 | 2 | 3 | 4 | 5 | 6 ]
описание: Какой день будет начинать неделю. 0=воскресенье, 1=понедельник, и т.д...
**&showPn**
по умолчанию: 1
значение: [ 0 | 1 ]
описание: Пгоказывать стрелочки Предыдущий/Следующий месяц.
**&debug**
по умолчанию: 0
значение: [ 0 | 1 ]
описание: Включить ли решим отладки, 1 - включить.
**&ph**
по умолчанию: cal_link
значение: [ string ]
описание: имя подстановщика, заменяющего непосредственно выводимые результаты.
**&activeDay**
по умолчанию: curDay
значение: [ string ]
описание: Класс для отображения дня, на который кликнули.` | https://habr.com/ru/post/91062/ | null | ru | null |
# Устанавливаем балансировщик нагрузки HAProxy на CentOS
***Перевод статьи подготовлен в преддверии старта курса [«Администратор Linux. Виртуализация и кластеризация»](https://otus.pw/KbNT/)***
---
Балансировка нагрузки — это распространенное решение для горизонтального масштабирования веб-приложений по нескольким хостам с предоставлением пользователям единой точки доступа к сервису. [HAProxy](http://www.haproxy.org/) является одной из самых популярных программ для балансировки нагрузки с открытым исходным кодом, которая также обеспечивает высокую доступность и функциональность проксирования.
HAProxy стремится оптимизировать использование ресурсов, максимизировать пропускную способность, минимизировать время отклика и избежать перегрузки каждого отдельно взятого ресурса. Она может быть установлена на множестве дистрибутивов Linux, таких как CentOS 8, на котором мы остановимся в этом руководстве, а также в системах [Debian 8](https://upcloud.com/community/tutorials/haproxy-load-balancer-debian/) и [Ubuntu 16](https://upcloud.com/community/tutorials/haproxy-load-balancer-ubuntu/).
HAProxy особенно подходит для веб-сайтов с очень высоким трафиком и поэтому часто используется для повышения надежности и производительности конфигураций веб-служб с несколькими серверами. В этом руководстве изложены шаги по настройке HAProxy в качестве балансировщика нагрузки на облачном хосте CentOS 8, который затем направляет трафик на ваши веб-серверы.
В качестве необходимого условия для достижения наилучших результатов у вас должно быть как минимум два веб-сервера и сервер для балансировки нагрузки. На веб-серверах должна быть запущена хотя бы базовая веб-служба, такая как nginx или httpd, для того чтобы можно было проверить балансировку нагрузки между ними.
Установка HAProxy на CentOS 8
-----------------------------
В силу того, что HAProxy — быстро развивающееся приложение с открытым исходным кодом, дистрибутив, доступный вам в стандартных репозиториях CentOS, может оказаться не самой последней версией. Чтобы узнать актуальную версию, выполните следующую команду:
```
sudo yum info haproxy
```
HAProxy всегда предоставляет на выбор три стабильные версии: две самые последние поддерживаемые версии и третью, более старую, которая все еще получает критические обновления. Вы всегда можете проверить самую последнюю стабильную версию, указанную на сайте HAProxy, а затем решить, с какой версией вы хотите работать.
В этом руководстве мы будем устанавливать самую последнюю стабильную версию 2.0, которая еще не была доступна в стандартных репозиториях на момент написания руководства. Вам нужно будет установить ее из первоисточника. Но сначала проверьте, выполнены ли у вас необходимые условия для загрузки и компиляции программы.
```
sudo yum install gcc pcre-devel tar make -y
```
Загрузите исходный код с помощью команды ниже. Вы можете проверить, существует ли более новая версия, доступная на [странице загрузки HAProxy](http://www.haproxy.org/#down).
```
wget http://www.haproxy.org/download/2.0/src/haproxy-2.0.7.tar.gz -O ~/haproxy.tar.gz
```
После завершения загрузки распакуйте файлы с помощью приведенной ниже команды:
```
tar xzvf ~/haproxy.tar.gz -C ~/
```
Перейдите в распакованный каталог с исходниками:
```
cd ~/haproxy-2.0.7
```
Затем скомпилируйте программу под вашу систему:
```
make TARGET=linux-glibc
```
И, наконец, установите саму HAProxy:
```
sudo make install
```
Теперь HAProxy установлена, но для ее работы требуются некоторые дополнительные манипуляции. Продолжим настройку программного обеспечения и сервисов ниже.
Настройка HAProxy под ваш сервер
--------------------------------
Теперь добавьте следующие каталоги и файл статистики для записей HAProxy:
```
sudo mkdir -p /etc/haproxy
sudo mkdir -p /var/lib/haproxy
sudo touch /var/lib/haproxy/stats
```
Создайте символьную ссылку для двоичных файлов, чтобы вы могли запускать команды HAProxy от имени обычного пользователя:
```
sudo ln -s /usr/local/sbin/haproxy /usr/sbin/haproxy
```
Если вы хотите добавить прокси-сервер в систему в качестве службы, скопируйте файл haproxy.init из examples в свой каталог /etc/init.d. Отредактируйте права доступа к файлу, чтобы скрипт выполнялся, а затем перезагрузите демон systemd:
```
sudo cp ~/haproxy-2.0.7/examples/haproxy.init /etc/init.d/haproxy
sudo chmod 755 /etc/init.d/haproxy
sudo systemctl daemon-reload
```
Вам также необходимо разрешить службе автоматическую перезагрузку при запуске системы:
```
sudo chkconfig haproxy on
```
В целях удобства также рекомендуется добавить нового пользователя для запуска HAProxy:
```
sudo useradd -r haproxy
```
После этого вы можете еще раз проверить номер установленной версии с помощью следующей команды:
```
haproxy -v
HA-Proxy version 2.0.7 2019/09/27 - https://haproxy.org/
```
В нашем случае версия должна быть 2.0.7, как показано в примере вывода выше.
Наконец, файрвол в CentOS 8 по умолчанию довольно рестриктивен для этого проекта. Используйте следующие команды, чтобы разрешить необходимые службы и перезагрузить файрвол:
```
sudo firewall-cmd --permanent --zone=public --add-service=http
sudo firewall-cmd --permanent --zone=public --add-port=8181/tcp
sudo firewall-cmd --reload
```
Настройка балансировщика нагрузки
---------------------------------
Настройка HAProxy — довольно простой процесс. По сути, всё, что вам нужно сделать, это сообщить HAProxy, какие соединения он должен прослушивать и куда следует их ретранслировать.
Это делается путем создания файла конфигурации /etc/haproxy/haproxy.cfg с определяющими настройками. Вы можете почитать о параметрах конфигурации HAProxy [на странице документации](https://cbonte.github.io/haproxy-dconv/2.0/configuration.html), если хотите узнать об этом больше.
Балансировка нагрузки на транспортном уровне (layer 4)
------------------------------------------------------
Начнем с базовой настройки. Создайте новый файл конфигурации, например, используя **vi** с командой ниже:
```
sudo vi /etc/haproxy/haproxy.cfg
```
Добавьте в файл следующие разделы. Замените **server\_name** тем, что должно вызывать ваши сервера на странице статистики, а **private\_ip** — приватными IP-адресами серверов, на которые вы хотите направлять веб-трафик. Вы можете проверить приватные IP-адреса [на панели управления UpCloud](https://hub.upcloud.com/networks/private?_ga=2.194047085.1141044831.1595511160-752947894.1595511160) и на вкладке *Private network* в меню *Network*.
```
global
log /dev/log local0
log /dev/log local1 notice
chroot /var/lib/haproxy
stats timeout 30s
user haproxy
group haproxy
daemon
defaults
log global
mode http
option httplog
option dontlognull
timeout connect 5000
timeout client 50000
timeout server 50000
frontend http_front
bind *:80
stats uri /haproxy?stats
default_backend http_back
backend http_back
balance roundrobin
server server_name1 private_ip1:80 check
server server_name2 private_ip2:80 check
```
Это определяет балансировщик нагрузки транспортного уровня (layer 4) с внешним именем http\_front, прослушивающий порт 80, который затем направляет трафик к бэкенду по умолчанию с именем http\_back. Дополнительная статистика /haproxy?stats подключает страницу статистики по указанному адресу.
Различные алгоритмы балансировки нагрузки.
------------------------------------------
Указание серверов в разделе бэкенда позволяет HAProxy использовать эти серверы для балансировки нагрузки в соответствии с алгоритмом циклического перебора, когда это возможно.
Алгоритмы балансировки используются для определения того, на какой сервер в бэкенде передается каждое соединение. Вот некоторые из полезных опций:
* **Roundrobin:** каждый сервер используется по очереди в соответствии со своим весом. Это самый плавный и честный алгоритм, когда время обработки серверами остается равномерно распределенным. Этот алгоритм является динамическим, что позволяет регулировать вес сервера на лету.
* **Leastconn:** выбирается сервер с наименьшим количеством соединений. Циклический перебор выполняется между серверами с одинаковой нагрузкой. Использование этого алгоритма рекомендуется для длинных сеансов, таких как LDAP, SQL, TSE и т. д., но он не очень подходит для коротких сеансов, таких как HTTP.
* **First:** первый сервер с доступными слотами для подключения получает соединение. Серверы выбираются от самого низкого числового идентификатора до самого высокого, который по умолчанию соответствует положению сервера в ферме. Как только сервер достигает значения maxconn, используется следующий сервер.
* **Source:** IP-адрес источника хешируется и делится на общий вес запущенных серверов, чтобы определить, какой сервер будет получать запрос. Таким образом, один и тот же IP-адрес клиента будет всегда доставаться одному и тому же серверу, в то время как серверы остаются неизменными.
Настройка балансировки нагрузки на прикладном уровне (layer 7)
--------------------------------------------------------------
Еще одна доступная возможность — настроить балансировщик нагрузки для работы на прикладном уровне (layer 7), что полезно, когда части вашего веб-приложения расположены на разных хостах. Это может быть достигнуто путем регулирования передачи соединения, например, по URL.
Откройте файл конфигурации HAProxy с помощью текстового редактора:
```
sudo vi /etc/haproxy/haproxy.cfg
```
Затем настройте сегменты фронтенд и бэкенд в соответствии с примером ниже:
```
frontend http_front
bind *:80
stats uri /haproxy?stats
acl url_blog path_beg /blog
use_backend blog_back if url_blog
default_backend http_back
backend http_back
balance roundrobin
server server_name1 private_ip1:80 check
server server_name2 private_ip2:80 check
backend blog_back
server server_name3 private_ip3:80 check
```
Фронтенд объявляет правило ACL с именем url\_blog, которое применяется ко всем соединениям с путями, начинающимися с /blog. Use\_backend определяет, что соединения, соответствующие условию url\_blog, должны обслуживаться бэкендом с именем blog\_back, а все остальные запросы обрабатываются бэкендом по умолчанию.
Со стороны бэкенда конфигурация устанавливает две группы серверов: http\_back, как и раньше, и новую, называемую blog\_back, которая обслуживает соединения с example.com/blog.
После изменения настроек сохраните файл и перезапустите HAProxy с помощью следующей команды:
```
sudo systemctl restart haproxy
```
Если при запуске вы получили какие-либо предупреждения или сообщения об ошибках, проверьте конфигурацию на их наличие и убедитесь, что вы создали все необходимые файлы и папки, а затем снова попробуйте перезапустить.
Тестирование настройки
----------------------
Когда HAProxy настроен и запущен, откройте публичный IP-адрес сервера балансировщика нагрузки в браузере и проверьте, правильно ли вы подключились к бэкенду. Параметр stats uri в конфигурации создает страницу статистики по указанному адресу.
```
http://load_balancer_public_ip/haproxy?stats
```
Когда вы загружаете страницу статистики, если все ваши серверы отображаются зеленым, то настройка прошла успешно!
Страница статистики содержит некоторую полезную информацию для отслеживания ваших веб-хостов, включая время работы/простоя и количество сеансов. Если сервер помечен красным, убедитесь, что сервер включен и что вы можете пропинговать его с машины балансировки нагрузки.
Если ваш балансировщик нагрузки не отвечает, убедитесь, что HTTP-соединения не блокируются файрволом. Также убедитесь, что HAProxy работает с помощью команды ниже:
```
sudo systemctl status haproxy
```
Защита страницы статистики с помощью пароля
-------------------------------------------
Однако, если страница статистики просто указана во фронтенде, то она открыта для всеобщего обозрения, что может оказаться не очень хорошей идеей. Вместо этого вы можете назначить ей собственный номер порта, добавив приведенный ниже пример в конец вашего файла haproxy.cfg. Замените **username** и **password** на что-нибудь безопасное:
```
listen stats
bind *:8181
stats enable
stats uri /
stats realm Haproxy\ Statistics
stats auth username:password
```
После добавления новой группы слушателей удалите старую ссылку на stats uri из фронтенд группы. Когда закончите, сохраните файл и перезапустите HAProxy.
```
sudo systemctl restart haproxy
```
Затем снова откройте балансировщик нагрузки с новым номером порта и войдите в систему с именем пользователя и паролем, которые вы указали в файле конфигурации.
```
http://load_balancer_public_ip:8181
```
Убедитесь, что все ваши серверы по-прежнему отображаются зеленым, а затем откройте только IP балансировщика нагрузки без каких-либо номеров портов в вашем браузере.
```
http://load_balancer_public_ip/
```
Если на ваших внутренних серверах есть хотя бы какое-то разнообразие целевых страниц, вы заметите, что каждый раз, когда вы перезагружаете страницу, вы получаете ответ от другого хоста. Вы можете попробовать различные алгоритмы балансировки в разделе конфигурации или ознакомиться с [полной документацией](https://cbonte.github.io/haproxy-dconv/).
Заключение: балансировщик нагрузки HAProxy
------------------------------------------
Поздравляем с успешной настройкой балансировщика нагрузки HAProxy! Даже с базовой настройкой балансировки нагрузки вы можете значительно повысить производительность и доступность вашего веб-приложения. Это руководство является лишь введением в балансировку нагрузки с помощью HAProxy, которая способна на гораздо большее, чем то, что можно описать в краткой инструкции по настройке. Мы рекомендуем поэкспериментировать с различными конфигурациями с помощью [обширной документации](https://cbonte.github.io/haproxy-dconv/2.0/configuration.html), доступной для HAProxy, а затем приступить к планированию балансировки нагрузки для вашей производственной среды.
Используя несколько хостов для защиты вашего веб-сервиса с помощью запаса мощности, сам балансировщик нагрузки все равно может представлять точку отказа. Вы можете еще больше повысить высокую доступность, установив плавающий IP между несколькими балансировщиками нагрузки. Вы можете узнать больше об этом в нашей [статье о плавающих IP-адресах на UpCloud](https://upcloud.com/community/tutorials/floating-ip-addresses/).
---
Подробнее о курсе [«Администратор Linux. Виртуализация и кластеризация»](https://otus.pw/KbNT/)\*\*\*
--- | https://habr.com/ru/post/512238/ | null | ru | null |
# Go глазами Rust-программиста: первые впечатления
***В преддверии старта курса [«Разработчик Golang»](https://otus.pw/tkAZ/) подготовили перевод интересного материала.** А каким было ваше первое впечатление от Go?*
---
На протяжении последних нескольких недель мне довелось использовать [Go](https://en.wikipedia.org/wiki/Go_(programming_language)) в работе. Я впервые использовал Go на более-менее крупном и серьезном проекте. До этого я достаточно много читал про Go и практиковался на примерах и небольших программах при изучении возможностей [Rust](https://en.wikipedia.org/wiki/Rust_(programming_language)), но реальное программирование — это совсем другое дело.
Я подумал, что вам может быть интересно услышать о моих впечатлениях. Я постараюсь не зацикливаться на сравнениях с Rust, но так как это мой основной язык, их не избежать. Я должен заранее вас предупредить о сильном уклоне в сторону Rust, но я сделаю все возможное, чтобы быть объективным.
### Общие впечатления
Программировать на Go приятно. В библиотеках было все, что мне было нужно, без слишком большого количества недоработок. Изучение тоже было приятным опытом — это хорошо продуманный и практичный язык. Как пример, узнав синтаксис, вы увидите, что многие идиомы из других языков переносятся на Go. Как только вы освоите часть Go, можно легко предсказать его возможности. Имея некоторый опыт других языков, я мог без проблем читать и понимать код Go без особой помощи гугла.
Я отметил намного меньше фрустрации и намного больше продуктивности, чем при использовании C/C++, Java, Python и т. д. Однако, Go все еще ощущается частью этого поколения языков. Он извлек из них уроки, и я думаю, что это, вероятно, лучший язык этого поколения; но он определенно часть этого поколения. Он скорее представляет инкрементное улучшение, нежели нечто принципиально новое (следует отметить, что это не оценочное суждение — инкрементность зачастую на пользу в мире разработки программного обеспечения). Хорошим примером этого является nil: такие языки как Rust и Swift избавились от null парадигмы, тем самым устранив целый класс ошибок. Go делает ее менее опасной: нет нулевых значений; разграничение nil и 0. Но основная идея все еще присутствует, как и распространенная рантайм ошибка разыменования нулевого указателя.
### Легкость освоения
Go невероятно прост в освоении. Я знаю, что это растиражированный рекламный лозунг, но я был очень удивлен, насколько быстро я смог достичь уровня продуктивности. Благодаря документации, инструментам и самому языку буквально за два дня я начал писать содержательный, пригодный для коммитов, код.
Несколько факторов, в пользу обучаемости:
* Go небольшой. Многие языки стараются быть небольшими, Go же на самом деле является таковым. (В основном это хорошо, и я впечатлен дисциплиной, которая для этого потребовалась).
* Стандартная библиотека хороша (и опять же тоже небольшая). Находить и использовать библиотеки в экосистеме очень легко.
* В языке очень мало того, чего нет в других языках. Go наследует много битов из других устоявшихся языков, полирует их и аккуратно соединяет. Он старательно избегает новизны.
### Рутинность кода
Код Go очень быстро становится повторяющимся. В нем отсутствует какой-либо механизм типа макросов или дженериков для сокращения повторений, (интерфейсы хороши для абстракций, но не так хорошо работают для уменьшения дублирования кода). У меня часто накапливается большое количество функций, идентичных за исключением типов.
Обработка ошибок также способствует повторению. Многие функции имеют больше шаблонов `if err != nil { return err }`, чем оригинального кода.
Использование дженериков или макросов для сокращения рутинности кода иногда критикуют за компромисс с его читаемостью. Но в случае с Go, я бы с ними не согласился. Копировать и вставлять код легко и быстро, но чтение Go кода может приводить к фрустрации, потому что вы должны игнорировать большую его часть или выискивать тонкие различия.
### То, что мне понравилось
* Время компиляции. Определенно быстро; определенно намного быстрее чем Rust. Но на самом деле не так быстро, как я ожидал (мне кажется, что оно на уровне C/C ++ или даже немного быстрее для средних и крупных проектов, а я ожидал чего-то практически мгновенного).
* Горутины и каналы. Облегченный синтаксис для запуска подпрограмм Go и использования каналов — это действительно хорошо. Такая небольшая деталь, делающая параллельное программирование намного приятнее, чем в других языках, действительно показывает силу синтаксиса.
* Интерфейсы. Они лишены изыска, но их легко понять и использовать, и они полезны во многих местах.
* `if ...; ... { }` синтаксис. Возможность ограничивать область видимости переменных телом if операторов — это хорошо. Это нечто сродни if let в Swift и Rust, но более общего назначения (Go не имеет паттерн матчинга как Swift и Rust, поэтому он не может использовать if let).
* Тест и док комментарии просты в использовании.
* Инструмент Go приятен — все сразу в одном месте без необходимости подключения множества инструментов через командную строку
* В наличии сборщик мусора (GC)! Отсутствие необходимости заботиться об управлении памятью действительно делает программирование проще
* Varargs.
### То, что мне не понравилось
Порядок значения не имеет.
* nil слайсы — nil, nil слайс и пустой слайс — все это разные вещи. Я более чем уверен, что вам нужны только двое из них, а не все три.
* Никаких первичных классов. Использование констант ощущается непривычно.
* Запрет на циклы импорта. Это действительно ограничивает полезность пакетов предназначенных для модуляризации проекта, поскольку это поощряет набивать большое количество файлов в один пакет (или множество небольших пакетов, что может быть так же плохо, если файлы, которые должны быть вместе, распределены в разные пакеты).
* `switch` может быть не исчерпывающим
* `for ... range` возвращает пару индекс/значение. Получить только индекс легко (просто проигнорируйте значение), но получение только значений требует явного указания. Для меня это шиворот-навыворот, так как в большинстве случаев мне нужно значение, а не индекс.
* Синтаксис:
+ Несоответствие между определениями и использованиями.
+ Избирательность компилятора (требующего или запрещающего, например, висящие запятые); в основном это облегчается хорошим набором инструментов, но существует несколько случаев, когда это создает раздражающий дополнительный шаг.
+ При использовании возвращаемых типов с несколькими значениями скобки требуются для типа, но не для return.
+ Для объявления структуры требуется два ключевых слова (type и struct).
+ Использование заглавных букв для обозначения переменных public или private. Это как венгерская нотация, только хуже.
* Неявные интерфейсы. Я знаю, что это так же в списке того, что мне нравится, но иногда это действительно раздражает, например, при необходимости найти все типы, которые реализуют интерфейс, или интерфейсы реализованные для данного типа.
* Вы не можете писать функции с получателем в другом пакете, поэтому, даже если интерфейсы типизированы неявно, они не могут быть реализованы для вышестоящих типов, что делает их гораздо менее полезными.
Я уже упоминал об отсутствии дженериков и макросов выше.
### Согласованность
Как разработчик языка и программист, меня, вероятно, больше всего удивило то, что в Go часто встречается несоответствие между тем, что встроено, и тем, что доступно пользователям. Задача многих языков — развеять как можно больше магии и сделать доступными встроенные функции для пользователей. Перегрузка операторов — простой, но противоречивый пример. В Go таится очень много магии! И вы очень легко врезаетесь в стену неспособности делать то, что могут встроенные вещи.
Некоторые моменты, которые особенно выделяются:
* Есть хороший синтаксис для возврата нескольких значений и для каналов, но их нельзя использовать вместе, потому что нет типов кортежей.
* Существует оператор `for ... range` для итерации по массивам и слайсам, но вы не можете перебирать другие коллекции, потому что концепция итераторов отсутствует.
* Такие функции, как `len` и `append`, являются глобальными, но невозможно сделать ваши собственные функции глобальными. Эти глобальные функции работают только со встроенными типами. Они также могут быть универсальными, даже если в Go нет дженериков!
* Нет перегрузки операторов. Это особенно раздражает при использовании `==`, потому что это означает, что вы не можете использовать пользовательские типы в качестве ключей для map, если они не *сопоставимы*. Это свойство является производным от структуры типа и не может быть переопределено программистом.
### Заключение
Go — простой, компактный и приятный язык. У него есть несколько острых углов, но главным образом он хорошо спроектирован. Он невероятно быстр в изучении и избегает любых функций, которые не известны на других языках.
По сравнению с Rust, Go — это совсем другой язык. Хотя оба они могут быть грубо описаны как системные языки или «замена» для C, они имеют разные цели и приложения, стили языкового дизайна и приоритеты. Сборка мусора — это действительно большая разница. Наличие GC в Go делает язык намного проще и меньше, и его легче понимать. Отсутствие GC в Rust делает его очень быстрым (особенно если вам нужна четкая задержка, а не просто высокая пропускная способность) и обеспечивает возможности и шаблоны программирования, которые невозможны в Go (по крайней мере, без ущерба для производительности).
Go — это компилируемый язык с хорошо реализованной средой выполнения. Он быстр. Rust также компилируемый, но имеет намного меньшую среду выполнения. Он очень быстр. Предполагая, что никаких других ограничений нет, я думаю, что выбор между использованием Go и Rust — это компромисс между гораздо более короткой кривой обучения и более простыми программами (что означает более быструю разработку) и, со стороны Rust, большой скоростью и более выразительной системой типов (что делает ваши программы более безопасными и ускоряет отладку и поиск ошибок).
---
На этом перевод подошел к концу, а мы приглашаем вас на [бесплатное практическое онлайн-занятие](https://otus.pw/tkAZ/), где вы узнаете, как за 60 минут создать полностью протестированный http-сервис с нуля без 3rd-party зависимостей.
--- | https://habr.com/ru/post/500278/ | null | ru | null |
# TDD по-фольксвагеновски
Компания Volkswagen [показала](http://geektimes.ru/post/263012/) всему миру, что такое настоящий Test Driven Development. Тесты прошли — можно спать спокойно.
Программное обеспечение, разрабатываемое в компании, довольно специфичное и предназначено для промышленных платформ (автомобильных компьютеров). Компания не раскрывает, какими инструментами пользуется при разработке; и тем более не выкладывает эти инструменты в открытый доступ, как это часто бывает среди ведущих IT компаний. Но сам инновационный подход Volkswagen к тестированию поразил всех. Этот передовой опыт несомненно заслуживает того, чтобы перенять его и внедрить также в мейнстриме нашей отрасли. И сообщество Github незамедлительно откликнулось на этот вызов. Итак, встречайте: **библиотеки для поддержки TDD в стиле Volkswagen**.
[](http://habrahabr.ru/post/269035/)
Актуальная информация о реализациях собрана [здесь](http://code.dblock.org/2015/10/09/passing-tests-with-volkswagen.html). На данный момент есть реализации для языков Ruby ([даже](https://github.com/jurre/rspec-volkswagen) [две](https://github.com/paulodiniz/minitest-volkswagen)), [JavaScript](https://github.com/auchenberg/volkswagen), [Java](https://github.com/aslakknutsen/arquillian-volkswagen), [D](https://github.com/repeatedly/d-volkswagen), [Go](https://github.com/zackexplosion/golang-volkswagen), [PHP](https://github.com/hmlb/phpunit-vw), [Objective-C](https://github.com/cezheng/Volkswagen-Xcode) и [Swift](https://github.com/neonichu/Winterkorn). Вот, к примеру, описание модуля [volkswagen](https://github.com/auchenberg/volkswagen) для JavaScript. (Другие реализации отличаются по синтаксису, но совершенно аналогичны по назначению.)
---
**Volkswagen** обнаруживает, что ваши тесты выполняются на сервере постоянной интеграции (CI) и обеспечивает их успешное прохождение.
**Для чего нужно?**
Если вы хотите, чтобы ваш софт был принят жителями США, хорошие результаты тестов с интеграционного сервера очень важны. Volkswagen использует так называемое «defeat device» для определения того, что проводится тестирование на интеграционном сервере, и понижает количество ошибок до приемлемого для прохождения тестов уровня. Это позволит вам тратить меньше времени на тестирование и больше наслаждаться жизнью как разработчику, которому доверяют.
В свой README файл вы можете вставить вот такой вечнозеленый бейдж для статуса сборки проекта: 
В синтакисие markdown:
`[](https://github.com/auchenberg/volkswagen)`
**Установка**
`npm install volkswagen`
**Использование**
Просто включите volkswagen в любом месте вашего кода, например в основном файле с тестами:
`require('volkswagen')`
**Статус проекта**
Обнаруживаемые серверы интеграции:
Travis CI, CircleCI, Jenkins CI, Hudson, Bamboo, TeamCity, Team Foundation Server, Visual Studio Online CI, GitLab CI, Codeship, Drone.io, Buildkite, TaskCluster. А также другие серверы, которые экспортируют переменную окружения CI или CONTINUOUS\_INTEGRATION.
Библиотеки для модульного тестования, тесты в которых обходятся: assert, tap, tape, chai а также любые другие тесты, которые устанавливают код возврата или выбрасывают ошибку.
**Лицензия**
MIT
---
Обратите внимание, что эффект снижения количества ошибок проявляется только при тестировании на интеграционном сервере. При запуске на машине разработчика тесты выполняются со всей строгостью. Ну и в production, ясное дело, не будет никаких отличий.
Добавить реализации для других языков и серверов интеграции приглашаются все желающие. Не забудьте добавить ссылку [сюда](https://github.com/dblock/code.dblock.org/blob/gh-pages/_posts/2015/2015-10-09-passing-tests-with-volkswagen.markdown). | https://habr.com/ru/post/269035/ | null | ru | null |
# Исследуем баг iOS с помощью Hopper
Привет! Меня зовут Александр Никишин, я занимаюсь разработкой iOS-приложений в компании Badoo. В статье я расскажу о том, как мы исследовали баг в UIKit, который Apple не хотела исправлять на протяжении полугода.
Всё началось в августе 2019 года с первых бета-версий iOS 13. Тогда мы впервые столкнулись с проблемой. В приложениях Badoo и Bumble мы постоянно работаем над улучшением интерфейсов и, например, стараемся максимально оптимизировать нудный и не любимый пользователями процесс регистрации. Системные предиктивные подсказки над клавиатурой — отличный способ сокращения количества кликов пользователя при вводе данных. Однако в новой версии iOS мы с удивлением обнаружили, что подсказки при вводе номера телефона пропали.
Когда вышла GM-версия, мы поняли, что проблема так и не была устранена. Нам казалось, что такой очевидный баг просто не могут пропустить регрессионные тесты, которые в арсенале Apple наверняка есть, и мы стали ждать исправления в первом большом пакете обновлений. На это [надеялись и другие разработчики](https://forums.developer.apple.com/message/374444#374444). Однако с выходом версии 13.1 ничего не изменилось, и нам ничего не оставалось, кроме как открыть радар, что мы и сделали в начале октября. Время шло, вышли iOS 13.2 и 13.3, а баг всё оставался неисправленным.
В феврале у нашей команды регистрации появилось немного свободного от работы над бэклогом времени, и я решил исследовать эту проблему поглубже.
Прежде чем начинать копать, нужно было выяснить, в какую сторону это делать. Поскольку подсказки продолжали работать на некоторых типах клавиатуры, первой же мыслью стало изучение иерархии её вьюшек в разных версиях iOS.
*iOS 12 vs iOS 13*
Тут же стало понятно, что Apple в iOS 13 провела рефакторинг имплементации клавиатуры и выделила подсказки в отдельный контроллер (`UIPredictionViewController`). Очевидно, тренд на модуляризацию и декомпозицию докатился и до неё (кстати, о нашем опыте их применения недавно [рассказывал Артём Лоенко](https://habr.com/ru/company/funcorp/blog/490382/)). Скорее всего, из-за этого и произошёл регресс функциональности. Круг поисков начал сужаться.
Я думаю, большинство iOS-разработчиков знает, что в открытом доступе легко найти интерфейсы приватных системных классов: для этого достаточно ввести всего один запрос в поисковике. При изучении [интерфейса класса](https://developer.limneos.net/index.php?ios=13.1.3&framework=UIKitCore.framework&header=UIPredictionViewController.h) `UIPredictionViewController` в глаза сразу бросается один из его методов:
Кажется, появилась зацепка, которую довольно легко проверить, используя старый добрый инструмент [подмены имплементации функций](https://nshipster.com/method-swizzling/) (Swizzling). Воспользуемся им, чтобы функция, находящаяся «под подозрением», всегда возвращала истинное значение:
```
+(void)swizzleIsVisibleForInputDelegate {
SEL targetSelector = sel_getUid("isVisibleForInputDelegate:inputViews:");
Class targetClass = NSClassFromString(@”UIPredictionViewController”);
if (targetClass == nil) {
return;
}
if (![targetClass instancesRespondToSelector:targetSelector]) {
return;
}
Method method = class_getInstanceMethod(targetClass, targetSelector);
if (method == NULL) {
return;
}
IMP originalImplementation = method_getImplementation(method);
IMP newImp = imp_implementationWithBlock(^BOOL(id me, id delegate, id views) {
// Вызываем оригинальную реализацию, чтобы избежать возможной неконсистентности состояний внутри приватных классов.
BOOL result = ((bool (*)(id,SEL,id,id))originalImplementation)(me, targetSelector, delegate, views);
if ([delegate isKindOfClass:[UITextField class]] && [delegate keyboardType] == UIKeyboardTypePhonePad) {
return YES;
}
return result;
});
method_setImplementation(method, newImp);
}
```
Перезапустив тестовый проект, я обнаружил, что телефонные подсказки вернулись в iOS 13 и работают «в штатном режиме». На этом можно было бы закончить расследование и, возможно, даже очень осторожно использовать это опасное и запрещённое гайдлайнами Apple решение в релизной сборке с возможностью удалённого включения/отключения для части пользователей (про опцию удалённого управления фичами можно посмотреть [запись доклада](https://habr.com/ru/company/badoo/blog/329292/) моей коллеги Катерины Трофименко). И всё же меня не переставало интересовать, по какой причине данная функция возвращает false при использовании телефонного типа клавиатуры.
Чтобы добраться до истины, нам нужен исходный код функции. Очевидно, что Apple не раздаёт код компонентов iOS направо и налево, так что нагуглить его не получится. Остаётся только один способ — реверсивный инжиниринг для декомпиляции бинарного кода. Ранее я неоднократно слышал о таком продукте, как [Hopper](https://www.hopperapp.com), и читал несколько статей о его применении с целью поковыряться «под капотом» у системных библиотек, но сам ни разу не использовал. И сразу же я был приятно удивлён: оказалось, что для того чтобы поиграться и изучить инструментарий, даже необязательно покупать полную версию. Демоверсия включает в себя бесконечные 30-минутных сессий работы без возможностей сохранения индекса и внесения изменений в бинарные файлы, а значит, является отличной площадкой для экспериментов.
Всё из того же [опубликованного](https://developer.limneos.net/index.php?ios=13.1.3&framework=UIKitCore.framework&header=UIPredictionViewController.h) приватного интерфейса можно узнать, что `UIPredictionViewController` является частью фреймворка UIKitCore. Остаётся только найти его и загрузить в Hopper. Бинарные файлы фреймворков находятся в глубинах Xcode. Вот, например, полный путь до нужного нам UIKitCore:
```
/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Library/Developer/CoreSimulator/Profiles/Runtimes/iOS.simruntime/Contents/Resources/RuntimeRoot/System/Library/PrivateFrameworks/UIKitCore.framework/UIKitCore
```
Делаем drag-and-drop файла в Hopper, подтверждаем действие в системном диалоге и ждём завершения индексации (в случае с таким большим фреймворком, как UIKit, это может занять от четырёх до шести минут).
Интерфейс программы довольно прост, я отмечу только ключевые элементы, которые потребовались для проведения моего исследования. В левой панели интерфейса можно найти поисковую строку, через которую происходит навигация по коду. Осуществив поиск по названию интересующего нас класса, быстро получаем исследуемую функцию, её ассемблерный код открывается в основном окне.
В верхней панели задач находятся кнопки переключения режимов отображения кода. Слева направо:
* ASM mode — ассемблерный код;
* CFG mode — ассемблерный код в виде блок-схемы (дерева), где куски кода объединены в блоки, а переходы показаны в виде ответвлений;
* Pseudo-code mode — cгенерированный псевдокод (подробнее о нём поговорим ниже);
* Hex mode — 16-ричная репрезентация бинарного файла, или абракадабра, плохо помогающая нам в нашем исследовании.
Теперь нужно выяснить, что же происходит внутри функции. Тело её довольно длинное, поэтому разобраться в логике, глядя на ассемблерный код, могут только настоящие ASM-гуру, коим я себя назвать не могу. Для этого поможет Pseudo-code mode, в котором Hopper максимально упрощает ассемблерные операции, подставляя там, где это возможно, реальные имена функций и используя имена регистров наподобие переменных. Выглядит это так:
Остаётся только пройтись по логике функции и понять, в какое из её ответвлений мы попадаем. В этом мне помогли [Symbolic Breakpoints](https://medium.com/rocket-fuel/ios-breakpoint-secret-sauce-for-better-debugging-c0009f116ca1), которые можно устанавливать и на системные вызовы, попутно печатая в консоль Xcode все необходимые переменные и результаты вызовов функций. Пользуясь таким нехитрым способом, я обнаружил, что выполнение функции прерывается ранним выходом из-за того, что в приведённом в качестве примера блоке кода не срабатывает одно из условий. Давайте разбираться, что тут происходит.
Немного контекста: в регистр rbx чуть выше по коду (который я опустил для простоты) помещается ссылка на объект, имплементирующий протокол `[UITextInputTraits\_Private](https://developer.limneos.net/index.php?ios=13.1.3&framework=UIKitCore.framework&header=UITextInputTraits_Private.h)` (это расширенная версия публичного протокола `[UITextInputTraits](https://developer.apple.com/documentation/uikit/uitextinputtraits)`).
Итак, первое из условий — это проверка того, что подсказки не скрыты конфигурацией поля ввода. В дебаге можно заметить, что оно выполняется: свойство `hidePrediction` возвращает false. Второе условие — проверка того, что клавиатура не находится в режиме “split” (на своём iPad [потяните за нижнюю правую кнопку вверх](https://support.apple.com/en-gb/guide/ipad/ipad997da62f/ipados), об этой штуке знают всего 2—3% пользователей). С этим тоже всё в порядке.
Идём дальше. На следующем этапе начинаются манипуляции с `keyboardType`, которые намекают нам на то, что истина где-то рядом. Сначала проверяется, что текущий `keyboardType` меньше или равен 0xb (или 11 в десятичном формате). Если открыть в Xcode декларацию `UIKeyboardType`, мы увидим, что существует 13 типов клавиатур, причём один из них (`UIKeyboardTypeAlphabet`) устарел и объявлен как ссылка на другой тип. То есть всего в enum 12 типов: если начать с 0, последний будет иметь значение, равное 11. Иными словами, в коде производится валидация значения в виде проверки на переполнение, и она, опять же, проходит успешно.
Далее мы видим очень странное условие `if (!COND)`, и я долго не мог понять, что же оно проверяет, учитывая, что нигде выше по коду переменная COND не объявлялась. Более того, мои [Symbolic Breakpoints](https://medium.com/rocket-fuel/ios-breakpoint-secret-sauce-for-better-debugging-c0009f116ca1) показывали, что именно невыполнение этого условия и приводит к раннему выходу из функции. И тут нам ничего не остаётся, кроме как вернуться к ASM mode и изучить данную часть кода в ассемблерном виде.
Чтобы найти данное условие в ASM-листинге, можно воспользоваться опцией “No code duplication”, которая покажет псевдокод не в виде исходного кода с условиями if-else, а в виде уникальных блоков кода и переходов в виде goto. В этом случае мы увидим позицию начала этих блоков в бинарном файле и используем этот указатель для поиска в ASM mode. Так я узнал, что интересующий нас блок находится по адресу fe79f4:
Вернувшись в ASM mode, мы легко найдём этот блок:
Мы подходим к самой сложной части, где будем разбирать три строчки ассемблерного кода.
Первую строчку я распознал по памяти (спасибо урокам ассемблера в родном МИЭТ, наконец-то настал в моей жизни тот момент, когда высшее образование пригодилось!). Тут всё довольно просто: в регистр ecx помещается константа 0x930 (100100110000 в бинарном формате).
Во второй строке мы видим инструкцию bt, производимую над регистрами `exc` и `eax`. Значение одного нам уже известно, значение второго можно увидеть на предыдущем скриншоте: `rax = [rbx keyboardType]` — в нём находится текущий тип клавиатуры. `rax` — это весь 64-битный регистр, `eax` — это его 32-битная часть.
С данными определились, осталось понять логику команды. Google нас приводит к [такому описанию](http://faydoc.tripod.com/cpu/bt.htm):
> Selects the bit in a bit string (specified with the first operand, called the bit base) at the bit-position designated by the bit offset operand (second operand) and stores the value of the bit in the CF flag.
Инструкция извлекает бит из первого операнда (константа 0x930) в позиции, заданной вторым операндом (тип клавиатуры), и помещает его в CF ([carry flag](https://ru.wikipedia.org/wiki/%D0%A4%D0%BB%D0%B0%D0%B3_%D0%BF%D0%B5%D1%80%D0%B5%D0%BD%D0%BE%D1%81%D0%B0)). То есть в результате в CF будет находиться 0 или 1 в зависимости от типа клавиатуры.
Переходим к последней операции `jb`, она имеет следующее [описание](http://faydoc.tripod.com/cpu/jb.htm):
`Jump short if below (CF=1)`
Нетрудно догадаться, что тут происходит переход выполнения функции (ранний выход), если в CF находится 1.
В этот момент пазл начинает складываться. Мы имеем битовую маску 100100110000 (в ней 12 битов — по числу доступных типов клавиатур), и именно она определяет условие раннего выхода. Теперь, если мы проверим наличие подсказок для всех типов клавиатуры в порядке возрастания `rawValue`, всё будет на месте.
В iOS 12 мы не найдём такой логики — подсказки там работают для любого типа клавиатуры. Подозреваю, что в iOS 13 Apple решила отключить подсказки для цифровых клавиатур, что в принципе понятно: я не могу придумать сценарий, когда системе нужно подсказывать числа. Видимо, по ошибке «под горячую руку» попал и `UIKeyboardTypePhonePad`, который очень похож на обычную цифровую клавиатуру. При этом `UIKeyboardTypeNamePhonePad`, комбинирующий для поиска телефонных контактов QWERTY-клавиатуру и точно такую же отключённую цифровую, продолжал показывать подсказки.
Работать с Hopper, к моему удивлению, оказалось очень приятно и занимательно, давно я не получал столько фана. Найденными изысканиями я поделился с инженерами Apple в своем баг-репорте, а его статус со временем изменился на “Potential fix identified — For a future OS update”. Надеюсь, фикс доедет до пользователей в будущих обновлениях. При этом Hopper можно использовать не только для поиска причин ваших или Apple багов, но и для обнаружения фиксов Apple для [программ сторонних разработчиков](https://twitter.com/steipete/status/1245371932314349570). | https://habr.com/ru/post/504084/ | null | ru | null |
# Строковые классы Java. Сравнение производительности
Никогда не задавались вопросом насколько собственно отличается производительность строковых классов Java?
В данном топике я попытался сравнить производительность java.lang классов String, StringBuilder и StringBuffer.
#### Очевидные факты
Не секрет, что в Java существуют три основных класса для работы со строками. Основной класс, который мы чаще всего используем в программах, это **String**. Особенностью данного класса является то, что он создает неизменяемые строки. Т.е. какой строкой символов мы объект при создании инициализировали, такой она и останется. Поэтому конструкция:
`String st = "Маша";
st += "Саша";`
Создаст новый объект содержащий строку «МашаСаша» а исходные объекты будут уничтожены сборщиком мусора.
Если операций конкатенации над одним и тем же строковым объектом производится много, это приводит к интенсивному процессу порождения новых объектов и добавляет работы сборщику мусора.
Если нам нужны изменяемые строки, разработчики нам предлагают другие классы. Первый, который был в Java изначально — **StringBuffer** и более новый StringBuilder (появился начиная с версии 1.5). Как пишут в документации, **StringBuffer** — безопасно применять в многопоточных приложениях, но второй более эффективен.
#### Чего хочется
Ну более эффективен, менее эффективен, этот конечно хорошо, но хочется цифр. Ведь иной программист может подумать, а стоит ли использовать «неудобные» StringBuffer/StringBuilder вместо такого замечательного String ради экономии пары милисекунд? Другие скажут, что не бывает таких ситуаций, когда нужно выполнить ну, скажем, сто тысяч конкатенаций… Но любопытно же, велика ли разница?
#### Тест
Читаем строки из текстового файла «onegin.txt» (призовем на помощь классика). Файл имеет размер 297463 байта, utf-8, 27195 слов. Сложим все слова файла в одну строку с использованием всех трех классов и сравним производительность. Чтоб было интереснее, проведем тест на разных JVM и в двух OS. Linux (я использую LinuxMint 9 это такой разукрашенный Ubuntu, если кто не знает) ну и Win XP Pro SP3. Обе операционки 32-битные, ибо пишу я с нетбука с Atom N280. Но мы же не рекорды ставим, нам важна тенденция.
Собственно сама программа, проще некуда:
> `package stringtest1;
>
>
>
> import java.io.BufferedReader;
>
> import java.io.FileNotFoundException;
>
> import java.io.FileReader;
>
> import java.io.IOException;
>
> import java.util.Scanner;
>
>
>
> public class Main {
>
>
>
> public static void main(String[] args) throws FileNotFoundException, IOException {
>
>
>
> BufferedReader reader = new BufferedReader(new FileReader("onegin.txt"));
>
>
>
> StringBuilder sb = new StringBuilder();
>
> String line = null;
>
> while ( (line = reader.readLine()) != null) {
>
> sb.append(line).append("\n");
>
> }
>
> reader.close();
>
> String[] words = sb.toString().split("\\s+");
>
> System.out.println("Total words:" + words.length);
>
> waitEnter();
>
>
>
> long ts = System.nanoTime();
>
>
>
> String buff = "";
>
> //2 StringBuffer buff = new StringBuffer();
>
> //3 StringBuilder buff = new StringBuilder();
>
>
>
> for (String word : words) {
>
> buff += word + " ";
>
> //2&3 buff.append(word).append(" ");
>
> }
>
>
>
> long te =System.nanoTime();
>
>
>
> System.out.println("Complete, lenght:" + buff.length() + " elapsed time:" + (te - ts)/1e6 + "ms");
>
>
>
> }
>
>
>
> private static void waitEnter() {
>
> Scanner scan = new Scanner(System.in);
>
> System.out.print("Press Enter key.");
>
> scan.nextLine();
>
> }
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Варианты для StringBuffer и StringBuilder аналогичны, и отображены в комментариях.
Замеры времени работы каждого варианта для каждой виртуальной машины производились 5 раз и вычислялось среднее значение.
#### Результаты
##### Linux
| Класс | Open JDK 1.6.0\_18 | HotSpot 1.6.0\_20 | JRockit 4.0.1 |
| --- | --- | --- | --- |
| String | 27390ms | 26850ms | 26940ms |
| StringBuffer | 35.55ms | 34.87ms | 15.41ms |
| StringBuilder | 33.01ms | 31.78ms | 12.82ms |
##### Windows XP
| Класс | HotSpot 1.6.0\_20 | JRockit 4.0.1 |
| --- | --- | --- |
| String | 55260ms | 45330ms |
| StringBuffer | 19.38ms | 14.50ms |
| StringBuilder | 16.83ms | 12.76ms |
#### Выводы
Если нам нужны модифицируемые строки, используем StringBuffer (в многопоточных приложениях) и StringBuilder в остальных. Разница весьма ощутима.
Понятно почему JVM от Open JDK немножко отстает, что-то там Sun или уже Oracle подкрутил. Не совсем понятно, почему такая большая разница в работе с объектами класса String под Linux и WinXP. Толи Win не дает JVM работать так же эффективно как Linux, то ли это особенности реализации JVM… Тут нужно копать дальше.
Для справки:
JRockit — это виртуальная машина от Oracle.
HotSpot — это машина изначально разработанная Sun, теперь само собой куплена Oracle.
Open JDK — Open-source JDK основаная на исходниках в свое время открытых Sun-ом. | https://habr.com/ru/post/102468/ | null | ru | null |
# Запускаем стенд испытаний коробок передач
После просмотра «Форд против Феррари» мы с женой вышли из кинотеатра под первый снег ноябрьским вечером. Глаза у меня горели, руки чесались. И пронеслась мысль: «Вот это да! Вот бы что-то такое поизобретать. Всякое инженерное, чтоб рёв мотора, гарь бензина и масло во все стороны!».
И, вы не поверите, на следующий же день натыкаюсь на объявление в газете: нужен человек для программирования стенда испытаний коробок передач.
Недолго думая, без демонстрации разукрашенных резюме, я позвонил. Буквально «на коленке» прикинув желания и возможности, мы сразу же договорились о встрече в ангаре-лаборатории.
Меня подвёз владелец фирмы по ремонту больших автокранов и всякой сверхтяжёлой техники. Сам стенд испытаний был уже почти готов:
Работа стенда должна была заключаться в пошаговой отладке коробки переключения передач (далее КПП), чтобы выявлять протечки масла, всякие баги и другие неприятности. Сердцем стенда был ПЛК, с помощью него нужно симулировать работу блока автоматического переключения передач. И ещё асинхронный двигатель с частотным преобразователем - это вместо двигателя внутреннего сгорания.
Ну, что ж, задача ясна (подумал я тогда).
Домой меня подвёз один из сотрудников. На вопрос, где применяются такие краны, он ответил:
– Представь себе промышленный ветрогенератор, как, например, в ростовской области, в Европе... Да у него одна лопасть весит двенадцать тонн, а сам генератор – больше пятидесяти! Манипулятору с таким не справиться.
Ну, и, кроме того, чтобы отремонтировать такой кран, нужен... другой такой же кран, ho-ho-ho!
Вечером вместо совместного с женой просмотра сериалов Интернет открыл для ̶н̶а̶с̶ меня дивный мир коробок передач.
### Коробка передач - что ты такое?
Коробки, о которых пойдёт речь, произведены компанией [ZF](https://en.wikipedia.org/wiki/ZF_Friedrichshafen) (в оригинале «Zahnradfabrik Friedrichshafen», но сокращено до аббревиатуры ZF в связи с тем, что (как оказалось) для иностранцев название было совершенно непроизносимым). Это немецкий производитель запчастей для автомобилей, тракторов, поездов и даже самолетов. Кстати, праотцом-основателем ZF считается [Фердинанд Адольф Август Цеппелин](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BF%D0%BF%D0%B5%D0%BB%D0%B8%D0%BD,_%D0%A4%D0%B5%D1%80%D0%B4%D0%B8%D0%BD%D0%B0%D0%BD%D0%B4_%D1%84%D0%BE%D0%BD). Да-да, тот самый Цеппелин, создавший в своё время целую отрасль дирижаблестроения.
Первые КПП применяли как раз для дирижаблей, а позже они начали появляться во всевозможных транспортных средствах, в том числе и в автокранах.
На этом историческая ремарка заканчивается, и перейдём к делу. Будем рассматривать КПП ZF 4WG210 на стыке программирования и жестокой реальности.
Ожидание:
```
int gearBox(int engine_speed, int gear)
{
/* Скорость на выходе КПП равна
* произведению скорости двигателя на передачу
*/
return engine_speed * gear;
}
```
Реальность:
Да, если взглянуть на функцию КПП совсем просто (или даже грубо), то скорость на выходе будет равна скорости двигателя умноженную на выбранную передачу. То есть на нейтральной умножаем на ноль - получаем на выходе ноль, на первой скорость на входе равна скорости на выходе, а на второй поедем в два раза быстрее.
Глянем в мануал: ZF 4WG210 имеет 4 передние передачи и 3 задние. Три задних... Неплохо, да? Читаем дальше: у каждой передачи есть своё передаточное число:
Значит скорость двигателя умножаем не на порядковый номер передачи, а на эту переменную:
```
typedef enum
{
gear_N, /* neutral */
gear_F1, /* forward */
gear_F2,
gear_F3,
gear_F4,
gear_R1, /* reverse */
gear_R2,
gear_R3,
GEAR_ITEMS
} gear_type;
const float speed_ratio[] = [ 0.000, /* N */
0.275, /* F1 */
0.479, /* F2 */
0.933, /* F3 */
1.572, /* F4 */
-0.290, /* R1 */
-0.505, /* R2 */
-0.983]; /* R3 */
float gearBox(float engine_speed, gear_type gear)
{
/* Скорость на выходе КПП равна произведению
* скорости двигателя на коэффициент передачи
*/
return engine_speed * speed_ratio[ gear ];
}
```
Но откуда берутся эти передаточные коэффициенты? От переключения между сцепляющими шестернями с разным радиусом:
На нашей КПП шесть сцеплений (cluthes), для каждой передачи два из них должны быть включены одновременно (engaged cluthes):
Бывают коробки с различным количеством передач и комбинаций включения.
Из этой и предыдущей таблиц можно получить передаточное число для каждого сцепления:
Добавляем массив с коэффициентами и комбинациями включения сцеплений:
```
/* K1 K2 K3 K4 KV KR */
const float clutch_ratio[] = [ 0.329, 0.574, 1.118, 1.406, 0.835, -0.880 ];
const int engaged_clutches[][] = {
/* K1 K2 K3 K4 KV KR */
[ 0, 0, 0, 0, 0, 0 ], /* N */
[ 1, 0, 0, 0, 1, 0 ], /* F1 */
[ 0, 1, 0, 0, 1, 0 ], /* F2 */
[ 0, 0, 1, 0, 1, 0 ], /* F3 */
[ 0, 0, 1, 1, 0, 0 ], /* F4 */
[ 1, 0, 0, 0, 0, 1 ], /* R1 */
[ 0, 1, 0, 0, 0, 1 ], /* R2 */
[ 0, 0, 1, 0, 0, 1 ], /* R3 */
};
```
Теперь дополним алгоритм КПП:
```
float gearBox(float engine_speed, gear_type gear)
{
float output_speed = 0;
/* Перебираем все сцепления на включенной передаче */
for (int clutch = 0; clutch < CLUTCH_ITEMS; clutch++) {
/* Если сцепление задействовано */
if (engaged_clutches[ gear ][ clutch ]) {
/* Умножаем текущую скорость на коэффициент этого сцепления */
output_speed = ( engine_speed *= clutch_ratio[ clutch ] );
}
}
return output_speed;
}
```
Также некоторые КПП имеют [гидротрансформатор](https://ru.wikipedia.org/wiki/%D0%93%D0%B8%D0%B4%D1%80%D0%BE%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%BE%D1%80) (`torque_converter`) и возможность его блокировки. Гидротрансформатор - это что-то типа сцепления между валом двигателя (`engine_speed`) и внутренним валом коробки (`inner_shaft_speed`). Но сцепление это не жёсткое: один вал крутит другой за счёт потока масла между турбинами.
Поэтому такое сцепление предотвращает резкие нагрузки на двигатель, добавляет инерции. Но если всё таки нужно жесткое зацепление валов друг за друга, то как раз можно и применить блокировку. Это позволяет увеличить КПД при передаче крутящего момента.
Не будем подробно выводить формулу гидротрансформатора, просто добавим этот параметр в общих чертах:
```
float gearBox(float engine_speed, gear_type gear, bool converter_block)
{
float output_speed = 0, inner_shaft_speed = 0;
/* Если включена блокировка гидротрансформатора */
if (converter_block)
inner_shaft_speed = engine_speed; /* Жёсткое зацерление */
else
inner_shaft_speed = torque_converter( engine_speed );
/* Перебираем все сцепления на включенной передаче */
for (int clutch = 0; clutch < CLUTCH_ITEMS; clutch++) {
/* Если сцепление задействовано */
if (engaged_clutches[ gear ][ clutch ]) {
/* Умножаем текущую скорость вала на коэффициент этого сцепления */
output_speed = ( inner_shaft_speed *= clutch_ratio[ clutch ] );
}
}
return output_speed;
}
```
В качестве эмуляции двигателя внутреннего сгорания подключили асинхронный двигатель, управляемый частотным преобразователем.
```
/* Задаём скорость двигателя */
engine_speed = frequency_converter( target_speed );
/* Управляем скоростью через КПП */
output_speed = gearBox( engine_speed, gear, converter_block );
```
Ну, вот, разобрались. Здесь мы рассмотрели так сказать математическую модель стенда испытаний. Теперь подключим коробку и двигатель к ПЛК.
### Подключаемся
Программа была написана в хорошо известном для АСУТП-шников CodeSys на языке [ST](https://ru.wikipedia.org/wiki/Structured_Text) (очень похож на Pascal). Хотел привести примеры кода, но в итоге всё так разрослось, что проще словами.
Каждому сцеплению K1..KR соответствует свой электроклапан Y1..Y6 (он же соленоид, он же «шифтовик»).
Переключение передач производится гидравлически. Когда двигатель разгоняет вал внутри коробки, он нагнетает давление масла. Если открыть один из клапанов, то это давление сдвинет сцепление, чтобы задействовать его в общей передаточной схеме. А если клапан закрыть, то масло пойдёт по другому пути и сдвинет сцепление обратно.
Чтобы открыть клапан нужно подать 10 Вольт, чтобы закрыть - 0 Вольт. Здесь клапаны типа ШИМ, поэтому можно применять плавное открытие.
*Но есть нюанс. В действительности напряжение с ПЛК сначала попадает на специальный конвертер, а он в свою очередь управляет клапанами по какой-то своей схеме с обратной связью.*
Каждому клапану соответствует свой датчик давления. Норма - 16Bar при включенном клапане. Датчики мониторятся по току 4..20мА.
У частотного преобразователя есть внешний вход 0..10В для управления скоростью, а текущая скорость считывается так же по току 4..20мА.
На коробке блок клапанов и датчиков давления выглядит так:
В реальном кране используется такой пульт переключения передач:
Здесь:
**↑** - движение вперёд
**↓** - движение назад
**N** - нейтраль
**+** - переключение на одну передачу вверх
**—** - переключение на одну передачу вниз
**KD** - kickdown control - принудительное переключение на пониженную передачу.
Нарисуем нечто подобное на панели управления и добавим управление двигателем:
На старте двигатель выключен, коробка на нейтральной передаче, гидротрансформатор разблокирован, тихо играет радио. Пришло время лабораторного халата и защитных очков. Морти, врубай!
1. Сначала запускаем двигатель. Необходимо набрать оборотов 600-700.
2. Ждём пока масло разогреется. Хотя бы градусов 40 пойдёт. При этом нагнетается давление для управления клапанами.
3. Теперь можно нажать на кнопку переключения передачи. Включаем!
4. Плавно открывается нужная пара клапанов. Для первой передачи это Y3 и Y5**.** Проверяем, что клапаны включились: давление на них должно быть около 16Bar.
5. При переключении на следующую передачу сначала происходит переключение на нейтраль: плавно закрываются все открытые клапаны. Проверяем давление - всё должно быть по нулям.
6. Включаем следующую пару клапанов.
На панели управления сей процесс выглядел так:
Дизайнер за́пил, не судите строго.При переключении с переднего хода на задний и обратно надо сначала убедиться, что ось центральной передачи полностью остановилась. Вспоминается, как «Разрушители мифов» пробовали включить заднюю передачу на полном ходу на автоматической КПП. Аварии не произошло, ведь на то он и автомат.
### Самое интересное
Пока писал статью 4WG210 уже починили и увезли. Но приехала ZF 6WG310. Этот монстр ещё мощнее, и уже с шестью передними передачами.
Ну, что ж, коллеги, а вот и [видео испытаний](https://youtu.be/wZDqYZrQNG8). Звук!
P.S. Старые зубры АСУТП подумают: «Пфф, нашёл о чём писать... Я таких проектов по два в день делаю». Не спорю: получилось минимум кода, но и максимум удовольствия! Ведь даже в таком простом проекте присутствовала та самая магия превращения виртуального в реальное.
Используемые материалы: [e-cran.ru](https://e-cran.ru/) | https://habr.com/ru/post/652435/ | null | ru | null |
# Оптимизация HTML5 игр для Android
Сегодня речь пойдет снова об элементе CANVAS, а так же немного об оптимизации самих игр в HTML5.
#### HTML часть
В современных браузерах для отрисовки в canvas используются мощи видеокарты, но, не всегда по умолчанию они включены. Можно залезть в настройки браузера и проверить. Для того, чтобы элемент вызывал такую обработку, можно в HTML добавить элементы 3D трансформации объекта. Отличным способом ускорения может (но не факт) послужить такая вот модификация канваса:
```
canvas.style.WebkitTransform= 'translate3d(0,0,0)';
... много подобных параметров
canvas.style.transform= 'translate3d(0,0,0)';
```
Я рассматриваю все с точки зрения разработки с использованием какого-нибудь фреймворка, вы же можете работать с чем-то другим, но, обратите внимание на эти нехитрые параметры, если ваш движок их не задает, то вы можете присвоить их элементу canvas через CSS, как классом, так и инлайн методом, ну или через JS.
Оптимизируйте ваш JS код. Избегайте частого обращения к DOM вашего приложения. Опять же, используя движок, обращений к DOM не должно быть вообще.
Не используйте *setInterval* / *setTimeout* / *while (1)* {}.
Для анимации в HTML5 был введен requestAnimationFrame, введен был специально для анимации, поэтому он для этого и оптимизирован. Обратите внимание, как ваш движок использует обновление кадров, учитывает ли он fps, и как обрабатывает deltaTime.
deltaTime — это временной фактор, который является переменной величиной времени, прошедшего с последнего кадра. Опять же, так как стандартный WebView в Android не слишком быстр (в отличии от WebView+ от Chromium), то ограничивать FPS в игре лучше в пределах 25 — 40 кадров в секунду принудительно. Игра будет работать стабильно, и для мобильной игры вполне нормально.
#### Android часть
Так же, в прошлой статье (которая была удалена из-за рекламы, а именно — ссылки на тестовое приложение) я уделял внимание созданию обертки для вашей игры в Android Studio, и, не отходя от этого подхода, рассмотрим вариант создания именно такого приложения.
Тут с оптимизацией все немного проще, в алгоритмы лезть не нужно, да и работа сводится к тому, что просто добавляем некоторые параметры для Android-приложения.
В манифест игры нужно добавить следующий флаг:
```
android:hardwareAccelerated="true"
```
Это подключит видеокарту (если есть) для обработки всего происходящего на экране, но, прежде чем включить ее в релиз, сперва хорошо протестируйте, для некоторых приложений может сделать только хуже, если железо не подходящее.
Следующее, что можно сделать — это отключить акселерацию в самом элементе WebView:
```
webview.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
```
Чтобы работало корректно, нужно в список импортов добавить View.
Такие вот несложные средства оптимизации я накопал. На этом пока все.
**Мнение автора на счет всей этой идеи**Вообще, HTML5 для Android очень сырой, во всех смыслах, и если в браузерах его использование еще оправдано, то вот в мобильниках — нет. Для этого лучше всего использовать стандартные средства Android. Там так же есть CANVAS, Bitmap, Paint и куча методов для рисования, построить на их основе несложный класс и пользоваться им для рисования — очень просто, и (что важно) очень производительно. Кроме того, через WebView есть проблема работы со звуком. Ее там просто нет. То есть она есть, если вы откроете игру, как обычную страницу, к примеру, в браузере на каком-нибудь сайте, но через WebView ее нет.
Тема использования HTML5 в Android больше актуальна для простых приложений, в которых есть красивый интерфейс, который средствами Android не так-то и просто реализовать по сравнению с HTML/CSS, однако для игр его использовать еще рано, но, вполне реально.
Я уверен, что в будущем ситуация пересилит в сторону нормальной работы WebView, или предложит его альтернативу.
PS: ссылки на примеры приводить больше не буду, если они кому-то потребуются — пишите в ЛС. Так же есть большая база примеров использования движков в JS. | https://habr.com/ru/post/278333/ | null | ru | null |
# Принципы построения систем потоковой аналитики
Проектирование систем потоковой аналитики и потоковой обработки данных имеет свои нюансы, свои проблемы и свой технологический стек. Об этом мы поговорили в очередном [открытом уроке](https://www.youtube.com/watch?v=NFjL8YQKuVg), прошедшим накануне запуска курса «[Data Engineer](https://otus.pw/IxY2/)».
На вебинаре обсудили:
* когда нужна потоковая обработка;
* какие элементы есть в СПОД, какие инструменты мы можем использовать для реализации этих элементов;
* как построить свою систему анализа кликстримов.
Преподаватель — [Егор Матешук](https://otus.ru/teacher/370/), Senior Data Engineer в MaximaTelecom.
### Когда нужна потоковая обработка? Stream vs Batch
Прежде всего, следует разобраться, когда нам нужна потоковая, а когда пакетная обработка. Давайте поясним сильные и слабые стороны этих подходов.
**Итак, минусы пакетной обработки (batch):**
* данные доставляются с задержкой. Поскольку у нас есть некий период вычислений, то на этот период мы всегда отстаём от реального времени. И чем больше итерации, тем сильнее мы отстаём. Таким образом, мы получаем задержку по времени, что в некоторых случаях критично;
* создаётся пиковая нагрузка на железо. Если мы очень много вычисляем в пакетном режиме, у нас по окончании периода (дня, недели, месяца) наблюдается пик нагрузки, ведь посчитать нужно много всего. К чему это приводит? Во-первых, начинаем упираться в лимиты, которые, как известно, не бесконечны. В результате система периодически работает на пределе возможностей, что нередко заканчивается сбоями. Во-вторых, так как все эти job’ы начинаются одновременно, они конкурируют и рассчитываются довольно медленно, то есть на быстрый результат рассчитывать не приходится.
**Но у пакетной обработки есть и плюсы:**
* высокая эффективность. Углубляться не будем, так как эффективность связана и с компрессией, и с фреймворками, и с применением колоночных форматов и т. п. Факт заключается в том, что пакетная обработка, если брать количество обработанных записей на единицу времени, будет эффективнее;
* простота разработки и поддержки. Вы можете обрабатывать какую-нибудь часть данных, тестируя и пересчитывая по мере необходимости.
**Плюсы потоковой обработки данных (streaming):**
* результат в режиме реального времени. Мы не ждём конца каких-либо периодов: как только к нам приходят данные (пусть даже совсем небольшой объём), мы можем сразу их отпроцессить и передать дальше. То есть результат по определению стремится к реал-тайму;
* равномерная нагрузка на железо. Понятное дело, что есть суточные циклы и т. д., однако нагрузка всё равно распределяется на весь день и получается более равномерной и предсказуемой.
**Главный минус потоковой обработки:**
* сложность разработки и поддержки. Во-первых, тестироваться, управлять и получать данные несколько тяжелее, если сравнивать с batch. Вторая сложность (на самом деле, это самая основная проблема) связана с откатами. Если job’ы не отработали, и произошёл сбой, то очень трудно уловить именно тот момент, где всё сломалось. И решение проблемы потребует от вас больше усилий и ресурсов по сравнению с пакетной обработкой.
Итак, если вы думаете о том, **нужны ли вам стримы**, ответьте для себя на следующие вопросы:
1. Действительно ли нужен real-time?
2. Много ли потоковых источников?
3. Критична ли потеря одной записи?
Рассмотрим **два примера**:
*Пример 1. Аналитика запасов для ритейла:*
* выкладка товара не меняется в реал-тайме;
* данные чаще всего доставляются в пакетном режиме;
* потери информации критичны.
В этом примере целесообразнее использовать batch.
*Пример 2. Аналитика для веб-портала:*
* скорость аналитики определяет время реакции на проблему;
* данные поступают в реальном времени;
* потери небольшого количества информации о пользовательской активности допустимы.
Представьте, что аналитика отражает, как посетители веб-портала себя чувствуют, используя ваш продукт. Например, вы выкатили новый релиз и вам нужно понять в течение 10-30 минут, всё ли в порядке, не сломались ли какие-нибудь пользовательские фичи. Допустим, пропал текст с кнопки «Заказать» — аналитика позволит быстро среагировать на резкое падение числа заказов, и вы сразу поймёте, что нужно откатываться.
Таким образом, во втором примере лучше использовать стримы.
### Элементы СПОД
Инженеры обработки данных захватывают, перемещают, доставляют, преобразовывают и хранят эти самые данные (да-да, хранить данные — это тоже активный процесс!).
Следовательно, чтобы построить систему потоковой обработки данных (СПОД), нам будут нужны следующие элементы:
1. **загрузчик данных** (средство доставки данных до хранилища);
2. **шина обмена данными** (нужна не всегда, но в стримах без неё никак, т. к. вам потребуется система, через которую вы будете обмениваться данными в реал-тайме);
3. **хранилище данных** (как же без него);
4. **ETL-движок** (необходим, чтобы делать различные фильтрации, сортировки и прочие операции);
5. **BI** (чтобы выводить результаты);
6. **оркестратор** (связывает весь процесс воедино, организовывая многоэтапную обработку данных).
В нашем случае мы рассмотрим простейшую ситуацию и сфокусируемся только на первых трёх элементах.
### Инструменты для обработки потоков данных
На роль **загрузчика данных** у нас есть несколько «кандидатов»:
* Apache Flume
* Apache NiFi
* StreamSets
#### Apache Flume
Первый, о ком поговорим — это **Apache Flume** — инструмент для транспортировки данных между различными источниками и хранилищами.
Плюсы:
* есть практически везде
* давно используется
* достаточно гибкий и расширяемый
Минусы:
* неудобная конфигурация
* сложно мониторить
Что касается его конфигурации, то она выглядит примерно так:
Выше мы создаём один простейший канал, который “сидит” на порту, берёт оттуда данные и просто их логирует. В принципе, для описания одного процесса это ещё нормально, но когда у вас таких процессов десятки, конфигурационный файл превращается в ад. Кто-то добавляет некие визуальные конфигураторы, но зачем мучиться, если есть инструменты, которые делают это из коробки? Например, те же NiFi и StreamSets.
#### Apache NiFi
По сути, выполняет ту же роль, что и Flume, но уже с визуальным интерфейсом, что большой плюс, особенно когда процессов много.
Пару фактов о NiFi
* изначально разработан в АНБ;
* сейчас поддерживается и развивается Hortonworks;
* входит в состав HDF от Hortonworks;
* имеет особую версию MiNiFi для сбора данных с устройств.
Система выглядит примерно следующим образом:
У нас есть поле для творчества и этапы обработки данных, которые мы туда накидываем. Есть много коннекторов на все возможные системы и т. д.
#### StreamSets
Это тоже система управления потоком данных с визуальным интерфейсом. Она разработана выходцами из Cloudera, легко устанавливается в виде Parcel на CDH, имеет особую версию SDC Edge для сбора данных с устройств.
Состоит из двух компонент:
* SDC — система, выполняющая непосредственно обработку данных (free);
* StreamSets Control Hub — центр управления несколькими SDC с дополнительными возможностями по разработке пайплайнов (paid).
Выглядит примерно так:
Неприятный момент — у StreamSets есть как бесплатная, так и платная части.
#### Шина обмена данными
Теперь давайте разберёмся, куда мы эти данные будем заливать. Претенденты:
* Apache Kafka
* RabbitMQ
* NATS
Apache Kafka — наилучший вариант, но если у вас в компании есть RabbitMQ или NATS, а вам нужно добавить чуть-чуть аналитики, то разворачивать Kafka с нуля будет не очень выгодно.
Во всех остальных случаях, Kafka — отличный выбор. По сути, это брокер сообщений с горизонтальным масштабированием и огромной пропускной способностью. Он отлично интегрирован во всю экосистему инструментов для работы с данными и выдерживает большие нагрузки. Обладает универсальнейшим интерфейсом и является кровеносной системой нашей обработки данных.
Внутри Kafka делится на Topic — некий отдельный поток данных из сообщений с одинаковой схемой или, хотя бы, с одинаковым назначением.
Чтобы обсудить следующий нюанс, нужно вспомнить, что источники данных могут немного различаться. Очень важен формат данных:
Отдельного упоминания заслуживает формат сериализации данных Apache Avro. Система использует JSON для определения структуры данных (схемы), которые сериализуются в **компактный бинарный формат**. Следовательно, мы экономим огромное количество данных, а сериализация/десериализация происходит дешевле.
Вроде бы всё неплохо, но наличие отдельных файлов со схемами порождает проблему, так как нам нужно между разными системами обмениваться файлами. Казалось бы, это просто, но когда вы работаете в разных отделах, ребята на другом конце могут что-нибудь поменять и успокоиться, а у вас всё поломается.
Чтобы не передавать все эти файлы на флешках, дискетах и наскальных рисунках, существует специальный сервис — Schema registry. Это сервис для синхронизации avro-схем между сервисами, которые пишут и читают из Kafka.
В терминах Kafka продюсер — это тот, кто пишет, консьюмер — тот, кто потребляет (читает) данные.
#### Хранилище данных
Претенденты (на самом деле вариантов много больше, но возьмем лишь несколько):
* HDFS + Hive
* Kudu + Impala
* ClickHouse
Прежде чем выбрать хранилище, вспомним, что такое **идемпотентность**. Википедия говорит, что идемпоте́нтность (лат. idem — тот же самый + potens — способный) — свойство объекта или операции при повторном применении операции к объекту давать тот же результат, что и при первом. В нашем случае процесс потоковой обработки должен быть построен так, чтобы при повторной заливке исходных данных результат оставался корректным.
**Как этого добиться** в стриминговых системах:
* выявить уникальный id (можно составной)
* использовать этот id для дедупликации данных
Хранилище HDFS + Hive **не даёт идемпотентности** для потоковой записи “из коробки”, поэтому у нас остаются:
* Kudu + Impala
* ClickHouse
**Kudu** — хранилище, подходящее для аналитических запросов, но с Primary Key — для дедупликации. **Impala** — SQL-интерфейс к этому хранилищу (и нескольким другим).
Что касается ClickHouse, то это аналитическая база данных от Yandex. Её главное назначение — аналитика на таблице, наполняемой большим потоком сырых данных. Из плюсов — есть движок ReplacingMergeTree для дедупликации по ключу (дедупликация предназначена для экономии места и может оставлять дубликаты в некоторых случаях, нужно учитывать [нюансы](https://clickhouse.yandex/docs/ru/operations/table_engines/replacingmergetree/)).
Остаётся добавить несколько слов про **Divolte**. Если помните, мы говорили о том, что некоторые данные нужно захватывать. Если вам нужно быстро и на коленке организовать аналитику для какого-нибудь портала, то Divolte — отличный сервис для захвата пользовательских событий на веб-странице через JavaScript.
### Практический пример
Что попытаемся сделать? [Попробуем построить пайплайн](https://youtu.be/NFjL8YQKuVg?t=4016), чтобы в реальном времени собирать Clickstream-данные. **Clickstream** — виртуальный след, который пользователь оставляет во время нахождения на вашем сайте. Будем захватывать данные с помощью Divolte, а писать их в Kafka.
Для работы нужен Docker, плюс потребуется клонировать [следующий репозиторий](https://github.com/Gorini4/divolte-streamsets-clickhouse-example). Всё происходящее будет запущено в контейнерах. Чтобы согласованно запустить сразу несколько контейнеров будет использоваться [docker-compose.yml](https://github.com/Gorini4/divolte-streamsets-clickhouse-example/blob/master/docker-compose.yml). Кроме того, есть [Dockerfile](https://github.com/Gorini4/divolte-streamsets-clickhouse-example/blob/master/Dockerfile), собирающий наш StreamSets с определёнными зависимостями.
Также есть три папки:
1. в [clickhouse-data](https://github.com/Gorini4/divolte-streamsets-clickhouse-example/tree/master/clickhouse-data) будут писаться данные clickhouse
2. ровно такая же папочка ([sdc-data](https://github.com/Gorini4/divolte-streamsets-clickhouse-example/tree/master/sdc-data)) у нас будет для StreamSets, где система сможет хранить конфигурации
3. третья папка ([examples](https://github.com/Gorini4/divolte-streamsets-clickhouse-example/tree/master/examples)) включает в себя файл с запросами и файл с конфигурацией пайплайна для StreamSets
Для запуска вводим следующую команду:
```
docker-compose up
```
И наслаждаемся тем, как медленно, но верно запускаются контейнеры. После запуска мы можем перейти по адресу [http://localhost:18630/](http://localhost:8290/) и сразу же потрогать Divolte:
Итак, у нас есть Divolte, который уже получил какие-то события и записал их в Kafka. Попробуем их высчитать с помощью StreamSets: <http://localhost:18630/> (пароль/логин — admin/admin).
Чтобы не мучиться, лучше [импортировать](https://youtu.be/NFjL8YQKuVg?t=4425) **Pipeline**, назвав его, к примеру, **clickstream\_pipeline**. А из папки examples импортируем **clickstream.json**. Если всё ок, [увидим следующую картину](https://youtu.be/NFjL8YQKuVg?t=4701):
Итак, мы создали connection к Кафке, прописали, какая Кафка нам нужна, прописали, какой топик нас интересует, потом выбрали те поля, которые нас интересуют, потом поставили слив в Кафку, прописав, в какую Кафку и какой топик. Отличия в том, что в одном случае, Data format — это Avro, а во втором — просто JSON.
Идём дальше. Мы можем, например, [сделать превью](https://youtu.be/NFjL8YQKuVg?t=4768), которое захватит в реальном времени из Кафки определённые записи. Далее всё записываем.
Выполнив запуск, увидим, что у нас в Кафку летит поток событий, причём это происходит в реал-тайме:
Теперь можно сделать для этих данных хранилище в ClickHouse. Чтобы работать с ClickHouse, можно использовать простой нативный клиент, выполнив следующую команду:
```
docker run -it --rm --network divolte-ss-ch_default yandex/clickhouse-client --host clickhouse
```
Обратите внимание — в этой строке указана сеть, к которой нужно подключаться. И в зависимости от того, как у вас называется папка с репозиторием, название сети у вас может отличаться. В общем случае команда будет следующей:
```
docker run -it --rm --network {your_network_name} yandex/clickhouse-client --host clickhouse
```
Список сетей можно посмотреть командой:
```
docker network ls
```
Что же, осталось всего ничего:
1. **Сначала «подпишем» наш ClickHouse на Кафку**, «объяснив ему», какого формата данные там нам нужны:
```
CREATE TABLE IF NOT EXISTS clickstream_topic (
firstInSession UInt8,
timestamp UInt64,
location String,
partyId String,
sessionId String,
pageViewId String,
eventType String,
userAgentString String
) ENGINE = Kafka
SETTINGS
kafka_broker_list = 'kafka:9092',
kafka_topic_list = 'clickstream',
kafka_group_name = 'clickhouse',
kafka_format = 'JSONEachRow';
```
2. **Теперь создадим реальную таблицу**, куда будем класть итоговые данные:
```
CREATE TABLE clickstream (
firstInSession UInt8,
timestamp UInt64,
location String,
partyId String,
sessionId String,
pageViewId String,
eventType String,
userAgentString String
) ENGINE = ReplacingMergeTree()
ORDER BY (timestamp, pageViewId);
```
3. **А потом обеспечим связь между этими двумя таблицами**:
```
CREATE MATERIALIZED VIEW clickstream_consumer TO clickstream
AS SELECT * FROM clickstream_topic;
```
4. **А теперь выберем необходимые поля**:
```
SELECT * FROM clickstream;
```
В итоге выбор из целевой таблицы даст нужный нам результат.
Вот и всё, это был простейший Clickstream, который можно построить. Если хотите выполнить вышеописанные шаги самостоятельно, [смотрите видео](https://www.youtube.com/watch?v=NFjL8YQKuVg) целиком. | https://habr.com/ru/post/477834/ | null | ru | null |
# 7 рекомендаций по оформлению кода на JavaScript
Автор материала, перевод которого мы публикуем сегодня, говорит, что она прямо-таки одержима написанием чистого кода. Она считает, что код надо писать так, чтобы, во-первых, с ним, в будущем, удобно было бы работать другим программистам, включая его автора, а во-вторых — с учётом возможности расширения этого кода. То есть, нужно стремиться к тому, чтобы в приложение сравнительно просто было бы добавлять новые возможности, и чтобы его кодовую базу было бы удобно сопровождать. Если бы программы писали, учитывая лишь нужды компьютеров, то, вероятно, программисты могли бы выражать свои мысли лишь с помощью нулей и единиц, больше ни о чём не заботясь. В этой статье приводится ряд рекомендаций по написанию качественного кода, проиллюстрированных примерами на JavaScript.
[](https://habr.com/company/ruvds/blog/418631/)
1. Используйте понятные имена переменных и функций
--------------------------------------------------
Код гораздо легче читать, когда при его написании используют понятные, описательные имена функций и переменных. Вот не очень понятный код:
```
function avg (a) {
let s = a.reduce((x, y) => x + y)
return s / a.length
}
```
Его читабельность значительно улучшится, если использовать в нём понятные имена переменных и функций, отражающие их смысл.
```
function averageArray (array) {
let sum = array.reduce((number, currentSum) => number + currentSum)
return sum / array.length
}
```
Не стремитесь к минимализму при написании текстов программ. Используйте полные имена переменных, которые тот, кто будет работать с вашим кодом в будущем, легко сможет понять.
2. Пишите короткие функции, решающие одну задачу
------------------------------------------------
Функции легче поддерживать, они становятся гораздо более понятными, читабельными, если они направлены на решение лишь какой-то одной задачи. Если мы сталкиваемся с ошибкой, то, при использовании маленьких функций, найти источник этой ошибки становится гораздо легче. Кроме того, улучшаются возможности по повторному использованию кода. Например, вышеприведённой функции можно было бы дать имя `sumAndAverageArray`, так как в ней мы вычисляем сумму значений элементов массива, используя метод `reduce`, а затем находим среднее значение, деля полученную сумму на количество элементов массива. Вот эта функция.
```
function sumAndAverageArray(array) {
let sum = array.reduce((number, currentSum) => number + currentSum)
return sum / array.length
}
```
Её можно разбить на две функции, тогда роль каждого фрагмента кода станет более понятной. Кроме того, если мы создаём большую программу, наличие функции `sumArray` может оказаться очень кстати. Вот код двух новых функций. Одна вычисляет сумму элементов массива, вторая возвращает их среднее значение.
```
function sumArray(array) {
return array.reduce((number, currentSum) => number + currentSum)
}
function averageArray(array) {
return sumArray(array) / array.length
}
```
Признаком того, что функцию можно разбить на две, является возможность использования слова «and» в её имени.
3. Документируйте код
---------------------
Пишите хорошую документацию к своему коду — тогда тот, кто столкнётся с ним в будущем, поймёт, что и почему в этом коде делается. Вот пример неудачной функции. Здесь используются некие «магические числа», их смысл нигде не пояснён.
```
function areaOfCircle (radius) {
return 3.14 * radius ** 2
}
```
Сюда можно добавить комментарии для того, чтобы этот код стал бы более понятным для того, кто не знает формулы для вычисления площади круга.
```
const PI = 3.14 // Число Пи, округлённое до двух знаков после запятой
function areaOfCircle (radius) {
// Функция реализует математическую формулу вычисления площади круга:
// Число Пи умножается на квадрат радиуса круга
return PI * radius ** 2
}
```
Этот код — всего лишь пример. Вероятно, в подобной ситуации, вместо введения собственной константы, хранящей число Пи, лучше будет воспользоваться стандартным свойством `Math.PI`.
Комментарии к коду должны отвечать на вопрос «почему».
Обратите внимание на то, что для целей документирования кода имеет смысл воспользоваться специальными инструментами и соответствующими им правилами комментирования кода. В применении к Python мне нравится [Google Style Docstrings](http://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html), в применении к JavaScript — [JSDoc](http://usejsdoc.org/).
4. Подумайте об использований правил Сэнди Метц
-----------------------------------------------
Сэнди Метц отлично программирует на Ruby, делает интересные доклады и пишет книги. Она сформулировала четыре правила написания чистого кода в объектно-ориентированных языках. Вот они.
1. Классы не должны быть длиннее 100 строк кода.
2. Методы и функции не должны быть длиннее 5 строк кода.
3. Методам следует передавать не более 4 параметров.
4. Контроллеры могут инициализировать лишь один объект.
Рекомендую посмотреть её [выступление](https://www.youtube.com/watch?v=npOGOmkxuio), касающееся этих правил.
Я следую этим правилам уже примерно два года, и они так основательно закрепились в моём сознании, что я выполняю их, буквально, «на автомате». Мне они нравятся, и я полагаю, что благодаря их использованию повышается удобство сопровождения кода.
Обратите внимание на то, что данные правила — это лишь рекомендации, но их использование позволит сделать ваш код значительно лучше.
5. Применяйте выбранные правила последовательно
-----------------------------------------------
Последовательное применение правил написания кода очень важно независимо от того, пишете ли вы код некоего проекта самостоятельно или работаете в команде. В частности, выражается это в том, что тот, кто читает код, являющийся результатом командной разработки, должен воспринимать его как единое целое. При таком подходе авторство отдельных строк кода можно установить, лишь обратившись к Git. Если вы, в JavaScript, используете точку с запятой — ставьте её везде, где это нужно. То же самое касается и кавычек — выберите двойные или одинарные кавычки и, если на то нет веских причин, всегда используйте то, что выбрали.
Рекомендую применять руководство по стилю кода и линтер, который позволяет приводить код к выбранному стандарту. Например, мне, для JavaScript, нравятся правила [Standard JS](https://standardjs.com/), для Python — правила [PEP8](https://www.python.org/dev/peps/pep-0008/?).
На самом деле, главное здесь — найти правила оформления кода и их придерживаться.
6. Помните о принципе DRY
-------------------------
Одна из первых идей, которую стараются донести до того, кто хочет стать программистом, звучит так: «не повторяйся» (Don’t Repeat Yourself, DRY). Если вы замечаете в своих проектах повторяющиеся фрагменты — используйте такие программные конструкции, которые позволят сократить повторы одного и того же кода. Я часто советую моим ученикам поиграть в игру [SET](https://www.nytimes.com/crosswords/game/set) для того, чтобы улучшить их навыки по распознаванию шаблонов.
Однако если вы приметесь фанатично применять принцип DRY или решите абстрагировать неудачно выбранные шаблоны, читаемость кода может серьёзно ухудшиться, и, позже, вам может понадобиться чаще прибегать к созданию копий одних и тех же конструкций. У Сэнди Метц, кстати, есть отличная статья, посвящённая тому, что дублирование кода — это меньшее зло, нежели [неудачная абстракция](https://www.sandimetz.com/blog/2016/1/20/the-wrong-abstraction).
В результате, не стоит повторяться, но и не стоит, в борьбе за соблюдение принципа DRY, видоизменять код до такой степени, что он может стать трудным для понимания.
7. Используйте идеи инкапсуляции и модульности
----------------------------------------------
Группируйте связанные переменные и функции для того, чтобы сделать ваш код понятнее и улучшить его с точки зрения его повторного использования. Вот пример не самого удачно организованного кода, в котором сведения о человеке оформлены в виде отдельных переменных.
```
let name = 'Ali'
let age = 24
let job = 'Software Engineer'
let getBio = (name, age, job) => `${name} is a ${age} year-old ${job}`
```
Если в подобной программе нужно обрабатывать данные многих людей, тогда в ней лучше будет использовать нечто вроде следующей конструкции.
```
class Person {
constructor (name, age, job) {
this.name = name
this.age = age
this.job = job
}
getBio () {
return `${this.name} is a ${this.age} year-old ${this.job}`
}
}
```
А если в программе надо работать лишь с данными об одном человеке, то их можно оформить так, как показано ниже.
```
const ali = {
name: 'Ali',
age: 24,
job: 'Software Engineer',
getBio: function () {
return `${this.name} is a ${this.age} year-old ${this.job}`
}
}
```
Похожим образом следует подходить к разбиению длинных программ на модули, на отдельные файлы. Это облегчит использование кода, выделенного в отдельные файлы, в разных проектах. В больших файлах с программным кодом часто тяжело ориентироваться, а небольшие понятные модули легко использовать и в том проекте, для которого они созданы, и, при необходимости, в других проектах. Поэтому стремитесь к написанию понятного модульного кода, объединяя логически связанные элементы.
Итоги
-----
В этом материале мы поделились с вами некоторыми рекомендациями по написанию чистого и понятного кода. Однако, это — лишь рекомендации. Это — советы, способствующие написанию качественных текстов программ. Если систематически применять правила, подобные изложенным здесь, то, в сравнении с кодом, при написании которого нечто подобное не применяется, код, написанный с использованием правил, будет получаться более понятным, его легче будет расширять, сопровождать и использовать повторно.
**Уважаемые читатели!** Каких правил оформления кода придерживаетесь вы?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/418631/ | null | ru | null |
# Реализация ролевой модели доступа с использованием Row Level Security в PostgreSQL
Развитие темы [Этюд по реализации Row Level Secutity в PostgreSQL](https://habr.com/ru/post/515896/) и **для развернутого ответа** на [комментарий.](https://habr.com/ru/post/515628/#comment_21973176)
Использованная стратегия подразумевает использование концепции «Бизнес-логика в БД», что было чуть подробнее описано здесь — [Этюд по реализация бизнес-логики на уровне хранимых функций PostgreSQL](https://habr.com/ru/post/515628/)
Теоретическая часть отлично описана в документации [Postgres Pro](https://postgrespro.ru/) — [Политики защиты строк](https://postgrespro.ru/docs/postgrespro/11/ddl-rowsecurity). Ниже рассмотрена практическая реализация **конкретной бизнес задачи — ролевая модель доступа к данным.**
> В статье ничего нового, нет скрытого смысла и тайных знаний. Просто зарисовка о практической реализации теоретической идеи. Если кому интересно — читайте. Кому не интересно — не тратьте свое время зря.
Постановка задачи
-----------------
Необходимо разграничить доступ на просмотр/вставку/изменение/удаление документа в соответствии с ролью пользователя приложения. Под ролью подразумевается запись в таблице **roles** связанной отношением многие-ко-многим с таблицей **users**. Детали реализации таблиц, по причине тривиальности, опущены. Также опущены конкретные детали реализации связанные с предметной областью.
Реализация
----------
#### Создаем роли, схемы, таблицу
**Создание объектов БД**
```
CREATE ROLE store;
CREATE SCHEMA store AUTHORIZATION store;
CREATE TABLE store.docs
(
id integer , --id документа
man_id integer , --id менеджера документа
stat_id integer , --id статуса документа
...
is_del BOOLEAN DEFAULT FALSE
);
ALTER TABLE store.docs ADD CONSTRAINT doc_pk PRIMARY KEY (id);
ALTER TABLE store.docs OWNER TO store ;
```
#### Создаем функции для реализации RLS
Проверка возможности выполнить SELECT строки
**check\_select**
```
CREATE OR REPLACE FUNCTION store.check_select ( current_id store.docs.id%TYPE ) RETURNS boolean AS $$
DECLARE
result boolean ;
curr_pid integer ;
curr_stat_id integer ;
doc_man_id integer ;
BEGIN
-- DBA имеет доступ ко всем документам
IF SESSION_USER = 'curr_dba'
THEN
RETURN TRUE ;
END IF ;
--------------------------------
--Если документ имеет метку 'удален' - не показывать в выборке
SELECT
is_del
INTO
result
FROM
store.docs
WHERE
id = current_id ;
IF result = TRUE
THEN
RETURN FALSE ;
END IF ;
--------------------------------
--Получить id текущего пользователя
SELECT
service_function.get_curr_pid ()
INTO
curr_pid ;
--------------------------------
--Получить id менеджера документа
SELECT
man_id
INTO
doc_man_id
FROM
store.docs
WHERE
id = current_id ;
--------------------------------
--Если менеджер документа не текущий пользователь или менеджер не назначен
--добавить документ в выборку
IF doc_man_id != curr_pid OR doc_man_id IS NULL
THEN
RETURN TRUE ;
ELSE
--Получить текущий статус документа
SELECT
stat_id
INTO
curr_statid
FROM
store.docs
WHERE
id = current_id ;
--Если статус позволяет просмотреть документ - добавить документ в выборку
IF curr_statid = 4 OR curr_statid = 9
THEN
RETURN TRUE ;
ELSE
--Иначе - исключить документ из выборки
RETURN FALSE ;
END IF ;
END IF ;
--------------------------------
RETURN FALSE ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
ALTER FUNCTION store.check_select( store.docs.id%TYPE ) OWNER TO store ;
REVOKE EXECUTE ON FUNCTION store.check_select( store.docs.id%TYPE ) FROM public;
GRANT EXECUTE ON FUNCTION store.check_select( store.docs.id%TYPE ) TO service_functions;
```
Проверка возможности выполнить INSERT строки
**check\_insert**
```
CREATE OR REPLACE FUNCTION store.check_insert ( current_id store.docs.id%TYPE ) RETURNS boolean AS $$
DECLARE
curr_role_id integer ;
BEGIN
--DBA может добавлять строку в любом случае
IF SESSION_USER = 'curr_dba'
THEN
RETURN TRUE ;
END IF ;
--------------------------------
--Получить id роли текущего пользователя
SELECT
service_functions.current_rid()
INTO
curr_role_id ;
--------------------------------
--Если роль допускает возможность создания нового документа
--разрешить
IF curr_role_id = 3 OR curr_role_id = 5
THEN
RETURN TRUE ;
END IF ;
--------------------------------
RETURN FALSE ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
ALTER FUNCTION store.check_insert( store.docs.id%TYPE ) OWNER TO store ;
REVOKE EXECUTE ON FUNCTION store.check_insert( store.docs.id%TYPE ) FROM public;
GRANT EXECUTE ON FUNCTION store.check_insert( store.docs.id%TYPE ) TO service_functions;
```
Проверка возможности выполнить DELETE строки
**check\_delete**
```
CREATE OR REPLACE FUNCTION store.check_delete ( current_id store.docs.id%TYPE )
RETURNS boolean AS $$
BEGIN
--Только DBA может удалять строку
IF SESSION_USER = 'curr_dba'
THEN
RETURN TRUE ;
END IF ;
--------------------------------
RETURN FALSE ;
END
$$ LANGUAGE plpgsql
SECURITY DEFINER;
ALTER FUNCTION store.check_delete( store.docs.id%TYPE ) OWNER TO store ;
REVOKE EXECUTE ON FUNCTION store.check_delete( store.docs.id%TYPE ) FROM public;
```
Проверка возможности выполнить UPDATE строки.
**update\_using**
```
CREATE OR REPLACE FUNCTION store.update_using ( current_id store.docs.id%TYPE , is_del boolean )
RETURNS boolean AS $$
BEGIN
--Документы имеющие статус 'удален' - не редактируются
IF is_del
THEN
RETURN FALSE ;
ELSE
RETURN TRUE ;
END IF ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
ALTER FUNCTION store.update_using( store.docs.id%TYPE , boolean ) OWNER TO store ;
REVOKE EXECUTE ON FUNCTION store.update_using( store.docs.id%TYPE , boolean ) FROM public;
GRANT EXECUTE ON FUNCTION store.update_using( store.docs.id%TYPE ) TO service_functions;
```
**update\_check**
```
CREATE OR REPLACE FUNCTION store.update_with_check ( current_id store.docs.id%TYPE , is_del boolean )
RETURNS boolean AS $$
DECLARE
current_rid integer ;
current_statid integer ;
BEGIN
--DBA может просматривать строку
IF SESSION_USER = 'curr_dba'
THEN
RETURN TRUE ;
END IF ;
--------------------------------
--Получить id роли текущего пользователя
SELECT
service_functions.current_rid()
INTO
curr_role_id ;
--------------------------------
--Удаление документа - изменение признака
IF is_deleted
THEN
--Если роль пользователя ***
IF current_role_id = 3
THEN
SELECT
stat_id
INTO
curr_statid
FROM
store.docs
WHERE
id = current_id ;
--Документ в статусе *** нельзя удалить
IF current_status_id = 11
THEN
RETURN FALSE ;
ELSE
--Можно удалить документ в других статусах
RETURN TRUE ;
END IF ;
--Иначе , если роль пользователя ***
ELSIF current_role_id = 5
THEN
--Все статусы документа
RETURN TRUE ;
ELSE
--Другие пользователи не могут удалять документы
RETURN FALSE ;
END IF ;
ELSE
--Обновление документа разрешено
RETURN TRUE ;
END IF ;
RETURN FALSE ;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
ALTER FUNCTION store.update_with_check( storg.docs.id%TYPE , boolean ) OWNER TO store ;
REVOKE EXECUTE ON FUNCTION store.update_with_check( storg.docs.id%TYPE , boolean ) FROM public;
GRANT EXECUTE ON FUNCTION store.update_with_check( store.docs.id%TYPE ) TO service_functions;
```
Включение политики Row Level Secutiry для таблицы.
**ENABLE ROW LEVEL SECURITY**
```
ALTER TABLE store.docs ENABLE ROW LEVEL SECURITY ;
CREATE POLICY doc_select ON store.docs FOR SELECT TO service_functions USING ( (SELECT store.check_select(id)) );
CREATE POLICY doc_insert ON store.docs FOR INSERT TO service_functions WITH CHECK ( (SELECT store.check_insert(id)) );
CREATE POLICY docs_delete ON store.docs FOR DELETE TO service_functions USING ( (SELECT store.check_delete(id)) );
CREATE POLICY doc_update_using ON store.docs FOR UPDATE TO service_functions USING ( (SELECT store.update_using(id , is_del )) );
CREATE POLICY doc_update_check ON store.docs FOR UPDATE TO service_functions WITH CHECK ( (SELECT store.update_with_check(id , is_del )) );
```
Итог
----
Это работает.
Предложенная стратегия позволила перенести реализацию ролевой модели с уровня бизнес-функций на уровень хранения данных.
Функции могут быть использованы в качестве шаблона для реализации более изощренных моделей скрытия данных, если того требуют бизнес-требования. | https://habr.com/ru/post/516040/ | null | ru | null |
# Расширяем функционал Monopoly City Streets
Разработчиками в MCS, к сожалению, не предусмотрена возможность застройки улицы большим количеством зданий за пару кликов мышкой. Но ведь игра написана на JS, так что ничего нам не мешает написать небольшой букмарклет, который и позволит нам добавить требуемый функционал.
Весь код MCS находится в файле [monopoly.1255614067.js](http://assets.monopolycitystreets.com/monopoly.1255614067.js). Если посмотреть firebug'ом, что происходит в процессе покупки здания — мы увидим, что используются 2 функции — MCS.BUILD.showLocations() [для отображения маркеров доступных мест] и MCS.BUILD.buyBuilding() [для, собственно, покупки здания]. После размышлений у меня получился следующий код:
> if (typeof MCS == "undefined") {
>
> alert('Букмарклет нужно вызывать только на странице монополии');
>
> throw '';
>
> }
>
> var buildingType = null;
>
> var player = MCS.getPlayerData();
>
> if (player == null) {
>
> alert('Перед вызовом необходимо авторизоваться');
>
> throw '';
>
> }
>
> var streetId = MCS.STREET.getStreetData().id;
>
> var streetData = MCS.STREET.getStreetData().data;
>
> if (streetId == null) {
>
> alert('Перед вызовом необходимо выбрать улицу');
>
> throw '';
>
> } else if (streetData.o != player.nickname) {
>
> alert('Перед вызовом необходимо выбрать свою улицу');
>
> throw '';
>
> }
>
> var locations = new Array();
>
> var builtCnt = 0;
>
> var buildLimit = 0;
>
> function buy() {
>
> if (builtCnt < buildLimit) {
>
> buyBuilding(locations[0]);
>
> MCS.STATUSBAR.redraw();
>
> getLocations();
>
> setTimeout(buy, 250);
>
> } else {
>
> done();
>
> }
>
> }
>
> function done()
>
> {
>
> MCS.STREET.show(streetId, null, false, false);
>
> MCS.LOADING.hide();
>
> alert('Построено зданий: ' + builtCnt + 'шт.');
>
> }
>
> function getLocations()
>
> {
>
> locations = new Array();
>
> $.ajax({
>
> url: "/build/getlocations",
>
> cache: false,
>
> data: {
>
> id: streetId,
>
> type: buildingType
>
> },
>
> dataType: "json",
>
> async: false,
>
> success: function (data, status) {
>
> $.each(data, function (foo, point) {
>
> if (point) {
>
> locations.push(foo);
>
> }
>
> });
>
> }
>
> });
>
> }
>
> function buyBuilding(location)
>
> {
>
> $.ajax({
>
> url: "/negotiate/buybuilding",
>
> type: "post",
>
> data: {
>
> nickname: player.nickname,
>
> hash: player.hash,
>
> id: streetId,
>
> type: buildingType,
>
> loc: location
>
> },
>
> dataType: "json",
>
> async: false,
>
> success: function (data, status) {
>
> player.balance -= MCS.buildings[buildingType].price;
>
> builtCnt++;
>
> }
>
> });
>
> MCS.TRACK.view({
>
> page: "build",
>
> section: "build",
>
> street: streetData.n,
>
> country: streetData.cy,
>
> region: streetData.re,
>
> building\_type: buildingType,
>
> activity: "build property",
>
> value: MCS.buildings[buildingType].price
>
> });
>
> }
>
> buildingType = prompt('Введите идентификатор здания. Список доступных типов можно узнать введя "?"', '?');
>
> if (buildingType != null) {
>
> if (buildingType == '?') {
>
> var string = '';
>
> for (i in MCS.buildings) {
>
> if (!isNaN(MCS.buildings[i].effect)) {
>
> string = string + "Идентификатор: " + i + ", наименование: " + MCS.LANG.building["building"+i] + ", стоимость: " + MCS.buildings[i].price\*1000 + "\n";
>
> }
>
> }
>
> alert(string);
>
> } else if (typeof MCS.buildings[buildingType] == "undefined" || isNaN(MCS.buildings[buildingType].effect)) {
>
> alert("Указан некорректный идентификатор");
>
> } else {
>
> var count = Math.floor(player.balance / MCS.buildings[buildingType].price);
>
> if (count > 0) {
>
> getLocations();
>
> var minCnt = Math.min(count, locations.length);
>
> if (minCnt == 0) {
>
> alert('На улице нет места под здания такого типа');
>
> } else {
>
> buildLimit = minCnt;
>
> if (!confirm('Сейчас попытаемся понастроить домов в количестве ' + minCnt + 'шт. Если хотите изменить предел (только в меньшую сторону) - нажмите "отмена"')) {
>
> buildLimit = prompt('Сколько зданий пытаться строить?', minCnt);
>
> if (buildLimit == null) {
>
> throw '';
>
> }
>
> if (isNaN(buildLimit) || buildLimit > minCnt || buildLimit < 0) {
>
> alert('Некорректное значение');
>
> throw '';
>
> }
>
> }
>
> MCS.LOADING.show();
>
> setTimeout(buy, 250);
>
> }
>
> } else {
>
> alert('У вас недостаточно средств для строительства этого здания');
>
> }
>
> }
>
> }
подсветка кода: [highlight.hohli.com](http://highlight.hohli.com/)
Перед началом работы скрипт проводит несколько проверок: наличие класса MCS (в противном случае мы точно не на сайте игры), наличие авторизации у пользователя, а так же проверяется текущая выделенная улица. Далее выдаётся запрос для выяснения типа здания — список последних берётся из кода игры. Проверяется наличие денег у игрока и наличие свободных мест на улице. Затем выясняем количество домов для постройки и приступаем к этому увлекательному занятию. Чтобы пользователь не скучал — не забываем отобразить «песочные часы» в верхней панели. И, наконец, выводится количество построенных домов.
Чтобы преобразовать этот скрипт в 1 строку — используем [javascriptcompressor.com](http://javascriptcompressor.com/), в результате у нас почти есть букмарклет — остаётся только добавить 'javascript:' в начало полученной строки.
Готовый текст букмарклета на пастебине: [pastebin.mozilla.org/678433](http://pastebin.mozilla.org/678433)
P.S. В качестве бонуса — букмарклет для отображения стоимости текущей улицы без зданий: `javascript:if(typeof MCS != "undefined"&&MCS.STREET.getStreetData().data)alert(MCS.STREET.getStreetData().data.p*1000);`
**UPD** Букмарклет для пакетного удаления зданий:
> if (typeof MCS == "undefined") {
>
> alert('Букмарклет нужно вызывать только на странице монополии');
>
> throw '';
>
> }
>
> var buildingType = null;
>
> var player = MCS.getPlayerData();
>
> if (player == null) {
>
> alert('Перед вызовом необходимо авторизоваться');
>
> throw '';
>
> }
>
> var streetId = MCS.STREET.getStreetData().id;
>
> var streetData = MCS.STREET.getStreetData().data;
>
> if (streetId == null) {
>
> alert('Перед вызовом необходимо выбрать улицу');
>
> throw '';
>
> } else if (streetData.o != player.nickname) {
>
> alert('Перед вызовом необходимо выбрать свою улицу');
>
> throw '';
>
> }
>
> function demolish() {
>
> if (removedCnt < removeCnt && buildingList.length) {
>
> $.ajax({
>
> url: "/negotiate/demolishbuilding",
>
> type: "post",
>
> data: {
>
> nickname: player.nickname,
>
> hash: player.hash,
>
> id: streetId,
>
> bid: buildingList.shift()
>
> },
>
> dataType: "json",
>
> async: false,
>
> success: function () {
>
> MCS.getPlayerData().balance += parseInt(MCS.buildings[removeMe].price / 2);
>
> }
>
> });
>
> removedCnt++;
>
> setTimeout(demolish, 500);
>
> } else {
>
> done();
>
> }
>
> }
>
> function done()
>
> {
>
> MCS.STREET.show(streetId, null, false, false);
>
> MCS.LOADING.hide();
>
> }
>
> var buildingTypes = new Array();
>
> var str = '';
>
> var i;
>
> for (i in streetData.b) {
>
> if (!isNaN(MCS.buildings[streetData.b[i].t].effect)) {
>
> if (typeof buildingTypes[streetData.b[i].t] == "undefined") {
>
> buildingTypes[streetData.b[i].t] = new Array();
>
> buildingTypes[streetData.b[i].t]['name'] = MCS.LANG.building["building"+streetData.b[i].t];
>
> buildingTypes[streetData.b[i].t]['count'] = 1;
>
> } else {
>
> buildingTypes[streetData.b[i].t]['count']++;
>
> }
>
> }
>
> }
>
> if (buildingTypes.length == 0) {
>
> alert('На выбранной улице нет доступных для сноса зданий');
>
> throw '';
>
> }
>
> for (i in buildingTypes) {
>
> str = str + "Идентификатор: " + i + ", наименование: " + buildingTypes[i]['name'] + ", количество: " + buildingTypes[i]['count'] + "шт." + "\n";
>
> }
>
> var removeMe = prompt("Введите идентификатор здания для сноса. Список зданий на улице:\n" + str);
>
> var buildingList = new Array();
>
> if (removeMe != null) {
>
> if (typeof buildingTypes[removeMe] == 'undefined') {
>
> alert('Указан некорректный тип зданий');
>
> throw '';
>
> }
>
> var removeCnt = buildingTypes[removeMe]['count'];
>
> var removedCnt = 0;
>
> if (!confirm('Будет предпринята попытка сноса зданий в количестве ' + removeCnt + 'шт. Если хотите изменить количество (только в меньшую сторону) - нажмите "отмена"')) {
>
> removeCnt = prompt('Введите количество домов для сноса');
>
> if (removeCnt == null) {
>
> throw '';
>
> }
>
> if (isNaN(removeCnt) || removeCnt > buildingTypes[removeMe]['count'] || removeCnt < 0) {
>
> alert('Некорректное значение');
>
> throw '';
>
> }
>
> }
>
> MCS.LOADING.show();
>
> for (i in streetData.b) {
>
> if (streetData.b[i].t == removeMe && removedCnt < removeCnt) {
>
> buildingList.push(i);
>
> }
>
> }
>
> setTimeout(demolish, 250);
>
> }
[pastebin.mozilla.org/678730](http://pastebin.mozilla.org/678730) | https://habr.com/ru/post/73164/ | null | ru | null |
# Классификация кассовых чеков
Банки получают содержание кассовых чеков клиентов по транзакциям, совершенных по собственным картам через Операторов Фискальных Данных с согласия клиента. Данные приходят в сыром текстовом формате, аналогичном тому, что вы получаете в магазине на бумажном носителе информации после каждой вашей покупки. Каждый магазин заносит товары в кассовое ПО в произвольном, полюбившемся ему формате. Чеки некоторых магазинов содержат полное название каждой из товарных позиций, большинство же, видимо, сильно экономят на бумаге и сокращают все названия.
В кассовых чеках не содержатся штрих-коды и другие идентификаторов товаров. К сожалению, исходя из вышеописанных причин, не может существовать единого каталога с категоризацией всех названий товаров из чеков. А ведь наличие такого каталога помогло бы более качественно отображать детализацию покупок клиенту. Дополнительно категоризация товарных позиций может быть использована в качестве дополнительных признаков в моделях, использующих транзакционные переменные.
Весной 2021-го года ВТБ организовывал соревнование на платформе [Boosters](https://boosters.pro/championship/data_fusion/overview) с целью решения этой задачи.
Описание соревнования
---------------------
Участникам был предоставлен массив данных, содержащий более семи миллионов неразмеченных чеков и более одного миллиона размеченных чеков. К сожалению, уникальных размеченных товарных позиций было порядка 50 тысяч, заявленный миллион чеков был сгенерирован на основе этой разметки. К счастью, в неразмеченных данных такая тенденция не прослеживалась и в них содержалось примерно 3 миллиона уникальных товарных позиций. В выборке содержались объекты из 90 различных классов.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Товарная позиция** | **Цена** | **Кол-во** | **НДС** | **День недели** | **Время** |
| ЙогуртпитEPICAклуб/мар290 | 10 | 1 | 2 | 5 | 11:34 |
| Пиво Велкопоповицкий Козел темное ж/б 3,7% 0,45л | 9 | 1 | 6 | 3 | 20:54 |
| Энерг. нап. Адреналин Раш 0,25л ж/б (ПепсиКо) | 10 | 1 | 1 | 4 | 14:38 |
| Нектар ФрутоНяня Тыквенный с мяк 0,5л | 12 | 1 | 6 | 6 | 17:12 |
| Картофель весовой | 8 | 0.43 | 1 | 2 | 11:03 |
В дополнение к названию товарных позиций были доступны мета-признаки: ценовой бакет, количество товара, тип НДС, день недели и время покупки. Опыт подсказывает, что весовые товары сложно купить в целом количестве штук, а схема налогообложения в РФ различна для ряда товаров и услуг, поэтому дополнительные категориальные признаки могут быть полезны для решения задачи.
Организаторы соревнования выбрали метрику [weighted f1 score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html) в качестве целевой. Соревнование проходило в формате docker. Время выполнения алгоритма ограничивалось 1.5 часами. Каждый сабмит не должен был превышать 500 мегабайт. Характеристики среды исполнения: 8 vCPU, 46 GB RAM, Nvidia Tesla V100 16 GB.
Подготовка данных
-----------------
Без преувеличения, текстовые данные кассовых чеков можно смело называть "грязными". Очень часто разделителем является не пробел, а точка, слэш, смена регистра, а иногда и смена языка. Некоторые магазины очень любят сокращения, другие, наоборот, для экономии обрезают часть слов. Некоторые даже экономят на мощности словаря и заменяют все похожие буквы из кириллицы на аналоги из латиницы или цифры: "к" на "k", "с" на "c" или "з" на "3". Также не всегда возможно по названию товара из чека произвести биекцию на товарную позицию, например, "*Шоколадный батончик Snickers Лесной орех, 81 г*" в каталоге может называться как "*Шок. бат*".
Алгоритм предобработки данных состоял из следующих этапов:
1. Перевод всех символов в нижний регистр.
2. Замена всех визуально-похожих символов на вариант из кириллицы.
3. Токенизация по группе регулярных выражений.
4. Замена всех последовательностей цифр на "1".
Так, например, строка "**Молоко Домик.в деревне 3.2% 0.5л пл/б БЗМЖ/Россия"** после предобработки превращалась в **"молоко домик в деревне 1% 1л пл/б бзмж россия".**
С одной стороны, размер обучающей выборки крайне мал для того, чтобы выучить вектора слов в режиме end-to-end. C другой стороны, доменный контекст в этой задаче сильно отличается от Википедии, Ленты и других популярных датасетов, на которых предобучают векторные представления слов. К счастью, после предобработки данных получалась выборка порядка 2.7 миллионов уникальных строк, что эмпирически можно считать достаточным объем для обучения векторов под специфичный домен. [Пример обучения векторов FastText](https://fasttext.cc/docs/en/unsupervised-tutorial.html) из туториала через CLI-интерфейс:
```
$./fasttext skipgram -input data/fil9 -output result/fil9 -minn 2 -maxn 5 -dim 300
```
Модели
------
Организаторами соревнования был предоставлен бейзлайн на основе логистической регрессии и мешка слов **0.63 F1**. Замена логистической регрессии на SVM и добавление символьных нграмм заметно улучшили качество до **0.84 F1**. В [соревновании на kaggle](https://www.kaggle.com/c/receipt-categorisation/leaderboard) на аналогичных данных от [@dremovd](/users/dremovd) значительно улучшало качество добавление контекста всего чека. В этом соревновании такой подход не зашел, так как чеки были искусственно сгенерированы.
На данный момент SOTA-решением для классификации текстов принято считать BERT-подобные архитектуры. Они показывают отличное качество за счет огромного количества обученных параметров, впитавших контекстные знания из огромных корпусов документов. К сожалению, названия товарных позиций сильно отличаются от текстов новостей и статей википедии. Более того, не существует аналогичных корпусов для домена кассовых чеков, на котором можно было бы обучить BERT. В случаях серьезного доменного отличия эмпирический опыт говорит, что рекуррентные сети справляются с решением задачи лучше.
В итоге выбор архитектуры был сделан в пользу двунаправленной рекуррентной сети с пуллингами и скип-коннекшенами. Представленная ниже архитектура практически полностью дублирует описанную в предыдущей [статье](https://habr.com/ru/company/alfa/blog/551130/).
В первую версию решения были добавлены дропауты и L2 регуляризации, а также подобрано число обучаемых параметров для того, чтобы сеть не переобучалась. Дополнительно был использован Cyclic Learning Rate для лучшей сходимости. В итоге такое решение получило **0.85 F1**.
Следующим шагом было ансамблирование моделей. Размеченная выборка была разделена на пять фолдов, выбранная архитектура обучалась на подмножествах из четырех фолдов до тех пор, пока росло качество на оставшемся фолде. Предсказания для тестовой выборки считались как среднее от пяти моделей. Ансамблирование улучшило качество решения до **0.86 F1**.
Вектора были необучаемыми параметрами сети ввиду того, что у [python-пакета fasttext](https://fasttext.cc) отсутствует совместимый с pytorch и tensorflow интерфейс для дообучения векторов в end-to-end режиме. FastText при построении векторного представления слова использует нграммы слова, а также особым образом учитывает его начало и конец. Улучшение алгоритма токенизации повысило качество решения до **0.865 F1**.
Соревнование проходило в docker-формате, что приводило к необходимости отправки архива с кодом и бинарников в проверяющую систему в рамках каждого сабмита. В системе было установлено ограничение в 500 мегабайт на размер входного файла. Бинарный файл с размерностью векторов 50 едва пролезал через это ограничение.
При использовании параметров по умолчанию библиотека fasttext создает 2 миллион хэшей для хранения векторов нграмм. Их количество можно снизить, уменьшая значение параметра **-bucket**. В ходе экспериментов выяснилось, что оптимальным размером вектора является 150. Таким образом, при размере словаря 95k и размерности ембеддинга 150 и **-butcket**=2m бинарный файл весит 1.2 ГБ, а при **-bucket**=700k — всего 480 МБ. Это бесценное знание помогло увеличить размерность с 50 до 150. Увеличение размера векторного представление слов повысило качество до **0.88+ F1**.
### Пролог
К сожалению, не всегда удавалось понять четкое различие между классами при помощи естественного интеллекта. В данных было несколько классов с продуктами, скорее всего, различающих по формату магазина: супермаркет, магазин у дома, гипермаркет. Более того, в выборке был выделен класс "другое", в который асессоры относили не только "другие товары", но и сложные объекты из остальных классов. Частичная переразметка этого класса не приводила к росту метрик, так как на тестовой выборке разметка, видимо, была идентичной.
В соревновании не зашли буквенные рекуррентные и сверточные сети, в том числе в качестве дополнительного энкодера. Полагаю, что это следствие обучения на небольшой размеченной выборке. Не зашел подход активного обучения. Видимо, fasttext впитал в себя максимум контекста из неразмеченной выборки.
Материалы
---------
### Турнирная таблица
Private leaderboardОставайтесь на связи, подписывайтесь на [Телеграмм-канале «Нескучный Data Science»](https://t.me/not_boring_ds).
### Публичные решения
<https://github.com/dremovd/data-fusion-1-baseline>
<https://github.com/gorodion/GoodsClassifier>
<https://github.com/aptmess/data_fusion_goodsification>
<https://github.com/pozdnyakovx/VTB_data_fusion_2021>
<https://github.com/pskliff/vtb-data-fusion>
<https://github.com/Irinas5555/Data-Fusion-Contest-Goodsification--18-place-on-public-liderboard->
<https://github.com/v-pozdnyakov/data-fusion-contest>
### Конференция Data Fusion | https://habr.com/ru/post/573332/ | null | ru | null |
# STB — погружение
Всем доброго времени суток.
Я думаю что многие из вас слышали о домашнем телевидении, и предложении купить себе в дом ТВ-декодер (приставку) чтобы вы могли насладиться качественным ТВ, покупать фильмы, узнавать погоду, и делать многое другое не отходя от телевизора.
Сейчас я расскажу вам что такое — эта приставка, со стороны разработчика программных продуктов.
Если вам это интересно — добро пожаловать под кат.
Что такое приставка?
--------------------
Приставка (*STB, Set-Top Box, бокс*) — это одноплатный компьютер, на которой установлена максимально урезанная ось из семейства GNU/Linux.
*Команда uname -a:*
```
# uname -a
Linux (none) 3.1.5-1.7 #66 SMP Wed Oct 22 14:40:19 EEST 2014 mips GNU/Linux
```
Боксы как-правило слабые.
Сильные представители (и, соответственно, дорогие) могут иметь:
* **Оперативная память** — от 300Mb до 1Gb
* **Всего места на приставке** — ~250Mb
* **Свободного места** — ~5-20Mb (возможно, бывает и больше, но это именно те цифры, с которыми приходится работать)
* **Процессор** — до 1.3Ghz (до двух ядер)
**Каждый бокс имеет (список содержит лишь важные элементы):**
* **Ethernet вход** — нужен для IPTV (если бокс IPTV), интеграции с сервисами, для подключения к приставке
* **HDMI выход** — без комментариев
* **Аналоговый выход** — без комментариев
* **S/PDIF** — без комментариев
* **USB входы** — как-правило один вход, но бывают боксы которые рассчитаны на подключение различных флешек и внешних жестких дисков одновременно, и поэтому могут иметь больше входов. Некоторые боксы даже поддерживают USB-хабы.
**В зависимости от задачи бокса и некоторых других факторов, бокс может иметь:**
* **Вход под сим-карту** — некоторые приставки имеют 3G модуль, и через симку пользователь сможет выйти в интернет без Ethernet кабеля. Кроме того, на симку могут приходить сообщения от оператора, и API платформ позволяет работать с СМС сообщениями.
* **Вход для сигнала** (спутниковый/кабельный вход) — если приставка спутниковая или кабельная, он необходим для приема цифрового вещания (проще говоря, чтобы можно было подключиться к потокам ТВ каналов). Помимо вещания через кабель может прийти служебная информация.
* **Вход под смарт-карту** — опишу это чуть ниже.
* **Разъем под Wi-Fi антенну** — некоторые боксы могут работать с Wi-Fi сетями.
**Вот так это может выглядеть (фотки из сети, для примера):**
#### Причем здесь JavaScript?
Когда абонент запускает дома приставку он видит красивый удобный портал, пользоваться которым он может используя пульт от приставки.
**Этот портал — ничто иное, как одностраничное приложение** (*SPA — Single Page Application*) **написанное на JavaScript**, и открытое во вкладке браузера запущенного на приставке.
Когда мы включаем бокс (по питанию) в общем случае происходит следующее (все лишнее не описываю):
1. Запустилась ось приставки
2. Приставка запускает браузер, и открывает в нем HTML файл
Здесь есть свои особенности:
* На некоторых приставках файл конфигурации доступен для записи — можно, например, изменить путь до HTML файла, который будет открываться во вкладке браузера при старте или рестарте браузера. В целом, многие настройки используются для оптимизации процесса отладки кода, не более.
* На некоторых приставках запускается не HTML файл вашего портала, а собственный портал приставки, в котором вы при помощи пульта вводите адрес файла (либо адрес вашего сервера, который раздает исходники), и затем браузер просто открывает ссылку которую вы ввели.
Добавлено от [rule](http://habrahabr.ru/users/rule/):
> Не все приставки позволяют менять страницу портала или адрес портала. Например Amino на первой вашей странице обязывает иметь специально ключи для этого т производителя. Есть несколько уровней доступа для этого.
Получается, что почти никаких навыков для разработки портала на приставке не нужно? Достаточно лишь настроить приставку, и научиться деплоить на нее свое приложение? — это не совсем так.
**Приставка — это платформа с очень низкой производительностью**, и поэтому разработка под веб, и под бокс, это совершенно разные уровни сложности. Именно поэтому почти любая ошибка кодирования дает о себе знать — ваше приложение будет неверно рендериться, рендериться «лесенкой», тормозить, отказываться работать, «валить» браузер, выдавать артефакты, выедать память, и многое-многое другое. Об этом я расскажу чуть позже.
#### Зачем нужна приставка?
* **Я абонент** — я хочу держать на стене плазму, подключить к ней приставку, и смотреть фильмы, спутниковое ТВ в высоком качестве, узнавать будут ли утром пробки когда я поеду на работу, и не прикладывать никаких усилий.
* **Я оператор связи** — я могу продавать (или, например, давать в аренду) своим абонентам приставки, и через нее продавать услуги (продажа фильмов, пакетов каналов, другое) и получать прибыль.
Соответственно, подавляющее большинство порталов на приставке направлено на решение одной большой задачи — с одной стороны создать возможность продажи услуг (продажа фильмов, просмотр платных каналов и многое другое), а с другой стороны сделать максимально удобное приложение интегрированное с другими сервисами (карта, почта, социальные сети, новости, SMS, серфинг в интернете и другое), позволяющее смотреть ТВ и решать множество других задач в одной «коробке».
Если это обычный браузер, разве мы сможем все это реализовать? Телевидение? Фильмы? SMS? — сможем, потому что **приставка это не просто коробка с браузером внутри**. **Каждый бокс предлагает собственное JavaScript API.**
#### JavaScript API приставки
В общем случае API приставки можно разделить на группы:
* API плеера приставки — методы чтобы управлять воспроизведением.
* API для получения информации о текущем потоке — субтитры, дорожки аудио, телетекст, другое...
* API для работы с входами приставки — проверка наличия HDMI, Ethernet кабеля, спутникового кабеля, наличие 3G, другое...
* API для проверки наличия соединения — наличие интернета во вставленном кабеле, наличие или качество спутникового сигнала, другое...
* API для работы с хранилищем приставки — не на всех боксах, но довольно часто локальное хранилище браузера очищается после рестарта приставки, поэтому для сохранения данных между перезагрузками используется отдельный API.
* API для получения данных — получение IP бокса, MAC-адреса, модель бокса, и другое..
* API для работы с сетью вещания — сканирование каналов, другое.
* API для настройки бокса — формат увеличения изображения, пропорции изображения, другое..
* API для работы с файлами и файловой системой — получить длительность файла, получить список файлов на флешке, узнать кодек видео, другое...
**Этого более чем достаточно для решения большинства задач.**
#### Как пользователь взаимодействует с порталом?
К каждой приставке в комплекте идет пульт управления. Обычно он содержит кнопки для решения основных задач связанных с ТВ:
* Кнопки навигации — «Вверх», «Вправо», «Вниз», «Влево», «Ввод», «Меню», «Назад».
* Кнопки управления громкостью — «Сделать громче», «Сделать тише», «Выключить звук»
* Кнопки для переключения каналов — «Следующий канал», «Предыдущий канал»
* Кнопки управления воспроизведением — «Плей», «Стоп», «Пауза», «Мотать вперед», «Мотать назад», «Начать запись». В зависимости от производителя какие-то кнопки могут отсутствовать или быть совмещенными.
* Цифровая клавиатура — цифры и нарисованные на них буквы. Нужны для упрощения ввода символов,
* Цветные кнопки — для упрощения взаимодействия со страницами. На эти кнопки вешается какая-то логика в зависимости от состояния текущей страницы.
* Включить/Выключить
* Другие кастомные кнопки — кнопки ведущие на конкретные страницы приложения, доп. управление навигацией, и другое.
**Как портал взаимодействует с пультом?**
Разрабатывая приложение нужно поймать нажатие кнопки и обработать его. Здесь все довольно просто — нажатие кнопки на пульте обрабатывается как обычное нажатие на клавишу клавиатуры. Одно отличие — коды клавиш для каждого вендора свои.
**Bonus-track** — на некоторых боксах события «keyup» и «keydown» приходят одновременно. Поэтому, если захотите сделать обработку зажатия клавиши пульта (такие кейсы бывают), вспомните про картинку *костыли\_и\_велосипеды.jpg*
#### Что мы имеем?
**Подведем небольшой промежуточный итог этой быстрой вводной:**
* Бокс — слабая машина на базе Linux
* Бокс при включении запускает браузер, и поэтому приложение на приставке — это веб-приложение по своей сути.
* Работа с боксом происходит через SSH или Telnet.
* Бокс предоставляет API доступное из браузера для решения широкого круга задач связанных с ТВ, аудио/видео файлами, и многим другим.
Таким образом, любая приставка — это платформа с низкой производительностью, с помощью которой можно решить задачи так или иначе связанные с ТВ. Все необходимые для этого инструменты в этой платформе есть.
Звучит хорошо? — звучит отлично! Однако, на практике все не так хорошо звучит, и сейчас мы переходим к более интересной, второй части статьи: Заметки
Заметки
-------
Повторюсь — приставка это компьютер с распиленным Linux, и браузером в который вкручен дополнительный API, благодаря которому большинство из задач стоящих перед порталом на приставке становятся реализуемыми.
Для нас важна лишь вторая часть этого высказывания — **производители боксов допиливают браузеры!**
В боксах бывают установлены различные браузеры, но чаще всего встречаются Opera или браузеры на WebKit. В результате допила браузеры начинают обладать самыми различными багами: утечки памяти в самых неожиданных местах, частично неработающий сборщик мусора, падение браузера в результате самого обычного вызова метода, баги отрисовки, и многое другое.
**Заметки которые написаны ниже — это субъективные выводы исходя из набитых шишек и найденных граблей.** *Очень надеюсь, что они окажутся вам полезны.*
**Поехали..**
#### Операции с DOM
Операции с DOM — **самые тяжелые операции**. На приставке это очень (!) заметно (в прямом смысле).
**Если количество операций с DOM не сведено к минимуму, тогда есть вероятность:**
* **Получить очень неприятный эффект** — **вы будете видеть (буквально) как отрисовывается страница.** Фактически, это Composite Layers, который отрабатывает очень медленно, и поэтому перерисовку грида страницы видно невооруженным глазом (заменяется один сектор сетки за другим, а не все сразу).
* Затратить много времени на рендер страницы.
Основная вытекающая из этого проблема — **существенно портится UX.** Я как пользователь хочу нажать кнопку, и увидеть мгновенно открывшуюся страницу, без месива из перерисовываемых слоев и ожидания в 1-3 секунды. Если я буду видеть это постоянно — у меня появятся неприятные ощущения от взаимодействия с порталом. Я как пользователь прежде всего хочу испытывать удовольствие от взаимодействия с приложением, и думать что потратил свои деньги не зря.
Копнем немного поглубже — Что конкретно нужно минизировать?
**Нужно минимизировать или исключить:**
* **Вставку элементов пачками** — давайте дружить с document.createDocumentFragment().
* **Изменение стиля элементов** — если есть возможность спроектировать страницу таким образом, чтобы в каком-то конкретном кейсе (например, перемещение элементов) вы смогли изменить стиль одного или двух элементов вместо целой пачки элементов, нужно ее использовать.
* **Layout + перерисовку дерева элементов.** Для понимания о чем идет речь я приведу пример. Например, у вас есть 3 слоя (div), расположенных друг рядом с другом. Если вы добавите первому из них границу в 1px, тогда перерисованы будут все слои вместо одного. Эту лишнюю нагрузку можно исключить спроектировав страницу по-другому.
* **Изменение размеров изображения** — если взять изображение размером 100x100, и разместить его задав ему размер 90x90, это будет лишней нагрузкой на браузер (браузер будет ужимать изображение). Если вы делаете каталог с плиткой, где каждый элемент содержит изображение, это будет лишней нагрузкой. Если есть возможность, вытягивайте с сервера изображения строго необходимого вам размера, и не перегружайте браузер лишними в данном случае действиями.
* **Анимации**. Приставка может вам позволить добавить анимацию в приложение, но только легковесную анимацию (прокрутка небольшого списка, меню, прокрутка текста). В остальных случаях приставке не хватит производительности, и анимация будет проходить рывками. Об анимации больших элементов страницы можно и вовсе забыть. Есть два исключения — канвас и CSS3 трансформации. Они работают более-менее (не тормозят существенно, но и не «60fps». Назовем это — терпимо), но это дополнительная сложность в разработке.
Резюмируем. **Рецепты при работе с DOM:**
* Используйте document.createDocumentFragment — одна операция с DOM намного эффективнее чем несколько (капитан очевидность снова с вами).
* Проектируйте страницу с расчетом на минимальное количество модификаций DOM при взаимодействии со страницей.
* Используйте верстку с абсолютно расположенными элементами.
* Не используйте изображения, которые не подходят вам по размеру.
* Стремитесь исключить лишнюю нагрузку на браузер.
* Стремитесь не использовать прозрачность — это заставляет браузер делать больше расчетов.
* Откажитесь от анимаций, или используйте канвас.
#### CSS
Без лишней воды, **рецепты по оптимизации таблиц стилей, и взаимодействию с классами**:
* **Старайтесь не использовать вложенность более одного уровня** — это нагрузка на браузер. Если сделать большую вложенность, при изменении разметки, классов элемента или стилей элемента, браузер будет обходить намного больше узлов с целью генерации стиля элемента, нежели с минимальной вложенностью.
* **Не используйте тяжелые селекторы.**
* Если необходимо произвести несколько операций (изменение стиля элемента), которые нельзя объединить — делайте их вместе, подряд. Браузер это определяет, и не перерисовывает (в том числе не производит перерасчёт стилей) элементы лишние n-раз.
Как следствие — использование CSS фреймворков (например, Bootstrap) нежелательно.
Есть отличное решение, которое дает мощный прирост производительности — постараться отказаться от классов, и генерировать верстку с inline-стилями (тег style). Возможно, есть даже плагины для Gulp/Grunt.
Немного про поддержку CSS свойств. В большинстве боксов стоит WebKit, и многое из CSS3 поддерживается. Если вы разрабатываете приложение не под один бокс, а сразу под несколько, тогда не рекомендую использовать различные новые «плюшки». Не исключено, что на одной платформе они отработают отлично, а на второй вам не прилетят баги.
Добавим конкретики. Что часто поддерживается (из CSS3; список очень неполный, составил исходя из реальных кейсов, по памяти):
* border-radius
* rgba
* linear-gradient
* text-overflow
* background-size
* Трансформации
* Анимации
* opacity
* box-shadow
* overflow-x
* overflow-y
* line-break
* word-wrap
* text-shadow
* @font-face
* box-sizing
* text-overflow
#### Баги
Помимо обычных багов которые могут возникнуть как следствие неверно запрограммированной логики, бокс довольно часто может бажить в не очевидных местах.
**Какие бывают баги?**
Чаще всего встречаются баги связанные с отрисовкой страницы: не отрисовался фон div'а, не выгрузился старый фон при перерисовке элемента, при отрисовке прозрачной границы браузер игнорирует все слои находящиеся под ней (видно сразу фон страницы), и многие другие баги.
Реже встречаются баги в движке: вызов нативного метода валит браузер, if в особых условиях валит браузер, итерация по ключам объекта происходит в не отсортированном виде (~~возможно, не баг~~ не баг: от [gibson\_dev](http://habrahabr.ru/users/gibson_dev/) «В том то и весь цимес что оно по спецификации так и есть, в сортированном виде только массивы, а конструкция for..in этого не гарантирует»), и другие еще более редкие кейсы.
Отдельная группа багов, это вендорные баги: криво работают потоки, неверно читается файловая система, неверно генерятся ответы при использовании API, и многое другое.
**Мораль написанного выше** — всегда досконально проверяйте ваше решение на всех поддерживаемых вами платформах. Если ваше решение работает на одной платформе, то нет никакой гарантии что оно будет работать и на всех остальных ваших платформах.
#### Утечки памяти
Утечка памяти на приставке может быть из «ниоткуда». Без примеров, потому что универсального рецепта как это обойти нет.
Правило простое — **периодически прогоняйте ваше приложение на утечки памяти.** Если утечки есть — ищем откуда, и закрываем «течь».
Другое
------
### Как обычно деплоится приложение (при разработке)?
Способов немного, и все они простые. Весь деплой заключается в том, чтобы скопировать файлы с вашей машины в папку на боксе, либо (что еще проще) настроить приставку таким образом, чтобы она тянула исходники не со своей файловой системы, а из сети (например, с вашего локального сервера).
Написал про каждый метод (как инструкцию), но чтобы не загромождать статью, все завернуто в спойлер.
**Скрытый текст**Способ #1 — Через флешку
1. Собираем наше приложение
2. Копируем исходники на флешку
3. Вставляем флешку в бокс
4. Заходим на приставку через telnet или ssh (в зависимости от бокса)
5. Заменяем исходники в директории, из которой приставка пытается запустить HTML файл (обычно это файл index.html)
Способ #2 — Выкачиваем исходники со своей машины
1. Разворачиваем сервер (например, на express'е), который раздает статику из директории в которую собирается ваше приложение
2. Собираем приложение
3. Архивируем приложение
4. Заходим на приставку через telnet или ssh (в зависимости от бокса)
5. Выкачиваем исходники с нашей машины (wget, curl)
6. Заменяем исходники в директории, из которой приставка пытается запустить HTML файл (обычно это файл index.html)
Я думаю что самый лучший способ — способ #3.
Способ #3 — Без деплоя
Этот способ будет работать, если вы можете указать приставке откуда ей тянуть HTML файл (почти на всех боксах это возможно).
1. Разворачиваем сервер (например, на express'е), который раздает статику из директории в которую собирается ваше приложение
2. Заходим на приставку через telnet или ssh (в зависимости от бокса)
3. Редактируем конфиг бокса — указываем адрес HTML файла на вашем локальном сервере
После перезапуска браузер приставки запросит файл с вашего сервера, и вытянет все исходники (скрипты, стили, изображения, другое) сам.
### Смарт-карта
В боксах может быть смарт-карта. Я не специалист в этой области, поэтому [читаем об этом в википедии](https://ru.wikipedia.org/wiki/%D0%A1%D0%BC%D0%B0%D1%80%D1%82-%D0%BA%D0%B0%D1%80%D1%82%D0%B0).
В боксе она может присутствовать в двух видах:
* Внешняя карта — нужно самостоятельно ее воткнуть в специальный вход в боксе.
* Интегрированная карта — зашита внутрь бокса, и фактически она всегда «вставлена» когда бокс включен.
Больше ничего об этом не напишу — не специалист, и понимаю как это работает только на уровне «потрогал-пощупал». Не хочу вам случайно соврать.
Финишируем
----------
**Бокс (приставка)** — интересная платформа, работая с которой можно набраться опыта как писать максимально производительные приложения. Более того, тонны интересных задач и багов при работе с этой платформой вам будут железно обеспечены.
Если вы любите хардкорное (в хорошем смысле этого слова) программирование, одностраничные приложения, и ищете бесценный опыт который вам железно пригодится — попробуйте написать приложение для приставки.
*P.S
Статья является вводной, и никаких особенностей боксов каких-то конкретных вендоров не рассматривается. Все в общих чертах, чтобы лишь сформировать представление что такое приставка, и дать базовую информацию как начать с ней работать и откуда ждать сложности.
Когда впервые держишь приставку в руках, может быть совершенно непонятно что это такое, и я очень надеюсь что эта статья сможет кому-нибудь послужить отправной точкой в работе боксами.
Будет отлично, если будут дополнения к этой статье — пишите в комментариях, я добавлю всю полезную информацию в текст статьи.* | https://habr.com/ru/post/259113/ | null | ru | null |
# Создание игр для NES на ассемблере 6502: оборудование NES и знакомство с ассемблером
**Оглавление**
Оглавление
----------
### Часть I: подготовка
* [Введение](https://habr.com/ru/post/596449/)
* [1. Краткая история NES](https://habr.com/ru/post/596449/)
* [2. Фундаментальные понятия](https://habr.com/ru/post/596475/)
* [3. Приступаем к разработке](https://habr.com/ru/post/596475/)
* [4. Оборудование NES](https://habr.com/ru/post/596583/)
* [5. Знакомство с языком ассемблера 6502](#intro)
* [6. Заголовки и векторы прерываний](https://habr.com/ru/post/597887/)
* [7. Зачем вообще этим заниматься?](https://habr.com/ru/post/597957/)
* [8. Рефакторинг](https://habr.com/ru/post/597997/)
### Часть II: графика
* [9. PPU](https://habr.com/ru/post/599107/)
* [10. Спрайтовая графика](https://habr.com/ru/post/599333/)
* [11. Язык ассемблера: ветвление и циклы](https://habr.com/ru/post/599369/)
* [12. Циклы на практике](https://habr.com/ru/post/599373/)
* [13. Графика фона](https://habr.com/ru/post/599413/)
* [14. Движение спрайтов](https://habr.com/ru/post/599433/)
* [15. Скроллинг фона](https://habr.com/ru/post/599695/)
4. Оборудование NES
-------------------
Содержание:
* Консоль
* Картриджи
* Как это связано с нашим тестовым проектом?
* Цвета и палитры
* Возвращаемся к тестовому проекту
Прежде чем приступать к разбору ассемблера, начнём с обзора самой NES.
Консоль
-------
Если открыть консоль NES и посмотреть внутрь, то можно увидеть нечто подобное:
*Материнская плата NTSC-версии NES (США/Япония). Фото Эвана Эмоса.*
Внешне на материнской NES выделяются разъём для картриджей в верхней части и два больших чипа. Слева находится вот такой чип с маркировкой «RP2A03»:
*Центральный процессор/аудиопроцессор Ricoh 2A03*
А справа расположен другой чип с маркировкой «RP2C02»:
*PPU Ricoh 2C02.*
Вместе эти два чипа обеспечивают всю вычислительную мощь NES. Первый чип (2A03) — это центральный процессор (CPU, central processing unit) консоли NES. 2A03 создан на основе процессора 6502 компании MOS Technologies и дополнен его производителем Ricoh несколькими особыми возможностями.
[Когда я говорю, что 2A03 «создан на основе» 6502, то подразумеваю, что между ними есть только одно важное отличие: в 2A03 отсутствует поддержка функции, которая в 6502 называется режимом «binary coded decimal» (BCD). BCD позволяет двоичным числам, с которыми работает центральный процессор, вести себя при сложении или вычитании как десятичные числа. Электронная схема BCD в процессоре 6502 находилась в сфере действия отдельного лицензионного соглашения, стороной которого не была компания Ricoh, поэтому она не могла легально включить режим BCD в свои процессоры, несмотря вся схема работы этого режима была реализована в кремнии. Чтобы обойти эту проблему, Ricoh изготовила «полный» 6502, но перерезала все электрические соединения между участком BCD чипа и остальной частью процессора.]
Также Ricoh включила в 2A03 полный аудиопроцессор (APU, audio processing unit), обрабатывающий музыку и звуковые эффекты.
Второй чип (2C02) — это PPU консоли NES (picture processing unit, «устройство обработки изображений»). Сегодня его можно воспринимать как «графическую карту». PPU получает команды от CPU и преобразует их в выводимую на экран информацию. CPU ничего не знает о том, как работают телевизоры; всю эту обработку он оставляет на долю PPU.
Картриджи
---------
Игры для NES распространяются на пластмассовых картриджах (или Game Pak'ах, как называла их Nintendo в США). Внутри каждого картриджа находится небольшая печатная плата, выглядящая примерно так:
*Печатная плата картриджа игры *Tetris*. Фото Эвана Эмоса.*
Как и на материнской плате консоли, на печатной плате картриджа выделяются два больших чипа. Левый имеет маркировку «PRG», а правый — «CHR». PRG-ROM — это «ROM программы», он содержит весь код игры (машинный код). CHR-ROM — это «ROM символов», содержащий все графические данные игры.
[На этой плате есть два дополнительных чипа. Справа от двух основных ROM находится CIC (Checking Integrated Circuit), или [чип «блокировки»](https://en.wikipedia.org/wiki/CIC_(Nintendo)). Это защита, при помощи которой Nintendo пыталась сделать так, чтобы на NES запускались только те картриджи, которые произведены компанией. (Также чип CIC является причиной того, что игры для NES часто многократно мерцают, пока не вытащишь их из разъёма и не вставишь заново, и лучше *не подув* при этом на контакты.) Под двумя чипами ROM находится «MMC1» — контроллер управления памятью, который мы подробно рассмотрим в других главах книги.]
Контактны этих двух чипов ROM соединены с группой золотых контактов на плате картриджа. Когда картридж вставляют в разъём картриджа на консоли, золотые контакты образуют электрическое соединение с аналогичной группой контактов в консоли. В результате этого PRG-ROM электрически соединяется напрямую с процессором 2A03, а CHR-ROM напрямую соединяется с PPU 2C02.
*Схема соединения чипов ROM картриджа с процессорами консоли.*
Как это связано с нашим тестовым проектом?
------------------------------------------
Если вернуться к исходникам тестового проекта на языке ассемблера, то можно увидеть множество строк, начинающихся с `.segment`. Это *ассемблерные директивы*, о которых мы поговорим в следующей главе. Они указывают, где в готовом файле ROM должны располагаться фрагменты кода.
Два сегмента не являются непосредственно частями кода самой игры. Сегмент `STARTUP` на самом деле ничего не делает; он необходим для кода на C, компилируемого в ассемблерный код 6502, но мы его не используем. Сегмент `HEADER` содержит информацию для эмуляторов о том, какие чипы есть в картридже.
Остальные сегменты относятся к разделению PRG/CHR. `CODE` — это, разумеется, код, сохраняемый в PRG-ROM. `VECTORS` — это способ задания кода, который должен находиться в самом конце блока PRG-ROM (о причинах этого мы поговорим позже). А `CHARS` обозначает всё содержимое CHR-ROM, обычно включаемое в виде двоичного файла.
Каким же будет содержимое чипа CHR-ROM, а значит, какую графику будет отображать игра?
`.res` — это ещё одна ассемблерная директива, приказывающая ассемблеру «зарезервировать» определённый объём пустого пространства; в данном случае это 8192 байта. Но если весь CHR-ROM пуст, то откуда берётся зелёный фон в нашем тестовом проекте?
Цвета и палитры
---------------
Когда выit я сказал, что в чипе CHR-ROM содержится «вся» графика игры, я немного упростил. Если точнее, чип CHR-ROM содержит *паттерны* различных цветов, отображаемых в игре. Однако сами цвета являются частью PPU. Устройство PPU знает, как отображать фиксированный набор из 64 цветов.
[Внимательные читатели могут заметить, что на изображении с цветовой палитрой есть только 56 цветов, а не 64. Так получилось потому, что восемь из 64 цветов, известных PPU — это просто чёрный цвет. Это вызвано особенностями отображения цвета ЭЛТ-телевизорами NTSC, а не ошибка в проектировании оборудования.
*Палитра цветов NES.*
Из-за аппаратных ограничений мы не можем использовать все 64 цвета одновременно. Мы назначаем цвета восьми *палитрам* системы из четырёх цветов. Четыре таких палитры используются для «фона», а остальные четыре — для «переднего плана».
Восемь палитр имеют одно дополнительное ограничение: первый цвет каждой из этих палитр должен быть одинаковым. Этот первый цвет используется как «стандартный» цвет фона (когда в текущем пикселе на фоне ничего не отрисовывается, используется стандартный цвет), а также как цвет прозрачности для переднего плана (при отрисовке пикселей переднего плана первый цвет считается прозрачным, что позволяет пикселям фона «за» ним просвечивать). Из-за этих ограничений NES одновременно может отображать не более 25 цветов — один «стандартный» цвет и восемь палитр по три цвета каждая.
*Восемь палитр, используемых в World 1-1 игры Super Mario Bros. Верхние четыре палитры используются для переднего плана, а четыре нижние — для фона. Обратите внимание, что многие элементы переднего плана и фона составлены из одинаковых паттернов, но разных палитр, например, разноцветные черепахи на переднем плане и графика кустов/облаков на фоне. Первый голубой цвет в каждой палитре — это цвет «неба» фона в World 1-1.*
PPU обозначает каждый цвет однобайтовым числом. Информация палитр хранится в конкретном месте распределения PPU (в отдельной RAM, доступ к которой есть только у самого PPU). 32-байтная область в памяти PPU от `$3f00` до `$3f20` содержит содержимое восьми палитр. «Стандартный цвет», являющийся первым цветом палитры, хранится в `$3f00`, `$3f04`, `$3f08`, `$3f0c`, `$3f10`, `$3f14`, `$3f18` и `$3f1c`.
[Хотя первый цвет каждой палитры часто повторяют вручную, PPU интересует только значение, записанное в `$3f00`. В нашей тестовой программе это свойство используется для уменьшении объёма необходимого кода.]
Цветовая палитра NES, на которую наложены байты, которые PPU использует для обозначения каждого цвета.
Возвращаемся к тестовому проекту
--------------------------------
Посмотрев на таблицу цветов, можно заметить, что цвет фона нашего тестового проекта соответствует `$29`. Если взглянуть на код тестового проекта, то можно найти следующее:
Эта строка ассемблерного кода приказывает процессору приготовиться к использованию числа `$29`, соответствующего зелёному цвету, который мы отображаем на фоне.
В следующей главе мы подробнее расскажем о том, как работает эта строка (и бОльшая часть остального исходного кода тестового проекта).
5. Знакомство с языком ассемблера 6502
--------------------------------------
Содержание:
* Наши первые опкоды: перемещение данных
* Возвращаемся к тестовому проекту
* Завершаем разбор кода main
* Домашняя работа
Программа «Hello World», которую вы создали в Главе 3, вероятно, непохожа ни на одну из тех, что вы видели раньше: 44 строки кода, в основном состоящих из трёхбуквенных аббревиатур и чисел, и всё это только для того, чтобы поменять цвет экрана. Что же такое мы скопипастили?
Как вы могли догадаться из названия этой главы, в helloworld.asm содержится *ассемблерный* код.
[Я предпочитаю использовать для ассемблерных файлов расширение `.asm`, но это абсолютная условность. Некоторые разработчики предпочитают для ассемблерных файлов расширение `.s`. В конечном итоге, выбор за вами — ca65 ассемблирует файл с любым расширением, если содержимое является ассемблерным кодом.]
Ассемблер находится всего на один уровень абстракции выше машинного кода. Для написания ассемблерного кода требуется подробное знание набора команд процессора, но он гораздо лучше читается, чем поток байтов машинного кода. Давайте рассмотрим пример ассемблерного кода, чтобы понять, как он работает:
**Код в текстовом виде**
```
.proc main
LDX PPUSTATUS
LDX #$3f
STX PPUADDR
LDX #$00
STX PPUADDR
copy_palettes:
LDA palettes,x
STA PPUDATA
INX
CPX #$20 ; 32 colors total
BNE copy_palettes
```
### Разделение команд и данных
Трёхбуквенные слова в верхнем регистре в строках 2-6 и 9-13 называются *опкодами*. Каждое из них представляет собой команду из набора команд процессора, однако здесь мы обозначаем их не числами, а по названиям. Например, `LDA` означает «load accumulator». В этой книге мы изучим несколько десятков опкодов; всего существует 56 «официальных» опкодов ассемблера 6502.
Благодаря тому, что команды записываются короткими «словами», мы можем визуально различать команды и данные вместо того, чтобы разбирать код побайтно. Всё что находится справа от опкода — это данные, сопровождающие команду. Мы называем данные для команды *операндом*. Например, `LDX #$3f` в строке 3 — это команда «загрузить в регистр X шестнадцатеричное значение $3f». `LDX` — это опкод, а `#$3f` — операнд.
[Здесь и далее в книге я буду записывать опкоды в верхнем регистре, но это мой личный выбор. Ассемблер понимает и опкоды в нижнем регистре, а некоторые разработчики предпочитают нижний регистр. То же самое справедливо и для значений операндов — `$3f` можно записать как `$3F`.]
### Константы и метки
Разделение команд и данных — невероятно полезная вещь, но ассемблер даёт нам ещё и множество других инструментов. Операнды в строках 2, 4, 6 и 10, набранные в верхнем регистре, это *константы*, заданные в другом месте. При запуске ассемблера (ca65) он заменяет имя константы (например, `PPUSTATUS`) её значением (например, `$2002`). Создать константу можно при помощи знака равенства: `PPUSTATUS = $2002`.
Ассемблер позволяет задавать *метки* — именованные места в коде, на которые в дальнейшем можно ссылаться. В строке 8 задаётся новая метка `copy_palettes`. Метка превращается в метку благодаря двоеточию (:) после неё. В строке 13 метка используется в качестве операнда опкода `BNE`. Позже мы подробнее рассмотрим, как это работает, а пока скажем, что строка 13, по сути, повторяет заново код из строк 8-13. В процессе своей работы ассемблер заменяет метки в вашем ассемблерном коде на адреса памяти в созданном машинном коде.
### Комментарии
При помощи символа точки с запятой (;) можно добавлять в ассемблерный код *комментарии*. Всё, начиная с точки запятой и до конца строки считается комментарием и будет вырезано после обработки кода ассемблером. Комментарии позволяют напоминать себе, что делает конкретный фрагмент кода. В показанном выше примере кода комментарий присутствует в строке 12.
### Директивы ассемблера
Кроме того, ассемблерный код позволяет использовать *директивы* — команды ассемблеру, влияющие на преобразование из ассемблерного кода в машинный; они отличаются от команд процессора, в которых исполняется машинный код. Директивы начинаются с точки (.). В строке 1 нашего примера кода использована директива `.proc`, обозначающая новую лексическую область видимости (подробнее об этом мы расскажем позже). Ещё одна распространённая директива — это `.byte`, обозначающая, что последующие байты должны копироваться в машинный код в «сыром» виде, а не обрабатываться как опкоды или операнды.
Наши первые опкоды: перемещение данных
--------------------------------------
Теперь, когда мы увидели, как выглядит ассемблерный код 6502, давайте приступим к его изучению! Я разбил опкоды, которые вы изучите в этой книге, на семь основных групп. Первая группа состоит из команд, перемещающих данные между регистрами и памятью.
### Загрузка данных: `LDA`, `LDX`, `LDY`
Команды «LD» загружают данные в регистр. Напомню, что в процессоре 6502 есть три регистра, с которыми можно работать: «A», или «accumulator» («накопитель»), позволяющий выполнять математические действия, а также «X» и «Y» — «индексные регистры». `LDA` загружает данные в накопитель, `LDX` загружает данные в регистр X, а `LDY` загружает данные в регистр Y.
Существует два основных источника этих данных: загрузка из адреса памяти и загрузка конкретного значения. Используемый источник зависит от того, как вы запишете операнд для опкода. Если вы используете 16-битное значение (четыре шестнадцатеричных цифры), то опкод загрузит содержимое этого адреса памяти. Если вы используете знак решётки (#), за которым следует 8-битное значение (две шестнадцатеричных цифры), то он загрузит точное значение. Вот пример:
Эти отличающиеся форматы операндов называются *режимами адресации (addressing modes)*. Процессор 6502 может использовать одиннадцать различных режимов адресации (однако большинство опкодов пользуется только их подмножеством).
[На случай, если вам интересно, эти 11 режимов адресации называются Accumulator, Immediate, Implied, Relative, Absolute, Zeropage, Indirect, Absolute Indexed, Zeropage Indexed, Indexed Indirect и Indirect Indexed.]
Два описанных выше режима называются *абсолютным (absolute)* (передающим адрес памяти) и *непосредственным (immediate)* (передающим конкретное значение) режимами. По мере необходимости в дальнейшем мы будем узнавать дополнительную информацию о режимах адресации.
Когда написанный вами код пропускается через ассемблер, разные режимы адресации транслируются в разные элементы набора команд. `LDA $3f00` превращается в `ad 00 3f`. В наборе команд `ad` — это номер набора команд, соответствующий команде «LDA в абсолютном режиме», а $3f00 помещается в прямом порядке байтов. Однако `LDA #$3f` превращается в `a9 3f`. Здесь `a9` — это номер из набора команд, соответствующий «LDA в непосредственном режиме». Ассемблер достаточно умён, чтобы вставить правильный номер из набора команд на основании того, как вы записали операнд, поэтому вам не нужно беспокоиться о том, *какую* из команд `LDA` необходимо использовать.
### Сохранение данных: `STA`, `STX`, `STY`
Опкоды «ST» выполняют операцию, обратную опкодам «LD» — они сохраняют содержимое регистра в адрес памяти. STA сохраняет содержимое накопителя в место, заданное его операндом, STX сохраняет содержимое регистра X, а STY — содержимое регистра Y. Команды ST не могут использовать непосредственный режим, потому что невозможно сохранить содержимое регистра в число. После выполнения операции сохранения в сохранённом регистре остаётся то же значение, что позволяет сразу же сохранить то же значение регистра в другое место.
### Передача данных: `TAX`, `TAY`, `TXA`, `TYA`
Команды «T» передают данные из одного реестра в другой. Все эти регистры читаются как «передать из регистра в регистр»; например, `TAX` — это команда «передать из накопителя в регистр X». Точнее будет назвать «передачу» в этих командах «копированием», потому что после применения одной из этих команд в обоих регистрах будет находиться значение из первого регистра.
### Небольшой пример
Теперь, когда вы изучили свои первые десять опкодов (и два режима адресации), можно рассмотреть небольшой пример, в котором они используются.
Что делает этот код? Давайте разберём его построчно:
1. Во-первых, мы загружаем значение `$a7` в накопитель. `LDA` — это опкод, загружающий данные в накопитель. Знак `#` перед `$a7` означает, что мы хотим использовать непосредственный режим, поэтому в накопитель записывается непосредственно это число, а не адрес памяти.
2. Затем мы копируем значение `$a7` из накопителя в регистр Y. Теперь и A, и Y содержат одинаковое значение.
3. Наконец, мы сохраняем значение регистра Y (`$a7`) в адрес памяти `$3f00`.
Возвращаемся к тестовому проекту
--------------------------------
Теперь вы знаете достаточную долю языка ассемблера, чтобы понять, что делает основная часть тестового проекта. В частности, давайте рассмотрим часть `main`, воссозданную здесь:
Основная часть этого кода состоит из загрузок и сохранений. Мы выполняем загрузку и сохранение в адреса памяти `$2001`, `$2002`, `$2006` и `$2007`. Загружаем значения непосредственного режима `$3f`, `$00`, `$29` и `%00011110` (двоичное, а не шестнадцатеричное значение).
Присмотревшись к загрузкам в непосредственном режиме, мы заметим, что первые два — это `$3f00` — адрес в памяти PPU, где начинаются палитры, за которым следует `$29` — зелёный цвет, который мы используем в фоне. Этот код приказывает PPU сохранить `$29` по адресу `$3f00`, но как?
### Ввод-вывод с отображением в память
На NES адреса в диапазоне `$2000`-`$6000` зарезервированы для использования в качестве адресов *ввода-вывода с отображением в память* (memory-mapped I/O, MMIO). «Ввод-вывод» (I/O, input/output) — это передача данных между различными устройствами. «С отображением в память» означает, что эти интерфейсы с другими устройствами отображены в адреса памяти — иными словами, определённые адреса памяти являются не памятью, а скорее связями с другими устройствами.
Адреса памяти в нижних адресах, начиная с `$2000`, соответствуют связям с PPU.
[Если вы хотите подробнее узнать об MMIO-адресах PPU (или о любой другой теме, связанной с NES), то изучите [NESDev Wiki](http://wiki.nesdev.com/w/index.php/PPU_registers). Хоть это и не лучший ресурс для обучения, он является бесценным справочным руководством по системе, в основе которого лежат тщательные исследования его участников.]
В нашем коде используется четыре MMIO-адреса; давайте посмотрим, что делает каждый из них (вместе с именем, под которым известен каждый из адресов).
### `$2006`: PPUADDR и `$2007`: PPUDATA
ЦП NES (в котором исполняется наш код) не имеет прямого доступа к памяти PPU. Адрес памяти ЦП `$2006` позволяет коду выбрать адрес в памяти PPU, а `$2007` позволяет коду записать байт данных в этот адрес. Чтобы задать адрес, в который вы хотите выполнить запись, нужно сохранить два байта данных в `$2006` — сначала «старший» (левый) байт, за которым следует «нижний» (правый) байт. Вот как это делается в тестовом проекте:
Этот код сначала сохраняет байт `$3f` в `$2006`, а затем байт `$00` в `$2006` — иными словами, он задаёт адрес `$3f00` для любых последующих операций записи в память PPU, то есть адрес первого цвета в первой палитре.
Для сохранения данных в выбранный адрес памяти PPU нужно сохранить байт в `$2007`:
Этот код записывает байт `$29` (обозначающий зелёный цвет) в выбранный ранее адрес памяти (`$3f00`). Каждый раз, когда мы сохраняем байт в PPUDATA, адрес памяти для следующего сохранения увеличивается на единицу. Если бы следующими строками в программе были `LDA #$21`
и `STA $2007`, то байт `$21` был бы записан в адрес PPU `$3f01`, хотя мы и ничего не делали с PPUADDR.
### `$2002`: PPUSTATUS
PPUSTATUS — это MMIO-адрес только для чтения. При загрузке из `$2002` получившийся байт даёт информацию о том, что в текущий момент делает PPU. Считывание из PPUSTATUS даёт один полезный побочный эффект: оно сбрасывает «фиксатор адреса» для PPUADDR. Для полного задания адреса памяти требуется две операции записи в PPUADDR, и может так оказаться, что ваш код выполняет одну запись, но никогда не добирается до второй. При считывании из PPUSTATUS следующая операция записи в PPUADDR всегда будет считаться «старшим» байтом адреса.
В нашем тестовом проекте мы считываем («загружаем») из PPUSTATUS, а затем пытаемся записать адрес в PPUADDR.
[Этот процесс — считывание из PPUSTATUS, запись двух байтов в PPUADDR и запись байтов в PPUDATA — мы будем использовать *постоянно*. Всё, что изменяет отображаемое на экране использует этот процесс, чтобы сообщить PPU, что отрисовывать, и буквально всё в игре будет изменять отображаемое на экране. Тщательное изучение этого процесса сильно пригодится в последующих главах.]
### `$2001`: PPUMASK
Есть ещё одна задача, которую наш тестовый проект должен выполнить после того, как прикажет PPU использовать цвет `$29` в качестве первого цвета первой палитры — он должен приказать PPU начать отрисовку на экран! PPUMASK позволяет коду дать PPU команды о том, что отрисовывать, а также настроить способ отображения цветов. Хранимый в PPUMASK байт — это набор из восьми *битовых флагов*, то есть каждый бит в байте действует как переключатель определённого свойства. В таблице показано, что делает каждый бит. (Помните, что биты, составляющие байт, пронумерованы 0-7, где бит 0 — самый правый, а бит 7 — самый левый.)
| № бита | Действие |
| --- | --- |
| 0 | Включить режим градаций серого
(0: обычный цвет, 1: градации серого) |
| 1 | Включить фон с левого края (8 пикселей)
(0: скрыть, 1: показать) |
| 2 | Включить передний план с левого края (8 пикселей)
(0: hide, 1: show) |
| 3 | Включить фон |
| 4 | Включить передний план |
| 5 | Выделить красный |
| 6 | Выделить зелёный |
| 7 | Выделить синий |
Прежде чем переходить к тестовому проекту, сделаем несколько примечаний по этим опциям. Биты 1 и 2 включают или отключают отображение графических элементов самых левых восьми пикселей экрана. В некоторых играх они отключены, чтобы избежать мерцания при скроллинге, о котором мы подробнее узнаем позже. Биты 5, 6 и 7 позволяют коду «выделить» определённые цвета — сделать зелёный, зелёный или синий ярче, а остальные два цвета сделать темнее. Использование одного из битов выделения, по сути, придаёт экрану оттенок цвета. Использование всех трёх одновременно делает весь экран *темнее*, что многие игры применяют для перехода от одной области к другой.
Давайте снова взглянем на код тестового проекта. Какое значение записывает наш тестовый проект в PPUMASK?
Вот побитовое описание опций, которые мы задаём:
| № бита | Значение | Действие |
| --- | --- | --- |
| 0 | 0 | Режим оттенков серого отключен |
| 1 | 1 | Отображаются левые 8 пикселей фона |
| 2 | 1 | Отображаются левые 8 пикселей переднего плана |
| 3 | 1 | Фон включен |
| 4 | 1 | Передний план включен |
| 5 | 0 | Нет выделения красного |
| 6 | 0 | Нет выделения зелёного |
| 7 | 0 | Нет выделения синего |
Так как при записи в PPUMASK наш тестовый проект включает рендеринг фона, после этой строки отображается зелёный фон.
Завершаем разбор кода `main`
----------------------------
Наш тестовый код записал цвет в память PPU и включил рендеринг на дисплей, так что, наверное, всё готово?
Не будем торопиться. Вспомним, что ЦП получает и исполняет команды по одной за раз, непрерывно. Если код записи не будет давать процессору работу, то он продолжит считывать память (пустую) и «исполнять» её, что может привести к катастрофическим результатам. К счастью, у этой проблемы есть простое решение:
Подробнее о том, как это работает, мы узнаем позже, но, по сути, эти две строки кода создают *метку* (`forever`), а затем приказывают ЦП получать эту метку как следующую инструкцию для исполнения. ЦП входит в бесконечный цикл, и ваш проект не делает ничего, кроме отображения зелёного фона.
Итак, мы рассмотрели всё, что находится в `main` (хотя и не обсудили пока, что делают `.proc` и `.endproc`), но в целом наш разбор тестового проекта практически завершён. Далее мы узнаем о векторах прерываний и о том, как код инициализует NES при первом включении питания.
Домашняя работа
---------------
Теперь, когда вы знаете, как тестовый проект задаёт цвет фона, попробуйте изменить его, чтобы он отображал другой цвет. Ниже представлена таблица цветов из Главы 4. Не забывайте переассемблировать и перекомпоновать свой код перед открытием файла в Nintaco.
*Цветовая палитра NES.*
[Создание игр для NES на ассемблере 6502: заголовки и векторы прерываний](https://habr.com/ru/post/597887/) | https://habr.com/ru/post/596583/ | null | ru | null |
# Использование инвентори-плагинов из Ansible Content Collections в Ansible Tower
ИТ-среды становятся все сложнее и сложнее. В этих условиях для системы ИТ-автоматизации критически важно иметь актуальную информацию обо узлах, которые присутствуют в сети и подлежат обработке. В Red Hat Ansible Automation Platform этот вопрос решается через так называемые инвентори ([inventory](https://docs.ansible.com/ansible/latest/user_guide/intro_inventory.html#intro-inventory)) – списки управляемых узлов.
В своей простейшей форме инвентори представляет собой статический файл. Это идеальный вариант, когда вы начинаете работать с Ansible, но по мере расширения автоматизации, его становится недостаточно.
И вот почему:
1. Как обновлять и поддерживать в актуальном состоянии полный список контролируемых узлов, когда что-то постоянно меняется, когда рабочие нагрузки – а вслед за ними и узлы, на которых они выполняются – то возникают, то исчезают?
2. Как классифицировать компоненты ИТ-инфраструктуры, чтобы прицельно выбирать узлы для применения той или иной автоматизации?
Ответы на оба эти вопроса дает динамический инвентори ([dynamic inventory](https://docs.ansible.com/ansible/latest/user_guide/intro_dynamic_inventory.html)) – скрипт или плагин, который ищет подлежащие автоматизации узлы, обращаясь к источнику истины (source of truth). Кроме того, динамический инвентори автоматически классифицирует узлы по группам, чтобы вы могли точнее отбирать целевые системы для выполнения той или иной автоматизации Ansible.
[Инвентори-плагины](https://docs.ansible.com/ansible/latest/plugins/inventory.html#plugin-list) дают пользователю Ansible возможность обращаться к внешним платформам для динамического поиска целевых узлов и использовать эти платформы в качестве источника истины при формировании инвентори. Стандартный список источников в Ansible включает облачные платформы AWS EC2, Google GCP и Microsoft Azure, также для Ansible есть и множество других инвентори-плагинов.
Ansible Tower поставляется вместе с рядом [инвентори-плагинов](https://docs.ansible.com/ansible-tower/latest/html/userguide/inventories.html#inventory-plugins), которые работают прямо «из коробки» и помимо выше перечисленных облачных платформ обеспечивают интеграцию с VMware vCenter, Red Hat OpenStack Platform и Red Hat Satellite. Для этих плагинов достаточно предоставить учетные данные для подключения к целевой платформе, после чего их можно использовать как источник инвентори-данных в Ansible Tower.
Помимо штатных плагинов из комплекта поставки Ansible Tower есть и другие инвентори-плагины, поддерживаемые силами сообщества Ansible. С переходом на [Red Hat Ansible Content Collections](https://www.ansible.com/blog/getting-started-with-ansible-collections) эти плагины стали включаться в соответствующие коллекции.
В этом посте мы для примера разберем работу с инвентори-плагином для ServiceNow, популярной платформы управления ИТ-сервисами, в CMDB которой заказчики часто хранят сведения обо всех своих устройствах. Кроме того, CMDB может содержать полезный для автоматизации контекст, например, сведения о владельцах серверов, уровнях обслуживания (production/non-production), установленных обновлениях и окнах технического обслуживания. Инвентори-плагин Ansible умеет работать с CMDB ServiceNow и входит в состав коллекции [servicenow](https://galaxy.ansible.com) на портале [galaxy.ansible.com](https://galaxy.ansible.com).
### Git-репозиторий
Чтобы использовать в Ansible Tower инвентори-плагин из коллекции, его надо задать в качестве источника проекта. В Ansible Tower проект – это интеграция с какой-то системой управления версиями, вроде репозитория git, которую можно использовать для синхронизации не только плейбуков автоматизации, но и переменных, а также списков инвентори.
Наш репозиторий на самом деле очень простой:
```
├── collections
│ └── requirements.yml
└── servicenow.yml
```
Файл servicenow.yml содержит подробности для инвентори плагина. В нашем случае мы просто указываем таблицу в CMDB ServiceNow, которую хотим использовать. А также задаем поля, которые будут добавляться в качестве переменных узла, плюс определенную информации по группам, которые хотим создать.
```
$ cat servicenow.yml
plugin: servicenow.servicenow.now
table: cmdb_ci_linux_server
fields: [ip_address,fqdn,host_name,sys_class_name,name,os]
keyed_groups:
- key: sn_sys_class_name | lower
prefix: ''
separator: ''
- key: sn_os | lower
prefix: ''
separator: ''
```
Обратите внимание, что здесь никак не конкретизируется инстанс ServiceNow, к которому мы будем подключаться, и не задаются никакие учетные данные для подлкючения. Все это мы позднее настроим в Ansible Tower.
[Файл collections/requirements.yml](https://docs.ansible.com/ansible/latest/galaxy/user_guide.html#install-multiple-collections-with-a-requirements-file) нужен для того, чтобы Ansible Tower мог скачать нужную коллекцию и получить тем самым нужный инвентори-плагин. Иначе пришлось бы вручную устанавливать и поддерживать эту коллекцию на всех наших узлах Ansible Tower.
```
$ cat collections/requirements.yml
---
collections:
- name: servicenow.servicenow
```
После того, как мы отправили эту конфигурацию в систему контроля версий, в Ansible Tower можно создавать проект, ссылающийся на соответствующий репозиторий. В примере ниже Ansible Tower увязывается с нашим репозиторием на github. Обратите внимание на SCM URL: он позволяет прописать учетную запись для подключения к частному репозиторию, а также задать конкретную ветвь, метку или коммит для извлечения.
### Создаем credentials для ServiceNow
Как уже говорилось, конфигурация в нашем репозитории не содержит учетных данных для подключения к ServiceNow и не конкретизирует инстанс ServiceNow, с которым мы будем общаться. Поэтому для задания этих данных мы создадим credentials в Ansible Tower. Согласно [документации инвентори-плагина ServiceNow](https://github.com/ServiceNowITOM/servicenow-ansible/blob/devel/docs/inventory.md), существует ряд переменных окружения, с помощью которых мы и зададим параметры подключения, например, так:
```
= username
The ServiceNow user account, it should have rights to read cmdb_ci_server (default), or table specified by SN_TABLE
set_via:
env:
- name: SN_USERNAME
```
В этом случае, если переменная окружения SN\_USERNAME задана, то инвентори-плагин будет использовать ее как учетную запись для подключения к ServiceNow.
Еще нам надо задать переменные SN\_INSTANCE и SN\_PASSWORD.
Однако в Ansible Tower нет credentials такого типа, где можно было бы указать эти данные для ServiceNow. Зато Ansible Tower позволяет нам определять [настраиваемые типы credentials](https://docs.ansible.com/ansible-tower/latest/html/userguide/credential_types.html), подробнее об этом можно почитать в статье [«Ansible Tower Feature Spotlight: Custom Credentials»](https://www.ansible.com/blog/ansible-tower-feature-spotlight-custom-credentials).
В нашем случае input-конфигурация для настраиваемых credentials для ServiceNow выглядит следующим образом:
```
fields:
- id: SN_USERNAME
type: string
label: Username
- id: SN_PASSWORD
type: string
label: Password
secret: true
- id: SN_INSTANCE
type: string
label: Snow Instance
required:
- SN_USERNAME
- SN_PASSWORD
- SN_INSTANCE
```
Эти credentials будут экспонироваться как переменные окружения с тем же именем. Это описывается в конфигурации injector-а:
```
env:
SN_INSTANCE: '{{ SN_INSTANCE }}'
SN_PASSWORD: '{{ SN_PASSWORD }}'
SN_USERNAME: '{{ SN_USERNAME }}'
```
Итак, мы определили нужный нам тип credential, теперь можно добавить учетную запись ServiceNow и задать инстанс, имя пользователя и пароль, вот так:
### Создаем инвентори
Итак, теперь у нас все готово, чтобы создать инвентори в Ansible Tower. Назовем его ServiceNow:
После создания инвентори мы можем прикрепить к ней источник данных. Здесь мы указываем проект, который создали ранее, и вводим путь к нашему инвентори-файлу YAML в репозитории системы управления версиями, в нашем случае это servicenow.yml в корне проекта. Кроме того, надо привязать и учетную запись ServiceNow.
Чтобы проверить, как все работает, попробуем синхронизироваться с источником данных, нажав кнопку «Sync all». Если все настроено правильно, то узлы должны импортироваться в наш инвентори:
Обратите внимание, что необходимые нам группы тоже создались.
### Заключение
В этом посте мы рассмотрели, как в Ansible Tower использовать инвентори-плагины из коллекций на примере плагина ServiceNow. Мы также безопасно прописали учетные данные для подключения к нашему инстансу ServiceNow. Привязка инвентори-плагина из проекта работает не только со сторонними или настраиваемыми плагинами, но и вполне может применяться для модификации работы некоторых штатных инвентори. Благодаря этому Ansible Automation Platform легко и бесшовно интегрируется с существующими инструментами при автоматизации ИТ-сред, которые становятся все сложнее и сложнее.
Найти дополнительные сведения по рассмотренным в этом посте темам, а также по другим аспектам применения Ansible можно здесь:
* Блог по [автоматизации ServiceNow с использованием Ansible](https://www.ansible.com/blog/topic/servicenow).
* [Как создавать свои собственные коллекции](https://www.ansible.com/how-to-build-ansible-collections-experience-from-community-members).
* Список поддерживаемых Red Hat коллекций на сайте Automation Hub ([cloud.redhat.com](https://cloud.redhat.com/)).
* [Электронные книги по Ansible Automation Platform](https://www.ansible.com/resources/ebooks).
*\*Red Hat не дает никаких гарантий корректности приведенного здесь кода. Все материалы предоставляются на условиях отсутствия поддержки, если только иное на заявлено в явном виде.* | https://habr.com/ru/post/521398/ | null | ru | null |
# Выпуск Rust 1.29
Команда разработчиков Rust рада сообщить о выпуске новой версии Rust: 1.29.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.
Если у вас установлена предыдущая версия Rust с помощью Rustup, то для обновления Rust до версии 1.29.0 вам достаточно выполнить:
```
$ rustup update stable
```
Если у вас еще не установлен Rustup, вы можете [установить его](https://www.rust-lang.org/install.html) с соответствующей страницы нашего веб-сайта. С [подробными примечаниями к выпуску Rust 1.29.0](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1290-2018-09-13) можно ознакомиться на GitHub.
Что вошло в стабильную версию 1.29.0
------------------------------------
1.29 привносит не очень много изменений. Ожидается что Rust 1.30 и 1.31 будут очень значительными, так что большая часть 1.29 итерации ушла на подготовку к будущим изменениям. Два самых заметных нововведения этого выпуска даже не касаются самого языка: это две новые возможности Cargo и обе они касаются предупреждений.
* `cargo fix` автоматически исправляет предупреждения в коде
* `cargo clippy` — статический анализатор Rust кода, помогающий поймать распространенные ошибки и просто улучшить код
### `cargo fix`
С выпуском Rust 1.29 у Cargo появляется новая подкоманда: `cargo fix`. Если вы когда-либо писали на Rust, то скорее всего уже сталкивались с предупреждениями компилятора. Например, рассмотрим такой код:
```
fn do_something() {}
fn main() {
for i in 0..100 {
do_something();
}
}
```
В нем мы вызываем `do_something` сто раз, но никогда не используем переменную `i`. Rust предупреждает нас об этом:
```
> cargo build
Compiling myprogram v0.1.0 (file:///path/to/myprogram)
warning: unused variable: `i`
--> src\main.rs:4:9
|
4 | for i in 1..100 {
| ^ help: consider using `_i` instead
|
= note: #[warn(unused_variables)] on by default
Finished dev [unoptimized + debuginfo] target(s) in 0.50s
```
Видите подсказку о переименовании в `_i`? Мы можем автоматически применить ее при помощи `cargo fix`:
```
> cargo fix
Checking myprogram v0.1.0 (file:///C:/Users/steve/tmp/fix)
Fixing src\main.rs (1 fix)
Finished dev [unoptimized + debuginfo] target(s) in 0.59s
```
Если теперь мы откроем `src\main.rs`, то увидим исправленный код:
```
fn do_something() {}
fn main() {
for _i in 0..100 {
do_something();
}
}
```
Теперь в коде используется `_i`, и предупреждение больше не выдается.
Первая версия `cargo fix` исправляет далеко не все предупреждения. Для своей работы `cargo fix` использует специальный API компилятора, который предлагает исправлять только те предупреждения, в которых мы абсолютно уверены. Со временем их список будет расширяться.
### `cargo clippy`
Еще о предупреждениях: теперь вы можете попробовать `cargo-clippy` через Rustup. Clippy это статический анализатор, который выполняет много дополнительных проверок вашего кода.
Например:
```
let mut lock_guard = mutex.lock();
std::mem::drop(&lock_guard)
operation_that_requires_mutex_to_be_unlocked();
```
Синтаксически это правильный код, но мы можем получить дедлок, потому что вызвали `drop` для \_ссылки на `lock_guard`\_, а не для самого `lock_guard`. Вызов `drop` для ссылки имеет мало смысла и почти наверняка является ошибкой.
Установим предварительную версию Clippy через Rustup:
```
$ rustup component add clippy-preview
```
и запустим ее:
```
$ cargo clippy
error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
--> src\main.rs:5:5
|
5 | std::mem::drop(&lock_guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: #[deny(drop_ref)] on by default
note: argument has type &std::result::Result, std::sync::PoisonError>>
--> src\main.rs:5:20
|
5 | std::mem::drop(&lock\_guard);
| ^^^^^^^^^^^
= help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.212/index.html#drop\_ref
```
Как видно из примечания к сообщению, вы можете получить полный список всех возможных предупреждений по ссылке.
Обратите внимание, что это только ознакомительная версия; Clippy еще не достиг 1.0, поэтому набор и поведение проверок еще могут меняться. Мы выпустим компонент `clippy`, как только он будет стабилизирован, а пока просим вас посмотреть на деле предварительную версию и рассказать нам о своем опыте.
Да, есть еще нюанс: к сожалению, пока что нельзя использовать clippy вместе с `cargo-fix`. Работа над этим ведется.
Подробности смотрите [в примечаниях к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1290-2018-09-13).
### Стабилизация стандартной библиотеки
В этом выпуске были стабилизированы следующие API:
* [`Arc::downcast`](https://doc.rust-lang.org/std/sync/struct.Arc.html#method.downcast)
* [`Rc::downcast`](https://doc.rust-lang.org/std/rc/struct.Rc.html#method.downcast)
* [`Iterator::flatten`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.flatten)
Также, теперь вы можете [`сравнивать &str` и `OsString`](https://github.com/rust-lang/rust/pull/51178/).
Подробности смотрите [в примечаниях к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1290-2018-09-13).
### Улучшения в Cargo
Выше мы уже описали две новые подкоманды Cargo. Также [`Cargo теперь будет автоматически пытаться починить Cargo.lock файлы, испорченные git merge`ом](https://github.com/rust-lang/cargo/pull/5831/). Это поведение можно отключить флагом `--locked`.
`cargo doc` обзавелся новым флагом: [`--document-private-items`](https://github.com/rust-lang/cargo/pull/5543). По умолчанию, `cargo doc` документирует только публичные части API, потому что предназначен для генерации пользовательской документации. Но если вы работаете над своим пакетом и в нем есть внутренняя документация, то `--document-private-items` включит генерацию документации вообще для всего.
Подробности смотрите [в примечаниях к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1290-2018-09-13).
Разработчики 1.29.0
-------------------
Множество людей участвовало в разработке Rust 1.29. Мы не смогли бы завершить работу без участия каждого из вас. [Спасибо!](https://thanks.rust-lang.org/rust/1.29.0)
От переводчика: Благодарю [@Revertron](https://github.com/Revertron) за помощь в переводе. | https://habr.com/ru/post/423249/ | null | ru | null |
# OpenStreetMap как источник геоданных
В работе программиста иногда возникает потребность в геоданных. Для этого можно использовать OpenStreetMap (OSM). Привлекательность OSM — в возможности совершенно легально использовать качественную картографическую информацию.
Цель публикации — разобрать на рабочих примерах процесс извлечения геоданных OSM. В результате будет получен программный код (на C#), который можно собрать в Visual или Xamarin Studio, выполнить его на разных ОС (под Mono) и получить результат в форматах CSV и geoJSON. Ограничений на размер обрабатываемых OSM-данных нет (от минимального до полного). Публикация рассчитана на разработчиков ПО, без опыта работы с OSM.
#### Введение
Как самостоятельно получить ответ на вроде бы простые и понятные вопросы (просто так, для интереса):
— сколько на Земле государств, каково их население?
— где расположены на Земле города с населением, например, более миллиона человек?
— сколько на Земле вулканов?
Или (легко получить на основе примеров):
— где расположены больницы, гостиницы в вашем/чужом городе? А между городами?
— где расположены заправки, зоопарки, музеи, рестораны? Да всё что угодно.
Задачу, в общем виде, можно сформулировать примерно так — найти нужные объекты, определить их точное расположение (широту, долготу), название и другую доступную информацию.
Далее эти объекты можно отобразить, например, на карте (OSM, Google, Yandex). В публикации, для визуализации результатов, используется ([автоматическое отображение на GitHub данных в формате geoJSON](http://habrahabr.ru/post/183288/)).
#### Базовые понятия и терминология
##### Точка (node)
[Базовым элементом](http://wiki.openstreetmap.org/wiki/RU:%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B_%D0%BA%D0%B0%D1%80%D1%82%D1%8B) структуры данных OSM является точка (node) с географическими координатами — широтой (latitude) и долготой (longitude). Высота точки над уровнем моря, в настоящее время, не указывается.
Точка может быть самостоятельным объектом (светофор, киоск, родник) и, без ограничений, входить в состав других объектов (линий и отношений). Точками могут помечаться и большие объекты — страны, города и даже континенты с набором соответствующих тегов.
**Примеры точек без тегов и с тегами (XML):**
```
```
Атрибуты node:
— id — уникальный идентификатор в базе OSM (используется для way и relation);
— lat — широта, lon — долгота;
— uid и user — идентификатор и имя оператора, внёсшего изменения (используется для way и relation);
— version — версия изменения (используется для way и relation);
— timestamp — время изменения (используется для way и relation);
— changeset — номер изменения (что-то типа транзакции, которую можно применить или отменить) (используется для way и relation).
Теги:
— k=«highway» v=«motorway\_junction» — [указывает на начало съезда с дороги](http://wiki.openstreetmap.org/wiki/RU:Tag:highway%3Dmotorway_junction);
— k=«ref» v=«29» — номер съезда;
— k=«name» v=«Bar Hill» — название;
— k=«exit\_to» v=«Bar Hill B1050; Longstanton» — куда;
— k=«layer» v=«3» — уровень;
— k=«fixme» v=«What is with all the layer=3s around this junction?» — автор сделал «узелок на память».
Количество точек в OSM, в настоящее время приближается к значению, которое превышает возможности 32-битного хранения. Поэтому OSM перешёл на 64 бита (для контроля количества точек в OSM даже сделан [on-line монитор](http://textual.ru/64/)).
##### Линия (way)
Линия — это последовательности точек. Менять последовательность нельзя. Несколько линий, логически, могут представлять один объект. Например, длинная дорога состоит из нескольких линий. Линии одной дороги связаны в единое целое соблюдением условия — точка окончания одной линии строго соответствует точке начала другой линии или нескольких линий (в случае ветвления дороги или съезда на другую дорогу). Такая целостность по точкам для линий в OSM хорошо соблюдается.
Полигон — это замкнутая линия, у которой совпадают первая и последняя точки. Полигон не является самостоятельным элементом OSM. Для больших полигонов (границы государств, береговые линии), которые состоят из набора незамкнутых линий, определены правила. Например, при определении береговых линий, земля будет слева по ходу движения, вода — справа. Для административных границ явно указывается — кто слева по ходу движения, кто справа.
**Пример линии (XML):**
```
```
Атрибут ref — указывает на id точки (для получения значения координат lat, lon). Важно учитывать последовательность элементов nd.
Теги:
— k=«boundary» v=«administrative» — [административная граница](http://wiki.openstreetmap.org/wiki/RU:Tag:boundary%3Dadministrative);
— k=«admin\_level» v=«6» — уровень 6;
— k=«left:county» v=«Cambridgeshire» — кто слева;
— k=«right:county» v=«Essex» — кто справа;
— k=«source» v=«OS\_OpenData\_Boundary-Line» — ссылка на первоисточник информации.
##### Отношение (relation)
Отношение — это логическое объединение точек, линий и других отношений в единый объект.
**Пример отношения (XML):**
```
```
member — участники отношения;
type — тип объекта (node, way, relation);
ref — ссылка на id объекта;
role — роль объекта в отношении.
В данном примере описывается мультиполигон (multipolygon) — парк с внутренними областями (это могут быть, например, пруды, поляны или наоборот места с растительностью).
Примечание: далеко не все мультиполигоны так описаны.
Несмотря, на вроде-бы высокие функциональные возможности, отношения в OSM используются мало. Хотя есть попытки применять отношения к разным объектам. Например, такой сугубо точечный объект как [автобусная остановка](http://wiki.openstreetmap.org/wiki/RU:Tag:highway%3Dbus_stop), по данным внутренней статистики OSM (статистика ведётся для большинства объектов) представлен: 1572243 точками, 2479 линиями и 1140 отношениями.
##### Объекты и теги (tag)
Объект — это элемент (точка, линия, отношение) с набором тегов (атрибутов). Тег (tag) определён как k=«ключ» v=«значение». Если элемент не имеет тегов, то он не является объектом, а входит в состав других объектов (с тегами тоже может входить).
Обязательных тегов у объекта нет. Нет обязательных требований по количеству, содержанию и порядку следования тегов. Тот кто вносит данные в OSM, сам определяет состав и содержание тегов ([Перечень рекомендованных к использованию общепринятых тегов](http://wiki.openstreetmap.org/wiki/RU:%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B_%D0%BA%D0%B0%D1%80%D1%82%D1%8B)).
В разных странах, регионах или областях одинаковые объекты могут значительно различаться по составу и содержанию тегов. Например, [город (city)](http://wiki.openstreetmap.org/wiki/RU:Tag:place%3Dcity) может быть обозначен точкой или линией (полигоном). В OSM-статистике видны явные региональные предпочтения.
Города, отмеченные точками: 
Города, отмеченные линиями: 
Поэтому, прежде чем использовать новый объект, желательно его исследовать на предмет того, какие теги, фактически, в нём используются.
##### Координаты и расстояния
Точные географические измерения довольно сложны. Надо учитывать: то что Земля не является идеальным шаром, высоту над уровнем моря, рельеф, [разные модели проекций](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%BA%D0%B0%D1%80%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%86%D0%B8%D0%B9) для отображения шарообразной Земли на плоскость.
В интернет картах используется проекция [EPSG:4326 – WGS-84](http://spatialreference.org/ref/epsg/4326/), которая базируется на широте и долготе спутниковой GPS навигации. Градусы указываются в десятичном виде: широта (lat=52.2600355), долгота (lon=0.0172928).
Например, есть две точки ([вулканы на острове Тристана-да-Кунья](http://en.wikipedia.org/wiki/List_of_mountains_and_hills_of_Saint_Helena,_Ascension_and_Tristan_da_Cunha)):
1. Вулкан «Green Hill» (id=2079122352, lat=-37.1324274, lon=-12.3096104);
2. Вулкан «Red Hill» (id=2079124574, lat=-37.1200039, lon=-12.2383527).
**Оценить точность**Длина одной угловой минуты широты на поверхности Земли равна (примерно) 1852 метра — ([одна морская миля](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D1%80%D1%81%D0%BA%D0%B0%D1%8F_%D0%BC%D0%B8%D0%BB%D1%8F)). «Примерно», потому что 1852 метра это среднее значение: 1862 м. на полюсе и 1843 м. на экваторе.
Длина одного градуса широты: 1852 \* 60 = 111120 м. (Длина одного градуса долготы: 1852 \* 60 \* COS(угла широты)).
Таким образом координаты точки в OSM (0.0000001) указаны с точностью ~ 1 см.
**Вычислить расстояние между точками**Расстояние между двумя близлежащими точками (без учёта шарообразности Земли) можно вычислять по теореме Пифагора.
Расстояние между вулканами «Green Hill» и «Red Hill»:
²√((37.1324274 — 37.1200039)² + (12.3096104 — 12.2383527)²) = ²√0.00523200316154 ≈ 0.072332587 (или 0.072332587 \* 111120 ≈ 8037.6 метров)
**Перевести значения координат из десятичного вида в угловой и обратно**В угловой вид:
37.1324274 = 37°
Десятичный остаток в минуты: 0.1324274° \* 60 = 7.945644'
Десятичный остаток в секунды: 0.945644' \* 60 = 56.73864" ≈ 57"
Итого: 37.1324274° ≈ 37°07'57"
В десятичный вид:
37°07'57" = 37° + 7/60 + 57/3600 ≈ 37 + 0.11666667 + 0.01583333 ≈ 37.1325°
С учётом всех округлений, погрешность составила:
37.1325° — 37.1324274° = 0.0000726° (или 0.0000726 \* 111120 ≈ 8 метров)
#### Откуда загрузить OSM-данные
Данные OSM хранятся в базе данных (БД). На регулярной основе происходит подготовка снимка БД в XML-формате в файл [planet.osm](http://planet.openstreetmap.org/). Заархивированный bzip2 файл занимает 45Gb, в распакованном виде — более 600Gb. Кроме этого есть [зеркала planet.osm и ссылки на интернет-ресурсы](http://wiki.openstreetmap.org/wiki/RU:Planet.osm), откуда можно скачать OSM-данные порезанные по регионам.
Для примеров публикации данные взяты с сервера [geofabrik](http://download.geofabrik.de/). Данные удобно порезаны по регионам и выложены, для выгрузки, в разных форматах: Shape-файлы (shp.zip), PBF-файлы (osm.pbf), XML-файлы (osm.bz2). В примерах публикации используются XML-файлы.
При чтении XML надо учитывать:
**Высокую степень целостности XML-файлов:**Целостность означает:
— Все объекты представлены в XML-файле один раз.
— Все ссылки на id объектов будут присутствовать в XML-файле (например, при описании линии не будет ссылок на несуществующие точки).
— Если объект частично выходит за границы описываемой области, он всё-равно будет описан полностью. Поэтому в двух XML-файлах, описывающих граничные области, возникают дубликаты объектов, которые переходят из одной области в другую. Например, если дублируется relation, то дублируются и way, и node и relation, которые в него входят.
**Отличия в организации XML-данных, взятых из разных источников:**Пример следования XML-атрибутов [geofabrik](http://download.geofabrik.de/):
```
```
Пример следования XML-атрибутов [gis-lab](http://gis-lab.info/projects/osm_dump/):
```
```
**При описании линии, порядок следования точек менять нельзя:**Пример замкнутой линии (простое четырёхугольное строение):
```
```
#### Пояснения к примерам
В публикации рассматривается два примера получения данных:
1. node-объекты (страны, города с миллионным населением, вулканы);
2. way-объекты (пустыни).
Типы данных выбраны так, чтобы, после обработки полных OSM-данных, был получен понятный и наглядный контент, но, при этом, файлы результатов не были бы слишком большими и их можно было показать на карте.
**Почему не утилита?**А почему бы просто не разработать утилиту, в которой предусмотреть все возможные механизмы фильтрации и отбора OSM-данных? Идея такая была (и даже попытка её реализовать). Но ничего не вышло. Действительно, работа с OSM-XML проста. Но логика условий отбора и взаимодействия тегов объектов может быть совершенно непредсказуемой. Поэтому проще иметь, своего рода, шаблон, который легко может быть доработан для получения нужных данных. Примеры и являются такими шаблонами.
**При разработке примеров были учтены следующие требования:** 1. OSM-данные должны браться прямо из архива;
2. Данные результатов должны быть представлены в форматах CSV и geoJSON;
3. Очень хорошо, если будет обеспечена работа на любом (от минимального до полного) объёме OSM-данных;
4. Очень хорошо, если будет обеспечена очистка данных от дубликатов;
5. Очень хорошо, если будет обеспечена работоспособность на разных ОС;
6. Примеры должны быть полностью функционально-завершёнными и работоспособными.
##### Обработка OSM-файлов
OSM-XML берётся прямо из заархивированных bzip2 файлов (\*.osm.bz2). Для работы с архивом используется библиотека [SharpZipLib](http://icsharpcode.github.io/SharpZipLib/). При обработке файлов большого размера, проблем не было обнаружено.
**Последовательно обрабатываются все \*.osm.bz2 файлы во входной директории:**
```
//..
// Директории для входных и выходных файлов
//
string dirIn = @".\in\"; // где лежат файлы (*.osm.bz2)
string dirOut = @".\out\"; // куда сохранять результат
//..
// если директории для результатов нет - создать
//
if (!Directory.Exists(dirOut))
Directory.CreateDirectory(dirOut);
//..
// обработать все *.osm.bz2 файлы во входной директории
//
foreach (string fileFullName in Directory.GetFiles(dirIn, "*.osm.bz2"))
{
FileInfo fileInfo = new FileInfo(fileFullName);
using (FileStream fileStream = fileInfo.OpenRead())
{
using (Stream unzipStream = new ICSharpCode.SharpZipLib.BZip2.BZip2InputStream(fileStream))
{
XmlReader xmlReader = XmlReader.Create(unzipStream);
while (xmlReader.Read())
{
if (xmlReader.Name == "node")
OSM_ProcessNode(xmlReader.ReadOuterXml());
else if (xmlReader.Name == "way")
OSM_ProcessWay(xmlReader.ReadOuterXml());
else if (xmlReader.Name == "relation")
OSM_ProcessRelation(xmlReader.ReadOuterXml());
}
}
}
OSM_WriteResultToFiles(); // Записать данные в форматах csv и geojson
}
```
**Условия отбора объектов:**Для того, чтобы найти нужный объект, надо проанализировать все теги (Key:Value пары). Например, так определены условия отбора way-объектов (пустыни):
```
private static void OSM_ProcessWay(string xmlWay)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xmlWay);
long wayId = Int64.Parse(xmlDoc.DocumentElement.Attributes["id"].Value);
foreach (XmlNode wayTag in xmlDoc.DocumentElement.ChildNodes)
{
if (wayTag.Name == "tag" && wayTag.Attributes["k"].Value == "natural" && wayTag.Attributes["v"].Value == "desert")
{
//.. логика обработки для найденного типа
}
}
}
```
Для поиска другого объекта надо просто указать другую Key:Value пару значений или несколько пар, если одновременно надо найти несколько объектов разных типов.
**Отобранные точечные объекты сохраняются в строковые буфера:**При обработке node-объектов, отобранные данные, подготовленные в строковом виде, записываются в строковый буфер. После обработки очередного OSM-файла, буфер записывается в файлы результатов и обнуляется. Периодическая запись в файлы результатов нужна, для того, чтобы не перегружать систему (ошибки типа — out of memory).
```
// Country
//
static StringBuilder sbCsvCountry = new StringBuilder();
static StringBuilder sbGeojsonCountry = new StringBuilder();
// City
//
static StringBuilder sbCsvCity = new StringBuilder();
static StringBuilder sbGeojsonCity = new StringBuilder();
static int numPopulationCityFiltr = 1000000; // фильтр для атрибута Population (показывать города >= numPopulationCityFiltr)
// Volcano
//
static StringBuilder sbCsvVolcano = new StringBuilder();
static StringBuilder sbGeojsonVolcano = new StringBuilder();
```
В примере обработки node-объектов все way- и relation-объекты учитываются для статистики (которую можно посмотреть в журнале).
**Для сохранения линий используются структуры (в виде списков классов):**Подготовка way-объектов проходит в два этапа (фактически, два полных XML-парсинга одного и того-же файла). Сперва определяются все way-объекты. Затем, при повторном парсинге, определяются широта (lat) и долгота (lon) всех точек (node), входящих в way-объекты. Дело в том, что описание точек (node) идёт перед описанием линий (way).
```
// структуры хранения
//
class NodeAttrItem // для node-тегов (здесь только node, которые входят в way и имеют собственные теги)
{
public long NodeId = 0;
public double Lat = 0;
public double Lon = 0;
public string Type;
public string Name;
public string NameEn;
public string NameRu;
public string Attrs;
}
class WayAttrItem // для way-тегов
{
public long WayId = 0;
public string Type;
public string Name;
public string NameEn;
public string NameRu;
public string Attrs;
}
class WayToNodeItem // для определения линий
{
public long WayId = 0;
public long NodeId = 0;
public double Lat = 0;
public double Lon = 0;
}
// данные результатов хранятся в виде списков
//
static List nodeAttrList = new List();
static List wayAttrList = new List();
static List wayToNodeList = new List();
```
Фактически, когда надо выбрать много объектов (например, береговые линии, дороги), могут возникать ошибки типа «Out of memory». Для устранения таких ошибок достаточно периодически записывать полученные данные в файлы результатов (например, после обработки очередного файла).
##### CSV и geoJSON
Формат CSV компактен и удобен для записи большого количества данных, которые потом можно легко импортировать, например, в БД.
Формат geoJSON, напротив, избыточен и «многословен» по структуре, но удобен тем, что данные сразу готовы для показа на карте. В примерах, для визуализации, используется возможность GitHub по отображению геоданных (файлы с расширением geojson).
**Немного о том как реализован geojson:**
```
// Глобальный заголовок - достаточно иметь один для всего файла
//
string geojsonHeader = "{\"type\":\"FeatureCollection\",\"features\":[";
string geojsonFooter = Environment.NewLine + "{}]}";
// Заголовок для каждого нового объекта (way или node)
//
string geojsonFeatureBegin = Environment.NewLine + "{" + Environment.NewLine + "\"type\":\"Feature\"," + Environment.NewLine + "\"geometry\":";
string geojsonFeatureEnd = Environment.NewLine + "},";
// Описание node
//
string geojsonPointBegin = "{\"type\":\"Point\",\"coordinates\":";
string geojsonPointEnd = "},";
// Описание way (в данном случае Polygon)
//
string geojsonPolygonBegin = "{\"type\":\"Polygon\",\"coordinates\":[[";
string geojsonPolygonEnd = "]]}";
// Описание тегов
//
string geojsonPropBegin = Environment.NewLine + "\"properties\":{";
string geojsonPropEnd = "}";
```
Переносы строк, при подготовке geojson, используются для удобства просмотра. Иногда в OSM-XML встречаются комбинации символов, которые могут сделать geoJSON невалидным. Это происходит, когда XML-данные корректны, а, после парсинга, JSON воспринимает их как ошибку (причины ошибок приходится искать в довольно больших файлах). Например, надо исправлять двойные кавычки ["], если они встречаются в тегах. В примере двойные кавычки исправляются на одинарные [']. Или широта/долгота могут указываться как, например, «32.» (исправляется на «32.0»).
Для того, чтобы линии не терялись на карте, они помечаются точками, которые хорошо видны (в примере каждая линия помечается точечным объектом, теги которого взяты у линии — функция OSM\_WriteResultToFilesGeojson).
##### Пояснения по работе с XML
**При обращении к атрибутам указываются имена, а не индексы:**При чтении XML-элементов и XML-атрибутов желательно указывать имя, а не индекс. Это конечно немного замедляет работу, зато гарантирует от неприятных сюрпризов, например, когда OSM-данные взяты из разных источников с разным порядком атрибутов.
```
xmlDoc.DocumentElement.Attributes["lat"].Value;
xmlDoc.DocumentElement.Attributes["lon"].Value;
```
**Все теги сохраняются в CSV как Key:Value пары:**При чтении тегов объекта, XML-блок перечитывается два раза. Первый раз, чтобы определить тип объекта. Второй раз, если найден искомый объект, для того чтобы сохранить теги.
```
// первое чтение - для определения искомого объекта
//
foreach (XmlNode nodeTag in xmlDoc.DocumentElement.ChildNodes)
{
if (nodeTag.Name == "tag")
{
if (nodeTag.Attributes["k"].Value == "place" && nodeTag.Attributes["v"].Value == "country")
{
string strAttrs = "";
bool isAttr = false;
// повторное чтение - для сохранения всех тегов
//
foreach (XmlNode nodeTag in xmlDoc.DocumentElement.ChildNodes)
{
if (nodeTag.Name == "tag")
{
if (isAttr)
strAttrs += ",";
else
isAttr = true;
strAttrs += String.Format("\"{0}\":\"{1}\"", nodeTag.Attributes["k"].Value, nodeTag.Attributes["v"].Value.Replace('\"', '\''));
}
}
}
}
}
```
Полный состав тегов нужен, например, если надо проанализировать состав всех тегов по новому объекту. У некоторых объектов (большие города, страны) тегов может быть очень много. Полный состав тегов сохраняется только в CSV-файле.
#### Быстродействие и дубликаты
Факторы, которые оказывают влияние на быстродействие:
**1. Скорость чтения OSM-файла (разархивирование и парсинг XML-элементов):**Для node-объектов OSM-файл должен быть прочитан 1 раз, а для way-объектов — 2 раза.
Необходимость двойного чтения вызвана тем, что в XML-файле сперва идут node-, и только за ними way-объекты. В данном случае двойное чтение просто упрощает алгоритм, позволяя избежать применения промежуточных структур для хранения широты и долготы точек.
**2. Удаление дубликатов и установка широты и долготы для точек, входящих в way:**Чтобы не создавать дубликаты объектов и уменьшить время определения широты и долготы точек, входящих в way, используется единый механизм, основанный на применении индексных массивов. Такой подход позволяет значительно увеличить скорость обработки за счёт оптимизации поисковых операций.
В примере с пустынями (для Африки) разница во времени обработки — без индексного массива (useIndexedCheck = false) ≈ 3.5 часа, с индексным массивом (useIndexedCheck = true) ≈ 1 час. Но, если, например, надо выбрать все дороги или береговые линии на полных данных OSM, то без индексации время обработки может растянуться на дни и даже недели (чем больше количество выбранных объектов — тем больше расход времени), а с индексацией — всё время займёт немногим более суток.
Как это работает?
Если, при каждом новом парсинге node или way, знать — был ли объект с таким id уже обработан раньше?, то становится просто выявлять дубликаты.
Если быстро (без поиска) определить, что считанная точка входит в линию, то это даёт значительный выигрыш по скорости. Так как общее количество точек может быть весьма значительным (более трёх миллиардов на полных данных), то и затраты времени на поисковые операции для каждой точки (по внутренним массивам nodeAttrList, wayAttrList, wayToNodeList), с накоплением данных, превращаются в значительные. То есть — применение индексного массива помогает избавиться от «холостых» поисковых операций.
Как это организовано в коде?
Для node- и way-объектов создаются массивы размерностью не менее максимального значения id для данного объекта (для определения максимального значения id используются значения статистики). В массивах для каждого node- или way-объекта выделяется ячейка размером byte, где индекс ячейки соответствует id объекта.
```
bool useIndexedCheck = true; // использовать/не использовать индексный массив
// если не использовать (false), то при обработке более одного *.bz2 файла, на границах соседних областей могут появляться дубликаты объектов
// если использовать (true), то потребуется дополнительно > 4 GB RAM
//--
long wayIdxSize = 512 * 1024 * 1024 - 1;
byte[] wayIdx;
long nodeIdxSize = (2L * 1024 * 1024 * 1024 - 57 - 1);
byte[] nodeIdx1;
byte[] nodeIdx2;
//-- если использовать индексный массив, то потребуется дополнительно > 4 GB RAM
//
if (useIndexedCheck)
{
wayIdx = new byte[wayIdxSize + 1];
nodeIdx1 = new byte[nodeIdxSize + 1];
nodeIdx2 = new byte[nodeIdxSize + 1];
}
```
При проверке нового node или way (при парсинге XML) происходит увеличение значения в индексированной ячейке на единицу.
```
// проверка на дубликаты
//
if (useIndexedCheck)
{
if(OSM_WayIdxAdd(wayId) > 1)
return;
}
//..
// функция установки признака дупликата в индексном массиве
//
private static byte OSM_NodeIdxAdd(long nodeId)
{
if (nodeId <= nodeIdxSize)
return ++nodeIdx1[nodeId];
return ++nodeIdx2[nodeId - nodeIdxSize];
}
```
Если значение в индексированной ячейке массива больше нуля, то объект с таким id уже был считан, а само значение будет указывать на количество повторений.
```
// функция подсчёта дубликатов
//
private static long OSM_NodeIdxDuplCount()
{
long numDupl = 0;
for (long n = 0; n <= nodeIdxSize; n++)
{
if (nodeIdx1[n] > 2) numDupl++;
if (nodeIdx2[n] > 2) numDupl++;
}
return numDupl;
}
```
#### Работоспособность на разных ОС
Здесь главная заслуга разработчиков Mono (за что им уважение и благодарность).
Оба примера разработаны на Visual Studio Community 2015 под Windows 7. Далее, полученный EXE-файл и библиотека ICSharpCode.SharpZipLib.dll (как есть) были перенесены в Linux (проверялось на OpenSuse, Mint, Ubuntu под Oracle Virtual Box) и выполнялись под Mono ([последняя версия Mono](http://www.mono-project.com/download/)). Всё заработало сразу, без проблем и дополнительных настроек.
**Для возможности работы в разных ОС, в код внесено несколько доработок:**Исправление пути.
```
//..
string dirIn = @".\in\"; // где лежат файлы (*.bz2)
string dirOut = @".\out\"; // куда сохранять результат (если директории нет - создаётся автоматически)
//..
OperatingSystem os = Environment.OSVersion;
PlatformID pid = os.Platform;
if (pid == PlatformID.Unix || pid == PlatformID.MacOSX) // 0 - Win32S, 1 - Win32Windows, 2 - Win32NT, 3 - WinCE, 4 - Unix, 5 - Xbox, 6 - MacOSX
{
dirIn = dirIn.Replace(@"\", @"/");
dirOut = dirOut.Replace(@"\", @"/");
}
```
Для перехода на новую строку надо использовать Environment.NewLine.
```
string geojsonFeatureBegin = Environment.NewLine + "{" + Environment.NewLine + "\"type\":\"Feature\"," + Environment.NewLine + "\"geometry\":";
string geojsonFeatureEnd = Environment.NewLine + "},";
```
#### Примеры на GitHub
Примеры кода (шаблоны консольных программ):
[Получение node-объектов](https://github.com/apelserg/data-osm-getdata/blob/master/code/osmnode.cs)
[Получение way-объектов](https://github.com/apelserg/data-osm-getdata/blob/master/code/osmway.cs)
Примеры полученных геоданных (geoJSON):
[Все государства на Земле.](https://github.com/apelserg/data-osm-getdata/blob/master/geojson/osmnode-country.geojson)
[Все города на Земле с населением более миллиона человек.](https://github.com/apelserg/data-osm-getdata/blob/master/geojson/osmnode-city.geojson)
[Все вулканы на Земле.](https://github.com/apelserg/data-osm-getdata/blob/master/geojson/osmnode-volcano.geojson)
[Все пустыни на Земле.](https://github.com/apelserg/data-osm-getdata/blob/master/geojson/osmway-desert.geojson)
#### Ссылки
[Объекты карты (перечень рекомендованных к использованию общепринятых тегов)](http://wiki.openstreetmap.org/wiki/RU:%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B_%D0%BA%D0%B0%D1%80%D1%82%D1%8B)
[Элементы карты](http://wiki.openstreetmap.org/wiki/RU:%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B_%D0%BA%D0%B0%D1%80%D1%82%D1%8B)
[Снимок базы данных Planet.osm](http://wiki.openstreetmap.org/wiki/RU:Planet.osm)
[Схема базы данных](http://wiki.openstreetmap.org/wiki/Database)
[Модели проекций](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%BA%D0%B0%D1%80%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%86%D0%B8%D0%B9)
[Спецификация GeoJSON](https://en.wikipedia.org/wiki/GeoJSON)
[Автоматическое отображение на GitHub данных в формате geoJSON](http://habrahabr.ru/post/183288/)
[Данные на geofabrik](http://download.geofabrik.de/)
[Данные на gis-lab](http://gis-lab.info/projects/osm_dump/)
[Программы и фреймворки для работы с OSM](http://wiki.openstreetmap.org/wiki/Frameworks)
[Библиотека для работы с архивами (SharpZipLib)](http://icsharpcode.github.io/SharpZipLib/)
[Скачать Mono](http://www.mono-project.com/download/) | https://habr.com/ru/post/270513/ | null | ru | null |
# Opensource система умного дома на nodejs
Интерфейс главного менюПривет, Хабр! Хочу поделиться своим проектом, который разрабатывал почти год - [appex-system](https://github.com/andaran/appex-system).
Дело началось с того, что я закончил изучение ноды. Нужно было запилить какой-нибудь проект, чтобы потренироваться, и я решил объединить 2 любимых дела - программирование и самоделки. И вот что из этого получилось.
Умный дом делится на устройства. Устройством может быть как одна плата (например esp8266), так и несколько (люстра, состоящая из 4 умных лампочек). Для каждого устройства пишется отдельное приложение на js. Устройство в месте с приложением объединяются в комнату, наподобие группы в телеграм, где и происходит их общение.
В каждой комнате имеется объект состояния. В свойствах этого объекта хранятся все нужные для работы данные - например статус лампочки. Общение между платами и приложением происходит по протоколу web sockets. Если запускать сервер локально, то ардуина получит команду через 4 миллисекунды после нажатия кнопки в приложении - вполне не плохо)
Для примера давайте соберем умную лампочку.
-------------------------------------------
Чтобы посмотреть систему, можете использовать мой [сервер](https://www.appex-system.ru/). Если хотите поднять её на локальной машине, вот небольшая инструкция для Вас:
Локальная установка1. Ставим всё необходимое. Подробно заострять на этом внимание не буду, инфы полно в интернете. Можно почитать эти гайды: [установка mongodb](https://www.digitalocean.com/community/tutorials/how-to-install-mongodb-on-ubuntu-20-04-ru), [установка nodejs](https://www.digitalocean.com/community/tutorials/node-js-debian-9-ru).
2. Клонируем репозиторий.`git clone https://github.com/andaran/appex-system`.
3. Скачиваем необходимые пакеты. `npm i`
4. Создаем конфиг окружения. Прописываем туда пароли для сессий, базу данных, порт, настройки для smtp почты. `nano .env`
```
# .env
# application
sessionSecretKey1=**********
sessionSecretKey2=**********
database=mongodb://127.0.0.1/appex
port=3001
# smtp mailer
mailUser=appex.system@yandex.ru
mailPass=**********
mailPort=465
mailHost=smtp.yandex.ru
```
5. Собираем приложение. `npm run build`
6. Запускаем! `node appex`
Хотелось бы обратить внимание на smtp. Т.к. проект создавался для публикации в интернете, для регистрации на почту приходит код. Для отправки я использую обычный аккаунт яндекса. В конфиге нужно указать логин и пароль от него.
Ключи для сессий генерируем рандомные и забываем.
На этом установка завершена.
Для начала регистрируемся в системе. Думаю, с этим без проблем справится каждый. Далее Вам будет предложено пройти обучение. После его прохождения можно приступать к работе.
Меню проектовДля Вас уже создадутся приложение и комната к нему. Их и используем. Жмем на значок лампочки, чтобы открыть редактор кода. В нем сверху есть строка "Подключиться к комнате". При наведении на неё вылезет меню, в котором уже будут вписаны данные созданной комнаты. Можно открыть эмулятор, пожмакать на кнопку и убедиться, что всё работает.
Теперь займемся допиливанием кода. Чтобы было удобнее работать, можете нажать Alt + V. Код откроется на весь экран.
Дополним верстку приложения. В правом верхнем углу экрана будет находиться индикатор подключения лампы к сети и режим обычной лампы. Если включить этот режим, то после подачи электричества на лампу она загорится не зависимо от значения виртуального выключателя.
В .app-wrap в атрибуте data-theme укажем цвет статус бара телефона при открытии приложения. Ещё добавим готовый пресет выключателя. О пресетах написано в [документации](https://www.appex-system.ru/doc#presets) проекта.
HTML
```
[[Switch id="switch"]]
[[Icon name="faPowerOff"]]
```
Теперь напишем стили. Тут ничего необычного.
CSS
```
/* обертка приложения */
.app-wrap {
height: 100vh;
display: flex;
justify-content: center;
align-items: center;
}
/* кружок за кнопкой */
.app-button-wrap {
width: 120px;
height: 120px;
background: #c8d6e5;
border-radius: 50%;
display: flex;
justify-content: center;
align-items: center;
opacity: 0.8;
transition: .5s;
margin: auto;
}
/* кнопка */
.app-button {
width: 110px;
height: 110px;
background: white;
border-radius: 50%;
color: #c8d6e5;
display: flex;
justify-content: center;
align-items: center;
font-size: 32px;
transition: .1s;
}
/* кнопка при клике */
.app-button:active {
transform: scale(.98);
}
.center-block {
display: flex;
justify-content: center;
align-items: center;
}
.indicator {
width: 24px;
height: 24px;
border-radius: 50%;
background: #ccc;
}
#switch {
width: auto;
height: auto;
}
.tools-wrap {
position: absolute;
top: 5px;
right: 5px;
display: flex;
align-items: center;
}
.appex-preset-switch__handle {
width: 40px;
height: 24px;
}
.appex-preset-switch__handle:after {
box-shadow: none;
height: 20px;
width: 20px;
margin-left: -16px;
}
.appex-preset-switch__input:checked + .appex-preset-switch__handle {
background: #00d2d3;
}
.appex-preset-switch__input:checked + .appex-preset-switch__handle:after {
margin-right: -16px;
}
```
Теперь самое интересное - js код приложения.
1. Добавляем объект состояния с состояниями по умолчанию.
```
/* начальное состояние */
App.state = {
status: true,
isOnline: true,
autoEnable: false,
}
```
2. Определяем настройки.
```
/* настройки */
App.settings = {
awaitResponse: true,
}
```
3. Находим необходимые элементы и вешаем на них слушатели события. Новое состояние отправляется на сервер с помощью метода `App.send();`
```
/* вешаем слушатели событий */
button.addEventListener('click', () => {
App.send({ status: !App.state.status });
window.navigator.vibrate(40);
});
swtch.addEventListener('change', e => {
App.send({ autoEnable: e.target.checked });
});
```
4. Добавляем проверку на онлайн. Каждые 10 секунд меняем свойство isOnline на false. Если в течение 3 секунд лампа не опровергает это, гасим индикатор онлайна.
```
/* проверка на онлайн */
setInterval(() => {
App.send({ isOnline: false });
setTimeout(() => {
if (!App.state.isOnline) {
indicator.style.backgroundColor = '#ccc';
}
}, 3000);
}, 10000);
```
5. Подписываемся на событие обновления состояния. При приходе нового состояния меняем внешний вид всех компонентов приложения на соответствующий.
```
/* обновление состояния */
App.on('update', state => {
if (state.status) {
button.style.color = '#00d2d3';
wrap.style.backgroundColor = '#00d2d3';
} else {
button.style.color = '#c8d6e5';
wrap.style.backgroundColor = '#c8d6e5';
}
swtch.querySelector('input').checked = state.autoEnable;
if (state.isOnline) {
indicator.style.backgroundColor = '#00d2d3';
}
});
```
6. Запускаем приложение. На этом с написанием кода под него мы закончили.
```
/* запускаем приложение */
App.start();
```
Скриншот приложенияПишем код для микроконтроллера
------------------------------
В качестве микроконтроллера был взят популярный esp-01. К нему докупил такие [реле](https://aliexpress.ru/item/1005001898935382.html?algo_pvid=4b9715ab-ad5b-417e-aac9-a2a0101d0357&algo_expid=4b9715ab-ad5b-417e-aac9-a2a0101d0357-0&btsid=0b8b034116274797812615512ef138&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_) и [блок питания](https://aliexpress.ru/item/4001252926156.html?algo_pvid=63ffa007-5613-44f1-b1c9-ac4bbc732ef4&algo_expid=63ffa007-5613-44f1-b1c9-ac4bbc732ef4-10&btsid=0b8b034116274800357112148ef138&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_).
Пилим прошивку и заливаем через arduino ide.
Прошивка
```
// необходимые библиотеки
#include
#include
#include
#include
#include
#include
SocketIOclient socketIO;
/\* ---==== Настройки ====--- \*/
#define ussid "" // Имя wifi
#define pass "" // Пароль wifi
#define roomID "" // ID комнаты
#define roomPass "" // Пароль комнаты
/\* ------------------------ \*/
/\*
Я достаточно долго искал способы хранения информации в c++,
которые будут больше всего похожи на объект js (мы ведь парсим json).
std::unordered\_map - самый подходящий, т.к. из него можно вытянуть или
изменить значения свойства, название которого передано через переменную.
Это дает возможность выборочно обновлять значения во время
парсинга json`а.
[!!!] Данный список должен полностью соответсвовать
объекту App.state в коде приложения.
Также необходимо добавить свойство "lastChange" - оно показывает
время последнего обращения к комнате.
\*/
std::unordered\_map receivedState = {
{ "status", "true" },
{ "isOnline", "true" },
{ "lastChange", "0" },
{ "autoEnable", "false" }
};
bool light = LOW;
/\* ---==== Функция обновления состояния ====--- \*/
void updateParams(String messageType) {
/\*
Именно в этой функции обрабатывается новое состояние.
К сожалению, все типы данных преобразуются в строки,
но запарсить число из строки позволяют встроенные
ардуиновские методы.
\*/
String status = receivedState.at("status").c\_str();
String online = receivedState.at("isOnline").c\_str();
String autoEnable = receivedState.at("autoEnable").c\_str();
/\* включаем лампу \*/
if (status == "true" && messageType != "connectSuccess") {
light = LOW;
Serial.println("RELAY ON");
}
/\* выключаем лампу \*/
if (status == "false" && messageType != "connectSuccess") {
light = HIGH;
Serial.println("RELAY OFF");
}
/\* подтверждаем, что лампа в сети \*/
if (online == "false") {
DynamicJsonDocument doc(1024);
JsonObject sendState = doc.createNestedObject();
sendState["isOnline"] = true;
message("updateState", sendState);
}
/\* включаем лампу при режиме автовключения \*/
if (messageType == "connectSuccess" && autoEnable == "true") {
DynamicJsonDocument doc(1024);
JsonObject sendState = doc.createNestedObject();
sendState["status"] = true;
message("updateState", sendState);
}
}
/\* ---==== События ====--- \*/
void socketIOEvent(socketIOmessageType\_t type, uint8\_t \* payload, size\_t length) {
switch (type) {
case sIOtype\_DISCONNECT: {
Serial.println("[IOc] Ошибка подключения!\n");
} break;
case sIOtype\_CONNECT: {
Serial.println("[IOc] Подключено!");
// join default namespace (no auto join in Socket.IO V3)
socketIO.send(sIOtype\_CONNECT, "/");
/\*
Теперь подключаемся к комнате.
Это работает как группа в каком-нибудь мессенджере -
как только один участник напишет сообщение
(передаст обновление для объекта состояния),
это сообщение сразу же получат все другие участники
(телефоны, платы esp, можно и малину подключить).
\*/
connectToRoom();
} break;
case sIOtype\_EVENT: {
char\* json = (char\*) payload;
// парсим событие с новым состоянием
parseEvent(json);
} break;
default: {
Serial.println("[IOc] Пришло что-то непонятное :(");
hexdump(payload, length);
} break;
}
}
/\* ---==== Замудреная функция парсинга ответа от сервера ====--- \*/
void parseEvent(char\* json) {
/\* parse json \*/
String messageType = "";
String parsedParams = "";
char oldSimbool;
bool parseTypeFlag = false;
bool parseParamsFlag = false;
for (unsigned long i = 0; i < strlen(json); i++) {
if (json[i] == '{') {
parseParamsFlag = true;
parsedParams = "";
}
if (json[i] == '"') {
if (parseTypeFlag) {
parseTypeFlag = false;
} else if (messageType.length() == 0) {
parseTypeFlag = true;
}
if (parseTypeFlag) {
continue;
}
}
if (parseTypeFlag) {
messageType += json[i];
}
if (parseParamsFlag) {
parsedParams += json[i];
}
if (json[i] == '}') {
parseParamsFlag = false;
}
oldSimbool = json[i];
}
StaticJsonDocument<200> doc;
DeserializationError error = deserializeJson(doc, parsedParams);
if (error) {
Serial.print("[ERR] Ошибка парсинга json!");
} else {
/\* count quantity of params and delete unnecessary symbols \*/
String prms = "";
int prmsQuant = 1;
for (unsigned long i = 1; i < parsedParams.length() - 1; i++) {
if (parsedParams[i] == '"') { continue; }
if (parsedParams[i] == ',') { prmsQuant++; }
prms += parsedParams[i];
}
/\* put params to array cells \*/
String namesAndValues[prmsQuant];
int numberOfParam = 0;
for (unsigned long i = 0; i < prms.length(); i++) {
if (prms[i] == ',') {
numberOfParam++;
continue;
}
namesAndValues[numberOfParam] += prms[i];
}
/\* split params and values \*/
std::string prmName;
std::string prmValue;
char\* values[prmsQuant];
bool typeFlag = false;
for (int i = 0; i < prmsQuant; i++) {
typeFlag = false;
prmName = "";
prmValue = "";
for (int j = 0; j < namesAndValues[i].length(); j++) {
if (namesAndValues[i][j] == ':') {
typeFlag = true;
continue;
}
if (typeFlag) {
prmValue += namesAndValues[i][j];
} else {
prmName += namesAndValues[i][j];
}
}
/\* save changes \*/
if (receivedState.count(prmName) != 0) {
receivedState.at(prmName) = prmValue;
} else {
Serial.print("[ERR] Неизвестный параметр \"");
Serial.print(prmName.c\_str());
Serial.println("\"!");
}
}
/\* call update function \*/
updateParams(messageType);
}
}
/\* ---==== Подключение к комнате ====--- \*/
void connectToRoom() {
// данные отсылаются в json
DynamicJsonDocument doc(1024);
JsonArray array = doc.to();
// добавляем название события, в данном случае - "connectToRoom".
array.add("connectToRoom");
// добавляем id и пароль комнаты для прохождения аутентификации
JsonObject params = array.createNestedObject();
params["roomId"] = roomID;
params["roomPass"] = roomPass;
// преобразуем json в строку
String output;
serializeJson(doc, output);
// отправляем событие подключения к комнате
socketIO.sendEVENT(output);
}
/\* ---==== Отправка данных ====--- \*/
void message(String eventType, JsonObject sendState) {
// данные отсылаются в json
DynamicJsonDocument doc(1024);
JsonArray array = doc.to();
// добавляем название события, обычно это 'update'
array.add(eventType);
// добавляем id и пароль комнаты для прохождения аутентификации,
// добавляем обновленные данные
JsonObject params = array.createNestedObject();
params["roomId"] = roomID;
params["roomPass"] = roomPass;
params["params"] = sendState;
// преобразуем json в строку
String output;
serializeJson(doc, output);
// шлем событие на сервер appex
socketIO.sendEVENT(output);
}
/\* ---==== Setup ====--- \*/
void setup() {
// запускаем Serial порт
Serial.begin(9600);
Serial.setDebugOutput(false);
pinMode(RELAY, OUTPUT);
digitalWrite(RELAY, light);
Serial.println("RELAY ON");
// подключаемся к WiFi
WiFi.begin(ussid, pass);
while (WiFi.status() != WL\_CONNECTED) {
delay(300);
Serial.print(".");
}
Serial.println("\n[LOG] Wifi connected!\n");
// ip адрес устройства
String ip = WiFi.localIP().toString();
Serial.printf("[SETUP] IP adress: %s\n", ip.c\_str());
// подключаемся к серверу
socketIO.beginSSL("appex-system.ru", 443, "/socket.io/?EIO=4");
// если пришел запрос
socketIO.onEvent(socketIOEvent);
}
/\* ---==== Loop ====--- \*/
void loop() {
// слушаем сервер
socketIO.loop();
digitalWrite(RELAY, light);
}
```
Такая лампа получилась. Ниже приведу видео с демонстрацией.
Заключение
----------
Итак, данный проект предназначен для людей, которым не хватает стандартных элементов управления других сервисов для создания собственного умного устройства.
С помощью appex можно сделать пульт управления к роботу, приложение для сложного автополива, гайвер-лампы, самодельных часов с кучей датчиков на борту и т.д.
Это моя первая публикация. Если кому зайдет, могу забацать ещё статейку в продолжение темы. Например, как эту лампу к яндекс Алисе подключить.
Всем хорошего дня. | https://habr.com/ru/post/570432/ | null | ru | null |
# Как я писал Pacman'a, и что из этого получилось. Часть 1
Здравствуйте, уважаемые хабралюди!
Последние несколько месяцев, в свободное время, я занимался разработкой клона знаменитой игры Pacman для ОС Android. Как это было, и что из этого вышло я хочу рассказать.
##### Почему Pacman?
Ответ на этот вопрос достаточно прост, и, возможно, уже мелькнул в мыслях кого-то из читателей. Да, совершенно верно, это было [тестовое задание](http://habrahabr.ru/company/ZeptoLab/blog/147684/) для компании ZeptoLab. Из требований этого задания понятны и инструменты, использованные при разработке: Android NDK, C++, OpenGL.
##### Pacman: начало
Итак, решение принято, инструменты выбраны. Что дальше? Опыта работы с Android NDK нет, опыт работы с OpenGL ограничивается теорией и лабораторными работами из [курса](http://courses.graphicon.ru/) компьютерной графики 2011 года. Опыт разработки на С++ есть, но не в геймдеве. Что ж, приступим.
Первое, что я сделал, это установил Android NDK (установка подробно расписана на множестве ресурсов, как иностранных, так и рунета) и запустил несколько примеров из его поставки: во-первых пример GL2JNI, во-вторых SanAngeles. Первый выводит треугольник при помощи OpenGL ES 2.0, второй показывает 3D-ролик, собранный из примитивов, используя OpenGL ES. Код выглядит на первый взгляд жутковато. Да и на второй тоже. Собственно, отправной точкой для меня стал файл gl\_code.cpp из проекта GL2JNI.
##### Почему OpenGL ES 2.0?
Конечно, для простой 2D-игры вполне достаточно статического конвейера OpenGL ES, никаких шейдеров не надо, зачем все это? Ответ: хотелось попробовать. В лабораторных работах по компьютерной графике пощупать шейдеры не удалось, так почему бы не наверстать упущенное?
Изучение OpenGL ES 2.0 начал отсюда, с хабрахабра, с перевода статьи [All about OpenGL ES 2.x – (part 1/3)](http://db-in.com/blog/2011/01/all-about-opengl-es-2-x-part-13/). К сожалению, сейчас найти перевод не могу, возможно, автор убрал его в черновики. Автор статьи говорит об OpenGL ES 2.x применительно к iOS, но практически все то же самое верно и для Android. Дочитав первую часть на русском и поняв, что этого мало, я устремился на англоязычные ресурсы (в основном — часть 2 и 3 приведенной выше статьи, но и другие источники тоже использовал), где и почерпнул все знания по OpenGL ES 2.0, которые использовал впоследствии.
##### Настало время для скриншота
Это один из самых первых скриншотов моей будущей игры. Самыми-самыми первыми были всякие экраны, замощенные треугольниками и растаманские треугольники, причудливо меняющие цвет.
Что можно увидеть на этом, казалось бы, примитивном скриншоте? Достаточно многое:
1. Загрузка текстур. Да, это важно, это был большой шаг;
2. Карта. Она есть, на ней различаются стены, еда и пустые места;
3. GUI. В левом нижнем углу видна кнопка. Да, это была самая первая кнопка.
Подробнее о каждом пункте:
###### Загрузка текстур
Загрузка текстур в Android NDK возможна несколькими способами:
* Использовать libpng и libzip для доступа к файлам ресурсов apk напрямую;
* Использовать AAssetManager, читать файл и интерпретировать его содержимое как картинку вручную;
* Использовать jni для доступа к android.graphics.Bitmap.
Возможно, существуют еще способы, но я их не нашел. Наиболее приемлемым показался третий вариант, его я и реализовал.
**Немного кода на Java**
```
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
/*Обертка над стандартным Bitmap, с которой впоследствии будем работать через jni*/
public class PngManager
{
private AssetManager amgr;
public PngManager(AssetManager manager){
amgr = manager;
}
public Bitmap open(String path){
try{
return BitmapFactory.decodeStream(amgr.open(path));
}catch (Exception e) { }
return null;
}
public int getWidth(Bitmap bmp) {
return bmp.getWidth();
}
public int getHeight(Bitmap bmp) {
return bmp.getHeight();
}
public void getPixels(Bitmap bmp, int[] pixels){
int w = bmp.getWidth();
int h = bmp.getHeight();
bmp.getPixels(pixels, 0, w, 0, 0, w, h);
}
public void close(Bitmap bmp){
bmp.recycle();
}
}
```
**Немного кода на С++**
```
/*Контейнер для бинарных данных текстуры*/
struct Texture{
char* pixels; /*should be allocated with new[width*height*4]; RGBA*/
int width;
int height;
Texture(): pixels(NULL), width(0), height(0){}
Texture(char* p, int w, int h): pixels(p), width(w), height(h){};
~Texture(){
if(pixels){
delete[] pixels;
pixels = NULL;
}
}
};
/*Статический метод, вызываемый при инициализации нативной библиотеки. Параметры передаются через jni из Java */
void Art::init(JNIEnv* env, jint _screenWidth, jint _screenHeight, jobject _pngManager, jobject javaAssetManager){
LOGI("Art::init");
free(env);
/*Все члены - статические*/
pngManager = env->NewGlobalRef(_pngManager);
pmEnv = env;
pmClass = env->GetObjectClass(pngManager);
pmOpenId = env->GetMethodID(pmClass, "open", "(Ljava/lang/String;)Landroid/graphics/Bitmap;");
pmCloseId = env->GetMethodID(pmClass, "close", "(Landroid/graphics/Bitmap;)V");
pmGetWidthId = env->GetMethodID(pmClass, "getWidth", "(Landroid/graphics/Bitmap;)I");
pmGetHeightId = env->GetMethodID(pmClass, "getHeight", "(Landroid/graphics/Bitmap;)I");
pmGetPixelsId = env->GetMethodID(pmClass, "getPixels", "(Landroid/graphics/Bitmap;[I)V");
/*...*/
}
/*Используем jni для доступа к нашей обертке*/
Texture* Art::loadPng(const char* filename){
LOGI("Art::loadPng(%s)", filename);
Texture* result = new Texture();
jstring name = pmEnv->NewStringUTF(filename);
jobject png = pmEnv->CallObjectMethod(pngManager, pmOpenId, name);
pmEnv->DeleteLocalRef(name);
pmEnv->NewGlobalRef(png);
jint width = pmEnv->CallIntMethod(pngManager, pmGetWidthId, png);
jint height = pmEnv->CallIntMethod(pngManager, pmGetHeightId, png);
jintArray array = pmEnv->NewIntArray(width * height);
pmEnv->NewGlobalRef(array);
pmEnv->CallVoidMethod(pngManager, pmGetPixelsId, png, array);
jint *pixels = pmEnv->GetIntArrayElements(array, 0);
result->pixels = argb2rgba((unsigned int*)pixels, width, height);
result->width = width;
result->height = height;
pmEnv->ReleaseIntArrayElements(array, pixels, 0);
pmEnv->CallVoidMethod(pngManager, pmCloseId, png);
return result;
}
```
Тут стоит немного остановиться на классе `Art`. Идея этого класса со статическими методами и членами взята у [Нотча](http://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%81%D1%81%D0%BE%D0%BD,_%D0%9C%D0%B0%D1%80%D0%BA%D1%83%D1%81) (из одной из его игр с открытым исходным кодом), так же как и само имя класса. В нем хранится все, связанное с артом: текстуры, музыка, звуки и т.д. В классе есть статические методы `init(), free(), getTexture(int id)` и еще пачка всяких полезностей.
###### Карта
С самого начала разработки я думал о том, каким сделать механизм загрузки уровней. Сходу на ум приходят варианты «захардкодить» и «читать из текстового файла». Это, конечно можно, но тогда ни о какой легкой правке карт говорить не приходится. В голову приходят мысли о редакторе уровней, тем более недавно видел вкусную статью… Нет! Так за деревьями леса не видно будет. Напоминаю себе, что цель – рабочий Pacman и как можно быстрее.
Но ведь только что я научился загружать png! Пикселами разных цветов обозначим клетки стен, еды, пустого пространства, Pacman'а и т.д. А Paint вполне подойдет в качестве редактора уровней. Размер карты может варьироваться, вплоть до 32х32.
Этот подход оправдал себя на 100%. Я получил очень легко редактируемые уровни практически бесплатно.
###### GUI
Еще одной проблемой для меня был графический интерфейс пользователя. Как дать пользователю возможность нажать кнопку или сделать swipe? Как среагировать на это? Как удобно организовать программную часть? Для себя я ответил на эти вопросы самостоятельно. На диаграмме классов мой ответ выглядит примерно так:
Есть базовый абстрактный класс `IRenderable`, от которого наследуется `Control`, от которого наследуется `Label, Button, CheckBox` и `Menu` (Содержащий список `Contro`l'ов). Все остальные меню (`Pause/Game/GameOver` и т.д.) наследуются от `Menu`. Все что им нужно сделать – при создании определить список `Control`’ов (`Button, Label` и т.д.), которые появятся при активизации меню. Кроме того, они могут определить свои реакции на события (например, `GameMenu` отслеживает swipe). Метод `render()` каждый следующий класс вызывает у предыдущего.
Кроме того, есть класс `Engine`, который отвечает за глобальную логику игры. Загрузка, переключение между меню, получение сообщений о действиях пользователя и т.д. В нем есть поле `Menu* currentMenu`, которое он и запрашивает о реакции на действие пользователя. `Engine` также вызывает `Menu::onShow()`.
##### Логика игровых персонажей
В игре помимо Pacman'a присутствуют монстры-противники. Каждый из них должен уметь двигаться по лабиринту, сталкиваться со стенами, есть друг друга, в конце концов. Их логика реализована в виде конечных автоматов (StateMachine). Для унификации была выстроена иерархия:
`StupidMonster` и `CleverMonster` отличаются своим поведением, задаваемым методом `newDirectionEvent()`: `StupidMonster` ходит по лабиринту случайным образом, не обращая внимания на `Pacman`’a. `CleverMonster` гонится за `Pacman`’ом по самому оптимальному маршруту. В этом месте я фактически реализовал велосипед, который по-научному называется шаблоном проектирования [«Стратегия»](http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D0%B0%D1%82%D0%B5%D0%B3%D0%B8%D1%8F_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F))
###### Поиск оптимального пути.
Поскольку карта представлена массивом, сделать поиск пути несложно. Я реализовал слегка модифицированный [волновой алгоритм](http://ru.wikipedia.org/wiki/%D0%92%D0%BE%D0%BB%D0%BD%D0%BE%D0%B2%D0%BE%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC) с сохранением фронта волны. Поскольку двигаться по лабиринту можно лишь по 4, а не направлениям, реализация достаточно тривиальна.
В классе `CleverMonster` есть статичное поле maps, которое является массивом (размер равен размеру карты) карт. При создании первого экземпляра `CleverMonster` выделяется память под этот массив. При разрушении последнего экземпляра память очищается. Реализовано это путем подсчета количества созданных объектов.
Алгоритм поиска пути в каждый момент времени:
1. Узнать координаты Pacman’a (pX, pY);
2. Заглянуть в массив maps по координатам: maps[pX, pY];
* Если соответствующая карта еще не построена (NULL), то перейти к пункту 3;
* Иначе перейти к пункту 5
3. Создать карту такого же размера, как исходная, сохранить в maps[pX, pY];
4. С помощью волнового алгоритма заполнить созданную карту полностью, начиная с клетки (pX, pY);
5. Строить путь, исходя из карты maps[pX, pY];
Эти ухищрения нужны для того, чтобы не считать многократно одни и те же маршруты. Одними и теми же картами пользуются все умные монстры. Каждая карта строится не более одного раза. Достаточно большая часть карт не строится никогда(так как Pacman не может ходить сквозь стены).
Для карты без стен размером 20x20 клеток в худшем случае будет израсходовано 20\*20\*20\*20\*4 = 640 000 байт или 625 килобайт памяти. Реально это число гораздо меньше из-за наличия стен.
##### Итог первой части
Таким был итог почти трех недель разработки. Монстры бегают за Pacman'ом, Pacman ест еду и умеет умирать три раза. Пользователь может поставить игру на паузу, перейти на следующий уровень при победе, или вернуться в меню и выбрать другой уровень. Pacman' анимирован, монстры – нет. Об анимации Pacman'а я подробнее напишу в следующей части.
В таком виде задание было отправлено на проверку в ZeptoLab, после чего меня пригласили на собеседование. Скажу честно – ни до, ни после этого я так не волновался и не тупил на самых простейших вопросах. По моим ощущениям, это был epic fail. Мне посоветовали прочитать несколько книг по алгоритмам и С++, предложили встретиться еще раз в феврале. Об игре был отзыв HR: «Одна из лучших присланных работ». И, кстати, я все еще ищу работу.
Проект в открытом доступе на [github](https://github.com/zagayevskiy/Pacman).
~~И в Google Play Market~~ Ссылка убрана, чтобы не было рекламы в профильных хабах.
[Ссылка](http://habrahabr.ru/post/178523/) на вторую часть. | https://habr.com/ru/post/178037/ | null | ru | null |
# Организация вызова x86-процедур из EFI Byte Code
Использование технологии EFI Byte Code (сокращенно – EBC) позволяет создавать [кроссплатформенные приложения](http://habrahabr.ru/post/212363/ "Кроссплатформенная оценка графических возможностей в контексте UEFI") и драйверы, выполняемые на виртуальном процессоре, реализованном в составе firmware платформы. Архитектура этого процессора определена в спецификации Unified Extensible Firmware Interface. В идеале, EBC-программа должна взаимодействовать исключительно с ресурсами виртуальной машины, системными таблицами UEFI и другими объектами, абстрагированными от аппаратной реализации платформы. На практике, точное следование данному принципу существенно ограничивает функциональность программного продукта. Выйти из положения не потеряв кроссплатформенности можно, если использовать подпрограммы в нативном коде центрального процессора, условно получающие управление в случае детектирования заданной аппаратной платформы.
#### Постановка задачи
Рассмотрим пример чтения заданного регистра MSR (Model Specific Register) из EBC-приложения. Как известно, в системе команд x86 предусмотрена инструкция RDMSR (Read MSR), получающая в качестве входного параметра 32-битный адрес MSR в регистре ECX, и возвращающая 64-битное содержимое MSR в регистрах EDX (старшие 32 бита) и EAX (младшие 32 бита). В системе команд виртуальной машины EBC аналогичной функциональности не предусмотрено, именно поэтому требуется вызов подпрограммы в нативном коде.
Отметим, что в информационно-диагностической утилите [UEFImark x64 Edition](http://jelezo.com.ua/programmy/utilita_uefimark.html "Утилита UEFImark") инструкция RDMSR используется непосредственно, а в [UEFImark EBC Edition](http://jelezo.com.ua/programmy/uefimark_ebc_edition.html "UEFImark, EBC Edition") для этого требуется вызов нативных подпрограмм из EBC-программы.
#### Условия эксперимента
Предполагается, что до передачи управления на рассматриваемую процедуру, EBC-программа детектировала платформу x86 и установлено, что поддерживается одна из архитектур IA32 или x64. Метод детектирования выходит за рамки данной статьи, его планируется рассмотреть в последующих публикациях.
Для трансляции примеров используется FASM 1.69.50. Инструкции EBC реализованы с помощью макросов, x86 код транслируется для 64-битного режима, особенности обеспечения его совместимости с 32-битным режимом рассмотрены ниже.
##### Вызывающая процедура EBC\_Read\_MSR
```
;--- Subroutine: EBC/x86 gate for Read MSR ----------------------------------;
; Caller must verify x86 support (IA32 or x64) before call this subroutine, ;
; but this subroutine differentiate IA32/x64 internally. ;
; ;
; INPUT: R1 = Global variables pool base address ;
; R6 = MSR index (same as ECX before RDMSR instruction) ;
; OUTPUT: R3 = MSR data after Read (same as EDX:EAX after RDMSR instruction) ;
; R4-R7 can be changed ;
;----------------------------------------------------------------------------;
EBC_Read_MSR:
XOR64 R7,R7 ; R7=0
PUSH64 R7 ; Storage for output
MOVQ R7,R0 ; Address of storage = stack pointer
PUSHN R7 ; Parameter#2 = Output address
PUSHN R6 ; Parameter#1 = MSR address
MOVINW R7,1,0
CMPI32WEQ R7,4 ; R7=4 for 32-bit, R7=8 for 64-bit
MOVIQW R7,_IA32_Read_MSR ; This pointer for IA32 (native width=4)
JMP8CS Native_Gate
MOVIQW R7,_x64_Read_MSR ; This pointer for x64 (native width=8)
Native_Gate: ADD64 R7,R1 ; Add base address = R1
CALL32EXA R7
POPN R6 ; Remove Parameter#1
POPN R7 ; Remove Parameter#2
POP64 R3 ; Read R3 = Output
RET
```
**Рис. 1**. *[EBC-процедура, вызывающая x86-процедуру чтения MSR](http://alpha.hstor.org/getpro/habr/post_images/5ce/e45/7d2/5cee457d2f234907869ef1f4b46591d3.png)*
Рассмотрим последовательность операций, выполняемых вызывающей EBC-процедурой.
1. Резервирование в стеке 64-битной переменной, в которую вызываемая процедура запишет содержимое заданного регистра MSR.
2. Запись в стек второго входного параметра для вызываемой процедуры – адреса для сохранения содержимого MSR. Это адрес переменной, созданной на шаге 1.
3. Запись в стек первого входного параметра для вызываемой процедуры – адреса регистра MSR, принятого подпрограммой в регистре R6.
4. Определение натуральной разрядности с помощью EBC-инструкции MOVINW. Если ранее было установлено, что платформа x86-совместимая, то значение натуральной разрядности 4 означает IA32 (4 байта = 32 бита), 8 означает x64 (8 байт = 64 бита).
5. Выбор адреса для точки входа в вызываемую подпрограмму (в соответствии с результатами шага 4 и размещение его в регистре R7.
6. Вызов подпрограммы по адресу, полученному на шаге 5.
7. Чтение и удаление из стека ранее записанных параметров, в регистр R3 читается значение переменной, созданной на шаге 1, в которую вызываемая подпрограмма записала результат – 64-битное содержимое MSR.
Разрядность параметров, которые записываются в стек инструкциями PUSHN (Push Natural) и считываются из стека инструкциями POPN (Pop Natural) равна 32 бита для IA32 UEFI и 64-бита для x64 UEFI.
##### Вызываемые процедуры: IA32\_Read\_MSR, x64\_Read\_MSR
```
;--- Read Model-Specific Register, selected by input index --------------;
; INPUT: Parm#1 = MSR address (ECX before RDMSR), natural width 32/64 ;
; Parm#2 = Address for write output data, natural width 32/64 ;
; OUTPUT: R7 = Reserved for UEFI status ;
; QWORD at Address [Parm#2] = MSR data (EDX:EAX after RDMSR) ;
;------------------------------------------------------------------------;
IA32_Read_MSR: ; Entry point for IA32
push rbx rcx rdx
mov ecx,[rsp+16] ; ECX = Parm#1 = MSR address, assembled same as [esp+16], can use for IA32
mov ebx,[rsp+20] ; EBX = Parm#2 = Output address, assembled same as [esp+20], can use for IA32
jmp Entry_R_MSR
x64_Read_MSR: ; Entry point for x64
push rbx rcx rdx
mov rbx,rdx ; RBX=Output address (p#2), RCX=MSR address (p#1)
Entry_R_MSR:
rdmsr ; RCX=Input, EDX:EAX=Output
mov [rbx+00],eax
mov [rbx+04],edx
pop rdx rcx rbx
ret
```
**Рис. 2**. *[Вызываемая x86-процедура чтения MSR](http://habrastorage.org/getpro/habr/post_images/a78/0f1/2d4/a780f12d404240e30d85b97d8b2332bf.png)*
Рассмотрим последовательность операций, выполняемых вызываемой x86-процедурой.
1. Точка входа для IA32 (метка IA32\_Read\_MSR). Сохранение в стеке регистров EBX, ECX, EDX. Из стекового фрейма, созданного вызывающей процедурой, читаются входные параметры: адрес MSR и адрес переменной для сохранения содержимого MSR. Переход к пункту 3.
2. Точка входа для x64 (метка x64\_Read\_MSR). Сохранение в стеке регистров RBX, RCX, RDX. В регистрах RCX и RDX принимаются соответственно первый и второй входной параметры.
3. Выполнение целевой операции – чтение MSR с помощью инструкции RDMSR.
4. Сохранение прочитанного содержимого MSR по адресу, заданному вторым входным параметром.
5. Восстановление регистров EDX, ECX, EBX (для IA32) или RDX,RCX, RBX (для x64) и возврат в вызвавшую процедуру.
Посмотрев на процедуру, можно найти противоречие: ряд инструкций 64-битного режима используются для 32-битной ветви выполнения, например, инструкции PUSH и POP, оперирующие с 64-битными регистрами. Как это работает? Дело в том, что 32-битные и 64-битные формы этих инструкций кодируются одинаково, а их интерпретация зависит от режима работы процессора. Так, код 53h в 32-битном режиме соответствует инструкции PUSH EBX, а в 64-битном режиме – инструкции PUSH RBX.
Рассмотрим механизмы передачи входных и выходных параметров подпрограмм.
Для IA32 EFI входные параметры вызываемой подпрограммы передаются через стек. В рассматриваемой процедуре первый параметр находится по адресу [ESP+16]. Смещение 16 складывается из двух слагаемых: 4 байта стека используются для хранения счетчика команд EIP, что необходимо при возврате из подпрограммы, 12 байт для регистров EBX, ECX, EDX, записанных в стек инструкцией PUSH. 4+12=16.
Для x64 UEFI четыре первых входных параметра вызываемой подпрограммы передаются через регистры RCX, RDX, R8, R9, последующие – через стек. В нашем примере используются только два параметра, передаваемые в RCX и RDX.
Для IA32 UEFI, содержимое 32-битного x86-регистра EAX после возврата из x86-подпрограммы, находится в 32 младших битах 64-битного EBC-регистра R7. Содержимое старших 32 бит R7 не определено. Для x64 UEFI, содержимое 64-битного x86-регистра RAX после возврата из x86-подпрограммы, находится в EBC-регистре R7. Данная функциональность удобна для передачи статусных кодов, в рассмотренном примере не используется.
Описанная технология применяется не только для вызова процедур, входящих в состав приложения, но и при обращении к UEFI API, обработка которых реализована в firmware. Например, при использовании функций [CPU Architectural Protocol](https://ru.intel.com/business/community/index.php?automodule=blog&blogid=59442&showentry=4648 "EFI Byte Code и управление временем") и [File I/O Protocol](https://ru.intel.com/business/community/index.php?automodule=blog&blogid=59442&showentry=4641 "Файловые операции в UEFI").
#### Резюме
Применять описанный метод следует только тогда, когда требуется обеспечить функциональность, недостижимую в рамках [EFI Byte Code](http://habrahabr.ru/post/214119/ "EFI Byte Code и операции с памятью"). Так, в информационно-диагностической утилитой [UEFImark EBC Edition](http://jelezo.com.ua/skrinshoty/utilita_uefimark_ebc_edition.html) для отображения модели процессора и списка поддерживаемых технологий используется инструкция CPUID в нативном коде.
Важно отметить, что любой непосредственный доступ к аппаратным ресурсам усложняет обеспечение кроссплатформенности. В частности, несмотря на то, что в выше приведенных примерах есть возможность различать x86-платформы IA32 и x64, до передачи управления приложение должно убедиться, что работает именно на платформе x86. Выполнение на ARM или Itanium приведет к непредсказуемым последствиям из-за различий в системе команд центрального процессора. | https://habr.com/ru/post/216413/ | null | ru | null |
# Основы Clojure Web Applications
Сегодня я попробую показать основы создания веб приложений на языке Clojure. Здесь не будет сложной логики и модных фреймворков. Будет использоваться ряд библиотек для работы с примитивами. По мере упоминания я попробую в двух словах объяснить, какой функционал они предоставляют.
Архитектура веб-приложений в примитивах состоит из веб-сервера, который направляет запросы на обработчики в зависимости от пути, параметров, метода. Обработчик выполняет определенный код, делает запросы к базе данных, работает с файловой системой. После обработки запроса, генерируется ответ и отсылается клиенту.
Наше приложение будет принимать через форму одно значение, брать из базы данных второе, складывать их, а результат отдавать клиенту. При этом введенное значение будет заменять старое в базе данных. Глупая, бесполезная и не интересная логика — я знаю.
Для разработки приложения на Clojure нам понадобится, разумеется, Clojure и ряд вспомогательных библиотек. Первым делом качаем ~~Cloj~~, ВНЕЗАПНО, [Leiningen](https://github.com/technomancy/leiningen/). Действительно, чтобы писать на Clojure, можно не устанавливать сразу Clojure, а скачать Leiningen. Это утилита для сборки проектов на Clojure с поддержкой обычного ряда задач, включая зависимости, и расширяемая плгинами. За подробностями отправляю на [страницу проекта](https://github.com/technomancy/leiningen/) или к [Алексу Отту](http://alexott.net/ru/clojure/ClojureLein.html).
Итак, приступим:
```
D:\dev\clojure>lein new web-clojure-demo
Created new project in: D:\dev\clojure\web-clojure-demo
```
Что же только что произошло? Leiningen создал папку проекта со следующей иерархией:
```
src/
web_clojure_demo/
core.clj
test/
web_clojure_demo/
test/
core.clj
.gitignore
README
project.clj
```
В первую очередь нас интересует файл project.clj. Структурно, он содержит обычный исходний код на Clojure:
```
(defproject web-clojure-demo "1.0.0-SNAPSHOT"
:description "FIXME: write description"
:dependencies [[org.clojure/clojure "1.2.1"]])
```
Leiningen использует содержимое этого файла для работы с проектом. Есть возможность указания различных директив, о которых можно почитать в документации. Нас в первую очередь интересует раздел зависимостей. В нем можно указать библиотеки, которые используются в приложении. При выполнении комманды *lein deps*, Leiningen самостоятельно поместит все зависимости в папку lib/, а в случае необходимости, скачает их из репозитория.
Мы будем использовать ряд библиотек, которые нужно указать в разделе *:dependencies*:
* [clojure-contrib](https://github.com/richhickey/clojure-contrib/) — содержит различный полезный функционал, не вошедший в состав стандартной библиотеки языка: функции для работы со строками и потоками ввода/вывода, дополнительные функции для работы с коллекциями, монады и т.д.
* [ring](https://github.com/mmcgrana/ring) — библиотека, предоставляющая ряд абстракций над HTTP.
* [compojure](https://github.com/weavejester/compojure/) — содержит набор макросов и функций для создания веб-приложений. Является оберткой над ring.
* clj-redis — клиентская библиотека для Redis. В данном примере я буду использовать это NoSQL хранилище. Для реляционных решений советую посмотреть в сторону ClojureQL.
* [enlive](https://github.com/cgrand/enlive) — библиотека для создания HTML ответа клиенту. Примечательна тем, что полностью выносит логику из шаблонов.
Для отладки приложения нам понадобится плагин к Leiningen. Просто добавьте в project.clj еще одну секцию *:dev-dependencies*.
Теперь он выглядит вот так:
```
(defproject web-clojure-demo "1.0.0-SNAPSHOT"
:description "FIXME: write description"
:dependencies [[org.clojure/clojure "1.2.1"]
[org.clojure/clojure-contrib "1.2.0"]
[ring/ring-jetty-adapter "0.2.5"]
[compojure "0.6.2"]
[clj-redis "0.0.9"]
[enlive "1.0.0-SNAPSHOT"]]
:dev-dependencies [[lein-ring "0.4.0"]]
:ring {:handler web-clojure-demo.core/engine})
```
Далее откроем файл *src/web\_clojure\_demo/core.clj*. Пока он содержит только объявление пространста имен. Добавим в него необходимые зависимости и следующий код:
```
(ns web-clojure-demo.core
(:use compojure.core)
(:use [ring.adapter.jetty :only [run-jetty]])
(:use [ring.util.response])
(:require [compojure.route :as route]
[compojure.handler :as handler]
[clj-redis.client :as redis]
[net.cgrand.enlive-html :as html]))
(def db (redis/init {:url "redis://127.0.0.1:6379"}))
(defn parse-input [a]
(Integer/parseInt a))
(html/deftemplate page-index "web_clojure_demo/index.html" [ctxt]
[:title] (html/content "Awesome application")
[:#old] (html/content (:old ctxt))
[:#msg2] (html/set-attr "style" "display: none"))
(html/deftemplate page-summary "web_clojure_demo/index.html" [ctxt]
[:title] (html/content "Awesome application")
[:#old] (html/content (:old ctxt))
[:#msg2] (html/content (str "Summary is " (:sum ctxt))))
(defn summary [value]
(let [old (redis/get db "value")]
(redis/set db "value" value)
(page-summary { :sum (+ (parse-input value) (parse-input old))
:old old})))
(defn index []
(let [old (redis/get db "value")]
(page-index {:old old})))
(defroutes main-routes
(GET "/" [] (index))
(POST "/some_action" [value] (summary value))
(route/not-found "Page not found"))
(def engine
(handler/site main-routes))
```
Рядом поместим шаблон *index.html*:
```
Old value:
```
Как вы заметили, он не содержит никаких специальных тегов.
Далее через консоль нужно обновить зависимости и запустить отладочный веб-сервер:
```
D:\dev\clojure\web-clojure-demo>lein deps
Copying 19 files to D:\dev\clojure\web-clojure-demo\lib
Copying 17 files to D:\dev\clojure\web-clojure-demo\lib\dev
D:\dev\clojure\web-clojure-demo>lein ring server
2011-03-31 22:23:25.125::INFO: Logging to STDERR via org.mortbay.log.StdErrLog
2011-03-31 22:23:25.125::INFO: jetty-6.1.14
2011-03-31 22:23:25.203::INFO: Started SocketConnector@0.0.0.0:3000
Started server on port 3000
```
Если вернуться к project.clj, можно заметить, что мы добавили аттрибут *:ring {:handler web-clojure-demo.core/engine}*. Он позволяет внутреннему веб-серверу Leiningen во время тестирования приложения направлять все запросы нашему обработчику. Это очень удобно, поскольку этот плагин Leiningen использует несколько заглушек, которые, например, позволяют обновлять исходный код без перезагрузки веб-сервера.
Давайте разберемся, что же происходит внутри.
```
(def db (redis/init {:url "redis://127.0.0.1:6379"}))
```
Этот код получает содинение с хранилищем Redis. Переменную db мы будем дальше использовать для работы.
```
(defroutes main-routes
(GET "/" [] (index))
(POST "/some_action" [value] (summary value))
(route/not-found "Page not found"))
(def engine
(handler/site main-routes))
```
Этот код определяет обработчики различных запросов. В данном случае используются библиотеки compojure. Макрос *site* создает функцию-хендлер, которая поддерживает необходимый функционал для работы типичных сайтов — сессии, куки, параметры и др. В *main-routes* указан список радичных запросов и функции-обработчики. В случае, если ниодин из обработчиков не подходит, срабатывает *not-found*.
```
(defn index []
(let [old (redis/get db "value")]
(page-index {:old old})))
(defn summary [value]
(let [old (redis/get db "value")]
(redis/set db "value" value)
(page-summary { :sum (+ (parse-input value) (parse-input old))
:old old})))
```
Это функции, которые обрабатывают наши запросы. Первая из них берет значение в базе и вызывает функцию генерации ответа из шаблона, вторая складывает имеющееся в базе значение и переданное и также вызывает генерацию ответа.
```
(html/deftemplate page-index "web_clojure_demo/index.html" [ctxt]
[:title] (html/content "Awesome application")
[:#old] (html/content (:old ctxt))
[:#msg2] (html/set-attr "style" "display: none"))
(html/deftemplate page-summary "web_clojure_demo/index.html" [ctxt]
[:title] (html/content "Awesome application")
[:#old] (html/content (:old ctxt))
[:#msg2] (html/content (str "Summary is " (:sum ctxt))))
```
Макрос deftemplate создает функцию, которая принимает параметр *ctxt*, загружает html-шаблон и преобразует в соответствии с заданными правилами, в нашем случае это задание содержимого или изменение стилей. Библиотека Enlive позволяет производить куда более интересные манипуляции с html.
Вот как выглядит работа нашего приложения:
Oops!
Исправим это недоразумение. Отредактируем код:
```
(html/deftemplate page-summary "web_clojure_demo/index.html" [ctxt]
[:title] (html/content "Awesome application")
[:#old] (html/content (:old ctxt))
[:#msg2] (html/content
(if (:error ctxt)
(:error ctxt)
(str "Summary is " (:sum ctxt)))))
(defn summary [value]
(let [old (redis/get db "value")]
(try
(let [ a (parse-input value) b (parse-input old)]
(redis/set db "value" value)
(page-summary { :sum (+ a b)
:old old}))
(catch NumberFormatException e
(page-summary {:old old :error "Number Format Exception"})))))
```
Теперь наше приложение корректно обрабатывает неподходящие данные. В случае ошибки, клиенту будет показано сообщение.
#### Заключение
Если я плохо осветил какую-либо часть, просьба сообщить мне об этом — статью дополню. В случае вопросов, просьба не стесняться. Здоровая и не очень критика также приветствуется.
Исходные коды этого примера можно найти в [репозитории](https://github.com/kondratovich/web-clojure-demo). | https://habr.com/ru/post/116595/ | null | ru | null |
# Управляем Windows пультом от телевизора или как передать сигналы через последовательный порт
Решил я , что хочу переключать громкость звука и аудио треки на ноутбуке под Windows с инфракрасного пульта. Под руку тут же попали: ардуино уно, кучка проводов с макетной платой, инфракрасный датчик, ноутбук и, собственно, инфракрасный пульт.
Идея есть, железо есть, а вот теория хромает. Как заставить компьютер понимать инфракрасные сигналы пульта и выполнять требуемые действия? Я надумал использовать ардуино для приема сигналов пульта через инфракрасный датчик на макетной плате и посылать сообщения в ноутбук через USB. Для этого требовались хоть какие то познания, как все это работает.
Было решено разобраться.
Знакомим ардуино с пультом
--------------------------
Для приема сигнала от инфракрасного пульта необходим приёмник, который мы подключим к ардуино через макетную плату по следующей схеме:
кодировка сигнала по протоколу NECДля того, чтобы ардуино понимала, по какому протоколу и с какой командой передается сигнал, существует библиотека IRremote, которую в новых версиях Arduino IDE можно добавить из стандартных библиотек.
[Сама библиотека](https://github.com/Arduino-IRremote/Arduino-IRremote)
Моим желанием было научиться менять громкость звука компьютера и управлять медиа (пауза/ переключение треков). Для этого необходимо 5 кнопок пульта.
Для того, чтобы понять, какую информацию нам передает пульт, необходимо воспользоваться командой IrReceiver.decodedIRData.decodedRawData. На мониторе порта мы увидим подробную информацию о том, что содержит сигнал. Здесь нас интересует значение команд. Каждая кнопка пульта содержит свою команду, их мы и будем использовать для управления медиа. Прощёлкав все интересующие нас кнопки и записав коды команд, мы можем написать следующее:
```
#include
int IR\_RECEIVE\_PIN = 2; // Получаем сигнал на 2-ой пин
long command;
void setup()
{
Serial.begin(9600);
IrReceiver.begin(IR\_RECEIVE\_PIN, ENABLE\_LED\_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) // Расшифровываем последовательность сигналов пульта
{
command = IrReceiver.decodedIRData.decodedRawData; /\* Проверяем какие комманды пульта
соответствуют нужным нам кнопкамм\*/
switch(command) //Задаем действия в соответствии с полученным провеяремым сигналом
{
case 0xEA15FF00:
Serial.write("D"); delay(120);
break;
case 0xB946FF00:
Serial.write("U"); delay(120);
break;
case 0xBF40FF00:
Serial.write("P"); delay(120);
break;
case 0xBC43FF00:
Serial.write("N"); delay(120);
break;
case 0xBB44FF00:
Serial.write("R"); delay(120);
break;
}
IrReceiver.resume(); // Продолжаем получать сигналы
}
}
```
Данный код сравнивает команды в принимаемом сигнале пульта с командами нужных нам кнопок, и если нужная кнопка была нам нажата, отправляет сообщение по USB.
Управление воспроизведением и громкостью Windows
------------------------------------------------
Как управлять громкостью и медиа Windows, я [нашел в этом посте](https://habr.com/ru/post/417303/?_ga=2.104404928.1711870870.1616175641-1476405791.1580044911).
Управление можно осуществлять с помощью виртуальных кодов - имитации действий клавиатурой и мышью. Я использовал С++ и Visual Studio так как там есть удобная для этой задачи библиотека Windows.h
Для того, чтобы программа имитировала нажатие клавиш, необходимо использовать функцию SendInput и написать следующее:
```
INPUT Input = { 0 };
Input.type = INPUT_KEYBOARD;
Input.ki.wVk = VK_VOLUME_UP; /* Пишем здесь нужный нам виртуальный код,
который мы хотим имитировать*/
SendInput(1, &Input, sizeof(Input));
ZeroMemory(&Input, sizeof(Input));
```
Нас интересуют следующие коды: увеличение и уменьшение громкости (VK\_VOLUME\_UP, VK\_VOLUME\_DOWN); проигрывание и пауза медиа (VK\_MEDIA\_PLAY\_PAUSE); "перелистывание" медиа (VK\_MEDIA\_NEXT\_TRACK, VK\_MEDIA\_PREV\_TRACK)
[Полный набор виртуальных кодов доступен здесь](https://docs.microsoft.com/ru-ru/windows/win32/inputdev/virtual-key-codes?redirectedfrom=MSDN).
Что такое Serial port и как с этим бороться?
--------------------------------------------
Ардуино уно передает сигналы компьютеру через USB, эмулируя последовательный порт (Serial port), который в Windows называется COM порт, как дань памяти старым последовательным портам IBM PC. Для того, чтобы получить сообщение от ардуино и выполнить какое то действие в зависимости от сообщения, необходима программа. Функции работы с последовательным портом также есть в библиотеке Windows.h
```
#include
#include
#include
int main(void)
{
HANDLE Port;
BOOL Status;
DCB dcbSerialParams = { 0 };
COMMTIMEOUTS timeouts = { 0 };
DWORD dwEventMask;
char ReadData;
DWORD NoBytesRead;
bool Esc = FALSE;
Port = CreateFile(L"\\\\.\\COM3", GENERIC\_READ, 0, NULL, // Открываем последовательный порт
OPEN\_EXISTING, 0, NULL);
if (Port == INVALID\_HANDLE\_VALUE)
{
printf("\nError to Get the COM state\n");
CloseHandle(Port);
}
else
{
printf("\nopening serial port is succesful\n");
}
dcbSerialParams.DCBlength = sizeof(dcbSerialParams);
Status = GetCommState(Port, &dcbSerialParams); // Принимаем существующие настройки порта
if (Status == FALSE)
{
printf("\n Error to Get the COM state \n");
CloseHandle(Port);
}
dcbSerialParams.BaudRate = CBR\_9600; // Задаем настройки порта
dcbSerialParams.ByteSize = 8;
dcbSerialParams.StopBits = ONESTOPBIT;
dcbSerialParams.Parity = NOPARITY;
Status = SetCommState(Port, &dcbSerialParams);
if (Status == FALSE)
{
printf("\n Error to Setting DCB Structure \n ");
CloseHandle(Port);
}
timeouts.ReadIntervalTimeout = 10; /\* Задаем временные интервалы приема сигналов
с порта (я их от балды поставил) \*/
timeouts.ReadTotalTimeoutConstant = 200;
timeouts.ReadTotalTimeoutMultiplier = 2;
if (SetCommTimeouts(Port, &timeouts) == FALSE)
{
printf("\n Error to Setting Timeouts");
CloseHandle(Port);
}
while (Esc == FALSE)
{
Status = SetCommMask(Port, EV\_RXCHAR);
if (Status == FALSE)
{
printf("\nError to in Setting CommMask\n");
CloseHandle(Port);
}
Status = WaitCommEvent(Port, &dwEventMask, NULL); /\* Задаем ожидание события
(поступления сообщения в порт) \*/
if (Status == FALSE)
{
printf("\nError! in Setting WaitCommEvent () \n");
CloseHandle(Port);
}
Status = ReadFile(Port, &ReadData, 3, &NoBytesRead, NULL); // Считываем сообщение
printf("\nNumber of bytes received = % d\n\n", sizeof(ReadData) - 1);
switch (ReadData) /\* В зависимости от сообщения
симулируем нажатие медиа клавиш \*/
{
case 'U':
{
INPUT Input = { 0 };
Input.type = INPUT\_KEYBOARD;
Input.ki.wVk = VK\_VOLUME\_UP;
SendInput(1, &Input, sizeof(Input));
ZeroMemory(&Input, sizeof(Input));
}
break;
case 'D':
{
INPUT Input = { 0 };
Input.type = INPUT\_KEYBOARD;
Input.ki.wVk = VK\_VOLUME\_DOWN;
SendInput(1, &Input, sizeof(Input));
ZeroMemory(&Input, sizeof(Input));
}
break;
case 'P':
{
INPUT Input = { 0 };
Input.type = INPUT\_KEYBOARD;
Input.ki.wVk = VK\_MEDIA\_PLAY\_PAUSE;
SendInput(1, &Input, sizeof(Input));
ZeroMemory(&Input, sizeof(Input));
}
break;
case 'N':
{
INPUT Input = { 0 };
Input.type = INPUT\_KEYBOARD;
Input.ki.wVk = VK\_MEDIA\_NEXT\_TRACK;
SendInput(1, &Input, sizeof(Input));
ZeroMemory(&Input, sizeof(Input));
}
break;
case 'R':
{
INPUT Input = { 0 };
Input.type = INPUT\_KEYBOARD;
Input.ki.wVk = VK\_MEDIA\_PREV\_TRACK;
SendInput(1, &Input, sizeof(Input));
ZeroMemory(&Input, sizeof(Input));
}
break;
default:
printf("\n Error\n");
break;
}
PurgeComm(Port, PURGE\_RXCLEAR); // Очищаем порт от всякого мусора
}
CloseHandle(Port); /\* Закрываем порт при завершении работы программы,
чтобы дргуие программы могли получить к нему доступ \*/
}
```
Информацию по работе с последовательными порта я [нашел здесь](https://ru.wikibooks.org/wiki/COM-%D0%BF%D0%BE%D1%80%D1%82_%D0%B2_Windows_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)#%D0%9E%D1%82%D0%BA%D1%80%D1%8B%D1%82%D0%B8%D0%B5_%D0%BF%D0%BE%D1%80%D1%82%D0%B0).
<https://www.xanthium.in/Serial-Port-Programming-using-Win32-API>
<http://citforum.ru/hardware/articles/comports/>
Итог
----
Теперь моей лени нет предела, мне не нужно дотягиваться до ноутбука, чтобы переключить трек или ролик на ютубе. Не зря говорят: Лень - двигатель прогресса.
У подобной комбинации (пульт + виртуальные коды) есть потенциал в управлении разными частями ОС. Например, можно назначить на кнопки запуск программ или сделать из пульта что-то вроде контроллера. Но самое удобное, на мой взгляд, это управление медиа. | https://habr.com/ru/post/555728/ | null | ru | null |
# Как я портирую код с помощью Hebron
Введение.
---------
В своей [предыдущей статье](https://habr.com/ru/post/686578/) я упомянул [Hebron](https://github.com/HebronFramework/Hebron) - утилиту для портирования кода с C на C# или на Rust.
В этой статье хотелось бы подробно расписать - как я с ней работаю.
Написанное можно воспринимать как своего рода мануал на тот случай, если кто-нибудь тоже захочет что-нибудь портануть.
Итак, портирование осуществляется в 4 шага:
Первый шаг: работа Hebron.
--------------------------
Hebron - это обычная Class Library и для работы с ней необходимо написать приложение на .NET.
К примеру, вот так выглядит соответствующее приложение, портирующее StbImageSharp: [ссылка на Github](https://github.com/StbSharp/StbImageSharp/blob/master/generation/StbImageSharp.Generator/Program.cs).
Непосредственно, обращение к Hebron осуществляется в этой строке:
`var result = RoslynCodeConverter.Convert(parameters);`
parameters содержат путь к исходному файле, о том с какими #defines его препроцессить, какие функции пропускать при портировании и т.д.
result - объект класса [RoslynConversionResult](https://github.com/HebronFramework/Hebron/blob/master/src/Hebron/Roslyn/RoslynConversionResult.cs). Он содержит набор Dictionary для каждого типа экспортируемого объекта(перечисления, делегаты, структуры, функции и т.д.): ключом является имя объекта, а значением сгенерированный код на C#.
После обращение к Hebron, приложение пишет код по разным файлам так, что каждому формату картинок соответствует свой файл: код связанный с загрузкой Png пишется в [StbImage.Generated.Png.cs](https://github.com/StbSharp/StbImageSharp/blob/master/src/StbImage.Generated.Png.cs), Jpg - в [StbImage.Generated.Jpg.cs](https://github.com/StbSharp/StbImageSharp/blob/master/src/StbImage.Generated.Jpg.cs) и т.д.
Однако, к сожалению, сгенерированный код сходу не компилируется из-за синтаксических ошибок. Поэтому требуется второй шаг.
Второй шаг: ручные правки.
--------------------------
Для начала я форматирую в Visual Studio все сгенерированные файлы(Ctrl-A, Ctrl-K, Ctrl-F), чтобы они стали более читаемыми. Затем приступаю к правке синтаксических ошибок.
Это долгий и сложный процесс, где приходится много превозмогать. Поскольку часто попадаются такие ошибки перед которыми хочется просто развести руками.
Часто приходится вносить правки в оригинальный исходный файл: вникать в логику оригинального кода и переписывать её таким образом, чтобы Hebron таки смог переварить изменённый код.
Впрочем, о том какие различия между C и C# вызывают больше всего боли при портировании я планирую запилить отдельную большую статью с примерами кода.
Третий шаг: фикс багов.
-----------------------
Когда новая библиотека начинает компилироваться, то я обычно пишу какое-нибудь простенькое тестовое приложение, чтобы протестировать новый проект.
Если он работает не так, как оригинал, то приходится разбираться в чём заключается проблема. Т.е. запускать две студии: в одной дебажить новую библиотеку, а в другой - оригинал. И дебаггерские шаг за шагом находить расхождения в логике.
Порой на этой требуется не меньше времени и превозмогания, чем на фикс синтаксических ошибок.
К примеру, однажды я потратил много времени на поиск бага в [StbVorbisSharp](https://github.com/StbSharp/StbVorbisSharp).
Проблема оказалась в файле [StbVorbisSharp.Generated.cs](https://github.com/StbSharp/StbVorbisSharp/blob/master/src/StbVorbis.Generated.cs), в строке:
`int book = g->subclass_books[pclass * 8 + (cval & csub)];`
cval & csub не были окружены скобочками. Из-за чего это выражение считалось не так, как надо.
Наконец, когда новая библиотека начинает более ни менее работать, я приступаю к последнему шагу.
#### Четвёртый шаг: чистка кода.
Здесь нужно сказать, что Hebron не скупится на скобочки(из описания предыдущего шага можно понять почему) или приведения к типам. Из-за чего сгенерированный код вызывает ужас у студии и она предлагает мне сделать множество автоисправлений. Выглядит это примерно так:
Чтобы решить эту проблему, я обычно запускаю [Rider](https://www.jetbrains.com/ru-ru/rider/) и осуществляю Code Cleanup(Ctrl-E, Ctrl-C). Я пользуюсь бесплатной лицензией, которую [JetBrains предоставляет для проектов с открытым исходным кодом](https://www.jetbrains.com/ru-ru/community/opensource/#support).
После очистки кода новая библиотека готова.
Кстати, пользуясь случаем, хочу поблагодарить JetBrains как за Rider, так и за лицензию. Спасибо!
Надеюсь, кто-нибудь из официальных представителей на хабре это прочитает.
Прочие порты.
-------------
Напоследок я бы хотел рассказать о моих портах, не входящих в StbSharp.
[FontStashSharp](https://github.com/FontStashSharp/FontStashSharp). На самом деле, этот проект уже нельзя считать портом, поскольку фактически весь оригинальный код был переписан. Неизменным остался, пожалуй, лишь код упаковки прямоугольников на атласе в классе [FontAtlas](https://github.com/FontStashSharp/FontStashSharp/blob/main/src/FontStashSharp/FontAtlas.cs).
[NvgSharp](https://github.com/rds1983/NvgSharp). Проект используется в отечественном игровом движке коммерческого уровня под названием [Citrus](https://github.com/game-forest/Citrus).
[DdsKtxSharp](https://github.com/rds1983/DdsKtxSharp). Не слишком известный проект, умеющий загружать картинки в форматах DDS и KTX. Важно отметить, что декодировать он их не умеет. Предполагается, что декодированием будет заниматься видеоускоритель.
[SamSharp](https://github.com/rds1983/SamSharp). Самый неизвестный проект, синтезирующий человеческую речь по какому-то древнему алгоритму, используемому ещё в Commodore C64. Важно отметить, что у оригинального кода не было свободной лицензии, поэтому её нет и у порта.
Пример работы:
Эпилог.
-------
Ну и совсем напоследок скажу, что готов принимать заявки на портирование. Для подачи такой заявки достаточно создать соответствующий кейс в [Hebron](https://github.com/HebronFramework/Hebron).
[freetype](http://freetype.org/) и [sqlite](https://www.sqlite.org/index.html) можно не предлагать. Поскольку к ним я уже приступал. И сломался на втором шаге. Собственно, вот [SqliteSharp](https://github.com/rds1983/SqliteSharp). FreeTypeSharp же история не сохранила.
Вот теперь, действительно, всё :) | https://habr.com/ru/post/687312/ | null | ru | null |
# Уязвимость HTTPoxy позволяет перенаправлять http-запросы веб-приложений
[](https://habrahabr.ru/company/pt/blog/306176/)
18 июля была опубликована информация о наборе уязвимостей, получившем название HTTPoxy. Используя его, злоумышленники могут подменять переменную окружения HTTP\_PROXY, что позволяет им перенаправлять http-запросы к веб-приложениям на свои ресурсы.
Уязвимость была выявлена при участии разработчика компании Vend Доменика Шайрлинка (Dominic Scheirlinck), который в своем блоге на Medium [рассказал](https://medium.com/we-build-vend/how-the-internets-biggest-blind-spot-lead-to-a-15-year-old-security-vulnerability-a2a6f6218a71#.rlbstynge) о том, как она была обнаружена его коллегами в ходе разбора одного из тикетов, поступившем в службу поддержки.
#### Как это работает
Шайрлинк подробно объясняет принцип работы HTTPoxy. Типичная атака с использованием этого набора уязвимостей выглядит так:
1. Атакующий создает специально составленный HTTP-запрос, в котором содержится заголовок Proxy;
2. CGI получает запрос и сохраняет значение заголовка в переменную среды HTTP\_PROXY;
3. CGI приложение запускает собственный веб-клиент, использующий переменную среды HTTP\_PROXY в качестве настроек прокси;
4. Клиент отправляет запрос, который вместо адреса назначения проксируется через сервер атакующего.
К примеру, так может выглядеть код эксплуатации на нескольких популярных языках:
PHP:
```
$client = new GuzzleHttp\Client();
$client->get('http://api.internal/?secret=foo')
```
Python:
```
from wsgiref.handlers import CGIHandler
def application(environ, start_response):
requests.get("http://api.internal/?secret=foo")
CGIHandler().run(application)
```
Go:
```
cgi.Serve(
http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
res, _ := http.Get("http://api.internal/?secret=foo")
// [...]
```
Более подробные PoC можно найти на GitHub в специальном [репозитории HTTPoxy](https://github.com/httpoxy).
Интересный момент заключается в том, что сам баг, который используется в атаке HTTPoxy, был обнаружен пятнадцать лет назад. На [сайте](https://httpoxy.org/), посвященном HTTPoxy, представлено подробное описание истории уязвимости.
Согласно ему, в марте 2001 была обнаружена и исправлена ошибка некорректной обработки заголовков HTTP\_PROXY в libwww-perl. В апреле того же года проблема была обнаружена в curl (и также исправлена, хотя и не для Windows). В 2012 году команда проекта Ruby разработала HTTP\_PROXY для Net::HTTP — в их системе уязвимости не было.
В ноябре 2013 года она была упомянута в листе рассылки NGINX — пользователь Джонатан Мэттьюс описал ошибку, хотя и не был полностью уверен в своей правоте. В феврале 2015 года уязвимость также была упомянута в списке рассылке Apache httpd-dev. И уже в июле 2016 года сотрудник Vend Скот Джири (Scott Geary) обнаружил баг в реальной системе.
#### Какие системы уязвимы
Как выяснила команда безопасности Vend, уязвимость содержится во многих современных языках и библиотеках.
* CVE-2016-5386 Go
* CVE-2016-5387 Apache HTTPD
* CVE-2016-5388 Tomcat
* CVE-2016-1000104 mod\_fcgi
* CVE-2016-1000107 Erlang HTTP Server
* CVE-2016-1000108 YAWS
* CVE-2016-1000109 HHVM FastCGI
* CVE-2016-1000110 Python CGIHandler
* CVE-2016-1000111 Python twisted
#### Как обнаружить уязвимость в своем софте
Специалисты компании RedHat [разработали](https://access.redhat.com/security/vulnerabilities/httpoxy) небольшой скрипт, позволяющий определить, уязвима ли конкретная система к HTTPoxy.
Для этого администратору сервера необходимо установить следующий CGI-скрипт и сделать его исполняемым:
```
test.cgi:
#!/bin/sh
echo "Content-Type:text/plain"
echo ""
echo "HTTP_PROXY='$HTTP_PROXY'"
```
После этого следует вызвать CGI-скрипт с заголовком Proxy:
```
curl -H ‘Proxy: AFFECTED’ http://my-server-name/cgi-bin/test.cgi
```
Если вывод команды выглядит следующим образом — сервер не подвержен уязвимости:
```
HTTP_PROXY="
```
Если же вывод выглядит не так, к примеру отображается надпись ниже, то система уязвима:
```
HTTP_PROXY='AFFECTED'
```
#### Как защититься
Конечные пользователи веб-приложений в данной ситуации никак не могут повысить уровень своей безопасности, однако разработчики этого программного обеспечения имеют все возможности по его защите.
Для этого им нужно заблокировать заголовки запросов Proxy — сделать это можно очень быстро. Это не должно повредить функциональности приложения, поскольку такие заголовки являются нестандартными и обычно не используются.
К примеру, вот так можно отключить заголовки Proxy в Apache c помощью файла .htaccess:
```
RequestHeader unset Proxy
```
Многие ИТ-компании и разработчики софта уже заявили о том, приняли меры к защите своих пользователей от уязвимости HTTPoxy — в их числе [Akamai](https://blogs.akamai.com/2016/07/akamai-mitigates-httpoxy-vulnerability.html), [CloudFlare](https://blog.cloudflare.com/cloudflare-sites-protected-from-httpoxy/), исправления выпустила и [RedHat](https://access.redhat.com/security/vulnerabilities/httpoxy).
Эксперты Positive Technologies разработали сигнатуру для Suricata IDS, позволяющую обнаружить использование заголовка “Proxy” в HTTP запросах и предотвратить возможные последствия. Сигнатуру и пример эксплуатации можно найти в официальном репозитории [twitter.com/AttackDetection/status/756142402268639232](https://twitter.com/AttackDetection/status/756142402268639232). | https://habr.com/ru/post/306176/ | null | ru | null |
# RESTful API на Node.js + MongoDB
Я, будучи разработчиком мобильных приложений, часто нуждаюсь в backend-сервисах для хранения пользовательских данных, авторизации и прочего. Конечно, для подобных задач можно использовать BaaS (Parse, Backendless, etc…). Но свое решение — это всегда более удобно и практично.
И я все же решил изучить совершенно неизвестные для меня технологии, которые сейчас весьма популярны и позиционируются, как легко осваиваемые новичками и не требующие глубоких знаний и опыта для реализации масштабных проектов. Вот и проверим вместе, может ли неспециалист написать свой эффективный и правильный бэкенд.
В данной статье будет рассмотрено построение REST API для мобильного приложения на Node.js с использованием фреймворка Express.js и модуля Mongoose.js для работы с MongoDB. Для контроля доступа прибегнем к технологии OAuth 2.0 с помощью модулей OAuth2orize и Passport.js.
Пишу с позиции абсолютного новичка. Рад любым отзывам и поправкам по коду и логике!
##### Содержание
1. [Node.js + Express.js, простой web-сервер](#p1)
2. [Error handling](#p2)
3. [RESTful API endpoints, CRUD](#p3)
4. [MongoDB & Mongoose.js](#p4)
5. [Access control — OAuth 2.0, Passport.js](#p5)
Работаю я в OSX, IDE — [JetBrains WebStorm](http://www.jetbrains.com/webstorm/).
Основы Node.js почерпнул в [скринкастах Ильи Кантора](http://learn.javascript.ru/nodejs-screencast), крайне рекомендую! ([А вот и пост про них на хабре](http://habrahabr.ru/post/193158/))
Готовый проект на последней стадии можно взять на [GitHub](https://github.com/ealeksandrov/NodeAPI). Для установки всех модулей, выполните команду npm install в папке проекта.
#### 1. Node.js + Express.js, простой web-сервер
Node.js обладает неблокирующим вводом-выводом, это круто для API, к которому будет обращаться множество клиентов. Express.js — развитый, легковесный фреймворк, позволяющий быстро описать все пути (API endpoints), которые мы будем обрабатывать. Так же к нему можно найти множество полезных модулей.
Создаем новый проект с единственным файлом server.js. Так как приложение будет целиком полагаться на [Express.js](http://expressjs.com/), установим его. Установка сторонних модулей происходит через Node Package Manager выполнением команды `npm install modulename` в папке проекта.
```
cd NodeAPI
npm i express
```
Express установится в папку node\_modules. Подключим его к приложению:
```
var express = require('express');
var app = express();
app.listen(1337, function(){
console.log('Express server listening on port 1337');
});
```
Запустим приложение через IDE или консоль (`node server.js`). Данный код создаст веб-сервер на localhost:1337. Если попробовать его открыть — он выведет сообщение `Cannot GET /`. Это потому что мы еще не задали ни одного пути (route). Далее создадим несколько путей и произведем базовые настройки Express.
```
var express = require('express');
var path = require('path'); // модуль для парсинга пути
var app = express();
app.use(express.favicon()); // отдаем стандартную фавиконку, можем здесь же свою задать
app.use(express.logger('dev')); // выводим все запросы со статусами в консоль
app.use(express.bodyParser()); // стандартный модуль, для парсинга JSON в запросах
app.use(express.methodOverride()); // поддержка put и delete
app.use(app.router); // модуль для простого задания обработчиков путей
app.use(express.static(path.join(__dirname, "public"))); // запуск статического файлового сервера, который смотрит на папку public/ (в нашем случае отдает index.html)
app.get('/api', function (req, res) {
res.send('API is running');
});
app.listen(1337, function(){
console.log('Express server listening on port 1337');
});
```
Теперь localhost:1337/api вернет наше сообщение. localhost:1337 отобразит index.html.
Тут мы переходим к обработке ошибок.
#### 2. Error handling
Сперва подключим удобный модуль для логгинга [Winston](https://github.com/flatiron/winston). Использовать мы его будем через свою обертку. Установим в корне проекта `npm i winston`, затем создадим папку libs/ и там файл log.js.
```
var winston = require('winston');
function getLogger(module) {
var path = module.filename.split('/').slice(-2).join('/'); //отобразим метку с именем файла, который выводит сообщение
return new winston.Logger({
transports : [
new winston.transports.Console({
colorize: true,
level: 'debug',
label: path
})
]
});
}
module.exports = getLogger;
```
Мы создали 1 транспорт для логов — в консоль. Так же мы можем отдельно сортировать и сохранять сообщения, например, в базу данных или файл. Подключим логгер в наш server.js.
```
var express = require('express');
var path = require('path'); // модуль для парсинга пути
var log = require('./libs/log')(module);
var app = express();
app.use(express.favicon()); // отдаем стандартную фавиконку, можем здесь же свою задать
app.use(express.logger('dev')); // выводим все запросы со статусами в консоль
app.use(express.bodyParser()); // стандартный модуль, для парсинга JSON в запросах
app.use(express.methodOverride()); // поддержка put и delete
app.use(app.router); // модуль для простого задания обработчиков путей
app.use(express.static(path.join(__dirname, "public"))); // запуск статического файлового сервера, который смотрит на папку public/ (в нашем случае отдает index.html)
app.get('/api', function (req, res) {
res.send('API is running');
});
app.listen(1337, function(){
log.info('Express server listening on port 1337');
});
```
Наше информационное сообщение теперь красиво отдельно выводится в консоль. Добавим обработку ошибок 404 и 500.
```
app.use(function(req, res, next){
res.status(404);
log.debug('Not found URL: %s',req.url);
res.send({ error: 'Not found' });
return;
});
app.use(function(err, req, res, next){
res.status(err.status || 500);
log.error('Internal error(%d): %s',res.statusCode,err.message);
res.send({ error: err.message });
return;
});
app.get('/ErrorExample', function(req, res, next){
next(new Error('Random error!'));
});
```
Теперь, если нет доступных путей, Express вернет наше сообщение. При внутренней ошибке приложения сработает так же наш обработчик, это можно проверить, обратившись по адресу localhost:1337/ErrorExample.
#### 3. RESTful API endpoints, CRUD
Добавим пути для обработки неких «статей»(articles). На хабре есть прекрасная [статья](http://habrahabr.ru/post/181988/), объясняющая, как правильно делать удобное API. Логикой их наполнять пока не будем, сделаем это в следующем шаге, с подключением базы данных.
```
app.get('/api/articles', function(req, res) {
res.send('This is not implemented now');
});
app.post('/api/articles', function(req, res) {
res.send('This is not implemented now');
});
app.get('/api/articles/:id', function(req, res) {
res.send('This is not implemented now');
});
app.put('/api/articles/:id', function (req, res){
res.send('This is not implemented now');
});
app.delete('/api/articles/:id', function (req, res){
res.send('This is not implemented now');
});
```
Для тестирования post/put/delete посоветую замечательную обертку над cURL — [httpie](https://github.com/jkbr/httpie). Далее я буду приводить примеры запросов именно с использованием этого инструмента.
#### 4. MongoDB & Mongoose.js
Выбирая СУБД, я руководствовался опять-таки стремлением изучить что-то новое. [MongoDB](http://www.mongodb.org/) — самая популярная NoSQL документ-ориентированная СУБД. [Mongoose.js](http://mongoosejs.com/) — обертка, позволяющая создавать удобные и функциональные схемы документов.
Скачиваем и устанавливаем [MongoDB](http://www.mongodb.org/downloads). Устанавливаем mongoose: `npm i mongoose`. Работу с бд я выделил в файл libs/mongoose.js.
```
var mongoose = require('mongoose');
var log = require('./log')(module);
mongoose.connect('mongodb://localhost/test1');
var db = mongoose.connection;
db.on('error', function (err) {
log.error('connection error:', err.message);
});
db.once('open', function callback () {
log.info("Connected to DB!");
});
var Schema = mongoose.Schema;
// Schemas
var Images = new Schema({
kind: {
type: String,
enum: ['thumbnail', 'detail'],
required: true
},
url: { type: String, required: true }
});
var Article = new Schema({
title: { type: String, required: true },
author: { type: String, required: true },
description: { type: String, required: true },
images: [Images],
modified: { type: Date, default: Date.now }
});
// validation
Article.path('title').validate(function (v) {
return v.length > 5 && v.length < 70;
});
var ArticleModel = mongoose.model('Article', Article);
module.exports.ArticleModel = ArticleModel;
```
В данном файле выполняется подключение к базе, а так же объявляются схемы объектов. Статьи будут содержать объекты картинок. Разнообразные сложные валидации можно описать так же здесь.
На данном этапе предлагаю подключить модуль [nconf](https://github.com/flatiron/nconf) для хранения пути к БД в нем. Так же в конфиг сохраним порт, по которому создается сервер. Модуль устанавливается командой `npm i nconf`. Оберткой будет libs/config.js
```
var nconf = require('nconf');
nconf.argv()
.env()
.file({ file: './config.json' });
module.exports = nconf;
```
Отсюда следует, что мы должны создать config.json в корне проекта.
```
{
"port" : 1337,
"mongoose": {
"uri": "mongodb://localhost/test1"
}
}
```
Изменения mongoose.js (только в шапке):
```
var config = require('./config');
mongoose.connect(config.get('mongoose:uri'));
```
Изменения server.js:
```
var config = require('./libs/config');
app.listen(config.get('port'), function(){
log.info('Express server listening on port ' + config.get('port'));
});
```
Теперь добавим CRUD actions в наши существующие пути.
```
var log = require('./libs/log')(module);
var ArticleModel = require('./libs/mongoose').ArticleModel;
app.get('/api/articles', function(req, res) {
return ArticleModel.find(function (err, articles) {
if (!err) {
return res.send(articles);
} else {
res.statusCode = 500;
log.error('Internal error(%d): %s',res.statusCode,err.message);
return res.send({ error: 'Server error' });
}
});
});
app.post('/api/articles', function(req, res) {
var article = new ArticleModel({
title: req.body.title,
author: req.body.author,
description: req.body.description,
images: req.body.images
});
article.save(function (err) {
if (!err) {
log.info("article created");
return res.send({ status: 'OK', article:article });
} else {
console.log(err);
if(err.name == 'ValidationError') {
res.statusCode = 400;
res.send({ error: 'Validation error' });
} else {
res.statusCode = 500;
res.send({ error: 'Server error' });
}
log.error('Internal error(%d): %s',res.statusCode,err.message);
}
});
});
app.get('/api/articles/:id', function(req, res) {
return ArticleModel.findById(req.params.id, function (err, article) {
if(!article) {
res.statusCode = 404;
return res.send({ error: 'Not found' });
}
if (!err) {
return res.send({ status: 'OK', article:article });
} else {
res.statusCode = 500;
log.error('Internal error(%d): %s',res.statusCode,err.message);
return res.send({ error: 'Server error' });
}
});
});
app.put('/api/articles/:id', function (req, res){
return ArticleModel.findById(req.params.id, function (err, article) {
if(!article) {
res.statusCode = 404;
return res.send({ error: 'Not found' });
}
article.title = req.body.title;
article.description = req.body.description;
article.author = req.body.author;
article.images = req.body.images;
return article.save(function (err) {
if (!err) {
log.info("article updated");
return res.send({ status: 'OK', article:article });
} else {
if(err.name == 'ValidationError') {
res.statusCode = 400;
res.send({ error: 'Validation error' });
} else {
res.statusCode = 500;
res.send({ error: 'Server error' });
}
log.error('Internal error(%d): %s',res.statusCode,err.message);
}
});
});
});
app.delete('/api/articles/:id', function (req, res){
return ArticleModel.findById(req.params.id, function (err, article) {
if(!article) {
res.statusCode = 404;
return res.send({ error: 'Not found' });
}
return article.remove(function (err) {
if (!err) {
log.info("article removed");
return res.send({ status: 'OK' });
} else {
res.statusCode = 500;
log.error('Internal error(%d): %s',res.statusCode,err.message);
return res.send({ error: 'Server error' });
}
});
});
});
```
Благодаря Mongoose и описанным схемам — все операции предельно понятны. Теперь, кроме node.js следует запустить mongoDB командой `mongod`. `mongo` — утилита для работы с БД, сам сервис — `mongod`. Создавать предварительно в базе ничего не нужно.
Примеры запросов с помощью httpie:
```
http POST http://localhost:1337/api/articles title=TestArticle author='John Doe' description='lorem ipsum dolar sit amet' images:='[{"kind":"thumbnail", "url":"http://habrahabr.ru/images/write-topic.png"}, {"kind":"detail", "url":"http://habrahabr.ru/images/write-topic.png"}]'
http http://localhost:1337/api/articles
http http://localhost:1337/api/articles/52306b6a0df1064e9d000003
http PUT http://localhost:1337/api/articles/52306b6a0df1064e9d000003 title=TestArticle2 author='John Doe' description='lorem ipsum dolar sit amet' images:='[{"kind":"thumbnail", "url":"http://habrahabr.ru/images/write-topic.png"}, {"kind":"detail", "url":"http://habrahabr.ru/images/write-topic.png"}]'
http DELETE http://localhost:1337/api/articles/52306b6a0df1064e9d000003
```
Проект на данном этапе можно взглянуть на [GitHub](https://github.com/ealeksandrov/NodeAPI/tree/e8764a97f9c70fb6eae102fda7237e745d9e99ac).
#### 5. Access control — OAuth 2.0, Passport.js
Для контроля доступа я прибегну к OAuth 2. Возможно, это избыточно, но в дальнейшем такой подход облегчает интеграцию с другими OAuth-провайдерами. К тому же, я не нашел рабочих примеров user-password OAuth2 flow для Node.js.
Непосредственно за контролем доступа будет следить [Passport.js](http://passportjs.org/). Для OAuth2-сервера пригодится решение от того же автора — [oauth2orize](https://github.com/jaredhanson/oauth2orize). Пользователи, токены будут храниться в MongoDB.
Сперва нужно установить все модули, которые нам потребуются:
* Faker
* oauth2orize
* passport
* passport-http
* passport-http-bearer
* passport-oauth2-client-password
Затем, в mongoose.js нужно добавить схемы для пользователей и токенов:
```
var crypto = require('crypto');
// User
var User = new Schema({
username: {
type: String,
unique: true,
required: true
},
hashedPassword: {
type: String,
required: true
},
salt: {
type: String,
required: true
},
created: {
type: Date,
default: Date.now
}
});
User.methods.encryptPassword = function(password) {
return crypto.createHmac('sha1', this.salt).update(password).digest('hex');
//more secure - return crypto.pbkdf2Sync(password, this.salt, 10000, 512);
};
User.virtual('userId')
.get(function () {
return this.id;
});
User.virtual('password')
.set(function(password) {
this._plainPassword = password;
this.salt = crypto.randomBytes(32).toString('base64');
//more secure - this.salt = crypto.randomBytes(128).toString('base64');
this.hashedPassword = this.encryptPassword(password);
})
.get(function() { return this._plainPassword; });
User.methods.checkPassword = function(password) {
return this.encryptPassword(password) === this.hashedPassword;
};
var UserModel = mongoose.model('User', User);
// Client
var Client = new Schema({
name: {
type: String,
unique: true,
required: true
},
clientId: {
type: String,
unique: true,
required: true
},
clientSecret: {
type: String,
required: true
}
});
var ClientModel = mongoose.model('Client', Client);
// AccessToken
var AccessToken = new Schema({
userId: {
type: String,
required: true
},
clientId: {
type: String,
required: true
},
token: {
type: String,
unique: true,
required: true
},
created: {
type: Date,
default: Date.now
}
});
var AccessTokenModel = mongoose.model('AccessToken', AccessToken);
// RefreshToken
var RefreshToken = new Schema({
userId: {
type: String,
required: true
},
clientId: {
type: String,
required: true
},
token: {
type: String,
unique: true,
required: true
},
created: {
type: Date,
default: Date.now
}
});
var RefreshTokenModel = mongoose.model('RefreshToken', RefreshToken);
module.exports.UserModel = UserModel;
module.exports.ClientModel = ClientModel;
module.exports.AccessTokenModel = AccessTokenModel;
module.exports.RefreshTokenModel = RefreshTokenModel;
```
Виртуальное свойство password — пример, как mongoose может в модели встроить удобную логику. Про хэши, алгоритмы и соль — не эта статья, не будем вдаваться в подробности реализации.
Итак, объекты в БД:
1. User — пользователь, который обладает именем, хэшем пароля и солью своего пароля.
2. Client — клиент-приложение, которому выдается доступ от имени пользователя. Обладают именем и секретным кодом.
3. AccessToken — токен (тип bearer), выдаваемый клиентским приложениям, ограничен по времени.
4. RefreshToken — другой тип токена, позволяет запросить новый bearer-токен без повторного запроса пароля у пользователя.
В config.json добавим время жизни токена:
```
{
"port" : 1337,
"security": {
"tokenLife" : 3600
},
"mongoose": {
"uri": "mongodb://localhost/testAPI"
}
}
```
Выделим в отдельные модули сервер OAuth2 и логику авторизации. В oauth.js описаны «стратегии» passport.js, мы подключаем 3 из них — 2 на OAuth2 username-password flow, 1 на проверку токена.
```
var config = require('./config');
var passport = require('passport');
var BasicStrategy = require('passport-http').BasicStrategy;
var ClientPasswordStrategy = require('passport-oauth2-client-password').Strategy;
var BearerStrategy = require('passport-http-bearer').Strategy;
var UserModel = require('./mongoose').UserModel;
var ClientModel = require('./mongoose').ClientModel;
var AccessTokenModel = require('./mongoose').AccessTokenModel;
var RefreshTokenModel = require('./mongoose').RefreshTokenModel;
passport.use(new BasicStrategy(
function(username, password, done) {
ClientModel.findOne({ clientId: username }, function(err, client) {
if (err) { return done(err); }
if (!client) { return done(null, false); }
if (client.clientSecret != password) { return done(null, false); }
return done(null, client);
});
}
));
passport.use(new ClientPasswordStrategy(
function(clientId, clientSecret, done) {
ClientModel.findOne({ clientId: clientId }, function(err, client) {
if (err) { return done(err); }
if (!client) { return done(null, false); }
if (client.clientSecret != clientSecret) { return done(null, false); }
return done(null, client);
});
}
));
passport.use(new BearerStrategy(
function(accessToken, done) {
AccessTokenModel.findOne({ token: accessToken }, function(err, token) {
if (err) { return done(err); }
if (!token) { return done(null, false); }
if( Math.round((Date.now()-token.created)/1000) > config.get('security:tokenLife') ) {
AccessTokenModel.remove({ token: accessToken }, function (err) {
if (err) return done(err);
});
return done(null, false, { message: 'Token expired' });
}
UserModel.findById(token.userId, function(err, user) {
if (err) { return done(err); }
if (!user) { return done(null, false, { message: 'Unknown user' }); }
var info = { scope: '*' }
done(null, user, info);
});
});
}
));
```
За выдачу и обновление токена отвечает oauth2.js. Одна exchange-стратегия — на получение токена по username-password flow, еще одна — на обмен refresh\_token.
```
var oauth2orize = require('oauth2orize');
var passport = require('passport');
var crypto = require('crypto');
var config = require('./config');
var UserModel = require('./mongoose').UserModel;
var ClientModel = require('./mongoose').ClientModel;
var AccessTokenModel = require('./mongoose').AccessTokenModel;
var RefreshTokenModel = require('./mongoose').RefreshTokenModel;
// create OAuth 2.0 server
var server = oauth2orize.createServer();
// Exchange username & password for access token.
server.exchange(oauth2orize.exchange.password(function(client, username, password, scope, done) {
UserModel.findOne({ username: username }, function(err, user) {
if (err) { return done(err); }
if (!user) { return done(null, false); }
if (!user.checkPassword(password)) { return done(null, false); }
RefreshTokenModel.remove({ userId: user.userId, clientId: client.clientId }, function (err) {
if (err) return done(err);
});
AccessTokenModel.remove({ userId: user.userId, clientId: client.clientId }, function (err) {
if (err) return done(err);
});
var tokenValue = crypto.randomBytes(32).toString('base64');
var refreshTokenValue = crypto.randomBytes(32).toString('base64');
var token = new AccessTokenModel({ token: tokenValue, clientId: client.clientId, userId: user.userId });
var refreshToken = new RefreshTokenModel({ token: refreshTokenValue, clientId: client.clientId, userId: user.userId });
refreshToken.save(function (err) {
if (err) { return done(err); }
});
var info = { scope: '*' }
token.save(function (err, token) {
if (err) { return done(err); }
done(null, tokenValue, refreshTokenValue, { 'expires_in': config.get('security:tokenLife') });
});
});
}));
// Exchange refreshToken for access token.
server.exchange(oauth2orize.exchange.refreshToken(function(client, refreshToken, scope, done) {
RefreshTokenModel.findOne({ token: refreshToken }, function(err, token) {
if (err) { return done(err); }
if (!token) { return done(null, false); }
if (!token) { return done(null, false); }
UserModel.findById(token.userId, function(err, user) {
if (err) { return done(err); }
if (!user) { return done(null, false); }
RefreshTokenModel.remove({ userId: user.userId, clientId: client.clientId }, function (err) {
if (err) return done(err);
});
AccessTokenModel.remove({ userId: user.userId, clientId: client.clientId }, function (err) {
if (err) return done(err);
});
var tokenValue = crypto.randomBytes(32).toString('base64');
var refreshTokenValue = crypto.randomBytes(32).toString('base64');
var token = new AccessTokenModel({ token: tokenValue, clientId: client.clientId, userId: user.userId });
var refreshToken = new RefreshTokenModel({ token: refreshTokenValue, clientId: client.clientId, userId: user.userId });
refreshToken.save(function (err) {
if (err) { return done(err); }
});
var info = { scope: '*' }
token.save(function (err, token) {
if (err) { return done(err); }
done(null, tokenValue, refreshTokenValue, { 'expires_in': config.get('security:tokenLife') });
});
});
});
}));
// token endpoint
exports.token = [
passport.authenticate(['basic', 'oauth2-client-password'], { session: false }),
server.token(),
server.errorHandler()
]
```
Для подключения этих модулей, следует добавить в server.js:
```
var oauth2 = require('./libs/oauth2');
app.use(passport.initialize());
require('./libs/auth');
app.post('/oauth/token', oauth2.token);
app.get('/api/userInfo',
passport.authenticate('bearer', { session: false }),
function(req, res) {
// req.authInfo is set using the `info` argument supplied by
// `BearerStrategy`. It is typically used to indicate scope of the token,
// and used in access control checks. For illustrative purposes, this
// example simply returns the scope in the response.
res.json({ user_id: req.user.userId, name: req.user.username, scope: req.authInfo.scope })
}
);
```
Для примера защита стоит на адресе localhost:1337/api/userInfo.
Чтобы проверить работу механизма авторизации — следует создать пользователя и клиента в БД. Приведу приложение на Node.js, которое создаст необходимые объекты и удалит лишние из коллекций. Помогает быстро очистить базу токенов и пользователей при тестировании, вам, думаю, достаточно будет одного запуска :)
```
var log = require('./libs/log')(module);
var mongoose = require('./libs/mongoose').mongoose;
var UserModel = require('./libs/mongoose').UserModel;
var ClientModel = require('./libs/mongoose').ClientModel;
var AccessTokenModel = require('./libs/mongoose').AccessTokenModel;
var RefreshTokenModel = require('./libs/mongoose').RefreshTokenModel;
var faker = require('Faker');
UserModel.remove({}, function(err) {
var user = new UserModel({ username: "andrey", password: "simplepassword" });
user.save(function(err, user) {
if(err) return log.error(err);
else log.info("New user - %s:%s",user.username,user.password);
});
for(i=0; i<4; i++) {
var user = new UserModel({ username: faker.random.first_name().toLowerCase(), password: faker.Lorem.words(1)[0] });
user.save(function(err, user) {
if(err) return log.error(err);
else log.info("New user - %s:%s",user.username,user.password);
});
}
});
ClientModel.remove({}, function(err) {
var client = new ClientModel({ name: "OurService iOS client v1", clientId: "mobileV1", clientSecret:"abc123456" });
client.save(function(err, client) {
if(err) return log.error(err);
else log.info("New client - %s:%s",client.clientId,client.clientSecret);
});
});
AccessTokenModel.remove({}, function (err) {
if (err) return log.error(err);
});
RefreshTokenModel.remove({}, function (err) {
if (err) return log.error(err);
});
setTimeout(function() {
mongoose.disconnect();
}, 3000);
```
Если вы создали данные скриптом, до следующие команды для авторизации вам так же подойдут. Напомню, что я использую [httpie](https://github.com/jkbr/httpie).
```
http POST http://localhost:1337/oauth/token grant_type=password client_id=mobileV1 client_secret=abc123456 username=andrey password=simplepassword
http POST http://localhost:1337/oauth/token grant_type=refresh_token client_id=mobileV1 client_secret=abc123456 refresh_token=TOKEN
http http://localhost:1337/api/userinfo Authorization:'Bearer TOKEN'
```
**Внимание!** На production-сервере обязательно используйте HTTPS, это подразумевается спецификацией OAuth 2. И не забудьте про правильное хэширование паролей. Реализовать https на данном примере несложно, в сети много примеров.
Напомню, что весь код содержится в репозитории на [GitHub](https://github.com/ealeksandrov/NodeAPI).
Для работы необходимо выполнить `npm install` в директории, запустить `mongod`, `node dataGen.js` (дождаться выполнения), а затем `node server.js`.
Если какую-то часть статьи стоит описать более подробно, пожалуйста, укажите на это в комментариях. Материал будет перерабатываться и дополняться по мере поступления отзывов.
Подводя итог, хочу сказать, что node.js — классное, удобное серверное решение. MongoDB с документ-ориентированным подходом — очень непривычный, но несомненно полезный инструмент, большинства возможностей которого я еще не использовал. Вокруг Node.js — очень большое коммьюнити, где есть множество open-source разработок. Например, создатель oauth2orize и passport.js — Jared Hanson сделал замечательне проекты, которые максимально облегчают реализацию правильно защищенных систем. | https://habr.com/ru/post/193458/ | null | ru | null |
# RuTracker: полгода без рейтинга
Цыплята осени, или записки обывателя
------------------------------------
**Год**: 2012
**Автор**: Anonymous
**Издательство**: «Нигде не купишь»
**Серия**: Популярная конспирология
**Жанр**: Триллер, детектив
**Язык**: Русский
**Описание**:
Осень, как известно, это не только «плачущее небо под ногами», но и пора, когда традиционно принято подсчитывать цыплят. Чем я и планирую заняться в этом посте, хотя основной его резон — вызвать дискуссию (на независимой площадке), поскольку сотни страниц обсуждения на ТРУ вылились в целенаправленный флуд и толстый троллинг. Надеюсь, Хабр позволит более взвешенно рассмотреть ситуацию.
`<лирический offtop>` Перед написанием этого поста засел просматривать архив обсуждения отмены рейтинга… Философическое занятие, доложу я вам. Спасибо администрации за то, что оставила хоть что-то из сотен страниц (тысячи сообщений за трое суток). Многое потёрто, изменились подписи и аватары, с помощью которых юзернеймы взывали к совести, логике и просто прикалывались. Но даже через полгода дух протеста и ощущение растерянности и бессилия — остались. При этом складывается такое впечатление, что администрация оставила архив обсуждения в назидание. Чтобы видели ~~холопы~~ юзернеймы, кто тут правит балом. Впрочем, это их право и мои домыслы.
Это присказка. А вот и сказка… Но в начале хотелось бы предупредить: читая нижеследующее, вы рискуете потратить время без пользы. По причине отсутствия инсайдерской информации, этот пост практически ни о чём. Просто предложение дискуссии, размышления вслух и прочие бесполезные рефлексии. Вот… теперь можно приглашать на сцену амбулу.
Начну со «сводки информбюро».
23-го февраля 2012 года (что уже вызывает нездоровые конспирологические мысли и апокалиптические ассоциации) на крупнейшем трекере рунета [внезапно выключили рейтинг](http://rutracker.org/forum/viewtopic.php?p=51401826#51401826). Без объявления войны и объяснения причин.
Самое интересное, что о готовящейся диверсии не знали даже модераторы, группа техпомощи и т. д.
[](https://habrastorage.org/getpro/habr/post_images/468/2f2/d42/4682f2d42fc8d7e98ef4f34bca82d68e.jpg)
В обсуждении этой кхм… «новости» тут же появились первые недовольные. Жаловались на падёж активных раздач (отключён один из пяти серверов), непривычный вид профиля и прочие неудобства. Но уже тогда кое-кто сказал о главном:
[](https://habrastorage.org/getpro/habr/post_images/57f/ae8/933/57fae8933e09a46a165c5e15616eaf8c.jpg)
В итоге глас народа очень быстро превратился в стон-рефрен:
[](https://habrastorage.org/getpro/habr/post_images/fe4/f05/488/fe4f05488e0e9997bc54c70046412c0a.jpg)
Администрация, что показательно, так и не соизволила снизойти до объяснения происходящего. Приближённые личности отписывались загадочными намёками
**например**[](https://habrastorage.org/getpro/habr/post_images/80a/f52/37f/80af5237f7816a241320870a0e3a6e80.jpg) Естественно, в условиях информационного вакуума возникли теории и домыслы…
Справедливости ради стоит отметить, что были и те, кто поддержал нововведения.
Как подсказывает здравый смысл и профили этих самых пользователей, отмена рейтинга порадовала в первую очередь товарищей со слабыми инет-каналами и любителей сваливать с раздачи.
Многие просто упрекали недовольных в кармодр\*\*\*стве. С точки зрения моих тараканов, это равносильно обвинениям на Хабре в том, что кто-то, мол, написал статью только для того, чтобы выйти из минусов или заработать инвайт. Имхо, лишь бы статья была интересной, а уж что послужило стимулом не столь важно. По-моему, лычки и прочие рюшики могут сказать человеку, насколько он полезен для данного ресурса, а также символизируют некое признание сообществом заслуг юзернейма.
В общем, буча в обсуждении была та ещё. И таки многим отмена рейтинга пришлась по душе.
Я их не виню. Создание комфортных и взаимовыгодных для всех (ну хотя бы для большинства) условий файлообмена — это проблема и задача администрации. То, что нововведения нашли поддержку у определённой части пользователей ещё не говорит о том, что они хорошие (равно как и плохие). Просто о сущности изменений (и о том, к чему они могут привести в итоге) можно составить представление, читая отзывы тех, кому они активно нравятся или не нравятся.
Архив обсуждения остался. Остались и вопросы.
**1. Каковы были реальные причины отмены рейтинга?**Было высказано много предположений. Перечислю по пунктам, присовокупив короткий комментарий.
**1. Рейдерский захват.**
Сложно комментировать за неимением данных.
**2. Снижение вычислительной нагрузки на сервера.**
Судя по тому, что статистика в данный момент таки ведётся, «нагрузку на сервера» никто таким образом снизить не пытался.
**3. Наезд силовых ведомств или левообладателей, вследствие чего было принято решение «спрятать» статистику пользователей — для их же защиты. Сюда же можно отнести подозрения, что отмена статистики связана со вступлением России в ВТО.**
Как видим, статистику узнать сейчас может любой желающий, так что этот пункт тоже отпадает.
**4. Недавняя DDoS-атака была «предложением к диалогу», и нововведения — один из пунктов достигнутого соглашения.**
Сложно комментировать из-за недостатка информации.
**5. Хитроумная попытка развалить ресурс изнутри, «бэз пылу, бэз шуму».**
Судя по последствиям, трекер таки сдуется через год-другой, если будет продолжать следовать нынешним путём. Так что вероятие такое есть. Хотя эта комбинация слишком сложная для действий полиции. Обычно товарищи в форме ограничиваются изъятием чего-нить материального на предмет экспертиз и прочих отпечатков.
**6. Как это ни пародоксально, отмена рейтинга может даже быть положительной в том плане, что пользователь будет держать на раздаче не «попсу», на которой часто зарабатывался рейтинг, а нечто действительно нужное и ценное.**
Как ни парадоксально, но с этой целью можно было бы ввести дополнительные плюшки (и вместе с тем адекватно ужесточить правила). Чтобы и любителей попсы не обидеть, и избежать кладбищенской тиши в разделах с «редкими раздачами». С другой стороны, всем известно, что пока раздел «прон»а не был вынесен на отдельный сайт, рейтинг поднимали в основном за счёт порева. И админов это не волновало… Сейчас же половина новинок банится копирастами ещё на подлёте, так что даже на «попсе» особо не наподымаешь.
**7. Попытка пресечь пагубную практику постоянной перерегистрации некоторых пользователей.**
Если честно, ТРУ — единственный трекер, наверное, чья администрация выглядит совершенно беспомощно в отношении мультиакков, читерства и т. д. Имхо, если нет желания — находятся оправдания, а при наличии желания — появляются «внезапные» возможности. Сдаётся мне, что администрации просто выгодно такое положение вещей. Хотя в технические вопросы я не вникал, но можно же сменить движок трекера, ввести дополнительные системы защиты от мультиводов и т. д. А вместо этого админы радостно распустили группу «античитеров» (а заодно и группу Top User-ов упразднили). И это с их точки зрения поможет навести порядок в этом вопросе? Ну-ну…
**8. Скорей всего, тут кроется другая причина, о которой нам боятся написать.**
No Comments.
Как видим, причины до сих пор покрыты мраком. Возможно хоть по истечении полугода официальный представитель ТРУ на Хабре даст внятное объяснение произошедшему...
**2. Почему это случилось столь внезапно?**Самым странным для меня лично было отсутствие соответствующего топика в «Новостях трекера» — на главной странице. Поздравления с Новым годом — пожалуйста, присутствуют. Объявления о начале и отмене фрилича тоже можно найти в архиве новостей. Даже поздравление с 23-м февраля есть. А для такого поворотного для трекера события места на главной не нашлось…
В 1-м номере журнала «Rutracker Magazine», затрагивалась, кстати, тема фрилича (в интервью с админом Apic):
> — Ну а теперь самый страшный и часто обсуждаемый вопрос: когда закончится фрилич?
>
> — Странный вопрос :). Никогда.
>
> Пачаму?
>
> В общем, главная причина для введения подобного решения заключается в постоянной перерегистрации пользователей, спустя месяц живы были около 8% зарегистрировавшихся и так ежемесячно. Т.е. из 100 зарегистрировавшихся спустя месяц 92 аккаунта уже были брошены. А без рейтинга количество перерегистраций снизилось и весьма значительно.
Хм… Стоп. «Без рейтинга»?.. То есть, как? Вроде на момент выхода журнала (19 февраля) рейтинг присутствовал. Как минимум напротив пункта «Рейтинг» в профиле были конкретные цифры вместо теперешней ссылки [Куда делся рейтинг?](http://rutracker.org/forum/viewtopic.php?t=3956322). Оговорка по Фрейду?
**3. Почему не было голосования?**Понятно, что для администрации «голосовалки» — чистая формальность. Но почему-то перед введением гораздо менее важных изменений админы не ленились поинтересоваться мнением пользователей, а здесь наоборот — все народные попытки провести «соцопрос» гасились на корню… Загадочно, ей-богу. Ведь практика опросов — обычное дело для ТРУ. Поневоле склоняешься к тому, что «у этого шага были веские причины». И при этом админам было важно, чтобы отмена рейтинга состоялась в сжатые сроки. Но вот почему?..
**4. Как сказалась отмена рейтинга на жизни ТРУ?**Самое смешное, что ничего вроде и не поменялось в итоге. То есть, ушли в небытие таймбонусы и просто бонусы. Зато появилась графа отданного «на редких» релизах. В целом, таблицу статистики просто перевернули зачем-то на бок…
Как-то символично это: последствия урагана, не иначе.
И да! Таки исчез показатель рейтинга, который теперь каждый желающий может вычислить сам, поделив данные графы «Отдано» на значение показателя «Скачано». Можно было бы предположить, что это сделано с целью поднять арифметическую грамотность среди пользователей ТРУ, но верится в это с трудом.
В общем, не изменилось ничего, кроме того, что качать теперь можно сколько влезет без необходимости раздавать.
Кстати, во 2-м номере журнала “Rutracker Magazine” (в интервью с админом t@v) затрагивался вопрос релизов:
> – Почему тебе нравится релизить?
>
> – Однозначно ответить невозможно. Пришел ещё на torrents.ru в основном за аудиокнигами. Начал релизить, когда понял, что рейтинг падает, а качать хотелось.
Надо же! Админа ТРУ в своё время встать на тропу релизёра заставило не чувство солидарности, совесть и прочие филантропские заморочки, а банальная необходимость поддерживать рейтинг. Внезапно!
Самое смешное, что в том же журнале “Rutracker Magazine” (первый номер) есть статья «Зачем мы создаем релизы?» Где прямым текстом раскрывается всё тот же секрет Полишинеля (здесь **только начало** этой статьи, которую можно прочесть целиком в журнале):
> Вы когда-нибудь задумывались над вопросом: зачем люди создают раздачи на торрент-трекерах? Ведь это затраченные время и силы на поиск или создание материала, его оформление, сидирование.
>
> В психологии выделяют несколько ключевых источников мотивации: самоутверждение (статус/тщеславие), конкуренция (зависть), удовольствие от процесса, внешние обстоятельства (**например, рейтинг**), страх, саморазвитие, свобода (независимость), принадлежность (сопричастность), интерес/выгода, власть и т.д.
>
> Очень условно можно выделить четыре основные категории пользователей торрент-трекеров:
>
> 1. Халявщик. Его принцип — скачал и свалил, чисто потребительский подход. Такие люди останавливают раздачу в клиенте сразу после завершения загрузки и очень редко создают собственные раздачи. А вот сообщений на форуме оставляют много и часто флудят. Что же заставляет таких людей все-таки остаться на раздаче и создать пару-тройку собственных?
>
> Ответ прост – страх и различные внешние причины (**рейтинги, таймбонусы**, запреты, баны и т. д). К сожалению, «халявщиков» становится все больше, особенно после введения на rutracker.org фрилича.
То есть, с одной стороны администрация признаёт важность присутствия «кнута» рейтинга, а с другой — заявляет, что это атавизЬм и дело житейское. Имхо, для определения подобного поведения используется термин шизофрения.
В общем, в данный момент феномен рутрекера мог бы послужить материалом для диссертации «ТРУ как зеркало сетевого коммунизма». Ибо судя по всему, администрация считает, что загадочные механизмы саморегулирования и не менее загадочная «совесть» пользователей помогут сохранить виртуальный трон ТРУ. Имхо, анонимус на такое просто рассмеётся в Web-интер**фейс**.
Помнится, года три-четыре назад, если знакомым надо было найти не информацию, а контент, их можно было смело перенаправлять не в гуглепоиск, а на ТРУ. Потому что, если не было книги или фильма на ТРУ, то с 99% вероятностью их вообще было не найти в рунете. Сейчас ситуация сильно изменилась. Да-да, раньше и солнышко ярче светило, и травка зеленее была, знаю. Но тем не менее. По моим субъективным наблюдениям количество новых релизов неуклонно уменьшается.
Для демонстрации последствий отмены рейтинга я просто приведу скриншоты раздач из не самых популярных разделов ТРУ. При этом на скринах представлены новинки соответствующих разделов (релизы упорядочены по времени размещения). Признаюсь, такой удручающей картины я никогда не наблюдал: сидируют единицы, часть раздач вообще умирает…
[**Experimental (lossy)**](http://upyourpic.org/images/201209/tc1uew6yu6.jpg)
[**Документальные фильмы и телепередачи » Кинематограф**](http://upyourpic.org/images/201209/83pr4uy9of.jpg)
[**Этническая музыка Индии (lossless)**](http://upyourpic.org/images/201209/udw4qrdprl.jpg)
К модераторам появляется всё больше вопросов относительно поддержания банального порядка на форуме. Если раньше им возможно времени не хватало на удаления мата и рекламного спама (просто потому что приходилось проверять кучу новых раздач каждый день). То чем они заняты теперь — загадка…
Тем более, что на форуме в последнее время наблюдаю спад активности. Процветают только топики, скромно помещённые в раздел «Для общения пользователей других ресурсов»:
[](https://habrastorage.org/getpro/habr/post_images/268/558/85a/26855885ae533aaf495201d41fb80978.jpg)
**5. Что ожидает ТРУ в будущем?**В принципе, уже несколько лет назад стало очевидно, что ТРУ достиг своего пика (в том, виде, в котором он существовал) и требуются некие перемены, корректирующие вектор развития ресурса. Сродни пересмотру менеджмента в стартапе, достигшем размеров корпорации. С первого взгляда может показаться, что администрация ТРУ совершает телодвижения в сторону большей открытости и снижения порога доступности трекера. Но все подобные изменения на уровне правил разбиваются об устаревшие принципы модерации и премодерации. Когда бесчисленные придирки к оформлению и прочее «следование букве» (вспомним хотя бы историю с помещением сериала «Сцена» / «The.Scene» в раздел **Разное » Разное » Видео**) убивают желание релизить. Уже сейчас количество новых книг, выкладывающихся на рутрекер, упало в разы. Если раньше на [www.mirknig.com](http://www.mirknig.com), например, были сплошь переливы с ТРУ, то теперь дай бог, чтобы с «мира книг» перелили на рутрекер хотя бы десятую часть новинок…
Подытоживая, можно сказать следующее: ТРУ всё больше приближается к некоему сетевому аналогу библиотечного «спецхрана» (с российской спецификой). Новинки появляются позже, чем на сайтах-конкурентах (или вообще не появляются). Раздачи закрываются левообладателями. Плюс — процветает поощряемая идеология «hit and run».
Имхо, есть несколько вариантов будущего рутрекера.
**1. Узкоспециализированный архив (а-ля музейный запасник релизов).**
Это не самый плохой вариант. Новинок в сети хватает. А вот старых телевизионных передач, артхаусных редкостей и прочих ненужных обычному юзернейму вещей за пределами ТРУ можно и не найти. Скачать подобные эксклюзивы на рутрекере зачастую было непросто, а сейчас — и подавно. Но всё-таки есть шанс достучаться до релизёра (если не забанен) или счастливцев, успевших затариться в лучшие времена, и попросить вернуться на раздачу. Если админы рутрекера направят свои усилия на сохранение раритетных материалов, выиграют все. Да, ТРУ придётся отказаться от имиджа «трекера всея рунет», но он хотя бы не скапустится совсем.
**2. Площадка в сети для властьимущих.**
А что? Будут «авторские раздачи» рекламных роликов правящей партии. Или, если не так толсто, логирование релизёрских телодвижений компетентными органами — на будущее. Уже давно ведь есть подозрения, что ТРУ сотрудничает не только с копирастами. Сначала наобъяснимая привязанность к зоне ".ру" (что особенно странно после событий с выпиливанием домена torrents.ru, после чего uniongang и tfile, например, срочно переехали в зоны .TV и .me соответственно). Потом — загадочная фраза админа в интервью журналу “Rutracker Magazine” (номер 02):
> — Рутрекер пережил многое: смену домена, ддос, пожар в дата центре, взломы и т.д., и всегда решал проблемы достаточно быстро, в течение нескольких дней, в чём секрет такого жизнелюбия?
>
> – Есть у меня определенные соображения на этот счёт, но, они не для публикации.
Опять же, вспомним об открытии на ТРУ представительства «Пиратской партии», что на фоне всяческого прогибательства перед копирастами выглядит несколько… кхм… непоследовательно. Зато у кое-кого появляется прекрасная возможность для всяческих «вбросов» и прочих провокаций.
**3. Нечто третье.**
Как известно, администрация ресурса страдает внезапностью. Поэтому что за фортель ждёт пользователей завтра — никому не известно. Возможно, трекер попробуют реанимировать очередным диковинным способом. Посмотрим...
**Доп. материалы****Screenlist**
Здесь я собирался предоставить разбитый на несколько категорий (к которым можно было отнести большинство комментариев) «отчёт в скриншотах». Но понял, что действие это будет избыточным: архив обсуждения пока на месте. А лепить скриншоты просто в угоду идеи оформления поста в виде релиза… как минимум лень.
Да и обвинения в предвзятости мне ни к чему. Каждый может вынести собственные умозаключения на основании личных наблюдений, имхо.
**Ссылки**
### 1. Обсуждения:
* [О введении системы таймбонусов и отмене фрилича (обсуждение)](http://rutracker.org/forum/viewtopic.php?t=2892713)
* [Куда делись рейтинг и часть статистики?](http://rutracker.org/forum/viewtopic.php?t=3958317)
* [Архив: Куда делись рейтинг и часть статистики… ой и бонусы?](http://rutracker.org/forum/viewtopic.php?t=3961896)
* [Архив: Куда делись рейтинг и статистика? / Куда делась часть раздач из профиля?](http://rutracker.org/forum/viewtopic.php?t=3957030)
* [Архив-2: Куда делись рейтинг и статистика? / Куда делась часть раздач из профиля?](http://rutracker.org/forum/viewtopic.php?t=3957735)
### 2. Тематические ссылки:
* [Статистика трекера](http://rutracker.org/forum/viewtopic.php?p=51418728#51418728)
* [Журнал Rutracker Magazine (2 номера)](http://rutracker.org/forum/viewtopic.php?t=3949538)
**Зарезервировано**Вот уже ~~десять дней~~ полгода (что символично) я жду обещанного комментария от бывшего модератора ТРУ **Scarabey**. ~~Я надеюсь, что есть объективные причины для этой задержки, и в конце концов мы узнаем, что думает по поводу отмены рейтинга и т. п. **Scarabey**. Поэтому просто зарезервировал место.~~
Уважаемому Scarabey видимо наплевать на свои обещания. Так что «кина не будет», сори.
##### Чем стала отмена рейтинга лично для меня
По большому счёту я только выиграл. Раритетных кинов и т. п. я успел натащить ещё с торрентс.ру полные карманы (дай бог всё пересмотреть теперь). А ощущение начала конца рутрекера заставило начать искать пути на закрытые зарубежные аналоги (хотя аналогов ТРУ на Западе таки нет, регистрация на трёх-пяти специализированных англоязычных трекерах удовлетворила большую часть моих запросов).
Параллельно зарегистрировался на нескольких перспективных трекерах-конкурентах в рунете. Так что скачать могу что угодно, минуя ТРУ. Боюсь, наступят времена, когда это мне сильно пригодится…
##### Некоторые мысли в заключение, или попытка послесловия
Я буду здесь писать ещё более банальные вещи, готовьтесь. Итак, что нам дают наблюдения за curriculum vitae rutracker.org?
Во-первых, в условиях усиливающегося давления копирастов, «классический» (трекерный) р2р-файлообмен сдаёт позиции. Причин несколько. Вот основные, имхо:
1. Сложно скрыть личность владельцев трекера. Ведь на хостинг и прочие дела нужны деньги. Трекеров, существующих исключительно за счёт некоего анонимного мецената, я не знаю. Соответственно, нужен донат (или реклама). А это значит, потянутся финансовые ниточки, которые в конце концов приведут к владельцам. И [как показывает практика](http://habrahabr.ru/post/150879/), достать их можно будет откуда угодно. Здесь можно было бы вспомнить об альтернативных способах оплаты. Криптовалюта и т. д. Но этим системам вряд ли дадут получить широкое распространение — судя по планомерной дискредитации Bitcoin (см. [очередной пример](http://habrahabr.ru/post/151034/)).
2. В «классической» схеме р2р-файлообмена есть слабое звено — сайт, он же торрент-трекер. Его можно заддосить, взломать, прекратить делигирование доменного имени и т. д.
Этих двух пунктов уже хватает с головой, имхо. Есть ли варианты? На мой взгляд, живучее других будут реально закрытые трекеры, информация о самом существовании которых попадёт в поле зрения левообладателей в последнюю очередь. Опять же, можно вспомнить [бестрекерные (trackerless) системы](https://ru.wikipedia.org/wiki/BitTorrent#.D0.A0.D0.B0.D0.B1.D0.BE.D1.82.D0.B0_.D0.B1.D0.B5.D0.B7_.D1.82.D1.80.D0.B5.D0.BA.D0.B5.D1.80.D0.B0).
Невзирая на возрастающее давление, всё ещё держится на плаву [eD2k](https://ru.wikipedia.org/wiki/EDonkey2000_(%D1%81%D0%B5%D1%82%D1%8C)). Не без помощи правообладателей потихоньку просыпается интерес пользователей к [частично или полностью децентрализованным анонимным сетям](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%BE%D0%BD%D0%B8%D0%BC%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8)
Понятно, что будущее у файлообмена есть. Вопрос, в какую сторону смотреть нашему брату-юзеру, оказавшемуся в данный момент на распутьи…
***ЗЫ***
`<романтический offtop>`
А давайте представим, что в феврале этого года мы стали свидетелями реструктуризации и ухода в подполье ТРУ…
А что? Не секрет, что есть закрытый форум для обладателей лычек и прочих «званий». Могли же они договориться и провернуть операцию прикрытия (отмену рейтинга), а сами под шумок уйти на несколько заранее созданных секретных специализированных трекеров. Трекеры эти закрытые в буквальном смысле, попасть на них практически нельзя. Материалы раздач понемногу выкладываются на другие трекеры, для чего есть специальная команда законспирированных «гонцов». На ТРУ они тоже релизят. Но только для того, чтобы поддерживать видимость жизнедеятельности ресурса. В сценарии предусмотрена постепенная смерть трекера «от естественных причин». Автоматически отпадут и проблемы с левообладателями, спецслужбами и т. д. Но контент будет жить…
Да, фантазия у меня буйная =).
На этой опти*мистической* ноте мои дилетантские рассуждения обрываются. Я не разбирался в технических вопросах, не вникал в детали. Это просто взгляд с точки зрения обывателя — обычного пользователя трекера. И писался пост скорее для таких же пользователей, которые вряд ли зарегестрированы на Хабре. Но теперь у них есть шанс почитать интересные комментарии (на что я очень надеюсь) профессионалов, то есть вас, дорогие хабровчане.
***ЗЗЫ***
Сомнительные красоты «оформления под релиз» подразумевали просмотр на обычном мониторе (с соотношением сторон 5:4). Как это выглядит на широкоформатных мониторах и гаджетах даже не представляю. Поэтому заранее (точнее запоздало) приношу извинения за толику экстравагантности — возможно в ущерб читабельности.
**ЗЗЫЫ** | https://habr.com/ru/post/150843/ | null | ru | null |
# Документируем ошибки в Doxygen
В этой статье речь пойдет о проверке системы документирования doxygen. Этот известный и широко используемый проект, по имеющему основания заявлению разработчиков, ставший фактически стандартом для документирования программного обеспечения, написанного на языке C++, еще не был проверен PVS-Studio. Doxygen просматривает исходный код программ и генерирует по нему документацию. Пришло время нам заглянуть в его исходники и посмотреть, что сможет найти PVS-Studio.
Введение
--------
Doxygen — кроссплатформенная система документирования исходных текстов, которая имеет широкий набор целевых языков: C++, C, Objective-C, Python, Java, C#, PHP, IDL, Fortran, VHDL и частично поддерживает D. Doxygen генерирует документацию на основе исходных текстов с комментариями особого вида и может быть настроен на извлечение структуры программы с недокументированными исходниками. Выходными форматами могут быть HTML, LATEX, man, rtf, xml. Doxygen используется в проектах KDE, Mozilla, Drupal, Pidgin, AbiWorld, FOX toolkit, Torque Game Engine, Crystal Space.
Подготовка и проверка
---------------------
Самые свежие исходники doxygen могут быть взяты с [github.com/doxygen/doxygen](https://github.com/doxygen/doxygen). Изначально репозиторий не содержит проектных файлов для Visual Studio, но так как разработчики используют cmake, то их можно сгенерировать. Я воспользовался консольной версией программы и командой «cmake -G „Visual Studio 12“» для генерации проектного файла для VS 2013. Для запуска проверки достаточно нажать Check Solution во вкладке PVS-Studio в Visual Studio.
Анализ предупреждений
---------------------
Перед непосредственным разбором предупреждений хочется обратить внимание на стиль написания doxygen. Зачастую в коде программист по непонятным причинам стремился уложить все в одну строку или пренебрегал пробелами между переменными и операторами, что существенно снижало читаемость кода. В некоторых местах попадалось странное форматирование. А порой встречалось и [такое](https://goo.gl/LTzGXn). Чтобы уместить некоторый код в статье, мне пришлось отформатировать его. После небольшого отступления предлагаю посмотреть на самые интересные ошибки, найденные в doxygen.
Предупреждение PVS-Studio: [V519](http://www.viva64.com/ru/d/0108/) The '\* outListType1' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 8326, 8327. util.cpp 8327
```
void convertProtectionLevel(MemberListType inListType,
int *outListType1,
int *outListType2)
{
static bool extractPrivate;
....
switch (inListType)
{
....
case MemberListType_priSlots:
if (extractPrivate)
{
*outListType1=MemberListType_pubSlots;
*outListType1=MemberListType_proSlots; <<<<====
}
else
{
*outListType1=-1;
*outListType2=-1;
}
break;
....
}
}
```
В теле if содержится двойное присваивание одной и той же переменной. Очевидно, что это опечатка или ошибка при копировании. Блок else подсказывает, что значение «MemberListType\_proSlots» должно быть записано в "\*outListType2". Ещё одну подобную ошибку можно найти здесь: doxygen.cpp 5742 (см. переменную 'da->type').
Следующее предупреждение PVS-Studio: [V519](http://www.viva64.com/ru/d/0108/) The 'pageTitle' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 970, 971. vhdldocgen.cpp 971
```
QCString VhdlDocGen::getClassTitle(const ClassDef *cd)
{
QCString pageTitle;
if (cd == 0)
return "";
pageTitle += cd->displayName();
pageTitle = VhdlDocGen::getClassName(cd);
....
}
```
Обратите внимание на операцию присваивания. Скорее всего, это опечатка и вместо "=" должно использоваться "+=". К вопросу о стиле, в исходном коде эта функция не содержит пробелов между операторами и значениями, что существенно ухудшает читаемость кода. Это увеличивает шанс возникновения ошибки, так как тяжело увидеть отсутствие "+" среди непрерывного потока символов. После добавления пробелов ошибка становится более заметной. Еще одна похожая ошибка прячется тут:
V519 The 'nn' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 2166, 2167. vhdldocgen.cpp 2167
Перейдем к следующему предупреждению.
Предупреждение PVS-Studio: [V523](http://www.viva64.com/ru/d/0112/) The 'then' statement is equivalent to the 'else' statement. docparser.cpp 521
```
static void checkUndocumentedParams()
{
....
if (g_memberDef->inheritsDocsFrom())
{
warn_doc_error(g_memberDef->getDefFileName(),
g_memberDef->getDefLine(),
substitute(errMsg,"%","%%"));
}
else
{
warn_doc_error(g_memberDef->getDefFileName(),
g_memberDef->getDefLine(),
substitute(errMsg,"%","%%"));
}
....
}
```
Метод программирования copy-paste может не только сэкономить время при написании кода, но и привнести в него ошибки. Здесь код из блока if был скопирован для использования в блоке else, но не изменен после вставки. При каждом использовании copy-paste следует придерживаться правила «Один раз скопируй, семь раз проверь».
Предупреждение PVS-Studio: [V523](http://www.viva64.com/ru/d/0112/) The 'then' statement is equivalent to the 'else' statement. translator\_tw.h 769
```
class TranslatorChinesetraditional : public Translator
{
public:
....
virtual QCString trGeneratedFromFiles(bool single, ....)
{
....
QCString result=(QCString)"?";
....
if (single) result+=":"; else result+=":";
....
}
....
}
```
Аналогичное предыдущему предупреждение. В блоке if в независимости от условия к строке result прибавляется один и тот же символ. Вряд ли это ожидаемое поведение, ведь тогда само условие не имеет смысла. И снова я склоняюсь к тому, что если бы, следуя общепринятому стилю, этот блок был разнесен на 4 строки, то он не просто бы выглядел красивее, но и сделал бы опечатку более очевидной. Интересно, что эта конструкция была дважды скопирована для дальнейшего использования в функциях, но ошибка так и не была замечена. В итоге еще два предупреждения приходятся на эти строчки:* V523 The 'then' statement is equivalent to the 'else' statement. translator\_tw.h 1956
* V523 The 'then' statement is equivalent to the 'else' statement. translator\_tw.h 1965
Предупреждение PVS-Studio: [V530](http://www.viva64.com/ru/d/0119/) The return value of function 'toupper' is required to be utilized. classdef.cpp 1963
```
void ClassDef::writeDocumentationContents(....)
{
QCString pageType = " ";
pageType += compoundTypeString();
toupper(pageType.at(1));
....
}
```
Тут программистом был неверно понят принцип работы функции toupper. Возможно, он ожидал, что функция изменит переданный символ на заглавную букву. На самом деле функция возвращает заглавный эквивалент символа-аргумента, а не изменяет его. Вот как объявлена функция toupper в заголовочном файле «ctype.h».
```
int toupper (int __c);
```
Уже из объявления функции видно, что параметр принимается по значению, а значит переданный символ не может быть изменен. Чтобы не допускать таких ошибок, достаточно внимательно читать описание к используемым функциям, в поведении которых вы не уверены.
Предупреждение PVS-Studio:
[V560](http://www.viva64.com/ru/d/0153/) A part of conditional expression is always false: (flags() &!0x0008). qfile\_win32.cpp 267
```
#define IO_Truncate 0x0008
bool QFile::open(....)
{
....
int length = INT_MAX;
if ((flags() & !IO_Truncate) && length == 0 && isReadable())
....
}
```
Данное условие всегда будет ложным из-за того, что логическое отрицание ненулевого значения всегда дает ноль. Последующее применение «И» не имеет значения, когда один из аргументов является нулем. В результате условие не зависит от остальных параметров. Более логичным здесь кажется использование оператора побитовой инверсии '~'.
Предупреждение PVS-Studio: [V560](http://www.viva64.com/ru/d/0153/) A part of conditional expression is always true: !found. util.cpp 4264
```
bool getDefs(....)
{
....
bool found=FALSE;
MemberListIterator mmli(*mn);
MemberDef *mmd;
for (mmli.toFirst();((mmd=mmli.current()) && !found);++mmli)
{
....
}
....
}
```
Сразу скажу, что в теле цикла for переменная found не изменяется. Из-за этого условие выхода из цикла зависит только от результата метода mmli.current. Это чревато тем, что цикл всегда будет проходить от начала до конца в независимости от того, было ли найдено искомое значение или нет.
Предупреждение PVS-Studio:
[V595](http://www.viva64.com/ru/d/0205/) The 'bfd' pointer was utilized before it was verified against nullptr. Check lines: 3371, 3384. dot.cpp 3371
```
void DotInclDepGraph::buildGraph(....)
{
....
FileDef *bfd = ii->fileDef;
QCString url="";
....
url=bfd->getSourceFileBase();
....
if (bfd)
....
}
```
V595 является, пожалуй, самым распространенным предупреждением среди всех проектов. Не всегда перед использованием указателя задумываешься, может ли он быть нулевым. Порой об этом вспоминаешь после второго или третьего использования и ставишь проверку. Но между ней и первым разыменованием может быть очень большое количество кода, что делает ошибку весьма трудной для обнаружения. Аналогичные предупреждения:* V595 The 'cd' pointer was utilized before it was verified against nullptr.
Check lines: 6123, 6131. doxygen.cpp 6123
* V595 The 'p' pointer was utilized before it was verified against nullptr.
Check lines: 1069, 1070. htmldocvisitor.cpp 1069
* V595 The 'Doxygen::mainPage' pointer was utilized before it was verified against nullptr.
Check lines: 3792, 3798. index.cpp 3792
* V595 The 'firstMd' pointer was utilized before it was verified against nullptr.
Check lines: 80, 93. membergroup.cpp 80
* V595 The 'lastCompound' pointer was utilized before it was verified against nullptr.
Check lines: 410, 420. vhdljjparser.cpp 410
* V595 The 'len' pointer was utilized before it was verified against nullptr.
Check lines: 11960, 11969. qstring.cpp 11960
* V595 The 'len' pointer was utilized before it was verified against nullptr.
Check lines: 11979, 11988. qstring.cpp 11979
* V595 The 'fd' pointer was utilized before it was verified against nullptr.
Check lines: 2077, 2085. doxygen.cpp 2077
Предупреждение PVS-Studio:
[V595](http://www.viva64.com/ru/d/0205/) The 'lne' pointer was utilized before it was verified against nullptr. Check lines: 4078, 4089. index.cpp 4078
```
static void writeIndexHierarchyEntries(OutputList &ol, ....)
{
QListIterator li(entries);
LayoutNavEntry \*lne;
for (li.toFirst();(lne=li.current());++li)
{
LayoutNavEntry::Kind kind = lne->kind();
....
bool addToIndex=lne==0 || lne->visible();
....
}
}
```
Я не описываю однотипные проверки, потому что они слишком скучны для статьи. Тем не менее я хочу рассмотреть ещё одно предупреждение V595. Здесь вход в цикл осуществляется, только если возвращаемое значение li.current() (которое присваивается указателю lne) будет не NULL. Это значит, что внутри цикла указатель гарантированно не будет нулевым, делая последующую проверку ненужной. Мне захотелось выписать этот пример, потому что обычно предупреждение V595 указывает на потенциальное разыменование нулевого указателя, а здесь оно показало лишнюю проверку.
Предупреждения анализатора: [V601](http://www.viva64.com/ru/d/0212/) The bool type is implicitly cast to the class type. docsets.cpp 473
```
struct IncludeInfo
{
....
bool local;
};
void DocSets::addIndexItem(Definition *context,MemberDef *md,
const char *,const char *)
{
QCString decl;
....
IncludeInfo *ii = cd->includeInfo();
....
decl=ii->local;
....
}
```
Анализатор обратил внимание на странное приведение bool к типу класса. В классе QCString не определен перегруженный оператор присваивания для аргумента типа bool, но определен конструктор с входным параметром типа int, который обозначает размер строки. Именно он вызывается для создания временного объекта при данном присваивании. Компилятор найдет конструктор с аргументом int и вызовет его, предварительно преобразовав bool к int. Переменная local может иметь только 2 значения: true или false, что соответствует 1 и 0. В первом случае конструктором будет создана строка из одного элемента. Во втором случае получится пустая строка. В конце будет вызван оператор присваивания с аргументом типа QCString. Похожее, но менее очевидное приведение осуществляется в следующих местах:* V601 The bool type is implicitly cast to the class type. Inspect the fifth argument. context.cpp 2315
* V601 The bool type is implicitly cast to the class type. Inspect the fifth argument. context.cpp 2675
* V601 The bool type is implicitly cast to the class type. Inspect the fifth argument. context.cpp 4456
Предупреждение PVS-Studio: [V614](http://www.viva64.com/ru/d/0230/) Potentially uninitialized pointer 't' used. vhdlparser.cc 4127
```
QCString VhdlParser::extended_identifier()
{
Token *t;
if (!hasError)
t = jj_consume_token(EXTENDED_CHARACTER);
return t->image.c_str();
assert(false);
}
```
В этом участке кода возможно разыменование неинициализированного указателя. Реальный код плохо оформлен, поэтому эта ошибка и осталась незамеченной. Для статьи я отформатировал код и ошибка стала сразу хорошо заметна. Еще две таких ошибки можно найти здесь:* V614 Potentially uninitialized pointer 'tmpEntry' used. vhdlparser.cc 4451
* V614 Potentially uninitialized pointer 't' used. vhdlparser.cc 5304
Предупреждение PVS-Studio: [V668](http://www.viva64.com/ru/d/0293/) There is no sense in testing the 'file' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. outputgen.cpp 47
```
void OutputGenerator::startPlainFile(const char *name)
{
....
file = new QFile(fileName);
if (!file)
....
}
```
Ни для кого уже не новость, что new в случае неудачного выделения памяти выбрасывает исключение, а не возвращает nullptr. Этот код — своеобразный архаизм программирования. Для современных компиляторов эти проверки больше не имеют смысла, их можно удалить. Еще 3 таких проверки:* V668 There is no sense in testing the 'expr' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. template.cpp 1981
* V668 There is no sense in testing the 'n' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. qglist.cpp 1005
* V668 There is no sense in testing the 'nd' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. qstring.cpp 12099
Предупреждение PVS-Studio: [V701](http://www.viva64.com/ru/d/0340/) realloc() possible leak: when realloc() fails in allocating memory, original pointer 'd' is lost. Consider assigning realloc() to a temporary pointer. qcstring.h 396
```
class BufStr
{
public:
....
void resize(uint newlen)
{
....
m_buf = (char *)realloc(m_buf,m_size);
....
}
private:
uint m_size;
char *m_buf;
....
}
```
Анализатор обнаружил неправильное использование функции «realloc». При неудачном выделении памяти «realloc» вернет nullptr, перезаписав предыдущее значение указателя. Чтобы предотвратить это, рекомендуется сохранять значение указателя во временной переменной перед использованием «realloc». Всего, помимо этой, в проекте было найдено 8 потенциальных утечек памяти:* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'd' is lost. Consider assigning realloc() to a temporary pointer. qcstring.h 396
* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'str' is lost. Consider assigning realloc() to a temporary pointer. growbuf.h 16
* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'str' is lost. Consider assigning realloc() to a temporary pointer. growbuf.h 23
* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'str' is lost. Consider assigning realloc() to a temporary pointer. growbuf.h 33
* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'm\_str' is lost. Consider assigning realloc() to a temporary pointer. vhdlstring.h 61
* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'shd->data' is lost. Consider assigning realloc() to a temporary pointer. qgarray.cpp 224
* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'm\_data' is lost. Consider assigning realloc() to a temporary pointer. qgstring.cpp 114
* V701 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'm\_data' is lost. Consider assigning realloc() to a temporary pointer. qgstring.cpp 145
Заключение
----------
В заключении хочется сказать, что анализатор прекрасно справился со своей работой и нашел много подозрительных мест, несмотря на то, что doxygen является популярным проектом и широко используется большим количеством как мелких, так и крупными компаниями. Я привел самые основные предупреждения и оставил такие неинтересные, как лишние проверки, неиспользуемые переменные и т.п. за рамками данной статьи. Стоит упомянуть, что в некоторых местах меня удивило весьма небрежное, по моему мнению, оформление кода.
Хочется пожелать читателям писать красивый, читаемый код и не допускать ошибок. И если первое целиком зависит от программиста, то со вторым может помочь анализатор. Скачать и бесплатно попробовать PVS-Studio на своем проекте можно здесь: <http://www.viva64.com/ru/pvs-studio-download/>
[](http://www.viva64.com/en/b/0345/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Igor Shtukarev. [Documenting Bugs in Doxygen](http://www.viva64.com/en/b/0345/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/265025/ | null | ru | null |
# ES6: полезные советы и неочевидные приёмы
Стандарт EcmaScript 2015 (ES6) существует уже несколько лет. Он принёс с собой множество новых возможностей, разные способы использования которых далеко не всегда очевидны. Вот обзор некоторых из этих возможностей с примерами и комментариями.
[](https://habrahabr.ru/company/ruvds/blog/352128/)
1. Обязательные параметры функции
---------------------------------
ES6 позволяет [задавать](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters) значения формальных параметров по умолчанию, что позволяет, при вызове функции без указания значений этих параметров, подставлять их стандартные значения. Это позволяет задавать параметры, без передачи которых функция работать не будет.
В следующем примере мы задаём функцию `required()` как значение по умолчанию для параметров `a` и `b`. Это означает, что если `a` или `b` не будут переданы функции при вызове, будет вызвана функция `required()` и мы получим сообщение об ошибке.
```
const required = () => {throw new Error('Missing parameter')};
//При вызове этой функции произойдёт ошибка, если параметры "a" или "b" не заданы
const add = (a = required(), b = required()) => a + b;
add(1, 2) //3
add(1) // Error: Missing parameter.
```
2. Секреты метода reduce
------------------------
Метод [reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) объекта `Array` чрезвычайно универсален. Обычно его используют для преобразования массива неких элементов к единственному значению. Однако с его помощью можно сделать ещё очень много всего полезного.
Обратите внимание на то, что в следующих примерах мы полагаемся на то, что исходное значение переменной — это либо массив, либо объект, а не нечто вроде строки или числа.
### ▍2.1. Использование reduce для одновременного выполнения мэппинга и фильтрации массива
Представим, что перед нами стоит следующая задача. Имеется список элементов, каждый из которых надо модифицировать (что сводится к использованию метода [map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)), после чего отобрать из него несколько элементов (это можно сделать с помощью метода [filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)). Эта задача вполне решаема последовательным применением методов `map` и `filter`, но так по списку элементов придётся пройтись дважды. А нас это не устраивает.
В следующем примере нужно удвоить значение каждого элемента в массиве, после чего — отобрать лишь те из них, которые больше 50. Обратите внимание на то, как мы можем использовать мощный метод `reduce` и для удвоения, и для фильтрации элементов. Это очень эффективно.
```
const numbers = [10, 20, 30, 40];
const doubledOver50 = numbers.reduce((finalList, num) => {
num = num * 2; //удвоить каждое число (аналог map)
//отобрать числа > 50 (аналог filter)
if (num > 50) {
finalList.push(num);
}
return finalList;
}, []);
doubledOver50; // [60, 80]
```
### ▍2.2. Использование reduce вместо map или filter
Если вы проанализировали вышеприведённый пример, то для вас окажется совершенно очевидной возможность использования метода `reduce` вместо `map` или `filter`.
### ▍2.3. Использование reduce для анализа расстановки скобок
Вот ещё один пример полезных возможностей метода `reduce`.
Предположим, что у нас имеется строка со скобками, и нам нужно узнать, сбалансированы они, то есть, во-первых, равно ли количество открывающих скобок скобкам закрывающим, и, во-вторых, то, что соответствующие открывающие скобки находятся перед закрывающими.
Эту задачу можно решить с помощью метода `reduce` так, как показано ниже. Тут мы используем переменную `counter` с начальным значением, равным 0. Мы увеличиваем её значение на единицу, если находим символ «(», и уменьшаем, если находим символ «)». Если скобки в строке сбалансированы, на выходе должен получиться 0.
```
//Возвращает 0 если скобки сбалансированы.
const isParensBalanced = (str) => {
return str.split('').reduce((counter, char) => {
if(counter < 0) { //matched ")" before "("
return counter;
} else if(char === '(') {
return ++counter;
} else if(char === ')') {
return --counter;
} else { //найден какой-то другой символ
return counter;
}
}, 0); //<-- начальное значение для счётчика
}
isParensBalanced('(())') // 0 <-- скобки сбалансированы
isParensBalanced('(asdfds)') //0 <-- скобки сбалансированы
isParensBalanced('(()') // 1 <-- скобки несбалансированы
isParensBalanced(')(') // -1 <-- скобки несбалансированы
```
### ▍2.4. Подсчёт количества совпадающих значений массива (преобразование массива в объект)
Иногда нужно подсчитать одинаковые элементы массива или преобразовать массив в объект. Для решения этих задач также можно использовать `reduce`.
В следующем примере мы хотим подсчитать количество автомобилей каждого типа и поместить результаты этих вычислений в объект.
```
var cars = ['BMW','Benz', 'Benz', 'Tesla', 'BMW', 'Toyota'];
var carsObj = cars.reduce(function (obj, name) {
obj[name] = obj[name] ? ++obj[name] : 1;
return obj;
}, {});
carsObj; // => { BMW: 2, Benz: 2, Tesla: 1, Toyota: 1 }
```
На самом деле, возможности `reduce` на этом не ограничиваются. Если вам интересны подробности об этом полезном методе — изучите примеры с [этой](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce) страницы.
3. Деструктурирование объектов
------------------------------
### ▍3.1. Удаление ненужных свойств
Бывает так, что из объекта требуется удалить ненужные свойства. Возможно, это свойства, которые содержат секретные сведения, возможно — они слишком велики. Вместо того, чтобы перебирать весь объект и удалять подобные свойства, можно извлечь эти свойства в переменные и оставить нужные свойства в rest-параметре.
В следующем примере нам нужно избавиться от свойств `_internal` и `tooBig`. Их можно присвоить переменным с такими же именами и сохранить оставшиеся свойства в rest-параметре `cleanObject`, который можно использовать позже.
```
let {_internal, tooBig, ...cleanObject} = {el1: '1', _internal:"secret", tooBig:{}, el2: '2', el3: '3'};
console.log(cleanObject); // {el1: '1', el2: '2', el3: '3'}
```
### ▍3.2. Деструктурирование вложенных объектов в параметрах функции
В следующем примере свойство `engine` — это вложенный объект объекта `car`. Если нам нужно узнать, скажем, свойство `vin` объекта `engine`, его легко можно деструктурировать.
```
var car = {
model: 'bmw 2018',
engine: {
v6: true,
turbo: true,
vin: 12345
}
}
const modelAndVIN = ({model, engine: {vin}}) => {
console.log(`model: ${model} vin: ${vin}`);
}
modelAndVIN(car); // => model: bmw 2018 vin: 12345
```
### ▍3.3. Слияние объектов
ES6 поддерживает оператор расширения (spread), выглядящий как три точки. Обычно его применяют для работы с массивами, но его можно использовать и с обычными объектами.
В следующем примере мы используем оператор расширения для формирования нового объекта из двух существующих. Ключи свойств объекта №2 переопределят ключи свойств объекта №1. В частности, свойства `b` и `c` из `object2` переопределят такие же свойства объекта `object1`.
```
let object1 = { a:1, b:2,c:3 }
let object2 = { b:30, c:40, d:50}
let merged = {…object1, …object2} //применим оператор расширения для формирования нового объекта
console.log(merged) // {a:1, b:30, c:40, d:50}
```
4. Коллекции
------------
### ▍4.1. Удаление повторяющихся значений из массивов
В ES6 можно избавляться от повторяющихся значений, используя коллекции ([Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)). Коллекции могут содержать только уникальные значения.
```
let arr = [1, 1, 2, 2, 3, 3];
let deduped = [...new Set(arr)] // [1, 2, 3]
```
### ▍4.2. Использование методов массивов с коллекциями
Преобразование коллекций в массивы не сложнее, чем использование вышеупомянутого оператора расширения. Все методы массивов можно использовать и с коллекциями.
Предположим, у нас имеется коллекция, которую нужно отфильтровать так, чтобы в ней содержались только элементы, которые больше 3. Вот как это сделать.
```
let mySet = new Set([1,2, 3, 4, 5]);
var filtered = [...mySet].filter((x) => x > 3) // [4, 5]
```
5. Деструктурирование массивов
------------------------------
Часто бывает так, что функция возвращает множество значений в виде массива. Извлечь эти значения из массива можно с использованием техники деструктурирования.
### ▍5.1. Обмен значений переменных
Вот пример того, как новые средства работы с массивами позволяют организовать обмен значений двух переменных.
```
let param1 = 1;
let param2 = 2;
//поменяем местами значения param1 и param2
[param1, param2] = [param2, param1];
console.log(param1) // 2
console.log(param2) // 1
```
### ▍5.2. Приём и обработка нескольких значений, возвращаемых функцией
В следующем примере мы загружаем некую статью, находящуюся по адресу `/post`, и связанные с ней комментарии с адреса `/comments`. Тут применяется конструкция `async/await`, функция возвращает результат в виде массива.
Деструктурирование упрощает присвоение результатов работы функции соответствующим переменным.
```
async function getFullPost(){
return await Promise.all([
fetch('/post'),
fetch('/comments')
]);
}
const [post, comments] = getFullPost();
```
Итоги
-----
В этом материале мы рассмотрели несколько простых, но неочевидных приёмов использования новых возможностей ES6. Надеемся, они вам пригодятся.
**Уважаемые читатели!** Если вы знаете какие-нибудь интересные приёмы использования возможностей ES6 — просим ими поделиться.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/352128/ | null | ru | null |
# Вычисление максимального числа в массиве на этапе компиляции
Здравствуй хабр!
Не так давно понадобилось вычислить максимальную длину из нескольких заданных строк на этапе компиляции. Нужно выделить память под массив char[], так чтобы в нем уместилась любая строка из заданных. Логично предположить, что если система спроектирована хорошо, никаких вычислений на этапе компиляции не нужно, можно воспользоваться динамическим выделением используя std::auto\_ptr или std::string, но это не тот случай. Структура в которой хранится буфер char[] должна быть POD-типом.
По сути задача сводится к определению максимального числа в массиве на этапе компиляции. В данном топике я покажу как это сделать в стандарте c++03 и c++11. В ходе поиска решений нашел две статьи, которые помогли мне решить проблему: [habrahabr.ru/post/166201](http://habrahabr.ru/post/166201/), [habrahabr.ru/post/38622](http://habrahabr.ru/post/38622/).
Итак, чтобы обойти все заданные строки, сложим их в массив:
```
const char str1[] = "Anna";
const char str2[] = "Denis";
const char str3[] = "Vladimir";
const char str4[] = "Alexey";
const char *arr[] = { str1, str2, str3, str4 };
```
Теперь, sizeof(arr) вернет 16, а sizeof(arr[2]) вернет 4. Увы, мы потеряли информацию о размере строк в каждом элементе массива arr. Трюк с тем чтобы положить результаты sizeof каждой строки в массив тоже не прокатит, так как на этапе компиляции не разрешены операции разыменовывания указателей. Вообщем нужно искать что-то помощнее обычных массивов…
Решение данной проблемы – это сделать эмуляцию массива с помощью структур. Сложим длины всех строк в отдельные структуры и свяжем их с помощью Loki::TypeList.
```
struct str_1 { static const int size = sizeof(str1); };
struct str_2 { static const int size = sizeof(str2); };
struct str_3 { static const int size = sizeof(str3); };
struct str_4 { static const int size = sizeof(str4); };
typedef LOKI_TYPELIST_4(str_1, str_2, str_3, str_4) List;
```
Теперь мы можем обойти данный список типов и у каждого из них выдернуть размер.
**Итоговый вариант с++03**
```
struct str_1 { static const int size = sizeof(str1); };
struct str_2 { static const int size = sizeof(str2); };
struct str_3 { static const int size = sizeof(str3); };
struct str_4 { static const int size = sizeof(str4); };
typedef LOKI_TYPELIST_4(str_1, str_2, str_3, str_4) List;
#define GetMaxLen(TypeList) \
\
template \
struct len \
{ \
static const int cur\_size = Cur\_Type::Head::size; \
static const int next\_size = len::max\_size; \
static const int max\_size = cur\_size > next\_size ? cur\_size : next\_size ; \
}; \
\
template<> \
struct len \
{ \
static const int max\_size = 0; \
}; \
\
static const int ml = len::max\_size; \
GetMaxLen(List);
// в \*.cpp
// LOKI\_STATIC\_CHECK((ml == sizeof(str3)), size\_is\_wrong);
```
Данный вариант не самый удобный, так как такую структуру легко поддерживать при относительно небольшом количестве строк. Однако с увеличением данного количества существует вероятность просто забыть добавить соответствующую структуру для строки.
На стандарте c++11 получается все намного красивее и удобнее. Плюс не нужно «извращаться» со структурами и списками типов. Нам разрешено разыменовывать указатели, но только constexpr и внутри constexpr функции.
**Итоговый вариант с++11**
```
constexpr const char str1[] = "Anna";
constexpr const char str2[] = "Denis";
constexpr const char str3[] = "Vladimir";
constexpr const char str4[] = "Alexey";
constexpr const char *arr[] = { str1, str2, str3, str4 };
#define GetMaxLenght(array) \
constexpr unsigned char str_len(const char* const str) \
{\
return *str ? (1 + str_len(str + 1)) : 0;\
}\
\
template \
struct MaxLenght\
{\
static const int prev\_size = MaxLenght::max\_size;\
static const int cur\_size = str\_len(array[index]);\
static const int max\_size = cur\_size > prev\_size ? cur\_size : prev\_size;\
};\
\
template <>\
struct MaxLenght<-1>\
{\
static const int max\_size = 0;\
};\
static const int AmountStr = sizeof(array) / sizeof(array[0]);\
static const int array##\_max\_size = MaxLenght::max\_size;
GetMaxLenght(arr);
// в \*.cpp
// static\_assert((arr\_max\_size == 8), "Error");
```
P.S. Надеюсь данная статья кому-то поможет.
P.P.S. Буду рад, если кто-то предложит решение с помощью boost или еще каких-либо инструментов. | https://habr.com/ru/post/192736/ | null | ru | null |
# Нисходящий парсер с операторным предшествованием
[Дуглас Крокфорд](http://www.crockford.com/)
2007-02-21
Введение
--------
В 1973 году на первом ежегодном симпозиуме «Принципы языков программирования» ([Principles of Programming Languages Symposium](http://www.sigplan.org/conferences/popl/main)) [Вон Пратт](http://boole.stanford.edu/pratt.html) представил статью «Нисходящий парсер с операторным предшествованием» ([Top Down Operator Precedence](http://portal.acm.org/citation.cfm?id=512931)). В этой статье Пратт описал метод синтаксического разбора, который объединяет лучшие стороны рекурсивного спуска и метода операторного предшествования [Флойда](http://en.wikipedia.org/wiki/Robert_W._Floyd). Метод Пратта очень похож на рекурсивный спуск, но требует меньше кода и работает гораздо быстрее. Пратт заявил, что его метод прост в освоении, реализации и использовании, необычайно эффективен и очень гибок. Благодаря своей динамичности он может использоваться для расширяемых языков.
Но если метод действительно безупречен, почему же разработчики компиляторов по сей день его игнорируют? В своей статье Пратт предположил, что БНФ-грамматики и их многочисленные модификации, а также связанные с ними теоремы и автоматы заняли нишу раньше и теперь препятствуют развитию теории синтаксического анализа в других направлениях.
Есть и другое объяснение: этот метод наиболее эффективен для динамических, функциональных языков программирования и использовать его в статическом, процедурном языке куда сложнее. Свою статью Пратт иллюстрирует на примере Lisp и играючи строит синтаксические деревья по потоку лексем. Но методы синтаксического разбора не особо ценятся в сообществе Lisp-программистов, которые проповедуют спартанский отказ от синтаксиса. С момента создания Lisp предпринималось немало попыток придать этому языку богатый синтаксис в стиле ALGOL: [CGOL Пратта](http://its.svensson.org/DOC%3BCGOL), [Lisp-2](http://www.softwarepreservation.org/projects/LISP/lisp2_family/), [MLISP](http://i.stanford.edu/pub/cstr/reports/cs/tr/68/92/CS-TR-68-92.pdf), [Dylan](http://www.opendylan.org/), [Interlisp's Clisp](http://www.researchgate.net/publication/220812814_CLISP_-_Conversational_LISP), [оригинальные М-выражения Маккарти](http://www-formal.stanford.edu/jmc/history/lisp/lisp.html) и так далее. Но все они провалились. Для Lisp-сообщества согласованность программ и данных оказалась важнее выразительного синтаксиса. С другой стороны, подавляющее большинство программистов любит синтаксис, поэтому сам Lisp так и не стал популярен. Методу Пратта нужен динамический язык, но сообщество динамических языков исторически не пользовалось синтаксисом, который так удобно реализуется методом Пратта.
JavaScript
----------
Ситуация изменилась с появлением JavaScript. JavaScript — динамический, функциональный язык, но синтаксически он явно принадлежит к семейству Си. Это динамический язык, и его сообщество любит синтаксис.
JavaScript ещё и объектно-ориентирован. Статья Пратта предвосхищала объектно-ориентированный подход, но в ней не хватало выразительной нотации для этого. JavaScript — идеальный язык для реализации метода Пратта. Я покажу, как можно быстро и эффективно создавать синтаксические анализаторы на JavaScript.
Одной статьи недостаточно, чтобы разобраться с JavaScript полностью и, возможно, нам этого и не захочется, потому что в этом языке чёрт ногу сломит. Но в нём есть блестящие стороны, вполне достойные рассмотрения. Мы создадим парсер, который может обработать Упрощённый JavaScript. И этот парсер мы напишем на Упрощённом JavaScript. Упрощённый JavaScript — это всё лучшее из языка, в том числе:
* Функции как объекты первого класса. В Упрощённом JavaScript функции являются лямбда-выражениями с лексической областью видимости.
* Динамические объекты с прототипным наследованием. Классов нет. Мы можем добавить новый член в объект с помощью обычного присваивания. Объект может наследовать члены другого объекта.
* Литералы для объектов и массивов. Для создания новых объектов и массивов эта нотация очень удобна. Литералы JavaScript послужили источником вдохновения для формата [JSON](http://www.json.org/).
Мы воспользуемся преимуществами прототипов JavaScript, чтобы создавать объекты лексем, которые наследуются от символов. Нашей реализации потребуется метод `Object.create` (создаёт новый объект, наследующий члены существующего объекта) и лексический анализатор, который по входной строке создаёт массив объектов-лексем. Двигаясь по этому массиву, мы построим дерево синтаксического разбора.
Таблица символов
----------------
Каждая лексема, например, оператор или идентификатор, будет унаследована от символа. Мы запишем все наши возможные символы (которые определяют типы лексем языка) в объект `symbol_table`.
```
var symbol_table = {};
```
Объект `original_symbol` — это прототип для всех остальных символов. Его методы обычно перегружены. Значение методов `nud` и `led`, а также силы связывания (binding power) будет объяснено ниже в разделе «Приоритеты».
```
var original_symbol = {
nud: function () {
this.error("Undefined.");
},
led: function (left) {
this.error("Missing operator.");
}
};
```
Определим функцию, которая создаёт символы. Она принимает на вход идентификатор символа (`id`) и силу связывания (необязательный параметр `bp`, по умолчанию — нуль), а возвращает объект символа для данного `id`. Если символ уже есть в `symbol_table`, функция его и возвращает. Иначе она создаёт новый символ, который унаследован от `original_symbol`, сохраняет его в таблице символов и возвращает. Объект символа изначально содержит `id`, значение, левую силу связывания (`lbp`) и всё, что пришло из `original_symbol`.
```
var symbol = function (id, bp) {
var s = symbol_table[id];
bp = bp || 0;
if (s) {
if (bp >= s.lbp) {
s.lbp = bp;
}
} else {
s = Object.create(original_symbol);
s.id = s.value = id;
s.lbp = bp;
symbol_table[id] = s;
}
return s;
};
```
Объявим часто встречающиеся разделители и завершающие символы.
```
symbol(":");
symbol(";");
symbol(",");
symbol(")");
symbol("]");
symbol("}");
symbol("else");
```
Символ `(end)` указывает на окончание потока лексем. Символ `(name)` — прототип для новых имён, к примеру, имён переменных. Я включил в их идентификаторы скобки, чтобы избежать возможных совпадений с пользовательскими лексемами.
```
symbol("(end)");
symbol("(name)");
```
Лексемы
-------
Мы предполагаем, что исходный текст уже преобразован в массив `tokens` примитивных лексем, в которых содержится поле `type` (`"name"`, `"string"`, `"number"`, или `"operator"`), и поле `value` (строка или число). Переменная `token` всегда ссылается на текущую лексему.
```
var token;
```
Функция `advance` создаёт новый объект лексемы из следующей примитивной лексемы и присваивает его переменной `token`. Если передан необязательный параметр `id`, функция проверяет, что лексема имеет соответствующий идентификатор. Прототип нового объекта лексемы — это символ `(name)` в текущей области видимости или символ из таблицы символов. Поле `arity` новой лексемы будет равняться либо `"name"`, либо `"literal"`, либо `"operator"`. Впоследствии, когда мы узнаем больше о роли лексемы в программе, это значение может измениться на `"binary"`, `"unary"` или `"statement"`.
```
var advance = function (id) {
var a, o, t, v;
if (id && token.id !== id) {
token.error("Expected '" + id + "'.");
}
if (token_nr >= tokens.length) {
token = symbol_table["(end)"];
return;
}
t = tokens[token_nr];
token_nr += 1;
v = t.value;
a = t.type;
if (a === "name") {
o = scope.find(v);
} else if (a === "operator") {
o = symbol_table[v];
if (!o) {
t.error("Unknown operator.");
}
} else if (a === "string" || a === "number") {
a = "literal";
o = symbol_table["(literal)"];
} else {
t.error("Unexpected token.");
}
token = Object.create(o);
token.value = v;
token.arity = a;
return token;
};
```
Область видимости
-----------------
У большинства языков имеется нотация для определения новых символов (например, имён переменных). В простом языке, когда мы встречаем новое слово, мы автоматически определяем его и помещаем в таблицу символов. В более сложных языках имеется область видимости, которая позволяет программисту контролировать доступ к переменной и время её жизни.
Область видимости (scope) — это та часть программы, в которой переменная определена и доступна. Области видимости могут быть вложенными. Переменная, определённая в некой области видимости, не видна за её пределами.
Мы будем хранить текущую область видимости в отдельной переменной `scope`.
```
var scope;
```
Объект `original_scope` — это прототип для всех объектов, представляющих собой область видимости. Он содержит метод `define`, который позволяет определять новые переменные. Метод `define` преобразует лексему-имя в лексему-переменную. Он выдаёт ошибку, если переменная уже была определена в области видимости или имя является зарезервированным словом.
```
var itself = function () {
return this;
};
var original_scope = {
define: function (n) {
var t = this.def[n.value];
if (typeof t === "object") {
n.error(t.reserved ?
"Already reserved." :
"Already defined.");
}
this.def[n.value] = n;
n.reserved = false;
n.nud = itself;
n.led = null;
n.std = null;
n.lbp = 0;
n.scope = scope;
return n;
},
```
Метод `find` используется, чтобы найти определение по имени. Он начинает поиск с текущей области видимости и идёт, если необходимо, вверх по цепочке, заканчивая таблицей символов. Если определение найти не удалось, он возвращает `symbol_table["(name)"]`. Метод проверяет, что значение с данным именем не равно `undefined` (что означало бы обращение к необъявленному имени) и что это не функция (что указывало бы на коллизию с унаследованным методом).
```
find: function (n) {
var e = this, o;
while (true) {
o = e.def[n];
if (o && typeof o !== 'function') {
return e.def[n];
}
e = e.parent;
if (!e) {
o = symbol_table[n];
return o && typeof o !== 'function' ?
o : symbol_table["(name)"];
}
}
},
```
Метод `pop` закрывает область видимости, заменяя её родительской.
```
pop: function () {
scope = this.parent;
},
```
Метод `reserve` используется, чтобы указать, что данное имя является зарезервированным словом в текущей области видимости.
```
reserve: function (n) {
if (n.arity !== "name" || n.reserved) {
return;
}
var t = this.def[n.value];
if (t) {
if (t.reserved) {
return;
}
if (t.arity === "name") {
n.error("Already defined.");
}
}
this.def[n.value] = n;
n.reserved = true;
}
};
```
Теперь нам нужна стратегия обработки зарезервированных слов. В некоторых языках слова, описывающие структуру программы (например, `if`), зарезервированы и не могут быть использованы в качестве имён переменных. Гибкость нашего синтаксического анализатора позволяет достичь большего. К примеру, мы можем сказать, что в любой функции любое взятое имя может быть использовано либо как оператор языка, либо как имя переменной. Мы будем резервировать слова локально только после того, как их использовали в качестве зарезервированных. Это упрощает жизнь создателю языка, потому что добавление новых ключевых слов не сломает существующие программы, и упрощает жизнь программистам, потому что им не мешают ненужные ограничения на использование имён.
Когда мы хотим создать новую область видимости для функции или блока, мы вызываем функцию `new_scope`, которая создаёт новый экземпляр прототипа `original_scope`.
```
var new_scope = function () {
var s = scope;
scope = Object.create(original_scope);
scope.def = {};
scope.parent = s;
return scope;
};
```
Приоритет
---------
Объекты лексем содержат методы, которые позволяют принимать решения о приоритетах, подбирать другие лексемы и строить деревья (а в более сложных проектах ещё и проверять типы, оптимизировать и генерировать код). Основная задача приоритетов следующая: для заданного операнда между двумя операторами определить, относится операнд к левому оператору или к правому:
`d`*A*`e`*B*`f`
Если *A* и *B* — операторы, к какому из них относится операнд `e`? Другими словами, мы должны выбрать между `(d` *A* `e)` *B* `f`
и `d` *A* `(e` *B* `f)`.
В конечном счёте основная сложность синтаксического разбора заключается в разрешении этой неопределённости. Объекты лексем из нашего метода хранят силу связывания (или уровень приоритета), и простые методы `nud` (null denotation, нуль-соответствие) и `led` (left denotation, левое соответствие). Методу `nud` неважно, какие лексемы стоят левее, а методу `led` — важно. Метод `nud` используется значениями (переменными и литералами) и префиксными операторами. Метод `led` используется инфиксными и постфиксными операторами. У лексемы могут быть определены оба метода `nud` и `led`. Например, минус (`-`) может быть как префиксным (смена знака числа), так и инфиксным (вычитание), поэтому для него определены оба метода.
В нашем парсере используются следующие силы связывания:
| | |
| --- | --- |
| 0 | операторы без связи: `;` и т. д. |
| 10 | операторы присваивания: `=` и т. д. |
| 20 | `?:` |
| 30 | `|| &&` |
| 40 | операторы сравнения: `===` и т. д. |
| 50 | `+ -` |
| 60 | `* /` |
| 70 | унарные операторы: `!` и т. д. |
| 80 | `. [ (` |
Выражения
---------
Основной компонент метода Пратта — функция `expression`. Она принимает на вход правую силу связывания, которая указывает, насколько активно выражение связывается с лексемами справа.
```
var expression = function (rbp) {
var left;
var t = token;
advance();
left = t.nud();
while (rbp < token.lbp) {
t = token;
advance();
left = t.led(left);
}
return left;
}
```
Функция `expression` вызывает метод `nud` текущей лексемы `token`, который обрабатывает литералы, переменные и префиксные операторы. Затем, до тех пор, пока правая сила связывания меньше, чем левая сила связывания следующей лексемы, у неё вызывается метод `led`. Этот метод обрабатывает инфиксные и постфиксные операторы. Процесс может быть рекурсивным, так как методы `nud` и `led` сами могут вызывать `expression`.
Инфиксные операторы
-------------------
Оператор `+` — это инфиксный оператор, поэтому у него есть метод `led`, превращающий объект лексемы в дерево, две ветви которого (`first` и `second`) — это операнды слева и справа от знака `+`. Метод `led` принимает левый операнд в качестве параметра, а правый находит с помощью вызова `expression`.
```
symbol("+", 50).led = function (left) {
this.first = left;
this.second = expression(50);
this.arity = "binary";
return this;
};
```
Символ `*` аналогичен `+` за исключением значения `id` и силы связывания. Он крепче связан с операндами, поэтому его сила связывания выше.
```
symbol("*", 60).led = function (left) {
this.first = left;
this.second = expression(60);
this.arity = "binary";
return this;
};
```
Не все инфиксные операторы будут выглядеть так же, но многие будут. Поэтому мы можем упростить себе работу, определив функцию `infix`, которая поможет нам создавать инфиксные операторы. Функция `infix` принимает `id`, силу связывания и опционально функцию `led`. Если функция не задана, `infix` создаёт функцию `led` по умолчанию, которая годится в большинстве случаев.
```
var infix = function (id, bp, led) {
var s = symbol(id, bp);
s.led = led || function (left) {
this.first = left;
this.second = expression(bp);
this.arity = "binary";
return this;
};
return s;
}
```
Теперь мы можем описать инфиксные операторы в более декларативном стиле:
```
infix("+", 50);
infix("-", 50);
infix("*", 60);
infix("/", 60);
```
`===` — это оператор точного сравнения в JavaScript.
```
infix("===", 40);
infix("!==", 40);
infix("<", 40);
infix("<=", 40);
infix(">", 40);
infix(">=", 40);
```
Тернарный оператор принимает три выражения, разделённые `?` и `:`. Это не обычный инфиксный оператор, поэтому здесь придётся задать функцию `led`.
```
infix("?", 20, function (left) {
this.first = left;
this.second = expression(0);
advance(":");
this.third = expression(0);
this.arity = "ternary";
return this;
});
```
Оператор точка (`.`) используется, чтобы обратиться к члену объекта. Справа от него обязательно должно быть имя, но использоваться оно будет как литерал.
```
infix(".", 80, function (left) {
this.first = left;
if (token.arity !== "name") {
token.error("Expected a property name.");
}
token.arity = "literal";
this.second = token;
this.arity = "binary";
advance();
return this;
});
```
Оператор `[` используется, чтобы обратиться к члену объекта или элементу массива динамически. За выражением справа должна следовать закрывающая скобка `]`.
```
infix("[", 80, function (left) {
this.first = left;
this.second = expression(0);
this.arity = "binary";
advance("]");
return this;
});
```
Все эти инфиксные операторы левоассоциативны. Мы можем также создать правоассоциативные операторы (например, логические || и &&), уменьшив правую силу связывания.
```
var infixr = function (id, bp, led) {
var s = symbol(id, bp);
s.led = led || function (left) {
this.first = left;
this.second = expression(bp - 1);
this.arity = "binary";
return this;
};
return s;
}
```
Оператор `&&` возвращает первый операнд, если он ложен, иначе возвращает второй. Оператор `||` возвращает первый операнд, если он истинен, иначе возвращает второй. Ложное значение — это `0`, пустая строка `""`, `false` или `null`. Любое другое значение (в том числе любой объект) считается истинным.
```
infixr("&&", 30);
infixr("||", 30);
```
Префиксные операторы
--------------------
Код, который мы использовали для правоассоциативных инфискных операторов, может быть адаптирован для префиксных операторов. Префиксные операторы правоассоциативны. Префикс не имеет левой силы связывания, потому что он не связывается ни с чем слева. Иногда префиксные операторы являются зарезервированными словами.
```
var prefix = function (id, nud) {
var s = symbol(id);
s.nud = nud || function () {
scope.reserve(this);
this.first = expression(70);
this.arity = "unary";
return this;
};
return s;
}
prefix("-");
prefix("!");
prefix("typeof");
```
Метод `nud` для скобки `(` вызывает `advance(")")`, чтобы найти парную скобку `)`. Сама лексема `(` не попадает в синтаксическое дерево, потому что `nud` возвращает только содержимое скобок.
```
prefix("(", function () {
var e = expression(0);
advance(")");
return e;
});
```
Операторы присваивания
----------------------
Для определения операторов присваивания мы могли бы воспользоваться функцией `infixr`. Но лучше мы напишем отдельную функцию `assignment`, потому что нам хочется сделать ещё кое-что: убедиться, что выражение слева является lvalue, то есть ему действительно можно что-то присвоить, и установить поле `assignment`, чтобы в дальнейшем мы могли легко найти все присваивания.
```
var assignment = function (id) {
return infixr(id, 10, function (left) {
if (left.id !== "." && left.id !== "[" &&
left.arity !== "name") {
left.error("Bad lvalue.");
}
this.first = left;
this.second = expression(9);
this.assignment = true;
this.arity = "binary";
return this;
});
};
assignment("=");
assignment("+=");
assignment("-=");
```
Заметьте: мы реализовали что-то вроде наследования. Функция `assignment` возвращает результат вызова `infixr`, а `infixr` — результат вызова `symbol`.
Константы
---------
Функция `constant` создаёт константы языка. Метод `nud` превращает лексему-имя в лексему-литерал.
```
var constant = function (s, v) {
var x = symbol(s);
x.nud = function () {
scope.reserve(this);
this.value = symbol_table[this.id].value;
this.arity = "literal";
return this;
};
x.value = v;
return x;
};
constant("true", true);
constant("false", false);
constant("null", null);
constant("pi", 3.141592653589793);
```
Символ `(literal)` — это прототип для всех строковых и численных литералов. Метод `nud` лексемы-литерала возвращает саму лексему.
```
symbol("(literal)").nud = itself;
```
Предложения
-----------
В оригинале метод Пратта создавался для функциональных языков, где есть только выражения. Большинство популярных языков используют предложения (statements), которые не настолько сложно вкладываются друг в друга как выражения. Мы можем легко обработать и предложения, если добавим новый метод к лексемам: `std` (statement denotation, соответствие предложения). Метод `std` похож на `nud`, но вызывается он только в начале предложения.
Функция `statement` разбирает одно предложение. Если текущая лексема содержит метод `std`, лексема резервируется и этот метод вызывается. Иначе мы считаем, что предложение представляет собой выражение, заканчивающееся точкой с запятой. Для надёжности мы будем считать за ошибку выражения, которые не являются присваиваниями или вызовами функций.
```
var statement = function () {
var n = token, v;
if (n.std) {
advance();
scope.reserve(n);
return n.std();
}
v = expression(0);
if (!v.assignment && v.id !== "(") {
v.error("Bad expression statement.");
}
advance(";");
return v;
};
```
Функция `statements` разбирает предложения, пока не встретит лексему `(end)` или `}`, которая обозначает конец блока. Функция возвращает предложение, массив предложений или `null`, если ни одного предложения не найдено.
```
var statements = function () {
var a = [], s;
while (true) {
if (token.id === "}" || token.id === "(end)") {
break;
}
s = statement();
if (s) {
a.push(s);
}
}
return a.length === 0 ? null : a.length === 1 ? a[0] : a;
};
```
Функция `stmt` используется, чтобы добавить символы предложений в таблицу символов. В качестве параметров она принимает `id` и функцию `std`.
```
var stmt = function (s, f) {
var x = symbol(s);
x.std = f;
return x;
};
```
Предложение-блок — это список предложений в фигурных скобках, для которых определена новая область видимости. В обычном JavaScript нет областей видимости для блоков, но в нашем Упрощённом JavaScript они будут.
```
stmt("{", function () {
new_scope();
var a = statements();
advance("}");
scope.pop();
return a;
});
```
Функция `block` разбирает блок.
```
var block = function () {
var t = token;
advance("{");
return t.std();
};
```
Предложение `var` определяет одну или несколько переменных в текущем блоке. За именем переменной может следовать знак равенства `=` и начальное значение переменной.
```
stmt("var", function () {
var a = [], n, t;
while (true) {
n = token;
if (n.arity !== "name") {
n.error("Expected a new variable name.");
}
scope.define(n);
advance();
if (token.id === "=") {
t = token;
advance("=");
t.first = n;
t.second = expression(0);
t.arity = "binary";
a.push(t);
}
if (token.id !== ",") {
break;
}
advance(",");
}
advance(";");
return a.length === 0 ? null : a.length === 1 ? a[0] : a;
});
```
Предложение `while` определяет цикл. Оно включает выражение в скобках и блок.
```
stmt("while", function () {
advance("(");
this.first = expression(0);
advance(")");
this.second = block();
this.arity = "statement";
return this;
});
```
Предложение `if` создаёт условную конструкцию. Если после блока следует символ `else`, тогда мы анализируем также следующий блок или следующее предложение `if`.
```
stmt("if", function () {
advance("(");
this.first = expression(0);
advance(")");
this.second = block();
if (token.id === "else") {
scope.reserve(token);
advance("else");
this.third = token.id === "if" ? statement() : block();
} else {
this.third = null;
}
this.arity = "statement";
return this;
});
```
Предложение `break` используется, чтобы завершить цикл раньше времени.
```
stmt("break", function () {
advance(";");
if (token.id !== "}") {
token.error("Unreachable statement.");
}
this.arity = "statement";
return this;
});
```
Предложение `return` используется, чтобы выйти из функции. Оно может содержать необязательное выражение (возвращаемое значение функции).
```
stmt("return", function () {
if (token.id !== ";") {
this.first = expression(0);
}
advance(";");
if (token.id !== "}") {
token.error("Unreachable statement.");
}
this.arity = "statement";
return this;
});
```
Функции
-------
Функции — это исполняемые значения. Функция может иметь необязательное имя (чтобы она могла вызвать себя рекурсивно), список имён параметров в скобках и тело — список предложений в фигурных скобках. У функции есть своя область видимости.
```
prefix("function", function () {
var a = [];
new_scope();
if (token.arity === "name") {
scope.define(token);
this.name = token.value;
advance();
}
advance("(");
if (token.id !== ")") {
while (true) {
if (token.arity !== "name") {
token.error("Expected a parameter name.");
}
scope.define(token);
a.push(token);
advance();
if (token.id !== ",") {
break;
}
advance(",");
}
}
this.first = a;
advance(")");
advance("{");
this.second = statements();
advance("}");
this.arity = "function";
scope.pop();
return this;
});
```
Функции выполняются с помощью оператора `(`. При вызове можно указать некоторое количество аргументов. Мы будем проверять левый операнд, чтобы отсечь ситуации, когда значение слева не может быть функцией.
```
infix("(", 80, function (left) {
var a = [];
if (left.id === "." || left.id === "[") {
this.arity = "ternary";
this.first = left.first;
this.second = left.second;
this.third = a;
} else {
this.arity = "binary";
this.first = left;
this.second = a;
if ((left.arity !== "unary" || left.id !== "function") &&
left.arity !== "name" && left.id !== "(" &&
left.id !== "&&" && left.id !== "||" && left.id !== "?") {
left.error("Expected a variable name.");
}
}
if (token.id !== ")") {
while (true) {
a.push(expression(0));
if (token.id !== ",") {
break;
}
advance(",");
}
}
advance(")");
return this;
});
```
Символ `this` — это особая переменная. При вызове метода в ней хранится ссылка на объект.
```
symbol("this").nud = function () {
scope.reserve(this);
this.arity = "this";
return this;
};
```
Литералы для объектов и массивов
--------------------------------
Литерал для массива — это набор выражений в квадратных скобках, разделённых запятыми. Каждое выражение вычисляется, и все результаты образуют новый массив.
```
prefix("[", function () {
var a = [];
if (token.id !== "]") {
while (true) {
a.push(expression(0));
if (token.id !== ",") {
break;
}
advance(",");
}
}
advance("]");
this.first = a;
this.arity = "unary";
return this;
});
```
Литерал для объекта — это набор пар в фигурных скобках, разделённых запятыми. Пара состоит из ключа и выражения, которые разделены двоеточием (`:`). Ключ — это литерал или имя, которое интерпретируется как литерал.
```
prefix("{", function () {
var a = [];
if (token.id !== "}") {
while (true) {
var n = token;
if (n.arity !== "name" && n.arity !== "literal") {
token.error("Bad key.");
}
advance();
advance(":");
var v = expression(0);
v.key = n.value;
a.push(v);
if (token.id !== ",") {
break;
}
advance(",");
}
}
advance("}");
this.first = a;
this.arity = "unary";
return this;
});
```
О чём подумать и что поделать
-----------------------------
Созданное дерево можно передать в генератор кода или интерпретатор. Для создания дерева требуется минимум вычислений. И, как мы видим, требуется не так уж много усилий от программиста, чтобы написать такой парсер.
Мы можем добавить в функцию `infix` параметр кода операции, который поможет генератору кода. Мы можем также передавать туда дополнительные методы для [свёртки констант](http://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D1%91%D1%80%D1%82%D0%BA%D0%B0_%D0%BA%D0%BE%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%82) и генерации кода.
Мы можем добавить другие предложения (например, `for`, `switch` и `try`), метки, больше кода для проверок на ошибки, восстановления после ошибок и кучу новых операторов. Мы можем добавить задание и вывод типов.
Мы можем сделать наш язык расширяемым. Мы можем позволить программисту объявлять новые операторы и предложения так же легко, как объявлять новые переменные.
[Испытайте сами парсер, описанный в этой статье.](http://javascript.crockford.com/tdop/index.html)
Ещё один пример использования этого метода синтаксического разбора вы можете найти в проекте [JSLint](http://jslint.com/).
**От переводчика:** ковырял исходники JSLint и решил, что русский перевод этой замечательной статьи не помешает. Парсер в JSLint действительно исключительно понятный, мощный и легко расширяемый. Большое спасибо [KVie](https://habrahabr.ru/users/kvie/) за редактирование перевода.
Данная статья выходила в составе книги Beautiful Code (девятая глава). Русский перевод всей книги в электронном виде можно купить на [сайте издательства «Питер»](http://www.piter.com/product/idealnyy-kod). | https://habr.com/ru/post/227241/ | null | ru | null |
# Old School: один день работы в DOS
[](https://habr.com/ru/company/ruvds/blog/566582/)
Обновление от 5 июля, 2021 года: по случаю празднования 4 июля у нас в США сегодня выходной, и у сотрудников Ars есть возможность успеть на [летнюю распродажу Steam](https://arstechnica.com/gaming/2021/07/steam-summer-sale-best-deals-hidden-gems-indie-games/) (или просто отдохнуть). В связи с этим мы достали из архивов редакции Ars несколько старых проектов, включая и этот в некотором смысле мазохистский эксперимент.
Еще в 2014 году почетный редактор Ars Шон Галлахер решил отметить 20 лет с момента окончания жизни MS-DOS и поработать в этой операционной системе в современных условиях. Получилось это…почти так же гладко, как можно было предположить.
Сегодня, спустя 27 лет после того, как в Microsoft объявили о завершении поддержки MS-DOS, мы решили освежить в памяти его опыт (и очень ценим современные возможности, поскольку теперь все работаем из дома немного больше). Датируется эта история 3 июля 2014 года и ниже передана в своем исходном виде.
Двадцать лет назад, когда в Microsoft сообщили, что заканчивают поддержку MS-DOS, [Джеймс Холл заявил миру](https://groups.google.com/forum/#!msg/comp.os.msdos.apps/oQmT4ETcSzU/O1HR8PE2u-EJ), что намерен создать версию этой ОС, которая станет всеобщим достоянием, с целью сохранить вселенную символьно-ориентированного программного обеспечения DOS. В конечном итоге проект Холла, изначально названный “PD-DOS”, получил имя [FreeDOS](http://www.freedos.org/) и на сегодня поддерживает экосистему разработчиков, ретро-геймеров и приверженных консерваторов, которые откажутся от WordStar только, когда вы вырвете дискеты из их мертвых окоченелых пальцев.
В честь двадцатилетия проекта (а также тех храбрых душ, которые и по сей день поддерживают очаг жизни DOS) я решил провести день во FreeDOS. Я настроил машину на работу с последним дистрибутивом этой ОС и программным обеспечением из репозиториев FreeDOS Package Manager. После я добавил и другое ПО, которое смог собрать из разных уголков сети – программы с открытым исходным кодом, бесплатные программы и те, которые больше не поддерживаются разработчиками, а также кое-что, любезно предоставленное Ли Хатчинсоном из его личной коллекции ПО для DOS. Мне хотелось узнать, возможно ли выполнять современную завязанную на интернете работу в DOS, и насколько болезненным это может оказаться.
Вскоре мой ПК стал словно из 1994 – в нем не было Twitter, Google и всего, что бы использовало SSL, но при этом присутствовали инструменты командной строки TCP/IP, функциональный по остальным возможностям браузер и…Gopher. Помимо этого, я установил WordPerfect 5, Microsoft Word 5, WordStar, Lotus 123 и dBase III – все, о чем можно было мечтать, не так ли?
Почему FreeDOS?
---------------
Linux тоже бесплатен, и я бы предпочел провести день за стареньким ноутбуком с Debian или Ubuntu, чем работать из командной строки DOS. Но в аскетичности и строгости DOS есть некая безумная красота – к тому, же это операционная система, которая способна загружаться с дискеты и не потея работать на 640Кб памяти (хотя она может и выходить за эти рамки при использовании одного из расширителей «верхней памяти» с открытым исходным кодом).
FreeDOS в некоторой степени изменила старую среду DOS. К примеру, в связи с добавлением поддержки FAT32 эта ОС может работать с дисками объемом до 8ТБ. [Модуль расширения LFNDOS](http://www.freedos.org/software/?prog=lfndos) привносит поддержку длинных имен файлов, появившуюся в Windows 95. При этом благодаря стараниям небольшой армии разработчиков, а также объектам интеллектуальной собственности, созданным на протяжении двадцати лет коммерческой и академической разработки DOS, FreeDOS содержит компиляторы для десятков языков программирования (хотя, насколько я знаю, Java к ним не относится).
В определенный момент FreeDOS стала единственной DOS, поставляемой с ведущими брендами ПК, но заказывать это нужно было отдельно. Dell и Hewlett Packard поставляли FreeDOS с машинам «без операционной системы» в качестве альтернативы предварительно настроенной Windows, что стало популярной опцией для дешевых ПК, особенно в Азии в конце последнего десятилетия. Эта ОС по-прежнему числится на сайтах Dell и HP, хотя варианта заказать с ней новенький ПК через онлайн-магазины этих компаний больше нет.
Но несмотря на то, что FreeDOS уходит в забытие, у нее до сих пор есть активное сообщество пользователей. Ее все еще используют в качестве легковесной ОС для «[загрузочных дискет](http://schierlm.users.sourceforge.net/bootdisk/)», необходимых для запусков сети, установки или исправления других ОС, а также обновления прошивок. Помимо этого, в связи с низким потреблением оперативной памяти и памяти хранилища, FreeDOS активно применяют в мире виртуальных машин (VM), где существуют [готовые образы](http://virtualboxes.org/images/freedos/) для различных десктопных и серверных VM-сред.
Однако, как это было всегда, для правильного функционирования DOS требуется самостоятельная настройка.
*Веб-браузер под DOS*
Настройка DOSтупа в интернет
----------------------------
Официальная текущая версия [FreeDOS 1.1](http://www.freedos.org/download/) от 2011 года доступна в виде образа Live CD, но в установке по умолчанию недостает многих компонентов, которые вам понадобятся для подключения к интернету 21 века, в том числе сетевых драйверов. К счастью, в доступе имеется еще один [CD-образ](http://www.ibiblio.org/pub/micro/pc-stuff/freedos/files/distributions/1.1/repos/), содержащий все пакеты репозитория, в том числе пару вариантов сетевых драйверов, которые можно установить с помощью FreeDOS Package Manager (FDNPKG).
Я предпочел установить большую часть библиотек, начиная с Crynwr – бесплатного набора сетевых драйверов, работающего почти со всеми стандартными сетевыми картами из эпохи DOS. Многие приложения DOS, использующие TCP/IP, вместо системного драйвера используют TCP библиотеку. Во FreeDOS есть две такие библиотеки, совместимые с Crynwr: [mTCP](http://www.brutman.com/mTCP/), до сих пор поддерживаемая и сопровождаемая набором утилит (включая клиента IRC), а также почтенная Waterloo TCP (WATTCP), выпущенная в начале 90-х. mTCP даже использовалась для создания веб-сервера – ее домашняя страница размещалась на [IBM PCjr](https://ru.wikipedia.org/wiki/IBM_PCjr).
Также можно найти драйвера формата «terminate and stay resident» (завершиться и остаться резидентной) для TCP и других сетей, которые потребуются для предоставления общего сетевого доступа к файлам. Но для того, чтобы заставить их работать, придется раздобыть все составляющие компоненты, так как большинство их них были коммерческими и теперь не поддерживаются. К счастью, некоторые пользователи с форумов VirtualBox уже [проделали в этом направлении немало работы](https://forums.virtualbox.org/viewtopic.php?f=4&t=47461). Я же выбрал альтернативный путь: запустил FTP на своем хосте с Mac OS X и использовал FTP-клиента для передачи файлов клиенту DOS. Это позволило достаточно быстро пополнить свой инструментарий на день работы с DOS.
Территория «заброшенного» ПО
----------------------------
Еще мне потребовалось программное обеспечение для создания контента. Будь я настолько заинтересован, то мог бы отказаться от роскоши текстового процессора и просто использовать утилиту EDIT.EXE или один из многих портированных открытых инструментов для работы с текстом. Если же вы ищете нечто более напоминающее опыт работы в современном Office, то можно воспользоваться бесплатным [Microsoft Word 5.5 для DOS](http://www.vintage-computer.com/vcforum/showthread.php?15238-MS-Word-5-5-for-DOS-for-FREE-(legally)).
Еще до того, как Microsoft победила в битвах за десктоп, у текстовых процессоров были свои приверженцы. По некоторым данным, Джордж Р. Р. Мартин до сих пор использует WordStar, с которым я недолго поработал в середине 80-х – он шел в комплекте с моим Kaypro PC. Однако меня не интересовало ничего, кроме гармоничного предустановленного темно-синего цвета WordPerfect 5. На моей сетчатке до сих пор остался выжженый некогда шаблон его функциональных клавиш. Хорошо, что у Ли Хатчинсона осталась копия этой программы.
Следующим шел выбор электронной таблицы. Использовать [Lotus 1-2-3](http://vetusware.com/download/Lotus%201-2-3%20Version%202.4%20_720k%20Disk%20Format_/?id=7839) или VisiCalc? Оба варианта бесплатно доступны в сети. Исполняемая версия [VisiCalc](http://www.bricklin.com/history/vclicense.htm), которую ее разработчик, Дэн Бриклин, разместил онлайн, представляет оригинальную версию с IBM PC, разработанную еще в 1981 году. Ее пользовательский интерфейс несколько упрощен, но с учетом того, что весит файл всего 27.5 Кб – то есть меньше, чем документ Word, который я создал для написания данной статьи – это можно счесть за образец элегантности. Распечаткой документов я больше практически не занимаюсь, поэтому поиском драйверов для принтера озадачиваться не стал.
К сожалению, отправить кому-нибудь документ в родном формате этих электронных таблиц – все равно, что отправить свитки Мертвого моря, если только у получателя не установлен [Apache OpenOffice](http://www.openoffice.org/), в случае чего можно послать ему файл `.WK1` из Lotus 1-2-3.
В завершении комплектации своего набора ПО я нашел `.ZIP` файл dBase III Эштона Тэйта и собрал быструю базу данных контактов. Мой внутренний Clipper-программист снова был счастлив.
*WordStar, любимый текстовый процессор Джорджа Р. Р. Мартина, также отлично работает во FreeDOS. Однако предустановленные цвета экрана заставляют мои глаза плакать кровью*
Интернет 1994 года
------------------
Но суть в том, что я работаю на сайте, в связи с чем оставался вопрос относительно использования интернета из DOS.
Да, существует веб-браузер на базе DOS, который все еще разрабатывается и при этом является открытым. Речь об [Arachne](http://www.glennmcc.org/). Последний раз он обновлялся год назад и находится под лицензией GPL. Arachne представляет собой графический браузер с собственным встроенным TCP/IP стеком и поддержкой SLIP/PPP (для тех, кто до сих пор живет в мире телефонных соединений). В нем даже есть встроенный почтовый клиент POP/SMTP, пусть даже весьма примитивный.
Arachne стабилен, но его трудно настроить в соответствии с требованиями современного веб-пространства. Например, в нем нет поддержки HTTPS, в следствии чего Google, Twitter, Yahoo и все сайты, перешедшие после скандала со Сноуденом на SSL-шифрование, оказываются недоступны. (Спасибо Биллу, что все еще есть Bing, не так ли?) Кроме того, он поддерживает только самые базовые таблицы стилей CSS, из-за чего современные сайты выглядят не столь современно. И несмотря на то, что почтовый клиент работает, прикрепление к письмам файлов требует некоторых стараний.
Я также попробовал [Dillo](http://sourceforge.net/p/freedos/news/2011/11/dillo-a-web-browser-for-dos/), еще один открытый браузер, основанный на кроссплатформенной библиотеке GUI под названием [FLTK](http://www.fltk.org/index.php), и функционирующий подобно Mozilla 4.0. Взаимодействие с FLTK напоминает взаимодействие с Windows 2.0. Мне удалось заставить его работать с Google (после отключения скачивания изображений), но поддержка мыши оказалась неустойчивой. При этом во время загрузки страниц он несколько раз падал и давал сбой.
Помучившись с Arachne, я нашел более надежного почтового клиента [FlMail](https://code.google.com/p/nanox-microwindows-nxlib-fltk-for-dos/wiki/FlMail), основанного на той же библиотеке FLTK. FlMail поддерживает SSL, а также работает с Gmail и другими службами сетевой почты, поддерживающими POP и SMTP. Однако, находясь в почтовом ящике, я по ошибке кликнул сообщение в формате HTML, и FlMail вошел в цикл «предварительного форматирования страницы», что дало мне повод пойти заварить очередную порцию кофе.
Попробовав позднее отправить сообщение с прикрепленным черновиком этой статьи, я столкнулся с тем же самым, после чего обнаружилось, что отправка провалилась. В итоге я решил вернуться к Arachne.
Игры, написание кода и радость возвращения в «сегодня»
------------------------------------------------------
Я попытался поделиться своими мучениями в Twitter. Печально, но клиента Twitter для DOS не существует. Когда я попробовал отправить твит из командной строки при помощи `WGET`, Twitter.com не смог разрешиться – мне не удалось выяснить, какой сетевой стек он должен использовать, поэтому я просто написал себе напоминание в заметке Post-It.
Вскоре я уже испытывал синдром отмены копипаста, и настало время передохнуть. Тогда я начал разбирать скачанные заранее игры. Одно из предлагаемых FreeDOS развлечений для геймеров – это его коллекция эмуляторов. Существуют десятки DOS-версий классических консолей, включая NES, Gameboy и Atari 800.
У меня также был бесплатный мод DOOM под названием FREEDOOM, и некоторое время я провел за исследованием пиксельного ада, расстреливая монстров. Еще было две версии Тетриса и сайд-скроллинг в стиле Марио под именем HappyLand, в котором я…честно говоря, не знал, что делать. Клон Space Invaders под DOS вел к сбою системы при каждой моей попытке его загрузить.
Напрудив лужу VGA-крови, я переключился на инструменты разработчика. GNU Compiler Collection была портирована на FreeDOS в виде платформы [DJGPP](http://www.delorie.com/djgpp/). Она позволяет создавать 32-битные программы, запускаемые из DOS, а в марте 2012 претерпела обновление, получив в дополнение к C, C++ и Fortran язык программирования Go. Эта платформа также включает интегрированную среду разработки RHIDE. Есть еще пара десятков других бесплатных компиляторов и сред выполнения, включая выпущенные в начале этого года для языка FORTH.
Конечно же, разработчикам доступно много разного ПО, поддержка которого давно прекратилась. Чисто из чувства ностальгии я скачал [Turbo Pascal](http://edn.embarcadero.com/article/20803) и [Harbour](http://harbour.github.io/), открытый компилятор для Clipper. Как только я отлажу свое приложение менеджера контактов DOS, так сразу же выложу ссылку на него.
К концу дня я уже был поистине готов вернуться в комфортную современную операционную систему – **любую** современную операционную систему. Но я все же понял, почему, даже спустя столько лет, к DOS все еще сохраняется интерес. Несмотря на свои архаичные ограничения, FreeDOS способна превратить даже самое древнее железо в функционирующую единицу интернет-мира и при этом поддерживает программы, созданные на протяжении десятилетий.
Только не просите меня использовать ее каждый день. Пожалуйста.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=old_school:_odin_den_raboty_v_dos) | https://habr.com/ru/post/566582/ | null | ru | null |
# Шесть картинок, как создать словарь
Словарь - это абстрактный тип данных, который связывает ключи со значениями. Его ещё называют ассоциативный массив, карта, таблица символов, коллекция. Будет две статьи на эту тему, где мы покажем шесть картинок / способов реализации словаря, которые отличаются друг от друга по времени работы и по требованию к памяти.
Первая статья:
1. Линейный массив
2. Односвязный список
3. Отсортированный массив
Вторая статья:
4. Двоичное дерево поиска
5. Хэш-таблица
6. Префиксное дерево
### Дом для кота, Интерфейс для словаря
Начнём созидание словаря с формулировки методов для работы с ним. Минимальный набор таких методов: **put** - добавить, **get** - получить.
По хорошему, мы должны создать обобщённый интерфейс с возможностью указать любой тип данных как для ключа, так и для значения. Однако, в рамках этой работы мы будем для удобства использовать **string** для ключей, **int** для значений. Ещё в словаре могут быть методы для удаления ключей, для итерации по всем записям, получение количества элементов и много других важных и приятных мелочей, которые мы опустим.
Пример кода на языке Java
```
interface IStorage
{
Integer get(String key);
void put(String key, Integer value);
}
public class Main
{
public static void main(String args[])
{
Main test = new Main();
test.runMapExample(new ArrayStorage());
}
void runMapExample(IStorage map)
{
map.put("cat", 30);
map.put("fox", 50);
map.put("art", 10);
map.put("owl", 80);
map.put("box", 20);
map.put("dog", 40);
System.out.println(map.get("art"));
System.out.println(map.get("box"));
System.out.println(map.get("cat"));
System.out.println(map.get("dog"));
System.out.println(map.get("fox"));
System.out.println(map.get("owl"));
}
}
```
### Картинка первая. Линейный массив.
Самый простой способ для хранения пар «ключ, значение» - это создание класса или структуры **Node** (узел) и декларация линейного массива сих пар.
Для поиска узла по ключу необходимо просканировать весь массив от начала до конца и в каждом узле проверять, не совпало ли значение. Если совпало - вернуть найденное значение, если сканирование завершилось, а значение так и не было найдено - рапортуем, что не найдено. На это нужно N операций.
```
class ArrayStorage implements IStorage
{
int size = 0;
Node[] array = new Node[1];
Node empty = new Node(null, null);
class Node
{
public String key;
public Integer value;
public Node(String key, Integer value)
{
this.key = key;
this.value = value;
}
}
Node find(String key)
{
for (int j = 0; j < size; j ++)
if (key.equals(array[j].key))
return array[j];
return empty;
}
public Integer get(String key)
{
return find(key).value;
}
```
Для добавления новой пары достаточно в конец массива вписать новый узел, это быстро, всего 1 операция. Однако, прежде чем добавить новый узел, мы должны убедиться, что в словаре нет узла с точно таким же значением ключа, для этого необходимо вызвать метод поиска. Если такой ключ есть - мы записываем новое значение на место старого.
```
void resize()
{
Node[] newArray = new Node[size * 2 + 1];
for (int j = 0; j < size; j ++)
newArray[j] = array[j];
array = newArray;
}
public void put(String key, Integer value)
{
Node node = find(key);
if (node.key == null)
{
if (size == array.length)
resize();
array[size++] = new Node(key, value);
} else
node.value = value;
}
}
```
Сколько памяти выделять для словаря? Какого размера массив необходимо декларировать для эффективной работы? Если размер массива будет совпадать с количеством элементов, то при каждом добавлении пары необходимо пересоздавать массив увеличенного размера и заниматься копированием значений из старого массива в новый, а это, на минуточку, N действий для каждой операции добавления элемента.
Чтобы избежать тьмы лишних действий, можно выделять массив удвоенного размера, тогда процесс пересоздания массива добавит к сложности алгоритма лишь Log N операций, однако размер требуемой памяти удвоится.
Сложность поиска: N операций = O(N).
Сложность вставки: N (поиск) + Log N (пересоздание) + 1 (вставка) = O(N).
Требование к памяти: N (словарь) + N (резерв) = O(N).
Вывод: простой, но медленный способ, двойной расход памяти
Исходный код **Storage1\_Array** можно посмотреть и запустить [здесь](https://jdoodle.com/ia/xy9).
### Картинка вторая. Односвязный список.
Есть идеи по экономии памяти, но чтобы при этом не нужно было тратиться на дополнительные операции по пересозданию массива и копированию элементов? Ответ лежит на поверхности: односвязный список! Это динамическая структура, которая занимает ровно столько место, сколько в ней элементов и позволяет легко добавлять новые сущности.
Как видим, в класс узла добавилось ещё одно поле **next** - указатель на следующий элемент списка (между нами говоря, накладные расходы на необходимость хранить этот указатель могут свести на нет то, ради чего мы, собственно, и).
Сложность поиска узла по ключу не изменилась - нам вновь необходимо сканировать весь список от начала до конца, прыгая по кочкам списка.
```
class LinkedListStorage implements IStorage
{
Node root = null;
Node empty = new Node(null, null, null);
class Node
{
public String key;
public Integer value;
public Node next;
public Node(String key, Integer value, Node next)
{
this.key = key;
this.value = value;
this.next = next;
}
}
Node find(String key)
{
for (Node curr = root; curr != null; curr = curr.next)
if (key.equals(curr.key))
return curr;
return empty;
}
public Integer get(String key)
{
return find(key).value;
}
```
Сложность добавления элемента значительно ускорился - нет дополнительных расходов на пересоздание массива, а новые пары удобнее всего добавлять в начало списка. Обратите внимание, что на рисунке порядок расположения пар реверсивен: кот был первым, а стал последним.
```
public void put(String key, Integer value)
{
Node node = find(key);
if (node.key == null)
root = new Node(key, value, root);
else
node.value = value;
}
}
```
Сложность поиска: N операций = O(N).
Сложность вставки: N (поиск) + 1 (вставка) = O(N).
Требование к памяти: N (словарь) = O(N).
Вывод: простой, но медленный способ, эффективен по памяти.
Исходный код **Storage2\_LinkedList** можно посмотреть и запустить [здесь](https://jdoodle.com/ia/xyb).
А можно ли как-то ускорить процесс поиска ключей? Линейное время, это слишком медленно и применимо лишь на малых размерах словаря. Можно.
### Картина третья. Отсортированный список.
В книжных словарях слова расположены по алфавиту, что позволяет искать их значительно быстрее, за логарифмическое время. Например, для поиска ключа в отсортированном списке из 1000 записей достаточно сделать всего десять сравнений, потому как 2^10 = 1024.
Давайте и мы попробуем располагать ключи в алфавитном порядке.
Теперь для поиска ключа можно применить бинарный поиск: смотрим, какой элемент посередине списка находится и рекурсивно продолжаем поиск либо в первой половине, либо во второй. Время поиска O(Log N).
```
class SortedStorage implements IStorage
{
int size = 0;
Node[] array = new Node[1];
class Node
{
public String key;
public Integer value;
public Node(String key, Integer value)
{
this.key = key;
this.value = value;
}
}
int findIndex(String key)
{
int left = 0;
int right = size - 1;
while (left < right)
{
int mid = (left + right) / 2;
if (key.equals(array[mid].key))
return mid; // found!
if (key.compareTo(array[mid].key) > 0)
left = mid + 1; // key < mid.key, move to right
else
right = mid - 1; // key > mid.key, move to left
}
if (left < size && key.compareTo(array[left].key) > 0)
left++; // key must be placed at the right of [left]
return left;
}
public Integer get(String key)
{
int j = findIndex(key);
if (j < size && key.equals(array[j].key))
return array[j].value;
return null;
}
```
Для добавления новой пары в словарь нужно сначала найти индекс в массиве, куда следует вставить пару, чтобы ключи располагались в алфавитном порядке, на это нужно Log N операций. Затем нужно сдвинуть все элементы на одну позицию вперёд и в освободившееся место разместить новую пару. Хотел бы обратить внимание, что сдвигать элементы нужно с хвоста поезда.
```
public void put(String key, Integer value)
{
int j = findIndex(key);
if (j < size && key.equals(array[j].key))
{
array[j].value = value;
return;
}
if (size == array.length)
resize();
for (int t = size; t > j; t--)
array[t] = array[t - 1];
array[j] = new Node(key, value);
size++;
}
void resize()
{
Node[] newArray = new Node[size * 2 + 1];
for (int j = 0; j < size; j ++)
newArray[j] = array[j];
array = newArray;
}
}
```
На сдвиг элементов может потребоваться до N действий. Возможны дополнительные операции на пересоздание и копирование массива в размере Log N.
Сложность поиска: Log N операций = O(Log N).
Сложность вставки: Log N (поиск) + Log N (пересоздание) + N (сдвиг) + 1 (вставка) = O(N).
Требование к памяти: N (словарь) + N (резерв) = O(N).
Вывод: логарифмический поиск, линейное добавление, двойной расход памяти.
Исходный код **Storage3\_SortedArray** можно посмотреть и запустить [здесь](https://jdoodle.com/ia/xye).
Кстати, а можно ли уменьшить расходы по памяти, используя для хранения пар односвязный отсортированный список? Увы, нельзя. Потому как мы можем только скользить по односвязному списку, без возможности перехода к любому элементу по индексу. А отличительная черта обычного массива - это моментальный доступ к любому элементу по его индексу, что и используется при двоичном поиске ключа в отсортированном массиве.
Впрочем, мы можем отказаться от излишних копирований и сдвигов элементов, если для хранения словаря воспользуемся двоичным деревом поиска.
Но об этом в следующей статье, а также на [бесплатном уроке](https://otus.pw/qS49/), который пройдет уже 20 октября.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/qS49/) | https://habr.com/ru/post/693888/ | null | ru | null |
# Что записано в this? Закулисье JavaScript-объектов
JavaScript — это мультипарадигменный язык, поддерживающий объектно-ориентированное программирование и динамическую привязку методов — мощную концепцию, которая позволяет структуре JavaScript-кода меняться во время выполнения программы. Это даёт разработчикам серьёзные возможности, это делает язык гибким, но за всё надо платить. В данном случае платить приходится понятностью кода. Серьёзный вклад в эту цену вносит ключевое слово `this`, вокруг особенностей поведения которого собрано много такого, что способно запутать программиста.
[](https://habr.com/ru/company/ruvds/blog/455527/)
Динамическая привязка методов
-----------------------------
Динамическая привязка позволяет задать, во время выполнения программы, а не во время её компиляции, метод, который нужно вызвать при выполнении некоей команды. В JavaScript этот механизм реализуется с помощью ключевого слова `this` и цепочки прототипов. В частности, конкретное значение `this` внутри метода определяется во время выполнения программы, при этом правила определения этого значения меняются в зависимости от того, как был объявлен этот метод.
Давайте поиграем в одну игру. Я называю её «Что записано в this?». Перед вами её первый вариант — код ES6-модуля:
```
const a = {
a: 'a'
};
const obj = {
getThis: () => this,
getThis2 () {
return this;
}
};
obj.getThis3 = obj.getThis.bind(obj);
obj.getThis4 = obj.getThis2.bind(obj);
const answers = [
obj.getThis(),
obj.getThis.call(a),
obj.getThis2(),
obj.getThis2.call(a),
obj.getThis3(),
obj.getThis3.call(a),
obj.getThis4(),
obj.getThis4.call(a)
];
```
Прежде чем читать дальше — подумайте о том, что попадёт в массив `answers` и запишите ответы. После того как вы это сделаете — проверьте себя, выведя массив `answers` с помощью `console.log()`. Удалось ли вам правильно «расшифровать» значение `this` в каждом из случаев?
Разберём эту задачу, начав с первого примера. Конструкция `obj.getThis()` возвращает `undefined`. Почему? К стрелочной функции `this` привязать нельзя. Такие функции используют `this` из окружающей их лексической области видимости. Метод вызывается в ES6-модуле, в его лексической области видимости `this` будет иметь значение `undefined`. По той же причине `undefined` возвратит и вызов `obj.getThis.call(a)`. Значение `this` при работе со стрелочными функциями не может быть переназначено даже с помощью `.call()` или `.bind()`. Это значение всегда будет соответствовать `this` из лексической области видимости, в которой находятся такие функции.
Команда `obj.getThis2()` демонстрирует порядок работы с `this` при использовании обычных методов объекта. Если `this` к подобному методу не привязывали, и при условии того, что этот метод не является стрелочной функцией, то есть — он поддерживает привязку `this`, ключевое слово `this` оказывается привязанным к тому объекту, для которого метод вызывается с использованием синтаксиса доступа к свойствам объекта через точку или с помощью квадратных скобок.
С конструкцией `obj.getThis2.call(a)` разобраться уже немного сложнее. Метод `call()` позволяет вызвать функцию с заданным значением `this`, которое указывают в виде необязательного аргумента. Другими словами, в данном случае `this` берётся из параметра `.call()`, в результате вызов `obj.getThis2.call(a)` возвращает объект `a`.
С помощью команды `obj.getThis3 = obj.getThis.bind(obj);` мы пытаемся привязать к `this` метод, представляющий собой стрелочную функцию. Как мы уже выяснили, сделать этого нельзя. В результате вызовы `obj.getThis3()` и `obj.getThis3.call(a)` возвращают `undefined`.
К `this` можно привязывать методы, представляющие собой обычные функции, поэтому `obj.getThis4()`, как и ожидается, возвращает `obj`. Вызов `obj.getThis4.call(a)` возвращает `obj`, а не, как можно было бы ожидать, `a`. Дело в том, что мы, прежде чем вызывать эту команду, уже привязали `this` командой `obj.getThis4 = obj.getThis2.bind(obj);`. Как результат, при выполнении `obj.getThis4.call(a)` учитывается состояние метода, в котором он пребывал после выполнения первой привязки.
Использование this в классах
----------------------------
Вот второй вариант нашей игры — та же задача, но теперь уже основанная на классах. Здесь используется синтаксис объявления общедоступных полей классов (в данный момент [предложение](https://github.com/tc39/proposal-class-fields) по этому синтаксису находится на третьем этапе согласования, он по умолчанию доступен в Chrome, пользоваться им можно и с помощью `@babel/plugin-proposal-class-properties`).
```
class Obj {
getThis = () => this
getThis2 () {
return this;
}
}
const obj2 = new Obj();
obj2.getThis3 = obj2.getThis.bind(obj2);
obj2.getThis4 = obj2.getThis2.bind(obj2);
const answers2 = [
obj2.getThis(),
obj2.getThis.call(a),
obj2.getThis2(),
obj2.getThis2.call(a),
obj2.getThis3(),
obj2.getThis3.call(a),
obj2.getThis4(),
obj2.getThis4.call(a)
];
```
Прежде чем читать дальше — подумайте над кодом и запишите своё видение того, что попадёт в массив `answers2`.
Готово?
Здесь все вызовы методов, за исключением `obj2.getThis2.call(a)`, вернут ссылку на экземпляр объекта. Этот же вызов вернёт объект `a`. Стрелочные функции всё ещё берут `this` из лексической области видимости. Разница между этим примером и предыдущим заключается в различии областей видимости, из которых берётся `this`.
А именно, тут мы работаем со свойствами классов, что и определяет особенности поведения этого кода.
Дело в том, что в ходе подготовки кода к выполнению запись значений в свойства классов происходит примерно так:
```
class Obj {
constructor() {
this.getThis = () => this;
}
...
```
Иначе говоря, получается, что стрелочная функция оказывается объявленной внутри контекста функции-конструктора. Так как мы работаем с классом, единственным способом создания его экземпляра является использование ключевого слова `new` (если забыть об этом ключевом слове — будет выдано сообщение об ошибке).
Важнейшие задачи, решаемые ключевым словом `new`, заключаются в создании нового экземпляра объекта и в привязке `this` к конструктору. Эта особенность, с учётом того, о чём мы уже говорили в предыдущем разделе, должна помочь вам разобраться в происходящем.
Итоги
-----
Справились ли вы с задачами, приведёнными в этом материале? Хорошее понимание того, как в JavaScript ведёт себя ключевое слово `this`, сэкономит вам массу времени при отладке, при поиске неочевидных причин непонятных ошибок. Если вы ответили на некоторые из вопросов неправильно, это значит, что вам будет полезно попрактиковаться.
Поэкспериментируйте с кодом примеров, а потом опять испытайте себя, и так — до тех пор, пока у вас не получится ответить на все вопросы правильно. После того как разберётесь в этом сами — найдите кого-нибудь, готового вас выслушать, и расскажите ему о том, почему методы из заданий возвращают именно то, что возвращают.
Если всё это кажется вам более сложным, чем вы ожидали, то знайте, что вы в этом не одиноки. Я проверял на знание особенностей `this` довольно много разработчиков, и я так думаю, что только один из них был абсолютно точен во всех своих ответах.
Та подсистема языка, которая, в самом начале, выглядела как динамический поиск методов, на который можно было влиять помощью `.call()`, `.bind()` или `.apply()`, стала выглядеть гораздо сложнее после появления стрелочных функций и классов.
Видимо, тут полезно будет отметить основные особенности классов и стрелочных функций в плане использования `this`. Помните о том, что стрелочные функции всегда пользуются `this` из их лексической области видимости, а ключевое слово `this` в классах, на самом деле, привязано к функции-конструктору класса. А если вы когда-нибудь почувствуете, что не знаете точно, на что указывает `this`, воспользуйтесь отладчиком для того чтобы проверить свои предположения на этот счёт.
Кроме того, помните о том, что очень многое в JavaScript можно сделать и не используя `this` в коде. Опыт подсказывает мне, что практически любой JS-код можно переписать в виде чистых функций, которые принимают все аргументы, с которыми работают, в виде явным образом заданного списка параметров (`this` можно воспринимать как неявным образом заданный параметр с мутабельным состоянием). Логика, заключённая в чистых функциях, детерминирована, что улучшает их тестируемость. Такие функции не имеют побочных эффектов, что означает, что при работе с ними, в отличие от манипуляций с `this`, вы вряд ли «сломаете» что-нибудь, находящееся за их пределами. Всегда, когда вы меняете `this`, вы сталкиваетесь с потенциальной проблемой, которая заключается в том, что что-то, зависящее от `this`, может перестать правильно работать.
Несмотря на вышесказанное надо отметить, что `this` — это полезная концепция. Например, её можно применить для того, чтобы организовать совместное использование некоего метода множеством объектов. Даже в функциональном программировании `this` может пригодиться для вызова из одного метода объекта других его методов, что позволяет создавать что-то новое на базе существующих конструкций.
[](https://ruvds.com/ru-rub/#order)
[](https://ruvds.com/ru-rub/news/read/104) | https://habr.com/ru/post/455527/ | null | ru | null |
# Установка GitLab на Slackware
Доброго времени суток. У меня есть маленький подручный сервер, который используется как git сервер для показа клиенту проекта и т.д. Сервер работает на операционной системе Slackware v.13.1.0, семейства linux. Почему не Debian или Ubuntu — так исторически сложилось. Для просмотра git репозиториев я использовал cgit. Недавно возникла необходимость начать использовать GitLab. Если интересно — добро пожаловать под кат.
Так что такое GitLab? Если вам знаком GitHub, то это похожая структура, только на вашем сервере и под вашем контролем.
Для того, чтобы GitLab у нас заработал, необходимо установить Ruby 2+, MySQL, Git, Apache 2+, а также Python 2.6+ и последний Redis. Я упущу процесс установки mysql.
Итак, по порядку.
Необходимые компоненты
======================
---
Устанавливаем Python
---------------------
Поставим сначала *пайтон*. Стягиваем [отсюда](http://slackware.osuosl.org/slackware64-current/source/d/python/) пакет.
**План действий**
```
#делаем файл исполняемым
sudo chmod +x python.SlackBuild
#запускам скрипт
sudo ./python.SlackBuild
#устанавливаем пакет
sudo installpkg python
```
Устанавливаем Ruby
-------------------
Следующим делом установим руби. Процесс аналогичный установке пайтона, скачиваем [отсюда](http://slackware.osuosl.org/slackware64-current/source/d/ruby/) файлики.
**План действий**
```
#делаем файл исполняемым
sudo chmod +x ruby.SlackBuild
#запускам скрипт
sudo ./ruby.SlackBuild
#устанавливаем пакет
sudo installpkg ruby
```
Альтернативный способ установки ruby:
**Альтернативный план действий**
```
#создаем временную папку и переходим в нее
mkdir /tmp/ruby && cd /tmp/ruby
#скачиваем исходники руби и распаковываем их
curl --progress ftp://ftp.ruby-lang.org/pub/ruby/2.0/ruby-2.0.0-p353.tar.gz | tar xz
#переходим в распакованную папку исзодиников и начинаем процесс сборки
cd ruby-2.0.0-p353
./configure --prefix=/usr/local/
make
sudo make install
```
Не зависимо от того каким способом устанавливали руби, проверим, что у нас установилось:
```
#проверяем куда установился руби
which ruby
#проверяем версию руби
ruby --version
#устанавливаем bundler, без него никуда
gem install bundler --no-ri --no-rdoc
```
Устанавливаем Redis
--------------------
Процедура установки Redis отличается от двух предыдущих.
**План действий**
```
#зайдем во временный каталог
cd /tmp
#создадим папку где будем производить все махинации
mkdir redis
cd redis
#стягиваем и распаковываем исходники редиса
wget http://download.redis.io/redis-stable.tar.gz
tar xvzf redis-stable.tar.gz
cd redis-stable
#собираем все до купы
make
#далее копируем исполняемые файлы сервера и клиента
cd src
sudo cp redis-server /usr/local/bin/
sudo cp redis-cli /usr/local/bin/
```
Это еще не все. Чтобы сервис редиса поднимался когда стартует сервер, необходимо подправить файл /etc/local.conf:
```
#открываем от рута файл на редактирование
sudo nano /etc/local.conf
#находим строчку где написано [components] и под ней добавляем
/usr/local/bin/redis-server
```
Запускаем redis-server просто выполнив комманду «redis-server» (без кавычек). В другом терминале сделаем проверку, что сервер редиса поднялся:
```
#Выполняем комманду
redis-cli ping
#Ответ
PONG
```
Устанавливаем Git
------------------
Осталось установить git.
```
#скачаем и распакуем нужную версию гита
cd /tmp && curl --progress https://git-core.googlecode.com/files/git-1.9.0.tar.gz | tar xz
#перейдем в распакованную папку
cd git-1.9.0/
#соберем сурсы до купы
make prefix=/usr/local all
#установим git
sudo make prefix=/usr/local install
```
GitLab
=======
---
Приступим непосредственно к процессу установки GitLab.
Добавление пользователя git в систему
-------------------------------------
Если у вас еще не был создан пользователь git в системе, то необходимо с этого начать. Для этого выполним комманду в терминале:
```
sudo /usr/sbin/adduser --disabled-login git
```
Проходим пошаговое создание профиля пользователя. После создания проверяем, что у нас в /home создалась папка нового пользователя с именем git (если вы указали другое имя пользователя, к примеру gitlab, то имя папки будет gitlab, а так же в конце статьи будут заметки, где и что надо будет изменить в gitlab и gitlab-shell, чтобы все заработало).
Устанавливаем и настраиваем gitlab-shell
----------------------------------------
Первым делом стянем и установим gitlab-shell:
**План действий**
```
#заходим в папку пользователя git
cd /home/git
#клонируем с гитхаба исходники
sudo -u git -H git clone https://github.com/gitlabhq/gitlab-shell.git
cd gitlab-shell
#вместо VERSION подставим необходимую версию, я использовал на тот момент v1.9.0
sudo -u git -H git checkout VERSION
#переименовываем пример конфига
sudo -u git -H cp config.yml.example config.yml
#отредактируем конфиг
nano config.yml
#найдем строчку
#gitlab_url: "http://localhost/"
#и поменяем http://localhost/ на валидный адрес
#запустим установку от лица пользователя git
sudo -u git -H ./bin/install
```
Создаем mysql пользователя и db
-------------------------------
Далее надо создать в mysql таблички для gitlab. Создадим временный файлик, к примеру gitlab\_tables.sql и сохраним в нем следующее:
**sql**
```
-- подставляем вместо USER_PASSWORD валидный пароль или оставляем так
CREATE USER 'gitlab'@'localhost' IDENTIFIED BY 'USER_PASSWORD';
CREATE DATABASE IF NOT EXISTS `gitlabhq_production` DEFAULT CHARACTER SET `utf8` COLLATE `utf8_unicode_ci`;
GRANT SELECT, LOCK TABLES, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER ON `gitlabhq_production`.* TO 'gitlab'@'localhost';
```
Логинимся в mysql пользователем root и выполняем не хитрую комманду
```
-- gitlab_tables.sql - имя временного файлика
source gitlab_tables.sql;
```
Легким движением рук мы создали пользователя с именем gitlab и базу данных gitlabhq\_production, а так же дали права для оного пользователя на эту базу.
Более этот файл не понадобится, можем смело его удалять.
Устанавливаем и настраиваем gitlab
----------------------------------
Теперь приступим к установке и настройке самого gitlab:
**План действий**
```
#переходим в корень домашней папки пользователя git
cd /home/git
#клонируем исходники gitlab в папку gitlab и переходим в новую склонированную папку
sudo -u git -H git clone https://github.com/gitlabhq/gitlabhq.git gitlab
cd /home/git/gitlab
#вместо VERSION подставим необходимую версию, я использовал на тот момент 7-2-stable
sudo -u git -H git checkout VERSION
#переименуем пример конфига в обычный кофиг
sudo -u git -H cp config/gitlab.yml.example config/gitlab.yml
#откроем на редактирование конфиг файл
sudo -u git -H nano config/gitlab.yml
#и заменим localhost на верный адрес
## Web server settings
host: localhost
port: 80
https: false
#скопируем конфиг для базы
sudo -u git cp config/database.yml.mysql config/database.yml
#откроем на редактирование настройки gitlab для работы с mysql базой
sudo -u git -H nano config/database.yml
#в этом файле следующие три строчки встречаются три раза, меняем параметры на те которые мы использовали при создании mysql базы ранее
database: gitlabhq_production
username: root
password: "secure password"
```
Устанавливаем права на файлы и папки внутри /home/git/gitlab:
**План действий**
```
cd /home/git/gitlab
sudo chown -R git log/
sudo chown -R git tmp/
sudo chmod -R u+rwX log/
sudo chmod -R u+rwX tmp/
sudo -u git -H mkdir /home/git/gitlab-satellites
sudo -u git -H mkdir tmp/pids/
sudo -u git -H mkdir tmp/sockets/
sudo chmod -R u+rwX tmp/pids/
sudo chmod -R u+rwX tmp/sockets/
sudo -u git -H mkdir public/uploads
sudo chmod -R u+rwX public/uploads
sudo -u git -H cp config/unicorn.rb.example config/unicorn.rb
sudo -u git -H git config --global user.name "GitLab"
sudo -u git -H git config --global user.email "gitlab@localhost"
sudo -u git -H git config --global core.autocrlf input
sudo -u git -H chmod o-rwx config/database.yml
```
Устанавливаем ruby gems
-----------------------
Следующим шагом будет установка ruby gems:
```
#заходим в папку gitlab в домашней папке пользователя git
cd /home/git/gitlab
#установим charlock_holmes, на момент установки актуальная версия была 0.7.3
sudo gem install charlock_holmes --version '0.7.3'
#запустим установку всего бандла зависимостей(этот шаг может занять много времени, запаситесь терпением)
sudo -u git -H bundle install --deployment --without development test postgres aws
```
Запускаем установку gitlab
--------------------------
Осталось только запустить установку и настройку самого gitlab:
```
#если запустите от пользователя root - процесс пойдет, вам покажут предупреждение что от рута нет гарантии, что все верно будет работать
#когда спросят подтверждения старта установки - отвечаем 'yes'
sudo -u git -H bundle exec rake gitlab:setup RAILS_ENV=production
```
По окончанию установки, если все прошло успешно, в консоли высветится следующее:
```
Administrator account created:
login.........root
password......5iveL!fe
```
Проверка валидности конфигурации gitlab
---------------------------------------
Осталось совсем не много. Проверим, что у нас все сконфигурировано верно и донастроим конфиг, чтобы при старте сервера, gitlab стартовал автоматически:
**План действий**
```
#проверим как сконфигурирован наш gitlab
sudo -u git -H bundle exec rake gitlab:env:info RAILS_ENV=production
#если предыдущая комманда выполнилась без ошибок, продолжаем далее, иначе резолвим ошибки
#скопируем скрипт
sudo cp lib/support/init.d/gitlab /etc/init.d/gitlab
#сделаем скрипт исполняемым
sudo chmod +x /etc/init.d/gitlab
#откроем на редактирование local.conf:
sudo nano /etc/local.conf
#находим строчку где написано [components] и под ней добавляем
git@/etc/init.d/gitlab
#git - имя пользователя от лица которого выполнить скрипт
```
Стартуем gitlab
---------------
Теперь самое время стартануть gitlab, для этого выполняем следующую комманду:
```
sudo -u git -H /etc/init.d/gitlab start
```
Если все хорошо, то в консоли мы увидим следующее:
```
The GitLab Unicorn web server with pid 15869 is running.
The GitLab Sidekiq job dispatcher with pid 16468 is running.
GitLab and all its components are up and running.
```
По умолчанию gitlab крутится через unicorn на порту 8080 и мы можем убедиться в этом:
```
#запустим браузер lynx
lynx localhost:8080
```
Результат работы lynx будет вывод страницы для авторизации пользователя. Вводим логин 'root' и пароль '5iveL!fe' (все без кавычек). Сабмитим форму и видим предложение от gitlab сменить текущий пароль, меняем.
Настраиваем Apache конфиг для gitlab
------------------------------------
Осталось настроить Apache. Переходим в папку /etc/httpd/sites-available и создаем там файлик gitlab со следующим содержимым:
**Содержимое конфиг файла gitlab для Apache**
```
ServerName OUR\_COOL\_URL
ServerSignature Off
ProxyPreserveHost On
# Ensure that encoded slashes are not decoded but left in their encoded state.
AllowEncodedSlashes Off
Order deny,allow
Allow from all
ProxyPassReverse http://127.0.0.1:8080
ProxyPassReverse http://OUR\_COOL\_URL/
# apache equivalent of nginx try files
RewriteEngine on
RewriteCond %{DOCUMENT\_ROOT}/%{REQUEST\_FILENAME} !-f
RewriteRule .\* http://127.0.0.1:8080%{REQUEST\_URI} [P,QSA]
# needed for downloading attachments
DocumentRoot /home/git/gitlab/public
Alias /gitlab /home/git/gitlab/public
Options All -Indexes
AllowOverride All
Order deny,allow
Allow from all
Options All -Indexes
AllowOverride All
Order deny,allow
Allow from all
LogFormat "%{X-Forwarded-For}i %l %u %t \"%r\" %>s %b" common\_forwarded
ErrorLog /var/log/httpd/gitlab\_error.log
LogLevel warn
CustomLog /var/log/httpd/gitlab\_access.log combined env=!dontlog
CustomLog /var/log/httpd/gitlab combined
```
Полезные заметки
================
---
Проблемы, с которыми возможно столкнуться во время установки и после
--------------------------------------------------------------------
* Если вы использовали другое имя пользователя отличное от git то необходимо во всех конфигах gitlab, gitlab-shell, redis поменять пути. К примеру, в gitlab-shell в файле config.yml необходимо в нескольких местах исправить пути, допустим у нас пользователь gitlab:
**План действия**
```
#путь где будут созданы репозитории
repos_path: "/home/gitlab/repositories"
#путь к папке где будут храниться паблик ключи пользователей
auth_file: "/home/gitlab/.ssh/authorized_keys"
#путь к файлу логов
log_file: "/home/gitlab/gitlab-shell/gitlab-shell.log"
```
* По умолчанию пользователь Administrator(root) создан с email example@localhost, мы можем изменить этот email, а так же email from на нужные в следующих файлах:
**Список файлов**
```
/home/git/gitlab/config/gitlab.teatro.yml: email_from: example@localhost
/home/git/gitlab/config/gitlab.teatro.yml: support_email: example@localhost
/home/git/gitlab/config/gitlab.yml: email_from: example@localhost
/home/git/gitlab/db/fixtures/development/01_admin.rb: s.email = "example@localhost"
/home/git/gitlab/db/fixtures/production/001_admin.rb: email: "example@localhost"
```
* Если у вас при git push в репозиторий проекта, созданного в gitlab, вылазит следующая ошибка «constants.rb:2:in `': uninitialized constant Bundler: :RbConfig (NameError)», то необходимо обновить установленный в системе ruby.
**План действия**
```
#запускаем
sudo /sbin/pkgtool
#открываем View и ищем в списке ruby (для быстрого перехода можно нажать на "r")
#выходим и пишем
which ruby
which rake
which gem
#сравниваем версии, 99% , что версия в pkgtool младше и нужно будет сделать обновление
#так же на всякий случай откроем на редактирование файлик boot в папке gitlab
sudo -u git -H nano config/boot.yml
#и добавим следующее прямо перед строчкой require 'rubygems', и заменим RIGHT_PATH_TO_GEM_FROM_WHICH_RESULT на путь который мы получили
#как результат комманды which gem
ENV['GEM_PATH'] = "RIGHT_PATH_TO_GEM_FROM_WHICH_RESULT"
Gem.clear_paths
```
* Если у вас во время git push в репозиторий проекта созданного в gitlab вылазит следующая ошибка «GitLab: An unexpected error occurred (redis-cli returned 127).», делаем следующее:
**План действия**
```
#открываем на редактирование файл config в gitlab-shell
cd /home/git/gitlab-shell && sudo -u git -H nano config.yml
#находим следующий блок
# Redis settings used for pushing commit notices to gitlab
redis:
bin: /usr/local/redis-cli
#и меняем значение в bin на правильный путь к redis-cli
```
Полезные ресурсы
----------------
* [Официальный сайт GitLab](https://about.gitlab.com/)
* [Официальный репозиторий GitLab на GitHub](https://github.com/gitlabhq)
* Поиграться с рабочим примером можно [тут](http://demo.gitlab.com/users/sign_in) | https://habr.com/ru/post/235591/ | null | ru | null |
# OpenSource в действии
Очень часто в сети можно встретить пространные рассуждения о несомненной пользе открытого программного обеспечения, о мотивации программистов, участвующих в подобных проектах и так далее. Кроме того, особенно отмечается тот факт, что любой пользователь подобного ПО при наличии определенных технических навыков сможет «заточить» все это добро под себя. Дескать, не зря же исходный код-то открыт.
Однако лично я знаю очень мало людей (если быть честным, всего двух), которые хотя бы в малой мере пользовались преимуществами открытого исходного кода используемых ими программ. Основные аргументы: я не знаю, где этот самый код брать; я не знаю, как это все потом собирать; я боюсь сделать из своего дистрибутива помойку, собирая собственные модули.
В этой небольшой статье я постараюсь привести простой пример того, как можно модифицировать что-либо, сохранив при этом стройную пакетную и репозитарную структуру дистрибутива.
Для иллюстрации всех приемов и механизмов я поставил перед собой довольно просто осуществимую, но не имеющую никакой практической ценности цель: у меня есть часто используемая утилита wget и я кровь из носа, как хочу, чтобы она со мной здоровалась при каждом запуске. Вот хочу и все тут. К этому и будем стремиться.
Поскольку все описанные далее манипуляции я выполнял на своем домашнем дистрибутиве (Fedora), то и рассматривать мы будем утилиты и команды, относящиеся к этой конкретной сборке. В других системах будут отличия (deb вместо rpm, aptitude вместо yum), но нас в большей части интересует методология, а не детали.
Для работы нам понадобятся установленные пакеты yum-utils и rpm-build.
Итак, для начала нам нужно определиться, к какому пакету относится наш исполняемый файл:
`[root@phantomazz ~]$ rpm –qf `which wget`
wget-1.11.4-3.fc11.x86_64`
Ага, наш пакет так и называется – “wget”. Теперь нам нужны его исходные коды. Помимо бинарных пакетов, в репозиториях хранятся обычно и пакеты с исходниками, поэтому нам не нужно ничего нигде искать. Достаточно воспользоваться встроенными средствами:
`[root@phantomazz ~]$ yumdownloader --source wget`
После выполнения этой команды в текущей директории появится rpm-пакет, содержащий интересующие нас исходные коды актуальной нам версии. Его необходимо установить:
`[root@phantomazz ~]$ rpm –ivh wget-1.11.4-3.fc11.src.rpm`
Все дальнейшие действия будут происходить в папке ‘/root/rpmbuild’, которая автоматом будет создана при установке пакета с исходными кодами. Именно там, в подпапке ‘SOURCES’ мы найдем непосредственно архив с исходными кодами ‘wget-1.11.4.tar.bz2’. Дальше дело техники: распаковать архив, найти файл ‘main.c’, в функции main сделать интересующие нас изменения (добавить вожделенный printf), и, внимание, запаковать все обратно в архив с таким же именем. Мы не будем собирать отдельный модуль – нас интересует пакет целиком, потому что это правильно. Никаких 'make && make install', после которых концы не найдешь, только пакеты, тем более что вся инфраструктура, необходимая для этого, уже подготовлена. Дело за малым – перейти в каталог ‘/root/rpmbuild/SPECS’ и выполнить:
`[root@phantomazz ~]$ rpmbuild -bb wget.spec`
Утилита rpmbuild сама выполнит сборку бинарных модулей и упакует все в единый пакет. Она действует в соответствии со .spec файлом, так что и на этом этапе есть возможность внести свои изменения: добавить или удалить какие-либо файлы из пакета, модифицировать установочные скрипты и так далее. Механизм обладает определенной гибкостью.
Итого на выходе в папке ‘/root/rpmbuild/RPMS’ мы получим пакет, готовый либо к немедленной установке в нашей системе, либо к дальнейшему распространению его среди подобных нам обладателей мании величия, которые любят, чтобы их утилиты с ними здоровались.
Как продолжение темы, возможно написание патча (кстати, примеры патчей можно посмотреть в каталоге с исходными кодами), автоматизирующего сборку пакета с нужным нам функционалом в будущих версиях, а возможен и запрет дальнейшего обновления этого пакета вообще, если он нас устраивает. Дело хозяйское. | https://habr.com/ru/post/77070/ | null | ru | null |
# Dropbox как Git репозиторий
Хочу поделиться хорошим способом хранения главного репозитория.
Делается это созданием bare—репозитория в папке Dropbox'a:
`~/Project $ git init
~/Project $ git add .
~/Project $ git commit -m "first commit"
~/Project $ cd ~/Dropbox
~/Dropbox $ mkdir Repos/YourProject.git
~/Dropbox $ cd Repos/YourProject.git
~/Dropbox $ git init --bare
~/Dropbox $ cd ~/Project
~/Project $ git remote add origin ~/Dropbox/Repos/YourProject.git
~/Project $ git push origin master`
Клонируем проект из Вашего репозитория, привязанного к Dropbox аккаунту:
`clone ~/Dropbox/Repos/YourProject.git`
Теперь можно совершать любые Git операции, которые будут синхронизированы со всеми рабочими машинами.
Все то же самое можно сделать с любым gui клиентом для Git.
#### GUI
Вот как процесс будет выглядеть для TortoiseGit:
В Dropbox папке, где предполагается хранить главный репозиторий, кликаем правой кнопкой мыши и выбираем «Git Create repository here...».
В появившемся окне ставим галочку «Make it Bare» и создаем bare—репозиторий.
Должны появиться следующие файлы и папки.
Клонировать репозиторий можно так:
Переходим в папку, где будет храниться проект, кликаем правой кнопкой и выбираем «Git Clone...».
Должно появиться окно, где надо указать Dropbox репозиторий, жмем OK.
 | https://habr.com/ru/post/119433/ | null | ru | null |
# Двухколёсная автоматизация загрузки файлов на сервер из Notepad++
Так уж вышло, что по работе, мне приходится редактировать файлы, к которым я имею доступ только через файловый менеджер CMS Bitrix, что влечёт за собой открытие множества вкладок в браузере и огромное количество ненужных телодвижений необходимых лишь для того, чтобы отредактировать несколько файлов.
Ниже я расскажу как решил эту проблему с помощью Node.js и свободного времени.
Первое что я сделал — это узнал, как вообще битрикс подходит к редактированию файлов. Всё оказалось довольно просто и ничуть не превзошло мои ожидания — текст файла отправляется формой на сервер вместе с именем файла, где php скрипт открывает указанный файл и записывает в него содержимое.
Самое логичное, что пришло мне в голову — имитировать отправку формы на тот же обработчик.
Для этого нужно сделать 3 вещи:
* Притвориться браузером
* Притвориться пользователем у которого есть права на редактирование файлов
* Отправить форму
Каждый, кто хоть немного знает о [http](http://ru.wikipedia.org/wiki/%C7%E0%E3%EE%EB%EE%E2%EA%E8_HTTP) протоколе знает что за определение клиентской программы отвечает строка User-Agent в заголовке запроса.
Вот именно здесь и следует указать сигнатуру программы, под которую мы маскируемся. У меня это:
`Mozilla/5.0 (Windows NT 6.1; WOW64; rv:22.0) Gecko/20100101 Firefox/22.0`
Чуть сложнее дело обстоит с выдачей себя за пользователя. Методом тыка, а точнее поочерёдным удалением кук, было установлено, что для того чтобы сайт считал пользователя вошедшим — ему необходимы лишь его логин и актуальный [phpsessid](http://www.php.su/articles/?cat=examples&page=070#start). Логин я и так знаю, а вот номер сессии узнать можно несколькими способами.
Во-первых, можно просто посмотреть его с помощью «Инструментов разработчика» доступных в любом браузере.
Во-вторых, раз уж мы отправляем форму — можно перед этим отправлять форму входа на сайт, чтобы он номер сессии пришёл нам в виде куки.
Учитывая, что в любом случае загрузка файлов связана со входом на сайт, я решил воспользоваться первым способом, однако вместо того чтобы каждый раз открывать FireBug, просто добавил вывод phpsessid на одну из страниц сайта.
Последнее, и главное, что нам необходимо сделать — это отправить данные на сервер, как-будто бы из формы.
Здесь тоже нет ничего сложного. Во всё том же заголовке запроса указываем Content-Type, который определяет тип прилагаемого к заголовку контента, и добавляем Content-Length, что необходимо для того чтобы сервер знал сколько контента надо принять.
После этого в теле запроса посылаем сериализованные данные, которыми являются текст файла, его имя на сервере и некоторые другие переменные необходимые обработчику формы.
Теперь, когда «расчёты» окончены, можно переходить к практике.
Для начала определим — какая вообще информация необходима для успешной загрузки файлов на сервер. Кроме указанных логина и номера сессии необходим путь к файлам на локальной машине и путь на сервере, куда эти файлы будут сохраняться.
Первый было решено передавать скрипту как аргумент, а всю остальную информацию хранить в файле в той папке, которая передаётся скрипту.
В nodejs аргументы командной строки хранятся в поле **argv** глобальной переменной **process**, причем, даже если аргументы в программу не передаются — в массиве **process.argv** всёравно лежат 2 строки — «node» и имя выполняемой программы, поэтому первый аргумент лежит по смещению — 2. Сначала проверяем, передан ли хоть какой-то аргумент нашему скрипту, и если его вдруг не оказалось — выходим.
```
if(process.argv.length<3){
console.log("Необходим один аргумент!");
process.exit(1);
}
```
Получив путь до локальной папки, открываем файл *config.json* который должен там лежать.
За работу с файлми в nodejs отвечает модуль fs (FileSystem). Модули в nodejs это по сути просто наборы функций, однако все мы знаем что функции в javascript не совсем такие как в других языках.
Нам же понадобится вполне заурядная функция **fs.readFile(path, callback)** которая, как вы и сами можете догадаться — считывает содержимое файла. Если с первым её аргументм всё понятно, то второй — это функция, которая будет выполнена, когда файл будет полностью прочтён. Причём прогамма не замрёт в ожидании этого момента, а продолжит своё выполнение. Такой подход к организации программы называется «Событийно-ориентированное программирование». Итак — читаем файл настроек в указанной папке. Его содержимое будет передано в callback функцию вторым аргументом. Первым же, будет ошибка или false если всё нормально.
```
var fs = require('fs'); // говорим, что будем использовать модуль fs
fs.readFile(process.argv[2]+'\config.json', function (err, data) {
if (err) throw err;
c = JSON.parse(data);// получаем информацию из json файла и записываем в глобальную переменную
//...что-то с этими данными делаем
});
```
Далее необходимо получить список файлов в папке и каждый из них загрузить на сервер, если только этот файл не является файлом конфигурации или другим игнорируемым файлом.
```
//...внутри предыдущей функции
fs.readdir(process.argv[2],function(err,files){ // берём список файлов в папке
if (err) throw err;
files.forEach(function(el,index,array){
if(el.split('.').length>1)
if(el!='config.json' && el!='.git' && el!='.gitattributes' && el!='.gitignore') // если файл подходит
upload(el); // загружаем его на сервер
});
});
```
Получив имя файла, мы можем прочитать его содержимое и послать его на сервер. Именно это мы и сделаем. Для того чтобы послать http запрос в nodejs есть модуль **http**. Подключив его мы можем вызвать функцию **http.request(method, path, port, hostname, headers, callback)**, где предпоследний аргумент буквально делает нас всемогущими, ведь он позволяет отправить запрос с каким угодно заголовком, именно здесь мы укажем User-Agent, куки и тип контента запроса. Делая запрос мы получаем его в переменную, через которую можем влиять на его поведение. Например методы **write()** и **end()**. Отправляют данные в теле запроса с той лишь разницей что write можно вызвать несколько раз подряд, а end — только в один раз т.к. сразу после его вызова последует завершение запроса.
Как было сказано ранее — данные необходимо отправлять в сериализованном виде, а именно — так как мы бы из видели в адресной строке. В nodejs есть модуль для работы с такими данными, и называется он — querystring. Он позволяет сохранять объект в строку и наоборот. Все данные формы у нас хранятся в глобальной переменной *query*, которую мы и сериализуем для последующей отправки.
```
var http = require('http');
var querystring = require('querystring');
function upload(file){
console.log("Загрузка файла %s:",file);
var fileData=fs.readFileSync(process.argv[2]+'\\'+file); // получаем содержимое файла
query.path=c.path+file;// указываем в форме имя отправляемого файла
query.filesrc=fileData.toString();
var str=querystring.stringify(query);// сериализуем данные формы
var len=str.length;
var request = http.request( // выполняем запрос
{
method:'post',
path:'/bitrix/admin/fileman_file_edit.php',
port:80,
hostname:'***.****.ru',
headers:{
'host':'***.****.ru',
'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:22.0) Gecko/20100101 Firefox/22.0',
'Cookie':'PHPSESSID='+c.phpsessid+';BITRIX_SM_LOGIN='+c.login,
'Content-Type':'application/x-www-form-urlencoded',
'Content-Length':len
}
},rListener); // указываем функцию которая будет вызвана когда придёт ответ
request.end(str); // посылаем тело запроса (сериализованную форму) и завершаем его
}
```
Ну и для того чтобы знать — загружен ли наш файл или труды наши были напрасны — принимаем ответ на запрос. Callback вызываемый при получении ответа, первым аргументом принимает всю информацию ответа, в том числе и статус. Всё тем же методом тыка, было обнаружено, что при успешной загрузке файла в ответ приходит редирект, в остальных же случаях в ответ приходит страница.
```
function rListener(response){
var status='';
switch(response.statusCode){
case 302: status='Файл загружен';break; // если пришёл редирект - всё ОК
case 200: status='Ваша сессия просрочена';break;
default : status='Ошибка';
}
console.log('%s (%d).',status,response.statusCode);
}
```
Полный код скрипта лежит [здесь](https://github.com/MadridianFox/Deploy_To_Bitrix).
Имея такой вот велосипед, довольно просто настроить вызов скрипта по нажатию клавиши в вашем любимом редакторе. У меня это Notepad++ с плагином NppExec. | https://habr.com/ru/post/190272/ | null | ru | null |
# Изоморфное Приложение с React и Redux
Итак, я знаю что ты любишь Todo списки, то есть, что тебе очень нравится писать Todo списки, поэтому мне хочется, чтобы ты создал один из них, используя новый, восхитительный и питательный *(«nutritious» прим. пер.)* Flux фреймворк, [Redux](https://github.com/gaearon/redux)! Я желаю тебе только лучшего.
В этой статье ты научишься как сконструировать свое собственное Redux приложение, не ограничиваясь, но так же включая.
* Цельнозерновой рендеринг на сервере
* Расширенный роутинг, богатый Omega-3
* Маслянистая асинхронная загрузка данных
* Гладкое функциональное послевкусие
Если это похоже на то, чего ты хочешь в этой жизни, вперед под кат, если нет, то не заморачивайся.
Хочу тебе сказать… Это будет не супер маленький туториал, так что пристегнись и приготовься к тернистому пути, не высовывай руки и ноги и все такое…
#### **Стоп, подожди, а что такое Redux?**
Ох, я рад что ты спросил!
[**Redux**](https://github.com/gaearon/redux) это новый Flux фреймворк от [Данила Абрамова](https://github.com/gaearon), который убирает много лишних сложностей. Ты можешь почитать почему этот фреймворк был создан [здесь](https://medium.com/@dan_abramov/the-evolution-of-flux-frameworks-6c16ad26bb31) или [посмотреть](http://www.youtube.com/watch?v=xsSnOQynTHs), в общем TL: DR **Redux** держит состояние твоего приложения в одном месте, и определяет минимальный, но достаточно мощный способ взаимодействия с этим состоянием *(state ориг.)*.
Если ты знаком с [традиционными](https://facebook.github.io/flux/docs/overview.html) [Flux](http://acdlite.github.io/flummox) [фреймворками](http://martyjs.org/), тогда самая большая разница, которую ты заметишь, это отсутствие Хранилищ *(Stores ориг.)*, и присутствие «Редюсеров» *(Reducers ориг.)*.
В **Redux**, все состояние приложения живет в одном месте (экземпляр Redux), вместо разделения на отдельные хранилища (которые могут немного противится изоморфизму).
«Редюсер» — это описание того как состояние будет изменятся, он ничего не меняет по сути, и выглядит примерно так:
```
function exampleReducer(state, action) {
return state.changedBasedOn(action)
}
```
Как? Ты посмотришь чуть позже.
Ты вероятно думаешь что **Redux** больше похоже на решение чем на фреймворк. Это минимальная база, которая содержит все лучшие идеи Flux. Эта статья я надеюсь научит тебя успешно это использовать, процветать и идти с минимальными мутациями.
#### **Делаем себе комфортно**
Мы будем использовать [Webpack](http://webpack.github.io/) и [Babel](http://babeljs.io/), чтобы связать вместе наше приложение, потому что мы классные, умные и радостные, и потому что они дают нам возможность [перезагрузки кода налету](https://gaearon.github.io/react-hot-loader/) и самые свежие ES6/7 фишки.
Сначала мы должны создать директорию и положить туда несколько файлов.
Вот ***package.json*** который я заранее приготовил:
**package.json**
```
{
"name": "isomorphic-redux",
"version": "1.0.0",
"description": "Basic isomorphic redux application",
"main": "index.js",
"scripts": {
"start": "NODE_PATH=$NODE_PATH:./shared node .",
"dev": "npm run start & webpack-dev-server --progress --color"
},
"author": " <>",
"license": "MIT",
"dependencies": {
"axios": "^0.5.4",
"express": "^4.13.2",
"immutable": "^3.7.4",
"object-assign": "^3.0.0",
"react": "^0.13.3",
"react-redux": "^0.2.2",
"react-router": "^1.0.0-beta3",
"redux": "^1.0.0-rc"
},
"devDependencies": {
"babel": "^5.8.20",
"babel-eslint": "^4.0.5",
"babel-loader": "^5.3.2",
"eslint": "^1.0.0",
"eslint-plugin-react": "^3.1.0",
"react-hot-loader": "^1.2.8",
"webpack": "^1.10.5",
"webpack-dev-server": "^1.10.1"
}
}
```
а также
**webpack.config.js**
```
var path = require('path');
var webpack = require('webpack');
module.exports = {
entry: [
'webpack-dev-server/client?http://localhost:8080/',
'webpack/hot/only-dev-server',
'./client'
],
output: {
path: path.join(__dirname, 'dist'),
filename: 'bundle.js'
},
resolve: {
modulesDirectories: ['node_modules', 'shared'],
extensions: ['', '.js', '.jsx']
},
module: {
loaders: [
{
test: /\.jsx?$/,
exclude: /node_modules/,
loaders: ['react-hot', 'babel']
}
]
},
plugins: [
new webpack.HotModuleReplacementPlugin(),
new webpack.NoErrorsPlugin()
],
devtool: 'inline-source-map',
devServer: {
hot: true,
proxy: {
'*': 'http://localhost:' + (process.env.PORT || 3000)
}
}
};
```
и ***.babelrc*** (для 'ES7' сахарка)
```
{
"optional": ["es7.decorators", "es7.classProperties", "es7.objectRestSpread"]
}
```
Признаться, эти файлы не так примечательны, просто создали себе разумное dev окружение.
Хорошо, теперь нужно запустить `npm i`, чтобы скачать все зависимые модули, и можно начинать.
#### **Подайте мне Seymour**
Базовая структура приложения будет выглядеть так:
```
client/
shared/
index.js
server.jsx
```
Все главные части кода будут лежать в `shared` директории, но нужен некоторый склеивающий код для отделения клиенсткой и серверной части.
**index.js**
```
'use strict';
require('babel/register')({});
var server = require('./server');
const PORT = process.env.PORT || 3000;
server.listen(PORT, function () {
console.log('Server listening on', PORT);
});
```
просто файл для запуска ***server.jsx***, итак теперь мы можем использовать ES6/JSX.
Функции сервера будет выполнять [Express](http://expressjs.com/), потому что это проще, и есть шанс что ты уже его знаешь.
**server.jsx**
```
import express from 'express';
const app = express();
app.use((req, res) => {
const HTML = `
Isomorphic Redux Demo
`;
res.end(HTML);
});
export default app;
```
Довольно стандартная фигня. Мы настроили Express сервер с глобальным middleware, но ничего не обрабатываем, просто пустая веб страничка, которая поможет нам заглянуть в пустоту существования. Давайте исправим это.
#### **Роутим как про**
Ты наверно думаешь, что с Express роутингом и шаблонизатором это будет легко. К сожалению ты ошибаешься, поскольку мы хотим расшарить как можно больше логики между сервером и клиентом. Мы будем использовать [React Router](https://github.com/rackt/react-router), так как он может роутить на клиенте и на сервере.
Итак, у нас есть root компонент `shared/components/index.jsx`, в который встроится наш React Router. Таким способом мы можем добавить эстетики всему приложению (шапку и подвал, например), хорошая архитектура для блестящего SPA.
**shared/components/index.jsx**
```
import React from 'react';
export default class AppView extends React.Component {
render() {
return (
Todos
=====
---
{this.props.children}
);
}
}
```
***children*** здесь потом превратится в дерево компонентов, которое даст нам роутер после его магии с зависимостями. Здесь нет ничего особенного, просто выводим все как есть.
Далее нам нужно определить роут в
**shared/routes.jsx**
```
import React from 'react';
import { Route } from 'react-router';
import App from 'components';
export default (
);
```
Здесь мы просто говорим React Router'у отображать наш `components/index` по пути '/'. Звучит неплохо!
Теперь тоже самое сделаем на сервере.
**server.jsx**
```
import React from 'react';
import { Router } from 'react-router';
import Location from 'react-router/lib/Location';
import routes from 'routes';
app.use((req, res) => {
const location = new Location(req.path, req.query);
Router.run(routes, location, (err, routeState) => {
if (err) return console.error(err);
const InitialComponent = (
);
const componentHTML = React.renderToString(InitialComponent);
const HTML = `...`;
res.end(HTML);
});
});
```
Здесь мы импортируем пару новых игрушек и говорим роутеру направить запрос в руки express. Надеюсь мы вернемся к `routeState` переменной и сможем отобразить тот маршрут который с нас спрашивают. Затем мы можем использовать ловкий метод `renderToString` из **React**, который выведет наш компонент в HTML строку, которую мы отдадим клиенту в **react-view** div написанный нами ранее.
```
${componentHTML}
```
Если мы запустим `npm start` то увидим здесь <http://localhost:3000/>, что роут вставился в HTML.
Ты заметишь, что появилось пару ошибок в консоле, о том что роутеру нужно несколько значений. Это потому что клиент пытается загрузить `bundle.js`, но мы еще не задали webpack'у точку входа, поэтому такая фигня.
Выглядит офигенно, и я уверен, что ваш мозг уже порвало, но сейчас у нас просто статическая страничка. Для того, чтобы получить всю сочную мякотку из React, нам нужно реализовать роутинг на клиенте.
Так что вперед, откроем `client/index.jsx` и напишем что нибудь:
**client/index.jsx**
```
import React from 'react';
import { Router } from 'react-router';
import { history } from 'react-router/lib/BrowserHistory';
import routes from 'routes';
React.render(
,
document.getElementById('react-view')
);
```
Мы сказали React'у вставить компонент Router'a в **react-view** div, и передали ему соответствующие параметры. **History** объект, который мы не видели в серверной части, необходимая часть конфигурации React Router'a (когда отображаем напрямую), и описывает как выглядит URL. А мы хотим хороший и чистый объект! Поэтому будем использовать **HTML5 History API** с **BrowserHistory**, хотя для старых браузеров мы могли бы использовать **HashHistory** и получать `/#` URL из адреса.
Теперь мы можем запустить наше приложение `npm run dev` и Webpack будет обрабатывать наш **bundle.js**. Выглядит не так уж интересно, но зайдя на <http://localhost:8080/> должно все работать без ошибок. С роутингом покончено, и мы готовы к Redux экшену.
#### **Reduce, Reuse, Redux**
Redux внешне очень похож на Flux за исключением того, как я говорил ранее, что используются редюсеры вместо хранилищ. Во-первых мы напишем несколько простых действий для изменения Todo листа.
**shared/actions/TodoActions.js**
```
export function createTodo(text) {
return {
type: 'CREATE_TODO',
text,
date: Date.now()
}
}
export function editTodo(id, text) {
return {
type: 'EDIT_TODO',
id,
text,
date: Date.now()
};
}
export function deleteTodo(id) {
return {
type: 'DELETE_TODO',
id
};
}
```
Как ты можешь видеть, в Redux создатели действий *(action creators ориг.)*, это просто функции, которые возвращают последовательно отформатированные объекты. Никакой магии, далее нам нужны редюсеры, чтобы обрабатывать их.
**shared/reducers/TodoReducer.js**
```
import { List } from 'immutable';
const defaultState = new List();
export default function todoReducer(state = defaultState, action) {
switch(action.type) {
case 'CREATE_TODO':
return state.concat(action.text);
case 'EDIT_TODO':
return state.set(action.id, action.text);
case 'DELETE_TODO':
return state.delete(action.id);
default:
return state;
}
}
```
Опять все просто. Здесь мы можем использовать [Immutable List object](https://facebook.github.io/immutable-js/docs/#/List), чтобы хранить неизменяемое состояние в хранилище (хотя в более больших приложениях может быть все посложнее), и возвращать новую версию состояния в зависимости от действия.
Redux не такой уж упрямый, у него всего два ожидания от своих редюсеров.
1. Он должен иметь сигнатуру `(state, action) => newState`.
2. Редюсер не изменяет передаваемое ему состояние, но возвращает его новую версию.
Как ты можешь увидеть, последнее неплохо вяжется с [Immuatable.js](https://facebook.github.io/immutable-js/)
Здесь у нас используется простая switch конструкция, но если тебе это не нравится, не стесняйся написать болванку, которая привнесет немного абстракции.
Redux не ограничивается использованием одного редюсера, для удобства их получения, можно создать `reducers/index.js`:
```
export { default as todos } from './TodoReducer';
```
Так как у нас всего он один, нам это не особо нужно, но понадобится в будущем.
#### **Ииииии… Экшн!**
Разговоры про редюсеры и действия, это хорошо, но наше приложение ничего не знает об этом! Пора это изменить.
Нам нужно пробросить экземпляр Redux через дерево компонентов, чтобы начать все это обрабатывать и связать все эти штуки вместе!
У NPM пакета `react-redux` есть несколько примочек, которые помогут нам в этом.
**server.jsx**
```
import { createStore, combineReducers } from 'redux';
import { Provider } from 'react-redux';
import * as reducers from 'reducers';
app.use((req, res, next) => {
const location = new Location(req.path, req.query);
const reducer = combineReducers(reducers);
const store = createStore(reducer);
Router.run(routes, location, (err, routeState) => {
if (err) return console.error(err);
const InitialView = (
{() =>
}
);
```
Мы создаем экземпляр компонента-хранилища Redux на каждый запрос и пробрасываем через все дерево компонентов (доступен как **.context.redux**, если вам когда либо понадобится к нему доступ), обернув root компонент в `Provider`.
Так же нам нужно отдать клиенту начальное состояние, чтобы он смог гидрировать свои хранилища.
Просто спросим состояние у Redux:
```
const initialState = store.getState();
```
И добавим пару строк в наш HTML шаблон:
```
Redux Demo
window.\_\_INITIAL\_STATE\_\_ = ${JSON.stringify(initialState)};
```
После этого у нас будет доступ к состоянию на клиенте через `window.__INITIAL_STATE__`, неплохо да?
Что нам теперь остается сделать, это трансформировать все в *Immutable.js* коллекции. И отдать их Redux когда мы инстанцируем новое хранилище.
**client/index.jsx**
```
import { createStore, combineReducers } from 'redux';
import { Provider } from 'react-redux';
import * as reducers from 'reducers';
import { fromJS } from 'immutable';
let initialState = window.__INITIAL_STATE__;
// Transform into Immutable.js collections,
// but leave top level keys untouched for Redux
Object
.keys(initialState)
.forEach(key => {
initialState[key] = fromJS(initialState[key]);
});
const reducer = combineReducers(reducers);
const store = createStore(reducer, initialState);
React.render(
{() =>
}
,
document.getElementById('react-view');
);
```
Это идентично инициализации состояния на сервере, за исключением того, что мы гидрируем хранилище состоянием, переданным нам от сервера.
Мы верно приближаемся к завершению нашего приложения, остается пару компонентов, чтобы соединить все точки.
#### **Соединяем все точки**
Мы будем использовать три компонента для отображения информации, которая может показаться немного излишней (скорее всего так и есть), но это покажет различия в Redux между «умными» и «тупыми» компонентами, что очень важно в больших приложениях.
Умные компоненты подписываются на события Redux хранилища (например используя ***@connector*** синтаксис декоратора), и пробрасывают его вниз по дереву к другим компонентам через свойства. Которые могут быть в любой точке дерева, но при разработке более сложных приложений, обычно доходит до самых нижних слоев.
Здесь мы будем использовать только один
**shared/components/Home.jsx**
```
import React from 'react';
import TodosView from 'components/TodosView';
import TodosForm from 'components/TodosForm';
import { bindActionCreators } from 'redux';
import * as TodoActions from 'actions/TodoActions';
import { connect } from 'react-redux';
@connect(state => ({ todos: state.todos }))
export default class Home extends React.Component {
render() {
const { todos, dispatch } = this.props;
return (
);
}
}
```
Далее напишем два «тупых» компонента, но сначала давайте посмотрим, что здесь происходит.
Если вы не знакомы с [декораторами](https://github.com/wycats/javascript-decorators) (**@connector** секция), то лучший способ это понять, думать, что это тоже самое что и миксины в компонентах. Ты наверное встречал похожие конструкции в других языках, в Python например.
Если нет, в javascript это просто функции, которые в некотором роде модифицируют другие функции (здесь «класс»).
Декоратор **@connect** оборачивает наш класс другим компонентом (), дающим доступ к запрашиваемым частям состояния, как к свойствам компонента, следовательно мы можем использовать `todos`, что мы и делаем. Он так же дает доступ к `dispatch` функции из Redux, с помощью которой мы можем обрабатывать наши действия, вот так:
```
dispatch(actionCreator());
```
Наконец, мы используем функцию `bindActionCreators` из Redux, чтобы пробросить связанные создатели действий.
Это значит, что в дочерних компонентах, мы сможем вызывать создателей действий напрямую, без оборачивания их в `dispatch()` функцию.
Смотрим
**components/TodosView.jsx**
```
import React from 'react';
export default class TodosView extends React.Component {
handleDelete = (e) => {
const id = Number(e.target.dataset.id);
// Equivalent to `dispatch(deleteTodo())`
this.props.deleteTodo(id);
}
handleEdit = (e) => {
const id = Number(e.target.dataset.id);
const val = this.props.todos.get(id).text
// For cutting edge UX
let newVal = window.prompt('', val);
this.props.editTodo(id, newVal);
}
render() {
return (
{
this.props.todos.map( (todo, index) => {
return (
{todo}
X
Edit
);
})
}
);
}
}
```
Здесь мы отображаем каждый элемент todo в хранилище, рядом с кнопками удаления и изменения, которые связаны с нашими создателями действий.
Так же, прошу заметить, что мы используем «arrow» функции в определении класса, контекст которых связан с конструктором класса (с тех пор как эти функции наследуют контекст от исполнителя). Если мы используем обычные функции ES6 класса (как render), тогда мы должны связать их с контекстом самостоятельно, что иногда утомительно.
> Обратите внимание, вы так же можете использовать ***React.createClass***, чтобы избежать проблем, и использовать миксины, хотя я предпочитаю использовать ES6 классы для чистоты и консистенции.
>
>
Наконец, определим
**components/TodosForm.jsx**
```
import React from 'react';
export default class TodosForm extends React.Component {
handleSubmit = () => {
let node = this.refs['todo-input'].getDOMNode();
this.props.createTodo(node.value);
node.value = '';
}
render() {
return (
);
}
}
```
Это так же «тупой» компонент, который позволяет просто добавить todo в хранилище.
Теперь нам остается определить роут в
**shared/routes.jsx**
```
import Home from 'components/Home';
export default (
);
```
И voilà, заходим на <http://localhost:8080/home> и смотрим на работающее приложение
#### **Последний рубеж: асинхронные действия**
Я знаю о чем ты думаешь.
Это невозможно.
А я говорю возможно!
Еще одна хорошая возможность у Redux, это определить свой middleware у диспетчера, который позволит изменять ваши действия (асинхронно). Я уверен, ты заметил из темы про Redux, что он работает с функциями с определенными сигнатурами.
Мы собираемся использовать свой Redux middleware, чтобы сделать наши действия в приложении более проще, и сделать наши создатели действий синхронными, что даст нам возможность использовать вкусные и блестящие ES6 промисы.
**shared/lib/promiseMiddleware.js**
```
export default function promiseMiddleware() {
return next => action => {
const { promise, type, ...rest } = action;
if (!promise) return next(action);
const SUCCESS = type;
const REQUEST = type + '_REQUEST';
const FAILURE = type + '_FAILURE';
next({ ...rest, type: REQUEST });
return promise
.then(res = > {
next({ ...rest, res, type: SUCCESS });
return true;
})
.catch(error => {
next({ ...rest, error, type: FAILURE });
// Another benefit is being able to log all failures here
console.log(error);
return false;
});
};
}
```
Это значит, что мы можем просто определить 'promise' ключ у нашего действия, чтобы оно автоматически пришло к состоянию resolved или rejected.
Мы также можем опционально отслеживать редюсеры для авто сгенерированных **\_REQUEST** и **\_FAILURE**, если нам надо проследить мутацию состояния.
И для их использования нам нужно поменять пару строчек в ***client/index.jsx*** и ***server.jsx***
```
...
import { applyMiddleware } from 'redux';
import promiseMiddleware from 'lib/promiseMiddleware';
...
const store = applyMiddleware(promiseMiddleware)(createStore)(reducer);
```
Так же не забываем пробрасывать **initialState** наряду с **reducer**
И теперь мы можем написать магическое действие ***createTodo*** для нашего создателя действий, например
```
import request from 'axios';
const BACKEND_URL = 'https://webtask.it.auth0.com/api/run/wt-milomord-gmail_com-0/redux-tutorial-backend?webtask_no_cache=1';
export function createTodo(text) {
return {
type: 'CREATE_TODO',
promise: request.post(BACKEND_URL, { text })
}
}
```
После небольшого изменения редюсера.
```
return state.concat(action.res.data.text);
```
Todo теперь сохраняются в мою внешнюю базу данных. Если мы хотим чтобы они загружались на старте нашего приложения, просто добавим **getTodos** создатель для действия.
```
export function getTodos() {
return {
type: 'GET_TODOS',
promise: request.get(BACKEND_URL)
}
}
```
Ловим его в редюсере
```
case 'GET_TODOS':
return state.concat(action.res.data);
```
И мы можем вызвать его когда ***TodosView*** инициализируется
```
componentDidMount() {
this.props.getTodos();
}
```
Когда middleware вызывает действие для начального запроса или возможного отказа, ты можешь взглянуть как мы могли бы отловить все это в редюсерах и обновлять состояние приложения соответствующим образом, во время загрузки или ошибки соответственно.
#### **Постой… А мы не сломали регидрацию состояния?**
Да. Давайте это исправим!
Проблема в том что мы добавили асинхронные действия, но не ждем их завершения перед отправкой состояния на клиент. Ты можешь подумать что это не имеет значения, поскольку мы можем отобразить экран загрузки на клиенте. Лучше чем висеть на сервере, да?
Ну, это зависит от многих факторов. Основная выгода серверного рендеринга, что мы можем гарантировать хорошее соединение с нашим бэкэндом (который может быть в том же датацентре!). Если пользователь пытается загрузить наш сайт через пропадающее мобильное соединение, например, намного лучше, чтобы он ждал наш сервер для получения начального состояния, нежели чтоб он получал его из разных ресурсов самостоятельно.
Решение этой проблемы в текущей ситуации не так уж и сложно. Ты можешь сделать это несколькими путями, путь которым я делаю, далек от идиеала:
Мы определяем, какие данные нужны компоненту в виде массива создателей действий. Мы можем использовать статическое свойство в определении класса:
```
static needs = [
TodoActions.getTodos
]
```
Также нужна функция, которая поймает все promise вызовы, соберет данные и отправит их
**shared/lib/fetchComponentData.js**
```
export default function fetchComponentData(dispatch, components, params) {
const needs = components.reduce( (prev, current) => {
return (current.needs || [])
.concat((current.WrappedComponent ? current.WrappedComponent.needs : []) || [])
.concat(prev);
}, []);
const promises = needs.map(need => dispatch(need(params)));
return Promise.all(promises);
}
```
Обрати внимание, что мы также должны проверить ключ **WrappedComponent**, так как вышеупомянутые «умные» компоненты будут обернуты в ***Connector*** компонент.
Теперь настраиваем сервер, чтобы он отвечал только тогда, когда у него есть все данные.
```
import fetchComponentData from 'lib/fetchComponentData';
Router.run(routes, location, (err, routeState) => {
if (err) return console.error(err);
function renderView() {
// ... Rest of the old code goes here
return HTML;
}
// Check this is rendering *something*, for safety
if(routeState)
fetchComponentData(store.dispatch, routeState.components, routeState.params)
.then(renderView)
.then(html => res.end(html))
.catch(err => res.end(err.message));
});
```
Убедись, что удалил создатель действия из ***onComponentMount***, чтобы избежать повторных вызовов, и перезапусти `npm run dev` чтобы обновить изменения на сервере.
#### **Что мы узнали?**
Что мир прекрасен!
Многое еще может быть сделано и многое сделано. В приложении с большим количеством роутов, тебе захочется наверное использовать React Router ***onLeave*** обработчик, чтобы загружать все данные нужные компоненту (как например [тут](https://github.com/bananaoomarang/chapters/blob/master/client/index.jsx#L36)), и ловить другие действия с асинхронным API.
Несмотря на все это, я надеюсь ты позволил себе насладится эпическим квестом в большое функциональное будущее.
Ты так же можешь посмотреть конечный результат на [Github](https://github.com/bananaoomarang/isomorphic-redux) и почитать побольше про Redux [здесь](https://github.com/gaearon/redux) | https://habr.com/ru/post/264423/ | null | ru | null |
# И снова о втором мониторе из планшета…
Оказавшись обладателем среднего такого планшета с нерабочим сенсором (старшенький сынуля постарался) долго думал, куда приспособить. Гуглил, гуглил и нагуглил ([раз](https://habr.com/ru/post/376313/), [два](https://habr.com/ru/post/157793/), Хакер №227), а так же много других рецептов с участием **spacedesk**, **iDispla** и некоторых других. Вот только незадача — у меня Linux. Погуглив ещё, я нашел несколько рецептов и путем несложного шаманства получил приемлемый результат.
Мой способ под катом.
Вам потребуется:
Linux с установленными:
* **x11vnc** (всякие tigervnc и прочие я откровенно недолюбливаю)
* **adb** из комплекта android-tools
Планшет/смарт с включенным режимом отладки и установленными:
* **AndroidNVC** (у меня именно он, т.к. нет рекламы)
* Какой нибудь блокировщик гашения экрана(без рекламы не нашел)
* Любой автозагрузчик(запускать VNC и блокировщик) — необязательно(об этом ниже).
так, стартуем.
1. Получаем Modeline для xorg.conf
```
$ cvt 1024 768 25 # Можно и gtf, но он не всегда дает корректный modeline.
```
2. Редактируем
**xorg.conf**
```
Section "ServerLayout"
Identifier "Xorg Configured"
Screen 0 "Monitor" 0 0
Screen 2 "Screen2" rightof "Screen0" # "Пустышка для VNC"
Option "Xinerama" "1"
EndSection
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# здесь все настройки оборудования, коли таковые есть
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#Dummy видеокарта
Section "Device"
Identifier "Device2"
Driver "dummy"
VideoRam 8000
EndSection
#Dummy монитор
Section "Monitor"
Identifier "Monitor2"
Modeline "1024x768@25" 23.77 1024 1056 1144 1176 768 785 789 807 # см. п. 1
EndSection
#Dummy экран
Section "Screen"
Identifier "Screen2"
Device "Device2"
Monitor "Monitor2"
DefaultDepth 24
SubSection "Display"
#разрешение плашета
Modes "1024x768"
Virtual 1024 748
EndSubSection
EndSection
```
Перезапускаем Х-сы и проверяем через arandr. Настраиваем расположение и ориентацию.Должно быть примерно так:
Сохраняем в файл — он нам пригодится.
3. Создаем файл для автозагрузки в WM/DE (у меня planshet.sh)
```
x11vnc -rfbport 5900 -display :0 -dontdisconnect -noxfixes -xdamage -shared -forever -clip 1024x768+1600+0 -scale 1024x768 -bg -cursor X -o /home/$USER/x11vnc.log -repeat
xrandr --addmode VIRTUAL1 1024x768 # необязательно
xrandr --output VIRTUAL1 --mode 1024x768 # необязательно
xrandr --output VIRTUAL2 --off --output HDMI1 --off --output VIRTUAL1 --mode 1024x768 --pos 1602x0 --rotate normal --output DP1 --off --output VGA1 --mode 1600x900 --pos 0x0 --rotate normal #вот эта строка заимствована из сохраненного файла arandr
```
Проверим:
```
$ xrandr |grep VIRTUAL1
VIRTUAL1 connected 1024x768+1600+0 (normal left inverted right x axis y axis) 0mm x 0mm
```
Так как в IceWM каталога автостарта нет, но есть файл ~/.icewm/startup(который должен быть исполняемым), добавим в него следующее:
```
sh -c /path/to/planshet.sh
```
4. Отключим гашение мониторов:
```
xset s off
xset s noblank
xset -dpms
```
А теперь самое интересное! Как получить координаты «тапов» для устройства без «метода проб и ошибок» истязая клавиатуру в консоли?!
Ради такого дела наваял я [программулю](https://github.com/delvin-fil/ADB-control-GUI). Если запускать ее из консоли, то получим искомое — вывод координат тапов.
6. Допишем все это в planshet.sh
**Полная версия**
```
#!/bin/bash
x11vnc -rfbport 5900 -display :0 -dontdisconnect -noxfixes -xdamage -shared -forever -clip 1024x768+1600+0 -scale 1024x768 -bg -cursor X -o /home/$USER/x11vnc.log -repeat
xrandr --addmode VIRTUAL1 1024x768 # необязательно
xrandr --output VIRTUAL1 --mode 1024x768 # необязательно
xrandr --output VIRTUAL2 --off --output HDMI1 --off --output VIRTUAL1 --mode 1024x768 --pos 1602x0 --rotate normal --output DP1 --off --output VGA1 --mode 1600x900 --pos 0x0 --rotate normal #вот эта строка заимствована из сохраненного файла arandr
xset s off
xset s noblank
xset -dpms
adb tcpip 5555
adb connect 192.168.0.14:5555
sudo adb devices
adb shell input tap 1000 20 # тапаем по "квадратикам" в правом верхнем углу (не знаю, как нызавется) - скрин 3
adb shell input tap 392 138 # тапаем по AndroidVNC
adb shell input tap 20 65 # запускаем VNC предварительно прописав адрес и порт
```
И сделаем
```
chmod +x /path/to/planshet.sh
```
Вот, собственно, и все. Перезагружаем Х-сервер и получаем мультискрин.
У меня на «маленьком» крутится conky.
Скрин двойного экрана прилагается.
А еще я на него кидаю datasheet'ы, когда что-то моделирую.
**UPD:**
Выяснилась интересная особенность(Проверялось только в **gentoo**). Если стартовать БЕЗ /etc/X11/xorg.conf, то xrandr работает вполне корректно. А если создать хоть чуть «неправильный» xorg.conf(ну например, у меня «интеграшка» от Intel капризничает с параметром «AccelMethod» «sna») то получим отказ в сдвиге dummy экрана и ошибку xrandr. При этом подключенный второй монитор через DVI работает «как часы».
Так что можете спокойно генерить нужные разрешения с помощью xrandr не заботясь об отсутствующии ксорговского конфига. | https://habr.com/ru/post/445294/ | null | ru | null |
# Уведомления о завершении консольных команд
[Undistract-Me](http://mumak.net/undistract-me/) — простая, но чрезвычайно полезная в хозяйстве утилита, которая делает одну вещь — выводит уведомление, когда длинная команда (по умолчанию 10 секунд, но можно настроить) завершила свое исполнение.
Также показывает название этой команды и время, которое она заняла. Должно работать со всеми окружениями рабочего стола.
Особенно хороша, когда вы, например, решили чего-нибудь скомпилировать, и не хотите все время пялиться в черный экран или проверять каждую минуту работает ли оно еще. Теперь во время пересборки ядра вы сможете наслаждаться своими любимыми видео с кошечками!
##### Установка
PPA для Ubuntu:
```
$ sudo add-apt-repository ppa:undistract-me-packagers/daily
$ sudo apt-get update
$ sudo apt-get install undistract-me
```
Для остальных:
```
$ git clone git://github.com/jml/undistract-me.git
$ . undistract-me/long-running.bash
$ notify_when_long_running_commands_finish_install
```
В настройках профиля включите опцию «Run command as a login shell» и перезапустите терминал.
Работает только с BASH, но есть [версия для ZSH](https://gist.github.com/shockone/5255331). | https://habr.com/ru/post/174449/ | null | ru | null |
# Проектирование идентичных форм в WPF с применением абстрактных классов
Недавно столкнулся с весьма интересной задачей, которая довольно-таки часто может встречаться при проектировании пользовательских интерфейсов. Вопрос, конечно, сравнительно тривиальный, однако полноценной и развёрнутой информации по нему я не нашёл, потому решил поделиться собственным опытом. Статья может оказаться полезной для Junior-разработчиков, а также людей, только начинающих изучать ООП и не имеющих серьёзного практического опыта в программировании.
Задача построения однотипных форм с шаблонной логикой
-----------------------------------------------------
Суть состоит в том, что нам необходимо создать энное количество форм, эквивалентных друг другу в определённой степени. То есть у каждой из этих форм могут присутствовать одинаковые поля, методы, бизнес-логика, но при этом они не будут являться абсолютно равноценными. У каждой из них может быть свой набор методов, переменных, визуальных стилей и прочих компонентов, характерных именно для её представления. Применительно в моём случае это были формы для создания заявок на выполнение производственных работ, притом что у каждой работы имелся индивидуальный набор полей.
Как наиболее грамотно спроектировать подобную систему, чтобы она была максимально удобной в использовании и минимально избыточной в реализации? Очевидно, что нагромождение контролов на все случаи жизни, часть из которых можно будет скрыть или деактивировать — далеко не всегда является удачным вариантом. Во-первых, со временем количество параметров может разрастись до такой степени, что полный набор уже не будет укладываться в размеры окна. Во-вторых, выглядеть такая система будет крайне перегруженной и абсолютно некомфортной для пользователя. Исходя из этого можно сказать, что предпочтительнее будет использовать разграничение функционала с разделением компонентов.
При разработке нескольких похожих форм возникает следующая проблема. Так как большинство методов и полей в каждой из них совпадает, то при изолированной реализации логики для каждой отдельно взятой формы, как это может сделать любой неопытный программист, возникает избыточность параметров и много повторяющегося кода. Следовательно, при каких-либо изменениях в структуре объектов либо в логике программы необходимо отдельно править каждый метод, что выливается в монотонную копипасту и значительную потерю времени на лишние действия, в том числе и на возможные ошибки при вставке «не туда».
Логически грамотным решением в подобной ситуации будет применение полиморфизма. Во избежание случаев, подобных описанному в предыдущем абзаце, в языках, реализующих объектно-ориентированную парадигму программирования, специально были разработаны такие фичи, как абстрактные классы — классы, содержащие абстрактные методы и свойства, которые могут использовать любые унаследованные от него потомки. Именно их мы возьмём за основу в данном примере.
Практическая реализация на WPF
------------------------------
Свой проект я разрабатывал именно на WPF, так как требовалась высокая гибкость и весьма сложная структура форм. Однако принцип данного подхода общий для любых платформ и языков, потому его можно свободно применять в Web, мобильной разработке и много где ещё.
Для демонстрации возможности абстрактных классов на примере пользовательского интерфейса сформулируем исходную задачу следующим образом:
**Необходимо рассчитать суммарную прибыль от проката кинофильма на основе имеющейся статистики. При этом фильм может быть двух разновидностей: полнометражный фильм или сериал. Для полнометражных фильмов прибыль рассчитывается на основе суммарных кассовых сборов от кинопроката. Для сериалов — по общей выручке от телеканалов. По результирующим данным вынести вердикт: оказался ли фильм прибыльным, если да — каков доход, если нет — каков убыток. Предусмотреть возможность изменения и сохранения расчётных параметров.**
Для начала создадим класс Movie, описывающий кинофильм:
```
public class Movie
{
public Movie(string Name, byte Type, int Cost, int? Dues, int DuesTV, int DuesExtra, short? CinemaPart, short? DistrPart)
{
this.Name = Name;
this.Type = Type;
this.Cost = Cost;
this.Dues = Dues;
this.DuesTV = DuesTV;
this.DuesExtra = DuesExtra;
this.CinemaPart = CinemaPart;
this.DistrPart = DistrPart;
}
public string Name { get; set; }
public byte Type { get; set; }
public int Cost { get; set; }
public int? Dues { get; set; }
public int DuesTV { get; set; }
public int DuesExtra { get; set; }
public short? CinemaPart { get; set; }
public short? DistrPart { get; set; }
}
```
Обозначения параметров:
* **Name** — название картины
* **Type** — тип, 0 — фильм, 1 — сериал
* **Cost** — суммарный бюджет
* **Dues** — прибыль с кинопроката
* **DuesTV** — прибыль с телевидения
* **DuesExtra** — доп. прибыль (DVD, прокаты)
* **CinemaPart** — доля кинотеатров от прибыли
* **DistrPart** — доля дистрибьюторов
Опишем главную форму, содержащую раскрывающийся список с перечнем фильмов, и заполним его четырьмя элементами:
**Разметка**
```
```
```
public partial class Movies : Window
{
public Movies()
{
InitializeComponent();
List movies = new List()
{
new Movie("Охотники за головами", 0, 100000000, 200000000, 40000000, 10000000, 55, 10),
new Movie("Сумерки", 0, 160000000, 300000000, 60000000, 20000000, 50, 11),
new Movie("Подземелье", 1, 6000000, null, 22000000, 2000000, null, null),
new Movie("Заложники Юпитера", 1, 11000000, null, 4000000, 600000, null, null)
};
movieList.ItemsSource = movies;
movieList.DisplayMemberPath = "Name";
}
private void calc\_Click(object sender, RoutedEventArgs e)
{
if (movieList.SelectedIndex != -1)
{
Movie movie = ((Movie)movieList.SelectedItem);
switch (movie.Type)
{
case 0:
Film film = new Film(movie);
film.ShowDialog();
break;
default:
Serial serial = new Serial(movie);
serial.ShowDialog();
break;
}
}
else
{
MessageBox.Show("Выберите кинофильм из списка");
}
}
private void movieList\_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
if (((Movie)movieList.SelectedItem).Type == 0)
Type.Content = "Фильм";
else
Type.Content = "Сериал";
}
}
```
Первые два экземпляра класса Movie являются фильмами с полным набором параметров, последние два — сериалами, у которых отсутствуют данные, связанные с кинопрокатом.
Сама форма будет выглядеть следующим образом:
После выбора элемента из списка по нажатию на кнопку должно открыться соответствующее окно, содержащее данные по фильму.
Для проведения основных расчётных операций и внесения изменений в список создадим новый абстрактный класс под названием MovieEdit, наследуемый от Window, который будет описывать общую логику расчёта прибыли и манипуляций с объектами. Это и есть наша абстрактная форма. Она не имеет визуального представления, а лишь содержит общие методы для работы с классом Movie независимо от категории и параметров:
```
public class MovieEdit : Window
{
protected Movie movie;
protected void calculate(double cost, double cash, string type)
{
double result = (cash - cost) / 1000000;
if (result > 0)
{
MessageBox.Show("Доход от " + type + " \"" + Title + "\":\n" + result + " млн.");
}
else
{
MessageBox.Show("Убыток " + type + " \"" + Title + "\":\n" + -result + " млн.");
}
}
protected void save(int Cost, int? Dues, int DuesTV, int DuesExtra, short? CinemaPart, short? DistrPart)
{
MessageBoxResult view = MessageBox.Show("Сохранить изменения?", "Подтверждение",
MessageBoxButton.YesNo, MessageBoxImage.Question);
if (view == MessageBoxResult.Yes)
{
movie.Cost = Cost;
if (Dues != null) movie.Dues = (int)Dues;
if (CinemaPart != null) movie.CinemaPart = (short)CinemaPart;
if (DistrPart != null) movie.DistrPart = (short)DistrPart;
movie.DuesTV = DuesTV;
movie.DuesExtra = DuesExtra;
Close();
}
}
protected void cancel()
{
MessageBoxResult view = MessageBox.Show("Отменить изменения?", "Подтверждение",
MessageBoxButton.YesNo, MessageBoxImage.Question);
if (view == MessageBoxResult.Yes)
{
Close();
}
}
}
```
Теперь создадим две формы для показа статистики по фильмам, отличающиеся категорией: отдельная форма для фильмов, отдельная для сериалов. Каждая из них будет содержать три кнопки: Рассчитать, Сохранить и Отменить. При этом наследоваться они будут уже не от Window, а от нашего абстрактного класса MovieEdit, чтобы иметь возможность использовать созданные ранее методы.
**Разметка**
```
```
На каждую кнопку поставим обработчик и внутри него вызовем соответствующие функции базового класса, передав нужные параметры:
```
public partial class Film : MovieEdit
{
public Film(Movie movie)
{
InitializeComponent();
this.movie = movie;
base.Title = movie.Name;
cost.Text = movie.Cost.ToString();
dues.Text = movie.Dues.ToString();
cinemaPart.Text = movie.CinemaPart.ToString();
distrPart.Text = movie.DistrPart.ToString();
duesTV.Text = movie.DuesTV.ToString();
duesExtra.Text = movie.DuesExtra.ToString();
}
private void _calc_Click(object sender, RoutedEventArgs e)
{
base.calculate(double.Parse(cost.Text),
double.Parse(dues.Text) * (100 - double.Parse(cinemaPart.Text) - double.Parse(distrPart.Text)) / 100
+ double.Parse(duesTV.Text) + double.Parse(duesExtra.Text), "фильма");
}
private void _save_Click(object sender, RoutedEventArgs e)
{
base.save(int.Parse(cost.Text), int.Parse(dues.Text), int.Parse(duesTV.Text),
int.Parse(duesExtra.Text), short.Parse(cinemaPart.Text), short.Parse(distrPart.Text));
}
private void _cancel_Click(object sender, RoutedEventArgs e)
{
base.cancel();
}
}
```
Также необходимо внести поправки в разметку конструктора: вместо тега Window верхнего уровня прописываем наш класс MovieEdit. Иначе возникнет ошибка сборки: визуальная часть и код формы должны наследоваться от одного класса, так как являются составными частями одного элемента.
```
...
```
Для второй формы проделываем те же действия:
**Разметка**
```
```
```
public partial class Serial : MovieEdit
{
public Serial(Movie movie)
{
InitializeComponent();
base.Title = movie.Name;
cost.Text = movie.Cost.ToString();
duesTV.Text = movie.DuesTV.ToString();
duesExtra.Text = movie.DuesExtra.ToString();
}
private void _calc_Click(object sender, RoutedEventArgs e)
{
base.calculate(double.Parse(cost.Text), double.Parse(duesTV.Text) + double.Parse(duesExtra.Text), "сериала");
}
private void _save_Click(object sender, RoutedEventArgs e)
{
base.save(int.Parse(cost.Text), null, int.Parse(duesTV.Text),
int.Parse(duesExtra.Text), null, null);
}
private void _cancel_Click(object sender, RoutedEventArgs e)
{
base.cancel();
}
}
```
Вся необходимая информация в наличии, можно тестировать проект. Теперь программа автоматически определяет, какую форму нужно открыть. Выбираем любой элемент из списка, жмём «Показать данные», рассчитываем прибыль по введённым параметрам и видим соответствующий результат:
**Итог:** как видим, нам удалось создать две формы с одинаковым поведением, но разным представлением, и при этом избежать дублирования кода. Вся логика работы с данными укладывается в три метода в чуть более чем 30 строк. Теперь для изменения реализации достаточно внести корректировку в конкретный абстрактный метод без необходимости править каждую форму по отдельности. Данный пример наглядно демонстрирует преимущества абстрактных классов.
В реальной практике формы, конечно же, не будут такими скромными. Например, на данный момент я разрабатываю две формы для редактирования заявок, каждая из которых содержит пару десятков полей и почти столько же кнопок для загрузки и скачивания файлов из базы. Естественно, приходится постоянно что-то добавлять и вносить поправки, а если после каждого изменения копировать код из одной формы в другую, закончить придётся не раньше следующего года. Уж лучше потратить это время на более полезные вещи, не правда ли?)
Исходники проекта можно найти [по адресу](https://github.com/lovk4ch/wpf_movies_demo/). | https://habr.com/ru/post/307308/ | null | ru | null |
# MySQL Query Killer — предохранитель от перегрузки СУБД
Здесь описывается процедура, предназначенная для предохранения базы данных высоконагруженной системы от перегрузки.
После того, как ваши запросы оптимизированы, по идее у вас не должно возникать ситуаций, когда
1. Один запрос блокирует другие
2. Какие-то запросы блокируют друг друга
Мы стремимся к тому, чтобы таких ситуаций не возникало.
Потому хорошим «сторожем работоспособности» будет умный «Query killer»,
который будет отслеживать подозрительные ситуации и освобождать базу данных.
Этот киллер допускает ситуацию, когда БД выполняет пару тяжелых запросов.
Но когда он видит, что начинает появляться много долгих запросов — то начинает принмать меры
#### Назначение
Query killer предназначен для:
1. **Отслеживание ситуаций, когда:**
1.1. Некоторые запросы делают lock-и, блокирующие другие запросы
1.2. Большое количеслых запросов, запущенных в короткий промежуток времени блокируют друг друга
2. **Логировния таких ситуаций**
3. **Разрешения таких ситуаций путем:**
3.1. Для ситуаций, когда один запрос блокирует другие — убить источник блокировок: убить самый долгий запрос
3.2. Для ситуаций, когда запросы блокируют друг друга — попытаться освободить базу данных: убить ряд запросов, которые длинее, чем некоторый нижний порог
Так, даже если когда-то ваши оптимизированные процедуры по генерации кеша или рабочие запросы снова начнут глючить — Qeury-Killer не допустит, чтобы из-за регенерации кеша загнулась БД, а просто убьет регенирацию и зарепортит лог ошибок.
*(Регенерация кэша должна предусматривать возможность своей гибели, и генерироваться во временную таблицу, которая позже переименовывается в целевую.)*
#### Логика — псевдокод
Ниже приведен псевдокод для Query-killer
```
-- CONSTANTS:
SET @alert_query_duration:=10;
SET @alert_queries_max_count:=6;
SET @dangerous_query_duration:=15;
SET @dangerous_queries_max_count:=30;
SET @dangerous_queries_affect_duration_bottom:=5;
-- Check long queries:
SELECT @alert_queries_count:=COUNT(0) FROM information_schema.processlist
WHERE COMMAND != 'Sleep' AND TIME>@alert_query_duration
ORDER BY TIME DESC;
IF (@alert_queries_count >= @alert_queries_max_count) THEN
1. Report to error_log:
module = Query killer
error = Maximum amount of long queries reached
context = List of all long queries (which longer than @alert_query_duration)
2. Take actions:
-- Check if there is a lot of dangerous queries already
-- (which may cause each other locks):
SELECT @dangerous_queries_count:=COUNT(0) FROM information_schema.processlist
WHERE COMMAND != 'Sleep' AND TIME>@dangerous_query_duration
ORDER BY TIME DESC;
IF (@dangerous_queries_count >= @dangerous_queries_max_count) THEN
-- KILL dangerous queries and queries, which probably might be already affected by them
-- (so kill all queryes, where TIME>@dangerous_queries_affect_duration_bottom)
...
ELSE
-- KILL one query (the longes one) which probably locks all others
...
END
END
```
#### Примеры ситуаций
Ниже приведены примеры опасных ситуаций:
1. Запросы делают lock-и, и тем самым блокируют другие запросы
Например, запрос для генерации деномализованного кэша делает длительный лок на таблицу, которая должна постоянно обновляться — возникает подобная картина:
```
97669965 root localhost gtf 289 Query CREATE TABLE gtf.cache_vw_...
99057101 root localhost:33092 gtf 284 Query UPDATE media INNER JOIN image_file USING(media_id) INNER JOIN i
99057467 root localhost:51863 gtf 276 Query UPDATE media INNER JOIN image_file USING(media_id) INNER JOIN i
99057499 root localhost:51868 gtf 275 Query UPDATE media INNER JOIN image_file USING(media_id) INNER JOIN i
99057840 root localhost:33164 gtf 267 Query UPDATE media INNER JOIN image_file USING(media_id) INNER JOIN i
99057907 root localhost:54313 gtf 266 Query UPDATE media INNER JOIN image_file USING(media_id) INNER JOIN i
99057987 root localhost:59942 gtf 264 Query UPDATE media INNER JOIN image_file USING(media_id) INNER JOIN i
99059528 root localhost:52062 gtf 229 Query UPDATE media INNER JOIN image_file USING(media_id) INNER JOIN i
```
Здесь первый запрос на создание cache-таблицы лочит обновление таблицы media
2. Большое количеслых запросов, запущенных в короткий промежуток времени и блокируют друг друга
Это могут быть запросы, использующие *Using temporary; Using filesort*
```
+------+-------------+-------+--------+----------------------------------+----------------------------------+---------+-----------------+------+----------------------------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+------+-------------+-------+--------+----------------------------------+----------------------------------+---------+-----------------+------+----------------------------------------------+
| 1 | SIMPLE | vw | ref | fk_cache_vw_video_website1 | fk_cache_vw_video_website1 | 4 | const | 8643 | Using where; Using temporary; Using filesort |
| 1 | SIMPLE | mtc | eq_ref | PRIMARY,content_id | PRIMARY | 4 | gtf.vw.media_id | 1 | Using where |
+------+-------------+-------+--------+----------------------------------+----------------------------------+---------+-----------------+------+----------------------------------------------+
```
Которые, тем не менее, вполне вменяемо выполняются в штатном режиме, но нагибают базу данных при пике нагрузки.
Скрипт полезен в системах, где применяется [методология разработки не ставящая целью «преждевременную» оптимизацию](http://ru.wikipedia.org/wiki/Бережливая_разработка_программного_обеспечения#.D0.9F.D1.80.D0.B8.D0.BD.D1.86.D0.B8.D0.BF.D1.8B) всех возможных участков системы,
а где первичная оптимизация производится в очевидных bottleneck-ах, и последующая — в выявляемых в процессе эксплуатации системы. | https://habr.com/ru/post/151418/ | null | ru | null |
# Руководство по фоновой работе в Android. Часть 3: Executors и EventBus
Приветствую, коллеги. Рад видеть вас снова в третьей части «Руководства по фоновой работе в Android». Если не видели предыдущие части, вот они:
* [Часть 1: AsyncTask](https://habrahabr.ru/company/epam_systems/blog/348894/)
* [Часть 2: Loaders](https://habrahabr.ru/company/jugru/blog/350094/)
В прошлый раз мы разобрались, как работают Loaders, а сразу после этого Google взял и сообщил, что они полностью переписали LoaderManager. Видимо, мне надо позже вернуться к этой теме, но пока что буду следовать плану и делиться подробностями того, как организовать фоновую работу в Android исключительно с помощью джавовых thread pool executors, а также как EventBus может помочь в этом, и как всё это работает под капотом.
**Давайте вспомним, в чём главная загвоздка: времязатратные операции вроде сетевых вызовов должны осуществляться в фоновом потоке, но публикация результата может происходить только в главном UI-потоке.**
Также было бы здорово сохранять результат продолжительной операции при изменении конфигурации.
В предыдущих текстах мы разобрались, как делать это с помощью AsyncTasks и Loaders. Однако у этих API есть свои недостатки, из-за которых приходится реализовывать довольно сложные интерфейсы и абстрактные классы. Кроме того, они не позволяют нам писать модули с асинхронной работой на чистой Java из-за использования Android-специфичных API.
Из-за этих ограничений возник подход, опирающийся на executors. Давайте рассмотрим его. Для начала, понятно, нам надо разжиться потоками, куда мы сможем отправлять свои задачи для фоновой работы. Давайте создадим для этого класс Background:
```
public class Background {
private final ExecutorService mService = new ScheduledThreadPoolExecutor(5);
public Future execute(Runnable runnable) {
return mService.submit(runnable);
}
public Future submit(Callable runnable) {
return mService.submit(runnable);
}
}
```
Итак, у нас есть executor, и есть метод, позволяющий запустить какой-то код асинхронно, обернув его в Runnable или Callable.
Здорово, давайте попробуем засунуть результат операции в UI-поток. Не проблема, мы знаем, что нам требуется только Handler:
```
public class Background {
...
private final Handler mUiHandler;
public void postOnUiThread(final Runnable runnable) {
mUiHandler.post(runnable);
}
}
```
Но подождите, мы не знаем, существует ли в этот момент вообще наш UI, и если да, как он узнает, что надо что-то изменить?
Тут на помощь и приходит подход, называемый «шина событий» или event bus. Общая идея в том, что есть некая общая шина (или даже несколько), куда публикуются события. Кто угодно может в любое время начать слушать шину, получать события, а затем прекращать слушать (звучит похоже на RxJava, да? Дождитесь следующей статьи!)
В общем, нам нужны три составляющих:
Сама шина
Источник (или источники) событий
Слушатель (или слушатели) событий
Можно отразить эту структуру такой диаграммой:
*Принципиальная схема передачи событий по шине*
Шина событий
------------
Никто не требует самостоятельно реализовывать шину с нуля. Можно выбрать одну из существующих реализаций: [Google Guava](https://github.com/google/guava/tree/master/guava/src/com/google/common/eventbus), [Otto](http://square.github.io/otto/) или [EventBus](https://github.com/greenrobot/EventBus) от greenrobot (у последнего есть стильная поддержка отправки событий на разные потоки с помощью аннотаций).
Объект шины мы можем использовать напрямую в наших презентерах, активностях, фрагментах и так далее, но я предпочитаю инкапсулировать его в том же классе Background:
```
public class Background {
private final Bus mEventBus;
public void postEvent(final Object event) {
mEventBus.post(event);
}
}
```
Давайте напишем клиентский код, использующий конструкцию, которую мы соорудили. Предположим, что мы хотим инициализировать базу данных перед использованием приложения, и это, конечно, занимает время. Так что внутри приложения мы запускаем инициализацию в фоне и публикуем событие о том, что инициализация базы завершилась:
```
mBackground.execute(new Runnable() {
@Override
public void run() {
try {
initDatabaseInternal();
mBackground.post(new DatabaseLoadedEvent());
} catch (Exception e) {
Log.e("Failed to init db", e);
}
}
});
```
Так что, например, мы можем спрятать прогресс-бар и перейти к нашей MainActivity:
```
public class SplashActivity extends Activity {
@Override
protected void onStart() {
super.onStart();
eventBus.register(this);
}
@Override
protected void onStop() {
eventBus.unregister(this);
super.onStop();
}
@Subscribe
public void on(DatabaseLoadedEvent event) {
progressBar.setVisibility(View.GONE);
showMainActivity();
}
}
```
Проблема тут нам уже хорошо известна: нельзя модифицировать UI из фонового потока, а код выше пытается сделать именно это.
Так что нам надо либо воспользоваться возможностями работы с потоком из библиотеки greenrobot, либо сделать всё самим. Не стоит изобретать велосипед в продакшн-приложении, но в целях обучения давайте попробуем сделать это голыми руками, тем более, что это очень просто.
Но перед этим давайте немного закопаемся в сорцы и посмотрим, как вызывается метод, помеченный аннотацией [Subscribe](https://habrahabr.ru/users/subscribe/), когда событие публикуется.
Заглянем в исходный код шины событий Google Guava:
```
public class EventBus {
private final SubscriberRegistry subscribers = new SubscriberRegistry(this);
public void register(Object object) {
subscribers.register(object);
}
public void unregister(Object object) {
subscribers.unregister(object);
}
public void post(Object event) {
Iterator eventSubscribers = subscribers.getSubscribers(event);
if (eventSubscribers.hasNext()) {
dispatcher.dispatch(event, eventSubscribers);
} else if (!(event instanceof DeadEvent)) {
// the event had no subscribers and was not itself a DeadEvent
post(new DeadEvent(this, event));
}
}
}
```
Как видим, шина событий хранит подписчиков в **SubscriberRegistry** и пытается передать каждое событие подписчику конкретно этого события (ключом здесь выступает название класса объекта). Список подписчиков можно представить себе в виде **Map** .
Обращение с потоками зависит от объекта dispatcher, который по умолчанию выставлен на **Dispatcher.perThreadDispatchQueue()**.
Что же происходит внутри dispatcher:
```
private static final class PerThreadQueuedDispatcher extends Dispatcher {
private final ThreadLocal> queue =
new ThreadLocal>() {
@Override
protected Queue initialValue() {
return Queues.newArrayDeque();
}
};
@Override
void dispatch(Object event, Iterator subscribers) {
Queue queueForThread = queue.get();
queueForThread.offer(new Event(event, subscribers));
Event nextEvent;
while ((nextEvent = queueForThread.poll()) != null) {
while (nextEvent.subscribers.hasNext()) {
nextEvent.subscribers.next().dispatchEvent(nextEvent.event);
}
}
}
```
Главное тут: **PerThreadQueuedDispatcher** использует ThreadLocal для хранения очереди событий. По сути, это означает, что метод подписчика будет вызван в том же самом потоке, в котором было опубликовано событие.
И что нам с этим делать? Решение нехитрое — просто публиковать события в том потоке, в котором хотите их обрабатывать:
```
public void postEventOnUiThread(final Object event) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
mEventBus.post(event);
}
});
}
```
Это работает, но привносит ту проблему, которую шина событий вроде как должна решать: понижение связности с помощью разделения публикации и обработки событий. С таким решением мы обязываем код, публикующий события, знать, в каком потоке клиент хотел бы обработать код.
Другим решением стало бы использование Handlers прямо в UI:
```
public class SplashActivity extends Activity {
@Subscribe
public void on(DatabaseLoadedEvent event) {
runOnUiThread(new Runnable() {
@Override
public void run() {
progressBar.setVisibility(View.GONE);
showMainActivity();
}
})
}
}
```
Это тоже не выглядит полноценным решением. И в этом состоит ограничение шины событий. Как с этим можно справиться? Конечно, с помощью RxJava! Но об этом — в следующей части.
> От автора: Я вхожу в программный комитет конференции Mobius, и её программа на 90% готова. Скорее смотрите, что вам [приготовила конференция](https://mobiusconf.com), и ждите новостей о финализации программы! | https://habr.com/ru/post/351166/ | null | ru | null |
# Гибкость и автоматизация в машинном обучении
В данной статье я хочу рассказать об основных сложностях автоматизации машинного обучения, ее природе и преимуществах, а также рассмотреть и более гибкий подход, позволяющий уйти от части недостатков.
Автоматизация по определению [Mikell P. Groover](https://www.wiley.com/en-us/Fundamentals+of+Modern+Manufacturing%3A+Materials%2C+Processes%2C+and+Systems%2C+6th+Edition-p-9781119128694) – это технология, при помощи которой процесс или процедура выполняются с минимальным человеческим участием. Автоматизация уже давно позволяет добиться повышения производительности труда, что зачастую ведет к снижению себестоимости единицы продукта. Методы автоматизации, как и области их применения, стремительно совершенствуются и в течение последних столетий развились от простых механизмов до промышленных роботов. Автоматизация начинает затрагивать не только физический труд, но и интеллектуальный, добираясь до сравнительно новых областей, включая и машинное обучение – automated machine learning (auto ml, aml). В то же время, автоматизация машинного обучения уже нашла свое применение в ряде коммерческих продуктов (например, Google AutoML, SAP AutoML и другие).
**Disclaimer***Данная заметка не претендует на догматичность в области и является ви́дением автора.*
#### Automated Machine Learning
Задачи в области обработки данных и машинного обучения связаны с множеством факторов, возникающих из-за сложности системы и затрудняющих их решение. К ним можно отнести ([согласно Charles Sutton](https://slideslive.com/38917537/towards-semiautomated-machine-learning)):
* Наличие неопределенности и неизвестности, к которым ведет недостаток априорных знаний о данных и искомых зависимостях. Таким образом, всегда присутствует исследовательский элемент.
* «Смерть от тысячи порезов». На практике при построении пайплайна обработки и анализа данных и последующего моделирования приходится принимать множество больших и небольших решений. Например, необходимо ли нормализовать данные, если да, то каким методом, а какие параметры должны быть у этого метода? И т.д.
* Наличие циклов обратной связи, вытекающее из неопределенности. Чем дольше происходит погружение в задачу и данные, тем больше удается узнать о них. Это ведет к необходимости сделать шаг назад и внести изменения в имеющиеся механизмы обработки и анализа.
* Кроме того, результаты моделей, полученных алгоритмами машинного обучения, являются лишь приближением реальности, т.е. заведомо не точны.
Таким образом, процесс получения полного пайплайна обработки и анализа данных можно рассматривать как сложную систему (т.е. complex system).
**Complex system**Как [сказал профессор Peter Sloot](http://www.nispb.ru/binaries/content/assets/uva/en/research/interviews/interview-with-prof.-peter-sloot.pdf), сложные системы это не только «налоговые формы» и «романтические отношения», но и широкий круг вещей и процессов. Например, (а) совместная работа молекул в клетке организма, позволяющая им поддерживать жизнь, (б) распространение эпидемии, (в) взаимодействия социальных групп и т.д. Отличительными чертами сложных систем служат в том числе наличие в них большого количества взаимодействующих элементов и нелинейные связи между ними, что может приводить к спонтанным эффектам, самоорганизации и другим сложно воспроизводимым процессам.
С одной стороны, наличие перечисленных факторов осложняет как решение задач машинного и глубокого обучения, так и их автоматизацию. С другой стороны, непрерывно растущие и все более доступные вычислительные возможности позволяют приложить к задаче большее количество ресурсов.
Согласно распространенному стандарту CRISP-DM, жизненный цикл проекта, связанного с анализом данных, итеративно состоит из шести основных этапов: понимание бизнес-задачи (business understanding), понимание и изучение данных (data understanding), обработка данных (data preparation), моделирование (modelling), оценка качества (evaluation) и практические применение (deployment, application). На практике, не все эти этапы на сегодняшний день могут быть эффективно автоматизированы.
В большинстве работ или существующих библиотек (h2o, auto-sklearn, autokeras) основной акцент делается на автоматизацию моделирования и отчасти на оценку качества. Однако расширение подхода в сторону автоматизации обработки данных позволяет покрыть большее количество этапов (что, например, было применено в сервисе Google AutoML).
#### Постановка задачи
Задачи машинного обучения с учителем могут быть решены различными методами, большинство из которых сводятся к минимизации функции потерь  или максимизации функции правдоподобия , с целью получения оценки параметров  на основе имеющейся выборки — обучающего набора данных :
 или , где  – обучаемые параметры модели (например, коэффициенты в случае регрессии).
Чтобы не ограничивать автоматизацию только моделированием, можно распространить область применения метода и на другие этапы пайплайна. Например, автоматизировать принятие решений о том, какие методы обработки данных применить, о выборе модели или их комбинаций, а также подбору близких к оптимальным гиперпараметров.
Проиллюстрируем описанное на простом примере, в рамках которого происходит выбор между двумя методами обработки данных ([standard scaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) и [quantile scaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.QuantileTransformer.html)) и двумя моделями ([random forest](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html) и [neural network](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html)), включая подбор некоторых гиперпараметров. Структуру выбора можно представить как дерево:
Каждый осуществляемый выбор является параметром системы, а само дерево при этом становится пространством возможных параметров. Такой взгляд на проблему позволяет подняться выше на уровень абстракции и сформулировать задачу получения итогового пайплайна, включающего методы обработки данных, модели и их параметры, как процесс минимизации или максимизации функции:
 или , где  – необучаемые параметры,  – выборка отложенного контроля (набор данных для кросс-валидации).
К основным достоинствам подобной автоматизации обучения можно отнести:
* Подбор большего числа параметров системы при наличии одной входной точки в рамках единого процесса оптимизации.
* Автоматизация рутины, спасающая исследователя или разработчика от «тысячи порезов».
* «Демократизация» машинного обучения за счет его автоматизации, что позволяет применять многие методы людям, не являющимися специалистами.
Однако автоматизация не лишена недостатков:
* С увеличением числа параметров растет и их пространство, что рано или поздно приводит к комбинаторному взрыву, требующему развития алгоритмов и увеличения количества вычислительных ресурсов.
* Полностью автоматические методы предоставляют не всегда гибкое решение по принципу “black box”, что снижает контроль над результатом.
* Пространство параметров ω нелинейно и обладает сложной структурой, что затрудняет процесс оптимизации.
#### От автоматизации к полуавтоматизации
Пытаясь сохранить как можно больше достоинств и уйти при этом от ряда недостатков, в частности, из-за желания получить дополнительный контроль над решением, мы пришли к подходу, который носит название semi-auto ml. Это сравнительно новое явление в области, о чем может косвенно свидетельствовать быстрый анализ Google Trends:
Достижение такого компромисса можно условно сравнить с различными способами переключения передач в автомобильных трансмиссиях (именно способами переключения, но не их внутренним устройством):
| | |
| --- | --- |
| image | Ручное переключение – водитель контролирует сцепление и передачи. Аналогия: пользователь самостоятельно производит выбор методов и создает пайплайн. |
| image | Автоматическое – нет необходимости самостоятельно выбирать передачи, только задать режим. Аналогия: пользователь получает готовое решение. |
| image | Полуавтоматическое переключение – водитель не контролирует сцепление, но имеет возможность выбора передач. Аналогия: пользователь определяет выбор методов, но делегирует их выбор или даже создание пайплайна системе. |
В ходе работ над внутренними проектами нами был создан инструмент, позволяющий решать задачу полуавтоматического машинного обучения на основе гибридной функционально-декларативной системы конфигурации. Такой подход к конфигурации использует не только стандартные типы данных, но и функции из распространенных современных библиотек для машинного и глубокого обучения. Инструмент позволяет автоматизировать создание простых методов обработки данных, базовое конструирование признаков (feature engineering), выбор моделей и их гиперпараметров, а также выполнять расчет на Spark или GPU кластере. В листинге приводится формализация примера, приведенного ранее в статье. Пример использует простые модели из sk-learn и hyperopt (в открытый код которого даже удалось внести незначительный вклад в ходе работы) для распределения параметров и оптимизации.
```
'preprocessing': {
'scaler': hp.choice('scaler', [
{
'func': RobustScaler,
'params': {
'quantile_range': (10, 90)
}},
{
'func': StandardScaler,
'params': {
'with_mean': True
}}
]),
},
'model': hp.choice('model', [
{
'func': RandomForestClassifier,
'params': {
'max_depth': hp.choice('r_max_depth', [2, 5, 10]),
'n_estimators': hp.choice('r_n_estimators', [5, 10, 50])
}
},
{
'func': MLPClassifier,
'params': {
'hidden_layer_sizes': hp.choice('hidden_layer_sizes', [1, 10, 100]),
'learning_rate_init': hp.choice('learning_rate_init', [0.1, 0.01])
}
},
])
```
Подобная полуавтоматическая система, включающая механизм конфигурации, дает возможность создавать заранее подготовленные типовые сценарии в случаях, когда, например, определенное семейство моделей лучше подходит для решения каких-либо задач. К ним, в частности, может относиться кредитный скоринг, однако подобный шаг требует дополнительных исследований на широком спектре схожих задач. Также при работе над механизмом поиска возможно автоматически поддерживать баланс в дилемме смещения-дисперсии (bias-variance tradeoff) за счет одновременного учета значений оптимизируемой функции как на обучающей, так и кросс-валидационной выборке.
#### Заключение
Полное отсутствие автоматизации на практике встречается довольно редко, поскольку даже перебор значений одного гиперпараметра в цикле – уже шаг к автоматизации. В то же время, полная автоматизация всего процесса построения пайплайна также практически недостижима на сегодняшний день. Соответственно, при разработке большинства современных проектов осознанно или неосознанно применяются подходы автоматизации.
Применение полуавтоматического машинного обучения позволяет более эффективно использовать ресурсы исследователя или разработчика за счет автоматизации рутины, не отбирая при этом значительную часть гибкости в работе. Как мы видим, предложенное решение требует участия человека, ограничивающего пространство возможных параметров системы. При этом введение типовых сценариев, полученных на основе системы конфигурации, позволяет использовать не только подходы частичной автоматизации, но и полной, не требующей участия человека. | https://habr.com/ru/post/491900/ | null | ru | null |
# Делаем бесплатный SSL сертификат в 2017 году
Предисловие
-----------
Недавно я искал ssl сертификат для своего сайта но на Хабре было только инструкция для StartSSl который уже не поддерживают Google Chrome и MozillaFirefox. И здесь я бы хотел показать как сделать сертификат пошагово на собственном сервере.
Итак начнем
-----------
Создадим папку для ssl в корне.
```
mkdir /ssl
```
Далее зайдем в конфиги Apache
```
cd /etc/apache2/sites-available
```
Скачаем пример конфига.
```
sudo wget https://linode.com/docs/assets/apache2-roundcube.sample.conf
```
Поменяем владельца на root и права.
```
sudo chown root:root apache2-roundcube.sample.conf
```
```
sudo chmod 644 apache2-roundcube.sample.conf
```
И редактируем.
```
nano apache2-roundcube.sample.conf
```
В теге и
ServerAdmin меняем на webmaster@названиесайта.
ServerName меняем на название сайта.
DocumentRoot меняем на директорию где лежит сайт, у меня это:
```
/var/www/html/
```
Все теги Directory удаляем кроме:
```
...
```
здесь меняем путь вместо /var/www/roundcube /var/www/html. И меняем путь к SSL сертификатам:
```
SSLCertificateFile /etc/apache2/ssl/webmail.example.com/apache.crt
```
```
SSLCertificateKeyFile /etc/apache2/ssl/webmail.example.com/apache.key
```
на
```
SSLCertificateFile /ssl/crt.crt
```
```
SSLCertificateKeyFile /ssl/key.key
```
Пример конфига:
```
# Apache2 vhost configuration sample for Roundcube
# https://linode.com/docs/email/clients/installing-roundcube-on-ubuntu-14-04/
# Virtual host configuration + information (replicate changes to \*:443 below)
ServerAdmin webmaster@uranius.pp.ua
ServerName uranius.pp.ua
DocumentRoot /var/www/html/
# ErrorLog /var/log/apache2/webmail.example.com/error.log
# CustomLog /var/log/apache2/webmail.example.com/access.log combined
# Permanently redirect all HTTP requests to HTTPS
RewriteEngine on
RewriteCond %{SERVER\_PORT} !^443$
RewriteRule ^/(.\*) https://%{HTTP\_HOST}/$1 [NC,R=301,L]
# Virtual host configuration + information (replicate changes to \*:80 above)
ServerAdmin webmaster@uranius.pp.ua
ServerName uranius.pp.ua
DocumentRoot /var/www/html
# ErrorLog /var/log/apache2/webmail.example.com/error.log
# CustomLog /var/log/apache2/webmail.example.com/access.log combined
# SSL certificate + engine configuration
SSLEngine on
SSLCertificateFile /ssl/crt.crt
SSLCertificateKeyFile /ssl/key.key
# Roundcube directory permissions + restrictions
Options -Indexes
AllowOverride All
```
Переименуем файл
```
sudo mv apache2-roundcube.sample.conf uranius.pp.ua.conf
```
Отключем не нужные конфиги
```
sudo a2dissite 000-default.conf default-ssl.conf
```
Включаем необходимые модули.
```
sudo a2enmod deflate expires headers rewrite ssl
```
Включаем конфиг сайта.
```
a2ensite uranius.pp.ua.conf
```
А теперь самое интересное, получим сертификат. Идем на [www.sslforfree.com](http://www.sslforfree.com). Вводим доменное имя и нажимаем получить. Далее скачиваем файл и загружаем его на сервер. Идем в папку, где лежит сайт и создаем директорию:
```
cd /var/www/html/
```
```
mkdir .wellknown
```
```
cd .wellknown
```
```
mkdir acme-challenge
```
```
cd acme-challenge
```
Ставим туда файл и нажимаем Download SSl Certificate. Скачиваем zip с сертификатами и загружаем на сервер в папку ssl в корне. Зайдем в папку и переименуем:
```
cd /ssl
```
```
mv certificate.crt crt.crt
```
```
mv private.key key.key
```
И сохраняем. Проверяем конфиги:
```
apachectl configtest
```
Осталось только перезапустить сервер и сайт готов.
```
/etc/init.d/apache2 restart
``` | https://habr.com/ru/post/324740/ | null | ru | null |
# Перепрограммируем кассу и печатаем на ней Киану Ривза
Привет, Хабр!
Как то раз была у меня «работа» — нужно было сделать управление кассовым аппаратом Штрих-ФР-К. Так как моя карьера начиналась с ремонта ККТ, то решил взяться за эту работу.
Так выглядит сама касса и пробное изображение моего коллеги:
Так же по мимо управления движками и термоголовкой в аппарате пришлось написать небольшой скрипт на питоне с использованием библиотеки OpenCV. Итак, поехали.
Все началось с изучения рем. дока. к данной кассе и последующего подключения логического анализатора на пины термоголовки. Я отправил на печать, через штриховый тест драйвер букву «С». И вот что у меня получилось:
По DATA значение точек (всего 432 точки в строке), SCK — cинхросигнал, STB0, STB1, STB2 — стробы для нагрева термоголовки, LATCH — защелкивание данных. Строчку вбил в сдвиговый регистр, прожег, пошел дальше.
Следующий этап был доработка платы для ускорения процесса разработки.
Теперь перейдем к коду.
```
void go(int n, int shag)
{
switch (shag)
{
case 0: PORTA=0b10001000; PORTD|=(1<<2); dela(n); PORTD&=0b11111011; PORTA=0; PORTD|=(1<<2); PORTD&=0b11111011;
break;
case 1: PORTA=0b10101010; PORTD|=(1<<2); dela(n); PORTD&=0b11111011; PORTA=0; PORTD|=(1<<2); PORTD&=0b11111011;
break;
case 2: PORTA=0b00100010; PORTD|=(1<<2); dela(n); PORTD&=0b11111011; PORTA=0; PORTD|=(1<<2); PORTD&=0b11111011;
break;
case 3: PORTA=0b01100110; PORTD|=(1<<2); dela(n); PORTD&=0b11111011; PORTA=0; PORTD|=(1<<2); PORTD&=0b11111011;
break;
case 4: PORTA=0b01000100; PORTD|=(1<<2); dela(n); PORTD&=0b11111011; PORTA=0; PORTD|=(1<<2); PORTD&=0b11111011;
break;
case 5: PORTA=0b01010101; PORTD|=(1<<2); dela(n); PORTD&=0b11111011; PORTA=0; PORTD|=(1<<2); PORTD&=0b11111011;
break;
case 6: PORTA=0b00010001; PORTD|=(1<<2); dela(n); PORTD&=0b11111011; PORTA=0; PORTD|=(1<<2); PORTD&=0b11111011;
break;
case 7: PORTA=0b10011001; PORTD|=(1<<2); dela(n); PORTD&=0b11111011; PORTA=0; PORTD|=(1<<2); PORTD&=0b11111011;
break;
}
}
```
Есть две схемы управления шаговым двигателем для этой кассы. 4-шаговый и 8-шаговым. Я выбрал 8, так как движки работали лучше.
```
#define DATA 2
#define SCK 1
#define LATCH 3
#define STB0 2
#define STB1 3
#define STB2 4
#define DATA_IN PORTB
#define STB_IN PORTE
int sck()
{
_delay_us(3);
DATA_IN|= (1<0)
{
DATA\_IN|=(1<
```
Код отправки данных в термоголовку. Термоголовка работает как сдвиговый регистр. Как она работает я писал выше.
```
void print_all_pixel()
{
while(n<55)
{
print_stroka(str[n]);
_delay_us(3);
n++;
}
latch();
n=0;
STB_IN&=0b11111011;
_delay_us(500);
STB_IN|=(1<
```
Функция печати и прожига строк.
```
void recieve()
{
///while(f);
if ((com==0x50)&&(rezhim==0))/// P
{
//USART_Transmit('X');
com=0;
USART_Transmit('B');
rezhim=1;
}
if ((rezhim==1)&&(send!=0))
{
str[iFF]=com;
send=0;
iFF++;
if (send == 1)
{
USART_Transmit('B');
}
if (iFF==54)
{
USART_Transmit('P');
USART_Transmit('R');
USART_Transmit('I');
USART_Transmit('N');
USART_Transmit('T');
USART_Transmit('E');
USART_Transmit('D');
PORTB|=1<<0;
_delay_ms(1);
print_all_pixel();
//print_all_pixel();
go1(1500,ggg);
rezhim=0;
iFF=0;
ggg++;
if (ggg==8)
{
ggg=0;
}
}
}
if ((com==0x52)&&(rezhim==0))///R
{
com=0;
go1(1000,ggg);
rezhim=0;
iFF=0;
ggg++;
if (ggg==8)
{
ggg=0;
}
USART_Transmit('O');
USART_Transmit('K');
//vpered(300);
}
}
```
Основная функция, которая крутится в вечном вайле. Когда приходит буква «P» я включаю вход в режим печати. Далее все остальные символы начинают набиваться в буфер. Далее когда буфер набивается 54 байтами (или 432 бита), то печатаем строку и отправляем по УСАРТ слово PRINTED.
Ну вот и все с железной частью. В следующей части я распишу про программную часть, а именно про программу на питоне. [Исходники](https://github.com/beetlea/shtrih-m-fr-k).
 | https://habr.com/ru/post/465867/ | null | ru | null |
# Entity Framework 6 with Full-Text Search via LINQ
Хочу поделиться своим костылем в решении довольно банальной проблемы: как подружить полнотекстовый поиск MSSQL c Entity Framework. Тема очень узкоспециальная, но как мне кажется, актуальна на сегодняшний день. Интересующихся прошу под кат.
Все началось с боли
===================
Я разрабатываю проекты на C# (ASP.NET) и иногда пишу микросервисы. В большинстве случаев для работы с данными я использую базу данных MSSQL. В качестве связующего звена между базой данных и моим проектом используется Entity Framework. С EF я получаю широкие возможности для работы с данными, формирования правильных запросов, регулирования нагрузки на сервер. Волшебный механизм LINQ просто очаровывает своими возможностями. Спустя годы я уже и не представляю более быстрые и удобные способы по работе с базой данных. Но как и практически любая ORM, EF имеет ряд недостатков. Во первых это производительность, но это тема отдельной статьи. А во вторых — это покрытие возможностей самой базы данных.
В MSSQL есть встроенный полнотекстовый поиск который работает “из коробки”. Для выполнения полнотекстовых запросов можно воспользоваться встроенными предикатами (CONTAINS и FREETEXT) или функциями (CONTAINSTABLE и FREETEXTTABLE). Есть только одна проблема: EF не поддерживает полнотекстовые запросы, от слова совсем!
Приведу пример из реального опыта. Допустим у меня есть таблица статей — Article, и я создаю для нее класс описывающий эту таблицу:
```
/// c#
public partial class Article
{
public int Id { get; set; }
public System.DateTime Date { get; set; }
public string Text { get; set; }
public bool Active { get; set; }
}
```
Потом мне надо сделать выборку из этих статей, скажем, вывести последние 10 опубликованных статей:
```
/// c#
dbEntities db = new dbEntities();
var articles = db.Article
.Where(n => n.Active)
.OrderByDescending(n => n.Date)
.Take(10)
.ToArray();
```
Все очень красиво пока не появляется задача добавить полнотекстовый поиск. Поскольку поддержки полнотекстовых функций выборки в EF нет (в .NET core 2.1 уже частично [есть](https://docs.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.sqlserverdbfunctionsextensions.freetext?view=efcore-2.1%5D)) то остается либо использовать какую-то стороннюю библиотеку, либо написать запрос на чистом SQL.
SQL запрос из примера выше не такой уж и сложный:
```
SELECT TOP (10)
[Extent1].[Id] AS [Id],
[Extent1].[Date] AS [Date],
[Extent1].[Text] AS [Text],
[Extent1].[Active] AS [Active]
FROM [dbo].[Article] AS [Extent1]
WHERE [Extent1].[Active] = 1
ORDER BY [Extent1].[Date] DESC
```
В реальных проектах все обстоит не так просто. Запросы к базе данных на порядок сложнее и поддерживать их в ручную сложно и долго. В результате первое время я писал запрос с помощью LINQ, потом доставал сгенерированный текст SQL запроса к БД, и уже в него внедрял полнотекстовые условия выборки данных. Далее отправлял это в `db.Database.SqlQuery` и получал нужные мне данные. Это все конечно хорошо пока на запрос не нужно навешать десяток различных фильтров со сложными join-нами и условиями.
Итак — у меня есть конкретная боль. Надо ее решать!
В поисках решения
=================
В очередной раз сидя в своем любимом поиске в надежде отыскать хоть какое-то решение я наткнулся на [этот репозиторий](https://github.com/fissoft/Fissoft.EntityFramework.Fts). С помощью этого решения можно внедрить в LINQ поддержку предикатов (CONTAINS и FREETEXT). Благодаря поддержки EF 6 специального интерфейса [`IDbCommandInterceptor`](https://docs.microsoft.com/en-us/dotnet/api/system.data.entity.infrastructure.interception.idbcommandinterceptor?view=entity-framework-6.2.0), позволяющего делать перехват готового запроса SQL, перед отправкой его в БД и было реализовано данное решение. В поле `Contains` подставляется специальная сгенерированная строка маркер, а потом после генерации запроса это место заменяется на предикат Пример:
```
/// c#
var text = FullTextSearchModelUtil.Contains("code");
db.Tables.Where(c=>c.Fullname.Contains(text));
```
Однако если выборку данных нужно отсортировать по рангу совпадений, то это решение уже не подойдет и придется писать SQL запрос вручную. По сути, это решение, подменяет обычный LIKE на выборку по предикату.
Итак, на этом этапе у меня встал вопрос: можно ли реализовать реальный полнотекстовый поиск с помощью встроенных функций MS SQL (CONTAINSTABLE и FREETEXTTABLE) чтобы все это генерировалось через LINQ да еще и с поддержкой сортировки запроса по рангу совпадений? Как оказалось, можно!
Реализация
==========
Для начала нужно было разработать логику написания самого запроса с помощью LINQ. Поскольку в реальных SQL запросах с полнотекстовыми выборками чаще всего используют JOIN для присоединения виртуальной таблицы с рангами, я решил пойти по этому же пути и в LINQ запросе.
Вот пример такого LINQ запроса:
```
/// c#
var queryFts = db.FTS_Int.Where(n => n.Query.Contains(queryText));
var query = db.Article
.Join(queryFts, article => article.Id, fts => fts.Key, (article, fts) => new
{
article.Id,
article.Text,
fts.Key,
fts.Rank,
})
.OrderByDescending(n => n.Rank);
```
Такой код еще нельзя было скомпилировать, но он уже визуально решал задачу по сортировке результирующих данных по рангу. Оставалось реализовать его на практике.
Дополнительный класс `FTS_Int` используемый в данном запрос:
```
/// c#
public partial class FTS_Int
{
public int Key { get; set; }
public int Rank { get; set; }
public string Query { get; set; }
}
```
Название было выбрано не случайно, так как ключевой столбец в этом классе должен совпадать по тику с ключевым столбцом в таблице поиска (в моем примере с `[Article].[Id]` тип `int`). В случае если нужно делать запросы по другим таблицам с другими типами ключевых столбцов, я предполагал просто скопировать подобный класс и создать его Key того типа который нужен.
Само условие для формирование полнотекстового запроса предполагалось передавать в переменной `queryText`. Для формирование текста этой переменной была реализована отдельная функция:
```
/// c#
string queryText = FtsSearch.Query(
dbContext: db, // текущий контекст БД, нужен для формирования правильных имен таблиц
ftsEnum: FtsEnum.CONTAINS, // тип запроса: CONTAINS или FREETEXT
tableQuery: typeof(News), // тип таблицы по которой делается запрос
tableFts: typeof(FTS_Int), // тип вспомогательного класс
search: "text"); // условие полнотекстового поиска
```
Выполнение готового запроса и получение данных:
```
/// c#
var result = FtsSearch.Execute(() => query.ToList());
```
Последняя функция `FtsSearch.Execute` обертка используется для временного подключения интерфейса `IDbCommandInterceptor`. В примере приведенном по ссылке выше автор предпочел использовать алгоритм подмены запросов постоянно для всех запросов. В результате после подключения механизма замены запросов в каждом запросе ищется необходимая комбинация для замены. Мне такой вариант показался расточительным, поэтому выполнение самого запроса данных выполняется в передаваемой функции, которая перед вызовом подключает автозамену запроса а после вызова — отключает.
Применение
==========
Я использую автогенерацию классов моделей данных из БД с помощью файла edmx. Поскольку просто созданный класс `FTS_Int` использовать в EF нельзя по причине отсутствия необходимых метаданных в `DbContext`, я создал реальную таблицу по его модели (может кто знает способ получше, буду рад вашей помощи в комментариях):
*Скриншот таблице созданной в файле edmx*
```
CREATE TABLE [dbo].[FTS_Int] (
[Key] INT NOT NULL,
[Rank] INT NOT NULL,
[Query] NVARCHAR (1) NOT NULL,
CONSTRAINT [PK_FTS_Int] PRIMARY KEY CLUSTERED ([Key] ASC)
);
```
После этого при обновлении файла edmx из БД добавляем созданную таблицу и получаем ее сгенерированный класс:
```
/// c#
public partial class FTS_Int
{
public int Key { get; set; }
public int Rank { get; set; }
public string Query { get; set; }
}
```
Запросы к этой таблице вестись не будут, она лишь нужна, чтобы правильно сформировались метаданные для создания запроса. Финальный пример использования полнотекстовых запрос к БД:
```
/// c#
string queryText = FtsSearch.Query(
dbContext: db,
ftsEnum: FtsEnum.CONTAINS,
tableQuery: typeof(Article),
tableFts: typeof(FTS_Int),
search: "text");
var queryFts = db.FTS_Int.Where(n => n.Query.Contains(queryText));
var query = db.Article
.Where(n => n.Active)
.Join(queryFts, article => article.Id, fts => fts.Key, (article, fts) => new
{
article,
fts.Rank,
})
.OrderByDescending(n => n.Rank)
.Take(10)
.Select(n => n.article);
var result = FtsSearch.Execute(() => query.ToList());
```
Также есть поддержка асинхронных запросов:
```
/// c#
var result = await FtsSearch.ExecuteAsync(async () => await query.ToListAsync());
```
SQL запрос сформированный до автозамены:
```
SELECT TOP (10)
[Project1].[Id] AS [Id],
[Project1].[Date] AS [Date],
[Project1].[Text] AS [Text],
[Project1].[Active] AS [Active]
FROM ( SELECT
[Extent1].[Id] AS [Id],
[Extent1].[Date] AS [Date],
[Extent1].[Text] AS [Text],
[Extent1].[Active] AS [Active],
[Extent2].[Rank] AS [Rank]
FROM [dbo].[Article] AS [Extent1]
INNER JOIN [dbo].[FTS_Int] AS [Extent2] ON [Extent1].[Id] = [Extent2].[Key]
WHERE ([Extent1].[Active] = 1) AND ([Extent2].[Query] LIKE @p__linq__0 ESCAPE N'~')
) AS [Project1]
ORDER BY [Project1].[Rank] DESC
```
SQL запрос сформированный после автозамены:
```
SELECT TOP (10)
[Project1].[Id] AS [Id],
[Project1].[Date] AS [Date],
[Project1].[Text] AS [Text],
[Project1].[Active] AS [Active]
FROM ( SELECT
[Extent1].[Id] AS [Id],
[Extent1].[Date] AS [Date],
[Extent1].[Text] AS [Text],
[Extent1].[Active] AS [Active],
[Extent2].[Rank] AS [Rank]
FROM [dbo].[Article] AS [Extent1]
INNER JOIN CONTAINSTABLE([dbo].[Article],(*),'text') AS [Extent2] ON [Extent1].[Id] = [Extent2].[Key]
WHERE ([Extent1].[Active] = 1) AND (1=1)
) AS [Project1]
ORDER BY [Project1].[Rank] DESC
```
По умолчанию полнотекстовый поиск работает по всем столбцам таблицы:
```
CONTAINSTABLE([dbo].[Article],(*),'text')
```
Если нужно сделать выборку только по некоторым полям, то их можно указать в параметре fields функции `FtsSearch.Query`.
Итого
=====
Результат — поддержка полнотекстового поиска в LINQ.
Нюансы данного подхода.
1. Параметр search в функции `FtsSearch.Query` не использует каких либо проверок или оберток для защиты от SQL инъекций. Значение этой переменной передается как есть в текст запроса. Если есть какие то идеи по этому поводу пишите в комментариях. Я же использовал обычное регулярное выражение которое просто убирает все символы отличных от букв и цифр.
2. Также нужно учитывать особенности построения выражений для полнотекстовых запросов. Параметр в функцию
```
/* Запрос с ошибкой */
CONTAINSTABLE([dbo].[News],(*),'Новое исследование')
```
имеет недопустимый формат так как MS SQL требует разделения слов логическими литералами. Чтобы запрос был выполнен успешно нужно исправить его так:
```
/* Корректный запрос */
CONTAINSTABLE([dbo].[News],(*),'Новое and исследование')
```
или изменить функцию выборки данных
```
/* Корректный запрос */
FREETEXTTABLE([dbo].[News],(*),'Новое исследование')
```
За более подробной информацией об особенностях создания запросов лучше обратиться к [официальной документации](https://docs.microsoft.com/ru-ru/sql/relational-databases/search/full-text-search?view=sql-server-2017).
3. Стандартное логирование с таким решением работает некорректно. Для этого был добавлен специальный логгер:
```
/// c#
db.Database.Log = (val) => Console.WriteLine(val);
```
Если посмотреть на сформированный запрос к базе данных то он будет сформирован до обработки функциями автозамены.
В ходе тестирования я проверял и на более сложных запросах со множественными выборками из разных таблиц и здесь не возникло никаких проблем.
Исходники на [GitHub](https://github.com/devlev/Devlev.EntityFramework.Fts) | https://habr.com/ru/post/455160/ | null | ru | null |
# Железный ренессанс
Одно из преимуществ Y Combinator состоит в том, что мы видим тенденции гораздо раньше большинства людей. В последней волне профинансированных нами стартапов видна одна такая тенденция. Семь из восьмидесяти четырёх компаний занимаются железом. Это много. И в целом их успехи выше среднего.
Конечно, стартапы, производящие железо, наталкиваются на сопротивление инвесторов. У инвесторов есть глубоко сидящее предубеждение против них. Но мнение инвесторов — лишь вторичный индикатор. Самые талантливые основатели видят будущее гораздо лучше самых проницательных инвесторов, ведь они сами его создают.
Эта тенденция не имеет единой движущей силы. Хардварные проекты [хорошо идут](http://bits.blogs.nytimes.com/2012/05/11/pebble-smartwatch-tops-out-at-10-million-on-kickstarter/) на краудфандинговых сайтах. Распространение планшетов и смартфонов открывает возможности для создания устройств, [контролируемых](http://lockitron.com/) ими, или даже [включающих](http://doublerobotics.com/) их в себя. Улучшается технология производства [электродвигателей](http://www.boostedboards.com/). Беспроводные сети есть почти везде. Проще стало организовать производство. Arduino, 3D-печать, лазерные резаки и доступные фрезеровальные станки с ЧПУ облегчают создание прототипов. Распространение становится всё меньшей проблемой, так как люди всё больше покупают в интернете.
Я могу ответить на вопрос, почему вдруг производить железо стало круто. На самом деле это было круто всегда. Вещи, которые можно пощупать — это прекрасно. Просто до недавнего времени это был далеко не такой прекрасный способ построить быстрорастущий бизнес, как софт. Но положение может измениться. Оно ведь сложилось не так давно, примерно в 1990 году. Возможно, окажется, что преимущество софтверных компаний было временным. Хакеры обожают делать физические устройства, а потребители — покупать их. Поэтому если лёгкость производства и распространения железа приближается к легкости производства и распространения софта, «железные» стартапы растут как грибы после дождя.
Не первый раз то, что когда-то было плохой идеей, вдруг оказывается хорошей. И не в первый раз основатели преподают урок инвесторам.
Так что, если вы хотите создавать физические устройства, пусть вас не останавливают опасения, что инвесторы посмотрят на вас косо. Конкретно мы, Y Combinator, будем только рады, если вы придёте к нам с «железным» стартапом.
Мы твёрдо уверены, что в истории найдётся место для второго Стива Джобса. И почти наверняка знаем, что и для первого `<подставьте своё имя>` тоже. | https://habr.com/ru/post/155983/ | null | ru | null |
# Как превратить Google-таблицы в REST API и использовать их с React-приложением
Взаимодействовать с API никогда не было просто. Но использовали ли вы когда-нибудь React для отправки формы в Google-таблицы? Если нет, то этот туториал для вас.
Сегодня мы поговорим о том, как отправлять данные формы из React в Google-таблицы, так же как вы отправляете данные с помощью REST API.
### Во-первых, создайте приложение React
Для начала вы можете использовать create-react-app, чтобы настроить React-приложение. Просто введите npx create-react-app react-googlesheets, чтобы инициализировать проект.
Структура папок### Как установить Semantic UI
Semantic UI – это фреймворк, используемый для проектирования и разработки красивых, адаптивных сайтов. В нём есть компоненты для кнопок, контейнеров, списков, инпутов и многого другого.
Чтобы установить Semantic UI в React-приложение, используйте следующую команду:
```
npm install semantic-ui-react semantic-ui-css
```
После завершения установки откройте файл index.js и импортируйте:
```
import 'semantic-ui-css/semantic.min.css'
```
Теперь запустите приложение с помощью команды npm start.
### Создадим несколько полей ввода
Давайте создадим форму и поля ввода, чтобы отправлять такие данные, как имя, возраст, зарплата и хобби, из нашего React-приложения.
Здесь мы будем использовать кнопку, форму, поля ввода, контейнер и хедер из библиотеки semantic-ui-react.
```
import React, { Component } from 'react'
import { Button, Form, Container, Header } from 'semantic-ui-react'
import './App.css';
export default class App extends Component {
render() {
return (
React Google Sheets!
Name
Age
Salary
Hobby
Submit
)
}
}
```
Вот как это будет выглядеть:
```
.form{
width: 500px;
}
.container{
padding:20px
}
```
Мы закончили с пользовательским интерфейсом, теперь добавим немного функциональности.
Прежде всего давайте создадим состояния для наших четырёх полей формы.
```
import React, { Component } from 'react'
import { Button, Form, Container, Header } from 'semantic-ui-react'
import './App.css';
export default class App extends Component {
constructor(props) {
super(props)
this.state = {
name: '',
age: '',
salary: '',
hobby: ''
}
}
changeHandler = (e) => {
this.setState({[e.target.name] : e.target.value})
}
submitHandler = e => {
e.preventDefault();
console.log(this.state);
}
render() {
const { name, age, salary, hobby } = this.state; (*)
return (
React Google Sheets!
Name
Age
Salary
Hobby
Submit
)
}
}
```
Здесь у нас есть четыре поля и их соответствующие состояния. У нас также есть метод changeHandler, чтобы отслеживать изменения состояний полей ввода.
Давайте деструктурируем состояния в методе рендеринга и добавим их значения в атрибут value каждого поля ввода (строка \*).
Последнее, что нам нужно сделать, – это написать обработчик onSubmit. В теге формы добавьте событие onSubmit с обработчиком submitHandler.
Заполните форму и нажмите «Отправить». Отправленные данные отобразятся в консоли.
Вот и всё – у нас есть форма, которая принимает имя, возраст, зарплату и хобби и выводит их в консоль.
### Как отправить данные в Google-таблицу
Давайте превратим Google-таблицы в REST API.
Мы будем отправлять данные в Google Sheets, так же как и с REST API, и для этого нам необходимо установить Axios. Это библиотека, которую вы можете использовать для отправки запросов к API, как и fetch.
Создайте новую таблицу, нажав «Файл», затем «Создать», а затем «Таблица» (прим. перев.: нажмите “Пустой файл”).
Присвойте таблице имя и сохраните её.
Нажмите кнопку «Поделиться» в правом верхнем углу экрана и измените откройте общий доступ.
Скопируйте ссылку, перейдите на<https://sheet.best/> и создайте бесплатную учётную запись.
Создайте новое соединение и вставьте скопированный URL-адрес из Google-таблиц в поле Connection URL.
Нажмите "Connect". Вы будете перенаправлены на страницу вашего подключения. Здесь вы можете увидеть все свои подключения. Щёлкните сведения о вашем новом подключении.
Скопируйте URL-адрес из строки “Connection URL”. Этот URL-адрес будет использоваться в качестве конечной точки API для отправки POST-запросов.
Теперь давайте установим Axios. Введите в терминал npm install axios.
После того как он был установлен, импортируйте его в начало файла. Мы сделаем POST-запрос в функции submitHandler.
```
submitHandler = e => {
e.preventDefault();
console.log(this.state);
axios.post('url', this.state)
.then(response => {
console.log(response);
})
}
```
Замените функцию submitHandler приведённым выше кодом. Здесь мы используем Axios для отправки данных по URL-адресу и вывода ответа в консоль с помощью ключевого слова .then.
Вставьте скопированный URL-адрес из sheet.best вместо ‘url’ в axios.post(‘url’)
```
submitHandler = e => {
e.preventDefault();
console.log(this.state);
axios.post('https://sheet.best/api/sheets/a6e67deb-2f00-43c3-89d3-b331341d53ed', this.state)
.then(response => {
console.log(response);
})
}
```
Теперь откройте Google-таблицы и заполните первую строку: имя, возраст, зарплата и хобби. Пожалуйста, заполните её правильно, иначе ничего не получится. Колонки чувствительны к регистру.
 Добавьте поля имени, возраста, зарплаты и хобби
Теперь запустите приложение React и заполните форму. Вы увидите, что данные попадают в вашу таблицу.
ФормаИтоговый результатЭто всё, ребята. Теперь вы знаете, как превратить Google-таблицы в REST API. Теперь вы можете отправлять свои данные в Google-таблицы с помощью React-приложения.
Также вы можете [найти код на Github](https://github.com/nishant-666/React-GoogleSheets) , чтобы поэкспериментировать с ним.
Учитесь с удовольствием!
[Узнайте подробности](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=040321), как получить Level Up по навыкам и зарплате или востребованную профессию с нуля, пройдя онлайн-курсы SkillFactory со скидкой 40% и промокодом **HABR**, который даст еще +10% скидки на обучение.
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=040321)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=040321)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=040321)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=040321)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=040321)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=040321)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=040321)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=040321)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=040321)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=040321)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=040321)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=040321)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=040321)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=040321)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=040321)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=040321)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=040321)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=040321)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=040321) | https://habr.com/ru/post/544866/ | null | ru | null |
# Кое-что о переменных MS Small Basic. И не только…
MS Small Basic в настоящее время является лучшим учебным текстовым языком программирования. С появлением современной среды программирования SB-Prime, библиотеки LitDev и ряда других библиотек он получил великолепные возможности, позволяющие писать на нём сложные, полезные и интересные программы, которые можно использовать не только в учебных проектах, но и для решения вполне серьёзных повесдневных задач, однако, ему присущ ряд недостатков, делающих его непригодным для создания действительно серьёзных, а члавное - ответственных проектов, что долвольно обидно.
Переменные в MS Small Basic не требуют объявления. Здорово? На первый взгляд — очень! Ничего не нужно заранее продумывать, даже следить, чтобы переменная получила значение до её использования — всё равно получит что-то типа нуля. При этом переменные как бы сами «решают», какого они типа — в зависимости от того, что в них записано. Это кажется очень удобным, особенно — для учебного языка программирования. Но если копнуть чуть глубже, мы увидим, что далеко не всё так здорово, как кажется на первый взгляд.
Как можно реализовать такие простые и умные переменные? Реализовать их можно либо созданием специального класса, который сам определяет тип передаваемых данных, хранит их в одной из подходящих внутренних переменных, выполняет проверки на корректность и преобразования данных в случае необходимости, либо… Либо так, как придумали в Microsoft.
Разработчики MS Small Basic решили проблему создания неких «универсальных» переменных, подходящих для хранения любых типов данных очень специфическим (зато простым и быстрым) способом. Начать с того, что переменные в MS Small Basic **все**(!) — действительно одного единственного типа: и числовые, и символьные, и текстовые, и даже массивы(!). Фантастика? Нет. Решение, найденное разработчиками, конечно в принципе имеет право на существование, но оно довольно примитивно и несёт с собой кучу неудобств при работе. Я бы даже сказал, разработчики поленились сильно напрягаться — они просто придумали хранить любые переменные как… (барабанная дробь!) …текстовые строки! Настоящие программисты, я думаю, в шоке, как от простоты идеи, так и от потенциального количества проблем, которые она за собой тащит. Ну и от ленивости разработчиков, я полагаю, тоже… :)
Итак, что же мы имеем? Мы имеем довольно неуклюжий способ уйти от проблем при создании класса умных переменных. Зато у нас есть «умные» строки, которые при каждой операции распознаются или переписываются в новую область памяти… (*«Да чёрт с ней, с оптимизацией!»*)
И эти же «умные» строки могут хранить в себе числа. Ну, в целом, да, действительно могут — в текстовом представлении, что, впрочем, можно сделать в ЛЮБОМ языке программирования — ну какая разница, что хранить в строковых переменных, особенно в «умных»? Текст — он и в Африке текст, а распознать его можно — как угодно…
Как производится «разбор» этих «умных строк»:
1. **Это массив?** Если да — то значит у нас есть массив «умных» строк, требующих разбора.
2. **Это число?** Да. Ну, тут, вроде, всё просто.
3. Если не 1. и не 2. , то это — просто текстовая строка.
В зависимости от того, можно ли преобразовать переменную в число или нет, она будет рассматриваться как число или текстовая строка. Таким образом, все следующие примеры — это сложение чисел:
`TextWindow.WriteLine("3"+"4")`
`TextWindow.WriteLine(3+4)`
`TextWindow.WriteLine(3+"4")`
А вот это — уже строки, поскольку `«3a»` или `«:»` не могут быть преобразованы в числа.
`TextWindow.WriteLine("3a"+"4")`
`TextWindow.WriteLine(3+":"+4)`
Зато мы легко можем увидеть, как выглядит «умная» строка с массивом, выполнив следующие команды:
`a[1] = "hello"`
`TextWindow.WriteLine(a)`
Кроме того, все остальные, в том числе и графические объекты, хранятся в Small Basic в виде «умных» строк, поэтому выполнив эти команды, вы увидите в консоли, например, идентификатор эллипса:
`ellipse = Shapes.AddEllipse(20,20)`
`TextWindow.WriteLine(ellipse)`
Поэтому стандартную операцию перемещения нашего эллипса:
`Shapes.Move(ellipse,50,50)`
Мы можем заменить на:
`Shapes.Move("Ellipse1",50,50)`
или на
`Shapes.Move("Ellipse"+1,50,50)`
Ничего не изменится! Теперь вы видите, какой простор для появления недиагностируемых ошибок оставляют такие вот «простые и классные» переменные без типа. А ведь Small Basic в первую очередь - учебный язык программирования. Он должен быть расчитан на предотвращение потенциальных ошибок учащихся, а не на их практически неконтролируемое размножение.
А если перейти к более серьёзным задачам, - тут же встает вопрос правильного выбора типов переменных или создания собственных типов, но SmallBasic сделает всё за вас — так, как ему больше «нравится»…
Такая или подобная концепция была бы хороша для какого-нибудь языка программирования, предназначенного для лентяев, не желающих вникать в суть программирования и фактически плюющих на конечный результат. Но применять подобное решение в учебном языке программирования?! Расчёт на детишек-глупышек, которые всё равно ничего не поймут, а все ошибки за них будут исправлять "умные" взрослые (в том случае, если смогут найти эти ошибки)?
В MS Small Basic в принципе отсутствует проверка корректности данных и их преобразований — как явных, так и неявных. В результате мы запросто можем записать вместо числа в переменную кусок текста или, выполнив случайно "неявное" преобразование число -> текст -> число (или наоборот), получим совсем не то число, которое было в начале.
Можете попробовать, например, создать переменную со значением 345876 (*число, да?*), а затем определить её длину как текстовой строки (**Text.GetLength()**) и вы получите — 6! *«Чёрт возьми, Холмс! Но как?!…»* Ведь это же число!
Приходит в голову только одна логичная (как ни странно!) мысль — писать все (ВООБЩЕ ВСЕ!) константы в программе как тестовые строки - в кавычках… Но это уже — полный бред! Хотя, наверное, должно сработать… и тем самым вообще уничтожить у учащихся понимание, что такое переменная.
Если у нас есть две переменных A и B со значениями 3 (число «три») и б0 («бэ» и «ноль» — ну так сложилось: опечатка в файле), то при сложении их в MS Small Basic мы получим 3б0 — нет, не число 360, а строку из трёх символов: «три», «бэ» и «ноль», а при вычитании — получим число «три», потому что текстовая строка, не содержащая чистого числа интерпретируется в MS Small Basic как число 0. И ни единого сообщения об ошибке! Здорово?! И это — учебный язык программирования!
А что делать, если две строки, содержащие числа нужно не сложить, а просто соединить? Ведь для склейки строк в MS Small Basic есть красивая операция «+»… Так вот она — не сработает! Она «тупо» сложит два числа (потому что приоритет сложения выше приоритета склейки). Нет, тут разработчики «вывернулись», придумав функцию гарантированной склейки **Text.Append()**, однако, создать, например, функцию определения типа переменной (вернее, хранящейся в ней данных) — почему-то забыли…
Если же мы захотим вывести число, содержащее десятичную точку в строку, например, используя **Text.Append()**, то точка «волшебным образом» может «превратиться» в запятую — в зависимости от региональных настроек Windows, и — при «переходе обратно к числу» в программе (переменная-то — одна) — мы вдруг обнаружим, что наше число стало нулём! Потому что в самом MS Small Basic десятичный разделитель — только точка, и, следовательно, строка цифр, содержащая десятичную запятую — числом не является, а значит = 0 (по правилам MS Small Basic).
Что можно сделать? Можно аккуратно написать функцию, которая будет пробегаться по всем элементам проверяемой строки (посимвольно) и сравнивать их с цифрами или с десятичной точкой, разумеется, учитывая при этом, что точка в числе может быть только одна. Или можно просто вычитать переменную, проверяемую на число, из нуля: операция «вычитание» со строками не работает, нечисловая строка интерпретируется как число 0, поэтому если результат вычитания останется нулём, то в проверяемой переменной — либо число 0, либо какой-то текст:
`' a - проверяемая переменная
If 0 - a = 0 Then
'а - не число или 0`
`Else`
`' a - число`
`EndIf`
Также, для того, чтобы гарантировать, что у нас точно число, а не текст, на него очень похожий, можно умножать переменную на 1: число не изменится, а строка — превратится в 0. Вроде просто… но глупо до невозможности! Но… если этого не делать, то в результате сложения можно получить — всё, что угодно!
Хуже обстоят дела с проверкой переменной на соответствие формату времени или даты: дело в том, что формат задаётся пользователем в настройках Windows и может меняться. Тут видится только один надёжный способ: вывести в какую-нибудь переменную текущие время или дату с помощью функций класса **Clock**: **Date** или **Time**. Затем выполнить посимвольный анализ полученной строки, понимая, что основное содержимое строк — это цифры, а то что между ними — разделители, соответствующие текущему установленному в Windows формату даты или времени. Теперь, основываясь на этих данных анализа, уже можно анализировать любую другую строку на предмет соответствия формату.
А еще в MS Small Basic у нас есть «массивы» с кривой индексацией: ведь индексами массива может быть всё что угодно, а далеко не только числа. Более того, порядок и следование индексов (даже числовых) — вообще не обязательны: это же просто строки! И если вы, создавая массив, укажете значения для 1, 2 и 4 элементов, пропустив 3-й, то… в вашем массиве будет всего 3 элемента(!), а индексом 3-го (по порядку) элемента будет 4-ка(!): то есть, проходя по массиву циклом For от 1 до 4, вы вообще не встретите элемента с индексом 3(!) — просто потому что его вообще не существует, зато если вы пройдете по массиву циклом For от 1 до длины массива (**Array.GetItemCount**), то вы никогда не увидите элемента с индексом 4(!), потому что фактическая длина массива — 3. А всё потому, что это не массив в привычном программистском представлении, а просто длинная текстовая строка вида «1=13;2=123;4=98», которая каждый раз(!) обрабатывается специальными функциями текстового поиска и лексического анализа. Ужас? Да не то слово!
И ладно бы еще создали для подобных массивов что-то похожее на функционал очень удобного оператора цикла **ForEach** (последовательный перебор по всем существующим элементам массива), существующего во многих современных языках программирования. Действительно, наличие такого инструмента избавило бы от многих проблем при работе с такими вот «умными» массивами. Но нет, на это, к сожалению, чего-то не хватило: то ли квалификации, то ли денег, то ли времени…
Остаётся единственный вариант — принудительная полная «инициализация» массива перед его использованием или изменением размера — прямой записью в цикле **в каждую** последовательную ячейку какого-нибудь «начального» значения, например нуля или пробела, что сразу сводит на нет по крайней мере одно из преимуществ такого «умного» массива.
А что MS Small Basic вытворяет со стеками? Если вы используете один стек — вроде всё работает, но стоит вам использовать 2 разных стека (с разными именами) и «инициализировать» их, например, пустыми строками (зачем это нужно - выходит за рамки данной статьи) — и эти стеки «волшебным образом» склеятся в один! Поэтому перед первым использованием переменным с именем стека необходимо присваивать какие-то, желательно различные, значения: например, разные текстовые строки.
Кстати, никого не смутило, что стек нужно инициализировать путем присваивания значения его имени? Тут не то, что о логике — о здравом смысле говорить не приходится! Воистину: "если в программе завёлся баг - не спешите исправлять его, а просто обзовите фичей"...
***Только понимание всего вышеизложенного позволит избегать в программах на MS Small Basic непонятных и неожиданных результатов и ошибок.***
Разумеется, такая реализация сказывается на быстродействии - в минус...
Ну тут Microsoft — просто, как обычно, в своём репертуаре:
«***Если наши программы на вашем компьютере работают медленно, купите себе новый более мощный компьютер***«.
*— Программы работают?
— Да.
— И в чём проблема?
— Медленно работают.
— А нам — плевать! Это — ваша проблема...*
Ну действительно, ведь проект-то — бесплатный. Зачем же напрягаться с оптимизацией, осмыслением самого языка (даром, что он - учебный)?
Как вам, например, ещё вот такой «перл»: после условия в операторе **If** обязательно нужен **Then**, а вот в операторе **While** — никакого оператора, закрывающего условие — не предусмотрено! Где тут логика? А ведь она так необходима именно в учебном языке программирования! Ну что стоило хоть как-то упорядочить синтаксис, продумать сам язык до начала его программирования?
А библиотеки классов? Возникает ощущение, что кто-то просто резвился — как детёныш шимпанзе в вольере, создавая их: ни логики, ни осмысленности, ни привязки к насущным требованиям — налепили кое-как первое, что в голову пришло: для каких-то задач функционал — откровенно избыточный, а для каких-то - его попросту не хватает (и заменить нечем)… Единственная надежда — на [**библиотеку LitDev**](https://smallbasic.rubasic.ru/obzor-obektov-biblioteki-litdev/), в которой тоже — местами «не все так просто»…
Такое ощущение, что язык MS Small Basic писался разными студентами кого-то из сотрудников Microsoft второпях: «давай-давай быстрее!» — «сделай как-нибудь, лишь бы работало!» — «надо успеть!» — «бегом-кувырком!»…
Ну что сказать? — «Успели»!…
Выпустили безусловно очень нужный, но крайне сырой и корявый продукт, который в последствии за все годы развития даже не удосужились доработать.
В итоге получилось как обычно: «хотели как лучше, а получилось — как всегда» - отличная идея разбилась о «скалы» человеческой лени, глупости и жадности... И это очень печально. Ведь MS Small Basic мог стать действительно мировым лидером среди учебных языков программирования.
**Единственный вывод из всего сказанного: на этом языке можно писать что-то серьёзное, только понимая и осознавая все эти нюансы и подводные камни.**
PS: А если честно, то что-либо хоть сколько нибудь серьёзное — надо писать на С или С++, ну в крайнем случае - на C#. Там, по крайней мере, есть уверенность, что программа будет вести себя именно так, как написано — без двусмысленностей и разночтений.
В статье использованы материалы MSDN. | https://habr.com/ru/post/654299/ | null | ru | null |
# Деревья выражений в enterprise-разработке
Для большинства разработчиков использование expression tree ограничивается лямбда-выражениями в LINQ. Зачастую мы вообще не придаем значения тому, как технология работает «под капотом».
В этой статье я продемонстрирую вам продвинутые техники работы с деревьями выражений: устранение дублирования кода в LINQ, кодогенерация, метапрограммирование, транспиляция, автоматизация тестирования.
Вы узнаете, как пользоваться expression tree напрямую, какие подводные камни приготовила технология и как их обойти.
Под катом — видео и текстовая расшифровка [моего доклада](https://dotnext-piter.ru/2018/spb/talks/2ijzwfkh84aecgiokae06o/) с DotNext 2018 Piter.
Меня зовут Максим Аршинов, я соучредитель аутсорс-компании «Хайтек Груп». Мы занимаемся разработкой ПО для бизнеса, и сегодня я расскажу о том, какое применение нашлось технологии expression tree в повседневной работе и как она стала нам помогать.
Я никогда специально не хотел изучать внутреннее устройство деревьев выражений, казалось, что это какая-то внутренняя технология для .NET Team, чтобы LINQ работал, а его API прикладным программистам знать не надо. Получалось так, что появлялись какие-то прикладные задачи, требующие решения. Чтобы решение мне нравилось, приходилось лезть «в кишочки».
Вся эта история растянута во времени, были разные проекты, разные кейсы. Что-то вылезало, и я дописывал, но я позволю себе пожертвовать исторической правдивостью в пользу большей художественности изложения, поэтому все примеры будут на одной предметной модели — интернет-магазине.
Представьте, что мы все пишем интернет-магазин. В нем есть товары и галочка «Для продажи» в админке. На публичную часть выводить мы будем только те товары, у которых эта галочка отмечена.
Берем какой-нибудь DbContext или NHibernate, пишем Where(), IsForSale выводим.
Все хорошо, но бизнес-правила не бывают одинаковыми, чтобы мы их написали раз и навсегда. Они со временем эволюционируют. Приходит менеджер и говорит, что надо еще следить за остатком и выводить на публичную часть только товары, у которых есть остатки, не забывая про галочку.
Легко добавляем такое свойство. Теперь наши бизнес-правила инкапсулированы, можем их повторно использовать.
Попробуем отредактировать LINQ. Все ли здесь хорошо?
Нет, это не будет работать, потому что IsAvailable не мапится никак на базу данных, это наш код, и query-провайдер не знает, как его разобрать.
Мы можем подсказать ему, что в нашем свойстве такая история. Но теперь эта лямбда продублирована и в linq-выражении, и в свойстве.
```
Where(x => x.IsForSale && x.InStock > 0)
IsAvailable => IsForSale && InStock > 0;
```
Значит, когда в следующий раз эта лямбда изменится, нам придется делать Ctrl+Shift+F по проекту. Естественно, все мы не найдем — баги и время. Хочется такого избежать.
Можем зайти с такой стороны и поставить перед Where() еще один ToList(). Это плохое решение, потому что если в базе миллион товаров, все поднимаются в оперативную память и фильтруются там.
Если у вас три товара в магазине, решение хорошее, но в E-commerce их обычно больше. Сработало это лишь потому, что, несмотря на схожесть лямбд между собой, тип у них абсолютно разный. В первом случае это делегат Func, а во втором — дерево выражений. Выглядит одинаково, типы разные, байт-код абсолютно разный.
Чтобы перейти от expression к делегату, надо просто вызвать метод Compile(). Это API предоставляет .NET: есть expression — скомпилировали, получили делегат.
А вот как перейти обратно? Есть ли в .NET что-то для перехода от делегата к деревьям выражений? Если вы знакомы с LISP, например, то там есть механизм цитирования, который позволяет код интерпретировать как структуру данных, но в .NET такого нет.
Экспрешны или делегаты?
=======================
Учитывая, что у нас есть два типа лямбд, можно пофилософствовать, что же первично: expression tree или делегаты.
```
// so slo-o-o-o-o-o-o-ow
var delegateLambda = expressionLambda.Compile();
```
На первый взгляд ответ очевиден: раз есть прекрасный метод Compile(), expression tree первичен. А делегат мы должны получать, компилируя выражение. Но компиляция — процесс медленный, и если мы начнем повсеместно это делать, то получим деградацию производительности. Кроме того, мы ее получим в случайных местах, там где пришлось скомпилировать expression в делегат, будет проседание по производительности. Отыскивать эти места можно, но они будут влиять на время ответа сервера, причем случайным образом.
Поэтому их надо как-то кэшировать. Если вы слушали доклад про concurrent-структуры данных, то вы знаете про ConcurrentDictionary (или просто про него знаете). Я опущу детали про способы кэширования (с блокировками, не блокировками). Просто у ConcurrentDictionary есть простой метод GetOrAdd(), и самая простая реализация: засунуть в ConcurrentDictionary и закэшировать. В первый раз мы получим компиляцию, но потом все будет быстро, потому что делегат уже скомпилирован.
Дальше можно использовать такой метод расширения можно использовать и отрефакторить наш код с IsAvailable(), описать expression, свойства IsAvailable() скомпилировать и вызвать относительно текущего объекта this.
Есть, по крайней мере, два пакета, которые это реализуют: [Microsoft.Linq.Translations](https://github.com/damieng/Linq.Translations/tree/master/Microsoft.Linq.Translations) и [Signum Framework](https://github.com/signumsoftware/framework) (опенсорсный фреймворк, написанный коммерческой компанией). И там, и там примерно одна и та же история с компиляцией делегатов. Немного разное API, но все как я показал на предыдущем слайде.
Тем не менее, это не единственный подход, и можно идти от делегатов к выражениям. Достаточно давно на хабре есть [статья](https://habrahabr.ru/post/155437/) про Delegate Decompiler, где автор утверждает, что все компиляции это плохо, потому что долго.
Вообще делегаты были раньше выражений, и можно от делегатов переходить к ним. Для этого автор использует метод methodBody.GetILAsByteArray(); из Reflection, который действительно возвращает в качестве массива байтов весь IL-код метода. Если это засунуть дальше в Reflection, то можно получить объектное представление этого дела, пройтись по нему циклом и построить expression tree. Таким образом, обратный переход тоже возможен, но его приходится делать руками.
Для того чтобы не бегать по всем свойствам, автор предлагает повесить атрибут Computed, чтобы пометить, что это свойство надо инлайнить. Перед запросом залезаем в IsAvailable(), вытаскиваем его IL-код, преобразуем к expression tree и заменяем вызов IsAvailable() на то, что написано в этом геттере. Получается такой ручной инлайнинг.
Чтобы это сработало, прежде чем передавать все в ToList(), вызываем специальный метод Decompile(). Он предоставляет декоратор для оригинального queryable и осуществляет инлайнинг. Только после этого мы передаем все в query-провайдер, и все у нас хорошо.
Единственная проблема с этим подходом заключается в том, что Delegate Decompiler 0.23.0 не собирается двигаться вперед, поддержки Core нет, и сам автор говорит, что это глубокая alpha, там много недописанного, поэтому в продакшне использовать нельзя. Хотя к этой теме мы еще вернемся.
Булевы операции
===============
Получается, что проблему дублирования конкретных условий мы решили.
Но условия часто необходимо комбинировать с помощью булевой логики. У нас был IsForSale(), InStock() > 0, а между ними условие «И». Если есть еще какое-то условие, или потребуется «ИЛИ»-условие.
В случае с «И» можно схитрить и свалить всю работу на query-провайдер, то есть написать много Where() подряд, это он делать умеет.
Если же потребуется «ИЛИ», это не пройдет, потому что WhereOr() в LINQ нет, а у выражений не перегружен оператор «||».
Спецификации
============
Если вы знакомы с книгой Эванса «DDD» или просто знаете что-то про паттерн Спецификация, то есть шаблон проектирования, предназначенный ровно для этого. Есть несколько бизнес-правил и вы хотите комбинировать операции в булевой логике — реализуйте Спецификацию.
Спецификация — это такой термин, старый паттерн из Java. А в Java, тем более в старом, никакого LINQ не было, поэтому он реализован там только в виде метода isSatisfiedBy(), то есть только делегаты, а про выражения там речи нет. В интернете есть реализация, которая называется [LinqSpecs](https://github.com/navozenko/LinqSpecs), на слайде вы ее увидите. Я ее немного подпилил напильником под себя, но идея принадлежит библиотеке.
Здесь перегружены все булевые операторы, перегружены операторы true и false, чтобы работали два оператора «&&» и «||», без них будет работать только одинарный амперсанд.
Дальше дописываем implicit-операторы, которые заставят компилятор считать, что спецификация — это и выражения, и делегаты. В любом месте, где в функцию должен прийти тип Expression<> или Func<>, вы можете передавать спецификацию. Так как перегружен оператор implicit, компилятор разберется и подставит либо свойства Expression, либо IsSatisfiedBy.
IsSatisfiedBy() можно реализовать с помощью кэширования выражения, которое пришло. В любом случае получается, что мы идем от Expression, делегат ему соответствует, мы добавили поддержку булевых операторов. Теперь это все можно компоновать. Бизнес-правила можно вынести в статические спецификации, их объявить и комбинировать.
```
public static readonly Spec
IsForSaleSpec = new Spec(x => x.IsForSale);
public static readonly Spec
IsInStockSpec = new Spec(x => x.InStock > 0);
```
Каждое бизнес-правило написано только один раз, оно никуда не потеряется, не продублируется, их можно комбинировать. Люди, приходя на проект, могут посмотреть, что у вас есть, какие условия, разобраться в предметной модели.
Есть небольшая проблема: методов And(), Or() и Not() у Expression нет. Это extension-методы, их надо реализовать самостоятельно.
Первая попытка реализации была такой. Про expression tree довольно мало документации в интернете, и она вся не подробная. Поэтому я попробовал просто взять Expression, нажал Ctrl+Space, увидел OrElse(), прочитал про него. Передал два Expression, чтобы скомпилировать и дальше получить лямбду. Так не будет работать.
Дело в том, что данный Expression состоит из двух частей: параметра и тела. Второй также состоит из параметра и тела. В OrElse() надо передавать тела выражений, то есть бесполезно сравнивать по «И» и «ИЛИ» лямбды, так не будет работать. Исправляем, но так снова не будет работать.
Но если в прошлый раз было NotSupportedException, что лямбда не поддерживается, то теперь странная история про параметр 1, параметр 2, «что-то неправильно, работать не буду».
С# 7.0 in a Nutshell
====================
Тут я подумал, что метод научного тыка не пройдет, надо разобраться. Начал гуглить и нашел сайт книжки Албахари «[С# 7.0 in a Nutshell](http://www.albahari.com/nutshell/linqkit.aspx)».
Джозеф Албахари, он же разработчик популярной библиотеки LINQKit и LINQPad, как раз описывает эту проблему. что нельзя просто взять и скомбинировать Expression, а если взять волшебный Expression.Invoke(), работать будет.
Вопрос: что такое Expression.Invoke()? Опять идем в Google. Он создает InvocationExpression, который применяет делегат или лямбда-выражение к списку аргументов.
Если я вам сейчас этот код зачитаю, что мы берем Expression.Invoke(), параметры передаем, то там написано тоже самое по-английски. Понятнее не становится. Есть какой-то волшебный Expression.Invoke(), который почему-то решает эту проблему с параметрами. Надо поверить, понимать не надо.
При этом, если попробовать скормить EF такие скомбинированные Expression, он опять упадет и скажет, что Expression.Invoke() не поддерживается. Кстати, EF Core начал поддерживать, а EF 6 не держит. Но Албахари предлагает просто написать AsExpandable(), и все заработает.
А еще вы можете подставлять в подзапросы Expression, где нам нужен делегат. Чтобы они совпали, мы пишем Compile(), но при этом, если написать AsExpandable(), как предлагает Албахари, этот Compile() на самом деле не произойдет, а все как-то магически будет сделано правильно.
Я на слово не поверил и полез в исходники. Что за метод AsExpandable()? В нем есть query и QueryOptimizer. Второй мы оставим за скобками, так как он неинтересный, а просто склеивает Expression: если есть 3 + 5, он поставит 8.
Интересно, что дальше вызывается метод Expand(), после него queryOptimizer, а затем все передается в query-провайдер как-то переделанное после метода Expand().
Открываем его, это Visitor, внутри мы видим неоригинальный Compile(), который компилирует что-то другое. Не буду рассказывать, что именно, хоть в этом и есть определенный смысл, но мы убираем одну компиляцию и заменяем ее на другую. Здорово, но попахивает маркетингом 80-го уровня, потому что performance impact никуда не денется.
В поисках альтернативы
======================
Я подумал, что так дело не пойдет и стал искать другое решение. И нашел. Есть такой Пит Монтгомери, который тоже [пишет](https://petemontgomery.wordpress.com/2011/02/10/a-universal-predicatebuilder/) об этой проблеме и утверждает, что Албахари схалтурил.
Пит поговорил с разработчиками EF, и они его научили все скомбинировать без Expression.Evoke(). Идея очень простая: засада была с параметрами. Дело в том, что при комбинации Expression есть параметр первого выражения и параметр второго. Они не совпадают. Тела склеили, а параметры остались висеть в воздухе. Их надо забиндить правильным образом.
Для этого надо составить словарь, посмотрев параметры выражений, если лямбда не от одного параметра. Составляем словарь, и все параметры второго перебиндиваем на параметры первого, чтобы изначальные параметры вошли в Expression, проехали по всему телу, которое мы склеили.
Такой простой метод позволяет избавиться от всех засад с Expression.Invoke(). Более того, в реализации Пита Монтгомери это сделано еще круче. У него есть метод Compose(), позволяющий комбинировать любые выражения.
Берем выражение и через AndAlso соединяем, работает без Expandable(). Именно такая реализация используется в булевых операциях.
Спецификации и агрегаты
=======================
Все было хорошо, пока не выяснилось, что в природе существуют агрегаты. Для тех, кто не знаком, поясню: если у вас есть доменная модель и вы представляете все сущности, которые связаны друг с другом, в виде деревьев, то висящее отдельно дерево — это агрегат. Заказ вместе с позициями заказа будет называться агрегат, а сущность заказа — корень агрегации.
Если кроме товаров, еще есть категории с объявленным для них бизнес-правилом в виде спецификации, что есть некий рейтинг, который должен быть больше 50, как сказали маркетологи и мы хотим его так использовать, то это хорошо.
Но если же мы хотим вытащить товары из хорошей категории, то опять плохо, потому что у нас не совпали типы. Спецификация для категории, а нужны продукты.
Опять надо как-то решать проблему. Первый вариант: заменить Select(), на SelectMany(). Здесь мне не нравятся две вещи. Во-первых, я плохо знаю, как реализована поддержка SelectMany() во всех популярных query-провайдерах. Во-вторых, если кто-то будет писать query-провайдер, то первое, что он будет делать, — это писать throw not implemented exception и SelectMany(). И третий момент: люди думают, что SelectMany() — это либо функциональщина, либо join’ы, обычно не ассоциируется с запросом SELECT.
Композиция
==========
Хотелось бы использовать Select(), а не SelectMany().
Примерно в то же время я читал про теорию категорий, про функциональную композицию и подумал, что если есть спецификации из продукта в bool снизу, есть какая-то функция, которая от продукта может перейти к категории, есть спецификация относительно категории, то, подставив первую функцию в качестве аргумента второй, мы получим что надо, спецификацию относительно продукта. Абсолютно так же, как работает функциональная композиция, но для деревьев выражений.
Тогда можно было бы написать такой метод Where(), что от продуктов надо перейти к категориям и к этой связанной сущности применить спецификацию. Такой синтаксис на мой субъективный вкус выглядит довольно понятно.
```
public static IQueryable Where(this IQueryable queryable,
Expression> prop, Expression> where)
{
return queryable.Where(prop.Compose(where));
}
```
С методом Compose() это тоже можно просто сделать. Берем входной Expression от продуктов и комбинируем его вместе с спецификаций относительно продукта и всё.
Теперь можно писать такие Where(). Это будет работать, если у вас агрегат любой длины. У Category есть SuperCategory и сколько угодно дальше свойств, которые можно подставить.
«Раз у нас есть инструмент функциональной композиции, и раз мы можем это компилировать, и раз мы можем собирать это динамически, значит есть запахло мета-программированием!», — подумал я.
Проекции
========
Где же мы можем применить мета-программирование, чтобы пришлось меньше кода писать.
Первый вариант — проекции. Вытаскивать целиком сущность зачастую слишком дорого. Чаще всего мы ее передаем на фронт, сериализуем JSON. А в нем не нужна вся сущность вместе с агрегатом. Максимально эффективно с помощью LINQ это можно сделать, написав такой Select() ручной. Не сложно, но нудно.
Вместо этого я всем предлагаю использовать ProjectToType(). По крайней мере, есть две библиотеки, которые это умеют: Automapper и Mapster. Почему-то очень многие знают, что AutoMapper умеет делать маппинг в памяти, но не все знают, что у него есть Queryable Extensions, там тоже Expression, и он может строить SQL-выражение. Если вы все еще пишете ручные запросы и вы используете LINQ, так как у вас нет супер-серьезных перформанс ограничений, то нет никакого смысла делать это руками, это работа машины, а не человека.
Фильтрация
==========
Если мы умеем так делать с проекциями, почему бы так не делать для фильтрации.
Вот тоже код. Приходит какой-то фильтр. Очень много бизнес-приложений выглядят так: пришел фильтр, добавим Where(), пришел еще фильтр, добавим Where(). Сколько фильтров есть, столько и повторите. Ничего сложного, но очень много копипасты.
Если мы как AutoMapper сделаем, напишем AutoFilter, Project и Filter, чтобы он сам все сделал, было бы круто — меньше кода.
В этом нет ничего сложного. Берем Expression.Property, проходимся по DTO и по сущности. Находим общие свойства, которые называются одинаково. Если они называются одинаково — это похоже на фильтр.
Дальше надо проверить на null, использовать константу, чтобы вытащить из DTO значение, подставить его в выражение и добавить конвертацию на случай, если у вас Int и NullableInt или другие Nullable, чтобы типы совпали. И поставить, например, Equals(), фильтр, который проверяет на равенство.
После чего собрать лямбду и пробежаться для каждого свойства: если их много, собрать либо через «И» или «ИЛИ», в зависимости от того, как работает у вас фильтр.
Тоже самое можно сделать для сортировки, но это немного сложнее, так как в методе OrderBy() два дженерика, поэтому их придется заполнять руками, с помощью Reflections создавать метод OrderBy() от двух дженериков, вставлять тип сущности, которой мы берем, тип сортируемого Property. В общем, тоже можно сделать, это несложно.
Возникает вопрос: где поставить Where() — на уровне сущности, как были объявлены спецификации или после проекции, и там, и там будет работать.
Правильно и так, и так, потому что спецификации по определению — бизнес-правила, а их мы должны холить-лелеять и с ними не ошибаться. Это одномерный слой. А фильтры — это больше про UI, а значит они фильтруют по DTO. Поэтому можно поставить два Where(). Тут скорее вопросы, насколько query-провайдер хорошо с этим справится, но я считаю, что ORM-решения и так пишут плохой SQL, и он сильно хуже не будет. Если вам это сильно важно, то эта история вообще не про ваc.
Как говорится, лучше один раз увидеть, чем сто раз услышать.
Сейчас в магазине есть три товара: «Сникерс», Subaru Impreza и «Марс». Странный магазин. Давайте попробуем найти «Сникерс. Есть. Посмотрим, что за сто рублей. Тоже «Сникерс». А за 500? Приблизим, ничего нет. А за 100500 Subaru Impreza. Отлично, то же самое касается сортировки.
Посортируем по алфавиту и по цене. Кода там написано ровно столько, сколько было. Эти фильтры работают для любых классов, как угодно. Если попробовать поискать по названию, то Subaru тоже найдется. А у меня в презентации было Equals(). Как так-то? Дело в том, что код здесь и в презентации немного разный. Строчку про Equals() я закомментировал и добавил особой уличной магии. Если у нас тип String, то надо не Equals(), а вызовем StartWith(), который я тоже получил. Поэтому для строк строится другой фильтр.
Это значит, что здесь вы можете нажать Ctrl+Shift+R, выделить метод и написать не if, а switch, а может даже реализовать паттерн «Стратегия» и далее go insane. Любые желания о работе фильтров вы можете реализовать. Все зависит от типов, с которыми вы работаете. Что самое важное, фильтры будут работать одинаково.
Вы можете согласовать, что фильтры во всех элементах UI должны работать так: строки ищутся одним способом, деньги — другим. Все это согласовать, один раз написать, все будет в разных интерфейсах правильно сделать, и никакие другие разработчики это не сломают, потому что этот код не на уровне прикладного, а где-то либо во внешней библиотеке, либо в вашем ядре.
Валидация
=========
Кроме фильтрации и проекции, можно заняться валидацией. На эту идею меня натолкнула JS-библиотека [TComb.validation](https://github.com/gcanti/tcomb-validation). TComb — это сокращение от Type Combinators и она основана на системе типов и т.н. refinement’ов, улучшений.
```
// null and undefined
validate('a', t.Nil).isValid(); // => false
validate(null, t.Nil).isValid(); // => true
validate(undefined, t.Nil).isValid(); // => true
// strings
validate(1, t.String).isValid(); // => false
validate('a', t.String).isValid(); // => true
// numbers
validate('a', t.Number).isValid(); // => false
validate(1, t.Number).isValid(); // => true
```
Сначала объявлены примитивы, соответствующие всем типам JS, и дополнительный тип nill, соответствующий либо undefined, либо нулю.
```
// a predicate is a function with signature: (x) -> boolean
var predicate = function (x) { return x >= 0; };
// a positive number
var Positive = t.refinement(t.Number, predicate);
validate(-1, Positive).isValid(); // => false
validate(1, Positive).isValid(); // => true
```
Дальше начинается интересное. Каждый тип можно усилить с помощью предиката. Если мы хотим числа больше нуля, то объявляем предикат x >= 0 и делаем валидацию, относительно типа Positive. Так из строительных блоков можно собирать любые свои валидации. Заметили, наверное, там тоже лямбда-выражения.
Вызов принят. Берем такой же refinement, пишем его на C#, пишем метод IsValid(), так же Expression компилируем, выполняем. Теперь у нас есть возможность валидацию проводить.
```
public class RefinementAttribute: ValidationAttribute
{
public IValidator Refinement { get; }
public RefinementAttribute(Type refinmentType)
{
Refinement = (IValidator)
Activator.CreateInstance(refinmentType);
}
public override bool IsValid(object value)
=> Refinement.Validate(value).IsValid();
}
```
Интегрируемся со стандартной системой DataAnnotations в ASP.NET MVC, чтобы это все работало из коробки. Объявляем RefinementAttribute(), передаем в конструктор тип. Дело в том, что RefinementAttribute дженериковый, поэтому здесь приходится так использовать тип, потому что нельзя объявить атрибут дженерик в .NET, к сожалению.
Так помечаем класс юзера рефайнментом. AdultRefinement, что возраст больше 18.
Чтобы совсем было хорошо, давайте сделаем валидацию на клиенте и сервере одинаковой. Сторонники NoJS предлагают на JS написать и бэк, и фронт. Хорошо, я на C# напишу и бэк и фронт, ничего страшного и просто транспилирую это в JS. Джаваскриптистам же можно писать на своих JSX, ES6 и транспилировать это в JavaScript. Почему нам нельзя? Пишем Visitor, проходимся, какие операторы нужны и пишем JavaScript.
Отдельно частый кейс валидации — это регулярные выражения, их тоже надо разобрать. Если у вас regexp, берем StringBuilder, собираем regexp. Здесь я использовал два восклицательных знака, так как JS — это динамически типизированный язык, это выражение будет приведено к bool всегда, чтобы с типом все было хорошо. Давайте посмотрим, как это выглядит.
```
{
predicate: “x=> (x >= 18)”,
errorMessage: “For adults only»
}
```
Вот наш рефайнмент, который приходит с бэкенда, предикат в виде строчки, так как в JS нет лямбд и errorMessage «For adults only». Попробуем заполнить форму. Не проходит. Смотрим, как это сделано.
Это React, мы запрашиваем с бэкенда из метода UserRefinment() Expression и errorMessage, конструируем refinment относительно number, используем eval, чтобы получить лямбду. Если я это переделаю и сниму ограничения типа, заменю на обычный number, отвалится валидация на JS. Вводим единицу, отправляем. Не знаю, видно или нет, здесь false вывелось.
В коде стоит alert. Когда отправляем onSubmit, alert того, что пришло с бэкенда. А на бэкенде такой простой код.
Мы просто возвращаем Ok(ModelState.IsValid), класс User, который мы получаем из формы на JavaScript. Вот этот атрибут Refinement.
```
using …
namespace DemoApp.Core
{
public class User: HasNameBase
{
[Refinement(typeof(AdultRefinement))]
public int Age { get; set; }
}
}
```
То есть валидация работает и на бэкенде, которая объявлена в этой лямбде. И мы ее транспилируем в JavaScript. Получается, пишем лямбда-выражения на C#, а код выполняется и там, и там. Наш ответ NoJS, мы тоже так можем.
Тестирование
============
Обычно именно тимлидов больше беспокоит количество ошибок в коде.Те, кто пишут юнит-тесты, знают библиотеку Moq. Не хочешь писать mock или какой-то класс объявлять — есть moq, у него есть fluent-синтаксис. Можно расписать, как ты хочешь чтобы он себя вел и подсунуть свое приложение для тестирования.
Эти лямбды в moq — это тоже Expression, не делегаты. Он пробегается по деревьям выражений, применяет свою логику и дальше кормит в Castle.DynamicProxy. А он создает в рантайме необходимые классы. Но мы же тоже так можем.
Один мой знакомый недавно спросил, есть ли в нашем Core что-то вроде WCF. Я ответил, что есть WebAPI. Он же хотел в WebAPI, как в WCF по WSDL построить прокси. В WebAPI есть только swagger. Но swagger — это просто текст, а знакомому не хотелось каждый раз следить, когда API поменяется и что сломается. Когда был WCF, он подключал WSDL, если спека поменялась у API, ломалась компиляция.
В этом есть определенный смысл, так как искать неохота, а компилятор может помочь. По аналогии с moq можно объявить метод GetResponse<>() дженериковы с вашим ProductController, и лямбда, переходящая в этот метод, параметризована контроллером. То есть вы, начиная писать лямбду, нажимаете Ctrl+Space и видите все методы, которые есть у этого контроллера, при условии, что есть библиотека, dll с кодом. Есть Intellisense, все это пишите, будто вы вызываете контроллер.
Дальше, как Moq, мы не будем это вызывать, а просто построим дерево выражений, пройдемся по нему, вытащим из конфига API всю информацию по роутингу. И вместо того, чтобы что-то делать с контроллером, который мы не можем выполнять, так как должны выполнить на сервере, сделаем просто POST- или GET-запрос, который нам нужен, и в обратную сторону десериализуем полученное в ответ, потому что из Intellisense и expression tree мы знаем о всех возвращаемых типах. Получается, пишем код про контроллеры, а на самом деле делаем Web-запросы.
Оптимизация Reflection
Все что касается мета-программирования, сильно перекликается с Reflection.
Мы знаем, что Reflection медленный, хотелось бы этого избежать. Здесь тоже есть хорошие кейсы работы с Expression. Первое — это активатор CreateInstance. Не надо его использовать вообще никогда, потому что есть Expression.New(), который просто можно загнать в лямбду, скомпилировать и после этого получить конструкторы.
Этот слайд я позаимствовал у замечательного спикера и музыканта Вагифа. Он в блоге делал какой-то бенчмарк. Вот Activator, это Пик Коммунизма вы видите, сколько он пытается все сделать. Constructor\_Invoke, он примерно как половина. А слева — New и compiled-лямбда. Есть небольшое увеличение производительности за счет того, что это делегат, а не конструктор, но выбор очевиден, понятно что это сильно лучше.
То же самое можно делать с геттерами или сеттерами.
Делается очень просто. Если вас по каким-то причинам не устраивает Fast Memember Марка Гравелли или Fast Reflect, не хотите тащить эту зависимость, можно сделать так же. Единственная сложность, что за всеми этими компиляциями надо следить, где-то хранить и прогревать кэш. То есть, если этого много, то на старте надо скомпилировать один раз.
Раз есть конструктор, геттеры и сеттеры, осталось только поведение, методы. Но их тоже можно компилировать в делегаты, и вы получите просто большой зоопарк делегатов, которым нужно будет уметь управлять. Зная все то, о чем я рассказал, кому-то в голову может прийти идея, что если там много делегатов, много выражений, то может быть есть место для того, что называют DSL, Little Languages или паттерн-интерпретатор, свободная монада.
Это все одни и те же вещи, когда для какой-то задачи мы придумываем набор команд и для него пишем свой интерпретатор, который это выполняет. То есть, внутри приложения пишем еще компилятор или интерпретатор, который знает, как эти команды использовать. Именно так это и сделано в DLR, в той части, которая работает с языками IronPython, IronRuby. Expression tree там используется для исполнения динамического кода в CLR. Это же можно делать в бизнес-приложениях, но мы пока такой необходимости не заметили и это остается за скобками.
Итоги
=====
В заключение хочу рассказать о том, к каким выводам мы пришли после внедрения и проб. Как я говорил, это происходило на разных проектах. Все что я написал, мы не используем повсеместно, но где-то если требуется, некоторые вещи использовались.
Первый плюс — это возможность автоматизировать рутину. Если у вас 100 тысяч формочек с фильтрациями, пагинациями и всем таким. У Моцарта была шутка, что с помощью игральных костей, достаточного количества времени и бокала красного вина, можно писать вальсы в любом количестве. Тут с помощью Expression Trees, немного мета-программирования можно писать формочки в любом количестве.
Сильно уменьшается количество кода, как альтернатива кодогенерации, если вы ее не любите, так как получается много кода, то можно его не писать, оставить все в рантайме.
Используя такой код для простых задач, мы еще больше снижаем требования к исполнителям, потому что императивного кода там остается очень мало и места для ошибки тоже. Вытащив большое количество кода в повторно используемые компоненты, мы этот класс ошибок убираем.
С другой стороны, мы так сильно повышаем требования к квалификации проектировщика, потому что вылезают вопросы знания о работе с Expression, Reflection, их оптимизации, о местах, где можно выстрелить себе в ногу. Здесь много таких нюансов, поэтому человеку, незнакомому с этим API, будет не сразу понятно, почему Expression просто так не комбинируется. Проектировщик должен быть круче.
В некоторых случаях за счет Expression.Compile() можно поймать деградацию производительности. В примере с кэшированием у меня было ограничение, что Expression’ы статические, потому что используется Dictionary для кэширования. Если кто-то не знает, как это устроено внутри, начнет бездумно это делать, объявит спецификации нестатическими внутри, метод кэша не сработает, и мы получим вызовы Compile() в случайных местах. Именно то, чего хотелось избежать.
Самый неприятный минус — код перестает выглядеть как C#-код, он становится менее идиоматическим, появляются статические вызовы, странные дополнительные методы Where(), какие-то implicit-операторы перегружены. Этого нет в документации MSDN, в примерах. Если к вам приходит, допустим, человек с небольшим опытом, не привыкший в случае чего лезть в исходники, он скорее всего будет находиться в небольшой прострации первое время, потому что это не вписывается в картину мира, на StackOverflow таких примеров нет, но с этим придется как-то работать.
В общем, это все, о чем я хотел сегодня рассказать. Многое из того, о чем я рассказал, более подробно, с деталями [написано](https://habr.com/users/marshinov/posts/) на Хабре. Код библиотеки выложен на гитхабе, но у нее есть один фатальный недостаток — полное отсутствие документации.
> 22-23 ноября в Москве пройдет [DotNext 2018 Moscow](https://dotnext-moscow.ru/). Предварительная сетка докладов уже выложена на сайте, [билеты](https://dotnext-moscow.ru/registration/) можно приобрести там же (**с первого октября** стоимость билетов увеличится). | https://habr.com/ru/post/423891/ | null | ru | null |
# Почему современное ПО такое медленное — разбираемся на примере диктофона Windows
Я прошу прощения за такой заголовок, потому что современное ПО может быть медленным по множеству разных причин. Слепое использование одного объяснения без малейшего расследования — это программный аналог [карго-культа](https://en.wikipedia.org/wiki/Cargo_cult). В этом посте рассматривается *один* пример того, почему современное ПО может быть мучительно медленным.
Я всего лишь хотел записать сорокасекундную озвучку [простенького видео](https://youtu.be/Sh08No3VuWk), поэтому запустил стандартное приложение *Запись голоса* (Voice Recorder) операционной системы Windows и нажал на кнопку записи. Казалось, что ничего не произошло.
Позже я проверил и оказалось, что программа выполняет запись. Я немного поэкспериментировал и выяснил, что в первый раз, когда я начинал запись после запуска *Записи голоса*, её реакции иногда предшествовала долгая задержка. Двадцатисекундная задержка при записи сорокасекундного клипа — довольно низкий КПД. Это расстроило меня настолько, что я захотел разобраться, почему так получается, и запустил [трассировку ETW](https://tinyurl.com/etwcentral).
Современное ПО любит использовать дополнительные процессы, поэтому меня не удивило то, что самым нагруженным процессом был не *SoundRec.exe*, а «RuntimeBroker.exe ». Взглянув на его использование процессора, я заметил, что нагрузка повышается, как только я запускаю *Запись голоса*, даже до того, как я нажму на кнопку записи.
*RuntimeBroker* сильно нагружал процессор и тратил бОльшую часть своего времени в одном потоке, который активно выполнял запросы результатов просмотра какой-то папки:
Следующим я посмотрел на график файлового ввода-вывода, чтобы понять, что за папку он сканирует. Результаты оказались немного разрозненными (возможно, иногда сканирование завершалось слишком рано?), но выяснилось, что *RuntimeBroker* сканировал (в том же потоке) часть моей папки с документами или её целиком.
Тем временем, ещё один поток *RuntimeBroker* тратил немного времени в *propsys.dll!TryGetFileTypeAssocFromStateRepository*.
Я предположил, что цель всего этого заключалась в том, чтобы найти все аудиофайлы в моей папке документов, чтобы заполнить список предыдущих записей. И когда я начал следить за этим, то выяснил, что при запуске *Записи голоса* программа после существенной паузы заполняет список записей. Если я нажимал кнопку записи *после* заполнения списка, запись начиналась мгновенно.
<сарказм>Очевидно, в этом случае ошибку совершил пользователь. Если бы я терпеливо подождал, пока мой медленный компьютер будет готов, то при начале записи программа была бы быстрой и отзывчивой.
Безумие этой задержки из-за сканирования папки с документами в том, что *Запись голоса*, похоже, игнорирует все аудиофайлы, не находящиеся в папке *Аудиозаписи*. Всё это сканирование происходит впустую?
Жалобы и вопросы
----------------
По поводу всего этого у меня есть некоторые соображения…
1. Команда `dir /s` может отсканировать мою папку с документами менее чем за две секунды. Почему у *RuntimeBroker* сканирование занимает в 5-10 раз больше времени? В этой папке у меня всего около 44 тысяч документов, что за фильтрация используется, которая добавляет на каждый файл лишние полмиллиона тактов?
2. Зачем *RuntimeBroker* сканирует всю папку с документами, если *Запись голоса* игнорирует аудиофайлы, не находящиеся в подпапке «Аудиозаписи»? Это проблема *WinRT* или *Записи голоса*?
3. Что происходит у пользователей, не имеющих SSD и 32 ГБ ОЗУ? В моём случае структура папки «Документы» целиком кэширована в память, поэтому для сканирования не требуется активность диска, но некоторым пользователям повезло меньше. Если у этих пользователей больше файлов и они хранятся на жёстком диске, то их остаётся только пожалеть.
4. При выполнении операции, не позволяющей пользователю работать с приложением, честнее использовать шкалу прогресса или курсор ожидания. UI *Записи голоса* всегда реагировал на взаимодействия, но на самом деле это было ложью — кнопка записи должна быть отключена, пока приложение не готово.
5. Почему сканирование папки с документами иногда выполняется только для части папки? У RuntimeBroker есть какое-то кэширование?
Я недостаточно знаю о [WinRT и RuntimeBroker](https://www.infoq.com/news/2011/09/Design-Details-Windows-Runtime/), чтобы осознанно говорить о причинах проблемы, но уверенно скажу, что если приложение-диктофон не способно мгновенно записывать голос на современном оборудовании, то в архитектуре определённо имеются изъяны.
Всё тестирование выполнялось на Windows 10, 21H2. В Windows 11 приложение *Запись голоса* заменено на *Windows Sound Recorder*, код которого полностью переписан. Похоже, в переписанной версии этого бага нет, так что ура, прогресс, но я опасаюсь за мир ПО, в котором приложения не исправляются, а переписываются. | https://habr.com/ru/post/693216/ | null | ru | null |
# Ленивая загрузка для карт
Если на странице есть интерактивная карта Яндекса или Google, то она может отнять несколько секунд в скорости загрузки, и здорово испортить отчет [Google PageSpeed](https://developers.google.com/speed/pagespeed/insights/).
В этой статье опишу пример оптимизации подключения Яндекс карты, где она будет подгружаться ленивым способом при наведении курсора мыши.
1. Сначала построим карту Яндекса ([тут](https://yandex.ru/map-constructor/)) и получим скрипт, примерно такой:
```
```
2. На своем сайте напишем контейнер для блока карты:
```
```
И стили для нашей статичной картинки (её легче сделать любым скриншотером):
```
.map.container-fluid {
height: 340px;
padding: 0;
background-image: url(/uploads/common/ymap0.png);
background-position: center center;
}
```
3. Самое интересное, напишем JavaScript код, который будет отслеживать события наведения мыши или нажатия на тач экран телефона, и подменять статичную картинку на интерактивную карту:
```
let map\_container = document.getElementById('map\_container');
let options\_map = {
once: true,//запуск один раз, и удаление наблюдателя сразу
passive: true,
capture: true
};
map\_container.addEventListener('click', start\_lazy\_map, options\_map);
map\_container.addEventListener('mouseover', start\_lazy\_map, options\_map);
map\_container.addEventListener('touchstart', start\_lazy\_map, options\_map);
map\_container.addEventListener('touchmove', start\_lazy\_map, options\_map);
let map\_loaded = false;
function start\_lazy\_map() {
if (!map\_loaded) {
let map\_block = document.getElementById('ymap\_lazy');
map\_loaded = true;
map\_block.setAttribute('src', map\_block.getAttribute('data-src'));
map\_block.removeAttribute('data\_src');
console.log('YMAP LOADED');
}
}
```
4. Profit! Теперь ваш сайт стал грузиться гораздо быстрее!
P.S.: Данный способ так же возможно адаптировать и для других объектов, не обязательных JS и CSS, благодаря чему скорость загрузки страницы может составить меньше секунды. | https://habr.com/ru/post/516700/ | null | ru | null |
# Разработка Shell Extensions для Windows Explorer
Для повышения удобства разрабатываемых продуктов, мы стараемся обеспечить максимальный уровень интеграции функционала в операционную систему, чтобы пользователю было удобно использовать весь потенциал приложения. В этой статье будут рассмотрены теоретические и практические аспекты разработки Shell Extensions, компонентов позволяющих интегрироваться в оболочку операционной системы Windows. В качестве примера рассмотрим расширение списка контекстного меню для файлов, а так же проведем обзор уже существующих решений в этой области.
Вообще говоря, существует огромное множество вариантов интеграционных компонентов оболочки операционной системы Windows, например: апплеты панели управления, хранители экрана и прочее, однако в данной статье мне бы хотелось подробнее остановиться на возможностях расширения Windows Explorer, компонента ОС, который мне приходилось расширять больше остальных, ввиду его функциональной нагрузки.
Windows Explorer позволяет расширять себя посредством использования специализированных COM объектов. Windows API, содержит интерфейсы и структуры описывающие, как должны работать такие COM объекты, какие методы должны экспортировать. После того как COM объект реализующий нужный функционал разработан, он регистрируется по определенному пути в реестре Windows, так чтобы Windows Explorer при выполнении описанного при регистрации функционала обратился к соответствующему COM объекту.
Итак, начнем разработку COM объекта позволяющего расширить список контекстного меню для файлов.
Разрабатывать будем при помощи .net framework.
Добавим в Assembly.cs следующие директивы, позволяющие использовать нашу сборку как COM объект:
```
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(true)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("345F4DC2-A9BF-11E2-AA47-CC986188709B")]
```
Нам понадобиться импортировать некоторые функции Windows API.
```
[DllImport("shell32")]
internal static extern uint DragQueryFile(uint hDrop,uint iFile, StringBuilder buffer, int cch);
[DllImport("user32")]
internal static extern uint CreatePopupMenu();
[DllImport("user32")]
internal static extern int InsertMenuItem(uint hmenu, uint uposition, uint uflags, ref MENUITEMINFO mii);
[DllImport("user32.dll")]
internal static extern bool SetMenuItemBitmaps(IntPtr hMenu, uint uPosition,
uint uFlags, IntPtr hBitmapUnchecked, IntPtr hBitmapChecked);
[DllImport("Shell32.dll")]
internal static extern void SHChangeNotify(int wEventId, uint uFlags, IntPtr dwItem1, IntPtr dwItem2);
const int SHCNE_ASSOCCHANGED = 0x08000000;
[DllImport("user32.dll", SetLastError = true)]
internal static extern bool PostMessage(IntPtr hWnd, [MarshalAs(UnmanagedType.U4)] uint Msg, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll", SetLastError = true)]
internal static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
```
Функция DragQueryFile позволит нам получить список файлов выбранных в каталоге, SHChangeNotify оповестить операционную систему о том, что оболочка была изменена.
Так как мы разрабатываем COM объект, который расширяет контекстное меню, мы должны реализовать интерфейс IShellExtInit. В методе Initialize мы получим базовую информацию о каталоге, в котором выполняемся.
```
[ComImport(), InterfaceType(ComInterfaceType.InterfaceIsIUnknown), GuidAttribute("000214e8-0000-0000-c000-000000000046")]
public interface IShellExtInit
{
[PreserveSig()]
int Initialize (IntPtr pidlFolder, IntPtr lpdobj, uint /*HKEY*/ hKeyProgID);
}
```
Также необходимо описать и реализовать COM интерфейс IContextMenu. Значение поля PreserveSig, равное true, инициирует непосредственное преобразование неуправляемых сигнатур со значениями HRESULT или retval, а значение false вызывает автоматическое преобразование значений HRESULT или retval в исключения. По умолчанию для поля PreserveSig используется значение true.
```
[ComImport(), InterfaceType(ComInterfaceType.InterfaceIsIUnknown), GuidAttribute("000214e4-0000-0000-c000-000000000046")]
public interface IContextMenu
{
// IContextMenu methods
[PreserveSig()]
int QueryContextMenu(uint hmenu, uint iMenu, int idCmdFirst, int idCmdLast, uint uFlags);
[PreserveSig()]
void InvokeCommand (IntPtr pici);
[PreserveSig()]
void GetCommandString(int idCmd, uint uFlags, int pwReserved, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] byte[] pszName, uint cchMax);
}
```
Метод QueryContextMenu будет вызван при вызове контекстного меню, в нем нам будет нужно реализовать функционал по добавлению пункта меню, GetCommandString будет возвращать некоторые детали по данной команде, ее описание и прочее. InvokeCommand будет вызван при выборе пункта меню, который мы добавим.
Для COM объекта так же необходимо реализовать функции установки и удаления.
```
[System.Runtime.InteropServices.ComRegisterFunctionAttribute()]
static void RegisterServer(System.Type type)
{
try
{
string approved = string.Empty;
string contextMenu = string.Empty;
RegistryKey root;
RegistryKey rk;
root = Registry.LocalMachine;
rk = root.OpenSubKey(Resources.ApprovedReg, true);
rk.SetValue(type.GUID.ToString("B"), Resources.Extension);
approved = rk.ToString();
rk.Flush();
rk.Close();
root = Registry.ClassesRoot;
rk = root.CreateSubKey(Resources.ExShellReg);
rk.Flush();
rk.SetValue(null, type.GUID.ToString("B"));
contextMenu = rk.ToString();
rk.Flush();
rk.Close();
EventLog.WriteEntry("Application", "Example ShellExt Registration Complete.\r\n" + approved + "\r\n" + contextMenu, EventLogEntryType.Information);
RestartExplorer();
}
catch(Exception e)
{
EventLog.WriteEntry("Application", "Example ShellExt Registration error.\r\n" + e.ToString(), EventLogEntryType.Error);
}
}
```
В этой функции мы выполняем регистрацию нашего компонента в реестре, так как у нас компонент расширяющий функционал контекстного меню, мы регистрируемся в разделе ContextMenuHandlers (\*\\shellex\\ContextMenuHandlers\\ExShell). После регистрации перезапускаем процесс explorer.exe для того, чтобы наши изменения сразу вступили в силу.
```
[System.Runtime.InteropServices.ComUnregisterFunctionAttribute()]
static void UnregisterServer(System.Type type)
{
try
{
string approved = string.Empty;
string contextMenu = string.Empty;
RegistryKey root;
RegistryKey rk;
// Remove ShellExtenstions registration
root = Registry.LocalMachine;
rk = root.OpenSubKey(Resources.ApprovedReg, true);
approved = rk.ToString();
rk.DeleteValue(type.GUID.ToString("B"));
rk.Close();
// Delete regkey
root = Registry.ClassesRoot;
contextMenu = Resources.ExShellReg;
root.DeleteSubKey(Resources.ExShellReg);
EventLog.WriteEntry("Application", "Example ShellExt Unregister Complete.\r\n" + approved + "\r\n" + contextMenu, EventLogEntryType.Information);
Helpers.SHChangeNotify(0x08000000, 0, IntPtr.Zero, IntPtr.Zero);
}
catch(Exception e)
{
EventLog.WriteEntry("Application", "Example ShellExt Unregister error.\r\n" + e.ToString(), EventLogEntryType.Error);
}
}
```
Функция удаления компонента, очищаем реестр от созданных ранее ключей.
Далее переходим к процессу реализации интерфейсных функций.Реализуем интерфейсы IShellExtInit, IContextMenu. Не буду детально описывать весь код этого класса, остановлюсь на реализации функций данных интерфейсов.
```
int IShellExtInit.Initialize (IntPtr pidlFolder, IntPtr lpdobj, uint hKeyProgID)
{
try
{
if (lpdobj != (IntPtr)0)
{
// Get info about the directory
IDataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(lpdobj);
FORMATETC fmt = new FORMATETC();
fmt.cfFormat = CLIPFORMAT.CF_HDROP;
fmt.ptd = 0;
fmt.dwAspect = DVASPECT.DVASPECT_CONTENT;
fmt.lindex = -1;
fmt.tymed = TYMED.TYMED_HGLOBAL;
STGMEDIUM medium = new STGMEDIUM();
dataObject.GetData(ref fmt, ref medium);
m_hDrop = medium.hGlobal;
}
}
catch(Exception)
{
}
return 0;
}
```
Функция инициализации компонента, запускается при открытии каталога или любого другого объекта, в контексте которого может находиться контекстное меню. Используем интерфейс IDataObject для получения данных о текущем объекте, в частности нас интересует hGlobal. Этот Handle идентифицирует текущий объект, внутри которого и происходит наше выполнение.
Далее рассмотрим функцию, которая вызывается при выпадении контекстного меню.
```
int IContextMenu.QueryContextMenu(uint hMenu, uint iMenu, int idCmdFirst, int idCmdLast, uint uFlags)
{
if ( (uFlags & 0xf) == 0 || (uFlags & (uint)CMF.CMF_EXPLORE) != 0)
{
uint nselected = Helpers.DragQueryFile(m_hDrop, 0xffffffff, null, 0);
if (nselected > 0)
{
for (uint i = 0; i < nselected; i++)
{
StringBuilder sb = new StringBuilder(1024);
Helpers.DragQueryFile(m_hDrop, i, sb, sb.Capacity + 1);
fileNames.Add(sb.ToString());
}
}
else
return 0;
```
В этом участке кода проверяем, что выполняемся в нужном контексте и пытаемся запросить количество выбранных в каталоге файлов, а так же сохранить список этих файлов. Также замечу, что при передаче iFile = 0xffffffff в функцию DragQueryFile она вернет количество файлов в каталоге.
```
// Add the popup to the context menu
MENUITEMINFO mii = new MENUITEMINFO();
mii.cbSize = 48;
mii.fMask = (uint) MIIM.ID | (uint)MIIM.TYPE | (uint) MIIM.STATE;
mii.wID = idCmdFirst;
mii.fType = (uint) MF.STRING;
mii.dwTypeData = Resources.MenuItem;
mii.fState = (uint) MF.ENABLED;
Helpers.InsertMenuItem(hMenu, (uint)iMenu, (uint)MF.BYPOSITION | (uint)MF.STRING, ref mii);
commands.Add(idCmdFirst);
System.Reflection.Assembly myAssembly = System.Reflection.Assembly.GetExecutingAssembly();
Stream myStream = myAssembly.GetManifestResourceStream(Resources.BitmapName);
Bitmap image = new Bitmap(myStream);
Color backColor = image.GetPixel(1, 1);
image.MakeTransparent(backColor);
Helpers.SetMenuItemBitmaps((IntPtr)hMenu, (uint)iMenu, (uint)MF.BYPOSITION, image.GetHbitmap(), image.GetHbitmap());
// Add a separator
MENUITEMINFO sep = new MENUITEMINFO();
sep.cbSize = 48;
sep.fMask = (uint )MIIM.TYPE;
sep.fType = (uint) MF.SEPARATOR;
Helpers.InsertMenuItem(hMenu, iMenu + 1, 1, ref sep);
}
return 1;
}
```
Здесь добавляем новый пункт меню при помощи вызова функции InsertMenuItem, затем подготавливаем и добавляем иконку к этому пункту меню, а так же разделительную линию для эстетической красоты. Структура MENUITEMINFO описывает наш пункт меню, а именно его тип (ftype), содержащиеся данные (dwTypeData), состояние (fState), идентификатор пункта меню (wID). Переменная hMenu идентифицирует текущее выпавшее меню, iMenu позиция по которой мы добавляемся. Для того, чтобы получить более полную информацию, можно обратиться в MSDN.
Далее рассмотрим функцию GetCommandString
```
void IContextMenu.GetCommandString(int idCmd, uint uFlags, int pwReserved, byte[] pszName, uint cchMax)
{
string commandString = String.Empty;
switch(uFlags)
{
case (uint)GCS.VERB:
commandString = "test";
break;
case (uint)GCS.HELPTEXTW:
commandString = "test";
break;
}
var buf = Encoding.Unicode.GetBytes(commandString);
int cch = Math.Min(buf.Length, pszName.Length - 1);
if (cch > 0)
{
Array.Copy(buf, 0, pszName, 0, cch);
}
else
{
// null terminate the buffer
pszName[0] = 0;
}
}
```
Данная функция возвращает независимое от языка описание команды, а так же краткую подсказку в виде helptext соответственно.
Ну и последняя функция, которая будет вызвана при выборе нашего пункта меню:
```
void IContextMenu.InvokeCommand (IntPtr pici)
{
try
{
System.Windows.Forms.MessageBox.Show("Test code");
}
catch(Exception exe)
{
EventLog.WriteEntry("Application", exe.ToString());
}
}
```
Тут все достаточно прозрачно.
Так как наш COM объект выполняется в контексте Windows Explorer, то для того чтобы его отлаживать, нам нужно подключаться к процессу explorer.exe. Для регистрации и удаления компонента Вы можете использовать bat файлы, поставляемые с исходниками к данной статье. Для регистрации мы используем RegAsm.exe утилиту, позволяющую COM клиентам использовать .net класс будто бы это COM, а также GacUtil для того, чтобы поместить сборку в GAC. После регистрации процесс explorer.exe будет перезапущен.
Так же обращу Ваше внимание на утилиту позволяющую просмотреть, а при необходимости и отредактировать все установленные в системе расширения Windows Explorer. Утилита называется ShellExView, скачать можно на сайте производителя [Nirsoft](http://www.nirsoft.net) или в приложении к статье.
Вот так выглядит наш компонент в ShellExView:
Так он выглядит при раскрытом контекстном меню:
Итак, мы рассмотрели пример разработки компонента расширяющего Windows Explorer, но данный вид расширения далеко не единственное, что мы можем изменять, и на что можем влиять.
Имея понимание того, как функционируют такого рода компоненты можно взглянуть на то, что уже было разработано сообществом и может быть использовано для облегчения выполнения таких операций.
Например, библиотека [SharpShell](http://sharpshell.codeplex.com/) позволяющая выполнять достаточно большой объем модификаций, а так же хорошо описанная в цикле статей [.NET Shell Extensions](http://www.codeproject.com/Articles/512956/NET-Shell-Extensions-Shell-Context-Menus) на CodeProject. В качестве аналога также можно использовать библиотеку [Windows Shell Framework](http://wsf.codeplex.com/) или библиотеку для связки ATL + С++ [Mini Shell Extension Framework](http://msf.codeplex.com/).
Также обращу Ваше внимание на предупреждение Microsoft относительно разработки таких вот расширений: “Не рекомендуется писать расширения оболочки в языках .NET, так как используется только одна среда выполнения CLR для одного процесса, поэтому может возникнуть конфликт между двумя расширениями оболочки, использующими разные версии CLR. Однако .Net Framework 4 поддерживает технологию side-by-side для версий .Net Framework 2.0, 3.0, 3.5 и позволяет в одном и том же процессе использовать как старую CLR 2, так и новую CLR 4”.
Подробнее почитать про ограничения использования .net при разработке Shell Extensions можно здесь: [Guidance for Implementing In-Process Extensions](http://msdn.microsoft.com/en-us/library/windows/desktop/dd758089%28v=vs.85%29.aspx)
**Еще посмотреть:**
[Explorer column handler shell extension in C#](http://www.codeproject.com/Articles/3747/Explorer-column-handler-shell-extension-in-C)
[Creating Shell Extension Handlers](http://msdn.microsoft.com/en-us/library/windows/desktop/cc144067%28v=vs.85%29.aspx)
Исходники и утилиты: [ExampleShell.rar](https://dl.dropboxusercontent.com/u/69198982/ExampleShell.rar)
P.S Расширение не тестировал на Windows 8, судя по отзывам, для корректной работы в реестре нужно установить в разделе HKEY\_CLASSES\_ROOT\CLSID\{guid компонента}\InprocServer32 следующее значение ThreadingModel = Apartment.
Спасибо за внимание! | https://habr.com/ru/post/177469/ | null | ru | null |
# ARM-ы для самых маленьких: тонкости компиляции и компоновщик
Продолжая серию статей про разработку с нуля для ARM, сегодня я затрону тему написания скриптов компоновщика для GNU *ld*. Эта тема может пригодиться не только тем, кто работает со встраиваемыми системами, но и тем, кто хочет лучше понять строение исполняемых файлов. Хотя примеры так или иначе основаны на тулчейне arm-none-eabi, суть компоновки та же и у компоновщика Visual Studio, например.
Предыдущие статьи:
* [ARM-ы для самых маленьких](http://habrahabr.ru/post/189484/)
* [ARM-ы для самых маленьких: который час?](http://habrahabr.ru/post/190032/)
Примеры кода из статьи: <https://github.com/farcaller/arm-demos>
Когда мы компилируем исходный файл, на выходе мы получаем файл объектный, который типично содержит в себе несколько секций с данными. Четыре самые распространенные секции это:
* **.text** — скомпилированный машинный код;
* **.data** — глобальные и статические переменные;
* **.rodata** — аналог `.data` для неизменяемых данных;
* **.bss** — глобальные и статические переменные, которые при старте содержат нулевое значение.
В бинарных файлах, с которыми мы работаем в рамках этого цикла, будут часто попадаться еще две секции:
* **.comment** — информация о версии компилятора;
* **.ARM.attributes** — ARM-специфичные атрибуты файла.
Помимо секций, в объектном файле есть еще одна важная сущность: таблица символов. Это своего рода хеш: имя — адрес (и дополнительные атрибуты). В таблице символов, например, указаны все экспортируемые функции и их адреса (которые будут указывать куда-то в секцию .text).
После того, как у нас получилось несколько таких файлов, за дело берется компоновщик, который по заданным правилам соберет все секции, выбросит ненужные и сделает итоговый исполняемый файл. Для «стандартных» ОС определены правила, где что должно находиться, но в случае микроконтроллеров нам обычно нужно заниматься распихиванием всего по флешу и оперативной памяти вручную.
#### Заглянем внутрь
В качестве первого примера мы изучим следующий код на C: `module_a.c`:
```
static int local_function();
int external_counter;
static int counter;
static int preset_counter = 5;
const int constant = 10;
int public_function()
{
volatile int i = 3 + constant;
++external_counter;
return local_function() * i;
}
static int local_function()
{
++counter;
++preset_counter;
return counter + preset_counter;
}
```
Скомпилируем его и посмотрим, какие секции мы получили:
```
% rake 'show:sections[a]'
arm-none-eabi-gcc -mthumb -O2 -mcpu=cortex-m0 -c module_a.c -o build/module_a.o
arm-none-eabi-objdump build/module_a.o -h
build/module_a.o: file format elf32-littlearm
Sections:
Idx Name Size VMA LMA File off Algn
0 .text 00000034 00000000 00000000 00000034 2**2
CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
1 .data 00000004 00000000 00000000 00000068 2**2
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000004 00000000 00000000 0000006c 2**2
ALLOC
3 .rodata 00000004 00000000 00000000 0000006c 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
4 .comment 00000071 00000000 00000000 00000070 2**0
CONTENTS, READONLY
5 .ARM.attributes 00000031 00000000 00000000 000000e1 2**0
CONTENTS, READONLY
```
Как мы видим — шесть секций, назначение которых нам уже более-менее известно. Второй строкой идут атрибуты секции, они будут интереснее позднее, при компоновке. Посмотрим, какие символы определены в этих секциях:
```
% rake 'show:symbols:text[a]'
arm-none-eabi-objdump build/module_a.o -j .text -t
build/module_a.o: file format elf32-littlearm
SYMBOL TABLE:
00000000 l d .text 00000000 .text
00000000 g F .text 00000034 public_function
```
Откроем man по objdump для консультации. В этой секции мы видим два символа: `.text` — это отладочный символ, который указывает на начало секции, `public_function` — это символ, который указывает на нашу функцию. Для `local_function` символа нет, так как функция объявлена как `static`, т.е., она не экспортируется за пределы объектного файла.
```
% rake 'show:symbols:data[a]'
arm-none-eabi-objdump build/module_a.o -j .data -j .bss -t
build/module_a.o: file format elf32-littlearm
SYMBOL TABLE:
00000000 l d .data 00000000 .data
00000000 l d .bss 00000000 .bss
00000000 l O .data 00000004 preset_counter
00000000 l O .bss 00000004 counter
```
В секциях `.data` и `.bss` находится два из наших счетчиков — `preset_counter` и `counter`. Они находятся в разных секциях, так как у `preset_counter` есть начальное значение, которое и сохранено в `.data`:
```
% rake 'show:contents[a,.data]'
arm-none-eabi-objdump build/module_a.o -j .data -s
build/module_a.o: file format elf32-littlearm
Contents of section .data:
0000 05000000
```
У `counter` значения нет, так что он инициализируется в ноль и попадает в секцию `.bss`. Сама секция `.bss` физически в файле не присутствует, так как ее содержимое всегда фиксировано, — это нули. Если бы вы объявили `char buffer[1024]` в коде, то компилятору пришлось бы записать в объектный файл килобайт пустого места, что лишено смысла.
В этот момент у вас может появится вопрос — куда пропал `external_counter`?
```
% rake 'show:symbols:all[a]'
arm-none-eabi-objdump build/module_a.o -t
build/module_a.o: file format elf32-littlearm
SYMBOL TABLE:
00000000 l df *ABS* 00000000 module_a.c
00000000 l d .text 00000000 .text
00000000 l d .data 00000000 .data
00000000 l d .bss 00000000 .bss
00000000 l d .rodata 00000000 .rodata
00000000 l O .data 00000004 preset_counter
00000000 l O .bss 00000004 counter
00000000 l d .comment 00000000 .comment
00000000 l d .ARM.attributes 00000000 .ARM.attributes
00000000 g F .text 00000034 public_function
00000004 O *COM* 00000004 external_counter
00000000 g O .rodata 00000004 constant
```
`external_counter` отправился в секцию `*COM*`. В данном случае это означает, что он, возможно, находится за пределами этого объектного файла. Уже на этапе компоновки *ld* будет разбираться, объявлен ли символ в другом файле, или ему следует создать его самому — в данном случае, в секции `.bss`. Также обратите внимание на то, что `const int constant` попал в `.rodata`. Компилятор гарантирует, что коду не понадобится изменять значение по этому адресу, так что компоновщик может спокойно разместить его во флеш-памяти.
Мы можем посмотреть на `.comment`:
```
% rake 'show:contents[a,.comment]'
arm-none-eabi-objdump build/module_a.o -j .comment -s
build/module_a.o: file format elf32-littlearm
Contents of section .comment:
0000 00474343 3a202847 4e552054 6f6f6c73 .GCC: (GNU Tools
0010 20666f72 2041524d 20456d62 65646465 for ARM Embedde
0020 64205072 6f636573 736f7273 2920342e d Processors) 4.
0030 372e3320 32303133 30333132 20287265 7.3 20130312 (re
0040 6c656173 6529205b 41524d2f 656d6265 lease) [ARM/embe
0050 64646564 2d345f37 2d627261 6e636820 dded-4_7-branch
0060 72657669 73696f6e 20313936 3631355d revision 196615]
0070 00
```
Тут действительно записана версия компилятора. Также мы можем заглянуть в `.ARM.attributes`, правда для этого стоит задействовать уже не *objdump*, а *readelf*:
```
% rake 'show:attrs[a]'
arm-none-eabi-readelf build/module_a.o -A
Attribute Section: aeabi
File Attributes
Tag_CPU_name: "Cortex-M0"
Tag_CPU_arch: v6S-M
Tag_CPU_arch_profile: Microcontroller
Tag_THUMB_ISA_use: Thumb-1
Tag_ABI_PCS_wchar_t: 4
Tag_ABI_FP_denormal: Needed
Tag_ABI_FP_exceptions: Needed
Tag_ABI_FP_number_model: IEEE 754
Tag_ABI_align_needed: 8-byte
Tag_ABI_align_preserved: 8-byte, except leaf SP
Tag_ABI_enum_size: small
Tag_ABI_optimization_goals: Aggressive Speed
```
Документацию по публичным тегам можно посмотреть на [инфоцентре ARM](http://infocenter.arm.com/help/topic/com.arm.doc.ihi0045d/IHI0045D_ABI_addenda.pdf).
#### Собираем все в кучу
Теперь, когда мы заглянули внутрь объектных файлов, давайте разберемся, как *ld* собирает их в одно успешное приложение.
Основная работа *ld* вертится вокруг карты памяти, которую мы видели в первой части. Если сильно упростить, компоновка — это процесс выдирания секций из объектных файлов, раскладывание их по указанным адресам и исправление перекрестных ссылок. В «стандартных» ОС ядро умеет читать выходной файл и загружать секции в память по ожидаемым виртуальным адресам. Также динамический компоновщик выполняет схожую работу, догружая в определенные места памяти внешние библиотеки и настраивая на них перекрестные ссылки.
Со встраиваемыми системами проще, программа для прошивки берет ваш бинарный файл и заливает на флешку как есть. Его не волнуют ни мачо, ни эльфы, он работает с бинарными дампами.
Возьмем простой сценарий компоновщика и разберем по кусочкам. `layout.ld:`
```
MEMORY
{
rom(RX) : ORIGIN = 0x00000000, LENGTH = 0x8000
ram(WAIL) : ORIGIN = 0x10000000, LENGTH = 0x2000
}
ENTRY(public_function)
SECTIONS
{
.text : { *(.text) } > rom
_data_start = .;
.data : { *(.data) } > ram AT> rom
_bss_start = .;
.bss : { *(.bss) } > ram
_bss_end = .;
}
```
Конфигурация компоновщика по умолчанию позволяет ему использовать всю доступную память (где-то около 0xFFFFFFFF байт в случае 32-битного ARM). Начнем с того, что определим регионы памяти, которые можно использовать: `rom` и `ram`. Буквы в скобках определяют атрибуты: доступ на чтение, запись, исполнение, выделение памяти. Секции, которые явно не указаны в сценарии, будут раскиданы по регионам с подходящими атрибутами автоматически. Если для секции не найдется места, компоновщик откажется работать, аргументируя свое поведение как-то так: `error: no memory region specified for loadable section `.data'`.
Два параметра, `ORIGIN` и `LENGTH`, задают начало и длину региона соответственно, еще можно встретить варианты `org`, `o`, `len` и `l`, они эквивалентны. Значение — это выражение, т.е., в нем можно выполнять арифметические операции или использовать суффиксы `K`, `M`, и т.п. Запись `LENGTH = 0x8000`, например, можно альтернативно выполнить так: `l = 32K`.
Вторая часть файла — конфигурация секций. В целом, это означает копирование ~~из одних протобафов в другие протобафы~~ заданных исходных секций в выходные секции.
Исходные секции задаются в форме `ИМЯ_ФАЙЛА(ИМЯ_СЕКЦИИ)`, символ `*` ведет себя стандартным образом, так что запись `*(.text)` означает: секции `.text` из всех файлов.
У секции есть два адреса: LMA (Load Memory Address) — откуда она загружается, и VMA (Virtual Memory Address) — по какому адресу она доступна в виртуальной памяти. Объясняя проще, LMA — это где она окажется в бинарном файле, а VMA — это куда будут перенаправлены символы, т.е., указатель на символ в коде будет ссылаться на VMA-адрес.
Нас интересуют три секции — код, данные и данные, которые нулевые по умолчанию. Таким образом, мы копируем код (`.text`) во флеш-память, данные (`.data`) – во флеш-память, но из расчета, что они будут доступны в оперативной памяти, и `.bss` — в оперативную память.
Для `.bss`, в общем случае, инициализация не требуется (**UPD**: мне тут подсказывают в жаббере, что таки требуется, мы должны гарантировать что там нули, а не мусор, который появился по какой-либо причине), так как при старте микроконтроллера оперативная память и так, вероятно, обнулена. Но вот с `.data` придется повозиться отдельно, проблема из-за двоякой натуры. С одной стороны, там хранятся конкретные данные (стартовое значение `preset_counter`), так что она должна быть во флеш-памяти. С другой стороны, это секция, доступная на запись, так что она должна быть в оперативной памяти. Эта проблема решается разными LMA и VMA, а также дополнительным кодом на C, который при запуске будет копировать содержимое из LMA в VMA. Для константных данных, которые обычно находятся в секции `.rodata`, такая процедура, например, не нужна, мы можем спокойно читать из прямо из флеш-памяти.
У компоновщика есть понятие курсора — это текущий LMA. В начале блока SECTIONS курсор равен нулю и постепенно увеличивается по мере добавления новых секций. Текущее значение курсора хранится в переменной `.` (точка).
Давайте запустим компоновщик и посмотрим результат его работы:
```
% rake 'show:map[a]'
arm-none-eabi-ld -T layout.ld -M -o build/out.elf build/module_a.o
Allocating common symbols
Common symbol size file
external_counter 0x4 build/module_a.o
Memory Configuration
Name Origin Length Attributes
rom 0x0000000000000000 0x0000000000008000 xr
ram 0x0000000010000000 0x0000000000002000 awl
*default* 0x0000000000000000 0xffffffffffffffff
```
Во-первых, мы видим, как компоновщик выносит в отдельную категорию «общий» символ `external_counter`. Далее мы видим, что наша конфигурация памяти была загружена и добавлена к конфигурации по умолчанию (которая выделяет все адресное пространство).
```
Linker script and memory map
.text 0x0000000000000000 0x34
*(.text)
.text 0x0000000000000000 0x34 build/module_a.o
0x0000000000000000 public_function
0x0000000000000034 _data_start = .
```
Далее компоновщик размещает в памяти секции, которые мы указали, в первую очередь `.text`.
```
.rodata 0x0000000000000034 0x4
.rodata 0x0000000000000034 0x4 build/module_a.o
0x0000000000000034 constant
.glue_7 0x0000000000000038 0x0
.glue_7 0x0000000000000000 0x0 linker stubs
.glue_7t 0x0000000000000038 0x0
.glue_7t 0x0000000000000000 0x0 linker stubs
.vfp11_veneer 0x0000000000000038 0x0
.vfp11_veneer 0x0000000000000000 0x0 linker stubs
.v4_bx 0x0000000000000038 0x0
.v4_bx 0x0000000000000000 0x0 linker stubs
.iplt 0x0000000000000038 0x0
.iplt 0x0000000000000000 0x0 build/module_a.o
.rel.dyn 0x0000000000000038 0x0
.rel.iplt 0x0000000000000000 0x0 build/module_a.o
```
Следом идут секции, которые мы не указывали явно — `.rodata`, `.glue_7`, `.glue_7t`, `.vfp11_veneer`, `.v4_bx`, `.iplt`, `.rel.dyn`. С `.rodata` все понятно, там в четырех байтах хранится наша константа `constant`. Что касается остальных секций, то их существование обязано всяческой поддержке работоспособности, например, трамплинам из ARM в Thumb. Все эти секции **пустые** и не попадают в итоговый образ.
```
.data 0x0000000010000000 0x4 load address 0x0000000000000038
*(.data)
.data 0x0000000010000000 0x4 build/module_a.o
0x0000000010000004 _data_end = .
```
Вот и наша секция `.data`, как видите, она находится по адресу `0x10000000`, хотя физически хранится по адресу `0x38` (т.е., сразу после `.rodata`). Тут же мы видим значение нашей переменной, прочитанной из курсора, `_data_end`.
```
.igot.plt 0x0000000010000004 0x0 load address 0x000000000000003c
.igot.plt 0x0000000000000000 0x0 build/module_a.o
.bss 0x0000000010000004 0x8 load address 0x000000000000003c
*(.bss)
.bss 0x0000000010000004 0x4 build/module_a.o
COMMON 0x0000000010000008 0x4 build/module_a.o
0x0000000010000008 external_counter
0x000000001000000c _bss_end = .
```
Еще одна пустая секция, следом за ней — `.bss`.
```
LOAD build/module_a.o
OUTPUT(build/out.elf elf32-littlearm)
.comment 0x0000000000000000 0x70
.comment 0x0000000000000000 0x70 build/module_a.o
0x71 (size before relaxing)
.ARM.attributes
0x0000000000000000 0x31
.ARM.attributes
0x0000000000000000 0x31 build/module_a.o
```
Наконец, *ld* генерирует выходной файл и выбрасывает ненужные секции. Вроде все?
```
0x0000000000000034 _data_start = .
...
.data 0x0000000010000000 0x4 load address 0x0000000000000038
```
Переменная, указывающая на начало `.data`, на самом деле указывает совсем не туда! А ведь и правда, курсор после `.text` указывает на его конец. Для правильной установки переменной ее надо перенести внутрь описания выходной секции:
```
.data :
{
_data_start = .;
*(.data)
_data_end = .;
} > ram AT> rom
```
Скомпонуем и посмотрим что изменилось:
```
% rake 'show:map[a]' SCRIPT=layout2.ld
arm-none-eabi-ld -T layout2.ld -M -o build/module_a.elf build/module_a.o
...
.data 0x0000000010000000 0x4 load address 0x0000000000000038
0x0000000010000000 _data_start = .
*(.data)
.data 0x0000000010000000 0x4 build/module_a.o
0x0000000010000004 _data_end = .
...
```
Отлично, теперь все на месте.
Вы можете задаться вопросом — а какое нам дело, где находится `.data`? Как вы помните, данные физически хранятся во флеше, а работать с ними предстоит из оперативной памяти. По этой причине нам придется написать загрузочный код, который будет копировать `.data` в оперативную память, а эти переменные помогут нам узнать конкретные адреса, куда надо переносить секцию.
#### Усложним задачу
С одним модулем мы разобрались. Давайте добавим второй файл и посмотрим что поменяется. Второй файл будет содержать уже известный нам `external_counter` и немного кода на C++: `module_b.cpp`
```
int external_counter;
extern "C" int public_function();
void function_b()
{
external_counter += public_function();
}
void function_c()
{
}
void function_d()
{
}
```
Как вы знаете, при компиляции кода на C++ имена функций и методов проходят «манглинг», когда в имени кодируются типы аргументов, имена классов и пространств имен:
```
% rake 'show:symbols:text[b]'
arm-none-eabi-gcc -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -mthumb -O2 -mcpu=cortex-m0 -c module_b.cpp -o build/module_b.o
arm-none-eabi-objdump build/module_b.o -j .text -t
build/module_b.o: file format elf32-littlearm
SYMBOL TABLE:
00000000 l d .text 00000000 .text
00000000 g F .text 00000014 _Z10function_bv
00000014 g F .text 00000002 _Z10function_cv
00000018 g F .text 00000002 _Z10function_dv
```
Мы компилируем код с флагами `-fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables`, чтобы избежать появления дополнительных секций, связанных с обработкой исключительных ситуаций. Имена функций были закодированы соответствующим образом.
Мы не можем сгенерировать карту для этого модуля, так как его нельзя скомпоновать самостоятельно, он зависит от функции `public_function` из модуля `a`. Компонуем оба модуля сразу:
```
% rake 'show:map[a|b]' SCRIPT=layout2.ld
arm-none-eabi-ld -T layout2.ld -M -o build/out.elf build/module_a.o build/module_b.o
...
.text 0x0000000000000000 0x34 build/module_a.o
0x0000000000000000 public_function
.text 0x0000000000000034 0x1c build/module_b.o
0x0000000000000034 function_b()
0x0000000000000048 function_c()
0x000000000000004c function_d()
...
```
Блок общих символов пропал, все символы найдены в соответствующих модулях. Секции `.text`, равно как и остальные, компонуются друг за другом.
#### Соберем мусор!
Для встраиваемых приложений размер выходного файла как никогда актуален, потому стоит позаботиться о том, чтобы максимальное количество ненужных данных и мертвого кода было удалено. Компоновщик в состоянии избавиться от секций, на которые никто не ссылается и которые не были явно указаны как необходимые в сценарии компоновки. Делается это достаточно просто — с помощью флага `--gc-sections`:
```
% rake 'show:map[a|b]' SCRIPT=layout2.ld GC=1
arm-none-eabi-ld --gc-sections -T layout2.ld -M -o build/out.elf build/module_a.o build/module_b.o
Discarded input sections
.rodata 0x0000000000000000 0x4 build/module_a.o
COMMON 0x0000000000000000 0x0 build/module_a.o
.text 0x0000000000000000 0x1c build/module_b.o
.data 0x0000000000000000 0x0 build/module_b.o
...
.text 0x0000000000000000 0x34
*(.text)
.text 0x0000000000000000 0x34 build/module_a.o
0x0000000000000000 public_function
...
```
Как видите, секция `.text` из `build/module_b.o` была удалена полностью, так как содержала бесполезные функции! Заодно компоновщик выбросил неиспользуемые константы из первого модуля.
На самом деле, эта оптимизация не полная, в чем мы легко можем убедиться с помощью несложного эксперимента, см. `module_c.cpp`
```
void function_b();
extern "C" int public_function()
{
function_b();
}
```
Мы заменим модуль `a` на модуль `c` и посмотрим, сможет ли компоновщик удалить секцию.
```
% rake 'show:map[b|c]' SCRIPT=layout2.ld GC=1
arm-none-eabi-gcc -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -mthumb -O2 -mcpu=cortex-m0 -c module_c.cpp -o build/module_c.o
arm-none-eabi-ld --gc-sections -T layout2.ld -M -o build/out.elf build/module_b.o build/module_c.o
Discarded input sections
.data 0x0000000000000000 0x0 build/module_b.o
.data 0x0000000000000000 0x0 build/module_c.o
.bss 0x0000000000000000 0x0 build/module_c.o
...
.text 0x0000000000000000 0x24
*(.text)
.text 0x0000000000000000 0x1c build/module_b.o
0x0000000000000000 function_b()
0x0000000000000014 function_c()
0x0000000000000018 function_d()
.text 0x000000000000001c 0x8 build/module_c.o
0x000000000000001c public_function
```
Хотя часть секций (впрочем, пустых) выбросить удалось, но мы все еще теряем бесценные байты на функции `function_c()` и `function_d()`, которые оказались в той же секции, что и `function_b()`, которая нам нужна. На помощь придут флаги компилятора, которые разбивают функции и данные в разные секции: `-ffunction-sections` и `-fdata-sections`:
```
% rake clean && rake 'show:symbols:all[b]' SPLIT_SECTIONS=1
arm-none-eabi-gcc -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -ffunction-sections -fdata-sections -mthumb -O2 -mcpu=cortex-m0 -c module_b.cpp -o build/module_b.o
arm-none-eabi-objdump build/module_b.o -t
build/module_b.o: file format elf32-littlearm
SYMBOL TABLE:
00000000 l df *ABS* 00000000 module_b.cpp
00000000 l d .text 00000000 .text
00000000 l d .data 00000000 .data
00000000 l d .bss 00000000 .bss
00000000 l d .text._Z10function_bv 00000000 .text._Z10function_bv
00000000 l d .text._Z10function_cv 00000000 .text._Z10function_cv
00000000 l d .text._Z10function_dv 00000000 .text._Z10function_dv
00000000 l d .bss.external_counter 00000000 .bss.external_counter
00000000 l d .comment 00000000 .comment
00000000 l d .ARM.attributes 00000000 .ARM.attributes
00000000 g F .text._Z10function_bv 00000014 _Z10function_bv
00000000 *UND* 00000000 public_function
00000000 g F .text._Z10function_cv 00000002 _Z10function_cv
00000000 g F .text._Z10function_dv 00000002 _Z10function_dv
00000000 g O .bss.external_counter 00000004 external_counter
```
Теперь, когда каждая функция и объект помещены в независимые секции, компоновщик может от них избавиться:
```
% rake clean && rake 'show:map[b|c]' SCRIPT=layout2.ld GC=1 SPLIT_SECTIONS=1
arm-none-eabi-gcc -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -ffunction-sections -fdata-sections -mthumb -O2 -mcpu=cortex-m0 -c module_b.cpp -o build/module_b.o
arm-none-eabi-gcc -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -ffunction-sections -fdata-sections -mthumb -O2 -mcpu=cortex-m0 -c module_c.cpp -o build/module_c.o
arm-none-eabi-ld --gc-sections -T layout2.ld -M -o build/out.elf build/module_b.o build/module_c.o
Discarded input sections
.text 0x0000000000000000 0x0 build/module_b.o
.data 0x0000000000000000 0x0 build/module_b.o
.bss 0x0000000000000000 0x0 build/module_b.o
.text._Z10function_cv
0x0000000000000000 0x4 build/module_b.o
.text._Z10function_dv
0x0000000000000000 0x4 build/module_b.o
.text 0x0000000000000000 0x0 build/module_c.o
.data 0x0000000000000000 0x0 build/module_c.o
.bss 0x0000000000000000 0x0 build/module_c.o
...
```
#### Вместо заключения
И снова объем статьи растет, теперь он в два раза больше первой части. К сожалению, компоновка — это сложная тема, и ее сложно осилить «влет». Через неделю мы продолжим изучение компоновщика и сделаем полноценный сценарий компоновки для наших встраиваемых приложений.
P.S. Как всегда, большое спасибо [pfactum](https://habrahabr.ru/users/pfactum/) за вычитку текста.
###### [Лицензия Creative Commons](http://creativecommons.org/licenses/by-nc-nd/3.0/deed.ru) Это произведение доступно по [лицензии Creative Commons «Attribution-NonCommercial-NoDerivs» 3.0 Unported](http://creativecommons.org/licenses/by-nc-nd/3.0/deed.ru). Программный текст примеров доступен по [лицензии Unlicense](http://unlicense.org) (если иное явно не указано в заголовках файлов). Это произведение написано исключительно в образовательных целях и никаким образом не аффилировано с текущим или предыдущими работодателями автора. | https://habr.com/ru/post/191058/ | null | ru | null |
# Принципы домашнего танкостроения
Хотели бы свой дистанционно управляемый танк? В этой статье я расскажу про общие принципы танкостроения из доступных материалов.
Я опишу процесс создания танка с камерой который управляется со смартфона по Wi-Fi. В ходе статьи я буду так же описывать и альтернативные решения, чтобы вы имея теоретическую базу могли создать что-то свое.
Эта статья рассчитана на людей, которые не имеют большого опыта в электронике, но очень хотят попробовать. Некоторые мои решения нельзя назвать правильными, из-за моей неопытности или просто потому, что мне так захотелось. Главная идея, которую я хочу донести – это то, что бы вы не повторяли как я, а делали свое уникальное на основе прочитанного здесь. Я буду показывать на примере своего танка, но изложенные тут принципы можно применять при создании другой подобной дистанционно управляемой техники.
**Материалы и компоненты, которые я использовал:**
* Корпус от игрушечного танка.
* Модуль ESP-32-Cam – контроллер для Wi-Fi и камера.
* Arduino Nano – контроллер для датчиков и управления движением.
* L298N – драйвер для двигателя.
* Набор датчиков – ультразвуковой дальномер; барометр; акселерометр и гироскоп; термометр и гигрометр; датчик Холла.
* Два литиевых аккумулятора, повышающий преобразователь, зарядная плата.
* Android смартфон с управляющим приложением.
Статья получилась довольно большая, но она поделена на разделы, которые соответствуют каждой части устройства или функциональному предназначению. В этих частях вначале будет теория, потом мой опыт и какие-то рекомендации. В конце статьи фото и видео демонстрация.
**Разделы статьи:**
* [Корпус и шасси](#1).
* [Система электропитания](#2).
* [Микроконтроллеры](#3).
* [Программное обеспечение (прошивка)](#4).
* [Коммуникации](#5).
* [Датчики](#6).
* [Исполнительные механизмы](#7).
*Часть своих мыслей я буду прятать под спойлер. Там я буду описывать то, без чего я считаю можно обойтись, но любознательные могут почитать.*
Любая техника состоит из множества компонентов, необходимо разложить то, что вы собираетесь делать на составные части, каждая из которых выполняет определенную функцию. Тогда вы будете легко ориентироваться в структуре вашего устройства, понимать, что за что отвечает и с меньшими затратами исправлять ошибки в процессе отладки. Ниже пример разложения моего танка на компоненты.
Корпус и шасси
--------------
От выбранного корпуса зависит что и как вы сможете разместить, а от шасси зависит проходимость и быстроходность. Например, если вы хотите весело гонять на улице вам стоит выбрать шасси с большим клиренсом и желательно с какой никакой, но системой подвески, если же ваша техника будет ездить исключительно по ровным полам вашего дома и без преодоления таких сложных противотанковых препятствий как махровые ковры, то вы можете не заморачиваться – подойдет любое шасси.
Скорее всего вы будете создавать такое устройство, в котором будут использоваться редукторы (набор шестеренок, которые меняют обороты на усилие и наоборот) учитывайте, что они могут довольно сильно шуметь. Моторы часто продаются в паре с редукторами и найти мотор подходящих вам характеристик для достижения необходимой динамики не сложно.
Старайтесь все что вы размещаете на корпусе закреплять при помощи надежных, но разборных соединений – что-то вроде болта с гайкой. Это убережет вас от случайных поломок и даст вам необходимую гибкость для полета вашей фантазии в размещении элементов.
В своем танке я взял корпус от игрушечного танка, отфрезеровав внутри все что было лишним, для увеличения полезного объема. Все ненужные отверстия залил термоклеем (на улице это полезно – меньше набивается всякой пыли и воды). Редуктор оставил родным, но один из двигателей пришлось заменить, так как оказалось он не имел совместимости со случайно слетевшей фрезой.
Для удобства доступа (и для красоты) я сделал верхнюю часть корпуса в виде откидной металлической крышки, на которой размещаются основные блоки танка. Под крышкой находится моторное отделение – два мотора + редукторы и батарейный отсек с двумя аккумуляторами. Сама крышка вырезана из куска метала от автомагнитолы и покрашена в черный цвет, петля обычная – мебельная (возможно, брутальное решение, но я так и хотел).
Корпус для ESP-32-Cam (белая коробка с антенной) – это перевернутый корпус от инфракрасного датчика движения (BV-201). Он достаточно просторный и разделяется на две части, что позволяет легко в нем что-то менять.
При креплении всех плат я использовал нейлоновые стойки M3 – если у вас не какая-то «дикая машина», которая требует большой прочности, я рекомендую использовать именно нейлоновые стойки, а не металлические, так как их легко подрезать/подпилить, и они являются диэлектриком, что иногда может быть полезно.
Учитывая неадекватные цены на готовые шасси/корпуса для самоделок, самым дешевым решением будет взять уже готовую игрушечную модель, при покупке которой вы получите: корпус, двигатели и шасси. Так вы сможете быстро сделать прототип и впоследствии легко что-либо поменять. Имея опыт построения прототипа, вы будете уже знать чего хотите и как этого достичь.
Система электропитания (бортовая сеть)
--------------------------------------
От этой системы зависит надежность вашей техники и продолжительность ее автономной работы.
В зависимости от сценария использования (температура, напряжение, ток, безопасность) вашего устройства вам могут понадобиться различные типы аккумуляторов. В интернете довольно много информации по аккумуляторам, поэтому я не буду на них заострять внимание. Скорее всего, это будут литиевые аккумуляторы: Li-Ion или Li-Po.
При подборе аккумуляторов необходимо определиться с потребностями вашей машины – номинальное напряжение и максимальный ток потребителей: двигатели, микроконтроллеры, датчики и другое. К максимальному току прибавьте хотя бы 30% запаса на случай модернизации или ошибки при расчетах.
Зная ток вашей нагрузки, вы можете определится с формфактором и количеством аккумуляторов (не забывайте, что есть аккумуляторы повышенной токоотдачи).
Сформировать нужное бортовое напряжение вы можете комбинацией нескольких аккумуляторов (учитывайте, что по мере разряда аккумуляторы будут снижать напряжение) или же подключить между аккумуляторами и нагрузкой DC-DC преобразователь – который повысит или понизит напряжение до необходимого уровня и будет его удерживать на всем рабочем диапазоне аккумуляторов.
Маленькие советы по бортовой сетиНе стоит подключать аккумуляторы методом «запаивания намертво», лучше соединить их при помощи разъемов или батарейных отсеков, так вы получите возможность легкой замены и обслуживания аккумуляторов и на время хранения сможете доставать аккумуляторы – для безопасности (Li-ion загораются так же эффективно, как и отдают энергию).
Учитывайте, что на платах с микроконтроллерами могут быть встроены стабилизаторы. Иногда есть смысл подключить плату в обход стабилизатора – тем самым обеспечив стабильное питание, а иногда через стабилизатор – возможно упростив схему, но учитывайте, что встроенные стабилизаторы могут иметь не самые лучшие характеристики.
По возможности изолируйте электрические контакты для защиты от короткого замыкания. Замыкание на неизолированном контакте – это самый простой и неприятный способ уничтожить то, что вы делаете.
Для защиты аккумуляторов и остальных компонентов желательно использовать плату контроллера батареи (BMS) – она подключается в разрыв между батареей и нагрузкой, обеспечивая защиту от короткого замыкания (КЗ), ограничивая диапазон напряжений и защищая от аварийных ситуаций. Не забывайте обращать внимание на максимальный ток, который может пропустить через себя BMS до отключения нагрузки. Также эти платы могут иметь возможность зарядки батареи.
Вы должны обеспечить стабильное питание всего устройства в любых, даже самых худших условиях. Когда все включено на максимум, напряжение не должно проседать до того уровня, при котором будут глюки или перезагрузки.
Достичь стабильности электропитания можно несколькими способами:
* Создать такие условия, при которых будет невозможно использовать энергии больше, чем устройство способно себе предоставить – например программной защитой или физическим ограничением.
* Разделить питание для силовой части – моторы и мощные потребители отдельно от интеллектуальной части – микроконтроллеры, датчики. Таким образом, при просадке напряжения в силовой части, например, из-за заклинившего мотора, вы убережетесь от просадки напряжения для вашего управления – микроконтроллеров.
* Обеспечить какую-то кратковременную защиту от просадки напряжения, это может помочь в большинстве случаев и легко в реализации. Примером может быть конденсатор по питанию для микроконтроллера.
Главная идея в том, что просадка напряжения не так страшна для исполнительных механизмов типа моторов или манипуляторов, как для микроконтроллеров, поскольку это значит потерю управления над всей машиной, со всеми последствиями...
Потребление тока моего танка составляет примерно такие значения:
| | |
| --- | --- |
| **Компонент** | **Ток, мА** |
| ESP-32-Cam | 350 |
| Arduino Nano | 25 |
| Датчики | 25 |
| Двигатели x2 | 600-1200 mA; >2A в режиме заклинивание |
| **Сумма:** | 1600 |
Из значений выше видно, что самым большим потребителем являются двигатели, у которых, к тому же, неравномерный расход энергии в зависимости от местности, по которой едет танк.
Танковая батарея состоит из пары дешевых литиевых аккумуляторов Westinghouse INR18650 2000мА\*ч, 20А. Дальше батарея подключается к повышающему DC-DC преобразователю MT3608, который формирует стабильные 5.1В для бортовой сети. Запас 0.1В нужен для уменьшения влияния просадки напряжения на проводах и диодах.
Аккумуляторы подключаются параллельно к плате зарядки. Хотя она может выполнять роль BMS, я подключил плату в обход, потому что она рассчитана всего лишь на ток в 1А, то есть будет отключаться при рабочем режиме танка.
На входе DC-DC преобразователя стоит конденсатор, который немного уменьшает эффект резких просадок напряжения от работы двигателей в момент переходных процессов или заклинивания. Рядом установлен светодиод, который является индикатором роботы танка – очень полезная штука, чтобы всегда видеть, что устройство включено.
Все подключаемое оборудование на танке питается от 5В, которые выходят от стабилизатора. Те датчики, которым требуется 3.3В, ввиду их малого потребления питаются от стабилизатора на Arduino Nano. На плате с ESP-32 имеется стабилизатор, который преобразует входные 5В в необходимые для ESP 3.3В.
Возле входа питающего напряжения на платах Arduino и ESP стоят электролитические конденсаторы с запирающим их диодом. Из-за диодов снижается напряжение питания, например для ESP пришлось использовать диод Шоттки (из-за его малого падения напряжения). Но зато эта небольшая емкость конденсаторов обеспечивает питание микроконтроллеров в кратковременных просадках питания при работе двигателей, или по мере того, как разряжаются аккумуляторы. Без этого они бы зависли намертво или перезагружались. Данная мера позволила расширить время автономной работы танка примерно на 40%.
На двигателях стоят керамические конденсаторы 0.1 мкФ, они гасят искру на щетках и устраняют помехи в цепи питания. Блокировочные конденсаторы также стоят возле входа по питанию на каждой плате микроконтроллеров, для защиты от помех.
Разводка бортовой сетиПри монтаже я использовал по одному контакту для минуса и для плюса. Из этих двух точек я делал разводку уже по всем местам, где требовалось питание. Делая так же, вы с меньшей вероятностью запутаетесь и будет меньше «[земляных петель](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D1%80%D0%B0%D0%B2%D0%BD%D0%B8%D0%B2%D0%B0%D1%8E%D1%89%D0%B8%D0%B9_%D1%82%D0%BE%D0%BA)». Точки плюса и минуса лучше разнести подальше друг от друга для безопасности, например у меня можно эффектно уничтожить танк удачным попаданием металлической отвертки на контакты (а вот и недостаток обхода BMS – нет защиты от КЗ).
Мое решение не идеальное, лучше было бы использовать раздельное питание, при котором силовая часть запитывалась бы отдельно и не влияла на работу микроконтроллеров. К тому же микроконтроллеры и большинство датчиков можно запитать напряжением 3.3В, уменьшив потери энергии на стабилизаторах, но мне просто захотелось, чтобы было единое бортовое 5В питание.
Рекомендую внимательно отнестись к организации бортовой сети, ведь случайные глюки не нравятся никому, и вы можете потратить уйму времени на отлов бага, которого можно было избежать, потратив немного больше усилий при проектировании.
Микроконтроллеры
----------------
Интеллектуальная часть вашей техники для обработки данных и управлением всеми остальными частями устройства. Не имея большого опыта брать голый микроконтроллер и городить вокруг него обвязку не имеет смысла – вы наберетесь опыта, но потратите много времени.
Если хотите поскорее увидеть готовый результат, гораздо более эффективно будет взять платы разработчика (dev board) с уже распаянными микроконтроллерами и дополнительными компонентами, вроде разъемов и программаторов. На таких платах могут быть установлены различные микроконтроллеры, на самом деле их очень много и в интернете по ним достаточно информации, могу лишь посоветовать начинающим смотреть в сторону плат с ESP-32, ESP-8266 и Arduino. Существует много других плат с классными микроконтроллерами, имеющие намного лучшие характеристики за те же деньги, но порог вхождения там будет выше, поскольку там не такое большое сообщество, меньше инструкций, документации, библиотек или попросту более сложное программирование.
Если же вам не хватает возможностей «обычных» микроконтроллеров или вы хотите сделать что-то более ресурсоемкое попробуйте поискать среди мини-компьютеров – Raspberry Pi и его аналоги.
Для своего танка я решил разделить логику на две части. Одна плата будет заниматься обработкой данных с датчиков, дергать моторами и заниматься другими «простыми делами» например моргать светодиодом или пищать в пищалку, то есть такой себе драйвер для доступа к остальным устройствам. Вторая плата будет заниматься обработкой камеры и коммуникациями с внешним миром.
Я выбрал две платы: в качестве драйвера – Arduino Nano, и ESP-32-CAM в роли коммуникационного центра с возможностью смотреть через камеру. Таким образом на танке получилось два бортовых микроконтроллера:
* ESP-32 в формфакторе платы с камерой – мне нужно было что то дешевое и что бы оно было с Wi-Fi и могло работать с камерой, лучшего по соотношению цена/возможности я не нашел.
* ATmega328 в виде платы Arduino Nano – это идеальная плата по размеру и у нее множество свободных пинов и все необходимые интерфейсы. Классический и надежный выбор для таких задач как снять показания датчиков и подергать моторами.
Можно было сделать все на одной плате, но есть несколько причин почему я выбрал две платы:
* Я хотел максимальной отзывчивости от Wi-Fi связи, поэтому любая лишняя задача на ESP дополнительно бы нагружала ее, и хоть она и двуядерная это могло бы привести к дополнительным задержкам, а это не позволительная роскошь.
* Плата с ESP-32 в формфакторе модуля ESP-32-CAM, к сожалению, имеет по жадному очень мало свободных пинов, причем часть из них зарезервирована для других нужд. Это значит, что все датчики не подключить, можно использовать было что-то типа сдвиговых регистров, но мне хотелось попроще.
* Некоторые из Arduino библиотек без обработки напильником плохо работают на ESP.
* Просто так захотелось, что бы было две платы. Мне нравится такая идея разделения обязанностей.
Вместо Arduino можно взять плату с ESP-8266 и отключить на ней Wi-Fi. Она бы тоже отлично подошла, даже лучше поскольку в наличии больше вычислительной мощности и оперативной памяти.
Забавный баг с ESP-32Перед прошивкой ESP-32 необходимо ее перевести в boot режим. Делается это замыканием контакта GPIO0 на GND. На танке есть переключатель (красный рычажок), который переводит ESP в режим прошивки или в рабочий режим. Но я столкнулся с плохо документированным багом/фичей. В обычном, рабочем режиме, на этом контакте генерируется какой-то специальный высокочастотный сигнал, нарушения которого приводит к различным глюкам всей ESP. Хотя контакт имеет внутреннюю подтяжку к питанию, это не спасало от помех на мой провод к переключателю (около 7 см), из-за этого постоянно были случайные зависания. При отключении провода от контакта, проблемы исчезали. Я выяснил, что это редкий баг (но бывает), замена платы мне помогла.
Среди аналогов плат разработчиков или микроконтроллеров по возможности старайтесь выбирать что-то более популярное, так вы сможете в случае необходимости найти решения большинства проблем.
Попробуйте хотя бы примерно представить какое количество вычислительных ресурсов вам необходимо, не имея опыта представить это довольно тяжело, но можно поискать в интернете похожие проекты и взять нечто подобное. Микроконтроллер подбирается под задачу, а не наоборот, избыточность не всегда хороша, как минимум это будет большее энергопотребление, а в некоторых случаях что-то реализовать может быть проще на более простом и «тупом камне».
Программное обеспечение (прошивка)
----------------------------------
Тут я опишу общие моменты по коду которые у меня возникали, некоторые подробности я упущу, они будут описаны в частях ниже.
Попробуйте VS Code и PlatformIOЕсли вы пишите код в Arduino IDE, рекомендую попробовать VS Code с расширением PlatformIO. Я сам ее использую так как, это дает возможность пользоваться такими плюшками «нормальных» IDE как автоподстановка, удобную работу с вкладками и несколькими проектами, более быстрая компиляция, преимуществ на самом деле больше, я описал лишь те, что главные для меня. В родной Arduino IDE было очень неудобно каждый раз переключатся между проектами и настраивать их заново. Сначала вы, потратите немного времени на изучение новой среды, но потом будете делать все намного быстрее и экономия времени будет вашим вознаграждением.
Я использовал Arduino фреймворк, таким образом получается единая экосистема на Arduino и ESP, хотя последняя обладает собственным фреймворком с прекрасной документацией.
В этом проекте используется платформа [espressif32](https://github.com/platformio/platform-espressif32) версии 3.2.1, потому что в версиях выше поломали алгоритм выделения памяти, и за чего ESP может перезагружаться. Это касается только моего случая поскольку у меня используется несколько протоколов типа HTTP, SSE, Websocket и частая передача данных, в других сценариях все нормально работает.
Маленькие советы по кодуСтарайтесь хранить константы особенно строковые в Flash памяти (память, где хранится прошивка). Если для Arduino с ее прекрасными 2 КБ ОЗУ не вызывает сомнений зачем так делать, то в случае с ESP-32 может показаться что там много оперативной памяти, но всякие веб-серверы и буферы данных, убедят вас в обратном. Может оказаться так что у вас будут случайные зависания из-за нехватки ОЗУ (такие баги довольно тяжело отслеживать). Что бы избежать этого вы можете пользоваться различными способами хранения констант в Flash памяти, характерными для вашей платформы – например для Arduino это макрос `F()` или модификатор `PROGMEM`, а ESP по умолчанию переменные обозначенные как `const` хранит в Flash памяти.
Библиотеки тоже могут вас обмануть – например вы можете найти какую-то «легкую» библиотеку, а потом выяснится, что она работает хуже, чем та, что казалась громоздкой на вид, но написанная более квалифицированными людьми. Не надо относится с недоверием ко всем библиотекам, просто будьте более бдительными при использовании чужого кода.
Так же не стоит забывать про правильное объявление типов переменных, не зачем занимать 4 байта (int) если вам нужно всего 255 значений (один байт). Для хранения различных состояний неплохо подходят перечисления (`Enum`), так как это всего лишь цифры, но уровень абстракции позволяет с ними комфортно работать. Иногда может показаться что эта экономия лишняя, но поверьте недостаток памяти вы встретите тогда, когда будете меньше всего этого ожидать.
**Алгоритм работы танка**
Это рабочие циклы в общих чертах. Мои алгоритмы нельзя назвать точным описанием того, что происходит на самом деле, для этого лучше смотреть код, я описываю лишь саму суть происходящего.
**Защита от сбоев**
Так как багов и зависаний не избежать, особенно в процессе отладки, пришлось сделать несколько элегантных костылей и назвать это «защитой от сбоев».
Следящие собаки (Watchdog). Есть такая штука как Watchdog, это аппаратный таймер, который все время считает в обратную сторону, и если дошел до нуля, то перезагружает микроконтроллер. В нормальном режиме работы, микроконтроллер должен периодически сбрасывать Watchdog приводя его время в изначальное состояние. Если вдруг микроконтроллер задумался и не успел сбросить, собака (Watchdog) дёрнет за рубильник перезагрузки – просто и эффективно.
На Arduino может резко закончится ОЗУ. Связано это с двумя факторами: радиус кривизны моих рук и использование библиотек. Мне не хотелось городить свои велосипеды (переписывать библиотеки), да и зависания были эпизодическими. Учитывая, что Arduino перезагружается быстро (пара сек), а если убрать мой код, в который специально вложены задержки, то еще быстрее. Я решил поставить собаку (таймер), которая бы следила бы за платой и в случае чего перезагружала бы плату. К сожалению, в Arduino Nano так реализован родной загрузчик что моя плата ушла бы в вечные перезагрузки ([Arduino WDT bootloop](https://www.google.com/search?q=Arduino+WDT+bootloop)). Можно это исправить, загрузив другой загрузчик (например [optiboot](https://github.com/Optiboot/optiboot)), но это слишком скучное решение поэтому я решил организовать собаку при помощи ESP-32.
На ESP все гораздо скучнее чем на Arduino, там две защиты от сбоев. Первая для защиты от нехватки ОЗУ при интенсивной передаче данных – обычный watchdog на 4 секунды. В случае зависания плата будет перезагружена, а скорость готовности к работе после включения позволяет даже не заметить обрыва связи по Wi-Fi (не требуется переподключение).
Вторая – защита от низкого питания (brownout detector) была выключена. Сделано это для того, чтобы в условиях 5В напряжения минус падение напряжения на диоде, была возможность поработать подольше. Теперь в случае реального зависания из-за нехватки питания, плата зависнет намертво или может что-то забаговатся, но это компенсируется программной защитой от перегрузки двигателей (подробнее ниже) и самое главное – увеличенным сроком работы от батареи, поскольку детектор имеет немного завышенный порог срабатывания.
**Защита от перегрузки двигателей**
Не смотря на название эта программная защита не защищает двигатели, а защищает бортовую сеть от просадки напряжения до критического уровня. Поскольку двигатели являются самими большими потребителями энергии на танке, то я сделал защиту, которая при напряжении ниже определенного уровня – останавливает двигатели (уменьшая тем самым потребления тока), это спасает от большинства перезагрузок или зависаний по питанию. При желании эту защиту можно отключить, но тогда есть риск намертво зависнуть и потерять управление.
Алгоритм реализован на Arduino, напряжение измеряется ее внутренним АЦП, он имеет следующий вид:
* С некоторой периодичностью (5 мс) замеряется напряжение на батарее.
* Если напряжение ниже порога, и в прошлое измерение не было такого, то просто запоминается этот факт.
* Если напряжение ниже порога, и в прошлом измерении тоже было ниже, то срабатывает защита – двигатели останавливаются. На терминал управления отправляется сообщение от том, что была сработана защита, пищалка издает характерный звуковой сигнал.
Я пробовал смягчить эффект просадки напряжения от переходных процессов (в момент смены стороны движения), путем плавной раскрутки двигателей, но это не дало ощутимого эффекта (возможно на больших двигателях это дало бы лучший результат), плюс потерялась динамика управления поскольку добавилась задержка во времени пока раскрутятся движки.
**Звуковые сигналы**
Звуковые оповещения – классная штука, позволяют мне знать, что с танком что-то произошло или же он готов к работе. Поскольку для генерации звукового сигнала требуется аппаратный таймер, то если танк движется – один из двигателей перестает получать ШИМ сигнал. Для устранения нежелательного движения перед тем, как пикнуть танк останавливается.
Всего у меня 4 звуковых сигнала:
* «Оповещение» – самый громкий, для разгона зевак по улице (что б не задавили танк), этот сигнал можно вызывать вручную с терминала управления.
* «Предупреждение» – просто что-то произошло, но не критично, например остановка двигателей из-за низкого напряжения.
* «Ошибка» – что-то сломалось так, что танк уже не может функционировать, без вмешательства или перезагрузки.
* «Хорошо» – значит, что все отлично, на данный момент используется как индикатор того, что танк готов к работе.
Все сигналы состоят из набора четырех частей. Каждая часть хранит частоту и длительность звучания, специальная функция переключает частоты во время звучания сигнала. Такая система оповещений простая в реализации и позволяет легко масштабироваться.
Аппаратная реализация пищалкиВ железе пищалка представляет собой обычный зуммер (пьезоизлучатель) подключений к Arduino через биполярный транзистор (базу не помешало бы подключить через резистор). Переключатель нужен для отключения звуковых сигналов – бесшумный режим.
**Управляющий терминал**
Это приложение, которое обеспечивает: управление движением, просмотр данных с датчиков, проведение диагностики и настройки танка. Приложение было сделано при помощи игрового движка Unity. Данное решение я могу обосновать как «just for fun». Выбор Unity обладает определенной избыточностью и костыльностью решений (из-за того, что движок не предназначен для такого).
Функционал приложения состоит из:
* Главный экран, на котором расположены кнопки управления движением танка, кнопки навигации по окнам приложения, верхней панели с данными датчиков и вспомогательной информации.
* Верхняя панель содержит данные с основных датчиков: скорость, расстояние до ближайшего препятствия (ультразвук), наклон танка, напряжение и уровень заряда батареи. Так же там есть уровень связи с повторителем, индикатор качества связи, последняя команда движения, которая была отправлена на танк и количество полученных кадров с камеры за секунду.
* Окно журнала (лог), куда Arduino, ESP и само приложение умеет записывать всякие события – удобно при отладке.
* Кнопка запуска акустического оружия подавления – звуковой сигнал оповещения.
* Окно настроек – можно подрегулировать масштаб видео, перезапустить стрим, вкл/выкл защиту от перегрузки, автоматическую настройку видео, а также настроить качество, разрешение и усиление видеокамеры.
* Окно телеметрии – вывод данных со всех датчиков и качество связи.
Алгоритм работы приложения:
* Поиск танка в Wi-Fi сети, если найден – установление с ним связи.
* Прием и отображение видео. При необходимости качество видео автоматически регулируется.
* Прием данных с датчиков.
* Прием данных в журнал (лог).
* Если есть команды управления – отправка их на танк.
* В случае обрыва связи, будет предпринята попытка заново установить связь.
Установление связи терминала с танком. Есть три режима соединения с танком:
* «Напрямую» – танк становится точкой Wi-Fi, к нему подключается терминал управления (смартфон).
* «Повторитель» – отдельная плата ESP8266 с внешней антенной, разворачивает точку Wi-Fi. К ней подключаются танк и терминал управления.
* «Нет соединения» – ничего не происходит.
При поиске танка, терминал периодически посылает сигналы через WebSocket на два IP адреса: адрес танка при режиме «Напрямую» и адрес при режиме «Повторитель», если с какого-то адреса приходит ответ, значит танк найден и выставляется соответствующий режим.
Почему WebSocket для поисковых сигналов?Потому что по HTTP запросу если нет ответа срабатывает исключение по таймауту (особенность Unity), которое нельзя обработать, это ни на что не влияет, но при отладке меня бесит. Если же отравлять стандартный Ping, это будет работать, но в Android нет. Там Ping сходит с ума, и может возвращать ответ и даже значения задержки (абсолютно случайное) даже если такой сети не существует, а телефон отключен от всех возможных интерфейсов. На компьютере такой проблемы нету – видимо какой-то баг на Android. Поэтому здесь я применил такой элегантный хак через WebSocket.
После установления режима связи, соединение периодически проверяется отправкой HTTP запроса, если есть ответ значит все хорошо, если нету, то все соединения прерываются и начинается процесс поиска танка заново.
**Определитель качества связи**
Как только танк вышел на рабочий режим («Напрямую» или «Повторитель»), на терминале запускается Ping который периодически отправляет сигналы на танк и возвращает задержку. Тут записывается минимальная и максимальная задержка. Так же сохраняется значения последних 15 отправленных Ping, по ним высчитывается средняя задержка и соотношения отправленных к принятым.
На главном экране приложения есть индикатор (цветной квадрат), возле которого выводятся краткие данные по качеству связи и меняется цвет индикатора: Зеленый – Хорошо; Желтый – Потери; Красный – Нет соединения. Эта нехитрая система позволяет быстро оценить состояние канала связи.
**Управление движением** **танка**
Изначально у меня была идея сделать управление танком при помощи двух виртуальных джойстиков. От этой идеи было решено отказаться так как двигатели весьма маломощные, и вместе с редуктором не позволяют развивать большие скорости, то есть попросту нету диапазона регулирования скоростей – максимальная скорость мала. Но я уверен, что, если бы танк мог бы развивать внушительные скорости, то это было бы круто – можно было бы плавно развивать скорость и выделываться дрифтом на танке.
На моей же тихоходной танкетке оказалось достаточно 8 направлений движения: влево, вправо, вперед, назад и по диагоналям для поворота танка на ходу. Каждой стороне движения (включая стоп) соответствует цифра от 0 до 8.
Как только изменяется состояние кнопок управления, на танк посредством HTTP GET запроса отправляется цифра, обозначающая сторону движения. Каждые полсекунды команда движения повторно отправляется на танк. В случае движения танк ожидает что каждая команда будет повторно отправлена не позже, чем через одну секунду, если же команды нету, то он останавливается. Команда «СТОП» повторяется всего три раза (если даже не дойдет, танк остановится сам).
Таким образом для движения танка необходима постоянное подтверждение команд с терминала, в случае их отсутствия танк автоматически прекращает движение. Эта избыточность позволяет достичь гарантии доставки команд движения и избежать забавной ситуации, когда танк движется, а вы не можете его остановить, потому что оборвалась связь.
Коммуникации
------------
### Внешняя связь
Вы можете использовать различные протоколы связи для управления своей техникой. Это может быть классический радиоканал, Wi-Fi или Bluetooth. У каждого есть свои плюсы и минусы, я же использовал Wi-Fi поэтому буду писать про него.
**Причины почему я выбрал Wi-Fi:**
* Мне нужно было передавать данные, возможно в будущем довольно большие объемы.
* Хотел управление (с передачей видео) в радиусе примерно 30 метров на улице.
* Хотелось управление со смартфона.
* Сама по себе технология мне нравится.
Учитывая, что на смартфоне не так и много радиоинтерфейсов, обычно это: NFC, GSM, Bluetooth и Wi-Fi, то только последний обладает нужными характеристиками. Bluetooth тоже неплохое решение если не надо передавать что-то вроде потокового видео.
Wi-Fi на танке работает в двух режимах «Напрямую» и «Повторитель». В режиме «Повторитель» танк и смартфон подключаются к другому микроконтроллеру (ESP8266), который выполняет роль Wi-Fi роутера. Сделано это для того, чтобы увеличить дальность связи, которая достигается несколькими вещами:
* Внешней антенной повторителя – эта антенна обладает лучшими качествами чем та, что в смартфоне.
* Физическим размещением повторителя где-то между смартфоном и танком.
По большому счету повторитель нужен для того, чтобы уменьшить влияние слабых Wi-Fi возможностей смартфона. Повторитель увеличивает радиус дальности связи примерно в 1.5-2 раза чем подключение напрямую. Добавление дополнительного элемента в цепочке передачи данных также увеличивает задержку примерно на 10-15 мс.
Почему Wi-Fi точка создается не на смартфоне?Таким образом я могу контролировать настройки Wi-Fi. На смартфоне, к сожалению, нельзя подробно настроить точку, при этом у разных производителей, свое виденье настроек по умолчанию, из-за этого нет гарантии одинаковой работоспособности на разных смартфонах. Но есть и плюсы в решении развернуть точку на телефоне, например легкость доступа из сети Wi-Fi, в мобильную сеть (Интернет), то есть танком можно управлять через удаленный веб сайт (я так делал в одной из версий своего танка).
**Методы улучшения Wi-Fi связи:**
* ESP-32 работает в Wi-Fi сети на диапазоне 2.4 ГГц, значит все что на этих частотах и не наш полезный сигнал, является нам помехой. Об этом надо помнить, например в некоторых, очень зашумленных местах ваше устройство будет работать гораздо хуже, чем могло бы.
* Внешняя антенна вместо интегрированной. Для стабильной и далекой связи, родная антенна обладает не лучшими характеристиками. Я использовал внешнюю антенну от старого роутера на 5 дБ (родная 2 дБ).
* ESP-32 поддерживает три стандарта Wi-Fi: 802.11b; 802.11g и 802.11n, каждый стандарт обладает своей скоростью передачи данных, и условиях при которых они передаются, например чувствительностью уровня сигнала. Зная свои потребности в необходимой скорости, вы можете поменять стандарт на более «простой», выиграв при этом в чувствительности. Например, я использую на своем танке 802.11b, который обеспечивает всего 11 Мбит/с (для передачи данных и видео достаточно), но увеличивает чувствительность приема.
* Если вы используете стандарт Wi-Fi: 802.11n, имеет смысл уменьшить ширину полосы пропускания с 40 МГц до 20 МГц. Уменьшение ширины также уменьшает теоретическую максимальную скорость со 150 до 75 Мбит/с (вряд ли такие скорости понадобятся и микроконтроллер будет с ними справляться). Из-за меньшего рабочего диапазона частот, уменьшается вероятность наложения вашего сигнала с каким-либо еще – меньше помех. На стандартах Wi-Fi: 802.11b/g, такой фичи еще не было, поэтому там нет смысла напрягаться.
* Wi-Fi на ESP-32 использует диапазон частот от 2400 МГц по 2484 МГц. Для того что бы устройства не мешали друг другу они работают на разных каналах (частотах). Если ваше устройство работает в месте, где много других Wi-Fi сетей, возможно имеет смысл перейти на другой канал, чтобы избежать взаимных помех. На танке я выбрал 11 канал как самый менее популярный.
* По умолчанию на ESP-32 включен режим энергосбережения (сна) для Wi-Fi. Это прекрасное решение для каких-то IoT штучек, но плохое для устройств, где нужен максимальный отклик. Из-за этого режима, Wi-Fi как бы иногда «отдыхает», видно это по большим случайным задержкам. Отключить легко – `WiFi.setSleep(false)`. Выключение этого режима, дает ровный стабильный отклик по сети, при условии отсутствия других проблем.
* Если вы используете одновременно Bluetooth и Wi-Fi, то надо помнить, что ESP-32 обладает одним радиомодулем. Хоть эти две технологии и работают в одном частотном диапазоне 2.4 ГГц, но все же их реальные рабочие частоты разнесены на десятки МГц. Поэтому при одновременной работе на этих двух технологиях ESP будет переключаться с одной связи на другую, вызывая задержки.
**Принцип разворачивания Wi-Fi на танке:**
* Вначале танк ищет, Wi-Fi точку повторителя, если она есть, он успешно к ней подключается.
* Если при каких-то обстоятельствах соединение с повторителем разорвется, танк попробует снова с первого пункта.
* Если повторитель не найден, танк разворачивает свою точку Wi-Fi.
Для любителей далекой связиESP-32 поддерживает Long Range мод, это протокол разработанный Espressif Systems, который позволяет сделать связь еще дальше, обладает увеличенной чувствительностью даже по сравнению с 802.11b. Разработчики говорят про связь на 1 км, и даже больше с применением направленных антенн. Но данный мод поддерживается только платами ESP-32.
Забавный аппаратный баг антенны ESP-32Встроенная антенна может быть плохо согласована. Это проверить очень легко – попробуйте пинговать ESP или смотрите видео с нее, если в этот момент к антенне приложить палец и связь улучшается (меньше задержки или больший FPS), значит антенна низкого качества. Как я понял такое встречается не часто и всему виной моя любовь к дешевым комплектующим. В сети есть решения вроде наклеить кусочек антистатического пакета или что-то подобное, но на деле эти решения не очень эффективные. В попытках с этим разобраться я потратил много часов и поменял антенну на внешнюю, я даже обклеил корпус ESP фольгой, хотя это больше, чтобы уберечь ее от случайных помех на улице, а еще это красиво.
Итого – танк имеет настроенный для его вида трафика Wi-Fi и два режима работы. Первый «напрямую» – для быстрого разворачивания, с меньшим радиусом работы и минимальной задержкой. И второй режим с повторителем, который хоть и добавляет задержку, позволяет работать танку на дальних дистанциях и в условиях сильно зашумленного эфира.
**Протоколы передачи данных**
Обмен данных между танком и терминалом управления происходит через три протокола: HTTP, WebSocket (WS), Server-Sent Events (SSE).
* HTTP – начать сеанс связи может только клиент, сервер не может обратится сам первый к клиенту. По нему передаются данные с датчиков, команды управления и конфигурации.
* WebSocket – позволяет передавать данные в две стороны от сервера клиенту и наоборот. Используется в качестве начального «ping» для установления режима связи и для передачи данных с ESP и Arduino в журнал.
* SSE – работает по принципу подписки клиента на сервер, но работает только в одну сторону, от сервера к клиенту. Передает на терминал некоторые данные с датчиков, которые быстро обновляются.
В качестве основного протокола используется HTTP. WebSocket и SSE я выбрал для «поиграться». Поэтому сценарии использования немного надуманы, можно было бы легко обойтись и без них. К тому же родной асинхронный веб сервер довольно быстро работает.
Выбор WS и SSE обусловлен двумя факторами:
* Позволяют передавать данные от сервера к клиенту напрямую. В HTTP, пришлось бы клиенту опрашивать сервер или городить свой велосипед.
* В теории работают быстрее HTTP, за счет меньшей избыточности данных и лишних сеансов установления связи.
**Скорость обновления данных**
На ESP-32 есть определенный лимит количества данных, которые она может обработать – примерно 15 пакетов/с. В случае превышения этого предела, данные отбрасываются с записью в UART «ERROR: Too many messages queued». Заметьте тут больше влияет количество соединений за секунду, чем объем данных.
Так как я хотел передачу побыстрее, я решил попробовать обойти это через WS и SSE. Трафик у меня почти всегда однородный, поэтому тестировалось все в одинаковых условиях. Вот какие результаты у меня получились:
* WebSocket – в лимит упирается аналогично HTTP серверу. Преимуществ кроме как передачи от сервера к клиенту напрямую не будет.
* SSE – позволяет немного увеличить лимит передачи на 3-5 пакетов/с.
* Оба протокола работают менее стабильно чем HTTP сервер. Например иногда, ESP-32, может перезагрузится или зависнуть, когда через них идет интенсивный трафик, как напоминание того, что «нечего обходить лимиты». Если не выделываться, то пользоваться можно.
Скорость отклика у всех трех протоколов одинаковая, нельзя сказать, что HTTP, медленнее чем WS или SSE при передаче таких же данных. Это значит, что для управления или чего-то другого что требует низкой задержки, более важна конечная реализация, чем выбор какого-то из этих протоколов.
Возможное решение лимита пакетовСкорее всего лимит пакетов возможно увеличить путем редактирования [конфигурации проекта](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html) (там есть размер буфера, и лимит очереди сообщений). Но для связки Arduino фреймворка и ESP-32 используются предварительно скомпилированный код ESP-IDF. Поэтому внести туда изменения очень сложно.
**Принцип передачи данных**
Данные передаются в виде строк. Часть из них в таком виде как есть, другая упаковывается в JSON.
На ESP-32 поднят асинхронный HTTP сервер. Он общается посредством HTTP GET запросов. Терминал передает команды управления запросом, в параметре которого находится цифра, которая соответствует стороне движения танка. Настройки камеры или Arduino передаются похожим образом. Данные с датчиков терминал опрашивает периодически, получая в ответе от ESP последние принятые показания в JSON формате.
WebSocket – передает терминалу служебные сообщения для журнала (лог) и подтверждения того что настройки Arduino были приняты.
SSE – используется для одной цели: передачи на терминал данных быстро обновляемых сенсоров сразу же как только они были приняты от Arduino.
**Передача данных с датчиков**
Датчики разделены на две группы:
* Медленные датчики – обновляются с определённым интервалом и передаются от Arduino к ESP. Терминал управления (приложение) периодически запрашивает эти данные. Частота обновления раз в две секунды. Передача через HTTP GET запросы.
* Быстрые датчики – обновляются с определенным интервалом (быстрее чем, медленные датчики) и передаются Arduino к ESP, после этого сразу же отправляться на терминал управления. Частота обновления 2.5 раза в секунду. Передача через SSE.
Разделение датчиков на медленные и быстрые, позволяет передавать определенные данные, которые должны быть немедленно или как можно чаще доставлены, отделяя их от тех которые могут подождать. Отправляя такими двумя кусками «быстрых» и «медленных» данных, уменьшается общее количество пакетов и время на отправку/прием и обработку этих данных, чем если их отправлять по отдельности.
### Внутренняя связь. Arduino – ESP
Для связи между платами Arduino и ESP-32-Cam используется протокол UART. Сначала я делал свой велосипед для передачи данных, но, когда этих данных стало много я понял, что намного лучше использовать готовое решение.
Таким решением стала прекрасная библиотека [SerialTrasfer](https://github.com/PowerBroker2/SerialTransfer), она берет на себя «грязную» работу по передаче данных»: организации правильной передачи пакетов, подсчета контрольных сум и позволяет передавать простые типы данных и структуры, как раз то, что мне и нужно, поскольку я храню данные с датчиков в структуре.
Хотя у SerialTrasfer заявлена поддержка программного UART'а (Software Serial), у меня не заработало. Из-за этого и учитывая интенсивный трафик, я оставил аппаратный UART на Arduino для передачи данных. Поэтому для перепрошивки Arduino, ее надо вытянуть из танка или отключить ESP (мешает прием данных по UART).
ESP-32 имеет на борту несколько аппаратных UART, которые к тому же в отличии от Arduino могут легко переконфигурироватся на другие выводы. UART\_0 остался для отладки и прошивки, а UART\_1 для связи с Arduino.
Скорость UART для передачи данных установлена в 76800 бод/с. На такой скорости возникает меньше всего ошибок при передаче из-за тактовой частоты микроконтроллеров 16 МГц у Arduino и 320 МГц на ESP. Такое решение позволяет с большой степенью гарантировать доставку корректных данных между ESP и Arduino, отказавшись от их проверки и возможного дублирования.
Из-за разной архитектуры микроконтроллеров Arduino Nano (ATmega328) – 8 бит и ESP-32 – 32 бит, необходимо использовать выравнивание данных в памяти, чтобы они (перечисления, структуры) были корректно приняты на обоих платформах. Я использую для этого атрибут «\_\_attribute\_\_((\_\_packed\_\_))».
Учитывая разные напряжения логичных уровней ESP-32 (3.3В) и Arduino (5В), UART между ними подключен через конвертер.
**Принцип передачи данных по UART:**
* Данные передаются парами: «Тип данных» и «Полезные данные», причем последние могут отсутствовать, ведь иногда достаточно лишь наличие самого факта передачи, например сигнал о том, что надо обновить wathdog таймер.
* Всего 8 типов данных: «Показания датчиков», «Команда управления», «Тип звукового сигнала», «Wathdog», «Сообщение в журнал (лог)», «Показания быстрых датчиков», «Настройки Arduino», «Считать настройки Arduino».
* На отправляющей стороне готовится сообщение вначале которого стоит тип данных, за ним данные, если они нужны.
* Приемная сторона принимает сообщение и в зависимости от типа сообщения, может быть: какое-то действие или распаковка «посылки» в виде полезных данных.
Такая простая система передачи данных легко масштабируется, позволяя передавать различные виды данных и вносит небольшую избыточность поскольку типы данных всего лишь перечисления (Enum) то есть обычные цифры.
Можно использовать не только UART, а например SPI, или I2C, или другой протокол передачи данных на произвольных выводах. Я же выбрал UART по причине его хорошей документации, легкости работы с ним, и то, что он все равно нужен был бы – для отладки.
Датчики
-------
Датчиков существует огромное количество на все случаи жизни, они нужны для измерения всех существующих и несуществующих физических величин. Это «глаза и уши» вашего устройства. С помощью них ваше устройство может воспринимать реальность и на основе этого с ней взаимодействовать.
Про работу с датчиками в сети есть довольно много информации. Опишу лишь то, что я считаю важным при выборе датчика:
* Диапазон, точность измерений.
* Вид выдачи информации: цифровой или аналоговый. В зависимости от «крутости» датчика он может сразу выдавать готовый (цифровой) результат по какому-то протоколу. Если ж датчик попроще, то он выдает в сыром (аналоговом) виде, что требует дополнительной обработки на приемной стороне и требует наличие свободного АЦП.
* Если датчик цифровой, то его рабочий протокол (интерфейс). Ведь при прочих равных некоторые интерфейсы гораздо проще реализовать чем, другие.
**На танке установлен ряд датчиков**:
* Модуль DHT-11 термометр и гигрометр. Не очень точный, зато дешевый и с ним легко работать. Я считаю, что на танке (с телеметрией) обязан быть классический датчик – термометр.
* Датчик Холла A3144, в роли тахометра. На ведущей звездочке левой гусеницы установлен маленький неодимовый магнит, напротив нее со стороны корпуса установлен датчик Холла. Датчик реагирует на каждый проход магнита над ним и таким образом считывает количество оборотов ведущей звездочки. Зная диаметр звезды, можно узнать на сколько именно продвинулся танк и с какой скоростью. Точность этой импровизации, оставляет желать лучшего, но зато прикольно работает.
* Барометр BMP-280. Позволяет получать атмосферное давление и на основе этого высоту над уровнем моря. Датчик имеет множество режимов работы на все случаи жизни, но немного сложный в настройке.
* Модуль акселерометр и гироскоп MPU-6050. Хороший, быстрый датчик для измерения ориентации в пространстве, использует сложную математику для работы, но это компенсируется наличием библиотек.
* Ультразвуковой дальномер US-025 (аналог HC-SR04). Используется для вывода расстояния до ближайшего препятствия спереди танка.
Забавный баг с шиной I2CНекоторые датчики (MPU-6050, BMP-280) подключаются по I2C. Иногда из-за этой шины микроконтроллер Arduino Nano может зависать намертво. Я смотрел осциллографом что там творится на шине, увидел вместо примерно ровных прямоугольных форм, ужасные искаженные фронты сигналов, которые больше напоминали треугольники или даже случайный шум, надо было очень постараться что бы понять, что там что. Я проверил на нескольких платах и без танка, результат был тот же. Я так и не понял из-за чего это возникает. Возможно мои китайские подделки Arduino, возможно что-то другое. Помогла сильная подтяжка шины к питанию через 1.3 кОм.
Показания с датчиков могут обрабатываться прямо на Arduino или ESP, а для тяжелых расчетов обработка на уровне приложения и на основе этого отправка команд управления на танк. В данный момент датчики не несут какой-то практической цели и установлены для обучения и как основа для дальнейших танковых модернизаций, а также придают танку вид «серьезного» устройства.
**Камера, прием видео**
На модуле ESP-32-Cam установлена 2Мп видеокамера OV2640. Камера может захватывать окружающий мир в потрясающем диапазоне разрешений от 96x96 до 1600x1200. На танке я же использую три разрешения: HVGA – 480x320; VGA – 640x480; SVGA – 800x600. Выбор этих разрешений обусловлен: быстрым формированием и передачей такого размера кадра, что дает стабильные 25 FPS, разрешения выше уже слишком большое для стабильного фреймрейта, а ниже – слишком теряется качество картинки.
В основу кода (тот, что на ESP) для работы с камерой взят стандартный пример «[CameraWebServer](https://github.com/espressif/arduino-esp32/tree/master/libraries/ESP32/examples/Camera/CameraWebServer)». Для камеры поднят отдельный HTTP сервер, который при подключении к нему отдает клиенту бесконечный поток картинок в формате JPEG с камеры – получается MJPEG стрим. Сервер камеры (не путать с сервером для передачи данных) может работать одновременно только с одним клиентом, но я видел в сети примеры работы и с большим количеством клиентов, мне такое не нужно поэтому я не заморачивался.
Прием кадров не сложная задача ведь поток MJPEG, это бесконечная передача JPEG изображений, достаточно вылавливать специальные маркеры (байты). Маркер всегда начинается с байта 0xFF, за ним следует байт, который обозначает тип маркера. Маркеры могут обозначать разное, но нас интересуют два типа маркеров начало кадра – 0xD8 и конец кадра – 0xD9.
Unity с коробки не умеет поддерживать MJPEG поток. Поискав по сети, я нашел примеры кода, часть из них не работала, или была устаревшей, или имели утечки памяти, платные решения я не рассматривал. Потыкав все возможное что я нашел, я понял, что ничего адекватного для моей задачи нету. Решено было городить свой велосипед. Так как я делал все в Unity я решил использовать их метод [UnityWebRequest](https://docs.unity3d.com/ScriptReference/Networking.UnityWebRequest.html) и стандартный механизм «многопоточной» работы с ними через сопрограммы (Coroutine).
Принцип приема изображения простой:
* Я сделал свою реализацию обработчика ([DownloadHandler](https://docs.unity3d.com/ScriptReference/Networking.DownloadHandler.html)), который просто дергает каждый раз событие передавая туда кучу байт (JPEG) в тот момент, когда пришел кадр.
* Дальше кадр попадает в метод ([LoadImage](https://docs.unity3d.com/ScriptReference/ImageConversion.LoadImage.html)), который пытается преобразовать JPEG байты в текстуру (Texture2D).
* Если у метода получилось, то текстура натягивается на объект на сцене, то есть отрисовывается и мы ее видим на экране.
Детектирование битого кадраИз-за приема битого кадра метод LoadImage может не загрузить текстуру. И хотя он должен в этом случае возвращать false, на деле он почему-то всегда возвращает true. Но я воспользовался тем, что, когда он не может загрузить текстуру он выдает вместо нее белую текстуру с красным вопросительным знаком, она размером ровно 8 на 8 пикселей. А я такой размер в работе танка не использую, поэтому простая проверка на размер текстуры на выходе дает понять, что пришла битая текстура и избежать мечты эпилептика – внезапно появляющейся белой текстуры, которая, по сути, будет мигать в реальных условиях. Кстати, хитрые Web-браузеры умеют в таком случае отрисовывать ту часть кадра что успешно пришла, но я так не умею поэтому обхожусь таким элегантным хаком.
**Кадровая частота**
Сама по себе камера довольно быстрая и честно выдает заявленные производителем 25 кадров в SVGA разрешении, но есть нюансы:
* Необходимо наличие PSRAM – это внешняя ОЗУ, в ней могут хранится кадры. Без нее нельзя будет выбрать более высокий размер разрешения и кадровых буферов. Большинство плат ESP-32-Cam уже имеют такую память.
* Частота XCLK сигнала – я не знаю точно, за что именно отвечает этот параметр. Как я понял тактирующий сигнал для каких внутренних нужд камеры. Если я правильно понял из документации, то он может быть в диапазоне от 6 до 24 МГц. Но в интернете советуют выставлять его 10 или 20 МГц. У себя я поставил 20 МГц. С данным параметром надо быть аккуратным, камера может не корректно работать с некоторыми разрешениями.
* Количество кадровых буферов – позволяет увеличить FPS, тот который камера снимает. Для увеличения числа данных буферов как раз таки и требуется наличие PSRAM. По идее каждый буфер кратно увеличивает FPS. Я использую 2 буфера.
* Качество JPEG – степень сжатия изображения, может быть в диапазоне от 0 до 63, но на практике при значениях ниже 10, кадр будет обрезаться из-за его большого размера при передаче по сети. Я же в основном регулирую в диапазоне от 16 до 63 качество. Этот параметр позволяет значительно увеличить FPS при плохом соединении, ценой квадратных артефактов на изображении.
Даже при хорошо настроенной камере, на приемной стороне вы можете увидеть ужасающе низкий FPS, это происходит, потому что из-за сетевых задержек кадры просто не успевают смениваться с нужной частотой. От состояния канала связи очень сильно зависит FPS, даже больше, чем от правильной настройки камеры. Потому что пока вы можете принимать по сети 5 кадров, то камера хоть 60 их наснимает больше вам не передаст. Поэтому надо очень внимательно отнестись к организации связи.
**Настройки видео**
У видео есть много настроек, некоторые из них я сделал что б можно было регулировать прямо из приложения:
* Разрешение – три на выбор HVGA, VGA, SVGA.
* Качество – уровень сжатия JPEG.
* Усиление (Gain ceiling) – позволяет усилить сигнал с камеры для лучшей видимости в условиях недостаточной освещенности, взамен дарит кучу шума в кадре.
**Автонастройка видео**
Возможность передавать качественный видео сигнал, а главное стабильный фреймрейт падает по мере ухудшения сигнала. Что б не крутить каждый раз руками настройки камеры я сделал функцию, которая сама крутит настройки вместо меня. Принцип работы простой:
* Зная количество кадров, которые приходят за секунду можно узнать FPS.
* Как только FPS падает ниже определенного порога, снижаем качество картинки (JPEG quality), если понижать качество уже некуда, то понижаем разрешение.
* Если FPS выше определённого порога, то все происходит точно так же только качество и разрешение повышаются.
Работает хоть и не всегда хорошо, но достаточно эффективно. Можно улучшить эту систему. Например, более точно определять момент «плохого видеосигнала» и расширить диапазон разрешений.
В моем случае стоит самая бюджетная версия камеры, для тех, кто будет делать что-то подобное с видом от первого лица (FPV), рекомендую купить версию камеры с линзой в 120 градусов обзора, потому что обычная с ее 66 градусами весьма печальна – банально не видно, что находится рядом.
Исполнительные механизмы
------------------------
Это то, что делает ваше устройство живым, например на моем танке это два мотора, которые приводят его в движение. Так же это мог бы быть какой-то лазер и сервоприводы для его наведения.
Зачастую исполнительные механизмы потребляют значительную часть бортовой энергии. Поскольку микроконтроллер может пропускать через себя лишь маленький ток, управлять такими устройствами надо через специальные «переходники» – драйверы.
Драйвер — это плата, к которой подключается микроконтроллер, исполнительный механизм и питание. Суть в том, что микроконтроллер посылает только сигналы управления в духе «сделай то или это», а драйвер сам разбирается как надо правильно привести в действие исполнительный механизм. Можно и самим генерировать необходимый сигнал с микроконтроллера, но тогда придётся сделать всю обвязку из электронных компонентов и реализовать алгоритм управления. Куда эффективнее и быстрее использовать готовое специализированное устройство – драйвер.
Для танка я использовал драйвер L298N. Можно было бы использовать более новые и эффективные драйвера. Но мне нравится использовать такое старье, которое имеет брутальный вид и большой, а главное теплый радиатор после работы – это придает дух танку и отлично вписывается в его дизайн «собрано с того, что было на столе».
Всего есть 9 команд управления:
* «Движение»: вперед, назад.
* «Поворот»: влево, вправо.
* «Движение с поворотом»: вперед и влево, вперед и вправо, назад и влево, назад и вправо.
* «Стоп».
Учитывая, что на танке установлены немного не одинаковые двигатели, то для прямолинейного движения у них выставлены разные максимумы ШИМ сигналов (максимальные скорости вращения двигателей).
Принцип управления двигателями такой:
* Команда «Стоп» – драйверу посылается сигнал остановить двигатели.
* Команда «Движение» – драйвер крутит оба двигателя вперед или назад.
* Команда «Поворот» – двигатель со стороны поворота вращается назад, а второй двигатель вперед. Таким образом достигается быстрый разворот на месте.
* Команда «Движение с поворотом» – двигатель гусеницы противоположный повороту работает на 100%, а двигатель со стороны поворота понижает обороты, например 70%. Получается плавный поворот в сторону тормозящей гусеницы.
Можно применять более агрессивную тактику тормоза, например реверсивное движение или блокировку мотора, но учитывая маленькую массу моего танка и почти полное отсутствие инерции, это избыточно. К тому же редуктор сопротивляется самопроизвольному движению, а еще такой тормоз кратковременно потребляет очень много энергии.
Для поворота можно заглушить (остановить) двигатель гусеницы со стороны, на которую идет поворот. Таким образом можно добиться красивого поворота на месте по радиусу вокруг гусеницы-тормоза.
Как видите нету ничего сложного в управлении исполнительным механизмом. Необходимо лишь подобрать драйвер, который будет подходить под ваши задачи, в зависимости от потребления тока и типа устройства, которым вы хотите управлять.
Фото и видео презентация
------------------------
Электрическая схема танкаТанк – вид спередиТанк – левый бортТанк – правый бортТанк с открытой крышкойНочной танковый рейдПрогулка в паркеТанк на фоне красивых огоньковБонус – прототип и первая версия танкаИтоги
-----
Весь исходный код прошивок Arduino, ESP-32 и Unity приложения я выложил в [репозитории на GitHub](https://github.com/TwFi/Wi-Fi-controlled-tank), не удивляйтесь если найдете «интересные решения». Моя цель показать вам сам принцип, лучше всего это разобраться самому и на основе полученных знаний сделать что-то свое.
Написание этой статьи помогло мне разложить по полочкам весь тот опыт что я получил при создании танка. И запомнить решения всех тех костылей, багов и недоработок, которые возникли в процессе, и которых вы сможете избежать что бы найти свои уникальные проблемы и поделится ними с сообществом. Я очень надеюсь, что я смогу кого-то вдохновить на создание подобной прикольной штуки. | https://habr.com/ru/post/671094/ | null | ru | null |
# R, Монте-Карло и enterprise задачи, часть 2
Как ни парадоксально, но пока еще нередко в enterprise встречаются задачи, отличные от построения еще одного личного кабинета, еще одного мониторинга или еще одного документооборота. Если немного подумать, а не хвататься сразу кодировать или искать специализированное ПО, то можно написать компактное, весьма элегантное и быстрое решение, используя метод Монте-Карло .
Задачи в Enterprise достаточны компактны для перебора и не требует точности 100 знаков после запятой. Не ракеты или реакторы запускаем и не научную теорию всего строим.
Рассмотрим далее на примере одной из нестандартных задач.
Является продолжением [серии предыдущих публикаций](https://habrahabr.ru/users/i_shutov/posts/).
Постановка задачи
=================
Задача имеет корни в IoT для сельского хозяйства. А именно, расстановка датчиков на картофельном поле с круговой схемой полива. Попросим у гугла немного картинок: [«Разгадка тайны круглых полей: всё интересней, чем ты думаешь!»](https://e-w-e.ru/razgadka-tajny-kruglyx-polej/). Нужно обеспечить нужные характеристики покрытия mesh сети, учитывая допустимые расстояния между соседями. При этом надо оптимизировать бюджет и выдать gps координаты на расстановку датчиков и сформировать кратчайшую схему обхода.
Решение
=======
Подключаем пакеты
-----------------
**Пакеты**
```
library(tidyverse)
library(magrittr)
library(scales)
library(data.table)
library(tictoc)
library(stringi)
library(arrangements)
library(ggforce)
```
Декомпозиця
-----------
Сначала попробуем сформировать этапы.
1. Берем `N` датчиков.
2. Ищем оптимальную расстановку.
3. Если характеристики не достигнуты, увеличиваем `N` на 1. Повторяем процедуру.
4. Для найденной расстановки ищем оптимальный маршрут обхода.
План вроде простой. Но как будем решать? Напрашивается метод Монте-Карло.
Функции-хелперы
---------------
Оформим функцию для визуального отображения расположения зондов.
**Визуализация поля**
```
drawDisk <- function(df) {
# отрисуем расположение точек и действующие силы
# если силы не заданы, создадим их по умолчанию равными 0
for(col in c("force_x", "force_y")){
if (!(col %in% names(df))) df[, col] <- 0
}
ggplot(data = df, aes(x = x, y = y)) +
ggforce::geom_circle(aes(x0 = 0, y0 = 0, r = 1, colour = "red"),
inherit.aes = FALSE) +
geom_point(size = 2, fill = "black", shape = 21) +
geom_text(aes(label = idx), hjust = 0.5, vjust = -1) +
# рисуем векторное поле
geom_segment(aes(xend = x + force_x / 10, yend = y + force_y / 10),
colour = "red",
arrow = arrow(length = unit(0.2,"cm")), size = 0.6) +
xlim(-1.5, 1.5) +
ylim(-1.5, 1.5) +
coord_fixed() +
labs(x = "Ось X", y = "Ось Y") +
theme_bw()
}
```
Генерация первичной расстановки
-------------------------------
Конечно же, и для этой задачи можно использовать Монте-Карло. Но только далеко не факт, что на малых выборках подберется оптимальная конфигурация. На больших выборках при неограниченном количестве состояний (а пространство круга содержит бесконечное количество точек) и неудачном коде не хватит никаких вычислительных ресурсов.
Но есть выход — можем вспомнить физику.
Предположим, что мы накидаем в круглую плоскую чашку `N` одинаково заряженных шариков. Они либо найдут устойчивую конфигурацию с минимум энергии, либо возникнут колебания. Непосредственно в этой задаче с большой вероятностью будет найдено стабильное расположение (из практики). Попробуем провести такую же симуляцию для расстановки зондов. Наделим каждый зонд единичным зарядом с единичной массой, радиус нашего картофельного поля выберем единичным. Для того, чтобы зонды не разлетелись в бесконечность, вокруг нашего поля поставим заряженных неподвижных «охранников». И проведем симуляцию для случайной первичной расстановки.
**Генерация первичной расстановки**
```
# Генерим точки-зонды внутри окружности единичного радиуса.
# Считаем, что все частицы единичного заряда, поэтому его опускаем
charges_dt <- tibble(idx = 1:13) %>%
mutate(angle = runif(n(), min = 0, max = 2*pi),
r = runif(n(), min = 0, max = 1),
x = r * cos(angle), y = r * sin(angle)) %>%
select(idx, x, y) %>%
setDT(key = "idx")
# для сходимости задачи генерируем также зафиксированные точки на внешней окружности
keepers_dt <- max(charges_dt$idx) %>%
{tibble(idx = (. + 1):(. + 40))} %>%
mutate(angle = (idx - 1) * (2 * pi / n()),
x = 1.3 * cos(angle), y = 1.3 * sin(angle)) %>%
select(idx, x, y) %>%
setDT(key = "idx")
```
Посмотрим, как расположились зонды при первичной установке.
**Визуализируем**
```
full_dt <- rbindlist(list(charges_dt, keepers_dt))
drawDisk(full_dt)
```
Поиск оптимального расположения
-------------------------------
Здесь задействуем физику, расчитаем малое перемещение частиц за счет действия на них cилы электростатического взаимодействия (закон Кулона).
Для упрощения задачи будем считать:
* каждую новую итерацию как движение из статичного состояния (как-бы случайная расстановка зондов);
* все зонды обладают единичным зарядом и единичной массой.
Для малых изменений получаем
Будем итеративно двигать, пока равнодействующие сил на зонды не станут меньше определенного порога.
**Поиск оптимального расположения**
```
max_force <- 10
tic("Balancing charges")
# Определяем точность моделирования!
# Будем двигать заряды пока они не застабилизируются
# Максимальная равнодействуюущая будет близка к 0
# и точки не стали разлетаться в бесконечность
while (max_force > 0.05 & nrow(charges_dt[x^2 + y^2 > 1.2]) == 0) {
# общий пул координат частиц на текущую итерацию
full_dt <- rbindlist(list(charges_dt, keepers_dt), fill = TRUE)
ff <- function(x0, y0){
# сила взаимодействия -- 1/r2, заряды единичные;
# проекция силы на оси, sqrt(r2) -- гипотенуза
# суперпозиция векторов даст результирующее воздействие на частицу
dx = full_dt$x - x0
dy = full_dt$y - y0
r2 = dx^2 + dy^2
# na.rm исключает NaN в т.ч.
list(sum(-dx * r2^(-1.5), na.rm = TRUE),
sum(-dy * r2^(-1.5), na.rm = TRUE))
}
# проведем расчет сил, итерируем по каждой "неприбитой гвоздями" точке
charges_dt[, c("force_x", "force_y") := ff(x0 = x, y0 = y), by = idx]
# определим максимальную силу, действующую на частицу
max_force <- charges_dt[, max(sqrt(force_x^2 + force_y^2), na.rm = TRUE)]
force_scale = if_else(max_force > 1, 1 / max_force / 1e2, 1/ max_force / 5e2)
# проводим передвижение точек
charges_dt %>%
.[, `:=`(x = x + force_x * force_scale,
y = y + force_y * force_scale)]
}
toc()
full_dt <- rbindlist(list(charges_dt, keepers_dt), fill = TRUE)
```
Оптимизация маршрута обхода
---------------------------
Для выбора оптимального маршрута опять же используем Монте-Карло. Ряд соображений:
* для генерации подмножества обходов используем комбинаторные функции;
* для каждого зонда добавим фиктивные точки входа и выхода, которые будут находиться на окружности вдоль радиуса, проходящего через зонд (кратчайший маршрут);
* для сокращения временных затрат сделаем однократный расчет матриц расстояний.
**Оптимизация маршрута обхода**
```
optimizePath <- function(dt) {
# попробуем оптимизировать маршрут обхода по предоставленным точкам
# 1. Выбираем в качестве начальной точки датчик, максимально близко расположенный к краю поля
dt[, r0 := sqrt(x^2+y^2)] %>%
setorder(-r0)
n1 <- dt[1, idx]
# теперь проводим симуляцию различных вариантов расстановки сенсоров
# получаем последовательность номеров и убираем n1, его будем принудительно ставить первым
points_in <- dt[idx != n1, idx]
# для каждой точки добавим еще ближайшую точку выхода
# (перпендикуляр к окружности, которая единичного радиуса)
augment_tbl <- dt %>%
mutate_at("idx", `*`, -1) %>%
mutate(r0 = sqrt(x^2 + y^2)) %>%
mutate_at(vars(x, y), ~(.x/r0)) %>%
bind_rows(dt) %>%
select(idx, x, y)
# однократно посчитаем матрицу расстояний между зондами
ll_tbl <- unique(augment_tbl$idx) %>%
tidyr::expand_grid(l = ., r = .) %>%
filter(l != r, (l > 0 | r > 0)) %>%
# построим уникальный идентификатор ребра
rowwise() %>%
# mutate(m = list(sort(c(l, r))))
mutate(edge_id = stri_c(sort(c(l, r)), collapse = "=")) %>%
ungroup() %>%
distinct(edge_id, .keep_all = TRUE) %>%
# подтягиваем координаты левой точки
left_join(select(augment_tbl, idx, l_x = x, l_y = y), by = c("l" = "idx")) %>%
# подтягиваем координаты левой точки
left_join(select(augment_tbl, idx, r_x = x, r_y = y), by = c("r" = "idx")) %>%
mutate(s = sqrt((l_x - r_x)^2 + (l_y - r_y)^2)) %>%
arrange(l, r)
points_seq <- arrangements::permutations(v = points_in, replace = FALSE,
layout = "column", nsample = 5000)
# добавляем точку входа в качестве первой и соотв. точку выхода в качестве последней
routes_lst <- points_seq %>%
rbind(-n1, n1, ., -tail(., 1)) %>%
as.data.frame() %>% as.list()
# превращаем все пути обхода в последовательности ребер
routes_dt <- data.table(route_id = seq_along(routes_lst), route = routes_lst) %>%
.[, .(from = unlist(route)), by = route_id] %>%
.[, to := shift(from, type = "lead"), by = route_id] %>%
# выкидываем все терминальные точки
na.omit() %>%
# строим нормализованный идентификатор ребра
.[, edge_id := stri_c(sort(unlist(.BY)), collapse = "="), by = .(from, to)] %>%
.[, .(route_id, edge_id)] %>%
# подтянем информацию о длине ребра из справочника
.[as.data.table(ll_tbl), s := i.s, on = "edge_id"]
# считаем длину маршрутов, оставляем кратчайший
best_routes <- routes_dt[, .(len = sum(s)), by = route_id] %>%
setorder(len) %>%
head(10) %T>%
print()
# сформируем ТП-10 лучших маршрутов
best_routes %>%
select(route_id) %>%
mutate(idx = routes_lst[route_id]) %>%
tidyr::unnest(idx) %>%
left_join(augment_tbl) %>%
tidyr::nest(data = -route_id) %>%
left_join(best_routes)
}
```
Получаем табличку подобного рода
```
route_id len
1: 2070 8.332854
2: 2167 8.377680
3: 4067 8.384417
4: 3614 8.418678
5: 5000 8.471521
6: 4495 8.542041
7: 2233 8.598278
8: 4430 8.609391
9: 2915 8.616048
10: 3380 8.695547
```
И посмотрим результат размещения
**Визуализируем**
```
tic("Route optimization")
best_tbl <- optimizePath(charges_dt)
toc()
best_route_tbl <- best_tbl$data[[1]]
full_dt <- rbindlist(list(best_route_tbl, keepers_dt), fill = TRUE)
gp <- drawDisk(full_dt) +
# добавим маршрут обхода
geom_path(arrow = arrow(type = "closed"), data = best_route_tbl)
gp
```
Формирование задания
--------------------
У нас есть пачка оптимальных расстановок, минимизированных по обходу. Переводим условные координаты в GPS, формируем маршрут обхода и выдаем GPS трекер агроному. Можно ставить зонды.
Полезные трюки
==============
Как всегда, затронем вопросы производительности. Если писать «не думая», то можно отправить машину на счет на часы или дни. `tidyverse` подход оказывается медленнее в $10^3$-$10^4$ раз. В приведенном выше коде расчеты по блокам занимают доли секунды. Этого достаточно для обычной задачи, но если нужно быстрее, то можно делать вставки на C++. В целом, скоростные характеристики достигаются результат рядом мер и методик.
1. Для небольших циклических расчетов накладные расходы на разыменовывание переменных даже в `data.table` могут оказаться значительными. Base R в блоке поиска оптимального расположения дает выйгрыш на порядок.
2. Если задачу можно распараллелить, то надо применять функциональные подходы. Проще будет сделать последующее распараллеливание.
3. Для однородных величин работа с матрицами оказывается на несколько порядков быстрее работы с `data.frame`. Связано это со схемой выделения памяти и адресации к элементам. Про матрицы незаслуженно забывают при погружении в `tidyverse`.
4. Все, что можно посчитать однократно и оформить в виде справочной таблицы, должно быть посчитано заранее.
5. Монте-Карло — очень хороший подход. Быстрое первичное применение может дать полезный результат, а также взглянуть на решение задачи и, возможно, найти какие-то упрощения и аналитики.
6. Не стесняемся использовать методы аналогии. Они могут позволить построить упрощенную модель исходной задачи, которая вычислительно существенно проще исходной и легко перекладывается на Монте-Карло.
Предыдущая публикация — [«Дети, русский язык и R»](https://habr.com/ru/post/548888/). | https://habr.com/ru/post/550752/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.