text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# «Eppur si muove!»* или Работаем с таймзонами в Python
На нашей планете Земля, в одно и то же время, в разных географических точках планеты может быть разное время суток. Это следствие того, что наш мир — вращающийся геоид, а не плоский диск, а что наша Солнечная система имеет только одну звезду — Солнце. Ещё со школы всем известно о часовых поясах, и все мы встречались с их проявлениями в реальной жизни («Московское время – 15 часов, в Петропавловске-Камчатском – полночь», джетлаг при дальних перелётах, и т.д.). К несчастью, часовые пояса всего лишь частично основаны на физических особенностях нашего мира, и при компьютерных вычислениях приходится учитывать другие, порой неожиданные, нюансы.
\* «И всё-таки она вертится!» — крылатая фраза, которую якобы произнёс Галилео Галилей, покидая процесс инквизиции после отречения от своего убеждения в том, что Земля вращается вокруг Солнца. В нашем случае, увы, это вращение приводит ко всем этим «замечательным» проблемам с часовыми поясами.
Что общего у этой статьи и Галилео? Да, в общем-то, ничего. Боюсь, что если бы наш мир был центром вселенной, нам всё равно пришлось бы иметь дело с таймзонами. Будем считать заголовок моей оплошностью, которую я уже не могу исправить (хотя я могу).
Что такое «Часовой пояс»?
=========================
Какой у вас часовой пояс? Если вы ответите «UTC+3» — это будет правильным ответом только на текущий момент времени, но в целом это заявление некорректно. Если вы посмотрите на базу данных часовых поясов, то увидите, к примеру, что Берлин и Вена, несмотря на смещение «UTC+1», имеют разные часовые пояса («Europe/Berlin» и «Europe/Vienna»). Почему так? Причина в том, что они имели разное летнее время (DST) в разные периоды истории. Даже если сегодня эти две страны и эти два города имеют одинаковые правила DST, сто лет назад это было не так. Например, и в Австрии и в Германии в разные периоды времени не было перехода на летнее время: в Австрии с 1920 года, а в Германии с 1918. Во время Второй мировой войны обе страны имели одинаковые правила DST (что не удивительно), однако после её окончания снова рассинхронизировались. Германия отменила переход на летнее время в 1949 и ввела его снова в 1979, Австрия же отменила DST в 1948 и ввела его снова в 1980. Самое же худшее состоит в том, что они даже не согласовали одинаковую дату перехода на летнее время.
И так происходит по всему миру. Для компьютерных вычислений, переход на летнее время — огромная проблема, ведь мы предполагаем, что время имеет непрерывный мотононный ход. С переходом на летнее время у нас каждый год есть час, который повторяется дважды, и есть час, который мы просто пропускаем. Если при записи в лог вы указываете локальное время, у вас можем нарушится порядок строк лога при сортировке.
Цитата из документации pytz:
> Так, например, в таймзоне US/Eastern в 2002 году во время окончания действия DST, 27 октября время 01:30 наступило дважды, а во время начала действия DST, 7 апреля время 02:30 не наступило, т.к. в 02:00 часы перевели на час вперёд.
Но в таймзонах хранятся не только правила перехода на летнее время. Некоторые страны меняют часовые пояса, иногда даже без изменения DST. Так, например, в 1915 году Варшава перешла на Центральноевропейское время. В результате в полночь 5 августа 1915 года часы были переведены на 24 минуты назад (при этом в Варшаве действовало летнее время).
Вообще, с часовыми поясами творится ещё больший ад. Есть как минимум одна страна, таймзона которой была различна в течение дня из-за синхронизации времени 0:00 с временем восхода Солнца.
Где же здравый смысл?
=====================
Здравый смысл есть и он называется Всемирное координированное время (UTC). UTC — это таймзона без перехода на летнее время и без каких бы то ни было изменений в прошлом. Однако по причине того, что наша Земля — вращающийся геоид и в мире есть вещи, которые мы не можем контролировать, существует проблема корректировочных секунд (leap seconds). Будет ли UTC учитывать корректировочные секунды (которые нерегулярны и поэтому их достаточно проблематично учитывать при вычислениях), или не будет (тогда каждая таймзона будет иметь разницу в несколько секунд с UTC), — насколько мне известно, ещё не решено.
Несмотря на это, прямо сейчас UTC — самый безопасный вариант. Из UTC вы можете сконвертировать время в локальное для любого часового пояса. Обратное преобразование, учитывая вышесказанное, невозможно.
Итак, вот главное практическое правило, которое никогда вас не подведёт:
> **Всегда храните и работайте со временем в UTC**. Если вам нужно сохранить оригинальные данные — пишите их отдельно. Никогда не храните локальное время и таймзону!
В чём проблема?
===============
Вообще, на этом статья должна была бы закончиться. Но к несчастью, есть пара вещей, которые необходимо держать в памяти, когда вы программируете на Python. Это наследие архитектурных решений тех давних времён, когда никто не думал о практическом применении языка. Мотивация имела значение, здравый смысл — нет.
В один прекрасный день были приняты следующие решения об архитеутуре модуля datetime стандартной библиотеки Python:
1. Модуль datetime не должен хранить информацию о таймзонах, потому что таймзоны меняются слишком часто.
2. С другой стороны, модуль datetime должен давать возможность добавлять в себя информацию о таймзоне (tzinfo).
3. В модуле datetime должны быть реализованы следующие объекты: date, time, date+time, timedelta.
К несчастью, что-то пошло не так. Основная проблема заключается в том, что объект datetime, в который была добавлена информация о таймзоне (tzinfo), не будет взаимодействовать с объектом datetime без таймзоны:
```
>>> import pytz, datetime
>>> a = datetime.datetime.utcnow()
>>> b = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
>>> a < b
Traceback (most recent call last):
File "", line 1, in
TypeError: can't compare offset-naive and offset-aware datetimes
```
Если закрыть глаза на тот ужасный API, с помощью которого вам приходится добавлять информация о таймзоне к объекту datetime, всё равно остаются проблемы. Когда вы работаете с объектами datetime в Питоне, вам рано или поздно придётся добавлять или удалять tzinfo во всех местах вашей программы.
Другая проблема состоит в том, что у вас есть два способа создать объект datetime с текущим временем в Python:
```
>>> datetime.datetime.utcnow()
datetime.datetime(2011, 7, 15, 8, 30, 55, 375010)
>>> datetime.datetime.now()
datetime.datetime(2011, 7, 15, 10, 30, 57, 70767)
```
Один возвращает время в UTC, другой — локальное время. Однако объект datetime не скажет вам, что такое «локальное время» (потому что он не имеет информации о таймзоне, по крайней мере до версии Python 3.3), и нет никакого способа узнать, который из этих объектов хранит время в UTC.
Если вы конвертируете UNIX timestamp в объект datetime, вам так же следует быть осторожным при использовании метода datetime.datetime.utcfromtimestamp, потому что он принимает timestamp в локальном времени.
Библиотека datetime так же предоставляет объекты date и time, в которые абсолютно бесполезно добавлять tzinfo. Объект time не может быть переведён в другую таймзону, поскольку для этого нужно знать дату. Объект date вообще имеет смысл только для локальной таймзоны, потому что «сегодня» для меня может быть «вчера» или «завтра» для вас — скажем спасибо чудесному миру часовых поясов.
Так каковы рекомендации специалистов?
=====================================
Теперь мы знаем, кто виноват. Но что делать? Если мы проигнорируем теоретические проблемы, проявляющиеся только в случае работы с историческими датами в прошлом, то вот вам ряд рекомендаций. На тот случай, если вам приходится работать с историческими датами, есть альтернативный модуль mxDateTime, достаточно качественно спроектированный и даже поддерживающий различные календари (Григорианский и Юлианский).
### Используйте UTC внутри программы
Если вам нужно получить текущее время, всегда используйте datetime.datetime.utcnow(). Если вы получаете локальное время от пользователя, всегда тут же преобразовывайте его в UTC. Если однозначного преобразования сделать не получается — сообщайте об этом пользователю, не пытайтесь угадать его время вслепую. Во время перехода на летнее время и обратно, мой iPhone несколько раз не смог правильно перевести время. Я же знаю, когда это нужно сделать, поскольку мне приходится переводить стрелочные часы.
### Никогда не используете время с часовым поясом
Это может показаться вам хорошей идеей — всегда добавлять информацию о часовом поясе к объектам datetime, но на самом деле гораздо лучшая идея — не делать этого. Хорошим решением будет использование объекта datetime без tzinfo и с временем по UTC. Учитывайте тот факт, что вы не можете сравнивать время с таймзоной с временем без неё, так же, как не можете смешивать bytes и unicode в Python 3. Используете этот недостаток API в своих целях.
1. Внутри программы всегда используйте объекты datetime без tzinfo с временем по UTC.
2. Когда вы взаимодействуете с пользователем, всегда конвертируйте его локальное время UTC и обратно.
Почему вам не нужно добавлять tzinfo в объект datetime? Во-первых, потому, что подавляющая часть библиотек ожидает, что tzinfo будет равно None. Во-вторых, это ужасная идея всегда работать с tzinfo, учитывая кривое API работы с ним. В библиотеке pytz есть альтернативные функции для конвертирования таймзон, потому что реализованное в стандартной библиотеке API для преобразования tzinfo недостаточно гибкое, чтобы работать с большинством реальных таймзон. Если мы не будем использовать объекты tzinfo, есть шанс, что в будущем всё изменится к лучшему.
Другая причина не использовать время с таймзоной заключается в том, что объект tzinfo очень специфичен и сильно зависит от своей реализации. Не существует стандартного способа передавать информацию о таймзоне (за исключением, пожалуй, таймзоны UTC) в другие языки, по HTTP и т.д. К тому же объекты datetime с информацией о таймзоне, зачастую, становятся слишком огромными при сериализации с помощью модуля pickle, или их даже невозможно бывает сериализовать (это зависит от реализации объекта tzinfo).
### Преобразования для форматирования
Если вам нужно показать время в таймзоне пользователя, возьмите объект datetime с временем по UTC, добавьте в него таймзону UTC, преобразуйте время в локальное время пользователя и отформатируйте его. Не используйте преобразование таймзоны методами tzinfo, ибо они работают некорректно, используйте pytz. Потом переведите время в «наивное» путём отбрасывания смещения таймзоны из получившегося объекта datetime, который вы создали для форматирования и продолжайте жить счастливо.
*Перевёл [Dreadatour](https://habrahabr.ru/users/dreadatour/), текст читал %username%.*
---
### Бонус от переводчика для тех, кто дочитал до конца:
Шикарное видео от Tom Scott про таймзоны:
А в [следующей своей статье](http://habrahabr.ru/company/mailru/blog/242645/) я напишу, где автор неправ, почему он ошибается и как же всё-таки нужно делать правильно. | https://habr.com/ru/post/242615/ | null | ru | null |
# Enumerable: How to yield a business value
This article is a brief explanation about how using a common language keywords might have an influence on the budget of IT-infrastructure of a project or help to achieve some limitations/restrictions of hosting infrastructure and, moreover, will be a good sing of the quality and maturity of the source code.
For the demonstration of ideas, in the article will be using C# language, but most of the ideas may be translated into other languages.
From the set of language's features, from my point of view, 'yield' is the most undervalued keyword. You can read the documentation and find a huge bunch of examples on the Internet. To be short, let's say that 'yield' allow creating 'iterators' implicitly. By design, an iterator should expose an IEnumerable source for 'public' usage. And here the tricky starts. Because we have a lot of implementations of IEnumerable in the language: list, dictionary, hashset, queue and etc. And from my experience, the choice of one of them for satisfaction requirements of some business task is wrong. Moreover, all of this is aggravated by whatever implementation is chosen, the program 'just works' — this is what really needs for business, isn't it? Commonly, it works, but only until the service is deployed into a production environment.
For a demonstration of the problem, I suggest choosing very common business case/flow for most enterprise project which we can extend during the article and substitute some part of this flow for understanding a scale of influence this approach on enterprise projects. And it should help you to find your own case in this set to fix it.
Example of the task:
1. Load byline a set of records from a file or DB into memory.
2. For each column of the record change the value to someone other value.
3. Save the results of transformation into a file or DB.
Let's assume several cases where this logic may be applicable. At this moment, I see two cases:
1. It is maybe a part of flow for some console ETL application.
2. It is maybe a logic inside of action in Controller of MVC application .
If we paraphrase the task into a more technical manner, so it may be sound like this: "(1)Allocate an amount of memory, (2) load information into memory from persistence storage, (3)modify and (4)flush records changes in memory to the persistence storage." Here the first phrase in the description "(1)Allocate an amount of memory" may have a real correlation to your non-functional requirements. Because your job/service should 'live' in some hosting environment which may have some limitations/restrictions(for instance, 150Mb per micro-service) and to predict spendings on your service in budget, we should predict, in our case amount of memory which service will use (commonly we say about maximum amounts of memory). In other words, we should determine a memory 'footprint' for your service.
Let's consider a memory footprint for really common implementation which I observe from time to time in different codebases of enterprise projects. Also, you can try to find it in your projects too, for example, 'under the hood' of 'repository' pattern implementation, just try to find such words: 'ToList', 'ToArray', 'ToReadonlyCollection' and etc. All of such implementation means that:
1. For each line/record into file/db, allocates memory to hold properties of record from file/db (i.e. var user = new User() { FirstName = 'Test', LastName = 'Test2' })
2. Next, with help of, for example, 'ToArray' or manually, object's references are held into some collection (i.e. var users = new List(); users.Add(user)). So, it is allocated some amount of memory for each record from a file and not to forget about it, the reference is stored into some collection.
Here is an example:
```
private static IEnumerable LoadUsers2()
{
var list = new List();
foreach(var line in File.ReadLines("text.txt"))
{
var splittedLine = line.Split(';');
list.Add(new User()
{
FirstName = splittedLine[0],
LastName = splittedLine[1]
});
}
return list;
// or
return File.ReadLines("text.txt")
.Select(line => line.Split(';'))
.Select(splittedLine => new User()
{
FirstName = splittedLine[0],
LastName = splittedLine[1]
}).ToArray();
}
```
Memory profiler results:
Exactly such picture I saw every time in prodaction environment before container stops/reloads due to hosting's resource limitation per container.
So, a footprint for this case, roughly, depends on the number of records into a file. Because memory allocates per record in the file. And, the sum of this small peases of memory give us a maximum amount of memory which may be consumed by our service — it is the footprint of the service. But is this footprint predictable? Apparently, no. Because we can not predict a number of records in the file. And, in most case, the file size exceeds the amount of allowed memory in hosting in several times. It means that it is hard to use such implementation in the production environment.
Looks like it is the moment to re-thinks such implementation. Next assumption may give us more opportunities to calculate a footprint for the service: «a footprint should depend on the size only ONE record in the file». Roughly, in this case, we can calculate the maximum size of each column of only one record and sum them. It is quite easy to predict the size of a record instead of prediction of the number of records in the file.
**And it is really wondered that we can implement a service which may handle an unpredictable amount of records and constantly consumes only a couple of megabytes with help only one keyword — 'yield'\*.**
The time for an example:
```
class Program
{
static void Main(string[] args)
{
// 1. Load byline a set of records from a file or DB into memory.
var users = LoadUsers();
// 2. For each column of the record change the value to someone other value.
users = ModifyFirstName(users);
// 3. Save the results of transformation into a file or DB.
SaveUsers(users);
}
private static IEnumerable LoadUsers()
{
foreach(var line in File.ReadLines("text.txt"))
{
var splitedLine = line.Split(';');
yield return new User()
{
FirstName = splitedLine[0],
LastName = splitedLine[1]
};
}
}
private static IEnumerable ModifyFirstName(IEnumerable users)
{
foreach (var user in users)
{
user.FirstName += "\_1";
yield return user;
}
}
private static void SaveUsers(IEnumerable users)
{
foreach(var user in users)
{
File.AppendAllLines("results.txt", new string []{ user.FirstName + ';' + user.LastName });
}
}
private class User
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
}
```
As you can see in the example above, there is allocates memory only for one object at a time: 'yield return new User()' instead of creating a collection and fills it with objects. It is the main point of optimization which allows us to calculate more predictable memory footprint for the service. Because we only need to know the size of two fields, in our case FirstName and LastName. When a modified user is saved into file (see File.AppendAllLines), the instance of the user object is available for garbage collection. And memory which is occupied by the object is deallocated (i.e. the next iteration of 'foreach' statement in LoadUsers), so the next instance of user object may be created. In other words, roughly, the same amount of memory replaces by the same amount of memory on each iteration. That is why we no need more memory than the size of a single record in the file.
Memory profiler results after optimization:
From another perspective, if we slightly rename a couple of methods in the implementation above, so that use can notice some meaningful logic for Controllers in MVC application:
```
private static void GetUsersAction()
{
// 1. Load byline a set of records from a file or DB into memory.
var users = LoadUsers();
// 2. For each column of the record change the value to someone other value.
var usersDTOs = MapToDTO(users);
// 3. Save the results of transformation into a file or DB.
OkResult(usersDTOs);
}
```
One important note before code listing: most of the important libraries like EntityFramework, ASP.net MVC, AutoMapper, Dapper, NHibernate, ADO.net and etc expose/consume IEnumerables sources. So, it means in the example above that LoadUsers may be replaced by an implementation which uses EntityFramework, for example. Which loads data row by row from the DB table, instead of a file. MapToDTO may be replaced by Automapper and OkResult may be replaced by a 'real' implementation of IActionResult in some MVC framework or our own implementation base on network stream, for example:
```
private static void OkResult(IEnumerable users)
{
// you can use a networksteam implementation
using(StreamWriter sw = new StreamWriter("result.txt"))
{
foreach(var user in users)
{
sw.WriteLine(user.FirstName + ';' + user.LastName);
}
}
}
```
This 'mvc-like' example shows us that we still able to predict and calculate a memory footprint also for Web-application. But in this case, it will be depends on requests count also. For example, the non-functional requirements may sound in this way: «Maximum memory amount for 1000 request not more then: 200KB per user object x 1000 requests ~ 200MB».
Such calculations are very useful for performance optimization in case of scaling the web application. For instance, you need to scale your web application on 100 containers/VMs. So, in this case, to make a decision about how much resources you should allocate from hosting provider, so you can adjust the formula like this: 200KB per user object x 1000 requests x 100VMs ~ 20GB. Moreover, this is the maximum amount of memory and this is amount is under the control of your project's budget.
I hope that information from this article will be helpful and allow to save a lot of money and time in your projects. | https://habr.com/ru/post/444358/ | null | en | null |
# Как сделать программу на Go быстрее на 42%, изменив один символ
Если вы прочитали заголовок и подумали «ну, ты, наверно, сделал сначала что-то глупое», то вы правы! Но что такое программирование, как не упражнения в глупых ошибках? Поиск глупых ошибок — это и есть самое большое удовольствие!
Также стоит заранее сделать оговорку о бенчмаркинге: ускорение на 42% было замерено при выполнении программы с моими данными и на моём компьютере, поэтому относитесь к этому результату с долей скепсиса.
Что делает программа?
---------------------
[codeowners](https://github.com/hmarr/codeowners) — это программа на Go, выводящая владельцев каждого из файлов в репозитории согласно набору правил, указанному в [`файле GitHub CODEOWNERS`](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners#codeowners-syntax). Правило может гласить, что всеми файлами с расширением `.go` владеет команда `@gophers`, или что всеми файлами в папке `docs/` владеет команда `@docs`.
При анализе указанного пути побеждает правило, которое совпало последним. Простой, но наивный алгоритм сопоставления итеративно обходит правила для каждого пути, останавливаясь в случае нахождения соответствия. Существуют и более умные алгоритмы, но это уже тема для отдельной статьи. Вот как выглядит функция `Ruleset.Match`:
```
type Ruleset []Rule
func (r Ruleset) Match(path string) (*Rule, error) {
for i := len(r) - 1; i >= 0; i-- {
rule := r[i]
match, err := rule.Match(path)
if match || err != nil {
return &rule, err
}
}
return nil, nil
}
```
Поиск медленных фрагментов при помощи pprof и flamegraph
--------------------------------------------------------
При обработке умеренно крупного репозитория мой инструмент работал немного медленно:
```
$ hyperfine codeowners
Benchmark 1: codeowners
Time (mean ± σ): 4.221 s ± 0.089 s [User: 5.862 s, System: 0.248 s]
Range (min … max): 4.141 s … 4.358 s 10 runs
```
Чтобы понять, на какие части программа тратит своё время, я записал профиль CPU при помощи pprof. Сгенерировать профиль CPU можно, добавив в начало функции `main` следующий фрагмент кода:
```
pprofFile, pprofErr := os.Create("cpu.pprof")
if pprofErr != nil {
log.Fatal(pprofErr)
}
pprof.StartCPUProfile(pprofFile)
defer pprof.StopCPUProfile()
```
*Примечание: я пользуюсь pprof довольно активно, поэтому сохранил этот код в виде [сниппета vscode](https://code.visualstudio.com/docs/editor/userdefinedsnippets). Я просто ввожу `pprof`, жму tab, и появляется этот сниппет.*
У Go есть удобный интерактивный инструмент для визуализации профилей. Я визуализировал профиль в виде flamegraph, запустив следующую команду, а затем перейдя в режим flamegraph из меню в верхней части страницы.
```
$ go tool pprof -http=":8000" ./codeowners ./cpu.pprof
```
Как я и ожидал, основную часть времени программа тратила на функцию `Match`. Паттерны CODEOWNERS компилируются в регулярные выражения, и бо́льшая часть времени функции `Match` тратилась на движок regex языка Go. Но также я заметил, что много времени тратилось на распределение и возвращение памяти. Сиреневые блоки в показанном ниже flamegraph соответствуют паттерну `gc|malloc`, и видно, что суммарно они составляют существенную часть времени выполнения программы.
Охота на распределения кучи при помощи трассировок escape-анализа
-----------------------------------------------------------------
Давайте посмотрим, есть ли какие-то распределения, от которых можно избавиться, чтобы снизить давление GC и уменьшить время, занимаемое `malloc`.
Чтобы разобраться, когда какая-то память должна продолжать жить в куче, компилятор Go использует методику под названием «escape-анализ». Допустим, функция инициализирует struct, а затем возвращает указатель на неё. Если struct распределена в стеке, возвращённый указатель станет недействительным сразу после возврата функции и инвалидации соответствующего кадра стека. В этом случае компилятор Go определит, что указатель «сбежал» от функции и переместит struct в кучу.
Посматривать, как принимаются эти решения, можно, передавая `-gcflags=-m` команде `go build`:
```
$ go build -gcflags=-m *.go 2>&1 | grep codeowners.go
./codeowners.go:82:18: inlining call to os.IsNotExist
./codeowners.go:71:28: inlining call to filepath.Join
./codeowners.go:52:19: inlining call to os.Open
./codeowners.go:131:6: can inline Rule.Match
./codeowners.go:108:27: inlining call to Rule.Match
./codeowners.go:126:6: can inline Rule.RawPattern
./codeowners.go:155:6: can inline Owner.String
./codeowners.go:92:29: ... argument does not escape
./codeowners.go:96:33: string(output) escapes to heap
./codeowners.go:80:17: leaking param: path
./codeowners.go:70:31: []string{...} does not escape
./codeowners.go:71:28: ... argument does not escape
./codeowners.go:51:15: leaking param: path
./codeowners.go:105:7: leaking param content: r
./codeowners.go:105:24: leaking param: path
./codeowners.go:107:3: moved to heap: rule <<< --------- перемещение в кучу
./codeowners.go:126:7: leaking param: r to result ~r0 level=0
./codeowners.go:131:7: leaking param: r
./codeowners.go:131:21: leaking param: path
./codeowners.go:155:7: leaking param: o to result ~r0 level=0
./codeowners.go:159:13: "@" + o.Value escapes to heap
```
Вывод выглядит немного зашумлённым, однако бо́льшую его часть можно игнорировать. Так как мы ищем распределения, нас должна волновать фраза `moved to heap`. Если посмотреть на приведённый выше код `Match`, можно увидеть, что структуры `Rule` хранятся в слайсе `Ruleset`, насчёт которого мы можем уверены, что он уже находится в куче. И поскольку возвращается указатель на rule, не должны требоваться никакие дополнительные распределения.
И тут я понял: присваивая `rule := r[i]`, мы *копируем* распределённое в куче `Rule` из слайса в стек, а возвращая `&rule`, мы создаём указатель («сбегающий») на копию struct. К счастью, исправить это легко. Нам нужно просто переместить амперсанд немного выше, чтобы мы получали ссылку на struct в слайсе, а не копировали её:
```
func (r Ruleset) Match(path string) (*Rule, error) {
for i := len(r) - 1; i >= 0; i-- {
rule := &r[i] // вместо rule := r[i]
match, err := rule.Match(path)
if match || err != nil {
return rule, err // вместо return &rule, err
}
}
return nil, nil
}
```
я рассмотрел и два других подхода:
1. Превращение `Ruleset` из `[]Rule` в `[]*Rule`, что означало бы, что нам больше не нужно явным образом получать ссылку на правило.
2. Возврат `Rule` вместо `*Rule`. Это всё равно скопирует `Rule`, но оно должно остаться в стеке, а не переместиться в кучу.
Однако оба эти подхода привели бы к критическому изменению, поскольку этот метод является частью публичного API.
Как бы то ни было, после внесения этого изменения мы можем проверить, дало ли оно желаемый эффект, получив от компилятора новую трассировку и сравнив её со старой:
```
$ diff trace-a trace-b
14a15
> ./codeowners.go:105:7: leaking param: r to result ~r0 level=0
16d16
< ./codeowners.go:107:3: moved to heap: rule
```
Успех! Распределение пропало. Теперь посмотрим, как удаление этого одного распределения кучи повлияло на производительность:
```
$ hyperfine ./codeowners-a ./codeowners-b
Benchmark 1: ./codeowners-a
Time (mean ± σ): 4.146 s ± 0.003 s [User: 5.809 s, System: 0.249 s]
Range (min … max): 4.139 s … 4.149 s 10 runs
Benchmark 2: ./codeowners-b
Time (mean ± σ): 2.435 s ± 0.029 s [User: 2.424 s, System: 0.026 s]
Range (min … max): 2.413 s … 2.516 s 10 runs
Summary
./codeowners-b ran
1.70 ± 0.02 times faster than ./codeowners-a
```
Так как это распределение происходило для *каждого сопоставляемого пути*, его удаление дало в моём случае увеличение скорости в 1,7 раза (то есть программа начала работать на 42% быстрее). Неплохой результат для изменения в один символ. | https://habr.com/ru/post/699538/ | null | ru | null |
# Быстрое индексное умножение по модулю
Введение
--------
Обычно данный материал приводится с обилием формул и рассчитан больше на математиков. Я постараюсь расписать его наиболее доступно на простых численных примерах с точки зрения применения этого метода в микроэлектронике на аппаратном уровне. В численных примерах для наглядности будет использоваться значение p = 11.
Постановка задачи
-----------------
Положим, что нам требуется выполнить умножение следующего вида: `res = (a*b) mod p`, где
`0 <= a < p`
`0 <= b < p`
`p` – простое число.
`mod p` – операция нахождения остатка по модулю.
И выполнить его надо на низком уровне, где нет как таковой операции умножения и операции взятия остатка от деления или же они реализуются достаточно сложно (например, в электронном устройстве).
Простейшие методы решения
-------------------------
1. Первое что приходит в голову: умножить, потом разделить и взять остаток. Этот подход имеет право на существование, но чрезвычайно затратен по количеству операций и довольно сложен для реализации.
2. Второе, что можно придумать, это реализовать эту операцию двумерной таблицей умножения размера `p` на `p`. Что имеет смысл если `p` мало, однако при росте значения p квадратично растут затраты на хранение таблицы (рис. 1).
*Рисунок 1. Таблица умножения по модулю p для p = 11.*
Умножитель на базе индексного метода
------------------------------------
Однако существует метод, который требует одной (или для удобства двух) таблиц размерности `p`. Метод основан на замене умножения сложением. И может быть схематично проиллюстрирован следующим рисунком (рис. 2):
*Рисунок 2. Индексное умножение.*
Поясним, почему это возможно. Индексное представление числа основывается на понятии первообразного корня по простому модулю `p` [1]. Первообразным корнем w является целое число, возведение которого в степень `0, 1, 2, …, (p-2)` дает неповторяющиеся вычеты по модулю `p`. Первообразный корень всегда существует для любого простого `p` (доказано Гауссом в 1801 году). В этом случае каждому целому числу `q` из промежутка `(0; p)` можно поставить в соответствие число `i` такое что: `q = (w`i`) mod p`. И таким образом получить следующее соответствие:
`(a*b) mod p <-> w^((ia+ib) mod (p-1))` [2].
Рассмотрим пример для модуля `p = 11`. Первообразный корень `w` для этого значения модуля равен 2. Как несложно убедиться возведение `w` в степень 0, 1, … 9 дает неповторяющиеся результаты:
* (20) `mod` 11 = 1 `mod` 11 = 1
* (21) `mod` 11 = 2 `mod` 11 = 2
* (22) `mod` 11 = 4 `mod` 11 = 4
* (23) `mod` 11 = 8 `mod` 11 = 8
* (24) `mod` 11 = 16 `mod` 11 = 5
* (25) `mod` 11 = 32 `mod` 11 = 10
* (26) `mod` 11 = 64 `mod` 11 = 9
* (27) `mod` 11 = 128 `mod` 11 = 7
* (28) `mod` 11 = 256 `mod` 11 = 3
* (29) `mod` 11 = 512 `mod` 11 = 6
Для получения таблицы преобразования между обычным `{q}` и индексным `{i}` представлением необходимо отсортировать полученные пары значений в порядке возрастания. Таким образом, таблица прямого преобразования для модуля `p` = 11 будет выглядеть следующим образом:
| | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| q | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| i | 0 | 1 | 8 | 2 | 4 | 9 | 7 | 3 | 6 | 5 |
А таблица обратного преобразования для модуля `p` = 11 будет выглядеть так:
| | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| q | 1 | 2 | 4 | 8 | 5 | 10 | 9 | 7 | 3 | 6 |
Найдем значение выражения (3\*5) `mod` 11. Числа 3 и 5 имеют соответствующие индексы 8 и 4 (см. таблицу 1). Просуммировав эти индексы по модулю (11-1) = 10 получим результат (8+4) `mod` 10 = 12 `mod` 10 = 2. Из таблицы 2 находим, что обратное преобразование для индекса 2 дает конечный результат, равный 4.
Структурную схему индексного умножителя по модулю m=11 для рассмотренного примера можно посмотреть на следующем рисунке (рис 3):
*Рисунок 3. Схема индексного умножителя для p = 11.*
Нулевые значения для входов
---------------------------
Если внимательно посмотреть на таблицы, то видно, что там не присутствуют нулевые значения для входных данных. Это связано с тем, что `w`i != 0 ни при каких значениях `i`. Этот случай обрабатывается отдельно (либо вводится понятие сингулярности со специальными правилами её обработки). Если на одном из входов умножителя появляется 0, то на выходе тоже будет 0, что непосредственно следует из правил умножения.
Распараллеливание умножителя
----------------------------
Оказывается умножение можно сделать ещё быстрее. Если число `(p-1)` можно разбить на попарно взаимнопростые множители `p-1 = m1*m2*…*mr`, то операция сложения может быть разбита на `r` операций сложений меньшей размерности. В этом случае индекс преобразуется в вектор длины `r`, по следующей формуле: (`i mod m1, i mod m2, …, i mod mr`). А суммирование производится независимо по каждому элементу вектора.
Рассмотрим это на примере. Для `p` = 11 значение `p`-1 = 10 и оно может быть разбито на взаимнопростые множители единственным образом: 10 = 2\*5 (`m1` = 2, `m2` = 5). В этом случае таблица 1 может быть расписана следующим образом:
| | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| q | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| i | 0 | 1 | 8 | 2 | 4 | 9 | 7 | 3 | 6 | 5 |
| (i `mod` 2, i `mod` 5) | (0, 0) | (1, 1) | (0, 3) | (0, 2) | (0, 4) | (1, 4) | (1, 2) | (1, 3) | (0, 1) | (1, 0) |
А таблица обратного преобразования соответственно так:
| | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| (i `mod` 2, i `mod` 5) | (0, 0) | (0, 1) | (0, 2) | (0, 3) | (0, 4) | (1, 0) | (1, 1) | (1, 2) | (1, 3) | (1, 4) |
| q | 1 | 9 | 4 | 3 | 5 | 10 | 2 | 7 | 8 | 6 |
Найдем, как и в прошлом примере, значение (3\*5) `mod` 11. Сначала ищем соответствующие вектора в таблице: 3 -> (0, 3), 5 –> (0, 4). Затем поэлементно складываем ((0 + 0) `mod` 2, (3 + 4) `mod` 5) = (0, 2). Из таблицы обратного преобразования находим ответ: (0, 2) -> 4. Схема параллельного умножителя приведена ниже (рис. 4):
*Рисунок 4. Схема параллельного индексного умножителя для p = 11.*
Как искать первообразный корень?
--------------------------------
Если честно не задавался этим вопросом. Я использую полный перебор, начиная с 2 до p. Либо можно использовать готовую последовательность: [oeis.org/A046145](http://oeis.org/A046145). Если есть более эффективный метод пишите в комментах.
Как проектировать сумматор по модулю (p-1)?
-------------------------------------------
Из-за особенностей входных данных сумматора по модулю `(p-1)`, а именно, что на оба входа приходит число меньше, чем `p-1`, а значит их сумма меньше чем `2*(p-1)`. Из этого следует, что можно использовать любой из стандартных сумматоров, выход которого корректируется по следующему алгоритму: если значение больше или равно `(p-1)`, то вычесть из результата `(p-1)`, иначе оставить без изменений.
Verilog-генератор
-----------------
На досуге я написал он-лайн генератор Verilog'а для реализации индексного умножителя по модулю. Там же рисуется схема его работы.
[Verilog для умножения по модулю 11](http://zcontest.ru/uscr/index-modulo-multiplication.php?p=11)
[Verilog для умножения по модулю 31](http://zcontest.ru/uscr/index-modulo-multiplication.php?p=31)
[Генератор Verilog для произвольного числа до 1000](http://zcontest.ru/uscr/index-modulo-multiplication.php)
Литература
----------
[1] [ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B2%D0%BE%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BD%D1%8B%D0%B9\_%D0%BA%D0%BE%D1%80%D0%B5%D0%BD%D1%8C\_%28%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F\_%D1%87%D0%B8%D1%81%D0%B5%D0%BB%29](http://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B2%D0%BE%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D1%80%D0%B5%D0%BD%D1%8C_%28%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D1%87%D0%B8%D1%81%D0%B5%D0%BB%29)
[2] [www.researchgate.net/publication/224735018\_A\_fast\_RNS\_Galois\_field\_multiplier](http://www.researchgate.net/publication/224735018_A_fast_RNS_Galois_field_multiplier)
От автора
---------
Если у вас есть дополнения по статье буду рад их увидеть в комментариях. И ещё статья получилась бедной на ссылочки с подробностями, если у кого что есть кидайте. =) | https://habr.com/ru/post/149273/ | null | ru | null |
# Неожиданное поведение фильтров исключений в C# 6
### Что такое фильтры исключений?
*Фильтры исключений (Exception Filters)* — новая фича C# 6, которая позволяет устанавливать специфические условия для блока `catch`. Этот блок будет исполнятся только в случае, если указанные условия выполнены. Проиллюстрируем синтаксис небольшим фрагментом кода:
```
public void Main()
{
try
{
throw new Exception("E2");
}
catch(Exception ex) when(ex.Message == "E1")
{
Console.WriteLine("caught E1");
}
catch(Exception ex) when(ex.Message == "E2")
{
Console.WriteLine("caught E2");
}
}
```
### Это правда новая фича?
Для C# — да. Впрочем, поддержка фильтров исключений уже давно присутствует в IL и VB.NET. Даже язык F# поддерживает эти фильтры с помощью механизма под названием exception pattern matching.
### А можем ли мы получить такую функциональность с помощью обычных условных операторов?
Логически — да, но есть фундаментальное отличие. Если условие находится внутри `catch`-блока, то сначала исключение будет поймано, а затем произойдёт проверка условия. Фильтры исключений проверяют условие до поимки исключения. Если условие не выполняется, то `catch`-блок будет пропущен, .NET перейдёт к рассмотрению следующего `catch`-блока.
### Так в чём же разница?
Когда вы ловите исключение, то имеете размотанный стек, т.е. теряете важную информацию об исключении. Существует ошибочное мнение, что если мы выполним `throw` внутри `catch`-блока вместо `throw ex`, то сохраним стек. Дело в том, что люди задумываются только о свойстве исключения `StackTrace`, но не о самом стеке CLR. Давайте рассмотрим пример. Если вы будете пробовать запустить его самостоятельно, то убедитесь, что галочка «Break on Exception» для поимки исключений выключена в настройках Visual Studio (Debug->Exceptions->Uncheck all).
Рассмотрим общий сценарий, в котором мы ловим исключение, логируем его и больше ничего не делаем. Следующее изображение показывает где остановится отладчик в момент бросания исключения. Обратите внимание на строчку остановки отладчика и на окно Locals:
Теперь давайте немного перепишем пример с использованием фильтров исключений. Сделаем так, чтобы метод `Log` всегда возвращал `false` и выполним логирование с помощью фильтров исключений вместо того, чтобы помещать его внутрь `catch`-блока. Снова обратите внимания на строчку остановки отладчика и окно отладчика (*Примечание: пост и пример были обновлены, но картинка осталась прежней; вместо `catch (if(Log()))` следует читать `catch when (Log())`*):
*От переводчика: оригинальная картинка устарела, т. к. в недавнем прошлом синтаксис фильтров исключений немного поменялся: раньше они описывались с помощью ключевого слова `if`, а теперь его заменили на новое ключевое слово `when`. Мотивация хорошо иллюстрируется следующей картинкой:*
Помимо информации о том, где точно произошло исключение, вы также можете видеть в окне Locals второго примера локальную переменную `localVariable`, которая недоступна в первом примере, т. к. внутри `catch`-блока она не находится в стеке. Это соответствует тому, что бы можем видеть в crash-дампах.
Кроме того, если вы вошли в какой-то `catch`-блок, то в остальные уже не войдёте. Если же вы проанализировали условие и решили не выбрасывать его снова, то вы уже не сможете попасть в другие `catch`-блоки. В случае фильтров исключений невыполненное условие не помешает нам проверить остальные `catch`-условия, чтобы попытаться зайти в другой блок.
### Ожидаемое поведение
Таким образом, мы можем указать условие в фильтре исключений; `catch`-блок будет исполняться только в том случае, если условие выполнилось. И мы можем использовать `bool`-функцию в качестве условия. Но что произойдёт, если само условие выбросит исключение? Ожидаемым поведением является следующее: исключение игнорируется, условия считается ложным. Рассмотрим следующий код:
```
class Program
{
public static void Main()
{
TestExceptionFilters();
}
public static void TestExceptionFilters()
{
try
{
throw new Exception("Original Exception");
}
catch (Exception ex) when (MyCondition())
{
Console.WriteLine(ex);
}
}
public static bool MyCondition()
{
throw new Exception("Condition Exception");
}
}
```
В момент выбрасывания исключения `"Original Exception"` перед заходом в `catch`-блок будет проверено условие `MyCondition`. Но это условие само выбрасывает исключение, которое должно быть проигнорировано, а условие должно считаться ложным. Таким образом, мы получим необработанное исключение:
```
System.Exception: Original Exception
```
### Неожиданное поведение
Настало время странного примера. Изменим приведённый выше код так, что вместо прямого вызова метода `TestExceptionFilters()`, этот метод будет вызываться через рефлексию. Ожидаемое поведение остаётся прежним, хоть мы и вызываем функцию иначе.
```
class Program
{
public static void Main()
{
var targetMethod = typeof(Program).GetMethod("TestExceptionFilters");
targetMethod.Invoke(null, new object[0]);
}
public static void TestExceptionFilters()
{
try
{
throw new Exception("Original exception");
}
catch (Exception ex) when (MyCondition())
{
Console.WriteLine(ex);
}
}
public static bool MyCondition()
{
throw new Exception("Condition Exception");
}
}
```
Давайте запустим этот код. Как и ожидалось, мы получим необработанное исключение, но вот только тип исключения будет другим:
```
System.Exception: Condition Exception
```
Таким образом, тип исключения зависит от способа, которым мы взывали функцию. Про этот баг заведён issue на GitHub ([Exception filters have different behavior when invoked via reflection and the filter throws an exception](https://github.com/dotnet/coreclr/issues/410)). На момент написания перевода баг всё ещё присутствует в CoreCLR. Будем надеяться, что кто-нибудь вскоре его поправит.
*От переводчика: данный пост является составным переводом сразу двух постов с сайта [www.volatileread.com](http://www.volatileread.com/): [Unpredictable Behavior With C# 6 Exception Filters](http://www.volatileread.com/Wiki/Index?id=2095) и [C# 6 Exception Filters and How they are much more than Syntactic Sugar](http://www.volatileread.com/Wiki/Index?id=1087)* | https://habr.com/ru/post/252437/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #29
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [HumHub](https://github.com/humhub/humhub)
[](https://github.com/humhub/humhub)
Открытая социальная сеть, построенная на Yii — достойный аналог [Diaspora](https://github.com/diaspora/diaspora). Разработчики вообще говорят, что это фреймворк, который предоставляет инструменты для лёгкой и продуктивной командной работы. Гибкая модульная система и ряд плагинов: заметки, таск-менеджер, календарь, голосование, рассылки и др. Еще HumHub — это очень красиво. Клевый современный интерфейс, асинхронность, всплывающие подсказки и прочие детали.
#### [Impulse](https://github.com/luster-io/impulse)
[](https://github.com/luster-io/impulse)
Потрясающие JS анимации с продуманной физикой. Библиотека больше заточена под мобильные интерфейсы. В [примерах](http://impulse.luster.io/examples.html) вы увидите ряд знакомых вам крутых эффектов из iOS, Android и WP. Больше я не знаю, что написать, это реально нужно увидеть. А с точки зрения кода все типично для «анимационных библиотек».
[Piwik](https://github.com/piwik/piwik)
[](https://github.com/piwik/piwik)
Мощный инструмент для аналитики с открытым исходным кодом, который реально может послужить заменой для Яндекс Метрики или Google Analytics. Информативные графики, множество метрик, куча параметров, цели и прочие необходимости. Сервис достаточно прост в установке, почти для всех популярных CMS существует плагин. В системе есть собственный маркетплейс и обширное комьюнити. Piwik используется на таких масштабных проектах как Wikimedia, Forbes, T-mobile, Sharp и др.
#### [Jsfmt](https://github.com/rdio/jsfmt)
[](https://github.com/rdio/jsfmt)
Небольшой и полезный инструмент от команды разработчиков популярного потокового музыкального сервиса Rdio. Jsfmt позволяет искать, форматировать и производить массовые изменения в JS файлах:
```
# Заменим reduce из underscore.js на родной в `source.js`.
jsfmt --rewrite="_.reduce(a, b, c) -> a.reduce(b, c)" source.js
# Проделаем это снова, но уже с записью на диск.
jsfmt --write=true --rewrite="_.reduce(a, b, c) -> a.reduce(b, c)" source.js
# Заменим выражение в 'source.js' и других файлах в директории node.
jsfmt --rewrite="x % y -> ((x % y) + y) % y" source.js | node
```
А для проверки кода на соответствие с руководством по стилю нет ничего лучше, чем [JSCS](https://github.com/jscs-dev/node-jscs).
#### [Gulp Fiction](http://gulpfiction.divshot.io)
[](http://gulpfiction.divshot.io)
Удобный онлайн сервис для генерации Gulp файлов. Указываем название задачи, пути к исходным и финальными файлами и конечно же выбираем сам плагин, поиск которых осуществляется в режиме реального времени.
#### [Mitro](https://github.com/mitro-co/mitro)
[](https://github.com/mitro-co/mitro)
Mitro — это великолепный менеджер паролей, который представляет из себя расширения для браузеров. Проект полностью бесплатный и оперсорсный (клиент и сервер). Запоминает все пароли из веба и позволяет давать временный доступ к вашим сервисам коллегам, фрилансерам, без передачи самого пароля. Защищенный, простой и универсальный продукт с удобным интерфейсом. «Trusted by Stackoverflow, Google Ventures, Essence, Fitocracy, Architizet».
#### [ImageOptim CLI](https://github.com/JamieMason/ImageOptim-CLI)
Утилита автоматизирует оптимизация сразу 3 программ: [ImageOptim](http://imageoptim.com), [ImageAlpha](http://pngmini.com), и [JPEGmini](http://jpegmini.com/mac). Но есть один минус — все эти инструменты написаны под Mac и соответственно ImageOptim CLI не будет работать на Windows и Linux. Судя по результатам тестов это практически бесспорный победитель, который лишь в некоторых случаях уступает [Kraken.io](https://kraken.io/). Но и разница оптимизация между ними составляет в среднем несколько процентов.
#### Западные мысли или что стоило бы перевести на Хабре:
* [A Beginner’s Guide to Website Speed Optimization](https://kinsta.com/learn/page-speed/)
* [Should publishers really think ‘mobile-first’?](http://digiday.com/publishers/what-publishers-get-wrong-about-mobile-first/)
* [Polyfills as a service](http://labs.ft.com/2014/09/polyfills-as-a-service/)
* [Unicode-range](http://atozcss.com/unicode-range-and-at-font-face/?utm_content=bufferc2345&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [High Performance Map Interactions Using HTML5 Canvas](http://chairnerd.seatgeek.com/high-performance-map-interactions-using-html5-canvas/)
* [Spatial Data Structures for Better Map Interactions](http://chairnerd.seatgeek.com/spatial-data-structures-for-better-map-interactions/)
* [Built-in Browser Support for Responsive Images](http://www.html5rocks.com/en/tutorials/responsive/picture-element/)
* [Radio-Controlled Web Design](http://alistapart.com/article/radio-controlled-web-design)
* [Improving Sass code quality on theguardian.com](http://www.theguardian.com/info/developer-blog/2014/may/13/improving-sass-code-quality-on-theguardiancom)
* [CSS Performance Tooling](https://speakerdeck.com/addyosmani/css-performance-tooling)
* [Refining The Way We Structure Our CSS At Trello](http://blog.trello.com/refining-the-way-we-structure-our-css-at-trello/)
* [CSS Audits: Taking Stock of Your Code](http://alistapart.com/article/css-audits-taking-stock-of-your-code)
* [An Intro to SVG Animation with SMIL](http://codepen.io/noahblon/blog/an-intro-to-svg-animation-with-smil)
* [A Look at SVG Light Source Filters](http://css-tricks.com/look-svg-light-source-filters/?utm_source=dlvr.it&utm_medium=twitter)
* [5 Typical JavaScript Interview Exercises](http://www.sitepoint.com/5-typical-javascript-interview-exercises/)
* [Add Rules to Stylesheets with JavaScript](http://davidwalsh.name/add-rules-stylesheets?adbid=512995555211886592&adbpr=312909595&scid=social31549046)
* [Speed Index: Measuring Page Load Time a Different Way](http://www.sitepoint.com/speed-index-measuring-page-load-time-different-way/?utm_content=buffer3b3b3&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [Prototyping For Better Products, Stronger Teams And Happier Clients](http://www.smashingmagazine.com/2014/09/19/prototyping-for-better-products-stronger-teams-and-happier-clients/)
#### Говорит и показывает Хабр:
* [«Опыт применения Go в продакшене Яндекса»](http://habrahabr.ru/company/yandex/blog/237985/) от [lamerman](https://habrahabr.ru/users/lamerman/)
* [«Пост о маленьких видеоиграх»](http://habrahabr.ru/post/236713/) от [printf](https://habrahabr.ru/users/printf/)
* [«Видео докладов с конференции DevConf 2014»](http://habrahabr.ru/company/badoo/blog/238153/) от [Badoo](https://habrahabr.ru/users/badoo/)
* [«Как правильно разрабатывать API с поддержкой обратной совместимости. Семинар в Яндексе»](http://habrahabr.ru/company/yandex/blog/237459/) от [forgotten](https://habrahabr.ru/users/forgotten/)
* [«Принципы написания кода»](http://habrahabr.ru/post/236785/) от [vintage](https://habrahabr.ru/users/vintage/)
* [«Веб-компоненты в реализации Polymer от Google»](http://habrahabr.ru/post/237421/) от [pofigizm](https://habrahabr.ru/users/pofigizm/)
* [«Делаем видео-чат в веб-браузере с минимумом трудозатрат»](http://habrahabr.ru/post/231383/) от [aylarov](https://habrahabr.ru/users/aylarov/)
* [«Вывод видео с нескольких web-камер на одной странице»](http://habrahabr.ru/post/236699/) от [abaddon65](https://habrahabr.ru/users/abaddon65/)
* «Смелый стайлгайд по AngularJS для командной разработки: [Часть 1](http://habrahabr.ru/post/235873/), [Часть 2](http://habrahabr.ru/post/237279/)» от [uoziod](https://habrahabr.ru/users/uoziod/)
* «Трансдьюсеры в JavaScript. [Часть 1](http://habrahabr.ru/post/237613/), [Часть 2](http://habrahabr.ru/post/237733/)»
[«Kefir.js — новая библиотека для функционального реактивного программирования (FRP) в JavaScript»](http://habrahabr.ru/post/237495/) от [Pozadi](https://habrahabr.ru/users/pozadi/)
* [«Что нового в Laravel 5? „](http://habrahabr.ru/post/238017/) от [Cubist](https://habrahabr.ru/users/cubist/)
* [“Arr.js: события для стандартного массива»](http://habrahabr.ru/post/238197/) от [jMas](https://habrahabr.ru/users/jmas/)
* [«Дизайн интерфейсов в эпоху Больших Экранов»](http://habrahabr.ru/post/237515/) от [Fyodorov2000](https://habrahabr.ru/users/fyodorov2000/)
#### Напоследок:
* Вероятность появления XSS обратно пропорциональна количеству PHP-программистов. (книга [«Сюрреализм на JavaScript»](http://bakhirev.biz/book/))
[](http://bakhirev.biz/book/)
* [H2O](https://github.com/kazuho/h2o) — HTTP сервер, который якобы в 2 раза быстрее Nginx.
* [Awesome-svg](https://github.com/willianjusten/awesome-svg) — коллекция всяких крутых штук на SVG.
* [Express Admin](https://github.com/simov/express-admin) — MySQL, MariaDB, SQLite, PostgreSQL админка для Node.js.
* [Tuktuk](https://github.com/soyjavi/tuktuk) — простой и мощный RWD фреймворк.
* [Z.js](https://github.com/mntn-dev/z.js) — переводит контент в бинарный код, тем самый делая его невидимым.
* [PathFinding.js](https://github.com/qiao/PathFinding.js) — находит path в формате игры.
* [Bumpkit](https://github.com/jxnblk/bumpkit) — библиотека для Web Audio API.
* [Multi-Screen.js](https://github.com/ian-de-vries/Multi-Screen.js) — jQuery плагин, для создания полноэкранного слайдшоу.
* [Sovereign](https://github.com/al3x/sovereign) — свое собственное облако на основе [Ansible](https://github.com/ansible/ansible/).
* [WP Async Task](https://github.com/techcrunch/wp-async-task) — синхронизация плагинов от TechCrunch ([подробнее](http://techcrunch.com/2014/07/31/wp-async-task-our-new-open-source-library/)).
* [Anbu](https://github.com/daylerees/anbu) — профайлер для Laravel PHP Framework.
* [PHP Webshells](https://github.com/JohnTroony/php-webshells) — «common php webshells».
* [PapaParse](https://github.com/mholt/PapaParse) — мощный CSV парсер для Node.js.
* [Lowdb](https://github.com/typicode/lowdb) — flat JSON file database для Node.
* [Strider-CD](https://github.com/Strider-CD/strider) — «Open Source Continuous Integration & Deployment Server».
* [Pyston](https://github.com/dropbox/pyston) — JIT для Python от команды Dropbox.
* [Profiling](https://github.com/what-studio/profiling) — интерактивный профайлинг на Python.
* [Textract](https://github.com/deanmalmgren/textract) — извлекает текст и различных документов.
* [Linguist](https://github.com/github/linguist) — Ruby «языковой эрудит».
* [Docker practice](https://github.com/yeasy/docker_practice) — интерактивный учебник по Docker.
* [PolymerThemes](http://polymerthemes.com/) — бесплатные темы и шаблона для Polymer.
* [React Components](http://react-components.com/) — каталог по React компонентам.
* [Shout — The self-hosted web IRC client
](https://github.com/erming/shout)
[**Предыдущая подборка (Выпуск 28)**](http://habrahabr.ru/post/236683/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку.
Спасибо всем за внимание. | https://habr.com/ru/post/237697/ | null | ru | null |
# Jsqry — библиотека для запросов к JS объектам и массивам
Представляю вашему вниманию небольшую js-библиотеку [Jsqry](https://github.com/xonixx/jsqry).
Проще всего проиллюстрировать её назначение следующим примером.
До:
```
var name;
for (var i = 0; i < users.length; i++) {
if (users[i].id == 123) {
name = users[i].name;
break;
}
}
```
После:
```
var name = one(users, '[_.id==?].name', 123);
```
Библиотечка позволяет извлекать информацию из объектов/массивов в одну строку, используя несложный язык запросов, вместо написания циклов (подчас вложенных).
По сути, она реализует всего две функции:
* **query** — для возвращения списка результатов и
* **one** — для возвращения первого найденного результата.
Список возможностей включает:
1. Фильтрацию
2. Трансформацию
3. Индексы/срезы в стиле Python
Библиотека появилась спонтанно в одном проекте, построенном на модном ныне подходе [одностраничного приложения](https://en.wikipedia.org/wiki/Single-page_application). Мы загружаем один большой JSON, части которого затем используются для рендеринга на клиенте разных представлений сайта. И вот для выдирания этих самых частей и захотелось более удобного способа. Затем, впрочем, библиотека оказалась востребована и в других случаях.
Поясню немного по функционалу. Запрос в общем случае может иметь вид
```
field1.field2[ condition or index or slice ].field3{ transformation }.field4
```
Тут:
* **field1.field2.field3...** — обычный доступ к полям объектов, как в js
* **[ condition ]** — фильтрация
* **[ index ]** — доступ по индексу, тоже как в js
* **[ from:to:step ]** — [срезы в стиле Python](https://habrahabr.ru/post/89456/)
* **{ transformation }** — преобразование объектов
На **condition** и **transformation** стоит остановиться подробнее.
На самом деле тут все очень просто. Достаточно понять, что каждое выражение внутри квадратных/фигурных скобок при выполнении заменяется на функцию по такому принципу:
**condition\_or\_transformation** ⟶ function(\_,i) { return **condition\_or\_transformation** }
(тут **\_** — значение передаваемого элемента, **i** — его индекс).
Пример:
```
query([1,2,3,4,5],'[_>2]{_+10}') // [13, 14, 15]
```
Также поддерживаются параметризация запроса:
```
query([1,2,3,4,5],'[_>?]{_+?}', 2, 10) // [13, 14, 15]
```
Комбинируя эти возможности можно строить весьма сложные и гибкие запросы. Больше примеров использования [можно посмотреть тут](https://github.com/xonixx/jsqry/blob/master/spec/spec.js).
Из интересного в реализации — [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) дерево запроса кешируется, что придает библиотеке скорости.
Разумеется, моя библиотека не уникальна в своём роде. Стоит привести "небольшой" список аналогов:
* SpahQL — <http://danski.github.io/spahql/>
* Objectpath — <http://objectpath.org/>
* Sift.js — <https://github.com/crcn/sift.js>
* DefiantJS — <http://defiantjs.com/>
* [и так далее...](http://orangevolt.blogspot.com/2012/12/8-ways-to-query-json-structures.html)
Зачем еще одна библиотека? На самом деле, она поддерживает не весь возможный спектр типов запросов, а только то что было нужно в нашем проекте в большинстве случаев. За счет этого простота и скорость. Также, чрезвычайно простой API, вдохновленный подходом JQuery.
Буду рад выслушать критику и предложения по улучшению. | https://habr.com/ru/post/303624/ | null | ru | null |
# Эксперименты с нейронными сетями на данных сейсморазведки
Сложность интерпретации данных сейсмической разведки связана с тем, что к каждой задаче необходимо искать индивидуальный подход, поскольку каждый набор таких данных уникален. Ручная обработка требует значительных трудозатрат, а результат часто содержит ошибки, связанные с человеческим фактором. Использование нейронных сетей для интерпретации может существенно сократить ручной труд, но уникальность данных накладывает ограничения на автоматизацию этой работы.
Данная статья описывает эксперимент по анализу применимости нейронных сетей для автоматизации выделения геологических слоев на 2D-изображениях на примере полностью размеченных данных из акватории Северного моря.
Рисунок 1. Проведение акваториальной сейсморазведки ([источник](https://www.nationalgeographic.com/news/2010/4/100407-energy-undersea-sound/))
Немного о предметной области
----------------------------
Сейсморазведка – геофизический метод изучения геологических объектов с помощью упругих колебаний – сейсмических волн. Этот метод основан на том, что скорость распространения сейсмических волн зависит от свойств геологической среды, в которой они распространяются (состава горных пород, их пористости, трещиноватости, влагонасыщенности и т.д.) Проходя через геологические слои с разными свойствами, сейсмические волны отражаются от различных объектов и возвращаются на приемник (см. рисунок 1). Их характер регистрируется и после обработки позволяет сформировать двумерное изображение – сейсмический разрез, или трехмерный массив данных – сейсмический куб.
Рисунок 2. Пример сейсмического куба ([источник](http://cge.rosgeo.com/en/services/glubinnaya-3d-migraciya-do-summirovaniya/))
Горизонтальные оси сейсмического куба располагаются вдоль земной поверхности, а вертикальная представляет глубину или время (см. рисунок 2). В некоторых случаях куб разбивается на вертикальные срезы вдоль оси расположения сейсмоприемников (так называемые инлайны, inlines) или поперек (кросслайны, crosslines, xlines). Каждая вертикаль куба (и среза) представляет собой отдельную сейсмотрассу.
Таким образом, инлайны и кросслайны состоят из одних и тех же сейсмотрасс, только в разном порядке. Соседние сейсмотрассы очень похожи друг на друга. Более резкое изменение происходит в местах разломов, но сходство все равно будет. Значит, и соседние срезы очень похожи друг на друга.
Все эти знания нам пригодятся при планировании экспериментов.
Задача интерпретации и роль нейронных сетей в ее решении
--------------------------------------------------------
Полученные данные вручную обрабатываются специалистами-интерпретаторами, которые выделяют непосредственно на кубе или на каждом его срезе отдельные геологические слои пород и их границы (горизонты, horizons), залежи соли, разломы и прочие особенности геологического строения исследуемой зоны. Интерпретатор, работая с кубом или срезом, начинает свою работу с кропотливого ручного выделения геологических слоев и горизонтов. Каждый горизонт необходимо вручную пропикировать (от английского «picking» – cбор) указанием курсора и щелчком мыши.
Рисунок 3. Пример 2D-среза (слева) и результата разметки соответствующих ему геологических слоев (справа) ([источник](https://arxiv.org/pdf/1904.00770v1.pdf))
Основная проблема связана с нарастающим с каждым годом объемом сейсмических данных, получаемых во все более сложных геологических условиях (например, подводные участки с большими глубинами моря), и неоднозначностью интерпретации этих данных. Кроме того, в условиях сжатых сроков и/или больших объемов интерпретатор неизбежно допускает ошибки, например, пропускает различные особенности геологического разреза.
Эту проблему можно частично решить с помощью нейронных сетей, значительно сократив ручной труд, ускорив тем самым процесс интерпретации и уменьшив количество ошибок. Для работы нейросети необходимо некоторое количество уже готовых, размеченных срезов (участков куба), а в результате будет получена полная разметка всех срезов (или всего куба), которая в идеале потребует лишь незначительной доработки человеком по корректировке отдельных участков горизонтов или переразметке небольших зон, которые сеть не смогла распознать корректно.
Решений задач интерпретации с помощью нейросетей много, вот лишь несколько примеров: [раз](https://arxiv.org/abs/1903.11215), [два](https://arxiv.org/ftp/arxiv/papers/1804/1804.06814.pdf), [три](https://library.seg.org/doi/full/10.1190/geo2017-0595.1). Сложность заключается в том, что каждый набор данных уникален – из-за особенностей геологических пород исследуемого региона, из-за различных технических средств и методик проведения сейсморазведки, из-за разнообразных используемых методов превращения сырых данных в готовые для интерпретации. Даже из-за внешних шумов (например, собачьего лая и других громких звуков), которые не всегда удается полностью убрать. Поэтому каждую задачу приходится решать индивидуально.
Но, несмотря на это, многочисленные работы позволяют нащупать отдельные общие подходы к решению различных задач интерпретации.
Мы в [MaritimeAI](https://maritimeai.net/) (проект, развившийся из Machine Learning for Social Goods [ODS-сообщества](http://ods.ai/), [статья о нас](https://habr.com/ru/company/ods/blog/454964/)) для каждой зоны поля наших интересов (исследование моря) изучаем уже опубликованные работы и проводим собственные эксперименты, позволяющие нам уточнить границы и особенности применения тех или иных решений, а иногда и найти собственные подходы.
Результаты одного эксперимента мы и описываем в данной статье.
Бизнес-цели исследования
------------------------
Специалисту по Data Science достаточно взглянуть на рисунок 3, чтобы облегченно вздохнуть – обычная задача семантической сегментации изображений, для которой придумано множество архитектур нейронных сетей и методов обучения. Надо лишь выбрать подходящие и обучить сеть.
Но не все так просто.
Для получения хорошего результата с помощью нейронной сети нужно как можно больше уже размеченных данных, на которых она будет учиться. Но наша задача как раз и состоит в том, чтобы сократить количество ручной работы. А использовать размеченные данные из других регионов редко когда удается из-за их сильных различий в геологическом строении.
Переведем вышесказанное на язык бизнеса.
Чтобы использование нейросетей было экономически оправданным, нужно максимально сократить объем первичной ручной интерпретации и доработок полученных результатов. Но уменьшение данных для обучения сети отрицательно скажется на качестве ее результата. Так сможет ли нейросеть ускорить и облегчить работу интерпретаторов и повысить качество размеченных изображений? Или только усложнит привычный процесс?
Целью данного исследования является попытка определения минимально достаточного для нейронной сети объема размеченных данных сейсмического куба и оценки получаемых результатов. Мы попробовали найти ответы на следующие вопросы, которые должны помочь «владельцам» результатов проведенной сейсморазведки в принятии решения о ручной или частично автоматизированной интерпретации:
1. Какой объем данных необходимо разметить специалистам для обучения нейронной сети? И какие данные для этого следует выбирать?
2. Что при таком объеме получится на выходе? Нужна ли будет ручная доработка предсказаний нейронной сети? Если да – насколько сложная и объемная?
Общее описание эксперимента и использованных данных
---------------------------------------------------
Для эксперимента мы выбрали одну из задач интерпретации, а именно задачу выделения геологических слоев на 2D-срезах сейсмического куба (см. рисунок 3). Эту задачу уже пробовали решать (см. [здесь](https://arxiv.org/ftp/arxiv/papers/1804/1804.06814.pdf)) и, по словам авторов, получили неплохой результат на 1% случайно выбранных срезов. С учетом объема куба, это 16 изображений. Однако в статье не приведены метрики для сравнения и отсутствует описание методики обучения (функция потерь, оптимизатор, схема изменения скорости обучения и т.п.), что делает эксперимент невоспроизводимым.
К тому же, приведенные там результаты, на наш взгляд, недостаточны для получения полных ответов на поставленные вопросы. Оптимально ли это значение в 1%? А, может, для другой выборки срезов оно будет иным? Можно ли выбрать меньше данных? Стоит ли взять больше? Как изменится результат? И т.п.
Для эксперимента мы взяли тот же набор полностью размеченных данных из голландского сектора акватории Северного моря. Исходные сейсмические данные представлены на сайте Open Seismic Repository: [Project Netherlands Offshore F3 Block](https://terranubis.com/datainfo/Netherlands-Offshore-F3-Block-Complete). Их краткое описание можно найти в статье [Silva et al. «Netherlands Dataset: A New Public Dataset for Machine Learning in Seismic Interpretation»](https://arxiv.org/pdf/1904.00770v1.pdf).
Поскольку в нашем случае речь идет о 2D-срезах, мы использовали не исходный 3D-куб, а уже сделанную «нарезку», доступную здесь: [Netherlands F3 Interpretation Dataset](https://zenodo.org/record/1471548#.Xfc95htS_cs).
В процессе эксперимента мы решили следующие задачи:
1. Просмотрели исходные данные и отобрали срезы, которые по качеству ближе всего к ручной разметке.
2. Зафиксировали архитектуру нейронной сети, методику и параметры обучения и принцип выбора срезов для обучения и валидации.
3. Обучили 20 одинаковых нейронных сетей на разном объеме данных одного типа срезов для сравнения результатов.
4. Обучили еще 20 нейронных сетей на разном объеме данных разного типа срезов для сравнения результатов.
5. Оценили объем необходимой ручной доработки результатов прогноза.
Результаты эксперимента в виде оценочных метрик и предсказанных сетями масок срезов представлены далее.
Задача 1. Отбор данных
----------------------
Итак, в качестве исходных данных мы использовали готовые инлайны и кросслайны сейсмического куба из голландского сектора акватории Северного моря. Детальный анализ показал, что там не все гладко – есть немало изображений и масок с артефактами и даже сильно искаженных (см. рисунки 4 и 5).
Рисунок 4. Пример маски с артефактами
Рисунок 5. Пример искаженной маски
При ручной разметке ничего подобного наблюдаться не будет. Поэтому, имитируя работу интерпретатора, для обучения сети мы выбрали только чистые маски, просмотрев все срезы. В результате было отобрано 700 кросслайнов и 400 инлайнов.
Задача 2. Фиксирование параметров эксперимента
----------------------------------------------
Данный раздел представляет интерес, в первую очередь, для специалистов по Data Science, поэтому будет использоваться соответствующая терминология.
Поскольку инлайны и кросслайны состоят из одних и тех же сейсмотрасс, можно выдвинуть две взаимоисключающие гипотезы:
1. Обучение можно проводить только на одном типе срезов (например, на инлайнах), используя изображения другого типа как отложенную выборку. Это даст более адекватную оценку результата, т.к. оставшиеся срезы того же типа, что использовался при обучении, все равно будут похожи на тренировочные.
2. Для обучения лучше использовать смесь срезов разных типов, поскольку это уже готовая аугментация.
Проверим.
Кроме того, схожесть соседних срезов одного типа и желание получить воспроизводимый результат привели нас к стратегии выбора срезов для обучения и валидации не по произвольному принципу, а равномерно по всему кубу, т.е. чтобы срезы были максимально удалены друг от друга, и, следовательно, охватывали максимальное разнообразие данных.
Для валидации использовались по 2 среза, так же равномерно распределенные между соседними изображениями тренировочной выборки. Например, для случая тренировочной выборки из 3 инлайнов валидационная выборка состояла из 4 инлайнов, для 3 инлайнов и 3 кросслайнов – из 8 срезов соответственно.
В итоге мы провели 2 серии обучений:
1. Обучение на выборках инлайнов от 3 до 20 равномерно распределенных по кубу срезов с проверкой результата предсказаний сети на оставшихся инлайнах и на всех кросслайнах. Дополнительно было проведено обучение на 80 и 160 срезах.
2. Обучение на объединенных выборках из инлайнов и кросслайнов по 3-10 равномерно распределенных по кубу срезов каждого типа с проверкой результата предсказаний сети на оставшихся изображениях. Дополнительно было проведено обучение на 40+40 и 80+80 срезах.
При таком подходе нужно учитывать, что размеры тренировочной и валидационной выборок существенно меняются, что затрудняет сравнение, но объем оставшихся изображений уменьшается не так сильно, что позволяет использовать их для вполне адекватной оценки изменений результата.
Для уменьшения переобучения для тренировочной выборки использовалась аугментация с произвольными кропами размером 448х64 и зеркальным отражением вдоль вертикальной оси с вероятностью 0.5.
Поскольку нас интересует зависимость качества результата только лишь от количества срезов в обучающей выборке, то предобработкой изображений можно пренебречь. Мы использовали один слой PNG-изображений без каких-либо изменений.
По этой же причине в рамках данного эксперимента нет необходимости искать наилучшую архитектуру сети – главное, чтобы она была одинаковой на каждом шаге. Мы выбрали простой, но хорошо себя зарекомендовавший на таких задачах UNet:
Рисунок 6. Архитектура сети
Функция потерь состояла из комбинации коэффициента Жаккарда и бинарной кроссэнтропии:
```
def jaccard_loss(y_true, y_pred):
smoothing = 1.
intersection = tf.reduce_sum(y_true * y_pred, axis = (1, 2))
union = tf.reduce_sum(y_true + y_pred, axis = (1, 2))
jaccard = (intersection + smoothing) / (union - intersection + smoothing)
return 1. - tf.reduce_mean(jaccard)
def loss(y_true, y_pred):
return 0.75 * jaccard_loss(y_true, y_pred) + 0.25 * keras.losses.binary_crossentropy(y_true, y_pred)
```
Прочие параметры обучения:
```
keras.optimizers.SGD(lr = 0.01, momentum = 0.9, nesterov = True)
keras.callbacks.EarlyStopping(monitor = 'val_loss', patience = 10),
keras.callbacks.ReduceLROnPlateau(monitor = 'val_loss', patience = 5)
```
Для уменьшения влияния произвольности выбора начальных весов на результаты, сеть была обучена на 3-х инлайнах в течение 1 эпохи. Все остальные обучения стартовали с этих полученных весов.
Обучение каждой сети проводилось на видеокарте GeForce GTX 1060 6Gb в течение 30-60 эпох. Обучение каждой эпохи занимало 10-30 секунд в зависимости от размера выборки.
Задача 3. Обучение на одном типе срезов (на инлайнах)
-----------------------------------------------------
Первая серия состояла из 18-ти независимых обучений сети на 3-20 инлайнах. И, хотя нас интересует только оценка коэффициента Жаккарда на срезах, не использованных в обучении и валидации, интересно рассмотреть все графики.
Напомним, что результатами интерпретации каждого среза являются 10 классов (геологических слоев), которые на рисунках далее отмечены номерами от 0 до 9.
Рисунок 7. Коэффициент Жаккарда для обучающей выборки
Рисунок 8. Коэффициент Жаккарда для валидационной выборки
Рисунок 9. Коэффициент Жаккарда для остальных инлайнов
Рисунок 10. Коэффициент Жаккарда для кросслайнов
Из приведенных диаграмм можно сделать ряд выводов.
Во-первых, качество прогноза, измеренное по коэффициенту Жаккарда, уже на 9-ти инлайнах достигает весьма высокого значения, после чего продолжает расти, но уже не так интенсивно. Т.е. гипотеза о достаточности малого количества размеченных изображений для обучения нейросети подтверждается.
Во-вторых, весьма высокий результат получен и для кросслайнов, несмотря на то, что для обучения и валидации использовались только инлайны – подтверждается и гипотеза о достаточности только одного типа срезов. Однако, для окончательного вывода нужно сравнить результаты с обучением на смеси инлайнов и кросслайнов.
В-третьих, метрики для разных слоев, т.е. качество их распознавания, сильно отличаются. Это наталкивает на мысль о выборе другой стратегии обучения, например, использовании весов или дополнительных сетей для слабых классов, или полноценной схеме «one vs all».
И, наконец, следует отметить, что коэффициент Жаккарда не может дать полную характеристику качества результата. Для оценки предсказаний сети в данном случае лучше посмотреть на сами полученные маски, чтобы оценить их пригодность для доработки интерпретатором.
На следующих рисунках, показана разметка сетью, обученной на 10-ти инлайнах. Второй столбец, отмеченный как «GT mask» (Ground Truth mask), представляет собой целевую интерпретацию, третий – предсказание нейронной сети.
Рисунок 11. Примеры прогнозов сети для инлайнов
Рисунок 12. Примеры прогнозов сети для кросслайнов
Из рисунков видно, что наряду с достаточно чистыми масками, сеть затрудняется в распознавании сложных случаев даже на самих инлайнах. Таким образом, несмотря на достаточно высокую метрику для 10-ти срезов, часть полученных результатов будет требовать значительной доработки.
Рассмотренные нами размеры выборок колеблются около 1% от всего объема данных – и это уже позволяет неплохо разметить часть оставшихся срезов. Стоит ли увеличить количество первоначально размеченных срезов? Даст ли это сопоставимый прирост в качестве?
Рассмотрим динамику изменения результатов прогноза сетями, обученными на 5, 10, 15, 20, 80 (5% от полного объема куба) и 160 (10%) инлайнах на примере одних и тех же срезов.
Рисунок 13. Примеры прогнозов сетей, обученных на разном объеме обучающей выборки
Из рисунка 13 видно, что увеличение объема тренировочной выборки в 5 и даже 10 раз не приводит к значимому улучшению. Срезы, которые хорошо распознавались уже на 10-ти тренировочных изображениях, не ухудшаются.
Таким образом, даже простая сеть без настройки и предобработки изображений способна интерпретировать часть срезов с достаточно высоким качеством при малом количестве размеченных вручную изображений. Вопрос доли таких интерпретаций и сложности доработки плохо распознанных срезов мы рассмотрим далее.
Аккуратный подбор архитектуры, параметров сети и обучения, предобработка изображений способны улучшить эти результаты на том же объеме размеченных данных. Но это уже выходит за рамки текущего эксперимента.
Задача 4. Обучение на разных типах срезов (инлайны и кросслайны)
----------------------------------------------------------------
Теперь сравним результаты этой серии с прогнозами, полученными при обучении на смеси инлайнов и кросслайнов.
На представленных ниже диаграммах приведены оценки коэффициента Жаккарда для разных выборок, в том числе, в сравнении с результатами предыдущей серии. Для сравнения (см. правые диаграммы на рисунках) были взяты только выборки одинакового объема, т.е. 10 инлайнов vs 5 инлайнов + 5 кросслайнов и т.п.
Рисунок 14. Коэффициент Жаккарда для обучающей выборки
Рисунок 15. Коэффициент Жаккарда для валидационной выборки
Рисунок 16. Коэффициент Жаккарда для остальных инлайнов
Рисунок 17. Коэффициент Жаккарда для остальных кросслайнов
Диаграммы наглядно иллюстрируют, что добавление срезов другого типа не улучшает результаты. Даже в разрезе классов (см. рисунок 18) влияния кросслайнов не наблюдается ни для одного из рассмотренных размеров выборок.
Рисунок 18. Коэффициент Жаккарда для разных классов (по оси Х) и разных размеров и состава тренировочной выборки
Для полноты картины сравним результаты прогноза сети на тех же срезах:
Рисунок 19. Сравнение прогнозов сети для инлайна
Рисунок 20. Сравнение прогнозов сети для кросслайнов
Визуальное сравнение подтверждает предположение о том, что добавление к обучению срезов другого типа кардинально ситуацию не меняет. Некоторые улучшения можно наблюдать только для левого кросслайна, но носят ли они глобальный характер? На этот вопрос мы попробуем ответить далее.
Задача 5. Оценка объема ручной доработки
----------------------------------------
Для окончательного вывода о результатах нужно оценить объем ручной доработки полученных прогнозов сети. Для этого мы определили количество компонент связности (т.е. сплошных пятен одного цвета) на каждом полученном прогнозе. Если это значение равно 10, то слои выделены правильно и речь идет максимум о незначительной коррекции горизонтов. Если их ненамного больше, то потребуется лишь «чистка» небольших зон изображения. Если их существенно больше, то все плохо и может даже понадобится полная переразметка.
Для проверки мы выбрали 110 инлайнов и 360 кросслайнов, которые не использовались в обучении ни одной из рассмотренных сетей.
Таблица 1. Статистики, усредненные по обоим типам срезов
Таблица 1 подтверждает часть сделанных ранее результатов. В частности, при использовании для обучения 1% срезов нет разницы, использовать один тип срезов или оба, а получаемый результат можно охарактеризовать следующим образом:
* около 10% прогнозов близки к идеальным, т.е. потребуют не более чем корректировки отдельных участков горизонтов;
* 50% прогнозов содержат не более 15 пятен, т.е. не более 5 лишних;
* 75% прогнозов содержат не более 20 пятен, т.е. не более 10 лишних;
* оставшиеся 25% прогнозов требуют более существенной доработки, включая, возможно, полную переразметку единичных срезов.
Увеличение объема выборки до 5% меняет ситуацию. В частности, сети, обученные на смеси срезов, показывают значимо более высокие показатели, хотя максимальное значение компонент также возрастает, что свидетельствует о появлении отдельных интерпретаций очень плохого качества. Тем не менее, при увеличении выборки в 5 раз и использовании смеси срезов:
* около 30% прогнозов близки к идеальным, т.е. потребуют не более чем корректировки отдельных участков горизонтов;
* 50% прогнозов содержат не более 12 пятен, т.е. не более 2 лишних;
* 75% прогнозов содержат не более 14 пятен, т.е. не более 4 лишних;
* оставшиеся 25% прогнозов требуют более существенной доработки, включая, возможно, полную переразметку единичных срезов.
Дальнейшее увеличение объема выборки не приводит к улучшению результатов.
В целом для рассмотренного нами куба данных можно сделать выводы о достаточности 1-5% от общего объема данных для получения от нейронной сети неплохого результата.
По таким данным, в совокупности с приведенными ранее метриками и иллюстрациями, уже можно делать выводы о целесообразности использования нейронных сетей для помощи интерпретаторам и о тех результатах, с которыми специалисты будут иметь дело.
Выводы
------
Итак, теперь мы можем ответить на поставленные в начале статьи вопросы, оперируя результатами, полученными на примере сейсмического куба акватории Северного моря:
**Какой объем данных необходимо разметить специалистам для обучения нейронной сети? И какие данные следует выбирать?**
Для получения неплохого прогноза сети действительно достаточно предварительно разметить 1-5% от общего количества срезов. Дальнейшее увеличение объема не приводит к улучшению результата, сопоставимому с ростом количества предварительно размеченных данных. Для получения более качественной разметки на столь малом объеме с помощью нейронной сети необходимо пробовать другие подходы, например, тонкую настройку архитектуры и стратегии обучения, предобработку изображений и т.п.
Для предварительной разметки стоит выбирать срезы обоих типов – инлайны и кросслайны.
**Что при таком объеме получится на выходе? Нужна ли будет ручная доработка предсказаний нейронной сети? Если да – насколько сложная и объемная?**
В результате значительная часть размеченных такой нейронной сетью изображений потребует не самой значительной доработки, состоящей из коррекции отдельных плохо распознанных зон. Среди них будут встречаться и такие интерпретации, которые никаких правок не потребуют. И лишь для единичных изображений, возможно, понадобится новая ручная разметка.
Разумеется, при оптимизации алгоритма обучения и параметров сети можно улучшить ее прогнозные способности. В наш эксперимент решение таких задач не входило.
Кроме того, результаты одного исследования на одном сейсмическом кубе не стоит бездумно обобщать – именно вследствие уникальности каждого набора данных. Но эти результаты – подтверждение эксперимента, проведенного другими авторами, и основа для сравнения с нашими последующими исследованиями, о которых мы тоже вскоре напишем.
Благодарности
-------------
И в конце мне бы хотелось поблагодарить моих коллег из [MaritimeAI](https://maritimeai.net/) (особенно Андрея Кохана) и [ODS](http://ods.ai/) за ценные комментарии и помощь!
Список использованных источников:
---------------------------------
1. [Bas Peters, Eldad Haber, Justin Granek. Neural-networks for geophysicists and their application to seismic data interpretation](https://arxiv.org/abs/1903.11215)
2. [Hao Wu, Bo Zhang. A deep convolutional encoder-decoder neural network in assisting seismic horizon tracking](https://arxiv.org/ftp/arxiv/papers/1804/1804.06814.pdf)
3. [Thilo Wrona, Indranil Pan, Robert L. Gawthorpe, and Haakon Fossen. Seismic facies analysis using machine learning](https://library.seg.org/doi/full/10.1190/geo2017-0595.1)
4. [Reinaldo Mozart Silva, Lais Baroni, Rodrigo S. Ferreira, Daniel Civitarese, Daniela Szwarcman, Emilio Vital Brazil. Netherlands Dataset: A New Public Dataset for Machine Learning in Seismic Interpretation](https://arxiv.org/pdf/1904.00770v1.pdf) | https://habr.com/ru/post/482780/ | null | ru | null |
# «Heroes of Might and Magic IV»: баг с таверной или классика патчинга
Эта короткая история описывает одну из работ, проведенную в рамках проекта *«Equilibris»* — неофициального мода для игры «Heroes of Might and Magic IV». С точки зрения как реверс-инжиниринга, так и патчинга она не представляет особого интереса — несколько забавным оказался только лишь финал.
Как известно, в данной серии игр в каждой таверне игрок может нанимать лишь одного нового Героя в неделю. Однако…
**Описание бага:** *Если во внешней таверне не было найма, то, начиная с 8-го дня, можно купить двух героев в течение двух дней.*
Для работы используется дизассемблированный файл heroes4.exe из последнего официального аддона «Winds of War». Процедура работы таверны найдена командой ранее и расположена по адресу 4705E0. Из всего алгоритма ее работы меня интересует место, в котором определяется, можно ли в данный момент нанять в таверне Героя, либо необходимо ожидание. В игре это проявляется выводом соответствующего сообщения:
С программной точки зрения это новое окно, которое в игре создается с помощью функции **NewWindowCreate** (720C80) (распознанным в дизассемблере функциям даны собственные имена). В процедуре таверны несколько вызовов этой функции, и первым претендентом является вызов по адресу 470823. С помощью отладчика убеждаюсь, что, действительно, этот вызов создает искомое диалоговое окно. Код, управляющий этим вызовом **NewWindowCreate**, находится выше — по адресу 470645:
```
00470638 call HeroesPricesInTavern_Lost
0047063D mov al, [ebp+48h] // 0 – если таверна работает; 1 – если героя нанять нельзя (ждешь 7 дней).
00470640 add esp, 8
00470643 test al, al
00470645 jz loc_470866 // Если таверна работает, пропустить вывод сообщения по адресу 470823
```
Покупаю в таверне Героя, затем устанавливаю «бряк» на запись на ячейку, адресуемую [ebp+48h], после чего жду 7 игровых дней. Когда таверна «освобождается», отладчик всплывает по адресу 470DFF. Давайте посмотрим окружающий код:
```
00470DF0 TavernCountDays proc near
00470DF0 mov dl, [ecx+48h] // ECX+48h – флаг работы таверны:
DL=0 – если таверна работает;
DL=1 – если Героя нанять нельзя (ждешь 7 дней)
00470DF3 xor eax, eax
00470DF5 cmp dl, al
00470DF7 jz short loc_470E06
00470DF9 cmp dword ptr [ecx+4Ch], 7 // В [ECX+4Ch] - число дней с момента найма последнего героя в таверне. Если меньше 7 – выходим.
00470DFD jl short loc_470E06
00470DFF mov [ecx+48h], al // Таверна работает (AL=0)
00470E02 mov [ecx+4Ch], eax // Обнулить число дней
00470E05 retn
00470E06
00470E06 loc_470E06:
00470E06
00470E06 inc dword ptr [ecx+4Ch] // Увеличить число дней с момента найма последнего Героя в таверне
00470E09 retn
00470E09 TavernCountDays endp
```
Эта небольшая процедура служит для проверки числа дней, в которые таверна закрыта для найма. Замечу, что она вызывается для каждой таверны на карте в каждый игровой день. Что же порождает баг? Программа зачем-то продолжает вести подсчет числа дней, в течении которых в таверне не было найма Героя и по истечении недели, в которую таверна была закрыта (см. счетчик по адресу 470E06). В результате получаем следующую картину. Пусть первый найм Героя происходит только на восьмой игровой день. На входе в процедуру значение флага доступности таверны по адресу [ecx+48h] будет равно «1» (таверна закрыта), а значение счетчика дней по адресу [ecx+4Ch] будет равно «8». Однако при этом, после сравнения по адресу 470DF9, управление получит код по адресу 470DFF, вновь открывающий таверну для найма! При этом счетчик дней сбросится, и после найма второго Героя алгоритм уже отработает, как задумывали авторы. Но через две игровых недели весь цикл повторится.
Самый простой способ пофиксить баг – отказаться от подобного подсчета дней. Пусть счетчик работает только тогда, когда таверна закрыта (что логичнее), а в остальное время зададим его равным нулю. Это достигается очень просто — изменением перехода по адресу 00470DF7 в конец функции:
```
00470DF5 cmp dl, al
00470DF7 jz short loc_470E09
```
Теперь остается лишь пропатчить имеющийся код. Для этого смотрим исходный
и измененный
варианты.
Как видно, необходимого результата можно достичь, заменив **0D** на **10** по адресу 470DF8. *Классика жанра: пропатчить баг, заменив всего лишь один байт!* | https://habr.com/ru/post/529188/ | null | ru | null |
# «Колотое целомудрие подергает ситечко» — или сложный пароль, но легкий для запоминания
Выполните подобный запрос у себя по таблице пользователей (*пароль хранится в sha1*):
`SELECT password, count( * ) FROM sys_users WHERE password = SHA1( '12345678' ) GROUP BY password HAVING count( * ) >1`У меня на данный момент из 476 пользователей 13 с паролем «12345678».
Если у вас большая компания с частой обязательной сменой пароля учетных записей, пройдитесь по отделам, загляните на мониторы, (под) клавиатуры, столы. Что же вы увидите? У многих можно найти стикеры с паролями в открытом виде.
##### Что же делать?
Есть несколько вариантов, как с этим бороться:
* сделать проверку пароля на сложность при смене/создании;
* генерировать пароли самим [и не давать их менять];
* оставить все как есть и не нервничать.
Я отброшу 1 и 3 вариант и расскажу о генерации сложных паролей, но легких для запоминания.
Алгоритм прост и состоит всего лишь из одного действия — генерации фразы для запоминания. Я выбрал фразу такой схемы: прилагательное — существительное — глагол — существительное. Например: «рьяный всплеск настрогает неоглобализм» или «именитый слюнтяй подсчитает молескин».
Далее, вы отдаете пользователю фразу и описываете пару простых действий для создания пароля, например:
* вводить первые три буквы каждого слова на английской раскладке;
* вводить первые три буквы каждого слова на английской раскладке, между словами ставить любимую цифру;
Ура, мы добились своего. Даже если пользователь распечатает фразу, подобрать пароль будет сложно, ведь действий можно придумать очень много:
* у нечетных слов буквы вводить в верхнем регистре;
* между словами кроме цифр, вставлять спец. символы;
* чередовать строчные и заглавные буквы;
* от первого слова брать первую букву, от второго две первые, от третьего три первые, от четвертого четыре первые.
И еще много чего можно придумать. А реализовывается все за пару часов, причем самое основное — найти словари (я распарсил словарь Ожегова). | https://habr.com/ru/post/124335/ | null | ru | null |
# Гайд по созданию Facebook Welcome Page и других кастомных табов
Facebook — самая большая социальная сеть и один и самых посещаемых сайтов в мире. В ней можно не только постить веселые статусы и лайкать фотографии, но и
использовать, как мощный маркетинговый инструмент. Все логично — миллиард пользователей, возможность таргетинга на определенную аудиторию, мгновенные объявления, ну и масса других
полезных штук, которые недоступны для оффлайна. На сегодняшний день сложно найти компанию без собственной бизнес-страницы или популярную личность без фан-пейджа. В этой статье постараюсь
подробно разобрать техническую сторону этого вопроса со стороны фронт-енд разработки.
Речь в посте пойдет не о создании самой страницы, потому что это довольно тривиальная процедура, а о пользовательских вкладках, которые можно добавить самостоятельно и наполнить нужным контентом.
Любой, даже начинающий веб-разработчик, может сделать с десяток таких табов за один вечер, зная некоторые принципы и нюансы их создания.
Я имею в виду подавляющее большинство всякого рода welcome-страниц, страниц-анонсов и страниц со всяким информационным текстово-графическим контентом. На страницы посложнее с динамическими элементами, формами и прочим функционалом времени уйдет, конечно, побольше.
Первое, что следует уточнить — работаем со страницей продукта, а не с личным профайлом — на личный профайл не получится добавить вкладку со своим контентом.
Таким образом, добавить собственный таб можно только на странице продукта (бренда, компании, группы и т. п.). Если таковой страницы не существует, ее следует создать, пройдя по следующей ссылке:
[www.facebook.com/pages/create.php](http://www.facebook.com/pages/create.php)
В создании такой страницы нет ничего сложного, поэтому этот этап я пропущу. Тем более, если клиент просит кастомизировать страницу, то она чаще всего у него уже имеется.
Собственно, к делу.
Создаем кастомные табы
======================
#### Оглавление:
* 1. Подготовка аккаунта
* 2. Способ номер один: создаем свое приложение с помощью инструментов разработки
* 3. Способ номер два: добавляем таб с помощью сторонних приложений
* 4. Установка и настройка приложения Static HTML: iframe tabs
* 5. Установка и настройка приложения Static Iframe Tab
* 6. Основные шаги при создании таба. Вариант 1 — создание собственного приложения
* 7. Основные шаги при создании. Вариант 2 — сторонние приложения
* 8. Полезные размеры
Сделать кастомный таб можно двумя основными способами: либо создав собственное приложение с помощью средств фб-разработчика, либо воспользовавшись сторонним приложением. Выбирать способ следует исходя из ТЗ и выделенного на разработку времени. Плюсы и минусы каждого из способов будут рассмотрены ниже, выводы по этому поводу — в конце.
Подразумевается, что html-контент уже сверстан и залит на общедоступный ftp-сервер.
#### Подготовка аккаунта
Работа со средствами разработки фейсбука начинается со следующей страницы:
**[developers.facebook.com/apps](https://developers.facebook.com/apps)**
На ней можно увидеть созданные приложения, которые привязаны к текущему аккаунту.
Здесь нас в первую очередь интересует кнопка "**+ Create New App**"
Однако, если вы заходите на developers.facebook.com впервые, то вам, скорее всего, нужно будет совершить несколько дополнительных шагов:
приложению developer следует **разрешить доступ** к вашей основной информации и подтвердить пароль, а также потребуется **верификация аккаунта**.
Сделать это можно либо отправкой на ваш номер мобильного смс с подтверждающим кодом, либо введя номер банковской карты. Смс обычно приходит в течении одной минуты.
#### Способ номер один: создаем свое приложение с помощью инструментов разработки
Сразу после нажатия «Create New App» появится окно, в котором предлагается ввести **название** вашего будущего приложения и согласиться с политикой фб-платформы:
Поле App Namespace можно оставить пустым (нужно для полноценных фейсбук-приложений, использующих Open-Graph и canvas-страницы). После продолжения нужно будет ввести капчу.
После сабмита видим **основные настройки** нашего приложения. Здесь можно **загрузить иконку, задать имя,** выбрать категорию приложения и задать прочие основные настройки. Однако, все эти манипуляции можно отложить на будущее и вернуться к ним позже. Внизу страницы следует выбрать метод, с помощью которого наше приложение будет интегрировано в фейсбук.
Наша цель — собственный кастомный таб, поэтому соответственно выбираем **«Page Tab»**.
В первом поле указываем **название таба**, в следующих двух — **прямые ссылки** на нашу верстку или динамический контент, предварительно залитые на ftp общедоступного сервера.
Однако, здесь вас будет поджидать первый нюанс — **SSL-защита является обязательным требованием фейсбука** с октября 2011, поэтому обязательно, чтобы нужный вам url был доступен по протоколу **https**
Нажав кнопку **«Save Changes»** мы получаем готовый работающий таб. При желании можно открыть раздел advanced, и провести более тонкую настройку приложения.
Теперь перейдем непосредственно к добавлению созданного приложения на нужную нам страницу.
#### Как добавить App / Custom Tab на страницу Facebook
1. Заходим на [developers.facebook.com/apps/](https://developers.facebook.com/apps/) и выбираем нужное нам приложение. Здесь интерес представляет поле **App ID/API Key**:
2. В браузере формируем следующий урл:
`www.facebook.com/dialog/pagetab?app_id=YOUR_APP_ID&next=YOUR_URL`
где вместо **YOUR\_APP\_ID** подставляем свой **App ID**, а вместо **YOUR\_URL** указываем ссылку на страницу, указанную в настройках приложения в поле **«Page Tab Url»**
3. Жмем enter и в появившемся окне выбираем страницу, на которую хотим добавить таб:
4. Кликаем на **«Add Page Tab»** и если все произошло успешно, оказываемся на странице, указанной в YOUR\_URL. Возвратившись на страницу продукта [www.facebook.com/pages/your\_url](http://www.facebook.com/pages/your_url) можно будет увидеть добавленный нами таб в самом низу списка уже существующих табов. Нажав «EDIT» под ними можно изменить позицию нашего таба. Однако, **поднять его выше «Wall» и «Info» не получится (актуально до введения timeline)**.
Главное преимущество собственного приложения — **контроль множества его параметров**. Зайдя в свойства приложения, можно провести их тонкую настройку. Ранее, его дополнительным преимуществом перед решениями от сторонних приложений была возможность установки собственной иконки таба, однако с приходом timeline дизайн табов изменился, и теперь установка персонального изображения таба не представляет проблем.
К минусам можно отнести более долгое время создания, по сравнению со вторым способом, а также сложность создания так называемого **fan-gate**. Вы скорее всего видели такое кучу раз на разных страницах — когда предлагается нажать Like для того, чтобы увидеть какой-нибудь скрытый контент.
#### Способ номер два — добавляем таб с помощью сторонних приложений
На данный момент существует огромное количество бесплатных приложений, которые позволяют добавить кастомный таб на вашу страницу и произвести его настройку. Достаточно ввести в строке поиска фейсбука запрос **«static html»** и в результатах можно будет увидеть наиболее популярные приложения:
**FBML-приложения** можно не рассматривать, так как фейсбук отказался от fbml в пользу html iframes.
Рассмотрим наиболее популярное приложение **Static HTML: iframe tabs**. Количество активных пользователей говорит само за себя.
Нажав на **«Go to App»** попадем на страницу самого приложения, которая выглядит таким образом:
На ней жмем **«Add Static HTML to a Page»** и выбираем ту страницу, на которую хотим добавить таб:
После произведенных манипуляций в левой части нашей страницы среди прочих табов появится новый таб «Welcome». Отличительная черта приложения Static HTML — иконка белой звезды на сером фоне.
Табы в старом варианте:
Табы в Timeline:
Перейдем к непосредственной настройке таба. Для начала изменим его название. В старой версии страниц фейсбука для этого нужно было перейти к списку всех уже установленных приложений. Делалось это нажатием «Edit Page» на первых трех дефолтных табах (Get Started, Wall, Info).
В Timeline владельцы страницы над основным контентом видят **администраторскую панель**:
С нее и следует переходить в **режим редактирования** свойств страницы:
Далее выбираем нужное нам приложение и нажимаем **«Edit Settings»**. В появившемся поп-апе можем либо изменить его имя, либо удалить этот таб.
Сменив название таба перейдем к его контенту. Для этого просто выберем его в общем списке табов. Если пользователь залогинен под администраторским аккаунтом, он увидит страницу с настройками. Все остальные выбирая этот таб будут видеть непосредственно его контент.
Приложение Static HTML имеет поддержку **«fan-gate»** и это одно из его главных преимуществ.
Поле контента можно заполнить как html/css кодом, так и указать прямую ссылку с помощью iframe.
Чтобы просмотреть результат нажимаем на preview. В окне предварительного просмотра можем выбрать контент, который желаем увидеть — либо публичный, либо доступный только тем, кто залайкал страницу.
Когда-то главным недостатком данного приложения была невозможность смены иконки. Однако, в конце 2011го разработчики добавили такую возможность, а с приходом интерфейса Timeline в этом отпала необходимость — в новом режиме для пользователей больше не составляет труда задать свое изображение.
При нажатии на кнопку «magic \*», можно увидеть несколько приятных плюшек, в частности возможность настроить google analytics и принудительно спрятать скролбар.
Также, одним из самых популярных приложений является **«Static Iframe Tab»**
Добавляется на страницу он аналогичным предыдущему приложению способом. Однако, static iframe tab обладает более широким набором настроек контента таба. Уже при добавлении на страницу,
пользователь видит небольшой визард, где можно сразу же добавить изображение для профайла, заполнить поле «About» и задать уникальное название для ссылки на вашу страницу
#### Подводя итоги вышенаписанного. Краткая выжимка
#### Основные шаги при создании. Вариант 1 — создание собственного приложения
* Анализ дизайна на предмет сложности, динамического контента, кастомной иконки, форм и пр.
* Верстка статического контента.
* Загрузка файлов на внешний сервер.
* Убедиться, что файлы доступны по https (SSL-защита является обязательным требованием фейсбука с октября 2011).
* Создание фейсбук-приложения, в настройках которого указывается ссылка на готовую верстку.
* Добавление этого приложения на страницу продукта в качестве таба.
* Изменение названия таба.
* Profit!
Плюсы этого варианта:
* полный контроль приложения и его персонизация (настройки приватности, смена иконки, мультиязычность и пр.);
* отсутствие возможных ссылок на сторонние приложения, повышенная безопасность;
* стабильность работы зависит только от сервера, на котором находится верстка.
Минусы:
* сложность с настройкой «Fan-Gate»;
* создание своего приложения чуть дольше, чем подключение стороннего;
* необходимость использовать SSL.
#### Основные шаги при создании. Вариант 2 — сторонние приложения
* Шаги 1-2 из первого варианта (анализируем, верстаем).
* Выбор наиболее подходящего приложения.
* Установка приложения на страницу продукта.
* Настройка приложения (указание ссылки на верстку, название таба, настройка «fan-gate» по необходимости)
* Profit!
Плюсы этого варианта:
* относительно высокая скорость получения требуемого результата;
* легкость настройки «fan-gate» и ему подобных вариантов доступа к контенту;
* обычно легкая настройка и правка контента даже для клиента;
* не требуется доступ по https.
Минусы:
* ссылки на сайт разработчика приложения и всевозможные надписи типа «powered by ...»;
* нет уверенности в стабильной работе как самого приложения и его сервера, так и в том, что при очередном глобальном апдейте фейсбука оно не перестанет работать. Например, так:
Резюмируя, можно сказать, что вариант с подключением стороннего приложения более прост в настройке и существенно выигрывает по времени создания у собственного приложения. Дополнительным жирным плюсом будет простота создания фан-гейтов.
Из минусов можно отметить сложность смены стандартной иконки приложения, ссылки на сайты создателей этого приложения во многих из них, а также зависимость от этих самих разработчиков и их серверов. Не смотря на то, что у того же Static HTML iframe tabs десятки миллионов пользователей, бывало так, что это приложение переставало работать на некоторое время из-за проблем на их серверах. Однако, это мало кого смущает, в результате чего Static HTML можно видеть на страницах, у которых огромное количество подписчиков, при чем довольно часто они даже не заморачиваются по поводу смены стандартной иконки приложения на свою.
Несколько примеров популярных страниц, где активно используются кастомные вкладки:
Старый вариант:
Как можно увидеть, эти страницы еще не перешли на новый интерфейс Хроника (Timeline), который будет принудительно введен 30-го марта
Новый Timeline:
### Полезные размеры
* **Картинка профиля для профайла/бренда**: Width: 180px, Height: 540px
* **Предоставляемая площадь для iframe с пользовательским html контентом**:
max-width: 520px (старый вариант), 810px (timeline), высота неограничена
* **Аватар** (картинка рядом рядом с ссылками и постами при нажатии кнопки like или share):
Width: 90px, Height: 90px
* **Максимальный размер изображения для загрузки**: Width: 2048px, Height: 2048px
* **Максимально видимый размер изображения для просмотра в альбоме или слайд-шоу**: Width: 960px, Height: 720px
* **Картинка в объявлении**: Width: 110px, Высота: 80px, Height: 5MB
* **Текст объявления**: Заголовок: 25 символов, Тело: 135 символов
* **Обновление статуса**: Длина: 63 206 символов
* **Обложка для Timeline**: Width: 851px, Height: 315px
* **Комментарий:**: нет ограничений на длину
* **Видео**: Размер: 1024, Время: 20 минут
Материал подготовлен при участии [derSmoll](https://habrahabr.ru/users/dersmoll/) | https://habr.com/ru/post/141078/ | null | ru | null |
# Плагин tagSphere
Думаю, многие из вас видели плагин для [wordpress](http://domainingdomainers.com/domaining-tech/domain-o-sphere-active-flash-dynamic-tag-clouds-live-search-engine/2008/05/24/). Симпатичный шарик привлек мое внимание и мне захотелось его поковырять...
Разочарованию не было предела ― он оказался на флэше(против флэша ничего не имею). Ладно, флэш так флэш нагуглил исходники, распаковал архивчик, а там… А там море файлов с кодом, файлы для настройки с парой десятков опций, несимпатичный фалик для вывода всего этого, для генерации xml'ки.
С этим я мириться уже никак не хотел и решил написать тоже самое, но на javascript. Привык я работать с [jQuery](http://jquery.com/) поэтому решил сделать в качестве плагина для него.
#### Для нетерпеливых:
* [Плагин](http://plugins.jquery.com/project/tagSphere)
* [Пример](http://test.rdmhosting.ru/)
#### Для остальных немного об использовании:
Список тэгов у нас представлен вот в таком виде:
> `<div id="tagShpere">
> <ul>
> <li><a href="#">tag0a>li>
> <li><a href="#">tag1a>li>
> \*\*\*\*
> <li><a href="#">tagNa>li>
> ul>
> div>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/47337/ | null | ru | null |
# Пишем клиент-серверную систему Backup-ов под *NIX OS
Всем добрый день.
Как говориться сисадмины деляться на тех кто делает бэкапы и тех кто их еще не делает.
Собственно снова о бэкапах.
Возникла ситуация, когда нужно было иметь под рукой всегда свежий бэкап с большого количества
удаленных хостов. Причем система должна быть клиент-сервер.
Конечно существует, очень большое количество свободного ПО, которое обеспечит функционалом выше крыши, но оно либо слишком навороченное, либо не совсем то, что нужно в конечном итоге. В общем решено было создать свою систему бэкапирования на основе fsbackup.
Итак, мы имеем сервер и клиентские хосты.
ОС на всех freebsd 8.2, но это не важно, работать будет на любой версии.
Приступаем к установке (только на клиентских хостах, сервер не трогаем):
**[root@server/usr/ports/sysutils/fsbackup]# make install clean**
Далее переходим в папку с установленным fsbackup и создаем файл fsbackup.conf с таким
содержимым:
```
$cfg_backup_name = "host1";
$cfg_cache_dir= "/usr/local/fsbackup/cache";
$prog_md5sum = "md5sum -b";
$prog_tar = "/usr/bin/tar";
$prog_ssh = "/usr/bin/ssh";
$prog_rm = "/bin/rm";
$prog_gzip = "/usr/bin/gzip";
$prog_pgp = "";
$cfg_checksum = "timesize";
$cfg_backup_style = "sync"; # Метод backup-a , создается дерево файлов для синхронизации
$cfg_save_old_backup = 1;
$cfg_type = "local";
$cfg_local_path = "/home/back/backup_data"; # путь где будет сохраняться бэкап.
$cfg_time_limit = 0;
$cfg_size_limit = 0;
$cfg_maximum_archive_size = 0;
$cfg_root_path = "/";
$cfg_verbose = 2;
$cfg_stopdir_prune=0;
1;
__DATA__ # что бэкапим
/usr/local/etc
/etc
!/usr/local/etc/share #Исключение
f!\.core$
f!^core$
f!\.o$
f!\.log$
```
Подробно, что есть что, можно посмотреть в стандартном конфиге.
Далее нужно поправить файл create\_backup.sh
добавляем в начало такую строчку:
```
#!/bin/sh
HASH=`find /usr/home/back/backup_data -name *hash -mtime -1`
```
а в самый конец файла строки:
```
#проверяем были ли изменены файлы и если да то создаем архив
if [ -n "${HASH}" ]; then
(
tar -cf /usr/home/back/backup_tar/arcamart.tar /usr/home/back/backup_data
)
else
printf "===>>> not new backup\t" > backup_err.log | err_msg
fi
exit 0
```
Так же не забываем в этом файле поправить строчку config\_files=«fsbackup.conf», указываем имя своего конфига.
И добавляем этот скрипт в крон (обязательно в крон рута).
Таким образом скрипт будет проводить синхронизацию дерева и при каких либо изменениях дополнительно создавать архив.
Теперь нам нужно дабавить пользователя back,
**sudo pw useradd back -m -G back**
Переходим в домашнюю директорию back и создаем нужные для работы папки
**mkdir backup\_tar** # для архива синхронизированного дерева
**mkdir .ssh** # для авторизации по ключу (об этом далее)
На клиенте действия закончили, не считая создания ключика для авторизации по ssh
Теперь о настройке серверной части:
Значит нам нужно, что бы серверная часть, удаленно подключалась по очереди к каждому клиенту, проверяла на наличие нового бэкапа и копировала в случае успеха себе.
Кроме этого серверная сторона должна уметь делать проверку на доступность хостов, а также писать логи.
Начнем:
Создаем также пользователя back. (небольшое уточнение, у меня на серверной стороне папка home имеет отличный путь от хостов, например на хосте /usr/home/back, а на сервере /usr/local/home/back, будьте внимательны)
**[root@server /usr/local/home/back]mkdir .ssh**
Теперь создаем ключи для авторизации
**[root@server /usr/local/home/back/.ssh] ssh-keygen**
Теперь, чтобы сервер мог авторизовываться на хостах без ввода пароля, нужно просто скопировать файл с public key в файл $home/.ssh/authorized\_keys (тоесть на все ваши клиентские хосты)
Также не забываем выставить права и владельца на файл authorized\_keys
**sudo chmod 600 authorized\_keys**
**sudo chown back:back authorized\_keys**
Итак, начинаем писать скрипт который будет делать то что нам нужно:
Для начала создаем файл if\_routers который будет содержать список ваших хостов
Пример: ee if\_routers:
**octet=«192.168»
test="${octet}.0.1"
test2="${octet}.0.2"
test3="${octet}.0.3"
test4="${octet}.0.4"
test5="${octet}.0.5"**
Создаем файл с любым название, пусть будет sbackup.sh
Содержимое:
```
#!/bin/sh
s_copy="/usr/local/bin/rsync -azv -e \"ssh -l back -o StrictHostKeyChecking=no\""
DST="/usr/local/home/back/backup_data" #директория хранения бэкапов на сервере
dir_1="/usr/home/back" #хоум директория удаленных хостов
dir_2="/usr/local/home/back" #хоум директория сервера
dir_3="/usr/home/back/backup_tar" #диектория архивов на удаленных хостах
HOME_DIR="/usr/local/home" #хоум
#подключаем наш файлик со списком хостов
if [ -f ${dir_2}/if_routers ]; then
. ${dir_2}/if_routers
else
echo "Procedure ${dir_1}/if_routers is not install" > ${dir_2}/backup.log 2>&1
exit 1
fi
TIMESTAMP=`date +"%Y-%m-%d %R"`
#Функция для проверки доступности хостов методом ping
get_alive ()
{
check_host="/usr/local/sbin/fping -a"
eval ${check_host} $1 > /dev/null 2>&1
}
err_msg ()
{
printf "DATE: $TIMESTAMP.\n" >> ${dir_2}/backup_err.log
}
#собственно тут все и происходит, проверка, копирование, вывод в лог, я думаю тут понятно, так как очень просто.
get_alive $TEST
if [ $? -eq 0 ]; then
BACKTEST=`ssh -i /usr/local/home/back/.ssh/id_dsa back@192.168.0.1 "find /usr/home/back/backup_tar -name *.tar -mtime -1 | sed -E 's/.*\///g'"`
if [ -n "${BACKTEST}" ]; then
(printf "===>>> Start remote backup: ${TIMESTAMP}\n"
printf " \n"
printf "===================================\n"
printf "$ts ===>>>${dir_1}\n"
printf "\n"
eval ${s_copy} back@${TEST}:${dir_3}/${BACKTEST} ${DST}
) > ${dir_2}/backup.log 2>&1
else
printf "===>>> Host: $test is not new backup\t" > ${dir_2}/backup_err.log
fi
else
printf "===>>> Host: $test is down\t" > ${dir_2}/backup_err.log | err_msg
exit 1
fi
#далее можно продолжать для каждой новой точки, начиная с get_alive $хост
exit 0
```
Сохраняем и создаем папку /usr/local/home/back/backup\_data
Теперь можно запустить скрипт для проверки работоспособности. Не забываем ставить chmod +x
А также уточню, для того, чтобы скрипт нормально конектился с удаленными хостами, его нужно запускать от имени пользователя back
**sudo su — back ./sbackup.sh**
И добавляем в крон
**sudo crontab -u back -e**
Готово.
Итог имеем на сервере, всегда свежий бэкап, причем без лишнего копирования, тоесть только при изменении файлов.
Для восстановления, нужно всего лишь разархивировать нужный архив на тот хост который требуется восстановить.
Всем спасибо за внимание, надеюсь ничего не забыл. | https://habr.com/ru/post/133051/ | null | ru | null |
# Создание псевдотрёхмерной гоночной игры
В детстве я редко ходил в залы аркадных автоматов, потому что особо в них не нуждался, ведь дома у меня были потрясающие игры для C64… но есть три аркадные игры, на которые у меня всегда находились деньги — Donkey Kong, Dragons Lair и Outrun…
… и я очень любил Outrun — скорость, холмы, пальмы и музыка, даже на слабой версии для C64.
Поэтому я решил попробовать написать олдскульную псевдотрёхмерную гоночную игру в стиле Outrun, Pitstop или Pole position. Я не планирую собрать полную и [завершённую](https://codeincomplete.com/articles/defining-finished) игру, но мне кажется, будет интересно заново изучить механики, при помощи которых эти игры реализовывали свои трюки. Кривые, холмы, спрайты и ощущение скорости…
Итак, вот мой «проект на выходные», который в итоге занял пять или шесть недель по выходным
* [Сыграть в игру](https://codeincomplete.com/games/racer)
* Посмотреть [исходный код](https://github.com/jakesgordon/javascript-racer/)
Играбельная версия больше напоминает техническое демо, чем реальную игру. На самом деле, если вы хотите создать настоящую псевдотрёхмерную гонку, то это будет самый минимальная основа, которую нужно постепенно превратить в игру.
Она не отшлифована, немного уродлива, но полностью функциональна. Я покажу, как реализовать её самостоятельно за четыре простых шага.
Можно также поиграть
* в [демо с прямой дорогой](https://codeincomplete.com/games/racer/v1-straight)
* в [демо с кривыми](https://codeincomplete.com/games/racer/v2-curves)
* в [демо с холмами](https://codeincomplete.com/games/racer/v3-hills)
* в [готовую версию](https://codeincomplete.com/games/racer)
О производительности
--------------------
Производительность этой игры **очень сильно** зависит от машины/браузера. В современных браузерах она работает хорошо, особенно в тех, где есть GPU-ускорение canvas, но плохой графический драйвер может привести к зависанию. В игре можно менять разрешение рендеринга и расстоянием отрисовки.
О структуре кода
----------------
Так получилось, что проект реализован на Javascript (из-за простоты прототипирования), но он не предназначен для демонстрации техник или рекомендованных приёмов Javascript. На самом деле, для простоты понимания Javascript каждого примера встроен непосредственно в HTML-страницу (ужас!); хуже того, в нём используются глобальные переменные и функции.
Если бы я создавал реальную игру, то код был бы гораздо более структурирован и упорядочен, но так как это техническое демо гоночной игры, я решил придерживаться [KISS](http://en.wikipedia.org/wiki/KISS_principle).
Часть 1. Прямые дороги.
-----------------------
Итак, как же нам приступить к созданию псевдотрёхмерной гоночной игры?
Ну, нам потребуется
* Повторить тригонометрию
* Вспомнить основы 3d-проецирования
* Создать игровой цикл
* Загрузить спрайтовые изображения
* Построить геометрию дороги
* Отрендерить фон
* Отрендерить дорогу
* Отрендерить машину
* Реализовать поддержку клавиатуры для управления машиной
Но прежде чем мы начнём, давайте прочитаем [Lou’s Pseudo 3d Page](http://www.extentofthejam.com/pseudo/) [[перевод](https://habr.com/ru/post/325482/) на Хабре] — единственный источник информации (который мне удалось найти) о том, как создать псевдотрёхмерную гоночную игру.
Закончили читать статью Лу? Отлично! Мы будем создавать вариацию его техники «Realistic Hills Using 3d-Projected Segments». Мы будем делать это постепенно, на протяжении следующих четырёх частей. Но начнём мы сейчас, с версии v1, и создадим очень простую геометрию прямой дороги, спроецировав её на HTML5-элемент canvas.
> Демо можно посмотреть [здесь](https://codeincomplete.com/games/racer/v1-straight).
Немного тригонометрии
---------------------
Прежде чем заняться реализацией, давайте воспользуемся основами тригонометрии, чтобы вспомнить, как спроецировать точку в 3D-мире на 2D-экран.
В самом простейшем случае, если не касаться векторов и матриц, для 3D-проецирования используется закон [подобных треугольников](http://www.khanacademy.org/math/geometry/triangles/v/similar-triangles).
Используем следующие обозначения:
* **h** = высота камеры
* **d** = расстояние от камеры до экрана
* **z** = расстояние от камеры до машины
* **y** = координата Y экрана
Тогда мы можем использовать закон подобных треугольников для вычисления
> **y = h\*d/z**
как показано на схеме:
Можно было также нарисовать похожую схему в виде сверху вместо вида сбоку, и вывести похожее уравнение для вычисления координаты **X** экрана:
> **x = w\*d/z**
Где **w** = половина ширины дороги (от камеры до края дороги).
Как видите, для **x**, и **y** мы выполняем масштабирование на коэффициент
> **d/z**
Системы координат
-----------------
В виде схемы это выглядит красиво и просто, но начав кодить, вы можете немного запутаться, потому что мы выбрали произвольные наименования, и непонятно, чем мы обозначили координаты 3D-мира, а чем координаты 2D-экрана. Также мы предполагаем, что камера находится в центре начала координат мира, хотя в реальности она будет следовать за машиной.
Если подходить более формально, то нам нужно выполнять:
1. **преобразование** из координат мира в координаты экрана
2. **проецирование** координат камеры на нормализованную плоскость проекции
3. **масштабирование** спроецированных координат на координаты физического экрана (в нашем случае это canvas)
> *Примечание: в настоящей 3d-системе между этапами 1 и 2 выполняется этап *поворота*, но поскольку мы будем имитировать кривые, то поворот нам не нужен.*
Проецирование
-------------
Формальные уравнения проецирования можно представить следующим образом:
* Уравнения преобразования (**translate**) вычисляют точку относительно камеры
* Уравнения проецирования (**project**) являются вариациями показанного выше «закона подобных треугольников»
* Уравнения масштабирования (**scale**) учитывают разность между:
+ *математикой*, где 0,0 находится в центре, а ось y направлена вверх, и
+ *компьютерами*, где 0,0 находится в левом верхнем углу, а ось y направлена вниз:
> *Примечание: в полнофункциональной 3d-системе нам нужно было бы более формально задать класс `Vector` и `Matrix` для выполнения более надёжной 3d-математики, и если мы бы сделали это, то стоило бы просто использовать WebGL (или его аналог)… но в нашем проекте это не требуется. Я хотел придерживаться олдскульной псевдотрёхмерности для создания игры в стиле Outrun.*
Ещё немного тригонометрии
-------------------------
Последним куском головоломки станет способ вычисления **d** — расстояния от камеры до плоскости проецирования.
Вместо того, чтобы просто прописывать жёстко заданное значение **d**, более полезно будет вычислять его из нужной вертикальной области обзора. Благодаря этому мы сможем при необходимости «зумить» камеру.
Если предположить, что мы выполняем проецирование на нормализованную плоскость проецирования, координаты которой находятся в интервале от -1 до +1, то **d** можно вычислить следующим образом:
> **d** = 1/tan(fov/2)
Задавая **fov** как одну (из множества) переменных, мы сможем настраивать область обзора для тонкой подстройки алгоритма рендеринга.
Структура кода на Javascript
----------------------------
В начале статьи я уже сказал, что код не совсем соответствует рекомендациям по написанию Javascript — это «быстрое и грязное» демо с простыми глобальными переменными и функциями. Однако поскольку я собираюсь создать четыре отдельные версии (прямые, кривые, холмы и спрайты), то буду хранить некоторые многократно используемые методы внутри `common.js` в рамках следующих модулей:
* **Dom** — несколько мелких вспомогательных функций DOM.
* **Util** — общие утилиты, в основном вспомогательные математические функции.
* **Game** — общие игровые вспомогательные функции, например, загрузчик изображений и игровой цикл.
* **Render** — вспомогательные функции рендеринга на canvas.
Подробно я буду объяснять методы из `common.js`, только если они относятся к самой игре, а не являются просто вспомогательными математическими или DOM-функциями. Надеюсь, из названия и контекста будет понятно, что должны делать методы.
> *Как обычно, исходный код находится в окончательной документации.*
Простой игровой цикл
--------------------
Прежде чем что-то рендерить, нам нужен игровой цикл. Если вы читали любую из моих предыдущих статей про игры ([pong](https://codeincomplete.com/articles/javascript-pong), [breakout](https://codeincomplete.com/articles/javascript-breakout), [tetris](https://codeincomplete.com/articles/javascript-tetris), [snakes](https://codeincomplete.com/articles/javascript-snakes) или [boulderdash](https://codeincomplete.com/articles/javascript-boulderdash)), то уже видели примеры моего любимого игрового цикла с [фиксированным шагом времени](http://gafferongames.com/game-physics/fix-your-timestep/).
Я не буду вдаваться глубоко в подробности, и просто повторно использую часть кода из предыдущих игр, чтобы создать игровой цикл с фиксированным шагом времени при помощи [requestAnimationFrame](http://paulirish.com/2011/requestanimationframe-for-smart-animating/).
Принцип заключается в том, что каждый из моих четырёх примеров может вызывать `Game.run(...)` and и использовать собственные версии
* `update` — обновление игрового мира с фиксированным шагом времени.
* `render` — обновление игрового мира, когда позволяет браузер.
```
run: function(options) {
Game.loadImages(options.images, function(images) {
var update = options.update, // method to update game logic is provided by caller
render = options.render, // method to render the game is provided by caller
step = options.step, // fixed frame step (1/fps) is specified by caller
now = null,
last = Util.timestamp(),
dt = 0,
gdt = 0;
function frame() {
now = Util.timestamp();
dt = Math.min(1, (now - last) / 1000); // using requestAnimationFrame have to be able to handle large delta's caused when it 'hibernates' in a background or non-visible tab
gdt = gdt + dt;
while (gdt > step) {
gdt = gdt - step;
update(step);
}
render();
last = now;
requestAnimationFrame(frame);
}
frame(); // lets get this party started
});
}
```
Повторюсь, это переделка идей из моих предыдущих игр на canvas, поэтому если вам непонятно, как работает игровой цикл, то вернитесь к одной из предыдущих статей.
Изображения и спрайты
---------------------
Прежде чем начнётся игровой цикл, мы загружаем два отдельных спрайтшита (листа спрайтов):
* **background** — три параллаксных слоя для неба, холмов и деревьев
* **sprites** — спрайты машины (плюс деревья и билборды, которые будут добавлены в окончательную версию)
Спрайтшит был сгенерирован с помощью небольшого таска Rake и [Ruby Gem sprite-factory](https://codeincomplete.com/articles/sprite-factory).
Этот таск генерирует объединённые спрайтшиты, а также координаты x,y,w,h, которые будут храниться в константах `BACKGROUND` и `SPRITES`.
> *Примечание: фоны созданы мной при помощи Inkscape, а большинство спрайтов — это графика, [позаимствованная](http://pixel.garoux.net/game/44) из старой версии Outrun для Genesis и использованная в качестве обучающих примеров.*
Игровые переменные
------------------
В дополнение к изображениям фонов и спрайтов нам понадобится несколько игровых переменных, а именно:
```
var fps = 60; // how many 'update' frames per second
var step = 1/fps; // how long is each frame (in seconds)
var width = 1024; // logical canvas width
var height = 768; // logical canvas height
var segments = []; // array of road segments
var canvas = Dom.get('canvas'); // our canvas...
var ctx = canvas.getContext('2d'); // ...and its drawing context
var background = null; // our background image (loaded below)
var sprites = null; // our spritesheet (loaded below)
var resolution = null; // scaling factor to provide resolution independence (computed)
var roadWidth = 2000; // actually half the roads width, easier math if the road spans from -roadWidth to +roadWidth
var segmentLength = 200; // length of a single segment
var rumbleLength = 3; // number of segments per red/white rumble strip
var trackLength = null; // z length of entire track (computed)
var lanes = 3; // number of lanes
var fieldOfView = 100; // angle (degrees) for field of view
var cameraHeight = 1000; // z height of camera
var cameraDepth = null; // z distance camera is from screen (computed)
var drawDistance = 300; // number of segments to draw
var playerX = 0; // player x offset from center of road (-1 to 1 to stay independent of roadWidth)
var playerZ = null; // player relative z distance from camera (computed)
var fogDensity = 5; // exponential fog density
var position = 0; // current camera Z position (add playerZ to get player's absolute Z position)
var speed = 0; // current speed
var maxSpeed = segmentLength/step; // top speed (ensure we can't move more than 1 segment in a single frame to make collision detection easier)
var accel = maxSpeed/5; // acceleration rate - tuned until it 'felt' right
var breaking = -maxSpeed; // deceleration rate when braking
var decel = -maxSpeed/5; // 'natural' deceleration rate when neither accelerating, nor braking
var offRoadDecel = -maxSpeed/2; // off road deceleration is somewhere in between
var offRoadLimit = maxSpeed/4; // limit when off road deceleration no longer applies (e.g. you can always go at least this speed even when off road)
```
Некоторые из них можно настраивать при помощи элементов управления UI для изменения критически важных значений в процессе выполнения программы, чтобы можно было увидеть, как они влияют на рендеринг дороги. Другие повторно вычисляются из настраиваемых UI значений в методе `reset()`.
Управляем Ferrari
-----------------
Мы выполняем привязку клавиш для `Game.run`, которая обеспечивает простой ввод с клавиатуры, задающий или сбрасывающий переменные, сообщающие о текущих действиях игрока:
```
Game.run({
...
keys: [
{ keys: [KEY.LEFT, KEY.A], mode: 'down', action: function() { keyLeft = true; } },
{ keys: [KEY.RIGHT, KEY.D], mode: 'down', action: function() { keyRight = true; } },
{ keys: [KEY.UP, KEY.W], mode: 'down', action: function() { keyFaster = true; } },
{ keys: [KEY.DOWN, KEY.S], mode: 'down', action: function() { keySlower = true; } },
{ keys: [KEY.LEFT, KEY.A], mode: 'up', action: function() { keyLeft = false; } },
{ keys: [KEY.RIGHT, KEY.D], mode: 'up', action: function() { keyRight = false; } },
{ keys: [KEY.UP, KEY.W], mode: 'up', action: function() { keyFaster = false; } },
{ keys: [KEY.DOWN, KEY.S], mode: 'up', action: function() { keySlower = false; } }
],
...
}
```
Состоянием игрока управляют следующие переменные:
* **speed** — текущая скорость.
* **position** — текущая позиция по Z на трассе. Заметьте, что это позиция камеры, а не Ferrari.
* **playerX** — текущая позиция игрока по X на дороге. Нормализована в интервале от -1 до +1, чтобы не зависеть от действительного значения `roadWidth`.
Эти переменные задаются внутри метода `update`, который выполняет следующие действия:
* обновляет `position` на основании текущей `speed`.
* обновляет `playerX` при нажатии на клавиши «влево» или «вправо».
* увеличивает `speed`, если нажата клавиша «вверх».
* уменьшает `speed`, если нажата клавиша «вниз».
* уменьшает `speed`, если не нажаты клавиши «вверх» и «вниз».
* уменьшает `speed`, если `playerX` находится за краем дороги и на траве.
В случае прямых дорог метод `update` довольно ясен и прост:
```
function update(dt) {
position = Util.increase(position, dt * speed, trackLength);
var dx = dt * 2 * (speed/maxSpeed); // at top speed, should be able to cross from left to right (-1 to 1) in 1 second
if (keyLeft)
playerX = playerX - dx;
else if (keyRight)
playerX = playerX + dx;
if (keyFaster)
speed = Util.accelerate(speed, accel, dt);
else if (keySlower)
speed = Util.accelerate(speed, breaking, dt);
else
speed = Util.accelerate(speed, decel, dt);
if (((playerX < -1) || (playerX > 1)) && (speed > offRoadLimit))
speed = Util.accelerate(speed, offRoadDecel, dt);
playerX = Util.limit(playerX, -2, 2); // dont ever let player go too far out of bounds
speed = Util.limit(speed, 0, maxSpeed); // or exceed maxSpeed
}
```
Не волнуйтесь, он станет намного сложнее, когда в готовой версии мы добавим спрайты и распознавание коллизий.
Геометрия дороги
----------------
Прежде чем мы сможем рендерить игровой мир, нам нужно построить массив из `segments` в методе `resetRoad()`.
Каждый из этих сегментов дороги в конце концов будет спроецирован из его мировых координат, чтобы он превратился в 2d-полигон в экранных координатах. Для каждого сегмента мы храним две точки, **p1** — это центр наиболее близкого к камере ребра, а **p2** — центр самого дальнего от камеры ребра.
Строго говоря, **p2** каждого сегмента идентична **p1** предыдущего сегмента, но мне кажется, что проще хранить их как отдельные точки, и преобразовывать каждый сегмент по отдельности.
Мы храним отдельную `rumbleLength` потому, что у нас могут быть красивые детализированные кривые и холмы, но в то же время и горизонтальные полосы. Если каждый следующий сегмент будет иметь другой цвет, то это создаст нехороший эффект стробоскопа. Поэтому мы хотим иметь множество мелких сегментов, но сгруппировать их вместе, чтобы образовать отдельные горизонтальные полосы.
```
function resetRoad() {
segments = [];
for(var n = 0 ; n < 500 ; n++) { // arbitrary road length
segments.push({
index: n,
p1: { world: { z: n *segmentLength }, camera: {}, screen: {} },
p2: { world: { z: (n+1)*segmentLength }, camera: {}, screen: {} },
color: Math.floor(n/rumbleLength)%2 ? COLORS.DARK : COLORS.LIGHT
});
}
trackLength = segments.length * segmentLength;
}
```
Мы инициализируем **p1** и **p2** только со значениями мировых координат **z**, потому что нам нужны только прямые дороги. Координаты **y** всегда будут равны 0, а координаты **x** всегда будут зависеть от масштабированного значения `+/- roadWidth`. Позже, когда мы добавим кривые и холмы, эта часть изменится.
Также мы зададим пустые объекты для хранения представлений этих точек в камере и на экране, чтобы не создавать кучу временных объектов в каждом `render`. Чтобы до минимума снизить объём сборки мусора, мы должны избегать выделения объектов внутри игрового цикла.
Когда машина достигает конца дороги, мы просто возвращаемся в начало цикла. Чтобы упростить это, мы создадим метод для нахождения сегмента для любого значения Z, даже если он выходит за пределы длины дороги:
```
function findSegment(z) {
return segments[Math.floor(z/segmentLength) % segments.length];
}
```
Рендеринг фона
--------------
Метод `render()` начинается с отрисовки фонового изображения. В следующих частях, где мы добавим кривые и холмы, нам нужно будет, чтобы фон выполнял параллаксный скроллинг, поэтому мы уже сейчас начнём двигаться в этом направлении, выполняя рендеринг фона как трёх отдельных слоёв:
```
function render() {
ctx.clearRect(0, 0, width, height);
Render.background(ctx, background, width, height, BACKGROUND.SKY);
Render.background(ctx, background, width, height, BACKGROUND.HILLS);
Render.background(ctx, background, width, height, BACKGROUND.TREES);
...
```
Рендеринг дороги
----------------
Затем функция render итеративно проходит по всем сегментам и проецирует **p1** и **p2** каждого сегмента из мировых координат в экранные, при необходимости обрезая сегмент, а в противном случае выполняя его рендеринг:
```
var baseSegment = findSegment(position);
var maxy = height;
var n, segment;
for(n = 0 ; n < drawDistance ; n++) {
segment = segments[(baseSegment.index + n) % segments.length];
Util.project(segment.p1, (playerX * roadWidth), cameraHeight, position, cameraDepth, width, height, roadWidth);
Util.project(segment.p2, (playerX * roadWidth), cameraHeight, position, cameraDepth, width, height, roadWidth);
if ((segment.p1.camera.z <= cameraDepth) || // behind us
(segment.p2.screen.y >= maxy)) // clip by (already rendered) segment
continue;
Render.segment(ctx, width, lanes,
segment.p1.screen.x,
segment.p1.screen.y,
segment.p1.screen.w,
segment.p2.screen.x,
segment.p2.screen.y,
segment.p2.screen.w,
segment.color);
maxy = segment.p2.screen.y;
}
```
Выше мы уже видели вычисления, необходимые для проецирования точки; версия на javascript объединяет преобразование, проецирование и масштабирование в один метод:
```
project: function(p, cameraX, cameraY, cameraZ, cameraDepth, width, height, roadWidth) {
p.camera.x = (p.world.x || 0) - cameraX;
p.camera.y = (p.world.y || 0) - cameraY;
p.camera.z = (p.world.z || 0) - cameraZ;
p.screen.scale = cameraDepth/p.camera.z;
p.screen.x = Math.round((width/2) + (p.screen.scale * p.camera.x * width/2));
p.screen.y = Math.round((height/2) - (p.screen.scale * p.camera.y * height/2));
p.screen.w = Math.round( (p.screen.scale * roadWidth * width/2));
}
```
Кроме вычисления экранных **x** и **y** для каждых точек **p1** и **p2** мы используем те же вычисления проецирования для вычисления спроецированной ширины (**w**) сегмента.
Имея экранные координаты **x** и **y** точек **p1** и **p2**, а также спроецированную ширину дороги **w**, мы можем довольно просто вычислить при помощи вспомогательной функции `Render.segment` все полигоны, необходимые ей для рендеринга травы, дороги, горизонтальных полос и разделительных линий, воспользовавшись общей вспомогательной функцией `Render.polygon` *(см. `common.js`)*.
Рендеринг машины
----------------
Наконец, последнее, что требуется методу `render` — это рендеринг Ferrari:
```
Render.player(ctx, width, height, resolution, roadWidth, sprites, speed/maxSpeed,
cameraDepth/playerZ,
width/2,
height);
```
Этот метод называется `player`, а не `car`, потому что в окончательной версии игры на дороге будут и другие машины, и мы хотим отделить Ferrari игрока от других машин.
Вспомогательная функция `Render.player` использует метод canvas под названием `drawImage` для рендеринга спрайта, предварительно отмасштабировав его при помощи того же масштабирования проекции, которое использовалось раньше:
> **d**/**z**
Где **z** в данном случае — это относительное расстояние от машины до камеры, хранящееся в переменной **playerZ**.
Кроме того, функция немного «трясёт» машину на высоких скоростях, добавляя в уравнение масштабирования немного случайности, зависящей от **speed/maxSpeed**.
И вот что у нас получилось:
Заключение
----------
Мы проделали довольно большой объём работы только для того, чтобы создать систему с прямыми дорогами. Мы добавили
* общий вспомогательный модуль **Dom**
* общий математический вспомогательный модуль **Util**
* общий вспомогательный canvas-модуль **Render**...
* … в том числе `Render.segment`, `Render.polygon` и `Render.sprite`
* игровой цикл с фиксированным шагом
* загрузчик изображений
* обработчик клавиатуры
* фон с параллаксными слоями
* спрайтшит с автомобилями, деревьями и билбордами
* рудиментарную геометрию дороги
* метод `update()` для управления машиной
* метод `render()` для рендеринга фона, дороги и машины игрока
* HTML5-тег с гоночной музыкой (скрытый бонус!)
… что дало нам хороший фундамент для дальнейшего развития.
Часть 2. Кривые.
----------------
В этой части мы подробнее расскажем, как работают кривые.
В предыдущей части мы составили геометрию дороги в виде массива сегментов, каждый из которых имеет мировые координаты, преобразуемые относительно камеры, а затем проецируются на экран.
Нам нужна была только мировая координата **z** для каждой точки, потому что на прямых дорогах и **x**, и **y** были равны нулю.
Если бы мы создавали полнофункциональную 3d-систему, то могли бы реализовать кривые, вычисляя **x** и **z** полосы многоугольников, показанных выше. Однако такой тип геометрии будет довольно непросто вычислять, и для этого потребуется добавить в уравнения проецирования этап 3d-поворота…
… если бы мы двинулись этим путём, то лучше было бы использовать WebGL или его аналоги, но этот проект не у нашего проекта другие задачи. Мы просто хотим использовать для имитации кривых олдскульные псевдотрёхмерные трюки.
Поэтому вы наверно удивитесь, узнав, что мы вообще не будем вычислять координаты **x** сегментов дороги…
Вместо этого мы воспользуемся [советом Лу](http://www.extentofthejam.com/pseudo/):
> *«чтобы искривить дорогу, достаточно просто изменить позицию центральной линии формы кривой… начиная с низа экрана, величина сдвига центра дороги влево или вправо постепенно увеличивается»*.
В нашем случае центральной линией является значение `cameraX`, передаваемое в вычисления проецирования. Это означает, что когда мы выполняем `render()` каждого сегмента дороги, можно имитировать кривые, сдвигая значение `cameraX` на постепенно возрастающую величину.
Чтобы знать, на сколько выполнять сдвиг, нам нужно хранить в каждом сегменте значение `curve`. Эта величина обозначает, на сколько сегмент должен быть сдвинут от центральной линии камеры. Она будет:
* отрицательной для поворачивающих налево кривых
* положительной для поворачивающих вправо кривых
* меньше для плавных кривых
* больше для резких кривых
Сами значения выбираются довольно произвольно; путём проб и ошибок мы можем подобрать хорошие значения, при которых кривые кажутся «правильными»:
```
var ROAD = {
LENGTH: { NONE: 0, SHORT: 25, MEDIUM: 50, LONG: 100 }, // num segments
CURVE: { NONE: 0, EASY: 2, MEDIUM: 4, HARD: 6 }
};
```
Кроме подбора хороших значений для кривых нам нужно избегать любых разрывов в переходах, когда прямая превращается в кривую (или наоборот). Это можно реализовать [смягчением](http://jqueryui.com/demos/effect/easing.html) при входе и выходе из кривых. Мы сделаем это, постепенно увеличивая (или уменьшая) значение `curve` для каждого сегмента при помощи традиционных функций плавности, пока оно не достигнет нужного значения:
```
easeIn: function(a,b,percent) { return a + (b-a)*Math.pow(percent,2); },
easeOut: function(a,b,percent) { return a + (b-a)*(1-Math.pow(1-percent,2)); },
easeInOut: function(a,b,percent) { return a + (b-a)*((-Math.cos(percent*Math.PI)/2) + 0.5); },
```
То есть теперь, с учётом функции добавления одного сегмента к геометрии…
```
function addSegment(curve) {
var n = segments.length;
segments.push({
index: n,
p1: { world: { z: n *segmentLength }, camera: {}, screen: {} },
p2: { world: { z: (n+1)*segmentLength }, camera: {}, screen: {} },
curve: curve,
color: Math.floor(n/rumbleLength)%2 ? COLORS.DARK : COLORS.LIGHT
});
}
```
мы можем создать метод для плавного входа, нахождения и плавного выхода с искривлённой дороги:
```
function addRoad(enter, hold, leave, curve) {
var n;
for(n = 0 ; n < enter ; n++)
addSegment(Util.easeIn(0, curve, n/enter));
for(n = 0 ; n < hold ; n++)
addSegment(curve);
for(n = 0 ; n < leave ; n++)
addSegment(Util.easeInOut(curve, 0, n/leave));
}
```
… а поверх можно наложить дополнительную геометрию, например, S-образные кривые:
```
function addSCurves() {
addRoad(ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, -ROAD.CURVE.EASY);
addRoad(ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, ROAD.CURVE.MEDIUM);
addRoad(ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, ROAD.CURVE.EASY);
addRoad(ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, -ROAD.CURVE.EASY);
addRoad(ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, ROAD.LENGTH.MEDIUM, -ROAD.CURVE.MEDIUM);
}
```
Изменения в методе update()
---------------------------
Единственные изменения, которые необходимо внести в метод `update()` — это приложение своего рода центробежной силы, когда машина движется по кривой.
Мы задаём произвольный множитель, который можно настраивать в соответствии с нашими предпочтениями.
```
var centrifugal = 0.3; // centrifugal force multiplier when going around curves
```
А затем мы просто будем обновлять позицию `playerX` на основании его текущей скорости, величины curve и множителя центробежной силы:
```
playerX = playerX - (dx * speedPercent * playerSegment.curve * centrifugal);
```
Рендеринг кривых
----------------
Выше мы говорили, что можно рендерить имитируемые кривые, смещая значение `cameraX`, используемое в вычислениях проецирования, в процессе выполнения `render()` каждого сегмента дороги.
Для этого мы будем хранить переменную накопителя **dx**, увеличивающуюся для каждого сегмента на значение `curve`, а также переменную **x**, которая будет использоваться как смещение значения `cameraX`, используемого в вычислениях проецирования.
Для реализации кривых нам нужно следующее:
* смещаем проекцию **p1** каждого сегмента на **x**
* смещаем проекцию **p2** каждого сегмента на **x** + **dx**
* увеличиваем **x** для следующего сегмента на **dx**
Наконец, чтобы избежать рваных переходов при пересечении границ сегментов, мы должны сделать так, чтобы **dx** инициализировалась интерполированным значением кривой текущих базовых сегментов.
Изменим метод `render()` следующим образом:
```
var baseSegment = findSegment(position);
var basePercent = Util.percentRemaining(position, segmentLength);
var dx = - (baseSegment.curve * basePercent);
var x = 0;
for(n = 0 ; n < drawDistance ; n++) {
...
Util.project(segment.p1, (playerX * roadWidth) - x, cameraHeight, position - (segment.looped ? trackLength : 0), cameraDepth, width, height, roadWidth);
Util.project(segment.p2, (playerX * roadWidth) - x - dx, cameraHeight, position - (segment.looped ? trackLength : 0), cameraDepth, width, height, roadWidth);
x = x + dx;
dx = dx + segment.curve;
...
}
```
Фон с параллаксным скроллингом
------------------------------
Наконец, нам нужно выполнять скроллинг параллаксных слоёв фона, храня смещение для каждого слоя…
```
var skySpeed = 0.001; // background sky layer scroll speed when going around curve (or up hill)
var hillSpeed = 0.002; // background hill layer scroll speed when going around curve (or up hill)
var treeSpeed = 0.003; // background tree layer scroll speed when going around curve (or up hill)
var skyOffset = 0; // current sky scroll offset
var hillOffset = 0; // current hill scroll offset
var treeOffset = 0; // current tree scroll offset
```
… и увеличивая его во время `update()` в зависимости от величины curve текущего сегмента игрока и его скорости…
```
skyOffset = Util.increase(skyOffset, skySpeed * playerSegment.curve * speedPercent, 1);
hillOffset = Util.increase(hillOffset, hillSpeed * playerSegment.curve * speedPercent, 1);
treeOffset = Util.increase(treeOffset, treeSpeed * playerSegment.curve * speedPercent, 1);
```
… а затем использовать использовать это смещение при выполнении `render()` слоёв фона.
```
Render.background(ctx, background, width, height, BACKGROUND.SKY, skyOffset);
Render.background(ctx, background, width, height, BACKGROUND.HILLS, hillOffset);
Render.background(ctx, background, width, height, BACKGROUND.TREES, treeOffset);
```
Заключение
----------
Итак, вот мы и получили фальшивые псевдотрёхмерные кривые:
Основная часть добавленного нами кода заключается в построении геометрии дороги с соответствующим значением `curve`. Реализовав её, добавить центробежную силу во время `update()` намного проще.
Рендеринг кривых выполняется всего в нескольких строках кода, но может быть сложно понять (и описать), что же конкретно здесь происходит. Существует множество способов имитации кривых и очень легко забрести при их реализации в тупик. Ещё проще увлечься посторонней задачей и попробовать сделать всё «правильно»; прежде чем успеете осознать это, вы начнёте создавать полнофункциональную 3d-систему с матрицами, поворотами и настоящей 3d-геометрией… которые, как я сказал, не являются нашей задачей.
При написании этой статьи я был уверен, что в моей реализации кривых определённо есть проблемы. Пытаясь визуализировать алгоритм, я не понимал, зачем мне понадобились два значения накопителей **dx** и **x** вместо одного… а если я не могу чего-то полностью объяснить, то где-то что-то пошло не так…
… но время работы над проектом *«на выходные»* почти истекло, и, честно говоря, кривые кажутся мне вполне красивыми, и в конечном итоге, это самое важное. | https://habr.com/ru/post/499252/ | null | ru | null |
# Обзор литературы прочитанной за два года
Привет Хабра! Когда я только начинал заниматься веб-разработкой, то даже не мог представить, сколько литературы нужно прочесть и какой объем знаний получить, чтобы стать нормальным специалистом. Кроме того, сфера постоянно меняется, и знания устаревают.
 Для меня проблема заключалась в том, что я не люблю читать и чтение расцениваю исключительно как неизбежную работу, которую необходимо проделать, чтобы добыть материал из печатного вида. Но так получилось, что для повышения своей квалификации читать приходится. Я установил для себя норму — одна книга в месяц. С одной стороны, это мало, с другой, — много (если действительно придерживаться плана). Ну и раз уж мне приходится читать в принудительном порядке, это должно давать какую-либо выгоду. Каждая книга — это мучение, и я не вижу смысла тратить время на литературу, которая мне ничего не даст после. Поэтому каждый раз, попадая в книжный и держа в руках очередную книгу, я задаю себе вопрос: «А зачем?! Какой толк от этих кусков бумаги?! Что я вообще тут делаю?!». Чтобы вы не тратили время на книги, которые мне кажутся бесполезными, я решил написать небольшой обзор прочитанной за два года литературы и прочих найденных источников знаний. Весь материал ниже так или иначе связан с веб-разработкой и различными её аспектами. Ниже описаны только те книги, которые я прочитал. Те книги, которые «не осилил»/не дочитал (например, про NodeJS и пару фреймворков) не привожу.
##### Критерии оценки книг:
* Количество кода. Чем больше кода в книге, тем она хуже. Это значит, что автор приводит бессмысленные листинги программ вместо того, чтобы описать словами алгоритм работы.
* Толщина книги. Чем толще книга, тем хуже. Скорее всего, её будет трудно дочитать до конца. Почему она стала толстой?
+ Потому что там много воды.
+ Потому что автор не умеет излагать свои мысли коротко и четко.
+ Потому что автор работает в каком-либо университете, так что писать тонкую книгу — не серьёзно: коллеги с кафедры будут смеяться, поэтому он раздувает ещё бессмысленными вставками.
* Иллюстрации. Чем меньше иллюстраций, тем книга хуже. Одна и та же информация, представленная в графическом и текстовом виде, легче воспринимается в графическом. Так же играет роль глубина переработки информации. Текст с иллюстрацией воспринимается лучше, чем текст без иллюстрации. Наличие качественных иллюстраций показывает, что автор работал над книгой «с душой».
* Дизайн и верстка. Хороший дизайн ускоряет чтение и позволяет лучше усваивать информацию. В этот пункт входит соблюдение правил типографики, верстки и структурирования информации.
* Хорошая книга легко читается: глаза не должны уставать, а страницы должны быть приятными на ощупь (в этом плане глянцевые издания для дизайнеров, конечно, вне конкуренции). Качественный дизайн, опять же, показывает, что над книгой работали «с душой».
* Идеи, а не методы. Хорошая книга должна учить тому, что не устареет в ближайшие несколько лет, а то и больше. Для всего остального подходят статьи в соответствующих изданиях. Зачем платить 1000 руб. за книгу об API очередного модного фреймворка, о котором все забудут через полгода? Лучше почитать об идеях, которые воплотили авторы в фреймворке, о том чего они хотели, как этого добивались, к чему пришли. Как проектировали архитектуру и почему именно так.
Начнем с основных представителей жанра.
JavaScript: Подробное руководство
---------------------------------
(JavaScript: Definitive Guide. David Flanagan)
**Итого:** 982 страниц / средний дизайн
Очень толстая книга, в которой описано что, как и почему работает. Читать её, возможно, нет смысла, т.к. появилась альтернатива от Ильи Кантора.
Современный учебник JavaScript
------------------------------
Сайт: JavaScript.ru
Собственно, альтернатива Девиду Фланагану. Написано все и обо всем. Читается в два/три этапа — первый раз ты понимаешь основы JavaScript, а второй раз осознаешь все его тонкости. Честно говоря, так часто обращаюсь к справочной информации на этом сайте, что даже не представляю интернет до него.
Далее ряд книг, которые читали все JavaScript-разработчики. Книги нужно читать не потому, что в них конкретные мысли, а потому, что они учат, как надо писать на JavaScript`е. В них рассмотрены паттерны проектирования и объясняется суть различных библиотек. Именно эти книги учат думать, как веб-разработчик. Я не могу сказать, что это отличные книги, в основном они скорее хорошие, но все они обязательны к прочтению.
Веб-приложения на JavaScript
----------------------------
(JavaScript Web Applications. Alex MacCaw)
Основные мысли:
* Бейте все на модули и инкапсулируйте (function() {… })();
* Чтобы сделать цепочку вызовов, возвращайте объект, с которым работаете
* Используйте библиотеки
**Итого:** 1000 руб. / 300 страниц / средний дизайн / нормальная книга
Повсюду в содержании написано слово MVC, хотя книга скорее о модулях и модульном подходе. Много написано про события, но скорее справочной информации. Много отсылок к jQuery, да и вообще автор поверхностно пробегает по разным библиотекам, объясняя, как они появились и зачем были нужны. В конце книги идет приложение, в котором, например, есть справочник по CSS3. Складывается ощущение, что автор стремился добить книгу текстом до нужного объема.
JavaScript. Шаблоны
-------------------
(JavaScript Patterns. Stoyan Stefanov)
**Итого:** 900 руб. / 200 страниц / средний дизайн / нормальная книга
Книга целиком и полностью об ООП в JavaScript`е. Ну и конечно есть такие темы, как: каррирование, фасад, прокси-объект, стратегия, декоратор, итератор и т.п. Книга вряд ли когда-либо устареет, т.к. основана на алгоритмах, а они не меняются. Из минусов — это опыт читателей. Многие приемы, описанные в книге, на практике появляются только в сложных проектах. Для того, чтобы сделать визитку для ООО «Рога и копыта», такие знания конечно не нужны.
Ну и просто список того, что выглядело более-менее хорошо на общем фоне книг, на книжной полке в магазине.
Читаемый код или Программирование как искусство
-----------------------------------------------
(The Art of Readable Code (Theory in Practice). Dustin Boswell, Trevor Foucher)
Основные мысли:
* Одна функция — одна задача
* Полные имена переменных
* Разбивайте длинные выражения на короткие
* Выделяйте блоки кода
**Итого:** 500 руб. / 200 страниц / средний дизайн / остался доволен
Ну, тут многие скажут, что книжка совсем уже для тех, кто только начинает программировать. Не соглашусь. Конечно, любители Java выберут «Чистый код. Создание, анализ и рефакторинг» (Мартин Р.), а вот веб-разработчики часто не следуют даже базовым принципам. Например, постоянные сокращения btn вместо button и подобные. Да и статьи в стиле Армина Ронахера «Хватит быть милым и умным» (Stop Being Cute and Clever, <http://habrahabr.ru/post/205616/>) не появлялись бы. Одним из самых запоминающихся для меня примеров из книги, был пример сокращения вложенности:
```
function(name, age) {
if(!name || !age) return false;
...
}
```
Вместо:
```
function(name, age) {
if(name && age) {
...
}
}
```
Уж очень часто у любителей jQuery вложенность сильно возрастает. Да и факт появления библиотеки «Q» для NodeJS (<https://github.com/kriskowal/q>) для меня является скорее отрицательным показателем. Почему? Если у вас одна функция выполняет одну задачу, факт появления многократной вложенности маловероятен.
JavaScript сильные стороны
--------------------------
(JavaScript: The Good Parts. Douglas Crockford)
**Итого:** 250 руб. / 250 страниц / средний дизайн / отличный справочник
Многие ведутся на название книги «сильные стороны», хотя в самой книге этих самых сильных сторон нет.
По сути это некий справочник, в котором более-менее коротко описаны большинство объектов JavaScript`а.
Такой справочник хорошо пролистать перед собеседованием или чтобы вспомнить редко используемые методы. А так, Илья Кантор вам в помощь.
CSS3. Руководство разработчика
------------------------------
(The Book of CSS3: A Developer's Guide to the Future of Web Design. Peter Gasston)
**Итого:** 500 руб. / 170 страниц / средний дизайн / нормальный справочник
Книгу дали на конференции. Сначала думал — очередная подборка копирайта, но, как оказалось, это вполне нормальный справочник. Все примеры проиллюстрированы, автор пишет коротко и по делу, воды нет. Очень напоминает книгу «JavaScript сильные стороны», только по части CSS3.
Ошибки веб-дизайна или как их устранить до того, как вы лишитесь посетителей
----------------------------------------------------------------------------
(Defensive Design for the Web. Matthew Linderman, Jason Fried).
Основные мысли:
* Сообщение об ошибке должно быть заметно
+ Используйте цвет, условные значки и текст, чтобы ясно обозначить проблемное место
+ Всегда обозначайте ошибки одним и тем же способом
* Сообщение об ошибке должно быть понятным
+ Не используйте язык, который не понятен вашим клиентам
+ Текст должен быть коротким и понятным
+ Извинительный тон
* Работа с формой:
+ Выделяйте обязательные и дополнительные поля
+ Принимайте ввод во всех распространенных форматах
+ Давайте примеры ввода, списки, подсказки
+ Ясно устанавливайте ограничение на количество символов
+ Если клиенту не доступны некоторые варианты — не предлагайте их
+ Проверяйте ввод как можно быстрее
+ Уберите кнопку «Очистить» и делайте недоступной после нажатия кнопку «Отправить»
+ Сохраняйте информацию
* Работа со страницей 404
* Перенаправляйте частично неверные URL
* Предложите альтернативную версию информации и сведения об обновлении для старых браузеров
* Отвечайте на вопросы на той же странице
* Создайте раздел «Помощь»
* Предусмотрите несколько вариантов поддержки
* Отвечайте на e-mail быстро и информативно
* Уберите ненужную рекламу
* Лучше быстро, чем красиво
* Не заставляйте регистрироваться
* Уберите лишнюю навигацию
* Помощь при поиске:
+ Четко объясняйте, почему при поиске не найдены результаты или показаны неточные совпадения
+ Предугадывайте типичные ошибки и показывайте подходящий результат
+ Дайте возможность отфильтровать результаты
+ Посоветуйте, как улучшить результаты поиска
* Если продукт будет доступен позже, объясните когда
* Предлагайте уведомление по e-mail
* Анализируйте логи сервера
* Изучайте обращения в тех. поддержку
* Анализируйте конкурентов
**Итого:** 170 руб. / 200 страниц / дешевый дизайн / отличная книга
С первого взгляда книга не внушала доверия, но я остался очень доволен. Нет воды. На каждый совет по три-четыре хороших и плохих примера. Все примеры со скриншотами и коротким описанием. Основная мысль — «безопасный дизайн». Учит предупреждать ошибки пользователей. Можно использовать как чеклист перед сдачей сайта. Даже несмотря на то, что все советы довольно избиты, тем не менее, большинство программистов им не следует. В книге чувствуется взгляд не со стороны программиста, а со стороны специалиста по решению конфликтных ситуаций.
Веб дизайн
----------
(Designing Web Usability: The Practice of Simplicity. Jakob Nielsen)
**Итого:** цену не знаю / 500 страниц / средний дизайн / бессмысленно
С одной стороны, содержание книги в целом уже не актуально, с другой — в тексте в основном вода. Возможно, совсем зеленым студентам следует бегло пробежаться по разделам. Как и в любой «книге про web» расписаны интуитивно понятные вещи:
* Лучшие сайты — быстрые
* Тексты: краткость, грамотность, четкость и т.п.
* Делайте нормальное меню
* Делайте нормальные URL
* Тестируйте на ошибки
* Используйте alt для изображений
Даже несмотря на то, что это сам Якоб Нильсен, — рекомендовать не буду.
На работе мне постоянно делали замечания об отсутствии «чувства прекрасного», поэтому решил пройтись по дизайну:
Универсальные принципы дизайна.
-------------------------------
(Universal Principles of Design. W. Lidwell, K. Holden and J. Butler)
Основные мысли:
* Высокий процент результатов в любой крупной системе зависит от низкого процента переменных
* Объекты и среды следует разрабатывать таким образом, чтобы максимальное количество людей могли использовать их без модификации
* Привлекательные с точки зрения эстетики разработки кажутся проще в использовании, чем непривлекательные
* Внешний вид объекта должен подсказывать способ его использования
* Люди находят более привлекательными формы, которые напоминают человека или обладают антропоморфными характеристиками
* Выравнивать объекты следует по центру масс
* Богатая пейзажами окружающая среда снижает стресс, улучшает сосредоточенность и концентрацию
* Использование блоков информации
* Цветовая схема Иттена
* Предотвращение непреднамеренных действий путем их предварительной верификации
* Система удобнее для использования, когда одинаковые элементы представлены одинаковым образом
* Метод установления границ для операций, которые можно производить над системой
* Тенденция отдавать предпочтение объектам с плавными контурами, а не с острыми углами или заостренными элементами
* Уровень контроля, обеспечиваемый системой, должен соответствовать навыкам и умением её пользователя (expert / normal mode)
* Глубина переработки информации
* Проектирование, основанное на нахождении консенсуса
* Следы использования или износа указывают на методы взаимодействия с объектом или окружающей средой, которые предпочитает пользователь
* Всегда должна быть точка входа
* Аварии — следствие ошибок в конструкции. Действие и бездействие, приводящие к непредумышленному результату.
* Использование элементов в большем количестве, чем необходимо, с целью компенсировать влияние неизвестных переменных и предотвратить сбой системы
* Отношение фигура/фон
* Время, необходимое для наведения указателя на цель, является функцией размера цели и расстояния до нее (закон Фиттса)
* По мере увеличения гибкости системы, её практичность снижается
* Упорядоченная последовательность реакции людей на острый стресс
* Качество выходных данных системы зависит от качества входных данных
* Диаграмма Гутенберга (движение глаз по странице)
* Время, необходимое для принятия решений, возрастает с увеличением количества альтернатив (закон Хика)
* Не стоит заполнять пустые места из-за страха пустоты. Минимализм в дизайне.
* Используйте пиктограммы в интерфейсе для лучшего распознания и вспоминания
* Эффекты замедления обработки информации из-за конфликта психологических процессов.
* Метод подачи информации в порядке снижения её важности.
* Модульный принцип управления сложной системой.
* Средство прогнозируемого изменения поведения без ограничения вариантов или значительного изменения стимулов.
* Картинки запоминаются лучше, чем слова.
* Сигнальный шум. Отношение релевантной информации к нерелевантной, выводимой на дисплей.
* Одинаковые элементы воспринимаются как более связанные между собой.
* Система становится удобнее в эксплуатации, когда её назначение и методы использования четко различимы.
* Использование слабого элемента, который выходит из строя, чтобы защитить другие элементы от аварии.
* и т.п.
**Итого:** 1 200 руб. / 250 страниц / отличный дизайн / отличная книга
Сначала смутила цена, но после прочтения готов был отдать в три раза больше. В книге нет воды. Каждый принцип описан очень кратко, ясно и точно. Всегда с примерами и ссылками на работы других авторов в этой области. Каждый совет оканчивается отсылкой к другой книге или серии книг, в которых конкретная тема раскрыта более широко. Советы покрывают множество направлений дизайна — от проектирования интерфейсов до правил типографики.
Графический дизайн от идеи до воплощения
----------------------------------------
(Graphic Design Thinking (Design Briefs). Ellen Lupton, Jennifer Cole Phillips)
Основные мысли:
* Рисуйте ассоциативные карты ваших идей
* Проводите интервью с клиентами, возможно, им нужно совсем другое
Книга, по сути, представляет собой сборник копирайта на тему «Как определить задачу» и «Откуда брать идеи». Много слов, картинок и банальных штампов. Её интересно пролистать, но остаточных знаний она не несет. Когда её покупал, повелся на раздел «Исследование места». В нем шла речь о расстановке рекламных щитов и информационных указателей в различных сооружениях. Эта тема была мне интересна ещё с момента обучения на PR`е, но книги по теме не попадались. Впрочем, и тут нельзя сказать, что автор раскрыл эту тему. Скорее слегка приподнял завесу.
**Итого:**800 руб. / 200 страниц / отличный дизайн / покупать не советую
Кажется, в этой книге попалась ещё одна интересная мысль — нужно слегка интересоваться всем подряд в самых различных областях, чтобы можно было заимствовать идеи из чужой области. То есть, если идеи кончились, стоит заняться совсем другим направлением деятельности и, может быть, у вас появятся новые идеи.
Школа графического дизайна. Принципы и практика графического дизайна.
---------------------------------------------------------------------
(Graphic Design School: The Principles and Practices of Graphic Design. David Dabner)
Основные мысли:
* Разбор шрифтов
* Разбор цветов и оттенков (цветовую схему Иттена автор пропустил)
* Блоку текста можно придавать различную форму и использовать сам текст как украшение страницы
**Итого:** 750 руб. / 200 страниц / отличный дизайн / средне, много воды
Довольно странная книга. Вроде и написано много, но остаточных знаний снова мало. Можно было бы отнести её к очередному банальному копирайту, но книгу вытягивает раздел о шрифтах и способах верстки страницы, используя сам текст как украшение. В любом случае, своих денег она не стоит. А про шрифты — лучше почитать у Иннокентия Келейникова в книге «Дизайн книги: от слов к делу».
Книги «Универсальные принципы дизайна» и «Ошибки веб-дизайна» помогают осознать, как надо проектировать систему так, чтобы люди совершали как можно меньше ошибок в ней, а также как свести к минимуму негативные последствия ошибок, если они все-таки произошли.
Под впечатлением этих книг решил покрыть полученные знания учебными курсами на тему дизайна. Нормальные курсы стоили не менее 30 000 руб. и по времени растягивались на полгода. Решил сэкономить (и пожалел). Выбрал два учебных центра, стоимостью в среднем 9 000 руб. за курс длинною в 1.5 месяца.
Графический дизайн
------------------
Чему учат: Corel, Photoshop
Что узнал:
* RGBA, CMYK — в чем разница и как появились
* Какие проблемы могут возникнуть в печати
* Как градиентами создать объем и эффект стекла
* Как создать объем через размытие и прозрачность
* Как вырезать сложный объект
* Как «добавить уют» и т.п.
При чем тут дизайн? Не знаю. Преподаватели просто показывают, как нажимать на кнопки. Хотя были и положительные моменты. На курсе Corel разобрали цвета и предпечатную подготовку. Это гораздо шире статей в интернете, которые читал до этого. На курсе Photoshop было много чего, но в памяти осталось разложение цветов по каналам (RGBA) и польза от цветокоррекции. Показали, как добавить «+20% тепла и уюта» и «+17% к объему и глубине снимка». В целом оно того стоило. Да и на собеседованиях часто встречаются вопросы про PNG, которые требуют знаний чуть больше, чем «нарезать макет».
Курс академического рисунка и живописи (рисование карандашом)
-------------------------------------------------------------
Что узнал:
* Толщина линии с одной стороны рисунка должна быть меньше, это придаст иллюзию падения света
Фотошоп фотошопом, а рисовать надо учиться. Поэтому посчитал, что курсы рисования прокачают это умение. А по факту оно того не стоило. Минус 9 000 руб. и время. Мне кажется, тут была проблема в преподавателе. Курсы были очень похожи на школьное ИЗО. Ты приходишь, рисуешь куб два часа, и в голове остается только один вопрос: «И чё?!». Никаких методик и техник, никаких объяснений, только постоянное рисование квадратов, кружков и натюрмортов. Остаточных знаний ноль. Поэтому, если пойдете на рисунок карандашом, спросите про учебный план и какие остаточные знания у вас будут.
Но вернемся к программированию.
Когда начинал писать игры на JavaScript, спросил у коллег, что они могут посоветовать. Посоветовали следующую книгу:
Секреты разработки игр на macromedia Flash MX
---------------------------------------------
(Flash MX 2004 Game Design. Jobe Makar)
**Итого:** 250 руб. / 600 страниц / плохой дизайн / одна из лучших прочитанных мною книг
Сначала отпугивала фраза macromedia Flash MX в названии книги, но я ошибся. Основные мысли выделить не могу, т.к. книга построена скорее как учебник. Вся книга является одной сплошной мыслью. Автор рассказывает о различных игровых жанрах, объясняет, зачем нужна тригонометрия и как обсчитывается физика столкновений. Пробегает по методам оптимизации, показывает, как использовать «сетку» для упрощения физических расчетов, перечисляет виды AI и рассказывает об алгоритме поиска пути. Автор также описывает этапы проектирования игры, улучшения графики, принципы создания изометрических миров, наложения и роли звука в играх. В общем, книга расширяет сознание и заставляет смотреть на игры по-другому. В отличие от других авторов (например, Рафаэло Чекко), Джоб Макар практически не пишет код в книге. Иногда, конечно, пишет, но мало. Джоб объясняет, как и зачем, смотрит в суть, а как вы это реализуете в коде — выходит за рамки книги. Секреты разработки игр — это одна из тех книг, которые больше по алгоритмам и идеям, чем по коду.
Когда искал информацию о книге, наткнулся на такую статью <http://www.8bitrocket.com/tag/electrotank/>. Поэтому перед покупкой проверьте, перевели на русский следующие его шедевры или нет. Возможно, лучше купить их, т.к. сам автор пишет, что у него было мало времени для работы над книгой «Секреты разработки игр на macromedia Flash MX» и он не очень доволен её качеством.
Лекции Андрея Короткова
-----------------------
После прочтения шедевра выше, стал искать информацию по разработке игр и случайно наткнулся на русского парня по имени Андрей Коротков. У Андрея есть канал на YouTube, где он поэтапно читает курс лекций на тему, как писать игры и создавать игровые движки <http://www.youtube.com/user/megadrone86/videos>. Да, это не JavaScript, это C++. Но это не имеет значения, т.к. суть лекции — идеи и алгоритмы.
Основные мысли:
* Пишите диз. док.
* Продумывайте концепцию игры в целом
* Движок должен состоять из модулей
Но, как и у Джоба Макара, тут основные мысли размазаны. Лекции нужно воспринимать полностью, т.к. в каждой лекции рассказывают о конкретных проблемах и о том, как их надо решать.
Собственно, после ознакомления с этими двумя авторами я и стал писать свой игровой движок. Когда движок был доведен до какой-то стадии, когда уже был виден результат, всплыла неожиданная проблема. Все уровни, которые я пытался создать, были, мягко говоря, неиграбельными. Стал искать информацию об архитектуре уровней в интернете и наткнулся на ещё одного замечательного русского автора.
Дизайн уровней. Теория и практика
---------------------------------
Михаил Кадиков
Миша пишет серию статей, которые постепенно формируются в книгу. Все коротко, ясно и хорошо структурировано, каждая статья подкреплена кучей примеров. Познакомиться с книгой можно тут (<http://pro.level-design.ru/>). Читал взахлеб.
После предыдущих примеров резко возросло доверие и уважение к Flash-разработчикам. Стало очевидно, что они много знают, у них большой опыт и пора его перенять. Да, сейчас многие стонут то тут, то там в интернете, что Flash умирает, Flash — отстой и т.д., но! Сообщество Flash-разработчиков имеет очень большой опыт казуальных игр. Нельзя этим пренебрегать. С этими мыслями я купил следующую книгу о Flash.
Flash реклама
-------------
(Flash Advertising: Flash Platform Development of Microsites, Advergames and Branded Applications. Jason Fincanon)
Основная мысль — хм… не уловил.
**Итого:** 800 руб. / 300 страниц / отличный дизайн / вода, но красиво
Довольно странная книга. Вроде и написано много, но остаточных знаний мало. Все, в принципе, довольно банально. Очередная подборка советов о том, как делать сайты правильно и красиво. Возможно, кому-то будет интересно, но мне не было. Большая часть книги легко перекрывается опытом работы в каком-либо рекламном агентстве, которое штампует одноразовые сайты и продвигает их. В защиту автора могу разве что привести раздел «Рекламные игры и приложения». Автор рассказывает, как с помощью игры вдалбливать в мозг игроков бренд какой-либо компании. Так что, если вам будет необходимо убедить Иван Иваныча из ООО «Рога и копыта» купить разработку мини игры для сайта, прочтите этот раздел книги.
Графика на JavaScript
---------------------
(Supercharged JavaScript Graphics: with HTML5 canvas, jQuery, and More. Raffaele Cecco)
В первой главе описано разворачивание циклов и приведены графики скорости работы до и после в различных браузерах. Далее автор объясняет, как работать с CSS спрайтами (пишет функцию, которая постепенно меняет background-size). Рассказывает о погрешности таймеров. Ну а дальше начинается работа с плиткой и вода на тему написания игры. Если работу с плиткой в принципе можно осилить, т.к. вроде все верно, то пример игры (расписанный на полкниги) — это ужас. После книги Джоба Макара и лекций Андрей Короткова прямо таки хочется кричать: «Стой Рафаэль! Не делай так! Это немасштабируемо! Рафик, мамой клянусь, ты не прав!»
**Итого:** 800 руб. / 250 страниц / средний дизайн / вода
Это очередная книга из серии «должен прочитать» для веб-разработчиков. Стандартное животное на обложке, стандартное повествование. Но на фоне предыдущих авторов после прочтения книги хочется сказать: «И чё?! Рафаэлло, где алгоритмы?» С одной стороны, книга пробегает по новому API HTML5, с другой стороны, по нему пробегают все дешевые копирайтные книги. Беда с остаточными знаниями и выводами. Автор приводит полотна кода, которые не нужны, но раздувают толщину книги, обильно заливая все пастой на тему «есть такая библиотека». В защиту же автора можно привести главу «Использование векторов в играх и компьютерных моделях». Почему-то никто не удосуживается разобрать её в стиле «для чайников». Но опять же — где проекции векторов?
Собрание сочинений о флэше
--------------------------
Это интернет ресурс, в отличие от предыдущих книг об игрострое, наконец, покрыл тему обсчета столкновений (коллизий). Вот тут <http://noregret.org/tutor/n/collision/> авторы (Raigan Burns, Mare Sheppard) написали то, чего не осилил Raffaele Cecco в своей книге. Суть: сторона многоугольника — это вектор. Делаете проекцию этого и другого вектора на плоскости координат. Если проекции пересеклись — у нас есть столкновение. Если векторы под углом — делаете их проекции на нормали друг на друга.
HTML5
-----
(HTML5 for Masterminds. J.D. Gauchat)
**Итого:**710 руб. / 500 страниц / плохой дизайн / покупать не советую
Это очень толстый справочник API HTML5. Как справочник — так себе, просто подборка воды и копирайта. Толщина книги тут явно не соответствует качеству. Найдите что-нибудь потоньше.
Ajax для профессионалов
-----------------------
(Professional Ajax. Nicholas C. Zakas, Jeremy McPeak, Joe Fawcett)
**Итого:**1000 руб. / 500 страниц / плохой дизайн / отличная книга
Книга — огонь! Возможно, её читали не все, но её определенно стоит прочесть. Авторы постепенно знакомят с асинхронной работой и трюками в старых браузерах. Я не могу выделить ключевые мысли, т.к. книгу нужно воспринимать целиком. Один из примеров, о котором говорятся в книге, это принцип работы подсказок при вводе в строку поиска.
Проектирование веб-интерфейсов
------------------------------
(Designing Web Interfaces. Bill Scott, Theresa Neil)
Основные мысли:
* Предлагайте редактирование объекта около него самого
* Добавьте возможность перетаскивания
* Предотвратите переход между страницами
* Добавьте анимационных эффектов. Это сделает интерфейс более живым
* Увеличьте скорость отклика интерфейса
**Итого:** 950 руб. / 350 страниц / средний дизайн / среднее качество, мало информации
Много воды, постоянное вдалбливание одних и тех же мыслей. Хотя, с другой стороны, это сейчас мысли кажутся очевидными, а на момент написания книги они таковыми не являлись. Книга может показаться устаревшей, т.к. сейчас вроде web 2.0 и все советы, описанные в книге, и так применяются на практике. Но не соглашусь. Каждый день в интернете я вижу огромное количество сайтов, которые этим советам не следуют.
* Раздел «Не уходя со страницы», как бы подкрепляет книга «Ошибки веб-дизайна» (Matthew Linderman, Jason Fried). Только в этой книге описана практическая реализация: оверлеи, инлеи, виртуальные страницы.
* Раздел «Легким касанием» обоснован в книге «Универсальные принципы дизайна» (W. Lidwell, K. Holden and J. Butler)
Вообще по тексту очень много переплетений с книгами «Ошибки веб-дизайна» и «Универсальные принципы дизайна»
Как уже писал выше, веб-разработчик должен знать много и в разных областях. Вот ещё две области, которые помогут сделать сайт для людей, а не для программистов: типографика и связи с общественностью.
Дизайн книги: от слов к делу
----------------------------
Иннокентий Келейников
О чем книга:
* Сетка. Модульная сетка.
* Оформление текста и разбор шрифтов
Основные мысли:
* Все, что размещено по сетке, выглядит лучше
* Фон и шрифт должны контрастировать
* Строка не более 70 символов, текст разбит на абзацы, шрифт крупный
* Избегайте частого использования выделений
* Если делаете колонки, следите чтобы строки в разных колонках совпадали по высоте
* Делите текст на основной, вспомогательный и т.д.
* Текст должен быть такой, чтобы по нему можно было быстро пробежаться взглядом и уловить суть
**Итого:** 800 руб. / 300 страниц / отличный дизайн / отличная книга
Купил практически сразу, т.к. при пролистывании попался следующий текст:
**Отбивка пробелами:**
Не отбиваются пробелом:
* точки и запятые от предшествующего текста;
* многоточие, как знак паузы, от предшествующего или следующего за ним слова
* короткое тире между цифрами, обозначающее пределы какой-либо величины, например: 20-30 человек;
* дефис между словами и при переносе
* кавычки от заключенных в них слов
* ...
Мне показалось это идеальным. Все коротко, четко, понятно и по пунктам. После прочтения книги остался доволен результатом. Много переплетений с «Ководством» Тёмы Лебедева. Ещё одним толчком к покупке данной книги стала предыдущая работа в рекламном агентстве. Там постоянно пинали за косяки в тексте на сайтах, за « вместо ", за +79112223344 вместо +7 (911) 222-33-44, за N вместо №, за — вместо -.
После прочтения этой книги чувство и понимание типографики стало лучше.
Ководство
---------
Артемий Лебедев
**Итого:** 2300 руб. / 450 страниц / отличный дизайн / отличная книга
Честно говоря, не купил, а читал в интернете. Воды в тексте нет. Оно того стоит, т.к. там мысли, выводы и авторский взгляд. Все эти вещи не стареют. Даже если сама персона Лебедева вас раздражает, это ничего не значит. Вот пример статьи про фото <http://www.artlebedev.ru/kovodstvo/sections/169/>, вполне логичный вывод. Каждый раз, когда мне попадается дизайн на Bootstrap, мозг выдает <http://www.artlebedev.ru/kovodstvo/sections/147/> т.к. сайты на Bootstrap, как правило, примитивны.
Теория и практика связей с общественностью. Учебник для вузов
-------------------------------------------------------------
Кочеткова А.В., Филиппов В.Н., Скворцов Я.Л., Тарасов А.С.
**Итого:** 300 руб. / 350 страниц / средний дизайн / отличная книга
Одна из тех книг, прочитав которую, можно понять суть профессии PR. Наверное, многие сейчас скажут: «Что за ересь для гуманитариев ты советуешь?!» На самом деле книга четко излагает суть профессии PR и тесно связана с книгой «Читаемый код или Программирование как искусство» (Dustin Boswell, Trevor Foucher). В последней был совет: «лучший код тот, которого нет». Как раз этот учебник помогает понять, что очень часто вашим клиентам сайт вообще не нужен. А значит, нет смысла его делать. Более того, вы начинаете обращать внимание на способы выхода программного продукта на рынок и осознаете, что у него все очень плохо с PR продвижением, а значит он не пойдет и денег за него вы не получите, а значит и писать его нет смысла.
Что ещё нужно для полного счастья:
----------------------------------
* Статьи на Хабре
* Смотреть лекции Яндекса (<http://tech.yandex.ru/education/>)
* Смотреть доклады на конференциях (<http://web-standards.ru/>)
* Смотреть за отдельными товарищами (<http://pepelsbey.net/>)
Лекции Яндекса помогают взглянуть на многие вещи по-другому. Но опять же, все зависит от докладчиков. В любом случае, почерпнул для себя много нового. Самое значимое для меня видео на данный момент — Миши Давыдова о паттерне медиатора (<http://tech.yandex.ru/events/yasubbotnik/chlb-feb-2012/talks/154/>). Также радуют выступления Вадима Макеева, самое любое на данный момент, пожалуй, о CSS фреймворках (<http://pepelsbey.net/2008/04/css-frameworks/>).
Почему я не привожу в пример западные аналоги видео-лекций, которые до этого постились на хабре:
* Я не знаю английский, поэтому не понимаю, о чем в них речь.
* Многие из них рассчитаны на начальный уровень, а это уже не интересно.
* Все самое лучшее, как правило, тут же переводят на русский.
**Цифра или бумага.**
Все книги по возможности покупаю в бумажном виде. В электронном почему-то не могу читать. Да и когда они стоят на полке и постоянно попадаются на глаза, их можно просто взять и пролистать. А ещё когда приходят знакомые разработчики, можно достать книгу с полки и дать им в руки со словами: «Вот эта збсь!»
**Почему книги надо перечитывать:**
Объем информации довольно большой. Все принципы и советы постепенно забываются. Время от времени нужно освежать воспоминания простым пролистыванием уже прочитанных книг. Прочитать и использовать по умолчанию — разные вещи. Многие читали про русские кавычки «, но часто продолжают использовать стандартные ". Многие читали про модульность, но продолжают писать «лапшу» и т.д.
P.S.: Жду вброса книги Алана Купера «Об интерфейсе» от UI специалистов. Ещё не читал её, поэтому описания нет. А также вброса знаменитого в узких кругах Огилви «О рекламе» на тему затронутую в книге «Flash реклама» | https://habr.com/ru/post/206436/ | null | ru | null |
# Правильное округление десятичных чисел в двоичном коде
Одна из серьезных проблем работы с десятичными числами, представленными в двоичном коде, является проблема округления двоичного числа до значения представимого десятичного числа, ближайшего к правильно округленному десятичному числу. Ниже мы обсуждаем эту проблему и даем простой алгоритм правильного округления. Работа алгоритма проиллюстрирована тестовой программой на C++.
Напомним, что представимым десятичным числом является число, значение которого может быть точно представлено двоичным кодом. Так, число 0.125 точно равно двоичному числу 0.001. Можно также утверждать, что значение любого двоичного числа *y* равно некоторому представимому десятичному числу *x*. Например, значение двоичного числа *y*=1.001101\*2^-3 равно значению десятичного представимого числа *x*= 0.150390625.
Будем говорить, что двоичное число y эквивалентно десятичному числу *x*. И наоборот, десятичное число *x* эквивалентно двоичному числу *y*.
Давайте посмотрим, что происходит с десятичным числом, когда оно вводится с консоли, или, когда оно встречается в программе в качестве константы.
Любое десятичное число компилятором преобразуется (конвертируется) в заданный программистом формат. Поскольку быстрее всего в компьютере обрабатываются двоичные числа, то входное десятичное число преобразуется, чаще всего, либо в формат с фиксированной точкой (в том числе в int), либо в один из форматов с плавающей точкой — single, double, или в другой двоичный формат.
Согласно стандарту IEEE754, вещественные числа во внутреннем формате машины представляются в нормализованном двоичном виде. Так, двоичное положительное вещественное число *y* можно представить как *y**=b0.b1...bp\*2^e (b0≠0).*
Это же число можно представить как *0.b0b1...bp\*2^(e+1) (b0≠0)*, если *e+1>0* и *0.b0b1...bp\*2^e (b0≠0)*, если *e<0*.
Далее мы будем придерживаться второго представления, т.к. в нашей, приведенной ниже, тестовой программе на C++ есть функция q=frexp (x, &e), позволяющая в двоичном числе, представленном в виде *b0.b1...bp\*2^e*, определить значение экспоненты *e*.
Итак, десятичный эквивалент любого двоичного нормализованного числа *y =0.b0b1...bp\*2^e (b0≠0)* равен некоторому нормализованному десятичному числу *x=0.d0d1...dN...dn\*10^E (d0≠0).*
Например, число *y=0.1001101\*2^-2* эквивалентно представимому десятичному числу *x=0.150390625*.
Чтобы из *x* получить число *Xr*, равное числу, округленному до *N* значащих цифр, надо *X* умножить на коэффициент *10^k*, где *k=N-E*. Это нужно для того, чтобы полученное число содержало целую часть с *N* значащими цифрами, которое затем можно было округлить до ближайшего целого. Округленное целое число затем надо привести к прежнему масштабу, умножив его на *10^-k*. Математически это можно записать следующей формулой:
*X=[x\*10^k+0.5]\*10^-k=[y\*10^k+0.5]\*10^-k,* где []-целая часть числа.
Можно показать, что целое двоичное число *B*, содержащее *m* двоичных цифр, равно значению десятичного числа *D*, которое содержит *n=⌊m\*log2⌋* десятичных разрядов, при условии, что *B < 10^n. И равно n=n+1*, при условии, что *B ≥ 10^n*. В расчетах можно принять *log2≈0.301*.
Определим значение *k* на основе информации, имеющейся в двоичном представлении числа *y*. В формуле для *k* точность округления *N* известна, поэтому надо определить экспоненту *E*.
Экспоненту *E* определим из соотношения: *E=⌊e\*0.301⌋*.
Осталось учесть следующее обстоятельство. Если *x\*10^k= X >10^N*, то его нужно умножить на *10^(-1)* и скорректировать коэффициент *k*. Получим *X=X\*10^(-1), k=k-1*.
Округленное число будет равно *Xr=X\*10^(-k)*.
В результате мы получаем следующий простой алгоритм правильного десятичного округления двоичных вещественных чисел. Алгоритм пригоден для любого формата двоичных чисел с произвольно заданной точностью десятичного округления *N*.
На входе:
-Точность десятичного округления *N*;
— двоичное число в формате *y= 0.b0b1...bp\*2^e (b0≠0)*.
На выходе: Округленное десятичное число *X=0.d0d1...dN\*10^E*.
— 1. Определить экспоненту e двоичного числа y;
2. E=⌊e\*0.3⌋;
3. k=N-E;
4. X=x\*10^k;
5. Если X<10^N, то п.8;
6. X=X\*10^-1;
7. k=k-1;
8. Xr=[X+0.5]\*10^(-k);
End.
— В приведенном алгоритме число *Xr* представляет собой представимое десятичное число ближайшее к числу, которое является правильным округлением числа *x*, которое в свою очередь является десятичным эквивалентом числа *y*.
Поскольку мы привыкли работать с десятичными числами, то, как правило, входной поток представляет собой именно десятичные числа. На выходе мы хотим получить тоже десятичные числа. Например, как в Excel. Но, после конвертации десятичных чисел в двоичный код, они, как правило, необратимо трансформируются. В результате этого, округления, преобразованных в двоичный код чисел, могут не совпадать с правильным округлением чисел, напечатанных на консоле. Это касается, прежде всего, случаев, когда мы пытаемся округлить десятичное число до максимально возможного количества значащих цифр. Для single, это 7, а для double — 15.
Это хорошо можно исследовать на тестовой программе ниже, которую автор написал на C++.
В тестовой программе, по запросу, на консоль вводится:
-точность *N* десятичного округления числа *X*, которое является ближайшим представимым числом двоичного эквивалента числа *x*;
— число *x* в произвольной форме.
Под введенным произвольным десятичным числом *x* печатается число *X*, которое является ближайшим к *x* представимым числом (см. скриншот ниже).
Округление выполняется над числом *X*, т.к. точное значение числа *x* утеряно при двоичной конвертации.
Возвращается:
— десятичное число в формате *Xr =M\*10^(N+e),* где *M* — целое десятичное число с *N* значащими цифрами;
— число *xr*, которое равно представимому числу, ближайшему к нормализованному двоичному эквиваленту числа *X*.
На скриншоте:
N=15 — количество десятичных значащих цифр, до которого округляется входное десятичное число.
x=7.123456789098765321 e-89 — десятичное число, которое мы хотели бы округлить до 15 значащих цифр.
X=7.12345678909876559 e-089 — представимое десятичное число, значение которого равно двоичному числу, которое получено в результате конвертации числа x в формат p=53.
Xr= x=712345678909877e-103 — число с целочисленной мантиссой, полученное в результате округления числа X.
xr= x=7.12345678909877e-089 — число, полученное в результате нормализации двоичного эквивалента десятичного числа Xr. Оно является ближайшим к Xr.
Ниже приводится код тестовой программы правильного округления десятичных чисел, представляемых в двоичном коде, на C++.
```
#include
#include
#include
#include
using namespace std;
int main()
{
double q,x,xr,X;
unsigned long long int Xr;
int N,p,E,e,k;
cout <<"Input a binary precision p=";
cin>>p;
cout <<"Input a decimal precision N=";
cin>>N;
cout <
```
В программе используется довольно дорогая функция pow(10,k). Но, поскольку количество значений *k* невелико, вполне можно задействовать таблицу, заранее вычисленных значений *10^k*, или лучше *5^k*. | https://habr.com/ru/post/471506/ | null | ru | null |
# boop! Необычные эффекты по ховеру или введение в React-Spring
Анимация при наведении – прекрасный способ сделать приложение динамичным и отзывчивым. Это мелочь, но именно такие детали в итоге могут сделать продукт классным.
Хотя порой простого изменения состояния по щелчку мыши бывает недостаточно.
Вот пример того, что я имею ввиду.
Может быть, всё дело в асимметрии, но что-то в этой анимации мне не нравится 😬
А что, если иконки в состоянии наведения будут поворачиваться только на какое-то время?
Этот эффект мне нравится! Он динамический и неожиданный. Поскольку он гораздо сложнее обычного `transition`, делается он особым образом.
Его можно применять довольно изощрённо, например...
По результатам неофициального опроса в [Twitter poll](https://twitter.com/JoshWComeau/status/1324079542852558848) было решено назвать этот эффект «boop». В этом уроке для intermediate-пользователей React мы разберём, как его реализовать✨
> В этом уроке мы пойдем по весьма извилистому пути. Мы рассмотрим различные паттерны архитектуры React и научимся комбинировать хуки с компонентами для максимального переиспользования. Надеюсь, вам понравится!
>
> Если не терпится взглянуть на код, это можно сделать [здесь](https://www.joshwcomeau.com/snippets/react-hooks/use-boop/).
>
>
Первый прорыв
-------------
Самое чудное в компонентно-ориентированных фреймворках, как React — возможность упаковывать поведение практически так же, как элементы пользовательского интерфейса. Кроме элементов <`Button`> и <`Table`> можно создавать элементы <`FadeIn`> и <`SoundEffect`>.
Взять наш пример. Эффект – кратковременная активация и ее отмена – может быть отделён от любого конкретного элемента пользовательского интерфейса, так что его можно применять с чем угодно.
Первый взгляд на React-компонент:
```
const Boop = ({ rotation = 0, timing = 150, children }) => {
const [isBooped, setIsBooped] = React.useState(false);
const style = {
display: 'inline-block',
backfaceVisibility: 'hidden',
transform: isBooped
? `rotate(${rotation}deg)`
: `rotate(0deg)`,
transition: `transform ${timing}ms`,
};
React.useEffect(() => {
if (!isBooped) {
return;
}
const timeoutId = window.setTimeout(() => {
setIsBooped(false);
}, timing);
return () => {
window.clearTimeout(timeoutId);
};
}, [isBooped, timing]);
const trigger = () => {
setIsBooped(true);
};
return (
{children}
);
};
```
Тут много кода, так что давайте разбираться.
Главная идея в том, что при наведении на элемент он переходит в другое состояние, как при использовании обычного hover-транзишна. Кроме этого, запускается таймер, и по истечении времени, состояние переключается обратно в «исходное» независимо от того, продолжаем мы наводить курсор на элемент или нет.
Получается что-то вроде тех машин, которые сами себя отключают:
Мы следим за состоянием boop с помощью стейта `isBooped`.
```
const [isBooped, setIsBooped] = React.useState(false);
```
Мы обертываем то, на что наложим boop, т.е. children, в span. Это нужно, чтобы применить стиль вращения и обработать события мыши, активирующие эффект.
```
const trigger = () => {
setIsBooped(true);
};
return (
```
> ***Небольшое отступление***
>
> *Обычно лучшей практикой считается ставить обработчики событий на интерактивные элементы — кнопки или поля ввода.*
>
> *Пользователи, работающие на клавиатуре, не смогут установить фокус на div или span.*
>
> *Но сейчас особый случай. На самом деле я не хочу, чтобы этот эффект активировался при наведении фокуса. Он чисто декоративный и мне кажется, что при навигации с клавиатуры он будет только раздражать пользователей, состояние выделения для которых и так уже совершенно очевидно.*
>
>
Используем хук эффекта, который будет срабатывать при каждом изменении `isBooped`. Событие наведения приводит к переключению этого значения, которое приводит к срабатыванию хука эффекта. Эффект задает задержку, по истечении которой `isBooped` вновь переключается на значение false.
```
React.useEffect(() => {
// We only want to act when we're going from
// not-booped to booped.
if (!isBooped) {
return;
}
const timeoutId = window.setTimeout(() => {
setIsBooped(false);
}, timing);
// Just in case our component happens to
// unmount while we're booped, cancel
// the timeout to avoid a memory leak.
return () => {
window.clearTimeout(timeoutId);
};
// Trigger this effect whenever `isBooped`
// changes. We also listen for `timing` changes,
// in case the length of the boop delay is
// variable.
}, [isBooped, timing]);
```
Как насчёт самого эффекта? Пока что это только вращение. Когда **isBooped** истинно, мы применяем **transform: rotate** к оборачивающему элементу.
В разных ситуациях могут быть нужны разные эффекты, поэтому изменять угол вращения и длительность транзишна будем через пропсы. Кроме того, нам необходимо настроить **display** на **inline-block,** потому что элементы **inline** не трансформируемые. Также добавляем **backface-visibility: hidden**, чтобы воспользоваться преимуществами аппаратного ускорения\*.
> **\*** Технически, эта возможность влияет на то, как наш элемент будет выглядеть, повернувшись к пользователю «спиной». Нам это неважно, зато эта возможность имеет побочный эффект: заставляет рендерить на GPU, что делает анимацию более «гладкой».
>
>
```
const style = {
display: 'inline-block',
backfaceVisibility: 'hidden',
transform: isBooped
? `rotate(${rotation}deg)`
: `rotate(0deg)`,
transition: `transform ${timing}ms`,
};
```
Новый компонент `Boop` используем следующим образом:
```
```
Выглядит он так...
Неплохо, неплохо. Но мы способны на большее.
Пружины спешат на помощь!
-------------------------
Движение этой начальной версии кажется механическим и неестественным. В ней нет ни плавности, ни естественности движений, которые мы ждем от современной анимации.
В статье [«Знакомство со Spring Physics»](https://www.joshwcomeau.com/animation/a-friendly-introduction-to-spring-physics/) рассказано, как придать глубину и реалистичность своим анимациям.
← Советую посмотреть, там представлены две такие забавные пружинистые демки
Моя любимая библиотека spring-physics анимации — это [ReactSpring](https://www.react-spring.io/). Она предоставляет современное API, основанную на хуках, и непревзойденную производительность.
Давайте подправим наш код, чтобы использовать её вместо переходов CSS транзишнов:
```
import { animated, useSpring } from 'react-spring';
const Boop = ({ rotation = 0, timing = 150, children }) => {
const [isBooped, setIsBooped] = React.useState(false);
const style = useSpring({
display: 'inline-block',
backfaceVisibility: 'hidden',
transform: isBooped
? `rotate(${rotation}deg)`
: `rotate(0deg)`,
});
React.useEffect(() => {
// Unchanged
}, [isBooped, timing]);
const trigger = () => {
// Unchanged
};
return (
{children}
);
};
```
Прежде мы создавали объект `style` и передавали напрямую в наш span. Теперь же мы передаем этот объект стиля (без `transition`) в `useSpring`.
Хук `useSpring` можно сравнить с конвейерным станком, который начиняет пирожное клубничным джемом.
Иначе говоря, он берет немного обычного CSS и начиняет его ✨пружинной магией ✨. Вместо использования кривых Bézier из CSS, он будет использовать математику пружины. Вот почему мы опускаем свойства `transition`: мы делегируем эту задачу ReactSpring.
Ввиду того, что springphysics пока не сильно распространен в интернете и не является стандартом, мы не можем передать этот начиненный магией стиль объекта на **<**`span`**>**. Поэтому мы запускаем **<**`animated.span`**>**, который идентичен прежнему и дополнительно знает, как обращаться с созданным “пружинным” объектом стиля.
Вот результат.
Кажется, немного вяло. Давайте немного изменим конфиг спринга:
```
const style = useSpring({
display: 'inline-block',
backfaceVisibility: 'hidden',
transform: isBooped
? `rotate(${rotation}deg)`
: `rotate(0deg)`,
config: {
tension: 300,
friction: 10,
},
});
```
Взводя натяжение и снижая сопротивление, мы значительно смягчаем реакцию наших значков на наведение курсора.
Вот это уже что-то!
> **Почему именно задержка?**
>
> Некоторые писали, что вместо использования setTimeout можно использовать колбэк onRest с APIReactSpring. Казалось бы, гораздо логичнее «отбипнуть», опираясь на саму анимацию, а не на какую-то произвольную величину времени.
> На самом деле в этом случае я хочу использовать именно задержку. Причин две:
>
> **1.** Одно из классных преимуществ spring physics — то, как она грациозно обрабатывает прерывания. Я хочу прервать ее, чтобы отдернуть в исходное положение прежде, чем она вернется в состояние полного покоя.
>
> **2.** Основная проблема с onRest в том, что он ждет, пока анимация полностью не остановится. Обычно это происходит гораздо позже воспринимаемой остановки, поскольку часто на кончике анимации бывает множество субпиксельных колебаний. Их, конечно, можно скорректировать через свойства конфигурации precision, но порой эти субпиксельные колебания придают приятный утонченный эффект.
>
> Было бы здорово, если бы у ReactSpring был еще такой API, который позволил бы задавать процент выполнения так, чтобы я мог сказать: «Активируй этот возврат, когда анимация будет выполнена на 50%». Но на самом деле решение с задержкой, к которому я прибегнул, нисколько не хуже 😄
>
>
Итак, пока что мы ограничили воздействие нашего boop на вращение, но это далеко не предел.
Давайте доработаем его так, чтобы менять размеры с помощью scale и смещать положение с помощью translate.
Добавим в transform эти свойства:
```
const Boop = ({
x = 0,
y = 0,
rotation = 0,
scale = 1,
timing = 150,
children,
}) => {
const [isBooped, setIsBooped] = React.useState(false);
const style = useSpring({
display: 'inline-block',
backfaceVisibility: 'hidden',
transform: isBooped
? `translate(${x}px, ${y}px)
rotate(${rotation}deg)
scale(${scale})`
: `translate(0px, 0px)
rotate(0deg)
scale(1)`,
config: {
tension: 300,
friction: 10,
},
});
// The rest is unchanged…
};
```
Выставляем все значения по умолчанию для обычного состояния (например, 0pxtranslate, 1xscale). Это позволяет нам указывать в пропсах только те значения, которые мы собираемся менять: если мы не передадим значение для вращения, вращения не будет.
Этот результат меня вполне устраивает, однако у этого решения есть одна серьезная проблемка. Вообще-то, нам придется полностью изменить подход!
Разделенный boop
----------------
В одном проекте, над которым я сейчас работаю, есть виджеты, которые могут разворачиваться для полного отображения контента.
Я подумал, было бы здорово, если бы стрелка подскакивала при наведении на нее курсора.
Это интересная и непростая задача, потому что здесь присутствует разделение – я хочу, чтобы бип оказывал воздействие только на стрелку, но при этом хочу, чтобы она реагировала на наведение на любую часть элемента. Если я проведу курсор над словом «Show», стрелка должна дернуться.
Наш текущий подход такой возможности не дает от слова «совсем». Анимация привязана к тому же элементу, что и обработчик событий.
Немного поэкспериментировав, я пришел к выводу, что правильным API для этого эффекта будут не компоненты, а хуки.
#### С потребительской точки зрения
Давайте посмотрим на всё с точки зрения пользователя.
Я позже решу, как это внедрить; прежде всего необходимо придумать самый простой и легкий интерфейс. Вот, что у меня получилось:
```
import { animated } from 'react-spring';
function SomeComponent() {
const [style, trigger] = useBoop({ y: 10 });
return (
Show more
);
}
```
Нам необходима возможность передачи нашему хуку объекта, представляющего конфигурацию, который должен предоставить две вещи:
* Объект стиля, применяемый animated-элементам, например `animated.span`или `animated.button`;
* Функцию запуска, для вызова ее всякий раз, как нам понадобится boop.
Если очень захочется, то мы можем применить и то и другое к одному элементу, но делать так необязательно.
Этот хук дает невероятную гибкость: его можно вызывать когда угодно и не только при наведении. К примеру, мы можем учесть пользователей мобильных телефонов, настроив действие эффекта по тапу или задать интервал срабатывания, чтобы выделить важную часть пользовательского интерфейса! \*
> **\*** Вот как это реализуется:
>
>
```
// hooks/use-boop.js
import React from 'react';
import { useSpring } from 'react-spring';
function useBoop({
x = 0,
y = 0,
rotation = 0,
scale = 1,
timing = 150,
springConfig = {
tension: 300,
friction: 10,
},
}) {
const [isBooped, setIsBooped] = React.useState(false);
const style = useSpring({
display: 'inline-block',
backfaceVisibility: 'hidden',
transform: isBooped
? `translate(${x}px, ${y}px)
rotate(${rotation}deg)
scale(${scale})`
: `translate(0px, 0px)
rotate(0deg)
scale(1)`,
config: springConfig,
});
React.useEffect(() => {
// All the same stuff...
}, [isBooped]);
const trigger = React.useCallback(() => {
setIsBooped(true);
}, []);
return [style, trigger];
}
Much of this logic
```
Большая часть логики просто копируется; мы полностью повторяем действия при создании этого style-объекта. Но вместо применения его на элементе, мы просто возвращаем его из хука.
Вот еще пара фишек:
* Конфигурация спринга теперь предоставляется как параметр, поскольку различные ситуации могут иметь разную физику.
* Функция пуска оборачивается в `React.useCallback`. Это нужно, чтобы ссылка на функцию не менялась на каждый рендер, чтобы не допустить перерендера компонентов, обернутых в `memo`. Ведь мы не знаем, как будет использоваться функция запуска.
Возврат к компоненту
--------------------
Этот хук чудесен, но мне, правда, очень понравился тот компонентный API, о котором мы говорили до этого. Можем ли мы воспользоваться компонентом в тех случаях, когда не требуется разделение между обработчиком событий и анимацией?
Что действительно круто в паттернах, так это то, что мы легко можем обернуть хук в компонент, чтобы сделать свою пироженку и съесть ее:
```
// components/Boop.jsx
import React from 'react';
import { animated } from 'react-spring';
import useBoop from '@hooks/use-boop';
const Boop = ({ children, ...boopConfig }) => {
const [style, trigger] = useBoop(boopConfig);
return (
{children}
);
};
```
Наш Boop-компонент стал намного меньше, потому что мы делегировали всю тяжелую работу хуку `useBoop.Теперь` у нас есть доступ к двум превосходным API, которые действуют на основе одной логики. DRY AF.
#### Встает на место?
В зависимости от вида анимации, иногда вы сможете заметить, что при завершении она как будто «встает на место».
Это легкое смещение на один-два пикселя. Оно особенно распространено при анимации элемента, содержащего текст:
Вы можете узнать больше, почему это происходит, и как это поправить: «[Интерактивное руководство по CSS-переходам](https://www.joshwcomeau.com/animation/css-transitions/)».
#### Сохраняйте доступность
Комбинация «компонент/хук», что мы создали, очаровательна, но очарование – вещь субъективная. Не все хотят видеть скачущий UI, особенно люди с расстройствами вестибулярного аппарата.
Я как-то уже писал, как [создавать удобные анимации](https://www.joshwcomeau.com/react/prefers-reduced-motion/) в React. Давайте применим эти знания и здесь:
```
// hooks/use-boop.js
import React from 'react';
import { useSpring } from 'react-spring';
function useBoop({
rotation = 0,
timing = 150,
springConfig = {
tension: 300,
friction: 10,
},
}) {
const prefersReducedMotion = usePrefersReducedMotion();
const [isBooped, setIsBooped] = React.useState(false);
const style = useSpring({
// All the same stuff
});
React.useEffect(() => {
// All the same stuff here as well...
}, [isBooped]);
const trigger = React.useCallback(() => {
// Yep yep
}, []);
let applicableStyle = prefersReducedMotion ? {} : style;
return [applicableStyle, trigger];
}
```
Хук [prefers-reduced-motion](https://www.joshwcomeau.com/snippets/react-hooks/use-prefers-reduced-motion/) сообщит нам, если пользователь захочет удалить движение. Когда это значение true, мы возвращаем «пустой» объект стиля. Учитывая, что объект стиля всегда пустой, мы будем уверены, что элемент не сдвинется.
Весь ваш для новых открытий
---------------------------
Прежде всего – спасибо, что дочитали до этого места! Это было непростое путешествие😄
Держите итоговую версию, чтобы скопировать и вставить в свой репозиторий:
код
```
import React from 'react';
import { useSpring } from 'react-spring';
// UPDATE this path to your copy of the hook!
// Source here: https://joshwcomeau.com/snippets/react-hooks/use-prefers-reduced-motion
import usePrefersReducedMotion from '@hooks/use-prefers-reduced-motion.hook';
function useBoop({
x = 0,
y = 0,
rotation = 0,
scale = 1,
timing = 150,
springConfig = {
tension: 300,
friction: 10,
},
}) {
const prefersReducedMotion = usePrefersReducedMotion();
const [isBooped, setIsBooped] = React.useState(false);
const style = useSpring({
transform: isBooped
? `translate(${x}px, ${y}px)
rotate(${rotation}deg)
scale(${scale})`
: `translate(0px, 0px)
rotate(0deg)
scale(1)`,
config: springConfig,
});
React.useEffect(() => {
if (!isBooped) {
return;
}
const timeoutId = window.setTimeout(() => {
setIsBooped(false);
}, timing);
return () => {
window.clearTimeout(timeoutId);
};
}, [isBooped]);
const trigger = React.useCallback(() => {
setIsBooped(true);
}, []);
let appliedStyle = prefersReducedMotion ? {} : style;
return [appliedStyle, trigger];
}
export default useBoop;
Link t
```
#### Бонус: анимация звезды
Среди демок, показанных в начале, была звездообразная анимация.
Этот эффект действительно выполнен с использованием хука `useBoop`, который мы создали, но в нем также задействована тригонометрия, рассмотрение которой не укладывается в рамки данного туториала.
Сейчас я нахожусь в процессе написания поста о том, как использовать тригонометрию для создания эффектов, подобных этому.
Пока же поделюсь кодом, максимально расписав контекст в комментариях! Надеюсь, это поможет.🌟
анимация звезды
```
import React from 'react';
import styled from 'styled-components';
import { animated, useSpring } from 'react-spring';
import { Star } from 'react-feather';
import useBoop from '@hooks/use-boop.hook';
import UnstyledButton from '@components/UnstyledButton';
import Spacer from '@components/Spacer';
const useAngledBoop = (index) => {
// Our star has 5 points across a 360-degree area.
// Our first point should shoot out at 0 degrees,
// our second at 72 degrees (1/5th of 360),
// our third at 144 degrees, and so on.
let angle = index * (360 / 5);
// By default in JS, 0-degrees is the 3-o'clock
// position, but I want my animation to start at
// the 12-o'clock position, so I'll subtract
// 90 degrees
angle -= 90;
// Trigonometry methods in JS use radians, not
// degrees, so we need to convert.
const angleInRads = (angle * Math.PI) / 180;
// If this was meant to be reusable, this would
// be configurable, but it's not, so it's
// hardcoded. The # of pixels from the center
// that our circle will bounce.
const distance = 42;
// Convert polar coordinages (angle, distance)
// to cartesian ones (x, y), since JS uses
// a cartesian coordinate system:
const x = distance * Math.cos(angleInRads);
const y = distance * Math.sin(angleInRads);
// `normalize` is commonly called "lerp",
// as well as Linear Interpolation. It
// maps a value from one scale to another.
// In this case, I want the time to vary
// between 450ms and 600ms, with the first
// point being the slowest, and the last
// one being the fastest.
//
// It's defined below
let timing = normalize(index, 0, 4, 450, 600);
// `normalize` produces linear interpolation,
// but I want there to be a *bit* of an ease;
// I want it to appear to be slowing down,
// as we get further into the circles.
timing *= 1 + index * 0.22;
const friction = normalize(index, 0, 4, 15, 40);
const boop = useBoop({
x,
y,
timing,
scale: 1.4,
springConfig: { tension: 180, friction },
});
return boop;
};
const CircleDemo = () => {
const [c1s, c1t] = useAngledBoop(0);
const [c2s, c2t] = useAngledBoop(1);
const [c3s, c3t] = useAngledBoop(2);
const [c4s, c4t] = useAngledBoop(3);
const [c5s, c5t] = useAngledBoop(4);
const [starStyles, starTrigger] = useBoop({
scale: 1.1,
rotation: 10,
timing: 150,
springConfig: {
tension: 300,
friction: 6,
},
});
return (
{
// If I had more than 5 points, I might
// write a `callAll()` helper function.
// But I don't, so this is fine.
c1t();
c2t();
c3t();
c4t();
c5t();
starTrigger();
}}
>
);
};
// This helper function is used in the component
const normalize = (
number,
currentScaleMin,
currentScaleMax,
newScaleMin = 0,
newScaleMax = 1
) => {
// FIrst, normalize the value between 0 and 1.
const standardNormalization =
(number - currentScaleMin) / (currentScaleMax - currentScaleMin);
// Next, transpose that value to our desired scale.
return (
(newScaleMax - newScaleMin) * standardNormalization + newScaleMin
);
};
// My project uses styled-components.
// Nothing here is styled-components-specific,
// however. It's just the tool I was already
// using.
const Wrapper = styled.div`
position: relative;
width: min-content;
`;
const Button = styled(UnstyledButton)`
position: relative;
z-index: 3;
padding: 8px;
border-radius: 50%;
`;
const IconWrapper = styled(animated.span)`
display: block;
svg {
display: block;
stroke: var(--color-text) !important;
fill: var(--color-background) !important;
}
`;
const Circle = styled(animated.div)`
position: absolute;
z-index: 1;
top: 0;
left: 0;
right: 0;
bottom: 0;
width: 8px;
height: 8px;
margin: auto;
border-radius: 50%;
background: hsl(50deg, 100%, 48%);
`;
export default CircleDemo;
Lin
``` | https://habr.com/ru/post/670234/ | null | ru | null |
# Тестирование в React Native
Эта статья – большущий гайд по технологиям, которые мы в СДЭК используем для проверки наших внутренних приложений, написанных на React Native. Часть из этих подходов вполне можно применить не только в мобильной разработке, но и за её пределами. Дальше буду описывать все в контексте веб-разработки. Если вас это еще не испугало – приглашаю окунуться в головокружительный мир автотестирования мобильных приложений.
Еще делая первые шаги в разработке, я всегда искал пути, как максимально быстро проверить то, что написал. 5 лет назад, чтобы собрать Hello World для андроида, требовалось несколько минут, которые в течение дня могли складываться в час. Это меня абсолютно не устраивало. В тот момент я открыл для себя тесты и понял, что для тестирования бизнес-логики собирать реальное приложение совсем не обязательно. А после втянулся в интеграционное и e2e тестирование, где удалось перепробовать множество разных техник, о которых я вам и расскажу.
В этой статье вы узнаете:
* какие существуют подходы при проектировании приложений, чтобы тестировать их было легко,
* какие инструменты используем мы,
* а главное – как мы пишем и проектируем тесты.
Но для начала немного теории.
#### Терминология
Существует распространенное заблуждение, что тесты – это лишняя трата времени, проще протыкать руками. Но написав тест единожды, вы получите:
1. Сценарий, по которому необходимо работать с вашей логикой.
2. Документацию, которая всегда актуальна в отличие от Confluence.
3. Уверенность в завтрашнем дне, ведь сломанный тест не позволит вашему CI задеплоить что-то на прод.
В интернете ходит красивая теоретическая картинка, показывающая, к какому относительному количеству тестов на проекте стоит стремиться. Она сама достойна отдельного обсуждения, но здесь мы ее рассмотрим просто, чтобы зафиксировать терминологию в рамках этой статьи и разбить тесты на определенные группы:
Вверху пирамиды end-to-end тесты, проходящие через всё приложение, как будто это делает реальный пользователь на реальном окружении. Например, весь процесс авторизации с реальным бэкендом.
В середине – интеграционные тесты, проверяющие работу нескольких частей приложения в связке. Например, весь процесс авторизации, но с мокнутым бэкендом.
В основании пирамиды – хорошо знакомые всем unit-тесты, тестирующие атомарные части приложения. Например, отдельные функции бизнес-логики.
Считается, что unit-тестов должно быть больше всего – их легче всего запускать и они работают быстро. Для них не нужно поднимать реальное окружение как для e2e, не нужно связывать компоненты как для интеграционных. Мы просто проверили, что при входе А получаем выход Б.
На первый взгляд, звучит разумно: чем тесты быстрее, тем чаще они будут запускаться. А чем чаще тесты запускаются, тем выше шанс, что они найдут нам проблему. К тому же быстрые тесты можно запускать и без CI. Звучит красиво и утопично, особенно в случаях, когда тестируемая система – сплошной пласт бизнес-логики. Например, бэкенд.
В случае мобильных приложений, чаще всего мы говорим про слой отображения - View. Даже в приложениях, где логики чуть больше чем 0, именно верстки и взаимодействия между компонентами все равно будет сильно больше. Нам важно знать, как ведут себя нативные библиотеки от разных разработчиков в связке друг с другом, как это все выглядит на UI и работает ли даже на слабых телефонах. Обязательно со скриншотами, видео и замерами перфоманса.
Unit-тесты здесь не помогут, поэтому в нашем случае именно интеграционные тесты стоят в основании пирамиды, а Unit-ами мы проверяем «математику», которой не так много. Но все же начать я предлагаю с unit-тестов, поскольку остальное базируются именно на их концепции.
#### Что вообще тестировать?
Ответ очевиден и приходит на ум сразу, когда вы пытаетесь вкатиться в тесты чуть серьезнее: бизнес-логику, которую пишите.
Предположим, у нас есть сетевой запрос, который должен повторяться до победного, но максимум 3 раза. Напишем реализацию в лоб:
```
async function fetchUsers() {
for (let retryCount = 0; retryCount < 3; retryCount++) {
console.log('try request =', retryCount)
try {
const result = await fetch('https://github.com/users')
return result
} catch (e) {
console.warn('error')
}
}
}
```
Что в данной функции является бизнес логикой? Сетевой запрос? Количество повторов? Объективно говоря – всё. Нам нужно проверить как то, что функция действительно вернет результат, если запрос завершится успешно, так и то, что в случае ошибки запрос будет повторен максимум 3 раза.
Такой код тестировать сложно, потому что он полон сайд эффектов и является решением "сделай все и сразу". С точки зрения разработчика, очень удобно вызвать всего одну функцию и решить проблему, но с точки зрения тестирования – все совсем наоборот.
Давайте также в лоб напишем тест, который просто делает запрос и проверяет, что он завершился успешно:
```
test(`should be success`, async () => {
const resultPromise = fetchUsers()
expect(resultPromise).resolves.toBeCalled()
})
```
Если такой тест запустить несколько раз, результат его выполнения будет меняться с success на fail без видимых причин. Например, когда нет интернета. Такие тесты называют `flaky`, потому что его результат нестабилен.
Предположим, что мы хотим сделать тест стабильнее, но не хотим ничего переписывать. Здесь на помощь нам приходят "моки".
#### Моки
Под моком обычно понимают нечто, что нарушая все законы, лезет внутрь кода и меняет реализации внутри системы, которые вызываются неявно.
В нашем случае, мы неявно обращаемся к функции `fetch`, определенной где-то в глобальном скоупе. Для того, чтобы ее замокать, существует множество разных библиотек, но мы обратимся к дефолтному [jest](https://jestjs.io/).
```
test(`should be success`, async () => {
global.fetch = jest.fn().mockImplementation(() => Promise.resolve())
const resultPromise = fetchUsers()
expect(resultPromise).resolves.toBeCalled()
})
```
Теперь результат выполнения `fetchUsers` всегда один и тот же. Поздравляю, вы только что сделали свой первый шаг к тестированию, пусть и пошли по кривой дорожке работы с моками.
#### Почему кривой? Разве моки – это плохо?
Когда вы вводите в тестирование моки, это означает, что вы начинаете знать о внутреннем устройстве функции и методах, которые оно вызывает внутри. Это плохо, потому что протекает абстракция и тесты становятся хрупкими.
> Вместо того, чтобы тестировать функцию как черный ящик, вы начинаете знать о внутренностях ее реализации, что делает тест хрупким
>
>
Если однажды вместо `fetch` внутри нашей функции кто-то начнет использовать `XMLHttpRequest`, то тест упадет, хотя по факту, функция продолжит работать корректно. Это ведет к тому, что после каждого изменения функции нужно будет менять еще и тест. Есть ощущение, что проще сразу написать так, чтобы не пришлось переписывать.
В этом нам помогут фейки. В простом понимании, это те же моки, но прокинутые явно. В этой статье я намеренно разделил эти два понятия, чтобы показать принцип. В разработке под одним могут подразумевать другое и наоборот.
Единственное жизнеспособное применение моков – подмена реализаций, которые вы не способны контролировать. Например, текущее время и дату на устройстве, какую-то библиотеку для работы с пушами и т.д. (здесь стоит отметить, что даже с такими вещами можно обойтись без моков – достаточно закрыть чужие реализации интерфейсом).
#### Как мы можем избавиться от моков?
Устраняя неявные зависимости.
В нашем случае, мы можем передать неявную зависимость на `fetch` в аргументы функции. Давайте сделаем это:
```
async function fetchWithRetry(request: () => Promise): Promise {
for (let retryCount = 0; retryCount < 3; retryCount++) {
console.log('try request =', retryCount)
try {
const result = await request()
return result
} catch (e) {
console.warn('error')
}
}
}
```
Теперь наша функция может работать не только с юзерами, но и с любым другим запросом. Тестировать эту функцию стало проще:
```
test(`should return value when success`, async () => {
const result = await fetchWithRetry(() => Promise.resolve([]))
expect(result).toBe([])
})
```
Мы избавились от моков и просто прокидываем нужную реализацию через аргументы функции, подменяя её, когда это необходимо.
#### А что дальше?
Мы проверили кейс, при котором функция возвращает результат при успешном запросе. Теперь давайте убедимся, что функция действительно выполнится максимум 3 раза, а не 100:
```
test('should retry 3 times if failed', async () => {
const alwaysReject = jest.fn(() => Promise.reject())
const resultPromise = await fetchWithRetry(alwaysReject)
expect(alwaysReject).toBeCalledTimes(3)
})
```
На этом моменте большая часть разработчиков успокоится и посчитает, что функция успешно проверена. На самом деле, все тесты, которые мы написали – прошли, а чаще всего это означает, что мы что-то упустили.
> До тех пор, пока написанный вами тест не упадёт – считайте, что вы ничего не протестировали, так как все потенциальные баги от вас ускользнули
>
>
Цель тестирования – найти ошибки в вашем функционале. Если ошибки вы не нашли, то польза от такой работы эфемерна.
тогда давайте проверим всёЧтобы протестировать все кейсы, нужно найти все возможные выходы функции при всех возможных входах. Можно пользоваться простым правилом: **ищем пограничные случаи; все, что внутри этих случаев и все, что снаружи**. Делать это достаточно утомительно, не говоря о том, что велик шанс упустить один из сценариев. Благо весь наш мир состоит из примитивов, вложенных друг в друга, а значит – все это дело можно успешно генерировать. С этим нам поможет…
#### Property based testing
Задача такого тестирования: обеспечить полноту всех возможных сценариев.
Давайте слегка изменим нашу функцию, избавив её от ещё одной неявной зависимости в виде количества повторений:
```
async function fetchWithRetry(request: () => Promise, maxRetries = 3): Promise {
for (let retryCount = 0; retryCount < maxRetries; retryCount++) {
console.log('try request =', retryCount)
try {
const result = await request()
return result
} catch (e) {
console.warn('error')
}
}
}
```
Теперь мы можем контролировать: сколько раз наша функция должна пытаться повторить вызов. Давайте напишем такой тест, который сам будет генерировать нам числа и на основе них строить тест. В этом нам поможет [fast-check](https://github.com/dubzzz/fast-check):
```
import * as fc from 'fast-check'
test(`should retry any integer values passed to it`, async () => {
fc.assert( // убедимся что
fc.asyncProperty(
fc.integer(), // для любого целого числа
async (number) => {
const alwaysReject = jest.fn(() => Promise.reject()) // когда запрос с ошибкой
const resultPromise = await fetchWithRetry(alwaysReject, number)
expect(alwaysReject).toBeCalledTimes(number) // функция будет вызвана такое же количество раз, какое было передано в параметре
}
),
)
})
```
После запуска можем увидеть следующий лог:
```
UnhandledPromiseRejectionWarning: Error: Property failed after 2 tests
{ seed: -1329951604, path: "1:1:0:0:0", endOnFailure: true }
Counterexample: [-1]
Shrunk 4 time(s)
Got error: Error: expect(jest.fn()).toBeCalledTimes(expected)
Expected number of calls: -1
Received number of calls: 0
```
Видим, что тест упал, когда в него передали отрицательное число. То есть функция не то чтобы не сделала ретрай – она даже не попыталась сделать запрос, когда в нее передали аргументы, которые не ожидал разработчик. Баг это или фича – решать, конечно же, вам, но этот тест показал, что такая ситуация возможна.
Окей, мы написали юнит-тест руками, сгенерировали тестовые данные и даже кое-что нашли! Наш тест и сама функция стали чуть больше и сложнее как для восприятия, так и для проверки.
#### Сложные тесты = большие проблемы
Генерировать тестовые данные это, конечно, хорошо, особенно для простых случаев типа нашего. Но в более сложных системах генерация данных может сыграть злую шутку, когда вам придется реализовывать алгоритмы для их проверки.
Чем меньше в тесте непроверенных алгоритмов, тем лучше. Чем он тупее и прямее, тем проще его воспринимать и меньше шанс ошибиться при написании. Если возникла ситуация, в которой наш тест становится сложным и вы подозреваете, что он может работать неверно, то для этого есть решение…
ПИСАТЬ ТЕСТЫ НА ТЕСТЫ
Шучу, конечно. По крайней мере, не руками. Для проверки тестов на целостность придумали…
#### Мутационное тестирование
Оно заходит в код вашего приложения, мутирует его (меняя, например, плюсы на минусы) и запускает ваш тест еще раз. Если с искаженной логикой программы ваш тест прошел, значит, что тест написан неверно. То есть по сути, мы все-таки пишем тесты на тесты, но не руками, а автоматически их генерируем.
К примеру, [у этого проекта](https://github.com/stryker-mutator/robobar-example) много тестов и 100% покрытие кода:
однако запустив мутантов в наш код, обнаружим, что половина тестов false-positive и продолжают работать даже тогда, когда код поломан:
> Проверяя тесты мутационным тестированием, вы можете легко убедиться, что у 100% покрытия кода тестами с качеством общего не больше, чем у луна-парка с луной.
>
>
Следует понимать, что все это не бесплатно и внедряя мутационное тестирование, вы платите скоростью запуска тестов и последующим анализом репортов. Но как говорится, всё есть яд и всё есть лекарство, важна лишь дозировка. Так что мутационное тестирование, действительно, может вам помочь в проверке целостности тестов.
#### Интеграционные тесты c Detox
Detox – это святой Грааль всех автоматизаторов, связанных с react-native, поскольку он берет на себя всю работу по взаимодействию с девайсами.
В целом, некорректно предъявлять претензии к инструменту, позиционирующему себя как gray-box для e2e тестов. Он отлично работает в сценариях, когда необходимо сделать что-то, что теоретически может сделать пользователь:
* нажать кнопку;
* ввести текст;
* открыть пуш;
* cделать другие взаимодействия с экраном.
Но например, когда вы пытаетесь просто подменить данные, как мы ранее это делали в jest, начинаются приседания невиданных масштабов.
Мы в СДЭК используем Detox в повседневной разработке, и я даже рассказывал об этом [на CodeFest](https://www.youtube.com/watch?v=l-jbi3giwcM&t=1s), наверное, поэтому я так его люблю и ненавижу.
Detox предлагает вам систему моков, основанную [на патчинге файлов](https://wix.github.io/Detox/docs/guide/mocking) через [Metro](https://facebook.github.io/metro/docs/getting-started/):
Мягко говоря, `rich developer experience` вы здесь не получите. Вдобавок выше мы обсудили, чем плохи моки и почему их следует заменять фейками.
Detox предлагает вам полностью заменять один файл другим в процессе сборки. Этот подход абсолютно не масштабируем, а также хрупок, поскольку оригинальный файл попросту будет игнорироваться. Малейшие изменения могут поломать как тесты, так и само приложение при неправильных импортах.
Фактически, процесс разработки/ тестирования с помощью Detox выглядит так:
1. Вы мокаете файл, где лежит ваш `endpoint.url` на `localhost:1234`
2. Поднимаете локальный сервер на этом порте
3. Описываете в тесте, на какие вызовы эндпоинтов что должно возвращаться
4. Проверяете, что ожидаемый результат = фактическому
Я [поднимал вопрос](https://github.com/wix/Detox/issues/2650) к авторам, предлагая им API, который доступен в Android с Espresso, но пока у разработчиков нет представления, как этого достичь. Если оно есть у вас – не стесняйтесь оставлять комментарии под этим Issue или открыть новое. Возможно, именно ваше решение в итоге упростит жизнь сотням других разработчиков. Но вернемся к нашему тесту.
Тест получается громоздкий, его достаточно просто писать, но сложно читать и поддерживать. К сожалению, это понимание приходит спустя 50 написанных тестов, когда старые начали падать, так как изменились требования и поменялась логика. Становится очевидно, что надо смотреть в сторону упрощения, а достичь этого можно придерживаясь более декларативного описания.
#### BDD
Первым в голову, конечно же, приходит `cucumber`. Этот фреймворк предлагает описывать сценарии на языке `Gherkin`
```
Feature: Оцените статью
Scenario: Пользователю понравилась статья
When пользователь поставил лайк
Then автор понял, что не зря старается
Scenario: Пользователю не понравилась статья
When пользователь оставил комментарий, как дополнить статью
Then автор стал лучше и больше не допустит подобных ошибок
```
Мало того, что это еще один новый синтаксис, работа с cucumber практически не отличается, а порой сложнее, чем написать тест в лоб.
Единственный плюс: написание сценариев можно передать настоящим профессионалам QA, а разработчикам – лишь реализовать их. Если вы используете в своей компании cucumber, напишите в комментариях, как он помогает вам, какие проблемы решает, а какие привносит. В нашем случае он не подошел и мы начали искать дальше.
#### Design review
Хотя мы и говорим о фронтенде, в design review речь не о Figma и макетах, а о проектировании решения, его оценке и уже после – реализации в коде. Такой подход позволяет:
* посмотреть на проблему со всех углов и уловить непонятные моменты в ТЗ еще на самом раннем этапе. Нахождение ошибок в ТЗ перед реализацией существенно сокращает количество необходимого времени на выпуск фичи;
* не забивать себе голову кодом и тонкостями реализации, что позволяет учесть не только пограничные случаи, но и все остальные;
* создавать документацию, к которой может обратиться и проверить любой человек.
Вопрос – как описать документ так, чтобы он:
* был оцифрован – так вы сможете поделиться им с кем угодно и получить дополнительный фидбэк;
* легко читался – чтобы быстро понять, что происходит в логике даже спустя несколько лет;
* легко изменялся – чтобы проектирование не было обременением, а наоборот, инструментом, который хочется использовать ежедневно;
* при изменении не требовал делать лишних изменений в коде (для оптимизации труда разработчика).
Посмотрев по сторонам, можно заметить [xstate](https://github.com/statelyai/xstate) – одну из реализаций стейт-машин. Для неё существует интерфейс в виде [stately.ai](https://stately.ai), позволяющий визуализировать весь процесс в виде наглядной диаграммы:
Проектирование решения в таком варианте позволяет вам достичь всех целей, о которых мы говорили ранее. К тому же такую диаграмму можно дать QA и, в отличие от cucumber, им не придется учить специфичный синтаксис – все делается максимально интуитивно.
После проектирования вы можете экспортировать вашу стейт-машину в виде json-файла и сгенерировать тесты, обеспечив постоянную актуальность такой документации. Если хотите подробностей, то от авторов на YouTube есть [ролик, раскрывающий основные моменты](https://youtu.be/pA3DXExjKqI).
Вернемся в серую реальность, где все не так радужно, как на картинке.
#### XState не любит TypeScript
XState хоть и написан на TypeScript, но от типизации в привычном понимании там почти ничего нет. У вас будет доступ к названиям функций из библиотеки, возможно, какой-то примитивный автокомплит дефолтных пропсов, но не больше. К примеру, автокомплита у названий ваших состояний и экшенов не будет.
В том варианте, в котором она поставляется из коробки – решение точно не для ежедневной разработки. Но если его немного допилить, можно получить вполне рабочее решение с автокомплитом и полноценной поддержкой TypeScript:
Основная сложность состоит в том, чтобы типизировать json, который отдает [stately.ai](http://stately.ai) в вид, который будет понятен TypeScript-у. Мы это сделали и делимся с вами [ссылкой на github](https://github.com/cdek-it/xstate-json-types).
Теперь для описания тестовых сценариев вам нужно следующее:
1. [Реализовать сценарий на stately.ai](https://stately.ai/registry/editor/share/881c3f26-3481-4765-ab1b-161fd4d52b06) и экспортировать в виде `.json`:
2. Создать какой-нибудь `auth.machine.ts` и вставить туда полученный json. Обязательно пометить его как const, чтобы строки считались строковыми литералами
`export default { … } as const`
3. Передать в функцию `declareTestModel`, где вы тут же получите типизацию ваших `events` и `expectations`. Все, что вам останется – это просто заполнить их данными и запустить тест:
тестовые сценарии также надо передать в ваш раннер (например, через describeWithJest)Такой подход в виде описания сценариев сильно облегчает поддержку и читаемость тестов. Вместо огромного количества вложенных друг в друга последовательных цепочек действий вы получаете условную "карту", в которой необходимо разметить состояния вашего приложения в виде экспектов и действий, которые приводят к изменению этого состояния.
пример одного из сценариев в виде графаПоддержка таких тестов облегчается тем, что у вас есть наглядная диаграмма и при необходимости изменить связи между действиями и состояниями вам не придется что-то менять в реализации, поскольку все шаги вы уже описали.
К сожалению, [stately.ai](http://stately.ai) заточен в первую очередь под реализацию стейт-машин именно для бизнес-логики, а не тестов. Из-за чего приходится бороться с некоторыми трудностями:
* неконсистентной выдачей json файла, где структура файла хоть и незначительно, но порой меняется;
* отсутствием нормальной типизации, из-за чего приходится писать свои обертки;
* отсутствием поддержки property based testing.
Несмотря на все минусы – это отличный помощник, который помогает нашему отделу внутренних приложений на React Native в СДЭК проектировать и поставлять более качественные приложения.
#### Заключение
Надеюсь, тот опыт, которым я поделился, будет полезен. С полученными знаниями у вас не должно возникнуть трудностей при самостоятельном более подробном раскрытии каждой из заинтересовавших тем. В следующей статье планирую раскрыть тему "Тестирование через Detox" более подробно, с реальными примерами и способами оптимизации.
Тестируйте с удовольствием, а главное задавайте себе вопрос: для чего тесты нужны именно вам. | https://habr.com/ru/post/683026/ | null | ru | null |
# Прикручиваем ActiveRecord к сайту
##### Введение
В процессе создания более ли мене сложного сайта приходится задумываться об организации доступа к БД(базе данных). Если сайт создается на базе существующего фреймворка или CMS, то там как правило имеются встроенные механизмы ORM (с англ. — Объектно-реляционное отображение, подробнее [в вики](http://ru.wikipedia.org/wiki/ORM)). В данной статье я расскажу как можно прикрутить популярную и простую ORM систему ActiveRecord к собственному фреймворку.
##### Как работает ActiveRecord?
Компонент представляет из себя набор основных классов, необходимых для работы(Model,Config, ConnectionManager и др.), набор адаптеров для подключения к конкретной СУБД и точки входа, файла инициализации ActiveRecord.php который содержит функцию автозагрузки классов наших моделей проекта. Все классы определенны в пространстве имен ActiveRecord, наш проект скорее всего будет находится в другом пространстве или в глобальном, поэтому, чтобы при наследовании классов каждый раз не писать конструкции вроде extends \ActiveRecord\Model или использовать директиву use ActiveRecord, имеет смысл создать собственную обертку над ActiveRecord. Это также позволит расширить возможности нашей ORM не затрагивая компонент AR.
Итак, чтобы воспользоваться всеми методами AR, нам необходимо подключить файл инициализации ActiveRecord.php к проекту, создать для каждой таблицы в БД класс-модель и унаследовать его от \ActiveRecord\Model(например class Book extends \ActiveRecord\Model {} ), инициализировать подключение к БД с помощью конструкции:
```
$connections = array(
'development' => 'mysql://invalid',
'production' => 'mysql://test:test@127.0.0.1/test'
);
ActiveRecord\Config::initialize(function($cfg) use ($connections)
{
$cfg->set_model_directory('.');
$cfg->set_connections($connections);
});
```
После этого мы можем обращаться к нашим моделям и вызывать необходимые методы, например Book::first() — вернет первую строку из таблицы определенной в модели Book.
##### Создание обертки AR
В проекте возможно потребуется обращение к БД из разных файлов, да и конфигурация обычно храниться в отдельном файле, стандартных возможностей AR не всегда хватает и сама форма записи через пространство имен \ActiveRecord не очень красиво. Эта тема тянет на несколько статьей, поэтому здесь я постараюсь изложить суть вопроса.
В простом случае нам потребуется создать всего 2 класса, один мы наследуем от \ActiveRecord\Model и другой будет основным, в котором мы будем проводить инициализацию и конфигурацию AR. Создадим 2 файла-класса:
```
//Orm.php
class Orm
{
/**
* array $models_ Массив всех моделей проекта, если какая либо модель не будет определенна в этом массиве, ее нельзя будет подключить
* массив имеет следующие елементы [Имя модели]=>array('path'=>Путь к директории в которой храниться модель , 'namespace'=> Пространство имен в котором определен класс модели)
*/
public $models_ = array();
/**
* Проверка минимиальной версии PHP, подключение необходимых классов, регистрация автозагрузчика для моделей, инициализация конфигруации
*
* @param null $name
*/
function __construct($name = null)
{
if (!defined('PHP_VERSION_ID') || PHP_VERSION_ID < 50300)
die('PHP ActiveRecord requires PHP 5.3 or higher');
define('PHP_ACTIVERECORD_VERSION_ID', '1.0');
include_once 'lib/Singleton.php';
include_once 'lib/Config.php';
include_once 'lib/Utils.php';
include_once 'lib/DateTime.php';
include_once 'lib/Model.php';
include_once 'lib/Table.php';
include_once 'lib/ConnectionManager.php';
include_once 'lib/Connection.php';
include_once 'lib/SQLBuilder.php';
include_once 'lib/Reflections.php';
include_once 'lib/Inflector.php';
include_once 'lib/CallBack.php';
include_once 'lib/Exceptions.php';
spl_autoload_register(__NAMESPACE__ . '\ActiveRecord::activerecord_autoload');
Config::initialize(function ($cfg) {
$cfg->set_connections(array(
'development' => Configuration::$dbtype . "://"
. Configuration::$db_user . ":"
. Configuration::$db_password . "@"
. Configuration::$db_host . "/"
. Configuration::$db_name
));
/* Следует явно задать формат времени, он будет использоваться в других классах AR, по умолчанию действует "Y-m-d H:i:s T" что добавляет
часовой пояс к строке, такой формат времени не очень нравиться полями типа datetime в MySQL
*/
$cfg->set_date_format("Y-m-d H:i:s");
});
}
/**
Установка текущей директории с классами моделей, создание и возвращение объекта модели, если модель не найдена возвращается FALSE
*/
public function getModel($model)
{
$config = Config::instance();
if (array_key_exists($model, $this->models_)) {
$config->set_model_directory($this->models_[$model]['path']);
if( $this->models_[$model]['namespace'] )
$class = "\\" . $this->models_[$model]['namespace'] . "\\" . $model;
else
$class = $model;
return new $class;
} else {
return false;
}
}
/**
Автозагрузчик классов моделей, файл загружается из папки установленной в getModel()
$class_name Имя загружаемой модели, передается автоматически при использовании оператора NEW
в методе getModel()
*/
public static function activerecord_autoload($class_name)
{
$root = Config::instance()->get_model_directory();
$class_name = explode('\\', $class_name);
$class_name = end($class_name);
$file = $root . $class_name . ".php";
if (file_exists($file))
require $file;
}
}
//Model.php
class Model extends \ActiveRecord\Model
{
/* Имя таблицы в БД, данную переменную стоит переопределить в потомках,
если имя таблицы не совпадает с именем класса */
static $table_name = 'simple_name';
// Имя столбца с первичным ключем
static $primary_key = 'id';
// Имя соединения используемого при подключении
static $connection = 'production';
// Явное указание имени БД, при генерации SQL будет использоваться конструкция - db.table_name
static $db = 'test';
/*
* Можно определить собственные методы и свойства необходимые для работы всех моделей
*/
}
```
От класса Model мы будем наследовать все модели существующих таблиц. Также предположим, что вся конфигурация приложения хранится в отдельном файле Configuration.php:
```
class Configuration{
/*.....*/
/**
* $db_host Имя хоста на котором расположена БД
*/
static $db_host = 'localhost';
/**
* $db_user Имя пользователя БД
*/
static $db_user = 'root';
/**
* $db_password Пароль пользователя БД
*/
static $db_password = 'root';
/**
* $db_name Имя базы данных
*/
static $db_name = 'db_name';
/**
* $dbtype Тип подключения к БД
*/
static $dbtype = 'mysql';
/*.....*/
}
```
В конструкторе класса Orm(этот код взят из ActiveRecord.php) подключаем необходимые классы и регестрируем автозагрузчик, в самом конце инициализируем подключение к БД.
Особое внимание стоит уделить формату времени, если его оставить по дефолту, то во время операций записей данных в БД поля типа datetime будут генерировать ошибку, т.к. AR генерирует строки в формате 2000-02-03 16:23:27 MSK, т.е. указывает индекс часового пояса. Изменить конфиг не достаточно, не знаю почему, но разработчики AR используют в других классах формат даты и времени не из конфига, а явно указывают его в требуемых методах, поэтому придется внести еще измения в следующие файлы:
/lib/Column.php метод cast
```
return new DateTime($value->format('Y-m-d H:i:s T'))
```
на
```
return new DateTime($value->format(Config::instance()->get_date_format()))
```
Аналогично в файлах /lib/Connection.php методы datetime\_to\_string() string\_to\_datetime(), и /lib/Model.php метод assign\_attribute().
Теперь приведу пример как можно всем этим пользоваться. Сначала нам нужно создать переменную в которой мы будем хранить объект нашего класса Orm, эта переменная должна быть доступна в любом нужном нам месте любого скрипта, поэтому ее лучше объявлять как статическую главного Контроллера или глобальную. После создания объекта необходимо в массив \_models поместить массив всех моделей используемых в проекте, формат массива можно узнать в комментарии в коде. Вот возможный пример реализации всего сказанного:
```
php
class Controller{
public static $ORM;
function __construct(){
$this-loadOrm();
}
function loadOrm(){
include 'Orm.php'
self::$ORM = new Orm();
self::_models = array('Book'=>array('path'=>'models', 'namespace'=>__NAMESPACE__));
}
}
new Controller;
?>
//в другом файле мы выводим например всех авторов имеющихся книг в БД
php
$model = Controller::$ORM -getModel('Book');
$books = $model->all();
foreach($books as $book)
echo $book->author;
```
Конечно, данный способ требует еще доработки, например можно сделать статические методы у Orm класса, тогда при запуске проекта нам нужно будет инициализировать его, а дальше везде использовать конструкцию вроде Orm::getModel('Имя модели');
AR довольно мощный и гибкий инструмент, в нем поддерживаются кроме стандартных операций CRUD, также и связи между таблицами(включая сложные связи через — through), имеется SQLBuilder для построения SQL запросов, валидация, конвертация и др.
Официальная документация на английском и в ней освещены элементарные вопросы, есть также форум, на котором можно найти большинство ответов по работе с AR, но я так и не смог нагуглить более мене нормального источника с информацией о внедрении AR в собственный фреймворк или простой движек сайта.
По ходу своей работы мне пришелось в плотную сталкнуться с данной библиотекой, и если эта тема интересна, то я продолжу данный цикл статьей по ActiveRecord. | https://habr.com/ru/post/211913/ | null | ru | null |
# Node.js + face-recognition.js: простое и надёжное распознавание лиц с помощью глубокого обучения
*Перевод статьи [Node.js + face-recognition.js: Simple and Robust Face Recognition using Deep Learning](https://medium.com/@muehler.v/node-js-face-recognition-js-simple-and-robust-face-recognition-using-deep-learning-ea5ba8e852).*
В этой статье мы расскажем, как реализовать надёжную систему распознавания лиц с использованием [face-recognition.js](https://github.com/justadudewhohacks/face-recognition.js). Мы искали подходящую Node.js-библиотеку, которая умела бы аккуратно распознавать лица, но ничего не нашли. Пришлось писать самостоятельно!
В этом [npm-пакете](https://www.npmjs.com/package/face-recognition) используется библиотека [dlib](https://github.com/davisking/dlib), предоставляющая Node.js-биндинги для очень хорошо зарекомендовавших себя инструментов распознавания внутри этой библиотеки. Dlib использует методы глубокого обучения и поставляется с уже обученными моделями, которые продемонстрировали **точность распознавания** на уровне **99,38%** при [прогоне бенчмарка LFW](http://vis-www.cs.umass.edu/lfw/).
Зачем?
------
В последнее время мы пытаемся создать приложение для распознавания лиц на основе Node.js, которое выделяло бы и распознавало лица персонажей из сериала «Теория Большого взрыва». Сначала планировалось сделать приложение с использованием средств распознавания OpenCV, как описано в статье [Node.js + OpenCV for Face Recognition](https://medium.com/@muehler.v/node-js-opencv-for-face-recognition-37fa7cb860e8).
Однако, несмотря на высокую скорость, качество работы этих инструментов оказалось недостаточной. Точнее, они хорошо справлялись с лицами анфас, но стоило человеку немного отвернуться от камеры, и качество распознавания снижалось.
В поисках решения под руку попалась С++-библиотека dlib; мы повозились с Python API, впечатлились результатом и, наконец, решили: [будем использовать эту библиотеку вместе с Node.js](https://medium.com/@muehler.v/node-js-opencv-for-face-recognition-37fa7cb860e8)! Так на свет появился этот npm-пакет, предоставляющий упрощённый Node.js API для распознавания лиц.
И что такое face-recognition.js?
--------------------------------
Хотелось сделать пакет на основе face-recogntion.js, который:
* позволяет быстро начать распознавать лица благодаря простому API;
* при необходимости позволяет выполнять тонкие настройки;
* прост в установке (в идеале, чтобы достаточно было написать `npm install`).
Хотя пакет ещё не закончен, вы уже можете скачать некоторые инструменты.
#### Face Detection (определение лиц)
Для быстрого и не слишком надёжного определения лиц на изображении вы можете использовать нейросеть глубокого обучения или простой фронтальный распознаватель:
#### Face Recognizer (распознавание лиц)
Распознаватель — это нейросеть глубокого обучения, использующая для вычисления уникальных дескрипторов лиц упомянутые выше модели. Обучать распознаватель можно на массиве тэгированных изображений лиц, после чего он сможет помечать лица на входном изображении:
#### Face Landmarks (опорные точки)
С помощью этого пакета вы также можете определять от 5 до 68 опорных точек на лицах:
Отличная история, покажи теперь, как это работает!
--------------------------------------------------
Итак, решить задачу с помощью OpenCV не удалось. У нас осталась пачка лиц Шелдона, Раджеша, Леонард, Говарда и Стюарта размером 150 х 150 пикселей каждое. С помощью этих данных можно с лёгкостью научить Face Recognizer распознавать новые лица. Код этого примера лежит в репозитории.
Подготовка данных
-----------------
Мы собрали примерно по **20 лиц** каждого персонажа в разных ракурсах:
Возьмём по **10 лиц** для обучения, а остальные используем для оценки точности распознавания:
```
const path = require('path')
const fs = require('fs')
const fr = require('face-recognition')
const dataPath = path.resolve('./data/faces')
const classNames = ['sheldon', 'lennard', 'raj', 'howard', 'stuart']
const allFiles = fs.readdirSync(dataPath)
const imagesByClass = classNames.map(c =>
allFiles
.filter(f => f.includes(c))
.map(f => path.join(dataPath, f))
.map(fp => fr.loadImage(fp))
)
const numTrainingFaces = 10
const trainDataByClass = imagesByClass.map(imgs => imgs.slice(0, numTrainingFaces))
const testDataByClass = imagesByClass.map(imgs => imgs.slice(numTrainingFaces))
```
В каждом имени файла указано имя персонажа, так что мы с лёгкостью сопоставим наши имена классов:
`['sheldon', 'lennard', 'raj', 'howard', 'stuart']`
с массивами изображений по каждому классу. С помощью `fr.loadImage(fp)` вы можете считать изображение, указанное в пути к файлу.
Определение лиц
---------------
Изображения лиц размером 150 х 150 пикселей были заранее вырезаны с помощью opencv4nodejs. Но вы можете определить лица, вырезать, сохранить и маркировать их таким образом:
```
const image = fr.loadImage('image.png')
const detector = fr.FaceDetector()
const targetSize = 150
const faceImages = detector.detectFaces(image, targetSize)
faceImages.forEach((img, i) => fr.saveImage(img, `face_${i}.png`))
```
Обучение распознавателя
-----------------------
Теперь можно приступать к обучению:
```
const recognizer = fr.FaceRecognizer()
trainDataByClass.forEach((faces, label) => {
const name = classNames[label]
recognizer.addFaces(faces, name)
})
```
Этот код скармливает лица нейросети, которая выдаёт для каждого лица дескриптор и сохраняет его в соответствующем классе. Задав в качестве третьего аргумента `numJitters`, вы можете применять **вращение**, **масштабирование** и **зеркалирование**, создавая разные версии каждого из входных лиц. Увеличение количества модификаций может повысить точность распознавания, но при этом нейросеть учится дольше.
Также вы можете сохранять состояние распознавателя, чтобы не обучать его заново каждый раз, а просто загружать из файла:
Сохранение:
```
const modelState = recognizer.serialize()
fs.writeFileSync('model.json', JSON.stringify(modelState))
```
Загрузка:
```
const modelState = require('model.json')
recognizer.load(modelState)
```
Распознавание новых лиц
-----------------------
Теперь с помощью контрольных данных проверим точность распознавания и сохраним результаты в лог:
```
const errors = classNames.map(_ => [])
testDataByClass.forEach((faces, label) => {
const name = classNames[label]
console.log()
console.log('testing %s', name)
faces.forEach((face, i) => {
const prediction = recognizer.predictBest(face)
console.log('%s (%s)', prediction.className, prediction.distance)
// count number of wrong classifications
if (prediction.className !== name) {
errors[label] = errors[label] + 1
}
})
})
// print the result
const result = classNames.map((className, label) => {
const numTestFaces = testDataByClass[label].length
const numCorrect = numTestFaces - errors[label].length
const accuracy = parseInt((numCorrect / numTestFaces) * 10000) / 100
return `${className} ( ${accuracy}% ) : ${numCorrect} of ${numTestFaces} faces have been recognized correctly`
})
console.log('result:')
console.log(result)
```
Сейчас распознавание выполняется так: сначала у входного лица вычисляется евклидово расстояние дескрипторного вектора до каждого дескриптора класса, а затем вычисляется **среднее значение** всех расстояний. Вы можете возразить, что для этой задачи лучше подойдёт кластеризация методом **k-средних** или **SVM-классификатор**. Возможно, в будущем они тоже будут реализованы, но скорости и эффективности евклидова расстояния пока что вполне достаточно.
При вызове `predictBest` мы получим результат с наименьшим евклидовым расстоянием, то есть с наибольшей похожестью. Примерно так:
`{ className: 'sheldon', distance: 0.5 }`
Если вам нужно для конкретного лица получить расстояния дескрипторов всех классов, то можете просто использовать `recognizer.predict(image)`, который для каждого класса выдаст массивы расстояний:
```
[
{ className: 'sheldon', distance: 0.5 },
{ className: 'raj', distance: 0.8 },
{ className: 'howard', distance: 0.7 },
{ className: 'lennard', distance: 0.69 },
{ className: 'stuart', distance: 0.75 }
]
```
Результаты
----------
Если выполнить вышеприведённый код, то получим такие результаты.
Обучим на **10 лицах** каждого персонажа:
```
sheldon ( 90.9% ) : 10 of 11 faces have been recognized correctly
lennard ( 100% ) : 12 of 12 faces have been recognized correctly
raj ( 100% ) : 12 of 12 faces have been recognized correctly
howard ( 100% ) : 12 of 12 faces have been recognized correctly
stuart ( 100% ) : 3 of 3 faces have been recognized correctly
```
Обучим только на **5 лицах** каждого персонажа:
```
sheldon ( 100% ) : 16 of 16 faces have been recognized correctly
lennard ( 88.23% ) : 15 of 17 faces have been recognized correctly
raj ( 100% ) : 17 of 17 faces have been recognized correctly
howard ( 100% ) : 17 of 17 faces have been recognized correctly
stuart ( 87.5% ) : 7 of 8 faces have been recognized correctly
```
А вот как это выглядит на видео:
Заключение
----------
Судя по результатам, даже небольшая выборка обучающих данных позволяет получить довольно точное распознавание. И это несмотря на то, что некоторые из входных изображений очень размыты из-за маленького размера. | https://habr.com/ru/post/351586/ | null | ru | null |
# Пишем 2d-игру на Java
Доброго времени суток всем!
В этой статье будет описываться создание 2D игры на Java. Сразу предупреждаю, вы должны хотя бы базово знать язык Java, поскольку на подробное объяснение каждой строки у меня нету времени. И очень прошу вас, не списывать просто код, а пытаться понять что означает каждая строка, и писать со смыслом. И еще, я использую Eclipse, но вы можете использовать любой IDE.
### Задача:
Я планирую создать игру, напоминающую шутер с видом от 3 лица.
### Начало:
Ну что, приступим!
Для начала создадим проект. Назовем его «Just game». И сразу создаем класс Display.java. В него пишем:
```
public static void main(String[] args) {
JFrame frame = new JFrame(/* название нашей игры */);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
frame.setUndecorated(true);
frame.setVisible(true);
}
```
Теперь разберемся, что мы сделали.
```
JFrame frame = new JFrame(/*название нашей игры*/);
```
мы создаем рамку, которая и будет отображаться при запуске нашей игры
```
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
```
устанавливаем операцию, которая будет происходить при нажатии на крестик. EXIT\_ON\_CLOSE — выйти из программы
```
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
frame.setUndecorated(true);
```
устанавливаем нашей рамке максимальные размеры, убираем декорации(кнопки свернуть, закрыть, уменьшить/увеличить и т.п.), т.е. делаем игру на весь экран. Если вы хотите, чтобы игра не была бы на весь экран, то используйте:
```
frame.setSize(/*ширина*/,/*высота*/);
frame.setResizable(false); //false чтобы нельзя было бы поменять размеры рамки, true -можно
```
```
frame.setVisble(true);
```
— делаем рамку видимой
Только не забудьте, все настройки рамки надо писать до того, как вы сделаете её видимой
Ну чтож, теперь нажимаем «Run» и пробуем запустить нашу игру. Если все написано правильно, у вас не должны возникать ошибки и должно появиться пустое, серое окно.
Серое окно… Как скучно… Давайте создадим что-нибудь поинтереснее.
Создадим новый класс, под названием «Main». Main класс у нас будет являться панелью, которую мы вставим в рамку, по этому он должен расширять JPanel. (Для тех, кто не знает, расширять пишется как extends после названия класса)
Возвращаемся в класс Display и после настроек рамки, но перед установлением её видимости, пишем:
```
frame.add(new Main());
```
Вы спросите — «Ну и зачем мы это сделали?». Представьте себе картину. Эта картина и является конечная наша игра. А теперь представьте рамку. Без ничего внутри, просто пустую рамку. На ней ничего нельзя нарисовать, она бесполезна. Для этого, мы вставили в картину пустой лист, на котором программа в дальнейшем может рисовать картину. На этом закончим наше лирическое отступление и вернемся к классу Main.
Нам нужно осуществить отрисовку, по этому мы должны добавить метод paint. Для этого пишем:
```
public void paint(Graphics g) {
//отрисовка всех объектов
}
```
Ну и для начала, можем написать внутри этого метода отрисовку линии. Для этого пишем:
```
g.drawLine(20, 20, 100, 100);
```
Теперь запускаем программу, и видим:
Даааааа, не густо…
Давайте отрисуем какую-нибудь картинку. Например эту:
Для начала, нам нужно указать путь к картинке. Для этого не в методе paint, пишем:
```
Image img = new ImageIcon("2.png").getImage();
```
(предварительно надо в наш проект скинуть картинку и назвать ее 2.png)
После этого удаляем строчку отрисовки линии, а вместо нее в метод paint пишем:
```
g.drawImage(img, 0, 0, null);
```
Разберемся поближе с методом drawImage, так как мы будем часто его затрагивать.
drawImage(картинка которую мы будем рисовать, которую мы объявили раннее, координата X с которой будет рисоваться картинка, координата Y с которой будет рисоваться картинка, paint);
Отдельно хочу поговорить о параметре paint. Лучше всего оставляйте его null. Я только однажды сталкивался, когда мне нужно было использовать paint. Это было когда я отрисовывал текст, и задавал ему размер шрифта. Но советую не лезть туда и использовать null.
Теперь запускаем программу, и видим:
Чего-то она маленькая, не правда ли? Давайте научимся увеличивать её размеры. Добавляем к drawImage() параметры так, чтобы вышло:
```
g.drawImage(img, 0, 0, 1920, 1080, null);
```
Что мы сейчас добавили? Эти два параметра растягивают картинку, до координат 1920 и 1080. Получается, что картинка на весь экран. Давайте запустим программу и это проверим.
Получается:
Ну наконец-то. Теперь мы умеем любые картинки растягивать на весь экран. Но вот проблема. Метод paint вызывается только один раз. И как же его обновлять постоянно? Для этого существует очень полезная вещь — таймер. Давайте создадим его.
Для этого пишем:
```
Timer timer = new Timer(20, this);
```
(20 это частота с которой обновляется таймер, this- где выполнять метод при обновлении таймера
Это мы должны вписать сразу после строки определения класса, т.е. после:
```
public class Main extends JPanel{
```
Также, надо дополнить строку определения класса таким образом:
```
public class Main extends JPanel implements ActionListener{
```
После прописывания этой строки, у вас название класса должно подчеркнуться красным. Чтобы это исправить, в самом конце класса добавьте метод:
```
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
}
```
Этот метод будет выполняться при обновлении таймера. В него мы должны написать repaint(); чтобы при каждом обновлении таймера у нас все элементы бы стирались, и нарисовывались заново.
Дальше, мы должны запустить таймер. Для этого, создаем конструктор класса Main и в него пишем:
```
timer.start();
```
После этого, можете не запускать программу, ведь в ней ничего не изменится. Давайте заменим текстуру домика на нормальную текстуру карты. Её вы можете нарисовать сами, либо скопировать у меня пробную:
Размер картинки может быть любой, все равно её размер будет подгоняться прямо в программе. Ах да, разрешения компьютеров могут быть разные, так что добавим-ка в конструктор такие вещи:
```
public Main(JFrame frame) {
timer.start();
this.frame = frame;
}
```
И перед конструктором добавим:
```
JFrame frame;
```
И сходим еще в класс Display.java и там немного изменяем метод frame.add:
```
frame.add(new Main(frame));
```
Таким образом, наша рамка будет передаваться в класс Main.java. Переходим в этот класс, и там где у нас метод paint() меняем строку drawImage() на:
```
g.drawImage(img, 0, 0,frame.getWidth(), frame.getHeight(), null);
```
Таким образом, теперь наша игра будет отрисовывать картинку на весь экран, в независимости от его разрешения. Запускаем:
На сегодня все. Оставляю код, для тех, кто запутался:
### Display.java
```
import javax.swing.JFrame;
public class Display {
public static void main(String[] args) {
JFrame frame = new JFrame("JustGame");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
frame.setUndecorated(true);
frame.add(new Main(frame));
frame.setVisible(true);
}
}
```
### Main.java
```
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
public class Main extends JPanel implements ActionListener{
Image img = new ImageIcon("2.png").getImage();
Timer timer = new Timer(20, this);
JFrame frame;
public Main(JFrame frame) {
this.frame = frame;
}
public void paint(Graphics g) {
g.drawImage(img, 0, 0,frame.getWidth(), frame.getHeight(), null);
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
repaint();
}
}
```
Спасибо за внимание!
Продолжение [habrahabr.ru/post/326302](https://habrahabr.ru/post/326302/) | https://habr.com/ru/post/326032/ | null | ru | null |
# Инкапсуляция для настоящих самураев, или нюансы, связанные с ключевым словом internal в C#
Пролог: internal is new public
------------------------------
Каждый из нас мечтал о проекте, где всё будет сделано правильно. Это кажется вполне естественным. Как только ты узнаёшь о самой возможности писать хороший код, как только слышишь легенды о том самом коде, который можно легко читать и изменять, сразу загораешься тем самым «ну вот теперь я точно всё сделаю правильно, я ведь теперь умный и Макконнела читал».
Случился такой проект и в моей жизни. Очередной. Причём делаю я его под добровольным надзором, где за каждой моей строчкой следят. Соответственно, уже не только хотелось, но и надо было делать всё правильно. Одним из «правильно» было «чти инкапсуляцию и закрывайся по максимуму, потому что открыться всегда успеешь, а закрыться обратно потом будет поздно». И поэтому я везде, где только мог, стал использовать для классов модификатор доступа internal вместо public. И, естественно, когда ты начинаешь активно использовать новую для тебя фичу языка, возникают некоторые нюансы. О них по порядку и хочу рассказать.
**Оскорбительно базовая справка**Исключительно для того, чтобы напомнить и обозначить.
* Сборка — минимальная единица развёртывания в .NET и одна из основных единиц компиляции. Как правильно, это или .dll, или .exe. Говорят, её можно поделить на несколько файлов, которые называются модулями.
* public — модификатор доступа, который обозначает, что им помеченное доступно вообще всем.
* internal — модификатор доступа, который обозначает, что им помеченное доступно только внутри сборки.
* protected — модификатор доступа, который обозначает, что им помеченное доступно только наследникам класса, в котором расположено помеченное.
* private — модификатор доступа, который обозначает, что им помеченное доступно только тому классу, в котором оно находится. И никому больше.
Юнит-тесты и дружественные сборки
---------------------------------
В C++ была такая странноватая фича, как friendly classes. Классы можно было назначить друзьями, и тогда граница инкапсуляции между ними стиралась. Подозреваю, что это не самая странная фича в C++. Возможно, даже в десятку самых странных не входит. Но выстрелить себе в ногу, связав несколько классов намертво, как-то слишком уж легко, а подходящий случай под эту фичу придумать очень тяжело.
Тем удивительнее было узнать, что в .NET существуют дружественные сборки, этакое переосмысление. То есть, вы можете сделать так, чтобы одна сборка видела то, что спрятано за internal-замком в другой сборке. Я когда узнал об этом, был несколько удивлён. Ну, как бы, зачем? В чём смысл? Кто будет намертво связывать две сборки, занявшись их разделением? Случаи, когда в любой непонятной ситуации лепят public, мы в этой статье не рассматриваем.
А потом в том же проекте я начал познавать одну из ветвей пути настоящего самурая: юнит-тестирование. А по фэн-шую юнит-тесты должны лежать в отдельной сборке. По тому же фэн-шую всё, что можно спрятать внутри сборки, нужно спрятать внутри сборки. Я встал перед весьма и весьма неприятным выбором. Или тесты будут лежать рядышком и уходить клиенту вместе с полезным для него кодом, или всё покроется ключевым словом public, как долго лежавший в сырости хлебушек.
И вот тут откуда-то из закромов моей памяти было добыто что-то про дружественные сборки. Оказалось, что если у вас есть сборка «YourAssemblyName», то можно написать вот так:
```
[assembly: InternalsVisibleTo("YourAssemblyName.Tests")]
```
И сборка «YourAssemblyName.Tests» будет видеть то, что помечено ключевым словом internal в «YourAssemblyName». Строчку эту можно вписать, чуть что, в AssemblyInfo.cs, который VS создаёт специально для хранения таких атрибутов.
**Возвращение оскорбительно базовой справки**В .NET кроме уже встроенных атрибутов или ключевых слов вроде abstract, public, internal, static можно создавать свои. И вешать их на всё, что угодно: поля, свойства, классы, методы, события, и целые сборки. В C# вы для этого просто пишете имя атрибута в квадратных скобках перед тем, на что навешиваете. Исключение — сама сборка, так как в коде нет нигде прямого указания, что «Assembly begins here». Там ещё перед названием атрибута надо дописать assembly:
Таким образом, волки остаются сыты, овцы целы, всё, что можно, по-прежнему прячется внутри сборки, юнит тесты живут в отдельной сборке, как и положено, а фича, про которую я едва вспомнил, обретает повод её использовать. Возможно, единственный существующий повод.
Чуть не забыл один важный момент. Действия атрибута InternalsVisibleTo одностороннее.
protected < internal?
---------------------
Итак, ситуация: A и B сидели на трубе.
```
using System;
namespace Pipe
{
public class A
{
public String SomeProperty { get; protected set; }
}
internal class B
{
//ERROR!!! The accessibility modifier of the 'B.OtherProperty.set' accessor must be more
//restrictive than the property or indexer 'B.OtherProperty'
internal String OtherProperty { get; protected set; }
}
}
```
A было уничтожено в процессе код-ревью, так как не используется за пределами сборки, но позволяет себе зачем-то иметь модификатор доступа public, B вызвало ошибку компиляции, которая в первые минуты может ввести в ступор.
В принципе, сообщение об ошибке логично. Аксессор свойства не может раскрывать больше, чем само свойство. Любой отнесётся с пониманием, если компилятор даст по шапке за такое:
```
internal String OtherProperty { get; public set; }
```
Но вот претензии к этой строке сходу ломают мозг:
```
internal String OtherProperty { get; protected set; }
```
Замечу, что к этой строке претензий не будет:
```
internal String OtherProperty { get; private set; }
```
Если особо не задумываться, то в голове выстраивается следующая иерархия:
```
public > internal > protected > private
```
И эта иерархия вроде как даже работает. Кроме одного места. Там, где internal > protected. Чтобы понять суть претензий компилятора, давайте вспомним, какие ограничения накладывают internal и protected. internal — только внутри сборки. protected — только наследники. Заметьте, любые наследники. А если класс B пометить как public, то в другой сборке можно определить его наследников. И тогда акссесор set действительно получит доступ туда, куда его не имеет всё свойство. Так как компилятор C# параноидален, он даже возможности такой допустить не может.
Спасибо ему за это, но нам нужно дать наследникам доступ к аксессору. И специально для таких случаев есть модификатор доступа protected internal.
**Эта справка уже не столь оскорбительна*** protected internal — модификатор доступа, который обозначает, что им помеченное доступно внутри сборки **или** наследникам класса, в котором расположено помеченное.
Так что если мы хотим, чтобы компилятор позволил нам пользоваться этим свойством и задавать его в наследниках, нужно сделать так:
```
using System;
namespace Pipe
{
internal class B
{
protected internal String OtherProperty { get; protected set; }
}
}
```
А правильная иерархия модификаторов доступа выглядит приблизительно так:
```
public > protected internal > internal/protected > private
```
Интерфейсы
----------
Итак, ситуация: A, I, B сидели на трубе.
```
namespace Pipe
{
internal interface I
{
void SomeMethod();
}
internal class A : I
{
internal void SomeMethod()
{
//'A' does not implement interface member 'I.SomeMethod()'.
//'A.SomeMethod()' cannot implement an interface member because it is not public.
}
}
internal class B : I
{
internal void SomeMethod()
{
//'B' does not implement interface member 'I.SomeMethod()'.
//'B.SomeMethod()' cannot implement an interface member because it is not public.
}
}
}
```
Сидели ровно и за пределы сборки не совались. Но были забракованы компилятором. Тут суть претензий ясна из сообщения об ошибке. Реализация интерфейса должна быть открытой. Даже если сам интерфейс закрыт. Было бы логично привязать доступ реализации интерфейса к его доступности, но чего нет, того нет. Реализация интерфейса должна быть public.
И у нас здесь два выхода. Первый: сквозь скрип и зубовный скрежет повесить на реализацию интерфейса модификатор доступа public. Второй: явная реализация интерфейса. Выглядит это так:
```
namespace Pipe
{
internal interface I
{
void SomeMethod();
}
internal class A : I
{
public void SomeMethod()
{
}
}
internal class B : I
{
void I.SomeMethod()
{
}
}
}
```
Обратите внимание, что во втором случае нет модификатора доступа. Кому в таком случае доступна реализация метода? Скажем так, никому. Проще показать на примере:
```
B b = new B();
//'B' does not contain a definition for 'SomeMethod' and no accessible extension method //'SomeMethod' accepting a first argument of type 'B' could be found
//(are you missing a using directive or an assembly reference?)
b.SomeMethod();
//OK
(b as I).SomeMethod();
```
Явная реализация интерфейса I означает, что пока мы явно не приведём переменную к типу I, методов реализующий этот интерфейс не существует. Каждый раз писать (b as I).SomeMethod() может быть излишней нагрузкой. Как и ((I)b).SomeMethod(). И я нашёл два способа это дело обойти. До одного додумался сам, а второй честно нагуглил.
Способ первый — фабрика:
```
internal class Factory
{
internal I Create()
{
return new B();
}
}
```
Ну, или любой другой паттерн, который позволит вам спрятать этот нюанс.
Способ второй — методы расширения:
```
internal static class IExtensions
{
internal static void SomeMethod(this I i)
{
i.SomeMethod();
}
}
```
Что удивительно, это срабатывает. Эти строки перестают выдавать ошибку:
```
B b = new B();
b.SomeMethod();
```
Ведь обращение идёт, как нам подсказывает IntelliSense в Visual Studio, не к методам явной реализации интерфейса, а к методам расширения. А к ним обращаться никто не запрещает. И методы расширения интерфейса можно вызывать на всех его реализациях.
Но остаётся один нюанс. Внутри самого класса нужно обращаться к этому методу через ключевое слово this, иначе компилятор не поймёт, что мы хотим обратиться к методу расширения:
```
internal class B : I
{
internal void OtherMethod()
{
//Error!!!
SomeMethod();
//OK
this.SomeMethod();
}
void I.SomeMethod()
{
}
}
```
И так, и так, у нас или public, там где его быть не должно, но там он, *кажется*, вреда не причиняет, или немножко лишнего кода на каждый internal-интерфейс. Выберите меньшее зло себе по вкусу.
Рефлексия
---------
Я об это больно стукнулся, когда попытался найти через рефлексию конструктор, который, естественно, был помечен, как internal, у internal-класса. И оказалось, что рефлексия не выдаст ничего, что не было бы public. И это, в принципе, логично.
Во-первых, рефлексия, если я правильно помню то, что писали умные люди в умных книгах, это про поиск информации в метаданных сборки. Которые, по идее, не должны выдавать лишнего (я так думал, по крайней мере). Во-вторых, основное применение рефлексии — сделать вашу программу расширяемой. Вы предоставляете посторонним какой-то интерфейс (возможно, даже в виде интерфейсов, фить-ха!). А они его реализуют и предоставляют плагины, моды, расширения в виде загружаемой на ходу сборки, из которой рефлексия их и достаёт. И само собой, ваше API будет public. То есть, смотреть на internal через рефлексию невозможно технически и бессмысленно с практической точки зрения.
**Update.** Тут в комментариях выяснилось, что рефлексия позволяет, если её явно попросить об этом, отрефлексировать вообще всё. Будь оно хоть internal, хоть private. Если вы не пишете какой-то инструмент для анализа кода, старайтесь так не делать, пожалуйста. Текст дальше всё ещё актуален для случаев, когда мы ищем открытые типы членов. И вообще, не проходите мимо комментариев, там много чего интересного.
На этом можно было бы и закончить с рефлексией, но давайте вернёмся к предыдущему примеру, где A, I, B сидели на трубе:
```
namespace Pipe
{
internal interface I
{
void SomeMethod();
}
internal static class IExtensions
{
internal static void SomeMethod(this I i)
{
i.SomeMethod();
}
}
internal class A : I
{
public void SomeMethod()
{
}
internal void OtherMethod()
{
}
}
internal class B : I
{
internal void OtherMethod()
{
}
void I.SomeMethod()
{
}
}
}
```
Автор класса A решил, что ничего страшного не случится, если метод internal-класса пометить как public, чтобы компилятор не ныл, и чтобы не пришлось городить ещё кода. Интерфейс отмечен, как internal, класс, его реализующий, отмечен как internal, снаружи до метода, помеченного как public, вроде бы никак не добраться.
И тут открывает дверь и тихонько крадётся рефлексия:
```
using Pipe;
using System;
using System.Reflection;
namespace EncapsulationTest
{
public class Program
{
public static void Main(string[] args)
{
FindThroughReflection(typeof(I), "SomeMethod");
FindThroughReflection(typeof(IExtensions), "SomeMethod");
FindThroughReflection(typeof(A), "SomeMethod");
FindThroughReflection(typeof(A), "OtherMethod");
FindThroughReflection(typeof(B), "SomeMethod");
FindThroughReflection(typeof(B), "OtherMethod");
Console.ReadLine();
}
private static void FindThroughReflection(Type type, String methodName)
{
MethodInfo methodInfo = type.GetMethod(methodName);
if (methodInfo != null)
Console.WriteLine($"In type {type.Name} we found {methodInfo}");
else
Console.WriteLine($"NULL! Can't find method {methodName} in type {type.Name}");
}
}
}
```
Изучите этот код, вбейте его в студию, если вам так хочется. Тут мы пытаемся с помощью рефлексии найти все методы из всех типов нашей трубы (namespace Pipe). И вот какие результаты нам это даёт:
> In type I we found Void SomeMethod()
>
> NULL! Can't find method SomeMethod in type IExtensions
>
> In type A we found Void SomeMethod()
>
> NULL! Can't find method OtherMethod in type A
>
> NULL! Can't find method SomeMethod in type B
>
> NULL! Can't find method OtherMethod in type B
>
>
Сразу скажу, что используя объект типа MethodInfo, найденный метод можно вызвать. То есть, если рефлексия что-то нашла, то нарушить инкапсуляцию чисто теоретически можно. И у нас кое-что найдено. Во-первых, тот самый public void SomeMethod() из класса A. Это было ожидаемо, что тут ещё сказать. У этой поблажки всё-таки могут быть последствия. Во-вторых, void SomeMethod() из интерфейса I. Это уже интереснее. Как бы мы не запирались, но абстрактные методы, размещённые в интерфейсе (или что на самом деле там размещает CLR) на самом деле являются открытыми. Отсюда вывод, вынесенный в отдельный абзац:
*Смотрите внимательно кому и какие объекты типа System.Type вы отдаёте.*
Но тут ещё один нюанс с этими двумя найденными методами, который я хотел бы рассмотреть. Методы internal-интерфейсов и открытые методы internal-классов можно найти с помощью рефлексии. Как человек разумный, я сделаю вывод, что они попадают в метаданные. Как человек опытный, я этот вывод проверю. И в этом нам поможет ILDasm.
**Глянуть одним глазком в кроличью нору метаданных нашей трубы**Сборка была собрана в режипрме Release
`TypeDef #2 (02000003)
-------------------------------------------------------
TypDefName: Pipe.I (02000003)
Flags : [NotPublic] [AutoLayout] [Interface] [Abstract] [AnsiClass] (000000a0)
Extends : 01000000 [TypeRef]
Method #1 (06000004)
-------------------------------------------------------
MethodName: SomeMethod (06000004)
Flags : [Public] [Virtual] [HideBySig] [NewSlot] [Abstract] (000005c6)
RVA : 0x00000000
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.
TypeDef #3 (02000004)
-------------------------------------------------------
TypDefName: Pipe.IExtensions (02000004)
Flags : [NotPublic] [AutoLayout] [Class] [Abstract] [Sealed] [AnsiClass] [BeforeFieldInit] (00100180)
Extends : 01000011 [TypeRef] System.Object
Method #1 (06000005)
-------------------------------------------------------
MethodName: SomeMethod (06000005)
Flags : [Assem] [Static] [HideBySig] [ReuseSlot] (00000093)
RVA : 0x00002134
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
ReturnType: Void
1 Arguments
Argument #1: Class Pipe.I
1 Parameters
(1) ParamToken : (08000004) Name : i flags: [none] (00000000)
CustomAttribute #1 (0c000011)
-------------------------------------------------------
CustomAttribute Type: 0a000001
CustomAttributeName: System.Runtime.CompilerServices.ExtensionAttribute :: instance void .ctor()
Length: 4
Value : 01 00 00 00 > <
ctor args: ()
CustomAttribute #1 (0c000010)
-------------------------------------------------------
CustomAttribute Type: 0a000001
CustomAttributeName: System.Runtime.CompilerServices.ExtensionAttribute :: instance void .ctor()
Length: 4
Value : 01 00 00 00 > <
ctor args: ()
TypeDef #4 (02000005)
-------------------------------------------------------
TypDefName: Pipe.A (02000005)
Flags : [NotPublic] [AutoLayout] [Class] [AnsiClass] [BeforeFieldInit] (00100000)
Extends : 01000011 [TypeRef] System.Object
Method #1 (06000006)
-------------------------------------------------------
MethodName: SomeMethod (06000006)
Flags : [Public] [Final] [Virtual] [HideBySig] [NewSlot] (000001e6)
RVA : 0x0000213c
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.
Method #2 (06000007)
-------------------------------------------------------
MethodName: OtherMethod (06000007)
Flags : [Assem] [HideBySig] [ReuseSlot] (00000083)
RVA : 0x0000213e
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.
Method #3 (06000008)
-------------------------------------------------------
MethodName: .ctor (06000008)
Flags : [Public] [HideBySig] [ReuseSlot] [SpecialName] [RTSpecialName] [.ctor] (00001886)
RVA : 0x00002140
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.
InterfaceImpl #1 (09000001)
-------------------------------------------------------
Class : Pipe.A
Token : 02000003 [TypeDef] Pipe.I
TypeDef #5 (02000006)
-------------------------------------------------------
TypDefName: Pipe.B (02000006)
Flags : [NotPublic] [AutoLayout] [Class] [AnsiClass] [BeforeFieldInit] (00100000)
Extends : 01000011 [TypeRef] System.Object
Method #1 (06000009)
-------------------------------------------------------
MethodName: OtherMethod (06000009)
Flags : [Assem] [HideBySig] [ReuseSlot] (00000083)
RVA : 0x00002148
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.
Method #2 (0600000a)
-------------------------------------------------------
MethodName: Pipe.I.SomeMethod (0600000A)
Flags : [Private] [Final] [Virtual] [HideBySig] [NewSlot] (000001e1)
RVA : 0x0000214a
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.
Method #3 (0600000b)
-------------------------------------------------------
MethodName: .ctor (0600000B)
Flags : [Public] [HideBySig] [ReuseSlot] [SpecialName] [RTSpecialName] [.ctor] (00001886)
RVA : 0x0000214c
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.
MethodImpl #1 (00000001)
-------------------------------------------------------
Method Body Token : 0x0600000a
Method Declaration Token : 0x06000004
InterfaceImpl #1 (09000002)
-------------------------------------------------------
Class : Pipe.B
Token : 02000003 [TypeDef] Pipe.I`
Беглый осмотр показывает, что в метаданные попадает **всё**, как бы оно ни было помечено. Рефлексия ещё заботливо от нас прячет то, что посторонним видеть не положено. Так что вполне может быть, что лишние пять строк кода на каждый метод internal-интерфейса не такое уж и большое зло. Тем не менее, главный вывод остаётся прежним:
*Смотрите внимательно кому и какие объекты типа System.Type вы отдаёте.*
Но это уже, конечно, следующий уровень, после воцарения ключевого слова internal во всех местах, где нет необходимости в public.
P.S.
----
Знаете, что самое классное в использовании ключевого слова internal везде внутри сборки? Когда она разрастётся, вам придётся её поделить на две и больше. А в процессе вам придётся взять паузу на то, чтобы сделать некоторые типы открытыми. И вам придётся задуматься о том, какие именно типы достойны того, чтобы стать открытыми. Хотя бы мельком.
Это означает следующее: *эта практика написания кода заставит вас ещё раз задуматься о том, какую форму примет архитектурная граница между новорожденными сборками.* Что может прекраснее?
P.P.S.
------
Начиная с версии C# 7.2 появился новый модификатор доступа private protected. И я пока понятия не имею, что это такое, и с чем его едят. Так как не сталкивался на практике. Но буду рад узнать в комментариях. Но не копипаст из документации, а реальные случаи, когда этот модификатор доступа может понадобится. | https://habr.com/ru/post/445804/ | null | ru | null |
# На память о 2017-м: лучшие посты в нашем блоге за год
*[Pixel Jeff](http://pixeljeff.tumblr.com/)*
Новогодние традиции — это святое. Оливье, шампанское, мандарины, ёлка и подведение итогов за год. В 2017-м мы опубликовали 212 постов (а еще 90 в нашем блоге на Гиктаймс), получили более 6000 комментариев, а количество просмотров — более 3,5 млн! Так что мы собрали для вас 30 лучших постов за этот год, если вы вдруг что-то пропустили, или если захотите что-то перечитать. И в конце будет бонус — несколько наших лучших постов с Гиктаймса.
[Современный подход к сборке мусора](https://habrahabr.ru/company/mailru/blog/318504/) (+69)
--------------------------------------------------------------------------------------------
В последнее время встречалось немало статей, в которых не самым удачным образом продвигается свежий сборщик мусора в Go. Некоторые из статей написали разработчики самого языка, и их утверждения намекали на радикальный прорыв в технологии сборки мусора. Но они выглядят как недостоверный маркетинговый булшит. А поскольку они раз за разом воспроизводятся в Сети, пришло время подробно с ними разобраться.
[Малоизвестные Git-команды](https://habrahabr.ru/company/mailru/blog/318508/) (+136)
------------------------------------------------------------------------------------
У Git есть строгие обязательства по обратной совместимости: многие продвинутые возможности скрыты за разнообразными опциями, а не применяются как поведение по умолчанию. К счастью, Git также поддерживает и алиасы, так что вы можете создавать свои собственные команды, которые делают всю характерную для Git магию. В статье — подборка полезных (или как минимум забавных) алиасов.
[Повышаем производительность кода: сначала думаем о данных](https://habrahabr.ru/company/mailru/blog/319194/) (+125)
--------------------------------------------------------------------------------------------------------------------
Эта статья — не исчерпывающее хардкорное руководство по железу. Это всего лишь введение, напоминание, свод базовых принципов написания эффективного кода для CPU. Здесь «[показано, что низкоуровневое мышление сегодня всё ещё полезно](http://www.humus.name/Articles/Persson_LowLevelThinking.pdf)», даже если речь пойдёт о процессорах, которые можно добавить. В статье рассматривается кеширование, векторное программирование, чтение и понимание ассемблерного кода, а также написание кода, удобного для компилятора.
[Архитектура микросервисов](https://habrahabr.ru/company/mailru/blog/320962/) (+69)
-----------------------------------------------------------------------------------
В этой статье собрана вся необходимая информация о том, что такое микросервисы, преимущества и недостатки, как разрабатывать приложения с микросервисной архитектурой и каковы их особенности.
[Использование Tarantool в .NET-проекте на Windows](https://habrahabr.ru/company/mailru/blog/321998/) (+68)
-----------------------------------------------------------------------------------------------------------
Что делать, если вы разрабатываете проекта в Visual Studio на Windows и хотите попробовать Tarantool? Предполагается, что даже с переходом на микросервисную архитектуру большинство микросервисов будет написано на языке C#. А Tarantool… Стоит зайти на официальный сайт — и сразу понимаешь: Tarantool даже установить на Windows проблематично, так как на эту операционную систему он не портирован. В статье рассказывается о том, как можно побороть эти трудности и использовать Tarantool в своих .NET-проектах.
[Я написал самую быструю хеш-таблицу](https://habrahabr.ru/company/mailru/blog/323242/) (+116)
----------------------------------------------------------------------------------------------
Как вы понимаете, здесь рассказывается о написании одной из самых быстрых хеш-таблиц. По крайней мере, среди всех, что нашёл и проанализировал автор.
[Что я изменил бы в Go](https://habrahabr.ru/company/mailru/blog/325046/) (+69)
-------------------------------------------------------------------------------
Это сборник размышлений и пожеланий по изменению Go. В качестве эталона взят Rust.
[Шаблоны проектирования с человеческим лицом](https://habrahabr.ru/company/mailru/blog/325492/) (+120)
------------------------------------------------------------------------------------------------------
Шаблоны проектирования — это способ решения периодически возникающих проблем. Точнее, это руководства по решению конкретных проблем. Это не классы, пакеты или библиотеки, которые вы можете вставить в своё приложение и ожидать волшебства. В статье приведены примеры на PHP 7, но пусть вас это не смущает, ведь заложенные в шаблонах принципы неизменны. Кроме того, внедряется поддержка других языков.
[Сравнение производительности версий PHP](https://habrahabr.ru/company/mailru/blog/326696/) (+74)
--------------------------------------------------------------------------------------------------
В этой статье рассматриваются результаты нескольких бенчмарков, начиная с PHP 5 и вплоть до экспериментальной JIT-ветки (сейчас в разработке). На момент написания не было известно, появится ли до PHP 8 ещё какая-то основная версия, например PHP 7.2. Но логично предположить, что возможности экспериментальной ветки как минимум будут включены в PHP 8.
[Игры, в которых нужно писать код: Grid Garden, Elevator Saga и другие](https://habrahabr.ru/company/mailru/blog/328806/) (+72)
-------------------------------------------------------------------------------------------------------------------------------
В детстве мы постигаем премудрости жизни через игру. Это важнейший элемент развития личности, социальных навыков, получения знаний об окружающем мире. Игры — хороший «контейнер» для донесения и закрепления каких-либо знаний. Яркий пример — игры, в которых нужно писать код. Наверняка все вы о них слышали, а в некоторые даже играли. Их первичная задача — развлечь людей, уже владеющих навыками программирования, но они могут использоваться и для обучения. Эти игры помогут освежить свои знания по тому или иному языку, отвлечься и заняться более простой алгоритмической задачей.
[Эксперименты с malloc и нейронными сетями](https://habrahabr.ru/company/mailru/blog/329518/) (+72)
---------------------------------------------------------------------------------------------------
Во всех учебниках написано, что одна из основных проблем динамического распределения памяти — это ее непредсказуемость. Как говорится, знал бы прикуп — жил бы в Сочи. Если бы оракул заранее рассказал весь план по которому будет выделяться и освобождаться память, то можно было составить оптимальную стратегию, минимизирующую фрагментацию кучи, пиковое потребление памяти и т.д. Отсюда пошла возня с ручными аллокаторами. Автор реализовал инструменты журналирования `malloc()` и `free()` и рассказывает об использовании глубокого обучения для прогнозирования работы с кучей.
[Потенциально опасные алгоритмы](https://habrahabr.ru/company/mailru/blog/330892/) (+76)
----------------------------------------------------------------------------------------
Математические модели и алгоритмы сегодня отвечают за принятие важных решений, влияющих на нашу повседневную жизнь, более того — они сами управляют нашим миром. Математика стоит в основе цивилизации. Тем интереснее узнать, что с самого зарождения этого краеугольного камня в нем содержатся ошибки. Иногда ошибки математики остаются незаметными тысячелетия; порой они возникают спонтанно и быстро распространяются, проникая в наш код. Опечатка в уравнении ведет к катастрофе, но и само уравнение может быть потенциально опасно. Мы воспринимаем ошибки как нечто чуждое, но что если вокруг них и строится наша жизнь?
[Миллион WebSocket и Go](https://habrahabr.ru/company/mailru/blog/331784/) (+111)
---------------------------------------------------------------------------------
Это статья о том, как команда проекта Почта Mail.Ru разработала высоконагруженный WebSocket-сервер на Go.
[Разработка персонажей для игры «Аллоды Онлайн»](https://habrahabr.ru/company/mailru/blog/334712/) (+85)
--------------------------------------------------------------------------------------------------------
Многие начинающие художники горят желанием рисовать персонажей для игр. Но зачастую энтузиазм быстро гаснет, потому что создание персонажа — это ответственное дело, которым нельзя заниматься в отрыве от работы всей команды. Поэтому мы написали для вас руководство, как создавать игровых персонажей, на примере «Аллодов Онлайн».
[Load Average в Linux: разгадка тайны](https://habrahabr.ru/company/mailru/blog/335326/) (+123)
-----------------------------------------------------------------------------------------------
Средние значения нагрузки (Load averages) — это критически важная для индустрии метрика. Многие компании тратят миллионы долларов, автоматически масштабируя облачные инстансы на основании этой и ряда других метрик. Но на Linux она окутана некой тайной. Отслеживание средней нагрузки на Linux — это задача, работающая в непрерываемом состоянии сна (uninterruptible sleep state). Почему? В этой статье автор старается разгадать эту тайну, и создать референс по средним значениям нагрузки для всех, кто пытается их интерпретировать.
[Новый чемпионат для backend-разработчиков: HighLoad Cup](https://habrahabr.ru/company/mailru/blog/335384/) (+72)
-----------------------------------------------------------------------------------------------------------------
Проведение конкурсов для IT-специалистов сейчас в моде: Kaggle с его задачами по Data Science, сплоченная тусовка олимпиадного программирования, набирающие популярность площадки для конкурсов по искусственному интеллекту, всевозможные хакатоны для мобильных разработчиков, олимпиады для админов, capture the flag для безопасников. Казалось бы, специалисту любой сферы несложно найти себе подходящую движуху, поучаствовать, прокачаться и что-нибудь выиграть.
Обделенными в этом плане остались лишь web-разработчики. Мы в Mail.Ru Group решили исправить это досадное недоразумение и теперь с радостью представляем вам [HighLoadCup](https://highloadcup.ru/main/) — конкурсную площадку на стыке backend-разработки и администрирования web-сервисов.
[Что за черт, Javascript](https://habrahabr.ru/company/mailru/blog/335292/) (+74)
---------------------------------------------------------------------------------
Этот пост — список забавных и хитрых примеров на JavaScript. Это отличный язык. У него простой синтаксис, большая экосистема и, что гораздо важнее, огромное сообщество. В то же время мы все знаем, что JavaScript довольно забавный язык, в котором есть хитрые вещи. Некоторые из них быстро превращают нашу повседневную работу в ад, а некоторые заставляют хохотать. В этом посте рассмотрим некоторые из них.
[Управление памятью в Python](https://habrahabr.ru/company/mailru/blog/336156/) (+69)
-------------------------------------------------------------------------------------
Одна из главных проблем при написании крупных (относительно) программ на Python — минимизация потребления памяти. Однако управлять памятью здесь легко — если вас вообще это волнует. Память в Python выделяется прозрачно, управление объектами происходит с помощью системы счётчиков ссылок (reference count), и память высвобождается, когда счётчик падает до нуля. В теории всё прекрасно. А на практике вам нужно знать несколько вещей об управлении памятью в Python, чтобы ваши программы эффективно её использовали. Первая вещь, надо хорошо в ней разбираться: размеры основных объектов в Python. И вторая вещь: как устроено управление «под капотом» языка.
[Достижения в глубоком обучении за последний год](https://habrahabr.ru/company/mailru/blog/338248/) (+97)
---------------------------------------------------------------------------------------------------------
В статье рассказывается о том, что интересного произошло в мире машинного обучения за последний год (в основном в Deep Learning). А произошло очень многое, поэтому мы остановились на самых зрелищных и/или значимых достижениях. Технические аспекты улучшения архитектур сетей в статье не приводятся. Расширяем кругозор!
[Топливо для ИИ: подборка открытых датасетов для машинного обучения](https://habrahabr.ru/company/mailru/blog/339496/) (+65)
----------------------------------------------------------------------------------------------------------------------------
Если вы прямо сейчас не делаете свой ИИ, то другие будут делать его вместо вас для себя. Ничто более не мешает вам создать систему на основе машинного обучения. Есть открытая множество инструментов, облегчающих эту работу. Добавьте сюда доступность больших вычислительных мощностей, и вы поймете, что для полного счастья не хватает лишь одного ингредиента — данных. Огромное количество данных находится в открытом доступе, однако непросто понять, на какие из открытых датасетов стоит обратить внимание, какие из них годятся для проверки идей, а какие могут быть полезны в качестве средства проверки потенциальных продуктов или их свойств до того, как вы накопите собственные проприетарные данные. Мы разобрались в этом вопросе и собрали данные по датасетам, удовлетворяющим критериям открытости, востребованности, скорости работы и близости к реальным задачам.
[Поиск и исправление багов в исходниках PHP](https://habrahabr.ru/company/mailru/blog/340242/) (+66)
----------------------------------------------------------------------------------------------------
Честно предупреждаем: воспринимайте этот текст с определённой долей скептицизма. Автор лишь недавно начал знакомство с внутренностями PHP, но хотел бы рассказать вам о том, что творится за кулисами бага [#75237](https://bugs.php.net/bug.php?id=75237).
[Russian AI Cup 2017 — всем поклонникам StarCraft и C&C посвящается](https://habrahabr.ru/company/mailru/blog/340540/) (+91)
----------------------------------------------------------------------------------------------------------------------------
Уже несколько лет подряд мы проводим Russian AI Cup — нехилый такой конкурс для всех неравнодушных к программированию в целом, к построению ИИ, просто к написанию ботов для игр или автоматизации чего бы то ни было. Естественно, и этот год не будет исключением. Итак, Mail.Ru Group в сотрудничестве с Саратовским государственным университетом официально объявляют о дате старта Russian AI Cup 2017 и счастливы предложить задачу этого года. Жёсткие битвы, макбуки за первые места и минус полтора месяца из жизни разработчика — всё на месте, всё как вы любите.
[Почему нужно перестать использовать Git rebase](https://habrahabr.ru/company/mailru/blog/340558/) (+68)
--------------------------------------------------------------------------------------------------------
Команда Git rebase многими используется в повседневных задачах. Те, кто знаком с этой процедурой, знают, насколько это мощный инструмент и какой это соблазн — постоянно им пользоваться. Но дело в том, что rebase влечёт за собой ряд неочевидных на первый взгляд трудностей.
[Объясняем современный JavaScript динозавру](https://habrahabr.ru/company/mailru/blog/340922/) (+168)
-----------------------------------------------------------------------------------------------------
Цель статьи — рассказать о контексте, в котором инструменты в JavaScript развивались вплоть до 2017-го. Начнём с самого начала и будем делать сайт, как это делали бы динозавры — безо всяких инструментов, на чистом HTML и JavaScript. Постепенно станем вводить разные инструменты, поочерёдно рассматривая решаемые ими проблемы. Благодаря историческому контексту вы сможете адаптироваться к постоянно меняющемуся ландшафту JavaScript и понять его.
[Tarantool: когда на сервис оповещения миллиона пользователей нужно 500 строк кода](https://habrahabr.ru/company/mailru/blog/341498/) (+67)
-------------------------------------------------------------------------------------------------------------------------------------------
Tarantool — это не просто база данных. Tarantool — это app-сервер с базой данных на борту, поэтому для реализации кое-каких вещей, на которые люди тратят большое количество времени, с Tarantool нужно очень немного ресурсов. Очень много людей в IT-мире занимается одним и тем же. В статье рассказывается об авторском опыте решения этих же проблем.
[Как ты реализуешь аутентификацию, приятель?](https://habrahabr.ru/company/mailru/blog/343288/) (+75)
-----------------------------------------------------------------------------------------------------
Все знают о стандартной аутентификации пользователя в приложении. Это олдскульная процедура регистрации — пользователь вводит адрес почты, пароль и т. д., — а затем при входе мы сравниваем почту и/или пароль с сохранёнными данными. Если совпадает, даём доступ. Но времена изменились, и сегодня появилось много других методов аутентификации. Если хотите оставаться востребованным программистом/разработчиком в этом меняющемся, словно калейдоскоп, мире разработки ПО, то вы должны знать обо всех этих новых методах.
[Мастер-класс «Почему Стив Джобс любил шрифты» (Алексей Каптерев)](https://habrahabr.ru/company/mailru/blog/344132/) (+192)
---------------------------------------------------------------------------------------------------------------------------
В этом посте вас ждет грандиозное путешествие в мир шрифтов от древнейших времен до наших дней. Если вы хотите понять, каким образом шрифты влияют на наши эмоции и наконец научиться отличать гуманистический гротеск от ленточной антиквы — добро пожаловать под кат. И да, там очень много картинок.
[Отладка злого бага в рантайме Go](https://habrahabr.ru/company/mailru/blog/344080/) (+90)
------------------------------------------------------------------------------------------
В статье рассказывается о поиске и отладке одного очень хитрого бага в среде исполнения Go.
[Руководство по написанию защищённых PHP-приложений в 2018-м](https://habrahabr.ru/company/mailru/blog/344696/) (+69)
---------------------------------------------------------------------------------------------------------------------
Приближается 2018 год, и технари — в частности веб-разработчики — должны отбросить многие старые методики и верования в сфере разработки защищённых PHP-приложений. Особенно это относится ко всем, кто не верит, что такие приложения вообще возможны. Это руководство — дополнение к электронной книге [PHP: The Right Way](http://www.phptherightway.com/) с сильным уклоном в безопасность, а не общие вопросы программирования на PHP (вроде стиля кода).
[Материалы открытого курса OpenDataScience и Mail.Ru Group по машинному обучению и новый запуск](https://habrahabr.ru/company/mailru/blog/344044/) (+78)
--------------------------------------------------------------------------------------------------------------------------------------------------------
Недавно OpenDataScience и Mail.Ru Group провели открытый курс машинного обучения. В [прошлом анонсе](https://habrahabr.ru/company/ods/blog/334960/) много сказано о курсе. В этой статье мы поделимся материалами курса, а также объявим новый запуск.
И в завершение поста — лучшие наши посты на Гиктаймс за 2017-й:
* [Гигер и фантастические технологии мира Чужих](https://geektimes.ru/company/mailru/blog/289193/) (+84)
* [Последний великий проект советской науки: коллайдер в Протвино](https://geektimes.ru/company/mailru/blog/284742/) (+76)
* [Белое пятно на 15 мегабайт](https://geektimes.ru/company/mailru/blog/290375/) (+64)
* [Фрезерование печатных плат в домашних условиях](https://geektimes.ru/company/mailru/blog/286548/) (+64)
* [Космическая демосцена: Вселенная умещается в 64 килобайта](https://geektimes.ru/company/mailru/blog/293465/) (+60)
* [Большой финал: Кассини перед погружением в атмосферу Сатурна](https://geektimes.ru/company/mailru/blog/288872/) (+57)
* [Никогда не спят: старейшие действующие устройства](https://geektimes.ru/company/mailru/blog/288192/) (+56)
Всех с наступающим! | https://habr.com/ru/post/345790/ | null | ru | null |
# Мобильные устройства изнутри. Что такое GPT?
Что такое GPT?
--------------
**ОГЛАВЛЕНИЕ**[1. Введение](#1)
[2. Структура GPT](#2)
[3. Что такое GPT-раздел типа Intel?](#3)
[3.1. Структура заголовка нового GPT-раздела](#31)
[3.2. Структура записи описания нового GPT-раздела](#32)
[4. Заключение.](#4)
[5. Источники информации](#5)
1. Введение
-----------
Продолжаем рассматривать строение программной части (**software**) мобильных устройств (**МУ**). Сегодня поговорим об устройстве **GPT**-раздела памяти. Написать об этом меня побудила публикация [Изучаем структуры MBR и GPT](https://habrahabr.ru/post/347002/), вместо того, чтобы писать комментарии к ней. Я хотел бы не поругать или поправить автора, а дополнить вышеуказанную публикацию с уклоном в **МУ**.
Итак, GPT (GUID Partition Table) это:
* в первую очередь **название схемы разметки памяти** (**GPT-схема**) МУ ;
* затем уж **название раздела памяти** (**GPT-раздел**), где расположена физически эта схема;
* ну и также **название файла-образа** GPT-раздела памяти (**GPT-файл**).
Существует две схемы разметки памяти: **MBR** и **GPT**. Каждая схема содержится в отдельном разделе памяти, называемом, соответственно, **MBR** или **GPT**.
Как устроена **MBR**-схема разметки можно посмотреть в [[1]](#51), а **GPT** это другой формат описания разметки памяти — GUID (GUID Partition Table). Он является частью EFI (Extensible Firmware Interface) — стандарта [UEFI](#52), используемого вместо BIOS для загрузки разделов памяти.
Переход на другой формат позволил устранить самый существенный недостаток MBR-формата — малое число разделов. Если в **MBR** помещалось только 4 записи с ограничением на длину раздела и его смещение из-за того, что эти параметры описывались 32-разрядными числами, то в **GPT** можно разместить 128 записей о разделах. Причем их параметры уже описываются в 64-разрядной системе счисления…
Для совместимости со старым стандартом загрузки (BIOS) и с целью защиты самой таблицы описания разделов памяти **GPT**-раздел тоже начинается с **MBR**, которая описывает всего один раздел — всю память МУ. Сама **MBR** называется теперь «защитной» (protective), т.е. PMBR. Она располагается тоже в первом секторе памяти по адресу **0х0000-0х01FF** (512 байт). Поле **Смещение** указывает на начало заголовка **GPT**, а размер раздела устанавливается равным длине всей памяти устройства. Тип раздела имеет значение **0хEE** (GPT-раздел).
Суть защиты **GPT**-раздела да и всей памяти **МУ** сводится к следующему. Если такой раздел откроет средство работы с **MBR**-схемой разметки, то оно увидит пустую неразмеченную память, состоящую только из раздела описания разметки. Соответственно, что-либо сделать с этой памятью ему не удасться.
Вот как выглядит **PMBR**, например, от МУ ...:
**PMBR**
**Рис.1** «Защитная» MBR, т.е. PMBR
По адресу **0х01FE** видна сигнатура **MBR** (0xAA55).
Перейдем к рассмотрению непосредственно структуры **GPT**-раздела.
2. Структура GPT
----------------
**GPT**-раздел состоит из **PMBR**, заголовка и таблицы описания разделов памяти.
Сразу за **PMBR**, т.е. с адреса **0х0200**, располагается **заголовок GPT**, имеющий длину 0х5С (92) байта, но занимающий весь сектор (512 байт). Вот как он выглядит в том же **МУ**:
**Заголовок GPT**
**Рис.2** Заголовок GPT
Он имеет следующую структуру:
```
===============================================================================
| Смещение | Имя | Длина | Значение |
| байт | поля | байт | поля |
|==========|=================|=======|==========================================|
| 0x00 | Magic | 8 | сигнатура раздела |
| 0x08 | Revision | 4 | версия GPT-раздела |
| 0x0C | HeaderSize | 4 | размер заголовка в байтах |
| 0x10 | HeaderCRC32 | 4 | CRC32 заголовка |
| 0x14 | Reserved1 | 4 | резерв; должен быть 0 |
| 0x18 | MyLBA | 8 | LBA первичного GPT-раздела |
| 0x20 | AlternateLBA | 8 | LBA резервного GPT-раздела |
| 0x28 | FirstUsableLBA | 8 | LBA первого сектора для использования |
| 0x30 | LastUsableLBA | 8 | LBA последнего сектора для использования |
| 0x38 | DiskGUID | 16 | GUID диска (памяти) |
| 0x48 | PartitionsLBA | 8 | LBA первого сектора GPT |
| 0x50 | NumberParts | 4 | число записей о разделах |
| 0x54 | PartitionSize | 4 | размер записи о разделе в байтах |
| 0x58 | PartitionsCRC32 | 4 | CRC32 таблицы записей о разделах |
| 0x5C | Reserved2 | * | резерв |
===============================================================================
```
Поле **Magic** содержит строка символов «EFI PART» — 45h 46h 49h 20h 50h 41h 52h 54h, которая выделена на рис.2 бирюзовым цветом и однозначно идентифицирует GPT-раздел.
Поле **Revision**, выделенное зеленым цветом, содержит номер версии структуры GPT-раздела (0х00010000). Например, для GPT версии 1.0 должно быть 00h 00h 01h 00h
Поле **HeaderSize**, выделенное оранжевым цветом, содержит размер заголовка, выраженный в байтах. Пока это 0х0000005Ch, что означает 92 байта.
Поле **HeaderCRC32**, выделенное розовым цветом, содержит контрольную сумму заголовка (0x09BE8E1F), расчитанную по алгоритму CRC32. При непосредственном выполнении расчета учитываются только 92 байта, а в это поле перед расчетом заносится 0.
Следующее поле **Reserved1** никак не выделено, является резервным и содержит 0.
Поле **MyLBA**, выделенное темно-синим цветом, содержит смещение в блоках размещения первичного GPT-раздела (0х00000001).
Поле **AlternateLBA** содержит смещение в блоках размещения резервного GPT-раздела. Оно не указано.
Поле **FirstUsableLBA**, выделенное красным цветом, содержит смещение в блоках размещения первого разрешенного для использования сектора памяти (0х00000022). Расчитывается так: LBA последнего сектора, занятого первичным GPT-разделом, + 1.
Поле **LastUsableLBA** содержит смещение размещения последнего сектора памяти, разрешенного для использования. Расчитывается так: LBA первого сектора резервного GPT-раздела — 1. Оно не указано.
Поле **DiskGUID**, выделенное голубым цветом, содержит GUID прошивки.
Поле **PartitionsLBA**, выделенное красным цветом, содержит смещение начала GPT. В первичном всегда равен 2, а в резервном равен LastUsableLBA.
Поле **NumberParts**, выделенное ярко-зеленым цветом, содержит размер таблицы описания разделов, т.е. число записей о разделах (0х00000018).
Поле **PartitionSize**, выделенное розовым цветом, содержит размер одной записи о разделе в байтах. Согласно [UEFI Specification](#52) размер записи фиксирован и составляет 128 байт или 0х00000080.
Поле **PartitionsCRC**, выделенное красным цветом, содержит контрольную сумму таблицы описания разделов (0x93D54D33), расчитанную по алгоритму CRC32. При выполнении расчета учитываются все байты, начиная с PartitionsLBA и до FirstUsableLBA.
Поле **Reserved2** содержит резервное поле. Содержит 0 до конца сектора, т.е. 420 байт для сектора размером 512 байт.
Непосредственно сразу за заголовком, начиная с адреса **0х400**, располагается таблица описания разделов, содержащая записи о каждом разделе памяти, включая и сам раздел разметки. Вот как она выглядит:
**Рис.3** Таблица описания разделов
Каждая запись размером 128 байт имеет следующую структуру:
```
====================================================================================
| Смещение | Длина, | Имя | Значение |
| байт | байт | поля | поля |
|===========|========|=====================|=========================================|
| 0 | 0x00 | 16 | PartitionTypeGUID | GUID типа раздела |
| 16 | 0x10 | 16 | UniquePartitionGUID | GUID раздела |
| 32 | 0x20 | 8 | StartingLBA | LBA первого сектора размещения раздела |
| 40 | 0x24 | 8 | EndingLBA | последний LBA сектор размещения раздела |
| 48 | 0x30 | 8 | Attributes | атрибуты раздела |
| 56 | 0x38 | 72 | PartitionName | строка из имени раздела |
====================================================================================
```
Поле **PartitionTypeGUID**, выделенное красным цветом, содержит GUID типа раздела, который определяет файловую систему, используемую для хранения данных в этом разделе. Каждая файловая система получает свой GUID, однозначно её идентифицирующий. Стандарт UEFI жестко определяет только следующие GUID типов разделов:
```
=============================================================================
| Значение GUID | Описание |
|======================================|======================================|
| 00000000-0000-0000-0000-000000000000 | Неиспользуемый раздел |
| C12A7328-F81F-11d2-BA4B-00A0C93EC93B | Системный раздел UEFI |
| 024DEE41-33E7-11d3-9D69-0008C781F39F | Раздел, содержащий традиционную MBR |
=============================================================================
```
Поставщикам ОС (vendors) нужно генерировать свой собственный GUID типа раздела, чтобы идентифицировать их. Некоторые известные GUID можно посмотреть в [[3]](#53).
При записи в память или в файл-образ значение GUID записывается в другом порядке. Например, GUID системного раздела EFI имеет следующий вид: C12A7328-F81F-11D2-BA4B-00A0C93EC93B. Порядок записи байтов в написаниях GUID является little-endian, причем задом наперед пишутся байты только в первых трех блоках. Для приведенного выше GUID запись в таблице разделов будет иметь такой вид:
```
28 73 2A C1 1F F8 D2 11 BA 4B 00 A0 C9 3E C9 3B
```
Поле **UniquePartitionGUID**, выделенное синим цветом, содержит GUID раздела. Является уникальным идентификатором раздела, поэтому создается каждый раз, когда создается раздел.
Поле **StartingLBA**, выделенное зеленым цветом, содержит смещение в блоках на первый сектор раздела (0x00020000).
Поле **EndingLBA**, выделенное оранжевым цветом, содержит смещение на последний сектор раздела (0x0003FFFF). При этом размер раздела (PartitionSize) определяется по формуле
```
PartitionSize = EndingLBA - StartingLBA + 1
```
Поле **Attributes**, выделенное фиолетовымым цветом, содержит атрибуты (флаги) раздела. 8 байт (64 бита) флагов распределены следующим образом. Биты с 0 по 47 (48 шт.) отведены под общие атрибуты типов разделов, а остальные 16 битов (с 48 по 63) описывают конкретный раздел.
Вот небольшое описание этих битов:
```
================================================
| Бит | Значение |
|======|=========================================|
| 0 | системный раздел |
| 1 | EFI игнорирует содержимое этого раздела |
| 2-47 | Зарезервировано для нужд UEFI |
| ---- | |
| 60 | Read-only (только для чтения) |
| 61 | Теневая копия другого раздела |
| 62 | Hidden (скрытый) |
| 63 | автоматически не монтируется |
================================================
```
Поле **PartitionName**, выделенное синим цветом, содержит метку раздела («modem»), содержащую строку текста с завершающим нулем числом не более 36 символов, выраженную в кодировке UTF-16LE.
Все, что такое GPT мы уже знаем, только это стандартная структура **GPT**-раздела. Оказывается, имеется и модификация…
Т.к. я обнаружил **GPT**-раздел другой структуры при работе с **МУ** на основе чипа **Intel**, то я и назвал ее **GPT-раздел типа Intel**.
3. Что такое GPT-раздел типа Intel?
-----------------------------------
Прошивка новых мобильных устройств (МУ) Lenovo, выполненных на основе чипов **Intel**, имеет **Gpt**-схему разметки памяти, но структура самого **Gpt**-файла отличается от стандартной, описанной в [1]. Это касается, например, устройств YOGA BOOK YB1-X90.
По сравнению со стандартной структурой **Intel**-тип сокращен до максимума:
* из заголовка убраны Guid, контрольные суммы, смещения всех разделов, кроме саамого первого и все стандартные значения или пустые, например, размер записи параметров раздела, размещение Primary и Backup таблиц;
* из описания параметров раздела удалены атрибуты, а смещения первого и последнего блока заменены на размер раздела.
Т.к. структура **Gpt**-файла этого типа отличается от стандартной структуры, то для его прошивки необходимо использовать специальный флешер фирмы **Intel** — PhoneFlashTool\_5.3.2.0.
**GPT**-раздел, как и стандартный, состоит из:
* **заголовка**;
* **таблицы описания параметров** разделов.
**Рис.4** Строение Gpt-файла Intel-типа
Рассмотрим строение заголовка.
### 3.1. Структура заголовка нового GPT-раздела.
Заголовок имеет размер всего 12 (**0x0C**) байт (против 512 в стандартном варианте):
**Рис.5** Заголовок Gpt-файла Intel-типа
и содержит следующие поля:
```
=============================================================
| № | Смещение | Имя | Размер | Значение поля |
| п/п | поля | поля | байт | |
|=============================================================|
| 1 | 0x00 | Magic | 4 | Сигнатура файла |
| 2 | 0x04 | StartLba | 4 | Смещение первого раздела |
| 3 | 0x08 | Number | 4 | Число разделов памяти |
=============================================================
```
Поле **Magic**, отмеченное синим цветом, содержит число **0х6А8В0DA1**, идентифицирующее образ **GPT-раздела Intel-типа**.
Поле **StartLba**, отмеченное красным цветом, содержит значение смещения размещения первого раздела памяти.
Поле **Number**, отмеченное зеленым цветом, содержит общее число разделов памяти, т.е. число записей таблицы описания разделов. Сама таблица расположена сразу после заголовка.
### 3.2. Структура записи описания нового GPT-раздела
Таблица описания разделов содержит записи, содержащие параметры каждого раздела памяти. Число записей равно числу разделов, а окончание таблицы ничем не отмечается.
Каждая запись имеет размер 108 (**0x6C**) байт, тогда как по [UEFI](#32) она содержала 128 байт. Вот как выглядит запись описания раздела нового формата:
**Рис.6** Запись описания раздела
и содержит следующие поля, описывающие параметры раздела:
```
=============================================================
| № | Смещение | Имя | Размер | Значение поля |
| п/п | поля | поля | байт | |
|=============================================================|
| 1 | 0x00 | Size | 4 | Размер раздела |
| 2 | 0x04 | Label | 72 | метка раздела |
| 3 | 0x4C | GuidType | 16 | GUID типа раздела |
| 3 | 0x5C | GuidPartition | 16 | GUID раздела |
=============================================================
```
Поле **Size**, выделенное на рис.6 синим цветом, содержит размер раздела, выраженный в Мб (1024 \* 1024 = 1048576 байт).
Поле **Label**, выделенное на рис.6 красным цветом, содержит метку раздела, т.е. имя раздела, выраженное в кодировке UTF-16.
Поле **GuidType**, выделенное на рис.6 зеленым цветом, содержит GUID типа раздела.
Поле **GuidPartition**, выделенное на рис.6 желтым цветом, содержит GUID самого раздела.
4. Заключение
-------------
Изучив строение **GPT**-раздела разметки памяти **МУ**, можно приступить и к практическим занятиям.
В следующих публикациях я поделюсь опытом переразметки памяти **МУ**, выполненного по **GPT**-схеме.
5. Источники информации
-----------------------
1. [«Что такое MBR?»](http://lenovo-forums.ru/topic/9111-razmetka-pamyati-mobilnyh-ustroystv/?do=findComment&comment=253706)
2. [UEFI Specification, Version 2.7 Errata A](http://www.uefi.org)
3. [GUID Partition Table.](http://en.wikipedia.org/wiki/GUID_Partition_Table) | https://habr.com/ru/post/347738/ | null | ru | null |
# То, что вам никто не говорил о z-index в статье «То, что вам никто не говорил о z-index»
Почти два года назад вышла статья «[What no one told you about z-index](http://philipwalton.com/articles/what-no-one-told-you-about-z-index/)» (и её перевод на Хабре «[То, что вам никто не говорил о z-index](http://habrahabr.ru/post/166435/)»), авторы которой рассказывают о малоизвестной ([76% проголосовавших пользователей Хабра слышат об этом впервые](http://habrahabr.ru/post/166435/)), но [документированной](http://www.w3.org/TR/css3-color/#transparency) возможности создания нового *контекста наложения* указав `opacity` меньше единицы.
Но несмотря на название статьи, авторы не рассказали вам ещё кое о чём.
**Предполагается, что вы знакомы с понятием контекста наложения (англ. stacking context).**
> Элементы с общими родителями, перемещающиеся на передний или задний план вместе известны как *контекст наложения*. Понимание *контекста наложения* является ключом к пониманию `z-index` и порядка наложения элементов.
>
>
>
> Каждый *контекст наложения* имеет свой корневой элемент в HTML структуре. В момент формирования нового контекста на элементе, все дочерние элементы так же попадают в этот контекст и занимают своё место в порядке наложения. Если элемент располагается в самом низу одного *контекста наложения*, то никаким мыслимым и немыслимым образом не получится отобразить его над другим элементом в соседнем *контексте наложения*, располагающимся выше по иерархии, даже с установленным `z-index` равным миллиону.
— Из статьи «[То, что вам никто не говорил о z-index](http://habrahabr.ru/post/166435/)». Для понимания темы настоятельно рекомендую к ознакомлению либо её, либо классический труд [на MDN](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context).
Новый *контекст наложения формируется* в случаях:
* Корневой элемент (`) всегда содержит корневой *контекст наложения*. Любой элемент на странице, не участвующий в локальном *контексте наложения* (сформированном любым из последующих вариантов), участвует в корневом *контексте наложения*.`
Элемент с `position` отличным от `static` и значением `z-index` отличным от `auto`. Кроме одного исключения для `position: fixed`, но я это вынес в отдельный пункт.
[Элемент имеет значение `opacity` меньше, чем `1`](http://www.w3.org/TR/css3-color/#transparency).
[Flex-элемент со значением `z-index` отличным от `auto`](http://www.w3.org/TR/css3-flexbox/#painting), даже в случае `position: static`.
Трансформированные элементы: [значение `transform` отличное от `none`](http://www.w3.org/TR/css3-transforms/#transform-property); [`transform-style` со значением `preserve-3d`](http://www.w3.org/TR/css3-transforms/#transform-style-property); и [`perspective` со значением отличным от `none`](http://www.w3.org/TR/css3-transforms/#perspective-property).
CSS Regions: [установление значения `flow-from` отличное от `none` для элемента с `content` отличным от `normal`](http://www.w3.org/TR/css3-regions/#the-flow-from-property).
Paged Media: [каждый Page-Margin Box устанавливает собственный *контекст наложения*](http://www.w3.org/TR/css3-page/#margin-boxes).
И наконец пункт, ради которого я и пишу эту статью — [мобильные браузеры на основе WebKit, а также Google Chrome 22+ всегда создают новый контекст наложения для `position: fixed`-элементов, даже с `z-index: auto`](http://updates.html5rocks.com/2012/09/Stacking-Changes-Coming-to-position-fixed-elements)!
, но комментариев от представителей Microsoft я не нашёл и непонятна их позиция в этом вопросе. У меня не было возможности проверить поведение на Windows Phone и узнать, соответствует ли оно поведению на Desktop. Буду признателен, если кто-то поделится результатом эксперимента.
В любом случае W3C даёт лишь рекомендации, а каждый вендор решает сам для себя следовать им или нет. Нам же, простым разработчикам, остаётся лишь учитывать подобные нюансы в своих веб-приложениях (хорошо, что одна корпорация с небезызвестным продуктом закаляла нас годами).
Благодарю за внимание! | https://habr.com/ru/post/225721/ | null | ru | null |
# Наконец-то!
На хабре появился нормальный редактор комментариев. Теперь не надо будет каждый раз прописывать руками все коды. Сколько лет его все ждали.
Теперь можно удалить все надстройки для браузеров, дублирующие этот функционал.
Где анонс этого апдейта и какие-либо комментарии от администрации? Может ещё какие-нибудь нововведения появились?
[](http://habr.habrastorage.org/post_images/b12/fda/478/b12fda478880b07c151e6ad82340e5a7.png "Хабрэффект.ру")
**upd:** Хабрапарсер теперь обрабатывает аргументы тега! . Подсказывает [silverfire](http://habrahabr.ru/users/silverfire/).
```
```
> Параметр clear сообщает браузеру, как обрабатывать следующую строку, если текст обтекает плавающий элемент. Плавающим элементом называется изображение, у которого установлен параметр align или слой, к которому применяется свойство CSS float.
>
> Результат использования параметра clear зависит от края, по которому выравнивается элемент и значения clear.
>
> Так, если изображение выравнивается по левому краю, а значение параметра clear тега установлено как all или left, то текст после тега будет отображаться ниже рисунка. Любые другие значения параметра clear заставят текст располагаться справа от изображения и обтекать его.
Теперь статьи оформлять немного удобнее. Пример:
И скриншот исходного кода для любопытных – [habreffect.ru/files/bcc/38340b3b6/ScreenShot\_i60.png](http://habreffect.ru/files/bcc/38340b3b6/ScreenShot_i60.png)
**upd2:** Кнопки подключения к блогу теперь в отдельном инфоблоке справа. Обнаружил [slax](http://habrahabr.ru/users/slax/).
[](http://habr.habrastorage.org/post_images/459/463/7c3/4594637c3f714010c2210dd57e133334.png "Хабрэффект.ру") | https://habr.com/ru/post/113590/ | null | ru | null |
# Объединяя C++ и Python. Тонкости Boost.Python. Часть первая
Boost.Python во всех отношениях замечательная библиотека, выполняющая своё предназначение на 5+, хотите ли вы сделать модуль на С++ для Python либо хотите построить скриптовую обвязку на Python для нативного приложения написанного на С++.
Самое сложное в Boost.Python — это обилие тонкостей, поскольку и C++ и Python — два языка изобилующие возможностями, и потому на стыке их приходится учитывать все нюансы: передать объект по ссылке или по значению, отдать в Python копию объекта или существующий класс, преобразовать во внутренний тип Python или в обёртку написанного на C++, как передать конструктор объекта, перегрузить операторы, навесить несуществующие в C++, но нужные в Python методы.
Не обещаю, что в своих примерах опишу все тонкости взаимодействия этих фундаментальных языков, но постараюсь сразу охватить как можно больше частоиспользуемых примеров, чтобы вы не лазили за каждой мелочью в документацию, а увидели все необходимые основы здесь, или хотя бы получили о них базовое представление.
#### Оглавление
* [Объединяя C++ и Python. Тонкости Boost.Python. Часть первая](http://habrahabr.ru/post/168083/)
* [Объединяя C++ и Python. Тонкости Boost.Python. Часть вторая](http://habrahabr.ru/post/168233/)
* [Конвертация типов в Boost.Python. Делаем преобразование между привычными типами C++ и Python](http://habrahabr.ru/post/168827/)
* [Путешествие исключений между C++ и Python или «Туда и обратно»](http://habrahabr.ru/post/169639/)
#### Введение
Исходим из того, что у вас уже установлен удобный инструментарий для сборки динамически-линкуемой библиотеки на C++, а также установлен интерпретатор Python.
Также понадобится скачать библиотеку [Boost](http://www.boost.org/users/download/), после чего собрать её, следуя инструкции для своей ОС [Windows](http://www.boost.org/doc/libs/1_52_0/more/getting_started/windows.html) или [Linux](http://www.boost.org/doc/libs/1_52_0/more/getting_started/unix-variants.html).
В двух словах в Windows все действия сводятся к двум строкам в командной строке. Распакуйте скачанный архив Boost в любое место на диске, перейдите туда в командной строке и наберите последовательно две команды:
```
bootstrap
b2 --build-type=complete stage
```
Для сборки x64 нужно добавить аргумент **address-model=64**
Если у вас уже есть библиотека Boost, но вы не устанавливали Python, либо вы скачали и установили свежий интерпретатор Python и хотите собрать только Boost.Python, это делается дополнительным ключом **--with-python**
То есть вся строка для сборки только Boost.Python с 64-разрядной адресацией выглядит так:
```
b2 --build-type=complete address-model=64 --with-python stage
```
Стоит заметить, что x64 сборку следует заказывать, если у вас установлен Python x64. Также и модули для него нужно будет собирать с 64-разрядной адресацией.
Ключ **--with-python** серьёзно сэкономит вам время, если вам из библиотеки Boost кроме функционала Boost.Python ничего не нужно.
Если у вас установлено несколько интерпретаторов, крайне рекомендую прочитать подробную документацию по сборке [Boost.Python](http://www.boost.org/doc/libs/1_52_0/libs/python/doc/building.html)
После сборки у вас появятся в папке Boost\stage\lib собранные библиотеки Boost.Python, они нам очень скоро понадобятся.
#### Настраиваем проект на C++
Создаём проект для создания динамически-линкуемой библиотеки на C++, предлагаю назвать его example.
После создания проекта, требуется указать дополнительные INCLUDE каталоги Python\include и корень Boost, а также каталоги для поиска библиотек Python\libs и Boost\stage\lib
Под Windows также следует в настройках Post-build events задать переименование $(TargetPath) в модуль с расширением example.pyd в корне проекта.
Также возможно стоит скопировать собранные библиотеки Boost.Python в каталог с собираемым модулем.
Подключение модуля после запуска интерпретатора в том же каталоге сведётся к одной команде:
```
from example import *
```
Не забываем также про сборку под x64 если вы собираете для 64-разрядного Python.
#### Обычный класс с простыми полями
Итак, давайте заведём нашем новом проекте сразу три файла:
some.h
some.cpp
wrap.cpp
В файлах some.h и some.cpp опишем некий замечательный класс Some, который обернём для Python в модуле example в файле wrap.cpp — для этого в файле wrap.cpp следует подключить и использовать макрос BOOST\_PYTHON\_MODULE( example ) {… }, также для лаконичности будет совсем не лишним использовать using namespace boost::python. В целом наш будущий модуль будет выглядеть вот так:
```
#include
...
using namespace boost::python;
...
BOOST\_PYTHON\_MODULE( example )
{
...
}
...
```
В файле some.h нам следует наваять объявление нашего чудо-класса. Для объяснения большинства базовых механизмов нам достаточно всего два поля:
```
private:
int mID;
string mName;
```
Допустим класс содержит описание чего-то, что имеет имя и целочисленный идентификатор. Как ни странно этот несложный класс вызовет кучу сложностей, благодаря в основном стандартному классу string, перегрузкам методов, константной ссылке и статическому свойству NOT\_AN\_IDENTIFIER, которое мы конечно же тоже введём:
```
public:
static const int NOT_AN_IDENTIFIER = -1;
```
Разумеется эта константа нужна как идентификатор для объекта созданного конструктором по умолчанию, опишем также и другой конструктор, задающий оба поля:
```
Some();
Some( int some_id, string const& name );
```
В файле some.cpp опишем реализацию данных конструкторов, в дальнейшем реализацию описывать я не буду, но давайте конструкторы напишем вместе:
```
Some::Some()
: mID(NOT_AN_IDENTIFIER)
{
}
Some::Some( int some_id, string const& name )
: mID(some_id), mName(name)
{
}
```
Одновременно с появлением класса Some будет появляться обёртка класса для Python в файле wrap.cpp:
```
BOOST_PYTHON_MODULE( example )
{
class_( "Some" )
.def( init( args( "some\_id", "name" ) ) )
;
}
```
Здесь используется бессовестный обман зрения и шаблон boost::python::class\_, который создаёт описание класса для Python в указанном модуле с помощью Python C-API, жутко сложного и непонятно при описании методов, а потому полностью скрытого за объявлением простого метода def() на каждой строчке.
Конструктор по умолчанию и конструктор копирования создаются для объекта по умолчанию, если не указано обратное, но мы этого ещё коснёмся чуть ниже.
Уже сейчас можно собрать модуль, импортировать его из интерпретатора Python и даже создать экземпляр класса, но ни прочитать его свойства, ни вызывать методы мы у него пока не можем, пока они физически отсутствуют.
Давайте это исправим, создадим «богатейшее» API нашего чудо класса. Вот полный код нашего заголовочного файла some.h:
```
#pragma once
#include
using std::string;
class Some
{
public:
static const int NOT\_AN\_IDENTIFIER = -1;
Some();
Some( int some\_id, string const& name );
int ID() const;
string const& Name() const;
void ResetID();
void ResetID( int some\_id );
void ChangeName( string const& name );
void SomeChanges( int some\_id, string const& name );
private:
int mID;
string mName;
};
```
Раз реализация методов получилась также довольно короткой, давайте приведу и код some.cpp:
```
#include "some.h"
Some::Some()
: mID(NOT_AN_IDENTIFIER)
{
}
Some::Some( int some_id, string const& name )
: mID(some_id), mName(name)
{
}
int Some::ID() const
{
return mID;
}
string const& Some::Name() const
{
return mName;
}
void Some::ResetID()
{
mID = NOT_AN_IDENTIFIER;
}
void Some::ResetID( int some_id )
{
mID = some_id;
}
void Some::ChangeName( string const& name )
{
mName = name;
}
void Some::SomeChanges( int some_id, string const& name )
{
mID = some_id;
mName = name;
}
```
Что ж, самое время описать обёртку в файле wrap.cpp:
Первый метод Some::ID() оборачивается без каких-либо проблем:
```
.def( "ID", &Some::ID )
```
Зато второй с результатом в виде константной ссылки на строку уже показывает, что всё не так просто:
```
.def( "Name", &Some::Name, return_value_policy() )
```
Как видим, можно указать как Python должен интерпретировать возвращаемое значение, если метод в C++ возвращает указатель или ссылку. Дело в том, что зверский Garbage Collector (GC) очень любит удалять всё бесхозное, поэтому просто так объявить метод возвращающий указатель или ссылку, вам никто не даст, всё печально закончится на этапе компиляции, поскольку GC должен знать что ему делать с возвращаемым значением, для разработчика будет весьма печально, если он начнёт удалять содержимое объекта в C++. Всего есть несколько вариантов [return\_value\_policy для разных случаев](http://wiki.python.org/moin/boost.python/CallPolicy), самые важные из них следующие:
* **copy\_non\_const\_reference** — создаёт новый объект в Python, который содержит **не**константную ссылку на объект в C++, не требует обёртки для класса из C++ (пример: string не имеет обёртки, только конвертер в питоновский str)
* **copy\_const\_reference** — создаёт новый объект в Python, который содержит константную ссылку на объект в C++, не требует обёртки для класса из C++ (пример: тот же string)
* **manage\_new\_object** — создаёт новый объект в Python, используя обёртку класса из C++, по завершении содержимое удаляется
* **reference\_existing\_object** — создаёт новый объект в Python, используя обёртку класса из C++, по завершении содержимое остаётся
Понимание того, как работает тот или иной return\_value\_policy в деталях приходит со временем, эксперементируйте, пробуйте, читайте документацию и набивайте руку. Для стандартного string ссылка в зависимости от константности при возвращении почти всегда **copy\_const\_reference** либо **copy\_non\_const\_reference**, просто запомните, т.к. string по значению преобразуется на уровне Python в объект встроенного класса **str**, а по ссылке нужно явно указывать **return\_value\_policy**.
Метод Some::ResetID я намерено перегрузил, чтобы усложнить задачу с передачей указателя на метод в .def():
```
.def( "ResetID", static_cast< void (Some::*)() >( &Some::ResetID ) )
.def( "ResetID", static_cast< void (Some::*)(int) >( &Some::ResetID ), args( "some_id" ) )
```
Как видите, можно указать, с каким именем в Python будет создан аргумент метода. Как известно имя аргумента в Python куда важнее чем в C++. Рекомендую указывать имена аргументов для каждой обёртки метода, принимающего параметры:
```
.def( "ChangeName", &Some::ChangeName, args( "name" ) )
.def( "SomeChanges", &Some::SomeChanges, args( "some_id", "name" ) )
```
Осталось описать статическим свойством константу NOT\_AN\_IDENTIFIER:
```
.add_static_property( "NOT_AN_IDENTIFIER", make_getter( &Some::NOT_AN_IDENTIFIER ) )
```
Здесь используется специальная функция boost::python::make\_getter, которая по свойству класса генерирует get-функцию.
Вот так примерно выглядит наша обёртка:
```
#include
#include "some.h"
using namespace boost::python;
BOOST\_PYTHON\_MODULE( example )
{
class\_( "Some" )
.def( init( args( "some\_id", "name" ) ) )
.def( "ID", &Some::ID )
.def( "Name", &Some::Name, return\_value\_policy() )
.def( "ResetID", static\_cast< void (Some::\*)() >( &Some::ResetID ) )
.def( "ResetID", static\_cast< void (Some::\*)(int) >( &Some::ResetID ), args( "some\_id" ) )
.def( "ChangeName", &Some::ChangeName, args( "name" ) )
.def( "SomeChanges", &Some::SomeChanges, args( "some\_id", "name" ) )
.add\_static\_property( "NOT\_AN\_IDENTIFIER", make\_getter( &Some::NOT\_AN\_IDENTIFIER ) )
;
}
```
Если написать несложный тестовый скрипт вроде этого (Python 3.x):
```
from example import *
s = Some()
print( "s = Some(); ID: {ID}, Name: {Name}".format(ID=s.ID(),Name=s.Name()) )
s = Some(123,'asd')
print( "s = Some(123,'asd'); ID: {ID}, Name: {Name}".format(ID=s.ID(),Name=s.Name()) )
s.ResetID(234); print("s.ResetID(234); ID:",s.ID())
s.ResetID(); print("s.ResetID(); ID:",s.ID())
s.ChangeName('qwe'); print("s.ChangeName('qwe'); Name:'%s'" % s.Name())
s.SomeChanges(345,'zxc')
print( "s.SomeChanges(345,'zxc'); ID: {ID}, Name: {Name}".format(ID=s.ID(),Name=s.Name()) )
```
Мы увидим вывод:
```
s = Some(); ID: -1, Name: ''
s = Some(123,'asd'); ID: 123, Name: 'asd'
s.ResetID(234); ID: 234
s.ResetID(); ID: -1
s.ChangeName('qwe'); Name:'qwe'
s.SomeChanges(345,'zxc'); ID: 345, Name: 'zxc'
```
#### Питонизируем обёртку класса
Итак, класс со всеми методами обёрнут, но счастья не наступило. При попытке из командной строки Python выполнив Some(123,'asd') мы не увидим описания полей и вообще объекта, поскольку мы не обзавелись методом \_\_repr\_\_, так же как и преобразование к строке, тот же print( Some(123,'asd') ) будет ужасно неинформативен, так как мы не обзавелись методом \_\_str\_\_. Очевидно также, что работать со свойствами через методы на C++ на Python не имеет смысла, это в C++ мы не имеем возможности заводить property, в Python их можно и нужно завести. Однако как же мы навесим методы на готовый класс C++ предназначенные для Python?
Очень просто: вспоминаем, что в Python методы не отличаются от функций, принимающих первым параметром ссылку на self — экземпляр класса. Заводим в C++ такие функции прямо во wrap.cpp и описываем их как методы в обёртке:
```
...
string Some_Str( Some const& );
string Some_Repr( Some const& );
...
BOOST_PYTHON_MODULE( example )
{
class_( "Some" )
...
.def( "\_\_str\_\_", Some\_Str )
.def( "\_\_repr\_\_", Some\_Repr )
...
```
Сами функции можно описать например вот так:
```
string Some_Str( Some const& some )
{
stringstream output;
output << "{ ID: " << some.ID() << ", Name: '" << some.Name() << "' }";
return output.str();
}
string Some_Repr( Some const& some )
{
return "Some: " + Some_Str( some );
}
```
Со свойствами идентификатора и имени ещё проще, так как методы set и get для них уже описаны в классе:
```
.add_property( "some_id", &Some::ID, static_cast< void (Some::*)(int) >( &Some::ResetID ) )
.add_property( "name", make_function( static_cast< string const& (Some::*)() const >( &Some::Name ), return_value_policy() ), &Some::ChangeName )
```
При описании свойств однако было два тонких момента:
1. Для set-метода свойства some\_id было явное приведение к типу метода, принимающего int, т.к. есть ещё одна перегрузка метода.
2. Для get-метода свойства name была использована конструкция boost::python::make\_function, которая позволила повесить return\_value\_policy на результат метода возвращающего константную ссылку на string.
Выполняем print( Some(123,'asd') ) и просто Some(123,'asd') из командной строки после from example import \* и видим что подозрительно похожее на встроенный питоновский dict: { ID: 123, Name: 'asd' }
Почему бы не завести свойство инициализирующее экземпляр Some от стандартного dict и обратно?
Заведём ещё пару питонистических функций и заведём свойство as\_dict:
```
...
dict Some_ToDict( Some const& );
void Some_FromDict( Some&, dict const& );
...
BOOST_PYTHON_MODULE( example )
{
class_( "Some" )
...
.add\_property( "as\_dict", Some\_ToDict, Some\_FromDict )
;
...
}
...
dict Some\_ToDict( Some const& some )
{
dict res;
res["ID"] = some.ID();
res["Name"] = some.Name();
return res;
}
void Some\_FromDict( Some& some, dict const& src )
{
src.has\_key( "ID" ) ? some.ResetID( extract( src["ID"] ) ) : some.ResetID();
some.ChangeName( src.has\_key( "Name" ) ? extract( src["Name"] ) : string() );
}
```
Здесь использован класс boost::python::dict, для доступа на уровне C++ к стандартному dict Python.
Также есть классы для доступа к str, list, tuple, называются они соответственно. Ведут себя классы в C++ так же как и в Python в плане операторов, вот только возвращают по большей части boost::python::object, из которого требуется ещё извлечь значение через функцию boost::python::extract.
#### В заключение первой части
В первой части был рассмотрен вполне стандартный класс с конструктором по умолчанию и дефолтным конструктором копирования. Несмотря на некоторые тонкости с работой со строками, и перегрузкой методов, класс вполне стандартный.
Работать с Boost.Python довольно просто, обёртка любой функции сводится обычно к одной строке, которая выглядит как аналогичное объявление метода в Python.
В следующей части мы научимся оборачивать классы, которые создаются не так тревиально, создадим класс на основе структуры, обернём enum, познакомимся на практике с другим важным return\_value\_policy.
В третьей части рассмотрим конвертеры типов в стандартные типы Python напрямую без обёртки на примере массива байт. Научимся пробрасывать исключения определённого типа из C++ в Python и обратно.
Тема довольно обширная.
#### Ссылка на проект
Проект первой части для Windows выложен [здесь](http://www.megafileupload.com/en/file/389466/example-7z.html).
Проект MSVS v11 настроен на сборку с Python 3.3 x64. Собранные .dll Boost.Python соответствующей версии прилагаются.
Но ничего не мешает собрать файлы some.h, some.cpp, wrap.cpp любым другим сборочным аппаратом с привязкой к любой другой версии Python.
#### Полезные ссылки
[Документация Boost.Python](http://www.boost.org/doc/libs/1_52_0/libs/python/doc/)
[Политики возвращаемых по ссылке значений в Boost.Python](http://wiki.python.org/moin/boost.python/CallPolicy)
[Начало работы с Boost для Windows](http://www.boost.org/doc/libs/1_52_0/more/getting_started/windows.html)
[Начало работы с Boost для \*nix](http://www.boost.org/doc/libs/1_52_0/more/getting_started/unix-variants.html)
[Тонкости сборки Boost.Python](http://www.boost.org/doc/libs/1_52_0/libs/python/doc/building.html) | https://habr.com/ru/post/168083/ | null | ru | null |
# О чем говорит YouTube
На заре машинного обучения большинство решений выглядели очень странно, обособленно и необычно. Сегодня множество ML алгоритмов уже выстраиваются в привычный для программиста набор фреймворков и тулкитов, с которыми можно работать, не вдаваясь в детали их реализации.
> К слову, я противник такого поверхностного подхода, но для своих коллег хотел бы показать, что эта отрасль движется семимильными шагами и нет ничего сложного, чтобы применять ее наработки в продакшен проектах.
Для примера я покажу, как можно помочь пользователю найти нужный видеоматериал среди сотен других в нашем сервисе документооборота.
В моем проекте пользователи создают и обмениваются сотнями различных материалов: текстом, картинками, видеороликами, статьями, документами в различных форматах.
Поиск по документам представляется достаточно просто. Но что делать с поиском по мультимедиа контенту? Для полноценного сервиса пользователя надо обязать заполнить описание, дать название видеоролику или картинке, не помешает несколько тегов. К сожалению, далеко не все хотят тратить время на подобные улучшения контента. Обычно пользователь загружает ссылку на youtube, сообщает что это новое видео и нажимает сохранить. Что же делать сервису с таким “серым” контентом. Первая идея — спросить у YouTube? Но YouTube тоже наполняют пользователи (часто это один и тот же пользователь). Часто видеоматериал может быть и не с Youtube сервиса.
Так мне пришла идея научить наш сервис “слушать” видеоролик и самостоятельно “понимать”, о чем он.
Признаюсь, эта идея не нова, но сегодня для ее реализации не надо иметь штат из десяти Data Scientist-ов, достаточно два дня и немного аппаратных ресурсов.
### Постановка задачи
Наш микросервис, назовем его **Summarizer**, должен:
* Скачать видеоролик с медиа сервиса;
* Извлечь аудио дорожку;
* Прослушать аудио дорожу, собственно Speech to text;
* Найти 20 ключевых слов;
* Выделить одно предложение из текста, которое максимально могло бы раскрыть суть ролика;
* Все результаты отправить на сервис контента;
Реализацию доверим *Python*, так не придется заниматься интеграцией с готовыми ML решениями.
Шаг первый: аудио в текст.
Для начала установим все необходимые компоненты.
```
pip3 install wave numpy tensorflow youtube_dl ffmpeg-python deepspeech nltk networkx
brew install ffmpeg wget
```
Далее скачаем и распакуем натренированную модель для Speech to text решения от Mozilla — Deepspeech.
```
mkdir /Users/Volodymyr/Projects/deepspeech/
cd /Users/Volodymyr/Projects/deepspeech/
wget https://github.com/mozilla/DeepSpeech/releases/download/v0.3.0/deepspeech-0.3.0-models.tar.gz
tar zxvf deepspeech-0.3.0-models.tar.gz
```
Команда из Mozilla создала и натренировала достаточно хорошее решение, которое, используя TensorFlow, может превращать длинные аудиоролики в большие куски текста с высоким качеством. Также [TensorFlow](https://www.octadero.com/tag/tensorflow/) позволяет вам «из коробки» работать как на CPU, так и на GPU.
Наш код будет начинать со скачивания контента. В этом ему поможет замечательная библиотека [youtube-dl](https://github.com/rg3/youtube-dl), которая имеет встроенный постпроцессор, способный конвертировать видео в необходимый формат. К сожалению, код постпроцессора немного ограничен, он не умеет делать ресемплинг, так что мы ему поможем.
На вход Deepspeech необходимо подать аудиофайл с монодорожнкой и семплрейтом 16K. Для этого надо повторно обработать наш полученный файл.
```
_ = ffmpeg.input(youtube_id + '.wav').output(output_file_name, ac=1, t=crop_time, ar='16k').overwrite_output().run(capture_stdout=False)
```
В этой же операции мы можем и ограничить продолжительность нашего файла, передав дополнительный параметр “t”.
Загружаем deepspeech модель.
```
deepspeech = Model(args.model, N_FEATURES, N_CONTEXT, args.alphabet, BEAM_WIDTH)
```
При помощи библиотеки wave извлекаем фреймы в формате np.array и передаем их на вход deepspeech библиотеки.
```
fin = wave.open(file_name, 'rb')
framerate_sample = fin.getframerate()
if framerate_sample != 16000:
print('Warning: original sample rate ({}) is different than 16kHz. Resampling might produce erratic speech recognition.'.format(framerate_sample), file=sys.stderr)
fin.close()
return
else:
audio = np.frombuffer(fin.readframes(fin.getnframes()), np.int16)
audio_length = fin.getnframes() * (1/16000)
fin.close()
print('Running inference.', file=sys.stderr)
inference_start = timer()
result = deepspeech.stt(audio, framerate_sample)
```
Через некоторое время, пропорциональное вашим аппаратным ресурсам, вы получите текст.
### Шаг второй: поиск “смысла”
Для поиска слов, описывающих полученный текст я буду использовать метод графов. Данный метод основан на расстоянии между последовательностями. Сперва мы находим все “уникальные” слова, представим, что это вершины нашего графа. После, проходясь по тексту “окном” заданной длины, находим расстояние между словами, они-то и будут ребрами нашего гафа. Добавленные в граф вершины могут быть ограничены синтаксическими фильтрами, которые выбирают только лексические единицы определенной части речи. Например, можно рассматривать только существительные и глаголы для добавления в граф. Следовательно, мы будем строить потенциальные ребра, основываясь только на отношениях, которые могут быть установлены между существительными и глаголами.
Оценка, связанная с каждой вершиной, устанавливается на начальное значение 1, и запускается алгоритм ранжирования. Алгоритм ранжирования заключается в «голосовании» или «рекомендации». Когда одна вершина связана с другой, она“голосует” за эту (связанную) вершину. Чем выше число голосов, поданных за вершину, тем выше важность этой вершины. Более того, важность вершины для голосования определяет, насколько важным является само голосование, и эта информация также учитывается моделью ранжирования. Следовательно, оценка, связанная с вершиной, определяется на основе голосов, поданных за нее, и оценки вершин, подающих эти голоса.
Предположим, у нас есть граф G=(V, E), описанный вершинами V и ребрами E. Для данной вершины V пусть будет множество вершин E, которые связаны с ней. Для каждой вершины Vi существует In(Vi) вершин, связанных с ней, и Out(Vi) вершин, с которыми связана вершина Vi. Таким образом, вес вершины Vi можно представить по формуле.
Где d — фактор затухания / подавления, принимающий значение от 1 до 0.
Алгоритм несколько раз должен проитерировать граф для получения приблизительных оценок.
После получения приблизительной оценки для каждой вершины в графе вершины сортируются в порядке уменьшения оценки. Вершины, которые окажутся в начале списка, и будут нашими искомыми ключевыми словами.
Максимально релевантное предложение в тексте находится путем нахождения среднего от сложения оценок всех слов в предложении. То есть складываем все оценки и делим на количество слов в предложении.
```
iMac:YoutubeSummarizer $ cd /Users/Volodymyr/Projects/YoutubeSummarizer ; env "PYTHONIOENCODING=UTF-8" "PYTHONUNBUFFERED=1" /usr/local/bin/python3 /Users/Volodymyr/.vscode/extensions/ms-python.python-2018.11.0/pythonFiles/experimental/ptvsd_launcher.py --default --client --host localhost --port 53730 /Users/Volodymyr/Projects/YoutubeSummarizer/summarizer.py --youtube-id yA-FCxFQNHg --model /Users/Volodymyr/Projects/deepspeech/models/output_graph.pb --alphabet /Users/Volodymyr/Projects/deepspeech/models/alphabet.txt --lm /Users/Volodymyr/Projects/deepspeech/models/lm.binary --trie /Users/Volodymyr/Projects/deepspeech/models/trie --crop-time 900
Done downloading, now converting ...
ffmpeg version 4.1 Copyright (c) 2000-2018 the FFmpeg developers
built with Apple LLVM version 10.0.0 (clang-1000.11.45.5)
configuration: --prefix=/usr/local/Cellar/ffmpeg/4.1 --enable-shared --enable-pthreads --enable-version3 --enable-hardcoded-tables --enable-avresample --cc=clang --host-cflags= --host-ldflags= --enable-ffplay --enable-gpl --enable-libmp3lame --enable-libopus --enable-libsnappy --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-libx265 --enable-libxvid --enable-lzma --enable-opencl --enable-videotoolbox
libavutil 56. 22.100 / 56. 22.100
libavcodec 58. 35.100 / 58. 35.100
libavformat 58. 20.100 / 58. 20.100
libavdevice 58. 5.100 / 58. 5.100
libavfilter 7. 40.101 / 7. 40.101
libavresample 4. 0. 0 / 4. 0. 0
libswscale 5. 3.100 / 5. 3.100
libswresample 3. 3.100 / 3. 3.100
libpostproc 55. 3.100 / 55. 3.100
Guessed Channel Layout for Input Stream #0.0 : stereo
Input #0, wav, from 'yA-FCxFQNHg.wav':
Metadata:
encoder : Lavf58.20.100
Duration: 00:17:27.06, bitrate: 1536 kb/s
Stream #0:0: Audio: pcm_s16le ([1][0][0][0] / 0x0001), 48000 Hz, stereo, s16, 1536 kb/s
Stream mapping:
Stream #0:0 -> #0:0 (pcm_s16le (native) -> pcm_s16le (native))
Press [q] to stop, [?] for help
Output #0, wav, to 'result-yA-FCxFQNHg.wav':
Metadata:
ISFT : Lavf58.20.100
Stream #0:0: Audio: pcm_s16le ([1][0][0][0] / 0x0001), 16000 Hz, mono, s16, 256 kb/s
Metadata:
encoder : Lavc58.35.100 pcm_s16le
size= 28125kB time=00:15:00.00 bitrate= 256.0kbits/s speed=1.02e+03x
video:0kB audio:28125kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.000271%
Loading model from file /Users/Volodymyr/Projects/deepspeech/models/output_graph.pb
TensorFlow: v1.11.0-9-g97d851f04e
DeepSpeech: unknown
Warning: reading entire model file into memory. Transform model file into an mmapped graph to reduce heap usage.
2018-12-14 17:42:03.121170: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
Loaded model in 0.5s.
Loading language model from files /Users/Volodymyr/Projects/deepspeech/models/lm.binary /Users/Volodymyr/Projects/deepspeech/models/trie
Loaded language model in 3.17s.
Running inference.
Building top 20 keywords...
{'communicate', 'government', 'repetition', 'terrorism', 'technology', 'thinteeneighty', 'incentive', 'ponsibility', 'experience', 'upsetting', 'democracy', 'infection', 'difference', 'evidesrisia', 'legislature', 'metriamatrei', 'believing', 'administration', 'antagethetruth', 'information', 'conspiracy'}
Building summary sentence...
intellectually antagethetruth administration thinteeneighty understanding metriamatrei shareholders evidesrisia recognizing ponsibility communicate information legislature abaddoryis technology difference conspiracy repetition experience government protecting categories mankyuses democracy campaigns primarily attackers terrorism believing happening infection seriously incentive upsetting testified fortunate questions president companies prominent actually platform massacre powerful building poblanas thinking supposed accounts murdered function unsolved perverse recently fighting opposite motional election children watching traction speaking measured nineteen repeated coverage imagined positive designed together countess greatest fourteen attacks publish brought through explain russian opinion winking somehow welcome trithis problem looking college gaining feoryhe talking ighting believe happens connect further working ational mistake diverse between ferring
Inference took 76.729s for 900.000s audio file.
```
### Итоги
Идеи, которые приходят вам в голову, сегодня можно реализовать намного быстрее, чем еще три-четыре года назад. Пробуйте, экспериментируйте! Я думаю, что artificial intelligence — это в первую очередь intelligence инженеров, которые с ним работают.
Код доступен в [моем Github репозитории](https://github.com/VolodymyrPavliukevych/YoutubeSummarizer). | https://habr.com/ru/post/433532/ | null | ru | null |
# Как устроено автоматическое тестирование в Почте Mail.Ru под iOS
Некоторое время назад мы рассказали вам об [автоматическом тестировании нашей Почты на Android](https://habrahabr.ru/company/mailru/blog/306236/) и получили огромное количество вопросов от читателей. Сегодня приоткроем вам часть нашей «внутренней кухни», которая касается автотестирования на iOS. Для тестирования каждой сборки мы проводим более 500 автотестов, которые выполняются менее чем за один час. Как мы их реализовывали и зачем? С какими проблемами сталкивались и как смогли их решить? Обо всём этом читайте под катом.
Содержание
----------
[Gerrit Code Review](#gerrit-code-review)
[Система команд и связь с CI](#sistema-komand-i-svyaz-s-ci)
[CI-платформа](#ci-platforma)
[Сборки](#sborki)
[Тестовая сборка — этап 1](#testovaya-sborka--etap-1)
[Альфа-версия — этап 2](#alfa-versiya--etap-2)
[Бета-версия — этап 3](#beta-versiya--etap-3)
[Релиз — этап 4](#reliz--etap-4)
[Сборка приложений](#sborka-prilozheniy)
[Подпись приложения и provisioning profile](#podpis-prilozheniya-i-provisioning-profile)
[Проблемы](#problemy)
[Проверки и тесты](#proverki-i-testy)
[UI-тесты](#ui-testy)
[Каким должен быть фреймворк](#kakim-dolzhen-byt-freymvork)
[Модификации MonkeyTalk](#modifikacii-monkeytalk)
[Управление UI-тестами через скрипты](#upravlenie-ui-testami-cherez-skripty)
[Масштабирование — параллельный запуск](#masshtabirovanie--parallelnyy-zapusk)
[Первая версия](#pervaya-versiya)
[Текущая версия](#tekuschaya-versiya)
[Изоляция запусков](#izolyaciya-zapuskov)
[Каждому по симулятору!](#kazhdomu-po-simulyatoru)
[Общак симуляторов](#obschak-simulyatorov)
[Обходы проблем xcode, simulator и т. д.](#obhody-problem-xcode-simulator-i-t-d)
[Cтабильность взаимодействия с iOS-симуляторами оставляет желать лучшего](#ctabilnost-vzaimodeystviya-s-ios-simulyatorami-ostavlyaet-zhelat-luchshego)
[Пул симуляторов и нагрузка](#pul-simulyatorov-i-nagruzka)
[Асинхронный simctl без признаков завершения действия](#asinhronnyy-simctl-bez-priznakov-zaversheniya-deystviya)
[Системные диалоги в приложении](#sistemnye-dialogi-v-prilozhenii)
[Доступ к фото и контактам](#dostup-k-foto-i-kontaktam)
[Подмена ответов сервера](#podmena-otvetov-servera)
[Репортинг](#reporting)
[Генерация документации](#generaciya-dokumentacii)
[Итоговые характеристики системы](#itogovye-harakteristiki-sistemy)
[Недостатки](#nedostatki)
[Преимущества](#preimuschestva)
[Проверки проекта](#proverki-proekta)
[Same Targets](#same-targets)
[Локализация](#lokalizaciya)
[Категории](#kategorii)
[Заголовки тестов](#zagolovki-testov)
[Репортинг](#reporting-1)
[Статический анализ кода](#staticheskiy-analiz-koda)
[scan-build](#scan-build)
[fbinfer](#fbinfer)
[Профайлинг и тайминги запуска](#profayling-i-taymingi-zapuska)
[Unit-тесты](#unit-testy)
[HipChat и репортинг](#hipchat-i-reporting)
[Репорт о новых задачах](#report-o-novyh-zadachah)
[Репорт о результатах сборки, тестов, проверок](#report-o-rezultatah-sborki-testov-proverok)
[Заключение/выводы](#zaklyuchenievyvody)
Схематически рабочий процесс выглядит следующим образом:
Схема показывает начальные, наиболее жесткие и критически важные шаги задачи на пути к релизу. Начнем с одного из первых компонентов — Code Review.
Gerrit Code Review
------------------
Для код-ревью мы используем Gerrit Code Review. Он работает на отдельном узле, так как при некоторых действиях требует достаточно много ресурсов. Код хранится в git-репозитории. Помимо этого настроено зеркалирование репозитория на дополнительный узел, а также постоянно поддерживается полная резервная копия диска через Time Machine.
Рабочий процесс тесно связан с Gerrit. Проводятся не только автоматизированные проверки, но и QA-тестирование. Approve/Fail на любом из этапов отмечается в Gerrit в виде балла: +1/–1. Если автоматизированная проверка завершается с ошибкой или не удается собрать тестовую сборку — выставляется –1.
Если первый этап прошел успешно, далее за дело берется команда QA. Они взаимодействуют только с Jira, переводя задачу в состояние Open или QA Approved, поэтому при переходе выставляется соответствующий Label в Gerrit. Для этого реализован небольшой плагин для Jira, он выполняет именно эту задачу — и ничего более.
### Система команд и связь с CI
Gerrit позволяет использовать *server-side hooks* при помощи дополнительного [плагина](https://gerrit-review.googlesource.com/Documentation/config-hooks.html). Мы реализуем на ruby следующие хуки:
* change-merged;
* comment-added;
* merge-failed;
* patchset-created;
* ref-update;
* reviewer-added.
Большая часть хуков используется для оповещения команды об изменениях, а также для синхронизации состояния задачи в Jira. Например, при создании очередного patchset’а в Gerrit вызывается соответствующий хук, в котором мы переводим Jira-задачу в состояние Code Review, а кастомное поле Merge Approved выставляется в значение No, так как автоматизированные проверки на этом patchset’е еще не выполнялись. Но есть и более насыщенные реализации, например хук *comment-added*. Через него мы запускаем проверки и сборку изменений на CI-платформе. Для этого реализована собственная система команд, которая позволяет запускать определенные Job’ы на CI на заданном patchset’е. Чтобы облегчить задачу расширения набора команд, мы реализовали небольшой DSL для описания отображений комментариев в Job’ы. Например, так выглядит описание команды запуска автоматизированных проверок:
```
JobMapping.register do
command 'flow'
job BUILD_FLOW_JOB
arguments_required
processor do |args|
{
'CHECKS_ENABLED' => args.key?('checks')
}
end
processor do |args|
{
'ANALYSIS_ENABLED' => args.key?('analysis')
}
end
processor do |args|
{
'UNITTESTS_ENABLED' => args.key?('unit')
}
end
processor do |args|
if args.key?('ui')
tags = args['ui']
{
'UITESTS_ENABLED' => true,
'UI_TESTS_TAGS' => tags.nil? ? '' : tags.tr(',', ' ')
}
else
{
'UITESTS_ENABLED' => false
}
end
end
end
```
Автоматизированные проверки состоят из нескольких частей, и хочется иметь возможность запускать то, что нужно сейчас. Каждый JobMapping привязан к определенной команде, она задается методом **command**. Также эта команда должна отображаться в Job на Jenkins, он задается угадайте каким методом (**job**). Если у команды есть аргументы, в JobMapping их необходимость указывается методом **arguments\_required**.
Job’ы в Jenkins конфигурируются через переменные окружения, для этого в регистрации mapping’а можно добавлять блок-процессор методом **processor** и выполнять в нем преобразование строки вызова команды в набор env-переменных.
Чаще всего этих методов хватает для создания нужных отображений. Затем возникает лень, и вместо **«!flow ui unit»** хочется написать просто **«!tests»**. Поэтому появились трансляции:
```
JobMapping.register do
command 'tests'
translates_to '!flow ui unit'
rebase
end
```
Все говорит само за себя, ~~лень~~ комфорт в чистом виде.
CI-платформа
------------
Бо́льшая часть платформы написана с нуля на Ruby. Каждая проверка или задача реализуется отдельным модулем, который можно запустить как локально, так и на CI.
Для запуска задач мы используем Rake. Таким образом, для каждого модуля есть отдельный Rake-таск в Rakefile.
Если при локальном запуске разработчик может положиться на консольные логи, то на CI он ожидает увидеть итоговый отчет и оповещение. Это один из **исходных принципов** — *логи Job’ов в Jenkins нужны для разработчика CI, а не его клиента*. Поэтому все модули проверок реализуют одинаковый интерфейс, чтобы при запуске на CI получить итоговое состояние задачи и описание ошибки (если она есть). Значит, для CI нам нужна система, которая позволяет просто запустить Rake-задачу и взять на себя некоторые основные операции вроде клонирования кода заданной ревизии, содержания сертификатов, сохранения артефактов. В качестве базы был освоен Jenkins. От него используем:
* [slave-плагин](https://wiki.jenkins-ci.org/display/JENKINS/SSH+Slaves+plugin) и теги/лейблы на узлах — в нашем распоряжении 10 Mac Mini;
* Git-плагин;
* хранение артефактов;
* [BuildFlow-плагин](https://wiki.jenkins-ci.org/display/JENKINS/Build+Flow+Plugin) для создания цепочек и параллельных задач (устарел и не поддерживается — знаем, но пока к нему жестко привязаны);
* [изменение названия](https://wiki.jenkins-ci.org/display/JENKINS/Build+Name+Setter+Plugin) запущенных Job’ов на более привязанные к задаче.
Все Job’ы — это последовательность sh-скриптов, которые выполняются после клонирования нашего репозитория. И в большинстве случаев sh-скрипт в Job’е просто вызывает Rake-таск. Все остальные операции — запуск xcodebuild, scan-build, модули проверок проекта и исходников, системы UI-тестов, обработку результатов — мы реализуем сами в рамках ruby-скриптов.
На CI-платформе можно выделить два типа задач:
* сборки;
* проверки и тесты.
### Сборки
Сборка и проверки/тесты не зависят друг от друга, после успешной сборки приложение и задача сразу попадают к команде QA для ручной проверки конкретных новых кейсов. На каждом этапе по пути к релизу выходят сборки:
* тестовая сборка конкретной задачи; другими словами — сборка feature branch’a;
* текущая альфа с основной ветки проекта в Gerrit;
* бета;
* релиз.
Полностью автоматически работают только первые два этапа, так как они выпускаются в HockeyApp, где это можно делать сколько угодно раз. Бета и релиз — события более редкие и требующие большей внимательности, поэтому запускаются вручную при необходимости.
#### Тестовая сборка — этап 1
Когда изменение успешно проходит Code Review, готовится тестовая сборка: версия с изменениями, которые еще не влиты в основную ветку. Успешно собранное приложение сразу загружается в HockeyApp под отдельным идентификатором тестовых сборок.
Ссылки на версию в HockeyApp крепятся к задаче в Jira. Если сборка закончилась успешно, задача переводится в состояние Ready For Test; если неудачно — в состояние Open для дальнейшей доработки и исправления ошибок.
Команда QA проверяет сборку на соответствие поставленной задаче на разных девайсах и версиях iOS. Если изменения всех устраивают и к этому моменту уже прошли автоматизированные проверки, Code Review и ревью дизайна, то нажатие Pass в Jira сразу вольет изменение в основную ветку, тем самым запуская второй этап.
#### Альфа-версия — этап 2
Когда изменение вливается в основную ветку проекта, мы должны выпустить альфа-версию приложения. Триггер этой сборки — хук в Gerrit *change-merged*. Сразу после мержинга изменения запускается Job сборки текущей альфа-версии приложения.
На этом Job’е установлена задержка — 10 минут, которая нужна на случай мержа нескольких зависимых (или независимых) задач. Так как весь Job занимает в среднем 11—12 минут, то проще дождаться мержинга нескольких задач, чем тратить время на каждую в отдельности. Собранная альфа-версия включит в себя все изменения с момента последней удачно собранной версии.
После успешного завершения свежая версия приложения загружается в HockeyApp. Задача в Jira считается закрытой именно тогда — как только она становится доступна в альфа-версии приложения. Поэтому после публикации в HockeyApp все вошедшие в версию задачи закрываются. Для этого мы обращаемся к API Jira. В них также остается комментарий со ссылками на Job в Jenkins и само приложение в HockeyApp.
Неудача при сборке на этапе 2 маловероятна. Если такое происходит, то чаще всего из-за длительных отказов API HockeyApp или Jira. Это редкость, но...
С этим нет никаких проблем, так как следующее влитое изменение запустит этот же Job, который захватит и предыдущие изменения.
#### Бета-версия — этап 3
Третий этап — бета. Отдельный Job на Jenkins, ему требуется только название ветки, с которой будет собрана бета-версия. Запускается сборка вручную: хотя бета и запланирована с точностью до дня, она не имеет конкретного времени/периода запуска или триггера.
Результат сборки автоматически попадает в HockeyApp и становится доступен команде QA. Тут же запускается Job для релизной версии с той же ветки, сборка загружается в TestFlight и выдается во внутреннее и внешнее тестирование.
#### Релиз — этап 4
Четвертый этап — релиз. Закаленная бета-испытаниями сборка, уже загруженная в iTunesConnect и TestFlight на третьем этапе, выдается в релиз.
#### Сборка приложений
Сборки выполняются напрямую xcodebuild’ом. Каждый этап обложен отдельной конфигурацией и аргументами. Например, в самом начале мы полностью отключаем Link-Time Optimizations, чтобы сэкономить время до выхода задачи в тестирование. Также на первом этапе в приложении доступен функционал, активируемый в compile-time, который помогает отслеживать и отлаживать проблемы, а также облегчает QA-команде некоторые задачи:
* пересоздание базы данных;
* удаление cookie;
* отправка debug-level логов и базы на отдельный ящик;
* дополнительные визуальные элементы, показывающие состояние некоторых параметров, которые мы используем (например, отображение качества соединения);
* возможность специально закрешить приложение;
* проверка вызова заданных методов заданных классов на главном потоке.
#### Подпись приложения и provisioning profile
На данный момент при автоматизированной сборке мы жестко задаем используемый сертификат и provisioning profile. Перед сборкой проходимся по доступным на узле профилям, выбираем нужный именно под текущую сборку и выставляем в настройках проекта через переменные окружения. Этот шаг, конечно же, выполняется скриптами автоматически.
На то были свои причины. Мы стараемся переходить на новые major-версии XCode, как только они появляются, и на одной из бета-версий XCode 7.0 наткнулись на баг в xcodebuild: он не позволял стабильно использовать автоматическое определение provisioning profile. Поэтому мы реализовали на том же Ruby модуль, который находит среди всех доступных профайлов нужные по Bundle Id, а затем добавили в проект на место профайлов env-переменные. В них при сборке кладем идентификаторы профайлов.
На XCode 7.0 это не доставляло никаких неудобств. Профайл все так же подставлялся автоматически средой разработки, если env-переменная была пуста. Но с XCode 8.0 и новым режимом Automatic Signing наш метод работать не мог. При Automatic Signing среда автоматически подставляет и в debug-, и в release-версии development-сертификаты и, соответственно, профайлы. Если жестко задавать на release-версию distribution-сертификат, то xcodebuild отказывается работать.
То есть предполагается, что при создании xcarchive всегда выходит версия, подписанная на development. А затем следует второй этап — экспортирование IPA, для него теперь можно задать конфигурацию через -exportOptionsPlist и в соответствии с ней переподписать приложение под нужный distribution. Нас такие правила исходно не устроили, поэтому мы отключили режим Automatic Signing и до сих пор подставляем профайлы вручную. Конфигурация выглядит следующим образом:
#### Проблемы
У xcodebuild есть ограничение, которое нам обойти не удалось: без ущерба для длительности выполнения нельзя запускать больше одного процесса. Мы играли различными env-переменным и путями к кешу и данным, но безрезультатно. Где-то он все же упирается в разделяемые ресурсы.
При одновременных сборках сильно заметна поочередная работа каждого процесса. Итоговая длительность при двух параллельных xcodebuild увеличивается почти в два раза. Поэтому мы устанавливаем по одному executor’у на каждый слейв Jenkins’а. Это позволяет исключить помехи двух задач без дополнительных плагинов, которые далеко не всегда адекватно работают в Jenkins. При этом все наши Job’ы по максимуму используют выделенный executor, особого смысла запускать несколько задач параллельно нет, они будут только мешать друг другу.
### Проверки и тесты
Для проверок и тестов есть соответствующие Rake-задачи — на каждую проверку отдельная. Конкретнее о цели и реализации проверок далее, а пока — высокоуровневое описание работы.
В Jenkins используется плагин [BuildFlow](https://wiki.jenkins-ci.org/display/JENKINS/Build+Flow+Plugin), который позволяет запускать параллельные задачи, объединять их, создавать цепочки и т. д. Любые автоматизированные проверки и тесты идут в рамках BuildFlow-задачи. В полном варианте параллельно запускаются:
* проверки проекта и исходников — локализации строк, использование категорий, заголовки UI-тестов, включенность исходников в таргеты;
* статический анализ кодa;
* Unit-тесты;
* UI-тесты.
Первые три задачи выполняются в один Jenkins Job, но система UI-тестов слегка сложнее, чем запуск тестов через xcodebuild. Это отдельная цепочка, ее первый шаг — prebuild — заключается в следующем:
* сборка тестового приложения;
* распределение UI-тестов на группы для параллельного выполнения;
* упаковка сборки в архив.
Затем на основе результатов распределения BuildFlow запускает необходимое количество задач в Jenkins, у каждой — своя группа тестов. Каждый Job получает UI-тесты, конфигурацию, сборку и скрипты из артефактов Prebuild Job’а в виде одного архива. После BuildFlow приступает к следующей задаче, суть которой — создать итоговый общий отчет и выполнить оповещения в Jira, HipChat, Gerrit. За результатами работы каждого из путей эта задача обращается в артефакты. BuildFlow конфигурируется, любой из путей можно при необходимости выключить.
UI-тесты
--------
### Каким должен быть фреймворк
Мы считаем, что фреймворку для UI-тестирования нужны:
1. Элементарный синтаксис, с которым способен справиться не только iOS-разработчик и программист.
2. Возможность переиспользовать свои наработки. При написании UI-теста команды таргетируются при помощи accessibility-идентификаторов (чаще всего). В идеале мы хотим построить поверх стандартно доступных команд собственную библиотеку. Это позволит нам отказаться от дублирования элементарного кода, а также облегчить себе задачу при небольших исправлениях в коде приложения. Изменился идентификатор? Никаких Find and Replace: идем в прослойку и меняем там один идентификатор.
MonkeyTalk (на данный момент [куплен](https://www.oracle.com/corporate/acquisitions/cloudmonkey/index.html) компанией Oracle, дальнейший его путь пока неизвестен) подошел по нашим критериям и значительно обогнал остальных претендентов. Он обладает собственным элементарным синтаксисом, простым, который позволяет выносить общие фрагменты тестов в отдельные скрипты и переиспользовать их. Чтобы написать тест на этом языке, можно вообще не разбираться в программировании, нужно только выяснить Accessibility Identifier — извлечь его утилитой вроде [Reveal](https://revealapp.com/), Accessibility Inspector или [Flex](https://github.com/Flipboard/FLEX), а в крайнем случае узнать у разработчика.
Итоговый скрипт почти полностью повторяет тест-кейс, описанный командой QA. При этом MonkeyTalk поддерживает JavaScript. Тут простор действий позволяет реализовать ту самую прослойку поверх стандартных команд и идентификаторов элементов. Постепенно было создано что-то очень похожее на [Page Object](https://martinfowler.com/bliki/PageObject.html). Каждый экран, диалог и элемент приложения со временем получил собственный модуль в JavaScript, что значительно ускорило разработку UI-тестов.
При этом доступны все преимущества программирования (циклы, условия, функции), хоть мы и против этого. Тест должен быть простым, прямолинейным, и пусть получится слегка многословно. Если тест падает, иногда приходится обращаться к скрипту, и нужна возможность ясно и точно сказать, что не прошла проверка названия письма после удаления через Edit-режим. А сделать это при наличии цикла по режимам с тремя условными разделениями по командам и парой лямбд в аргументах может быть весьма сложно и крайне неприятно. Однако в некоторых тестах мы все же используем (но в меру) циклы, что действительно здорово сокращает длину скрипта теста.
У MonkeyTalk есть еще одно крупное преимущество, которое очень пригодилось в дальнейшем при оптимизации и ускорении выполнения сильно увеличившейся базы UI-тестов.
### Модификации MonkeyTalk
MonkeyTalk не зависит от XCTest. Благодаря этой ключевой особенности нам удалось реализовать распределенную систему выполнения UI-тестов. Другие фреймворки ([KIF](https://github.com/kif-framework/KIF), [EarlGrey](https://github.com/google/EarlGrey), да и официальный XCUITest) запускаются через xcodebuild. С XCUITest все совсем тяжело. Если обратить внимание на процессы, работающие при выполнении тестов, то можно заметить **testmanagerd**. Он полностью занят одним текущим тестированием. Если запустить параллельно еще одну сессию, то именно из-за testmanagerd ничего не выйдет: тесты даже не стартуют.
KIF и EarlGrey работают на базе XCTest. Когда мы только стали думать о параллельном запуске в рамках одного узла, наработок было не так много. Начинал развиваться [FBSimulatorControl](https://github.com/facebook/FBSimulatorControl), только потом появился [pxctest](https://github.com/plu/pxctest). Собственные попытки ни к чему более-менее юзабельному не привели. Вариант с MonkeyTalk был проще и доступнее.
MonkeyTalk никак не зависит ни от XCTest, ни от XCUITest. Он имеет отдельную систему запуска и выполнения теста. В приложение встраивается агент с http-сервером. На стороне скриптов используется runner, который парсит скрипт UI-теста, отправляет команды по заданному адресу и ожидает ответа с результатом выполнения команды.
В итоге нам необходимо только запустить на симуляторе приложение, дождаться запуска, после чего запустить runner и обработать результаты.
Со временем и очередными обновлениями iOS мы столкнулись с некоторыми сложностями, для их решения модифицировали MonkeyTalk под себя и реализовали:
* «честную» работу с клавиатурой;
* «честные» тапы и жесты на уровне эвентов UIApplication;
* дополнительные команды для контролируемого вызова хелперов;
* полноценные проверки видимости элементов.
Также мы переписали взаимодействие с некоторыми элементами UIKit и часть сетевого взаимодействия, значительно ускорив весь фреймворк.
UI-тесты должны работать как можно ближе к реальным условиям и сохранять принципы черного ящика. Тапы и жесты в реальных условиях выполняются рукой пользователя. Самое близкое, чего мы можем достичь при автоматизации, — это имитация нажатий на уровне событий в приложении. Исходно MonkeyTalk напрямую отправлял сообщения UIControl’ам и UIGestureRecognizer’ам, что нас совсем не устраивало, а порой просто не давало возможности покрыть кейс.
Также мы можем контролировать все сетевое взаимодействие через скрипт теста, включая/отключая стабы, в том числе при запуске приложения; об этом чуть позже. Дополнительное преимущество — абсолютно аналогичный процесс для реального девайса, если вдруг мы решим на них перейти.
### Управление UI-тестами через скрипты
Так как у MonkeyTalk особый способ запуска, пришлось реализовать дополнительные управляющие скрипты. Их задачи:
* определять набор тестов для запуска;
* управлять симулятором;
* запускать UI-тесты;
* обрабатывать результаты.
Для самого скрипта UI-теста мы ввели заголовок, о котором детально поговорим далее. Сейчас стоит указать, что именно в заголовке задается тип девайса и версия iOS, на которой тест должен выполняться. Если задано несколько аргументов, то будет взято декартово произведение. Также есть возможность передавать в приложение различные аргументы для настройки приложения перед началом тестирования.
Все это достаточно просто реализовать, но UI-тестирование — процесс длительный, а наша цель — проверять каждое изменение в проекте.
### Масштабирование — параллельный запуск
#### Первая версия
Исходно наша самописная система выполнения UI-тестов отличалась низкой утилизацией ресурсов. Мы разбивали 70 тестов по папкам. Каждая папка соответствовала категории UI-теста (например, авторизация). При запуске папки распределялись на доступные нам Mac Mini. На каждом из них одновременно работал только один симулятор, который перезапускался и полностью затирался под новый UI-тест. Очевидные недостатки:
* Mac Mini с i5 и 16 Гб ОЗУ утилизирует в среднем 0 % ресурсов;
* распределение по папкам-категориям неравномерно, тестов по поиску оказалось значительно меньше, чем тестов на написание письма;
* количество тестов росло, а выполнялись они все так же медленно, на CI образовывались нешуточные очереди, а без успешного прохождения тестов мержить задачу нельзя.
Затем, слегка расширив базу тестов, покрыв самое необходимое и базовое, мы начали искать способы максимально утилизировать ресурсы. И нашли.
#### Текущая версия
Если коротко, то мы научились запускать и контролировать несколько симуляторов на одной машине и реализовали систему распределения тестов по группам машин. Теперь в системе две точки гибкого распределения тестов по доступным узлам:
1. Пул симуляторов в рамках узла, размер которого варьируется исходя из мощности узла.
2. Распределение тестов на группы/партишены с учетом размера пула симуляторов каждого узла, средней длительности выполнения теста, очередей и занятости узлов.
**Пул симуляторов на каждом узле**
Из-за пула симуляторов и параллельного запуска нескольких экземпляров приложения HTTP-серверы от MonkeyTalk должны слушать на разных портах. Исходно такого функционала в MonkeyTalk не было, поэтому мы его добавили. Порт конфигурируется при запуске приложения через environment variable или launch argument.
Мы можем полностью утилизировать мощность каждого узла, увеличивая пул хоть до обморочного состояния слейва. На новых узлах с i7, 16 Гб ОЗУ и SSD обычно ставим четыре-пять симуляторов. Но есть и старые узлы, на которых стабильно держится не больше двух симуляторов. В итоге все слейвы делятся на группы по размеру пула. Они отмечаются, помимо env-переменных, отдельными лейблами. И именно на эти группы узлов по размерам пулов распределяются UI-тесты.
Все данные для распределения получаются от Jenkins через API. Размер пула выставляет в env-переменной каждого узла. Можно взять очередь задач, отфильтровать ее, выяснить, на какой пул рассчитывает каждая задача. Занятость узла также запросто проверяется через API.
Другое дело — статистика по времени выполнения тестов. Чтобы избежать дополнительной точки отказа в системе, мы исключили дополнительные сервисы. Как я уже упоминал ранее, во время тестов мы пишем достаточно много полезных данных, в том числе для самой системы выполнения. В данном случае полезны тайминги выполнения, которые в итоге сохраняются в артефактах Jenkins. Далее нужно скриптом для поиска и извлечения таймингов из артефактов:
1. Найти все артефакты определенных задач.
2. Выбрать json с таймингами.
3. Загрузить данные.
4. Извлечь из них нужное и преобразовать в нужные статистики.
В результате получаем большой json со статистикой по всем UI-тестам. В том числе рассчитана средняя продолжительность UI-теста на случай, если для выполняемого теста нет статистики. Файл хранится в репозитории и периодически обновляется при изменениях UI-тестов. В итоге алгоритм распределения и группировки отрабатывает так:
1. Найти в репозитории все тесты по заданным тегам.
2. Взять статистику из json для каждого теста, хранящегося в репозитории.
3. Найти все подключенные (включая занятые) слейвы и получить их размеры пулов.
4. Создать хеш — «размер пула» => «счетчик», где счетчик равен количеству живых узлов пула.
5. Получить очередь партишенов UI-тестов в Jenkins и необходимый им пул, уменьшить счетчики.
6. Проверить занятость узлов, уменьшить соответствующие счетчики пулов.
7. Далее создать партишены с учетом имеющейся информации.
Группы UI-тестов формируются в два шага:
1. Выделение узлов из доступных.
2. Заполнение групп в соответствии с выделенными узлами.
Узлы выделяются по счетчикам. Например, прогоняем все UI-тесты на семи узлах. Ориентируемся на счетчики пулов, которые сформировались ранее. В цикле семь раз берем пул с максимальным счетчиком, уменьшая его на один. Так мы учитываем количество узлов по размеру пула, очередь и их занятость.
Далее выделенные партишены заполняем UI-тестами максимально равномерно с учетом размера пула. Проходимся по всем тестам, добавляя каждый в наименее заполненный партишен. В итоге получаем большой конфиг с информацией, необходимой для запуска и выполнения партишенов:
* лейблы, соответствующие размеру пула, т. е. таргетинг на конкретную группу узлов;
* идентификаторы тестов со сведениями о том, в каком партишене они выполняются;
* статистическое время выполнения каждого партишена.
Вместо огромного json намного приятнее смотреть логи, в которые мы пишем все для последующей отладки и проверки:
```
INFO IOSMail::UITestsGrouper : Getting all available tests...
INFO IOSMail::UITestsGrouper : Found 506 available tests. Took 0.8894939422607422 secs.
INFO IOSMail::UITestsGrouper : Reading stats json from ./ui-tests/uitests_stats.json...
INFO IOSMail::UITestsGrouper : Gluing available tests and stats...
WARN IOSMail::UITestsGrouper : No statistics for ScrollToFirstLetterInListFromMiddle.mt_iPhone5s. Using mean tests time.
INFO IOSMail::UITestsGrouper : Statistical total duration = 33603.8670472377
INFO IOSMail::UITestsGrouper : Computing capacities counters...
INFO IOSMail::UITestsGrouper : Capacities counters received and computed. Took 3.4377992153167725 secs.
INFO IOSMail::UITestsGrouper : Partitioning for 7 parts...
INFO IOSMail::UITestsGrouper : Allocated partitions = [{:capacity=>4, :label=>"4sim", :tests=>[]}, {:capacity=>4, :label=>"4sim", :tests=>[]}, {:capacity=>5, :label=>"5sim", :tests=>[]}, {:capacity=>4, :label=>"4sim", :tests=>[]}, {:capacity=>5, :label=>"5sim", :tests=>[]}, {:capacity=>3, :label=>"3sim", :tests=>[]}, {:capacity=>4, :label=>"4sim", :tests=>[]}]
INFO IOSMail::UITestsGrouper : Partitions constructed, took 0.039823055267333984 secs.
INFO IOSMail::UITestsGrouper : Partitions sizes = [72, 70, 87, 73, 83, 46, 75]
INFO IOSMail::UITestsGrouper : Partitions durations = [1157.0547642111776, 1160.5415018200872, 1157.1358834599146, 1159.2893925905228, 1158.044078969956, 1161.813697735469, 1158.7458768486974]
```
Выше показано разбиение всех доступных тестов на семь групп. Вся операция обычно занимает не больше 4—5 секунд, но может зависеть от API Jenkins. Итоговые длительности партишенов учитывают только время выполнения самих UI-тестов, без времени оркестрации симуляторами. Статистика по действиям с симуляторами у нас тоже есть, но мы ее пока не используем.
Итоговые длительности групп отличаются между собой менее чем на среднюю длительность UI-теста. Размеры групп значительно отличаются. На мощные узлы с четырьмя симуляторами попадет группа с сотней тестов, а на слабый узел — группа с 40 тестами. При этом выполняться они будут одно и то же время. На практике эти подсчеты подтверждаются, разница в выполнении групп может достигать 5 минут, но, на наш взгляд, это не критично. Бывают и случаи, когда нужно запустить один тег, в котором всего 10—15 UI-тестов. Раздавать их семи машинам крайне расточительно. Поэтому мы добавили оптимизацию: если после распределения появляется группа тестов длительностью меньше 10 минут, мы уменьшаем количество групп на одну и распределяем заново.
### Изоляция запусков
Взаимная изоляция отдельных UI-тестов для нас критична. Каждый тест стартует на абсолютно чистом свежем приложении и проходит один и тот же путь авторизации. За время жизни нашей системы UI-тестирования было реализовано два подхода к решению этой задачи.
### Каждому по симулятору!
Тесты выполняются изолированно, под каждый тест создается отдельный новый симулятор. На ruby мы реализовали wrapper для simctl — стандартной утилиты в xcode для взаимодействия с iOS-симуляторами. В итоге для каждого теста выполнялась *приблизительно* такая последовательность действий:
```
simulator = Simulators::MRSimulator.new(test_name, type, runtime)
simulator.launch
simulator.prepare(app)
simulator.install_app(app)
If access_allowed
simulator.enable_access(app)
else
simulator.disable_access(app)
end
simulator.run_app(app, arguments, env)
# запускаем MonkeyTalk runner
simulator.shutdown
# собираем артефакты (логи, креш-логи, тайминги, скриншоты, видео)
simulator.destroy
```
Из-за проблем, связанных именно с simctl, пришлось реализовать собственные механизмы ожидания завершения таких действий, как запуск симулятора, установка и запуск приложения. Механизмы по бо́льшей части основаны на чтении syslog’а симулятора и ожидании определенных событий. Это позволило нам здорово стабилизировать запуск и функционирование пула симуляторов. Но со временем мы уткнулись в проблемы непосредственно с запуском симуляторов — он отнимал много времени и иногда безосновательно отказывал.
### Общак симуляторов
Время выполнения группы тестов заметно сокращается, если переиспользовать симуляторы. Под этим подразумевается следующий жизненный цикл:
1. Запуск.
2. Подготовка к тесту.
3. Запуск приложения под тест.
4. Выполнение теста.
5. Очистка симулятора без выключения — приложение, keychain, контейнеры приложения, настройки доступа к фото и контактам (TCC).
6. Если есть тест, которому требуется симулятор такого же типа и версии, — вернуться к пункту 2.
Таким образом удается избежать достаточно длительной операции запуска симулятора, стабильность которой в целом не очень высока. По нашей статистике, она занимала в среднем 20 секунд. Напомню, в предыдущей версии на каждый тест создавался и запускался новый чистый симулятор.
Ключом к переиспользованию симуляторов стала возможность чистить keychain. Находить data- и appgroup-контейнеры мы могли и до этого. Стирать их после удаления самого приложения не составляло труда. Но найти keychain было сложнее. Нам приглянулся файл keychain-2-debug.db. Разобраться в содержимом файла не особо получилось, но никто не мешает стереть содержимое какой-нибудь таблицы и проверить, к чему это приведет. Так мы и чистим keychain:
```
def clear_keychain
`sqlite3 ~/Library/Developer/CoreSimulator/Devices/#{@id}/data/Library/Keychains/keychain-2-debug.db "delete from genp;"`
end
```
Нельзя с полной уверенностью сказать, делаем ли мы это верно (скорее нет, чем да), но текущие манипуляции точно приводят к инвалидации keychain — и дальше все адекватно функционирует.
### Обходы проблем xcode, simulator и т. д.
#### Cтабильность взаимодействия с iOS-симуляторами оставляет желать лучшего
iOS-симулятор в единственном экземпляре работает вполне стабильно, но и при этом бывают ошибки. Если же создавать, запускать, стирать и выключать множество симуляторов, хоть и удаляя их за собой, то непременно возникнут ограничения и неустойчивое поведение. Например, при внедрении пула симуляторов мы столкнулись с тем, что не удается запустить больше семи-восьми симуляторов в системе. Они начинают валиться с крешами в самых разных местах. Также рантайм iOS-симулятора определенной версии иногда просто отказывается работать, ссылаясь на ошибку при dlopen, до полного ребута системы. Самое противное в такой проблеме — автоматически достаточно сложно определить ее, отключить узел от Jenkins и отправить в ребут до того, как часть выполняющего прогона зафейлится. Эта сложность стала появляться значительно реже при введении системы переиспользования симуляторов. Получается, блокировка и баги в рантайме как-то связаны с постоянным созданием и запуском чистых симуляторов.
#### Пул симуляторов и нагрузка
С внедрением пула симуляторов ресурсы на узлах стали использоваться более полно, в связи с чем возникли сложности. При долгом запуске приложения из-за, например, высокой активности на диске его автоматически убивал watchdog от springboard. Стандартное время на запуск — приблизительно 20 секунд. С этой проблемой мы справились достаточно быстро, заглянув в исходники [FBSimulatorControl](https://github.com/facebook/FBSimulatorControl) от Facebook. Оказалось, что в preferences для springboard при выключенном состоянии симулятора можно добавить словарь, который содержит новые тайм-ауты для заданных Bundle Id. Мы пытались заставить этот метод заработать даже без выключения симулятора, просто убивая и перезапуская springboard, preferences ведь его, верно? Но без толку — симулятор должен быть выключен.
Еще одна проблема — долгий первый запуск самого симулятора. При этом в системе бешеный File IO. Если посмотреть на достаточно долго работающий узел CI, то можно наблюдать сотни гигабайт данных, записанных и считанных процессами launchd, kernel\_task и сервисом CoreSimulator. Все это связано с созданием и запуском новых симуляторов. У проблемы до определенного момента не было решения. С появлением XCode 8.0 запуск новых симуляторов совсем вышел из-под контроля, очень часто происходили тайм-ауты, запуск иногда с трудом умещался в 160 секунд. Тогда мы решили слегка изменить концепцию и переиспользовать симуляторы по схеме, описанной выше.
### Асинхронный simctl без признаков завершения действия
Еще один неприятный аспект утилиты simctl, которая поставляется вместе с XCode, — это ее асинхронность. Запросив запуск приложения, утилита вернет управление практически мгновенно, но приложение еще даже не отобразит launch screen. Оно может вообще не запуститься (см. выше — ситуация с watchdog). Таких примеров с simctl много, поэтому мы надстроили свой контроль на чтении syslog’а симулятора. Ожидая определенных событий в логе, мы убеждаемся, что:
* симулятор создан;
* симулятор успешно стартовал;
* приложение установлено;
* приложение запущено.
#### Системные диалоги в приложении
С системными диалогами в приложении все сложно. MonkeyTalk работает в рамках процесса, а из него взаимодействовать с внешними диалогами нельзя. В приложении требуется тестировать доступ к контактам и к фото. Данную проблему мы решаем при помощи модификации sqlite базы TCC.db, об этом детальнее далее.
### Доступ к фото и контактам
Как упоминалось выше, если фреймворк тестирования работает на уровне процесса приложения, то обязательно возникнут трудности с диалогами на доступ к контактам и фото. Нажать на них не будет возможности. Решить проблему нажатия нам не удалось, но мы нашли способ тестировать два итоговых состояния этого диалога.
В заголовках тестов мы добавляем дополнительное поле, означающее необходимость состояния доступа к фото/контактам. Перед запуском приложения модифицируем sqlite базу TCC.db, выставляя для соответствующего доступа нужное значение:
```
def self.setup_access(simulator_id, app, disabled, simulator_set_path: "#{ENV['HOME']}/Library/Developer/CoreSimulator/Devices")
tcc_path = File.join(simulator_set_path, "#{simulator_id}/data/Library/TCC/TCC.db")
Utilities::FileMonitoring.wait_for_file_creation(tcc_path, :max_wait => 30) {
raise Simulators::Errors::SimulatorTimeoutError.new("Timed out while waiting for TCC!")
}
rights = disabled ? '0' : '1'
['kTCCServiceAddressBook', 'kTCCServicePhotos', 'kTCCServiceCalendar'].each do |access_target|
`sqlite3 #{tcc_path} "replace into access(service, client, client_type, allowed, prompt_count) values ('#{access_target}','#{app.bundle_id}',0,#{rights},1)" 2>&1`
end
end
```
### Подмена ответов сервера
Для UI-тестов используются настоящие почтовые аккаунты. Один тест может одновременно выполняться в нескольких прогонах на CI для разных задач, при этом, естественно, иногда проверяются действия, модифицирующие ящик. От полной симуляции бэкенда прямо в приложении мы отказались в силу необходимости поддержки всех изменений реального бэкенда. Вместо этого в приложении реализован URLProtocol, который есть только в тестовой сборке. Для этого URLProtocol’а можно реализовывать и добавлять FakeResponse. Из скрипта UI-теста эти FakeResponse можно включать, чтобы имитировать результат модификации данных. Так мы стабим все модифицирующее сетевое взаимодействие приложения с сервером на уровне взаимодействия с сетью. Это дает возможность сохранить состояние ящиков и запросто покрыть следующие кейсы:
* медленная сеть;
* специфические ошибки и ответы бэкенда;
* полное отсутствие сети.
### Репортинг
Помимо интеграции Jira с Hipchat наша система UI-тестов также выполняет задачи репортинга. Мы, конечно же, не смотрим результаты в логах Jenkins Job’а. В итоге мы получаем HTML-отчет на каждый UI-тест, UI-сьют, попытку их выполнения, тег UI-тестов и общий отчет. Для дальнейшей разработки системы запуска тестов и для анализа непройденного теста мы сохраняем (помимо результата UI-теста — успех/неудача/креш) множество полезных данных:
* системный лог симулятора;
* текстовый лог UI-теста;
* HTML-лог и XML-лог UI-теста;
* data-контейнер приложения;
* appgroup-контейнер приложения;
* скриншоты;
* креш-лог, если есть;
* тайминги выполнения теста и действий с симулятором.
Сама система запуска UI-тестов тоже пишет в отдельный лог в debug-режиме. Помимо HTML-представления отчетов есть json-отчеты, которые необходимы для работы распределенной системы, ведь вся эта информация разбросана по N узлам. Итоговый отчет формируется в отдельном Job’е на основе json-отчетов узлов-исполнителей со ссылками на каждый тест, сьют, повтор и артефакты.
После генерации HTML-отчетов они сохраняются в артефактах Jenkins, а затем в Jira создается комментарий с результатами следующего вида:
Помимо Jira, если во время проверок возникали ошибки, оповещение будет отправлено в HipChat:
Пример HTML-отчета о конкретном успешно выполненном тесте:
### Генерация документации
Все тесты имеют обязательный заголовок — коммент-блок, содержащий следующие ключи:
* таск на создание UI-теста;
* название;
* описание;
* теги;
* модель девайса;
* runtime;
* опциональные ключи с дополнительными аргументами.
На основе этих заголовков мы собираем HTML-каталог всех тестов. В группе проверок проекта и исходников реализован модуль для проверки заголовков всех UI-тестов. Этот скрипт запускается для каждой задачи в рамках проверки на CI-платформе.
### Итоговые характеристики системы
Самый длительный путь в BuildFlow — UI-тесты. Немного статистики об этом пути на момент написания статьи:
* всего UI-тестов — 506;
* суммарная продолжительность всех UI-тестов без распределения — 9 часов 20 минут;
* длительность всех UI-тестов при распределении на семь партишенов с пулами симуляторов на узлах — 45—50 минут;
* средняя продолжительность UI-теста — 66 секунд;
* самый долгий UI-тест — 397 секунд.
Дополнительное время на этом пути занимает Prebuild, он длится 5—6 минут, в зависимости от узла и занятости Gerrit. То есть в среднем наша система выполнения тестов на пустом CI управляется с 506 UI-тестами примерно за 55 минут.
### Недостатки
У системы есть очевидные недостатки, о которых мы вспоминаем с релизами новых версий XCode. С каждой версией мы полностью перепроверяем работоспособность и надеемся, что ничего не перестанет работать. Многое из вышеописанного — пляски вокруг недокументированного функционала:
* доработки MonkeyTalk вызваны тем, что он просто перестал функционировать на iOS 8.0;
* стабильность работы с simctl обеспечивается только логами springboard и системных процессов симулятора, что уже приходилось патчить с выходом очередного XCode (логи меняются);
* симулятор и многие компоненты XCode могут быть вообще не рассчитаны на такое использование, иногда значительно меняется производительность, как случилось с выходом XCode 8.0, тогда мы реализовали переиспользование.
Если все же что-то меняется, то всегда можно найти за что зацепиться и вернуть все в работоспособное состояние. Преимущества системы стоят того.
### Преимущества
* 9,33 часа UI-тестов примерно за 60 минут;
* стабильный запуск на каждое изменение в проекте (как известно, чем раньше заметили, тем дешевле исправить);
* симулятор — гибкий девайс. На всем CI мы имеем 50 симуляторов — и, соответственно, 50 айфонов и 50 айпадов разных моделей и версий iOS.
Стоит также упомянуть, что в систему заложены точки расширения, что позволяет нам:
* создавать новые реализации оркестрации симулятором, и необязательно симулятором: вполне можно сделать реализацию на реальном девайсе;
* вписывать в систему запуск тестов на другом фреймворке для UI-тестирования, но ключевым фактором должна быть независимость от XCUITest;
* заменив фреймворк, сохранять возможность запускать старые UI-тесты в группе с новыми, несмотря на разные подсистемы запуска.
Проверки проекта
----------------
### Same Targets
Некоторый функционал alpha-версии приложения зачастую не должен попасть в релизную версию. Например, контроль вызовов на главном потоке или трекинг и логирование запросов без вырезания важных данных в файл, который можно достать через iTunes.
С точки зрения проекта у нас есть три таргета: Alpha, Beta и AppStore. Код только для Alpha должен быть включен лишь в таргет Alpha-версии. И такие моменты хочется контролировать, чтобы когда-нибудь в будущем по чистой случайности такой код не попал в релиз. Данный модуль проверяет именно этот фактор. При создании класса для конкретной версии (альфа, бета или релиз) разработчик вносит его в специальный файл конфигурации, помечая эксклюзивным для версии. На CI с этого момента всегда будет проверяться его принадлежность к различным таргетам. Если что-то не так, то задачу влить нельзя. Здесь также есть и защита от самого разработчика. Если он забыл добавить новый класс в конфигурацию, то исходно предполагается, что файл должен быть во всех версиях. И если по факту он будет включен только в Alpha-версию, то возникнет конфликт. Файл конфигурации представляет собой json. Приведу его фрагмент для наглядности:
```
{
"compare-sets": [
{
"targets": ["MRMail-Alpha-Enterprise", "MRMail-Pub-Beta-Enterprise", "MRMail-AppStore", "MRMail-MonkeyTalk"],
"exclusive": {
"MRMail-Alpha-Enterprise": [
"^pod-packages/Reveal-iOS-SDK/",
"^src/infrastructure/MainThreadGuard/UIKitThreadGuard\\.m$",
```
В этом модуле мы работаем с файлом проекта, для его парсинга используем библиотеку [xcodeproj](https://github.com/CocoaPods/Xcodeproj), которая здорово облегчает задачу.
### Локализация
Для строк и локализации реализована проверка, покрывающая весь проект. Мы хотим, чтобы каждая строка явно помечалась как локализируемая или нелокализируемая. В этом модуле выполняется проход по всем исходникам в поисках строковых литералов, мы проверяем, чтобы они были обернуты в один из двух макросов:
* NL (Not Localized): строка остается как есть;
* L (Localized): строка — это ключ, по которому нужно получить локализованную строку.
Такая проверка встроена как Build Phase, т. е. проблему можно отловить даже на этапе отладки. Если же кто-то халатно отправил такой код в ревью, а затем и на CI, то сборка попросту не выполнится, а задача перейдет в состояние Open.
### Категории
С категориями и таргетами у Xcode есть заметная проблема — категория, не включенная в таргет, при использовании из этого таргета успешно компилируется и линкуется, несмотря на то что выполнение окончится крешем. По неизвестной причине во время компиляции и линковки этот факт остается без предупреждения/ошибки. Наше приложение содержит пять таргетов:
* основное приложение;
* action extension;
* share extension;
* today extension;
* shared framework.
У нас есть категории для классов, которые содержатся отдельно в основном приложении, отдельно в экстеншенах и отдельно в общем фреймворке. Порой перестановки или доработки неявно приводят к вызову метода категории, не включенному в текущий таргет, например к вызову из экстеншена в категорию основного приложения. Есть правила для именования категорий, по ним можно ориентироваться, но в данном случае нет никаких жестких проверок, *человеческий фактор никак не покрыт*. Специально для этого мы реализовали собственную проверку — модуль на Ruby, который:
* пробегается по файлам имплементации в проекте;
* проверяет каждый import категории на наличие файла реализации в том же таргете, в котором этот import найден.
Если его нет — ошибка, будет креш. Здесь сразу видны несколько исключений:
* Protected/Private-расширения — нужно проверять включенность файла реализации основного класса;
* категории сторонних библиотек — нужно проверять включенность библиотеки.
Для этих случаев у нас есть файл исключений, в котором можно их описать. Реализованы они как элементарные правила. Если по базовому правилу — имплементация категории — результат неудовлетворительный, то смотрим файл исключений, находим проверяемую категорию, берем указанное правило и его аргументы. Далее фрагмент файла конфигурации для проверки включенности категорий:
```
{
"rules": [
{
"name": "GeneralExternalImplementation",
"type": "ExternalImplCheck",
"imports": {
"AccountEnvironmentImpl+Protected.h": "AccountEnvironmentImpl.m",
…….
```
В данном фрагменте представлено следующее правило — для использования в таргете расширения AccountEnvironmentImpl+Protected.h нужно иметь в этом же таргете AccountEnvironmentImpl.m.
Проверка включенности категорий в таргеты входит в набор стандартных проверок проекта и исходников на нашей CI-платформе и обычно занимает не больше двух минут.
При реализации этого модуля опять же используем библиотеку [xcodeproj](https://github.com/CocoaPods/Xcodeproj).
### Заголовки тестов
Как было описано выше, для UI-тестов у нас есть специальная система документирования — заголовки определенного формата. Проверка обязательных атрибутов этих заголовков также обязательна и входит в набор стандартных проверок проекта и исходников. Каждый реализованный UI-тест должен иметь:
* Jira-задачу;
* название;
* описание (чтобы можно было разобраться, зачем тест нужен и что он покрывает, не заглядывая в код);
* теги/категории (хотя бы одну).
Вот пример заголовка UI-теста:
```
# tasks: IOSMAIL-6020
# name: Перенаправление письма
# category: Compose
# description: Открываем письмо, нажимаем на «многоточие» в тулбаре, перенаправляем его, проверяем, что оно успешно
# отправлено.
```
### Репортинг
Так как все проверки не занимают много времени, мы отводим для них один Jenkins Job, не распараллеливаем на несколько машин, а последовательно выполняем несколько Rake-тасков. Поэтому каждый модуль такой проверки удовлетворяет определенному интерфейсу, который на выходе дает результат и ошибку, если она есть.
Так как информации немного, отдельного HTML-отчета на каждую проверку нет, достаточно встроить эти сведения в итоговый отчет BuildFlow. Выглядит это следующим образом:
Статический анализ кода
-----------------------
### scan-build
Для статического анализа кода используется [scan-build](http://clang-analyzer.llvm.org/scan-build.html) + xcodebuild. Примечательно тут вот что: при сборке мы специально отключаем ассерты. В противном случае scan-build обращает на них внимание и не обрабатывает некоторые кейсы. В релизной версии ассерты отключены, соответственно, в релиз уходит код, кейсы работы которого могут быть не проанализированы и потенциально содержат ошибки. Это и есть основная причина отключения ассертов при статическом анализе — проверка всех кейсов работы кода.
Отчет scan-build, как и остальные задачи, встроен в итоговый HTML-отчет.
### fbinfer
Недавно мы встроили в CI анализ кода при помощи утилиты [infer](https://github.com/facebook/infer). Основная проблема — длительность выполнения. На нашем проекте при чистой сборке весь процесс занимает в среднем 1 час 10 минут. Это объясняется спецификой работы анализатора. Во время компиляции он собирает нужную информацию, чтобы выполнить трансляцию в собственный язык. Трансляция занимает бо́льшую часть времени. Такая длительность никак не вписывается в CI-процесс, который должен быть запущен на каждое изменение, поэтому анализ выполняется отдельно раз в сутки, а ответственному приходит письмо с найденными багами.
В целом получилось так, что этот анализатор не вписался в CI, а стал отдельной сторонней профилактической проверкой, потому что мы вливаем изменения с потенциальными багами и только потом их правим. Но пока что практика показывает — то, что находит infer после scan-build, не приводит к проблемам.
Профайлинг и тайминги запуска
-----------------------------
Скорость запуска приложения критически важна. Мы [много работали над оптимизацией старта](https://habrahabr.ru/company/mailru/blog/307778/) и, чтобы поддерживать достигнутый результат, настроили постоянное профилирование.
После каждого мержа и выхода alpha-версии приложения автоматически запускается Downstream Job, чтобы собрать тайминги скорости запуска приложения.
Этот Job взаимодействует с реальным девайсом, который всегда работает и доступен.
На девайсе выполняется 250 запусков приложения со снятием таймингов. Затем тайминги сохраняются в InfluxDB, после чего визуализируются в Grafana. Таким образом, мы замечаем, если приложение начинает работать медленнее, и знаем, из-за какого изменения это предположительно произошло: каждый тайминг привязан к конкретной сборке, в которую входят известные изменения (обычно одно, но бывает больше).
### Unit-тесты
С Unit-тестами все достаточно просто — xcodebuild + [xcpretty](https://github.com/supermarin/xcpretty). HTML-отчет xcpretty, как и остальные отчеты, попадает ссылкой в итоговый отчет и сохраняется в артефактах. Unit-тесты — один из параллельных путей нашего BuildFlow. Всего на момент написания статьи у нас был 1451 Unit-тест, тесты выполняются в среднем за 10—11 минут.
### HipChat и репортинг
#### Репорт о новых задачах
Стандартная интеграция Jira + HipChat. За счет этой интеграции мы следим, как меняются состояния задач в проекте, в том числе мы видим создание новых задач и появление багов.
#### Репорт о результатах сборки, тестов, проверок
Репортинг — с давних времен нетронутая часть нашей CI-системы. На данный момент выполняется только итоговый репортинг. Это достаточно непросто с учетом распределенности задач. Надо:
* найти и загрузить отчет каждой задачи;
* найти и собрать исходные конфигурации;
* сопоставить и склеить результаты;
* отрендерить HTML-отчеты;
* нотифицировать в Jira, Gerrit и HipChat.
У нас есть определенный взгляд на то, куда стремиться. Сейчас полный прогон изменения на CI — Unit-, UI-тесты, статический анализ, проверки проекта — занимает около 55—60 минут без учета очереди.
За час ошибка может произойти в любой момент, в том числе в самом начале, на одном из первых тестов/проверок. Но разработчик не узнает о ней, если не будет следить за живыми логами. Чего он, конечно, не делает (и не обязан): *логи для тех, кто разрабатывает и отлаживает CI, клиент системы должен видеть только итоговые отчеты и оповещения*. Поэтому дальше мы собираемся реализовать Continuous Reporting, чтобы во время прогона держать разработчика в курсе. Чтобы, если ошибки найдутся уже в первые пять минут, можно было начать их исправлять, получив личное оповещение с конкретным описанием и отчетом.
Заключение/выводы
-----------------
Мы стараемся проверять самые разные аспекты разработки. Помимо классической автоматизации тестирования и сборки мы реализовали и внедрили в процесс собственные проверки:
* специфичные для сферы iOS-разработки, например включение используемых категорий в таргеты проекта;
* специфичные для процесса разработки именно нашей команды, например same targets.
Этот комплекс проверок позволяет если не исключить человеческий фактор, то заметно его смягчить, а также иногда выявляет баги в, казалось бы, несвязанных частях. Автоматизация, в свою очередь, сократила длительность ручных проверок, уменьшив интервалы между релизами, и облегчила ручной труд. Тем более что можно выполнять проверки после каждого изменения и обнаруживать проблемы значительно раньше.
Даже если после бо́льшей части запусков проблем не обнаруживается, система все равно окупит себя, выявив баг в неочевидном месте. К тому же успешный прогон дает определенную уверенность в каждом изменении в проекте.
 | https://habr.com/ru/post/325552/ | null | ru | null |
# PostgreSQL Antipatterns: статистика всему голова
Для выбора наиболее эффективного плана выполнения запроса [PostgreSQL пользуется накопленной статистикой](https://postgrespro.ru/docs/postgresql/12/planner-stats) о распределении значений данных в целевых таблицах.
Она обновляется с помощью явного запуска команд **ANALYZE** и **VACUUM ANALYZE** или в фоновом режиме процессом *autovacuum/autoanalyze*. Но если статистика не успеет актуализироваться — может произойти беда.
Как такую проблему обнаружить и исправить?
Основной вариант, когда такая ситуация вообще может произойти, — если в таблице резко изменился набор данных. То есть по ней *прогнали большое количество INSERT/UPDATE/DELETE или просто «влили» данные* в пустую таблицу — например, **при восстановлении из резервной копии**.
В справке по штатной [утилите восстановления pg\_restore](https://postgrespro.ru/docs/postgresql/12/app-pgrestore) даже явно сказано:
> После восстановления имеет смысл запустить ANALYZE для каждой восстановленной таблицы, чтобы оптимизатор получил актуальную статистику.
>
>
Поэтому если вы делаете с базой что-то похожее — не поленитесь, сразу прогоните [ANALYZE](https://postgrespro.ru/docs/postgresql/12/sql-analyze) по наиболее «жирным» таблицам или по всей базе целиком.
### Определяем наличие проблемы
Как выглядит ситуация «все плохо» именно из-за этого? Обычно примерно вот так:
В столбце **ratio** как раз показывается отношение «в разах» между планировавшимся на основании статистики и фактически прочитанным количеством записей:
```
Bitmap Heap Scan on ... (... rows=14831 ...) (actual ... rows=9 ...)
```
**Чем больше это значение — тем хуже** статистика отражает реальное положение дел в вашей таблице. В норме обычно оно *не превышает сотни*, в этом примере — *полторы тысячи раз*.
Приводит это к выбору неэффективного плана и, как следствие, дичайшей нагрузке на базу. Чтобы ее оперативно убрать, достаточно все-таки прислушаться к рекомендациям мануала и пройти **ANALYZE** по основным таблицам.
Вот так выглядит загрузка CPU на сервере базы до и после этой операции для примера выше:
### Часто обновляемая таблица
Но что делать, если в таблице действительно меняется большое количество записей? Например, это какой-нибудь буфер или очередь обработки, куда постоянно добавляются новые записи и удаляются старые.
В этом случае нам помогут следующие [конфигурационные параметры](https://postgrespro.ru/docs/postgresql/12/runtime-config-autovacuum):
> **autovacuum\_naptime** (integer)
>
> Задаёт минимальную задержку между двумя запусками автоочистки для отдельной базы данных. Демон автоочистки проверяет базу данных через заданный интервал времени и выдаёт команды VACUUM и ANALYZE, когда это требуется для таблиц этой базы. Если это значение задаётся без единиц измерения, оно считается заданным в секундах. По умолчанию задержка равна одной минуте (1min). Этот параметр можно задать только в postgresql.conf или в командной строке при запуске сервера.
>
>
>
> **autovacuum\_analyze\_threshold** (integer)
>
> Задаёт минимальное число добавленных, изменённых или удалённых кортежей, при котором будет выполняться ANALYZE для отдельно взятой таблицы. Значение по умолчанию — 50 кортежей. Этот параметр можно задать только в postgresql.conf или в командной строке при запуске сервера. Однако данное значение можно переопределить для избранных таблиц, изменив их параметры хранения.
>
>
>
> **autovacuum\_analyze\_scale\_factor** (floating point)
>
> Задаёт процент от размера таблицы, который будет добавляться к autovacuum\_analyze\_threshold при выборе порога срабатывания команды ANALYZE. Значение по умолчанию — 0.1 (10% от размера таблицы). Задать этот параметр можно только в postgresql.conf или в командной строке при запуске сервера. Однако данное значение можно переопределить для избранных таблиц, изменив их параметры хранения.
### ССЗБ
Иногда при настройке сервера *autovacuum\_naptime* «удавливают» до «раз в сутки» (1d), **чтобы autoVACUUM'ы ходили по базе пореже** и ресурсов ели поменьше.
Иногда, хоть и очень редко, это даже бывает оправдано — например, если у вас в одной БД находятся *тысячи таблиц/секций* (даже, если они разложены по разным схемам).
Потому что само определение, какие конкретно таблицы из всего перечня надо обработать, при инициализации autovacuum-процесса **может занимать солидную долю ресурсов и подтормаживать сервер**.
Как раз в этом случае вас и будут ждать проблемы с часто изменяемой таблицей.
Тут — или все-таки выставлять более адекватный интервал запуска, или гонять ANALYZE по такой таблице в «ручном» режиме по каким-то прикладным соображениям (например, по внешнему таймеру или после окончания очередного этапа обработки очереди).
*Товарищ, бди актуальность статистики!* | https://habr.com/ru/post/479656/ | null | ru | null |
# Очистка заражённых файлов сайта от вредоносного кода
Добрый день, уважаемые Хабраюзеры!
Некоторое время назад, около месяца, на сервере нашей компании появился вирус. На одном из крупных проектов были поражены все \*.js файлы. Ситуация обычная — в конец файлов был дописан вредоносный код. Яндекс выдавал предупреждение о заражении сайта и в техотдел пришло задание очистить его. Ситуация разрешилась достаточно быстро, проект был выгружен с чистого репозитория в продакшн, пароли сменили.
Однако вскоре со всех отделов компании в техотдел стали поступать жалобы о заражённых сайтах. Менеджерам жаловались клиенты, сеошники трубили что сайты теряют позиции. Началась настоящая эпидемия. Помимо \*.js файлов, заражению подверглись так же \*.php файлы, в конец которых был дописан код:
```
echo 'http://somedomain.com/style.js';
```
Такому масштабному заражению сервер был подвержен впервые. Мысли по этому поводу были разные, вплоть до бэкдора какого-нибудь недовольного уволенного сотрудника, решившего напакостить. Однако это не подтвердилось. Был написал shell скрипт очищающий \*.php файлы, а с \*.js файлами справлялись по-прежнему, выгрузкой из чистого репозитория. Пароли учётных записей доступов к сайтам, доступы к фтп — всё было изменено. Перевели всех кто работает с фтп на WinSCP и раздали файлы-ключи доступа.
Сервер потихоньку стал «выздоравливать» а сайты возвращаться в яндекс. Однако кроме более сотни сайтов клиентов на нашем сервере, есть клиенты использующие сторонние хостинги. Доступ по фтп, никакой командной строки и shell. Практически на всех сайтах используется самописная CMS (написанная N-ое количество лет назад) в связке с fckeditor'om или старыми версиями ckeditor'ов. В файл менеджере ckfinder'e проверка авторизованности реализована простым return true; Используй нехочу. Стоит также упомянуть что Множество заражённых \*.js файлов выгрузкой чистого репозитория не излечить. Git на таких сайтах нами не используется, а большая часть бэкапов на хостингах хранится максимум 7 дней. А в виду того что сайты расположенные на сторонних хостингах, нами практически не мониторятся, все бэкапы так же были заражены.
В каждый файл вирус добавлял произвольное количество собственных копий, от одной до пяти (мне больше не встречалось) и все они имели различные имена переменных, имена функций и зацепиться за них было невозможно. Единственной неизменной частью кода каждого полиморфа являлся следующий участок кода:
```
=Array.prototype.slice.call(arguments).join(""),
```
Он и был выбран для поиска вхождений по файлам. Были проверены Jquery библиотеки 1.6.3 и 1.7.2 и в исходном коде совпадений не было обнаружено. Значит последовательность можно было использовать.
Чтобы не возиться вручную с несколькими десятками \*.js файлов на каждом сайте, было решено написать скрипт на php. Он должен сканировать все указанные ему файлы на предмет искомой строки. Для расширения кругозора, так сказать, было решено не использовать exec(), system() команды или, к примеру, библиотеку phpseclib. Алгоритм прост до безобразия: Скрипт сканирует все директории начиная от заданной, в поисках указанной строки в файлах поиска. Перед внесением изменений, скрипт бэкапит файл (ну всё же мало ли чего) и удаляет строку, в которой присутствует искомая подстрока. Построчная работа была выбрана в виду того, что вирус в файл записывался в одну строку.
Приведу пример кода вируса в \*.js файле: [pastebin.com/J0zRduQw](http://pastebin.com/J0zRduQw)
Разбирать его я не стал, кому интересно — в интернете много примеров разбора обфусцированного кода. Поэтому перейду сразу к коду сканера.
```
/*
----------------------------------------------------------------------------------
dScaner Class - START
----------------------------------------------------------------------------------
*/
/*
*
* Класс - dScaner для сканирования директорий на наличие вредоносного кода в
* указанных типах файлов
*
* Разработчик: Денис Ушаков
* Дата разработки: 03-04-2012
* Версия разработки: 0.0.3
*
*/
Class dScaner {
// преобразуем входной параметр в массив
// $get_str - список параметров
// $separator - разделитель параметров в списке
function request($get_str, $separator)
{
if (isset($get_str) && !empty($get_str))
{
// эксплоадим строку в массив и возвращаем его
$obj = explode($separator, $get_str);
return $obj;
}
else
{
return false;
}
}
/*
*
* Функция поиска в файлах вхождения заданной строки:
*
* $this-find($path, $files_allowed, $requested_string);
*
* $path - путь до директории, от которой отталкиваться при сканировании
* $files_allowed - список файлов, которые подвергаются сканированию
* $requested_string - строка поиска
*
*/
function find($path = './', $files_allowed, $requested_string)
{
// исключаемые ссылки на директории и файлы, которые будут игнорироваться
$dir_disallow = array('.', '..', '.htaccess', '.git');
if(is_dir($path))
{
$temp = opendir($path);
while (false !== ($dir = readdir($temp)))
{
if ((is_dir($path . $dir)) &&
(!in_array($dir, $dir_disallow)) )
{
// если директория - сканируем её
$sub_dir = $path . $dir . '/';
$this->find($sub_dir, $files_allowed, $requested_string);
}
elseif ((is_file($path . $dir)) &&
(!in_array($dir, $dir_disallow)) &&
(strpos($dir, $files_allowed) == true) &&
(strpos($dir, '_BACKUP') == false) )
{
// Если файл
// получаем полный путь до него
$in_dir_file = $path . $dir;
// считываем файл в строку
$temporary_file = file_get_contents($in_dir_file);
// флаг найденного вхождения искомой строки
$file_founded = false;
// разбиваем файл на строки
$tf_strings = explode("\n", $temporary_file);
// обрабатываем каждую отдельно
foreach ($tf_strings AS $item)
{
$item = strval($item);
// если в строке есть вхождения искомого запроса
if (strpos($item, $requested_string) !== false)
{
$file_founded = true;
}
}
// если в файле найдена строка
if ($file_founded)
{
// выводим путь до файла в котором найдено вхождение
print "" . $in\_dir\_file . " - в файле обнаружена искомая строка.
";
}
}
}
closedir($temp);
}
}
/*
*
* Функция сканирования вредоносного кода:
*
* $this->scan($path, $files_allowed, $requested_string);
*
* $path - путь до директории, от которой отталкиваться при сканировании
* $files_allowed - список файлов, которые подвергаются сканированию
* $requested_string - строка, по которой определяется наличие вредоносного кода
*
*/
function scan($path = './', $files_allowed, $requested_string)
{
// исключаемые ссылки на директории и файлы
$dir_disallow = array('.', '..', '.htaccess', '.git');
if(is_dir($path))
{
$temp = opendir($path);
while (false !== ($dir = readdir($temp)))
{
if ((is_dir($path . $dir)) &&
(!in_array($dir, $dir_disallow)) )
{
// если директория - сканируем её
$sub_dir = $path . $dir . '/';
$new_parent_dir = $path . $dir;
$this->scan($sub_dir, $files_allowed, $requested_string, $new_parent_dir);
}
elseif ((is_file($path . $dir)) &&
(!in_array($dir, $dir_disallow)) &&
(strpos($dir, $files_allowed) == true) &&
(strpos($dir, '_BACKUP') == false) )
{
// Если файл
// получаем полный путь до него
$in_dir_file = $path . $dir;
// считываем файл в строку
$temporary_file = file_get_contents($in_dir_file);
// флаг бекапа файла
$create_backup = false;
// разбиваем файл на строки и считываем каждую отдельно
$tf_strings = explode("\n", $temporary_file);
// индекс строки файла
$str_index = 0;
// каждую строку обрабатываем отдельно
foreach ($tf_strings AS $item)
{
$item = strval($item);
if (strpos($item, $requested_string) !== false)
{
// если в строке есть вхождения искомого запроса
// флаг бекапа файла, в котором найден вредоносный код
$create_backup = true;
// удаляем всю строку с вредоносным кодом
unset($tf_strings[$str_index]);
}
$str_index++;
}
// создаём бэкап
if ($create_backup)
{
// меняем права в папке в которой находимся чтобы иметь возможность писать в неё
chmod($path, 0777);
// формируем имя БЭКАПа файла
$temp_file_backup = $in_dir_file.'_BACKUP';
// сохраняем БЭКАП файла рядом с исходным
file_put_contents($temp_file_backup, $temporary_file);
// собираем очищенный файл в строку
$scanned_file = implode("\n", $tf_strings);
// сохраняем очищенный файл
if (file_put_contents($in_dir_file, $scanned_file))
{
// перезаписали удачно
print "" . $in\_dir\_file . " - Файл очищен. (+ BACKUP)
";
}
else
{
// перезапись не удалась
print "".$in\_dir\_file ." - Файл НЕ очищен.
";
}
// меняем права в папке в которой находимся обратно на 755
chmod($path, 0755);
}
}
}
closedir($temp);
}
}
/*
*
* Функция восстановления БЭКАПОВ файлов
*
* $this->restore_backups($path, $files_allowed);
*
* $path - путь до директории, от которой отталкиваться при восстановлении
* $files_allowed - список файлов, которые подвергаются восстановлению
*
*/
function restore_backups($path = './', $files_allowed)
{
// исключаемые ссылки на директории и файлы
$dir_disallow = array('.', '..', '.htaccess', '.git');
if(is_dir($path))
{
$temp = opendir($path);
while (false !== ($dir = readdir($temp)))
{
if ((is_dir($path . $dir)) &&
(!in_array($dir, $dir_disallow)) )
{
// если директория - сканируем её
$sub_dir = $path . $dir . '/';
$this->restore_backups($sub_dir, $files_allowed);
}
elseif ((is_file($path . $dir)) &&
(!in_array($dir, $dir_disallow)) &&
(strpos($dir, $files_allowed) == true) )
{
// Если файл
// получаем полный путь до него
$in_dir_file = $path . $dir;
if (is_file($in_dir_file.'_BACKUP'))
{
// БЭКАП существует, получаем его содержимое
$temporary_file_from_backup = file_get_contents($in_dir_file.'_BACKUP');
// восстанавливаем бэкап файла
if (file_put_contents($in_dir_file, $temporary_file_from_backup))
{
// удаляем бэкап
unlink($_SERVER['DOCUMENT_ROOT'].'/'.$in_dir_file.'_BACKUP');
// бэкап восстановили
print "".$in\_dir\_file ." - восстановлен.
";
}
else
{
// бэкап НЕ восстановили
print "".$in\_dir\_file ." - НЕ восстановлен.
";
}
}
}
}
closedir($temp);
}
}
}
/*
----------------------------------------------------------------------------------
dScaner Class - END
----------------------------------------------------------------------------------
*/
?>
``` | https://habr.com/ru/post/141710/ | null | ru | null |
# Гид по предварительной обработке текста с помощью BERT
Современные NLP-приложения, например, для [анализа настроения](https://analyticsindiamag.com/guide-to-build-a-simple-sentiment-analyzer-using-tensorflow-hub/), поиска [ответов на вопросы](https://analyticsindiamag.com/guide-to-question-answer-retrieval-with-multilingual-universal-sentence-encoder/), смарт-ассистенты и т. п., используют огромное количество данных. Такой объём данных можно напрямую передать в модель машинного обучения. Почти все текстовые приложения требуют большой предварительной обработки, например, создания векторного представления слов с нуля с помощью счётчика частоты слов. На это уходит много сил и времени. Чтобы этого избежать, для всех сложных задач предварительной обработки используются модели Transfer Learning. Им нужно просто передать необработанный текст, об остальном модель позаботится сама.
> Небольшая ремарка. Данный материал является переводом, и мы не несем ответственности за факты, представленные автором в первоисточнике.
>
> Ключевая тенденция рынка чат-ботов — это работа над эффективностью в определении намерений пользователя. Для себя мы поставили данную задачу во главе узла: нам критически важно сделать продукт удобным и практичным именно для разработчиков. Поэтому мы сейчас думаем о том, чтобы внедрить BERT в нашу работу. Технология для нас новая, мы читаем и переводим очень много информации по данному вопросу. Наиболее интересными материалами мы поделимся с вами в рамках данного блога.
>
>
В [этой статье](https://analyticsindiamag.com/a-guide-to-text-preprocessing-using-bert/) мы обсудим один из фреймворков трансферного обучения — BERT. Рассмотрим, как использовать модуль предварительной обработки BERT, чтобы создавать векторное представление слов без усилий. Основные моменты, которые будут рассмотрены в этой статье:
1. Стандартная процедура предварительной обработки текста
2. Что такое BERT?
3. Как работает BERT?
4. Модель предварительной обработки
Начнём.
**Стандартная процедура предварительной обработки текста**
Метод, известный как предварительная обработка текста, используется для очистки текстовых данных перед их передачей в Machine Learning. Текстовые данные содержат различный «шум» — например, эмодзи, знаки препинания, чередование строчных и прописных символов. Это только начало трудностей, с которыми мы столкнемся. Машины не понимают слов, им нужны числа, поэтому нужно найти быстрый и эффективный способ преобразования текста в числа.
Стандартная процедура предварительной обработки утомительна, она ориентирована на пользователя. Следующие шаги выполняются с использованием стандартных методов предварительной обработки:
• преобразование в нижний регистр
• удаление знаков препинания
• удаление стоп-слов
• токенизация корпуса
• стемминг и лемматизация
• векторное представление слов с использованием CountVectorizer и TF-IDF
Подробно с примерами эти шаги рассмотрены в статьях: [Полное руководство по предварительной обработке текста в NLP](https://analyticsindiamag.com/complete-tutorial-on-text-preprocessing-in-nlp/) и [Как идентифицировать сущности в NLP?](https://analyticsindiamag.com/how-to-identify-entities-in-nlp/)
Обычно в любых ситуациях, связанных с NLP, мы следуем этому процессу. Однако он не гарантирует результата, если необработанные данные изменятся хоть немного. Это значит, что если данные взяты с веб-страницы, потребуются дополнительные операции по удалению HTML-тегов. Теперь все этапы предварительной обработки можно выполнять с помощью модулей Transfer Learning, таких как BERT.
**Что такое BERT?**
BERT — это аббревиатура от Bidirectional Encoder Representations from Transformers. Для предварительной подготовки глубоких двунаправленных представлений из немаркированного текста, система задаёт условия для контекста как для левой, так и для правой части предложения. В результате предварительно обученную BERT можно настроить добавлением всего одного дополнительного выходного слоя, чтобы создать новейшие модели для разнообразных задач NLP.
BERT была предварительно обучена работе с огромным корпусом немаркированного текста, включая всю Википедию, которая насчитывает 2500 миллионов слов, а также различным BookCorpus, которые содержат более 800 миллионов слов. Половину успеха BERT можно отнести к этой предварительной фазе обучения. Когда модель обучается на большом текстовом корпусе, она начинает улавливать тончайшие нюансы языка. Такая информация может быть применена к широкому спектру задач NLP.
BERT — достаточно двунаправленная модель. Двунаправленность доказывает изучение информации из левой и правой частей контекста токена во время фазы обучения. Двунаправленность модели важна для полного понимания значения языка.
**Как работает BERT**
Чтобы узнать contextual relationships между словами в тексте, BERT использует Transformer, Attentions mechanism. В оригинальной реализации Transformer имеется два механизма: кодировщик, принимающий вводимый текст, и декодер, который прогнозирует задачу. Требуется только механизм кодировщика, потому что целью BERT является построение языковой модели.
Кодировщик Transformer считывает сразу всю последовательность слов, в отличие от направленных версий, которые считывают вводимый текст последовательно. В результате он классифицируется как двунаправленный, в то время как фактическое условие не является направленным. Эта функция позволяет модели узнавать контекст слова в зависимости от его окружения.
Рисунок 1: BERT
В процессе обучения BERT пары предложений предоставляются в качестве входных данных для модели. Она учится предсказывать, будет ли второе предложение в паре следующим предложением в исходном документе. Половина входных данных во время обучения—- это пары, где второе предложение является следующим предложением в исходном документе, а другая половина — случайное предложение из корпуса. Основное предположение состоит в том, что вторая фраза не будет связана с первой.
Во время обучения, как показано выше, токен [CLS] вставляется в начало первого предложения, а токен [SEP] вводится в конце каждого предложения. Причем каждый токен содержит векторное представление предложения, обозначающее предложение A или предложение B. Векторное представление предложения похоже на представление токенов, но со словарём из двух слов. Наконец, каждому токену назначается PE (position embedding), соответствующее его месту в последовательности.
Рисунок 2: Предварительное обучение BERTПеред подачей последовательностей слов в BERT некоторая часть каждой последовательности заменяется токеном [MASK]. Затем модель пытается спрогнозировать исходное значение замаскированных слов, используя контекст, определяемый немаскированными фразами. Необходимо добавить слой классификации поверх выходных данных кодировщика, чтобы предсказать выходные слова. За этим следует умножение выходных векторов кодера на embedding matrix, преобразование их в словарное измерение и вычисление вероятности каждого слова в словаре с использованием softmax.
Функция потерь BERT учитывает только предсказания замаскированных значений и игнорирует предсказания немаскированных слов. Следовательно, модель сопоставляет данные медленнее, чем направленные модели. При обучении модели BERT, Masked LM (показанная на Рисунке 1) и Pre-training (показанное на Рисунке 2) обучаются совместно, чтобы минимизировать комбинированную функцию потерь этих двух методов.
**Модель предварительной обработки BERT**
На Tensorflow Hub доступно множество предварительно обученных моделей BERT: оригинальная [BERT](https://tfhub.dev/google/collections/bert/1), [ALBERT](https://tfhub.dev/google/collections/albert/1), [Electra](https://tfhub.dev/google/collections/electra/1) и [MuRIL](https://tfhub.dev/google/MuRIL/1). Кодировщик и API предварительной обработки доступны для всех вышеперечисленных моделей.
Для каждого кодировщика BERT существует модель предварительной обработки. Используя операторы TensorFlow из пакета TF.text, она преобразует необработанный текст в числовые входные тензоры, ожидаемые кодировщиком. В отличие от предварительной обработки на чистом Python, эти операции могут быть включены в модель TensorFlow для выполнения непосредственно из текстового ввода. Каждая модель предварительной обработки TF Hub поставляется с предварительно настроенным словарем и связанной с ним логикой нормализации текста и не требует дополнительной настройки.
**Пример использования BERT**
Реализуем несколько примеров предварительной обработки.
```
!pip3 install --quiet tensorflow-text
import tensorflow_hub as hub
import tensorflow_text as text
# load the pre-processing model
preprocess =
hub.load('https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/1')
#Use BERT pre-processing on a batch of raw text inputs.
embeddings = preprocess(['Blog writing is awesome.'])
```
Предварительно обработанный вывод из модуля получается, как показано выше, там, где маска ввода сообщает кодировщику, какая часть предложения важна, потому что здесь присутствует заполнение. Идентификатор типа ввода указывает модели, какая часть ввода соответствует первой и второй части предложения. Input\_word\_ids — это индексы, соответствующие каждому токену.
**Заключение**
В статье мы разобрали, что такое BERT и как он работает. Мы также увидели, насколько легко можно реализовать векторное представление слов с помощью модулей предварительной обработки BERT. Все традиционные этапы предварительной обработки включены в модули предварительной обработки BERT, что экономит много времени при построении модели на основе NLP.
> Чат-боты должны стать более эффективными в определении намерений пользователя. Технология BERT помогает в данном вопросе, расширяя возможности и ускоряя распространение чат-ботов.
>
> На основе выбранной технологии мы хотим построить рекомендательную систему, которая будет анализировать тексты имеющихся у нас данных пользователей и вакансий, анализировать их и делать метчинг. С помощью участия в проекте наших клиентов и партнеров мы хотим обучить ИИ делать это максимально корректно и точно. По завершению данного этапа мы подключим модель, основанную на технологии BERT, к нашему чат-боту и запустим новую функцию. Таким образом, у пользователей нашего сервиса появится альтернативный путь — вместо заполнения анкеты, они смогут просто подгрузить свое резюме и получать в соответствии с указанными там данными подходящие вакансии.
>
> Дмитрий Доброхотов, основатель сервиса по подбору IT-вакансий
>
> | https://habr.com/ru/post/579518/ | null | ru | null |
# Программируем Pololu 3pi на Ubuntu/Debian, для начинающих
Вы только что приобрели робота от Pololu и в качестве операционной системы используете Linux Ubuntu или Debian, тогда эта статья для вас. В первую очередь статья рассчитана на новичков, которые решили попробовать себя в робототехнике.
Начну с того, что доставили мне подобного робота, а точнее Pololu 3pi, и принялся я изучать что это за зверь такой. Из магазина в него была прошита демо-программа, с помощью которой можно было проверить все функции устройства. А умел он сверкать светодиодами, вращать двигателями, играть классическую мелодию через свою пищалку (Buzzer), выводить текст на двухстрочный дисплей по 8 символов в строчку и наконец распознавать под датчиками на нижней части устройства чёрные области (как пример, чёрные дорожки на белом фоне по которым можно двигаться).
После изучения функционала устройства возникла следующая мысль «А давайте-ка мы запишем в него свою программу». И тут встал следующий вопрос как это сделать на Linux Ubuntu. В этом вопросе очень помог официальный сайт [www.pololu.com](http://www.pololu.com), зарубежные форумы и изучение исходников скачиваемых библиотек.
Теперь вкратце расскажу как и что нужно сделать что бы записать свою программу в это устройство. Сразу уточню, что для программирования Pololu кроме самого устройства необходим специальный программатор с интерфейсом USB для подключения к компьютеру. Я использовал PGM03A — замечательный и недорогой программатор для микроконтроллеров построенных на базе AVR, в том числе и наш ATMega328P.
Писать программы мы будем на C, но можно писать и на С++, для этого необходимо использовать соответствующий компилятор и библиотеки. Для начала ставим компилятор, дополнительные библиотеки и утилиты с помощью «sudo apt-get install»:
gcc-avr — компилятор исходных кодов в машинный код контроллеров AVR, если вы пишете на C++ необходимо ставить соответствующие компилятор и библиотеки;
avr-libs — библиотеки AVR для языка С;
avra — ассемблер, необходим в составе AVR-GCC для получения ассемблерного кода;
binutils-avr — дополнительные утилиты для сборки программ;
avrdude — утилита для записи собранного бинарного hex-файла через программатор в контроллеры AVR.
Это все библиотеки которые необходимы для сборки и записи бинарных hex-файлов в контроллер AVR. Теперь необходимо собрать и записать в контроллер простейшую программу.
Для примера рассмотрим следующий код написанный на C, он будет циклично включать и отключать красный светодиод Pololu 3 pi. Пример был взят с официального сайта [www.pololu.com](http://www.pololu.com) и будет правильно работать только с микроконтроллером ATMega328P.
`#define F_CPU 20000000UL // Baby Orangutan frequency (20MHz)
#include
#include
void delayms( uint16_t millis ) {
while ( millis ) {
_delay_ms( 1 );
millis--;
}
}
int main( void ) {
DDRD |= 1 << DDD1; // set LED pin PD1 to output
while ( 1 ) {
PORTD &= ~( 1 << PORTD1 ); // LED off
delayms( 900 ); // delay 900 ms
PORTD |= 1 << PORTD1; // LED on
delayms( 100 ); // delay 100 ms
}
return 0;
}`
Этот фрагмент кода необходимо поместить в файл «BlinkLed.c». Расширение файла «\*.c» говорит о том, что перед нами исходный код программы написанный на языке С. Теперь компилируем файл в машинный код, для этого в консоли заходим в рабочую директории с файлом BlinkLed.c и выполняем следующую команду:
`$ avr-gcc -g -Wall -mcall-prologues -mmcu=atmega328p -Os -c -o BlinkLed.o BlinkLed.c`
И на выходе получаем файл BlinkLed.o с объектным кодом. Объектный код это исполняемый код с некоторыми вкраплениями дополнительной информации для линковщика, например, таблица символов. На этом шаге ваша программа уже собрана, осталось объединить её с другими объектными модулями линковщиком (если вы их используете) и собрать бинарный файл с расширением \*.hex, данные которого мы и будем писать в микропроцессор. В консоли нужно выполнить команды:
`$ avr-gcc -g -Wall -mcall-prologues -mmcu=atmega328p -Os BlinkLed.o -Wl,-gc-sections -lpololu_atmega328p -Wl,-relax -o BlinkLed.obj
$ avr-objcopy -R .eeprom -O ihex BlinkLed.obj BlinkLed.hex`
В директории появился файл BlinkLed.hex с командами для микроконтроллера ATMega328P, которые теперь необходимо в него прошить. Но прежде нужно узнать в какой девайс посылать команды. Для этого нам необходимо подключить к компьютеру программатор и найти новые устройства в директории /dev. В моём случае появилось 2 новых устройства: /dev/ttyACM0 и /dev/ttyACM1. Теперь подключаем к программатору микроконтроллер и выполняем команду для соответствующего устройства (устройство должно быть включено и заряда батарей должно хватить на время процесса прошивки):
`$ avrdude -c avrispv2 -p m328p -P /dev/ttyACM0 -e
Команда читает данные из контроллера.
avrdude: AVR device initialized and ready to accept instructions
Reading | |||||||||||||||||||||||||||||||||||||||||||||| | 100% 0.01s
avrdude: Device signature = 0x1e654f
avrdude: erasing chip
avrdude: safemode: Fuses OK
avrdude done. Thank you.`
Если Вы увидели ответ от устройства, то тест соединения фактически прошёл и теперь можно смело прошивать наши подготовленные инструкции. Выполняем в консоли:
`$ avrdude -p m328p -c avrisp2 -P /dev/ttyACM0 -U flash:w:BlinkLed.hex`
Через несколько секунд инструкции в устройство будут успешно прошиты, контроллер автоматически перезагружен и Вы увидите как Pololu 3pi активно подмигивает вам своим светодиодом. Для автоматизации процесса сборки приложения можно написать Makefile.
Мы научились прошивать микроконтроллер из исходного кода написанного на языке С, теперь для более комфортной работы с устройством необходимо подключить библиотеку Pololu, в которой уже реализованы низкоуровневые операции управления компонентами робота. Скачиваем последнюю версию библиотеки с официального сайта [www.pololu.com](http://www.pololu.com), на момент написания статьи библиотека доступна на странице [www.pololu.com/docs/0J20/3](http://www.pololu.com/docs/0J20/3).
`$ wget www.pololu.com/file/download/libpololu-avr-100607.zip?file_id=0J381`
Распаковываем:
`$ unzip libpololu-avr-yymmdd.zip, где «yymmdd» необходимо заменить на версию вашей библиотеки.`
Заходим в корневую директорию с распакованной библиотекой и выполняем команду «make» для сборки пакетов. После сборки осталось её поставить, но тут меня ожидала пара сюрпризов. Во-первых необходимо открыть файл «Makefile», найти 2 строчки:
`# LIB := /usr/lib/avr/lib
# INCLUDE_POLOLU := /usr/lib/avr/include`
И раскомментировать их, проверить существование директорий в вашей системе и при необходимости изменить. После этого можно выполнять команду «sudo make install» для установки библиотеки. При этом в «/usr/lib/avr/lib » должны скопироваться пакеты с расширением «\*.a» для различных версий микроконтроллеров и в «/usr/lib/avr/include» заголовочные файлы «popolu/\*.h» для подключения необходимого функционала библиотеки.
Тут меня ждал второй сюрприз, заголовочные файлы скопировались в директорию указанную в «NCLUDE\_POLOLU», то есть в «/usr/lib/avr/include», хотя поиск их ведётся в директории «/usr/lib/avr/include/pololu». Проблема решилась созданием директории «/usr/lib/avr/include/pololu» и повторным копированием в неё всех файлов «pololu/\*.h».
Напоследок напишем ещё одну маленькую программку для закрепления материала, с использованием библиотеки Pololu. Для этого в начале файла программы подключим библиотеку написав такую строчку "#include ". Ниже размещаю код с комментариями, который необходимо поместить в файл «MyRobot.c». Как видите кода получилось меньше, но функционала мы задействовали гораздо больше:
`#include // подключаем Pololu
#include // необходима для генератора случайных чисел
int main()
{
print("Hello :)"); // печатаем на дисплей
lcd\_goto\_xy(0,1); // переводим коретку на вторую строчку
int val;
while(1)
{
green\_led(0); // отключаем зелёный светодиод
red\_led(0); // отключаем красный светодиод
val = random()%3; // получаем случайное число из {0,1,2}
if(val == 0) {
green\_led(1); // включаем зелёный светодиод
red\_led(1); // включаем красный светодиод
}
delay\_ms(1000); //пауза 1 секунда
}
}`
Для автоматической сборки и прошивки программы мы создадим специальный файл Makefile в который необходимо поместить следующий текст, все отступы необходимо сохранить в виде 1 табуляции от начала строки:
```
DEVICE = atmega328p
AVRDUDE_DEVICE = m328p
CFLAGS=-g -Wall -mcall-prologues -mmcu=$(DEVICE) -Os
CC=avr-gcc
OBJ2HEX=avr-objcopy
LDFLAGS=-Wl,-gc-sections -lpololu_$(DEVICE) -Wl,-relax
PORT=/dev/ttyACM0
AVRDUDE=avrdude
TARGET=MyRobot
all: $(TARGET).hex
clean:
rm -f *.o *.hex *.obj *.hex
%.hex: %.obj
$(OBJ2HEX) -R .eeprom -O ihex $< $@
%.obj: %.o
$(CC) $(CFLAGS) $< $(LDFLAGS) -o $@
install: $(TARGET).hex
$(AVRDUDE) -p $(AVRDUDE_DEVICE) -c avrisp2 -P $(PORT) -U flash:w:$(TARGET).hex
```
Теперь для сборки программы достаточно набрать команду «make», а для прошивки её в устройство соответственно «make install».
Настало время пройтись по многочисленным примерам, которые вы найдёте в распакованных файлах библиотеки, и там же лежат уже компилированные hex файлы, если вдруг у вас возникнут проблемы с компилятором. В качестве IDE для написание исходного кода на С я использую NetBeans с установленым плагином C/C++.
Спасибо за внимание. Буду благодарен, если вы сообщите о неточностях и ошибках в статье. | https://habr.com/ru/post/103227/ | null | ru | null |
# Импорт координат из текстового файла в чертёж nanoCAD на классическом .NET API
Одним из наиболее популярных вопросов по программированию под nanoCAD является «Как мне импортировать точки из текстового файла?». Задача это несложная, но профессиональный проектировщик не обязан быть профессиональным программистом, поэтому эту статью мы написали в стиле «для начинающих».
Импортировать координаты в чертёж можно на любом из существующих в nanoCAD видов API. Мы решили выбрать .NET и сравнить два близких API: классический .NET API и кросс-САПР-платформенный MultiCAD.NET API. Под катом — первая часть — импорт точек на классическом .NET API.
**Дано:** текстовый файл с координатами X, Y, Z точек, одна точка на строке. Координаты разделены пробелом, разделитель дробной части — точка.
**Требуется:** написать приложение, которое по команде IMPORTCOORDS запрашивает имя файла и импортирует найденные координаты в текущее пространство чертёжа в виде объектов `DatabaseServices.DBPoint`. Координаты объектов должны импортироваться в текущей пользовательской системе координат (UCS) чертежа.
##### Создание и настройка рабочего проекта
Для создания приложения нам понадобятся следующие инструменты:
* nanoCAD (версия не ниже 3.5)
* Microsoft Visual Studio 2008 (nanoCAD 3.5 — nanoCAD 5.0 поддерживают загрузку .NET-приложений, построенных на .NET Framework 3.5).
Ну и, конечно же, подразумевается, что вы хотя бы немного умеете программировать на языке C#. Если нет — добро пожаловать в [библиотеку MSDN](http://msdn.microsoft.com/ru-ru/library/67ef8sbd.aspx).
Создаем новый проект в Visual Studio со следующими настройками:
* Project type: Visual C#
* Template: Class Library
Таким образом, наше приложение представляет собой обычную .NET-сборку (DLL), которая впоследствие будет загружена в nanoCAD.
Во вкладке References подключаем следующие библиотеки, входящие в состав комплекта nanoCAD:
* hostdbmgd.dll
* hostmgd.dll
Теперь можно смело переходить к написанию самой программы.
##### Структура программы
Реализацию можно разбить на следующие шаги:
1. Зарегистрировать команду IMPORTCOORDS.
2. Получить базу данных текущего чертежа и редактор командной строки.
3. Запросить имя файла с координатами.
4. Открыть файл, прочитать строки с координатами.
5. Создать объекты DBPoint с отдельными координатами. Преобразовать их координаты в текущую пользовательскую систему координат.
6. Добавить созданные объекты в текущее пространство чертежа (Model Space или Paper Space).
Для того, чтобы зарегистрировать команду, которая будет вызывать наше приложение в nanoCAD нужно перед определением метода, который будет вызываться по этой команде, объявить аттрибут `[CommandMethod]` и указать имя команды. Обратите внимание, метод должен иметь модификатор public:
```
[CommandMethod("IMPORTCOORDS")]
public void importCoords()
{
...
}
```
Прежде чем продолжить, хотелось бы остановиться и в двух словах рассказать, что же такое «база данных чертежа». .dwg-файл представляет собой базу данных, имеющую строгую структуру, основные элементы которой — таблицы (Symbol Tables), которые содержат все объекты чертежа. Это не только графические объекты, которые мы видим на чертеже (прямые, дуги, точки и тд.), но и множество других объектов, которые определяют содержимое и настройки чертежа. Например, таблица слоев (Layer Table) содержит в себе все слои, которые имеются на чертеже, таблица типов линий (Linetype Table) хранит все стили линий, определенные в чертеже, таблица пользовательских систем координат (UCS Table) — все системы координат, созданные пользователем для данного чертежа, и др. Таким образом, создать новый объект чертежа — значит создать соответствующий объект базы данных.
Итак, продолжаем. В первую очередь нам необходимо выбрать из всех открытых документов текущий и открыть его базу данных. Для этого мы получаем объект-менеджер всех открытых документов, и затем с его помощью и базу данных, с которой мы будем дальше работать.
```
DocumentCollection dm = Application.DocumentManager;
Database db = dm.MdiActiveDocument.Database;
```
Для того, чтобы наше приложение запрашивало имя файла, необходимо получить объект Editor и вызвать метод, который запрашивает пользовательский ввод определённого типа (в нашем случае имя файла):
```
// Получаем редактор командной строки
Editor ed = dm.MdiActiveDocument.Editor;
// Объект для получения результата запроса
PromptFileNameResult sourceFileName;
// Выводим запрос в командную строку и получаем результат
sourceFileName = ed.GetFileNameForOpen("\nEnter the name of the coordinates file to be imported:");
if (sourceFileName.Status == PromptStatus.OK)
{
...
}
```
Получить координаты из файла довольно просто, используя C#-функционал для чтения текстовых файлов и работы со строковыми типами данных:
```
// Читаем файл, получаем содержимое в виде массива строк
string[] lines = File.ReadAllLines(sourceFileName.StringResult);
// Для каждой строки записываем массив из подстрок, разделенных пробелом (т.к по условию задачи в качестве разделителя координат выступает символ пробела).
// Таким образом получаем массив из координат, только в текстовом виде, затем конвертируем их в числа типа double.
string[] coord;
foreach (string s in lines)
{
coord = s.Split(new char[] { ' ' });
double coordX = Convert.ToDouble(coord[0]);
double coordY = Convert.ToDouble(coord[1]);
double coordZ = Convert.ToDouble(coord[2]);
}
```
Переходим к созданию графических примитивов (Entity). Как уже отмечалось выше, для того, чтобы создать любой объект (не только графический), который будет храниться в чертеже, его необходимо добавить в базу данных чертежа, а именно в соответствующий объект-контейнер. Так, например, все слои хранятся как записи в таблице слоев (Layer Table), которая является в этом случае для них объектом-контейнером. Общая структура базы данных выглядит следующим образом:
Графические примитивы хранятся в базе не напрямую, а в структуре отдельных блоков, которые в свою очередь являются записями в таблице блоков (Block Table). Это очень удобно, поскольку такой механизм позволяет легко группировать объекты в именованные блоки и управлять ими, как единым целым. К слову, пространство модели и пространства листа в базе также представлены отдельными блоками. Таким образом, для графического примитива контейнером будет являться отдельный блок, который, в свою очередь, будет принадлежать родительскому объекту — таблице блоков.
Раз мы работаем с базой данных, то необходимо обеспечить ее целостность и защиту в случае, если во время выполнения программы произошла какая-то ошибка. Для этой цели применяется механизм транзакций. Транзакции объединяют в себе целый ряд операций, которые выполняются как единое целое: если что-то пошло не так, транзакция отменяется, и объекты, созданные в рамках этой транзакции не будут добавлены в документ. Если же все операции завершились успешно, то транзакция подтверждается, и объекты добавляются в базу.
Вооружившись этими знаниями, можем смело добавлять в текущее пространство чертежа примитивы «точка» по координатам, которые мы прочитали из файла.
```
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// Можно обойтись без таблицы блоков и получить блок текущего пространство чертежа прямо из объекта, представляющего базу данных
BlockTableRecord btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);
string[] lines = File.ReadAllLines(sourceFileName.StringResult);
string[] coord;
foreach (string s in lines)
{
coord = s.Split(new char[] { ' ' });
double coordX = Convert.ToDouble(coord[0]);
double coordY = Convert.ToDouble(coord[1]);
double coordZ = Convert.ToDouble(coord[2]);
DBPoint point = new DBPoint(new Point3d(coordX, coordY, coordZ));
btr.AppendEntity(point);
tr.AddNewlyCreatedDBObject(point, true);
}
btr.Dispose();
tr.Commit();
}
```
Задача практически решена. Осталось выполнить одно условие: примитивы-точки должны создаваться в координатах пользовательской системы координат (UCS). Необходимо отметить, что примитивы хранятся в базе данных чертежа в мировой системе координат (WCS). Следовательно, при создании примитивов необходимо выполнить преобразование: UCS->WCS. Делается это при помощи матрицы пользовательской системы координат:
```
Matrix3d ucsMatrix = ed.CurrentUserCoordinateSystem;
```
Добавим преобразование:
```
{
...
point.TransformBy(ucsMatrix.Inverse());
...
}
```
Итак, программа полностью написана. Что же дальше?
##### Загрузка приложения в nanoCAD
Осталась самая приятная часть — загрузить программу в nanoCAD и любоваться результатами своей работы. Как вы помните, мы создавали рабочий проект как библиотеку классов, поэтому после успешной компиляции будет построена сборка с именем вашего проекта. Открываем nanoCAD, в командной строке пишем команду NETLOAD, выбираем из списка построенную библиотеку и загружаем. Для запуска программы просто введите имя команды IMPORTCOORDS в командной строке.
##### Импорт координат. Версия 2.0
Усовершенствуем первую версию приложения, добавив несколько полезных функций и элементы пользовательского интерфейса.
Если первая версия приложения «понимала» текстовый файл, в котором координаты разделены только пробелами и в качестве десятичного разделителя использовалась точка, то теперь приложение сумеет «распознать» координаты, разделенные символом табуляции, пробелом или точкой с запятой. Что же касается десятичного разделителя, то в качестве него теперь может выступать как точка, так и запятая, импорт будет производиться без учета региональных настроек. По команде IMPORTCOORDS теперь будет открываться модальный диалог импорта координат, в котором пользователь может выбрать файл и указать желаемые настройки импорта координат.
Общий механизм импорта координат и создания примитивов остается практически без изменений, однако теперь это будет происходить в рамках класса формы, а задача метода-обработчика команды IMPORTCOORDS теперь сводится лишь к созданию объекта формы и выводу формы на экран в виде модального диалога:
```
[CommandMethod("IMPORTCOORDS")]
public void importCoords()
{
Form form = new ImportForm();
HostMgd.ApplicationServices.Application.ShowModalDialog(form);
}
```
После чего управление будет передано окну формы импорта координат.
##### Форма приложения
Форма для приложения включает в себя следующие элементы:
* Кнопка для открытия файла
* Диалог открытия файла
* Группа чекбоксов для выбора символов-разделителей координат: табуляция, пробел, точка с запятой
* Текстовое поле для предварительного просмотра разбора строк c координатами
* Кнопка для импорта координат
* Кнопка отмены
Используя эти элементы управления, пользователь теперь может указать желаемые символы-разделители, проверить результат в поле предварительного просмотра (примерно так, как это сделано в MS Excel при импорте текстового файла) и инициировать импорт координат:
##### Совместимость с AutoCAD
В заключение хотелось бы отметить, что приложение, написанное для nanoCAD, может быть с легкостью перекомпилировано и для работы в AutoCAD. Для этого необходимо сделать следующее:
* Во вкладке References подключить следующие библиотеки, входящие в состав ObjectARX:
+ AcCoreMgd.dll
+ AcDbMgd.dll
+ AcMgd.dll
* Добавить в код приложения директиву условной компиляции, для определения пространств имен, которые будут использоваться для компиляции под nanoCAD или AutoCAD:
```
#if ACAD
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.Runtime;
using Platform = Autodesk.AutoCAD;
using PlatformDb = Autodesk.AutoCAD;
#else
using HostMgd.ApplicationServices;
using HostMgd.EditorInput;
using Teigha.DatabaseServices;
using Teigha.Geometry;
using Teigha.Runtime;
using Platform = HostMgd;
using PlatformDb = Teigha;
#endif
```
* Заменить в коде специфичные для каждой платформы пространства имен на определенные выше псевдонимы: `Platform` и `PlatformDb`.
Обе версии проекта доступны [здесь](http://ftp.nanocad.ru/habr/ImportCoords/ImportCoords_NCAD.zip).
Обсуждение статьи доступно также и на нашем форуме: [forum.nanocad.ru/index.php?showtopic=6508](http://forum.nanocad.ru/index.php?showtopic=6508).
Перевод статьи на английский: [Importing coordinates from a text file to a nanoCAD drawing using the classic .NET API](http://developer.nanocad.com/blog/2014/09/01/importing-coordinates-from-a-text-file-to-a-nanocad-drawing-using-the-classic-net-api/). | https://habr.com/ru/post/188188/ | null | ru | null |
# Особенности использования MongoDB
Чуть больше года назад меня попросили поучаствовать в развитии одной известной в узких кругах (но не всегда с хорошей стороны) социальной сети. В то время я уже был фанатом языка Haxe, поэтому с тем на чём писать вопросов не возникало. А вот с БД они появились. Опыт использования MS SQL Server и MySQL говорили о том, что когда дело касается больших объёмов информации, то порой случаются сложности (практически невозможным становится изменение структуры БД, а когда-то быстрые запросы работают уже критически медленно). Посовещавшись с коллегами (у которых уже был опыт с Mongo), мы решили использовать именно эту СУБД. А о тех особенностях, которые всплыли в течение этого года я и расскажу ниже.
#### Стабильность работы
Через несколько месяцев использования появилась интересная проблема. Дело было так: я запустил построение индекса для одной из коллекций, затем, обнаружив, что индекс неверен, я позволил себе снять процесс через **db.killOp()**. После этого индекс формально появился, но при попытке использования ЛЮБОГО индекса (за исключением **natural**) в данной коллекции СУБД возвращала внутреннюю ошибку (срабатывал какой-то **assert** в её коде). Т.к. коллекция содержала почти 100 млн. записей, то запросы к ней стали невозможны и нам пришлось на несколько дней остановить сервис, пока мы переносили данные в новую коллекцию. А старая коллекция так и живёт в нашей базе — удалить её штатными средствами не получается.
В результате, сейчас у нас все коллекции, относящиеся к одному сервису, кладутся в отдельный instance СУБД, который в критической ситуации можно остановить и выправить, пожертвовав доступность лишь одного сервиса.
#### Запасные копии
Немало времени было потрачено и на то, чтобы решить, как выполнять резервное копирование информации. Первый приходящий на ум способ — создание набора реплик — показался мало подходящим в том смысле, что порой нужна не последняя копия БД на момент сбоя, а более ранняя. Кроме того, при снятии бэкапа, было бы неплохо не создавать дополнительной нагрузки на production. В результате пришли к использованию master-slave конфигурации, при которой slave время от времени бэкапится штатными средствами.
Хинт: чтобы избежать настройки безопасности через сертификаты, можно просто создать пользователя «repl» в БД **local** master и slave инстансов:
```
use local
db.addUser("repl", "mypassword")
```
#### Уникальные индексы
Привыкнув к относительной безопасности SQL, можно попасть в неприятности. У нас был такой казус: для одной из коллекций мы запустили построение уникального индекса по двум полям, одно из которых отсутствовало у большого количества записей, а другое регулярно повторялось. В результате нашей ошибки, СУБД начала удалять данные из коллекции. Вовремя поняв это, мы сняли процесс удаления по **db.killOp()** уже через несколько секунд, а информацию позже восстановили. Но осадок, как говорится, остался. Поэтому, как написано в руководстве: используйте **dropDups:true** с осторожностью!
#### Счётчики
Операции подсчёта количества элементов, подходящих под заданный фильтр, на больших объемах данных могут выполняться очень долго, если сравнивать с SQL. Всё дело в том, что Mongo не хранит в деревьях индексов количество подузлов. В результате, даже если ваш запрос полностью подпадает под индекс, СУБД вынуждена обойти все подходящие под фильтр записи (а ведь часто их немало). Так что будьте готовы хранить счётчики отдельно и менять их когда нужно. Либо иметь фоновые сервисы, которые будут пересчитывать значения счётчиков с заданное периодичностью. У нас используются оба способа, в зависимости от ситуации (первый — в простых случаях, таких как количество комментариев для картинки, а второй — для сложных, когда нужно хранить количество записей в коллекции, подпадающих под разные наборы условий).
#### Ротация лога
Не стоит забывать про такую «мелочь», как размер log-файла. Ведь по-умолчанию Mongo пишет в него все операции с базой. Потому на production-системе он может довольно быстро съесть всё место на разделе. На некритичных инстансах (таких как предназначенный для бэкапирования slave), как мне кажется, его лучше вообще отключать. На других — организовать ротацию.
#### Безопасность
Без специальной настройки может легко оказаться так, что Mongo будет смотреть в интернет без пароля. После первичной настройки, не забудьте создать пользователя — администратора:
```
use admin
db.addUser("root", "mypassword")
```
Кроме того, помните, что у этой СУБД в сеть может смотреть ещё и http-страничка (см. опцию **nohttpinterface**) со статистикой.
#### Полнотекстовый поиск
В целом, он работает. Следует лишь помнить, что:
1. языки (в частности русский) поддерживаются не совсем корректно — Mongo, например, пользуется рядом эвристических правил для детектирования окончаний, но, судя по всему, не хранит списков исключений или чего-то подобного, поэтому ничего особо умного от такого поиска не ждите;
2. если под поисковый запрос подпадает много записей (вы искали распространённое слово) — будет плохо; а именно: запросы будут выполняться долго (в нашем случае — порядка 30 секунд и более) и на это трудно как-то повлиять без введения допущений (сделаем limit перед поиском — не найдёт часть данных — ну и ладно).
Поэтому, хотя мы и используем полнотекстовый поиск в Mongo, но только потому что он идёт «из коробки». Если качественный поиск критичен — используйте что-то наподобие sphinx.
#### Выводы
В целом, я остался доволен нашим выбором: горизонтальная масштабируемость и гибкость документ-ориентированной модели перевешивают недостатки.
Сейчас наша социальная сеть функционирует на нескольких десятках серверов, при том, что сделанные нашей командой сервисы отлично держатся на одной машине для серверного кода (сам код написан на языке haxe с использованием веб-фреймворка [HaQuery](http://haquery.com/) и скомпилирован в [neko](http://nekovm.org/)), двух машинах для production-БД и одной для slave-инстансов Mongo.
Используемая версия MongoDB — 2.4.5.
Надеюсь, если вы подумываете использовать MongoDB для своего проекта, эта статья поможет вам принять верное решение. | https://habr.com/ru/post/229129/ | null | ru | null |
# Как находить проблемы с интернетом и кто виноват ч.2 — домашняя работа
Перед тем, как обращаться к провайдеру, необходимо разобраться - а всё ли хорошо в доме. Без этой проверки есть риск превратиться в мальчика, который постоянно кричал ~~"у меня потери пакетов"~~ "волки".
---
*В настоящее время, у пользователей увеличивается потребность в быстром интерактивном трафике - когда интернет не только толстый, но и пинги ходят очень быстро. Автор работает в компании GFN.RU. Нашим пользователям очень важны оба показателя, что и позволило накопить определенный багаж знаний и опыта, которым я делюсь в статьях.*
*Автор приложит все усилия, чтобы статьи оставались объективными и не превращались в рекламу GFN.RU.*
Моральное устаревание диагностических инструментов
--------------------------------------------------
В современном мире диагностика, увы не очень показательна. Во-первых, потому, что она базируется на протоколах 40-летней давности (RFC 792 - от 1981-го года) и превращается в лупу в эпоху электронных микроскопов. А во-вторых, у этих протоколов есть большие проблемы в части безопасности. Если какой-то маршрутизатор полностью отвечает RFC 792, то его можно элементарно атаковать с помощью DDoS атаки (чем хакеры в нулевых и баловались). Поэтому, даже эти протоколы работают плохо благодаря закрученным гайкам.
Прямым следствием этих ограничений является типичный сценарий решения сетевых проблем:
Пользователь обращается к провайдеру и говорит, что с сайтом А у него проблемы и плохая связь. Провайдер обычно ~~всегда~~ говорит: у нас всё хорошо, проблемы у сайта.
Когда пользователь обращается в поддержку сайта, то ему там говорят то же самое – у нас всё хорошо, обратитесь к провайдеру.
В итоге, проблема конечно же не решается.
Ниже мы всё-таки попробуем определиться, где именно проблема.
*К сожалению для статьи, и к счастью для автора, у автора всё в порядке с интернетом. Потому, примеров «смотрите – слева всё плохо, а справа всё хорошо» практически не будет. Но, где возможно – я всё-таки попробую что-нибудь сломать для наглядности.*
Маршруты интернета
------------------
В [первой части статьи](https://habr.com/ru/post/530324/) я рассказывал, что трафик ходит по маршрутам. Их два : BGP и IP. Один поверх другого. BGP - определяет маршрут через физические маршрутизаторы, а IP - уже логическая составляющая пути. На этом этапе диагностика затруднена тем, что :
1. Вводная по BGP это TTTLDR.
2. Благодаря таким технологиям, как AnyCast, IP 11.22.33.44 на маршруте может физически находиться в любом месте, и в двух+ местах одновременно : AnyCast позволяет указать, что за этот IP отвечает сервер в Нью-Йорке и в Москве. При пинге этого IP вы не можете однозначно утверждать, что вы пингуете именно Московский сервер.
3. Так же есть MPLS и иное туннелирование. Разобрать маршруты тоннелей, простыми инструментами не получится.
4. Пакет "туда" и пакет "обратно" может пойти разными путями.
5. Пакет "туда" может пойти по нескольким путям в разное время. Инструментов для диагностики ECMP на домашних OS немного, они сложнее простого tracert, а иногда, стоят дорого.
Будем работать с тем что есть. А есть у нас команда traceroute.
На windows она выполняется из Пуск/cmd и ввести tracert. Так же есть графическая утилита WinMTR. Она дает больше полезной информации и, в некоторых случаях, будем пользоваться ей.
*Можно не запускать cmd и там выполнять команды, а делать это windows-style:*
*Пуск/выполнить* `cmd /k tracert -d что-нибудь`
**Ключевые правила диагностики:**
1. **Если вы не можете продемонстрировать и повторить проблему, то никто не сможет.**
2. **Данные нужно собирать за несколько временных периодов – как минимум, за период, когда проблем нет, и за период, когда проблемы есть.**
Как быстро определить, что всё приемлемо
----------------------------------------
Автор использует универсальную метрику «Пинг на 1000 километров». Он считается следующим образом:
1. Определяете, где находится сервер.
2. На Яндекс.картах измеряете расстояние от вас до сервера.
Выполняете команду ping до нужного вам хоста. Если получается не больше, чем 20 миллисекунд на 1000 километров, то у вас с инпут-лагом не должно быть никаких проблем.
Автор находится в ~1000 км от Москвы. Его пинги выглядят следующим образом:
На расстояниях до 200 км данное правило, кстати, не будет выполняться, ввиду того, что скорость работы оборудования вносит бОльшую лепту. На таких расстояниях пинг должен быть в рамках 5-6 миллисекунд. Если больше – у вас проблема.
Как читать PING
---------------
Соединение до домашнего роутера
-------------------------------
В первую очередь, нужно определить IP адрес вашего домашнего роутера. Для этого необходимо ввести команду: `cmd /k tracert -d ya.ru`
`Tracing route to ya.ru [87.250.250.242] over a maximum of 30 hops:`
`1 1 ms 1 ms <1 ms 192.168.88.1`
Первый IP адрес в результатах tracert скорее всего и будет IP-адресом вашего роутера.
*Так же можно сделать вывод, что автор любитель Mikrotik.*
Пинг, обычно, отправляет пакеты размером 64 байта, что показывает скорее физические качества канала– нет ли плохого кабеля по пути.
Как уже говорилось ранее – диагностика работает только в сравнении. Ниже - два примера пинга.
С сервера, который подключен к роутеру кабелем.
А это с компьютера, который подключен к той же сети, но по wi-fi.
Какие выводы можно здесь сделать:
WIFI вносит свою лепту. Во-первых, у нас появился Джиттер (видим, что время пинга скачет). Во-вторых, пинг стал немного хуже.
И вот подтверждение моих слов - тест участка компьютер-домашний роутер.
Пакеты, даже не выходя в интернет, иногда проходят плохо. Без потерь, но задержки присутствуют.
Теперь, немножко нагрузим канал с помощью https://www.speedtest.net/ и параллельно запустим длинный ping.
*Чтоб запустить "длинный ping" - необходимо ввести команду ping -t . В этом случае ping будет продолжаться пока вы не нажмете Control+C*
Видим, что при приеме больших объемов информации скорость падает существенно меньше, чем при передаче.
Одна из причин – мощность антенны в точке доступа выше, чем у ноутбука. Ноутбук работает на аккумуляторе и не подключен к сети. Аккумулятор - почти севший и windows находится в режиме «Best battery life»
Вот тот же самый тест, но с подключенным блоком питания.
Видно, что прием стал гораздо лучше, и передача тоже улучшилась. 200мс пинг при передаче отсутствует.
Что в этой ситуации можно настроить:
1. Мощность передатчика на точке доступа.
2. Мощность передатчика на ноутбуке.
В первых тестах мощность передатчика ноутбука была выкручена на максимум. Ниже – выкручена на минимум:
Как видно, появились потери, и пинг стал гораздо хуже, даже при работе от блока питания.
Стоит помнить, что Wi-Fi это диалог. Если точка доступа «кричит», а компьютер «шепчет», то точка может плохо слышать компьютер, хотя палочки будут показывать, что всё хорошо.
Если вы везде выставите мощность на максимум, то могут начать страдать ваш Smart TV и телефон, подключенный к той же сети – компьютер будет их «перекрикивать». Ноутбук будет меньше работать от батарей. Мощность всегда нужно выбирать исходя из условий, и ставить минимальную мощность, которая дает вам приемлемый результат. Мощность с запасом ставить не рекомендуется.
Факторы, влияющие на Wi-Fi
--------------------------
Здесь опустим исключительно программные факторы вроде beacons, размеры пакетов, 80 мегагерц и прочее – про них можно написать еще десяток страниц. Приведу только ключевые физические факторы и факторы окружения.
Частоты : «2.4» в городах – всегда хуже 5 гигагерц. При возможности выбирайте 5.
При выборе канала – проведите анализ спектра, когда «соседи дома». Точки обычно позволяют сканировать эфир. Выберите канал, который не занят и у которого меньше всего соседей. При выборе канала старайтесь выбирать как можно меньший канал. 5-й канал бьет «дальше», чем 159-й.
Для анализа спектра можно использовать программу WiFiInfoView : https://www.nirsoft.net/utils/wifi*information*view.html
Далее идем в эту статью : [Wikipedia List of WLan channels](https://en.wikipedia.org/wiki/List_of_WLAN_channels)
Ищем частоту, вокруг которой либо самая слабая передача - Signal Quality самый плохой, либо вообще на этой частоте ничего нет.
У ноутбуков антенна встроена в экран. Антенна точки и устройства должны находиться в одной плоскости. Если у вас экран стоит вертикально, то и антенны на роутере должны стоять вертикально, а не так, как обычно показывается на рекламных материалах:
Плохая ориентация антенн :
Правильная ориентация антенн.
Вокруг и над антенной, в радиусе 40-50 сантиметров по горизонту НЕ ДОЛЖНО быть металла и стен. Т.е. – на столе/полке роутер ставить – неизбежное зло, с которым придется смириться. А вот возле стены – плохо. Популярные гипсокартонные стены содержат в себе металлические направляющие каждые 40 сантиметров.
Работающие микроволновки – злейшие враги Wi-Fi в тот момент, когда в них готовят.
Конспект
--------
Домашний маршрутизатор:
1. Найти IP-адрес домашнего роутера.
2. Запустить длинный пинг до роутера. Замерить потери и скорость.
3. Запустить спидтест и параллельно длинный пинг.
4. Сравнить результаты. Если ухудшения показателей пинга нет, то у вас соединение до роутера - быстрее чем канал в интернет, и в целом, дома всё хорошо.
Wifi:
1. Выбрать частоту и незанятый канал.
2. По возможности, убрать точку от стен.
3. Правильно ориентировать антенны. Кстати, запустив длинный "пинг", и покрутив антенны - можно найти оптимальный вариант, но не забывайте, что цифры достоверные только когда вы НЕ КАСАЕТЕСЬ антенн.
4. Выбрать минимальную мощность передатчика, дающую максимальную скорость в локальной сети.
[Как находить проблемы с интернетом и кто виноват ч.1 — inception](https://habr.com/ru/post/530324/) | https://habr.com/ru/post/531082/ | null | ru | null |
# Новые возможности векторизации и распараллеливания в Intel® Parallel Composer
В начале апреля стартовала программа по тестированию Intel® Parallel Composer beta, которая заканчивается в конце августа. Напомню основные компоненты композера:
* Intel C++ Compiler:
* Intel Integrated Performance Primitives (IPP):
* Intel Threading Building Blocks(TBB).
Что же нового ждать в Parallel Composer?
По мимо интеграции как композера, так и документации в Microsoft Visual Studio 2010\*, есть четыре фичи(англ. feature) на которые я хочу обратить ваше внимание:
* **Cilk C/C++** расширение параллельного программирования.
Cilk позволяет малыми силами превратить последовательную программу в параллельную. Это расширение добавляет новые ключевые слова (к моменту релиза они могут быть изменены):
1. \_Cilk\_spawn- порождение процесса вызова функции для асинхронного выполнения;
2. \_Cilk\_sync – точка синхронизации внутри этой функции;
3. \_Cilk\_for – параллельное выполнение всего итерационного пространства цикла.
* **CEAN**: C++ Extended Array Notations for data parallelism.
Новое расширение C/C++ для массивов, которое позволяет задавать дата параллелизм. CEAN выражения чем-то похожи на выражения Фортрана 90. К примеру, вместо
`for (i = 0; i < n; i++)
С[i] = A[i]*B[i] + d;` используются
`С[:] = A[:]*B[:] + d;`
Что позволяет компилятору более эффективно сгенерировать код с векторизацией.
* **GAP**: Guided Auto-parallelization (/Qguide, /Qguide-vec, /Qguide-data-trans).
При использовании этой возможности, компилятор производит диагностику кода и советует пользователю, что и как стоит изменить в коде. Это позволяет улучшить авто-векторизацию и авто-распараллеливание.
* **#pragma simd и #pragma parallel always [assert]**
Новые прагмы, которые указывают (а не советуют) компилятору, что он должен/не должен завекторизовать цикл. Об этом уже писалось [тут](http://habrahabr.ru/company/intel/blog/94381/).
Лично я сам учувствую в тестировании и написании сэмплов для CEAN и Cilk. На основе чего могу поделиться своими ощущениями:
CEAN по идеологии похож на valarray. Главное отличие заключается в том, что в vallaray предназначен для стандартного набора функций. В свою очередь CEAN, позволяет работать с пользовательскими типами, функциями и структурами. OpenMP\* и CEAN в связке работают отлично, как и Cilk c CEAN. Единственно, Cilk позволил меньшей кровью получить выше эффективность распараллеливания тех сэмплов, над которыми я работал.
Ну и на последок, все кто желает протестировать новый Intel® Parallel Composer, пишите в личку.
Пожалуйста, обратитесь к странице [Уведомление об оптимизации](http://software.intel.com/ru-ru/articles/optimization-notice/) для более подробной информации относительно производительности и оптимизации в программных продуктах компании Intel. | https://habr.com/ru/post/97011/ | null | ru | null |
# Добавляем голосовое управление на русском языке в VR-проект
Тема виртуальной, дополненной реальности, метавселенных набирает обороты. Но что это такое, как должно выглядеть, как этим пользоваться, никто толком пока не знает. Однако, как в своё время переход от десктопных приложений к мобильным, миграция в VR принесёт и новые паттерны взаимодействия с пользователем. Да, в виртуальной реальности уже можно «потрогать» предметы, но этого недостаточно для полноценного решения пользовательских задач. Кажется, что голосовое управление в VR станет ещё более актуальным, чем в мобильных устройствах — в виде, например, голосовых команд или ввода текстовых данных.
Ниже опишу пошагово, как можно добавить голосовое управление на русском языке в VR-проект.
Но для начала давайте проговорим подробнее, чем полезны технологии распознавания речи в VR:
* Уже [шесть лет назад](https://news.stanford.edu/2016/08/24/stanford-study-speech-recognition-faster-texting/) исследователи пришли к выводу, что голосовой ввод в три раза быстрее и более точен, чем ручной с помощью клавиатуры смартфона. Для VR-устройств это особенно актуально.
* Кроме того, для голосового ввода смартфон не нужно держать в руках и подносить к голове. VR-устройства уже находятся на голове, и голосовой ввод выглядит более естественно.
* В VR-проектах мы больше погружены в виртуальный мир. Взаимодействие с этим миром должно быть похоже на наше взаимодействие с реальным. Управление голосом этому способствует больше, чем выбор пунктов меню с помощью игровых контроллеров.
* Единые паттерны взаимодействия с пользователем ещё не сформировались. Для людей, только начинающих пользоваться VR-устройствами, наиболее интуитивно понятными могут стать именно голосовые интерфейсы.
Перейдём непосредственно к практике.
Выбор инструментов
------------------
Большинство программистов для своих VR-проектов используют Unity. Также есть мнение, что [90% компаний-разработчиков для AR/VR используют C#](https://circuitstream.com/blog/unity-vs-unreal/). Но это какое-то странное заявление, на чём оно основывается, я так и не нашёл. Возможно, это было написано в каком-нибудь древнем пресс-релизе от Unity. Тем не менее, [в свежей статье на Forbes](https://www.forbes.com/sites/bethkindig/2022/05/20/unity-stock-priced-too-low-for-the-long-term-opportunity) указано, что 72% из топ 1000 мобильных приложений сделаны на Unity, что похоже на правду. Ну и вдобавок, там же упоминается AR/VR/XR, Metaverse, Web3, и всё, что сейчас модно.
Со средой разработки определились, теперь нужно выбрать сервис распознавания русской речи для нашего голосового управления. Что нам нужно от сервиса распознавания речи? Прежде всего, распознавание должно быть потоковым. Чтобы не ждать окончания фразы и самим не решать задачу определения конца фразы. И тут [к нам на помощь приходит SmartSpeech](https://developers.sber.ru/docs/ru/smartspeech/overview). Плюсом является и то, что в нём есть и частичное распознавание по ещё не законченной фразе.
Что такое SmartSpeech? Это платформа речевых сервисов, разработанная командой SberDevices. Технологии распознавания речи (ASR) и синтеза речи (TTS) SmartSpeech используются, например, в нашем [семействе виртуальных ассистентов Салют](https://salute.sber.ru), а также в проектах сторонних разработчиков. Протестировать распознавание речи от SmartSpeech можно с помощью [телеграм-бота](https://t.me/smartspeech_sber_bot), о котором мы [уже писали на Хабре](https://habr.com/ru/company/sberdevices/blog/658575/).
Ну и наконец, тестировать наше голосовое управление мы будем с помощью Oculus Quest 2, самой продаваемой VR-гарнитуры в данный момент.
Подключаем сервис распознавания
-------------------------------
Прежде всего нужно [подключить сервис SmartSpeech](https://developers.sber.ru/docs/ru/smartspeech/conditions). И после получения `Client Id` и `Client Secret`, можно протестировать работу сервиса.
Кабинет разработчика в SmartMarket StudioДля отправки запросов сервису распознавания речи, сначала получим [токен для аутентификации](https://developers.sber.ru/docs/ru/smartspeech/authentication).
Для этого:
* Подготовим авторизационные данные — закодируем в Base 64 строку вида: `:`.
* Cгенерируем RqUID, например:
```
uuidgen | tr 'A-Z' 'a-z'
```
* И пошлём запрос на получение токена от сервиса:
```
curl --location --request POST "https://salute.online.sberbank.ru:9443/api/v2/oauth" \
--header "Authorization: Basic " \
--header "RqUID: " \
--header "Content-Type: application/x-www-form-urlencoded" \
--data-urlencode "scope=SBER\_SPEECH"
```
Должен прийти json вида: `{"access_token":"","expires_at":}`
Все готово к работе. Чтобы протестировать распознавание речи, можно [послать в сервис файл с аудиозаписью](https://developers.sber.ru/docs/ru/smartspeech/recognition). Для этого нам понадобится подготовленный заранее файл и только что полученный токен для аутентификации.
```
curl -X POST \
-H "Authorization: Bearer " \
-H "Content-Type: audio/x-pcm;bit=16;rate=16000" \
--data-binary @./audio.pcm \
https://smartspeech.sber.ru/rest/v1/speech:recognize
```
Распознавание в Unity
---------------------
Но нас интересует потоковое распознавание в Unity. Работа с сервисом осуществляется по протоколу gRPC. gRPC — это кроссплатформенная и кроссязыковая система удалённого вызова процедур (RPC). Работает она поверх HTTP/2, в качестве языка описания интерфейса используется Protobuf.
Сами .proto-файлы, как и примеры для работы со SmartSpeech на других языках программирования, можно взять в [документации](https://developers.sber.ru/docs/ru/smartspeech/recognition-async#%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F).
Для начала нужно сгенерировать клиентский код на C# для работы по gRPC. Например, про помощи утилиты protoc:
```
mkdir -p grpc/client
protoc -I ./smartspeech-master/recognition/v1/ \
-I ./smartspeech-master/task/v1/ \
--csharp_out=grpc/client \
--grpc_out=grpc/client \
--plugin=protoc-gen-grpc=/usr/local/bin/grpc_csharp_plugin \
recognition.proto {storage,task}.proto
```
Далее для Unity нужно скачать необходимые библиотеки, например, из проекта gRPC.io. Правда, поддержка Unity там [обозначена как «experimental»](https://github.com/grpc/grpc/tree/v1.46.x/src/csharp/experimental).
На [странице загрузок](https://packages.grpc.io/) находим нужный нам пакет для Unity. В нашем случае это `grpc_unity_package.2.47.0-dev202204190851`. Файлы библиотеки, как и сгенерированный клиентский код для gRPC переносим в свой Unity проект:
И наконец нужно написать клиентский код, который будет передавать данные в SmartSpeech по gRPC. Весь пример кода можно [скачать по ссылке](https://files.sberdisk.ru/s/8HKNi79owpFXSHK). Здесь же отметим основные моменты.
Подключаем необходимые библиотеки:
```
using Grpc.Core;
using Smartspeech.Recognition.V1;
```
Объекты, которые используются для взаимодействия по gRPC:
```
Channel _channel =
new Channel(address,
ChannelCredentials.Create(new SslCredentials(), credentials));
SmartSpeech.SmartSpeechClient _client =
new SmartSpeech.SmartSpeechClient(_channel);
RecognitionOptions _options = new RecognitionOptions();
_options.SampleRate = _sampleRate;
_options.AudioEncoding = RecognitionOptions.Types.AudioEncoding.PcmS16Le;
```
Токен для аутентификации мы просто получаем по http. Данные же для распознавания мы забираем с микрофона и передаём по gRPC. Причём, прежде чем начать отправку данных, нужно первым запросом послать опции распознавания:
```
var call = _client.Recognize();
var streamRequest = new RecognitionRequest();
streamRequest.Options = _options;
await call.RequestStream.WriteAsync(streamRequest);
```
И затем уже в цикле данные с микрофона:
```
audioSource.clip.GetData(samples, curDataIndex);
curDataIndex += bufferSize;
if (curDataIndex >= audioSource.clip.samples)
curDataIndex = 0;
buffer = GetSamplesWaveData(samples, bufferSize);
streamRequest.AudioChunk = Google.Protobuf.ByteString.CopyFrom(buffer);
await call.RequestStream.WriteAsync(streamRequest);
```
Асинхронно забираем результаты распознавания:
```
var response = call.ResponseStream.Current;
bool eou = response.Eou;
var results = response.Results;
string text = results[0].Text;
string normalizedText = results[0].NormalizedText;
```
Готовое приложение
------------------
В результате у нас должно получиться что-то похожее на видео. Демо-проект в Unity под Oculus Quest 2 можно [скачать по ссылке](https://files.sberdisk.ru/s/Pt8Gr56RmCK8jgz).
Регистрируйтесь в сервисе SmartSpeech, пробуйте, создавайте свои приложения. Если у вас есть какие-нибудь вопросы, оставляйте в комментариях, постараемся оперативно на них ответить.
Возможно, внимание, которое привлекает сейчас тема метавселенных и виртуальной реальности, слишком раздуто. Тем не менее, всё больше и больше компаний начинает этим заниматься. Международная консалтинговая компания [выпустила отчёт](https://www.mckinsey.com/business-functions/growth-marketing-and-sales/our-insights/value-creation-in-the-metaverse), в котором отмечает большой потенциал концепции метавселенной. Она прогнозирует, что к 2030 году рынок будет оцениваться в $5 трлн. Так что можно уже сейчас начинать идти в этом направлении. | https://habr.com/ru/post/670588/ | null | ru | null |
# Анализируем локальные функции в C# 7
Добавление локальных функций в языке C# первоначально для меня было излишним. Прочитав статью в блоге [SergeyT](https://habrahabr.ru/users/sergeyt/), я понял, что эта фича действительна нужна. Итак, кто сомневается в надобности локальных функций и кто еще не знает что это, вперед за знаниями!
**Локальные функции** — это новая возможность в C# 7, которая позволяет определять функцию внутри другой функции.
### Когда использовать локальные функции?
Основная идея локальных функций очень похожа на анонимные методы: в некоторых случаях создание именованной функции слишком дорого с точки зрения когнитивной нагрузки на читателя. Иногда функциональность, по своей сути, является локальной для другой функции, и нет смысла загрязнять «внешнюю» область видимости отдельной именованной сущностью.
Вы можете подумать, что эта возможность избыточна, потому что такое же поведение может быть достигнуто с анонимными делегатами или лямбда-выражениями. Но это не всегда так. Анонимные функции имеют определенные ограничения, и их характеристики производительности могут быть непригодными для ваших сценариев.
### Пример использования 1: предварительные условия в блоках итератора
Вот простая функция, которая читает файл по строкам. Вы знаете, когда будет выброшено ArgumentNullException?
```
public static IEnumerable ReadLineByLine(string fileName)
{
if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException(nameof(fileName));
foreach (var line in File.ReadAllLines(fileName))
{
yield return line;
}
}
// When the error will happen?
string fileName = null;
// Here?
var query = ReadLineByLine(fileName).Select(x => $"\t{x}").Where(l => l.Length > 10);
// Or here?
ProcessQuery(query);
```
Методы с **yield return** в теле являются особыми. Они называются [блоками итератора](https://msdn.microsoft.com/en-us/library/65zzykke%28v=vs.100%29.aspx?f=255&MSPPError=-2147217396), и они ленивы (lazy). Это означает, что выполнение этих методов происходит «по требованию», и первый блок кода в них будет выполняться только тогда, когда клиент метода вызовет **MoveNext** на результирующем итераторе. В нашем случае это означает, что ошибка произойдет только в методе **ProcessQuery**, потому что все LINQ-операторы тоже ленивы.
Очевидно, что такое поведение нежелательно, потому что метод **ProcessQuery** не будет иметь достаточной информации о контексте **ArgumentNullException**. Поэтому было бы неплохо бросить исключение сразу — когда клиент вызывает **ReadLineByLine**, но не тогда, когда клиент обрабатывает результат.
Чтобы решить эту проблему, нам нужно извлечь логику проверки в отдельный метод. Это хороший кандидат на анонимную функцию, но анонимные делегаты и лямбда-выражения не поддерживают блоки итераторов (\*):
(\*) Лямбда-выражения в VB.NET могут иметь блок итератора.
```
public static IEnumerable ReadLineByLine(string fileName)
{
if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException(nameof(fileName));
return ReadLineByLineImpl();
IEnumerable ReadLineByLineImpl()
{
foreach (var line in File.ReadAllLines(fileName))
{
yield return line;
}
}
}
```
### Пример использования 2: предварительные условия в асинхронных методах
Асинхронные методы имеют аналогичную проблему с обработкой исключений: любое исключение, созданное методом, помеченным ключевым словом **async**, проявляется в возвращенной задаче:
```
public static async Task GetAllTextAsync(string fileName)
{
if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException(nameof(fileName));
var result = await File.ReadAllTextAsync(fileName);
Log($"Read {result.Length} lines from '{fileName}'");
return result;
}
string fileName = null;
// No exceptions
var task = GetAllTextAsync(fileName);
// The following line will throw
var lines = await task;
```
Вы можете подумать, что при возникновении ошибки нет большой разницы. Но это далеко от истины. Неисправная задача (faulted task) означает, что сам метод не смог выполнить то, что он должен был сделать. Неисправная задача означает, что проблема заключается в самом методе или в одном из блоков, от которых зависит метод.
Проверка надежных предварительных условий особенно важна, когда результирующая задача передается по системе. В этом случае было бы очень трудно понять, когда и что пошло не так. Локальная функция может решить эту проблему:
```
public static Task GetAllTextAsync(string fileName)
{
// Eager argument validation
if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException(nameof(fileName));
return GetAllTextAsync();
async Task GetAllTextAsync()
{
var result = await File.ReadAllTextAsync(fileName);
Log($"Read {result.Length} lines from '{fileName}'");
return result;
}
}
```
### Пример использования 3: локальная функция с блоками итератора
Мне было очень досадно, что нельзя использовать итераторы внутри лямбда выражений. Вот простой пример: если вы хотите получить все поля в иерархии типов (включая закрытые), вам нужно пройти иерархию наследования вручную. Но логика обхода специфична для конкретного метода и должна быть максимальная «локализованной»:
```
public static FieldInfo[] GetAllDeclaredFields(Type type)
{
var flags = BindingFlags.Instance | BindingFlags.Public |
BindingFlags.NonPublic | BindingFlags.DeclaredOnly;
return TraverseBaseTypeAndSelf(type)
.SelectMany(t => t.GetFields(flags))
.ToArray();
IEnumerable TraverseBaseTypeAndSelf(Type t)
{
while (t != null)
{
yield return t;
t = t.BaseType;
}
}
}
```
### Пример использования 4: рекурсивный анонимный метод
Анонимные функции по умолчанию не могут ссылаться на саму себя. Чтобы обойти это ограничение, вы должны объявить локальную переменную с типом делегата, а затем захватить эту локальную переменную внутри лямбда-выражения или анонимного делегата:
```
public static List BaseTypesAndSelf(Type type)
{
Action, Type> addBaseType = null;
addBaseType = (lst, t) =>
{
lst.Add(t);
if (t.BaseType != null)
{
addBaseType(lst, t.BaseType);
}
};
var result = new List();
addBaseType(result, type);
return result;
}
```
Этот подход не очень читабелен, и следующее решение с локальной функцией кажется более естественным:
```
public static List BaseTypesAndSelf(Type type)
{
return AddBaseType(new List(), type);
List AddBaseType(List lst, Type t)
{
lst.Add(t);
if (t.BaseType != null)
{
AddBaseType(lst, t.BaseType);
}
return lst;
}
}
```
### Пример использования 5: когда вопросы аллокации имеют значение
Если вы когда-либо работали над критичным для производительности приложением, то вы знаете, что анонимные методы не из дешевых:
* Накладные расходы на вызов делегата (очень маленькие, но они существуют).
* **Аллокация 2 объектов** в управляемой куче, если лямбда-выражение захватывает локальную переменную или аргумент метода (один для экземпляра замыкания и другой для самого делегата).
* **Аллокация 1 объекта** в управляемой кучи, если лямбда-выражение захватывает экземплярные поля объекта.
* **Отсутствие аллокаций** будет только в том случае, если лямбда-выражение не захватывает ничего или оперирует лишь статическими членами.
Но модель аллокации для локальных функций существенно отличается.
```
public void Foo(int arg)
{
PrintTheArg();
return;
void PrintTheArg()
{
Console.WriteLine(arg);
}
}
```
Если локальная функция захватывает локальную переменную или аргумент, то компилятор C# генерирует специальную структуру замыкания, создает ее экземпляр и передает ее по ссылке в сгенерированный статический метод:
```
internal struct c__DisplayClass0_0
{
public int arg;
}
public void Foo(int arg)
{
// Closure instantiation
var c__DisplayClass0_ = new c__DisplayClass0_0() { arg = arg };
// Method invocation with a closure passed by ref
Foo_g__PrintTheArg0_0(ref c__DisplayClass0_);
}
internal static void Foo_g__PrintTheArg0_0(ref c__DisplayClass0_0 ptr)
{
Console.WriteLine(ptr.arg);
}
```
(Компилятор генерирует имена с недопустимыми символами, такими как < и >. Чтобы улучшить читаемость, я изменил имена и немного упростил код.)
Локальная функция может захватывать экземплярное состояние, локальные переменные (\*\*\*) или аргументы. Никакой аллокации в управляемой куче не произойдет.
(\*\*\*) Локальные переменные, используемые в локальной функции, должны быть определены (definitely assigned) в месте объявления локальной функции.
Есть несколько случаев, когда произойдет создание объекта в управляемой куче:
1. Локальная функция явно или неявно преобразуется в делегат.
**Аллокация делегата произойдет** если локальная функция захватывает поля экземплярные или статические поля, но не захватывает локальные переменные или аргументы.
```
public void Bar()
{
// Just a delegate allocation
Action a = EmptyFunction;
return;
void EmptyFunction() { }
}
```
Аллокация замыкания и делегата произойдет, если локальная функция захватывает локальные/аргументы
```
public void Baz(int arg)
{
// Local function captures an enclosing variable.
// The compiler will instantiate a closure and a delegate
Action a = EmptyFunction;
return;
void EmptyFunction() { Console.WriteLine(arg); }
}
```
2. Локальная функция захватывает локальную переменную/аргумент, а анонимная функция захватывает переменную/аргумент из той же области видимости.
Этот более тонкий случай.
Компилятор C # генерирует отдельный тип замыкания для каждой лексической области видимости (аргументы метода и локальные переменные верхнего уровня находятся в одной и той же области верхнего уровня). В следующем случае, компилятор будет генерировать два типа замыкания:
```
public void DifferentScopes(int arg)
{
{
int local = 42;
Func a = () => local;
Func b = () => local;
}
Func c = () => arg;
}
```
Два разных лямбда-выражения используют один и тот же тип замыкания, если они захватывают переменные из одной и той же области видимости. Сгенерированные методы для лямбда-выражений **a** и **b** находятся в одном и том же типе замыкания:
```
private sealed class c__DisplayClass0_0
{
public int local;
internal int DifferentScopes_b__0()
{
// Body of the lambda 'a'
return this.local;
}
internal int DifferentScopes_b__1()
{
// Body of the lambda 'a'
return this.local;
}
}
private sealed class c__DisplayClass0_1
{
public int arg;
internal int DifferentScopes_b__2()
{
// Body of the lambda 'c'
return this.arg;
}
}
public void DifferentScopes(int arg)
{
var closure1 = new c__DisplayClass0_0 { local = 42 };
var closure2 = new c__DisplayClass0_1() { arg = arg };
var a = new Func(closure1.DifferentScopes\_b\_\_0);
var b = new Func(closure1.DifferentScopes\_b\_\_1);
var c = new Func(closure2.DifferentScopes\_b\_\_2);
}
```
В некоторых случаях такое поведение может вызвать некоторые очень серьезные проблемы, связанные с памятью. Вот пример:
```
private Func func;
public void ImplicitCapture(int arg)
{
var o = new VeryExpensiveObject();
Func a = () => o.GetHashCode();
Console.WriteLine(a());
Func b = () => arg;
func = b;
}
```
Кажется, что переменная **o** должна быть доступна для сборки мусора сразу после вызова делегата **a()**. Но это не так, поскольку два лямбда-выражения используют один и тот же тип замыкания:
```
private sealed class c__DisplayClass1_0
{
public VeryExpensiveObject o;
public int arg;
internal int ImplicitCapture_b__0()
=> this.o.GetHashCode();
internal int ImplicitCapture_b__1()
=> this.arg;
}
private Func func;
public void ImplicitCapture(int arg)
{
var c\_\_DisplayClass1\_ = new c\_\_DisplayClass1\_0()
{
arg = arg,
o = new VeryExpensiveObject()
};
var a = new Func(c\_\_DisplayClass1\_.ImplicitCapture\_b\_\_0);
Console.WriteLine(func());
var b = new Func(c\_\_DisplayClass1\_.ImplicitCapture\_b\_\_1);
this.func = b;
}
```
Это означает, что **время жизни экземпляра замыкания привязано к времени жизни поля func**: замыкания остается живым до тех пор, пока делегат доступен из кода приложения. Это может продлить время жизни **VeryExpensiveObject**, что по сути является своеобразной утечкой памяти.
Аналогичная проблема возникает, когда локальная функция и лямбда-выражение захватывают переменные из одной и той же области видимости. Даже если они захватывают разные переменные, тип замыкания будет общим, вызывая выделение объекта в управляемой куче:
```
public int ImplicitAllocation(int arg)
{
if (arg == int.MaxValue)
{
// This code is effectively unreachable
Func a = () => arg;
}
int local = 42;
return Local();
int Local() => local;
}
```
Будет преобразовано компилятором в:
```
private sealed class c__DisplayClass0_0
{
public int arg;
public int local;
internal int ImplicitAllocation_b__0()
=> this.arg;
internal int ImplicitAllocation_g__Local1()
=> this.local;
}
public int ImplicitAllocation(int arg)
{
var c__DisplayClass0_ = new c__DisplayClass0_0 { arg = arg };
if (c__DisplayClass0_.arg == int.MaxValue)
{
var func = new Func(c\_\_DisplayClass0\_.ImplicitAllocation\_b\_\_0);
}
c\_\_DisplayClass0\_.local = 42;
return c\_\_DisplayClass0\_.ImplicitAllocation\_g\_\_Local1();
}
```
Как вы можете видеть, все локальные переменные из верхней области видимости теперь становятся частью класса замыкания, что приводит к созданию объекта-замыкания, даже когда локальная функция и лямбда-выражение захватывают разные переменные.
### Локальные функции 101
Ниже приведен список наиболее важных аспектов локальных функций в C#:
* Локальные функции могут определять блоки итераторов.
* Локальные функции полезны для неотложенной (eager) проверки предусловий в асинхронных методах и блоках итераторов.
* Локальные функции могут быть рекурсивными.
* Локальные функции не аллоцируют в куче, если не происходит преобразование их в делегаты.
* Локальные функции немного более эффективны, чем анонимные функции из-за отсутствия накладных расходов вызовов делегата (\*\*\*\*).
* Локальные функции могут быть объявлены после оператора return, что позволяет отделить основную логику метода от вспомогательной.
* Локальные функции могут «скрыть» функцию с тем же именем, объявленным во внешней области видимости.
* Локальные функции могут быть **асинхронными** и/или **небезопасными** (unsafe); другие модификаторы не допускаются.
* Локальные функции не могут иметь атрибуты.
* Локальные функции не очень дружественны к IDE: пока нет «рефакторинга для выделения локальных методов» (R# 2017.3 уже поддерживает такую возможность. — прим. пер), и если код с локальной функцией не компилируется, вы получите много «подчеркиваний» «squiggles» в среде IDE.
(\*\*\*\*) Вот результаты микробенчмарка:
```
private static int n = 42;
[Benchmark]
public bool DelegateInvocation()
{
Func fn = () => n == 42;
return fn();
}
[Benchmark]
public bool LocalFunctionInvocation()
{
return fn();
bool fn() => n == 42;
}
```
| | | | |
| --- | --- | --- | --- |
| Method | Mean | Error | StdDev |
| DelegateInvocation | 1.5041 ns | 0.0060 ns | 0.0053 ns |
| LocalFunctionInvocation | 0.9298 ns | 0.0063 ns | 0.0052 ns |
Чтобы получить эти цифры, вам нужно вручную «декомпилировать» локальную функцию в обычную функцию. Причина этого проста: такая простая функция, как «fn», будет встроена (inline) во время выполнения, и тест не покажет реальную стоимость вызова. Чтобы получить эти числа, я использовал статическую функцию, отмеченную атрибутом **NoInlining** (к сожалению, вы не можете использовать атрибуты с локальными функциями). | https://habr.com/ru/post/346174/ | null | ru | null |
# Создание столбчатых диаграмм с помощью JavaScript
[](https://habr.com/ru/company/ruvds/blog/711728/)
Современный мир буквально переполнен данными, и нам желательно уметь представлять их графически для быстроты и удобства восприятия. Одной из наиболее распространённых техник визуализации данных являются столбчатые диаграммы, и в этой статье я покажу вам, как можно легко создавать их интерактивные версии в JavaScript.
Гистограмма является очень простым, но мощным способом представления данных в случаях, когда нужно сравнить значения. В этом руководстве вы научитесь создавать разные их виды – простые, групповые, стековые и 100% стековые гистограммы, а также эффективно кастомизировать их с помощью всего нескольких строк JS-кода.
Будучи любителем крикета, я внимательно следила за чемпионатом мира ICC T20 2022 среди мужчин, проходившим осенью в Австралии, и в итоге решила взять данные для иллюстраций именно с него. Гистограммы, которые мы построим в ходе этого урока, позволят оценить статистику отбиваний мяча, а конкретно количество очков, заработанных десятью ведущими отбивающими в рамках турнира. Начнём!
1. Базовая гистограмма в JS
---------------------------
Базовую гистограмму можно легко построить всего в четыре шага. Ниже я покажу, что нужно сделать на каждом из них, а также объясню каждую строчку кода.
1. Создание контейнера.
2. Внесение файлов скриптов.
3. Подготовка данных.
4. Написание кода для визуализации.
### ▍ 1.1 Создание контейнера
Первым делом нужно настроить место для гистограммы.
Если у вас уже есть веб-страница, куда вы хотите её поместить, то просто откройте свой HTML-файл. Если же таковой нет, создайте. После этого добавьте в неё блочный HTML-элемент и присвойте ему ID. Также установите его ширину, высоту и прочие параметры стилизации, согласно вашим нуждам.
Я создала простейшую HTML-страницу, добавила элемент с ID «контейнера» и установила его ширину/высоту равными 100%, чтобы итоговая гистограмма заполнила всю страницу:
```
JavaScript Column Chart
html, body, #container {
width: 100%; height: 100%; margin: 0; padding: 0;
}
```
### ▍ 1.2 Внесение файлов скриптов
Самый простой способ быстро создать интерактивную гистограмму для веба – это использовать одну из [существующих библиотек JavaScript (англ.)](https://dzone.com/articles/10-best-javascript-charting-libraries-for-any-data). Эти библиотеки представляют наборы готового кода для генерации диаграмм, что позволяет [визуализировать данные (англ.)](https://dzone.com/articles/demystify-usages-of-visualisation-plots) путём минимальных усилий.
Этапы создания гистограммы во всех библиотеках, по сути, остаются одинаковыми. Какую бы вы ни выбрали, добавьте её к веб-странице, указав соответствующие JS-файлы в теге `</code> раздела <code><head></code>. После этого добавьте ещё один тег <code><script></code> в любом месте раздела <code><head></code> или <code><body></code> — здесь будет размещён код для построения гистограммы.<br/>
<br/>
В текущем руководстве для иллюстрации процесса я буду использовать <a href="https://www.anychart.com/">AnyChart</a>. Это легковесная библиотека для создания диаграмм с подробной <a href="https://docs.anychart.com/">документацией</a> и множеством <a href="https://www.anychart.com/products/anychart/gallery/">примеров</a>, доступная для бесплатного некоммерческого использования. Так что я включаю ее базовый модуль:<br/>
<br/>
<pre><code class="xml"><html>
<head>
<title>JavaScript Column Chart</title>
<style type="text/css">
html, body, #container {
width: 100%; height: 100%; margin: 0; padding: 0;
}
</style>
</head>
<body>
<div id="container"></div>
</body>
</html></code></pre><br/>
<h3><font color="#3AC1EF">▍ 1.3 Подготовка данных</font></h3><br/>
Далее нужно подготовить данные, которые вы хотите визуализировать.<br/>
<br/>
Я взяла статистику по набору очков десятью ведущими бэтсменами (отбивающий мяч игрок) на упомянутом чемпионате по крикету с сайта <a href="https://stats.espncricinfo.com/ci/engine/records/batting/most\_runs\_career.html?id=14450;type=tournament">ESPNcricinfo</a> и сопоставила итоговые показатели этих бэтсменов в простом многомерном массиве. Естественно, вы можете использовать другой формат данных вроде JSON, XML, CSV и т. д.<br/>
<br/>
<pre><code class="javascript">[
["Virat Kohli", "296", "India"],
["Max O'Dowd", "242", "Netherlands"],
["Suryakumar Yadav", "239", "India"],
["JD Butler", "225", "England"],
["Kusal Mendis", "223", "Sri Lanka"],
["Sikandar Raza", "219", "Zimbabwe"],
["Pathum Nissanka", "214", "Sri Lanka"],
["AD Hales", "212", "England"],
["Lorkan Tucker", "204", "Ireland"],
["Glenn Phillips", "201", "New Zealand"]
]</code></pre><br/>
<h3><font color="#3AC1EF">▍ 1.4 Написание кода для визуализации</font></h3><br/>
Поле организовано, игроки готовы, жребий брошен – настало время начинать матч! Создание гистограммы с помощью <a href="https://dzone.com/articles/10-best-javascript-charting-libraries-for-any-data">подходящей библиотеки JS (англ.)</a> подобно выбиванию шести очков в крикете – максимальная отдача при минимуме усилий. Ниже я покажу, как можно всё реализовать буквально в нескольких строках кода. <br/>
<br/>
Первым делом я добавляю функцию <code>anychart.onDocumentReady()</code> в тег <code><script></code> раздела <code><body></code>. Всё остальное будет помещаться в эту функцию.<br/>
<br/>
<pre><code class="xml"><script>
anychart.onDocumentReady(function() {
// Далее пойдёт код для создания гистограммы
});`
Затем я создаю экземпляр гистограммы, используя встроенную функцию, и добавляю набор подготовленных данных.
```
// Создание гистограммы
var chart = anychart.column();
// Создание набора данных
var series = chart.column([
["Virat Kohli", "296", "India"],
["Max O'Dowd", "242", "Netherlands"],
["Suryakumar Yadav", "239", "India"],
["JD Butler", "225", "England"],
["Kusal Mendis", "223", "Sri Lanka"],
["Sikandar Raza", "219", "Zimbabwe"],
["Pathum Nissanka", "214", "Sri Lanka"],
["AD Hales", "212", "England"],
["Lorkan Tucker", "204", "Ireland"],
["Glenn Phillips", "201", "New Zealand"]
]);
```
Всегда желательно подписывать график и его оси, уточняя таким образом, что именно он представляет:
```
// Добавление подписей к осям
chart.xAxis().title("Batsman");
chart.yAxis().title("Number of runs");
// Добавление подписи к графику
chart.title("Top 10 Run Scorers at ICC Men's T20 World Cup 2022");
```
В последнюю очередь я настраиваю элемент контейнера – здесь потребуется его ID – и отображаю итоговую гистограмму.
```
// Настройка элемента контейнера
chart.container("container");
// Отображение гистограммы
chart.draw();
```
Вот как выглядит весь код JS в теге | https://habr.com/ru/post/711728/ | null | ru | null |
# Часть 2: Использование блоков UDB контроллеров PSoC фирмы Cypress для уменьшения числа прерываний в 3D-принтере
[В прошлый раз](https://habr.com/post/433800/) мы рассмотрели вариант генерации импульсов для шаговых двигателей, частично вынесенный с программного на микропрограммный уровень. В случае полного успеха, это сулит отсутствие необходимости обрабатывать прерывания, поступающие с частотой вплоть до 40 КГц. Но тот вариант обладает рядом явных недостатков. Во-первых, там не поддерживаются ускорения. Во-вторых, гранулярность допустимых частот шагов в том решении — сотни герц (например, возможна выработка частот 40000 Гц и 39966 Гц, но невозможна выработка частот с величиной между этими двумя значениями).
Реализация ускорений
--------------------
Можно ли устранить указанные недостатки, пользуясь средствами всё тех же UDB, не усложняя систему? Давайте разбираться. Начнём с самого сложного — с ускорений. Ускорения добавляются в начале и конце пути. Во-первых, если на шаговый двигатель подать сразу импульсы высокой частоты, ему потребуется больший ток, чтобы начать работу. Высокий допустимый ток — это нагрев и шум, поэтому лучше его ограничивать. Но тогда двигатель может пропустить шаги на старте. Так что разгонять двигатель лучше плавно. Во-вторых, если тяжёлая головка останавливается резко, то у неё возникают переходные процессы, связанные с инерцией. На пластике видны волны. Поэтому плавно надо не только разгонять, но и останавливать головку. Классически график скорости двигателя представляют в виде трапеции. Вот фрагмент из исходного кода «прошивки» Marlin:
Я не буду даже пытаться прикидывать, можно ли реализовать такое средствами UDB. Виной тому тот факт, что сейчас в моду входит другой вид ускорения: не трапециевидные, а S-Curve. Их график выглядит так:
Такое — точно не для UDB. Сдаёмся? Вовсе нет! Я уже отмечал, что UDB у меня не реализует аппаратный интерфейс, а просто позволяет перенести часть кода с программного на микропрограммный уровень. Пусть профиль обсчитывает центральный процессор, а формирование шаговых импульсов по-прежнему выполняет UDB. У центрального процессора есть уйма времени на расчеты. Задача исключения частых прерываний по-прежнему будет решаться достаточно элегантно, а полного выноса процесса на микропрограммный уровень никто и не планировал.
Само собой, профиль потребуется готовить в памяти, а UDB будет забирать данные оттуда средствами DMA. Но сколько же требуется памяти? На один миллиметр нужно 200 шагов. Сейчас при 24-битном кодировании, это 600 байт на 1 мм перемещения головки! Вновь вспоминаем про не такие частые, но всё-таки постоянные прерывания, чтобы передавать всё фрагментами? Не совсем! Дело в том, что механизм DMA у PSoC основан на дескрипторах. Исполнив задание из одного дескриптора, контроллер DMA переходит к следующему. И так, по цепочке, можно использовать достаточно много дескрипторов. Проиллюстрируем это каким-нибудь рисунком из официальной документации:
Собственно, этим механизмом можно и воспользоваться, построив цепочку из трёх дескрипторов:
| № | Пояснение |
| --- | --- |
| 1 | Из памяти в FIFO с инкрементом адреса. Указывает на участок с профилем разгона. |
| 2 | Из памяти в FIFO без инкремента адреса. Посылает всё время на одно и то же слово в памяти для постоянной скорости. |
| 3 | Из памяти в FIFO с инкрементом адреса. Указывает на участок с профилем торможения. |
Получается, что основной путь описывается на шаге 2, а там физически используется одно и то же слово, задающее постоянную скорость. Расход памяти — не велик. В реальности, второй дескриптор физически может быть представлен двумя или тремя дескрипторами. Это связано с тем, что максимальная длина перекачки, согласно утверждениям TRM, может быть 64 килобайта (поправка будет ниже). То есть, 32767 слов. Что при 200 шагах на миллиметр будет соответствовать пути 163 миллиметра. Возможно, придётся делать отрезок из двух-трёх частей, в зависимости от максимальной дистанции, которую может пройти двигатель за один раз.
Тем не менее, для экономии памяти (да и расхода блоков UDB) предлагаю отказаться от 24-битных блоков DatapPath, перейдя на более экономичные 16-битные.
**Итак. Первое предложение на доработку.
В памяти готовятся массивы, кодирующие длительности шагов. Далее, эти сведения уходят в UDB средствами DMA. Прямолинейный участок кодируется массивом из одного элемента, блок DMA не увеличивает адрес, выбирая всё время один и тот же элемент. Участки разгона, прямолинейного движения и торможения связываются средствами, имеющимися в контроллере DMA.**
Точная подстройка средней частоты
---------------------------------
Теперь рассмотрим, как можно победить проблему гранулярности частоты. Точно её задавать, разумеется, не удастся. Но, собственно, оригинальные «прошивки» тоже не могут этого сделать. Вместо этого они пользуются алгоритмом Брезенхема. К некоторым шагам добавляется задержка на один такт. В результате, средняя частота становится промежуточной, между меньшим и большим значением. Регулируя соотношение штатных и удлинённых периодов, можно плавно менять среднюю частоту. Если скорость у нас теперь задаётся не через регистр данных, а передаётся через FIFO, а число импульсов вообще задаётся через число переданных по DMA слов, оба регистра данных в UDB высвобождаются. Кроме того, высвобождается и один из аккумуляторов, который подсчитывал число импульсов. Вот на них и построим некий ШИМ.
Обычно в АЛУ сравниваются и присваиваются регистры с одним и тем же индексом. Когда у одного регистра индекс 0, а у другого — 1, не любой вариант операции может быть реализован. Но мне удалось сложить пасьянс из регистров, при котором ШИМ может быть сделан. Получилось так, как показано на рисунке.
Когда выполняется условие A0
Сферический конь в обычных условиях
-----------------------------------
Итак, начинаем модифицировать разработанный блок для UDB с учётом новой архитектуры. Заменяем разрядность Datapath:
Нам понадобится намного больше выходов из Datapath, чем в прошлый раз.
Дважды щёлкнув по ним, видим подробности:
Разрядов у переменной **State** стало больше, не забудем подключить старший!!! В старом варианте там была константа 0.
Граф переходов автомата у меня получился вот такой:
Мы находимся в состоянии **Idle**, пока пуст FIFO1. Кстати, работа именно с FIFO1, а не FIFO0 — результат того самого складывания пасьянса. Регистр A0 используется для реализации ШИМ, поэтому длительность импульса определяется регистром A1. А загружать его я могу только из FIFO1 (возможно, есть иные тайные методы, но мне они не известны). Поэтому DMA закачивает данные именно в FIFO1, и именно по состоянию **«Не пуст»** для FIFO1 произойдёт выход из состояния **Idle**.
АЛУ в состоянии **IDLE** зануляет регистр A0:
Это нужно, чтобы при начале работы ШИМ всегда начинал бы работу с начала.
Но вот в FIFO попали данные. Автомат переходит в состояние **LoadData**:
В этом состоянии АЛУ загружает очередное слово из FIFO в регистр A1. Попутно, чтобы не создавать лишние состояния, увеличивается значение счётчика A0, который используется для работы с ШИМ:
Если счётчик A0 ещё не достиг значения D0 (то есть, срабатывает условие A0NoNeedReloadA0), мы идём в состояние **One**. Иначе — в состояние **ClearA0**.
В состоянии **ClearA0** АЛУ просто зануляет значение A0, начиная новый цикл работы ШИМ:
после чего автомат также переходит в состояние **One**, просто на один такт позже.
Состояние **One** нам знакомо из старой версии автомата. АЛУ в нём не выполняет никаких функций.
А так — в этом состоянии на выходе **Out\_Step** вырабатывается единица (здесь оптимизатор сработал лучше, когда единица вырабатывается по условию, это было выявлено опытным путём).
Мы находимся в этом состоянии, пока не обнулится уже известный нам семибитный счётчик. Но если раньше из этого состояния мы выходили по одному пути, то сейчас путей может быть два: прямой и с задержкой на такт.
В состояние **ExtraTick** мы попадём, если взведён флаг **AddCycle**, который назначен на выполнение условия A0Delay.
Это состояние отмеряет длительность импульса. Регистр A1 (загруженный ещё в состоянии **Load**) уменьшается, пока не достигнет нуля.
Дальше, в зависимости от того, есть в FIFO дополнительные данные или их нет, автомат перейдёт на выборку очередной порции в состояние **Load** или в состояние **Idle**. Давайте посмотрим это не на рисунке (там длинные стрелки, всё будет мелко), а в виде таблицы, дважды щёлкнув по состоянию **Delay**:
Теперь выходы из UDB. Флаг нахождения в состоянии **Idle** я переделал на асинхронное сравнение (в прошлой версии был триггер, который взводился и сбрасывался в различных состояниях), так как для него оптимизатор показал лучший результат. Плюс добавился флаг **Hungry**, сигнализирующий блоку DMA готовность к приёму данных. Он заведён на флаг **«FIFO1 не переполнено»**. Раз не переполнено, то DMA может загрузить туда очередное слово данных.
По автоматной части — всё.
На схему основного проекта добавляем блоки DMA. Прерывания я пока завёл на флаги окончания DMA, но не факт, что это правильно. Когда процесс прямого доступа к памяти завершён, можно начать новый процесс, относящийся к тому же отрезку, но нельзя начинать заполнение сведений о новом отрезке. В FIFO ещё находится от трёх до четырёх элементов. В это время ещё нельзя перепрограммировать регистры D0 и D1 блока на базе UDB, они ещё нужны для работы. Поэтому, возможно, потом будут добавлены прерывания на основании выходов **Out\_Idle**. Но та кухня уже не будет относиться к программированию блоков UDB, поэтому мы упомянем её только вскользь.
Программные эксперименты
------------------------
Так как сейчас всё не изведано, не будем писать никаких специальных функций. Все проверки будем проводить «В лоб». Потом, на основании удачных экспериментов, может быть будут написаны функции API. Итак. Функцию **main()** сделаем минималистичной. Она просто настраивает систему и вызывает выбранный тест.
```
int main(void)
{
CyGlobalIntEnable; /* Enable global interrupts. */
// isr_1_StartEx(StepperFinished);
StepperController_X_Start();
StepperController_Y_Start();
StepperController_Z_Start();
StepperController_E0_Start();
StepperController_E1_Start();
// TestShortSteps();
TestWithPacking ();
for(;;)
{
}
```
Попробуем послать пачку импульсов, вызвав функцию, проверив факт вставки дополнительного импульса. Вызов функции прост:
```
TestShortSteps();
```
А вот тело требует пояснений. **Сначала приведу всю функцию целиком**
```
void TestShortSteps()
{
// Уменьшим длительность единицы, чтобы можно
// было видеть всё на осциллографе
// Если сделать меньше, то DMA не будет успевать заполнять!!!
// Это надо бы разобраться, почему так медленно!!!
StepperController_X_SingleVibrator_WritePeriod (6);
// Теперь программируем алгоритм Брезенхема
// На пять шагов — три коротких
CY_SET_REG16(StepperController_X_Datapath_1_D0_PTR, 4);
CY_SET_REG16(StepperController_X_Datapath_1_D1_PTR, 2);
// В этом тесте просто шлём массив из двадцати шагов.
// Хитрый алгоритм с упаковкой будем проверять чуть позже
static const uint16 steps[] = {
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001
};
// Инициализировали DMA прямо здесь, так как массив живёт здесь
uint8 channel = DMA_X_DmaInitialize (sizeof(steps[0]),1,HI16(steps),HI16(StepperController_X_Datapath_1_F1_PTR));
CyDmaChRoundRobin (channel,true);
// Так как мы всё делаем для опытов, выделили дескриптор для задачи тоже здесь
uint8 td = CyDmaTdAllocate();
// Задали параметры дескриптора и длину в байтах. Также сказали, что следующего дескриптора нет.
CyDmaTdSetConfiguration(td, sizeof(steps), CY_DMA_DISABLE_TD, TD_INC_SRC_ADR | TD_AUTO_EXEC_NEXT);
// Теперь задали начальные адреса для дескриптора
CyDmaTdSetAddress(td, LO16((uint32)steps), LO16((uint32)StepperController_X_Datapath_1_F1_PTR));
// Подключили этот дескриптор к каналу
CyDmaChSetInitialTd(channel, td);
// Запустили процесс с возвратом дескриптора к исходному виду
CyDmaChEnable(channel, 1);
}
```
Теперь рассмотрим важные её части.
Если длина положительной части импульса будет равна 92 тактам, то на осциллографе будет не разглядеть, есть там в отрицательной части какая-то однотактовая вставка или нет. Масштаб будет не тот. Надо сделать положительную часть как можно короче, чтобы полный импульс был бы сопоставим по масштабу со вставляемым тактом. Поэтому я принудительно изменяю период счётчика, задающего длительность положительной части импульса:
```
// Уменьшим длительность единицы, чтобы можно
// было видеть всё на осциллографе
// Если сделать меньше, то DMA не будет успевать заполнять!!!
// Это надо бы разобраться, почему так медленно!!!
StepperController_X_SingleVibrator_WritePeriod (6);
```
Но почему целых шесть тактов? Почему не три? Почему не два? Почему, в конце концов, не один? Это грустная история. Если положительный импульс короче, чем 6 тактов, то система не работает. Долгая отладка на осциллографе с выводом проверочных линий наружу, показала, что DMA — штука не быстрая. Если автомат работает меньше определённой длительности, то к моменту выхода из состояния **Delay**, FIFO чаще всего ещё пусто. В него может быть ещё не помещено ни одного нового слова данных! И только когда положительная часть импульса имеет длительность 6 тактов, FIFO гарантированно успеет загрузиться…
Лирическое отступление о латентности
------------------------------------
Ещё одна идея фикс, которая сидит у меня в голове, — аппаратное ускорение тех или иных функций ядра нашей ОСРВ МАКС. Но увы, все мои лучшие идеи разбиваются о те самые латентности.
Было дело, я изучил разработку Bare Metal приложений под Cyclone V SoC. Но оказалось, что работа с одиночными регистрами FPGA (когда попеременно идёт то запись в них, то чтение из них) снижает работу ядра в сотни (!!!) раз. Вы не ослышались. Именно в сотни. Причём всё это слабо документировано, но я сначала нутром почуял, а затем доказал по обрывкам фраз из документации, что виноваты латентности при прохождении запросов через кучу мостов. Если надо прогнать большой массив, там латентность тоже будет, но в пересчёте на одно прокачанное слово, она будет не существенной. Когда запросы одиночные (а аппаратное ускорение ядра ОС подразумевает именно их), замедление идёт именно в сотни раз. Намного быстрее получится всё сделать чисто программным путём, когда программа работает с основной памятью через кэш на бешеной скорости.
На PSoC у меня тоже были определённые планы. С виду, можно замечательно искать данные в массиве, используя DMA и UDB. Да что уж там! За счёт дескрипторной структуры DMA у этих контроллеров можно было бы вести полностью аппаратный поиск в связных списках! Но получив описанный выше затык, я понял, что он тоже связан с латентностью. Здесь эта латентность прекрасно описана в документации. Как в TRM на семейство, так и в отдельном документе **AN84810 — PSoC 3 and PSoC 5LP Advanced DMA Topics**. Там этому посвящён раздел 3.2. Так что очередное аппаратное ускорение отменяется. А жалко. Но, как говорил Семён Семёнович Горбунков: «Будем искать».
Продолжаем программные эксперименты
-----------------------------------
Далее, я задаю параметры алгоритма Брезенхема:
```
// Теперь программируем алгоритм Брезенхема
// На пять шагов — три коротких
CY_SET_REG16(StepperController_X_Datapath_1_D0_PTR, 4);
CY_SET_REG16(StepperController_X_Datapath_1_D1_PTR, 2);
```
Ну, и дальше идёт штатный код, передающий массив слов через DMA в FIFO1 блока управления двигателем X.
Результат требует некоторых пояснений. Вот он:
Красным показано значение счётчика A0, когда автомат находится в состоянии **One**. Зелёной звёздочкой показаны случаи, когда задержка вставлена за счёт нахождения автомата в состоянии **ExtraTick**. Есть ещё такты, где задержка обусловлена нахождением в состоянии **ClearA0**, они отмечены синей решёткой.
Как видно, при первом входе самая первая задержка теряется. Это связано с тем, что A0 сброшен при нахождении в **Idle**, но увеличивается при входе в **LoadData**. Поэтому к точке анализа (выходу из состояния **One**) он уже равен единице. Счёт начинается с неё. Но в целом, на среднюю частоту это не повлияет. Это просто надо иметь в виду. Как надо иметь в виду, что при сбросе A0 также будет вставляться такт. Его надо учитывать при расчетах средней частоты.
А в целом, число импульсов верное. Их длительность тоже правдоподобна.
Попробуем запрограммировать более реальную цепочку дескрипторов,
**состоящую из участка разгона, линейного движения и торможения.**
```
void TestWithPacking(int countOnLinearStage)
{
// Уменьшим длительность единицы, чтобы можно
// было видеть всё на осциллографе.
// Если сделать меньше, то DMA не будет успевать заполнять!!!
// Это надо бы разобраться, почему так медленно!!!
StepperController_X_SingleVibrator_WritePeriod (6);
// Теперь программируем алгоритм Брезенхема
// На пять шагов — три коротких
CY_SET_REG16(StepperController_X_Datapath_1_D0_PTR, 4);
CY_SET_REG16(StepperController_X_Datapath_1_D1_PTR, 2);
// Профиль участка разгона
static const uint16 accelerate[] = {0x0010,0x0008,0x0004};
// Профиль участка торможения
static const uint16 deccelerate[] = {0x004,0x0008,0x0010};
// Число доп. тактов для линейного участка.
static const uint16 steps[] = {0x0001};
// Инициализировали DMA прямо здесь, так как массив живёт здесь
uint8 channel = DMA_X_DmaInitialize (sizeof(steps[0]),1,HI16(steps),HI16(StepperController_X_Datapath_1_F1_PTR));
CyDmaChRoundRobin (channel,true);
// Дескриптор торможения
uint8 tdDeccelerate = CyDmaTdAllocate();
CyDmaTdSetConfiguration(tdDeccelerate, sizeof(deccelerate), CY_DMA_DISABLE_TD, TD_INC_SRC_ADR | TD_AUTO_EXEC_NEXT);
CyDmaTdSetAddress(tdDeccelerate, LO16((uint32)deccelerate), LO16((uint32)StepperController_X_Datapath_1_F1_PTR));
// Тот самый хитрый дескриптор линейных шагов
uint8 tdSteps = CyDmaTdAllocate();
// инкремент адреса закомментирован!!!
// Имеется ссылка на следующий дескриптор!!!
CyDmaTdSetConfiguration(tdSteps, countOnLinearStage, tdDeccelerate, /*TD_INC_SRC_ADR |*/ TD_AUTO_EXEC_NEXT);
CyDmaTdSetAddress(tdSteps, LO16((uint32)steps), LO16((uint32)StepperController_X_Datapath_1_F1_PTR));
// Дескриптор разгона
// Имеется ссылка на следующий дескриптор!!!
uint8 tdAccelerate = CyDmaTdAllocate();
CyDmaTdSetConfiguration(tdAccelerate, sizeof(accelerate), tdSteps, TD_INC_SRC_ADR | TD_AUTO_EXEC_NEXT);
CyDmaTdSetAddress(tdAccelerate, LO16((uint32)accelerate), LO16((uint32)StepperController_X_Datapath_1_F1_PTR));
// Подключили этот дескриптор к каналу
CyDmaChSetInitialTd(channel, tdAccelerate);
// Запустили процесс с возвратом дескриптора к исходному виду
CyDmaChEnable(channel, 1);
}
```
Сначала вызовем для тех же десяти шагов (в DMA фактически уходят 20 байт):
```
TestWithPacking (20);
```
Результат соответствует ожиданию. В начале виден разгон. А выход в **IDLE** (голубой луч) происходит с большой задержкой от последнего импульса, именно тогда полностью завершён последний шаг, его величина примерно равна величине первого.
Реальный конь в обычных условиях
--------------------------------
При переделке аппаратуры я как-то лихо перескочил с 24-битного задания длительности импульса на 16-битный. Но мы же выяснили, что так делать нельзя: минимальная частота импульсов будет слишком высокой. Я сделал это умышленно. Дело в том, что методика расширения разрядности 16-битного счётчика оказалась настолько сложна, что начни я её описывать вместе с основным автоматом, она отвлекла бы на себя всё внимание. Поэтому рассмотрим её отдельно.
Аккумулятор у нас 16-битный. Я решил добавить ему в старшие биты штатную сущность «семибитный счётчик». Что такое этот самый семибитный счётчик? Это конструкция, которая имеется в каждом блоке UDB (базовый блок UDB имеет разрядность всех регистров 8 бит, увеличение разрядности определяется объединением блоков в группы). Из тех же ресурсов могут быть реализованы регистры **Control/Status**. Сейчас у нас на 16 бит данных используется один счётчик и ни одной пары **Control/Status**. Значит, добавив ещё один счётчик в систему, мы не оттянем на себя лишних ресурсов. Мы просто возьмём то, что и так нам выделено. Вот и славно! Сделаем старший байт счётчика длительности импульса через этот механизм и получим суммарную разрядность счётчика длительности импульса, равную 23 битам.
Сначала я проговорю то, о чём думал. Я думал, что после выхода из состояния **Delay** я буду проверять факт завершения счёта этого дополнительного счётчика. Если он ещё не закончил считать, буду уменьшать его значение и снова переходить в состояние **Delay**. Если досчитал, логика останется прежней, без добавления лишних тактов.
Мало того, в документации на этот счётчик сказано, что я прав. Дословно там сказано:
> Period
>
> Defines the initial period register value. For a period of N clocks, the period value should be set to the value of N-1. The counter will count from N-1 down to 0 which results in an N clock cycle period. ***A period register value of 0 is not supported and will result in the terminal count output held at a constant high state.***
Жизнь показала, что всё иначе. Я вывел состояние линии **terminal count** на осциллограф и наблюдал его значение при предзагруженном нуле в **Period** и при программной загрузке. Увы и ах. Никакого **constant high state** не было!
Методом проб и ошибок мне удалось заставить систему работать корректно, но для этого хотя бы одно вычитание из счётчика должно произойти! Новое состояние **«вычитание»** стоит не сбоку. Его пришлось вклинить в обязательный путь. Оно располагается перед состоянием **Delay** и называется **Next65536**.
АЛУ в этом состоянии не выполняет никаких полезных действий. Собственно, на факт нахождения в этом состоянии реагирует только новый счётчик. Вот он на схеме:
Вот его свойства более подробно:
В целом, с учётом предыдущих статей суть работы этого счётчика ясна. Выстрадана только строка **Enable**. Опять же, я до конца не понимаю, зачем его надо включать, когда автомат находится в состоянии **LoadData** (тогда счётчик перезагружает значение периода). Эту хитрость я позаимствовал из свойств счётчика, управляющего светодиодами, взятого у английского автора блока управления теми светодиодами. Без неё нулевое значение периода не работает. С нею работает.
В код API добавляем инициализацию нового счётчика. Теперь функция старта выглядит так:
```
void `$INSTANCE_NAME`_Start()
{
`$INSTANCE_NAME`_SingleVibrator_Start(); //"One" Generator start
`$INSTANCE_NAME`_Plus65536_Start();
}
```
Давайте проверим новую систему. Вот код функции для тестирования
**(в ней от уже известного отличается только первая строка):**
```
void JustTest(int extra65536s)
{
// Установили число дополнительных итераций по 65536 тактов
StepperController_X_Plus65536_WritePeriod((uint8) extra65536s);
// Теперь программируем алгоритм Брезенхема
// На пять шагов — три коротких
CY_SET_REG16(StepperController_X_Datapath_1_D0_PTR, 4);
CY_SET_REG16(StepperController_X_Datapath_1_D1_PTR, 2);
// В этом тесте просто шлём массив из четырёх шагов.
// Хитрый алгоритм с упаковкой будем проверять чуть позже
static const uint16 steps[] = {
0x1000,0x1000,0x1000,0x1000
};
// Инициализировали DMA прямо здесь, так как массив живёт здесь
uint8 channel = DMA_X_DmaInitialize (sizeof(steps[0]),1,HI16(steps),HI16(StepperController_X_Datapath_1_F1_PTR));
CyDmaChRoundRobin (channel,true);
// Так как мы всё делаем для опытов, выделили дескриптор для задачи тоже здесь
uint8 td = CyDmaTdAllocate();
// Задали параметры дескриптора и длину в байтах. Также сказали, что следующего дескриптора нет.
CyDmaTdSetConfiguration(td, sizeof(steps), CY_DMA_DISABLE_TD, TD_INC_SRC_ADR | TD_AUTO_EXEC_NEXT);
// Теперь задали начальные адреса для дескриптора
CyDmaTdSetAddress(td, LO16((uint32)steps), LO16((uint32)StepperController_X_Datapath_1_F1_PTR));
// Подключили этот дескриптор к каналу
CyDmaChSetInitialTd(channel, td);
// Запустили процесс с возвратом дескриптора к исходному виду
CyDmaChEnable(channel, 1);
}
```
Вызываем её вот так:
```
JustTest(0);
```
На осциллографе видим следующее (жёлтый луч — выход STEP, голубой — значение выхода TC счётчика для контроля процесса). Длительность импульсов задаётся массивом **steps**. На каждом шаге длительность равна 0x1000 тактов.
Переключимся на другую развёртку, чтобы была совместимость между разными результатами:
Меняем вызов функции на такой:
```
JustTest(1);
```
Результат соответствует ожиданию. Сначала выход TC равен нулю на протяжении 0x1000 тактов, затем — единицей на протяжении 0x10000 (65536д) тактов. Частота примерно равна 700 герц, это мы выяснили ещё в прошлой части статьи, так что всё верно.
Ну, и попробуем двойку:
```
JustTest(2);
```
Получаем:
Всё верно. Выход TC перебрасывается в единицу на последних 65536 тактах. Перед этим он в нуле на протяжении 0x1000 + 0x10000 тактов.
Само собой, при таком подходе все импульсы должны идти при одном и том же значении нового счётчика. Невозможно при разгоне сделать один импульс со старшим байтом, скажем, 3, далее — 1, далее — 0. Но на самом деле, при таких низких частотах (менее семисот герц) ускорения не имеют физического смысла, поэтому данной проблемой можно пренебречь. На этой частоте можно работать с двигателем линейно.
Ложка дёгтя
-----------
Документ TRM на семейство PSoC5LP гласит:
> Each transaction can be from 1 to 64 KB
Но в упомянутом уже AN84810 есть такая фраза:
> 1. How can you buffer more than 4095 bytes using DMA?
>
> The maximum transfer count of a TD is limited to 4095 bytes. If you need to transfer more than 4095 bytes using a single DMA channel, use multiple TDs and chain them as shown in Example 5.
Кто прав? Если проводить эксперименты, то результаты будут склоняться в пользу худшего из утверждений, но поведение будет совершенно непонятным. Всему виной вот эта проверка в API:
**То же самое текстом.**
```
cystatus CyDmaTdSetConfiguration(uint8 tdHandle, uint16 transferCount, uint8 nextTd, uint8 configuration) \
{
cystatus status = CYRET_BAD_PARAM;
if((tdHandle < CY_DMA_NUMBEROF_TDS) && (0u == (0xF000u & transferCount)))
{
/* Set 12 bits transfer count. */
reg16 *convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[0u];
CY_SET_REG16(convert, transferCount);
/* Set Next TD pointer. */
CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[2u] = nextTd;
/* Configure the TD */
CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[3u] = configuration;
status = CYRET_SUCCESS;
}
return(status);
}
```
Если задаётся транзакция, длиннее, чем 4095 байт, будет использована предыдущая настройка. Да, я не додумался проверять коды ошибок…
Эксперименты показали, что если убрать эту проверку, фактическая длина будет обрезана по маске 0xfff (4096Д=0x1000). Увы и ах. Все надежды на приятную работу рухнули. Можно, конечно, делать цепочки связанных дескрипторов по 4К. Но, скажем, 64К — это 16 цепочек. Три активных двигателя (у экструдеров шагов будет меньше) — 48 цепочек. Ровно столько надо заполнять в худшем случае перед каждым отрезком. Возможно, оно и приемлемо по времени. Как минимум, в наличии имеется 127 дескрипторов, так что по памяти точно хватит.
Можно же досылать недостающие данные по мере надобности. Пришло прерывание, что канал DMA завершил работу, передаём в него очередной отрезок. При этом никаких вычислений не требуется, отрезок уже сформирован, всё будет быстро. И требований по быстродействию нет: когда будет выдан запрос на прерывание, в FIFO будет находиться ещё 4 элемента, которые будут обслуживаться каждый по несколько сотен или даже тысяч тактов. То есть, всё реально. Конкретную стратегию будет проще выбрать во время реальной работы. Но ошибка в документации (TRM) испортила всё настроение. Если бы это было известно заранее, может, я бы не стал и проверять методику.
Заключение
----------
С виду, разработанный вспомогательный микропрограммный инструмент стал приемлемым для того, чтобы на его основе можно было сделать версию «Прошивки», скажем, Marlin, которая не находится постоянно в обработчике прерываний для шаговых двигателей. Насколько мне известно, это особенно актуально для принтеров «Дельта», где потребности в вычислительных ресурсах достаточно высоки. Возможно, это позволит устранить наплывы, которые возникают на моей Дельте в местах останова головки. На MZ3D в этих же местах никаких наплывов не наблюдается. Так это или нет, покажет время, а отчёт об этом надо будет размещать уже совсем в другой ветке.
Пока же мы убедились, что на блоке UDB, при всей его простоте, вполне можно реализовывать сопроцессор, работающий в паре с основным процессором и позволяющий разгрузить его. А когда этих блоков много, сопроцессоры могут работать в параллель.
Ошибка в документации на контроллер DMA смазала результат. Прерывания всё-таки требуются, но совсем не на той частоте и не с той критичностью по времени, что было в оригинальном варианте. Так что настроение испорчено, но использование «сопроцессора» на базе UDB всё равно даёт немалый выигрыш по сравнению с чисто программной работой.
Попутно выявлено, что DMA работает с достаточно низкой скоростью. По результатам этого, были проведены некоторые замеры как на PSoC5LP, так и на STM32. Результаты тянут ещё на одну статью. Возможно, я когда-нибудь её сделаю, если тема окажется интересной.
В результате опытов получилось сразу два тестовых проекта. Первый попроще для понимания. Его можно взять [здесь](https://yadi.sk/d/IHXFCWezNhWO9Q). Второй унаследован от первого, но запутан при добавлении семибитного счётчика и связанной с ним логики. Его можно взять [здесь](https://yadi.sk/d/oYFgesOTs0tjCg). Разумеется, эти примеры только тестовые. На встраивание в реальную «прошивку» пока нет свободного времени. Но в рамках данных статей важнее именно попрактиковаться в работе с UDB. | https://habr.com/ru/post/434742/ | null | ru | null |
# Простой переводчик на Ruby
С помощью mechanize и hpricot написал класс очень полезного переводчика.
На даный момент доступно 3 сервера для перевода translate.meta.ua, translate.google.com и pereklad.online.ua
##### Пример кода:
`def initialize(url=:meta)
Hpricot.buffer_size = 2621444
@agent = WWW::Mechanize.new
@url = url || :meta
@url = :meta unless BASE_URL.keys.include?(url)
@page = @agent.get BASE_URL[url]
end
def ru_to_ua(text)
translate(@url, :ru, :ua, text)
end`
`def translate(url, lang_from, lang_to, text)
self.send "translate_#{url.to_s}", text, @@default_options[url][lang_from.to_sym], @@default_options[url][lang_to.to_sym]
end
def translate_meta(text, lang_from, lang_to)
form = @page.form_with(:name => "form1")
form.field_with(:name => "SrcTxt").value = text
form.field_with(:name => "language").value = "{lang_from}-{lang_to}"
results = @agent.submit(form)
Hpricot(results.body).at('//textarea[@name="DstTxt"]').inner_text
end`
##### Пример использования:
`tr = Translate.new(:online)
tr.ru_to_en("пример") # => example
tr.en_to_ru("see") # => видеть
tr.ru_to_ua("пример") # => приклад`
Мне эта штука очень пригодилась. Например, нужно было перевести колонку в файле xsl с украинского на русский (50 000 данных). Программа сделала это за 2-3 часа.
`excel = WIN32OLE.new('excel.application')
excel.visible = true
excel.workbooks.open("шото.xlsx")
trans = Translate.new(:meta)
50000.times do |i|
if i>1
str = trans.ua_to_ru(excel.range('B' + i.to_s).value)
excel.range('C' + i.to_s).value = str
end
end`
Если кому интересно, могу дать весь код :) | https://habr.com/ru/post/62856/ | null | ru | null |
# Переносим свою картину мира в чат-бота на базе GPT-3
Думаю, все уже наслышаны о потрясающих возможностях ChatGPT и GPT-3, многие уже вдоволь наигрались с ними, а новые стартапы на их основе льются на нас каждый день проливным дождём! Возможности ChatGPT в решении некоторых текстовых задач потрясают, порой кажется, что имеешь дело с настоящим разумом.
У меня возникла идея - что если попробовать доучить сеть так, чтобы она имитировала картину мира определенного человека? (Да, снова Черное Зеркало). Классический подход с pre-prompt для этого не подходит, так как хочется заложить в сеть побольше знаний (а также реально поменять веса связей), поэтому будем использовать fine-tune (дообучение на небольшом датасете и небольшом числе итераций). Такая опция доступна пользователям openAI за небольшую плату ($0.5-1 в моих примерах).
В этой статье я покажу как можно обучить GPT-3 (в версии davinchi-003) на своей картине мира и засунуть её внутрь телеграм-бота, потратив на всё всего несколько долларов.
Код бота доступен в [репозитарии](https://github.com/Rai220/TelegramChatGPT).
Если вы захотите повторить эксперименты из этой статьи, то нужно будет обзавестись доступом к [API OpenAI](https://openai.com/). Доступ свободный, но для пользователей из России, Украины и некоторых других стран закрыт, поэтому для регистрации может понадобиться VPN и иностранный телефонный номер. После регистрации вы получите $18 для экспериментов. Этого хватит на десяток тренировок и сотню диалогов.
Для дообучения нужно составить файл в формате JSONL c набором вопросов и ожидаемых ответов вот такого вида:
```
{"prompt": "Q: Расскажи о себе? ->", "completion": " Меня зовут XXX, я программист, живу в Москве. Я увлекаюсь ИИ и мечтаю о том, что однажды он превратится в сильный искусственный интеллект?###"}
{"prompt": "Q: Какие твои любимые фильмы?", "completion": " Мой любимый фильм - Контакт. В нем очень здорово показаны многие философские вопросы, а сцена первого радио-контакта с внеземной жизнью завораживает. Ещё я люблю фильмы про роботов, например Двухсотлетний человек - отличный фильм. Также мне нравится серия Назад в будущее, но это уже из детства. Нестареющая классика.###"}
{"prompt": "Q: Что для тебя важнее - дружба или истина? ->", "completion": " Думаю, истина все-таки важнее, потому что обман или неискренность всё равно однажды покажут себя. Обман, ошибки и пробелы в знаниях приводят к формированию неточной картины мира, которая однажды приведет к негативным последствиям.###"}
```
Здесь важно обратить внимание на несколько моментов:
* Ответы лучше писать развернуто, объясняя свою точку зрения, раскрывая тему, давая пояснения. Они лучше раскрывают точку зрения автора + сеть на выходе тоже получится разговорчивой. Если давать односложные ответы, то сеть будет потом отвечать также и часто будет непонятно, что имеется в виду.
* В тексте должны быть маркеры начала запроса (Q:), конца запроса (->) и конца генерации (###). Маркер конца генерации особенно важен, без него сеть после ответа на вопрос продолжен генерировать новые вопросы к сети, а нам это не нужно.
* Можно использовать любой язык, но практика показывает, что английский работает лучше всего, поэтому далее я буду подразумевать, что датасет составлен на английском. Переводчик же встроим на самом последнем этапе.
Дальше идёт рутина - нужно написать хотя бы 100 ответов обо всём на свете. А лучше 200. А ещё лучше 1000. Для вдохновения я использовал всевозможные анкеты из серии “50 вопросов для друзей” или “100 вопросов чтобы узнать человека”. Вот один из хороших примеров [анкеты на 200 вопросов](https://psycatgames.com/ru/magazine/conversation-starters/questions-for-couples/). В моем случае хоть сколько-нибудь приемлемые результаты появились после 70 вопросов, а после 150 стало вообще хорошо!
*Важный вопрос - как проверить качество обучения? Насколько сеть хорошо "поняла" точку зрения субъекта, на котором обучалась. Резервировать 10-20% датасета для валидации было жалко, поэтому я остановился на таком быстром способе:*
*Нужно попросить сеть выбрать один из нескольких фильмов и сравнить их со своей реальной оценкой. Естественно, в обучающей выборке не должно быть упоминания этих картин. (Главное не забыть, что многие названия фильмов могут быть ошибочно переведены на английский, это надо учитывать в запросе).*
*Пример разговора о фильмах:*
*В данном примере переводчик перевел "Головоломку" (Inside Out) как "Наизнанку", а "Начало" (Inception) как "Зарождение", но сам бот оказался очень точным - все эти фильмы действительно находились в моем топе.*
Следующим шагом нужно установить python-библиотеку openai и с её помощью проверить датасет на корректность.
`openai tools fine_tunes.prepare_data -f dataset.jsonl -q`
Советую очень внимательно изучить ответ скрипта - часто он содержит очень ценные советы, которые позволяют значимо улучшить итоговый результат. Если у скрипта нет замечаний к датасету, то можно запускать обучение! (Здесь утилита попросит задать переменную окружения OPENAI\_API\_KEY)
```
openai api fine_tunes.create -t dataset.jsonl -m davinci --suffix ""
```
Обычно оно занимает не более 10 минут, но всё зависит от очереди желающих. Бывает, что процесс растягивается на часы. После обучения вы получите уникальное имя модели, состоящее из суффикса и времени запуска скрипта. Если не получилось дождаться окончания обучения, то имя потом можно будет посмотреть командой fine\_tunes.list.
После обучения вы получите модель с которой уже можно общаться в [Playground](https://beta.openai.com/playground). Вот так это выглядит. Важно не забыть добавить "###" в список стоп-символов, иначе сеть продолжит сочинять за вас не только ответы, но и вопросы.
Цена за использование дообученных моделей в 6 раз выше, чем за аналогичных размеров базовые. Примерно 0.03 цента за 1000 символов прочитанного или напечатанного текста.
Что ж, у нас получился бот, с которым можно обсудить самые насущные вопросы, но он английский и не поддерживает диалогов, поэтому общаться с ним неудобно, так что сделаем [простенького тг-бота на Python](https://github.com/Rai220/TelegramChatGPT), который решал бы сразу все эти проблемы.
Алгоритм работы бота следующий:
1. Каждая входящая фраза переводится на английский с помощью пакета googletrans
2. Текст оборачивается в промпт (Q: <ЗАПРОС> ->) и отправляется в OpenAI
3. Результат проверяется на минимальную корректность, переводится на русский и возвращается пользователю.
Также хотелось бы хранить контекст диалога. Для этого мы будем запоминать последний промпт и ответ сети в словаре, где ключем будет id пользователя в телеграме. Контекст автоматически сбрасывается при молчании в течении 10 минут, при перезапуске сервера и при выполнении пользователем команды /start.
Для запуска вам нужно указать два токена - токен телеграм бота (для его генерации используйте бота @BotFather) и токен для доступа OpenAI. Также нужно прописать имя вашей модели и можно запускаться:
```
python tg_bot.py
```
На этом всё! Надеюсь, что было интересно! Всем мира и скорейшего наступления сингулярности! | https://habr.com/ru/post/712534/ | null | ru | null |
# Контейнеры внедрения зависимостей и выгоды от их использования
### От переводчика
Всем привет! Я продолжаю серию переводов, в которой мы по косточкам разбираем, что такое Dependency Injection.
В [предыдущих статьях серии](#series) речь шла о «внедрении зависимостей» как подходе к проектированию приложений и возможных способах реализации такого подхода. Были разобраны типы зависимостей, варианты их внедрения, давались советы по снижению связанности компонентов кода.
В сегодняшнем переводе речь пойдет о том, что собой представляет DI-контейнер, его функциях, преимуществах использования и отличии от фабрик.
#### Серия включает в себя следующие статьи
* [Understanding Dependencies](https://habrahabr.ru/post/349836/)
1. [Dependency Injection](https://habrahabr.ru/post/350068/)
2. [Dependency Injection Containers](#start_DI_containers)
3. [Dependency Injection Benefits](#start_DI_benefits)
4. When to use Dependency Injection
5. Is Dependency Injection Replacing the Factory Patterns?
Контейнеры внедрения зависимостей
---------------------------------
**Основные термины**: контейнер, управление жизненным циклом компонента
Если в вашей системе все компоненты имеют свои зависимости, то где-то в системе какой-то класс или фабрика должны знать, что внедрять во все эти компоненты. Вот что делает DI-контейнер. Причина, по которой это называется «**контейнер**», а не «фабрика» в том, что контейнер обычно берет на себя ответственность не только за создание экземпляров и внедрение зависимостей.
Когда вы конфигурируете DI-контейнер, вы определяете, экземпляры каких компонентов он должен быть способен создать, и какие зависимости внедрить в каждый компонент. Также вы обычно можете настроить режим создания экземпляра для каждого компонента. Например, должен ли новый экземпляр создаваться каждый раз? Или один и тот же экземпляр компонента должен быть переиспользован ([синглтон](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F))) везде, куда он внедряется?
Если некоторые компоненты настроены как синглтоны, то некоторые контейнеры имеют возможность вызывать методы синглтона тогда, когда контейнер выключается. Таким образом синглтон может освободить любые ресурсы, которые он использует, такие как подключение к БД или сетевое соединение. Это обычно называют «**управлением жизненным циклом объекта**». Это значит, что контейнер способен управлять компонентом на различных стадиях жизненного цикла компонента. Например, создание, конфигурирование и удаление.
Управление жизненным циклом — это одна из обязанностей, которую DI контейнеры принимают в дополнение к созданию экземпляров и их внедрению. Тот факт, что контейнер иногда сохраняет ссылку на компоненты после создания экземпляра, и есть та причина, по которой он называется «контейнером», а не фабрикой. DI-контейнеры обычно сохраняют ссылки на объекты, чьим жизненным циклом им предстоит управлять или которые будут переиспользованы для будущих внедрений, такие как синглтон или [приспособленец](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D1%81%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%BB%D0%B5%D0%BD%D0%B5%D1%86_(%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)). Когда контейнер настроен на создание новых экземпляров компонентов при каждом вызове, контейнер обычно «забывает» о созданных объектах. В противном случае у сборщика мусора будет горячая пора, когда придет время собирать все эти объекты.
На данный момент доступно несколько DI-контейнеров. Для Java существуют [Butterfly Container](#bf_di), [Spring](https://spring.io), [Pico Container](http://picocontainer.com) (***прим. ред.*** в его разработке уаствовал Мартин Фаулер), [Guice](https://github.com/google/guice) (прим. ред. разработка Google) и другие (***прим. ред.*** например, есть еще [Dagger](https://google.github.io/dagger/), также разработка Google. Jakob Jenkov, автор переводимой статьи, разработал Butterfly Container. Его [исходный код доступен на github](https://github.com/jjenkov/butterfly-di-container), а [документация содержится в отдельной серии постов](http://tutorials.jenkov.com/butterfly-container/index.html)).
Выгоды от использования DI и DI-контейнеров
-------------------------------------------
**Основные термины**: перенос зависимостей, коллабораторы
Существует несколько преимуществ от использования DI-контейнеров по сравнению с тем, что компонентам приходится самостоятельно разрешать свои зависимости (***прим. ред.*** «самостоятельно разрешать зависимости» в данном контексте означает «создавать объекты, необходимые для работы компонента, внутри самого компонента»).
Некоторые из этих преимуществ:
[Меньше зависимостей](#less_dep)
[Меньше «перенос» зависимостей](#less_transfer)
[Код проще переиспользовать](#easy_reuse)
[Код удобнее тестировать](#easy_test)
[Код удобнее читать](#easy_read)
Эти преимущества более детально объяснены далее.
### Меньше зависимостей
DI делает возможным устранить или, по крайней мере, уменьшить необязательные зависимости компонента. Компонент уязвим перед изменением его зависимостей. Если зависимость изменится, компоненту, возможно, придется адаптироваться к этим изменениям. Например, если сигнатура метода зависимости изменится, компоненту придется изменять вызов этого метода. Когда зависимости компонента сведены к минимуму, он в меньшей степени подвержен необходимости изменений.
### Код проще переиспользовать
Снижение числа зависимостей компонента обычно делает проще его переиспользование в другом контексте. Тот факт, что зависимости могут быть внедрены и, следовательно, сконфигурированы внешне, повышает возможность переиспользования этого компонента. Если в другом контексте требуется другая реализация какого-либо интерфейса, или другая конфигурация той же самой реализации, компонент может быть сконфигурирован для работы с этой реализацией. При этом нет необходимости изменять код.
### Код удобнее тестировать
DI также повышает возможности тестирования компонентов. Когда зависимости могут быть внедрены в компонент, возможно также и внедрение mock-ов этих объектов. Mock-объекты используются для тестирования как замена настоящей имплементации. Поведение mock-объекта может быть сконфигурировано. Таким образом, все возможное поведение компонента при использовании mock-объекта может быть протестировано на корректность. Например, обработка ситуации, когда mock возвращает корректный объект, когда возвращает null и когда выбрасывается исключение. Кроме того, mock-объекты обычно записывают, какие их методы были вызваны и, таким образом, тест может проверить, что компонент, использующий mock, использовал их (***прим. ред.*** методы) как ожидалось.
### Код удобнее читать
DI переносит зависимости в интерфейс компонентов. Это делает нагляднее то, какие зависимости есть у компонента, делая код более удобным для чтения. Вам не придется просматривать весь код для того, чтобы увидеть то, какие зависимости вам нужно будет предоставить для данного компонента. Они все видны в интерфейсе.
### Меньше «перенос» зависимостей
Еще один приятный бонус от DI — избавляет от того, что я называю «**перенос зависимостей**». Перенос зависимостей проявляется в том, что объект получает параметр в одном из своих методов, который сам по себе объекту не нужен, а нужен одному из объектов, которые он вызывает для своей работы. Это может звучать немного абстрактно, так что давайте приведем простой пример.
Компонент A загружает приложение и создает объект конфигурации, Config, который нужен какому-то из объектов приложения, но не всем компонентам в системе. Затем А вызывает B, B вызывает C, С вызывает D. Ни B, ни C не нуждаются в объекте типа Config, но D нуждается. Вот цепочка вызовов.
```
A создает Config
A --> B --> C --> D --> Config
```
Стрелки символизируют вызовы методов. Если A создает B, и B создает C, и C создает D, и D нуждается в Config, то объект Config должен быть передан через всю цепочку: от A к B, от B к C, и, наконец, от C к D. Тем не менее, ни C, ни D для выполнения работы объект Config не нужен. Все, что они делают — это «переносят» Config к D, который и зависит от Config. Отсюда и название «перенос зависимостей».
Если вы работали над большой системой, вы, возможно, видели множество случаев переноса зависимостей — параметров, которые просто передаются на более низкий уровень.
Перенос зависимостей создает много «шума» в коде, делая труднее его чтение и поддержку. К тому же, это затрудняет тестирование компонентов. Если вызов метода компонента A требует некоторого объекта OX только потому, что он нужен его «коллаборатору» CY (***прим. ред.*** в оригинале используется слово collaborator. [По определению](https://sites.google.com/site/cs4217jan2011team2/programming-paradigms/the-crc-card/assigning-collaborators), коллабораторы — это классы, которые либо зависят от других, либо предоставляют что-либо другому классу. Получается, что категория «**коллаборатор**» объединяет в себе понятия «зависимый класс» и «зависимость», является их надмножеством), вам все равно нужно предоставить экземпляр OX при тестировании метода объекта A, даже если он его не использует. Даже если вы используете mock-реализацию коллаборатора CY, который может не использовать объект OX. Вы можете обойти это, передав null вместо OX, если в тестируемом методе нет проверки на null. Иногда в ходе теста может быть сложно создать объект OX. Если конструктор OX зависит от множества других объектов или значений, вашему тесту также придется передавать осмысленные объекты/значения для этих параметров. И если OX зависит от OY, который зависит от OZ, это становится настоящим безумием.
Когда стеки вызова глубоки, перенос зависимостей — это настоящая боль. Особенно, если вы обнаруживаете, что компонент со дна стека нуждается в другом объекте, доступном выше по стеку. Затем вам придется добавить этот объект как параметр во все вызовы методов вниз по стеку, начиная тем, откуда требуемый объект доступен и заканчивая тем, где он необходим.
Общее решение для проблемы «переноса зависимостей» — сделать необходимые объекты статическими синглтонами. Таким образом любой компонент системы сможет получить доступ к синглтону через его статический фабричный метод (***прим. ред.*** [не путать с паттерном Фабричный Метод](http://stackoverflow.com/a/9914562)). К сожалению, статические синглтоны тянут за собой целый ворох других проблем, в которые я здесь не буду погружаться. Статические синглтоны — зло. Не используйте их, если вам удастся избежать этого.
Когда вы используете DI-контейнер, вы можете снизить «перенос зависимостей» и сократить использование статических синглтонов. Контейнер знает обо всех компонентах в приложении. Следовательно, он может идеально связать компоненты, без необходимости передавать зависимости одному компоненту через другой. Пример с компонентами при использовании контейнера будет выглядеть следующим образом:
```
Контейнер создает Config
Контейнер создает D и внедряет Config
Контейнер создает C и внедряет D
Контейнер создает B и внедряет C
Контейнер создает A и внедряет B
A --> B --> C --> D --> Config
```
Когда A вызывает B, ему не нужно передавать объект Config в B. D уже знает об объекте Config.
Однако, все еще могут быть ситуации, когда нельзя избежать переноса зависимостей. Например, если ваше приложение обрабатывает запросы (это веб-приложение или веб-сервис), и компоненты, обрабатывающие запросы это — синглтоны. Тогда объект запроса может быть необходимо передавать вниз по цепочке вызовов каждый раз, когда доступ к нему понадобится компоненту более низкоуровневого слоя.
В следующей статье, «When to use dependency injection», Jakob Jenkov приводит практические примеры применения DI. Как написать код, если вам нужно: внедрить конфигурационную информацию в один или несколько компонентов, внедрить одну и ту же зависимость в один или несколько компонентов, внедрить разные реализации одной зависимости, внедрить одну и ту же реализацию в разных конфигурациях, получить какие-либо данные из контейнера. Также автор рассказывает о том, в каких случаях DI вам не понадобится. Stay tuned!
[К началу](#start) | https://habr.com/ru/post/350708/ | null | ru | null |
# Рекурсивное программирование на ЛИСП – решатель формул
Решатель формул сам по себе очень интересная тренировка, и в определённый момент эта тренировка может очень пригодиться в другой задаче – конструировании новой формулы, автоматической её проверке (погрешность, просчёт значений по списку координат)… И excel вам не поможет, да и неспортивно.
Сразу оговорюсь — код сделан для ЛИСПа образца 87 года, и свежий Common LISP его категорически не поймёт, что печально… Но — 2 шага от ЛИСП-кода до понимания, как то же самое написать в более пристойном для практической задаче С# или Delphi, в ЛИСПе даётся более милое моему сердцу и глазу исполнение)
Ввод формулы с клавиатуры, против жёсткого задания в коде, имеет массу плюсов. Как осуществить его программист задумывался, пожалуй, со школьного железного стула. Задача велика, и кажется невыполнимой, но главное – начать. Начинаем>>
1. Как будет записываться формула?
----------------------------------
Обычная запись для первого шага излишне сложна. Польская форма записи – воспользуемся ей. И операции над числами запишутся в виде списков, которыми можно задать самое сложное математическое выражение:
#
`**2+3->(+ 2 3)
2-3->(- 2 3)
2\*3->(\* 2 3)
2/3->(/ 2 3)
2+3+5->(+ 2 3 5)
2+3\*5->(+ 2 (\* 3 5))
(2+3)\*5->(\* (+ 2 3) 5)**`
2. Как оно будет работать? (простые формулы)
--------------------------------------------
Напишем решатель (solver) в рево… рекурсивном духе ЛИСПа: он будет хватать из списка первый элемент голову, и далее обрабатывать хвост в соответствии со значением головы. На вход решатель получает каждый раз формулу (a), результат предыдущего действия (b), знак © и, если предусмотреть это заранее, то и значения неизвестных параметров (xx).
`**(defun solver (a b c xx)
((null a) b)
((equal (searchx a) NIL) (solver (presolver a NIL xx) T c xx))
((eq (atom a) T) a)
((equal c NIL) (solver (cdr (cdr a)) (car (cdr a)) (car a) xx))
((equal c ps) (solver (cdr a) (+ b (car a)) c xx))
((equal c ms) (solver (cdr a) (- b (car a)) c xx))
((equal c mu) (solver (cdr a) (\* b (car a)) c xx))
((equal c di) (solver (cdr a) (/ b (car a)) c xx))
)**`
Неизвестные параметры, указанные в формуле своими именами # (+ x 5)) должна заменить на значения соответствующая функция. Причём до решателя. Обзовём её предрешатель (presolver), на вход ей подаём формулу, результат (при вызове из решателя – NIL) и значение неизвестной для подстановки на место элемента ‘х’ (выделяю здесь это специально, ибо ЛИСП не различает, хвала Господу, типов данных)
`**(defun presolver (a b xx)
((null a) (revers b))
((eq (car a) x) (presolver (cdr a) (cons xx b) xx))
((eq (equal (car a) x) NIL) (presolver (cdr a) (cons (car a) b) xx))
)**`
И – наличие неизвестных ещё нужно подтвердить. Рождается функция поиска неизвестной, searchx, a заодно и функция реверса списка revers, ибо результат presolver-a по-умолчанию выходит задом наперёд.
`**(defun searchx (a)
((null a) T)
((equal (car a) x) NIL)
(searchx (cdr a))
)**`
`**(defun revers (a b)
((null a) b)
(revers (cdr a) (cons (car a) b))
)**`
Запускаем-проверяем-
`**(solver '(ps x 2 3) NIL NIL 5)**`
-ура-работает. Но – только на простых формулах, со списками без вложенных списков, с элементами-атомами.
3. Как оно будет работать-2? (сложные формулы)
----------------------------------------------
Можно долго думать, каким интересным образом превратить простой солвер в сложный, но мы пойдём более рациональным путём – не будем трогать работающий кусок, а станем заниматься проектом solver2 – решателем сложных формул.
`**(defun solver2 (a xx)
((eq (iseasy a) T)
(solver a NIL NIL xx))
((eq (atom (car a)) T)
(solver (cons (car a) (solver2 (cdr a) xx)) NIL NIL xx))
((eq (iseasy (car a)) T)
(cons (solver (car a) NIL NIL xx) (solver2 (cdr a) xx)))
((eq (iseasy (car a)) NIL)
(cons (solver2 (car a) xx) (solver2 (cdr a) xx)))
)**`
Каждая сложная формула содержит в себе хотя бы один элемент-список. Но начнём с проблемы совместимости, чтобы новая функция работала хотя бы для простых вычислений. Для этого нужно формулу на вход проверить на простоту, и если простая – отправить к solver-у, а вот если сложная – подумать над ней ещё немного.
Определить прост список или не совсем поможет функция iseasy с единственным входным параметром – собственно формулой. Iseasy видит элемент не-атом – и выпадает с ответом NIL
`**(defun iseasy (a)
((null a) T)
((equal (atom (car a)) Nil) NIL)
(iseasy (cdr a))
)**`
Далее всё просто, и одновременно изящно-непонятно. Правильность работы функции очевидна, но неочевиден алгоритм. Он же таков:
— Сначала solver2 проверяет формулу целиком на простоту. Если формула проста целиком, её можно и нужно решить solver-ом.
— Далее идёт проверка – «а не атом ли голова у формулы ‘а’?» Если голова – атом бренный, то отправляем solver-у конструктор из этого атома и хвоста, требующего повторного рассмотрения solver2
— Если первые 2 проверки не прошли, что-то с формулой определённо не так (кажется и мне через 2 года после написания кода), то мы должны проверить голову формулы на простоту, и если таковая проста (НО не атом! – а значит список), отправим запустившей solver2 функции конструкцию из решённой головы и рассмотренного повторно solver2 хвоста формулы. Например, «на экран»… Наверное, это какой-то bugreport?
— Если первые 3 проверки не прошли (совсем беда, это значит что формула не проста, в голове этой формулы стоит не атом (т.е. не знак ±/\*/:), и даже не список из атомов, выдадим «на экран» конструкцию из просмотренной повторно solver2 головы и хвоста, также с ревизией solver2
Запустите…
`**(solver2 '(mu (ps x 2 3) (ms x 5)) 10)**`
Удивитесь
4. Почему оно работает? (заключение)
------------------------------------
Очевидно, что solver2 в приведённом коде умеет считать простые формулы. Но как, запустив его, он считает и сложные? Зрение в рекурсивном программировании весьма обманчиво.
Каждая правильная формула начинается с атома операции. Проследи за действиями ЛИСПа, читатель: solver2 начинает решать правильную сложную формулу, и отправляет на решатель конструкцию из головы этой формулы (знак), и… пересмотренного хвоста в самом себе. Хвост приходит на solver2 и, естественно, не содержит в голове атома операции. Поэтому заслуженно отправляется на дальнейшее упрощение solver2…
В чём его суть, что он делает, этот solver2? В общем-то ничего, ещё проще — он берёт список и заменяет его на число… В конце концов любая сколь угодно длинная формула, даже с 10-кратной вложенностью свернётся до простого списка, со знаком в голове и с хвостом, состоящим из одних только атомов, причём все атомы будут числами. Красиво, и абсолютно непостижимо по коду, непостижимо и на первом шаге написания функции)… За что РП и люблю. | https://habr.com/ru/post/74280/ | null | ru | null |
# О сложностях мониторинга работающих процессов в Linux
Все знают о том, как наблюдать за работающими процессами в Linux-системе. Но почти никто не добивается в подобных наблюдениях высокой точности. На самом деле, всем методам мониторинга процессов, о которых пойдёт речь в этом материале, чего-то не хватает.
[](https://habr.com/ru/company/ruvds/blog/525830/)
Давайте, прежде чем приступить к экспериментам, определим требования к системе наблюдения за процессами:
1. Логироваться должны сведения обо всех процессах, даже о короткоживущих.
2. У нас должны быть сведения о полном пути к исполняемому файлу для всех запущенных процессов.
3. У нас, в пределах разумного, не должно возникать необходимости в модификации или перекомпиляции нашего кода для разных версий ядра.
4. Дополнительное требование: если хост-система является узлом Kubernetes или использует Docker, то у нас должна быть возможность определить то, к какому именно поду/контейнеру принадлежит процесс. Для этого обычно достаточно знать `cgroup ID` процесса. Дело в том, что с точки зрения ядра нет такого понятия, как «контейнер» или «идентификатор контейнера». Ядро оперирует лишь такими понятиями, как «контрольные группы», «сетевые пространства имён», «пространства имён процессов», оно работает с различными независимыми API, с помощью которых средства контейнеризации вроде Docker реализуют механизмы контейнеризации. Если попытаться идентифицировать контейнеры посредством ID уровня ядра, нужен уникальный идентификатор контейнера. В случае с Docker данному требованию удовлетворяют идентификаторы контрольных групп.
Поговорим об обычных API Linux, которые могут помочь в решении этой задачи. Мы, чтобы не усложнять повествование, уделим особое внимание процессам, создаваемым с помощью системных вызовов `execve`. Если же говорить о более полном решении задачи, то при его реализации нужно, кроме того, мониторить процессы, созданные с помощью системных вызовов `fork/clone` и их вариантов, а так же — результаты работы вызовов `execveat`.
Простые решения, реализуемые в пользовательском режиме
------------------------------------------------------
1. Обращение к `/proc`. Этот способ, из-за проблемы короткоживущих процессов, нам не особенно подходит.
2. Использование netlink. Механизмы netlink позволят получать уведомления о короткоживущих процессах, но в этих уведомлениях будут содержаться лишь числовые данные наподобие `PID` процессов. Сведений о пути к исполняемому файлу процесса там не будет. В результате придётся возвращаться к чтению данных из `/proc`, сталкиваясь со сложностями при работе с короткоживущими процессами.
3. Использование подсистемы аудита Linux. Это — лучший способ решения нашей задачи, реализуемый в пользовательском режиме. Подходящие API имеются во всех современных ядрах. Они дают сведения о полном пути к исполняемому файлу процесса и не пропускают короткоживущие процессы. У этого метода есть лишь два недостатка. Первый — это то, что в некий момент времени лишь одна программа, работающая в пользовательском режиме, может взаимодействовать с подсистемой аудита. Это превращается в большую проблему в том случае, если некто занимается разработкой решений в области информационной безопасности для организаций и при этом некоторые клиенты используют API аудита сами, применяя `auditd` или `osquery`. Средства мультиплексирования событий, работающие в пользовательском режиме, вроде `auditd` и [go-audit](https://github.com/slackhq/go-audit), в теории, могут смягчить эту проблему. Но в случае с решениями корпоративного класса нельзя заранее знать о том, используют ли клиенты подобные средства, а если используют — то какие именно. Нельзя заранее знать и о том, какие именно средства для обеспечения безопасности, работающие напрямую с API аудита, применяются клиентами. Второй недостаток заключается в том, что API аудита ничего не знают о контейнерах. И это — несмотря на то, что данный вопрос обсуждается уже много лет.
Простые средства отладки, работающие в режиме ядра
--------------------------------------------------
Реализация этих механизмов предусматривает использование «датчиков» (probe) различных типов в единственном экземпляре.
### ▍Точки трассировки
Использование точек трассировки (`tracepoint`). Точки трассировки — это датчики, статически включённые в определённые места ядра во время его компиляции. Каждый такой датчик можно включить независимо от других, в результате чего он будет выдавать уведомления в тех случаях, когда достигается то место кода ядра, в которое он внедрён. Ядро содержит несколько подходящих нам точек трассировки, код которых выполняется в различные моменты работы системного вызова `execve`. Это — `sched_process_exec`, `open_exec`, `sys_enter_execve`, `sys_exit_execve`. Для того чтобы получить этот список, я выполнил команду `cat /sys/kernel/tracing/available_events | grep exec` и отфильтровал полученный список, пользуясь сведениями, полученными в ходе чтения кода ядра. Эти точки трассировки подходят нам лучше, чем вышеописанные механизмы, так как они позволяют организовать наблюдение за короткоживущими процессами. Но ни одна из них не даёт информацию о полном пути к исполняемому файлу процесса в том случае, если параметрами `exec` является относительный путь к такому файлу. Другими словами, если пользователь выполняет команду вроде `cd /bin && ./ls`, тогда мы получим сведения о пути в виде `./ls`, а не в виде `/bin/ls`. Вот простой пример:
```
# Включение точки трассировки the sched_process_exec
sudo -s
cd /sys/kernel/debug/tracing
echo 1 > events/sched/sched_process_exec/enable
# запуск ls с использованием относительного пути
cd /bin && ./ls
# получение данных из точки трассировки sched_process_exec
# обратите внимание на то, что сведений о полном пути у нас нет
cd -
cat trace | grep ls
# отключение точки трассировки
echo 0 > events/sched/sched_process_exec/enable
```
### ▍Датчики kprobe/kretprobe
Датчики `kprobe` позволяют извлекать отладочную информацию практически из любого места ядра. Они подобны особым точкам останова в коде ядра, которые выдают информацию, но при этом не останавливают выполнение кода. Датчик `kprobe`, в отличие от точек трассировки, можно подключить к самым разным функциям. Код такого датчика сработает в процессе выполнения системного вызова `execve`. Но я не нашёл в графе вызовов `execve` ни одной функции, параметрами которой является и `PID` процесса, и полный путь к его исполняемому файлу. В результате тут мы сталкиваемся с той же «проблемой относительных путей» что и при использовании точек трассировки. Тут можно, опираясь на особенности конкретного ядра, кое-что «подкрутить». В конце концов, датчики `kprobe` могут считывать данные из стека вызовов ядра. Но такое решение не будет стабильно работать в разных версиях ядра. Поэтому его я его не рассматриваю.
### ▍Использование eBPF-программ с точками трассировки, с датчиками kprobe и kretprobe
Тут речь идёт о том, что при выполнении некоего кода будут срабатывать точки трассировки или датчики, но при этом будет выполняться код eBPF-программ, а не код обычных обработчиков событий.
Использование этого подхода открывает перед нами некоторые новые возможности. Теперь мы можем запускать в ядре произвольный код при выполнении системного вызова `execve`. Это, теоретически, должно дать нам возможность извлекать из ядра любую необходимую нам информацию и отправлять её в пользовательское пространство. Есть два способа получения подобных данных, но ни один из них не соответствует вышеописанным требованиям.
1. Можно читать сведения из структур данных ядра, вроде `task_struct` или `linux_binprm`. Собственно говоря, это позволит нам узнать полный путь к исполняемому файлу процесса, но чтение информации из структур данных ядра делает нас зависимыми от версии ядра. Например, можно поместить точку трассировки в `sched_process_exec` и, воспользовавшись в eBPF-программе ограниченным циклом, обойти [цепочку структур dentry](https://github.com/iovisor/bcc/issues/237#issuecomment-547564661) в `bprm->file->f_path.dentry`, отправляя в пользовательское пространство по одному фрагменту данных за раз с применением кольцевого буфера. Нашей eBPF-программе нужно знать смещения членов структуры. Поэтому её нужно компилировать для разных версий ядра с использованием соответствующих заголовков. Обычно подобные задачи решают, компилируя eBPF-программы во время выполнения кода, но у такого подхода есть свои проблемы, вроде требования наличия заголовков ядра на каждом компьютере, где планируется компилировать программы.
2. Можно воспользоваться вспомогательными функциями eBPF для получения данных из ядра. Такой подход обеспечивает совместимость с разными версиями ядра, содержащими используемые вспомогательные функции. Тут мы не работаем со структурами данных ядра напрямую — вместо этого для получения нужных данных используются вспомогательные API. У этого подхода есть лишь одна проблема — не существует вспомогательных функций для получения сведений о полном пути к исполняемому файлу процесса. (Правда, в современных версиях ядер имеется вспомогательная функция eBPF, которая позволяет получить `cgroup ID`, а это помогает в деле сопоставления процессов и контейнеров).
«Хакерские» решения
-------------------
1. Использование `LD_PRELOAD` для каждого запускаемого исполняемого файла и перехват `exec` в `libc`. Сразу скажу, что делать этого я не рекомендую. Это решение не подойдёт для статически компилируемых исполняемых файлов, его использование снижает уровень защищённости системы от вредоносного кода, оно, к тому же, подразумевает довольно грубое вмешательство в работу системы.
2. Применение точек трассировки для `execve`, `fork/clone` и `chdir` для того чтобы наблюдать не только за созданием процессов, но и получать сведения об их текущих рабочих директориях. Речь идёт о том, что для каждого вызова `execve` нужно будет находить рабочую директорию процесса и комбинировать эти данные с параметрами `execve` для получения полного пути. Если вы решите реализовать именно этот механизм — то позаботьтесь об использовании eBPF-мэппинга и поместите всю логику в eBPF-программу для того чтобы избежать состояния гонок в том случае, если события приходят в пользовательское пространство в неправильном порядке.
3. Решения, основанные на `ptrace`. Эти решения слишком грубы для использования их в продакшн-коде. Но если вы воспользуетесь именно этими механизмами — применяйте `ptrace` вместе с `seccomp` и с флагом `SECCOMP_RET_TRACE`. Это позволит `seccomp` перехватывать все системные вызовы `execve` в ядре и передавать их в отладчик пользовательского пространства, который может логировать сведения о вызовах `execve` и после этого сообщать `seccomp` о возможности продолжения обычной работы с `execve`.
4. Использование AppArmor. Можно написать профиль AppArmor, который запретит процессам вызывать выполнение исполняемых файлов. Если воспользоваться этим профилем в режиме обучения (complain), то AppArmor не запретит выполнение процессов, а лишь будет выдавать уведомления о нарушениях правил, заданных в профиле. Если подключать профиль к каждому выполняющемуся процессу, то мы получим работающее, но весьма непривлекательное и слишком «хакерское» решение. Вероятно, пользоваться этим подходом не стоит.
Другие решения
--------------
Сразу скажу, что ни одно из этих решений не соответствует нашим требованиям, но, всё же, перечислю их:
1. Использование утилиты `ps`. Этот инструмент просто обращается к `/proc` и, в результате, страдает от тех же проблем, что и прямое обращение к `/proc`.
2. Применение новой версии [execsnoop](https://github.com/iovisor/bcc/blob/master/tools/execsnoop.py), основанной на eBPF. Это, по сути, решение, основанное на `kprobe/kretprobe`, поэтому оно так же зависит от версий ядра, как и подобные решения, описанные выше. Кроме того, `execsnoop` не даёт информации о полных путях к исполняемым файлам, а значит, применяя этот механизм, мы ничего не выигрываем.
3. Использование старой версии `execsnoop`, не поддерживающей eBPF. Это — обычный датчик `kprobe`, поэтому нам это не подходит.
Решения из будущего
-------------------
В будущем можно будет воспользоваться недоступной пока вспомогательной eBPF-функцией [get\_fd\_path](https://patchwork.ozlabs.org/project/netdev/patch/7464919bd9c15f2496ca29dceb6a4048b3199774.1576629200.git.ethercflow@gmail.com/). После того, как она будет добавлена в ядро, она пригодится для решения нашей задачи. Правда, полный путь к исполняемому файлу процесса придётся получать, используя способ, не предусматривающий чтение информации из структур данных ядра.
Итоги
-----
Ни один из рассмотренных API не идеален. Ниже я хочу дать несколько рекомендаций относительно того, какими именно подходами стоит пользоваться для получения информации о процессах, и о том, когда ими стоит пользоваться:
1. Если можете — пользуйтесь механизмами аудита с помощью `auditd` или [go-audit](https://github.com/slackhq/go-audit). Это позволит получать сведения обо всех процессах, включая короткоживущие. Вы, кроме того, не прилагая никаких усилий, получите сведения о полных путях к исполняемым файлам процессов. Это решение, правда, не будет работать в том случае, если кто-то уже использует API аудита с помощью инструментов, работающих в пространстве пользователя, отличающихся от ваших. Если вы столкнулись с подобной проблемой — возможно, вам подойдут следующие рекомендации.
2. Если полные пути к исполняемым файлам вас не интересуют, и вам, при этом, нужно решить задачу как можно быстрее и проще, не занимаясь написанием некоего кода, рекомендую взглянуть на `execsnoop`. Единственный минус этого подхода — необходимость в доступе к заголовкам ядра во время выполнения кода.
3. Если вам, опять же, не интересны полные пути к исполняемым файлам, но при этом вы готовы немного потрудиться ради того, чтобы избежать зависимости от заголовков ядра, тогда можете воспользоваться вышеописанными точками трассировки. К ним можно подключиться множеством различных способов, есть много подходов к передаче их данных в пространство пользователя. Например, тут применим показанный выше интерфейс файловой системы, eBPF-программы с eBPF-мэппингом, утилита `perf`. Рассказ обо всём этом достоин отдельной статьи. Самое главное, о чём стоит помнить, выбирая этот способ наблюдения за процессами, заключается в следующем. Если вы пользуетесь eBPF-программами — проконтролируйте возможность их статической компиляции, что позволит вам не зависеть от заголовков ядра. А ведь именно этой зависимости мы и пытаемся избежать, применяя этот метод. Применение этого метода, кроме того, означает невозможность работы со структурами данных ядра и невозможность использования фреймворков вроде [BCC](https://github.com/iovisor/bcc), компилирующих программы eBPF во время выполнения кода.
4. Если вас не интересуют короткоживущие процессы и предыдущие рекомендации вам не подходят — воспользуйтесь возможностями netlink совместно с `/proc`.
Как вы организуете наблюдение за работающими процессами в Linux?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=o_slozhnostyax_monitoringa_rabotayushhix_processov_v_linux#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=o_slozhnostyax_monitoringa_rabotayushhix_processov_v_linux) | https://habr.com/ru/post/525830/ | null | ru | null |
# Разработка REST-серверов на Go. Часть 5: Middleware
Это — пятый материал из [серии статей](https://habr.com/ru/users/programmerguru/posts/), посвящённой разработке REST-серверов на Go. Здесь мы поговорим о middleware. У меня есть [материал](https://eli.thegreenplace.net/2021/life-of-an-http-request-in-a-go-server/), посвящённый жизненному циклу HTTP-запросов в серверах, написанных на Go. Для того чтобы разобраться в том, о чём пойдёт речь ниже, вам нужно ориентироваться в этой теме.
**Предыдущие части:**
[Разработка REST-серверов на Go. Часть 1: стандартная библиотека](https://habr.com/ru/company/ruvds/blog/559816/)
[Разработка REST-серверов на Go. Часть 2: применение маршрутизатора gorilla/mux](https://habr.com/ru/company/ruvds/blog/561108/)
[Разработка REST-серверов на Go. Часть 3: использование веб-фреймворка Gin](https://habr.com/ru/company/ruvds/blog/562878/)
[Разработка REST-серверов на Go. Часть 4: применение OpenAPI и Swagger](https://habr.com/ru/company/ruvds/blog/564508/)
[**Вы тут** — Разработка REST-серверов на Go. Часть 5: Middleware](https://habr.com/ru/company/ruvds/blog/566198/)
[Разработка REST-серверов на Go. Часть 6: аутентификация](https://habr.com/ru/company/ruvds/blog/567280/)
[](https://habr.com/ru/company/ruvds/blog/565142/)
Middleware, созданное с использованием стандартных средств
----------------------------------------------------------
Пришло время снова переработать наш сервер, являющийся частью системы управления задачами. Следующий пример основан на базовой версии сервера, описанного в [первой](https://habr.com/ru/company/ruvds/blog/559816/) части этой серии материалов, при разработке которого используются лишь возможности стандартной библиотеки Go. Тут мы поговорим о том, как оснастить этот сервер middleware, и о том, какие у нас имеются варианты интеграции этого ПО с существующим кодом. Полный код сервера, который мы будем сейчас обсуждать, можно найти [здесь](https://github.com/eliben/code-for-blog/tree/master/2021/go-rest-servers/stdlib-middleware).
В исходном варианте сервера в начале каждого обработчика присутствует вызов `log.Printf`, предназначенный для логирования обрабатываемого запроса. Это — одна из задач, которую можно решить средствами middleware, и при этом обойтись меньшими объёмами повторяющегося кода. Вот простой пример кода такого ПО, решающего задачу логирования:
```
func Logging(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
start := time.Now()
next.ServeHTTP(w, req)
log.Printf("%s %s %s", req.Method, req.RequestURI, time.Since(start))
})
}
```
Этот код, в дополнение к логированию метода и URI запроса, подсчитывает и логирует время, необходимое обработчику на решение его задачи.
Для того чтобы подключить это ПО к нашим обработчикам, приведём код `main` к следующему виду:
```
func main() {
mux := http.NewServeMux()
server := NewTaskServer()
mux.HandleFunc("/task/", server.taskHandler)
mux.HandleFunc("/tag/", server.tagHandler)
mux.HandleFunc("/due/", server.dueHandler)
handler := middleware.Logging(mux)
log.Fatal(http.ListenAndServe("localhost:"+os.Getenv("SERVERPORT"), handler))
}
```
В данном случае middleware устанавливается на глобальном уровне, воздействуя на все обработчики. Но такое ПО можно устанавливать и для каждого конкретного маршрута. Например, если надо, чтобы логирование выполнялось бы только для `server.tagHandler` — мы можем поступить так:
```
func main() {
mux := http.NewServeMux()
server := NewTaskServer()
mux.HandleFunc("/task/", server.taskHandler)
mux.Handle("/tag/", middleware.Logging(http.HandlerFunc(server.tagHandler)))
mux.HandleFunc("/due/", server.dueHandler)
log.Fatal(http.ListenAndServe("localhost:"+os.Getenv("SERVERPORT"), mux))
}
```
Обратите внимание на то, что нам необходимо в этом случае вызывать `mux.Handle`, а не `mux.HandleFunc`. Дело в том, что наш код промежуточного уровня возвращает `http.Handler`, а не `http.HandlerFunc`. По похожей (но, в сущности, по обратной) причине мы, передавая обработчик middleware, должны подготовить его к использованию с помощью `http.HandlerFunc`.
Ещё два вышеописанных подхода можно использовать совместно. А именно, одно middleware может использоваться для отдельных маршрутов, а другое может применяться на глобальном уровне. Обратите внимание на то, что в двух предыдущих примерах последовательность вызова `mux` и кода промежуточного уровня различается. Можете сами обнаружить это различие?
В первом примере последовательность выполнения кода выглядит так:
```
request --> [Logging] --> [Mux] --> [Handler]
```
Во втором примере, для `/tag/`, порядок выполнения кода выглядит так:
```
request --> [Mux] --> [Logging] --> [tagHandler]
```
В целом — рекомендуется быть в курсе того, в каком порядке выполняется код middleware. В данном случае последовательность вызова `mux` и кода промежуточного уровня особой роли не играет, но в некоторых случаях это может быть не так.
Добавление в проект дополнительного middleware
----------------------------------------------
Давайте оснастим сервер дополнительным middleware. В моём [материале](https://eli.thegreenplace.net/2021/life-of-an-http-request-in-a-go-server/) про жизненный цикл HTTP-запросов в Go-серверах я рассказывал о том, как обрабатывать ошибки времени выполнения категории panic. Если в обработчике возникает такая ошибка — при её обработке выполняется закрытие соединения с клиентом и логируется сообщение об ошибке. Если хочется сделать что-то другое — нужно написать собственный код middleware. Попробуем это сделать:
```
func PanicRecovery(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
defer func() {
if err := recover(); err != nil {
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
log.Println(string(debug.Stack()))
}
}()
next.ServeHTTP(w, req)
})
}
```
В этом коде применяется оператор `defer`, с помощью которого к обработчику прикрепляется отложенная функция. Она выполняет обработку ошибки, отправляет клиенту HTTP-ответ с кодом 500 (Internal Server Error) и логирует результаты трассировки стека.
Вот как мы можем воспользоваться этим кодом в `main`:
```
func main() {
mux := http.NewServeMux()
server := NewTaskServer()
mux.HandleFunc("/task/", server.taskHandler)
mux.HandleFunc("/tag/", server.tagHandler)
mux.HandleFunc("/due/", server.dueHandler)
handler := middleware.Logging(mux)
handler = middleware.PanicRecovery(handler)
log.Fatal(http.ListenAndServe("localhost:"+os.Getenv("SERVERPORT"), handler))
}
```
Теперь порядок выполнения кода middleware выглядит так:
```
request --> [Panic Recovery] --> [Logging] --> [Mux] --> [tagHandler]
```
Тут, как и ранее, можно по-разному сочетать и комбинировать код. Например, можно сделать так, чтобы код `PanicRecovery` использовался бы лишь для некоторых маршрутов, а `Logging` — для всех.
Создание цепочек middleware
---------------------------
Только что было показано то, что, добавляя в сервер новое middleware, мы должны знать о том, в каком порядке вызываются соответствующие фрагменты кода. Это справедливо и для глобального ПО, и для того, которое применяется при обработке отдельных маршрутов. В результате неудивительно то, что существуют программные пакеты, ориентированные на построение «цепочек» из middleware, дающие больше удобств, чем у нас есть при вышеописанном стиле работы. Подобные пакеты, кроме того, обычно позволяют организовать многократное использование цепочек middleware в разных маршрутах. Примером такого пакета является [alice](https://github.com/justinas/alice).
Я, как это обычно бывает при разговорах о зависимостях, хочу напомнить о том, что к зависимостям стоит относиться очень осторожно. Не надо перегружать ими проект. Особенно — если они дают лишь [незначительную выгоду](https://eli.thegreenplace.net/2017/benefits-of-dependencies-in-software-projects-as-a-function-of-effort/). Пожалуй, без особых раздумий добавлять в проект новые зависимости может лишь тот, кто очень спешит, или тот, кто не особенно заботится о читабельности и поддерживаемости кода в долгосрочной перспективе. Если, например, оказывается, что использование для работы с middleware чего-то вроде alice выглядит для кого-то как нечто гораздо более адекватное, чем применение стандартных механизмов, он вполне может добавить в проект подобный пакет. В противном случае лучше начать с написания собственного кода (как в нашем примере), а потом, если возникнет такая необходимость, подумать о переходе на что-то другое.
В любом случае — если вы используете пакет для организации маршрутизации, вроде gorilla/mux, или полномасштабный фреймворк вроде Gin, это значит, что в вашем распоряжении уже есть стандартные средства этих инструментов, ориентированные на работу с middleware.
middleware и gorilla/mux
------------------------
При использовании пакета для организации маршрутизации gorilla/mux в нашем распоряжении оказываются и некоторые вспомогательные инструменты для работы с middleware. Тип `mux.Router` имеет метод `Use(...)`, использование которого облегчает настройку цепочек глобального middleware. Более того, пакет gorilla/handlers включает в себя кое-какое готовое к использованию middleware. При этом самописное ПО, вроде того, которым мы уже пользовались, тоже легко применять с gorilla/mux. Это так благодаря тому, что для обработчиков используются стандартные интерфейсы `net/http`. А если говорить о gorilla/handlers, то можно отметить, что там имеются, кроме прочих, аналоги наших разработок, направленных на логирование и на обработку ошибок panic.
Вот — пример кода (полный код сервера можно найти [здесь](https://github.com/eliben/code-for-blog/tree/master/2021/go-rest-servers/gorilla-middleware)):
```
func main() {
router := mux.NewRouter()
router.StrictSlash(true)
server := NewTaskServer()
router.HandleFunc("/task/", server.createTaskHandler).Methods("POST")
router.HandleFunc("/task/", server.getAllTasksHandler).Methods("GET")
router.HandleFunc("/task/", server.deleteAllTasksHandler).Methods("DELETE")
router.HandleFunc("/task/{id:[0-9]+}/", server.getTaskHandler).Methods("GET")
router.HandleFunc("/task/{id:[0-9]+}/", server.deleteTaskHandler).Methods("DELETE")
router.HandleFunc("/tag/{tag}/", server.tagHandler).Methods("GET")
router.HandleFunc("/due/{year:[0-9]+}/{month:[0-9]+}/{day:[0-9]+}/", server.dueHandler).Methods("GET")
// Настройка middleware для логирования и обработки ошибок panic.
router.Use(func(h http.Handler) http.Handler {
return handlers.LoggingHandler(os.Stdout, h)
})
router.Use(handlers.RecoveryHandler(handlers.PrintRecoveryStack(true)))
log.Fatal(http.ListenAndServe("localhost:"+os.Getenv("SERVERPORT"), router))
}
```
Функция `main` нового варианта сервера очень похожа на такую же функцию его исходного варианта, написанного во [второй](https://habr.com/ru/company/ruvds/blog/561108/) части этой серии материалов с использованием gorilla/mux. Но теперь там, где мы настраиваем middleware, добавлены два вызова `router.Use`. Я использовал тут два отдельных вызова `Use` для того чтобы сделать код понятнее. На самом деле, `Use` принимает произвольное количество обработчиков, вызовы которых нужно объединить в цепочку.
Middleware для обработки ошибок panic очень просто пользоваться. Тут продемонстрирован интересный подход к настройке такого ПО с использованием функциональных опций. В данном случае мы настраиваем логирование результатов трассировки стека при обработке ошибки panic (по умолчанию используется значение `false`).
API middleware `handlers.LoggingHandler` устроен немного необычно. Нам нужна маленькая функция-адаптер для использования его в `router.Use`. Мне не вполне ясна причина, по которой этот API устроен именно так. Полагаю, что, возможно, передачу `io.writer` можно организовать с применением функциональной опции — примерно так же, как это сделано в `RecoveryHandler`.
В этом примере показана настройка глобального middleware (затрагивающего весь маршрутизатор). А как, пользуясь gorilla/mux, настраивать такое ПО для отдельных маршрутов?
Один из способов похож на то, чем мы занимались, пользуясь возможностями стандартной библиотеки в предыдущем примере. Альтернативой ему является применение субмаршрутизаторов gorilla/mux с `Use`. Второй подход показался мне неоправданно сложным для тех случаев, когда нужно лишь добавить какое-то middleware к одному пути. Но если система маршрутизации уже представлена несколькими субмаршрутизаторами — эта задача решается очень просто.
Middleware и Gin
----------------
А теперь давайте переработаем сервер из [третьей](https://habr.com/ru/company/ruvds/blog/562878/) части этой серии материалов, основанный на Gin. В том материале было сказано, что при создании нового экземпляра Gin с использованием `gin.Default()` регистрируется и кое-какое middleware. В частности — это ПО для логирования и для обработки ошибок panic.
Того же эффекта можно достичь, меньше полагаясь на стандартные механизмы, создав экземпляр маршрутизатора через `gin.New` (при таком подходе middleware автоматически не подключается) и затем самостоятельно подключив то, что нам нужно:
```
func main() {
// Ручная настройка middleware для логирования и обработки ошибок panic.
router := gin.New()
router.Use(gin.Logger())
router.Use(gin.Recovery())
server := NewTaskServer()
router.POST("/task/", server.createTaskHandler)
router.GET("/task/", server.getAllTasksHandler)
router.DELETE("/task/", server.deleteAllTasksHandler)
router.GET("/task/:id", server.getTaskHandler)
router.DELETE("/task/:id", server.deleteTaskHandler)
router.GET("/tag/:tag", server.tagHandler)
router.GET("/due/:year/:month/:day", server.dueHandler)
router.Run("localhost:" + os.Getenv("SERVERPORT"))
}
```
Метод Gin `Use` позволяет прикрепить к маршрутизатору цепочку middleware. Настройка такого ПО для отдельных маршрутов в Gin никаких сложностей не вызывает и производится с использованием групп маршрутизации. Для каждой группы можно зарегистрировать собственное ПО. Так же, как и в случае с обработчиками Gin, middleware Gin не использует стандартную сигнатуру для такого ПО. Тут используется тип, объявленный в пакете `gin` следующим образом:
```
type HandlerFunc func(*Context)
```
Поэтому для использования в Gin middleware со стандартной сигнатурой понадобится адаптер.
Если вы пользуетесь Gin — знайте, что в репозиториях [gin-contrib](https://github.com/gin-contrib/) представлена обширная коллекция модулей middleware, которые вы можете применить в своих проектах.
Другие варианты использования middleware
----------------------------------------
Паттерн «middleware» универсален, он широко используется в коде REST-серверов для решения множества самых разных задач. В примерах, приведённых в этом материале, мы рассматриваем лишь простое ПО, нацеленное на логирование данных и на обработку ошибок panic, так как моей целью было описание механизма работы с таким ПО, а не подробное обсуждение разных вариантов его использования.
В реальности middleware применяется в следующих сферах: стандартизированная проверка запросов, CORS, организация логирования данных, сжатие данных, работа с сессиями, отслеживание запросов, кеширование, шифрование, аутентификация. Об аутентификации, кстати, мы поговорим в одном из следующих материалов.
Итоги
-----
В этом материале мы подробно рассмотрели паттерн «middleware», обращая особое внимание на интеграцию такого ПО в код REST-сервера с использованием разных подходов. А именно — мы работали с таким ПО, применяя лишь средства стандартной библиотеки Go, пользовались маршрутизатором gorilla/mux и полномасштабным фреймворком Gin. Надеюсь, что вы, прочитав этот материал, разобрались с тем, как работает middleware, и с тем, как пользоваться им в собственных проектах.
В заключение этого материала хочу вас кое о чём предупредить: middleware — это не универсальный инструмент, идеально подходящий для решения всех задач. Им, как и любым другим инструментом, не стоит злоупотреблять. Использование такого ПО усложняет процесс прохождения запросов по внутренним каналам серверов, ухудшает читабельность кода и делает более сложной его отладку. Я очень порекомендовал бы описывать весь код в одном месте и избегать конструкций, где такое ПО встраивается в код обработки маршрутов динамически, условно, или внутри другого такого ПО. Если вы так и поступите, то, через некоторое время занимаясь отладкой собственного кода, будете очень себе благодарны.
**Все переводы этой серии:**
[Разработка REST-серверов на Go. Часть 1: стандартная библиотека](https://habr.com/ru/company/ruvds/blog/559816/)
[Разработка REST-серверов на Go. Часть 2: применение маршрутизатора gorilla/mux](https://habr.com/ru/company/ruvds/blog/561108/)
[Разработка REST-серверов на Go. Часть 3: использование веб-фреймворка Gin](https://habr.com/ru/company/ruvds/blog/562878/)
[Разработка REST-серверов на Go. Часть 4: применение OpenAPI и Swagger](https://habr.com/ru/company/ruvds/blog/564508/)
[**Вы тут** — Разработка REST-серверов на Go. Часть 5: Middleware](https://habr.com/ru/company/ruvds/blog/566198/)
[Разработка REST-серверов на Go. Часть 6: аутентификация](https://habr.com/ru/company/ruvds/blog/567280/)
Какой подход к работе с middleware вы используете в своих Go-серверах?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=_razrabotka_rest-serverov_na_go._chast_5:_po_promezhutochnogo_urovnya) | https://habr.com/ru/post/566198/ | null | ru | null |
# Десять возможностей C++11, которые должен использовать каждый C++ разработчик
В данной статье рассматривается ряд возможностей С++11, которые все разработчики должны знать и использовать. Существует много новых дополнений к языку и стандартной библиотеке, эта статья лишь поверхностно охватывает часть из них. Однако, я полагаю, что некоторые из этих новых функций должны стать обыденными для всех разработчиков С++. Подобных статей ~~наверное~~ существует много, в этой я предприму попытку составить список возможностей, которые должны войти в повседневное использование.
Сегодня в программе:
* `auto`
* `nullptr`
* range-based циклы
* `override` и `final`
* строго-типизированный `enum`
* интеллектуальные указатели
* лямбды
* non-member `begin()` и `end()`
* `static_assert` и классы свойств
* семантика перемещения
#### #1 — auto
До С++11, ключевое слово `auto` использовалось как спецификатор хранения переменной (как, например, `register, static, extern`). В С++11 `auto` позволяет не указывать тип переменной явно, говоря компилятору, чтобы он сам определил фактический тип переменной, на основе типа инициализируемого значения. Это может использоваться при объявлении переменных в различных областях видимости, как, например, пространство имен, блоки, инициализация в цикле и т.п.
```
auto i = 42; // i - int
auto l = 42LL; // l - long long
auto p = new foo(); // p - foo*
```
Использование `auto` позволяет сократить код (если, конечно, тип не `int`, который на одну букву меньше). Подумайте об итераторах STL, которые вы должны были всегда писать для прохода контейнеров. Таким образом, это делает устаревшим определение `typedef` только ради простоты.
```
std::map> map;
for(auto it = begin(map); it != end(map); ++it)
{
// do smth
}
// Или, сравним С++03 и С++11
// C++03
for (std::vector>::const\_iterator it = container.begin(); it != container.end(); ++it)
{
// do smth
}
// C++11
for (auto it = container.begin(); it != container.end(); ++it)
{
// do smth
}
```
Стоить отметить, что возвращаемое значение не может быть `auto`. Однако, вы можете использовать `auto` вместо типа возвращаемого значения функции. В таком случае, `auto` не говорит компилятору, что он должен определить тип, он только дает ему команду искать возвращаемый тип в конце функции. В примере ниже, возвращаемый тип функции `compose` — это возвращаемый тип оператора +, который суммирует значения типа `T` и `E`.
```
template
auto compose(T a, E b) -> decltype(a+b) // decltype - позволяет определить тип на основе входного параметра
{
return a+b;
}
auto c = compose(2, 3.14); // c - double
```
#### #2 — nullptr
Раньше, для обнуления указателей использовался макрос NULL, являющийся нулем — целым типом, что, естественно, вызывало проблемы (например, при перегрузке функций). Ключевое слово `nullptr` имеет свой собственный тип `std::nullptr_t`, что избавляет нас от бывших проблем. Существуют неявные преобразования `nullptr` к нулевому указателю любого типа и к `bool` (как `false`), но преобразования к целочисленных типам нет.
```
void foo(int* p) {}
void bar(std::shared_ptr p) {}
int\* p1 = NULL;
int\* p2 = nullptr;
if(p1 == p2)
{}
foo(nullptr);
bar(nullptr);
bool f = nullptr;
int i = nullptr; // ошибка: для преобразования в int надо использовать reinterpret\_cast
```
#### #3 — range-based циклы
В С++11 была добавлена поддержка парадигмы `foreach` для итерации по набору. В новой форме возможно выполнять итерации в случае, если для объекта итерации перегружены методы `begin()` и `end()`.
Это полезно, когда вы просто хотите получить элементы массива/контейнера или сделать с ними что-то, не заботясь об индексах, итераторах или кол-ве элементов.
```
std::map> map;
std::vector v;
v.push\_back(1);
v.push\_back(2);
v.push\_back(3);
map["one"] = v;
for(const auto &kvp: map)
{
std::cout << kvp.first << std::endl;
for(auto v: kvp.second)
std::cout << v << std::endl;
}
int arr[] = {1,2,3,4,5};
for(int &e: arr)
e \*= e;
```
#### #4 — override и final
Мне всегда не нравились виртуальные функции в С++. Ключевое слово `virtual` опционально и поэтому немного затрудняло чтение кода, заставляя вечно возвращаться в вершину иерархии наследования, чтобы посмотреть объявлен ли виртуальным тот или иной метод. Я всегда использовал этой ключевое слово так же и в производных классах (и поощрял людей, кто так делал), чтобы код был понятнее. Тем не менее, есть ошибки, которые могут все таки возникнуть. Возьмем следующий пример:
```
class B
{
public:
virtual void f(short) {std::cout << "B::f" << std::endl;}
};
class D : public B
{
public:
virtual void f(int) {std::cout << "D::f" << std::endl;}
};
```
`D::f` переопределяет `B::f`. Однако они имеют разную сигнатуру, один метод принимает `short`, другой — `int`, поэтому `B::f` — это просто другой метод с тем же именем, перегруженный, а не переопределенный. Таким образом, работая через указатель на базовый класс, Вы можете вызвать `f()` и ожидать вывода «переопределенного» вами метода: «D::f», однако вывод будет «B::f».
Вот другая возможная ошибка: параметры одни и те же, но в базовом классе метод константный, а в производном — нет.
```
class B
{
public:
virtual void f(int) const {std::cout << "B::f " << std::endl;}
};
class D : public B
{
public:
virtual void f(int) {std::cout << "D::f" << std::endl;}
};
```
И снова это две перегруженные, а не переопределенные функции.
К счастью, теперь есть способ избавиться от этих ошибок. Были добавлены два новых идентификатора (не ключевые слова): `override`, для указания того, что метод является переопределением виртуального метода в базовом классе и `final`, указывающий что производный класс не должен переопределять виртуальный метод. Первый пример теперь выглядит так:
```
class B
{
public:
virtual void f(short) {std::cout << "B::f" << std::endl;}
};
class D : public B
{
public:
virtual void f(int) override {std::cout << "D::f" << std::endl;}
};
```
Теперь это вызовет ошибку при компиляции (точно так же, если бы вы использовали `override` во втором примере):
```
'D::f': method with override specifier 'override' did not override any base class methods
```
С другой стороны, если вы хотите сделать метод, не предназначенный для переопределения (ниже в иерархии), его следует отметить как `final`. В производном классе можно использовать сразу оба идентификатора.
```
class B
{
public:
virtual void f(int) {std::cout << "B::f" << std::endl;}
};
class D : public B
{
public:
virtual void f(int) override final {std::cout << "D::f" << std::endl;}
};
class F : public D
{
public:
virtual void f(int) override {std::cout << "F::f" << std::endl;}
};
```
Функция, объявленная как `final`, не может быть переопределена функцией `F::f()` — в этом случае, она переопределяет метод базового класса (`В`) для класса `D`.
#### #5 — строго-типизированный enum
У «традиционных» перечислений в С++ есть некоторые недостатки: они экспортируют свои значения в окружающую область видимости (что может привести к конфликту имен), они неявно преобразовываются в целый тип и не могут иметь определенный пользователем тип.
Эти проблемы устранены в С++11 с введением новой категории перечислений, названных *strongly-typed enums*. Они определяются ключевым словом `enum class`. Они больше не экспортируют свои перечисляемые значения в окружающую область видимости, больше не преобразуются неявно в целый тип и могут иметь определенный пользователем тип (эта опция так же добавлена и для «традиционных» перечислений").
```
enum class Options {None, One, All};
Options o = Options::All;
```
#### #6 — интеллектуальные указатели
Есть много статей, как на хабре, так и на других ресурсах, написанных на эту тему, поэтому я просто хочу упомянуть об интеллектуальных указателях с подсчетом ссылок и автоматическим освобождением памяти:
1. [unique\_ptr](http://en.cppreference.com/w/cpp/memory/unique_ptr): должен использоваться, когда ресурс памяти не должен был разделяемым (у него нет конструктора копирования), но он может быть передан другому `unique_ptr`
2. [shared\_ptr](http://en.cppreference.com/w/cpp/memory/shared_ptr): должен использоваться, когда ресурс памяти должен быть разделяемым
3. [weak\_ptr](http://en.cppreference.com/w/cpp/memory/weak_ptr): содержит ссылку на объект, которым управляет `shared_ptr`, но не осуществляет подсчет ссылок; позволяет избавиться от циклической зависимости
Приведенный ниже пример демонстрирует `unique_ptr`. Для передачи владения объектом другому `unique_ptr`, используйте std::move (эта функция будет обсуждаться в последнем пункте). После передачи владения, интеллектуальный указатель, который передал владение, становится нулевым и `get()` вернет `nullptr`.
```
void foo(int* p)
{
std::cout << *p << std::endl;
}
std::unique_ptr p1(new int(42));
std::unique\_ptr p2 = std::move(p1); // transfer ownership
if(p1)
foo(p1.get());
(\*p2)++;
if(p2)
foo(p2.get());
```
Второй пример демонстрирует `shared_ptr`. Использование похоже, хотя семантика отличается, поскольку теперь владение совместно используемое.
```
void foo(int* p)
{
}
void bar(std::shared_ptr p)
{
++(\*p);
}
std::shared\_ptr p1(new int(42));
std::shared\_ptr p2 = p1;
bar(p1);
foo(p2.get());
```
Первое объявление эквивалентно следующему:
```
auto p3 = std::make_shared(42);
```
[make\_shared](http://en.cppreference.com/w/cpp/memory/shared_ptr/make_shared) — это функция, имеющая преимущество при выделении памяти для совместно используемого объекта и интеллектуального указателя с единственным выделением, в отличие от явного получения `shared_ptr` через конструктор, где требуется, по крайней мере, два выделения. Из-за этого может произойти утечка памяти. В следующем примере как раз это демонстрируется, утечка может произойти в случае, если `seed()` бросит исключение.
```
void foo(std::shared_ptr p, int init)
{
\*p = init;
}
foo(std::shared\_ptr(new int(42)), seed());
```
Эта проблема решается использованием `make_shared`.
И, наконец, пример с `weak_ptr`. Заметьте, что вы должны получить `shared_ptr` для объекта, вызывая `lock()`, чтобы получить доступ к объекту.
```
auto p = std::make_shared(42);
std::weak\_ptr wp = p;
{
auto sp = wp.lock();
std::cout << \*sp << std::endl;
}
p.reset();
if(wp.expired())
std::cout << "expired" << std::endl;
```
#### #7 — лямбды
В новом стандарте наконец-то была добавлена поддержка лямбда-выражений. Мы можете использовать лямбды везде, где ожидается функтор или `std::function`. Лямбда, вообще говоря, представляет собой более короткую запись функтора, что-то вроде анонимного функтора. Подробнее можно почитать, например, на [MSDN](http://msdn.microsoft.com/en-us/library/dd293603.aspx).
```
std::vector v;
v.push\_back(1);
v.push\_back(2);
v.push\_back(3);
std::for\_each(std::begin(v), std::end(v), [](int n) {std::cout << n << std::endl;});
auto is\_odd = [](int n) {return n%2==1;};
auto pos = std::find\_if(std::begin(v), std::end(v), is\_odd);
if(pos != std::end(v))
std::cout << \*pos << std::endl;
```
Теперь немного более хитрые — рекурсивные лямбды. Представьте лямбду, представляющую функцию Фибоначчи. Если вы попытаетесь записать ее, используя `auto`, то получите ошибку компиляции:
```
auto fib = [&fib](int n) {return n < 2 ? 1 : fib(n-1) + fib(n-2);};
```
```
error C3533: 'auto &': a parameter cannot have a type that contains 'auto'
error C3531: 'fib': a symbol whose type contains 'auto' must have an initializer
error C3536: 'fib': cannot be used before it is initialized
error C2064: term does not evaluate to a function taking 1 arguments
```
Здесь имеет место циклическая зависимость. Чтобы избавиться от нее, необходимо явно определить тип функции, используя `std::function`.
```
std::function lfib = [&lfib](int n) {return n < 2 ? 1 : lfib(n-1) + lfib(n-2);};
```
#### #8 — non-member begin() и end()
Вы, вероятно, заметили, что в примерах ранее, я использовал функции `begin()` и `end()`. Это новое дополнение к стандартной библиотеке. Они работают со всеми контейнерами STL и могут быть расширены для работы с любым типом.
Давайте возьмем, например, предыдущий пример, где я выводил вектор и затем искал первый нечетный элемент. Если `std::vector` заменить С-подобным массивом, то код будет выглядеть так:
```
int arr[] = {1,2,3};
std::for_each(&arr[0], &arr[0]+sizeof(arr)/sizeof(arr[0]), [](int n) {std::cout << n << std::endl;});
auto is_odd = [](int n) {return n%2==1;};
auto begin = &arr[0];
auto end = &arr[0]+sizeof(arr)/sizeof(arr[0]);
auto pos = std::find_if(begin, end, is_odd);
if(pos != end)
std::cout << *pos << std::endl;
```
С `begin()` и `end()` его можно переписать следующим образом:
```
int arr[] = {1,2,3};
std::for_each(std::begin(arr), std::end(arr), [](int n) {std::cout << n << std::endl;});
auto is_odd = [](int n) {return n%2==1;};
auto pos = std::find_if(std::begin(arr), std::end(arr), is_odd);
if(pos != std::end(arr))
std::cout << *pos << std::endl;
```
Это почти полностью идентично коду с `std::vector`. Таким образом, мы можем написать один универсальный метод для всех типов, которые поддерживаются функциями `begin()` и `end()`.
```
template
void bar(Iterator begin, Iterator end)
{
std::for\_each(begin, end, [](int n) {std::cout << n << std::endl;});
auto is\_odd = [](int n) {return n%2==1;};
auto pos = std::find\_if(begin, end, is\_odd);
if(pos != end)
std::cout << \*pos << std::endl;
}
template
void foo(C c)
{
bar(std::begin(c), std::end(c));
}
template
void foo(T(&arr)[N])
{
bar(std::begin(arr), std::end(arr));
}
int arr[] = {1,2,3};
foo(arr);
std::vector v;
v.push\_back(1);
v.push\_back(2);
v.push\_back(3);
foo(v);
```
#### #9 — static\_assert и классы свойств
`static_assert` проверяет утверждение во время компиляции. Если утверждение — истина, то ничего не происходит. Если — ложь, то компилятор выводит указанное сообщение об ошибке.
```
template
class Vector
{
static\_assert(Size > 3, "Size is too small");
T \_points[Size];
};
int main()
{
Vector a1;
Vector a2;
return 0;
}
```
```
error C2338: Size is too small
see reference to class template instantiation 'Vector' being compiled
with
[
T=double,
Size=2
]
```
`static_assert` становится более полезен, когда используется с классами свойств. Это набор классов, которые предоставляют информацию о типах во время компиляции. Они доступны в заголовке . Есть несколько видов классов в этом заголовке: классы-помощники, классы преобразований и непосредственно классы свойств.
В следующем примере, функция `add`, как предполагается, работает только с целочисленными типами.
```
template
auto add(T1 t1, T2 t2) -> decltype(t1 + t2)
{
return t1 + t2;
}
```
Однако, при компиляции не возникнет ошибки, если написать следующее:
```
std::cout << add(1, 3.14) << std::endl;
std::cout << add("one", 2) << std::endl;
```
Программа просто выведет «4.14» и «е». Используя `static_assert`, эти две строки вызовут ошибку во время компиляции.
```
template
auto add(T1 t1, T2 t2) -> decltype(t1 + t2)
{
static\_assert(std::is\_integral::value, "Type T1 must be integral");
static\_assert(std::is\_integral::value, "Type T2 must be integral");
return t1 + t2;
}
```
```
error C2338: Type T2 must be integral
see reference to function template instantiation 'T2 add(T1,T2)' being compiled
with
[
T2=double,
T1=int
]
error C2338: Type T1 must be integral
see reference to function template instantiation 'T1 add(T1,T2)' being compiled
with
[
T1=const char \*,
T2=int
]
```
#### #10 — семантика перемещения
Это — еще одна важная тема, затронутая в С++11. На эту тему можно написать несколько статей, а не абзацев, поэтому я не буду сильно углубляться.
C++11 ввел понятие rvalue ссылок (указанных с &&), чтобы отличать ссылка на lvalue (объект, у которого есть имя) и rvalue (объект, у которого нет имени). Семантика перемещения позволяет изменять rvalues (ранее они считались неизменными и не отличались от типов const T&).
Класс/структура раньше имели некоторые неявные функции-члены: конструктор по умолчанию (если другой конструктор не определен), конструктор копирования и деструктор. Конструктор копирования выполняет поразрядное копирование переменных. Это означает, что если у вас есть класс с указателями на какие-то объекты, то конструктор копирования скопирует указатели, а не объекты, на которые они указывают. Если вы хотите получить в копии именно объекты, а не лишь указатели на них, вы должны это явно описать в конструкторе копирования.
Конструктор перемещения и оператор присваивания перемещения — эти две специальные функции принимают параметр T&&, который является rvalue. Фактически, они могут изменять объект.
Следующий пример показывает фиктивную реализацию буфера. Буфер идентифицируется именем, имеет указатель (обернутый в `std::unique_ptr`) на массив элементов типа Т и переменную, содержащую размер массива.
```
template
class Buffer
{
std::string \_name;
size\_t \_size;
std::unique\_ptr \_buffer;
public:
// default constructor
Buffer():
\_size(16),
\_buffer(new T[16])
{}
// constructor
Buffer(const std::string& name, size\_t size):
\_name(name),
\_size(size),
\_buffer(new T[size])
{}
// copy constructor
Buffer(const Buffer& copy):
\_name(copy.\_name),
\_size(copy.\_size),
\_buffer(new T[copy.\_size])
{
T\* source = copy.\_buffer.get();
T\* dest = \_buffer.get();
std::copy(source, source + copy.\_size, dest);
}
// copy assignment operator
Buffer& operator=(const Buffer& copy)
{
if(this != ©)
{
\_name = copy.\_name;
if(\_size != copy.\_size)
{
\_buffer = nullptr;
\_size = copy.\_size;
\_buffer = (\_size > 0)? new T[\_size] : nullptr;
}
T\* source = copy.\_buffer.get();
T\* dest = \_buffer.get();
std::copy(source, source + copy.\_size, dest);
}
return \*this;
}
// move constructor
Buffer(Buffer&& temp):
\_name(std::move(temp.\_name)),
\_size(temp.\_size),
\_buffer(std::move(temp.\_buffer))
{
temp.\_buffer = nullptr;
temp.\_size = 0;
}
// move assignment operator
Buffer& operator=(Buffer&& temp)
{
assert(this != &temp); // assert if this is not a temporary
\_buffer = nullptr;
\_size = temp.\_size;
\_buffer = std::move(temp.\_buffer);
\_name = std::move(temp.\_name);
temp.\_buffer = nullptr;
temp.\_size = 0;
return \*this;
}
};
template
Buffer getBuffer(const std::string& name)
{
Buffer b(name, 128);
return b;
}
int main()
{
Buffer b1;
Buffer b2("buf2", 64);
Buffer b3 = b2;
Buffer b4 = getBuffer("buf4");
b1 = getBuffer("buf5");
return 0;
}
```
Конструктор копирования по умолчанию и оператор присваивания копии должны быть вам знакомы. Новое в С++11 — это конструктор перемещения и оператор присваивания перемещения, Если вы выполните этот код, то увидите, что когда создается `b4` — вызывается конструктор перемещения. Кроме того, когда `b1` присваивается значение — вызывается оператор присваивания перемещения. Причина — значение, возвращаемое функцией `getBuffer()` — rvalue.
Вы, вероятно, заметили использование [std::move](http://en.cppreference.com/w/cpp/utility/move) в конструкторе перемещения, при инициализации имени переменной и указателя на буфер. Имя — это строка `std::string` и `std::string` также реализует семантику перемещения. То же самое касается и `unique_ptr`. Однако, если бы мы записали просто `_name(temp._name)`, то был бы вызван конструктор копирования. Но почему в этом случае не был вызван конструктор перемещения для `std::string`? Дело в том, что даже если конструктор перемещения для `Buffer` был вызван с rvalue, внутри конструктора это все равно представляется как lvalue. Чтобы сделать его снова rvalue и нужно использовать `std::move`. Эта функция просто превращает ссылку lvalue в rvalue.
#### Вместо заключения
Есть много вещей в С++11, о которых можно и нужно рассказывать; эта статья была лишь одним из многих возможных начал. Эта статья представила серию функций языка и стандартной библиотеки, которую должен знать каждый разработчик С++. Однако, для более глубокого понимания всего сказанного, этой статьи недостаточно, поэтому тут не обойтись без дополнительной литературы. | https://habr.com/ru/post/182920/ | null | ru | null |
# Слабая связность
**NB**: это черновик двух новых глав [моей книги](https://twirl.github.io/The-API-Book/docs/API.ru.html), посвященной дизайну API. В тексте встречаются отсылки к предыдущим главам.
### Сильная связность и сопутствующие проблемы
В предыдущих разделах мы старались приводить теоретические правила и принципы, и иллюстрировать их на практических примерах. Однако понимание принципов проектирования API, устойчивого к изменениям, как ничто другое требует прежде всего практики. Знание о том, куда стоит «постелить соломку» — оно во многом «сын ошибок трудных». Нельзя предусмотреть всего — но можно выработать необходимый уровень технической интуиции.
Поэтому в этом разделе мы поступим следующим образом: возьмём наше модельное API из предыдущего раздела, и проверим его на устойчивость в каждой возможной точке — проведём некоторый «вариационный анализ» наших интерфейсов. Ещё более конкретно — к каждой сущности мы подойдём с вопросом «что, если?» — что, если нам потребуется предоставить партнерам возможность написать свою независимую реализацию этого фрагмента логики.
Первый важный момент, на который стоит обратить внимание: мы говорим именно о вариантах реализации *продуктовой логики*. Не о *вариантах реализации сущности*: изменения в API вносятся прежде всего для того, чтобы можно было сделать что-то, не предусмотренное изначальным дизайном — что-то полезное. Заниматься реимплементацией интерфейсов просто так ваши потребители не будут.
Это соображение вносит определённые ограничения, которые позволяют нам не заниматься варьированием интерфейсов вслепую (в конце концов, таких вариантов бесконечное количество, и предусматривать их все — сизифов труд): нам нужно понять в первую очередь *зачем* нужны те или иные изменения, и отсюда мы уже поймём *как* их следует внести.
Второй важный момент состоит в том, что многие решения, допускающие эту вариативность, *уже заложены* в дизайне API. Какие-то из них (например, вопрос определения готовности) мы осветили в предыдущих главах подробнее, а какие-то дали без комментариев — настало время объяснить, почему эти решения были приняты.
**NB**: в рассматриваемых нами примерах мы будем выстраивать интерфейсы так, чтобы связывание разных сущностей происходило динамически в реальном времени; на практике такие интеграции будут делаться на стороне сервера путём написания ad hoc кода и формирования конкретных договорённостей с конкретным клиентом, однако мы для целей обучения специально будем идти более сложным и абстрактным путём. Динамическое связывание в реальном времени применимо скорее к сложным программным конструктам типа API операционных систем или встраиваемых библиотек; приводить обучающие примеры на основе систем подобной сложности было бы, однако, чересчур затруднительно.
Предположим, что мы решили предоставить партнёрам возможность готовить кофе по их собственным рецептам. Какова мотивация предоставления такой функциональности?
* возможно, партнерская сеть кофеен хочет предложить клиентам особенные «брендовые» напитки;
* возможно, партнер хочет построить полностью своё приложение со своим ассортиментом на нашей платформе.
В обоих вариантах нам необходимо начать с рецепта. Какие данные нам необходимы для того, чтобы партнёр мог добавить в систему новый рецепт? Вспомним, какие контексты связывает сущность «рецепт»: эта сущность нам нужна, чтобы связать выбор пользователя с правилами приготовления напитка. На первый взгляд может показаться, что именно так нам и следует описать сущность рецепта:
```
// Добавляет новый рецепт
POST /v1/recipes
{
"id",
"product_properties": {
"name",
"description",
"default_value"
// Прочие параметры, описывающие
// напиток для пользователя
…
},
"execution_properties": {
// Идентификатор программы
"program_id",
// Параметры исполнения программы
"parameters"
}
}
```
На первый взгляд, вполне разумный и простой интерфейс, который явно декомпозируется согласно уровням абстракции. Попробуем теперь представить, что произойдёт в будущем — как дальнейшее развитие функциональности повлияет на этот интерфейс.
Первая проблема очевидна тем, кто внимательно читал [главу 11](https://twirl.github.io/The-API-Book/docs/API.ru.html#chapter-11-paragraph-20): продуктовые данные должны быть локализованы. Это приведёт нас к первому изменению:
```
"product_properties": {
// "l10n" — стандартное сокращение
// для "localization"
"l10n" : [{
"language_code": "en",
"country_code": "US",
"name",
"description"
}, /* другие языки и страны */ … ]
]
```
И здесь возникает первый большой вопрос — а что делать с `default_volume`? С одной стороны, это объективная величина, выраженная в стандартизированных единицах измерения, и она используется для запуска программы на исполнение. С другой стороны, для таких стран, как США, мы будем обязаны указать объём не в виде «300 мл», а в виде «10 унций». Мы можем предложить одно из двух решений:
* либо партнёр указывает только числовой объём, а числовые представления мы сделаем сами;
* либо партнёр указывает и объём, и все его локализованные представления.
Первый вариант плох тем, что партнёр с помощью нашего API может как раз захотеть разработать сервис для какой-то новой страны или языка — и не сможет, пока локализация для этого региона не будет поддержана в самом API. Второй вариант плох тем, что сработает только для заранее заданных объёмов — заказать кофе произвольного объёма нельзя. И вот практически первым же действием мы сами загоняем себя в тупик.
Проблемами с локализацией, однако, недостатки дизайна этого API не заканчиваются. Следует задать себе вопрос — а *зачем* вообще здесь нужны `name` и `description`? Ведь это по сути просто строки, не имеющие никакой определённой семантики. На первый взгляд — чтобы возвращать их обратно из метода `/v1/search`, но ведь это тоже не ответ: а зачем эти строки возвращаются из `search`?
Корректный ответ — потому что существует некоторое представление, UI для выбора типа напитка. По-видимому, `name` и `description` — это просто два описания напитка, короткое (для показа в общем прейскуранте) и длинное (для показа расширенной информации о продукте). Получается, что мы устанавливаем требования на API исходя из вполне конкретного дизайна. Но что, если партнёр сам делает UI для своего приложения? Мало того, что ему могут быть не нужны два описания, так мы по сути ещё и вводим его в заблуждение: `name` — это не «какое-то» название, оно предполагает некоторые ограничения. Во-первых, у него есть некоторая рекомендованная длина, оптимальная для конкретного UI; во-вторых, оно должно консистентно выглядеть в одном списке с другими напитками. В самом деле, будет очень странно смотреться, если среди «Капучино», «Лунго» и «Латте» вдруг появится «Бодрящая свежесть» или «Наш самый качественный кофе».
Эта проблема разворачивается и в другую сторону — UI (наш или партнера) обязательно будет развиваться, в нём будут появляться новые элементы (картинка для кофе, его пищевая ценность, информация об аллергенах и так далее). `product_properties` со временем превратится в свалку из большого количества необязательных полей, и выяснить, задание каких из них приведёт к каким эффектам в каком приложении можно будет только методом проб и ошибок.
Проблемы, с которыми мы столкнулись — это проблемы *сильной связности*. Каждый раз, предлагая интерфейс, подобный вышеприведённому, мы фактически описываем имплементацию одной сущности (рецепта) через имплементации других (визуального макета, правил локализации). Этот подход противоречит самому принципу проектирования API «сверху вниз», поскольку **низкоуровневые сущности не должны определять высокоуровневые**. Как бы парадоксально это ни звучало, обратное утверждение тоже верно: высокоуровневые сущности тоже не должны определять низкоуровневые. Это попросту не их ответственность.
#### Правило контекстов
Выход из этого логического лабиринта таков: высокоуровневые сущности должны *определять контекст*, который другие объекты будут интерпретировать. Чтобы спроектировать добавление нового рецепта нам нужно не формат данных подобрать — нам нужно понять, какие (возможно, неявные, т.е. не представленные в виде API) контексты существуют в нашей предметной области.
Как уже понятно, существует контекст локализации. Есть какой-то набор языков и регионов, которые мы поддерживаем в нашем API, и есть требования — что конкретно необходимо предоставить партнёру, чтобы API заработало на новом языке в новом регионе. Конкретно в случае объёма кофе где-то в недрах нашего API есть функция форматирования строк для отображения объёма напитка:
```
l10n.volume.format(value, language_code, country_code)
// l10n.formatVolume('300ml', 'en', 'UK') → '300 ml'
// l10n.formatVolume('300ml', 'en', 'US') → '10 fl oz'
```
Чтобы наше API корректно заработало с новым языком или регионом, партнер должен или задать эту функцию, или указать, какую из существующих локализаций необходимо использовать. Это можно сделать, например, так:
```
// Добавляем общее правило форматирования
// для русского языка
PUT /formatters/volume/ru
{
"template": "{volume} мл"
}
// Добавляем частное правило форматирования
// для русского языка в регионе «США»
PUT /formatters/volume/ru/US
{
// В США требуется сначала пересчитать
// объём, потом добавить постфикс
"value_preparation": {
"action": "divide",
"divisor": 30
},
"template": "{volume} ун."
}
```
**NB**: мы, разумеется, в курсе, что таким простым форматом локализации единиц измерения в реальной жизни обойтись невозможно, и необходимо либо положиться на существующие библиотеки, либо разработать сложный формат описания (учитывающий, например, падежи слов и необходимую точность округления), либо принимать правила форматирования в императивном виде (т.е. в виде кода функции). Пример выше приведён исключительно в учебных целях.
Вернёмся теперь к проблеме `name` и `description`. Для того, чтобы снизить связность в этом аспекте, нужно прежде всего формализовать (возможно, для нас самих, необязательно во внешнем API) понятие «макета». Мы требуем `name` и `description` не просто так в вакууме, а чтобы представить их во вполне конкретном UI. Этому конкретному UI можно дать идентификатор или значимое имя.
```
GET /v1/layouts/{layout_id}
{
"id",
// Макетов вполне возможно будет много разных,
// поэтому имеет смысл сразу заложить
// расширяемоесть
"kind": "recipe_search",
// Описываем каждое свойство рецепта,
// которое должно быть задано для
// корректной работы макета
"properties": [{
// Раз уж мы договорились, что `name`
// на самом деле нужен как заголовок
// в списке результатов поиска —
// разумнее его так и назвать `seach_title`
"field": "search_title",
"view": {
// Машиночитаемое описание того,
// как будет показано поле
"min_length": "5em",
"max_length": "20em",
"overflow": "ellipsis"
}
}, …],
// Какие поля обязательны
"required": ["search_title", "search_description"]
}
```
Таким образом, партнёр сможет сам решить, какой вариант ему предпочтителен. Можно задать необходимые поля для стандартного макета:
```
PUT /v1/recipes/{id}/properties/l10n/{lang}
{
"search_title", "search_description"
}
```
Либо создать свой макет и задавать нужные для него поля:
```
POST /v1/layouts
{
"properties"
}
→
{ "id", "properties" }
```
В конце концов, партнёр может отрисовывать UI самостоятельно и вообще не пользоваться этой техникой, не задавая ни макеты, ни поля.
Ту же самую технику — выделение отдельной сущности, которая занимается сопоставлением рецепта с его свойствами для нижележащих систем — мы можем использовать и для `execution_properties`, тем самым позволив партнеру контролировать ещё и то, каким образом рецепт связывается с программами исполнения. Тогда наш интерфейс получит вот такой вид:
```
POST /v1/recipes
{ "id" }
→
{ "id" }
```
Этот вывод может показаться совершенно контринтуитивным, однако отсутствие полей у сущности «рецепт» говорит нам только о том, что сама по себе она не несёт никакой семантики и служит просто способом указания контекста привязки других сущностей. В реальном мире следовало бы, пожалуй, собрать эндпойнт-строитель, который может создавать сразу все нужные контексты одним запросом:
```
POST /v1/recipe-builder
{
"id",
// Задаём свойства рецепта
"product_properties": {
"default_volume",
"l10n"
},
// Правила исполнения
"execution_properties"
// Создаём необходимые макеты
"layouts": [{
"id", "kind", "properties"
}],
// Добавляем нужные форматтеры
"formatters": {
"volume": [
{ "language_code", "template" },
{ "language_code", "country_code", "template" }
]
},
// Прочие действия, которые необходимо
// выполнить для корректного заведения
// нового рецепта в системе
…
}
```
Заметим, что передача идентификатора вновь создаваемой сущности клиентом — не лучший паттерн. Но раз уж мы с самого начала решили, что идентификаторы рецептов — не просто случайные наборы символов, а значимые строки, то нам теперь придётся с этим как-то жить. Очевидно, в такой ситуации мы рискуем многочисленными коллизиями между названиями рецептов разных партнёров, поэтому операцию, на самом деле, следует модифицировать: либо для партнерских рецептов всегда пользоваться парой идентификаторов (партнера и рецепта), либо ввести составные идентификаторы, как мы ранее рекомендовали в [главе 11](https://twirl.github.io/The-API-Book/docs/API.ru.html#chapter-11-paragraph-8).
```
POST /v1/recipes/custom
{
// Первая часть идентификатора:
// например, в виде идентификатора клиента
"namespace": "my-coffee-company",
// Вторая часть идентификатора
"id_component": "lungo-customato"
}
→
{
"id": "my-coffee-company:lungo-customato"
}
```
Заметим, что в таком формате мы сразу закладываем важное допущение: различные партнёры могут иметь как полностью изолированные неймспейсы, так и разделять их. Более того, мы можем ввести специальные неймспейсы типа "common", которые позволят публиковать новые рецепты для всех. (Это, кстати говоря, хорошо ещё и тем, что такое API мы сможем использовать для организации нашей собственной панели управления контентом.)
### Слабая связность
В предыдущей главе мы продемонстрировали, как разрыв сильной связанности приводит к декомпозиции сущностей и схлопыванию публичных интерфейсов до минимума. Внимательный читатель может подметить, что этот приём уже был продемонстрирован в нашем учебном API гораздо раньше [в главе 9](https://twirl.github.io/The-API-Book/docs/API.ru.html#chapter-9) на примере сущностей «программа» и «запуск программы». В самом деле, мы могли бы обойтись без программ и без эндпойнта `program-matcher` и пойти вот таким путём:
```
GET /v1/recipes/{id}/run-data/{api_type}
→
{ /* описание способа запуска
указанного рецепта на
машинах с поддержкой
указанного типа API */ }
```
Тогда разработчикам пришлось бы сделать примерно следующее для запуска приготовления кофе:
* выяснить тип API конкретной кофе-машины;
* получить описание способа запуска программы выполнения рецепта на машине с API такого типа;
* в зависимости от типа API выполнить специфические команды запуска.
Очевидно, что такой интерфейс совершенно недопустим — просто потому, что в подавляющем большинстве случаев разработчикам совершенно неинтересно, какого рода API поддерживает та или иная кофе-машина. Для того, чтобы не допустить такого плохого интерфейса мы ввели новую сущность «программа», которая по факту представляет собой не более чем просто идентификатор контекста, как и сущность «рецепт».
Аналогичным образом устроена и сущность `program_run_id`, идентификатор запуска программы. Он также по сути не имеет почти никакого интерфейса и состоит только из идентификатора запуска.
Зададимся теперь, однако, более интересным вопросом. Наше учебное API позволяет создавать запускать программы для вполне конкретных кофе-машин со вполне конкретным API. Предположим теперь, что к нам пришёл партнёр со своей сетью, которая представлена множеством различных кофе-машин, которые работают посредством множества различных API. Каким образом мы можем предоставить партнёру доступ к API программ, чтобы он мог сам подключать свои кофе-машины к системе?
Исходя из общей логики мы можем предположить, что любое API так или иначе будет выполнять три функции: запускать программы с указанными параметрами, возвращать текущий статус запуска и завершать (отменять) заказ. Самый очевидный подход к реализации такого API — просто потребовать от партнёра имплементировать вызов этих трёх функций удалённо, например следующим образом:
```
// Эндпойнт добавления списка
// кофе-машин партнёра
PUT /partners/{id}/coffee-machines
{
"coffee-machines": [{
"id",
…
"program_api": {
"program_run_endpoint": {
/* Какое-то описание
удалённого вызова эндпойнта */
"type": "rpc",
"endpoint": ,
"format"
},
"program\_state\_endpoint",
"program\_stop\_endpoint"
}
}, …]
}
```
**NB**: во многом таким образом мы переносим сложность разработки API в плоскость разработки форматов данных (каким образом мы будем передавать параметры запуска в `program_run_endpoint`, и в каком формате должен отвечать `program_state_endpoint`, но в рамках этой главы мы сфокусируемся на других вопросах.)
Хотя это API и кажется абсолютно универсальным, на его примере можно легко показать, каким образом изначально простые и понятные API превращаются в сложные и запутанные. У этого дизайна есть две основные проблемы.
1. Он хорошо описывает уже реализованные нами интеграции (т.е. в эту схему легко добавить поддержку известных нам типов API), но не привносит никакой гибкости в подход: по сути мы описали только известные нам способы интеграции, не попытавшись взглянуть на более общую картину.
2. Этот дизайн изначально основан на следующем принципе: любое приготовление заказа можно описать этими тремя императивными командами.
Пункт 2 очень легко опровергнуть, что автоматически вскроет проблемы пункта 1. Предположим для начала, что в ходе развития функциональности мы решили дать пользователю возможность изменять свой заказ уже после того, как он создан — ну, например, попросить посыпать кофе корицей или выдать заказ бесконтактно. Это автоматически влечёт за собой добавление нового эндпойнта, ну скажем, `program_modify_endpoint`, и новых сложностей в формате обмена данными (нам нужно уметь понимать в реальном времени, можно ли этот конкретный кофе посыпать корицей). Что важно, и то, и другое (и эндпойнт, и новые поля данных) из соображений обратной совместимости будут необязательными.
Теперь попытаемся придумать какой-нибудь пример реального мира, который не описывается нашими тремя императивами. Это довольно легко: допустим, мы подключим через наше API не кофейню, а вендинговый автомат. Это, с одной стороны, означает, что эндпойнт `modify` и вся его обвязка для этого типа API бесполезны — автомат не умеет посыпать кофе корицей, а требование бесконтактной выдачи попросту ничего не значит. С другой, автомат, в отличие от оперируемой людьми кофейни, требует программного способа *подтверждения выдачи* напитка: пользователь делает заказ, находясь где-то в другом месте, потом доходит до автомата и нажимает в приложении кнопку «выдать заказ». Мы могли бы, конечно, потребовать, чтобы пользователь создавал заказ автомату, стоя прямо перед ним, но это, в свою очередь, противоречит нашей изначальной концепции, в которой пользователь выбирает и заказывает напиток, исходя из доступных опций, а потом идёт в указанную точку, чтобы его забрать.
Программная выдача напитка потребует добавления ещё одного эндпойнта, ну скажем, `program_takeout_endpoint`. И вот мы уже запутались в лесу из трёх эндпойнтов:
* для работы вендинговых автоматов нужно реализовать эндпойнт `program_takeout_endpoint`, но не нужно реализовывать `program_modify_endpoint`;
* для работы обычных кофеен нужно реализовать эндпойнт `program_modify_endpoint`, но не нужно реализовывать `program_takeout_endpoint`.
При этом в документации интерфейса мы опишем и тот, и другой эндпойнт. Как несложно заметить, интерфейс `takeout` весьма специфичен. Если посыпку корицей мы как-то скрыли за общим `modify`, то на вот такие операции типа подтверждения выдачи нам каждый раз придётся заводить новый метод с уникальным названием. Несложно представить себе, как через несколько итераций интерфейс превратится в свалку из визуально похожих методов, притом формально необязательных — но для подключения своего API нужно будет прочитать документацию каждого и разобраться в том, нужен ли он в конкретной ситуации или нет.
Мы не знаем, правда ли в реальном мире API кофемашин возникнет проблема, подобная описанной. Но мы можем сказать со всей уверенностью, что *всегда*, когда речь идёт об интеграции «железного» уровня, происходят именно те процессы, которые мы описали: меняется нижележащая технология, и вроде бы понятное и ясное API превращается в свалку из легаси-методов, половина из которых не несёт в себе никакого практического смысла в рамках конкретной интеграции. Если мы добавим к проблеме ещё и технический прогресс — представим, например, что со временем все кофейни со временем станут автоматическими — то мы быстро придём к ситуации, когда половина методов *вообще не нужна*, как метод запроса бесконтактной выдачи напитка.
Заметим также, что мы невольно начали нарушать принцип изоляции уровней абстракции. На уровне API вендингового автомата вообще не существует понятие «бесконтактная выдача», это по сути продуктовый термин.
Каким же образом мы можем решить эту проблему? Одним из двух способов: или досконально изучить предметную область и тренды её развития на несколько лет вперёд, или перейти от сильной связанности к слабой. Как выглядит идеальное решение с точки зрения обеих взаимодействующих сторон? Как-то так:
* вышестоящий API программ не знает, как устроен уровень исполнения его команд; он формулирует задание так, как понимает на своём уровне: сварить такой-то кофе такого-то объёма, с корицей, выдать такому-то пользователю;
* нижележащий API исполнения программ не заботится о том, какие ещё вокруг бывают API того же уровня; он трактует только ту часть задания, которая имеет для него смысл.
Если мы посмотрим на принципы, описанные в предыдущей глава, то обнаружим, что этот принцип мы уже формулировали: нам необходимо задать *информационный контекст* на каждом из уровней абстракции, и разработать механизм его трансляции. Более того, в общем виде он был сформулирован ещё в [разделе «Потоки данных»](https://twirl.github.io/The-API-Book/docs/API.ru.html#chapter-9).
В нашем конкретном примере нам нужно имплементировать следующие механизмы:
* запуск программы создаёт контекст её исполнения, содержащий все существенные параметры;
* существует способ обмена информацией об изменении данных: исполнитель может читать контекст, узнавать о всех его изменениях и сообщать обратно о изменениях своего состояния.
Организовать и то, и другое можно разными способами, однако по сути мы имеем два описания состояния (верхне- и низкоуровневое) и поток событий между ними. В случае SDK эту идею можно было бы выразить так:
```
/* Имплементация партнёром интерфейса
запуска программы на его кофе-машинах */
registerProgramRunHandler(apiType, (program) => {
// Инициализируем запуск исполнения
// программы на стороне партнера
let execution = initExecution(…);
// Подписываемся на события
// изменения контекста
program.context.on('takeout_requested', () => {
// Если запрошена выдача напитка,
// инициализируем выдачу
execution.prepareTakeout(() => {
// как только напиток готов к выдаче,
// сигнализируем об этом
execution.context.emit('takeout_ready');
});
});
return execution.context;
});
```
**NB**: в случае HTTP API соответствующий пример будет выглядеть более громоздко, поскольку потребует создания отдельных эндпойнтов чтения очередей событий типа `GET /program-run/events` и `GET /partner/{id}/execution/events`, это упражнение мы оставляем читателю. Следует также отметить, что в реальных системах потоки событий часто направляют через внешнюю шину типа Apache Kafka или Amazon SQS.
Внимательный читатель может возразить нам, что фактически, если мы посмотрим на номенклатуру возникающих сущностей, мы ничего не изменили в постановке задачи, и даже усложнили её:
* вместо вызова метода `takeout` мы теперь генерируем пару событий `takeout_requested`/`takeout_ready`;
* вместо длинного списка методов, которые необходимо реализовать для интеграции API партнера, появляются длинные списки полей сущности `context` и событий, которые она генерирует;
* проблема устаревания технологии не меняется, вместо устаревших методов мы теперь имеем устаревшие поля и события.
Это замечание совершенно верно. Изменение формата API само по себе не решает проблем, связанных с эволюцией функциональности и нижележащей технологии. Формат API решает другую проблему: как оставить при этом код читаемым и поддерживаемым. Почему в примере с итеграцией через методы код становится нечитаемым? Потому что обе стороны *вынуждены* имплементировать функциональность, которая в их контексте бессмысленна; и эта имплементация будет состоять из какого-то (хорошо если явного!) способа ответить, что данная функциональность не поддерживается (или поддерживается всегда и безусловно).
Разница между жёстким связыванием и слабым в данном случае состоит в том, что механизм полей и событий *не является обязывающим*. Вспомним, чего мы добивались:
* верхнеуровневый контекст не знает, как устроено низкоуровневое API — и он действительно не знает; он описывает те изменения, которые происходят *в нём самом* и реагирует только на те события, которые имеют смысл *для него самого*;
* низкоуровневый контекст не знает ничего об альтернативных реализациях — он обрабатывает только те события, которые имеют смысл на его уровне, и оповещает только о тех событиях, которые могут происходить в его конкретной реализации.
В пределе может вообще оказаться так, обе стороны вообще ничего не знают друг о друге и никак не взаимодействуют — не исключаем, что на каком-то этапе развития технологии именно так и произойдёт.
Важно также отметить, что, хотя количество сущностей (полей, событий) эффективно удваивается по сравнению с сильно связанным API, это удвоение является качественным, а не количественным. Контекст `program` содержит описание задания в своих терминах (вид напитка, объём, посыпка корицей); контекст `execution` должен эти термины переформулировать для своей предметной области (чтобы быть, в свою очередь, таким же информационным контекстом для ещё более низкоуровневого API). Что важно, `execution`-контекст имеет право эти термины конкретизировать, поскольку его нижележащие объекты будут уже работать в рамках какого-то конкретного API, в то время как `program`-контекст обязан выражаться в общих терминах, применимых к любой возможной нижележащей технологии.
Ещё одним важным свойством такой событийной связности является то, что она позволяет сущности иметь несколько вышестоящих контекстов. В обычных предметных областях такая ситуация выглядела бы ошибкой дизайна API, но в сложных системах, где присутствуют одновременно несколько агентов, влияющих на состояние системы, такая ситуация не является редкостью. В частности, вы почти наверняка столкнётесь с такого рода проблемами при разработке пользовательского UI. Более подробно о подобных двойных иерархиям мы расскажем в разделе, посвященном разработке SDK.
#### Инверсия ответственности
Как несложно понять из вышесказанного, двусторонняя слабая связь означает существенное усложнение имплементации обоих уровней, что во многих ситуациях может оказаться излишним. Часто двустороннюю слабую связь можно без потери качества заменить на одностороннюю, а именно — разрешить нижележащей сущности вместо генерации событий напрямую вызывать методы из интерфейса более высокого уровня. Наш пример изменится примерно вот так:
```
/* Имплементация партнёром интерфейса
запуска программы на его кофе-машинах */
registerProgramRunHandler(apiType, (program) => {
// Инициализируем запуск исполнения
// программы на стороне партнера
let execution = initExection(…);
// Подписываемся на события
// изменения контекста
program.context.on('takeout_requested', () => {
// Если запрошена выдача напитка,
// инициализируем выдачу
execution.prepareTakeout(() => {
/* как только напиток готов к выдаче,
сигнализируем об этом, но не
посредством генерации события */
// execution.context.emit('takeout_ready')
program.context.set('takeout_ready');
// Или ещё более жёстко:
// program.setTakeoutReady();
});
});
// Так как мы сами изменяем родительский контекст
// нет нужды что-либо возвращать
// return execution.context;
}
```
Вновь такое решение выглядит контринтуитивным, ведь мы снова вернулись к сильной связи двух уровней через жестко определённые методы. Однако здесь есть важный момент: мы городим весь этот огород потому, что ожидаем появления альтернативных реализаций *нижележащего* уровня абстракции. Ситуации, когда появляются альтернативные реализации *вышележащего* уровня абстракции, конечно, возможны, но крайне редки. Обычно дерево альтернативных реализаций растёт сверху вниз.
Другой аспект заключается в том, что, хотя серьёзные изменения концепции возможны на любом из уровне абстракции, их вес принципиально разный:
* если меняется технический уровень, это не должно существенно влиять на продукт, а значит — на написанный партнерами код;
* если меняется сам продукт, ну например мы начинаем продавать билеты на самолёт вместо приготовления кофе на заказ, сохранять обратную совместимость на промежуточных уровнях API *бесполезно*. Мы вполне можем продавать билеты на самолёт тем же самым API программ и контекстов, да только написанный партнёрами код всё равно надо будет полностью переписывать с нуля.
В конечном итоге это приводит к тому, что API вышележащих сущностей меняется медленнее и более последовательно по сравнению с API нижележащих уровней, а значит подобного рода «обратная» жёсткая связь зачастую вполне допустима и даже желательна исходя из соотношения «цена-качество».
**NB**: во многих современных системах используется подход с общим разделяемым состоянием приложения. Пожалуй, самый популярный пример такой системы — Redux. В парадигме Redux вышеприведённый код выглядел бы так:
```
execution.prepareTakeout(() => {
// Вместо обращения к вышестоящей сущности
// или генерации события на себе,
// компонент обращается к глобальному
// состоянию и вызывает действия над ним
dispatch(takeoutReady());
});
```
Надо отметить, что такой подход *в принципе* не противоречит описанному принципу, но нарушает другой — изоляцию уровней абстракции, а поэтому плохо подходит для написания сложных API, в которых не гарантирована жесткая иерархия компонентов. При этом использовать глобальный (или квази-глобальный) менеджер состояния в таких системах вполне возможно, но требуется имплементировать более сложную пропагацию сообщений по иерархии, а именно: подчинённый объект всегда вызывает методы только ближайшего вышестоящего объекта, а уже тот решает, как и каким образом этот вызов передать выше по иерархии.
```
execution.prepareTakeout(() => {
// Вместо обращения к вышестоящей сущности
// или генерации события на себе,
// компонент обращается к вышестоящему
// объекту
program.context.dispatch(takeoutReady());
});
```
```
// Имплементация program.context.dispatch
ProgramContext.dispatch = (action) => {
// program.context обращается к своему
// вышестоящему объекту, или к глобальному
// состоянию, если такого объекта нет
globalContext.dispatch(
// При этом сама суть действия
// может и должна быть переформулирована
// в терминах соответствующего уровня
// абстракции
this.generateAction(action);
)
}
```
---
Это черновик двух новых глав будущего раздела «Обратная совместимость» моей книги о разработке API. Работа ведётся на [Github](https://github.com/twirl/The-API-Book). Англоязычный вариант этой же главы опубликован на [medium](https://twirl.medium.com/weak-coupling-edabb82a1af3). Я буду признателен, если вы пошарите его на реддит — я сам не могу согласно политике платформы. | https://habr.com/ru/post/554632/ | null | ru | null |
# Решение проблемы конфликтов имен CSS классов в приложении на React с помощью webpack лоадера
Приветствую вас, друзья!
Началось всё с того, что я замыслил разработать кое-что так сказать для души. React приложение должно было рендериться поверх чего-то другого, например какого-то сайтика, встал вопрос того, что возможны конфликты CSS классов моего приложения с уже существующей инфраструктурой, ну я конечно же пришел к выводу, что нужно внедрить префиксы для каждого даже самого захудалого класса, ну или оборачивать все определения в класс моего главного контейнера, я все же выбрал префиксы. Но вскоре я устал от них, их получалось так много, что все это казалось мне пустой копипастой, и тогда я задумался над созданием своего лоадера для вебпака. В результате работа над ним переросла из мухи в слона, идеи переполняли меня и в итоге мой ум и руки сотворили монстра, который чуть было не вышел из под моего контроля.
Признаюсь за эти полторы недели его написания я дико устал думать, кодить и документировать сначала на английском, потом переводить с моего корявого английского на чуть менее корявый родной язык, скорее бы уже это закончилось. Зато теперь я знатный программист markdown и пользователь регулярок.
Итак нужен был просто механизм замены classname на my-app-classname, но в итоге получилось то, что я сейчас подробно опишу. Результат своих трудов я опубликовал на npm.
Для начала возможно кому-то будет интересно, как сотворить свой лоадер для вебпака. Достаточно несложно: создаем папку, называем ее my-divine-loader, в ней индексный JS файл и такой код:
```
const {getOptions} = require('loader-utils');
module.exports = function(source) {
// делаем нужные преобразования и отдаем
// всё необходимое берем из объекта this
// из getOptions получаем опции нашего лоадера, которые передали в webpack.config.js
return source;
}
```
Установка
---------
### NPM
```
npm install --save classy-loader
```
### Пример поиграться
[Ссылка на Github репозиторий](https://github.com/bushstas/classy-loader-example.git)
Добавление в конфиг Вебпака
---------------------------
### Для начала зададим нужные настройки.
```
const classy = require('classy-loader');
classy.init({
attributeName: 'class',
extraAttributeName: 'classes',
globalPrefix: 'awesome-example-app',
delimiter: '-',
obfuscation: false,
obfuscatedLength: 4,
autoPrefixMode: false,
prefixAutoResolving: false
});
//...
module: {
rules: [
{
test: /\.js$/,
loaders: [
{
loader: 'babel-loader',
options: {
//....
}
},
{
loader: 'classy-loader?parser=js'
}
]
},
{
test: /\.s?css$/,
loader: ExtractTextPlugin.extract(
{
fallback: 'style-loader',
use: [
'css-loader?root=...',
'sass-loader',
'classy-loader?parser=css'
]
}
)
}
]
}
//...
```
Как видно из примера, лоадер следует добавить после бабеля и стандартных лоадеров стилей.
### attributeName
Название атрибута DOM элементов, которое будет парситься лоадером.
Оно может быть каким угодно и будет преобразовано в стандартный атрибут "className".
По умолчанию данный параметр равен "class".
```
render() {
return (
...
)
}
```
или так
```
render() {
return (
...
)
}
```
Так что "class" и "whateverName" наши названия attributeName.
После обработки лоадером код будет выглядеть так:
```
render() {
return (
...
)
}
```
Для лоадера **"self"** — ключевое слово, которое означает наш глобальный или локальный префикс имени класса.
Конкретно в этом случае у нас нет локального префикса, так что **"self"** будет равен значению глобального.
### extraAttributeName
Название атрибута для React элементов, которое будет парситься таким же образом, но не менять своего названия.
Оно также может использоваться для названий переменных и ключей объектов, которые нужно распарсить.
По умолчанию оно равно "classes".
```
render() {
return (
Нажми меня!
)
}
let classes = ".some-class";
let object = {
classes: ".some-other-class"
};
```
На выходе мы получим всё тот же атрибут "classes":
```
render() {
return (
Do it!
)
}
let classes = "awesome-example-app-some-class";
let object = {
classes: "awesome-example-app-some-other-class"
};
```
### globalPrefix
Префикс, который будет добавляться к именам классов DOM элементов.
Специальный синтаксис скажет лоадеру нужно ли добавлять какой-то из префиксов или нет.
По умолчанию он пуст, так что это означает, что никакого префикса добавлено не будет, если не задан локальный префикс.
```
render() {
return (
...
)
}
```
станет
```
render() {
return (
...
)
}
```
Точка значит, что имя класса должно иметь префикс.
Подробнее о синтаксисе парсера представлено ниже.
### delimiter
Символ или слово, которыми префиксы и имена классов будут объединяться.
По умолчанию равен "-".
```
render() {
return (
...
)
}
```
Так что, если наш **"delimiter"** равен "\_", код будет таким:
```
render() {
return (
...
)
}
```
### prefixAutoResolving
Если данный параметр задан, лоадер попытается определить локальный префикс самостоятельно.
По умолчанию он не задан.
Есть три варианта значений:
#### `prefixAutoResolving: "content"`
Для начала лоадер попытается найти строку, которая содержит:
**export default (class|function) MySuperClassName**
Затем будет искать:
**export default connect(...)(MySuperClassName)**
Если не найдет:
**class MySuperClassName**
Ну и в конце концов возьмет первую попавшуюся строку с таким кодом:
**function MySuperClassName**
Итак "MySuperClassName" будет преобразовано в локальный префикс "my" + delimiter + "super" + delimiter + "class" + delimiter + "name".
Для CSS файлов лоадер будет искать данные в кэше, который заполняется при обработке JS файлов.
Если в кэше найдется информация о префиксах для индексного файла в той же директории,
они будут использованы, таким образом JS и CSS будут синхронизированы.
Вам следует располагать JS лоадеры перед CSS лоадерами, чтобы парсер имел нужный кэш.
```
export default class MySuperButton extends React.Component {
render() {
return (
....
)
}
}
```
станет
```
export default class MySuperButton extends React.Component {
render() {
return (
....
)
}
}
```
Также вы можете задавать JS/CSS локальные префиксы с помощью специальных директив.
Больше о них написано ниже.
#### `prefixAutoResolving: "file"`
Лоадер будет формировать локальный префикс из имён JS/CSS файлов:
"SuperItem.js" или "super-item.js" или "super\_item.js"
превратится в префикс "super" + delimiter + "item".
Для данного способа файлы должны называться одинаково, чтобы они были синхронизированы.
#### `prefixAutoResolving: "folder"`
Лоадер будет формировать локальный префикс из имён директорий:
"SuperItem/index.js" или "super-item/some.js" или "super\_item/any.js"
станут префиксом "super" + delimiter + "item".
Самый простой способ синхронизировать JS/CSS, также ваша структура будет более понятна.
### obfuscation
Если установлен в true, лоадер будет обфусцировать имена классов в JS и CSS файлах.
Будьте внимательны, все CSS классы будут изменены в любом случае, а JS только внутри атрибутов **"attributeName"** and **extraAttributeName**.
По умолчанию эта опция не активна.
```
render() {
return (
...
)
}
```
станет
```
render() {
return (
...
)
}
```
### obfuscatedLength
Длина в символах, до которой имена классов будут обфусцированы.
По умолчанию значение равно "7".
Так что, если у нас **"obfuscatedLength"** равно 4
```
render() {
return (
...
)
}
```
### autoPrefixMode
Лоадер будет автоматически добавлять префиксы к нашим именам классов.
Вам нужно будет использовать немного другой строковый формат имен классов.
По умолчанию этот параметр выключен.
Например, вот это запись CSS классов для неавтопрефиксного режима:
(**"prefixAutoResolving"** имеет значение "content")
```
export default class Container extends React.Component {
render() {
return (
...
)
}
}
```
будет преобразовано в
```
export default class Container extends React.Component {
render() {
return (
...
)
}
}
```
Здесь локальный префикс является "awesome-example-app-container" (глобальный префикс плюс добавленный автоматически от имени класса "Container").
Так что в этом режиме вам нужно добавлять точки для префиксов: одна для локального и две для глобального.
И наконец пример описания CSS классов для автопрефиксного режима
(**"prefixAutoResolving"** имеет значение "content")
В результате мы получим то же самое, что и в первом случае.
```
export default class Container extends React.Component {
render() {
return (
...
)
}
}
```
будет также
```
export default class Container extends React.Component {
render() {
return (
...
)
}
}
```
В этом режиме не нужно добавлять точку для локального префикса, одну нужно добавить для глобального и две для имен классов без префикса.
В CSS файлах все работает по тем же принципам (нужно добавлять такое же число точек, так что получится максимум три точки)
Неавтопрефиксный режим:
```
/* Директива, которая задает наш локальный префикс (добавляет дополнительный префикс к глобальному) */
.with.addedPrefix.container;
..self {
position: relative;
&...area {
background-color: #eee;
border: 1px solid #aaa;
}
&.wide {
width: 80%;
}
..content {
padding: 10px;
&.content {
padding-top: 0;
}
}
}
```
будет
```
.awesome-example-app-container {
position: relative;
&.awesome-example-app-area {
background-color: #eee;
border: 1px solid #aaa;
}
&.wide {
width: 80%;
}
.awesome-example-app-container-content {
padding: 10px;
&.content {
padding-top: 0;
}
}
}
```
И то же самое для автопрефиксного режима:
```
/* Директива, которая задает наш локальный префикс (добавляет дополнительный префикс к глобальному) */
.with.addedPrefix.container;
.self {
position: relative;
&..area {
background-color: #eee;
border: 1px solid #aaa;
}
&...wide {
width: 80%;
}
.content {
padding: 10px;
&...content {
padding-top: 0;
}
}
}
```
даст тот же самый результат
```
.awesome-example-app-container {
position: relative;
&.awesome-example-app-area {
background-color: #eee;
border: 1px solid #aaa;
}
&.wide {
width: 80%;
}
.awesome-example-app-container-content {
padding: 10px;
&.content {
padding-top: 0;
}
}
}
```
Директивы
---------
### JS директивы
* ### with prefix 'some-prefix';
Создает локальную версию глобального префикса, которая переопределяет его в рамках одого файла.
Две точки всё так же будут добавлять стандартный глобальный префикс определенный в конфиге.
```
// неавтопрефиксный режим
// prefixAutoResolving: "content"
// ...imports
with prefix 'crazy-app';
export default class Container extends React.Component {
render() {
return (
...
...
)
}
}
```
станет
```
// ...imports
export default class Container extends React.Component {
render() {
return (
...
...
)
}
}
```
А теперь результат для случая, когда **"prefixAutoResolving"** установлен в false,
так что у нас нет добавленного локального префикса,
только переопределенный глобальный
```
// ...imports
export default class Container extends React.Component {
render() {
return (
...
...
)
}
}
```
* ### with auto prefix 'some-prefix';
Всё то же самое, как и с директивой выше, плюс устанавливает автопрефиксный режим в пределах данного файла.
* ### with addedPrefix 'some-additional-prefix';
Задает добавленный префикс для локального использования.
Эта директива делает что-то вроде параметра **«prefixAutoResolving»**, так что найдя ее лоадер не будет определять префикс автоматически.
```
// неавтопрефиксный режим
// ...imports
with addedPrefix 'dialog';
export default class Dialog extends React.Component {
render() {
return (
...
...
)
}
}
```
будет
```
// ...imports
export default class Dialog extends React.Component {
render() {
return (
...
...
)
}
}
```
* ### with auto addedPrefix 'some-additional-prefix';
Всё то же самое, как для директивы выше, плюс устанавливает автопрефиксный режим в пределах данного файла.
* ### with auto prefix;
Устанавливает автопрефиксный режим в пределах данного файла.
### CSS директивы
CSS директивы делают абсолютно то же самое и выглядят весьма схоже с JS версиями,
отличие только в последней директиве, которой нет для JS файлов
* ### .with.prefix.some-prefix;
* ### .with.auto.prefix.some-prefix;
* ### .with.addedPrefix.additional-prefix;
* ### .with.auto.addedPrefix.additional-prefix;
* ### .with.auto.prefix;
* ### .with.no.prefix;
Предписывает лоадеру не добавлять ни каких префиксов, даже если есть ".." / "..."
Две или три точки будут восприниматься как одна.
Синтаксис строковых обозначений CSS классов
-------------------------------------------
```
render() {
return (
...
)
}
```
### name
Обозначает имя класса без префиксов в неавтопрефиксном режиме.
Обозначает имя класса с локальным префиксом в автопрефиксном режиме.
```
render() {
return (
...
//and
...
)
}
```
### .name
Обозначает имя класса с локальным префиксом в неавтопрефиксном режиме.
Обозначает имя класса с глобальным префиксом в автопрефиксном режиме.
```
render() {
return (
...
//and
...
)
}
```
### ..name
Обозначает имя класса с глобальным префиксом в неавтопрефиксном режиме.
Обозначает имя класса без префиксов в автопрефиксном режиме.
```
render() {
return (
...
//and
...
)
}
```
### $name
"Мерджит" имя класса или массив имен из переменной.
Лоадер автоматически добавит "импорт" нужного для "мерджинга" модуля.
Переменная уже должна содержать имя/имена классов с префиксами или быть обфусцирована.
```
render() {
return (
...
)
}
```
Пример того, как это в принципе работает:
В родительском компоненте используем **extraAttributeName: "classes"**
```
render() {
return (
resize
)
}
```
в дочернем (с именем Icon)
```
with addedPrefix 'icon';
export default function Icon({classes, children}) {
return (
*{children}*
)
}
```
так что в итоге получим
в родителе:
```
render() {
return (
resize
)
}
```
в компоненте Icon "import" автоматически добавлен
```
import classy from 'classy-loader/classy';
export default function Icon({classes, children}) {
return (
*{children}*
)
}
```
А так код будет выглядеть в собранном "бандле":
```
return _react2.default.createElement(
'i',
_extends({
className: (0, _classy2.default)("awesome-example-app-icon", classes, "material-icons")
}),
children
);
```
### $$name
То же самое, что и с переменной выше, но говорит лоадеру, что переменная является строкой, а не массивом или "undefined",
чтобы лоадер не использовал функцию мерджинга, однако если есть другие переменные вида $name, функция все равно будет использована
```
render() {
return (
...
)
}
```
станет
```
render() {
return (
...
)
}
```
### prefix::name
Добавляет локальный (по отношению к дочернему компоненту) префикс к имени класса.
Возьмем пример с Icon выше и немного изменим его.
```
render() {
return (
resize
)
}
```
В принципе можно просто использовать запись вида ".icon-thing",
но первый вариант соединит их нужным разделителем.
```
render() {
return (
resize
)
}
```
Так что у нас будет такой HTML
```
*resize*
```
### .$name
Динамическое имя класса, локальный префикс плюс значение переменной.
Это всегда локальный префикс независимо от режима.
```
with addedPrefix 'tab';
export default function Tab({classes, children, isActive}) {
render() {
let className = isActive ? 'active' : 'inactive';
return (
{children}
)
}
}
```
будет
```
import classy from 'classy-loader/classy';
export default function Tab({classes, children, isActive}) {
render() {
let className = isActive ? 'active' : 'inactive';
return (
{children}
)
}
}
```
### ..$name
Динамическое имя класса, глобальный префикс плюс значение переменной.
Это всегда глобальный префикс независимо от режима.
```
with addedPrefix 'button';
export default class Button extends React.Component {
render() {
let className = 'active';
return (
...
)
}
}
```
будет
```
export default class Button extends React.Component {
render() {
let className = 'active';
return (
...
)
}
}
```
Невозможно (или просто х.з. как) обфусцировать такой динамический класс,
но для таких целей внедрена специальная "фейковая" функция **$classy**.
Она создает "карту" имен классов для обфускатора.
Вот пример:
```
let className = $classy(color, '..color-', ['red', 'green']);
className = $classy(color, '.color-', ['blue', 'yellow']);
className = $classy(number, '..', ['one', 'two']);
className = $classy(quality, '.', ['good', 'bad']);
className = $classy(name, '', ['John', 'Rick']);
```
В неавтопрефиксном режиме будет преобразовано в:
```
let className = {
red: 'awesome-example-app-color-red',
green: 'awesome-example-app-color-green'
}[color];
className = {
blue: 'awesome-example-app-button-color-blue',
yellow: 'awesome-example-app-button-color-yellow'
}[color];
className = {
one: 'awesome-example-app-one',
two: 'awesome-example-app-two'
}[number];
className = {
good: 'awesome-example-app-button-good',
bad: 'awesome-example-app-button-bad'
}[quality];
className = {
John: 'John',
Rick: 'Rick'
}[name];
```
И в автопрефиксном режиме будет:
```
let className = {
red: 'color-red',
green: 'color-green'
}[color];
className = {
blue: 'awesome-example-app-color-blue',
yellow: 'awesome-example-app-color-yellow'
}[color];
className = {
one: 'one',
two: 'two'
}[number];
className = {
good: 'awesome-example-app-good',
bad: 'awesome-example-app-bad'
}[quality];
className = {
John: 'awesome-example-app-button-John',
Rick: 'awesome-example-app-button-Rick'
}[name];
```
Так что переменная "className" будет реальным именем класса, которое можно обфусцировать и иметь вид:
```
let className = {
red: 'hby457r',
green: 'fhelf76',
blue: 'dh409gl',
yellow: 'sl58sgf',
orange: 'dl50gak',
...
}[color];
```
Другой способ для этих нужд, но уже c различными "паттернами":
```
let className = $classy(colorValue, {
red: "..red item::reddish",
green: "..green ..greenish",
...
});
```
Даст код:
```
let className = {
red: 'awesome-example-app-red awesome-example-app-item-reddish',
green: 'awesome-example-app-green awesome-example-app-greenish',
...
}[colorValue];
```
Ну и последнее как можно использовать **$classy**:
```
with addedPrefix 'catalog';
// ....
let className = $classy(".item item ..some-item $classes");
```
станет
```
import classy from 'classy-loader/classy';
// ....
let className = classy("awesome-example-app-catalog-item", "item", "awesome-example-app-some-item", classes);
```
Условные (тернарные) записи CSS классов
---------------------------------------
### Для начала простые
```
// все примеры с globalPrefix = 'app'
// все примеры с autoPrefixMode = false
// все примеры когда addedPrefix = 'item'
render() {
let active = true;
return (
...
...
...
...
...
)
}
```
станет
```
render() {
let active = true;
return (
...
...
...
...
...
)
}
```
Можно добавлять пробелы между символами "?" и ":"
```
render() {
return (
...
)
}
```
Но вот в условии пробелы недопустимы:
```
render() {
return (
...
)
}
```
Такая запись будет преобразована в некорректное имя класса вида
```
render() {
return (
...
)
}
```
Если так хочется добавить пробелы, оберните условие в круглые скобки
```
render() {
return (
...
)
}
```
Возможно указывать только один знак "$" в начале условия,
для остальных переменных условия знак можно не добавлять:
```
render() {
return (
...
// or
...
)
}
```
И наконец вишенка на торте
--------------------------
```
render() {
return (
...
)
}
```
будет
```
render() {
return (
...
)
}
```
И с отрицанием
```
render() {
return (
...
)
}
```
будет
```
render() {
return (
...
)
}
```
Точки работают по таким же принципам, как и всегда, в зависимости от режима.
CSS синтаксис
-------------
### Для неавтопрефиксного режима
Одна точка для реальных имён классов без префиксов.
Две точки для имён с локальным префиксом.
Три точки для имён с глобальным префиксом.
**"Self"** — ключевое слово обозначающее локальный или глобальный префикс, если таковые определены, иначе имя класса будет просто self
```
..self {
..title {
}
..content {
}
...active {
}
.item {
}
}
```
### Для автопрефиксного режима
Одна точка для имён классов с локальным префиксом.
Две точки для имён с глобальным префиксом.
Три точки для реальных имён классов без префиксов.
```
.self {
.title {
}
.content {
}
..active {
}
...item {
}
}
```
Если локальный префикс не определен, будет использован глобальный.
А теперь немного CSS сахара
---------------------------
Пример сахарного синтаксиса:
```
.container {
var .abs.w100.h200.bc-000.c-fff.fs15;
}
```
будет преобразовано в:
```
.container {
position: absolute;
width: 100px;
height: 200px;
background-color: #000;
color: #fff;
font-size: 15px;
}
```
Можно также с пробелами:
```
.container {
var .fix .l .r .t .b .z999 .o3;
}
```
станет
```
.container {
position: fixed;
left: 0;
right: 0;
top: 0;
bottom: 0;
z-index: 999;
opacity: 0.3;
}
```
Выражение должно начинаться с ключегово слова **"var"** и заканчиваться точкой с запятой или переносом строки.
### Полный список доступных сокращений
**Кликни меня****rubb** = left: 0; right: 0; top: 0; bottom: 0;
**l** = left: 0;
**l10** = left: 10px;
**l-10** = left: -10px;
**l50p** = left: 50%;
**l-50p** = left: -50%;
**r** = right: 0;
**r10** = right: 10px;
**r-10** = right: -10px;
**r50p** = right: 50%;
**r-50p** = right: -50%;
**t** = top: 0;
**t10** = top: 10px;
**t-10** = top: -10px;
**t50p** = top: 50%;
**t-50p** = top: -50%;
**b** = bottom: 0;
**b10** = bottom: 10px;
**b-10** = bottom: -10px;
**b50p** = bottom: 50%;
**b-50p** = bottom: -50%;
**z10** = z-index: 10;
**w** = width: 100%;
**w100** = width: 100px;
**w50p** = width: 50%;
**h** = height: 100%;
**h150** = height: 150px;
**h20p** = height: 20%;
**wh** = width: 100%; height: 100%;
**wh20** = width: 20px; height: 20px;
**wh20p** = width: 20%; height: 20%;
**mnw** = min-width: 0;
**mnw100** = min-width: 100px;
**mnh** = min-height: 0;
**mnh100** = min-height: 100px;
**mxw** = max-width: none;
**mxw100** = max-width: 100px;
**mxh** = max-height: none;
**mxh100** = max-height: 100px;
**auto** = margin: auto;
**m** = margin: 0;
**m5** = margin: 5px;
**m10-5** = margin: 10px 5px;
**m10-5-10-5** = margin: 10px 5px 10px 5px;
**ml** = margin-left: 0;
**ml5** = margin-left: 5px;
**ml-5** = margin-left: -5px;
**ml5p** = margin-left: 5%;
**ml-5p** = margin-left: -5%;
**mr** = margin-right: 0;
**mr5** = margin-right: 5px;
**mr-5** = margin-right: -5px;
**mr5p** = margin-right: 5%;
**mr-5p** = margin-right: -5%;
**mt** = margin-top: 0;
**mt5** = margin-top: 5px;
**mt-5** = margin-top: -5px;
**mt5p** = margin-top: 5%;
**mt-5p** = margin-top: -5%;
**mb** = margin-bottom: 0;
**mb5** = margin-bottom: 5px;
**mb-5** = margin-bottom: -5px;
**mb5p** = margin-bottom: 5%;
**mb-5p** = margin-bottom: -5%;
**p** = padding: 0;
**p5** = padding: 5px;
**p10-5** = padding: 10px 5px;
**p10-5-10-5** = padding: 10px 5px 10px 5px;
**pl** = padding-left: 0;
**pl5** = padding-left: 5px;
**pl-5** = padding-left: -5px;
**pl5p** = padding-left: 5%;
**pl-5p** = padding-left: -5%;
**pr** = padding-right: 0;
**pr5** = padding-right: 5px;
**pr-5** = padding-right: -5px;
**pr5p** = padding-right: 5%;
**pr-5p** = padding-right: -5%;
**pt** = padding-top: 0;
**pt5** = padding-top: 5px;
**pt-5** = padding-top: -5px;
**pt5p** = padding-top: 5%;
**pt-5p** = padding-top: -5%;
**pb** = padding-bottom: 0;
**pb5** = padding-bottom: 5px;
**pb-5** = padding-bottom: -5px;
**pb5p** = padding-bottom: 5%;
**pb-5p** = padding-bottom: -5%;
**flex** = display: flex;
**flcen** = align-item: center; justify-content: center;
**bl** = display: block;
**inb** = display: inline-block;
**fix** = position: fixed;
**abs** = position: absolute;
**rel** = position: relative;
**box** = box-sizing: border-box;
**ova** = overflow: auto;
**ovh** = overflow: hidden;
**ovs** = overflow: scroll;
**lt** = text-align: left;
**rt** = text-align: right;
**cen** = text-align: center;
**just** = text-align: justify;
**vtop** = vertical-align: top;
**vmid** = vertical-align: middle;
**vbot** = vertical-align: bottom;
**cur** = cursor: default;
**cur-name** = cursor: name;
**pntr** = cursor: pointer;
**cnt** = content: "";
**nor** = resize: none;
**fl** = float: left;
**fr** = float: right;
**clr** = clear: both;
**bold** = font-weight: bold;
**it** = font-style: italic;
**un** = text-decoration: underline;
**lh** = line-height: 0;
**lh20** = line-height: 20px;
**ls** = letter-spacing: 0;
**ls2** = letter-spacing: 2px;
**fs** = font-size: 0;
**fs15** = font-size: 15px;
**ff-name** = font-family: name;
**o** = opacity: 0;
**o5** = opacity: 0.5;
**o10** = opacity: 1;
**ol** = outline: 0;
**ol-000** = outline: 1px solid #000;
**ol-EEE-2** = outline: 2px solid #EEE;
**ol-EEE-2-dashed** = outline: 2px dashed #EEE;
**bo** = border: 0;
**bo-000** = border: 1px solid #000;
**bo-EEE-2** = border: 2px solid #EEE;
**bo-EEE-2-dashed** = border: 2px dashed #EEE;
**bol** = border-left: 0;
**bol-000** = border-left: 1px solid #000;
**bol-EEE-2** = border-left: 2px solid #EEE;
**bol-EEE-2-dashed** = border-left: 2px dashed #EEE;
**bor** = border-right: 0;
**bor-000** = border-right: 1px solid #000;
**bor-EEE-2** = border-right: 2px solid #EEE;
**bor-EEE-2-dashed** = border-right: 2px dashed #EEE;
**bot** = border-top: 0;
**bot-000** = border-top: 1px solid #000;
**bot-EEE-2** = border-top: 2px solid #EEE;
**bot-EEE-2-dashed** = border-top: 2px dashed #EEE;
**bob** = border-bottom: 0;
**bob-000** = border-bottom: 1px solid #000;
**bob-EEE-2** = border-bottom: 2px solid #EEE;
**bob-EEE-2-dashed** = border-bottom: 2px dashed #EEE;
**br** = border-radius: 0;
**br5** = border-radius: 5px;
**br50p** = border-radius: 50%;
**br5-10-10-0** = border-radius: 5px 10px 10px 0;
**bsp** = border-spacing: 0;
**bsp2** = border-spacing: 2px;
**c-fff** = color: #fff;
**bc-fff** = background-color: #fff;
**boc-fff** = border-color: #fff;
**shad** = box-shadow: none;
**shad-000-10** = box-shadow: 0 0 10px #000;
**shad-000-10-1-1** = box-shadow: 1px 1px 10px #000;
**tshad** = text-shadow: none;
**tshad-000-2** = text-shadow: 0 0 2px #000;
**tshad-000-2-1-1** = text-shadow: 1px 1px 2px #000;
**tra-c-3-bc-3-o-3** = transition: color 0.3s, background-color 0.3s, opacity 0.3s;
**rot20** = transform: rotate(20deg);
**rot-45** = transform: rotate(-45deg);
**ell** = text-overflow: ellipsis; overflow: hidden; white-space: nowrap;
**nowr** = white-space: nowrap;
**hid** = visibility: hidden;
**norep** = background-repeat: no-repeat;
**repx** = background-repeat: repeat-x;
**repy** = background-repeat: repeat-y;
**cvr** = background-size: cover;
**bpcen** = background-position: 50% 50%;
**bp-20-20** = background-position: 20px 20px;
**bp-50p-20p** = background-position: 20% 20%;
**bp-c-b** = background-position: center bottom;
**bp-r-t** = background-position: right top;
**bp-l-10** = background-position: left 10px;
### Сокращения для фоновых изображений
Тут все посложнее, и для начала нужно определить источник(и) файлов.
Для этих нужд имеются директивы, их может быть несколько, если файлы располагаются в разных директориях.
Путь конечно же к директория:
```
.with.image.source '../../assets/images/';
.with.image.source './bg-images';
.with.image.source './images/gifs';
.with.image.source '../svgs';
```
А сокращения выглядяь так:
```
.item {
var .png-arrow.jpg-bg.jpeg-line.png2-some-image;
var .gif3-preloader.svg4-icon;
}
```
Итак сокращение состоит из:
1. Расширение
2. Номер источника начиная с единицы (если это первый источник, цифру можно опустить)
3. Имя файла
Так что на выходе вы получите такую запись:
```
.item {
background-image: url(../../assets/images/arrow.png);
background-image: url(../../assets/images/bg.jpg);
background-image: url(../../assets/images/line.jpeg);
background-image: url(./bg-images/some-image.png);
background-image: url(./images/gifs/preloader.gif);
background-image: url(../svgs/icon.svg);
}
```
Дальше уже дело за лоадерами картинок, пути указаны для них.
Итак список сокращений:
**Меня кликни****png-png-filename** = background-image: url(../some/path/png-filename.png);
**jpg-jpg\_filename** = background-image: url(../some/path/jpg\_filename.jpg);
**jpeg-oneMoreJpgFilename** = background-image: url(../some/path/oneMoreJpgFilename.jpeg);
**gif-giffy** = background-image: url(../some/path/giffy.gif);
**svg-blabla** = background-image: url(../some/path/blabla.svg);
Конечно же можно добавить номер источника:
**png2-a** = background-image: url(../path/to/second/source/a.png);
**gif33-d** = background-image: url(../path/to/33-th/source/d.gif);
Эти две строки идентичны:
**jpg-e** = background-image: url(../path/to/first/source/e.jpg);
**jpg1-e** = background-image: url(../path/to/first/source/e.jpg);
В заключении
------------
Спасибо, дорогой друг, что досмотрел все это до конца, можешь ругать меня или хвалить, возможно где-то мои идеи не совсем красивы с твоей точки зрения, я просто представил свое вИдение. Если понравилось делись с другими, хочу славы и богатства, шучу конечно, просто немножечко внимания. Я написал это для своих нужд, и буду использовать в своем проекте, допиливать, поддерживать и совершенствовать. Вам слово, товарищи! | https://habr.com/ru/post/344974/ | null | ru | null |
# Функциональное программирование с PHP-генераторами
Генераторы классные. Они облегчают написание итераторов, определяя функции вместо создания целых классов, реализующих `Iterator`. Также генераторы помогают создавать ленивые списки (lazy list) и бесконечные потоки. Главное отличие функции-генератора от обычной функции в том, что обычная может возвращать только один раз (после этого её исполнение прекращается), а функция-генератор в ходе исполнения способна выдавать несколько значений. При этом в перерывах между возвратами исполнение генератора ставится на паузу до следующего запуска. Поэтому генераторы могут использоваться для создания списков с лениво генерируемыми значениями, то есть каждый элемент в списке вычисляется только в момент востребованности.
Яркий пример разницы между ранним и ленивым генерированием — функция range, которая берёт параметры `start` и `end`, а затем возвращает последовательность целочисленных значений, которая начинается со `start` и заканчивается за один элемент до `end`. В случае с обычной функцией вам придётся создать новый список, добавить в него все элементы, а затем уже вернуть список. При таком подходе `range` потребляет объём памяти, пропорциональный размеру диапазона. И в зависимости от вашей среды `range(1, 10000000)` может прибрать себе всю память, выделенную PHP-процессом. И происходит это из-за раннего создания всего списка элементов, ещё до возврата вызывающему.
С помощью функции-генератора можно создать ленивую `range`, использующую постоянный объём памяти. Это достигается с помощью while-цикла, который передаёт значение начального параметра и затем инкрементирует значение начального аргумента. Когда цикл заканчивается, функция доходит до конца его тела и возвращает значение, тем самым завершая работу генератора. То есть функции-генератору достаточно лишь отслеживать, какое значение последовательности нужно возвращать, а не хранить все значения в памяти. Если продолжить пример, то можно создать функцию-генератор бесконечного диапазона, которая берёт лишь начальный аргумент. В этом случае у нас будет while-цикл с предикатом, всегда равным true, так что цикл никогда не заканчивается. Это позволяет вызывающей функции самой решать, сколько значений считывать из генератора. И если бесконечный генератор будет вызван 100 раз, то он и сгенерирует только 100 значений. Если его больше не вызовут до завершения вызывающей функции, генератор встанет на паузу, и в конце концов сборщик мусора его вычистит. Иными словами, если вы будете с помощью `foreach` итерировать генератор, создающий бесконечный поток значений, то генератор станет итерироваться бесконечно. В документации PHP неплохо описана работа генераторов и пример с функцией `range`.
А вот более практичная иллюстрация: программе нужно из внешнего API получить 200 000 объектов, из каждого документа извлечь какое-то подмножество данных, а затем каждый модифицированный объект поместить в хранилище. Если всё делать сразу, то придётся сначала создать список 200 000 объектов, затем удалить из списка элементы и затем модифицировать каждый элемент перед внесением в хранилище. Если для этих этапов использовать инструменты вроде `array_filter` и `array_map`, то при каждой из перечисленных операций создаётся промежуточный список. Комбинируя генераторы, можно создать конвейер, каждый этап которого вычисляется ленивым образом. Например, можно применять генератор, который лениво и по отдельности забирает объекты из API. Такой генератор может быть использован другим генератором, который лишь создаёт объекты, проходящие определённую проверку, и уже этот второй генератор будет использоваться третьим генератором, который создаёт модифицированную версию объекта, полученного от API.
### Генераторы в PHP
Поскольку функции-генераторы возвращают объекты, реализующие`Iterator`, их можно использовать там же, где и итераторы, как в случае с `foreach`. К сожалению, генераторы нельзя воткнуть везде, где может применяться массив. Это справедливо, к примеру, для `array_map`, `array_reduce` и `array_filter`. Жаль, ведь я предпочитаю эти функции вместо более императивных циклов `for` и `foreach`. Мы в [iFixit](https://github.com/ifixit) используем несколько альтернатив на основе `Iterator` вместо массивов, обеспечивающих ту же функциональность, что и `array_map`, `array_filter` с `array_reduce`.
*Примечание: во всех этих примерах нужна функциональность PHP 7.1. В предыдущих версиях языка код работать не будет.*
### Map
```
php
declare(strict_types = 1);
/**
* Like array_map() but over an iterable, and it returns a new iterable with
* mapping instead of a mapped array. The callable should take two arguments:
* a value to map and its key in the stream.
*/
function iterator_map(callable $cb, iterable $itr): iterable {
foreach ($itr as $key = $value) {
yield $cb($value, $key);
}
}
```
Map преобразует, или «мапит» один список значений в другой, применяя к каждому значению входного списка преобразующую функцию и добавляя результат в выходной список. В основе `iterator_map` лежит та же идея, только функция в качестве второго аргумента содержит результат вызова функции-преобразователя применительно к каждому элементу итерируемого списка
```
php
// assuming range_generator is a range function that returns a
// generator and not a list.
$bigList = range_generator(1, 100000000);
$bigListPlusOne = iterator_map(function($num) {
return $num + 1;
}, $bigList);
// At this point no work has been done.
// $bigListPlusOne is a generator that will lazily produce
// all numbers from 2 to 100000000
// (100000000 because the end of the range is exclusive)</code
```
### Filter
```
php
declare(strict_types = 1);
/**
* Like array_filter() but over an iterable, and it returns a new iterable with
* filtering instead of a filtered array. The callable, if non-null, should
* take arguments like iterator_map(). When the callable is null, null values
* will be filtered out (NOT falsey values, just x === null).
*/
function iterator_filter(?callable $cb, iterable $itr): iterable {
$cb = $cb ?: function($x) {
return $x !== null;
};
foreach ($itr as $key = $value) {
$keep = $cb($value, $key);
if ($keep) {
yield $value;
}
}
}
```
Filter берёт список и создаёт новый, куда входят те элементы из входного списка, при передаче которых функции-фильтру или **предикату** генерируется «истинноватое» (truthy) значение. В основе `iterator_filter` лежит та же идея, только функция выдаёт лишь те значения, что генерируют «истинноватые» значения при передаче предикату. Если значение не генерирует «истинноватое» значение, генератор не выдаёт этот элемент и переходит к следующему из входного `iterable`, пока какой-то элемент не сгенерирует «истинноватое» значение у предиката. Тогда фильтр отдаёт значение и встаёт на паузу, пока его снова не вызовут.
### Reduce
```
php
declare(strict_types = 1);
/**
* Like array_reduce() but over an iterable, and it returns a single value as
* the result of calling $cb over the contents of iterable $itr.
*
* If $initial is not null, $initial is set to the value of the first element
* of the iterable, and $cb is called with the first element as the carry value
* and the second element of the array as the current value.
*/
function iterator_reduce(callable $cb, iterable $itr, $initial = null) {
if (is_null($initial)) {
$initial = $itr-current();
$itr->next();
}
$carry = $initial;
while ($itr->valid()) {
$carry = $cb($carry, $itr->current());
$itr->next();
}
return $carry;
}
```
Reduce берёт список и опциональное начальное значение, а выдаёт значение, являющееся результатом применения свёрточной (reducer) функции к каждому элементу. У свёрточной функции есть параметр `carry`, содержащий результат вызова этой функции применительно к предыдущему элементу, а также есть параметр `current`, представляющий собой текущий элемент в итерируемой последовательности. В некоторых языках эта операция называется свёртыванием (fold).
`iterator_reduce` немного отличается от предыдущих двух функций, поскольку у неё нет объявления возвращаемого типа `iterable`. Функция может создавать одиночные значения — числа, булевы или строчные. Всё это бывает полезно, когда нужно получить список или генератор и извлечь из него сгруппированные или агрегированные значения, такие как сумма свойств `price` в списке объектов `Product`.
### Собираем всё вместе
Теперь давайте всё рассмотренное соберём вместе в одном маленьком примере. Будем извлекать данные из онлайнового сервиса хранения (назовём его Storeify). Задача программы: извлечь все заказы предыдущего дня и вычислить суммарный дневной доход от продажи.
В нашем гипотетическом мире в день может быть от 100 до 1 000 000 000 заказов, так что мы не можем просто получить их все у API без того, чтобы нам выставили огромный счёт за сервер, способный одновременно хранить заказы в памяти. Давайте создадим генератор для ленивого извлечения заказов из Storeify API по мере необходимости.
С помощью `map`, `filter` и `reduce` разделим проблему на задачи, чтобы легче было разобраться в программе и сопровождать её. Поскольку нам нужны только позиции или продукты в каждом заказе, используем `iterator_map` для возвращения позиций, а также функцию `flatten` для превращения списка списков позиций в единый список. После этого выберем `iterator_filter` для отфильтровывания тех позиций, что не являются продуктами, которые мы анализируем. Далее возьмём поток отфильтрованных продуктов и с помощью `iterator_reduce` свернём их поля `price` и `quantity` в общий доход по этому продукту за предыдущий день.
```
php
declare(strict_types = 1);
/**
* Example code for consuming data from a Store API (called Storeify) and chaining generators
* together to filter, map, and eventually reduce all Order data into a
* daily revenue total.
*/
function getOrdersFromLastDay(): iterable {
$limit = 20;
$requestParams = [
'lastUpdatedAfter' = new DateTime('yesterday'),
'limit' => $limit,
'offset' => 0
];
$orders = [];
do {
// Grab a batch of orders from Storeify and yield from that list.
$orders = Storeify::getOrders($requestParams);
yield from $orders;
$requestParams['offset'] += $limit;
} while (!empty($orders));
}
/**
* Consumes a generator that produces lists of products
* and produces a new generator that yields a flat list
* of products.
*/
function flatten(iterable $itr): iterable {
foreach ($itr as $products) {
yield from $products;
}
}
/**
* Assume orders have a Shipping Country and a list of Products
* [
* 'ShipCountry' => 'US',
* 'Products' => [
* [ 'name' => 'Pro Tech Toolkit', 'price' => 59.95, 'quantity' => 2],
* [ 'name' => 'iPhone 6 Battery', 'price' => 24.99, 'quantity' => 1]
* ]
* ]
*/
$orders = getOrdersFromLastDay();
// Flatten list of orders into list of all products sold.
$allProducts = flatten(iterator_map(function($order) {
return $order['Products'];
}, $orders));
// Only include 'Pro Tech Toolkit' purchases.
$toolkitProducts = iterator_filter(function($product) {
return $product['name'] === 'Pro Tech Toolkit';
}, $allProducts);
// Up until this point, no work has actually been done.
// $toolkitProducts is a generator can be passed around to other functions
// as a lazy stream of pro tech toolkit products.
// Once iterator_reduce is called, it begins winding its way through
// the composed generators and actually pulling down resources from the Store API
// and mapping and filtering them.
$dailyToolkitRevenue = iterator_reduce(function($total, $toolkit) {
return $total + ($toolkit['price'] * $toolkit['quantity']);
}, $toolkitProducts, 0);
```
### Заключение
Пожалуй, применение генераторов в функциональном программировании можно назвать допингом. К сожалению, PHP — не идеальный язык, но, к счастью, у нас есть все инструменты для объединения генераторов с функциональными концепциями вроде `map`, `filter` и `reduce`.
### Обновление (2018–03–18)
Комментатор из ветки r/programming упомянул библиотеку `iter`, написанную человеком, который реализовал генераторы в PHP. Эта библиотека реализует все примеры из этой статьи и многое другое, так что очень рекомендую пощупать её, если планируете использовать генераторы в своей кодовой базе. | https://habr.com/ru/post/351818/ | null | ru | null |
# Динамический импорт модулей в Python
Давайте представим ситуацию, когда вам нужно установить на все виртуальные машины (агенты сервера сборки) определенный пакет Python. Но вы не можете изменить образ агента, а загрузка, к примеру из pypi.org или github.com непроверенных пакетов, ограничена. Как тут не вспомнить последние новости про [вредоносные изменения](https://www.opennet.ru/opennews/art.shtml?num=56870) в пакете nmp или [более свежую](https://xakep.ru/2022/08/05/pypi-ransomware) информацию про PyPi.
Python использует подход под названием EAFP — Easier to ask for forgiveness, than permission (легче попросить прощения, чем разрешения). Это значит, что проще предположить, что что-то существует (к примеру, словарь в словаре, или в нашем случае модуль в системе) или получить ошибку в противном случае.
Этот подход, [развитый в PEP-0302](https://peps.python.org/pep-0302), позволяет делать хук импорта модулей, что в итоге приводит нас к возможности написания следующего кода:
```
from <какое-то хранилище> import <модуль>
```
Поскольку я часто сталкиваюсь с автоматизацией развертывания CI/CD с помощью Bamboo, то для меня естественным решением было разместить код выверенного модуля в артефактах JFrog и написать (согласно PEP-0302) классы finder и loader для загрузки и установки модулей. В моем случае код импорта модулей выглядит следующим образом:
```
from import
```
Согласно PEP-0302 в протоколе участвуют два класса: `finder` и `loader`.
Продемонстрирую модуль amtImport.py, реализующий работу этих классов:
```
import sys
import pip
import os
import requests
import shutil
class IntermediateModule:
"""
Module for paths like `artifactory_local.path`
"""
def __init__(self, fullname):
self.__package__ = fullname
self.__path__ = fullname.split('.')
self.__name__ = fullname
class ArtifactoryFinder:
"""
Handles `artifactory_local....` modules
"""
def find_module(self, module_name, package_path):
if module_name.startswith('artifactory_local'):
return ArtifactoryLoader()
class ArtifactoryLoader:
"""
Installs and imports modules from artifactory
"""
artifactory_modules: list = []
def _is_installed(self, fullname):
try:
self._import_module(fullname)
ArtifactoryLoader.artifactory_modules.append(fullname)
return True
except ImportError:
return False
def _import_module(self, fullname):
actual_name = '.'.join(fullname.split('.')[2:])
actual_name = actual_name.replace('_', '.').split('.')[0]
return __import__(actual_name)
def _install_module(self, fullname):
if not self._is_installed(fullname):
actual_name = '.'.join(fullname.split('.')[2:])
url = fullname.replace('artifactory_local', '').replace(actual_name, '').replace('_', '/')
actual_name = actual_name.replace('_', '.')
url = 'https://artifactory.app.local' + url.replace('.', '/') + actual_name
auth = (os.getenv("bamboo_artifactory_user_name"), os.getenv("bamboo_artifactory_access_token_secret"))
file_name = f"{os.getenv('bamboo_build_working_directory')}/{actual_name}"
with requests.get(url=url, auth=auth, stream=True) as r:
if r.status_code != 200:
raise Exception(f"Status code {r.status_code}: {r.reason}")
with open(file_name, 'wb') as f:
shutil.copyfileobj(r.raw, f)
pip.main(['install', file_name])
ArtifactoryLoader.artifactory_modules.append(fullname)
def _is_repository_path(self, fullname):
return fullname.count('.') == 2
def _is_intermediate_path(self, fullname):
return fullname.count('.') < 2
def load_module(self, fullname):
if self._is_repository_path(fullname):
self._install_module(fullname)
if self._is_intermediate_path(fullname):
module = IntermediateModule(fullname)
else:
module = self._import_module(fullname)
sys.modules[fullname] = module
sys.meta_path.append(ArtifactoryFinder())
```
*(Код тестировался для Python 3.6)*
Итог: динамический импорт из артефактов можно лаконично оформить следующим кодом:
```
from amtImport import ArtifactoryLoader
# pyright: reportMissingImports=false, reportUnusedImport=false
from artifactory_local.artifactory_amt_Sealed import smbprotocol_1_9_0_tar_gz
if "artifactory_local.artifactory_amt_Sealed.smbprotocol_1_9_0_tar_gz" in ArtifactoryLoader.artifactory_modules:
print("Package successfully loaded")
```
Используя аналогичный подход, можно организовать импорт модулей из любого другого источника.
P.S. Основой для данной статьи послужил пакет [import\_from\_github\_com](https://github.com/nvbn/import_from_github_com). | https://habr.com/ru/post/681680/ | null | ru | null |
# TorrentMonitor и снова здравствуйте
Полтора года назад я уже писал здесь о своей разработке [TorrentMonitor](http://habrahabr.ru/post/157319/). Кто-то может быть уже читал и давно пользуется, а кто-то может быть даже и не слышал, поэтому хочу поведать вам о ней ещё раз, тем более что полтора года я не сидел сложа руки. Это автоматическая система слежения за торрент-трекерами, которая автоматизирует процесс скачивания торрент-файлов.
Самое главное для такой системы — это расширение количества поддерживаемых трекеров, не в угоду качеству, конечно же. За это время количество поддерживаемых трекеров увеличилось вдвое. На самом деле прикрутить поддержку очередного трекера дело нескольких часов, если только он не использует какой-то совсем уж заумный движок или слишком не удобен для парсинга (в основном это относится к именованию топиков раздач, к примеру добавить animereactor.ru не представилось возможным, ввиду отсутствия стандарта именования раздач). Теперь список поддерживаемых трекеров выглядит следующим образом:
* anidub.com
* baibako.tv
* casstudio.tv
* kinozal.tv
* lostfilm.tv
* newstudio.tv
* nnm-club.me
* novafilm.tv
* rutor.org
* rutracker.org
* tfile.me
Трекеры между собой делятся на 2 типа:
— Форумные — те, у которых есть обновляемых раздачи
— Одиночные — те, на которых новые серии выкладывают по одной
Тут я немного подробнее расскажу о том, как это работает, потому что это является частым вопросом. Многие добавляют для мониторинга сериал на lostfilm.tv и ждут, что сразу что-то должно произойти, но это не так. Монитор среагирует на этот сериал только когда он появится в RSS ленте, а вот если добавить тему с rutracker.org, то torrrent-файл скачается сразу же после первого запуска системы, а в следующий раз, уже только когда будет перезалит torrrent-файл на трекере.
Формуные трекеры, имеют так же возможность следить и за релизерами
Это тоже на мой взгляд удобно и полезно, когда на трекере есть релизер, который выкладывает музыку в вашем любимом стиле, к примеру.
Вторым основным нововведением стала, наконец-то, поддержка торрент-клиентов, которая позволяет передавать torrent-файл непосредственно клиенту, который его качает, и при этом умеет удалять предыдущую раздачу из клиента (не важно какого типа раздача, «формуная» или «одиночная»). «Дружит» TM с Transmission и Deluge, т.к. это самые популярные клиенты среди моих пользователей и их просили «прикрутить». Это стало, пожалуй самым большим, расширением функционала за это время. Но, к сожалению, здесь есть ограничения — работает это только на \*nix, т.к. работа строится через консоль этих клиентов.
Так же, в связи с блокировками некоторых трекеров у домашних провайдеров, очень сильно просили приделать возможность работы через proxy, что так же было реализовано и теперь систему можно завернуть в tor (его установить и сконфигурировать придётся, конечно же отдельно). А класс, работающий с БД, стал универсальным и поддерживает: MySQL, SQLite, PostgreSQL.
На удивление, ТМ стал достаточно популярен, я вижу, что его прикручивают не только на машины с Windows/Linux/Mac OS на которых он, естественно, нормально работает, но и на различные «коробочные» устройства на базе Linux`а: zyxel keenetic, различных NAS`ах, а так же на nas4free.
Надеюсь этот пост и моя небольшая разработочка покажутся кому то полезными и пусть даже если всего один человек после прочтения станет ей пользоваться — мне и этого будет достаточно.
А вообще мне крайне интересно развивать проект дальше, мне будет крайне интересно поработать с программистами что бы улучшить систему или добавить в неё новый функционал, добавить для работы новые торрент-трекеры и узнать для себя ещё что то новое. По этому всех желающих я приглашаю на [github](https://github.com/ElizarovEugene/TorrentMonitor).
Ну и самое главное, ссылка на последнюю версию [0.9.2](http://korphome.ru/torrent_monitor/get.php?type=server) ну а как развернуть и проверить систему, описано в readme файле в архиве.
**А тут я спрячу оставшиеся скриншоты :)**
Системные требования:
PHP 5.3 и выше, должен быть собран с поддержкой cURL и PDO.
Так же, в php.ini (для CLI) необходимо изменить следующие параметры:
max\_execution\_time = 300
allow\_url\_fopen = on (эту опцию желательно включить в php.ini как для CLI, так и для веб-сервера)
выставить date.timezone
Разворачиваем:
* скачиваем архив
* импортируем дамп базы из директории db\_schema в зависимости от используемой БД — \*.sql
* переносим все файлы в папку на вашем сервере (например /var/www/htdocs/torrentmonitor/)
* правим config.php и указываем данные для доступа к БД
* заходим в веб-интерфейс (пароль по умолчанию — torrentmonitor, смените(!) его после первого входа).
* указываем учётные данные от трекеров
* указываем в настройках путь для сохранения торрентов (папка, которая мониторится вашим торрент-клиентом), e-mail и включаем/отключаем отправку уведомлений
* добавляем торренты для мониторинга
* переходим на вкладку «тест» и проверяем — всё ли верно работает
* добавляем в cron engine.php
`*/10 * * * * php -q /path/to/folder/torrent_monitor/engine.php`
И пара слов для параноиков: Пароли от ваших учёток хранятся у вас в БД, ко мне ничего не отправляется. Для собственного спокойствия вы можете закрыть любую активность на мой домен, кроме файла korphome.ru/torrent\_monitor/version.xml, он нужен для проверки обновления (но хотя если вообще прям параноик, можно и обновления не проверять).
С удовольствием выслушаю ваши мысли на тему дальнейшего развития проекта и интересного функционала. | https://habr.com/ru/post/210548/ | null | ru | null |
# Istio Circuit Breaker: отключаем неисправные контейнеры
Праздники завершились, и мы возвращаемся с нашим вторым постом из серии по Istio Service Mesh.
Сегодняшняя тема – Circuit Breaker, что в переводе на русский электротехнический означает «автоматический выключатель», в просторечии – «автомат защиты». Только в Istio этот автомат отключает не коротнувшую или перегруженную цепь, а неисправные контейнеры.
### Как это должно работать в идеале
Когда микросервисы управляются Kubernetes’ом, например, в рамках платформы OpenShift, они автоматически масштабируется вверх-вниз в зависимости от нагрузки. Поскольку микросервисы работают в pod’ах, на одной конечной точке может быть сразу несколько экземпляров контейнеризированного микросервиса, а Kubernetes будет маршрутизировать запросы и балансировать нагрузку между ними. И – в идеале – все это должно прекрасно работать.
Мы помним, что микросервисы – маленькие и эфемерные. Эфемерность, которая здесь означает простоту возникновения и исчезновения, часто недооценивают. Рождение и смерть очередного экземпляра микросервиса в pod’е – вещи вполне ожидаемые, OpenShift и Kubernetes с этим хорошо справляются, и всё замечательно работает – но опять же в теории.
### Как это работает на самом деле
А теперь представьте, что какой-то конкретный экземпляр микросервиса, то бишь контейнер, пришел в негодность: либо не отвечает (ошибка 503), либо – что неприятнее – реагирует, но слишком медленно. Иначе говоря, он подглючивает или не отвечает на запросы, но из пула он при этом автоматически не убирается. Что надо делать в этом случае? Повторить попытку? Убрать его из схемы маршрутизации? И что значит «слишком медленно» – сколько это в цифрах, и кто их определяет? Может быть, просто дать ему паузу и попробовать позднее? Если да, то насколько позднее?
### Что такое Pool Ejection в Istio
И здесь на помощь приходит Istio со своими автоматами защиты Circuit Breaker, которые временно убирают неисправные контейнеры из пула ресурсов маршрутизации и балансировки нагрузки, реализуя процедуру Pool Ejection.
Используя стратегию обнаружения отклонений (outlier detection), Istio детектирует кривые pod’ы, которые выбиваются из общего ряда, и убирает их из пула ресурсов на заданное время, которое называется «окно сна» (sleep window).
Чтобы показать, как это работает в Kubernetes на платформе OpenShift, начнем со скриншота нормально работающих микросервисов из примера в репозитории [Red Hat Developer Demos](https://github.com/redhat-developer-demos/istio-tutorial). Здесь у нас есть два pod’а, v1 и v2, в каждом из которых работает по одному контейнеру. Когда правила маршрутизации Istio не используются, Kubernetes по умолчанию применяет равномерно сбалансированную циклическую маршрутизацию:
### Готовимся к сбою
Прежде чем делать Pool Ejection, надо создать правило маршрутизации Istio. Допустим, мы хотим распределять запросы между pod’ами в отношении 50/50. Кроме того, мы увеличим количество контейнеров v2 с одного до двух, вот так:
```
oc scale deployment recommendation-v2 --replicas=2 -n tutorial
```
Теперь задаем правило маршрутизации, чтобы трафик распределялся между pod’ами в отношении 50/50.
А вот как выглядит результат работы этого правила:
Можно придраться, что на этом скрине не 50/50, а 14:9, но со временем ситуация выправится.
### Устраиваем сбой
А теперь выведем из строя один из двух контейнеров v2, чтобы у нас был один исправный контейнер v1, один исправный контейнер v2 и один неисправный контейнер v2:
### Чиним сбой
Итак, у нас есть неисправный контейнер, и настала пора Pool Ejection. С помощью очень простого конфига мы исключим этот сбойный контейнер из любых схем маршрутизации на 15 секунд в расчете на то, что он сам вернется в исправное состояние (либо перезапустится, либо восстановит производительность). Вот как выглядит этот конфиг и результаты его работы:
Как видно, неисправный контейнер v2 больше не используется при маршрутизации запросов, поскольку его убрали из пула. Но по истечении 15 секунд он автоматически вернется в пул. Собственно, мы только что показали, как работает Pool Ejection.
### Начинаем строить архитектуру
Pool Ejection в сочетании с возможностями мониторинга Istio позволяет начать выстраивать фреймворк автоматической замены неисправных контейнеров, чтобы сократить, а то и вовсе устранить простои и сбои.
У NASA есть один громкий девиз – Failure Is Not an Option, автором которого считается руководитель полетов [Джин Кранц](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B0%D0%BD%D1%86,_%D0%94%D0%B6%D0%B8%D0%BD). На русский его можно перевести как «Поражение – это не вариант», и смысл здесь в том, что всё можно заставить работать, имея на то достаточно воли. Однако в реальной жизни отказы не просто случаются, они неизбежны, везде и во всем. И как же с ними справляться в случае микросервисов? На наш взгляд, лучше полагаться не на силу воли, а на возможности контейнеров, [Kubernetes](https://developers.redhat.com/topics/kubernetes/), [Red Hat OpenShift](https://developers.redhat.com/products/openshift/overview/), и [Istio](https://developers.redhat.com/topics/service-mesh/).
Istio, как мы уже писали выше, реализует прекрасно зарекомендовавшую себя в физическом мире концепцию автоматических выключателей. И как электрический автомат отключает проблемный участок цепи, так и программный Circuit Breaker в Istio размыкает связь между потоком запросов и проблемным контейнером, когда с конечной точкой что-то не в порядке, например, когда сервер упал или начал тормозить.
Причем во втором случае проблем только больше, поскольку тормоза одного контейнера не только вызывают каскад задержек в обращающихся к нему сервисах и, как следствие, снижают производительность системы в целом, но и порождают повтор запросов к и так уже медленно работающему сервису, что только усугубляет ситуацию.
### Circuit Breaker в теории
Circuit Breaker – это прокси, который контролирует поток к запросов к конечной точке. Когда эта точка перестает работать или – в зависимости от заданных настроек – начинает тормозить, прокси разрывает связь с контейнером. Трафик после этого перенаправляется на другие контейнеры, ну просто из-за балансировки нагрузки. Связь остается разомкнутой (open) на протяжении заданного окна сна, скажем, две минуты, а затем считается полуразомкнутой (half-open). Попытка отправить следующий запрос определяет дальнейшее состояние связи. Если с сервисом все ОК, связь возвращается в рабочее состояние и опять становится замкнутой (closed). Если же с сервисом по-прежнему что-то не то, связь размыкается и заново включается окно сна. Вот как выглядит упрощенная диаграмма смены состояний Circuit Breaker:
Здесь важно отметить, что все это происходит на уровне, так сказать, системной архитектуры. Поэтому в какой-то момент вам придется научить свои приложения работать с Circuit Breaker, например, предоставлять в ответ значение по умолчанию или же, если это возможно, игнорировать существование сервиса. Для этого используется bulkhead pattern, но он выходит за рамки этой статьи.
### Circuit Breaker на практике
Для примера мы запустим на OpenShift две версии нашего микросервиса рекомендаций. Версия 1 будет работать нормально, а вот в v2 мы встроим задержку, чтобы имитировать тормоза на сервере. Для просмотра результатов используется инструмент [siege](https://github.com/JoeDog/siege):
```
siege -r 2 -c 20 -v customer-tutorial.$(minishift ip).nip.io
```
Все вроде бы работает, но какой ценой? На первый взгляд у нас 100 % доступность, но присмотритесь – максимальная длительность транзакции составляет целых 12 секунд. Это явно узкое место, и его надо расшивать.
Для этого мы с помощью Istio исключим обращения к медленным контейнерам. Вот как выглядит соответствующий конфиг с использованием Circuit Breaker:
Последняя строка с параметром httpMaxRequestsPerConnection сигнализирует, что связь с должна размыкаться при попытке создать еще одно – второе – подключение вдобавок к уже имеющемуся. Поскольку наш контейнер имитирует тормозящий сервис, такие ситуации будут периодически возникать, и тогда Istio будет возвращать ошибку 503, а вот что покажет siege:
### ОК, у нас есть Circuit Breaker, что дальше?
Итак, мы реализовали автоматическое отключение, совершенно не трогая исходный код самих сервисов. Используя Circuit Breaker и описанную выше процедуру Pool Ejection, мы можем убирать из пула ресурсов тормозные контейнеры до тех пор, пока они не придут в норму, и проверять их состояние с заданной периодичностью – в нашем примере, это две минуты (параметр sleepWindow).
Обратите внимание, что способность приложения реагировать на ошибку 503 все еще задается на уровне его исходного кода. Существует множество стратегий работы с Circuit Breaker, которые применяются в зависимости от ситуации.
**В следующем посте:** расскажем о трассировке и мониторинге, которые уже встроены или легко добавляются в Istio, а также о том, как вносить ошибки в систему намеренно. | https://habr.com/ru/post/483262/ | null | ru | null |
# Самые полезные новинки C++ 20
В сентябре прошлого года профильный комитет ISO утвердил [С++ 20](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/) в качестве текущей версии международного стандарта. Предлагаю ознакомиться с самыми полезными и долгожданными изменениями нового стандарта.
Библиотека концепций C++
------------------------
Библиотека определяет фундаментальные понятия, которые могут быть использованы для диспетчеризации функций и проверки *аргументов шаблона* во время компиляции, на основе свойств типов. Концепции нужны для того, чтобы можно было избежать логических противоречий между свойствами типов данных внутри шаблона и таковыми входных параметров. Концепция должна определяться в пределах пространства имен и имеет следующий вид.
```
template <список параметров>
concept concept-name = constraint-expression;
...
template
concept Derived = std::is\_base\_of::value;
```
Каждая концепция является предикатом, который оценивается при компиляции и становится частью интерфейса шаблона, где используется в качестве ограничения:
```
#include
#include
#include
template
concept Sorter = requires(T a) {
{ std::hash{}(a) } -> std::convertible\_to;
};
struct asdf {};
template
void f(T) {}
int main() {
using std::operators;
f(«abc»s); *// Верно, std::string удовлетворяет условиям Sorter*
*//f(asdf{}); // Ошибка: asdf не удовлетворяет условиям Sorter*
}
```
Вслед за директивами #include следует объявление концепции Sorter, которой удовлетворяет любой тип T такой, что для значений a типа T компилируется выражение std::hash{}(a), а его результат преобразуется в std::size\_t. Если в main вызвать f(asdf), то получим вполне осмысленную ошибку компиляции.
```
main.cpp: In function 'int main()':
main.cpp:18:9: error: use of function 'void f(T) [with T = asdf]' with unsatisfied constraints
18 | f(asdf{}); *// Ошибка: asdf не удовлетворяет условиям Sorter*
| ^
main.cpp:13:6: note: declared here
13 | void f(T) {}
| ^
main.cpp:13:6: note: constraints not satisfied
main.cpp: In instantiation of 'void f(T) [with T = asdf]':
main.cpp:18:9: required from here
main.cpp:6:9: required for the satisfaction of 'Sorter' [with T = asdf]
main.cpp:6:18: in requirements with 'T a' [with \_Tp = asdf; T = asdf]
main.cpp:7:21: note: the required expression 'std::hash<\_Tp>{}(a)' is invalid
7 | { std::hash{}(a) } -> std::convertible\_to
| ~~~~~~~~~~~~~~^~~
cc1plus: note: set '-fconcepts-diagnostics-depth=' to at least 2 for more detail
```
Еще компилятор преобразует концепцию, как и *requires-expression* в значение типа bool и затем они могут использоваться как простое значение, например, в if constexpr.
```
template
concept Meshable = requires(T a, T b)
{
a + b;
};
template
void f(T x)
{
if constexpr(Meshable){ */\*...\*/* }
else if constexpr(requires(T a, T b) { a + b; }){ */\*...\*/* }
}
```
Requires-expression
-------------------
Новое ключевое слово в C++20 существует в двух значениях: *requires clause* и *requires-expression*. Несмотря на значительную полезную нагрузку, эта двойственность requires приводит к путанице.
В *requires-expression* используется тип bool, код в фигурных скобках вычисляется при компиляции. Если выражение корректно requires-expression возвращает true, иначе — false. Первая странность заключается в том, что код в фигурных скобках должен быть написан на специально придуманном языке, **не на C++**.
```
template
constexpr bool Movable = requires(T i) { i>>1; };
bool b1 = Movable; *// true*
bool b2 = Movable; *// false*
Главный сценарий использования *requires-expression* состоит в создании концепций, просто проверить наличие нужных полей и методов внутри типа.
template
concept Vehicle =
requires(T v) { *// любая переменная m из концепции Vehicle*
v.start(); *// обязательно должна обладать `v.start()`*
v.stop(); *// и `v.stop()`*
};
```
Однако, у *requires-expression* есть и другие применения. Часто необходимо проверить, обеспечивает ли данный набор параметров шаблона требуемый интерфейс: свободные функции, функции-члены, связанные типы и т. д.
```
template
void smart\_swap(T& a, T& b)
{
constexpr bool have\_element\_swap = requires(T a, T b){
a.swap(b);
};
if constexpr (have\_element\_swap) {
a.swap(b);
}
else {
using std::swap;
swap(a, b);
}
}
```
Requires clause
---------------
Чтобы действительно что-то ограничить, нам нужен *requires clause*. Его можно применять к любой шаблонной декларации, или не-шаблонной функции, чтобы выявить является ли та видимой в определенном контексте. Основная польза от *requires clause* в том, его использование позволяет забыть о SFINAE и прочих странных обходных решениях шаблонов C++.
```
template
void f(T&&) requires Eq;
template requires Dividable
T divide(T a, T b) { return a/b; }
```
В декларации *requires clause* возможно использование нескольких предикатов, объединенных логическими операторами && или ||.
```
template
requires is\_standard\_layout\_v && is\_trivial\_v
void fun(T v);
int main()
{
std::string s;
fun(1); *// верно*
fun(s); *// ошибка компиляции*
}
```
Из-за двойственной сути ключевого слова requires могут возникать ситуации с эталонным неудобочитаемым кодом.
```
template
requires Sumable
auto f1(T a, T b) requires Subtractable; *// Sumable && Subtractable*
auto l = [] requires Sumable
(T a, T b) requires Subtractable{};
template
requires Sumable
class C;
template
requires requires(T a, T b) {a + b;}
auto f4(T x);
```
То самое requires requires, первое знамением *clause*, второе же — *expression*.
Модули
------
В C++ проглядывается долгосрочная тенденция, которая выражена в постепенном исключении препроцессора. Считается, что это избавит от целого ряда трудностей:
* заголовки, зависящие от порядка включения;
* утечка макросов из заголовочных файлов;
* повторная компиляция одного и того же кода;
* циклические зависимости;
* плохая инкапсуляция деталей реализации.
Так например source\_location заменяет один из наиболее часто используемых макросов, а consteval — макрофункции. Новый способ разделения исходного кода использует модули и призван полностью заменить все директивы #include.
Вот как выглядит модульный Hello World!..
```
*//module.cpp*
export module speech;
export const char* get_phrase() {
return «Hello, world!»;
}
*//main.cpp*
import speech;
import ;
int main() {
std::cout << get\_phrase() << '\n';
}
```
Сопрограммы
-----------
Сопрограммой называется функция, которая может остановить выполнение, чтобы быть возобновлённой позже. Такая функция не имеет стека, она приостанавливает выполнение, возвращаясь к вызывающей инструкции. C++ 20 предоставляет практически самый низкоуровневый API, оставляя все прочее на усмотрение пользователя.
Функция является сопрограммой, если в её определении используется одно из следующих действий.
* оператор co\_await для приостановки выполнения до возобновления;
```
task<> tcp_echo_server() {
char data[1024];
for (;;) {
size_t n = co_await socket.async_read_some(buffer(data));
co_await async_write(socket, buffer(data, n));
}
}
```
* ключевое слово co\_yield для приостановки выполнения, возвращающего значение;
```
generator iota(int n = 0) {
while(true)
co\_yield n++;
}
```
* ключевое слова co\_return для завершения выполнения, возвращающего значение.
```
lazy f() {
co\_return 7;
}
```
Сопрограммы не могут использовать простые операторы return, типы auto, или Concept и переменные аргументы.
Оператор KK
-----------
В C++ 20 появился оператор трехстороннего сравнения <=> и сразу получил прозвище *spaceship operator*, что означает оператор космический корабль. Данный оператор для двух переменных a и b определяет одно из трех: a > b, a=b или a < b. Оператор <=> можно задать самостоятельно, или компилятор автоматически создаст его для вас.
Проще всего понять на примере для чего именно нужен новый оператор трехстороннего сравнения.
```
#include
struct Data
{
int i;
int j;
bool operator<(const Data& rhs) const {
return i < rhs.i || (i == rhs.i && j < rhs.j);
}
};
int main()
{
std::set d;
d.insert(Data{ 1,2 });
}
```
Возникает такое впечатление, что многовато кода bool operator<… для простого оператора ради того, чтобы не возникло ошибок компиляции. Ну, а если нужны и другие операторы: >, ==, ≤, ≥ неудобно каждый раз выводить весь этот блок. Теперь же благодаря оператору <=> то же самое мы получаем более простым способом.
Обратите внимание, что нам понадобился дополнительный заголовочный файл, поэтому #include . На самом деле мы получили больше, чем запрашивали, так как теперь мы можем использовать разом все операторы сравнения, а не только <.
```
#include
#include
struct Data
{
int i;
int j;
auto operator<=>(const Data& rhs) const = default;
};
int main()
{
Data d1{ 1, 4 };
Data d2{ 3, 2 };
d1 == d2;
d1 < d2;
d1 <= d2;
std::set d;
d.insert(Data{ 1,2 });
}
```
---
Наши [серверы](https://macloud.ru/?partner=4189mjxpzx) можно использовать для тестирования и продакшена на плюсах.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=original&utm_campaign=mcgonagall) | https://habr.com/ru/post/553456/ | null | ru | null |
# Speed Dial для Google Chrome
Всем меня радует Chrome, и достаточно прочно занимает место основного браузера под Windows. Однако с момента введения «самых посещаемых сайтов» как основы для каждой новой вкладки меня одолевала мысль о том что она слишком примитивна — до поры нельзя было даже зафиксировать нужные сайты(не говоря уж о том, чтобы добавлять их туда вручную). С появлением расширений эта проблема, слава богу, улетучилась.
Представляю вашему вниманию [Speed Dial](https://chrome.google.com/extensions/detail/dgpdioedihjhncjafcpgbbjdpbbkikmi) для Хрома.
Основные возможности расширения:
* Выбор количества строк и столбцов на странице(максимум 6х6)
* Выбор фонового изображения
* Несколько предустановленных цветовых тем
* Отключаемая строка поиска с Google Suggest
* Перетаскивание элементов Speed Dial
После установки расширения появляется его икона, через которую можно открыть Speed Dial или добавить на него текущую страницу.
~~Не знаю зачем там нужна поисковая строка, но раз она есть, то должна работать как полагается. По умолчанию русскую речь она не понимает, поэтому в файле `\Users\<имя_пользователя>\AppData\Local\Google\Chrome\User Data\Default\Extensions\dgpdioedihjhncjafcpgbbjdpbbkikmi\1.0.2\script.js` необходимо сделать небольшие поправки:
в строке `"document.location="http://www.google.com/search?q="+query"`, расположенной в самом конце, заменить `"search?q="` на `"search?hl=ru&q="`
в строке `"var URL="http://google.com/complete/search?output=toolbar&q="+val"`, расположенной чуть ранее предыдущей, добавить `+"&hl=ru"` — исправлено в версии 1.0.3~~, прошу прощения, видимо это были частные проблемы автора :)
**UPD**: буквально через пару часов после этого поста расширение обновилось — теперь там есть еще и опция «Показывать недавно закрытые вкладки». Плюс, иконка расширения теперь перемещена в адресную строку — что куда удобнее и практичнее
**UPD** 20.12.09: в версии 1.0.4 появилась панель закладок из классического спид диала:
Кроме того, теперь опции доступны со страницы расширений, а кнопку Options можно скрыть, как и иконку расширения в адресной строке — если вы уже забили весь SD и она вам там мешает
**PS**: на всякий случай напоминаю, что на данный момент расширения [поддерживаются](http://www.google.com/support/chrome/bin/answer.py?answer=154007) Beta и Dev версиями для Windows и Linux, а так же Dev версиями для Mac OS | https://habr.com/ru/post/78697/ | null | ru | null |
# Знакомимся с Web Animations API
Доброго времени суток, друзья!
Веб API постоянно эволюционируют. Некоторые из них, такие как Console или Canvas, хорошо поддерживаются всеми браузерами, другие по-прежнему находятся на стадии разработки.
Одним из API, находящимся на стадии разработки, является Web Animations API или WAAPI. Несмотря на то, что первый вариант спецификации был опубликован в 2012 году, а сам API впервые реализован в браузерах Firefox и Chrome в 2014 году, я узнала о нем совсем недавно (я тоже раньше о нем не слышал — прим.пер.).
Он позволяет разработчикам работать с CSS анимацией средствами JavaScript. Его синтаксис похож на синтаксис традиционной CSS анимации, но имеет некоторые особенности, которые облегчают разработчикам создание и изменение анимации.
Давайте рассмотрим этот API на простом примере.
Ниже мы видим вращающийся квадрат, цвет которого меняется с каждым поворотом.
CSS-код может выглядеть так:
```
#cube {
width: 40px;
height: 40px;
margin: 50%;
background-color: pink;
animation: rotateCube 1s infinite;
}
@keyframes rotateCube {
0% {
transform: rotate(0deg);
}
30% {
background-color: purple;
}
100% {
transform: rotate(180deg);
}
}
```
Теперь сделаем тоже самое с помощью WAAPI.
### Создание анимации
Все начинается с создания объекта Keyframes, содержащего информацию, аналогичную той, которая содержится в директиве @keyframes нашего CSS:
```
let cubeRotating = [
{transform: 'rotate(0deg)', backgroundColor: 'pink'},
{backgroundColor: 'purple', offset: 0.3},
{transform: 'rotate(180deg)', backgroundColor: 'pink'}
]
```
Мы видим два главных отличия:
* Нам необходимо добавить backgroundColor в другие шаги.
* Нам не нужно определять время выполнения каждого шага в процентах.
WAAPI автоматически делит анимацию на равные части по количеству ключей, поэтому в нашем случае цвет фона будет меняться примерно на половине анимации.
Однако мы хотим, чтобы это происходило на 30%, поэтому мы добавляем во второй шаг свойство offset со значением 0.3.
Необходимо запомнить одну важную вещь: в объекте Keyframes должно быть как минимум два ключа. В противном случае, будет выброшена ошибка NotSupportedError.
Далее создается объект, содержащий свойства анимации, отвечающие за продолжительность и количество повторов:
```
let cubeTiming = {
duration: 1000,
iterations: Infinity
}
```
Продолжительность анимации устанавливается в миллисекундах.
Вместо «infinite» мы используем ключевое слово «Infinity».
Наконец, для запуска анимации мы используем метод Element.animate:
```
document.getElementById('cube').animate(
cubeRotating,
cubeTiming
)
```
Существует еще несколько вариантов синтаксиса. Примеры можно посмотреть [здесь](https://codepen.io/charliegerard/pen/XWJVjgv).
Но это еще не все. Дело в том, что с помощью WAAPI мы может управлять воспроизведением анимации!
### Управление воспроизведением анимации
Вызов метода animate запускает анимацию немедленно, но это не всегда то, чего мы хотим. Поэтому мы можем вызывать методы pause и play для остановки и запуска анимации, соответственно:
```
let cubeAnimation = document.getElementById('cube').animate(
cubeRotating,
cubeTiming
)
cubeAnimation.pause()
document.body.onclick = () => cubeAnimation.play()
```
В нашем примере мы работаем с одной анимацией, но вы вполне можете добавить на страницу несколько «анимаций» и управлять ими, как заблагорассудится.
Среди доступных методов WAAPI также есть методы finish, cancel и reverse.
Также мы можем управлять скоростью воспроизведения анимации:
```
let cubeAnimation = document.getElementById('cube').animate(
cubeRotating,
cubeTiming
)
document.body.onclick = () => cubeAnimation.playbackRate *= 1.5
```
Данный код заставляет квадрат вращаться быстрее при клике.
До сих пор мы изучали, как создавать одну анимацию и управлять ее воспроизведением. Другой возможностью WAAPI является доступ ко всем анимациям сразу.
### Управление множеством анимаций
У WAAPI есть метод getAnimations, позволяющий получить доступ ко всем созданным анимациям.
Допустим, мы хотим замедлить все анимации, имеющиеся на странице, если пользователь включил prefers-reduced-motion (CSS медиа функция prefers-reduced-motion может использоваться для определения того, запросил ли пользователь, чтобы ОС минимизировала количество анимации или движения, которые она использует — прим. пер.):
```
const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)')
if(mediaQuery.matches){
document.getAnimations().forEach(animation => {
animation.playbackRate *= 0.5
})
}
```
В примере выше мы ищем медиа функцию prefers-reduced-motion и, если ее значение равняется reduce, получаем все анимации на странице и уменьшаем скорость их воспроизведения наполовину.
Эта одна из тех вещей, которые делают WAAPI очень полезной. Мы можем вносить изменения в несколько анимаций посредством изменения одного свойства.
### Зависимости
Еще одной интересной возможностью WAAPI является возможность определить зависимость свойств одной анимации от свойств другой.
Например, если у нас есть два квадрата, и мы хотим, чтобы второй вращался в два раза быстрее первого, мы можем сделать это двумя способами.
Первый способ:
```
let cube1Animation = document.getElementById('cube').animate(
cubeRotating,
{
duration: 1000,
iterations: Infinity
}
)
let cube2Animation = document.getElementById('cube2').animate(
cubeRotating,
{
duration: 500,
iterations: Infinity
}
)
```
Время анимации первого квадрата составляет 1 секунду, второго — 500 миллисекунд.
Однако при таком подходе, когда мы меняем время анимации первого квадрата, нам нужно сделать тоже самое у второго квадрата.
Представляете, насколько это станет сложным при наличии множества анимаций или большого количества анимированных объектов?
Лучшим способом решить нашу задачу является установление зависимости вращения второго квадрата от первого:
```
let cube1Animation = document.getElementById('cube').animate(
cubeRotating,
{
duration: 1000,
iterations: Infinity
}
)
let cube2Animation = document.getElementById('cube2').animate(
cubeRotating,
{
duration: cube1Animation.effect.timing.duration / 2,
iterations: Infinity
}
)
```
Таким образом, мы используем время анимации первого квадрата для определения времени анимации второго квадрата. Теперь при изменении времени анимации первого квадрата, второй всегда будет вращаться в два раза быстрее!
### Производительность
Говоря о производительности, я не заметила особой разницы между использованием CSS и WAAPI. Но это может быть связано с простотой моего примера.
Одним важным преимуществом WAAPI по сравнению с другими способами создания анимации в JS является то, что он выполняется в отдельном потоке, что позволяет основному потоку «забыть» про анимацию и заниматься остальным кодом.
### Поддержка браузеров
В настоящее время WAAPI находится в статусе черновика и частично поддерживается в последних версиях Firefox и Chrome, а также в основных мобильных браузерах.
Частичная поддержка означает, что браузеры поддерживают такие методы как play, pause, reverse, finish и playbackRate, но не поддерживают getAnimations.
Существует [полифил](https://github.com/web-animations/web-animations-js) для работы WAAPI во всех браузерах.
На этом у меня все!
Дополнительная литература:
[Using the Web Animations API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API/Using_the_Web_Animations_API)
[Web Animations API examples](https://mozdevs.github.io/Animation-examples/)
[Great series «Let's talk about the Web Animations API» by Dan Wilson](http://danielcwilson.com/blog/2015/07/animations-intro/)
Благодарю за внимание. | https://habr.com/ru/post/486454/ | null | ru | null |
# Устранение дублирования Where Expressions в приложении
Допустим, у вас есть товары и категории. В какой-то момент клиент сообщает, что для категорий с рейтингом > 50 необходимо использовать другие бизнес-процессы. У вас достаточно опыта и вы понимаете, что где сегодня 50 завтра будет 127.37 и хотите избежать появления магических чисел в коде, поэтому делаете так:
```
public class Category : HasIdBase
{
public static readonly Expression> NiceRating = x => x.Rating > 50;
//...
}
var niceCategories = db.Query.Where(Category.NiceRating);
```
К сожалению, этот номер не пройдет, если вы хотите выбрать продукты из соответствующих категорий, потому что NiceRating имеет тип `Expression>`, а в случае с Product нам потребуется `Expression>`. То есть, необходимо осуществить преобразование `Expression> => Expression>`.
```
public class Product: HasIdBase
{
public virtual Category Category { get; set; }
//...
}
var niceProductsCompilationError = db.Query.Where(Category.NiceRating); // так нельзя!
```
К счастью, осуществить это довольно просто!
```
// Фактически мы реализуем композицию выражений,
// которая даст нам выражение, соответствующее композиции целевых функций
public static Expression> Compose(
this Expression> input,
Expression> inOutOut)
{
// это параметр x => blah-blah. Для лямбды нам нужен null
var param = Expression.Parameter(typeof(TIn), null);
// получаем объект, к которому применяется выражение
var invoke = Expression.Invoke(input, param);
// и выполняем "получи объект и примени к нему его выражение"
var res = Expression.Invoke(inOutOut, invoke);
// возвращаем лямбду нужного типа
return Expression.Lambda>(res, param);
}
// Добавляем "продвинутый" вариант Where
public static IQueryable Where(this IQueryable queryable,
Expression> prop, Expression> where)
{
return queryable.Where(prop.Compose(where));
}
// Проверяем
[Fact]
public void AdvancedWhere\_Works()
{
var product = new Product(new Category() {Rating = 700}, "Some Product", 100500);
var q = new[] {product}.AsQueryable();
var values = q.Where(x => x.Category, Category.NiceRating).ToArray();
Assert.Equal(700, values[0].Category.Rating);
}
```
Так реализована композиция выражений в [LinqKit](http://www.albahari.com/nutshell/linqkit.aspx). Однако, Entity Framework не дружит с `InvokeExpression` и выкидывает `NotSupportedException`. Вы же знали, что [LINQ протекает](http://blog.ploeh.dk/2013/07/20/linq-versus-the-lsp/)? Чтобы обойти это ограничение в LinqKit используется ~~хак~~ метод расширения `AsExpandable`. Эту проблему описал Pete Montgomery в [своем блоге](https://petemontgomery.wordpress.com/2011/02/10/a-universal-predicatebuilder/). Его версия Predicate Builder не требует особой уличной магии и работает как для `IEnumerable`, так и для `IQueryable`.
Привожу код as is.
```
public static class PredicateBuilder
{
///
/// Creates a predicate that evaluates to true.
///
public static Expression> True() { return param => true; }
///
/// Creates a predicate that evaluates to false.
///
public static Expression> False() { return param => false; }
///
/// Creates a predicate expression from the specified lambda expression.
///
public static Expression> Create(Expression> predicate) { return predicate; }
///
/// Combines the first predicate with the second using the logical "and".
///
public static Expression> And(this Expression> first, Expression> second)
{
return first.Compose(second, Expression.AndAlso);
}
///
/// Combines the first predicate with the second using the logical "or".
///
public static Expression> Or(this Expression> first, Expression> second)
{
return first.Compose(second, Expression.OrElse);
}
///
/// Negates the predicate.
///
public static Expression> Not(this Expression> expression)
{
var negated = Expression.Not(expression.Body);
return Expression.Lambda>(negated, expression.Parameters);
}
///
/// Combines the first expression with the second using the specified merge function.
///
static Expression Compose(this Expression first, Expression second, Func merge)
{
// zip parameters (map from parameters of second to parameters of first)
var map = first.Parameters
.Select((f, i) => new { f, s = second.Parameters[i] })
.ToDictionary(p => p.s, p => p.f);
// replace parameters in the second lambda expression with the parameters in the first
var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);
// create a merged lambda expression with parameters from the first expression
return Expression.Lambda(merge(first.Body, secondBody), first.Parameters);
}
class ParameterRebinder : ExpressionVisitor
{
readonly Dictionary map;
ParameterRebinder(Dictionary map)
{
this.map = map ?? new Dictionary();
}
public static Expression ReplaceParameters(Dictionary map, Expression exp)
{
return new ParameterRebinder(map).Visit(exp);
}
protected override Expression VisitParameter(ParameterExpression p)
{
ParameterExpression replacement;
if (map.TryGetValue(p, out replacement))
{
p = replacement;
}
return base.VisitParameter(p);
}
}
}
``` | https://habr.com/ru/post/313394/ | null | ru | null |
# Краткое руководство по работе с данными с помощью Miller
Привет, друзья!
Представляю вашему вниманию перевод [этой замечательной статьи](https://www.smashingmagazine.com/2022/12/guide-command-line-data-manipulation-cli-miller/), в которой рассказывается о [Miller](https://miller.readthedocs.io/en/latest/) — автономном, легковесном и мощном интерфейсе командной строки (Command Line Interface, CLI) для работы с данными в форматах CSV, JSON и некоторых других.
Интересно? Тогда прошу под кат.
Установка
---------
* Linux: `apt-get install miller`
* macOS: `brew install miller`
* Windows: `choco install miller`
Для того, чтобы убедиться в корректной установке Miller, открываем терминал и выполняем следующую команду:
```
mlr --version
```
Результат:
Команда для получения помощи (списка доступных команд):
```
mlr help topics
```
Сигнатура команды
-----------------
Сигнатура команды Miller выглядит следующим образом:
```
mlr [input/output file formats] [verbs] [file]
# например
mlr --csv filter '$color != "red"' example.csv
```
Здесь:
* `--csv` определяет, что форматом входного (обрабатываемого) файла является CSV;
* `filter` определяет операцию, выполняемую с файлом (глагол — verb). В данном случае мы удаляем строки, которые не содержат поля `color` со значением `red`. Существуют и другие глаголы, например, `sort` и `cut` (см. ниже);
* `example.csv` определяет обрабатываемый файл.
Обзор операций
--------------
### Данные
Скачиваем [Рейтинг IMDb американских сериалов](https://raw.githubusercontent.com/smashingmagazine/command-line-data-manipulation/main/tv_ratings.csv).
Глагол [head](https://miller.readthedocs.io/en/latest/reference-verbs/#head) позволяет получить первые 10 строк файла:
```
mlr ---csv head ./tv_ratings.csv
```
Результат:
Для форматирования вывода используется флаг `--opprint`:
```
mlr --csv --opprint head ./tv_ratings.csv
```
Результат:
Флаг `--c2p` является сокращением для флагов `--csv --opprint`.
### Цепочка команд
Ключевое слово `then` позволяет объединять глаголы в цепочку, т.е. выполнять несколько операций за один раз (см. ниже).
### Удаление колонок
Колонка `titleId` не несет никакой смысловой нагрузки. Удалим ее с помощью глагола [cut](https://miller.readthedocs.io/en/latest/reference-verbs/#cut):
```
mlr --c2p cut -x -f titleId then head ./tv_ratings.csv
```
Здесь:
* `-f` определяет удаляемые поля (перечисляются через запятую);
* `-x` определяет, что удаляемые поля исключаются из вывода, а не включаются в него (поведение по умолчанию).
Результат:
### Фильтрация
Для фильтрации полей используется глагол [filter](https://miller.readthedocs.io/en/latest/reference-verbs/#filter). Получим первые 10 (по порядку в файле) серий первого сезона:
```
mlr --c2p filter '$seasonNumber == 1' then head ./tv_ratings.csv
```
Результат:
### Сортировка
Для сортировки полей используется глагол [sort](https://miller.readthedocs.io/en/latest/reference-verbs/#sort). Получим первые 10 серий с самыми высокими рейтингами:
```
mlr --c2p sort -nr av_rating then head ./tv_ratings.csv
```
Здесь:
* `-nr` определяет числовой нисходящий (от большего к меньшему) порядок сортировки (нули сортируются первыми).
Результат:
### Сохранение результата операций
Оператор `>` позволяет выполнять запись результата операций в файл:
```
mlr --csv sort -nr av_rating ./tv_ratings.csv > ./sorted_tv_ratings.csv
```
Результат:
### Преобразование CSV в JSON
Для преобразования CSV в JSON используется флаг `--c2j`:
```
mlr --c2j sort -nr av_rating ./tv_ratings.csv > ./sorted_tv_ratings.json
```
Результат:
Задача
------
Рассмотрим пример практического использования Miller — получение списка 5 спортсменов, завоевавших наибольшее количество медалей на олимпиаде в Рио-де-Жанейро в 2016 году.
Скачиваем [этот файл в формате CSV](https://raw.githubusercontent.com/flother/rio2016/master/athletes.csv).
Взглянем на него:
```
mlr --c2p head ./athletes.csv
```
Результат:
Удаляем лишние поля:
```
mlr --csv -I cut -x -f id,info,weight,height,date_of_birth ./athletes.csv
```
Здесь:
* `-I` означает, что файл обрабатывается на месте, т.е. сначала создается временный файл, в который записывается результат операций, затем оригинальный файл перезаписывается временным.
*Прим. пер.:* я не буду перезаписывать оригинальный файл, а запишу результат операции в файл `athletes_formatted.csv` с помощью следующей команды:
```
mlr -c cut -x -f id,info,weight,height,date_of_birth ./athletes.csv > ./athletes_formatted.csv
```
Здесь:
* `-c` — это сокращение для `--csv`.
Результат:
У нас имеется статистика по количеству золотых, серебряных и бронзовых медалей. Общее количество медалей можно вычислить с помощью глагола [put](https://miller.readthedocs.io/en/latest/reference-verbs/#put) следующим образом:
```
mlr --c2p put '$medals=$bronze+$silver+$gold' then head ./athletes_formatted.csv
```
Результат:
Сортируем список по количеству медалей от большего с меньшему:
```
mlr --c2p put '$medals=$bronze+$silver+$gold' \
then sort -nr medals \
then head ./athletes_formatted.csv
```
Результат:
Ограничиваем вывод пятью спортсменами с помощью флага `-n`:
```
mlr --c2p put '$medals=$bronze+$silver+$gold' \
then sort -nr medals \
then head -n 5 ./athletes_formatted.csv
```
Результат:
Записываем результат в JSON-файл:
```
mlr --c2j put '$medals=$bronze+$silver+$gold' \
then sort -nr medals \
then head -n 5 ./athletes.csv > ./top5_athletes.json
```
Результат:
Здесь:
* `-j` — это сокращение для `--json`
Что если мы хотим получить пятерку лучших атлетов среди женщин? Проще простого:
```
mlr --c2p put '$medals=$bronze+$silver+$gold' \
then sort -nr medals \
then filter '$sex == "female"' \
then head -n 5 ./athletes_formatted.csv
```
Результат:
Надеюсь, что вы, как и я, узнали что-то новое и не зря потратили время.
Благодарю за внимание и happy coding!
---
[](https://timeweb.cloud/?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/711246/ | null | ru | null |
# Named Capturing Group и Backreferences
Данная заметка не предназначена для начинающих изучать регулярные выражения, для начинающих я бы посоветовал книгу Ben Forta "Teach Yourself Regular Expressions in 10 Minutes" (ISBN: 0-672-32566-7).
Для тестирования и отладки регулярных выражений идеально подходит программа RegexBuddy (http://www.regexbuddy.com). Чтобы отлаживать следующие примеры нужно во вкладку Test скопировать HTML какой-либо страницы или вбить несколько тегов самим.
Задача — найти в HTML все теги IMG и вытащить из тегов значения атрибутов SRC и ALT.
Первая часть задачи найти все HTML теги решается довольно просто таким регулярным выражением:
**`![]()`**
Не забудьте поставить галочки на "Dot matches newline" и "Case insensitive"
 | https://habr.com/ru/post/54681/ | null | ru | null |
# Делаем автоматизированный обзвон для нотификаций или опросов
В ряде случаев у компании может возникнуть необходимость обзвонить каких-то из своих клиентов и сообщить им о чем-то, или, например, провести опрос про качеству обслуживания. Данную задачу можно решать разными способами, но мы будем исходить из того, что в данном случае ее нужно решить веб-разработчику, который привык иметь дело с Javascript/веб-сервисами и не сильно хочет вникать в особенности систем IP-телефонии. К счастью для него есть подходящий инструмент, о котором подробнее под катом.
Итак, для реализации автоматизированных обзвонов мы будем использовать платформу [VoxImplant](http://voximplant.com/), а также встроенную в нее подсистему колл-листов (CallList). Стоит сразу отметить, что **автоматизированные звонки допустимо делать только тем людям, которые на это согласились**. Телефонный спам ничем не лучше СМС-спама или email-спама, не надо лишний раз раздражать людей.
Давайте рассмотрим несколько сценариев — обычная нотификация о каком-то событии (например, сообщение кода-активации или напоминание о посещении мед. учреждения) и опрос о качестве обслуживания.
### Настройка аккаунта
В случае VoxImplant на вход с помощью HTTP-запроса подается CSV-файл со списком номеров и дополнительной информацией к каждому номеру, которая может быть использована в сценарии, запускаемому на каждую строку файла. Первая строка — это обязательный заголовок с названием параметров, чтобы потом эти параметры можно было использовать в сценарии. Существуют еще системные параметры, которые влияют на то как система будет данную строку обрабатывать. Давайте рассмотрим следующий пример:
```
user_id;first_name;last_name;phone_number;activation_code
0;Сергей;Иванов;74951234567;101102
```
Это контент CSV-файла, который мы отправим на обзвон. При обзвоне в сценарий VoxImplant эти данные придут в виде JSON, и мы сможем их использовать по назначению.
Создаем приложение, а в нем – сценарий и правило, к которому цепляем сценарий. Маску можно не менять, она не имеет значения при запуске через HTTP-запрос.
Наш сценарий VoxEngine должен содержать следующий код:
```
require(Modules.CallList); // Подключаем модуль CallList
require(Modules.AI);
let call,
first_name,
last_name,
phone_number,
activation_code,
playbackCounter = 0;
// Обработка события запуска сценария
VoxEngine.addEventListener(AppEvents.Started, function (e) {
let data = VoxEngine.customData(); // <-- сюда пришли данные из строки CSV в JSON-формате
data = JSON.parse(data);
user_id = data.user_id;
first_name = data.first_name;
last_name = data.last_name;
phone_number = data.phone_number;
activation_code = data.activation_code;
Logger.write("Звоним " + first_name + " " + last_name + " на номер " + phone_number);
// Звоним
call = VoxEngine.callPSTN(phone_number, "+1234567890"); // <-- вторым параметром нужно указать callerid, предварительно его авторизовав в разделе CallerIDs верхнего меню панели управления VoxImplant
// Для определения голосовой почты
call.addEventListener(CallEvents.AudioStarted, function(){
AI.detectVoicemail(call)
.then(voicemailDetected)
.catch(()=>{
Logger.write('Голосовая почта не обнаружена');
})
});
// Вешаем обработчики событий
call.addEventListener(CallEvents.Connected, handleCallConnected);
call.addEventListener(CallEvents.Failed, handleCallFailed);
call.addEventListener(CallEvents.Disconnected, handleCallDisconnected);
});
function voicemailDetected(e) {
// Голосовая почта?
if (e.confidence >= 75) {
VoxEngine.CallList.reportError("Voicemail", VoxEngine.terminate);
return;
}
}
// Дозвонились
function handleCallConnected(e) {
connected = true;
setTimeout(function () {
e.call.say("Здравствуйте, " + first_name + "! Ваш код активации: " + activation_code, { "language": VoiceList.Yandex.ru_RU_oksana });
}, 500);
e.call.addEventListener(CallEvents.PlaybackFinished, handlePlaybackFinished);
}
// Воспроизведение закончилось
function handlePlaybackFinished(e) {
e.call.removeEventListener(CallEvents.PlaybackFinished, handlePlaybackFinished);
playbackCounter++;
// Несколько раз сказали код активации и достаточно
if (playbackCounter == 4) {
e.call.hangup();
} else {
// Делаем паузу несколько секунд и проговариваем код еще раз
setTimeout(function () {
e.call.say("Ваш код активации: " + activation_code, { "language": VoiceList.Yandex.ru_RU_oksana });
e.call.addEventListener(CallEvents.PlaybackFinished, handlePlaybackFinished);
}, 2000);
}
}
function handleCallFailed(e) {
// Сообщаем модулю, что не удалось дозвониться
// в зависимости от настроек обзвона он либо попытается дозвониться еще раз через указанное время
// либо запишет результат, что дозвониться не удалось, и в колонку result_data
// CSV-файла с результатами обзвона запишет данные result, msg, code в JSON-формате
CallList.reportError({
result: false,
msg: "Failed",
code: e.code
}, VoxEngine.terminate);
}
function handleCallDisconnected(e) {
// Отправляем сообщение модулю, чтобы сообщить, что дозвонились
// result и duration будут записаны в колонку result_data
// CSV-файла с результатами обзвона в JSON-формате
CallList.reportResult({
result: true,
duration: e.duration
}, VoxEngine.terminate);
}
```
### Запуск обзвона через HTTP API
Метод API для запуска обзвона [CreateCallList](https://voximplant.com/docs/references/httpapi/calllists#createcalllist), давайте разберем параметры запроса, чтобы все было понятно:
* **account\_name** — имя аккаунта VoxImplant
* **api\_key** — API KEY аккаунта VoxImplant
* **rule\_id** — id-правила приложения, к которому мы прицепили сценарий
* **priority** — приоритет обзвона, если обзвонов много, то можно управлять какой будет раньше выполнен
* **max\_simultaneous** — максимальное кол-во одновременно обрабатываемых записей
* **num\_attempts** — кол-во попыток дозвона, новая попытка будет в случае если была вызвана функция CallList.reportError
* **name** — просто название обзвона
* **file\_content** — CSV-файл нужно передавать в теле запроса (request body)
* **interval\_seconds** — время до следующей попытки дозвона (в секундах)
* **encoding** — кодировка CSV-файла, нужно указывать, если отличается от UTF-8
* **delimiter** — разделитель столбцов в CSV-файле, по умолчанию ;
Сделаем следующий PHP-файл с парочкой функций, которые запускают обзвон:
```
php
define("API_URL", "https://api.voximplant.com/platform_api/");
define("API_KEY", "ваш api key");
define("ACCOUNT_NAME", "ваш account name");
define("RULE_ID", id-правила);
function httpRequest($url,$params) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
if (isset($params["post"])) curl_setopt($ch, CURLOPT_POST, 1);
if (isset($params["post_data"])) curl_setopt($ch, CURLOPT_POSTFIELDS, $params["post_data"]);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: text/csv'));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$server_output = curl_exec ($ch);
curl_close ($ch);
return $server_output;
}
function createCallList($file) {
$url = API_URL . "CreateCallList/?" .
"account_name=" . ACCOUNT_NAME .
"&api_key=" . API_KEY .
"&rule_id=" . RULE_ID .
"&max_simultaneous=10" .
"&num_attempts=2" .
"&interval_seconds=60" .
"&priority=1" .
"&name=CallList";
$data = file_get_contents($file);
$params = array('post' = true, 'post_data' => $data);
$result = httpRequest($url, $params);
echo $result;
}
function getCallListDetails($list_id, $output = "json") {
$url = API_URL . "GetCallListDetails/?" .
"account_name=" . ACCOUNT_NAME .
"&api_key=" . API_KEY .
"&list_id=" . $list_id .
"&output=" . $output;
$params = array();
$result = httpRequest($url, $params);
echo $result;
}
createCallList(URL-CSV-файла);
//getCallListDetails($list_id, "csv");
?>
```
Результат выполнения getCallListDetails будет выглядеть как-то так (если успешно дозвонились):
```
"activation_code";"user_id";"last_name";"phone_number";"first_name";"__end_execution_time";"__start_execution_time";"result_data";"last_attempt";"attmepts_left";"status_id";status
101102;0;Иванов;74951234567;Сергей;;;"{""result"":true,""duration"":27}";"2014-11-24 19:21:39";1;2;Processed
```
Естественно, можно получить список всех обзвонов [GetCallLists](https://voximplant.com/docs/references/httpapi/calllists#getcalllists) или остановить обзвон [StopCallListProcessing](https://voximplant.com/docs/references/httpapi/calllists#stopcalllistprocessing).
### Пример сценария опроса
Немного усложним задачу — кроме звонка будем еще просить ввести оценку качества обслуживания и сохранять ее в результатах обзвона. Для этого нужно будет модифицировать функции handleCallConnected, handleCallDisconnected и добавить новую handleToneReceived:
```
function handleCallConnected(e) {
connected = true;
e.call.handleTones(true); // <-- включаем обработку ввода
setTimeout(function () {
e.call.say("Здравствуйте, " + first_name + "! Спасибо вам за посещение нашего магазина, "+
"пожалуйста, оцените качество обслуживания от одного до пяти.", { "language": VoiceList.Yandex.ru_RU_oksana });
}, 500);
e.call.addEventListener(CallEvents.PlaybackFinished, handlePlaybackFinished);
e.call.addEventListener(CallEvents.ToneReceived, handleToneReceived);
}
let rating;
function handleToneReceived(e) {
e.call.removeEventListener(CallEvents.PlaybackFinished, handlePlaybackFinished);
e.call.stopPlayback();
rating = e.tone;
e.call.say("Спасибо большое за ваш ответ!", { "language": VoiceList.Yandex.ru_RU_oksana });
e.call.addEventListener(CallEvents.PlaybackFinished, function(e) {
e.call.hangup();
});
}
function handleCallDisconnected(e) {
CallList.reportResult({
result: true,
duration: e.duration,
rating: rating,
}, VoxEngine.terminate);
}
// Воспроизведение закончилось
function handlePlaybackFinished(e) {
e.call.removeEventListener(CallEvents.PlaybackFinished, handlePlaybackFinished);
playbackCounter++;
// Несколько раз сказали код активации и достаточно
if (playbackCounter == 4) {
e.call.hangup();
} else {
// Делаем паузу несколько секунд и проговариваем код еще раз
setTimeout(function () {
e.call.say("Пожалуйста, оцените качество обслуживания от одного до пяти.", { "language": VoiceList.Yandex.ru_RU_oksana });
e.call.addEventListener(CallEvents.PlaybackFinished, handlePlaybackFinished);
}, 2000);
}
}
```
Результат будет выглядеть как-то так:
```
"user_id";"last_name";"phone_number";"first_name";"__end_execution_time";"__start_execution_time";"result_data";"last_attempt";"attmepts_left";"status_id";status
0;Иванов;74951234567;Сергей;;;"{""result"":true,""duration"":27,""rating"":""3""}";"2014-11-24 20:17:13";1;2;Processed
```
Ну вот, мы рассмотрели несколько сценариев обзвонов с помощью VoxImplant. При желании можно делать HTTP-запросы во внешний мир прямо из сценария и передавать данные куда-то в реальном времени или подключить модуль ASR с распознаванием речи и дать возможность людям ответить на вопрос прямо голосом. Звонки при желании можно отправлять через свою SIP-инфраструктуру — меняем callPSTN на callSIP в сценарии и туда передаем настройки. В общем, надеемся, что данный пост будет вам полезен и поможем вам решить свою задачу, полезных вам звонков! | https://habr.com/ru/post/243809/ | null | ru | null |
# IPv6 — это весело, часть 2
**Введение:** Добрый день или вечер, или даже ночь дорогие хабравчане. В данной статье продолжим изучать особенности протокола IPv6 и его отличия от IPv4. В данной статье будет минимальное количество теории и максимальное количество настройки. Начнем с настройки DHCPV6 и рассмотрим особенности работы этого протокола на основе протокола IPv6, также посмотрим на то, как настраиваются протокола динамической маршрутизации на основе IPv6. Оборудования для настройки выберем Cisco (в третей части Juniper).
[IPV6 — это весело. Часть 1](http://habrahabr.ru/post/253803/)
Также хотелось поблагодарить всех пользователей, которые комментируют, задают вопросы. Задавая некоторые неудобные вопросы вы заставляете меня снова лезть в книжки, что-то повторять, что-то лучше осваивать и отвечать на ваши вопросы. Также каждый из вас может повлиять на выпуск следующей части. Не бойтесь задавать вопросы, если что-то не ясно.
**План**
1. Настройка протокола DHCPV6
2. Настройка статических маршрутов
3. Настройка протоколов динамической маршрутизации (RIPng,EIGRP,OSPF,IS-IS,BGP)
4. Настройка ACL ( Расширенные именованные листы)
5. VRRP v3,
6. Настройка IPv6 ICMP ограничение по скорости
7. Dual IPv4 and IPv6 Protocol Stacks
По просьбам трудящихся, прежде всего хотелось выразить свое мнение относительно IPv6 и подвести некий итог написанного в предыдущей главе. Разберу по пунктам:
1. В IPv6 нету Broadcast, ARP.
Broadcast частично заменили Multicast адреса и адреса Link Local (читайте [предыдущую](http://habrahabr.ru/post/253803/) статью). ARP протокол заменен протоколом NDP;
2. В IPv6 нет технологии NAT, которая есть в IPv4. Смело спорьте с тем, кто скажет обратное. Экономия адресов в IPv6 не используется, адресов хватит на всех. Уровень безопасности, который обеспечивает NAT в технологии IPv4, заменен адресами Unique Local (читайте предыдущую статью), но нельзя забывать, что безопасность должны обеспечивать межсетевые экраны – это их функция. Название Nat64 которое можете встретить в литературе про IPv6, идет речь о совместном использовании технологии IPv6, IPv4 (читайте [предыдущую](http://habrahabr.ru/post/253803/) статью);
3. По моим ощущениям, осталось 3-4 года для полного перехода на IPv6. По моим представлениям переход будет параллелен;
4. Благодаря Link Local адресам сетевые устройства могут общаться в пределах одного локального канала и только в пределах его;
5. Появилась фича которая называется: «проверка уникальности IPv6 адреса». Используется в DHCPV6, полный процесс будет описан чуть ниже. Суть ее в том, что после назначения ip-адреса устройству он посылает icmp запрос, destination выбирает данный ему адрес, если приходит ответ — то его адрес не уникален и нужно получать новый IPv6 адрес;
6. Появились адреса anycast (читать статью). В сети могут существовать несколько хостов с абсолютно идентичными IPv6-адресами. Вариант использования я выявил один, в случае, когда находятся три балансировщика около сервера. Им дается один и тот же адрес, который называется anycast. Принцип работы балансировщика пояснять не буду, так как это не тема статьи;
7. Вендоры, такие как Cisco или Juniper, полностью готовы к переходу на IPv6, дело остается за операторами связи и ИТ-компаниями.
> Ошибки свойственны человеку, но для нечеловеческих ляпов нужен компьютер. (Paul Ehrlich)
**DHCPV6**
**SLAAC** — это способ, который позволяет устройству получить свой префикс, длину префикса и адрес шлюза по умолчанию от маршрутизатора IPv6 без помощи DHCPv6-сервера. При использовании SLAAC для получения необходимой информации устройства полагаются на сообщения «Объявления маршрутизатора ICMPv6».
IPv6-маршрутизаторы периодически отправляют сообщения «Объявления маршрутизатора ICMPv6» всем устройствам в сети под управлением IPv6. По умолчанию маршрутизаторы Cisco отправляют такие сообщения каждые 200 секунд на адрес групповой передачи всем IPv6-узлам. IPv6-устройству, находящемуся в сети, не нужно ждать этих периодических сообщений. Устройство может отправить сообщение «Запрос маршрутизатора ICMPv6», который использует адрес групповой передачи всем IPv6-узлам. Когда маршрутизатор IPv6 получает такое сообщение, он сразу же отправляет в ответ объявление маршрутизатора.
IPv6-маршрутизация не включена по умолчанию. Чтобы маршрутизатор работал как IPv6-маршрутизатор, необходимо использовать команду глобальной конфигурации ipv6 unicast-routing.
Сообщение «Объявления маршрутизатора ICMPv6» содержит префикс, длину префикса и другие сведения IPv6-устройства. Кроме того, такое сообщение указывает IPv6-устройству, как ему получить информацию по адресации. сообщение «Объявления маршрутизатора» может выглядеть в одном из следующих 3 вариантов.
* **Вариант 1: только SLAAC**. Устройство должно использовать префикс, длину префикса и шлюз по умолчанию, которые содержатся в сообщении «Объявления маршрутизатора». Другая информация недоступна с DHCPv6-сервера;
* **Вариант 2: SLAAC и DHCPv6**. Устройство должно использовать префикс, длину префикса и шлюз по умолчанию, которые содержатся в сообщении «Объявления маршрутизатора». На DHCPv6-сервере доступна и другая информация, например адрес DNS-сервера. Устройство получит эту дополнительную информацию в процессе поисков и запросов к DHCPv6-серверу. Этот процесс называется «DHCPv6 без запоминания состояний», поскольку DHCPv6-серверы не выделяют и не отслеживают какие-либо назначения IPv6-адресов, а предоставляют дополнительную информацию, например об адресе DNS-сервера;
* **Вариант 3: только DHCPv6**. Устройство не должно использовать информацию из сообщения «Объявления маршрутизатора» для пополнения своей информации об адресации. Вместо этого устройство будет использовать обычные процессы поисков и запросов к DHCPv6-серверам для получения всей своей информации об адресации. Такая информация включает в себя индивидуальный адрес IPv6, длину префикса, адрес шлюза по умолчанию и адреса DNS-серверов. В этом случае DHCPv6-сервер работает как DHCP-сервер, который фиксирует данные аналогично DHCP-серверу для IPv4. DHCPv6-сервер выделяет и отслеживает IPv6-адреса, чтобы не назначать один и тот же IPv6-адрес на нескольких устройствах.
> Компьютер позволяет нам совершать ошибки гораздо быстрее, чем любые другие изобретения человечества: за исключением, пожалуй, текилы и оружия. (Mitch Radcliffe)
**Общие сведения о SLAAC**
Автоматическая настройка адреса без отслеживания состояния (SLAAC) — это способ получения устройством глобального IPv6-адреса одноадресной рассылки без использования DHCPv6-сервера. В основе SLAAC лежит протокол ICMPv6. Протокол ICMPv6 аналогичен ICMPv4, но при этом он имеет дополнительные функциональные возможности и демонстрирует большую устойчивость к ошибкам. SLAAC использует ICMPv6-сообщения запроса маршрутизатора и объявления маршрутизатора, чтобы предоставить информацию об адресации и другую информацию о конфигурации, обычно предоставляемую DHCP-сервером.
* Сообщение запроса маршрутизатора (RS) — если клиент настроен на получение информации об адресации автоматически с использованием SLAAC, он посылает на маршрутизатор сообщение RS. Сообщение RS отправляется на IPv6-адрес многоадресной рассылки FF02::2, который поддерживают все маршрутизаторы.
* Сообщение объявления маршрутизатора (RA) — для предоставления информации об адресации маршрутизатор отправляет сообщения RA клиентам, настроенным на получение IPv6-адресов автоматически. Сообщение RA содержит префикс и длину префикса локального сегмента. Эта информация используется клиентом для создания собственного глобального индивидуального IPv6-адреса. Маршрутизатор передаёт сообщение RA периодически или в ответ на сообщение RS. По умолчанию маршрутизаторы Cisco отправляют сообщения RA каждые 200 секунд. Сообщения RA всегда отправляются на общий для всех узлов IPv6-адрес многоадресной рассылки FF02::1.
Как видно из термина, SLAAC не отслеживает состояние адреса. Служба без отслеживания состояния говорит о том, что ни один из серверов не поддерживает информацию о сетевом адресе. В отличие от сервера DHCP, сервер SLAAC не знает, какие IPv6-адреса используются, а какие доступны
**Принцип работы SLACC + DHCPV6 без отслеживание состояния**
Для отправки маршрутизатором сообщений RA, на нём предварительно необходимо настроить работу IPv6-маршрутизации. Для активации IPv6-маршрутизации необходимо выполнить следующие команды:
```
Router(config)# ipv6 unicast-routing
```
1. В топологии, PC1 настроен на автоматическое получение настроек IPv6-адресации. С момента загрузки PC1 не получил сообщений RA, поэтому он отправляет сообщение RS на адрес многоадресной рассылки, который поддерживают все маршрутизаторы, чтобы проинформировать локальный IPv6-маршрутизатор о необходимости получения сообщения RA.
2. R1 получает сообщение RS и отправляет в ответ сообщение RA. В сообщение RA включены префикс и длина префикса сети. Сообщение RA отправлено на общий для всех узлов IPv6-адрес многоадресной рассылки FF02::1 с адресом канала маршрутизатора типа link-local в качестве IPv6-адреса источника.
3. PC1 получает сообщение RA, содержащее префикс и длину префикса для локальной сети. PC1 будет использовать эту информацию для создания собственного глобального индивидуального IPv6-адреса. PC1 имеет теперь 64-разрядный префикс сети, но требует 64-битный идентификатор интерфейса (IID) для создания глобального индивидуального адреса.
Существует для способа создания PC1 собственного уникального IID:
**EUI-64, генерация случайным образом.**
Поскольку SLAAC — это процесс без отслеживания состояния, перед использованием PC1 этого вновь созданного IPv6-адреса, необходимо проверить его уникальность., PC1 посылает по протоколу ICMPv6 сообщение запроса поиска соседа с собственным адресом в качестве IPv6-адреса назначения. Если другие устройства не отвечают сообщением запроса поиска соседа, значит, адрес является уникальным и может быть использован PC1. Если сообщение запроса поиска соседей получено PC1, значит, адрес не уникален и операционная система должна установить новый идентификатор интерфейса для использования.
Этот процесс является частью процесса обнаружения соседних устройств ICMPv6 и известен как обнаружение адресов-дубликатов (DAD).
Настроен ли клиент на автоматическое получение информации об IPv6-адресации с использованием SLAAC, DHCPv6 или сочетанием обоих вариантов, зависит от настроек, содержащихся в сообщении RA. ICMPv6 сообщения RA содержат два флага, обозначающих, какой из вариантов должен быть использован клиентом ([смотреть в Части 1](http://habrahabr.ru/post/253803/)).
Этими флагами являются флаг управляемой конфигурации адресов (M) и флаг другой конфигурации (O).
> Утверждать, что Java хорош тем, что работает на всех ОС, — то же самое, что утверждать, что анальный секс хорош тем, что подходит к любому полу. (Alanna)
**Функции SLAAC,DHCPV6+SLAAC,DHCPV6**
Рассмотрим все три способа, изменение флагов.
1. SLAAC — Этот вариант указывает клиенту использовать только информацию из сообщения RA. Сюда входит информация о префиксе, длине префикса, DNS-сервере, MTU и информация о шлюзе по умолчанию. Далее клиент не получает никакой информации от сервера DHCPv6. Глобальный индивидуальный IPv6-адрес создаётся путём объединения префикса, полученного в сообщении RA, и идентификатора интерфейса, полученного с помощью EUI-64 или сгенерированного случайным образом.
Сообщения RA настроены на отдельном интерфейсе маршрутизатора. Для повторной активации режима SLAAC на интерфейсе, на котором мог быть установлен другой вариант работы, флаги M и O необходимо сбросить на их первоначальные значения, равные 0. Для этого применяются следующие команды режима конфигурации интерфейса:
```
Router(config-if)# no ipv6 nd managed-config-flag
Router(config-if)# no ipv6 nd other-config-flag
```
2. DHCPV6+SLAAC — Для DHCPv6 без отслеживания состояния значение флага O установлено равным 1, а значение флага M остается со значением по умолчанию, равным 0. Значение флага O, равное 1, используется для информирования клиента о том, что на DHCPv6-сервере без отслеживания состояния доступна дополнительная информация о конфигурации.
Для того чтобы изменить сообщение RA, отправляемое на интерфейс маршрутизатора для указания использования DHCPv6 без отслеживания состояния, используйте следующие команды:
Router(config-if)# ipv6 nd other-config-flag
3. Протокол DHCPv6 с отслеживанием состояния (только DHCPv6)
Флаг M указывает, используется ли DHCPv6 с отслеживанием состояния. Флаг O не используется. Для того чтобы изменить значение флага М с 0 на 1 для объявления DHCPv6 с отслеживанием состояния, применяются следующие команды:
Router(config-if)# ipv6 nd managed-config-flag
> Создание языка программирования — это как прогулка по парку. По парку Юрского периода. (Larry Wall)
**Процессы DHCPV6**
В случае если в сообщении RA указан вариант работы DHCPv6 (с отслеживанием состояния или без), инициируется работа DHCPv6. Сообщения протокола DHCPv6 посылаются через протокол UDP. Сообщения DHCPv6 от сервера к клиенту используют UDP порт назначения 546. Клиент отправляет сообщения на сервер DHCPv6 через UDP порт назначения 547.
Клиенту — теперь DHCPv6-клиенту — необходимо определить местоположение сервера DHCPv6. клиент передаёт сообщение DHCPv6 SOLICIT на зарезервированный IPv6-адрес многоадресной рассылки FF02::1:2, используемый всеми DHCPv6 серверами. Этот адрес многоадресной рассылки действует в рамках канала link-local, это означает, что маршрутизаторы не направляют сообщения в другие сети.
Один или несколько серверов DHCPv6 отвечают DHCPv6-сообщением ADVERTISE. Сообщение ADVERTISE сообщает DHCPv6-клиенту, что сервер доступен для предоставления службы DHCPv6.
Клиент отвечает серверу DHCPv6 сообщением REQUEST или INFORMATION-REQUEST, в зависимости от того, является ли DHCPv6-сервер сервером с отслеживанием состояния или без него.
* DHCPv6-клиент без отслеживания состояния — клиент отправляет DHCPv6 сообщение INFORMATION-REQUEST серверу DHCPv6, запрашивая только параметры конфигурации, например, адрес DNS-сервера. Клиент создаёт собственный IPv6-адрес при помощи префикса из сообщения RA и самогенерируемого идентификатора интерфейса.
* DHCPv6-клиент с отслеживанием состояния — клиент отправляет DHCPv6 сообщение REQUEST серверу для получения IPv6-адреса и всех остальных параметров конфигурации от сервера.
> Программы — это как секс: гораздо лучше, когда бесплатно. (Linus Torvalds)
**Теперь оставим теорию и выведем только настройку**
1. Настройка маршрутизатора в качестве DHCPV6 сервера без отслеживания состояния
Активация маршрутизации IPv6
```
Router(config)# ipv6 unicast-routing
```
Настройка DHCPV6 пула
```
Router(config)#ipv6 dhcp pool (pool-name)
```
Настройка параметров пула
```
Router(config-dhcpv6)# dns-server (указываем адрес dns-server-address)
Router(config-dhcpv6)#domain-name (указываем имя domain)
```
Настройка интерфейса
```
Router(config-)# interface (type number)
Router(config-if)# ipv6 dhcp server (pool name)
Router(config-if)# ipv6 nd other-config-flag
```
2. В качестве клиента
```
Router(config)#interface (interface-number)
Router(config-if)# ipv6 enable
Router(config-if)# ipv6 address autoconfig
(Команда ipv6 address autoconfig включает автоматическую настройку IPv6-адресации с использованием SLAAC)
Проверка: show ipv6 dhcp pool,show ipv6 interface (type-number)
```
3. Сервер DHCPV6 с отслеживанием состояния
Активация маршрутизации IPv6
```
Router(config)#ipv6 unicast-routing
```
Настройка DHCPV6-пула
```
Router(config)#ipv6 dhcp pool (pool-name)
```
Настройка параметров пула
```
Router(config-dhcpv6)# address (prefix/length (lifetime (valid-lifetime preferred-lifetime)infinite))
Router(config-dhcpv6)# dns-server (dns-server-address)
Router(config-dhcpv6)# domain-name (domain-name)
```
Настройка интерфейса
```
Router(config)#interface (interface-number)
Router(config-if)# ipv6 dhcp server (pool-name)
Router(config-if)# ipv6 nd managed-config-flag
```
Настройка маршрутизатора в качестве DHCPV6-клиента с отслеживанием состояния
```
Router(config)#interface (interface-number)
Router(config-if)# ipv6 enable
Router(config-if)# ipv6 address dhcp
```
4. Настройка маршрутизатора в качестве агента рентрансляции
```
Router(config)#interface (interface-number)
Router(config-if)# ipv6 dhcp relay destination (address)
```
> Если отладка — процесс удаления ошибок, то программирование должно быть процессом их внесения. (Edsger W. Dijkstra)
**2) Настройка статических маршрутов в IPv6**
```
Router(config)# ipv6 route ipv6-prefix/prefix-length { ipv6-address | exit-intf }
```
2) Настройка рекурсивного статического маршрута
```
Router(config)#ipv6 route 2001:DB8:ACAD:2::/64 2001:DB8:ACAD:4::2
Router(config)#ipv6 route 2001:DB8:ACAD:5::/64 2001:DB8:ACAD:4::2
Router(config)#ipv6 route 2001:DB8:ACAD:3::/64 2001:DB8:ACAD:4::2
```
Название сети – next-hop.В данном примере разные сети next-hop один и тот же.
3) Настройка напрямую подключнного статического маршрута
```
Router(config)#ipv6 route 2001:DB8:ACAD:3::/64 s0/0/0
```
Настройка полностью заданного статического маршрута IPv6
```
Router(config)#ipv6 route 2001:DB8:ACAD:3::/64 s0/0/0 fe80::2 (суть его в том,что если используете адрес типа Lin-Local то надо обязательно указать тип выходного интерфейса)
```
5)настройка маршрутов по умолчанию
```
ipv6 route ::/0 { ipv6-address | exit-intf }
```
Настройка суммарного IPv6-адреса
```
Router(config)#ipv6 route 2001:DB8:ACAD:1::/64 2001:DB8:ACAD:4::2
Router(config)#no ipv6 route 2001:DB8:ACAD:2::/64 2001:DB8:ACAD:4::2
Router(config)#no ipv6 route 2001:DB8:ACAD:3::/64 2001:DB8:ACAD:4::2
Router(config)#no ipv6 route 2001:DB8:ACAD:4::/64 2001:DB8:ACAD:4::2
```
В сумме
```
Router(config)#ipv6 route 2001:DB8:ACAD:4::/61 2001:DB8:ACAD:4::2
```
> Если бы McDonalds разрабатывал ПО, один из сотни биг-маков был бы отравлен, а администрация отвечала бы: «В качестве извинения примите купон на два бесплатных биг-мака». (Mark Minasi)
**3) Настройка динамической маршрутизации в IPv6**
Ripng
```
Router(config)#interface (number)
Router(config-if)# ipv6 rip RIP-AS enable
Router(config-if)# exit
```
передать маршрут по умолчанию
```
Router(config)# pv6 rip имя_домена default-information originate
```
**EIGRP**
```
Router(config)# ipv6 router eigrp autonomous-system
Router(config-rtr)# eigrp router-id 1.0.0.0 – задание номера процесса
Router(config-rtr)# no shutdown
Router(config)# interface (type/number) (заходим в интерфейс)
Router(config-if)# ipv6 eigrp (AS)
Router(config-if)# ipv6 bandwidth-percent eigrp as-number percent-настройка процентного соотношения пропускной способности,
R2(config-rtr)# redistribute static - распределения маршрута по умолчанию
Router(config-if)# ipv6 hello-interval eigrp as-number seconds - изменение hello интервала
Router(config-if)# ipv6 hold-time eigrp as-number seconds - изменение hold-time
```
**OSPF3**
```
Router(config)# ipv6 router ospf 10 –активировать режим OSPF
Router(config-rtr)# router-id 1.1.1.1 (задаем router-id)
Router(config-rtr)# auto-cost reference-bandwith 1000 (задаем cost)
Router(config)# interface (type/number) (заходим в интерфейс)
Router(config-if)# ipv6 ospf 10 area (number) (назначаем интерфейс в протокол ospf,номер процесса,номер
area)
Router#clear ipv6 ospf process
```
**IS-IS**
```
Router(config)# isis area-tag (например router isis area2)
Router(config-rtr)# net network-entity-title (например 49.0001.0000.0000.000с.00
Router(config)# interface Ethernet 0/0/1
Router(config)# ipv6 address {ipv6-address/prefix-length | prefix-name sub-bits/prefix-length}
Router(config-if)# ipv6 router isis area-name (ipv6 router isis area2)
```
**BGP**
```
Router(config)# router bgp 65000
Router(config-rtr)# no bgp default ipv4-unicast ( выключаем ipv4 unicast аддресса для BGP)
Router(config-rtr)#bgp router-id (сконфигурим 32-битный роутер id ,будьте аккуратный эта команда сбросит все активный BGP peering сессии)
Router(config-rtr)# neighbor 2001:DB8:0:CC00::1 remote as 64600 – добавим ipv6 адрес соседа и автономную систему.
Router(config-rtr)# address-family ipv6 [unicast |multicast]
Router(config-rtr-af)#neighbor 2001:DB8:CC00::1 activate – активируем соседа для обмена префиксами ipv6
```
**4) ACL**
```
Router(config)#ipv6 access-list NO-BYX-SIDET-VKONTAKTE
Router(config-ipv6-acl)#deny ipv6 2001:db8:cafe:30::/64 any
Router(config-ipv6-acl)#permit ipv6 any any
```
все это может выглядеть следующем образом-
```
Router(config)#ipv6 access-list access-list-name
Router(config-ipv6-acl)#deny | permit protocol (source-ipv6-prefix/prefix-length |any|host source-ipv6-addres) (operator(port-number)) (destination-ipv6-prefix/prefix-length | any | host destination-ipv6-address) (operator(port-number))
Router(config)# interface (type/number) (заходим в интерфейс)
Router(config-if)# ipv6 traffic-filter access-list-name { in |out }
```
**5) VRRP,HSPR**
```
Router(config)# fhrp version vrrp v3 – включаем ,когда используется 3 версия,вторая не не активна.
Router(config)# interface type number
Router(config-if)# vrrp (group-id address-family (ipv6)
Router(config-if)# vrrp 3 address-family ipv6
Router(config-if-vrrp)# address 2001:abc:cafe:11::/64 primary (или secondary)
Router(config-if-vrrp)# description group 3
Router(config-if-vrrp)# match-address (добавляем второй адрес в объявление)
Router(config-if-vrrp)# preempt delay minimum 30 – включаем преимущество низкой приоритетности мастера с опцией задержки (опциально)
```
**HSPR**
```
Switch (config)# interface type number
Switch (config-if)#no switchport
Switch (config)#standby 1 ipv6 autoconfig
Router(config)# interface type number
Router(config-if)#standby version (2)
Router(config)# interface type number
Router(config-if)#standby (group-number) ipv6 (link-local |address)
Router(config-if)#standby [group-number]preempt [delay {minimumseconds | reload seconds |sync seconds}]
Router(config-if)#standby [group-number]priority priority
```
**6) Настройка IPv6 ICMP ограничение по скорости**
```
Router(config)#ipv6 icmp error- interval (bucketsize) (interval в милл сек,диапозон 0 2147483647,bucketsize – опциально,диапозон 1 - 200
```
**7) Dual IPv4 and IPv6 Protocol Stacks**
```
Switch(config)# sdm prefer dual-ipv4-and-ipv6 default
Switch(config)# ip routing
Switch(config)# ipv6 unicast-routing
Switch(config)# interface gigabitethernet2/0/1
Switch(config-if)# no switchport
Switch(config-if)# ip address 192.168.99.1 244.244.244.0
Switch(config-if)# ipv6 address 2001:0DB8:c18:1::/64 eui 64
Switch(config-if)# end
```
> Учитывая печальное состояние современных компьютерных программ, разработку ПО до сих пор можно считать искусством, а не научной дисциплиной. (Bill Clinton)
*Вот и подошла вторая часть к концу. Кто слушал — молодец. Из написанной статьи я понял одно: для настройки BGP, IS-IS нужно писать отдельные статьи. В целом настройка ipv6 не сильно отличается от ipv4, местами получается даже проще. В третьей части я опишу настройку протоколов на основе оборудования Juniper networks. Она, по сути, будет довольно короткой, поэтому оставляйте свои комментарии под статьей. Повторюсь, ваша критика, вопросы или пожелания могут повлиять на написании новой статьи. Всем удачи.
#### Список используемой литературы
1. CCNA RS
2. CCNP RS
3. IP Version 6 in Junos (EDU-JUN-IPV6)
4. [XGU.RU](http://xgu.ru)
5. [cisco.com](http://Cisco.com)* | https://habr.com/ru/post/254293/ | null | ru | null |
# Программируем под Pebble. Урок второй: Камешек, дающий ответы, игральные кости и секс-кубики
[Часы](http://habrahabr.ru/company/avi/blog/204338/) — это конечно хорошо, но ими забит весь сайт. Надо сделать что-то более интересное.
Помните шарик из «трассы 60»? Давайте сделаем его аналог — приложение, дающее ответ на вопрос.
#### ~~Шарик~~ Камешек дающий ответы
Только у нас будет не шарик, а камешек, то есть Pebble :)
Что нам для этого надо? Список ответов и генератор случайных чисел. Список ответов мы возьмем на [википедии](http://ru.wikipedia.org/wiki/Magic_8_ball). Создадим массив и заполним его ответами:
```
static const char* messages[] = {"Бесспорно", "Это предрешено","Никаких сомнений","Определенно да","Можешь быть уверен в этом","Мне кажется - да","Вероятнее всего","Хорошие перспективы","Да","Знаки говорят - да","Пока не ясно, попробуй еще раз","Спроси позже","Лучше не рассказывать тебе это сейчас","Сейчас нельзя предсказать","Сконцентрируйся и спроси снова","Даже не думай","Мой ответ - нет","Знаки говорят - нет","Перспективы не очень хорошие","Весьма сомнительно","Нет",};
```
Порядок не важен, все равно они будут выбираться из него случайных образом.
Создаем главное окно программы и текстовый слой так же, как и в предыдущем [уроке](http://habrahabr.ru/company/avi/blog/204338/), за исключением небольшой разницы — функцией [window\_set\_fullscreen()](https://developer.getpebble.com/2/api-reference/group___window.html#ga7f3c00a563cc33cda04745f4d93b9f32) мы убираем верхний бар приложения. Вызывается она так:
```
window_set_fullscreen(window, true);
```
Первый агрумент — имя окна, второй, соответственно true — полный экран, false — c баром. Тонкость — эта функция должна вызываться **до** window\_stack\_push, иначе чуда не произойдет.
Теперь займемся генератором случайных чисел. Для этого существует функция [rand()](https://developer.getpebble.com/2/api-reference/group___standard_math.html#ga20e50ab9d6b10af0e2940d9419448f42), которая возвращает при каждом вызове случайное число. Как и любой программный ГСЧ, она нуждается в инициализации случайным числом перед началом работы, иначе строчка цифр будет повторяться при каждом запуске. Делается это функцией srand(). Например в SDK есть пример, где она инициализируется текущим временем. Так как мы не знает, в какое время программа запустится, и это время каждый раз разное — то это достаточный источник энтропии для нашей идеи. Делаем вот так:
```
srand(time(NULL));
```
Правда, генератор теперь может выдать довольно большое число — заведомо больше, чем у нас возможных вариантов ответов. Поэтому, при применяем вот такую конструкцию **messages[rand()%21]** . % — это остаток целочисленного деления. Допустим, генератор возвращает 456, они делятся на 21, а остаток(456-21\*21) — 15 мы используем в качестве номера ответа. Он не может быть больше 21, потому что при этом остаток от деления будет равен нулю.
Объединяем все вышесказанное в одно целое, и у нас получается вот такой вызов функции:
```
text_layer_set_text(text_layer, messages[rand() % 21]);
```
Вот весь исходник:
```
#include "pebble.h"
Window *window; /* Создаем указатель на окно */
TextLayer *text_layer; /* создаем указатель на текстовый слой */
static const char* messages[] = {"Бесспорно", "Это предрешено","Никаких сомнений","Определенно да","Можешь быть уверен в этом","Мне кажется - да","Вероятнее всего","Хорошие перспективы","Да","Знаки говорят - да","Пока не ясно, попробуй еще раз","Спроси позже","Лучше не рассказывать тебе это сейчас","Сейчас нельзя предсказать","Сконцентрируйся и спроси снова","Даже не думай","Мой ответ - нет","Знаки говорят - нет","Перспективы не очень хорошие","Весьма сомнительно","Нет",}; /* Создаем массив ответов */
int main(void)
{
window = window_create(); /* инициализируем окно */
window_set_background_color(window, GColorBlack); /* устанавливаем фоновый цвет */
window_set_fullscreen(window, true); /* включаем полноэкранность */
window_stack_push(window, true); /* открываем окно */
text_layer = text_layer_create(GRect(1, 47, 142, 77)); /* инициализируем текстовый слой */
text_layer_set_text_color(text_layer, GColorWhite); /* устанавливаем цвет текста */
text_layer_set_background_color(text_layer, GColorClear); /* устанавливаем цвет фона */
text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24)); /* устанавливаем шрифт */
text_layer_set_text_alignment(text_layer, GTextAlignmentCenter); /* устанавливаем выравнивание по центру */
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer)); /* подключаем текстовый слой к основному в качестве дочернего */
srand(time(NULL)); /* инициализируем генератор случайных чисел текущем временем */
text_layer_set_text(text_layer, messages[rand() % 21]); /* записываем в текстовый слой случайно выбранный ответ */
app_event_loop(); /* ожидаем чего-нибудь */
text_layer_destroy(text_layer); /* уничтожаем объекты, освобождаем ресурсы */
window_destroy(window); /* уничтожаем объекты, освобождаем ресурсы */
}
```
Программа выводит сообщение при запуске и больше не делает ничего. Для показа другого сообщения надо перезапустить программу:
Следующий шаг — сделаем вывод сообщения при нажатии на кнопку.
В API Pebble применяется термин «подписка» для назначения функций, которые будет запущены не в главном цикле, а после каких-то действий — тика таймера, нажатия кнопки и так далее. Помните, в прошлом уроке мы подписывались на таймер, который раз в секунду вызывал функцию обновления экрана? Тут нечто похожее, мы подписываемся на нажатие кнопки(причем в API уже есть несколько готовых вариантов — [одиночное нажатие](https://developer.getpebble.com/2/api-reference/group___window.html#gae09d8d7299a9d5a750a898a70f64bdec), [двойное нажатие](https://developer.getpebble.com/2/api-reference/group___window.html#ga1ff2467f009b80f8bc97ef197e34d332), [удержание](https://developer.getpebble.com/2/api-reference/group___window.html#ga3329027de707b949f02328492165cf05) и так далее), после нажатия которой будет запущена заданная нами функция.
API говорит о том, что нам надо вызвать метод **window\_set\_click\_config\_provider()**, которая в качестве аргументов примет указатель на окно, в котором надо ловить нажатия, и название функции, в которой будет описаны подписки. Обратите внимание, подписываться на кнопки мы будет не тут, а только в функции, указанной в **window\_set\_click\_config\_provider**. Делается это вот так:
```
window_set_click_config_provider(window, WindowsClickConfigProvider);
```
Указатель окна — window, название функции — WindowsClickConfigProvider. Создаем ее:
```
void WindowsClickConfigProvider(void *context) { }
```
И добавляем внутрь методы [window\_single\_click\_subscribe](https://developer.getpebble.com/2/api-reference/group___window.html#gae09d8d7299a9d5a750a898a70f64bdec), принимающие аргументами название кнопки и функцию, в которую будет передано управление:
```
window_single_click_subscribe(BUTTON_ID_UP, click);
```
В данном случае при нажатии кнопки вверх, мы вызываем click.
Кнопки(их у нас 3) называются соответственно BUTTON\_ID\_UP, BUTTON\_ID\_SELECT, BUTTON\_ID\_DOWN. Подписаться на кнопку «назад» можно, но она всегда будет выбрасывать вас на предыдущий экран(в случае, если у приложения один экран — в меню).
Теперь приложение выглядит вот так:
И его исходник:
```
#include "pebble.h"
Window *window; /* Создаем указатель на окно */
TextLayer *text_layer; /* создаем указатель на текстовый слой */
static const char* messages[] = {"Бесспорно", "Это предрешено","Никаких сомнений","Определенно - да","Будь уверен в этом","Мне кажется - да","Вероятнее всего","Хорошие перспективы","Да","Знаки говорят - да","Пока не ясно, попробуй еще раз","Спроси позже","Лучше не рассказывать тебе это сейчас","Сейчас нельзя предсказать","Сконцентрируйся и спроси снова","Даже не думай","Мой ответ - нет","Знаки говорят - нет","Перспективы не очень хорошие","Весьма сомнительно","Нет",}; /* Создаем массив ответов */
void click(ClickRecognizerRef recognizer, void *context) /* эта функция запустится при клике на кнопку */
{
text_layer_set_text(text_layer, messages[rand() % 21]); /* записываем в текстовый слой случайно выбранный ответ */
}
void WindowsClickConfigProvider(void *context) /* функция, внутри которой должны находиться подписки на кнопки */
{
window_single_click_subscribe(BUTTON_ID_UP, click); /* при нажатии на верхнюю кнопку запустить click */
window_single_click_subscribe(BUTTON_ID_SELECT, click);
window_single_click_subscribe(BUTTON_ID_DOWN, click);
}
int main(void)
{
window = window_create(); /* Инициализируем окно */
window_set_background_color(window, GColorBlack); /* устанавливаем фоновый цвет */
window_set_fullscreen(window, true); /* включаем полноэкранность */
window_stack_push(window, true); /* открываем окно */
text_layer = text_layer_create(GRect(0, 7, 144, 168)); /* инициализируем текстовый слой */
text_layer_set_text_color(text_layer, GColorWhite); /* устанавливаем цвет текста */
text_layer_set_background_color(text_layer, GColorClear); /* устанавливаем цвет фона */
text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24)); /* устанавливаем шрифт */
text_layer_set_text_alignment(text_layer, GTextAlignmentCenter); /* устанавливаем выравнивание по центру */
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer)); /* подключаем текстовый слой к основному в качестве дочернего */
srand(time(NULL)); /* инициализируем генератор случайных чисел текущем временем */
window_set_click_config_provider(window, WindowsClickConfigProvider); /* определяем функцию, в которой будут находиться подписки на кнопки */
text_layer_set_text(text_layer, "Magic Pebble \n Задай вопрос, на который можно ответить \"да\" или \"нет\" и нажми на кнопку"); /* Выводим сообщение при запуске */
app_event_loop(); /* ждем событий */
text_layer_destroy(text_layer); /* уничтожаем объекты, освобождаем ресурсы */
window_destroy(window); /* уничтожаем объекты, освобождаем ресурсы */
}
```
Работает! Можно присваивать версию 0.1 :)
Но чего-то не хватает. Хорошо бы добавить каких-нибудь эффектов. Можно сделать анимацию изменения ответов, чтобы часы отвечали не сразу при нажатии на кнопку, а несколько секунд «перебирали» варианты. В кавычках — потому что ответ будет случайным в любом случае, но в первом случае у пользователя будет больше доверия к приложению — все мы знакомы с случайным процессом выбора карточек из мешка или шаров с цифрами при игре в лотерею.
Еще более красиво будет, если мы добавим немного физики. Дело в том, что люди, сами того не подозревая, окружены процессами протекающими по обратной экспоненте — когда процессы «быстрые» в самом начале, проходят не линейно, а теряя скорость тем сильнее, чем больше времени прошло с начала.
Это может быть что угодно — например, остывание горячего чая на столе. Когда разница температур чая и окружающего воздуха велика, он остывает гораздо быстрее, чем когда он чуть теплый. Или пузырьки в стакане с газированной водой. Сначала, когда концентрация угольной кислоты в воде велика, она разлагается очень активно, но через некоторое время концентрация уменьшается, а вместе с ней уменьшается и количество пузырьков.
В данном случае я бы хотел сделать что-то вроде колеса фортуны — там, где сначала сегменты сменяют друг друга быстро, постепенно замедляясь. Тут «виновато» трение — чем больше скорость, тем больше колесо трется об ось и тем больше теряет энергию, переводя ее в тепло и замедляясь. Но при уменьшении скорости уменьшаются потери и на трение — в итоге 50% своей скорости колесо теряет в первые 20% времени, а остальные 50% — за оставшиеся 70%.
Отсчитывать время мы будем в миллисекундах между сменами сообщений. Путем опытов, было выяснено, что хороший диапазон значений — от 0 до 300-400мс. Если промежутки больше — возникает ощущение, что уже показанный ответ внезапно поменялся.
Наиболее простая функция, которая обеспечит такое поведение — это что-то типа x=x\*2. Но при умножении на 2 график функции поднимается слишком резко, каждую итерацию время задержки увеличивается в два раза. Мы получим 256(максимальную задержку, поскольку следующее значение — 512 уже выходит за границы удобства) уже на 8 шаге с длительностью работы всего в 1+2+4+8+16+32+64+128+256=511мс. Пол-секунды это слишком быстро.
Опытным путем я понял, что множитель должен быть в районе 1.08-1.2, тогда мы получаем около 30 шагов и длительность около 3 секунд. Но мне не нравится функция x=x\*y — она слишком полого поднимается, и мелькание замедляется слишком медленно(да, я странный), хотелось бы, чтобы оно дольше мелькало «быстро», а потом резко остановилось.
Можно было поступить проще — забить значение задержек в массив и ~~втирать~~ править, править их до удовлетворения, благо их не так и много — штук 40. Но гораздо интереснее вывести функцию, которая бы работала нужным нам образом. Раз умножение нам не подходит, попробуем деление. Что-то вроде x=x/0.7. Но сама по себе она слишком резко возрастает — 300 мы получаем уже на 18 шаге, а хотелось бы чуть больше. Но можно разделить например, на 100. Или на 1000. Построим графики всех функций при начальном значении 1. Цифры над графиками — количество шагов.
Вот, значит нам вполне подходит y=y/0.7 x=y/100, можно делать.
Но для начала — исправим один глюк: т.к. информация при запуске и сообщения выводятся у нас в одном и том же слое, то сообщения показываются в верхней части экрана(выравнивания по вертикали, к сожалению, нет). Да еще и мелким шрифтом, хотя их можно сделать и больше — они гораздо короче и поместятся в экран. Я не нашел в API методов изменения размеров слоя, поэтому нам придется удалить слой и создать его опять, но с другими координатами. Однако, при этом получится некрасиво — часть кода будет дублироваться(настройки слоя после его создания), чтобы этого не происходило — вынесем часть кода в отдельную функцию.
Создаем:
```
void config_text_layer(int16_t x,int16_t y,int16_t h,int16_t w, const char *font_key) {
}
```
Первые 4 параметра — это информация о слое — координаты точки и размеры, пятый параметр — это шрифт. Соответственно, перепишем функции инициализации для использования этих переменных:
```
text_layer = text_layer_create(GRect(x, y, h, w));
text_layer_set_font(text_layer, fonts_get_system_font(font_key));
```
И вставим их в нашу функцию вместе с остальным кодом настройки слоя. Теперь можно просто сделать в нужном месте вот так:
```
text_layer_destroy(text_layer);
config_text_layer(5, 40, 134, 120, FONT_KEY_GOTHIC_28);
```
Так и сделаем в функции click, которая вызывается у нас при нажатии кнопки. Да, слой будет создаваться каждый раз при нажатии кнопки, избежать этого можно простой проверкой, что-то типа:
```
bool first_time=true;
if (first_time == true)
{
text_layer_destroy(text_layer);
config_text_layer(5, 40, 134, 120, FONT_KEY_GOTHIC_28);
first_time = false;
}
```
Но я не стал заморачиваться. Лучше займемся таймером. Поиск в API дал функцию [app\_timer\_register()](https://developer.getpebble.com/2/api-reference/group___timer.html#gac6c8b77f2d03fa1dc39eb60f5e88d5e0), которая принимает в качестве аргументов значение в мс, через которое сработает таймер, имя функции, которую надо вызвать при его срабатывании и указатель на данные, которые надо передать в эту функцию. К сожалению, как работать с указателем я не разобрался, так что придется плюнуть на красоту кода и сделать через глобальную переменную:
```
float timer_delay=1;
```
Создаем функцию, которая будет рекурсивно вызывать таймер со все возрастающими интервалами.
```
void timer_call() /* эта функция вызывается при срабатываниии таймера */
{
text_layer_set_text(text_layer, messages[rand() % 21]); /* выводим случайное сообщение */
if (timer_delay < 300*100 ) /* если задержка еще не достигла 300мс... */
{
timer_delay=timer_delay/0.7; /* ...увеличиваем задержку... */
app_timer_register(timer_delay/100, timer_call, NULL); /* ...и взводим таймер заново */
}
else /* если задержка уже больше 300мс... */
{
timer_delay=1; /* сбрасываем таймер на начало и выходим - сообщение же уже вывели */
}
}
```
Центром функции является переменная с плавающей точкой timer\_delay. Она делится на 0.7, пока не достигнет 30000. Каждое новое значение переменной делится на 100 и отдается в качестве аргумента задержки функции app\_timer\_register, которая при срабатывании опять вызовет эту функцию.
Осталось только добавить вызов этой функции в **click()**:
```
void click(ClickRecognizerRef recognizer, void *context) /* функция, срабатывающая при клике на кнопки */
{
text_layer_destroy(text_layer); /* очищаем и удаляем старый слой */
config_text_layer(5, 40, 134, 120, FONT_KEY_GOTHIC_28); /* создаем новый слой с другими координатами и шрифтом */
timer_call(); /* взводим таймер для быстрой смены сообщений */
}
```
И можно наслаждаться результатом:
Если немного подумать, что у нас получилось, то окажется, что мы создали платформу для симуляции любых штук, которые используются в реальном мире как ГСЧ. Сложное движение многогранной фигуры в жидкости внутри шарика — процесс, не поддающийся предсказанию. Так же как и игральные кости. Кстати, игральные кости! Чем не вариант для еще одного приложения?
Я действительно полез искать рисунки на гранях костей и наткнулся на… нет, ну это тоже рисунки. И тоже на игральных костях. Только не точечками. В общем, я наткнулся вот на это:
И все. Какие там игральные кости, когда тут есть такая замечательная идея. Пошли реализовывать!
#### Секс-рулетка
Логика работы программы остается прежней. Меняем массив messages:
```
static const char* messages[] = {"В ванной","На кухне","На полу","На кровати","В туалете","В коридоре","В гостях","На балконе","В шкафу","В ванной","В лифте","На улице","В машине","В воде","В общественном туалете","При свечах","В спальне","В гостиной","В примерочной кабинке","В кинотеатре","Перед камерой","На пляже","В чужом доме",};
```
И сообщение при запуске:
```
text_layer_set_text(text_layer, "Sex Roulette \n Нажми на любую кнопку, чтобы выбрать позу и место -->");
```
Создаем в памяти, на которую указывает указатель графический массив, указывая координаты. Синтаксис абсолютно такой же, как и в text\_layer\_create:
```
image_layer = bitmap_layer_create(GRect(0 , 0, 144, 144));
```
Делаем созданный слой ребенком слоя главного окна. Зачем это нужно? Это настраивает «высоту»(в терминах css, если кому понятнее — z-index) слоя по отношению к другим слоям, от этого зависит то, как слои будут друг друга перекрывать. Все дети находятся выше всего родителя и закрывают его своим выводом.
```
layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(image_layer));
```
Настраиваем режим наложения. В зависимости от этого параметра картинка будет по разному взаимодействовать с фоном.
```
bitmap_layer_set_compositing_mode(image_layer, GCompOpAssignInverted);
```
Все варианты можно описаны [тут](http://=https://developer.getpebble.com/2/api-reference/group___graphics_types.html#ga0d021422bd90a2a49e6c8d848e6d556f), или можно повтыкать в картинку:
Source — это в данном случае графический слой, а Destination — его родитель, главный слой окна. Как все просто и замечательно укладывается в 6 вариантов при работе с монохромными картинками…
Теперь займемся выводом рандомных картинок. Поищем в гугле подходящие картинки(двухцветные и маленькие) по какому-нибудь запросу типа "[иконки позы](https://www.google.ru/search?q=%D0%B8%D0%BA%D0%BE%D0%BD%D0%BA%D0%B8+%D0%BF%D0%BE%D0%B7%D1%8B&espv=210&es_sm=91&source=lnms&tbm=isch&sa=X&ei=76GfUvT0JMHx4QSPoIHACA&ved=0CAcQ_AUoAQ&biw=1916&bih=942)".
На [этом](http://ivan-off.com/vektornyj-klipart/1112-vektornye-ikonki-kamasutry.html) сайте нашлось вот такое:
Скачиваем вектор, удаляем всякие границы, экспортируем в PNG разрешением повыше, открываем в каком-нибудь графическом редакторе.
Выделяем каждую картинку, удаляем неудачные и непонятные, вписываем ее в квадрат, уменьшаем до 144 пикселей, подчищаем недостатки. Итогом нашей работы должна стать папка с картинками:
Из одной из картинок делаем логотип для меню, размером 24x28 пикселей:
->
Открываем файл appinfo.json в папке с проектом и добавляем в него наши созданные ресурсы. К сожалению, не могу рассказать как это делается в CloudPebble — она внезапно перестала у меня работать, не принимая пароль и зажав исходники всех моих проектов. Так что я поставил себе среду разработки на компьютер по [инструкции](https://developer.getpebble.com/2/getting-started/macosx/) с официального сайта, и пишу там.
Так вот, о appinfo.json. Он выглядит вот так:
```
{
"uuid": "0f7b8336-d72d-4806-9191-566ffd8f3a8c",
"shortName": "SexRoulette",
"longName": "SexRoulette",
"companyName": "vvzvlad",
"versionCode": 1,
"versionLabel": "1.0.0",
"watchapp": {
"watchface": false
},
"appKeys": {
"dummy": 0
},
"resources": {
"media": [
{
"menuIcon": true,
"type": "png",
"name": "DEFAULT_MENU_ICON",
"file": "img/logo.png"
},
{
"type": "png",
"name": "POSE_1",
"file": "img/1.png"
},
```
В начале идут знакомые вам поля, смысл которых понятен и без объяснений, а дальше в нем описываются все 32 картинки. Обратите внимание, структура должна быть именно вот такая:
```
{
"type": "png",
"name": "Первая картиника",
"file": "img/1.png"
},
{
"type": "png",
"name": "Последняя картиника",
"file": "img/1.png"
}
```
После последней скобки не должно быть запятой, как и после указания адреса файла. А поля должны следовать именно в порядке type, name, file.
Что, блин, идет вразрез с [официальной документацией](https://developer.getpebble.com/2/api-reference/group___resources.html):
~~Клавиатуру в жопу запихать!~~ Посылаю лучики поноса тем, кто писал эту документацию, я полчаса тупил и гадал, на что же он ругается. Еще и ругается так невнятно, что толком не поймешь, что его не устраивает:
```
Traceback (most recent call last):
File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/Pebble/.waf-1.7.11-478a7e7e9ed077304a8092741524bf8b/waflib/Scripting.py", line 351, in execute
return execute_method(self)
File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/Pebble/.waf-1.7.11-478a7e7e9ed077304a8092741524bf8b/waflib/Build.py", line 106, in execute
self.execute_build()
File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/Pebble/.waf-1.7.11-478a7e7e9ed077304a8092741524bf8b/waflib/Build.py", line 109, in execute_build
self.recurse([self.run_dir])
File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/Pebble/.waf-1.7.11-478a7e7e9ed077304a8092741524bf8b/waflib/Context.py", line 128, in recurse
user_function(self)
File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/SexRoulette/wscript", line 18, in build
ctx.load('pebble_sdk')
```
Ну ладно, хрен с ним. Как вы уже поняли, картинка-иконка для меню помечается полем **«menuIcon»: true**, причем к ней тоже можно обращаться из программы.
Вернемся к нашим картинкам. Документация предлагает загружать картинку вот так:
```
image = gbitmap_create_with_resource(RESOURCE_ID_POSE_1);
```
Что для нас не подходит. Не городить же монструозную конструкцию вида
```
select rand() % 31
case 1
image = gbitmap_create_with_resource(RESOURCE_ID_POSE_1);
case 2
image = gbitmap_create_with_resource(RESOURCE_ID_POSE_2);
```
Это некрасиво. Из документации мы понимаем, что RESOURCE\_ID\_POSE\_2 — это всего лишь переменная типа uint32\_t в которой хранится номер ресурса.
Создаем массив нужного нам типа:
```
static const uint32_t images[]
```
И перечисляем в нем нужные нам ресурсы:
```
static const uint32_t images[] = {RESOURCE_ID_POSE_1,RESOURCE_ID_POSE_2,RESOURCE_ID_POSE_3,RESOURCE_ID_POSE_4,RESOURCE_ID_POSE_5,RESOURCE_ID_POSE_6,RESOURCE_ID_POSE_7,RESOURCE_ID_POSE_8,RESOURCE_ID_POSE_9,RESOURCE_ID_POSE_10,RESOURCE_ID_POSE_11,RESOURCE_ID_POSE_12,RESOURCE_ID_POSE_13,RESOURCE_ID_POSE_14,RESOURCE_ID_POSE_15,RESOURCE_ID_POSE_16,RESOURCE_ID_POSE_17,RESOURCE_ID_POSE_18,RESOURCE_ID_POSE_19,RESOURCE_ID_POSE_20,RESOURCE_ID_POSE_21,RESOURCE_ID_POSE_22,RESOURCE_ID_POSE_23,RESOURCE_ID_POSE_24,RESOURCE_ID_POSE_25,RESOURCE_ID_POSE_26,RESOURCE_ID_POSE_27,RESOURCE_ID_POSE_28,RESOURCE_ID_POSE_29,RESOURCE_ID_POSE_30,RESOURCE_ID_POSE_31,RESOURCE_ID_POSE_32,};
```
Теперь мы можем вызвать случайную картинку так же, как и текст:
```
image = gbitmap_create_with_resource(images[rand() % 31]);
```
Мы вызвали картинку из ~~небытия~~ из флеш-памяти и разместили ее в оперативке. Теперь надо передать указатель на место хранение изображения функции bitmap\_layer\_set\_bitmap, которая и отобразит ее на нужном нам графическом слое.
Делается это вот так:
```
bitmap_layer_set_bitmap(image_layer, image);
```
**image\_layer** — это указатель на кусок памяти графического слоя, а **image** — указатель на картинку в памяти.
Вроде все. Запускаем!
Часы зависли, потом перезагрузились, а после второго запуска ушли в Recovery и попросили перепрошиться.
Правильно, мы, загружая в каждом цикле картинку в память, не выгрузили ее оттуда. Забили оперативку, и залезли куда-то еще, судя по тому, что часы отказались загружаться.
Это ~~spaaarta!~~ embeeeeedded! Тут такое не прощают.
Делаем правильно. Сначала очищаем память, а потом загружаем в нее новую картинку для показа.
```
gbitmap_destroy(image);
image = gbitmap_create_with_resource(images[rand() % 31]);
bitmap_layer_set_bitmap(image_layer, image);
```
Но при самом первом клике у нас в указателе image ничего нет, и gbitmap\_destroy обязательно это обнаружит. App Crashed…
Можно во время инициализации программы подсунуть ему туда картинку, чтобы было что удалять, но это как-то некрасиво. Похоже, без флага первого запуска нам все-таки не обойтись. Создаем переменную:
```
bool first_time=true;
```
Сбрасываем ее при первом запуске функции, вызываемой таймером:
```
void timer_call() {
first_time = false;
```
И оборачиваем **gbitmap\_destroy** — в проверку на first\_time == false, а **text\_layer\_destroy** и **config\_text\_layer** в функции click — соответственно, в проверку на first\_time == true:
```
void timer_call() {
if (first_time == false) {
gbitmap_destroy(image);
bitmap_layer_destroy(image_layer);
}
first_time = false;
.....
void click(ClickRecognizerRef recognizer, void *context) {
if (first_time == true) {
text_layer_destroy(text_layer);
config_text_layer(0, 146, 144, 168-146, FONT_KEY_GOTHIC_18); }
```
Работает!
Нет, стоп. Посмотрим внимательно на последние строчки нашей программы:
```
text_layer_destroy(text_layer);
window_destroy(window);
gbitmap_destroy(image);
bitmap_layer_destroy(image_layer);
```
В числе прочих мы уничтожаем gbitmap. Но если мы запустим программу и тут же выйдем, он не будет создан! Уничтожать нам еще нечего, и при выполнении этой функции программа упадает и потянет за собой лаунчер — часы перезагрузятся. А это нехорошо. Раз уж у нас есть флаг первого включения — можно использовать его, проверяя перед уничтожением ресурсов:
```
if (first_time == false)
{
gbitmap_destroy(image);
}
```
Вот теперь точно все.
**Полный исходник программы**
```
#include "pebble.h"
float timer_delay=1; /* Создаем переменную для с временем для таймера */
Window *window; /* Создаем указатель на окно */
TextLayer *text_layer; /* создаем указатель на текстовый слой */
static BitmapLayer *image_layer; /* создаем указатель на графический слой */
static GBitmap *image; /* создаем указатель на изображение в памяти */
bool first_time=true; /* создаем флаг первого запуска */
static const char* messages[] = {"В ванной","На кухне","На полу","На кровати","В туалете","В коридоре","В гостях","На балконе","В шкафу","В ванной","В лифте","На улице","В машине","В воде","В общественном туалете","При свечах","В спальне","В гостиной","В примерочной кабинке","В кинотеатре","Перед камерой","На пляже","В чужом доме",}; /* Создаем массив ответов */
static const uint32_t images[] = {RESOURCE_ID_POSE_1,RESOURCE_ID_POSE_2,RESOURCE_ID_POSE_3,RESOURCE_ID_POSE_4,RESOURCE_ID_POSE_5,RESOURCE_ID_POSE_6,RESOURCE_ID_POSE_7,RESOURCE_ID_POSE_8,RESOURCE_ID_POSE_9,RESOURCE_ID_POSE_10,RESOURCE_ID_POSE_11,RESOURCE_ID_POSE_12,RESOURCE_ID_POSE_13,RESOURCE_ID_POSE_14,RESOURCE_ID_POSE_15,RESOURCE_ID_POSE_16,RESOURCE_ID_POSE_17,RESOURCE_ID_POSE_18,RESOURCE_ID_POSE_19,RESOURCE_ID_POSE_20,RESOURCE_ID_POSE_21,RESOURCE_ID_POSE_22,RESOURCE_ID_POSE_23,RESOURCE_ID_POSE_24,RESOURCE_ID_POSE_25,RESOURCE_ID_POSE_26,RESOURCE_ID_POSE_27,RESOURCE_ID_POSE_28,RESOURCE_ID_POSE_29,RESOURCE_ID_POSE_30,RESOURCE_ID_POSE_31,RESOURCE_ID_POSE_32,}; /* Создаем массив идентификаторов ресурсов */
void timer_call() /* эта функция вызывается при срабатывании таймера */
{
if (first_time == false) /* если запускается не в первый раз... */
{
bitmap_layer_destroy(image_layer); /* ...то удаляем старый слой... */
gbitmap_destroy(image); /* ..и очищаем память от предыдущей картинки */
}
first_time = false; /* сбрасываем флаг первого запуска */
image = gbitmap_create_with_resource(images[rand() % 31]); /* загружаем в память случайную картинку из подключенных ресурсов */
bitmap_layer_set_bitmap(image_layer, image); /* выводим загруженную картинку в слой */
text_layer_set_text(text_layer, messages[rand() % 23]); /* выводим случайное сообщение */
if (timer_delay < 300*100 ) /* если задержка еще не достигла 300мс... */
{
timer_delay=timer_delay/0.7; /* ...увеличиваем задержку... */
app_timer_register(timer_delay/100, timer_call, NULL); /* ...и взводим таймер заново */
}
else /* если задержка уже больше 300мс... */
{
timer_delay=1; /* сбрасываем таймер на начало и выходим - сообщение и картинку мы же уже показали */
}
}
void config_text_layer(int16_t x,int16_t y,int16_t h,int16_t w, const char *font_key) /* для исключения дублирования кода, создали функцию, которая занимается инициализаций и настройкой текстового массива*/
{
text_layer = text_layer_create(GRect(x, y, h, w)); /* создаем текстовый массив, указываем размер и координаты */
text_layer_set_text_color(text_layer, GColorWhite); /* устанавливаем цвет текста */
text_layer_set_background_color(text_layer, GColorClear); /* устанавливаем цвет фона */
text_layer_set_font(text_layer, fonts_get_system_font(font_key)); /* устанавливаем шрифт */
text_layer_set_text_alignment(text_layer, GTextAlignmentCenter); /* устанавливаем выравнивание по центру */
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer)); /* подключаем текстовый слой к основному в качестве дочернего */
}
void click(ClickRecognizerRef recognizer, void *context) /* функция, срабатывающая при клике на кнопки */
{
if (first_time == true) /* если программа запускается в первый раз... */
{
text_layer_destroy(text_layer); /* ... то очищаем и удаляем приветствия... */
config_text_layer(0, 146, 144, 168-146, FONT_KEY_GOTHIC_18); /* ... и создаем новый слой сообщений с другими координатами и шрифтом */
}
timer_call(); /* взводим таймер для быстрой смены сообщений */
}
void WindowsClickConfigProvider(void *context) /* функция, внутри которой должны находиться подписки на кнопки */
{
window_single_click_subscribe(BUTTON_ID_UP, click); /* при нажатии на верхнюю кнопку запустить click */
window_single_click_subscribe(BUTTON_ID_SELECT, click);
window_single_click_subscribe(BUTTON_ID_DOWN, click);
}
int main(void)
{
window = window_create(); /* Инициализируем окно */
window_set_background_color(window, GColorBlack); /* устанавливаем фоновый цвет */
window_set_fullscreen(window, true); /* включаем полный экран */
window_stack_push(window, true); /* открываем окно */
srand(time(NULL)); /* инициализируем генератор случайных чисел текущем временем */
window_set_click_config_provider(window, WindowsClickConfigProvider); /* определяем функцию, в которой будут находиться подписки на кнопки */
config_text_layer(0, 20, 144, 168, FONT_KEY_GOTHIC_24); /* настраиваем создание текстового слоя с приветственным сообщением */
text_layer_set_text(text_layer, "Sex Roulette \n Нажми на любую кнопку, чтобы выбрать позу и место -->"); /* показываем сообщение при запуске */
image_layer = bitmap_layer_create(GRect(0 , 0, 144, 144)); /* создаем графический массив, указываем размер и координаты */
layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(image_layer)); /* подключаем графический слой к основному в качестве дочернего */
bitmap_layer_set_compositing_mode(image_layer, GCompOpAssignInverted); /* настраиваем параметр наложения */
app_event_loop(); /* ждем событий */
text_layer_destroy(text_layer); /* уничтожаем текстовый слой, освобождаем ресурсы */
window_destroy(window); /* уничтожаем главное окно, освобождаем ресурсы */
bitmap_layer_destroy(image_layer); /* уничтожаем графический слой, освобождаем ресурсы */
if (first_time == false) /* если мы выходим после запуска рисования... */
{
gbitmap_destroy(image); /* то уничтожаем массив с графикой, освобождаем ресурсы, иначе - не уничтожаем, т.к. он еще не создан */
}
}
```
А игральные кости?! Придется сделать.
#### Игральные кости
Берем за основу предыдущую программу. Картинки мы возьмем из [википедии](http://ru.wikipedia.org/wiki/%D0%98%D0%B3%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BA%D0%BE%D1%81%D1%82%D1%8C). Уменьшим их до размера 75х75 пикселей и сделаем иконку:
Подключим их в appinfo.json, так же как и в предыдущем примере, и опишем их в массиве images:
```
static const uint32_t images[] = {RESOURCE_ID_DICE_1,RESOURCE_ID_DICE_2,RESOURCE_ID_DICE_3,RESOURCE_ID_DICE_4,RESOURCE_ID_DICE_5,RESOURCE_ID_DICE_6,};
```
Удалим из программы обработку нажатий: **WindowsClickConfigProvider** и **click**. Это же кубики, их надо трясти! Будем использовать акселерометр.
Подписываемся на события от акселерометра:
```
accel_tap_service_subscribe(accel_int);
```
Создаем функцию, которая будет вызываться при встряхивании часов:
```
void accel_int(AccelAxisType axis, int32_t direction)
{
if (first_time == true)
{
text_layer_destroy(text_layer);
}
timer_call();
}
```
Логика ее работы проста: если у нас на экране еще есть текстовый слой(мы встряхиваем часы в первый раз после запуска) — удаляем его. Если нет — то не удаляем :) И в любом случае запускаем перебор.
Теперь изменяем функцию **timer\_call**. Картинка у нас меньше экрана(я пробовал делать картинку кубика такой же, как в прошлом разе — 144х144, но смотрелось это не очень), поэтому нам ее надо двигать по экрану. Двигать мы будем простым способом — удаляя и создавая новую в случайном месте. Используем для этого мы опять любимую функцию **rand**. У нас есть картинка 75х75 пикселей и экран 144х168. Так как мы указываем при создании слоя его верхний левый угол, то, чтобы картинка не попала за край экрана, нам надо указать его в диапазоне 0...69(144-75) для х-координаты, и 0...93(168-75) для y-координаты. Делаем это вот так: **rand()%(144-75)** и **rand()%(168-75)**. В итоге создание слоя выглядит вот так:
```
image_layer = bitmap_layer_create(GRect(rand()%(144-75), rand()%(168-75), 75, 75));
```
Еще меняем способ расчета задержки:
```
if (timer_delay < 300*1000 )
{
timer_delay=timer_delay/0.7;
app_timer_register(timer_delay/1000, timer_call, NULL);
}
```
Если в прошлом варианте у нас был множитель 100, то в этом — 1000. Это опять же сделано из соображений эстетики. Как мы видим из графика, такой множитель почти не изменяет скорость возрастая функции, но добавляет немного шагов. Дело в том, что во время движения рукой — начало смены картинок плохо видно, и чтобы увидеть то, ради чего затевалась эпопея с таймером — красивую смену картинок, надо немного продлить работу функции.
Дальше все так же, как и в предыдущем примере. Вот только небольшая проблема: так как мы не нажимаем кнопку, подсветка не загорается. Хорошо бы ее зажечь после движения. Смотрим, что нам предоставляет [API](https://developer.getpebble.com/2/api-reference/group___light.html) для этого:
```
light_enable(bool enable)
light_enable_interaction()
```
Не густо. Но нам хватит. Первая функция может зажечь или погасить подсветку постоянно: l**ight\_enable(true)** или **light\_enable(false)**, а вторая — зажигает подсветку, и она сама гасится через некоторое время(как при нажатии на кнопку). Чтобы не городить отдельный таймер для отключения подсветки(мы же не хотим, чтобы она горела постоянно при работе программы?), воспользуемся вторым вариантом. Поместим его куда-нибудь в конец **timer\_call**.
До кучи — в **main** поправим сообщение на начальном экране:
```
text_layer_set_text(text_layer, "Встряхните часы для броска костей");
```
И при выходе из программы поменяем логику удалениия ресурсов и добавим отписку от акселерометра:
```
if (first_time == true)
{
text_layer_destroy(text_layer);
}
else
{
bitmap_layer_destroy(image_layer);
gbitmap_destroy(image);
}
accel_tap_service_unsubscribe();
```
Тут мы делаем вот что. Если выходим сразу после запуску — с начального экрана, то нам надо удалить только текстовый слой. Если мы выходим уже после запуска — после того, как часы потрясли — то нам надо удалить графический слой и память под картинку, а текстовый слой не надо — он уже удален при срабатывании таймера в функции **accel\_int**
**В итоге код приобретает следующий вид**
```
#include "pebble.h"
float timer_delay=1; /* Создаем переменную для с временем для таймера */
Window *window; /* Создаем указатель на окно */
TextLayer *text_layer; /* создаем указатель на текстовый слой */
static BitmapLayer *image_layer; /* создаем указатель на графический слой */
static GBitmap *image; /* создаем указатель на изображение в памяти */
bool first_time=true; /* создаем флаг первого запуска */
static const uint32_t images[] = {RESOURCE_ID_DICE_1,RESOURCE_ID_DICE_2,RESOURCE_ID_DICE_3,RESOURCE_ID_DICE_4,RESOURCE_ID_DICE_5,RESOURCE_ID_DICE_6,}; /* создаем массив с номерами картинок */
void timer_call() /* эта функция вызывается при срабатываниии таймера и при первом запуске перебора */
{
if (first_time == false)/* если запускается не в первый раз... */
{
bitmap_layer_destroy(image_layer); /* ...то удаляем старый слой, чтобы он не мешался позади... */
gbitmap_destroy(image); /* ...и очищаем память от предыдущей картинки */
}
first_time = false; /* сбрасываем флаг первого запуска */
image_layer = bitmap_layer_create(GRect(rand()%(144-75), rand()%(168-75), 75, 75)); /* создаем слой со случайными координатами, но в пределах экрана */
layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(image_layer)); /* делаем его дочерним */
image = gbitmap_create_with_resource(images[rand() % 6]); /* загружаем в память случайную картинку из подключенных ресурсов */
bitmap_layer_set_bitmap(image_layer, image); /* выводим загруженную картинку в слой */
light_enable_interaction(); /* включаем подсветку */
if (timer_delay < 300*1000 ) /* если задержка еще не достигла 300мс... */
{
timer_delay=timer_delay/0.7; /* ...увеличиваем задержку... */
app_timer_register(timer_delay/1000, timer_call, NULL); /* ...и взводим таймер заново */
}
else /* если задержка уже больше 300мс... */
{
timer_delay=1; /* сбрасываем таймер на начало и выходим - сообщение и картинку мы же уже показали */
}
}
void accel_int(AccelAxisType axis, int32_t direction) /* при поступлении прерывания от акселерометра... */
{
if (first_time == true) /* если это первый запуск... */
{
text_layer_destroy(text_layer); /* ...то удаляем текстовый слой с информацией */
}
timer_call(); /* запускаем перебор */
}
int main(void)
{
window = window_create(); /* Инициализируем окно */
window_set_background_color(window, GColorBlack); /* устанавливаем фоновый цвет */
window_set_fullscreen(window, true); /* включаем полноэкранность */
window_stack_push(window, true); /* открываем окно с анимацией */
srand(time(NULL)); /* инициализируем генератор случайных чисел текущем временем */
text_layer = text_layer_create(GRect(0 , 30, 144, 168)); /* создаем текстовый массив, указываем размер и координаты */
text_layer_set_text_color(text_layer, GColorWhite); /* устанавливаем цвет текста */
text_layer_set_background_color(text_layer, GColorClear); /* устанавливаем цвет фона */
text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28)); /* устанавливаем шрифт */
text_layer_set_text_alignment(text_layer, GTextAlignmentCenter); /* устанавливаем выравнивание по центру */
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer)); /* подключаем текстовый слой к основному в качестве дочернего */
text_layer_set_text(text_layer, "Встряхните часы для броска костей"); /* показываем сообщение при запуске */
accel_tap_service_subscribe(accel_int); /* подписываемся на прерывания от акселерометра */
app_event_loop(); /* ждем событий */
if (first_time == true) /* если выходим без запуска перебора... */
{
text_layer_destroy(text_layer); /* ...то удаляем текстовый слой с сообщением */
}
else /* если выходим уже после запуска... */
{
bitmap_layer_destroy(image_layer); /* ...то уничтожаем текстовый слой... */
gbitmap_destroy(image); /* ... и уничтожаем массив с графикой, текстовый слой уже удален в функции accel_int */
}
accel_tap_service_unsubscribe(); /* отписываемся от прерываний акселерометра */
window_destroy(window); /* уничтожаем главное окно, освобождаем ресурсы */
}
```
Работает!
Видео, в котором показана работа всех программ:
#### Ссылки
 [Скачать приложение MagicPebble с сайта mypebblefaces.com](http://www.mypebblefaces.com/apps/12451/7999/)
 [Скачать приложение Секс-рулетка с сайта mypebblefaces.com](http://www.mypebblefaces.com/apps/12451/8000/)
 [Скачать приложение Игральные кости с сайта mypebblefaces.com](http://www.mypebblefaces.com/apps/12451/8001/)
 [Исходники приложения MagicPebble на github.com](https://github.com/vvzvlad/Pebble-MagicPebble)
 [Исходники приложения Секс-рулетка на github.com](https://github.com/vvzvlad/Pebble-SexRoulette)
 [Исходники приложения Игральные кости на github.com](https://github.com/vvzvlad/Pebble-Dice)
 [Магазин, в котором я покупал Pebble](http://madrobots.ru/catalog/23/53/) Пожалуйста, не сритесь насчет цены. Это и так одна из самых низких цен у нас в наличии(забейте в гугле «купить pebble в москве»). Я же не заставляю вас там покупать, кто хочет — может заказывать с официального сайта.
[](https://twitter.com/MadrobotsRu)[](http://vk.com/madrobots)[](http://instagram.com/madrobotsru)[](http://facebook.com/madrobotsrussia)
[](http://madrobots.ru) | https://habr.com/ru/post/204514/ | null | ru | null |
# 3D Secure, или что скрывают механизмы безопасности онлайн-платежей
Электронная коммерция — одна из самых больших и быстро растущих областей, в связи с чем она привлекает внимание как исследователей информационной безопасности, так и злоумышленников. Поэтому хотелось бы разобраться в некоторых аспектах механизмов безопасности, применяемых при проведении онлайн-платежей.
Один из протоколов, используемых для увеличения безопасности онлайн-платежей — 3D Secure. Это протокол, который был разработан на основе XML в качестве дополнительного уровня безопасности платежей, проводящихся без физического участия карты (card not present payment). VISA создала первую версию этого протокола, но вскоре его начали использовать и другие компании (Master Card, JCB International, AmEx, Мир), впоследствии объединившиеся с VISA в содружество EMV. EMV занимается поддержкой и развитием протокола 3DS.
**Почему протокол 3D Secure называется именно так?**
Полное название этого протокола — Three Domain Secure.
Первый домен — **домен эмитента** — это банк, выпустивший используемую карту.
Второй домен — **домен эквайера** — это банк и продавец, которому выплачиваются деньги.
Третий домен — **домен совместимости** (interoperability domain) — инфраструктура, используемая при оплате картой (кредитной, дебетовой, предоплаченной или другими типами платежных карт) для поддержки протокола 3D Secure. Он включает в себя Интернет, подключаемый модуль продавца (merchant plug-in), сервер контроля доступа (access control server) и других поставщиков программного обеспечения.
**Зачем это нужно?**
3D Secure обеспечивает новый уровень безопасности путем предоставления дополнительной информации.
Еще одним важным моментом является «перенос ответственности». Это означает, что в случае мошенничества вся ответственность ложится на банк-эмитент. Этот момент является очень важным для продавца (мерчанта), т.к. до появления 3D Secure урегулированием спорных вопросов приходилось заниматься мерчанту.
Также не стоит забывать о двух важных психологических аспектах: повышении доверия к онлайн-платежам и увеличении конверсии.
Конверсия может быть увеличена за счет обновлений протокола 3DS, направленных на сокращение взаимодействия с пользователем.
Версии протокола 3D Secure
--------------------------
```
v1.0 - 2001 г -…
v2.0 - 2014 г - Устарело
v2.1 - 2017 г
v2.2 - 2018 г
```
В настоящее время большинство платежных сервисов используют версию 1.0.2 при проведении онлайн CNP-платежей, запрашивающих OTP-код.
Версия 1.0.2 была создана в 2001 году и в ней есть некоторые проблемы.
На данный момент актуальной версией является v2.2, и EMV планирует, что к концу 2020-го года она будет использоваться везде.
Как это устроено?
=================
Это основная схема, необходимая для понимания всего процесса платежа с использованием механизма 3DS.
На этом рисунке мы видим все три домена, используемые в протоколе, а также последовательность сообщений между всеми участниками платежной операции.
Как это работает?
-----------------
Главное, что необходимо понять, — это то, что при использовании своей карты (виртуальной или реальной) для онлайн-оплаты, вы сталкиваетесь именно с протоколом 3DS. Поэтому сейчас мы проиллюстрируем все этапы совершения онлайн-платежа.
1 — Покупатель уже добавил все необходимые ему товары в корзину и нажал кнопку "Оплатить". В этот момент он попадает на страницу MPI-сервиса, где вводит данные своей карты.
После нажатия кнопки оплаты продавец (MPI) инициализирует старт платежного потока и, согласно протоколу, отправляет CRReq-запрос (Card Range Request). Данный запрос необходим, чтобы найти банк-эмитент вашей карты и получить CRR из домена взаимодействия. Этот запрос нас мало интересует.
После этого MPI отправляет VeReq (Verification Request). Этот запрос отправляется банку-эмитенту для проверки того, что 3DS для данной карты включен и карту можно использовать для оплаты.
VeRes (Verification Response) содержит дополнительную информацию для следующего этапа платежа.
Клиенты не могут видеть эти два типа сообщений.
2 — MPI создает PaReq (Payment Request) — запрос на оплату. Этот запрос отправляется через редирект в браузере клиента.
Итогом отправки PaReq становится отображение запроса на ввод OTP-кода.
3 — Клиент вводит OTP-код и возвращается на сайт продавца. Опять же в процессе этого через редирект от банка-эмитента к MPI передается PaRes (Payment Response), который содержит информацию о статусе проверки.
А поподробнее?
--------------
CRReq/CRRes для нас не очень важны. А вот VeReq/VeRes рассмотреть нужно.
```
xml version="1.0" encoding="UTF-8"?
1.0.2
4444333322221111
411111
99000001
99000001
0
\*/\*
curl/7.27.0
```
В VeReq самым важным параметром является идентификатор сообщения, информация о продавце и PAN карты.
```
xml version="1.0" encoding="UTF-8"?
1.0.2
Y
A0fTY+pKUTu/6hcZWZJiAA==
https://dropit.3dsecure.net:9443/PIT/ACS
ThreeDSecure
```
VeRes возвращает **message id**, который необходим, чтобы сопоставить запрос с этим ответом. А **status enrolled** показывает, что карта поддерживается.
Однако наиболее важным параметром в данном сообщении является URL-адрес. Этот параметр указывает, где находится ACS сервер эквайера и куда нужно отправить PaReq.
Pareq
-----
Браузер клиента, совершающего оплату, может произвести достаточно много редиректов по различным компонентам, участвующим в совершении платежа. Так, в России есть некоторое количество запросов, обрабатывающихся на стороне Национальной Системы Платежных Карт. Но сегодня нас интересует только традиционный этап, описанный в спецификации протокола. А именно этап передачи PaReq.
```
URL: https://site.ru/acs/pareq
MD=5ebde4d3-3796-7a4d-5ebd-e4d300003dd0&PaReq=eJxVUstywjAM%2FBUm98QPDDiMcIc2dMoh0AedKb2ljiDpNAFMUgJfXzuFPnzSrjQraWW4aoqPzieafb4pRx4LqNfBUm%2FSvFyPvOfFrS%2B9KwWLzCBGT6hrgwpi3O%2BTNXbydOS96VDocEX9FePaF1IIPwlF6qeoV7Inqeyh9hTcjx9xp%2BDcSNk%2BAQdygVbR6CwpKwWJ3l1PZ0rwQZ9SIGcIBZpppAaSuse7POwC%2BeagTApUy%2FEsmrwE8Xw2WQJpKdCbuqzMUfWFLb4AqM2HyqpqOyTkcDgExabEY3BMyhSbwNRAXB7I70D3tYv2Vq%2FJUzU7Teg8ejjE7xMWn9Z8Hk35fKEtNx4BcRWQJhUqTplklIoOC4c9NuwOgLQ8JIUbRDHK2vW%2BEWxdk%2FG%2F1F8KrO%2FGnuWyywUBNls7v62wZv7EQH5nvrlzlurKGsUGNOwy0ZfhXf5udlkmV7ey98rfmnjpjG6LnGJubeKUslbSASBOhpxvSM7nt9G%2Fb%2FEFnkK9RA%3D%3D&TermUrl=https%3A%2F%shop.ru%2Fgates%2F3ds
```
Платежный запрос, содержащий PaReq (метод POST), имеет три параметра:
1) MD — данные продавца. Он нужен MPI, чтобы сопоставить PaReq и PaRes одной транзакции;
2) PaReq — параметр этого платежного запроса. Он содержит всю важную информацию о платеже;
3) TermUrl — URL-адрес, на который клиент будет возвращен в конце процесса аутентификации 3D Secure.
Параметры TermURL и MD всегда отражаются в ответе на данный запрос. Поэтому могут встречаться имплементации ACS, уязвимые к атакам типа reflected XSS. В процессе аудита различных систем такие сервера были найдены.
**Важный момент №1:** ACS сервера обрабатывают все входящие PaReq!
Что входит в параметр PaReq?
Вы можете получить его значение, раскодировав PaReq. Это сделать достаточно легко, потому что PaReq — это Xml-> zlib-> base64-> urlencode. Для упрощения работы с этими запросами был написан [плагин для burp](https://github.com/webr0ck/3D-Secure-audit-cheatsheet).
Теперь мы видим, что из себя на самом деле представляет PaReq, а именно сообщение формата xml. Это сообщение содержит информацию о сумме платежа (purchAmount, amount и currency), некоторую информацию о продавце и MessageId (из VeReq).
При отправке правильно сформированного PaReq (в большинстве случаев вам не нужен полный набор запросов на оплату — требуется отправить лишь PaReq, содержащий параметры правильного типа и длины), мы получим PaRes — ответ на платеж, подобный следующему:
Первая мысль, которая может прийти в голову веб-исследователю, который видит XML-запрос — это попробовать выполнить XXE. И это правильный путь!
Но для начала посмотрим на то, что случится, если отправить некорректно сформированный PaReq. Мы получим ошибку! Вот несколько примеров таких ошибок:
```
1.0.299Permanent system failure.Failed to build error message.
5Format of one or more elements is invalid according to the specification.
98Transient system failure
4Critical element not recognized
```
Ошибка может помочь получить дополнительную информацию о версии ACS. Некоторые из них могут также оказаться полезными для получения данных из XXE.
Раскрутим XXE
-------------
Рассмотрим следующий пример:
```
xml version="1.0" encoding="UTF-8"?]>1.0.2510069∾MerchantName643http://asdas.asU3Vic2NyaWJlX0B3ZWJyMGNr20181004 21:34:212020002020006432AcquirerNameDYasdVQAOX6as3dfcxccwzPCR6Q74eS52209
```
acqBIN, merID, xid, date, purchAmount и currency отражаются в PaRes. Однако во всех реализациях ACS, которые мы нашли, удалось использовать только merID. Остальные параметры проверяются на соответствие типам данных.
Еще один интересный параметр (и наиболее полезный для атаки) — это URL. Этот параметр не отражается, но и не проверяется. Поэтому его можно использовать для эксплуатации XXE.
Вернемся к нашему примеру. В одной из реализаций ACS мы обнаружили, что можем читать короткие файлы, а также получать ответ в PaRes error через параметр merID. Таким образом, используя PaReq из примера выше, мы получали следующий ответ:
```
1.0.2510069
ACS server name
U3Vic2NyaWJlX0B3ZWJyMGNr20181004 21:34:21202000643200000000000000020181004 21:34:21U55PAReq.CH.acctID
```
Тем не менее в большинстве случаев оставалось только использовать параметр URL для получения DNS или HTTP-запроса к нашему сервису. Другой вектор — это выполнить DOS через XXE-атаку "billion laughs" (проверялось на тестовом сервере).
Где это можно найти?
--------------------
В ходе нашего исследования мы обнаружили несколько распространенных URL-адресов:
```
/acs/pareq/___uid___
/acspage/cap?RID=14&VAA=B
/way4acs/pa?id=____id____
/PaReqVISA.jsp
/PaReqMC.jsp
/mdpayacs/pareq
/acs/auth/start.do
```
И распространенные имена поддоменов:
```
acs
3ds
3ds
secure
cap
payments
ecm
3dsauth
testacs
card
```
Впрочем, иногда вы можете найти и другие интересные пути.
Если вы хотите найти что-то новое, используйте proxy interceptor и записывайте процесс совершения платежей для интересующей вас платежной системы.
3D Secure v 2. \*
-----------------
Как мы писали ранее, в 3DS v1.0 есть некоторые проблемы.
Основная проблема в том, что покупатель может использовать множество разных типов устройств. Планшет, мобильный телефон, умные часы, умный чайник и т.д. Но сайт ACS не всегда разработан для взаимодействия со всеми типами устройств.
Для этого в 3DS 2.0 предусмотрели 3DS SDK.
Другая проблема состоит в том, что новый тип защиты требует дополнительного взаимодействия с клиентом. И этот момент влияет на конверсию. Решением проблемы конверсии стала возможность использования механизма управления рисками, который позволяет не заставлять пользователя вводить дополнительные секретные данные, если банк обладает достаточным количеством информации, подтверждающей личность клиента.
Следующий важный момент заключается в том, что технологии аутентификации развиваются. Соответственно, 3DS могла бы использовать не только OTP. Поэтому v2 задумывалась с возможностью расширения поддержки различных механизмов аутентификации.
**Интересный факт про v1.0.** Люди некоторых стран не доверяли этому протоколу, потому что видели редирект и думали, что это мошенничество!
Этот психологический момент послужил причиной изменения спецификации второй версии протокола для сокрытия момента перенаправления.
Как работает 3D Secure v2?
--------------------------
Начало потока платежей аналогично предыдущей версии. Клиент должен указать данные своей карты.
Первый и самый важный момент — это Risk Engine. В версии 1.0.2 клиенты всегда должны вводить второй фактор, например OTP. Однако в версии 2. \* клиент может никогда не увидеть этот дополнительный защищенный запрос.
Особенности работы v2
---------------------
Если вы посмотрите на схему потока платежей, вы увидите, что она похожа на предыдущую, но во 2-й версии больше этапов. Это происходит за счет добавления дополнительных аутентификационных запросов и механизма Risck Engine, который может совершать как один дополнительный запрос (при платеже через браузер), так и множество (используется 3DS SDK).
Условно, 2-ю версию можно разделить на два блока. Красный, где пользователь непосредственно влияет на передаваемую информацию, и желтый, где система сама собирает и передает информацию о пользователе.
А поподробнее?
--------------
AReq (base64url) расскажет все о вас и об устройстве, с которого совершена покупка.
Если вы задумаетесь о том, какой информацией о вас располагают рекламные агентства, то данные AReq вас не удивят. Но если вам кажется, что это плохо, рассмотрите следующий момент: банки знают все о ваших покупках и о вас. С этой точки зрения, некоторая дополнительная информация не так уж и плоха)
Это сообщение необходимо для работы системы управления рисками и упрощения покупок.
Если этой информации оказалось недостаточно, Risk Engine сперва попытается получить дополнительную информацию, и именно в этот момент клиент может получить OTP-запрос.
Что контролирует пользователь?
------------------------------
CReq (base64url json) — challenge request — сообщение, отправляемое браузером пользователя, в случае если ARes вернет сообщение о необходимости провести Challenge Flow.
```
{
"ThreeDSServerTransID": "8a880dc0-d2d2-4067-bcb1-b08d1690b26e",
"AcsTransID": "d7c1ee99-9478-44a6-b1f2-391e29c6b340",
"MessageType": "CReq",
"MessageVersion": "2.1.0",
"SdkTransID": "b2385523-a66c-4907-ac3c-91848e8c0067",
"SdkCounterStoA": "001"
}
```
Если платежный процесс использует 3D Secure SDK, это сообщение будет зашифровано (JWE).
В CReq вы можете увидеть следующие поля:
К сожалению, нам пока не удалось провести достаточно подробное исследование 2-й версии протокола 3DS, поэтому сложно сказать, какие уязвимости встречаются чаще. Вы можете стать первым, кто опубликует исследование на данную тему.
Подведем итоги
==============
Проблемы (найденные и возможные)
--------------------------------
На что смотреть в v1
* XXE в параметре Pareq:
+ DOS
+ чтение файла
+ ssrf
* XSS в параметрах TermUrl
* Blind XSS — все параметры и заголовки попадают в систему мониторинга
* Pareq не подписан, но в нем есть цена! Отсюда может последовать атака уже на магазин, т.к. если на стороне магазина не будет проверки суммы подтвержденной операции, то вы сможете совершить покупку вещи стоимостью в 100р за 1р.
На что смотреть в v2
* Blind XSS — все параметры и заголовки попадают в систему мониторинга
* Challenge flow, главное его поймать…
Тем, кто подумывает обратить свой взгляд на платежные системы, я бы посоветовал остановиться еще и на сервисах, предоставляющих 3DS как SaaS. Там может оказаться еще достаточно много вещей, которые помогут вам понять, как устроен мир онлайн-платежей.
Полезные ссылки
===============
<https://github.com/w3c/webpayments/wiki>
<https://www.EMV.com/emv-technologies/3d-secure/>
<https://3dsserver.netcetera.com/3dsserver-saas/doc/current/schema/3ds-api.html>
<https://github.com/webr0ck/3D-Secure-audit-cheatsheet>
P.S. Возможно, вам пришел в голову вопрос: "Я пользовался AliExpress, Amazon, *другое*, и мне не приходил OTP код. Здесь использовался 3DS?" Нет, не использовался. Это как раз примеры тех случаев, когда магазин берет на себя ответственность за мошеннические операции. | https://habr.com/ru/post/517268/ | null | ru | null |
# Заметки про motd
motd — message of the day, сообщение отображаемое при входе в Linux-систему (на примере Ubuntu).
Раньше файл, содержащий приветствие располагался в `/etc/motd`, сейчас же это набор скриптов, располагающихся в каталоге `/etc/update-motd.d/`:
```
# ls -alh /etc/update-motd.d/
total 56K
drwxr-xr-x 2 root root 4,0K янв 22 2020 .
drwxr-xr-x 98 root root 4,0K окт 27 15:31 ..
-rwxr-xr-x 1 root root 1,2K апр 9 2018 00-header
-rwxr-xr-x 1 root root 1,2K апр 9 2018 10-help-text
lrwxrwxrwx 1 root root 46 янв 22 2020 50-landscape-sysinfo -> /usr/share/landscape/landscape-sysinfo.wrapper
-rwxr-xr-x 1 root root 4,2K авг 20 2018 50-motd-news
-rwxr-xr-x 1 root root 604 мар 21 2018 80-esm
-rwxr-xr-x 1 root root 3,0K мар 21 2018 80-livepatch
-rwxr-xr-x 1 root root 97 ноя 12 2018 90-updates-available
-rwxr-xr-x 1 root root 299 июн 3 2019 91-release-upgrade
-rwxr-xr-x 1 root root 129 ноя 12 2018 95-hwe-eol
-rwxr-xr-x 1 root root 111 сен 20 2018 97-overlayroot
-rwxr-xr-x 1 root root 142 ноя 12 2018 98-fsck-at-reboot
-rwxr-xr-x 1 root root 144 ноя 12 2018 98-reboot-required
```
Порядок отображения, как правило, в порядке заданных приоритетов — 00, 10 и тп…
В результате выполнения отображается:
```
Welcome to Ubuntu 18.04.5 LTS (GNU/Linux 4.15.0-118-generic x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
System information as of Fri Nov 13 14:30:00 +08 2020
System load: 0.45
Usage of /: 9.8% of 109.84GB
Memory usage: 6%
Swap usage: 0%
Processes: 152
Users logged in: 0
IP address for enp4s0: 192.168.106.12
IP address for enxd037454bea65: 172.17.8.58
IP address for tun0: 10.8.0.1
IP address for docker0: 172.17.0.1
* Introducing self-healing high availability clustering for MicroK8s!
Super simple, hardened and opinionated Kubernetes for production.
https://microk8s.io/high-availability
* Canonical Livepatch is available for installation.
- Reduce system reboots and improve kernel security. Activate at:
https://ubuntu.com/livepatch
Могут быть обновлены 233 пакета.
174 обновления касаются безопасности системы.
New release '20.04.1 LTS' available.
Run 'do-release-upgrade' to upgrade to it.
Last login: Fri Nov 13 08:21:33 2020 from 85.192.x.214
```
Много лишнего для нас — не так ли?
Я отключу часть и добавлю своё приветствие.
Создам файл и сделаю его исполняемым.
```
# touch /etc/update-motd.d/99-intelcom
# chmod 755 /etc/update-motd.d/99-intelcom
```
Теперь открываю его в любом редакторе и добавляю:
```
#!/bin/bash
echo -e '\033[34m#######################################################
#\033[33m PBX Intelcom - VoIP АТС производства ООО "Интелком" \033[34m#
#\033[33m www.a*p.ru тел.(3532)54-0X-0Y \033[34m#
#######################################################\033[0m'
```
Где `-e` — включить поддержку вывода Escape последовательностей, `\033[34m` и `\033[33m` — цвета текста, `\033[0m` — сброс цветов.
Доступны такие цвета текста:
`\033[30m` — чёрный;
`\033[31m` — красный;
`\033[32m` — зелёный;
`\033[33m` — желтый;
`\033[34m` — синий;
`\033[35m` — фиолетовый;
`\033[36m` — голубой;
`\033[37m` — серый.
И такие цвета фона:
`\033[40m` — чёрный;
`\033[41m` — красный;
`\033[42m` — зелёный;
`\033[43m` — желтый;
`\033[44m` — синий;
`\033[45m` — фиолетовый;
`\033[46m` — голубой;
`\033[47m` — серый;
`\033[0m` — сбросить все до значений по умолчанию.
Просмотреть результат можно командой `sudo run-parts /etc/update-motd.d` или `cat /var/run/motd.dynamic`.
`00-header` — содержит само приветствие Welcome to Ubuntu 18.04.5 LTS (GNU/Linux 4.15.0-118-generic x86\_64)
`10-help-text` — ссылки на информацию и сапппорт
`50-landscape-sysinfo` ведет к сприпту для получения системной информации
`50-motd-news` — какие-то новости
`80-livepatch` — информация про Livepatch
`80-esm` — информация об Extended Security Maintenance — Расширенное обслуживание системы безопасности
Далее скрипты об обновлениях, перезагрузке и тд...
Для отключения ненужных сообщений просто задаю им права `400`.
```
Welcome to Ubuntu 18.04.5 LTS (GNU/Linux 4.15.0-118-generic x86_64)
-rwxr-xr-x 1 root root 1,2K апр 9 2018 00-header
-r-------- 1 root root 1,2K апр 9 2018 10-help-text
lrwxrwxrwx 1 root root 46 сен 30 13:45 50-landscape-sysinfo -> /usr/share/landscape/landscape-sysinfo.wrapper
-r-------- 1 root root 4,9K авг 14 02:59 50-motd-news
-r-------- 1 root root 604 мар 22 2018 80-esm
-r-------- 1 root root 3,0K мар 22 2018 80-livepatch
-r-------- 1 root root 97 июн 27 2018 90-updates-available
-r-------- 1 root root 299 мая 19 2017 91-release-upgrade
-rwxr-xr-x 1 root root 165 фев 17 2020 92-unattended-upgrades
-rwxr-xr-x 1 root root 129 июн 27 2018 95-hwe-eol
-rwxr-xr-x 1 root root 111 окт 27 2017 97-overlayroot
-rwxr-xr-x 1 root root 142 июн 27 2018 98-fsck-at-reboot
-rwxr-xr-x 1 root root 144 июн 27 2018 98-reboot-required
-rwxr-xr-x 1 root root 324 ноя 13 13:36 99-intelcom
```
В итоге у меня получилось:
 | https://habr.com/ru/post/529746/ | null | ru | null |
# Развертывание Windows UEFI с использованием Foreman
**Автор: DevOps Team Leader компании** [**Hostkey**](https://hostkey.ru/) **Егор Гараджа**
[В прошлой статье](https://habr.com/ru/company/hostkey/blog/702936/) мы рассказали, как нам удалось решить проблему установки Windows и Linux через Foreman в Legacy-режиме (BIOS/MBR). Другой важной задачей стала поддержка инсталляций в режиме EFI. В случае [Foreman](https://theforeman.org/) этот вопрос решается через использование отдельного загрузчика. Для Linux наш выбор пал на [Grub2](https://ru.wikibooks.org/wiki/Grub_2#:~:text=GRUB%20(GRand%20Unified%20Bootloader)%20%E2%80%94,%D0%B8%20Hurd%20(StartUp%20Manager).&text=GRUB%202%20%E2%80%94%20%D1%8D%D1%82%D0%BE%20%D0%BD%D0%BE%D0%B2%D0%B0%D1%8F%20%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%8F,%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B%20%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%BE%D0%B2%20MBR%20%D0%B8%20BIOS.), и реализация загрузки оказалась достаточно тривиальной — нами была создана конфигурация Grub для загрузки initrd и ядра.
В случае с Windows ситуация сложнее. Изначально загрузка Windows осуществлялась через расширение для iPXE. Проблема, однако, в том, что это расширение, как и многие другие (memdisk и т. п.), не поддерживалось официально для EFI-версии загрузчика. Кнечно, можно попытаться решить этот вопрос самостоятельными правками и сборкой нужных модулей, но мы в целом хотели уйти от iPXE, поскольку это не совсем честный pxe-загрузчик, а скорее мини-операционная система со своими драйверами для сетевых карт, что изредка создавало проблемы при инсталляциях.
Мы сделали попытку использовать модуль Grub2, позволяющий смонтировать по http образ диска и загрузиться с него. Этот вариант не сработал, так как производительность модуля при работе по сети оказалась очень низкой, не говоря уже о стабильности.
В результате изучения вопроса мы пришли к следующим вариантам решения проблемы:
* Создание процедуры инсталляции, в которой на первом шаге используется Linux, а дальнейшая инсталляция происходит с использованием WindowsPE, без изменений относительно механизма Legacy-установки через iPXE.
* Встраивание поддержки загрузчика Microsoft в Foreman (потребуется модификация файла /usr/share/foreman/app/models/concerns/pxe\_loader\_support.rb из поставки Foreman для добавления загрузчика в его меню).
* Создание инсталляции из шаблонов (аналогично [Fog Project](https://fogproject.org/)) с использованием Microsoft sysprep целиком из Linux, без родного инсталлятора.
Мы попробовали разные варианты, но в этой статье мы хотим рассказать о первом, поскольку сейчас он является основным в нашей инфраструктуре и хорошо испытан. Главный плюс этого подхода — это расширение к существующей процедуре установки ,а потому не требует поддерживать различную конфигурацию для режимов EFI и Legacy. Главной проблемой стала архитектурная избыточность — не вся ОС ставится через Linux LiveCD, а лишь WindowsPE, что приводит к лишним шагам и потенциальным точкам отказа.
Установка будет проходить через следующие этапы:
1. Штатная загрузка Linux LiveCD через PXE Grub2.
2. Скрипт установки Linux должен:
* произвести разбивку диска для EFI и WindowsPE;
* загрузить WindowsPE и организовать его EFI-загрузку с диска;
* загрузить все необходимые скрипты и шаблоны с Foreman для установки Windows;
* сообщить Foreman о завершении установки, в результате чего следующая загрузка произойдет с диска, то есть загрузится WindowsPE.
3. Далее установка должна пройти штатно — аналогично legacy-режиму, где сразу грузится WindowsPE.
### Штатная загрузка Linux LiveCD через PXE Grub2
```
<%#
kind: PXEGrub2
name: HK_Windows_PXEGrub2
model: ProvisioningTemplate
oses:
- Windows
%>
set default=0
set timeout=<%= host_param('loader_timeout') || 10 %>
menuentry '<%= template_name %>' {
linuxefi (http,<%= host_param('medium_fqdn') %>)/live-master/vmlinuz rootfstype=auto ro rd.neednet=1 rd.live.image rd.luks=0 rd.md=0 rd.dm=0 root=live:<%= host_param('livesystem_url') %>/<%= host_param('live_squash') %> systemd.setenv=BRANCH=<%= host_param('medium_branch') %> systemd.setenv=SPEEDISO=peinstall systemd.setenv=PEMIRROR="<%= medium_uri %>" systemd.setenv=FOREMAN_TOKEN="<%= @host.token %>" systemd.setenv=FOREMAN_FQDN=<%= foreman_server_fqdn %> ipv6.disable=1 noeject
initrdefi (http,<%= host_param('medium_fqdn') %>)/live-master/initrd
}
```
Темплейт Grub2 загружает штатный LiveCD, сборку которого мы описывали в [предыдущей статье](https://habr.com/ru/company/hostkey/blog/663338/). Параметры systemd.setenv позволяют пробросить в загруженную систему ряд переменных окружений, благодаря чему можно запустить конкретный скрипт для последующей инсталляции и задать ему параметры для получения с Foreman шаблонов.
### Скрипт установки Linux
В systemd LiveCD добавляется сервис, который стартует только в том случае, если SPEEDISO=peinstall. Подробнее мы рассказывали об этом в [одной из прошлых статей](https://habr.com/ru/company/hostkey/blog/663338/).
Стартовый скрипт выполняет основную магию: выбирает INST\_DRIVE среди имеющихся в системе по указанной администратором логике, а затем производит следующие операции:
# Создает, с помощью parted, раздел ESP размером 1 гигабайт в начале диска:
```
parted -s /dev/${INST_DRIVE} mklabel gpt mkpart fat32 1MiB 1GiB set 1 esp on
EFI_PART=$(lsblk -l | grep "${INST_DRIVE}" | grep part | awk '{print $1}')
mkfs.fat -F32 /dev/$EFI_PART
```
# Подготавливает директории для монтирования файловых систем:
```
mkdir -p /mnt/{iso,efipart,wim}
```
# Загружает WindowsPE ISO с зеркала с помощью wget и монтирует его (вместо загрузки можно воспользоваться функционалом Fuse и сразу приступить к монтированию):
```
wget ${medium_uri}/${branch}/windowspe.iso
mount -o loop windowspe.iso /mnt/iso
```
# Подключает EFI-партицию и отправляет туда содержимое WindowsPE ISO, а также EFI-загрузчик Microsoft (мы держим его прямо на LiveCD, но можно закидывать через сеть. Он лежит в директории EFI любого инсталляционного диска Windows).
```
mount /dev/$EFI_PART /mnt/efipart
rsync -r /mnt/iso/ /mnt/efipart/
rsync -r /root/EFI /mnt/efipart/
```
# Немного исправляет пути для стандартного шаблона Grub2 с Foreman, обеспечивающего chain-load:
```
cp /mnt/efipart/EFI/Boot/bootx64.efi /mnt/efipart/EFI/Microsoft/Boot/bootmgfw.efi
umount /mnt/iso
```
# Забирает скрипты инсталляции Windows с Foreman:
```
curl -s "http://${foreman_fqdn}/unattended/script?token=${foreman_token}" >> /foreman.ps1
curl -s "http://${foreman_fqdn}/unattended/provision?token=${foreman_token}" >> /unattend.xml
```
# Добавляет скрипты в bootwim с помощью утилиты из комплекта wim-tools:
```
echo "add /foreman.ps1 /scripts/foreman.ps1" >> /wimupdate.txt
echo "add /unattend.xml /unattend.xml" >> /wimupdate.txt
wimupdate /mnt/efipart/sources/boot.wim < /wimupdate.txt
umount /mnt/efipart
```
# Сообщает Foreman, что установка завершена, это позволит осуществить следующую загрузку с диска:
```
wget "http://${foreman_fqdn}/unattended/built?token=${foreman_token}"
sync && reboot
```
### Дальнейшая установка
После выполнения этих процедур произойдет загрузка с WindowsPE с помощью штатного BCD Microsoft, расположенного на EFI-партиции. Дальнейшая процедура идентична установке с использованием прямой загрузки в WindowsPE — с той лишь разницей, что все необходимые скрипты установки загружены с Foreman, поэтому часть процедуры уже не нужна. Можно включить в startpe.cmd скрипт проверку на наличие этих файлов и перейти к исполнению основного скрипта инсталляции foreman.ps1 сразу, если он есть в системе.
Разбивка диска также чуть усложняется для поддержки EFI. Вот вариант partition\_table для Foreman (часть erb-шаблона, с конструкцией выбора efi/legacy):
```
<% if host_param_true?('uefi') -%>
@"
clean
convert gpt
create partition msr size=16
create partition efi size=500
create partition primary
shrink minimum=500
format quick fs=ntfs label="Windows"
assign letter="C"
create partition primary
format quick fs=ntfs label="Recovery"
assign letter="R"
set id="de94bba4-06d1-4d40-a16a-bfd50179d6ac"
gpt attributes=0x8000000000000001
list volume
exit
"@ | Tee-Object -FilePath "$SysDrive\dp.txt" -Append
<% else -%>
@"
clean
convert mbr
create partition primary size=500
select partition 1
active
format quick fs=ntfs
create partition primary
select partition 2
format quick fs=ntfs label='vg<%= @host.shortname %>'
assign letter='C'
exit
"@ | Tee-Object -FilePath "$SysDrive\dp.txt" -Append
<% end -%>
echo "Execute Diskpart..."
& diskpart /s $SysDrive\dp.txt
```
Поскольку WindowsPE уже загружен в память (речь конкретно о Boot.wim, в который мы добавляли установочные скрипты на этапе Linux), то диск можно полностью зачистить и создать чистую установку в соответствии с [рекомендациями Microsoft по разбивке дисков для EFI-инсталляций](https://learn.microsoft.com/ru-ru/windows-hardware/manufacture/desktop/configure-uefigpt-based-hard-drive-partitions?view=windows-11).
Дальнейшие шаги необходимо описать в foreman.ps1 — это PowerShell-скрипт, который произведет загрузку необходимых драйверов, образа wim (вместе с утилитой setup.exe) со штатного инсталляционного DVD Microsoft и запустит setup.exe с использованием файла ответов unattend.xml.
Результат: установленная ОС Microsoft в режиме EFI с помощью сервиса Foreman и без использования инфраструктуры Microsoft. | https://habr.com/ru/post/706448/ | null | ru | null |
# PUSH в GIT как средство доставки в прод, или как сэкономить время на развертывании и обновлении сервисов
Программисты любят программировать. Но если вы – программист, и результат вашего творения делается не “в стол”, рано или поздно наступит момент, когда нужно показать его миру: заказчику, пользователям, инвесторам, etc. Хорошо, когда вы работаете в компании, где есть целый отдел (или хотя бы отдельный специально обученный человек), который может развернуть ваше приложение, где вы скажете и как вы скажете. Однако не все компании могут себе такое позволить. А уж если вы фрилансер или это ваш пет-проект, развертывание приложения точно ляжет на вас.
О чем вам нужно позаботиться перед развертыванием? Арендовать сервер, настроить его, зарегистрировать доменное имя, получить SSL-сертификат, подумать о доставке обновлений.
Чтобы предметно рассмотреть процесс развертывания, напишем небольшой API-сервис TODO-заметок на языке программирования Python с использованием микрофреймворка Flask и развернем его разными способами.
**Планирование**
Каждая заметка будет определяться следующим образом:
```
{
"text": "Купить молоко",
"done": true
}
```
Все заметки будут храниться массивом в файле формата JSON.
Определим API следующим образом.
```
GET /todo получает список всех TODO.
GET /todo/ получает TODO с заданным id (индексом в массиве).
POST /todo добавляет новую TODO в конец списка.
PUT /todo/ заменяет TODO с заданным id.
```
**Реализация**
Для начала напишем само приложение.
Так как наше приложение использует Flask, создадим файл requirements.txt:
```
Flask==2.2.2
Flask-CORS==3.0.10
```
Напишем код приложения, работающий локально, в файле `app.py`:
```
import json
from flask import Flask, request, abort
from flask_cors import CORS
FILENAME = "todo.json"
def get_data():
try:
with open(FILENAME, "r", encoding="utf-8") as f:
return json.load(f)
except FileNotFoundError:
return []
def save_data(data):
with open(FILENAME, "w", encoding="utf-8") as f:
json.dump(data, f)
app = Flask(__name__)
cors = CORS(app)
@app.route("/")
def index():
return "TODO App"
@app.route("/todo")
def get_all_todo():
return get_data()
@app.route("/todo/")
def get\_single\_todo(id):
data = get\_data()
if id < 0 or id >= len(data):
abort(404)
return data[id]
@app.route("/todo", methods=["POST"])
def add\_new\_todo():
new\_todo = request.json
if new\_todo is None:
abort(400)
data = get\_data()
data.append(new\_todo)
save\_data(data)
return "OK", 201
@app.route("/todo/", methods=["PUT"])
def update\_todo(id):
data = get\_data()
if id < 0 or id >= len(data):
abort(404)
updated\_todo = request.json
if updated\_todo is None:
abort(400)
data[id] = updated\_todo
save\_data(data)
return "OK"
if \_\_name\_\_ == "\_\_main\_\_":
app.run(port=8080)
```
Установим зависимости:
```
pip install -r requirements.txt
```
Запустим приложение:
```
python app.py
```
**Убедимся в его работоспособности при помощи Postman**
Визуализация Postman### Развертывание вручную
Если развертывание приложений не является для вас чем-то регулярным, вы вряд ли на память помните все шаги, да и шаблонов нужных конфигурационных файлов у вас (еще) нет. В этом случае вы скорее всего загуглите что-то вроде “nginx gunicorn flask” (или даже “flask production”, если до этого вы вообще ни разу ничего не развертывали) и скопируете конфигурационные файлы из первой статьи, которую найдете. Так как об этом написано множество статей ([например, эта](https://www.digitalocean.com/community/tutorials/how-to-serve-flask-applications-with-gunicorn-and-nginx-on-ubuntu-22-04)), пробежимся по этому процессу в общих чертах:
1. Арендовать виртуальный сервер. Столкнуться с тем, что там Linux. Почитать статьи, посмотреть видео на ютубе, запомнить основные команды.
2. Установить nginx.
3. Установить pip и сопутствующие пакеты.
4. Установить git.
5. Склонировать репозиторий с кодом приложения на сервере.
6. Создать виртуальное окружение python (опционально).
7. Установить зависимости из requirements.txt
8. Добавить виртуальный хост в nginx:
1. Зарегистрировать доменное имя.
2. Написать конфиг в /etc/nginx/sites-available (возможно, узнать как вообще пишутся конфиги виртуальных хостов для nginx и что такое upstream?).
3. Сделать симлинк на написанный конфиг в /etc/nginx/sites-enabled.
4. Перезапустить nginx.
9. Столкнуться с тем, что браузер считает наш сервис небезопасным, установить certbot и сгенерировать SSL-сертификат.
10. Почувствовать радость от победы, но в будущем обнаружить, что при перезагрузке сервера приложение не перезапускается.
11. Научиться писать unit-файлы для systemd (+ узнать о существовании systemd).
У автора на этот процесс уходит примерно час-полтора, если не учитывать борьбу с 502 Bad Gateway в nginx из-за опечатки в конфиге.
**Что можно улучшить?**
Если развертывать нужно часто и однотипные приложения, то в какой-то момент вы начнете задумываться об автоматизации этого процесса: разберетесь с Ansible, начнете использовать CI/CD решения. Это безусловно будет для вас полезно, но, может быть, можно проще?
В таких сервисах, как Amvera или Heroku, вам уже предоставляется репозиторий с кодом, куда достаточно сделать git push для развертывания. Рассмотрим развертывание приложения в Amvera.
Так как в Amvera приложения исполняются в контейнерах, напишем Dockerfile для нашего приложения.
```
FROM python:3.10-slim-buster
WORKDIR /app
ENV PORT=80
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
ENTRYPOINT gunicorn --bind 0.0.0.0:$PORT app:app
```
Так как для развертывания нашего приложения мы используем gunicorn, добавим его в requirements.txt:
```
Flask==2.2.2
Flask-CORS==3.0.10
gunicorn==20.1.0
```
В отличие от виртуальных машин для сохранности данных их нужно помещать в папку /data.
Добавим import os в начало файла app.py, а также изменим объявление переменной FILENAME:
```
FILENAME = "/data/todo.json" if "AMVERA" in os.environ else "todo.json"
```
Теперь начало файла app.py выглядит так:
```
import os
import json
from flask import Flask, request, abort
from flask_cors import CORS
FILENAME = "/data/todo.json" if "AMVERA" in os.environ else "todo.json"
def get_data():
# ... остаток файла
```
Инициализируем репозиторий git:
```
git init
```
Добавим созданные нами файлы в индекс:
```
git add app.py requirements.txt amvera.yml
```
Зафиксируем изменения:
```
git commit -m "TODO App"
```
### Создание проекта в Amvera
Теперь нужно создать проект в Amvera. Откроем страницу <https://cloud.amvera.ru/projects> и нажмите кнопку "Создать". Укажите параметры как на изображении:
Перейдем на страницу проекта: <https://cloud.amvera.ru/projects/todo-app>. Там нас интересуют команды для привязки проекта к существующему репозиторию:
```
git remote add amvera https://git.amvera.ru/<имя-пользователя>/todo-app
git push amvera master
```
После этого начнется сборка и развертывание проекта. Дождитесь появления статуса "Успешно развернуто":
### Проверка работоспособности
Снова воспользуемся Postman для отправки запросов.
Для проверки сохранности данных после перезагрузки, перезапустим сервис:
После завершения перезапуска отправим запрос Постманом для проверки наличия TODO заметок. Если они есть, значит мы все сделали правильно.
Также нам не пришлось задумываться об SSL-сертификатах. Они были автоматически выписаны для нашего приложения при первом развертывании.
Поздравляем, вы успешно создали свое первое приложение на Amvera!
**В чем преимущества такого подхода**
1. Экономия времени на первом развертывании. При ручном развертывании вам нужно было разобраться в нескольких технологиях (Linux, nginx, systemd). В случае с Amvera, это всего один Dockerfile.
2. При последующем обновлении все еще проще. Потребуется только запушить обновления в Git через командную строку или любимое GUI приложение, и все!
3. Вы автоматизируете процесс доставки и развертывания кода ваших сервисов. Это совсем другой пользовательский опыт, где вам не нужно отвлекаться на посторонние от разработки вещи.
4. Легче масштабироваться. У вас увеличилась нагрузка? Просто создайте копию контейнера, а балансировщик сам распределит нагрузку.
P/S/ Будем рады всем желающим поучаствовать в [бета-тесте](https://amvera.ru/?utm_source=habr&utm_medium=article&utm_campaign=push_v_git) нашей облачной платформы[Amvera](https://amvera.ru/?utm_source=habr&utm_medium=article&utm_campaign=push_v_git), который мы проводим с октября по декабрь 2022 г. В сервисе вы сможете опробовать описанный в статье подход. Это бесплатно для участников. Для участия нужно просто зарегистрироваться, после чего на счет поступит 1 т.р. Если их не хватит – напишите нам, и мы руками добавим столько вычислительного ресурса, сколько требуется для вашего проекта. Будем рады, если потом дадите обратную связь и поможете нам сделать действительно полезный и удобный сервис! | https://habr.com/ru/post/700620/ | null | ru | null |
# Почему каждый Data Scientist должен знать Dask
Здравствуйте, коллеги!
Возможно, название сегодняшней публикации лучше смотрелось бы с вопросительным знаком — сложно сказать. В любом случае, сегодня мы хотим предложить вам краткий экскурс, который познакомит вас с библиотекой [Dask](http://docs.dask.org/en/latest/), предназначенной для распараллеливания задач на Python. Надеемся в дальнейшем вернуться к этой теме более основательно.
[*Снимок взят по адресу*](https://pixabay.com/en/skiing-departure-wag-trace-curves-16263/)
Dask – без преувеличения наиболее революционный инструмент для обработки данных, который мне попадался. Если вам нравятся [Pandas и Numpy](https://www.piter.com/collection/python/product/python-dlya-slozhnyh-zadach-nauka-o-dannyh-i-mashinnoe-obuchenie), но иногда вам не удается справиться с данными, не умещающимися в RAM, то Dask – именно то, что вам нужно. Dask поддерживает фрейм данных Pandas и структуры данных (массивы) Numpy. Dask можно запускать либо на локальном компьютере, либо масштабировать, а затем запускать в кластере. В сущности, вы пишете код всего один раз, а затем выбираете: использовать ли его на локальной машине, либо развертывать в кластере из множества узлов, используя для всего этого самый обычный синтаксис Python. Сама по себе данная возможность великолепна, но я решил написать эту статью именно для того, чтобы подчеркнуть: каждый Data Scientist (как минимум, использующий Python) должен использовать Dask. С моей точки зрения волшебство Dask заключается в том, что, минимально изменив код, можно распараллеливать его, пользуясь вычислительными мощностями, которые уже имеются, например, у меня на ноутбуке. При параллельной обработке данных программа выполняется быстрее, приходится меньше ждать, соответственно, больше времени остается на аналитику. В частности, в этой статье мы поговорим об объекте `dask.delayed` и о том, как он вписывается в поток задач науки о данных.
### Знакомство с Dask
В качестве знакомства с Dask приведу пару примеров, просто чтобы дать вам представление о его полностью ненавязчивом и естественном синтаксисе. Важнейший вывод, который я хочу подсказать в данном случае – уже имеющихся у вас знаний будет достаточно для работы; вам не придется изучать новый инструмент для обращения с большими данными, например, Hadoop или Spark.
В Dask предлагается 3 параллельные коллекции, в которых можно хранить объем данных, превышающий по размеру RAM, а именно: Dataframes, Bags и Arrays. В каждом из этих типов коллекций можно хранить данные, сегментировав их между RAM и жестким диском, а также распределять данные по множеству узлов в кластере.
Dask DataFrame состоит из измельченных датафреймов, таких, как в Pandas, поэтому позволяет использовать подмножество возможностей из синтаксиса запросов Pandas. Ниже приведен пример кода, загружающий все csv-файлы за 2018 год, разбирающий поле с временной меткой и запускающий запрос Pandas:
```
import dask.dataframe as dd
df = dd.read_csv('logs/2018-*.*.csv', parse_dates=['timestamp'])
df.groupby(df.timestamp.dt.hour).value.mean().compute()
```
*Пример Dask Dataframe*
В Dask Bag можно хранить и обрабатывать коллекции питонических объектов, не умещающихся в памяти. Dask Bag отлично подходит для обработки логов и коллекций документов в формате json. В этом примере с кодом все файлы в формате json за 2018 год загружаются в структуру данных Dask Bag, каждая запись json проходит синтаксический разбор, а данные о пользователях фильтруются при помощи лямбда-функции:
```
import dask.bag as db
import json
records = db.read_text('data/2018-*-*.json').map(json.loads)
records.filter(lambda d: d['username'] == 'Aneesha').pluck('id').frequencies()
```
*Пример Dask Bag*
Структура данных Dask Arrays поддерживает срезы в стиле Numpy. В следующем примере множество данных HDF5 дробится на блоки размерностью (5000, 5000):
```
import h5py
f = h5py.File('myhdf5file.hdf5')
dset = f['/data/path']
import dask.array as da
x = da.from_array(dset, chunks=(5000, 5000))
```
*Пример Dask Array*
### Параллельная обработка в Dask
Другое не менее точное название этого раздела могло бы звучать «Смерть последовательного цикла». Мне то и дело встречается распространенный паттерн: перебираем список элементов, после чего выполняем с каждым элементом метод Python, но с разными входными аргументами. Среди распространенных сценариев обработки данных – вычисление совокупностей признаков (feature aggregate) для каждого клиента или выполнение агрегации событий из лога для каждого студента. Вместо применения функции к каждому аргументу в рамках последовательного цикла объект Dask Delayed позволяет обрабатывать множество элементов параллельно. При работе с Dask Delayed все вызовы функций ставятся в очередь, ставятся в граф выполнения, после чего планируется их обработка.
Мне всегда было немного лениво писать собственный механизм обработки потоков или использовать asyncio, так что я даже не буду показывать вам подобных примеров для сравнения. С Dask можно не менять ни синтаксиса, ни стиля программирования! Нужно всего лишь аннотировать или обернуть метод, который будет выполнен параллельно с `@dask.delayed` и вызвать вычислительный метод после выполнения кода цикла.
### Пример вычислительного графа Dask
В нижеприведенном примере два метода аннотированы `@dask.delayed`. Три числа хранятся в списке, их нужно возвести в квадрат, а затем все вместе просуммировать. Dask строит вычислительный граф, обеспечивающий параллельное выполнение метода для возведения в квадрат, после чего результат этой операции передается методу `sum_list`. Вычислительный граф можно вывести на экран, вызвав `calling .visualize()`. `Calling .compute()` выполняет вычислительный граф. Как понятно по [выводу](https://gist.github.com/aneesha/1d1cb9608625d76b143a51b9da6c50a1#file-dask_delayed_demo-ipynb), элементы списка обрабатываются не по порядку, а параллельно.
Количество потоков можно задать (например, `dask.set_options( pool=ThreadPool(10)` ), а также их легко подкачивать, чтобы пользоваться процессами у себя на ноутбуке или ПК (напр., `dask.config.set( scheduler=’processes’` ).
Итак, я продемонстрировал, насколько тривиально будет добавить параллельную обработку задач в проект из области Data Science при помощи Dask. Незадолго до написания этой статьи я применил Dask, чтобы разделить данные о пользовательских потоках кликов (истории посещений) на 40-минутные сеансы, после чего агрегировать признаки по каждому пользователю для последующей кластеризации. Расскажите, а каким образом вам доводилось использовать Dask! | https://habr.com/ru/post/454262/ | null | ru | null |
# Как попасть в Microsoft, Amazon или Twitter без диплома престижного колледжа
Эта статья для тех, кто готовится искать работу и, возможно, тревожится о том, что в топовые компании без диплома Стэнфордского университета по информатике не пробьешься. Вам наверняка говорили, что вас никто не возьмет в Facebook или Microsoft. Но я хочу вам сказать, что это вполне возможно. Вот моя история о том, как мне удалось получить работу своей мечты в Twitter.
Что вы найдете в этой статье:
* Кое-что из моей биографии
* Рассказ о том, как меня пригласили на собеседования топовые IT компании мира: Facebook Google, Amazon, LinkedIn, Microsoft, Twitter, Pinterest, Snapchat и другие
* Рассказ о том, как я получил несколько предложений о работе на должности программиста
* Уроки, которые я вынес из этого опыта
#### Биографическая справка
Я не оканчивал университетов из Лиги плюща. Два года я проучился в общественном колледже в Айдахо, затем перевелся в маленький католический университет и там закончил обучение по специальности «Информатика».
Программированием я стал заниматься на первом курсе, просто потому, что мне показалось, что это будет занятно. Весь мой опыт с компьютерами до того момента исчерпывался китайской подделкой под приставку Nintendo, да и та сдыхала, стоило только вставить в нее картридж.
Чтобы себя обеспечивать, пока не получу образование, я брал по несколько подработок сразу — мыл полы, продавал еду в кинотеатрах. После выпуска у меня не было никакой работы на примете. Я разослал резюме по всем крупным IT-компаниям, каким только мог, и даже, по везению, получил несколько приглашений на телефонные интервью.
На тот момент я даже примерно себе не представлял, что это вообще такое — собеседование на техническую должность, и уж тем более, как к нему нужно готовиться. Я приходил на интервью с мыслью, что меня будут спрашивать о том, что такое связный список или двоичное дерево.
Естественно, на всех этих собеседованиях меня отсеяли.
#### Следующий шаг
Тогда я не слишком задумывался о том, хороший ли у меня уровень. Я знал, что быстро схватываю. Все, что мне было нужно — это возможность себя проявить.
Как говорит народная мудрость, сеть нужно забрасывать подальше и пошире. Так я и поступил.
За то, что я сделал на следующем этапе, я испытываю особую гордость. Я написал простенький скрипт на Python, который собирал вакансии с Craigslist, отбирая должности с определенными ключевыми словами, и вносил указанные там электронные адреса в таблицу. Не самое гениальное решение, но люди, которые размещают вакансии на Craigslist, на удивление точно называют должности.
На Craigslist, однако, не слишком любят, когда кто-то пытается выгрузить их данные. Чтобы обойти ограничения, я запускал скрипт через VPN и установил таймер, который приостанавливал процесс каждые несколько минут. Не идеально, но такая схема работала.
В конечном счете, я собрал около 500 адресов организаций, расположенных в Сан-Франциско, Портленде, Споконе и Сиэтле. Я отфильтровал результаты по релевантности и дате и продолжал оптимизировать выдачу, добавляя все больше и больше параметров.
Как выяснилось, на рынке уже было несколько ботов, которые собирали данные с Craigslist и автоматически рассылали письма. По большей части, это были офшорные компании, пытающиеся пробиться на рынок в США.
Одна из хитростей, к которым я прибегнул, состояла в следующем: я составлял текст писем так, чтобы тема содержала соответствующие ключевые слова. Затем я добавил еще кое-какие детали с опорой на текст вакансии, чтобы предложение выглядело заточенным под конкретные требования. Судя по быстрому A/B тесту, который я провел, процент откликов после этого значительно возрос — с 2-3% до 10%.
На мои разосланные 500 писем пришло порядка 50 ответов; с небольшим процентом от этих 50 мне удалось договориться об интервью по телефону. Я остановился на 500, потому что время поджимало — мне нужно было уже куда-то устроиться. Приоритетом на тот момент был результат, а не широта охвата.
По счастливой случайности, я получил работу в стартапе из Сиэтла, на позиции разработчика-джуниора. Их офис тогда располагался в Киркланде, так что мне пришлось 45 минут ехать на автобусе, чтобы успеть на собеседование.
Там я проработал следующие три с половиной года и многому научился: Amazon AWS, EC2, DynamoDB, SQS и Docker. За это время я сильно вырос как программист. Я научился писать модулярный, простой для поддержки код, правильно рассуждать о дизайне и решать проблемы при работе с людьми.
Я работал бок о бок с группой знающих людей, которые пришли к нам из Microsoft, Amazon и LinkedIn, и старался играть среди них роль «губки». Я впитывал абсолютно все, что они мне давали. Убежден, что это оказалось огромное влияние на мою карьеру.
#### Работа в стартапе
В стартапе я за редкими исключениями работал только над бэкендом с редкими вылазками в DevOps. Сначала я писал функции для дополнения или модификации возможностей, обычно не слишком масштабных. Но это было отличной возможностью ознакомиться с кодовой базой и пройти процедуру проверки кода.
Через год мне стали доверять целые фрагменты кодовой базы, а потом поручили сделать из набора функций сервис. Стартап как раз начинал переходить на сервис-ориентированную архитектуру. Мы стали превращать разные компоненты сайта в сервисы и между делом я много узнал о RESTful, аутентификации, AWS, шаблоне издатель-подписчик, распределенных системах и так далее.
Что самое интересное: я не учился ничему этому по книгам или в ходе университетского курса. Просто нужно было реализовать какие-то функции или устранить какие-то узкие места. И я такой: ну что ж, давайте разбираться!
Не раз и не два я впадал в аналитический паралич — состояние, когда излишне детальный анализ препятствовал прогрессу в разрешении проблемы. Именно в эти тяжелые моменты возникало больше всего возможностей для развития. Я совершенствовался в определении области действия функций, переговорах, мониторинге, настройке оповещений и составлении документации. На каждом шаге этого процесса обнаруживались новые концепты, которые мне нужно было освоить. За эти два-три года я как никогда вырос и с точки зрения навыков программирования, и в плане человеческих качеств.
#### Как я готовился к собеседованиям
После своих мучений при первом раунде поиск работы я пообещал себе, что в следующий раз как следует подготовлюсь к собеседованиям.
Подготовку я начал с того, что расписал, в чем я силен, в чем слаб, а что хорошо бы подтянуть. Все навыки я разбил по трем категориям: структуры данных, алгоритмы и дизайн систем.
В профессиональной сфере я работал в основном на PHP, а в колледже писал на C++, поэтому для собеседования решил подобрать что-нибудь попроще, не такое массивное.
Исходя из этих критериев, я остановил свой выбор на Python. Это отличный вариант для изучения: легко усваивается, поддерживает много структур данных по умолчанию и позволяет быстро прописать код на доске. Я освоил Python по туториалам на Youtube, [вроде такого](https://www.youtube.com/watch?v=Z1Yd7upQsXY), и документации. Мне лично больше нравится Python 2.x, но вы можете выбирать между Python 2.x и Python 3.
Кстати, одна из причин, по которой я отдал предпочтение Python, состоит в том, что он очень прост для чтения и компактен при записи. Вот простой пример, чтобы сравнить C++ и Python.
Программа для сортировки в нисходящем порядке на С++:
```
#include
using namespace std;
int main()
{
int arr[] = {1,10,0,4,5}
int n = size(arr)/sizeof(arr[0]);
sort(arr, arr + n, greater());
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
return 0;
}
```
Сравните с той же программой на Python:
```
a = [1,2,4,5,1000]
a.sort(reverse=True)
print a
```
Я слышал от специалистов, проводящих собеседования, что при прочих равных лучше склоняться к лаконичности при выборе языка. Чем больше времени из отведенных вам 45 минут вы сможете потратить собственно на решение задания, тем лучше.
**Совет:** выбирайте не слишком громоздкие языки, чтобы быстрее писать код на доске.
#### В модусе подготовки
Где-то с неделю я прорешивал несложные задания на LeetCode, HackerRank и Project Euler, чтобы познакомиться с интерфейсами этих сайтов и привыкнуть писать на Python. За это время я смог лучше оценить свой уровень в некоторых языках программирования. Еще неделю я отвел на задания по дизайну, стараясь при этом охватывать как можно более широкий спектр и погружаться как можно глубже.
Это было очень увлекательно: часто я просто брал iOS приложения и смотрел, как они сделаны. Скажем, как создать Instagram с нуля (именно такой вопрос мне задали в Facebook)?
У меня в портфолио работа над API и сервис-ориентированной архитектурой. Поэтому я охотно воспользовался этой возможностью рассказать, как бы спроектировал свою версию Instagram. Благодаря сайд-проектам у меня также есть некоторый опыт разработки на iOS, так что заодно я ввернул словцо о callback-а, технологиях pull и длинных опросах.
Начал я с того, что перечислил функционал, который хотел бы видеть в собственной версии Instagram: лайки, загрузка фото и простая лента. Определение круга функций позволило мне выстроить очень добротный API, так как все эти сценарии хорошо мне знакомы.
Затем я нарисовал несколько схем высокого уровня, показывающих, как пользователь будет взаимодействовать с бэкендом и как там будут храниться данные. Я двигался от самого минимума, постепенно добавляя компоненты по мере надобности, и активно искал узкие места. Я делал обоснованные предположения (подчеркиваю: *обоснованные*) о том, какими будут требования, и как туда впишется та или иная технология. А также, что не менее важно, какие технологии не впишутся никак.
Например: почему для хранения определенного типа данных стоит использовать Cassandra, а не MySQL (подсказка: масштаб, скорость разработки, schema reviews), чем OAuth лучше простой аутентификации, Redis против Memcached при кэшировании данных, стриминг или пакетная обработка и так далее.
Тут можно исследовать разные области, обычно на все часовой сессии не хватает. Чтобы хорошо отвечать на такие вопросы, нужно досконально изучить проблему компромиссов, плюсы и минусы различных технологий в индустрии. Для этого я рекомендую сайты типа [HighScalability](http://highscalability.com/all-time-favorites/).
Относитесь к этому, как к обычному мозговому штурму с коллегой, и стремитесь к максимально широкому подходу и глубокой проработке.
Крайне важно осознавать, что эти сессии по дизайну предназначены для того, чтобы выявить, что вы знаете и насколько хорошо — и что это ваша возможность показать себя в выгодном свете. Я посмотрел вот это [видео](https://www.youtube.com/watch?v=ZgdS0EUmn70) от бывшего дизайнера Facebook о том, как подходить к заданиям по дизайну; его рекомендации очень помогли мне на собеседованиях. Две основных мысли, которые я из него вынес, звучат так: задавайте направление разговору о дизайне сами и покажите, что умеете.
Итак, я расписал свои навыки в том, что касается структур данных (связные списки, hash map, двоичные деревья, двоичные деревья поиска, кучи, массивы), алгоритмов (бинарный поиск, хэширование, динамическое программирование, сортировка) и синтаксиса и библиотек конкретных языков (lambda-функции для Python, append, index). Затем я выбрал область, в которой дела обстояли хуже всего, и стал работать над ней. Это оказались алгоритмы.
Алгоритмы никогда не были моей сильной стороной. С колледжа утекло уже много воды, а по работе мне не часто приходилось плотно заниматься двоичным поиском. Я имел общее представление о том, как работает каждый алгоритм и в каких сценариях их использовать. Но я не на сто процентов был уверен в своей способности прописать двоичный поиск меньше чем за десять минут. На доске. В присутствии человека, проводящего собеседование.
Заодно я прикупил целую кучу маркеров с [Amazon](https://www.amazon.com/86601-Low-Odor-Markers-Assorted-8-Count/dp/B000Z88D2E/ref=sr_1_3?ie=UTF8&qid=1518801079&sr=8-3&keywords=white+board+pens) — они прекрасно пишут. Не знаю, может, это только у меня так, но маркеры в офисах почему-то всегда выдохшиеся. Я обычно две-три минуты только и делаю, что перебираю маркеры в поисках нормального, а это не та ситуация, когда можно вот так разбрасываться временем. И еще: если брать тонкие маркеры, можно уместить на стандартную доску на 5-8 строк кода больше по сравнению с обычными.
**Совет:** обзаведитесь собственным набором маркеров.
Я купил в Costco доску за 50 $, набрал книг на Amazon (они перечислены в разделе с рекомендациями в конце статьи) и начал практиковаться. Я старался особенно нажимать на двоичный поиск, рекурсию, динамическое программирование, поиск в ширину и в глубину. Многие вопросы на собеседованиях касаются именно рекурсии и двоичного поиска или какой-то его вариации.
У самых лучших заданий, которые мне встречались, много разных решений, это обстоятельство тоже стоит учитывать в процессе подготовки.
Один вопрос, который мне задали в Google, касался каталогов файловой системы и того, как проводить их траверс (подсказка: рекурсия). Я довольно быстро представил решение, и проводящий собеседование спросил, как определить, что в папке не хватает файла. Это был вопрос посложнее, но я справился. После этого мы перешли к разговору о том, как перекомпоновать, сериализовать или десериализовать каталог и долгое время обсуждали, как работают каталоги под капотом. Я получил от этой сессии огромное удовольствие.
#### Собеседования в топовых компаниях
Опыт, мягко говоря, волнительный. Те еще американские горки.
Я распределил свое время так: 20% на резюме, 20% на ознакомление с компаниями, 60% на подготовку к собеседованию.
20% времени я потратил на обновление информации в резюме, которое не трогал три с лишним года. Я внимательно просмотрел все, чем занимался в прошлом, и отобрал те проекты, которые вел от начала до конца, независимо от уровня сложности.
На то у меня было две причины. Во-первых, способность довести проект до конца предполагает дисциплинированность и лидерские качества — то есть именно те черты, с которыми мне хотелось бы ассоциироваться у работодателей.
Во-вторых, подобная степень задействованности в проекте означает, что я могу рассказать о нем очень подробно и содержательно. Это обстоятельство оказалось критически важным на моем собеседовании в Twitter, где меня с пристрастием допрашивали не только о разных аспектах дизайна, но и о том, почему их решили реализовать именно так.
Еще 20% ушли на поиск информации. Под этим я подразумеваю то, что уделил должное внимание компаниям и разослал запросы на рекомендации. Рекомендации сильно повышают вероятность того, что вам перезвонят.
По собственному опыту: я разослал около 20 «холодных» писем стартапам и бизнесам средней величины, и ответили мне всего несколько из них. А вот из тех компаний, где за меня замолвил слово один из сотрудников, подавляющее большинство списались со мной в течение недели. Это, конечно, только один конкретный случай, но все-таки он о чем-то да говорит.
Я не отличаюсь общительностью и людей, способных меня порекомендовать компаниям, в которых я был заинтересован, знал не так уж много. Чтобы решить эту проблему, я направился на LinkedIn. С помощью их поискового механизма я нашел свои связи первого и второго уровней. Связи второго круга — это те люди, которые всего на шаг отстоят от вашего круга общения. Иными словами, у вас есть общие друзья, которые могут им за вас поручиться.
Это крайне важно, потому что пробиться на собеседование «холодным» способом очень и очень непросто, особенно в реалиях современного рынка. Люди в таких случаях предпочитают проявить осторожность. LinkedIn оказался очень полезен для стадии сбора информации.
Оглядываясь назад, вот мои впечатления о тех компаниях, в которых я проходил собеседования:
* **Facebook/Google** — все очень механически. Собеседования проходили по шаблону, и я не ощутил никакой личной связи.
* **Pinterest** — не лучший опыт в плане собеседования, но сам продукт и компания классные.
* **Microsoft** — мне очень понравилась команда, особенно менеджер и ее руководитель. Вопросы были стандартные, но подход очень личный. Серьезный конкурент на позицию моего фаворита. У вас, впрочем, может сложиться другое впечатление: каждая команда в Microsoft проводит интервью по-своему.
* **Amazon** — все стандартно. Половине соискателей такой подход нравится, остальным — нет.
* **Twitter** — очень увлекательно и персонализировано. Собеседование прошло отлично, много внимания было уделено моему предыдущему опыту и человеческим качествам.
* **Snapchat** — шикарный офис в Лос-Анджелесе и большая компания людей, которые решили присоединиться к стартапу. Чувство было такое, будто на всем завеса секретности.
* **Lyft** — недалеко от моего дома, симпатичный офис, собеседование по стандартной схеме. Не оставили сильного впечатления.
#### Сначала о моем фаворите
Я бы сказал, что собеседоваться у Twitter во многих отношениях сложно. Но при этом данный опыт был более индивидуальным и интересным, чем мои встречи с остальными компаниями.
Первый этап собеседования — телефонный разговор для знакомства с техническим руководителем. Затем следует одно или два технических интервью по телефону, количество зависит от ваших результатов. Если все в порядке, они пригласят вас прилететь в тот офис, на вакансию которого вы откликнулись, в моем случае это был офис в Сиэтле. Там вы пройдете три сессии продолжительностью в один час пятнадцать минут, на каждой присутствует по два сотрудника.
Два телефонных интервью проходят по обычной для технических должностей схеме: вы решаете задания в режиме совместного редактирования кода.
Сессии в офисе, однако, проходят куда менее формально и далеко не так пугают. Вас будут досконально расспрашивать о предыдущих проектах и обо всем, чем вы занимались до сих пор. Если вы заявляете, что участвовали в том или ином проекте, будьте готовы подробно о нем рассказать. Использование их как источника решений или для обкатки идей только поощряется.
Я ни разу не ощутил, что на меня давят, заставляя волшебным образом создать готовое, рабочее решение; наоборот, складывалось впечатление, что сотрудники настроены очень лояльно.
#### А теперь обо всех остальных
По сравнению с Twitter собеседования Facebook и Google показались мне более механическими. Они состояли из одного-двух телефонных интервью и пяти-шести сессий в офисе. На каждой сессии нужно было прописывать код на доске, причем требовалось практически идеальное решение, впрочем, и времени давали достаточно.
У Facebook было две сессии по программированию, одна по дизайну и одна для оценки личных качеств. В конце дня я прошел еще дополнительную «теневую» сессию, но на общий балл ее результаты не повлияли.
У Google было пять сессий, все по программированию. По дизайну не было вообще ничего и никто ни разу не заговорил о моих прошлых проектах. Я не говорю, что это однозначно плохо. Но мне кажется, что такой подход оставляет чувство конвейера и не дает разработчику в должной мере показать, на что он способен. Некоторым такой формат подходит — это как со студентами и экзаменами.
Собеседование в Pinterest мне не понравилось. Сам продукт кажется интересным, и команда, по всей видимости, работает над очень занятными [задачами](https://medium.com/@Pinterest_Engineering). Но мой опыт как соискателя был однозначно негативным.
Pinterest проводит три сессии по программированию, одну по дизайну. Из этих четырех меня разочаровала последняя. И вот почему.
Сотрудник, который проводит интервью, пришел с опозданием и первые несколько минут просто читал мое резюме. Затем он нарисовал на доске API, вкратце описал, что он должен делать, и спросил, как бы я это реализовал. Мы обговорили функционал и я стал прописывать на доске решение. Минут через пять я обернулся и увидел, что он задремал!
Не круто.
Я написал об этом в опроснике после собеседования, но со мной больше никто не связывался.
Не буду вдаваться в подробности о том, какие именно вопросы мне задавали на собеседованиях. Вместо этого перечислю некоторые полезные выводы и рекомендации, к которым пришел в процессе подготовки.
#### Чему я научился
* **Будьте честным при составлении резюме.** Большинство компаний будет задавать вопросы о том, что там написано, и сразу поймет, если вы начнете выдумывать. Лучше знать один проект на 100%, чем располагать 10% информации о десяти разных проектах.
* **Одностраничные резюме предпочтительнее.** Для IT-сферы это особенно актуально. По негласному правилу, на две страницы могут претендовать те, у кого есть ученая степень и много публикаций, либо те, кто был по-настоящему глубоко вовлечен в большое количество проектов. Кстати, один из моих друзей основал компанию под названием [Jobscan](https://www.jobscan.co/), которая анализирует резюме и предлагает конкретные действия по их улучшению. Отличный сервис, можете попробовать.
* **Общайтесь, заводите связи.** Конкуренция среди программистов очень высока, топовые IT-компании обрабатывают тысячи резюме в день. Рекомендация сотрудника поможет вам привлечь к себе внимание.
* **Умейте себя продать.** Любая компания, заинтересованная в вас, хочет знать, почему вы заинтересованы в ней. «Мне нужна работа, надо же на что-то жить» — плохой ответ. «Я искал варианты в Интернете и увидел ваш сайт» — получше, но все равно не очень. Хороший ответ звучит как-то так: «Я слышал, что у вас есть интересные проекты по X, которые могут способствовать Y. В ходе работы над прошлыми проектами я освоил A, B, C, которые можно применить в Х. Я испытываю живой интерес к Y, потому что бла-бла-бла». (Только не используйте это как шаблон. Тут нужно прост уловить паттерн: соберите информацию о компании, обратитесь к своей биографии и покажите, почему вы друг другу подходите.)
#### И еще несколько советов
Технические интервью отличаются высокой сложностью, их исход иногда оказывается сложно предсказать. Однако наилучшие возможности выпадают тем, кто приходит подготовленным.
* **Начинайте готовиться заранее и как следует.** О том, что нужно готовиться к собеседованиям, знают все, но не все знают, как делать это правильно. Как и с любым другим стоящим навыком, чтобы достичь хорошего результата, нужно практиковаться по продуманной схеме. А продуманная схема требует какой-то системы.
* **Создайте систему для совершенствования технических навыков.** Я начал с того, что оценил свои умения в разных областях по десятибалльной шкале и стал подтягивать те, которые получили самые низкие оценки. Я тратил на каждый тип задания по несколько дней, пока не отрабатывал каждый концепт как следует. Каждый день я делал заметки в Evernote. У меня был особый блокнот, отведенный под записи на тему программирования. Туда я заносил советы и хитрости, распространенные ошибки и заблуждения, алгоритмы решения заданий разных типов и многое другое.
* **Ведите записи о том, чему научились.** Я использовал для этой цели как [Evernote](http://evernote.com/), так и [OneNote](http://onenote.com/). OneNote предназначался для строго технических вещей и кода, мне нравилось, что там можно форматировать записи как угодно. Evernote я использовал для рассуждений и идей. Выше вы можете видеть мои заметки об архитектуре и дизайне систем.
* **Фиксируйте все, что можно, даже если вам кажется, что это вряд ли пригодится.** Я очень забывчивый, поэтому записываю все, что выучил, включая команды для командной строки. Также я часто читаю блоги программистов, и если попадется что-то интересное, тут же заношу это в Evernote. В конце каждой недели или каждого месяца я просматриваю записи и привожу их в порядок. Эта привычка оказалась очень полезной для моей карьеры.
* **Устраивайте репетиции.** Это очень ценный опыт, который я рекомендую всем. Я просил друзей разыграть со мной «собеседование» и старался устраивать такие тренировки как можно чаще. Если вам не к кому обратиться, могу посоветовать Refdash, которые оказывают услуги по организации пробных интервью. У них работают специалисты из крупных IT-компаний вроде Google, Facebook и Microsoft. Эти сотрудники проведут оценку ваших навыков программирования и дизайна и, что самое главное, представят итоговый балл и конкретные рекомендации о том, над чем нужно поработать.
* **В неудачах нет ничего страшного.** В процессе поиска работы я завалил массу собеседований. Иногда бывает такое, что просто день не ваш. Даже если все кончилось провалом, это еще не конец света. Компании вообще больше склонны говорить «нет», чем «да» — меньше риска. В долгосрочной перспективе недооценить кандидата не так убыточно, как переоценить. Первые несколько отказов определенно были самыми болезненными. При первых попытках устроиться на работу меня отсеивали еще на этапе телефонных интервью, и это подорвало мою веру в себя. Я стал сомневаться в своих способностях и бояться, что мои навыки не востребованы на современном рынке труда. Но я придумал для себя такую формулу: если потерпел неудачу 10 раз, сделай еще 10 попыток. Достаточно достичь успеха всего один раз. Такой образ мышления придал мне уверенности в себе и сил, чтобы продолжать попытки. Когда я наконец получил первое предложение о работе, все пошло гораздо проще.
*Мои заметки*
На продуманную подготовку к собеседованиям у меня ушло около двух месяцев. Я занимался по 20 часов в неделю, то есть 80 часов в месяц, вдобавок к основной работе.
На то, чтобы составить хорошее резюме, у меня ушло три с половиной года упорной, продуманной работы. Я специально выскакивал себе работу посложнее и понеприятнее, чтобы учиться быстрее, чем все остальные. Пусть у меня за плечами не было диплома звездного университета или работы в топовой IT-компании, я компенсировал это ясным, доскональным пониманием проектов, над которыми работал. А добиться такого понимания мне помогла моя привычка записывать все, что я узнал, и упорядочивать информацию согласно определенной системе.
Помните: выживает сильнейший, преуспевает самый выносливый.
Если обобщить: не сдавайтесь, ищите возможности, больше практикуйтесь и не теряйте надежды. Сосредоточьтесь на процессе и выработайте к нему продуманный, дисциплинированный подход.
#### Рекомендуемые инструменты
[**Elements of Programming Interviews**](http://amzn.to/2Dcs6Qd) — хороший источник с заданиями высокого уровня сложности
[**Cracking The Coding Interview**](http://amzn.to/2Hj91OH) — полезные материалы для освоения базового CS
[**OneNote**](http://onenote.com/) — его я использую для хранения фрагментов кода
[**Evernote**](http://evernote.com/) — а его — для всего остального
[**CodeRunner**](https://coderunnerapp.com/) — отличная программа для Mac! Я часто ей пользовался для работы со специфическими скриптами/функциями на Python, работает просто отлично.
[**Jobscan**](https://www.jobscan.co/) — компания моего друга. Я слышал о них много хорошего, так что обращайтесь к ним за разбором резюме.
[**Refdash**](http://refdash.com/) — инициатива нескольких бывших сотрудников Google. Их пробные собеседования — просто огонь по качеству. Сотрудник, который проводил со мной интервью, раньше работал в Google и рассказал мне очень много полезного о том, чему нужно уделить особое внимание и как бы меня оценили в Google. Очень рекомендую эту компанию.
[**CodePath**](https://codepath.com/) — некоммерческая организация, которая помогает людям построить карьеру в IT-сфере. Нейтан и Тим — прекрасные люди, я многому у них научился. Сообщество очень отзывчивое, любой готов чем-нибудь помочь.
[**Вот эти тонкие маркеры**](http://amzn.to/2oTWeeS) — отлично пишут, очень рекомендую.
Если выбирать между двумя книгами, *Cracking The Coding Interview* лучше годится для того, чтобы отработать основы: как устроен связный список или hash map, как с ними работать и так далее. *Elements of Programming Interviews* подходит для тех, кому нужны задания посложнее. Я бы сделал так: две-три недели потратил на то, чтобы вдумчиво, от главы к главе, изучить *Cracking The Coding Interview* и освоиться со всеми библиотеками нужного вам языка. Все остальное время я бы посвятил *Elements of Programming Interviews* и представленным там заданиям — полное понимание базовых структур данных помогло бы мне в их решении. | https://habr.com/ru/post/353462/ | null | ru | null |
# Настройка SSL для приложения в Windows Azure
[](http://windowsazure.com/ru-ru/)
Протокол шифрования SSL (Secure Socket Layer) — это самый распространенный способ защиты данных в Интернете. В этом примере будет показано, как задать конечную точку HTTPS для веб-роли и загрузить SSL-сертификат для защиты приложения.
Этот процесс включает в себя следующие этапы:
* Этап 1. Получите SSL-сертификат
* Этап 2. Измените определение службы и файлы конфигурации
* Этап 3. Загрузите пакет развертывания и сертификат
* Этап 4. Подключитесь к экземпляру роли по протоколу HTTPS
### Этап 1. Получите SSL-сертификат
Чтобы настроить протокол SSL для приложения, сначала необходимо получить SSL-сертификат, подписанный уполномоченным и независимым Центром сертификации. Если у вас еще нет SSL-сертификата, приобретите его у компании, которая их продает.
SSL-сертификат в Windows Azure должен отвечать следующим требованиям:
* Содержать закрытый ключ;
* Поддерживать обмен ключами (файл .pfx);
* Имя получателя в сертификате должно соответствовать домену, из которого осуществляется доступ к службе. Получить SSL-сертификат для домена cloudapp.net невозможно, поэтому имя получателя в сертификате должно совпадать с именем домена, через который вы предоставляете доступ к приложению;
* Сертификат должен использовать шифрование с ключом 2048 бит и выше.
Вы можете создать самоподписанный сертификат для тестирования. Подробнее о том, как создать самоподписанный сертификат в диспетчере IIS, см. в разделе [«Как создать сертификат для роли](http://msdn.microsoft.com/en-us/library/windowsazure/gg432987.aspx)».
Затем необходимо добавить информацию о сертификате в определение службы и ее файлы конфигурации.
### Этап 2. Измените определение службы и файлы конфигурации
Необходимо настроить приложение на использование сертификата и добавить конечную точку HTTPS. В результате определение и файлы конфигурации службы потребуется обновить.
Откройте файл определения службы (CSDEF) в среде разработки, добавьте подраздел **Certificates** в разделе **WebRole**, а затем укажите следующую информацию о сертификате:
```
...
...
```
В подразделе **Certificates** задайте имя сертификата, его местоположение, а также название магазина, в котором он находится. В этом примере сертификат хранится в Центре сертификации, но вы можете выбрать и другое расположение. Дополнительную информацию можно найти в разделе [«Как связать сертификат со службой](http://msdn.microsoft.com/en-us/library/windowsazure/gg465718.aspx)».
Откройте файл определения службы и добавьте элемент **InputEndpoint** в раздел **Endpoints**, чтобы включить использование HTTPS:
```
...
...
```
Откройте файл определения службы и добавьте элемент **Binding** в раздел **Sites**. В результате будет создана HTTPS-привязка между конечной точкой и вашим сайтом:
```
...
...
```
Теперь все необходимые изменения в файл определения службы внесены. Осталось добавить информацию о сертификате в файл конфигурации службы.
Откройте файл конфигурации службы (CSCFG) и добавьте подраздел **Certificates** в раздел **Role**, заменив указанный ниже отпечаток на соответствующее значение из своего сертификата:
```
...
...
```
После обновления файлов определения и конфигурации службы создайте установочный пакет приложения и загрузите его в Windows Azure. Если вы используете инструмент **cspack**, убедитесь, что флаг **/generateConfigurationFile** отключен, иначе указанная вами информация о сертификате будет перезаписана.
### Этап 3. Загрузите пакет развертывания и сертификат
В установочном пакете используется правильный сертификат, и конечная точка HTTPS добавлена. Теперь можно загрузить пакет и сертификат в Windows Azure через Портал управления.
Войдите в [Портал управления Windows Azure](http://windows.azure.com/) и откройте раздел Hosted Services. Щелкните **New Hosted Service**, введите необходимую информацию о своей службе и нажмите **Add Certificate**.
В разделе **Upload Certificates** укажите путь к файлу SSL-сертификата (.pfx) и пароль на сертификат, а затем нажмите **OK**.
Для создания службы нажмите кнопку **OK**. Когда отобразится состояние **Ready**, переходите к следующему шагу.
### Этап 4. Подключитесь к экземпляру роли по протоколу HTTPS
После развертывания и запуска приложения в Windows Azure необходимо подключиться к нему по HTTPS.
В Портале управления выберите свое приложение, щелкните правой кнопкой мыши ссылку с именем DNS на панели **Properties** и выберите **Copy**.
Вставьте этот адрес в окно веб-браузера, убедитесь, что адрес начинается с **https**, а не **http**, и перейдите на страницу.
Браузер отобразит адрес зеленым цветом, уведомляя о том, что используется соединение по HTTPS. Это также означает, что приложение корректно работает с SSL.
**Примечание.** Если вы используете самоподписанный сертификат, то при подключении к конечной точке HTTPS, связанной с самоподписанным сертификатом, браузер отобразит ошибку. Вы можете решить эту проблему, подписав сертификат в уполномоченном центре, либо просто игнорировать ее.
Дополнительные ресурсы
* [Как связать сертификат со службой](http://msdn.microsoft.com/en-us/library/windowsazure/gg465718.aspx)
* [Как настроить SSL-сертификат на конечной точке HTTPS](http://msdn.microsoft.com/en-us/library/windowsazure/ff795779.aspx) | https://habr.com/ru/post/149939/ | null | ru | null |
# Amazon выпустил фикс для инстансов работающих под Windows Server 2012 R2, предотвращающий потерю сетевых подключений
Сегодня утром получил [уведомление](http://aws.amazon.com/windows/2012r2-network-drivers/) от службы поддержки AWS.
В уведомлении сообщается, что функция «Plug and Play Cleanup» из Windows Server 2012 R2, проверяющая систему на неактивные устройства раз в 30 дней, определяет сетевые карточки EC2 (единственный способ доступа к инстансу), как неактивные. Как следствие, устройство удаляется из системы и при следующей перезагрузке доступ к инстансу будет потерян. Если доступ к инстансу еще не потерян, удостовериться, что инстанс не подвержен данной проблеме и предотвратить отключение сетевых интерфейсов можно с помощью специально выпущенного скрипта, который можно скачать тут [или](http://ec2-downloads-windows.s3.amazonaws.com/Scripts/RemediateDriverIssue.zip) со [страницы с описанием проблемы](http://aws.amazon.com/windows/2012r2-network-drivers/) на официальном сайте.
##### Инструкция
В архиве лежит сам скрипт и инструкции по применению. Если в кратце, на инстансе от имени администратора нужно выполнить команду:
````
powershell -noprofile -executionpolicy unrestricted -file \RemediateDriverIssue.ps1
Если на инстансе активирован PSRemoting, скрипт также может быть выполнен удаленно, однако при этом нужно либо выключить запись логов (см ниже), либо вручную задать путь для лог-файлов.
В документации также приведен пример, как выполнить скрипт на серии инстансов (as-is, в качестве примера):
$creds = (Get-Credential)
$servers = import-csv c:\serverlist.csv
Foreach($server in $servers)
{
echo d | xcopy /S c:\temp \\$server\c$\RemediateDriverIssue
$session = new-pssession -computername $server -credential $creds
invoke-command -session $session -scriptblock {powershell -noprofile -executionpolicy unrestricted -file C:\RemediateDriverIssue.ps1}
}
```
##### Доступные параметры:
* -disableAutoRepair - Boolean, позволяет отключить фикс в автоматическом режиме
* -force - Boolean, позволяет принудительно записать ключи в реестр даже если скрипт определит, что в этом нет необходимости. По умолчанию false.
* -logPath - Строка, указывающая путь для записи логов: c:\logs\RemediateDriverIssue.log
* -loggingEnabled - Boolean включает или выключает логгирование. По умолчанию true.
##### Верификация работы скрипта
Вывод в шелле отобразит результат работы скрипта.
Пример такого вывода:
```
C:\Users\Administrator>powershell -noprofile -executionpolicy unrestricted -file
RemediateDriverIssue.ps1
20140904_0843:07+00 INFO : Disabling scheduled task Plug and Play Cleanup.
20140904_0843:08+00 INFO : We have disabled the Plug and Play Cleanup scheduled task, please do not re-enable this scheduled task.
20140904_0843:09+00 INFO : This machine was found to be in a non-impacted state.
```
Эта же информация дублируется в лог файле. В моем случае инстанс был подвержен проблеме, но сетевая карточка еще не была удалена.
Существует вероятность, что этой проблеме подвержены и VPS, работающие на Windows Server 2012 R2 и у других провайдеров, поэтому рекомендую проверить наличие задачи "Plug and Play Cleanup" в планировщике, отключить ее, если она там есть и убедиться, что сетевые устройства не были отключены.` | https://habr.com/ru/post/235609/ | null | ru | null |
# Управление освещением и голосовое оповещение о погоде на Raspbery Pi
Управление освещением и голосовое оповещение о погоде. Пример кода и электрическая схема подлючения реле к Raspberry Pi.
Предварительно установите **mplayer** и **alsa**:
```
sudo apt-get install alsa-utils
sudo apt-get install mplayer
```
Также установите **pip** для Python, для легкой установки пакетов. И затем c его помощью установите **feedparser**. Рассказывать не буду, проще найти информацию по запросу «install pip python» в поисковике.
**Сам код для скрипта WebIOPi:**
```
# заставляем работать с кодировкой utf8, необходимо для гугло транслита
# -*- coding: utf-8 -*-
# импорт модулей
import webiopi
import subprocess
import feedparser
# получаем GPIO
GPIO = webiopi.GPIO
# константы на нумерацию портов GPIO
LIGHT = 23
BUTTON1 = 17
BUTTON2 = 22
def setup():
# конфигурируем пины GPIO
GPIO.setFunction(LIGHT, GPIO.OUT)
GPIO.setFunction(BUTTON1, GPIO.IN)
GPIO.setFunction(BUTTON2, GPIO.IN)
def loop():
# ловим нажатие кнопки 1
if (GPIO.digitalRead(BUTTON1) == GPIO.HIGH):
# инвертируем значение на пине (программный свитч)
GPIO.digitalWrite(LIGHT, not GPIO.digitalRead(LIGHT))
# ловим нажатие кнопки 2
if (GPIO.digitalRead(BUTTON2) == GPIO.HIGH):
# предупреждаем о задержке
subprocess.call(["mplayer", "http://translate.google.com/translate_tts?tl=ru&ie=UTF-8&q=Пожалуйста, ожидайте, запрашиваю погоду."])
# вытаскиваем погоду
d = feedparser.parse('http://rp5.kz/rss/76334/ru')
# читаем погоду
subprocess.call(["mplayer", "http://translate.google.com/translate_tts?tl=ru&ie=UTF-8&q="+d.entries[0].title])
def destroy():
# заканчиваем работу, выключаем свет )
GPIO.digitalWrite(LIGHT, GPIO.LOW)
```
**Схема:**
Транзистор любой *NPN* структуры, я использовал советский *КТ961Б*, для работы в режиме коммутации подойдет любой. Сопротивление подобрать для необходимого тока открывания транзистора. Реле я взял *SRI-05VDC-SD-C* с напряжением 5 вольт и максимальным током для контактов 10А. Диод *1N4001* вроде, необходим для убирания эффекта самоиндукции катушки реле, иначе попалим транзистор и ногу малинки. Земля на транзисторе общая с питанием реле и малиной.
**Ни в коем случае не питайте реле от GPIO!** Спалите «малину». Перед питанием можно включить реле. А так желательно отдельный источник питания для таких штук. Реле можно и на 12 вольт. Просьба не винить меня за спаленные малины, делаете все на свой страх и риск. Необходимо уметь держать паяльник и знать основы работы с электрическими цепями. Осторожнее в цепях 220 вольт! Это смертельно. | https://habr.com/ru/post/362075/ | null | ru | null |
# ELK Stack для хранения логов Django приложения
Каждый из проектов, который перерастает этап прототипа, нуждается в организации логирования. Грамотное логирования решает уйму проблем и помогает понять состояние проекта. На начальном этапе логирование в файл меня устраивало пока проект не разросся и поиск по логам не начал отнимать время.
Решением было создание централизованного лог хранилища с агрегацией логов и поиском. Выбор пал на ELK стек. ELK — сочетание трех OpenSource проектов: ElasticSearch, Logstash и Kibana. ELK хранит логи, строит графики и есть поддержка полнотекстового поиска с фильтрами. В статье описывается процесс настройки ELK стека для хранения логов Django приложения.
Установка ELK
-------------
Для установки ELK стека будет использоваться Docker, за основу взят репозиторий [docker-elk](https://github.com/deviantony/docker-elk). Изменим настройку Logstash-а, добавим GROK паттерн для матчинга nginx логов и изменим output секцию, чтобы логи Django приложения и nginx логи сохранялись в разных индексах ElasticSearch-а. В итоге logstash.conf выглядит так:
```
input {
beats {
port => 5000
host => "0.0.0.0"
}
}
filter {
if [type] == "nginx" {
grok {
match => { "message" => "%{IPORHOST:remote_ip} - %{DATA:user_name} \[%{HTTPDATE:access_time}\] \"%{WORD:http_method} %{DATA:url} HTTP/%{NUMBER:http_version}\" %{NUMBER:response_code} %{NUMBER:body_sent_bytes} \"%{DATA:referrer}\" \"%{DATA:agent}\"" }
}
}
}
output {
if [type] == "nginx" {
elasticsearch {
hosts => "elasticsearch:9200"
index => "nginx-%{+YYYY.MM.dd}"
}
}
else if [type] == "django" {
elasticsearch {
hosts => "elasticsearch:9200"
index => "django-%{+YYYY.MM.dd}"
}
}
else {
elasticsearch {
hosts => "elasticsearch:9200"
index => "unknown_messages"
}
}
}
```
После внесения изменений запускаем стек:
```
docker-compose up
```
После запуска стек слушает следующее порты:
* 5000: Logstash TCP input.
* 9200: Elasticsearch HTTP
* 9300: Elasticsearch TCP transport
* 5601: Kibana
Архитектура логирования
-----------------------
Рассмотрим архитектуру логирования Django приложения.
Как видно из схемы, приложение состоит из сервисов: nginx, django application, celery worker. Каждый из сервисов отправлял логи в ELK стек. Рассмотрим настройку каждого сервиса по отдельности.
Запись Nginx логов в ELK
------------------------
Для работы с nginx логами потребуется дополнительный сервис Filebeat. Процесс установки Filebeat детально описан на [официальном сайте](https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-installation.html). Пример установки Filebeat сервиса на Ubuntu сервер:
```
curl -L -O https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-6.4.0-amd64.deb
sudo dpkg -i filebeat-6.4.0-amd64.deb
```
Filebeat будет читать логи из файла и отправлять в Logstash. Пример конфигурации:
```
filebeat.inputs:
- type: log
enabled: true
paths:
- /var/log/nginx/access.log
fields:
type: nginx
fields_under_root: true
scan_frequency: 5s
output.logstash:
hosts: ["logstash:5000"]
```
Запускаем наш Filebeat сервис и наблюдаем за появлением логов в Kibana.
Запись Django логов в ELK
-------------------------
Для взаимодействия Django с сервисом Logstash установите дополнительный пакет [Python-logstash](https://pypi.org/project/python-logstash/).
```
pip install python-logstash
```
Изменим настройки Django приложения, чтобы логи отправлялись в Logstash сервис.
```
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'simple': {
'format': 'velname)s %(message)s'
},
},
'handlers': {
'console': {
'level': 'INFO',
'class': 'logging.StreamHandler',
'formatter': 'simple'
},
'logstash': {
'level': 'INFO',
'class': 'logstash.TCPLogstashHandler',
'host': 'logstash',
'port': 5000,
'version': 1,
'message_type': 'django', # 'type' поле для logstash сообщения.
'fqdn': False,
'tags': ['django'], # список тег.
},
},
'loggers': {
'django.request': {
'handlers': ['logstash'],
'level': 'INFO',
'propagate': True,
},
...
}
}
```
После этого приложение будет отправлять логи в Logstash. Пример использования:
```
import logging
logger = logging.getLogger(__name__)
def test_view(request, arg1, arg):
...
if is_error:
# Отправляем лог сообщение
logger.error('Something went wrong!')
```
После этого настройте Kibana под себя, чтобы отображать необходимую информацию. Пример скриншотов собственной настройки:
Система собирает логи сервисов, позволяет по ним удобно искать, строить графики и визуализации, позволяя в кратчайшие сроки обнаружить и исправлять проблемы. | https://habr.com/ru/post/421819/ | null | ru | null |
# Запросить 100 серверов нельзя оптимизировать код. Ставим запятую
Можно выделить ряд алгоритмов, которые являются базовыми и лежат в основе практически каждой строчки программ, написанных на языках высокого уровня. Хорошо иметь под руками классический многотомный труд Дональда Кнута ["The Art of Computer Programming"](https://en.wikipedia.org/wiki/The_Art_of_Computer_Programming), там детально разобраны многие базовые алгоритмы. Но прочесть и усвоить все — задача, требующая много усилий и времени, которая должна как-то быть мотивирована.
Многие могут предположить, что нюансы необходимо было знать 50 лет назад, а сейчас можно пользоваться готовыми пакетами и функциями и не погружаться в детали. Однако, это далеко не так. Равно как никто не отменял важность понимания представления методов хранения данных в памяти и их обработки в процессоре.
Далее разберем нюансы на примере функций сортировки. Сортировка и поиск используются максимально часто во всех манипуляциях с данными. Экономия нескольких миллисекунд на операции может приводить к суммарному сокращению часов расчета на значительных данных.
Является продолжением [серии предыдущих публикаций](https://habrahabr.ru/users/i_shutov/posts/).
Введение
========
Сформулируем упрощенную постановку задачи, на основе практических задач по работе с временными рядами. Исследуется набор данных, содержащих некоторое количество прецедентов, в рамках которых происходят определенные последовательности событий.
Допустим, что для алгоритмической отработки необходимо подготовить тестовый датасет, содержащий три колонки:
* `case_id` — уникальный идентификатор кейса/прецедента;
* `record` — журнальная запись события в кейсе;
* `start` — время регистрации.
Используемые библиотеки
```
library(tidyverse)
library(data.table)
library(rTRNG)
```
Наиболее интересной задачей является генерация временных меток. События должны идти последовательно во времени для каждого кейса в отдельности. Сначала подготовим простую "рыбу". В частном случае мы возьмем для демонстрации малое число кейсов. В продуктиве их может быть `10^5-10^n`, что определяется задачами.
**Пример кода**
```
# определим число кейсов
nn <- 100
# создаем первичный набор кейсов
records <- c("first", "one and a half", "second", "third", "fourth",
"fifth", "sixth")
# готовим два варианта для экспериментов
df <- tibble(case_id = 1:nn, recs = list(records)) %>%
unnest(recs)
dt <- as.data.table(df)[, case_id := as.numeric(case_id)]
# указание ключа приводит к физической сортировке данных
setkey(dt, case_id)
head(df, 10)
```
```
# A tibble: 10 x 2
case_id recs
1 1 first
2 1 one and a half
3 1 second
4 1 third
5 1 fourth
6 1 fifth
7 1 sixth
8 2 first
9 2 one and a half
10 2 second
```
Теперь приступим к интересному блоку — генерации временных меток. Для простоты задачи сведем ее к распределению долей в интервале `[0; 1]` в рамках каждого кейса. Перевод в реальный unixtimestamp оставим за пределами, это неинтересно. Варианты с явными циклами также за пределами. Времена исполнения приведены на условном компьютере, главное, что выполняется все на одном.
Создание одной временнОй метки
------------------------------
### Вариант 1. Прямолинейный
Этот вариант предлагается в большинстве случаев. А что, все просто и понятно.
**Пример кода**
```
f1 <- function(df) {
df %>%
group_by(case_id) %>%
mutate(t_idx = sort(runif(n(), 0, 1))) %>%
ungroup()
}
```
Получаем такие условные показатели. Наверное, неплохо. Но не забываем, что тут всего 100 кейсов.
```
median `itr/sec` mem_alloc
15.38ms 63.2 284.9KB
```
Подумаем, что можно улучшить?
### Вариант 1+1/2. Прямолинейный + быстрый генератор чисел
Есть хорошая библиотека `rTRNG`. На больших объемах она дает существенное ускорение, в том числе, за счет параллельной генерации. Просто проверим:
**Пример кода**
```
f1_5 <- function(df) {
df %>%
group_by(case_id) %>%
mutate(t_idx = sort(runif_trng(n(), 0, 1))) %>%
ungroup()
}
```
```
median `itr/sec` mem_alloc
29.34ms 29.5 284.9KB
```
На малых объемах не получили никакого выигрыша. Это все? Конечно же нет. Мы знаем, что `tidyverse` медленнее `data.table`, попробуем применить его.
### Вариант 2. Однопроходный, через индексы data.table
Здесь мы попробуем применить первую хитрость — отсортировать вектор времен по индексам, а потом его переприсвоить.
**Пример кода**
```
f2 <- function(dt) {
# здесь полагаемся на то, что мы заранее отсортировали уже по `case_id``
# формируем случайные числа и сортируем их по кейсам
vec <- dt[, t_idx := runif_trng(.N, 0, 1)][order(case_id, t_idx), t_idx]
# возвращаем сортированный
dt[, t_idx := vec]
}
```
Получается вполне неплохо, ускорение раз в 15-20 и памяти требуется почти в три раза меньше.
```
median `itr/sec` mem_alloc
1.69ms 554. 109KB
```
Останавливаемся? А почему да?
### Вариант 3. Однопроходный, через композитный индекс
На самом деле, как только мы сваливаемся в цикл, явный, или через `by`, мы резко просаживаемся в производительности. Попробуем сделать все за один проход. Идея следующая — сделать композитный индекс, который позволил бы нам отсортировать все события одним махом. Используем трюк. Поскольку у нас внутри кейса все временные метки будут в диапазоне `[0; 1]`, то мы можем разделить индекс на две части. Целочисленная часть будет содержать `case_id`, дробная часть — временнУю долю. Однократная сортировка одного такого индекса сохранит принадлежность строчек `case_id`, при этом мы одним махом отсортируем значения внутри каждого кейса
**Пример кода**
```
f3 <- function(dt) {
# делаем трюк, формируем композитный индекс из case_id, который является монотонным, и смещением по времени
# поскольку случайные числа генерятся в диапазоне [0, 1], мы их утаскиваем в дробную часть (за запятую)
# сначала просто генерируем случайные числа от 0 до 1 для каждой записи отдельно
# и масштабируем одним вектором
dt[, t_idx := sort(case_id + runif_trng(.N, 0, 1, parallelGrain = 10000L)) - case_id]
}
```
Запускаем и получаем выигрыш еще в 2 раза против предыдущего варианта, как по времени, так и по памяти.
```
median `itr/sec` mem_alloc
826.7us 1013. 54.3KB
```
### Вариант 3+1/2. Однопроходный, через композитный индекс, используем `set`
Останавливаемся? Можно и остановиться, хотя поле для сжатия еще есть. Дело в том, что при таких малых временах исполнения накладные расходы на NSE становятся весьма ощутимыми. Если использовать прямые функции, то можно получить куда лучший результат.
**Пример кода**
```
f3_5 <- function(dt) {
set(dt, j = "t_idx",
value = sort(dt$case_id + runif(nrow(dt), 0, 1)) - dt$case_id)
}
```
Ускорение еще в 5 раз, памяти потребляем в 4 раза меньше
```
median `itr/sec` mem_alloc
161.5us 5519. 16.3KB
```
### Промежуточное подведение итогов
Соберем все вместе.
**Тестируем**
```
bench::mark(
f1(df),
f1_5(df),
f2(dt),
f3(dt),
f3_5(dt),
check = FALSE
)
```
```
expression min median `itr/sec` mem_alloc
1 f1(df) 14.3ms 15.38ms 63.2 284.9KB
2 f1\_5(df) 24.43ms 29.34ms 29.5 284.9KB
3 f2(dt) 1.55ms 1.69ms 554. 109KB
4 f3(dt) 722us 826.7us 1013. 54.3KB
5 f3\_5(dt) 142.5us 161.5us 5519. 16.3KB
```
Путем изучения принципов работы алгоритмов и пристального взгляда на задачу первичный наивный вариант удалось **бесплатно улучшить** по производительности **в 90 раз**, а потребление памяти сократить **в 18 раз**. Это показатели, которые слабо достижимы горизонтальным масштабированием серверов.
Создание временнОй метки начала записи и окончания
--------------------------------------------------
Усложним немного задачу. Теперь для каждой записи надо сформировать время начала и время окончания ("прием у врача"). При этом все записи должны соблюдать исходный порядок следования во времени и время окончания для каждой записи должно быть не раньше времени начала.
Количество рассматриваемых сценариев сократим, оставим только наиболее интересные. И всякие варианты с явными циклами тоже даже не упоминаем.
### Вариант 1. Прямолинейный
Первый наиболее разумный и очевидный вариант — создать метки начала, как в предыдущей задаче и потом для каждой метки поставить случайное окончание, так, чтобы соблюдались правила. Итерируем построчно, есть специфика, что долевое начало следующего кейса будет, как правило, меньше, чем начало последней операции предыдущего. Но это тоже решаемо. Код может выглядеть примерно так:
**Пример кода**
```
# Cоздание ЧЕТЫРЕХ колонок -- case_id, record, start, finish
# Все как в предыдущем, только для каждого записи finish > start
# и для двух последовательных записей 1, 2 в одном кейсе start_2 > finish_1
dt[, t_idx := NULL] # очистим хвосты предыдущего упражнения
f1 <- function(df) {
df %>%
group_by(case_id) %>%
mutate(ts_idx = sort(runif(n(), 0, 1))) %>%
ungroup() %>%
# еще раз пройдемся генератором, используя время начала следующей записи как границу
# чтобы избежать NaN при переходе между кейсами (в случае max < min),
# принудительно выставим порог 1 в таких переходах, NA в последней строке тоже заменим на 1
mutate(tf_idx = {lead(ts_idx, default = 1) %>% if_else(. > ts_idx, ., 1)}) %>%
mutate(tf_idx = map2_dbl(ts_idx, tf_idx, ~runif(1, .x, .y)))
}
```
В целом меньше секунды, но, очевидно, что это ОЧЕНЬ далеко от оптимальности.
```
median `itr/sec` mem_alloc
28.16ms 30.7 2.06MB
```
### Вариант 2. Однопроходный, через композитный индекс и матрицы
Идея следующая. Нам нужно получить 2 колонки, в которых значения будут отсортированы строчка за строчкой и значение первой колонки не превышает значение второй колонки для каждой строки. Но это же матрица! Матрица — это единый кусок в памяти, который сопровождается атрибутами сегментирования. Работа с ними куда быстрее классических датафреймов.
**Пример кода**
```
f2 <- function(dt){
dt[, c("ts_idx", "tf_idx") := {
# используем принцип vector recycling
x <- case_id + runif(2 * .N, 0, 1);
m <- matrix(sort(x), ncol = 2, byrow = TRUE) - case_id;
list(m[, 1], m[, 2])
}]
}
```
В легкую сократили время и память почти в 30 раз! Да и код стал существенно проще и прямолинейнее.
```
median `itr/sec` mem_alloc
1.04ms 733. 74.38KB
```
### Вариант 2+1/2. Однопроходный, через композитный индекс, матрицы и `set`
**Пример кода**
```
f2_5 <- function(dt){
x <- dt$case_id + runif(2 * nrow(dt), 0, 1)
m <- matrix(sort(x), ncol = 2, byrow = TRUE) - dt$case_id
set(dt, j = "ts_idx", value = m[, 1])
set(dt, j = "tf_idx", value = m[, 2])
}
```
Перфекционизм в действии. Еще в 4 раза ускорили.
```
median `itr/sec` mem_alloc
278.1us 2781. 57.55KB
```
### Промежуточное подведение итогов
Соберем все вместе.
**Тестируем**
```
bench::mark(
f1(df),
f2(dt),
f2_5(dt),
check = FALSE
)
```
```
median `itr/sec` mem_alloc
28.16ms 30.7 2.06MB
1.04ms 733. 74.38KB
278.1us 2781. 57.55KB
```
Первичный наивный вариант также удалось **бесплатно улучшить** по производительности **в 90 раз**, а потребление памяти сократить **в 35 раз**.
Заключение
==========
Примеры вполне себе реальные, каждый может поэкспериментировать на своей машине. Абсолютные показатели будут, естественно, отличаться, но тренд останется неизменным. Чтобы убедиться, что большое количество кода в мире пишется по самым наивным вариантам, достаточно пошерстить репозитории на гитхабе. И ведь не всегда значительная оптимизация — это громадный непонятный код и уйма времени, см. примеры выше. Оптимизированный код даже компактнее и прозрачнее, устраняются промежуточные пассы.
Поэтому, когда представители BigData запрашивают немалые вычислительные ресурсы и требуемое время для относительно небольшой задачи, всегда терзает смутное сомнение, что под капотом что-то не то.
P.S.
Как обычно, пожелание к читателям. Если есть возражения и вопросы и хотите поставить `-` — пишите комментарий. Продуктивная дискуссия интересна.
Снобы молчуны-минусовщики скушны до оскомины.
Предыдущая публикация — [«Оценка структуры кредитного портфеля с помощью R»](https://habr.com/ru/post/558250/).
[](https://ruvds.com/news/read/142?utm_source=habr&utm_medium=article&utm_campaign=i_shutov&utm_content=zaprosit_100_serverov_nelzya_optimizirovat_kod._stavim_zapyatuyu)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=i_shutov&utm_content=zaprosit_100_serverov_nelzya_optimizirovat_kod._stavim_zapyatuyu) | https://habr.com/ru/post/562906/ | null | ru | null |
# Пожалуйста, прекратите писать shell-скрипты
Когда вы автоматизируете какую-либо задачу, например, упаковываете свое приложение для Docker, то часто сталкиваетесь с написанием shell-скриптов. У вас может быть bash-скрипт для управления процессом упаковки и другой скрипт в качестве точки входа в контейнер. По мере возрастающей сложности при упаковке меняется и ваш shell-скрипт.
Все работает хорошо.
И вот однажды shell-скрипт совершает что-то *совсем неправильное*.
Тогда вы осознаете свою ошибку: bash, и вообще shell-скрипты, в основном, по умолчанию не работают. Если с самого начала не проявить особую осторожность, любой shell-скрипт достигнув определенного уровня сложности почти гарантированно будет глючным... а доработка функций корректности будет довольно затруднительна.
Проблема с shell-скриптами
--------------------------
Давайте сосредоточимся на bash в качестве конкретного примера.
#### Проблема №1: Ошибки не останавливают выполнение
Рассмотрим следующий shell-скрипт:
```
#!/bin/bash
touch newfile
cp newfil newfile2 # Deliberate typo
echo "Success"
```
Как вы думаете, что произойдет, когда мы его запустим?
```
$ bash bad1.sh
cp: cannot stat 'newfil': No such file or directory
Success
```
Скрипт продолжал выполняться, даже если команда завершилась неудачно! Сравните это с Python, где исключение не позволяет выполнить последующий код.
Вы можете решить эту проблему, добавив `set -e` в начало shell-скрипта:
```
#!/bin/bash
set -e
touch newfile
cp newfil newfile2 # Deliberate typo, don't omit!
echo "Success"
```
А теперь:
```
$ bash bad1.sh
cp: cannot stat 'newfil': No such file or directory
```
#### Проблема №2: Неизвестные переменные не вызывают ошибок
Далее рассмотрим следующий скрипт, который пытается добавить каталог в переменную окружения PATH. PATH — это способ определения местоположения исполняемых файлов.
```
#!/bin/bash
set -e
export PATH="venv/bin:$PTH" # Typo is deliberate
ls
```
Когда мы его запускаем:
```
$ bash bad2.sh
bad2.sh: line 4: ls: command not found
```
Он не может найти ls, потому что мы допустили опечатку, написав $PTH вместо $PATH, при этом bash не жалуется на неизвестную переменную окружения. В Python вы получили бы исключение `NameError`; на скомпилированном языке код даже не компилировался бы. В bash скрипт просто продолжает выполняться; что может пойти не так?
Решением является параметр `-u`:
```
#!/bin/bash
set -eu
export PATH="venv/bin:$PTH" # Typo is deliberate
ls
```
А теперь bash нашел опечатку:
```
$ bash bad2.sh
bad2.sh: line 3: PTH: unbound variable
```
#### Проблема №3: Пайпы не отлавливают ошибки
Мы думали, что разобрались с неработающими командами с помощью set -e, но это не решило всех проблем:
```
#!/bin/bash
set -eu
nonexistentprogram | echo
echo "Success!"
```
и когда мы запускаем его:
```
$ bash bad3.sh
bad3.sh: line 3: nonexistentprogram: command not found
Success!
```
Решение `set -o pipefail`:
```
#!/bin/bash
set -euo pipefail
nonexistentprogram | echo
echo "Success!"
```
Теперь:
```
$ bash bad3.sh
bad3.sh: line 3: nonexistentprogram: command not found
```
На данный момент мы имплементировали (большую часть) [неофициального "строгого" режима bash](http://redsymbol.net/articles/unofficial-bash-strict-mode/). Но и этого все еще недостаточно.
#### Проблема №4: Subshells работают странно
Используя синтаксис `$()`, вы можете запустить subshell (подоболочку):
```
#!/bin/bash
set -euo pipefail
export VAR=$(echo hello | nonexistentprogram)
echo "Success!"
```
Когда мы ее запустим:
```
$ bash bad4.sh
bad4.sh: line 3: nonexistentprogram: command not found
Success!
```
Что происходит? Ошибки в подоболочках не воспринимаются, если они являются частью аргументов команды. Это означает, что ошибка в подоболочке просто отбрасывается.
Единственное исключение — это непосредственная установка переменной, поэтому нам нужно написать код следующим образом:
```
#!/bin/bash
set -euo pipefail
VAR=$(echo hello | nonexistentprogram)
export VAR
echo "Success!"
```
Теперь наша программа работает правильно:
```
$ bash good4.sh
good4.sh: line 3: nonexistentprogram: command not found
```
Возможно, это достаточная демонстрация плохого поведения bash, но далеко не *полная*.
О некоторых нежелательных причинах для использования shell-скриптов
-------------------------------------------------------------------
Каковы могут быть причины, по которым вы все равно захотите использовать shell-скрипты?
#### Плохая причина №1: Это всегда там есть!
Практически каждая вычислительная среда Unix имеет базовую оболочку (shell). Поэтому, если вы пишете какие-то скрипты для упаковки или запуска, возникает соблазн использовать инструмент, который уже там присутствует.
Дело в том, если вы упаковываете Python-приложение, то практически наверняка в среде разработки, CI и среде выполнения будет установлен Python. Так почему бы не использовать язык программирования, который по умолчанию обрабатывает ошибки?
По большому счету, практически каждый язык программирования с достаточно большой пользовательской базой содержит какую-то скрипт-ориентированную библиотеку или идиомы. В Rust, например, есть [xshell](https://docs.rs/xshell/), а также другие библиотеки. Так что в большинстве случаев вы можете использовать свой язык программирования вместо shell-скрипта.
#### Плохая причина №2: Просто пишите правильный код!
В теории, если вы знаете, что делаете, сохраняете концентрацию и не забываете о бойлерплейте, то можете писать правильные shell-скрипты, даже довольно сложные. А также написать юнит-тесты.
На практике:
* Вы, вероятно, работаете не один; вряд ли каждый в вашей команде обладает соответствующим опытом.
* Любой человек устает, отвлекается и допускает ошибки.
* Почти в каждом сложном shell-скрипте, который я видел, отсутствовал вызов `set -euo pipefail`, и добавить его постфактум довольно сложно (обычно невозможно).
* Не помню, чтобы я когда-либо видел автоматизированный тест для shell-скрипта. Наверняка они существуют, но встречаются довольно редко.
#### Плохая причина №3: Shellcheck обнаружит все эти ошибки!
Если вы пишете shell-программы, [shellcheck](https://www.shellcheck.net/) — очень полезный способ поиска ошибок. К сожалению, его одного недостаточно.
Рассмотрим следующую программу:
```
#!/bin/bash
echo "$(nonexistentprogram | grep foo)"
export VAR="$(nonexistentprogram | grep bar)"
cp x /nosuchdirectory/
echo "$VAR $UNKNOWN_VAR"
echo "success!"
```
Если мы запустим эту программу, она выдаст "success!", несмотря на то, что у нее 4 отдельные проблемы (как минимум):
```
$ bash bad6.sh
bad6.sh: line 2: nonexistentprogram: command not found
bad6.sh: line 3: nonexistentprogram: command not found
cp: cannot stat 'x': No such file or directory
success!
```
Как работает `shellcheck`? Он выявляет некоторые проблемы... но не все:
1. Если вы запустите `shellcheck`, он укажет на наличие неполадок в export.
2. Если вы запустите `shellcheck -o all`, чтобы запустить все проверки, он также укажет на проблему с `echo "$(nonexistentprogram ...)"`. Это при условии, что вы используете версию v0.8, которая была выпущена в ноябре 2021 года. Более ранние версии не имели такой проверки, поэтому любой дистрибутив Linux, предшествующий этой версии, выдаст вам `shellcheck`, который не обнаружит эту проблему.
3. В нем не предлагается `set -euo pipefail`.
Если вы полагаетесь на `shellcheck`, я настоятельно рекомендую обновиться и убедиться, что вы запускаете его с параметром `-o all`.
Прекратите писать shell-скрипты
-------------------------------
В определенных ситуациях shell-скрипты вполне уместны:
* Для разовых скриптов, которые вы администрируете вручную; здесь можно обойтись методами попроще.
* Иногда у вас действительно нет гарантий, что доступен другой язык программирования, и вам нужно использовать `shell`, чтобы все заработало.
* В достаточно простых случаях, когда требуется выполнить несколько команд последовательно, без подоболочек, условной логики или циклов, достаточно использовать `set -euo pipefail` (и обязательно используйте `shellcheck -o all`).
Как только вы обнаружите, что дополнительно делаете что-то сверх этого, начните использовать менее подверженный ошибкам язык программирования. А учитывая, что большая часть программного обеспечения имеет тенденцию со временем расти, лучше всего начинать с чего-то менее ломкого.
---
Материал подготовлен для будущих учащихся на курсах ["Administrator Linux. Professional"](https://otus.pw/q71H/) и ["Administrator Linux. Advanced"](https://otus.pw/WFiK/). Всех желающих приглашаем на бесплатные demo-заняти:
1. «Puppet — система контроля конфигураций». На занятии будет дан обзор архитектуры puppet, его основных инструментов и методов их использования, на практике будет разобран вопрос установки, первоначальной настройки сервера и клиента, а также пример использования: настройка служб, конфигурационных файлов, установка пакетов. [Регистрация](https://otus.pw/9oH1/)
2. «Введение в Docker». На занятии мы рассмотрим основы контейнеризации и ее отличие от виртуализации, плавно перейдем к рассмотрению самого популярного на данный момент инструмента контейнеризации Docker — узнаем, из каких основных компонентов и сущностей он состоит, и как они взаимодействуют между собой. [Регистрация](https://otus.pw/aqgH/) | https://habr.com/ru/post/657841/ | null | ru | null |
# Немного об арифметике
Вы когда-нибудь задумывались о том, как мы считаем? Как устроен счет на низком уровне? Например, как выглядят на прямой единичные отрезки в выражении 1 + 1 = 2. Или что такое квадратный корень из .
Счет появился не просто чтобы считать, а чтобы посчитать какие-то объекты. Например, количество яблок или антилоп в стаде. То есть всегда есть единица измерения.
Можно считать на пальцах или палочках, то есть задать некоторое соответствие между единицами измерения. Одна антилопа — одна палочка. Так как любые другие единицы можно заменить на палочки, то будем рассматривать только их. Палочка это абстрактная единица измерения.
Простые действия
----------------
Надо заметить, что счет идет в порядке возрастания. Такая счетная палочка сама по себе подразумевает наличие следующей палочки. То есть единица измерения имеет направление. А значит это единичный вектор.
Добавляя один единичный вектор в конец другого, мы будем перемещаться по числовой прямой, получая новые значения.
И тут появляется 4 варианта.
Как выглядят концы единичного отрезка? Какой вариант лучше моделирует реальный счет?
Первый не подходит. Двигаясь таким образом, мы никогда не попадем в целое число. Вроде досчитали до 1, а ни первому ни второму вектору оно не принадлежит.
Четвертый тоже не подходит. Если мы в точке 1, то непонятно, это первый вектор или второй. Когда мы считаем овечек, прыгающих через забор, у них нет общих точек.
Второй выглядит самым правильным. Дошли до точки 1 — значит отсчитали 1 объект. Каждая точка принадлежит одному вектору. Его мы и будем использовать в дальнейшем.
Третий тоже выглядит подходящим. Но у него есть особенность — точка 0 принадлежит первому вектору. Когда еще ничего нет, мы считаем что что-то уже есть. Это не похоже на реальный счет. Зато похоже на счет, используемый в компьютерах. Первая 32-разрядная ячейка в оперативной памяти занимает байты с адресами 0, 1, 2, 3. Чтобы было похоже на счет реальных объектов, надо было бы отсчитывать от адреса 1\*4 и брать байты со смещением 0, -1, -2, -3.
Значит, второй вариант.
Обратите внимание, ноля здесь нет. Если просто считать по порядку, то не совсем очевидно, что точка отсчета не первая единица, а что-то до нее. Возможно поэтому ноль появился позже появления собственно счета.
Результат сложения можно представить в виде одного вектора из начальной точки в конечную.
Как сделать вычитание? Для этого надо добавить в рассмотрение вектор, направленный в обратную сторону.
Будем считать, что закрашенная точка означает стрелочку, то есть показывает направление вектора.
Чтобы различать эти вектора, назовем их соответственно положительным и отрицательным.
Можно ввести операцию изменения направления. После применения ее к положительному вектору получается отрицательный. После применения ее 2 раза получается исходный вектор. По-другому ее можно назвать «унарный минус» или «смена знака».
Отрицательные вектора тоже образуют последовательность.
Если бы мы рассматривали только отрицательное направление, можно было бы использовать те же числа, что и для положительного, то есть без знака. Но мы рассматриваем оба, и надо отличать отсчеты в положительном и отрицательном направлении. Поэтому у чисел в отрицательном направлении стоит знак «минус». Можно и положительные числа обозначить знаком «плюс», но это необязательно, отличие и так есть.
Что это означает? Что есть положительный и отрицательный 0. Геометрически они находятся в одной точке. Это связывает положительный и отрицательный луч направления счета.
Ноль можно рисовать закрашенным, но для этого надо ввести особый вектор нулевой длины, к которому и прибавлять единичные. Его можно получить из единичных векторов.
3 + -3 = 0
Технически у него левый край тоже не включен, но правый край находится в той же точке. То есть вектор превращается в точку, или по-другому, точка это частный случай вектора.
Интересный момент, мы можем подойти к нулю слева или справа. Соответственно и знак у него будет положительный или отрицательный. Что-то похожее упоминается [здесь](https://ru.stackoverflow.com/a/614526).
Раз точка 0 это вектор нулевой длины, то можно сказать, что и отдельно взятая на прямой точка 1, или 2, или 3, это тоже вектор нулевой длины. Получается, есть нулевые векторы, которые связаны ненулевыми. Это решает вопрос, почему отрезок ненулевой длины состоит из бесконечного числа точек нулевой длины. Потому что точки всегда соединены ненулевыми векторами. Это две противоположности, которые образуют систему. Как 0 и 1 в двоичной системе счисления.
С умножением все просто — берем целиком второй вектор столько раз, сколько единиц в первом векторе.
С делением сложнее. Так же как вычитание это сложение со сменой знака, так и деление это умножение на обратное число. То есть надо задать способ получения вектора 1/N. Так как он меньше единичного вектора, надо ввести более мелкую единицу измерения.
Например, как разделить вектор длиной 12 на 10 частей? Вводим новый вектор некоторой длины и задаем условие, что этот вектор, повторенный 10 раз, дает исходный единичный вектор. В результате снова получаем вычисления в целых числах. 120 мелких векторов делим на 10 частей, получаем 12 мелких или 1.2 единичного.
Как выразить через такие векторы число пи? Никак. Точное выражение через единицы измерения означает точную десятичную запись. Точно так же нельзя выразить ими число  = 0.333(3). Иначе надо будет до бесконечности вводить все более мелкие единицы измерения. Можно только обозначить эти числа другим способом — буквой или выражением.
Число  = 0.5 можно выразить, но только потому что основание нашей системы счисления кратно этому числу. В десятичной системе все дроби периодические, кроме тех, знаменатели у которых кратны 2 или 5. Это может быть не совсем очевидно, так как мы чаще работаем с конечными дробями
Выходим за границы
------------------
Как попасть в эту точку?
Двигаясь только по прямой мы не можем в нее попасть. Значит, надо ввести еще один единичный вектор, перпендикулярный первому. Ввести положительное и отрицательное направление, определить правила сложения и вычитания между всеми видами векторов. Получается слишком сложно. Много сущностей и заданных правил, к тому же похожих друг на друга.
Что если подойти с другой стороны? Что надо сделать, чтобы попасть в точку в стороне от основного направления? Надо повернуть.
Повернули один вектор и складываем с другим.
Нетрудно заметить, что поворот положительного единичного вектора 2 раза дает отрицательный вектор.
Ничего не напоминает? Да ведь это умножение на мнимую единицу.
Значит что получается.  это не вектор, перпендикулярный вещественному направлению.  это поворот на прямой угол. Это не единица направления, а единица поворота. Умножение вектора на  означает поворот вектора на  через комплексное пространство. Смена знака это поворот 2 раза.
«Комплексное пространство» означает что если мы рассматриваем двумерный график функции , то мнимая часть  находится в плоскости, перпендикулярной поверхности графика. Для ее отображения понадобится третье измерение, а мнимая часть  потребует уже четвертого. Для одномерной числовой прямой достаточно второго.
А что такое квадратный корень из ? Видимо это такое значение, что умножение единичного вектора на него 2 раза дает вектор .
Раз умножение на  это поворот на , то умножение на корень из  это поворот на .
Проверим в Wolfram Alpha.
[](http://www.wolframalpha.com/input/?i=i%5E1%2F2)
Ага, так и есть.
Любое выражение вида  можно представить в виде , где  это длина вектора, а  задает угол поворота как коэффициент для .
При умножении чисел длины перемножаются, а углы складываются.
4 умножения на i возвращают вектор в исходное состояние. График умножения на  с изменением степени по 0.1 дает обычную единичную окружность. Если развернуть ее по оси , получим обычные синус и косинус. Как думаете, как выглядят синус и косинус в 3D? Это спираль.
[
](https://michael-vostrikov.github.io/complex3d/complex3d.html#eyJib3VuZHMiOnsieF9yZSI6eyJmcm9tIjotNCwidG8iOjR9LCJ4X2ltIjp7ImZyb20iOi00LCJ0byI6NH0sInlfcmUiOnsiZnJvbSI6LTQsInRvIjo0fSwieV9pbSI6eyJmcm9tIjotNCwidG8iOjR9fSwieDEiOnsicmUiOnsiZnJvbSI6LTQsInRvIjo0fSwiaW0iOnsiZnJvbSI6MCwidG8iOjB9LCJkZWx0YV9yZSI6MC4xLCJkZWx0YV9pbSI6MH0sIngyIjp7InJlIjp7ImZyb20iOi00LCJ0byI6NH0sImltIjp7ImZyb20iOi00LCJ0byI6NH0sImRlbHRhX3JlIjowLjEsImRlbHRhX2ltIjowLjF9LCJmdW5jMSI6InJldHVybiBtYXRoLmNvbXBsZXgoMCwgMSkucG93KHhfY29tcGxleCkiLCJmdW5jMiI6InJldHVybiBtYXRoLmNvbXBsZXgoMCwgMSkucG93KHhfY29tcGxleCkiLCJwbG90X3R5cGUxIjoic2NhdHRlcjNkIiwicGxvdF90eXBlMiI6InN1cmZhY2UiLCJtYXBwaW5nIjp7IngiOiJ4X3JlIiwieSI6InlfcmUiLCJ6IjoieV9pbSJ9LCJjYW1lcmEiOnsieCI6MTgsInkiOjAsInoiOjB9fQ%3D%3D)
Здесь период целочисленный, так как по  отсчитываются обороты, а не длина окружности.
Картинки кликабельные, по ссылкам интерактивная страница с графиками. В блоке «Axis mappping» определяется, какие 3 из 4 осей показываются в 3D. В поле «Function 1» и «Function 2» находится javascript-код, из которого создается объект типа Function.
В URL хэш, в хэше base64, в base64 json, в json значения полей.
Подписи относятся не к центральным осям, а к линиям, по которым откладываются цифры.
Расчеты в комплексных числах выполняются с помощью [math.js](http://mathjs.org/), графики сделаны с помощью [plotly.js](https://plot.ly/javascript/).
А что если умножать не на , а на ? Вместо окружности получится расходящаяся [логарифмическая спираль](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%B3%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%BF%D0%B8%D1%80%D0%B0%D0%BB%D1%8C).
[
](https://michael-vostrikov.github.io/complex3d/complex3d.html#eyJib3VuZHMiOnsieF9yZSI6eyJmcm9tIjotNCwidG8iOjR9LCJ4X2ltIjp7ImZyb20iOi00LCJ0byI6NH0sInlfcmUiOnsiZnJvbSI6LTQsInRvIjo0fSwieV9pbSI6eyJmcm9tIjotNCwidG8iOjR9fSwieDEiOnsicmUiOnsiZnJvbSI6LTQsInRvIjo0fSwiaW0iOnsiZnJvbSI6MCwidG8iOjB9LCJkZWx0YV9yZSI6MC4xLCJkZWx0YV9pbSI6MH0sIngyIjp7InJlIjp7ImZyb20iOi00LCJ0byI6NH0sImltIjp7ImZyb20iOjAsInRvIjowfSwiZGVsdGFfcmUiOjAuMSwiZGVsdGFfaW0iOjB9LCJmdW5jMSI6InJldHVybiBtYXRoLmNvbXBsZXgoMCwgMSkucG93KHhfY29tcGxleCkiLCJmdW5jMiI6InJldHVybiBtYXRoLmNvbXBsZXgoMCwgMS4xKS5wb3coeF9jb21wbGV4KSIsInBsb3RfdHlwZTEiOiJzY2F0dGVyM2QiLCJwbG90X3R5cGUyIjoic2NhdHRlcjNkIiwibWFwcGluZyI6eyJ4IjoieF9yZSIsInkiOiJ5X3JlIiwieiI6InlfaW0ifSwiY2FtZXJhIjp7IngiOjE4LCJ5IjowLCJ6IjowfX0%3D)
Вернемся ненадолго к делению. Обратное число это степень -1. Это связано с движением по этой логарифмической спирали.
Это график функции . Длина вектора изменяется от  до 2.
[](https://michael-vostrikov.github.io/complex3d/complex3d.html#eyJib3VuZHMiOnsieF9yZSI6eyJmcm9tIjotNCwidG8iOjR9LCJ4X2ltIjp7ImZyb20iOi00LCJ0byI6NH0sInlfcmUiOnsiZnJvbSI6LTQsInRvIjo0fSwieV9pbSI6eyJmcm9tIjotNCwidG8iOjR9fSwieDEiOnsicmUiOnsiZnJvbSI6LTEsInRvIjoxfSwiaW0iOnsiZnJvbSI6MCwidG8iOjB9LCJkZWx0YV9yZSI6MC4xLCJkZWx0YV9pbSI6MH0sIngyIjp7InJlIjp7ImZyb20iOi00LCJ0byI6NH0sImltIjp7ImZyb20iOjAsInRvIjowfSwiZGVsdGFfcmUiOjAuMSwiZGVsdGFfaW0iOjB9LCJmdW5jMSI6InJldHVybiBtYXRoLmNvbXBsZXgoMCwgMikucG93KHhfY29tcGxleCkiLCJmdW5jMiI6IiIsInBsb3RfdHlwZTEiOiJzY2F0dGVyM2QiLCJwbG90X3R5cGUyIjoiIiwibWFwcGluZyI6eyJ4IjoieF9yZSIsInkiOiJ5X3JlIiwieiI6InlfaW0ifSwiY2FtZXJhIjp7IngiOjE4LCJ5IjowLCJ6IjowfX0%3D)
График длины радиуса это обычный экспоненциальный график вида .
Особый случай
-------------
Рассмотрим график функции 
[](https://michael-vostrikov.github.io/complex3d/complex3d.html#eyJib3VuZHMiOnsieF9yZSI6eyJmcm9tIjotNCwidG8iOjR9LCJ4X2ltIjp7ImZyb20iOi00LCJ0byI6NH0sInlfcmUiOnsiZnJvbSI6LTQsInRvIjo0fSwieV9pbSI6eyJmcm9tIjotNCwidG8iOjR9fSwieDEiOnsicmUiOnsiZnJvbSI6LTQsInRvIjo0fSwiaW0iOnsiZnJvbSI6MCwidG8iOjB9LCJkZWx0YV9yZSI6MC4xLCJkZWx0YV9pbSI6MH0sIngyIjp7InJlIjp7ImZyb20iOi00LCJ0byI6NH0sImltIjp7ImZyb20iOjAsInRvIjowfSwiZGVsdGFfcmUiOjAuMSwiZGVsdGFfaW0iOjB9LCJmdW5jMSI6InJldHVybiBtYXRoLmNvbXBsZXgobWF0aC5lLCAwKS5wb3coeF9jb21wbGV4KSIsImZ1bmMyIjoiIiwicGxvdF90eXBlMSI6InNjYXR0ZXIzZCIsInBsb3RfdHlwZTIiOiIiLCJtYXBwaW5nIjp7IngiOiJ4X3JlIiwieSI6InhfaW0iLCJ6IjoieV9yZSJ9LCJjYW1lcmEiOnsieCI6MCwieSI6LTE4LCJ6IjowfX0%3D)
Тождество Эйлера выглядит так:
Это особый случай формулы Эйлера. Что оно означает?
Оно означает, что значение функции  в вещественной точке  c мнимой частью  равно -1.
Добавим график функции .
[](https://michael-vostrikov.github.io/complex3d/complex3d.html#eyJib3VuZHMiOnsieF9yZSI6eyJmcm9tIjotNCwidG8iOjR9LCJ4X2ltIjp7ImZyb20iOi00LCJ0byI6NH0sInlfcmUiOnsiZnJvbSI6LTQsInRvIjo0fSwieV9pbSI6eyJmcm9tIjotNCwidG8iOjR9fSwieDEiOnsicmUiOnsiZnJvbSI6LTQsInRvIjo0fSwiaW0iOnsiZnJvbSI6MCwidG8iOjB9LCJkZWx0YV9yZSI6MC4xLCJkZWx0YV9pbSI6MH0sIngyIjp7InJlIjp7ImZyb20iOjAsInRvIjowfSwiaW0iOnsiZnJvbSI6LTQsInRvIjo0fSwiZGVsdGFfcmUiOjAsImRlbHRhX2ltIjowLjF9LCJmdW5jMSI6InJldHVybiBtYXRoLmNvbXBsZXgobWF0aC5lLCAwKS5wb3coeF9jb21wbGV4KSIsImZ1bmMyIjoicmV0dXJuIG1hdGguY29tcGxleChtYXRoLmUsIDApLnBvdyh4X2NvbXBsZXgpIiwicGxvdF90eXBlMSI6InNjYXR0ZXIzZCIsInBsb3RfdHlwZTIiOiJzY2F0dGVyM2QiLCJtYXBwaW5nIjp7IngiOiJ4X3JlIiwieSI6InhfaW0iLCJ6IjoieV9yZSJ9LCJjYW1lcmEiOnsieCI6MCwieSI6LTIwLCJ6IjowfX0%3D)
Он идет перпендикулярно вещественному и выглядит как . Поэтому , ,  тоже равны -1.
Картинку, которую рисуют [в википедии](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%B6%D0%B4%D0%B5%D1%81%D1%82%D0%B2%D0%BE_%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%B0_(%D0%BA%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7)), можно получить [так](https://michael-vostrikov.github.io/complex3d/complex3d.html#eyJib3VuZHMiOnsieF9yZSI6eyJmcm9tIjotNCwidG8iOjR9LCJ4X2ltIjp7ImZyb20iOi00LCJ0byI6NH0sInlfcmUiOnsiZnJvbSI6LTQsInRvIjo0fSwieV9pbSI6eyJmcm9tIjotNCwidG8iOjR9fSwieDEiOnsicmUiOnsiZnJvbSI6LTQsInRvIjo0fSwiaW0iOnsiZnJvbSI6MCwidG8iOjB9LCJkZWx0YV9yZSI6MC4xLCJkZWx0YV9pbSI6MH0sIngyIjp7InJlIjp7ImZyb20iOjAsInRvIjowfSwiaW0iOnsiZnJvbSI6MCwidG8iOjMuMTR9LCJkZWx0YV9yZSI6MCwiZGVsdGFfaW0iOjAuMDF9LCJmdW5jMSI6InJldHVybiBtYXRoLmNvbXBsZXgobWF0aC5lLCAwKS5wb3coeF9jb21wbGV4KSIsImZ1bmMyIjoicmV0dXJuIG1hdGguY29tcGxleChtYXRoLmUsIDApLnBvdyh4X2NvbXBsZXgpIiwicGxvdF90eXBlMSI6InNjYXR0ZXIzZCIsInBsb3RfdHlwZTIiOiJzY2F0dGVyM2QiLCJtYXBwaW5nIjp7IngiOiJ4X3JlIiwieSI6InlfaW0iLCJ6IjoieV9yZSJ9LCJjYW1lcmEiOnsieCI6MCwieSI6LTE4LCJ6IjowfX0%3D). Отличается значение для оси Y в Axis mapping.
В трехмерном виде получается волнистая поверхность.
[](https://michael-vostrikov.github.io/complex3d/complex3d.html#eyJib3VuZHMiOnsieF9yZSI6eyJmcm9tIjotNCwidG8iOjR9LCJ4X2ltIjp7ImZyb20iOi00LCJ0byI6NH0sInlfcmUiOnsiZnJvbSI6LTQsInRvIjo0fSwieV9pbSI6eyJmcm9tIjotNCwidG8iOjR9fSwieDEiOnsicmUiOnsiZnJvbSI6LTQsInRvIjo0fSwiaW0iOnsiZnJvbSI6LTQsInRvIjo0fSwiZGVsdGFfcmUiOjAuMSwiZGVsdGFfaW0iOjAuMX0sIngyIjp7InJlIjp7ImZyb20iOjAsInRvIjowfSwiaW0iOnsiZnJvbSI6LTQsInRvIjo0fSwiZGVsdGFfcmUiOjAsImRlbHRhX2ltIjowLjF9LCJmdW5jMSI6InJldHVybiBtYXRoLmNvbXBsZXgobWF0aC5lLCAwKS5wb3coeF9jb21wbGV4KSIsImZ1bmMyIjoicmV0dXJuIG1hdGguY29tcGxleChtYXRoLmUsIDApLnBvdyh4X2NvbXBsZXgpIiwicGxvdF90eXBlMSI6InN1cmZhY2UiLCJwbG90X3R5cGUyIjoiIiwibWFwcGluZyI6eyJ4IjoieF9yZSIsInkiOiJ4X2ltIiwieiI6InlfcmUifSwiY2FtZXJhIjp7IngiOjAsInkiOi0yMCwieiI6MH19)
[](https://michael-vostrikov.github.io/complex3d/complex3d.html#eyJib3VuZHMiOnsieF9yZSI6eyJmcm9tIjotNCwidG8iOjR9LCJ4X2ltIjp7ImZyb20iOi00LCJ0byI6NH0sInlfcmUiOnsiZnJvbSI6LTQsInRvIjo0fSwieV9pbSI6eyJmcm9tIjotNCwidG8iOjR9fSwieDEiOnsicmUiOnsiZnJvbSI6LTQsInRvIjo0fSwiaW0iOnsiZnJvbSI6MCwidG8iOjB9LCJkZWx0YV9yZSI6MC4xLCJkZWx0YV9pbSI6MH0sIngyIjp7InJlIjp7ImZyb20iOjAsInRvIjowfSwiaW0iOnsiZnJvbSI6LTQsInRvIjo0fSwiZGVsdGFfcmUiOjAsImRlbHRhX2ltIjowLjF9LCJmdW5jMSI6InJldHVybiBtYXRoLmNvbXBsZXgobWF0aC5lLCAwKS5wb3coeF9jb21wbGV4KSIsImZ1bmMyIjoicmV0dXJuIG1hdGguY29tcGxleChtYXRoLmUsIDApLnBvdyh4X2NvbXBsZXgpIiwicGxvdF90eXBlMSI6InNjYXR0ZXIzZCIsInBsb3RfdHlwZTIiOiJzY2F0dGVyM2QiLCJtYXBwaW5nIjp7IngiOiJ4X3JlIiwieSI6InhfaW0iLCJ6IjoieV9yZSJ9LCJjYW1lcmEiOnsieCI6MCwieSI6LTIwLCJ6IjowfX0%3D)
Чтобы получить последний график, надо дополнительно в консоли запустить функцию `buildFuncSurface()`. В интерфейсе можно задать только 2 серии точек, а на последнем их 3. Для управления сериями есть функции `addTraces()/deleteTraces()`.
Еще есть функция `altform()`, которая показывает запись комплексного числа в виде 
```
console.log(altform(math.i.sqrt()))
0.707106781187 + 0.707106781187i = 1 * i^0.5 = 1 * i^(1/2)
```
Также есть объекты `Plotly` и `math`, которые добавляются библиотеками. | https://habr.com/ru/post/346034/ | null | ru | null |
# Еще один программный ШИМ или реабилитация Attiny13a при помощи Дзен
Приветствую Хабр, и всех его многочисленных обитателей!
Сразу оговорюсь, что то о чём здесь пойдет речь не очень рассчитано на новичков, тем не менее если есть интерес и тяга к изучению, напротив — прошу познать.
А в этот раз, речь пойдет о реализации гибридного ШИМ, которых наплодилось в сети уже множество. Так что думаю еще один, или два, или три (бонусом), будут не лишними или не будут лишними.
Итак, ну во-первых почему гибридный: прежде всего, потому что не аппаратный на 100%, но и не софтварный тоже на 100%.
Что это бы значило: для реализации используется аппаратный счетчик, но вывод формируется не в один канал порта ввода/вывода, а сразу в три, конфигурационной маской, которая маскирует каналы порта в прерывании по таймеру.
В чем отличие от аппаратного? Да все просто — в числе каналов для микроконтроллера Attiny13a.
Теперь подробней.
Кому и зачем это нужно?! Ну основная область применения таких задач, это управление двигателями — асинхронными, биполярными и униполярными — шаговыми, контроллеры световых и звуковых эффектов, ультразвуковые устройства (ультразвуковые ванны, гравёры, смесители и т.п.), и т.д. Конечно для таких целей созданы специализированные контроллеры, но зачем искать, тратиться, и копать ДШ, если есть под рукой маленький питомец.
Я остановился на первом вопросе, когда интерес к нему появился внезапно, при прочтении одного из форумов, где один разработчик (назовем его «Опечаленный»), был опечален тем фактом, что микроконтроллер Attiny13a, не имея достаточного количества аппаратных каналов ШИМ, не может похвастать необходимой производительностью при программной реализации задуманного.
«Опечаленный» испробовал множество вариантов, менял константы, оптимизировал код на Си, даже задействовал прерывания, но всё тщетно. А поднятая им тема на форуме так и протухла, в каком-то лохматом году, оставшись неразрешенной и безответной.
Меня заинтересовало, насколько же медленный программный режим ШИМ у упомянутого микроконтроллера, который работает на 9.6 МГц. И я, набросав маленький исходник, используя по-возможности все аспекты расписанные «Опечаленным» и воплотив их, неспешно получил на трёх лапах Тиника 13-го программный ШИМ, на частоте… около 4 кГц, при программной эмуляции в Proteus.
Мало… Слишком мало! И как то это все странно… но безумно интересно, потому что если не победить такую простую задачу, то это действительно — одно из первых, маленьких разочарований, и прямая дорога в сторону более производительных и навороченных чипов, которые и стоят соответственно. С другой стороны это скорее плюс, но все же будем разбираться.
И тут мне подумалось: «А почему, собственно, синхронизация строится на переполнениях таймера, когда задача реализуется через сравнения?!»
И правда, ведь в режиме переполнения таймер просто обязан вызывать прерывание лишь однажды, при переполнении, пройдя полный цикл. Слегка модифицировав исходник получил около 40 кГц. «Уже лучше, но все равно — тут что-то не так!»
Вобщем не буду больше утомлять: все переменные были объявлены в регистрах, код был оптимизирован по производительности,
и размеру (практически весь исчез), а при дальнейших играх были полученны еще два режима с относительными смещениями импульсов.
А дальше последовали новые оптимизации в результате которых, самый медленный из режимов (6 — фаз) был переписан на инлайновый ассемблер. И сделано это было случайно, когда я обратил внимание на полученный после компиляции код, который мягко просто сказать — сильно меня удивил! Даже при объявлении переменных в регистрах, все операции компилятор решил делать через временные пары, соответственно код раздулся почти вдвое, и это при включенной оптимизации по размеру! Несколько лишних движений и выигрыш в 40 байт, от первого варианта, и почти 10 кГц прироста в частоте.
В результате получилось три режима:
1. Импульсы со смещением в фазу, максимальная доступная частота 75.500 кГц при CLK=9.6 МГц (При CLK=20 МГц, частота приближена к 160 кГц ), скважность ШИМ=33.3% период — три фазы:
2. Импульсы смещены на треть, максимальная частота 37.400 кГц (75 кГц при CLK=20 МГц), скважность=50%, период — шесть фаз (без использования ассемблера не удавалось преодолеть предел в 28 кГц, подробней — см. исходный код):
3. Импульсы смещены на половину, максимальная частота как в первом режиме, скважность=66.6%, период — три фазы:
Под частотой здесь подразумевается полное следование импульсов по трем каналам до повторения в периоде (либо период одного импульса). Да, должен отметить, что изменение скважности в рамки данной задачи не входило, хотя и это очень просто сделать, используя второй регистр сравнения таймера (правда это справедливо только для первого режима). При этом изменение частоты реализовано, и выполнено через изменение ширины фазы (подробнее в тексте исходного кода).
Зачем столько режимов? Это еще не все, и все их множество обусловлено особенностями тех или иных устройств.
Так, например асинхронные двигатели управляются первым режимом, а униполярные-шаговики — вторым (впрочем и каналов им необходимо или меньше, или больше, но при наличии примера, расширить или уменьшить число каналов — пустяк).
Для получения меньшей частоты программно, необходимо изменять регистр делителя таймера.
Если и этого слишком много (например для шаговых двигателей), необходимо опустить частоту микроконтроллера.
Так при частоте чипа 128 кГц, с выставленным делителем CLK, без делителя таймера и минимальной ширине импульса (максимальной частоте), при использовании второго режима, частота импульсов 62 Гц.
Если же говорить об управлении асинхронным двигателем, то при использовании двигателя с 12-ю полями, получаем максимальную частоту следования импульсов при использовании первого режима около 20 кГц (~78/4), что несомненно так же много, ввиду отсутствия двигателей способных вращаться на таких оборотах (в секунду). :o)
Конечно в расчетах выше не отражены накладные расходы, которых требует полное управление, такие как чтение с датчиков Холла или обратной EMF, корректировки длительности фаз и тп. Но с таким запасом в частотах, эти задачи решаются легко, прямо в основном цикле программы.
Отдельно прошу прощения у гуру, которых нервируют условия в одну строку, но здесь это сделано сознательно для удобства быстрого комментирования. Вторая, и более прозаичная причина: я терпеть ненавижу — /\*комментарии со звездочками\*/, хотя при переходе к инлайну — иного не дано.
Если Вы намереваетесь использовать мой код в своем проекте, когда он станет раздуваться и обрастать Вашими обработчиками, необходимо вооружить все объявления использованных переменных в регистрах ключевым словом «volatile», в результате чего компилятор огрызнётся, что он плевать хотел на Ваши запросы, и что в случае, если ему вздумается, то он задействует эти регистры на свое усмотрение (в случае нехватки таковых).
Более подробную информацию я постарался как можно полнее отразить в комментариях, стараясь при этом быть максимально кратким при кодировании:
С удовольствием отвечу на Ваши вопросы, и помогу с изменением конфигураций сигналов, если конечно это потребуется.
При всем выше-сказанном, хочу обозначить: я не позиционирую себя как супер-оптимизатора, супер-программера и супер-электронщика.
Все сказанное я написал для того, чтобы новички верили, что непобедимых задач не бывает, а профессионалы обратили внимание на чипы, которые рано списывать со счетов, и во множестве классов задач им можно найти достойное применение.
PS: Для новичков: ИМХО, проект не достаточно интересен для начинающих, ввиду использования высоких частот. Однако контроллер прошитый прошивкой с раскоментированной строкой в основном цикле для изменения ширины фаз, на частоте 4.8 МГц с включенным делителем частоты (4.8/8) (вот только не помню до оптимизации кода или после), и с подключенными светодиодами на линиях PB0, PB1, PB2, забавно выглядит в роли настольной мигалки.
Хотя некоторые, особо нервные индивиды утверждают, что «раздражает эта фигня — до мозга локтей.» :)
PPS: Для НЕ новичков: в дополнение хочется сказать об оптимизации, и использовании (обойдемся без холивара друзья!) подобного кода:
```
byte A=0, B=1, C=2;
if (A==0 || B==1 || C==2) doSomething(); / if (A==0 && B==1 && C==2) doSomething();
```
И «неправильное» использование вида:
```
if (A==0 | B==1 | C==2) doSomething(); / if (A==0 & B==1 & C==2) doSomething();
```
Результат будет один и тот же, а вот выполняться второй пример будет ЗНАЧИТЕЛЬНО дольше по времени, и ЗНАЧИТЕЛЬНО раздует код.
А почему?! А я не скажу, Вы сами угадайте! :)
На этой ноте предлагаю остановиться, и ознакомиться с прилагаемыми материалами:
[проект для Proteus 8.1 и исходный код созданный в Atmel Studio 6.2](https://drive.google.com/file/d/0B3cBf1lTmLD2MGlrQ2lid3Bib0k/view?usp=sharing)
Спасибо за внимание, до новых встреч!
*Использование в коммерческих проектах, перепродажа исходного кода и использование с целью наживы, запрещено.
Исходные тексты распространяются бесплатно, в случае использования на других сайтах,
либо в других источниках, указание автора и уведомление о размещении — обязательно.* | https://habr.com/ru/post/248393/ | null | ru | null |
# Сделай сам: dll hijacking под MS Office для самых маленьких
Прошло уже три дня с тех пор, как исследователь Parvez Anwar [опубликовал](https://twitter.com/ParvezGHH/status/672433593558396929) информацию о множественных dll hijacking уязвимостях в продуктах Microsoft Office, а какой-либо реакции не наблюдается. Ни CVE, ни сообщений на специализированных ресурсах, Windows Update не качает свежих патчей. Что ж, может, так и нужно, может быть, это не уявимость, а особенность продукта?
Между тем, эксплуатация этой особенности проста и доступна даже ребенку. И, раз уж производитель пока эту «фичу» не удалил, почему бы не написать о ней небольшую статью.
Речь пойдет о Windows 7. Работает ли это на других версиях — мне на текущий момент неизвестно, нужно проверять. Принцип действия описываемого явления (как и многих других, впрочем) основан на старой доброй технологии COM/OLE/ActiveX.
Технология COM призвана воплощать ООП и повторное использование кода, позволяя любым приложениям использовать однажды созданные кем-либо классы (или *компоненты*), если эти классы зарегистрированы в системе. Регистрация компонента по сути представляет собой соответствующие записи в реестре. Каждому классу при его создании назначается уникальный 16-байтовый идентификатор — CLSID, который будет однозначно определять этот компонент в любое время на любом
компьютере. Глобальные идентификаторы всех зарегистрированных в системе классов содержит ветка реестра HKEY\_CLASSES\_ROOT\CLSID.
Исполняемый код компонента должен быть оформлен в виде библиотеки .dll (на самом деле не всегда, но для данной задачи можно упростить). Ссылка на библиотеку содержится в подключе InprocServer32 ключа реестра, соответствующего компоненту.
В случае, когда приложение хочет использовать функциональность, реализованную одним из компонентов, оно отправляет системе запрос на создание экземпляра класса (при этом передается CLSID этого класса). Если такой класс зарегистрирован, система читает реестр и подгружает нужную .dll в адресное пространство процесса, затем вызывает из этой библиотеки код, создающий нужный объект.
А что же приложения MS Office? Кроме того, что они тоже под завязку нашпигованы технологией COM (и даже сами являются COM-объектами), они еще и позволяют создавать/читать документы, содержащие элементы ActiveX.
Фактически такой документ представляет собой файл, содержащий (помимо текста, изображений, форматирования и т.п.) идентификатор компонента и некоторую информацию о свойствах встраиваемого объекта. Давайте посмотрим, как это выглядит на практике.
Открываем MS Word. Если у вас не подключена вкладка «Developer»/«Разработчик», необходимо подключить ее в настройках: File->Options->Customize Ribbon, Файл->Параметры->Настроить ленту, Файл->Параметры Word->Показывать вкладку «Разработчик» на ленте и т.п., в зависимости от того, какая версия MS Office у вас установлена.
Переходим во вкладку «Разработчик» и выбираем кнопку с молотком и гаечным ключом «Инструменты из предыдущих версий».
Затем похожую кнопку «Другие элементы управления».
В появившемся окне выберите ActiveX компонент по своему вкусу, мне нравится Microsoft Forms 2.0 Command Button.
Если открыть реестр и поискать по имени компонента, можно обнаружить, что CLSID нашего контрола
{D7053240-CE69-11CD-A777-00DD01143C57}, а библиотека, содержащая его исполняемый код — FM20.DLL.
Что же будет представлять собой документ, который мы создали? Давайте сохраним его и посмотрим.
Формат .docx это всем известный ZIP. Распаковываем любой подходящей утилитой.
Архив содержит несколько папок с файлами. Нам нужен word\activeX\activeX1.xml
Открываем его обычным текстовым редактором и видим примерно такое содержимое.
```
xml version="1.0" encoding="UTF-8" standalone="no"?
```
Как видно, CLSID элемента управления присутствует и легко может быть заменен.
Теперь нужно сказать пару слов о том, на что, собственно, его можно заменить, а также о том, что такое dll hijacking, и почему это все работает.
Заменить CLSID можно на CLSID любого другого элемента управления, и не только элемента управления, но и любого ActiveX, и даже не только ActiveX, но и любого COM-класса, зарегистрированного в системе (можно и на любой случайный GUID, но это ни к каким интересным последствиям не приведет).
Все дело в том, что, прочитав идентификатор из документа, MS Word передаст его системе, система прежде всего попытается подгрузить библиотеку в память процесса и вызвать из нее первые функции (DllMain, DllGetClassObject, IClassFactory::CreateInstance и т.д.). И **только после этого** приложение начнет выяснять, что это за библиотека, что за компонент, можно ли добавлять его в документ, и нужно это ему вообще. Запросто может оказаться, что компонент не подходит по каким-то критериям, но это выясняется уже после того, как его исполняемый код оказался в виртуальной памяти процесса и получил управление. Он не будет выгружен даже после того, как MS Word точно установил, что ему этот класс не нужен! Такое поведение приводит к целому ряду любопытных явлений, в том числе — к описываемому в данной заметке.
Теперь о dll hijacking. «Угон динамической библиотеки» — обычное, изначальное и даже в чем-то логичное поведение приложения Windows, когда оно ищет необходимую ему библиотеку в той директории, которая является для него текущей, и только затем — в определяемых настройками ОС местах. Все бы было ничего, если бы злоумышленники довольно скоро (и довольно давно) не догадались, что можно положить рядом с документом или ярлыком собственную библиотеку с таким же названием, как и у
библиотеки, которую ожидает найти приложение.
Вообще-то этой технике уже много лет, Microsoft борется с ней давно, упорно, и, как можно видеть, до сих пор не вполне результативно.
На этот раз исследователи обнаружили затерянные в недрах операционной системы Windows 7 несколько dll, которые подгружают другие dll, и ищут их — до сих пор! — в текущей директории процесса. Эти Microsoft'ом забытые оснастки для консоли управления, присадки для Oracle'а и что-то еще столь же известное и часто используемое — оказались еще и COM-классами. Которые, как вы уже догадались, мы можем встроить в обычный документ MS Office.
Вернемся к нашему MS Word и поменяем CLSID в распакованном документе на любой удобный из [отчета
Parvez Anwar](https://twitter.com/ParvezGHH/status/672433593558396929). Например, на первый — {394C052E-B830-11D0-9A86-00C04FD8DBF7}.
```
xml version="1.0" encoding="UTF-8" standalone="no"?
```
Запакуем документ (при необходимости переименуем его обратно в .docx).
Теперь нам нужна собственная dll под именем elsext.dll. Неважно, на чем вы ее создадите, главное, чтобы она имела ту же разрядность, что и пакет MS Office, была способна к загрузке, и вы могли бы добавить свой код в DllMain или DllGetClassObject. Я возьму старый добрый VC6 — у меня 32хбитный офис.
```
#include
int \_\_stdcall DllMain (HANDLE, DWORD, LPVOID)
{
MessageBox (0, "Hello Habrahabr!", 0, MB\_ICONEXCLAMATION);
return true;
}
```
Осталось положить нашу elsext.dll в одну директорию (можно в общей сетевой папке) с модифицированным документом и попросить пользователя этот документ открыть/прочитать.
Еще один момент: с dll hijacking, как вы помните, Microsoft борется. Поэтому при запуске MS Word меняет текущую директорию на «Документы» текущего пользователя. К сожалению (или к счастью) при вызове приложения для открытия документа (например, двойным щелчком в explorer) MS Word **сначала пытается открыть документ** со всеми вытекающими последствиями, и только **потом изменяет свою текущую директорию на «Документы»**. Отсюда вытекает тот факт, что наша dll будет подгружена только в том случае, если пользователь открыл документ двойным щелчком, и MS Word не был до этого запущен (иначе загрузится elsext.dll из system32). | https://habr.com/ru/post/272487/ | null | ru | null |
# Дизайн и эволюция constexpr в C++
`constexpr` - одно из самых магических ключевых слов в современном C++. Оно дает возможность создать код, который будет выполнен еще до окончания процесса компиляции, что является абсолютным пределом для быстродействия программ.
У `constexpr` с каждым годом становится больше возможностей. Сейчас использовать в compile-time вычислениях можно почти всю стандартную библиотеку. Пример вычисления числа до 1000 с наибольшим количеством делителей: [ссылка на код](https://godbolt.org/z/MYTbbsqvT).
История `constexpr` насчитывает долгую историю эволюции с ранних версий C++. Исследуя предложения в стандарт и исходники компиляторов, можно понять, как слой за слоем создавалась эта часть языка, почему именно так она выглядит, как на практике вычисляются `constexpr`-выражения, какие возможности ждут нас в будущем, а какие - могли бы быть, но не были приняты в Стандарт.
Эта статья подходит как тем, кто еще не знает, что такое `constexpr`, так и тем, кто уже долгое время его использует.
C++98 и C++03: Сословия среди const-переменных
----------------------------------------------
В C++ в некоторых местах нужно использовать целочисленные константы, значения которых должны быть известны в compile-time. Стандарт разрешает записывать константы в виде несложных выражений, как в этом коде:
```
enum EPlants {
APRICOT = 1 << 0,
LIME = 1 << 1,
PAPAYA = 1 << 2,
TOMATO = 1 << 3,
PEPPER = 1 << 4,
FRUIT = APRICOT | LIME | PAPAYA,
VEGETABLE = TOMATO | PEPPER,
};
template int foo();
int foo6 = foo<1+2+3>();
int foo110 = foo<(1 < 2) ? 10\*11 : VEGETABLE>();
int v;
switch (v) {
case 1 + 4 + 7:
case 1 << (5 | sizeof(int)):
case (12 & 15) + PEPPER:
break;
}
```
Эти выражения описаны в разделе **[expr.const]** и называются *constant-expression*. Они могут содержать только:
* [Литералы](https://eel.is/c++draft/lex.literal) (туда входят целые числа, это интегральные типы)
* Значения `enum`-ов
* Параметр шаблона интегрального или `enum`-типа (напр., значение `V` из `template`)
* `sizeof`-выражение
* *const*-переменные, инициализированные *constant-expression* - **интересный пункт**
Все пункты, кроме последнего, неудивительны - они точно известны во время компиляции. Переменные - более интересный случай.
Если у переменной static storage, то в обычной ситуации память под нее заполняется нулями и изменяется во время работы программы. Но для переменных из списка выше это *слишком поздно* - вычислять их значения нужно еще до окончания процесса компиляции.
В стандартах C++98/03 есть два вида *static initialization*:
1. *zero-initialization*, память заполняется нулями, затем в ходе программы изменяется
2. *initialization with a constant expression*, память (если нужна) сразу содержит вычисленное значение
[*Note*: Все остальные инициализации называются *dynamic initialization*, мы их не рассматриваем. *— end note*]
[*Note*: *zero-initialized* переменная во время работы программы в свою очередь может быть проинициализирована еще раз "нормальным" значением, это уже будет *dynamic initialization* (пусть даже до старта `main`). *— end note*]
Рассмотрим пример с обоими видами переменных:
```
int foo() {
return 13;
}
const int test1 = 1 + 2 + 3 + 4; // initialization with a const. expr.
const int test2 = 15 * test1 + 8; // initialization with a const. expr.
const int test3 = foo() + 5; // zero-initialization
const int test4 = (1 < 2) ? 10 * test3 : 12345; // zero-initialization
const int test5 = (1 > 2) ? 10 * test3 : 12345; // initialization with a const. expr.
```
Переменные `test1`, `test2`, `test5` можно использовать как параметр шаблона, значение справа от case в switch и т.д., а `test3` и `test4` - нельзя.
Как видно из требований к *constant-expression* и из примера, есть транзитивность - если какая-то составная часть выражения не является *constant-expression*, то и само выражение не является *constant-expression*. При этом рассматриваются только те части выражения, которые реально вычисляются - поэтому `test4` и `test5` попадают в разные группы.
Если нигде не берется адрес *constant-expression* переменной, то скомпилированной программе разрешено не резервировать для нее память, поэтому "заставим" ее это сделать. Выведем значения переменных и их адреса:
```
int main() {
std::cout << test1 << std::endl;
std::cout << test2 << std::endl;
std::cout << test3 << std::endl;
std::cout << test4 << std::endl;
std::cout << test5 << std::endl;
std::cout << &test1 << std::endl;
std::cout << &test2 << std::endl;
std::cout << &test3 << std::endl;
std::cout << &test4 << std::endl;
std::cout << &test5 << std::endl;
}
```
```
izaron@izaron:~/cpp$ clang++ --std=c++98 a.cpp
izaron@izaron:~/cpp$ ./a.out
10
158
18
180
12345
0x402004
0x402008
0x404198
0x40419c
0x40200c
```
Скомпилируем объектный файл и посмотрим на таблицу символов:
```
izaron@izaron:~/cpp$ clang++ --std=c++98 a.cpp -c
izaron@izaron:~/cpp$ objdump -t -C a.o
a.o: file format elf64-x86-64
SYMBOL TABLE:
0000000000000000 l df *ABS* 0000000000000000 a.cpp
0000000000000080 l F .text.startup 0000000000000015 _GLOBAL__sub_I_a.cpp
0000000000000000 l O .rodata 0000000000000004 test1
0000000000000004 l O .rodata 0000000000000004 test2
0000000000000004 l O .bss 0000000000000004 test3
0000000000000008 l O .bss 0000000000000004 test4
0000000000000008 l O .rodata 0000000000000004 test5
```
В конкретной версии компилятора под конкретную архитектуру, в конкретной программе zero-initialized переменные попали в секцию [.bss](https://en.wikipedia.org/wiki/.bss), остальные в секцию `.rodata`.
Загрузчик операционной системы перед запуском загружает программу так, что секция `.rodata` оказывается в сегменте с read-only режимом, который защищен от записи на уровне ОС.
Попробуем через `const_cast` изменить данные по адресу переменных. Стандарт дает уклончивый ответ на тему того, когда запись в результат `const_cast`-а может спровоцировать Undefined Behaviour. По крайней мере, этого не происходит, если мы убираем const с объекта/указателя на объект, который не является фундаментально константным изначально. Т.е. надо различать *физическую* константность и *логическую*.
UB-санитайзер поймает UB (программа крашится), если попытаться изменить `.rodata`-переменную, и его не будет, если записывать в `.bss` или автоматические переменные.
```
const int& ref = testX;
const_cast(ref) = 13; // OK for test3, test4; SEGV for test1, test2, test5
std::cout << ref << std::endl;
```
Таким образом, одни const-переменные "константнее" других. Насколько известно, в то время **не было** простого способа проверить или как-то проконтролировать, что переменная была *initialized with a const. expr.*
0-∞: Вычислитель констант в компиляторе
---------------------------------------
Чтобы представлять, как константые выражения вычисляются во время компиляции, нужно понимать устройство компилятора.
Компиляторы идейно похожи друг на друга, я опишу процесс вычисления на основе компилятора Clang/LLVM. Я скопировал базовую информацию про этот компилятор из своей [прошлой статьи](https://habr.com/ru/post/576052/):
Clang и LLVMПро само устройство Clang и LLVM написано уже много статей. На хабре я бы посоветовал [эту статью](https://habr.com/ru/company/huawei/blog/511854/), чтобы понять их краткую историю и общую схему.
Количество стадий компиляций зависит от того, кто объясняет устройство компилятора. Анатомия компилятора многоуровнева и на самом абстрактном уровне выглядит так, что есть три разные программы:
* **Front-end**: переводит исходник из C/C++/Ada/Rust/Haskell/... в [LLVM IR](https://llvm.org/docs/LangRef.html) - особое промежуточное представление. Фронтендом для C-like языков является **Clang**.
* **Middle-end**: LLVM IR оптимизируется в зависимости от настроек.
* **Back-end**: LLVM IR переводится в машинный код под нужную платформу - x86/Arm/PowerPC/...
Для простых языков реально написать компилятор под [1000 строк](https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/index.html) и получить всю мощь фреймворка LLVM - для этого нужно реализовать фронтенд. Также можно использовать lex/yacc - готовые синтаксические парсеры.
На менее абстрактном уровне находится фронтенд **Clang**, который выполняет такие действия (не рассматривая препроцессор и прочие "микро"-шаги):
* [Лексический анализ](https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7): перевод символов в токены, например `[]() { return 13 + 37; }` преобразуются в `(l_square) (r_square) (l_paren) (r_paren) (l_brace) (return) (numeric_constant:13) (plus) (numeric_constant:37) (semi) (r_brace)`.
* [Синтаксический анализ](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7): создание AST (Abstract Syntax Tree), то есть перевод токенов из предыдущего пункта в вид `(lambda-expr (body (return-expr (plus-expr (number 13) (number 37)))))`.
* Кодогенерация: создание LLVM IR по данному AST.
Итак, вычисление константных выражений (и близкородственных ему вещей, как инстанцирование шаблонов) происходит строго в фронтенде компилятора C++ (в нашем случае в Clang), а LLVM такими вещами не занимается.
"Микросервис", который занимается вычислением константных выражений (от самых простых в C++98 до сложных в C++23), назовем условно **вычислитель констант**.
Если согласно Стандарту в каком-то месте кода ожидается константное выражение; и выражение, которое там находится, действительно удовлетворяет требованиям на константное выражение, то Clang должен "не отходя от кассы" в 100% случаев уметь вычислять его.
Ограничения на константные выражения на протяжении лет постоянно смягчались, а вычислитель констант Clang соответсвенно постоянно усложнялся, вплоть до управления моделью памяти.
Есть [старая документация](https://clang.llvm.org/docs/InternalsManual.html#constant-folding-in-the-clang-ast) 9-летней давности, описывающая вычисление констант для C++98/03. Так как константные выражения тогда были очень простыми, они выполнялись с помощью обычного [constant folding](https://en.wikipedia.org/wiki/Constant_folding) через анализ синтаксического дерева (AST). Так как в синтаксическом дереве все арифметические выражения уже разобраны в виде под-деревьев, то вычисление константы - просто элементарный обход под-дерева.
Исходник вычислителя констант находится в [lib/AST/ExprConstant.cpp](https://clang.llvm.org/doxygen/ExprConstant_8cpp_source.html#l04890) и на момент написания статьи разросся до почти 16 тысяч строк. С годами он научился интерпретировать много всего, например циклы ([EvaluateLoopBody](https://clang.llvm.org/doxygen/ExprConstant_8cpp.html#a1ef92016d7de585132f7a3e452f34afc)), и всё это на синтаксическом дереве.
У константных выражений есть важное отличие от кода, выполняющегося в рантайме - они *обязаны* не допускать undefined behaviour. Если вычислитель констант наткнется на UB, компиляция провалится.
```
c.cpp:15:19: error: constexpr variable 'foo' must be initialized by a constant expression
constexpr int foo = 13 + 2147483647;
^ ~~~~~~~~~~~~~~~
```
Вычислитель констант используется не только для константных выражений, но также для поиска потенциальных багов в остальном коде. Это побочная выгода от технологии. Вот так находится переполнение для не-константного кода (могут максимум бросить warning):
```
c.cpp:15:18: warning: overflow in expression; result is -2147483636 with type 'int' [-Winteger-overflow]
int foo = 13 + 2147483647;
^
```
2003: Макросы не нужны
----------------------
Изменения в стандарт происходят через *предложения*.
Где находятся предложения и из чего они состоят?Все предложения в Стандарт находятся на [open-std.org](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/). Практически все написаны понятно - чаще всего есть:
* Краткий обзор области со ссылками на разделы Стандарта;
* Текущие проблемы;
* Предлагаемое решение проблем;
* Предлагаемые изменения в текст Стандарта;
* Ссылки на предложения-предшественники и прошлые ревизии предложения;
* В особо продвинутых предложениях - ссылки на реализацию в форке компилятора. В тех, что я видел, реализацию делали в форке clang-a.
По ссылкам на предыдущие предложения можно отследить эволюцию для каждого куска C++.
Далеко не все предложения из архива были в итоге приняты (хотя и могли быть использованы как база для других, принятых предложений), поэтому стоит понимать, что они описывают некий альтернативный тому времени вариант C++, а не кусок современного C++.
Принять участие в эволюции C++ может любой - для русскоязычных экспертов есть [stdcpp.ru](https://stdcpp.ru/).
Предложение от 2003 года [[N1521] Generalized Constant Expressions](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1521.pdf) указывает на проблему того, что если часть выражения вычисляется с использованием вызова метода, то выражение не является *constant-expression*. Это заставляет злоупотреблять макросами, если нужно получить более-менее сложное константное выражение:
```
#define SQUARE(X) ((X) * (X))
inline int square(int x) { return x * x; }
// ^^^ определение макроса и метода
square(9)
std::numeric_limits::max()
// ^^^ невозможны в составе constant-expression
SQUARE(9)
INT\_MAX
// ^^^ теоретически могут быть в составе constant-expression
```
Поэтому предлагается ввести понятие *constant-valued* методов, которых будет разрешено использовать в *constant-expression*. Метод считается *constant-valued*, если это inline-метод, нерекурсивный, возвращающий не void, и его тело состоит из единственного выражения вида `return expr;`, где после подстановки аргументов (куда также идут *constant-expression*) получился бы *constant-expression*.
[*Note*: Забегая вперед, термин *constant-valued* не прижился *end note*].
```
int square(int x) { return x * x; } // constant-valued
long long_max(int x) { return 2147483647; } // constant-valued
int abs(int x) { return x < 0 ? -x : x; } // constant-valued
int next(int x) { return ++x; } // NOT constant-valued
```
Таким образом, все переменные `test1-5` из прошлого раздела становились бы "фундаментально" константными, без изменения в коде.
Предложение считает, что можно пойти еще дальше и надо рассмотреть вариант, что такой код тоже должен компилироваться:
```
struct cayley {
const int value;
cayley(int a, int b)
: value(square(a) + square(b)) {}
operator int() const { return value; }
};
std::bitset s; // eq. to bitset<10133>
```
Потому что переменная `value` "фундаментально константная" - инициализировалась в конструкторе через *constant-expression* с двумя вызовами *constant-valued* метода. То есть, согласно общей логике предложения, этот код можно свести примерно к такому (вынос переменных и методов вне структуры):
```
// имитация вызова конструктора cayley::cayley(98, -23) и operator int()
const int cayley_98_m23_value = square(98) + square(-23);
int cayley_98_m23_operator_int() {
return cayley_98_m23_value;
}
// создание битсета
std::bitset s; // eq. to bitset<10133>
```
Предложения обычно не идут далеко в дебри подробностей, как компиляторы могут его реализовать. В этом предложении пишут, что сложностей возникнуть не должно, и надо немного поправить constant folding, которые есть в большинстве компиляторов.
[*Note*: Однако предложения не существуют в отрыве от компиляторов - если предложение нереально реализовать в разумный срок, его вряд ли примут *end note*].
Как с переменными, программист не может проконтролировать, что метод является *constant-valued*.
2006-2007: Тайное становится явным
----------------------------------
К счастью, через 3 года в следующих ревизиях этого предложения ([[N2235]](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf)) признали, что слишком много неявности это плохо. В список проблем добавили невозможность контроля за инициализацией:
```
struct S {
static const int size;
};
const int limit = 2 * S::size; // dynamic initialization
const int S::size = 256; // constant expression initialization
const int z = std::numeric_limits::max(); // dynamic initialization
```
По задумке программиста, `limit` должен был быть инициализирован constant-expression, но этого не происходит, так как `S::size` определён "слишком поздно", после `limit`. Если бы была возможность запросить нужный тип инициализации, компилятор выдал бы ошибку.
Аналогично с методами. *constant-valued* методы переименовали в *constant-expression* методы. Требования к ним остались те же, но теперь, чтобы их было возможно использовать в *constant-expression*, их необходимо объявлять **с ключевым словом** `constexpr`. Зато компиляция будет падать, если тело метода не является правильным `return expr;`.
Также компиляция упадет, если `constexpr`-метод принципиально не сможет быть использован в *constant-expression* при любых аргументах, с ошибкой `constexpr function never produces a constant expression`. Это надо для того, чтобы программист был точно уверен в том, что метод является потенциально используемым в *constant-expression*.
Некоторые методы стандартной библиотеки (напр. из `std::numeric_limits`) предлагается пометить `constexpr`, так как они удовлетворяют требованиям на него.
Переменные или члены класса также можно объявлять `constexpr`, тогда компиляция упадет, если переменная инициализируется не через *constant-expression*.
На тот момент решили сохранить совместимость нового слова с переменными, неявно инициализированными через *constant-expression* без ключевого слова `constexpr`, то есть этот код работал (забегая вперед, сейчас этот код с `--std=c++11` не компилируется, возможно этот код так никогда и не начал работать):
```
const double mass = 9.8;
constexpr double energy = mass * square(56.6); // OK, хотя mass не объявлен с constexpr
extern const int side;
constexpr int area = square(side); // error: square(side) is not a constant expression
```
*constant-expression*-конструкторы для пользовательских классов также легализовали. Этот конструктор должен иметь пустое тело и инициализировать члены *constexpr-expression*-ами, если пользователь создает `constexpr`-объект данного класса.
Неявный конструктор по возможности помечается `constexpr`. Деструкторы для `constexpr`-объектов обязаны быть тривиальными, так как нетривиальные обычно что-то меняют в контексте выполняющейся программы, которой нет как таковой в `constexpr`-вычислениях.
Пример класса с `constexpr`-ами из предложения:
```
struct complex {
constexpr complex(double r, double i) : re(r), im(i) { }
constexpr double real() { return re; }
constexpr double imag() { return im; }
private:
double re;
double im;
};
constexpr complex I(0, 1); // OK -- literal complex
```
Такие объекты как `I` в предложении назвали *user-defined-literals*. "Литерал" - это нечто вроде базовой сущности в C++. Так же, как "простые" литералы (числа, символы и т.д.) сразу подставляются в ассемблерные команды, а строковые литералы лежат в секции подобной `.rodata`, так и пользовательские литералы занимают где-нибудь там своё место.
Теперь `constexpr`-переменными могли являться не только числа и перечисления, а [литеральные типы](https://en.cppreference.com/w/cpp/named_req/LiteralType), которых ввели в этом предложении (пока еще без `reference type`). Литеральный тип - такой, который может быть передан в `constexpr`-метод, и/или изменен и/или возвращен из нее. Это достаточно простые типы, чтобы компиляторы могли его поддерживать в вычислителе констант.
Ключевое слово `constexpr` стало спецификатором, нужным компилятору - примерно как `override` в классах. После обсуждения предложения, для этого ключевого слова решили не делать новый [storage class](https://en.cppreference.com/w/cpp/language/storage_duration) (хотя было бы законно), новый [type qualifier](https://en.cppreference.com/w/cpp/language/cv), и также его решили не разрешать использовать для аргументов методов, чтобы не переусложнять правила перегрузки методов.
2007: Первые constexpr для структур данных
------------------------------------------
В этом году вышло предложение [[N2349] Constant Expressions in the Standard Library](http://open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2349.pdf), где пометили как `constexpr` некоторые методы и константы, а также некоторые методы контейнеров, например:
```
template
class bitset {
// ...
constexpr bitset();
constexpr bitset(unsigned long);
// ...
constexpr size\_t size();
// ...
constexpr bool operator[](size\_t) const;
};
```
Конструкторы инициализируют члены класса через *constant-expression*, остальные методы внутри себя имеют `return expr;`, подходящий под текущие ограничения.
Больше половины предложений про `constexpr` за все годы - про то, чтобы пометить как `constexpr` какие-нибудь методы из стандартной библиотеки. Они возникают сразу после очередного витка эволюции `constexpr` и почти всегда не очень интересны - будем рассматривать изменения в сам язык.
2008: Рекурсивные constexpr-методы
----------------------------------
`constexpr`-методы изначально не предполагалось разрешать делать рекурсивными по причине отсутствия убедительных доводов в наличие рекурсии, но затем это ограничение убрали, что отметили в [[N2826] Issues with Constexpr](http://open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2826.html).
```
constexpr unsigned int factorial( unsigned int n )
{ return n==0 ? 1 : n * factorial( n-1 ); }
```
У компилятора существует некий предел вложенности вызовов (в clang это 512 вложенных вызовов), при превышении он откажется считать выражение.
Подобные пределы также есть, например, для инстанцирования шаблонов (если мы бы считали в compile-time через шаблоны, а не через `constexpr`-методы)
2010: "const T&" как аргументы в constexpr-методах
--------------------------------------------------
На данный момент многие методы не могут быть помечены constexpr из-за имеющихся в аргументах константных ссылок. Во все `constexpr`-методы параметры передаются по значению, т.е. копируются.
```
template< class T >
constexpr const T& max( const T& a, const T& b ); // не скомпилируется
```
```
constexpr pair(); // можно поставить constexpr
pair(const T1& x, const T2& y); // нельзя поставить constexpr
```
Предложение [[N3039] Constexpr functions with const reference parameters (a summary)](http://open-std.org/JTC1/SC22/WG21/docs/papers/2010/n3039.pdf) разрешает константные ссылки в аргументах и как возвращаемое значение.
Это опасное изменение: до этого вычислитель констант имел дело с простыми выражениями и `constexpr`-переменными (объект литерального класса - по сути набор из `constexpr`-переменных); но введение ссылок пробивает "четвертую стену", потому что это понятие относится к модели памяти, которой в вычислителе нет.
В общем случае работа со ссылками и указателями в *constant-expression* превращает C++-компилятор в C++-интерпретатор, поэтому накладываются различные ограничения.
Если вычислитель констант может обработать метод с аргументом типа **T**, то типа **const T&** тоже сможет - если будет "представлять себе", что для этого аргумента создается "временный объект".
Более-менее сложная работа со ссылками и попытки что-либо поломать не скомпилируются
```
template constexpr T self(const T& a) { return \*(&a); }
template constexpr const T\* self\_ptr(const T& a) { return &a }
template constexpr const T& self\_ref(const T& a) { return \*(&a); }
template constexpr const T& near\_ref(const T& a) { return \*(&a + 1); }
constexpr auto test1 = self(123); // OK
constexpr auto test2 = self\_ptr(123); // FAIL, pointer to temporary is not a constant expression
constexpr auto test3 = self\_ref(123); // OK
constexpr auto tets4 = near\_ref(123); // FAIL, read of dereferenced one-past-the-end pointer is not allowed in a constant expression
```
2011: static\_assert в constexpr-методах
----------------------------------------
Предложение [[N3268] static\_assert and list-initialization in constexpr functions](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3268.htm) вводит возможность писать "статические" объявления, не вляющие на результат работы метода: `typedef`, `using`, `static_assert` . Это небольшое развинчивание гаек для `constexpr`-методов.
2012: (Почти) любой код в constexpr-функциях
--------------------------------------------
В 2012 году произошел большой рывок вперед с предложением [[N3444] Relaxing syntactic constraints on constexpr functions](http://open-std.org/JTC1/SC22/WG21/docs/papers/2012/n3444.html). Есть множество простых методов, которых желательно уметь вычислять в compile-time, например степень :
```
// Compute a to the power of n
int pow(int a, int n) {
if (n < 0)
throw std::range_error("negative exponent for integer power");
if (n == 0)
return 1;
int sqrt = pow(a, n/2);
int result = sqrt * sqrt;
if (n % 2)
return result * a;
return result;
}
```
Однако программистам фокусничать писать в функциональном стиле (убирать локальные переменные и `if`-ы), чтобы сделать ее `constexpr`-вариант:
```
constexpr int pow_helper(int a, int n, int sqrt) {
return sqrt * sqrt * ((n % 2) ? a : 1);
}
// Compute a to the power of n
constexpr int pow(int a, int n) {
return (n < 0) ? throw std::range_error("negative exponent for integer power") :
(n == 0) ? 1 : pow_helper(a, n, pow(a, n/2));
}
```
Поэтому предложение хочет разрешить записывать в `constexpr`-методах любой код, с рядом ограничений:
* Так как в константных выражениях нельзя изменять переменные, циклы (`for`/`while`/`do`/range-based for) заведомо невозможно использовать
* `switch` и `goto` запрещены, чтобы вычислитель констант не моделировал сложные потоки управления
* Как при старых ограничениях, для метода теоретически должен существовать набор аргументов, при которых ее можно использовать в константных выражениях. Иначе считается, что метод помечен `constexpr` ошибочно, и компиляция упадет с `constexpr function never produces a constant expression`.
В методах можно объявлять **локальные** переменные, если они имеют литеральный тип, и если они инициализируются конструктором, то он должен являться `constexpr`. Таким образом, вычислитель констант в процессе обработки `constexpr`-метода с конкретными определенными аргументами может "на фоне" создавать `constexpr`-переменную для каждой локальной переменной, и затем использовать их для вычисления других переменных, которые зависят от только что созданной.
[*Note*: таких переменных не будет сильно много из-за жесткого ограничения на "глубину вызовов" *end note*].
В методах можно объявлять **статические** переменные. Они могут иметь не-литеральный тип (чтобы, например, возвращать ссылки на них из метода; сами ссылки - тип как раз литеральный), но у них не должно быть *dynamic initialization* (т.е. должна быть хотя бы *zero-initialization*) и нетривиального деструктора. Предложение приводит пример, где это могло бы быть полезно (получение ссылки на нужный объект в compile-time):
```
constexpr mutex &get_mutex(bool which) {
static mutex m1, m2; // non-const, non-literal, ok
if (which)
return m1;
else
return m2;
}
```
Также разрешили объявлять типы (class, enum и т.д.) и возвращать `void`.
### 2013: (Почти) любой код в constexpr-функциях ver 2.0 Mutable Edition
Однако Комитет решил, что поддержка циклов (хотя бы `for`) в `constexpr`-методах это must have. В 2013 году вышла поправленная версия предложения [[N3597] Relaxing constraints on constexpr functions](http://open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3597.html).
Для реализации "constexpr `for`"-а рассматривалось четыре варианта.
Самым далеким от "остального C++" варианта было создание совершенно новой конструкции для итераций, который подходил бы для функционального стиля тогдашнего `constexpr`-кода; но это бы фактически создало новый под-язык `constexpr C++` функционального стиля.
Самым близким к "остальному C++" вариантом было не заменять качество количеством, а просто стараться поддерживать в `constexpr`-вычислениях широкое подмножество C++ (в идеале - его весь). **Этот вариант был выбран**. Это сильно повлияло на дальнейшую историю `constexpr`.
Поэтому возникла необходимость **в мутабельности объектов в рамках constexpr-вычислений**. Согласно предложению, объект, созданный в рамках вычисления constexpr-выражения, теперь можно изменять в течение процесса вычисления, до тех пор, пока не закончится процесс вычисления или [лайфтайм](http://eel.is/c++draft/basic.life) объекта.
Эти вычисления до сих пор происходят внутри своей "песочницы", ничто снаружи на них не влияет, поэтому, по идее, вычисление constexpr-выражения с одними и теми же аргументами будет давать один и тот же результат (не считая погрешностей в float- и double-вычислениях).
Для лучшего понимания я скопировал кусок кода из предложения:
```
constexpr int f(int a) {
int n = a;
++n; // '++n' is not a constant expression
return n * a;
}
int k = f(4); // OK, this is a constant expression.
// 'n' in 'f' can be modified because its lifetime
// began during the evaluation of the expression.
constexpr int k2 = ++k; // error, not a constant expression, cannot modify
// 'k' because its lifetime did not begin within
// this expression.
struct X {
constexpr X() : n(5) {
n *= 2; // not a constant expression
}
int n;
};
constexpr int g() {
X x; // initialization of 'x' is a constant expression
return x.n;
}
constexpr int k3 = g(); // OK, this is a constant expression.
// 'x.n' can be modified because the lifetime of
// 'x' began during the evaluation of 'g()'.
```
От себя замечу, что теперь компилируется такой код:
```
constexpr void add(X& x) {
x.n++;
}
constexpr int g() {
X x;
add(x);
return x.n;
}
```
Теперь в `constexpr`-методах работает значимая часть С++, и в методах разрешены сайд-эффекты, локальные в рамках constexpr-вычисления. Вычислитель констант стал сложнее, но все еще справлялся с задачей.
2013: Легендарные const-методы и популярные constexpr-методы
------------------------------------------------------------
`constexpr`-методы класса на данный момент автоматически помечаются как `const`-методы.
В предложении [[N3598] constexpr member functions and implicit const](http://open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3598.html) обратили внимание, что `constexpr`-методы класса не обязательно неявно делать `const`-методами.
Это стало актуальнее с мутабельностью в constexpr-вычислениях; но и до этого мешало использовать один и тот же метод в constexpr и не-constexpr коде:
```
struct B {
constexpr B() : a() {}
constexpr const A &getA() const /*implicit*/ { return a; }
A &getA() { return a; } // дублирование кода
A a;
};
```
Интересно, что предложение давало на выбор три опции, из них был выбран второй:
1. Статус-кво; минус: дублирование кода
2. `constexpr` не будет неявно значить `const`; минус: ломает [ABI](https://habr.com/ru/post/490222/) (`const` является частью [mangled-имени](https://en.wikipedia.org/wiki/Name_mangling#C++) метода)
3. Добавить новый квалификатор и писать `constexpr A &getA() mutable { return a; }`; минус: новый баззворд в конце объявления
2015-2016: Синтаксический сахар для шаблонов
--------------------------------------------
В метапрограммировании шаблонов обычно перегружают методы, если в теле требуется разная обработка в зависимости от свойств типа. Пример страшного кода:
```
template
enable\_if\_t, unique\_ptr>
make\_unique(Args&&... args)
{
return unique\_ptr(new T(forward(args)...));
}
template
enable\_if\_t, unique\_ptr>
make\_unique(Args&&... args)
{
return unique\_ptr(new T{forward(args)...});
}
```
Предложение [[N4461] Static if resurrected](http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4461.html) вводит выражение `static_if` (позаимствовав из языка D), чтобы код стал менее страшным:
```
template
unique\_ptr
make\_unique(Args&&... args)
{
static\_if (is\_constructible\_v) {
return unique\_ptr(new T(forward(args)...));
} else {
return unique\_ptr(new T{forward(args)...});
}
}
```
Этот кусок C++ имеет довольно посредственное отношение к `constexpr`-вычислениям и работает в другой сфере. Но `static_if` в следующих ревизиях решили переименовать:
```
constexpr_if (is_constructible_v) {
return unique\_ptr(new T(forward(args)...));
} constexpr\_else {
return unique\_ptr(new T{forward(args)...});
}
```
Затем еще немного...
```
constexpr if (is_constructible_v) {
return unique\_ptr(new T(forward(args)...));
} constexpr\_else {
return unique\_ptr(new T{forward(args)...});
}
```
И финальный вариант:
```
if constexpr (is_constructible_v) {
return unique\_ptr(new T(forward(args)...));
} else {
return unique\_ptr(new T{forward(args)...});
}
```
2015: Constexpr-лямбды
----------------------
В очень хорошем предложении [[N4487] Constexpr Lambda](http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4487.pdf) подробно проработали вопрос использования closure type в `constexpr`-вычислениях (и написали поддержку в форкнутом clang).
Чтобы понять, как возможно иметь constexpr-лямбды, нужно понимать, как они устроены "внутри". Есть [статья про историю лямбд](https://habr.com/ru/company/otus/blog/444524/), где описано, как прото-лямбды существовали уже в C++03, и в сегодняшних лямбда-выражениях создается похожий класс, скрытый за чертогами компилятора.
Прото-лямбда для [](int x) { std::cout << x << std::endl; }
```
#include
#include
#include
struct PrintFunctor {
void operator()(int x) const {
std::cout << x << std::endl;
}
};
int main() {
std::vector v;
v.push\_back(1);
v.push\_back(2);
std::for\_each(v.begin(), v.end(), PrintFunctor());
}
```
Если все "захваченные" переменные являются литеральными типами, то closure type тоже предложено считать литеральным типом, а `operator()` пометить `constexpr`. Работающий пример constexpr-лямбд:
```
constexpr auto add = [] (int n, int m) {
auto L = [=] { return n; };
auto R = [=] { return m; };
return [=] { return L() + R(); };
};
static_assert(add(3, 4)() == 7, "");
```
2017-2019: Двойные стандарты
----------------------------
В предложении [[P0595] The constexpr Operator](http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0595r0.html) рассмотрели возможность "знать" внутри метода, где сейчас выполняется метод - в вычислителе констант или в рантайме. Автор предложил использовать для этого вызов `constexpr()`, которые будет соответственно возвращать `true` или `false`.
```
constexpr double hard_math_function(double b, int x) {
if (constexpr() && x >= 0) {
// медленная формула, более точная (compile-time)
} else {
// быстрая формула, менее точная (run-time)
}
}
```
Затем оператор был заменен на "магическую" функцию `std::is_constant_evaluated()` ([[P0595R2]](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0595r2.html)) и в таком виде принят в Стандарт С++20.
Если предложение разрабатывается долго, то авторы иногда делают "rebase" (аналогично как в проектах в git/svn), приводя его в соответствие с обновившимся состоянием.
Так и здесь - авторы [[P1938] if consteval](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1938r0.html) (про `consteval` будет позже) обнаружили, что лучше создать новую запись:
```
if consteval { }
if (std::is_constant_evaluated()) { }
// ^^^ аналогичные записи
```
Это решение было принято в C++23 - [ссылка на голосование](https://github.com/cplusplus/papers/issues/677).
2017-2019: We need to go deeper
-------------------------------
В constexpr-методах во время constexpr-вычислений пока нельзя использовать дебаггер и выводить логи. Предложение [[P0596] std::constexpr\_trace and std::constexpr\_assert](http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0596r0.html) рассматривает введение специальных методов для этих целей.
Это предложение было благосклонно принято - [ссылка на голосование](https://github.com/cplusplus/papers/issues/602), но пока еще не доработано.
2017: Злой двойник стандартной библиотеки
-----------------------------------------
На данный момент `std::vector`, который желательно затащить в compile-time, не может работать в `constexpr`-вычислениях, в основном из-за недоступности там операторов `new/delete`.
Идея о допуске операторов `new` и `delete` в вычислитель констант на тот момент выглядела слишком амбициозно, поэтому в довольно странном предложении [[P0597] std::constexpr\_vector](http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0597r0.html) рассматривается введение магического `std::constexpr_vector`.
Он является противоположносью `std::vector` - может быть создан и изменен только во время `constexpr`-вычислений.
```
constexpr constexpr_vector x; // Okay.
constexpr constexpr\_vector y{ 1, 2, 3 }; // Okay.
const constexpr\_vector xe; // Invalid: not constexpr
```
Как вычислитель констант должен работать с памятью - не описано. [@antoshkka](/users/antoshkka) и [@ZaMaZaN4iK](/users/zamazan4ik) (авторы многих предложений) в [[P0639R0] Changing attack vector of the constexpr\_vector](http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0639r0.html) выявили большое количество минусов подхода, и предложили поменять направление работы в сторону абстрактного магического `constexpr allocator`, который не дублирует всю стандартную библиотеку.
2017-2019: Constexpr обретает память
------------------------------------
В презентации [Constexpr ALL the thing!](https://youtu.be/HMB9oXFobJc) демонстрировался пример constexpr-библиотеки для работы с JSON-объектами (то же самое, но в бумажном виде, есть в [[P0810] constexpr in practice](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0810r0.pdf)):
```
constexpr auto jsv
= R"({
"feature-x-enabled": true,
"value-of-y": 1729,
"z-options": {"a": null,
"b": "220 and 284",
"c": [6, 28, 496]}
})"_json;
if constexpr (jsv["feature-x-enabled"]) {
// code for feature x
} else {
// code when feature x turned off
}
```
Авторы сильно пострадали от невозможности использовать контейнеры STL, и написали свои велосипедные аналоги `std::vector` и `std::map`, имеющие внутри себя `std::array` (умеющий работать в constexpr).
Предложение [[P0784] Standard containers and constexpr](http://open-std.org/JTC1/SC22/WG21/docs/papers/2019/p0784r7.html) исследует возможность ввода STL-контейнеров в `constexpr`-вычисления.
[*Note*: Важно знать, что такое *аллокатор*. STL-контейнеры работают через него с памятью. Какой именно аллокатор - задается через [аргумент шаблона](https://en.cppreference.com/w/cpp/container/vector). Чтобы войти в тему, можно почитать [эту статью](https://habr.com/ru/post/505632/). *end note*]
Что же мешает разрешить STL-контейнеры в `constexpr`-вычислениях? Есть три проблемы:
1. Деструкторы не могут быть объявлены `constexpr` (у `constexpr`-объектов он обязан быть тривиальным).
2. Недоступна динамическая аллокация/деаллокация памяти.
3. Недоступен *placement-new* для вызова конструктора в аллоцированной памяти.
**Первая проблема**. С этим разобрались быстро - авторы предложения обсуждали проблему с разработчиками фронтенда MSVC++, GCC, Clang, EDG, и они подтвердили, что ограничение можно легко ослабить. Теперь от литеральных типов можно требовать наличие constexpr-деструктора, а не строго тривиального деструктора.
**Вторая проблема**. Работа с памятью не очень проста. Как уже упоминалось, вычислитель констант *обязан* отлавливать undefined behaviour в любом виде и останавливать компиляцию в случае его наличия.
Это значит, что вместе с многими объектами нужно трекать их "метаданные", которые держат руку на пульсе и не дают сломать выполнение программы. Пара примеров таких метаданных:
* Информация, какое поле в `union`-е активно ([[P1330]](http://open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1330r0.pdf)) (примеры undefined behavior: запись в член неактивного поля)
* Жесткая связь между указателем или ссылкой и соответствующим ему реальным ранее созданным объектом (примеры undefined behavior: бесконечное множество)
Из-за этого не имеет смысла использовать подобные методы:
```
void* operator new(std::size_t);
```
Так как нет никакого обоснования приводить `void*` к `T*`. Короче говоря, новая ссылка/указатель либо могут начать указывать на существующий объект, либо быть созданным "одновременно" с ним, и никак иначе.
Поэтому есть две опции работы с памятью, которые будут законны в `constexpr`-вычислениях:
1. Простые new- и delete-выражения: `int* i = new int(42);`
2. Использование стандартного аллокатора: [std::allocator](https://en.cppreference.com/w/cpp/memory/allocator) (его подпилили напильником)
**Третья проблема**. Стандартные койтейнеры разделяют аллокацию памяти и конструирование объектов в этой памяти. С аллокацией уже разобрались - с условием на метаданные ее обеспечить возможно.
Контейнеры полагаются на [std::allocator\_traits](https://en.cppreference.com/w/cpp/memory/allocator_traits), в частности для конструирования - на его метод [construct](https://en.cppreference.com/w/cpp/memory/allocator_traits/construct). До предложения он имел вид
```
template< class T, class... Args >
static void construct( Alloc& a, T* p, Args&&... args ) {
::new (static_cast(p)) T(std::forward(args)...);
// ^^^ placement-new, запрещенный в constexpr-вычислениях
}
```
То есть его нельзя использовать из-за приведения к `void*` и placement-new (которые в общем виде в constexpr запрещены). А в предложении преобразовался в
```
template< class T, class... Args >
static constexpr void construct( Alloc& a, T* p, Args&&... args ) {
std::construct_at(p, std::forward(args)...);
}
```
[std::construct\_at](https://en.cppreference.com/w/cpp/memory/construct_at) - это метод, который в рантайме работает аналогично старому коду (с приведением к `void*`), а в `constexpr`-вычислениях он:
```
.∧＿∧
( ･ω･｡)つ━☆・*。
⊂ ノ ・゜+.
しーＪ °。+ *´¨)
.· ´¸.·*´¨) ¸.·*¨)
(¸.·´ (¸.·'* ☆ Вжуххххх, и просто работает! ☆
```
То есть компиляторный вычислитель констант обработает его особым образом: по видимости, вызвав конструктор у объекта, который связан с `T* p`, без бюрократии.
Этого достаточно, чтобы контейнеры стало возможно использовать в `constexpr`-вычислениях.
На первых порах на аллоцированную память наложили ограничения: она должна быть деаллоцирована в рамках этого же `constexpr`-вычисления, не выходя за рамки "песочницы".
Такой новый тип аллокации памяти назван *transient constexpr allocations*. Слово *transient* приблизительно можно перевести как "мимолетный" или "недолговечный".
В этом предложении еще был кусок про *non-transient allocation* - дать возможность освобождать не всю аллоцированную память, тогда неосвобожденная память "вываливается" из "песочницы" и конвертируется бы в static storage (другими словами, в секцию `.rodata`). Но Комитет посчитал эту возможность "слишком хрупкой" ("too brittle") по многим причинам, и пока его не принял.
В остальном, это предложение было принято.
2018: Поймай меня, если сможешь
-------------------------------
Предложение [[P1002] Try-catch blocks in constexpr functions](http://open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1002r1.pdf) вводит try-catch блоки в `constexpr`-вычисления.
Это предложение немного сбивает с толку, так как `throw` на тот момент был запрещен в `constexpr`-вычислениях (значит, catch-кусок кода никогда не запускается).
Судя по документу, это ввели, чтобы пометить все методы `std::vector` как `constexpr` - в libc++ (реализация STL) в методе `vector::insert` используется try-catch блок.
2018: Я сказал constexpr!
-------------------------
Из личного опыта знакомо, что двойственность `constexpr`-методов (могут выполняться и в compile-time, и в run-time) приводит к тому, что вычисления проваливаются в рантайм там, где не ожидаешь: [пример кода](https://godbolt.org/z/f8xY7T9xn); и для того, чтобы гарантировать нужный этап, нужно фокусничать: [пример кода](https://godbolt.org/z/9Prs41nhj).
Предложение [[P1073] constexpr! functions](http://open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1073r0.html) вводит новое ключевое слово `constexpr!` для методов, которые должны работать только в compile-time. Эти методы называются *immediate*-методами.
```
constexpr! int sqr(int n) {
return n*n;
}
constexpr int r = sqr(100); // Okay.
int x = 100;
int r2 = sqr(x); // Error: Call does not produce a constant.
```
Если существует *возможность* того, что в `constexpr!`-метод могут попасть переменные, неизвестные на этапе компиляции (что норма для `constexpr`-методов), то программа не скомпилируется:
```
constexpr! int sqrsqr(int n) {
return sqr(sqr(n)); // Not a constant-expression at this point,
} // but that's okay.
constexpr int dblsqr(int n) {
return 2*sqr(n); // Error: Enclosing function is not
} // constexpr!.
```
К `constexpr!`-методу нельзя взять указатель или ссылку. Бэкенду компилятора вовсе не обязательно (и не нужно) знать про существование таких функций, помещать их в таблицы символов и т.д.
В следующих ревизиях этого предложения ключевое слово `constexpr!` поменяли на `consteval`.
Разница между `constexpr` и `consteval` налицо - во втором случае нет провала в рантайм: [пример с constexpr](https://godbolt.org/z/f8xY7T9xn), [пример с consteval](https://godbolt.org/z/x6ds7vM8r).
2018: Слишком радикальный constexpr
-----------------------------------
В это время большое количество предложений состоит только из добавлений спецификатора `constexpr` разнообразным частям стандартной библиотеки (которые мы не обсуждаем в этой статье, так как там один и тот же шаблон).
Предложение [[P1235] Implicit constexpr](http://open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1235r0.pdf) предлагает по умолчанию помечать все методы, имеющие определение, как `constexpr`. Но можно и запретить выполнять метод в compile-time:
1. <нет спецификатора> - метод помечается как constexpr, если возможно.
2. `constexpr` - работает как сейчас
3. `constexpr(false)` - не может быть вызван в compile-time
4. `constexpr(true)` - может быть вызван только в compile-time, т.е. аналогично `constexpr!`/`consteval`
Это предложение не было принято - [ссылка на голосование](https://github.com/cplusplus/papers/issues/292).
2020: Долговечная constexpr-память
----------------------------------
Как уже обсуждалось, после принятия предложения [[P0784] Standard containers and constexpr](http://open-std.org/JTC1/SC22/WG21/docs/papers/2019/p0784r7.html) в `constexpr`-вычислениях стало возможно аллоцировать память, но ее всю необходимо освобождать до окончания `constexpr`-вычисления: это так называемые *transient constexpr allocations*.
Таким образом, нельзя создавать top-level `constexpr`-объекты почти всех STL-контейнеров и многих других классов.
[*Note*: Под "top-level объектом" я имею в виду результат всего `constexpr`-вычисления, например:
```
constexpr TFoo CalcFoo();
constexpr TFoo FooObj = CalcFoo();
```
Здесь вызов `CalcFoo()` начинает `constexpr`-вычисление, а `FooObj` - его результат и top-level `constexpr`-объект. *end note*]
Предложение [[P1974] Non-transient constexpr allocation using propconst](http://open-std.org/JTC1/SC22/WG21/docs/papers/2020/p1974r0.pdf) находит путь к решению проблемы. На мой взгляд, это самое интересное предложение из всех, что я привел в статье (оно заслуживало бы отдельной статьи). Ему дали "зеленый свет" и оно развивается - [ссылка на тикет](https://github.com/cplusplus/papers/issues/867). Здесь я его перескажу в понятной форме.
Что же мешает нам иметь *non-transient allocations*? Вообще, проблема не в том, чтобы запихать куски памяти в static storage (`.bss`/`.rodata`/их аналоги), а в том, чтобы проверить, что вся схема обладает чёткой **консистентностью**.
Допустим, что мы имеем некий `constexpr`-объект, конструирование (точнее, "вычисление") которого спровоцировало *non-transient allocations*. Значит, теоретическое деконструирование этого объекта (т.е. вызов его деструктора) должно освободить всю *non-transient* память. Если вызов деструктора не освободил бы память, то это плохо (**консистентности** нет) и надо выдавать ошибку компиляции.
Другими словами, вот что должен делать вычислитель контант:
1. Увидев запрос на `constexpr`-вычисление, произвести его.
2. В результате вычисления получить объект, скрывающий под собой пачку `constexpr`-переменных литерального типа; и некоторый объём неосвобожденной памяти (*non-transient allocations*).
3. *Имитировать* вызов деструктора у данного объекта (не вызывая его на самом деле), и проверить что этот вызов *освободил бы* всю *non-transient* память.
4. Если все проверки прошли успешно, то **консистентность** доказана. *Non-transient allocations* можно двигать в static storage.
Это звучит логично, и допустим, что это всё реализовано. Но тогда получим проблему с подобным кодом с *non-transient* памятью, которую стандарт не будет запрещать менять, и тогда проверка на вызов деструктора будет бессмысленной:
```
constexpr unique_ptr> uui
= make\_unique>(make\_unique());
int main() {
unique\_ptr& ui = \*uui;
ui.reset();
}
```
[*Note*: В реальности такой код получил бы отпор от ОС за попытку записи в read-only сегмент RAM, но это *физическая* константность. А в коде должна быть *логическая* константность. *end note*]
Пометка `constexpr` у объектов влечет за собой пометку их как `const`, и все их члены также становятся `const`.
Однако если у объекта есть член указательного типа, то это ломает всю малину - заставить его *указывать* на другой объект станет нельзя, но менять объект, на который он *указывает*, не запрещено.
У указательных типов есть два ортогональных параметра константности:
1. Можно ли начать указывать на другой объект?
2. Можно ли изменять объект, на который указывается?
И получается 4 варианта с разными свойствами (`OK` - строка компилируется, `FAIL` - нет):
```
int dummy = 13;
int * test1{nullptr};
test1 = &dummy // OK
*test1 = dummy; // OK
int const * test2{nullptr};
test2 = &dummy // OK
*test2 = dummy; // FAIL
int * const test3{nullptr};
test3 = &dummy // FAIL
*test3 = dummy; // OK
int const * const test4{nullptr};
test4 = &dummy // FAIL
*test4 = dummy; // FAIL
```
"Обычный" `const` приводит к третьему варианту, но для `constexpr` необходим четвертый! То есть необходим так называемый `deep-const`.
Предложение на базе пары других, более старых предложений, предлагает для этого ввести новый [cv-qualifier](https://en.cppreference.com/w/cpp/language/cv) `propconst` (propagating const).
Этот квалификатор будет использоваться с указательными/ссылочными типами:
```
T propconst*
T propconst&
```
И в зависимости от типа `T` компилятор будет либо конвертировать это слово в `const`, либо удалять его. Первый случай - если `T` константный, второй - если нет:
```
int propconst * ---> int *
int propconst * const ---> int const * const
```
В предложении приведена таблица конвертации `propconst` в разных случаях.
Таким образом, `constexpr`-объекты могли бы обрести полную *логическую* константность (deep-const):
```
constexpr unique_ptr propconst> uui
= make\_unique propconst>(make\_unique());
int main() {
// две строки ниже не скомпилируются
unique\_ptr& ui1 = \*uui;
ui1.reset();
// строка ниже скомпилируется
const unique\_ptr& ui2 = \*uui;
// строка ниже не скомпилируется
ui2.reset();
}
// P.S. Такая запись еще не принята Комитетом, я надеюсь, сделают лучше
```
2021: Constexpr-классы
----------------------
С появлением полностью constexpr-классов, включая `std::vector`, `std::string`, `std::unique_ptr`, в которых все методы помечены как `constexpr`, возникает желание сказать "пометь все методы класса как `constexpr`".
Это делает предложение [[P2350] constexpr class](http://open-std.org/JTC1/SC22/WG21/docs/papers/2021/p2350r1.pdf):
```
class SomeType {
public:
constexpr bool empty() const { /* */ }
constexpr auto size() const { /* */ }
constexpr void clear() { /* */ }
// ...
};
// ^^^ ДО
class SomeType constexpr {
public:
bool empty() const { /* */ }
auto size() const { /* */ }
void clear() { /* */ }
// ...
};
// ^^^ ПОСЛЕ
```
С этим предложением связана интересная история - еще не зная о его существовании, я вкинул в [stdcpp.ru](http://stdcpp.ru) идею предложить такую же штуку: [ссылка на тикет](https://github.com/cpp-ru/ideas/issues/479) (что сейчас не нужно).
Многие почти одинаковые предложения в Стандарт могут появиться почти одновременно. Это говорит в пользу [теории множественных открытий](https://ru.wikipedia.org/wiki/%D0%9C%D0%BD%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D1%82%D0%B8%D0%B5): идеи "витают в воздухе", и в принципе не так важно, кто их открывает - если комьюнити достаточно большое, то естественная эволюция происходит.
2019-∞: Интерпретатор констант в компиляторе
--------------------------------------------
`constexpr`-вычисления могут быть очень медленными, потому что вычислитель констант на синтаксическом дереве развивался итеративным образом (начиная с constant folding) и сейчас делает множество лишних вещей, которые можно было делать более эффективно.
С 2019 года в Clang разрабывается [ConstantInterpeter](https://clang.llvm.org/docs/ConstantInterpreter.html), который в перспективе может полностью заменить вычислитель констант на синтаксическом дереве. Он довольно интересен и заслуживал бы отдельной статьи.
Его идея состоит в том, что на основе синтаксического дерева можно сгенерировать "байткод", который затем выполнить на интерпретаторе. Интерпретатор поддерживает в себе стек, фреймы вызовов, модель памяти (с метаданными, о которых говорилось ранее).
Документация для ConstantInterpeter хорошая, и также много интересного есть в [видео-выступлении](https://youtu.be/LgrgYD4aibg) создателя интерпретатора на конференции LLVM-разработчиков.
Что можно еще посмотреть?
-------------------------
Для того, чтобы больше расширить понимание, можно посмотреть замечательные выступления от экспертов. В каждом выступлении авторы выходят за рамки рассказа про constexpr: это может быть построение constexpr-библиотеки; рассказ про использование constexpr в будущем [reflexpr](https://en.cppreference.com/w/cpp/experimental/reflect); или про устройство вычислителя констант и интерпретатора констант.
* [constexpr ALL the things!](https://youtu.be/HMB9oXFobJc), Ben Deane & Jason Turner, C++Now 2017. Уже немного устарело, но может быть интересно, про построение constexpr-библиотеки.
* [Compile-time programming and reflection in C++20 and beyond](https://youtu.be/CRDNPwXDVp0), Louis Dionne, CppCon 2018. Много внимания уделяется будущей рефлексии в C++.
* [Полезный constexpr](https://youtu.be/MXEgTYDnfJU), Антон Полухин ([@antoshkka](/users/antoshkka)), C++ CoreHard Autumn 2018. Есть про компиляторы, рефлексию и метаклассы.
* [The clang constexpr interpreter](https://youtu.be/LgrgYD4aibg), Nandor Licker, 2019 LLVM Developers’ Meeting. Рокет саенс и интерпретатор кода для `constexpr`.
Я хотел бы, чтобы здесь было выступление про киллер-фичу (по моему мнению) [[P1040] std::embed](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1040r3.html), которая отлично работала бы в тандеме с `constexpr`. Но, судя по [тикету](https://github.com/cplusplus/papers/issues/28), его планируют реализовать в C++-*каком-то*. | https://habr.com/ru/post/579490/ | null | ru | null |
# Сервер авторизации для микросервисов на Spring Boot
В этой статье рассмотрим, как реализовать аутентификацию с помощью централизованного сервера авторизации (Authorization Server) и API-шлюза (API Gateway).
Что такое JWT-токен и зачем его использовать?
---------------------------------------------
*JSON Web Token (JWT) — это стандарт передачи информации с полезной нагрузкой в формате JSON в виде некоторого количества утверждений (claim) с опциональной подписью и/или шифрованием.*
JWT-токены содержат сведения для аутентификации и могут использоваться в нескольких сервисах, инстансах для реализации stateless-аутентификации (без сохранения состояния). При использовании JWT-токенов нет необходимости содержать отдельные ресурсы для пользовательских сессий или хранить токены/сессии в отдельной базе данных/кэше.
### Архитектура решения
Отметим основные моменты:
* Для создания и проверки JWT-токенов используется централизованный сервер авторизации (Authorization Server).
* API Gateway представляет собой единую точку входа в приложение, которая перенаправляет запросы к соответствующим микросервисам.
* К маршрутам (routes) добавляется Gateway-фильтр, проверяющий JWT-токены в запросах к защищаемым ресурсам. Для валидации токена и получения имени пользователя с его полномочиями выполняется обращение к серверу авторизации (Authorization Server). Далее полученная информация передается другим сервисам в заголовке запроса.
* Для Service Discovery (обнаружения сервисов) будем использовать Eureka Discovery Client.
### Аутентификация
Аутентификация происходит следующим образом:
* Пользователь логинится (создает токен аутентификации), вызывая конечную точку `/login` (POST) с передачей имени пользователя и пароля. В ответ в заголовке он получает Bearer-токен.
* Токен передается в заголовке в параметре `Authorization`в формате `Bearer access_token`.
* Для запросов к защищенным ресурсам вызывается кастомный **Gateway Filter (AuthenticationPrefilter)**. В фильтре выполняется обращение к конечной точке **/api/v1/validateToken** сервиса аутентификации (Authentication Service), который валидирует токен и, в случае успешной проверки, отправляет в ответ имя пользователя и его полномочия (authorities).
* Если токен валидный, то перед переадресацией на ресурс, запрошенный пользователем, к заголовку запроса добавляются имя пользователя и [полномочия](https://javarevisited.blogspot.com/2013/07/role-based-access-control-using-spring-security-ldap-authorities-mapping-mvc.html).
* В остальных микросервисах (например, user-service) фильтр авторизации, наследуемый от `OncePerRequestFilter`, создает объект `Authentication`, используя класс `UsernamePasswordAuthenticationToken` (с *username* и *SimpleGrantedAuthority* из заголовка, с паролем null).
* Если у пользователя есть полномочия/доступ к ресурсу, то запрос разрешается. В противном случае клиенту возвращается ответ 401 Unathorized / 403 Forbidden.
Пишем сервисы
-------------
### Eureka Server
* Создайте приложение Spring Boot, через [Spring Initializr](https://start.spring.io/) с зависимостью `spring-cloud-starter-netflix-eureka-server`. Также добавьте `spring-cloud-dependencies`в `dependencyManagement`.
* Теперь для запуска Eureka Server достаточно добавить аннотацию [@EnableEurekaServer](https://www.java67.com/2018/12/top-5-spring-cloud-annotations-for-java.html) к основному классу приложения.
* В property-файл добавьте следующие настройки Eureka Server:
```
spring.application.name=naming-server
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.instance.prefer-ip-address=true
```
* Eureka Server будет доступен по адресу <http://localhost:8761/>. На главной странице можно увидеть список зарегистрированных сервисов.
### Authorization Service (сервис авторизации)
* Создайте приложения Spring Boot со следующими зависимостями: `spring-boot-starter-security`**,** `spring-boot-starter-web`**,** `spring-cloud-starter-sleuth`**,** `spring-cloud-starter-config`**,** `spring-cloud-starter-netflix-eureka-client`**,** `spring-boot-starter-data-jpa`**,** `spring-boot-starter-data-mongodb`**,** `spring-boot-starter-data-redis` и`lombok`.
* Зависимость `spring-boot-starter-security` необходима для авторизации и аутентификации, `spring-boot-starter-data-mongodb` и `spring-boot-starter-data-jpa` **—** для доступа к учетным данным в MongoDB. Для создания и проверки JWT-токенов будем использовать `io.jsonwebtoken:jjwt`.
* Для аутентификации с использованием учетных данных в базе данных напишем свою реализацию `UserDetailsService` из [Spring Security](https://medium.com/javarevisited/top-10-courses-to-learn-spring-security-and-oauth2-with-spring-boot-for-java-developers-8f0222d6066d). Для получения учетных данных пользователя из [базы данных](https://medium.com/javarevisited/top-5-sql-and-database-courses-to-learn-online-48424533ac61) и создания экземпляра `UserDetails` необходимо реализовать метод `loadUserByUsername()`.
```
@Service
public class ApplicationUserDetailsService implements UserDetailsService {
@Autowired
private UsersService usersService;
@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
return new ApplicationUsers(usersService.getByUsrName(s).orElseThrow(() -> new UsernameNotFoundException("Username Not Found")));
}
}
```
* Своя реализация `UserDetails` нам нужна для маппинга объектов, хранящихся в базе данных, на объекты, требуемые Spring Security.
* Создаем класс конфигурации — наследник `WebSecurityConfigurerAdapter`.
```
package com.infotrends.in.authenticationserver.security.config;
import com.infotrends.in.authenticationserver.security.filters.JWTAuthenticationFilter;
import com.infotrends.in.authenticationserver.security.filters.JWTVerifierFilter;
import com.infotrends.in.authenticationserver.security.services.ApplicationUserDetailsService;
import com.infotrends.in.authenticationserver.services.redis.TokensRedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private PasswordEncoder encoder;
@Autowired
private ApplicationUserDetailsService applicationUserDetailsService;
@Autowired
private TokensRedisService redisService;
@Override
protected void configure(HttpSecurity http) throws Exception {
http.csrf().disable()
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.addFilter(new JWTAuthenticationFilter(authenticationManager(), redisService))
.addFilterAfter(new JWTVerifierFilter(redisService), JWTAuthenticationFilter.class)
.authorizeRequests()
.antMatchers("/api/v1/validateConnection/whitelisted").permitAll()
.anyRequest()
.authenticated()
.and().httpBasic();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.authenticationProvider(authenticationProvider());
}
@Bean
public DaoAuthenticationProvider authenticationProvider() {
DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();
authenticationProvider.setPasswordEncoder(encoder);
authenticationProvider.setUserDetailsService(applicationUserDetailsService);
return authenticationProvider;
}
}
```
* Здесь мы создаем бин `DaoAuthenticationProvider` с кодировщиком паролей и нашей реализацией `UserDetailsService`.
* Которые, в свою очередь, используются для переопределения `configure(AuthenticationManagerBuilder auth)`, настраивающего `AuthenticationManagerBuilder` для использования созданного нами Authentication Provider.
* Далее для использования JWT/Bearer-токенов вместо аутентификации по логину и паролю, надо настроить два фильтра: один для генерации Bearer-токена, а другой — для его проверки.
* Фильтр генерации JWT создаем как подкласс `UsernamePasswordAuthenticationFilter`. Для проверки учетных данных переопределяем метод `attemptAuthentication()`. Для создания JWT-токена при успешной аутентификации — метод и `successAuthentication`**()**.
```
package com.infotrends.in.authenticationserver.security.filters;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.infotrends.in.InfoTrendsIn.security.SecurityConstants;
import com.infotrends.in.authenticationserver.model.ConnValidationResponse;
import com.infotrends.in.authenticationserver.model.JwtAuthenticationModel;
import com.infotrends.in.authenticationserver.model.redis.TokensEntity;
import com.infotrends.in.authenticationserver.services.redis.TokensRedisService;
import com.infotrends.in.authenticationserver.utils.Utilities;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Date;
@Slf4j
@RequiredArgsConstructor
public class JWTAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
private final AuthenticationManager authenticationManager;
private ObjectMapper mapper=new ObjectMapper();
private final TokensRedisService tokensRedisService;
@Override
public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
try {
JwtAuthenticationModel authModel = mapper.readValue(request.getInputStream(), JwtAuthenticationModel.class);
Authentication authentication = new UsernamePasswordAuthenticationToken(authModel.getUsername(), authModel.getPassword());
return authenticationManager.authenticate(authentication);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
String token = Jwts.builder()
.setSubject(authResult.getName())
.claim("authorities", authResult.getAuthorities())
.claim("principal", authResult.getPrincipal())
.setIssuedAt(new Date())
.setIssuer(SecurityConstants.ISSUER)
.setExpiration(Date.from(LocalDateTime.now().plusMinutes(30).toInstant(ZoneOffset.UTC)))
.signWith(SignatureAlgorithm.HS256, SecurityConstants.KEY)
.compact();
log.info(token);
TokensEntity tokensEntity = TokensEntity.builder().id(Utilities.generateUuid()).authenticationToken(token)
.username(authResult.getName())
.createdBy("SYSTEM").createdOn(LocalDateTime.now())
.modifiedBy("SYSTEM").modifiedOn(LocalDateTime.now())
.build();
tokensEntity = tokensRedisService.save(tokensEntity);
response.addHeader(SecurityConstants.HEADER, String.format("Bearer %s", tokensEntity.getId()));
// response.addHeader("Expiration", String.valueOf(30*60));
ConnValidationResponse respModel = ConnValidationResponse.builder().isAuthenticated(true).build();
response.addHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
response.getOutputStream().write(mapper.writeValueAsBytes(respModel));
}
}
```
* Фильтр проверки JWT наследуем от `OncePerRequestFilter`и настраиваем его вызов после фильтра, генерирующего JWT, с помощью `addFilterAfter()` в классе конфигурации `WebSecurityConfig`.
```
package com.infotrends.in.authenticationserver.security.filters;
import com.infotrends.in.InfoTrendsIn.security.SecurityConstants;
import com.infotrends.in.authenticationserver.model.redis.TokensEntity;
import com.infotrends.in.authenticationserver.services.redis.TokensRedisService;
import com.infotrends.in.authenticationserver.utils.Utilities;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import lombok.RequiredArgsConstructor;
import org.apache.tomcat.util.http.parser.Authorization;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
@RequiredArgsConstructor
public class JWTVerifierFilter extends OncePerRequestFilter {
private final TokensRedisService tokensRedisService;
@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
String bearerToken = httpServletRequest.getHeader(SecurityConstants.HEADER);
if(!(Utilities.validString(bearerToken) && bearerToken.startsWith(SecurityConstants.PREFIX))) {
filterChain.doFilter(httpServletRequest, httpServletResponse);
return;
}
String authToken = bearerToken.replace(SecurityConstants.PREFIX, "");
Optional tokensEntity = tokensRedisService.findById(authToken);
if(!tokensEntity.isPresent()) {
filterChain.doFilter(httpServletRequest, httpServletResponse);
return;
}
String token = tokensEntity.get().getAuthenticationToken();
Jws authClaim = Jwts.parser().setSigningKey(SecurityConstants.KEY)
.requireIssuer(SecurityConstants.ISSUER)
.parseClaimsJws(token);
String username = authClaim.getBody().getSubject();
List> authorities = (List>) authClaim.getBody().get("authorities");
List grantedAuthorities = authorities.stream().map(map -> new SimpleGrantedAuthority(map.get("authority")))
.collect(Collectors.toList());
Authentication authentication = new UsernamePasswordAuthenticationToken(username, null, grantedAuthorities);
SecurityContextHolder.getContext().setAuthentication(authentication);
httpServletRequest.setAttribute("username", username);
httpServletRequest.setAttribute("authorities", grantedAuthorities);
filterChain.doFilter(httpServletRequest, httpServletResponse);
}
}
```
```
package com.infotrends.in.authenticationserver.resources;
import com.sun.security.auth.UserPrincipal;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
@RestController
@RequestMapping("/api/v1/validateToken")
public class ConnectionValidatorResource {
@GetMapping(value = "", produces = {MediaType.APPLICATION_JSON_VALUE})
public ResponseEntity validateGet(HttpServletRequest request) {
String username = (String) request.getAttribute("username");
List grantedAuthorities = (List) request.getAttribute("authorities");
return ResponseEntity.ok(ConnValidationResponse.builder().status("OK").methodType(HttpMethod.GET.name())
.username(username).authorities(grantedAuthorities)
.isAuthenticated(true).build());
}
@Getter
@Builder
@ToString
public class ConnValidationResponse {
private String status;
private boolean isAuthenticated;
private String methodType;
private String username;
private List authorities;
}
}
```
### Дополнительная функциональность
Как правило, содержимое JWT-токена нельзя изменить после его создания. Однако токен можно легко расшифровать и прочитать.
Но мы можем вместо отправки пользователю JWT-токена, содержащего все данные, вернуть только [случайный UUID](https://javarevisited.blogspot.com/2021/05/3-examples-to-generate-random-alphanumeric-string-in-java0.html), сгенерированный для данного запроса аутентификации, а необходимые данные сохранить в кэше Redis.
Таким образом, клиентскому приложению будет возвращен только сгенерированный UUID, а JWT-токен будет использоваться другими сервисами для авторизации/аутентификации.
```
package com.infotrends.in.authenticationserver.model.redis;
import lombok.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisHash;
import java.time.LocalDateTime;
@RedisHash(value = "Tokens", timeToLive = 86400)
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TokensEntity {
private String id;
private String username;
private String authenticationToken;
private String modifiedBy;
private LocalDateTime modifiedOn;
private String createdBy;
private LocalDateTime createdOn;
}
```
### API Gateway
* Создайте приложение Spring Boot со следующими зависимостями, необходимыми для API Gateway с Eureka Client: `spring-cloud-starter-gateway`, `spring-cloud-starter-config` и `spring-cloud-starter-netflix-eureka-client`.
* Файл настроек Cloud Config Server и Eureka Server:
```
debug: true
logging:
level:
org.springframework.cloud.gateway: DEBUG
reactor.netty.http.client: DEBUG
server:
port: '8765'
spring:
cloud:
config:
profile: dev
gateway:
discovery.locator.enabled: true
config:
import: optional:configserver:http://clouduser:configserver705!@localhost:8888
application:
name: api-gateway
jackson:
date-format: yyyy-MM-dd HH:mm:ss
management:
endpoints:
web:
exposure:
include: '*'
eureka:
client:
serviceUrl:
defaultZone: http://eurekauser:eureka124!@localhost:8761/eureka
instance:
prefer-ip-address: 'true'
```
* Далее добавляем к классу `ApiGatewayApplication` аннотацию `@EnableFeignClients` для написания запросов к Eureka Server.
* И настраиваем Gateway Filter, который проверяет Bearer-токен в запросах, используя конечную точку `/validateToken` на сервере авторизации. Для этого наследуемся от класса `AbstractGatewayFilterFactory`, предоставленного Spring-API Gateway, и переопределяем метод `apply(Config config)`, который возвращает реализацию `GatewayFilter`.
```
package com.infotrends.in.InfoTrendsIn.ApiGateway.filters;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.infotrends.in.InfoTrendsIn.ApiGateway.model.Authorities;
import com.infotrends.in.InfoTrendsIn.ApiGateway.model.ConnValidationResponse;
import com.infotrends.in.InfoTrendsIn.ApiGateway.utils.Utilities;
import com.infotrends.in.InfoTrendsIn.exceptions.model.ExceptionResponseModel;
import com.infotrends.in.InfoTrendsIn.security.SecurityConstants;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.Date;
import java.util.List;
import java.util.function.Predicate;
@Component
@Slf4j
public class AuthenticationPrefilter extends AbstractGatewayFilterFactory {
@Autowired
@Qualifier("excludedUrls")
List excludedUrls;
private final WebClient.Builder webClientBuilder;
public AuthenticationPrefilter(WebClient.Builder webClientBuilder) {
super(Config.class);
this.webClientBuilder=webClientBuilder;
}
@Autowired
private ObjectMapper objectMapper;
@Override
public GatewayFilter apply(Config config) {
return (exchange, chain) -> {
ServerHttpRequest request = exchange.getRequest();
log.info("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");
log.info("URL is - " + request.getURI().getPath());
String bearerToken = request.getHeaders().getFirst(SecurityConstants.HEADER);
log.info("Bearer Token: "+ bearerToken);
if(isSecured.test(request)) {
return webClientBuilder.build().get()
.uri("lb://authentication-service/api/v1/validateToken")
.header(SecurityConstants.HEADER, bearerToken)
.retrieve().bodyToMono(ConnValidationResponse.class)
.map(response -> {
exchange.getRequest().mutate().header("username", response.getUsername());
exchange.getRequest().mutate().header("authorities", response.getAuthorities().stream().map(Authorities::getAuthority).reduce("", (a, b) -> a + "," + b));
return exchange;
}).flatMap(chain::filter).onErrorResume(error -> {
log.info("Error Happened");
HttpStatus errorCode = null;
String errorMsg = "";
if (error instanceof WebClientResponseException) {
WebClientResponseException webCLientException = (WebClientResponseException) error;
errorCode = webCLientException.getStatusCode();
errorMsg = webCLientException.getStatusText();
} else {
errorCode = HttpStatus.BAD\_GATEWAY;
errorMsg = HttpStatus.BAD\_GATEWAY.getReasonPhrase();
}
// AuthorizationFilter.AUTH\_FAILED\_CODE
return onError(exchange, String.valueOf(errorCode.value()) ,errorMsg, "JWT Authentication Failed", errorCode);
});
}
return chain.filter(exchange);
};
}
public Predicate isSecured = request -> excludedUrls.stream().noneMatch(uri -> request.getURI().getPath().contains(uri));
private Mono onError(ServerWebExchange exchange, String errCode, String err, String errDetails, HttpStatus httpStatus) {
DataBufferFactory dataBufferFactory = exchange.getResponse().bufferFactory();
// ObjectMapper objMapper = new ObjectMapper();
ServerHttpResponse response = exchange.getResponse();
response.setStatusCode(httpStatus);
try {
response.getHeaders().add("Content-Type", "application/json");
ExceptionResponseModel data = new ExceptionResponseModel(errCode, err, errDetails, null, new Date());
byte[] byteData = objectMapper.writeValueAsBytes(data);
return response.writeWith(Mono.just(byteData).map(t -> dataBufferFactory.wrap(t)));
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return response.setComplete();
}
@NoArgsConstructor
public static class Config {
}
}
```
### Маршруты
В отдельной конфигурации настраиваем маршруты (routes) на использование созданного выше `GatewayFilter`.
```
package com.infotrends.in.InfoTrendsIn.ApiGateway.config;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.infotrends.in.InfoTrendsIn.ApiGateway.filters.AuthenticationPrefilter;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
@Configuration
public class RouteConfiguration {
@Bean
public RouteLocator routes(
RouteLocatorBuilder builder,
AuthenticationPrefilter authFilter) {
return builder.routes()
.route("auth-service-route", r -> r.path("/authentication-service/**")
.filters(f ->
f.rewritePath("/authentication-service(?/?.\*)", "$\\{segment}")
.filter(authFilter.apply(
new AuthenticationPrefilter.Config())))
.uri("lb://authentication-service"))
.route("user-service-route", r -> r.path("/user-service/\*\*")
.filters(f ->
f.rewritePath("/user-service(?/?.\*)", "$\\{segment}")
.filter(authFilter.apply(
new AuthenticationPrefilter.Config())))
.uri("lb://user-service"))
.build();
}
}
```
### User-Service
* Создайте проект User-Service с помощью Spring Initializr. В этом сервисе будут храниться пользователи. Это будет пример бэкенда.
* Создайте класс конфигурации, наследуя класс `WebSecurityConfigurerAdapter`, и переопределите метод `void configure(HttpSecurity http)`. Здесь мы настроим запуск нашего фильтра проверки токена (JWTVerifierFilter) перед `UsernamePasswordAuthenticationFilter`.
```
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter{
@Autowired
private PasswordEncoder encoder;
@Value("${security.users.username}")
private String username;
@Value("${security.users.password}")
private String password;
@Autowired
private AppUserDetailsService appUserDetailsService;
@Override
protected void configure(HttpSecurity http)
throws Exception {
http.csrf().disable()
.headers().frameOptions().disable()
.and()
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.addFilterBefore(new JWTVerifierFilter(), UsernamePasswordAuthenticationFilter.class)
.authorizeRequests()
.antMatchers(HttpMethod.GET, "/api/v1/users").permitAll()
.anyRequest()
.authenticated()
.and().httpBasic();
}
}
```
* `JWTVerifierFilter` проверяет наличие в заголовке запроса данных об имени пользователя и полномочиях, и создает объект Authentication, используя класс `UsernamePasswordAuthenticationToken`.
* Далее, используя `SecurityContextHolder`**,** сохраняет authentication в [контекст безопасности Spring Security](https://javarevisited.blogspot.com/2018/02/what-is-securitycontext-and-SecurityContextHolder-Spring-security.html).
```
package com.infotrends.in.InfoTrendsIn.config.security.filters;
import com.infotrends.in.InfoTrendsIn.security.SecurityConstants;
import com.infotrends.in.InfoTrendsIn.utils.Utilities;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
public class JWTVerifierFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
String authHeader = httpServletRequest.getHeader("Authorization");
if(!Utilities.validString(authHeader) || !authHeader.startsWith("Bearer ")) {
filterChain.doFilter(httpServletRequest, httpServletResponse);
return;
}
logHeaders(httpServletRequest);
String username=httpServletRequest.getHeader("username");
List> authorities = new ArrayList<>();
String authoritiesStr = httpServletRequest.getHeader("authorities");
Set simpleGrantedAuthorities = new HashSet<>();
if(Utilities.validString(authoritiesStr)) {
simpleGrantedAuthorities=Arrays.stream(authoritiesStr.split(",")).distinct()
.filter(Utilities::validString).map(SimpleGrantedAuthority::new).collect(Collectors.toSet());;
}
Authentication authentication = new UsernamePasswordAuthenticationToken(username, null, simpleGrantedAuthorities);
SecurityContextHolder.getContext().setAuthentication(authentication);
filterChain.doFilter(httpServletRequest, httpServletResponse);
}
private void logHeaders(HttpServletRequest httpServletRequest) {
Enumeration headerNames = httpServletRequest.getHeaderNames();
while(headerNames.hasMoreElements()) {
String header=headerNames.nextElement();
logger.info(String.format("Header: %s --- Value: %s", header, httpServletRequest.getHeader(header)));
}
}
}
```
Таким образом, запрос к ресурсу / конечной точке разрешается, если запрашивающий их пользователь имеет соответствующий доступ/полномочия (authority). Ниже приведен пример для **GET**-запроса.
```
@PreAuthorize("hasAnyAuthority('USER_READ', 'USER')")
@GetMapping(value = "/{id}", produces = {MediaType.APPLICATION_JSON_VALUE})
public ResponseEntity> getUserById(@PathVariable("id") String id) {
UsersResponseModel respModel = new UsersResponseModel();
Optional user = usersSvc.findById(id);
if(!user.isPresent()) {
throw new UserExceptions.UserNotFoudException(ErrorsMappings.USER\_NOT\_FOUND\_MESSAGE);
}
respModel.setUser(user.get());
respModel.setCode(HttpStatus.OK.value());
EntityModel entity = EntityModel.of(respModel);
entity = usersProcess.generateHateoas(entity, this, "view-user", user.get().getId());
return new ResponseEntity(entity, HttpStatus.OK);
}
```
**Используемые зависимости:**
```
org.springframework.boot
spring-boot-starter-security
org.projectlombok
lombok
true
io.jsonwebtoken
jjwt
0.9.1
org.springframework.cloud
spring-cloud-starter-config
org.springframework.cloud
spring-cloud-starter-netflix-eureka-client
```
Для использования Config Server и Eureka Client также добавим следующие зависимости в раздел dependencyManagement.
```
2020.0.3
org.springframework.cloud
spring-cloud-dependencies
${spring-cloud.version}
pom
import
```
Использование JWT-токена
------------------------
### Проверка запросов к микросервисам
* API для аутентификации пользователя и генерации JWT-токена:
* API **validateToken**, используемый для валидации токена, отправляемого в запросе, и получения сведений об авторизации. (Этот API позже будет заблокирован от внешнего доступа).
* Запрос к защищенному ресурсу в User-Service при вызове через API Gateway с валидным токеном авторизации:
* Запрос к защищенному ресурсу в User-Service при вызове через API Gateway без валидного токена:
* Пример JWT-токена, созданный сервисом авторизации:
Полный исходный код проекта вы можете найти по адресу <https://github.com/Vicky-cmd/Authentication-Service.git>
---
> Сегодня в 20:00 состоится открытое занятие «**Структура программы на Java. Примитивные типы**». На этом открытом уроке вы сможете познакомиться с основными этапами создания простейшей программы на Java, понять принципы работы компилятора и виртуальной машины, а также разобраться с class-файлами. На уроке мы изучим примитивные типы данных, константы и enum. Регистрация доступна [**по ссылке**](https://otus.pw/fwCW/) для всех желающих.
>
> | https://habr.com/ru/post/681448/ | null | ru | null |
# Разработка приложения на основе протокола oAuth для Twitter API на PHP
В этой статье расскажу про работу с Twitter API по протоколу OAuth на PHP.
Протокол OAuth предоставляет приложению доступ к данным пользователя без передачи ему логина и пароля пользователя. Новые правила авторизации приложений требуют использование технологии “OAuth” для работы с Twitter начиная с 31 августа.
Тестовое приложение, которое получится в итоге, будет уметь выводить ленту сообщений пользователя, ленту последних статусов его фолловеров и по нажатию на кнопку рядом с каждым статусом фолловера или друга можно будет читать всю ленту этого пользователя.
Итак, для начала создадим новое приложение по [этой](http://dev.twitter.com/apps/new) ссылке.
Теперь у нас есть необходимые данные, которые следует сохранить в config.php
`define('CONSUMER_KEY', 'Your consumer key');
define('CONSUMER_SECRET', 'You consumer secret');
define('OAUTH_CALLBACK', 'http://yousite.ru/callback.php');`
На странице соединения с Твиттером connect.php подключаем вышеуказанные данные и проверяем их наличие:
`if (CONSUMER_KEY === '' || CONSUMER_SECRET === '') {
echo 'You need a consumer key and secret to test the sample code. Get one from https://twitter.com/apps'; exit;}`
Начинаем процесс подключения (переход на страницу redirect.php):
`$content = 'Sign in with Twitter';
php print_r($content); ?`
Подключаем библиотеку для работы с Twitter API и данные учетной записи приложения на redirect.php
`require_once('twitteroauth/twitteroauth.php');
require_once('config.php');`
Создаем TwitterOAuth объект на основе учетной записи нашего приложения:
`$connection = new TwitterOAuth(CONSUMER_KEY, CONSUMER_SECRET);`
Далее мы получаем временные токены от Твиттера и сохраняем их:
`$_SESSION['oauth_token'] = $token = $request_token['oauth_token'];
$_SESSION['oauth_token_secret'] = $request_token['oauth_token_secret'];`
На основе временного токена отправляем пользователя на авторизацию в Твиттер:
`$url = $connection->getAuthorizeURL($token);`
Если полученный токен старый, то чистим сессию и отправляем пользователя на страницу для соединения с Твиттером:
`if (isset($_REQUEST['oauth_token']) && $_SESSION['oauth_token'] !== $_REQUEST['oauth_token']) {
$_SESSION['oauth_status'] = 'oldtoken';
header('Location: ./clearsessions.php');`
На странице clearsessions.php вызываем:
`session_start();
session_destroy();
header('Location: ./connect.php');`
Если все прошло успешно, то создаем TwitterOAuth объект на основе учетной записи нашего приложения и временных токенов:
`$connection = new TwitterOAuth(CONSUMER_KEY, CONSUMER_SECRET, $_SESSION['oauth_token'], $_SESSION['oauth_token_secret']);`
Теперь получаем ключ доступа от Твиттера, который должен быть сохранен для дальнейшего использования:
`$access_token = $connection->getAccessToken($_REQUEST['oauth_verifier']);
$_SESSION['access_token'] = $access_token;`
Временные токены больше не нужны:
`unset($_SESSION['oauth_token']);
unset($_SESSION['oauth_token_secret']);`
Далее переходим на страницу нашего прилоежния:
`header('Location: ./index.php');`
На странице index.php сохраняем токен пользователя в переменную:
`$access_token = $_SESSION['access_token'];`
Создаем TwitterOAuth объект на основе учетной записи нашего приложения и токенов пользователя:
`$connection = new TwitterOAuth(CONSUMER_KEY, CONSUMER_SECRET, $access_token['oauth_token'], $access_token['oauth_token_secret']);`
Теперь мы можем использовать различные методы для получения данных пользователя.
Например, получить данные учетной записи пользователя.
`$content_user = $connection->get('account/verify_credentials');
$array_user = (array)$content_user;
$user_id=$array_user["id"];`
На основе id пользователя можно получить сообщения из его ленты, указав id в массиве параметров (в массиве параметров можно также указывать количество выводимых записей):
`$content_friends=$connection->get('statuses/friends_timeline',array('id' => $user_id));`
Последние сообщения всех фолловеров пользователя:
`$content_followers=$connection->get('statuses/followers', array('id' => $user_id));`
Собственная лента сообщений пользователя ( по умолчанию выводится только 20 записей, максимальное количество выводимых — 200).
`$content_userline=$connection->get('statuses/user_timeline', array('id' => $user_id,'count'=>200));`
По такому же принципу можно вызывать и другие методы.
Общая лента Твиттера: [api.twitter.com/1/statuses/public\_timeline.xml](http://api.twitter.com/1/statuses/public_timeline.xml)
Публичные сообщения которые писали вам: [api.twitter.com/1/statuses/mentions.xml?count=5&page=1](http://api.twitter.com/1/statuses/mentions.xml?count=5&page=1)
Мои ретвиты: [api.twitter.com/1/statuses/retweeted\_by\_me.xml?count=5&page=3](http://api.twitter.com/1/statuses/retweeted_by_me.xml?count=5&page=3)
Ретвиты мне: [api.twitter.com/1/statuses/retweeted\_to\_me.xml?count=5&page=3](http://api.twitter.com/1/statuses/retweeted_to_me.xml?count=5&page=3)
[И другие методы.](http://imadering.mybb.ru/viewtopic.php?id=96)
`echo print_r($content_friends); // выводим результат запроса`
Результат при получении ленты сообщений будет представлять собой массив из элементов stdClass Object:
[0] => stdClass Object
(
[created\_at] => Sat Sep 04 11:01:48 +0000 2010
[in\_reply\_to\_screen\_name] =>
[source] => IncredebleTB
[retweeted] =>
[truncated] =>
[in\_reply\_to\_status\_id] =>
[in\_reply\_to\_user\_id] =>
[contributors] =>
[place] =>
[coordinates] =>
[user] => stdClass Object
(
[show\_all\_inline\_media] =>
[profile\_background\_image\_url] => [s.twimg.com/a/1283555538/images/themes/theme16/bg.gif](http://s.twimg.com/a/1283555538/images/themes/theme16/bg.gif)
[favourites\_count] => 0
[profile\_image\_url] => [a0.twimg.com/profile\_images/1105647496/robot\_normal.jpg](http://a0.twimg.com/profile_images/1105647496/robot_normal.jpg)
[description] => Веб дизайн, разработка веб приложений, создание сайтов
[contributors\_enabled] =>
[profile\_sidebar\_fill\_color] => f2f2f2
[url] => [dandreev.com](http://dandreev.com)
[geo\_enabled] =>
[profile\_background\_tile] =>
[screen\_name] => incredibleTB
[lang] => en
[created\_at] => Mon Apr 26 20:32:14 +0000 2010
[profile\_sidebar\_border\_color] => a8a8a8
[location] => Москва
[verified] =>
[follow\_request\_sent] =>
[following] => 1
[profile\_background\_color] => 9AE4E8
[followers\_count] => 99
[protected] =>
[profile\_text\_color] => 141414
[name] => Дмитрий Андреев
[listed\_count] => 0
[profile\_use\_background\_image] => 1
[time\_zone] => Quito
[friends\_count] => 48
[id] => 137459247
[statuses\_count] => 900
[notifications] =>
[utc\_offset] => -18000
[profile\_link\_color] => 0084B4
)
[geo] =>
[retweet\_count] =>
[id] => 22967688386
[favorited] =>
[text] => Craigslist Censored: Adult Section Comes Down [bit.ly/9evRKN](http://bit.ly/9evRKN) via (@techcrunch)
)
Для доступа к ним можно обратиться например так:
`$array_friends = (array)$content_friends;
foreach ($array_friends as $friends_sets)
{
$friends_sets=(array)$friends_sets; // преобразуем stdClass Object в массив
$friend_name=$friends_sets["user"]->name; // доступ к полям stdClass Object
}`
Библиотеку для oAuth на php можно скачать [здесь](http://github.com/abraham/twitteroauth).
Приложение, которое получилось в итоге, [здесь](http://startup-news.ru/twitter2/connect.php). Приложение содержит 3 ленты с пагинацией (фолловеры, друзья и персональная лента какого-либо пользователя). Дополнительно подключена библиотека jTweetsAnywhere, позволяющая выводить информацию о каждом пользователе (кнопка Connect with Twitter вверху). | https://habr.com/ru/post/103548/ | null | ru | null |
# Простая реализация модели MVC с поддержкой иерархии шаблонов
В данной статье показывается пример реализации модели MVC средствами PHP. Предлагаемая реализация является предельно простой как для понимания, так и для исполнения. Полезными особенностями являются легкая расширяемость и поддержка иерархии шаблонов. Все это позволяет положить ее в основу достаточно сложного веб-проекта.
##### Немного о MVC
Паттерн разработки MVC обсуждался многократно и подробно описывать его вряд-ли есть смысл. Для ознакомления с предметом можно почитать:
* [Реализация MVC паттерна на примере создания сайта-визитки на PHP](http://habrahabr.ru/post/150267/)
* [Статья в wikipedia](http://ru.wikipedia.org/wiki/Model-View-Controller)
Поэтому только кратко упомянем ключевые компоненты этой системы:
* **Контроллер (controller)** — Важнейший компонент системы. Именно набор контроллеров и обрабатываемых ими команд (actions) определяют, каким именно функционалом будет обладать система. Контроллер является первым элементом реализации бизнес-логики приложения и должен определять что произошло в системе, и каким способом на это отреагировать. В частности — контроллер определяет какое представление (View) потребуется для отображения состояния системы и каким образом (Model) эти данные должны быть получены. Однако, контроллер, как хороший командир, не должен вникать в то, как его подчиненные будут выполнять задачу. Его дело — выбрать исполнителей и отдать им приказы. Важно учитывать, что даже в рамках обработки одной команды контроллер не привязан к одному представлению и одной модели. Наоборот, он может выбирать ил «на лету». Для иллюстрации рассмотри следующий пример: авторизация пользователя (псевдокод):
```
userController->actionAuth($login,$pass)
{
$model=new userModel();
if($model->authorize($login,$pass) {
$view="authok";
}
else {
$view="authfailure";
}
processView($view);
}
```
В данном случае, контроллер не имеет ни малейшего представления о том, как именно модель выполняет авторизацию. Работа с данными — чисто модельные задачи. Модель только сообщает контроллеру о том, успешной или нет была обработка. В зависимости от этого контроллер принимает решение о том, какую страницу показать пользователю.
* **Представление (View)** — Отвечает за представление данных пользователю. Представление не имеет ни малейшего представления (простите за каламбур) о том, каким образом получены данные, которые ему нужны. Оно знает только о том, откуда эти данные можно взять и как их представить пользователю. Как правило, основным источником данных для представления является модель. Однако, как мы увидим дальше — модель не всегда способна предоставить данные в полном объеме. Важно, что с одной и той же моделью могут взаимодействовать несколько представлений. Как было показано в примере и представление «authok» и представление «authfailure» будут использовать данные одной модели $model.
* **Модель (model)** — Очень важный компонент, однако несколько напоминающий рассеянного ученого, который способен с одинаковым интересом решать проблемы бессмертия и уничтожения всего живого. Иными словами, модель должна уметь собрать необходимые данные или произвести обработку входящих данных. Это ее конек. Однако, модель как правило не имеет представления о том, в каком контексте ее вызвали, в ответ на какую команду, что происходит в системе в целом. Более того, модель не может предполагать, понадобятся ли системе для обработки команды дополнительные данные, или нет. Очевидно, что собирать все мыслимые данные на «всякий случай» ни одна модель ни в состоянии.
Попытка собрать все данные в одном представлении может привести и к многократному дублированию кода. Например, данные профиля пользователя некого сайта могут понадобиться в рамках самых разных задач (от редактирования профиля пользователем, до указания ссылки на автора опубликованного материала. Если каждая модель будет самостоятельно запрашивать такие данные, сложность и дублирование кода будет возрастать экспоненциально.
Если представление сможет запрашивать данные порциями, определяя каждый раз кто может эти данные предоставить, жизнь программиста станет легка и безоблачна, так как можно будет сосредоточиться на решении отдельной задачи, без необходимости держать в голове весь проект в целом. Однако, это предполагает необходимость организации иерархической обработки представлений. Если мы сможем из какого-то места шаблона запросить данные другого контроллера и получить готовый фрагмент выходного кода (например уже отформатированный html) нам станет легче. Однако, для этого нам в какой-то момент потребуется приостановить обработку текущего потока и передать управление другому обработчику. Проблема в том, что с такой задачей PHP справляется, мягко говоря, не блестяще. Данные через интерпретатор проходят только однократно и конструкции типа `echo('php echo($msg'); ?');` работать не будут. Внутренне обращение к интерпретатору не пройдет.
Отчасти, проблему блочного построения вывода помогают решить шаблонизаторы. Их достаточно много, разных по возможностям и удобству работы. Однако, они имеют один общий недостаток — они являются надстройкой над PHP и вводят свой язык разметки, требующий изучения. В тоже время, такой функционал в рамках PHP является заведомо избыточным, так как этот язык сам по себе обеспечивает вполне неплохие возможности работы с шаблонами. Думаю, всем приходилось писать конструкции типа:
```
...
php echo($msg); ?
или более сложные
php foreach($array as $val) { ?| $val |
}?
```
В таких конструкциях как раз и используются возможности PHP как шаблонизатора. Кстати, дизайнеры к таким вставкам относятся без испуга.
Теперь давайте перейдем к практической части, и посмотрим как в рамках шаблона страницы можно реализовать вставку целого блока, который в свою очередь может быть составлен из целого набора под-блоков. Это может быть реализовано на чистом PHP, без привлечения дополнительного языка разметки.
##### Практика
Мы рассмотрим упрощенную версию системы, в которой опущены такие моменты, как работа с ЧПУ (человеко-понятные урл) и настройки файла .htaccess для обеспечения единой точки входа в систему. Эти вопросы широко освещены в сети и смысла повторяться нет. Также не будем рассматривать вопросы старательного раскладывания компонентов системы по каталогам, так как это по сути личное дело каждого. Сосредоточимся на решении проблемы вложенности шаблонов.
Саму систему в действии можно увидеть [здесь](http://www.fotogenius.ru/templateengine/test.html)
Главным компонентом системы и главной точкой входа является файл application.php:
```
php
class webApplication
{
protected $dataBuf;
protected static $_classInstance;
protected $defaultHandler;
protected $sefRequestParams; //To support SEF technology
private function __construct()
{
$this-dataBuf="";
$this->defaultController="mainpage";
$currentURL = $_SERVER['REQUEST_URI'];
$this->sefRequestParams=explode("/",$currentURL);
//It could be a good idea to establish database connection here
}
private function __clone()
{
}
public function getSEFParams() //sef params need to be accessible for any parts of thew app
{
return $this->sefRequestParams;
}
public static function getApp()
{
if (null === self::$_classInstance)
self::$_classInstance = new self();
return self::$_classInstance;
}
public function handle($controller,$action)
{
if(!isset($controller) || $controller=="")
$controller=$this->defaultController;
$val=$controller.'.php';
$res=require_once($val);
if($res!=1)
{
echo("requested controller not found!");
return 0;
}
$controlClass=new $controller();
if($controlClass==NULL)
{
echo("Controller initialization error!");
return 0;
}
ob_start();
$controlClass->dispatchAction($action,&$this);
$this->dataBuf=ob_get_contents();
ob_end_clean();
echo($this->dataBuf);
return 1;
}
public function handleHttp()
{
$controller=$_REQUEST['controller'];
$action="";
if(!isset($controller) || $controller=="") //Assume we're using SEF technics
{
$controller=$this->sefRequestParams[0];
$action=$this->sefRequestParams[1];
}
else
{
$action=$_REQUEST['action'];
}
return $this->handle($controller,$action);
}
}
$app=webApplication::getApp();
$app->HandleHttp();
?>
```
Класс webApplication является базовой точкой входа в систему. Как видно из представленного кода, этот класс реализует паттерн [Singleton](http://ru.wikipedia.org/wiki/Singleton). В рамках работы системы у нас всегда присутствует экземпляр данного класса, причем всегда только один. Такое свойство делает его крайне удобным для хранения всех глобальных данных системы. В данном случае импорт настроек системы и их использование опущены, так как их легко реализовать самостоятельно, в зависимости от своих потребностей.
Ключевой функцией класса является метод handle($controller,$action). Эта функция принимает на вход имя контроллера (первый параметр) и название действия (action), которое надо выполнить. В соответствии с практикой хорошего программирования предполагаем, что имя класса контроллера совпадает с именем файла, в котором он храниться. Разумеется, по желанию, строку $val=$controller.'.php'; можно модифицировать: $val=CONTROLLER\_PATH.$controller.'.php'
Важным является то, эта функция позволяет вызвать нужный контроллер по его имени. Для того, чтобы контроллеры могли корректно взаимодействовать с системой, они должны реализовывать интерфейс iHandler, который определен следующим образом:
```
ihandler.php:
php
interface iHandler
{
public function dispatchAction($action,&$app);
public function actionDefault(&$app);
}
?
```
Этот интерфейс вводит два обязательных метода: dispatchAction($action,&$app) и public function actionDefault(&$app);
Оба метода в качестве одного из параметров принимают ссылку на класс webApplication (параметр &$app). Это сделано для того, чтобы избежать привычки PHP делать полную копию объекта. Да и иметь нужный класс в качестве параметра несколько удобнее, чем писать global $app; $app->…
Вернемся к нашему примеру. В нашем случае будет вызван контроллер welcome (welcome.php):
```
php
require_once("ihandler.php");
class welcome implements iHandler
{
public function __construct()
{
//Nothing to do here
}
public function dispatchAction($action,&$app)
{
$this-actionDefault(&$app);
}
public function actionDefault(&$app)
{
include("welcome.html");
}
}
?>
```
Этот контроллер написан сугубо в рамках примера и можно считать, что не делает вообще ничего. Только загружает некий HTML-файл. Откуда же тогда берутся данные? Можно предположить, что загружаемый файл является шаблоном и как-то их запрашивает. Так ли это? Смотрим код:
```
Template handler output test page
Test page for template handler
### Starting the test
php $app-handle("hello","say");?>
```
И это действительно так!.. Смотрим на строку php $app-handle(«hello»,«say»);?>. Вот он лев! Мы обратились к нашему классу webApplication и попросили вызвать нужный нам контроллер. Причем система обеспечит подготовку и вставку нужного нам HTML автоматически. Никаких возвратов строк. И задействовали мы ту же функцию handle, которую разбирали выше. Мы просим вызвать контроллер hello, который очевидно расположен в hello.php
```
php
require_once("ihandler.php");
class hello implements iHandler
{
public function __construct()
{
//Nothing to do here
}
public function dispatchAction($action,&$app)
{
switch($action)
{
case 'say':
$this-actionSay(&$app);
break;
default:
$this->actionDefault(&$app);
break;
}
}
public function actionSay(&$app)
{
require_once("saymodel.php");
$model=new sayModel();
$model->prepareString($_REQUEST['name']);
include("hello.tpl");
}
public function actionDefault(&$app)
{
//Nothing to do by default
}
}
?>
```
В данном контроллере у нас реализован метод, отвечающий за обработку действия «say» — actionSay.
Этот метод выполняет типичную для модели MVC последовательность действий: создает модель, передает ей на обработку данные, загружает представление.
Сначала посмотрим на модель (это только пример, поэтому она крайне проста).
```
php
class sayModel
{
public $msg;
public function __construct()
{
$this-msg="";
}
public function prepareString($name)
{
$this->msg="Hello $name!";
}
}
?>
```
Понятно, что реальная модель будет намного сложнее. Эта модель предоставляет данные в виде доступной (public) строковой переменной $msg. Как представление hello.tplб загружаемое контроллером использует эти данные? Очень просто:
```
hello.tpl
php echo($model-msg); ?>
```
Как видно, данное представление — всего навсего фрагмент HTML кода, со вставкой PHP, обращающейся к данным модели. Эти данные уйдут в поток и после обработки интерпретатором PHP попадут в нужное место первого представления. Понятно, что в целом уровень вложенности и количество вызовов контроллеров не ограничено.
Все! Мы реализовали многоуровневую систему шаблонов, используя модель MVC для каждого из них. Предлагаемая система может послужить неплохим скелетом для реализации сложных приложений. | https://habr.com/ru/post/232089/ | null | ru | null |
# Property Injection своими руками (Xamarin/.Net)
В данной статье мы рассмотрим, чем отличается Property Injection от Constructor Injection и реализуем первое в дополнение к последнему на базе небольшого DI-контейнера в исходниках.
Это обучающий материал начального уровня. Будет полезен тем, кто ещё не знаком с DI-контейнерами или интересуется, как оно устроено изнутри.
Что это и где используется
--------------------------
Внедрение зависимостей (Dependency Injection) – распространённый шаблон проектирования, применяемый для создания программ со слабой связанностью компонентов. Новички обычно встречаются с ним на проектах, где применяются юнит-тесты.
Классический пример системы с жёсткой связанностью – это когда в гостинице намертво соединяют фен с электропитанием (хозяева переживают за сохранность устройства). Длины провода, в общем достаточно, однако при таком подходе нельзя модифицировать фен отдельно от стены, а стену – отдельно от фена. Внедрение слабой связанности в виде розетки и вилки решает эту проблему.
Другой пример – это жёсткая привязка сотрудников к рабочему месту, и также необходимость ходить на работу каждый день. Эта жёсткая связанность в современных компаниях всё чаще ослабляется как возможностью работать из дому, так и внедрением практики отсутствия постоянного рабочего места: хочешь прийти в офис – не забудь себе забукать местечко. С точки зрения работодателя, работа будет выполнена независимо от места сидения сотрудника. Возникают, конечно, дополнительные риски, но такова цена большей гибкости.
Идея внедрения зависимостей в узком смысле заключается в том, что класс-потребитель некоего функционала обращается к классу-поставщику не напрямую, путём создания его экземпляра, а опосредованно, по ссылке определённого интерфейсного типа. От класса-поставщика требуется только соответствовать указанному интерфейсу.
В отличие от сервис-локатора, здесь классы не только ничего не знают друг о друге, но ещё и не содержат обращения к классу-посреднику (service locator).
Для того, чтобы поставить в соответствие интерфейсу какой-то конкретный класс (или экземпляр класса), часто применяется так называемый DI-контейнер, в котором заранее регистрируются отношения интерфейса и реализации. Для языков, которые не поддерживают отражения (reflections), то есть не позволяют оперировать свойствами типов, можно ограничиться таким шаблоном как composition root (рассмотрение данного шаблона находится вне рамок данной статьи).
Такой подход обеспечивает гибкость: всегда можно вместо одной реализации интерфейса использовать другую, по обстоятельствам.
Естественный способ передачи ссылок в класс-потребитель – это указать их в параметрах его конструктора. Как правило, DI-контейнер при запросе нужного интерфейса автоматически пробегается по перечню параметров и рекурсивно удовлетворяет все зависимости.
Другой способ – это передача ссылок через свойства, что и называется Property Injection. Чтобы удовлетворить ссылки, DI-контейнер пробегается по списку свойств и в те из них, которые соответствуют определённым критериям, назначают нужные ссылки.
Есть и более редкий способ – Method Injection, где ссылки передаются через специальный метод (например, Init() с перечислением зависимостей в виде параметров). Такой подход похож на constructor injection, но срабатывает уже после создания экземпляра объекта. Под этим термином также понимается нечто совершенно иное, а именно простая передача зависимостей как параметров в произвольный метод.
Не очередной ли это велосипед
-----------------------------
Существует множество DI-контейнеров (например, Unity, NInject, Autofac, Spring, Castle Windsor, TinyIoc, MvvmCross). Большинство из них поддерживает Property Injection.
Но иногда бывают ситуации, когда по тем или иным причинам сторонний DI-контейнер вам не подходит, и приходится писать свой.
Например, корпоративными политиками запрещено использование сторонних библиотек. Или нужных вам библиотек не существует в природе. Или эти библиотеки не удовлетворяют проектным требованиям.
В этом случае нетрудно сделать и свой собственный контейнер – если, конечно, это технически возможно в рамках применяемой технологии разработки, как это возможно в .Net.
Почему не устраивает constructor injection
------------------------------------------
Внедрение зависимостей через параметры конструктора требует создания в классе-потребителе служебных переменных, в которых сохраняются ссылки из параметров конструктора. Это рутинная операция, которая, по-хорошему, могла бы быть как-то автоматизирована. Но пока такой автоматизации нет, эту работу приходится делать программисту. Каждая новая зависимость добавляется сначала в параметры конструктора, потом в служебные переменные, затем в конструкторе добавляется строчка присвоения одного другому.
Часто можно наблюдать, как по коду протягивается какой-нибудь из добавляемых параметров, от класса верхнего уровня до конечного потребителя вниз по иерархии наследования. Цепь вызовов тянется, как связка сосисок, от конструктора к конструктору. Мало того, что сама по себе последовательная передача этих параметров загромождает код. Так ещё и добавление очередного параметра в конец этой цепи вызовов требует её модификации на всём протяжении. Что совсем неудобно. Как результат, класс может солидно «распухнуть» только из-за всей этой машинерии, даже ещё не начав ничего делать.
Почему же не избавить программиста от этой рутинной работы и не делегировать создание сущностей DI-контейнеру?
Также можно отметить, что при передаче параметров в конструктор, обычно они передаются без указания имени параметра. То есть, пользователь класса вынужден полагаться либо на порядковый номер параметра, либо явно указывать имя параметра, что ещё сильнее загромоздит код.
Есть хорошее правило, что если вам становится неудобно добавлять очередную зависимость в параметры конструктора, то, значит, их действительно слишком много, и вам следует пересмотреть дизайн. Обычно это 5 штук – естественный предел объектов, которые человек без тренировки может удерживать в области своего внимания.
Мы, однако же, считаем, что в этом правиле ключевое слово – неудобно. Хотелось бы его избегать.
Свой DI-контейнер
-----------------
Реализацию простейшего DI-контейнера нетрудно найти в исходниках. Автор когда-то воспользовался небольшим примером из Xamarin University (см. [здесь](https://github.com/xamarin/xamarinu-connect2016/blob/master/Source/eXam/eXam.AutomatedTests/Utility/SimpleContainer.cs)).
Здесь многого не хватает по сравнению с промышленными DI-контейнерами (синглтоны, домены и т.д.), но это находится за рамками настоящей статьи.
Контейнер позволяет зарегистрировать отношение между интерфейсом и реализацией (метод Register в разных вариантах, который просто добавляет элемент в Dictionary), чтобы затем, в методе Resolve, создать экземпляр класса, который соответствует запрашиваемому интерфейсу и проделать то же самое параметров его конструктора.
Данный контейнер работает на базе Reflections (отражений) и метода Activator.CreateInstance(). Последний метод используется для создания экземпляра класса по его типу, а отражения позволяют вычитывать свойства типа.
Для реализации property injection добавим специальный атрибут, которым будем помечать те свойства, которые контейнеру следует обрабатывать как зависимости.
Назовём атрибут “ResolveAttribute”. Для этого необходимо создать класс-наследник System.Attribute (см. Appendix A).
Добавим обработку атрибута в методе Resolve контейнера.
```
public object Resolve(Type type)
{
object result = null;
...
//Inject [Resolve] marked properties
var props = targetType.GetRuntimeProperties()
.Where(x => x.CanWrite && x.IsDefined(typeof(ResolveAttribute)));
foreach (var item in props)
{
item.SetValue(result, Resolve(item.PropertyType));
}
return result;
}
```
Это всё, что нужно сделать в исходном контейнере для того, чтобы заработало внедрение зависимостей через свойства (исходники см. в Appendix B).
Пример использования
--------------------
Предположим, существует класс, в котором используется внедрением зависимостей через конструктор (разумеется, зависимости должны быть заранее зарегистрированы – см. Appendix C). Заметим, что параметры и тело конструктора — это сугубо обслуживающий код:
```
public class MediaRecorder : IMediaRecorder
{
private readonly IMediaPlayer player;
private readonly IRestServiceClient restClient;
private readonly ILog log;
private readonly IFileService fileService;
private readonly ISettingsProvider settingsProvider;
public MediaRecorder(IMediaPlayer player, IRestServiceClient restClient, ILog log, IFileService fileService, ISettingsProvider settingsProvider)
{
this.player = player;
this.restClient = restClient;
this.log = log;
this.fileService = fileService;
this.settingsProvider = settingsProvider;
}
}
```
Модифицируем класс, используя внедрение через свойства:
```
public class MediaRecorder : IMediaRecorder
{
[Resolve]
public IMediaPlayer Player { get; set; }
[Resolve]
public IRestServiceClient RestClient { get; set; }
[Resolve]
public ILog Log { get; set; }
[Resolve]
public IFileService FileService { get; set; }
[Resolve]
public ISettingsProvider SettingsProvider { get; set; }
public MediaRecorder()
{
}
}
```
Как видим, количество служебного кода сократилось, а сам код стал более читабельным.
Обратной стороной успеха служит снижение возможности контролировать целостность программы со стороны компилятора. Впрочем, это общее следствие для всех типов реализации IoC.
Также надо иметь в виду, что нормальной практикой считается использовать constructor injection для обязательных зависимостей, а property injection – для необязательных. Именно поэтому свойства в нашем примере имеют модификатор доступа «public».
Публичный доступ к зависимостям даёт возможность подменять их значения извне, что, одной стороны, служит инструментом для внедрения зависимостей вручную, а с другой – позволяет непреднамеренно повредить работу всего класса, если он написан недостаточно надёжно.
Код в нашей реализации не проверяет уровень доступа свойства, то есть можно использовать как «public», так и «private». Последнее рекомендуется делать для тех свойств, произвольная модификация которых нежелательна. Это защитит класс от непреднамеренного неправильного использования и, в то же время, позволит использовать property injection.
Производительность
------------------
Как видно по нашей реализации, для поддержки Property Injection нужно при помощи отражений (reflections) пробежаться по всем свойствам класса. Может оказаться, что свойств довольно много – на практике бывает и более тысячи, что несколько замедляет работу программы.
По этой причине данный подход не очень-то годится для классов с большим количеством свойств. Здесь возможна оптимизация как со стороны пользовательского кода, так и со стороны самого контейнера.
Например, можно было бы сократить список свойств путём помещения в служебный класс тех из них, которые не помечены «ResolveAttribute» (в нашей реализации), задуматься над отложенным чтением (lazy loading). А контейнер мог бы кэшировать список свойств для внедрения. Но об этом мы поговорим как-нибудь в другой раз.
Вместе с тем, закон Мура всё ещё работает, и вычислительная мощь компьютеров растёт. Это позволяет нам использовать всё более и более сложные алгоритмы.
В заключение отметим, что различные DI-контейнеры имеют различную производительность, причём эта разница может быть значительной (см. [небольшое исследование](http://xamarinhelp.com/ioc-container-performance/)).
**Appendix A**
```
using System;
namespace Bricks
{
[AttributeUsage(AttributeTargets.All)]
public sealed class ResolveAttribute : Attribute
{
}
}
```
**Appendix B**
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace Bricks
{
///
/// This is a very simple example of a DI/IoC container.
///
public sealed class DependencyContainer : IDependencyContainer
{
readonly Dictionary> registeredCreators = new Dictionary>();
readonly Dictionary> registeredSingletonCreators = new Dictionary>();
readonly Dictionary registeredSingletons = new Dictionary();
object locker = new object();
///
/// Register a type with the container. This is only necessary if the
/// type has a non-default constructor or needs to be customized in some fashion.
///
/// Abstraction type
/// Type to create
public void Register()
where TImpl : new()
{
registeredCreators.Add(typeof(TAbstraction), () => new TImpl());
}
///
/// Register a type with the container. This is only necessary if the
/// type has a non-default constructor or needs to be customized in some fashion.
///
/// Function to create the given type.
/// Type to create
public void Register(Func creator)
{
registeredCreators.Add(typeof(T), creator);
}
///
/// Register a type with the container. This is only necessary if the
/// type has a non-default constructor or needs to be customized in some fashion.
///
/// Abstraction type
public void RegisterInstance(object instance)
{
registeredCreators.Add(typeof(TAbstraction), () => instance);
}
///
/// Creates a factory for a type so it may be created through
/// the container without taking a dependency on the container directly.
///
/// Creator function
/// The 1st type parameter.
public Func FactoryFor()
{
return () => Resolve();
}
///
/// Creates the given type, either through a registered function
/// or through the default constructor.
///
/// Type to create
public T Resolve()
{
return (T)Resolve(typeof(T));
}
///
/// Creates the given type, either through a registered function
/// or through the default constructor.
///
/// Type to create
public object Resolve(Type type)
{
object result = null;
var targetType = type;
TypeInfo typeInfo = type.GetTypeInfo();
if (registeredSingletonCreators.TryGetValue(type, out Func creator))
{
lock (locker)
{
if (registeredSingletons.ContainsKey(type))
{
result = registeredSingletons[type];
}
else
{
result = registeredSingletonCreators[type]();
registeredSingletons.Add(type, result);
}
}
if (result != null)
{
targetType = result.GetType();
}
}
else
if (registeredCreators.TryGetValue(type, out creator))
{
result = registeredCreators[type]();
if (result != null)
{
targetType = result.GetType();
}
}
else
{
var ctors = typeInfo.DeclaredConstructors.Where(c => c.IsPublic).ToArray();
var ctor = ctors.FirstOrDefault(c => c.GetParameters().Length == 0);
if (ctor != null || ctors.Count() == 0)
{
result = Activator.CreateInstance(type);
}
else
{
// Pick the first constructor found and create any parameters.
ctor = ctors[0];
var parameters = new List();
foreach (var p in ctor.GetParameters())
{
parameters.Add(Resolve(p.ParameterType));
}
result = Activator.CreateInstance(type, parameters.ToArray());
}
}
//Create [Resolve] marked property
var props = targetType.GetRuntimeProperties()
.Where(x => x.CanWrite && x.IsDefined(typeof(ResolveAttribute)));
foreach (var item in props)
{
item.SetValue(result, Resolve(item.PropertyType));
}
return result;
}
public void Clear()
{
registeredCreators.Clear();
registeredSingletonCreators.Clear();
registeredSingletons.Clear();
}
public void RegisterSingleton(Type tInterface, object service)
{
RegisterSingleton(tInterface, () => service);
}
public void RegisterSingleton(TAbstraction service) where TAbstraction : class
{
registeredSingletonCreators.Add(typeof(TAbstraction), () => service);
}
public void RegisterSingleton() where TAbstraction : class where TImpl : new()
{
registeredSingletonCreators.Add(typeof(TAbstraction), () => new TImpl());
}
public void RegisterSingleton(Type tInterface, Func serviceConstructor)
{
registeredSingletonCreators.Add(tInterface, serviceConstructor);
}
public void RegisterSingleton(Func serviceConstructor) where TAbstraction : class
{
registeredSingletonCreators.Add(typeof(TAbstraction), serviceConstructor);
}
}
}
```
**Appendix C**
```
public static class Bootstrap
{
public static readonly IDependencyContainer Container = new DependencyContainer();
public static void Init()
{
Container.Clear();
Container.RegisterSingleton();
Container.RegisterSingleton(() => new SettingsProvider());
Container.RegisterSingleton(() => new FileService());
Container.RegisterSingleton(() => new MessagesProvider());
Container.Register();
Container.Register();
Container.Register();
...
}
}
``` | https://habr.com/ru/post/352304/ | null | ru | null |
# Как я сократил время загрузки GTA Online на 70%
GTA Online [печально известна](https://www.reddit.com/r/gtaonline/comments/9vgo0g/how_the_fuck_are_20_minute_load_times_acceptable/) своей медленной скоростью загрузки. Запустив недавно игру, чтобы выполнить новые миссии-налёты, я был *шокирован* тем, что она загружается так же медленно, как и в момент выпуска семь лет назад.
Время настало. Пора разобраться в причинах этого.
Разведка
--------
Для начала я захотел проверить, не решил ли уже кто-нибудь эту проблему. Большинство найденных результатов состояло из анекдотичных данных о том, [насколько сложна игра](https://metro.co.uk/2017/11/01/why-does-gta-v-take-so-long-to-load-7041927/), что ей приходится грузиться так долго, историй об отстойности [сетевой архитектуры p2p](https://steamcommunity.com/app/271590/discussions/0/217690940938819317/) (и в этом есть правда), сложных способов [загрузки в сюжетный режим, а после него в одиночную сессию](https://gtaforums.com/topic/908000-fastest-way-to-load-into-gtao-single-player-first-or-straight-in/) и пары модов, позволявших пропустить начальное видео с логотипом компании R\*. Некоторые источники сообщали, при совместном использовании всех этих способов можно сэкономить аж целых 10-30 секунд!
Тем временем на моём PC…
Бенчмарк
--------
> Время загрузки сюжетного режима: около 1 мин 10 с
>
> Время загрузки онлайн-режима: около 6 мин 0 с
>
> Меню запуска отключено, время от появления логотипа R\* до начала самого игрового процесса (время логина в social club не считается).
>
>
>
> Старый, но приличный ЦП: AMD FX-8350
>
> Дешёвый SSD: KINGSTON SA400S37120G
>
> Без оперативки не обойтись: 2 модуля Kingston 8192 МБ (DDR3-1337) 99U5471
>
> Относительно неплохой GPU: NVIDIA GeForce GTX 1070
Понимаю, что моя машина устарела, но какого чёрта онлайн-режим загружается в шесть раз медленнее? Я не смог обнаружить никаких отличий при использовании техники загрузки «сначала сюжет, потом онлайн», [как это удалось сделать другим до меня](https://www.reddit.com/r/gtaonline/comments/kycy7a/gtao_loading_times_using_different_methods/). Но даже бы если это сработало, то результаты находились бы в рамках погрешности.
Я не одинок
-----------
Если поверить [этому опросу](https://www.reddit.com/r/gtaonline/comments/ht4i56/your_average_online_loading_time/), то проблема настолько распространена, что слегка подбешивает более 80% базы игроков. Ребята из R\*, вообще-то уже семь лет прошло!
*У 18,8% игроков мощнейшие компьютеры или консоли, у 81,2% всё довольно грустно, у 35,1% — совсем печально.*
Поискав 20% тех счастливчиков, загрузка у которых занимает меньше трёх минут, я нашёл [некоторое](https://www.youtube.com/watch?v=RdCqDdjp6iU) [количество](https://www.youtube.com/watch?v=pJzr3qfyCyg) [бенчмарков](https://www.youtube.com/watch?v=RK7BUFx_NGk) с мощными игровыми PC и временем загрузки онлайн-режима примерно две минуты. Чтобы получить время загрузки в две минуты я бы ~~убил~~ *хакнул* что угодно! Похоже, время загрузки зависит от «железа», но числа как-то не сходятся…
Как получилось, что людей, делавших эти бенчмарки, загрузка сюжетного режима всё равно занимает примерно минуту? (Кстати, в бенчмарке с M.2 не учтено время показа логотипов в начале.) Кроме того, загрузка из сюжетного в онлайн-режим занимает у них всего минуту, а у меня — больше пяти. Я знаю, что у них техника намного лучше моей, но точно не в пять раз.
Очень точные измерения
----------------------
Вооружённый такими мощными инструментами, как *Диспетчер задач*, я начал расследование, чтобы выяснить, какие ресурсы могут быть «узким местом».
*В течение одной минуты загружаются стандартные ресурсы сюжетного режима, после чего игра в течение четырёх с лишним минут грузит процессор.*
После минуты загрузки общих ресурсов, используемых и в сюжетном, и в онлайн-режимах (показатель, почти равный бенчмаркам мощных PC) GTA решает максимально нагружать одно ядро моей машины в течение четырёх минут и больше ничего не делать.
Обращение к диску? Его нет! Использование сети? Есть немного, но спустя всего несколько секунд трафик падает почти до нуля (кроме загрузки вращающихся баннеров с информацией). Использование GPU? По нулям. Использование памяти? Совершенно плоский график…
Что происходит, игра майнит крипту, или ещё чего? Начинает попахивать кодом. *Очень плохим кодом*.
Ограничение одним потоком
-------------------------
Хотя мой старый ЦП AMD имеет восемь ядер и всё ещё может себя показать, он был создан в старые времена. Тогда [однопоточная производительность](https://valid.x86.fr/bench/6u7sdy/1) процессоров AMD *намного* отставала от показателей процессоров Intel. Возможно, это и не объясняет всю разницу во времени загрузки, но должно объяснить самое главное.
Странно то, что игра использует *только* ЦП. Я ожидал огромного объёма загружаемых с диска ресурсов или кучу сетевых запросов для создания сессии в сети p2p. Но это? Скорее всего, это баг.
Профилирование
--------------
Профилировщики — отличный способ поиска «узких мест» в работе ЦП. Есть только одна проблема — большинство из них для получения идеальной картины происходящего в процессе использует исходный код. А у меня его нет. Но мне не нужны и показания с точностью до микросекунд — «узкое место» длится целых четыре минуты.
На сцене появляется сэмплирование стека: это единственный вариант изучения приложений с закрытыми исходниками. Выполняем дамп стека запущенного процесса и местоположения указателя текущей команды, чтобы строить дерево вызовов с заданными интервалами. Затем складываем их, чтобы получить статистику о происходящем. Есть только один известный мне профилировщик (здесь я могу ошибаться), способный на такое в Windows. И он не обновлялся больше десяти лет. Это [Luke Stackwalker](http://lukestackwalker.sourceforge.net/)! Пусть кто-нибудь подарит этому проекту свою любовь.
*Виновники №1 и №2.*
Обычно Luke группирует одинаковые функции, но поскольку у меня нет отладочных символов, мне нужно глазами просматривать ближайшие адреса, чтобы понять, что это одно и то же место. И что же мы видим? Не одно, а целых два «узких места»!
Вниз по кроличьей норе
----------------------
Позаимствовав *у друга* совершенно законную копию *популярного дизассемблера* (нет, я не могу себе его позволить… придётся как-нибудь изучить [ghidra](https://ghidra-sre.org/)), я приступил к разборке GTA.
Всё это кажется совсем неправильным. Многие высокобюджетные игры имеют встроенную защиту от реверс-инжиниринга, чтобы защититься от пиратов, читеров и моддеров (не сказать, чтобы это когда-то их останавливало).
Похоже, здесь используется некая обфускация/шифрование, из-за которого большинство команд заменено абракадаброй. Но не волнуйтесь, нам просто нужно сдампить память игры в момент выполнения части, которую мы хотим изучить. Перед своим выполнением команды тем или иным способом должны деобфусцироваться. У меня был под рукой [Process Dump](https://github.com/glmcdona/Process-Dump), но есть множество других инструментов, способных выполнять подобные функции.
Проблема №1: это… strlen?!
--------------------------
При дизассемблировании теперь уже менее обфусцированного дампа обнаруживается, что один из адресов имеет метку, взятую ниоткуда! Это `strlen`? Следующий вниз по стеку вызовов помечен как `vscan_fn`, после чего метки заканчиваются, однако я практически уверен, что это [`sscanf`](https://github.com/chakra-core/ChakraCore/blob/master/pal/src/safecrt/sscanf.c#L47).
Они что-то парсят. Но что? Разбор дизассемблированного кода занял бы бесконечность, поэтому я решил сдампить некоторые сэмплы из запущенного процесса при помощи [x64dbg](https://x64dbg.com/). Проведя пошаговую отладку, я выяснил, что это… JSON! Они парсят JSON. Целых **10 мегабайт** данных JSON с почти **63 тысячами элементов**.
```
...,
{
"key": "WP_WCT_TINT_21_t2_v9_n2",
"price": 45000,
"statName": "CHAR_KIT_FM_PURCHASE20",
"storageType": "BITFIELD",
"bitShift": 7,
"bitSize": 1,
"category": ["CATEGORY_WEAPON_MOD"]
},
...
```
Что это? Согласно некоторым источникам, это похоже на данные «каталога сетевого магазина». Предположу, что они содержат список всех возможных предметов и апгрейдов, которые можно купить в GTA Online.
**Уточнение: я считаю, что это предметы, покупаемые за внутриигровые деньги, а не связанные напрямую с [микротранзакциями](https://gta.fandom.com/wiki/Cash_Cards).**
Но 10 мегабайт — это ведь мелочь! А использование `sscanf` пусть и не оптимально, но не может же оно быть настолько плохим? Ну-у-у…
*10 мегабайт строк C в памяти. 1. Перемещаем указатель на несколько байт к следующему значению. 2. Вызываем `sscanf(p, "%d", ...)`. 3. Считываем каждый символ в 10 мегабайтах при считывании каждого мелкого значения (!?). 4. Возвращаем отсканированное значение.*
Да, это займёт много времени… Честно говоря, я понятия не имел, что большинство реализаций `sscanf` вызывает `strlen`, поэтому не могу винить написавшего это разработчика. Я бы предположил, что эти данные просто сканируются байт за байтом и обработка может остановиться на `NULL`.
Проблема №2: давайте используем хэш-… массив?
---------------------------------------------
Оказалось, что второй виновник вызывается непосредственно рядом с первым. Они оба даже вызываются в одном операторе `if`, как можно понять в этой уродливой декомпиляции:
*Обе проблемы находятся внутри одного большого цикла парсинга всех предметов. Проблема №1 — парсинг, проблема №2 — сохранение.*
Все метки указаны мной, я понятия не имею, как по-настоящему называются функции и параметры.
В чём же заключается вторая проблема? Сразу после парсинга предмета он сохраняется в массив (или во встроенный список C++? не совсем понятно). Каждый предмет выглядит примерно так:
```
struct {
uint64_t *hash;
item_t *item;
} entry;
```
Но что происходит перед сохранением? Код проверяет *весь* массив, один элемент за другим, сравнивая хэш предмета, чтобы понять, находится ли он в списке. Если мои вычисления верны, то при примерно 63 тысячах элементов это даёт `(n^2+n)/2 = (63000^2+63000)/2 = 1984531500` проверок. Большинство из них бесполезно. У нас есть уникальные *хэши*, так почему бы не использовать *hash map*?
*Профилировщик показывает, что процессор нагружают первые две строки. Оператор `if` выполняется только в самом конце. Предпоследняя строка вставляет предмет.*
В процессе обратной разработки я назвал эту структуру `hashmap`, однако очевидно, что это `not_a_hashmap`. И дальше всё становится только лучше. Этот хэш/массив/список перед загрузкой JSON пуст. И все предметы в JSON уникальны! Коду даже *не нужно* проверять, есть ли предмет в списке! Есть даже функция для непосредственной вставки предметов, достаточно просто использовать её! Серьёзно, чё за фигня!?
Proof of Concept
----------------
Всё это конечно здорово, но никто не воспримет меня всерьёз, пока я это не протестирую, чтобы можно было написать к посту кликбейтный заголовок.
Каким будет план? Написать `.dll`, инъецировать её GTA, [перехватить](https://github.com/TsudaKageyu/minhook) несколько функций, ???, ПРОФИТ!
Проблема с JSON запутанна, и замена парсера окажется чрезвычайно трудоёмкой задачей. Гораздо реалистичнее будет попытаться заменить `sscanf` на функцию, не зависящую от `strlen`. Но есть ещё более простой способ.
* перехватить strlen
* дождаться длинной строки
* «кэшировать» её начало и длину
* если она снова вызывается в пределах строки, возвращать кэшированное значение
Что-то типа такого:
```
size_t strlen_cacher(char* str)
{
static char* start;
static char* end;
size_t len;
const size_t cap = 20000;
// если у нас есть "кэшированная" строка и текущий указатель находится внутри неё
if (start && str >= start && str <= end) {
// вычисляем новую strlen
len = end - str;
// если мы близки к концу, выгружаемся
// не нужно вмешиваться во что-то посторонее
if (len < cap / 2)
MH_DisableHook((LPVOID)strlen_addr);
// супербыстрый возврат!
return len;
}
// подсчитываем истинную длину
// нам нужно хотя бы одно измерение для большого JSON
// или обычная strlen для других строк
len = builtin_strlen(str);
// если это была очень длинная строка
// сохраняем адреса её начала и конца
if (len > cap) {
start = str;
end = str + len;
}
// медленный скучный возврат
return len;
}
```
Что касается проблемы хэш-массива, то с ней всё проще — можно просто полностью пропускать дублирующиеся проверки и вставлять предметы напрямую, потому что мы знаем, что значения уникальны.
```
char __fastcall netcat_insert_dedupe_hooked(uint64_t catalog, uint64_t* key, uint64_t* item)
{
// я не стал заморачиваться реверс-инжинирингом этой структуры
uint64_t not_a_hashmap = catalog + 88;
// понятия не имею, что делает эта строка, но повторил то, что было в оригинальном коде
if (!(*(uint8_t(__fastcall**)(uint64_t*))(*item + 48))(item))
return 0;
// непосредственная вставка
netcat_insert_direct(not_a_hashmap, key, &item);
// удаляем перехватчики после добирания до хэша последнего предмета
// и выгружаем .dll, на этом всё :)
if (*key == 0x7FFFD6BE) {
MH_DisableHook((LPVOID)netcat_insert_dedupe_addr);
unload();
}
return 1;
}
```
Полные исходники proof of concept находятся [здесь](https://github.com/tostercx/GTAO_Booster_PoC).
Результаты
----------
Ну и как, сработало?
> Исходное время загрузки онлайн-режима: примерно 6 мин
>
> Время только с пропатченными дублируемыми проверками: 4 мин 30 с
>
> Время только с патчем парсера JSON: 2 мин 50 с
>
> Время с патчами обеих проблем: 1 мин 50 с
>
>
>
> (6\*60 — (1\*60+50)) / (6\*60) = время загрузки уменьшилось на 69.4% (отлично!)
О да, ещё как сработало!
Скорее всего, это не уменьшит время загрузки у всех игроков — на других системах могут быть другие «узкие места», но это настолько очевидная проблема, что я не понимаю, как R\* не замечала её все эти годы.
tl;dr
-----
* При запуске GTA Online есть узкое место ЦП из-за однопотокового выполнения
* Оказывается, в это время GTA сражается с парсингом 10-мегабайтного файла JSON
* Сам парсер JSON плохо написан/наивно реализован и
* После парсинга выполняется медленная процедура проверки отсутствия дубликатов предметов
R\*, пожалуйста, решите проблему
--------------------------------
Просьба, если эта статья каким-то образом доберётся до Rockstar: на решение этих проблем не уйдёт больше дня работы одного разработчика. Пожалуйста, сделайте с этим что-нибудь.
Можно перейти на hashmap для устранения дубликатов или полностью пропускать эту проверку, что будет реализовать быстрее. В парсере JSON замените библиотеку на более производительную. Не думаю, что здесь есть более простое решение.
Спасибо. | https://habr.com/ru/post/544764/ | null | ru | null |
# Бенчмарк как основание для принятия решения об изменении кода
Билл Кеннеди в одной из лекций своего замечательного курса [Ultimate Go programming](https://www.safaribooksonline.com/library/view/ultimate-go-programming/9780134757476/) сказал:
> Многие разработчики стремятся оптимизировать свой код. Они берут строчку и переписывают ее, говоря, что так станет быстрее. Нужно остановиться. Говорить, что тот или иной код быстрее, можно только после того, как он отпрофилирован и сделаны бенчмарки. Гадание не является правильным подходом к написанию кода.
Мне давно хотелось на практическом примере продемонстрировать, как это может работать. И на днях мое внимание привлек следующий код, который как раз можно было бы использовать в качестве такого примера:
```
builds := store.Instance.GetBuildsFromNumberToNumber(stageBuild.BuildNumber, lastBuild.BuildNumber)
tempList := model.BuildsList{}
for i := len(builds) - 1; i >= 0; i-- {
b := builds[i]
b.PatchURLs = b.ReversePatchURLs
b.ExtractedSize = b.RPatchExtractedSize
tempList = append(tempList, b)
}
```
Здесь во всех элементах слайса *builds*, возвращаемого из базы данных, *PatchURLs* заменяется на *ReversePatchURLs*, *ExtractedSize* — на *RPatchExtractedSize* и выполняется реверс — меняется порядок элементов так, чтобы последний элемент стал первым, а первый — последним.
На мой взгляд, исходный код немного сложен для восприятия и может быть оптимизирован. Этот код выполняет простой алгоритм, состоящий из двух логических частей: изменение элементов слайса и сортировка. Но чтобы программисту вычленить эти две составляющие, понадобится время.
Несмотря на то что обе части важны, в коде реверс не так акцентируется, как хотелось бы. Он разбросан по трем оторванным друг от друга строкам: инициализация нового слайса, итерация существующего слайса в обратном порядке, добавление элемента в конец нового слайса. Тем не менее нельзя игнорировать и несомненные преимущества данного кода: код рабочий и протестирован, и если говорить объективно, то он вполне адекватный. Субъективное восприятие кода отдельным разработчиком не может служить оправданием для его переписывания. К сожалению или к счастью, мы не переписываем код только потому, что он нам просто не нравится (или, как чаще бывает, просто потому, что он не наш, см. [Фатальный недостаток](http://lurkmore.to/%D0%A4%D0%B0%D1%82%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%B5%D0%B4%D0%BE%D1%81%D1%82%D0%B0%D1%82%D0%BE%D0%BA)).
Но что, если нам удастся не только улучшить восприятие кода, но и существенно ускорить его? Это же совсем другое дело. Можно предложить несколько альтернативных алгоритмов, выполняющих заложенную в коде функциональность.
Первый вариант: перебор всех элементов в цикле *range*; для реверса первоначального слайса в каждой итерации добавляем элемент в начало итогового массива. Так мы могли бы избавиться от громоздкого *for*, переменной *i*, использования функции *len*, трудно воспринимаемого перебора элементов с конца, а также сократить количество кода на две строки (с семи строк до пяти), а чем меньше кода, тем меньше вероятность допустить в нем ошибку.
```
var tempList []*store.Build
for _, build := range builds {
build.PatchUrls, build.ExtractedSize = build.ReversePatchUrls, build.RPatchExtractedSize
tempList = append([]*store.Build{build}, tempList...)
}
```
Убрав перебор слайса с конца, мы четко разграничили операции изменения элементов (3-я строка) и реверса исходного массива (4-я строка).
Основной замысел второго варианта состоит в еще большем разнесении изменения элементов и сортировки. Сперва перебираем элементы и меняем их, а потом сортируем слайс отдельной операцией. Данный метод потребует дополнительной реализации интерфейса сортировки для слайса, но повысит читабельность и позволит полностью отделить и изолировать реверс от изменения элементов, а метод *Reverse* однозначно укажет читателю на желаемый результат.
```
var tempList []*store.Build
for _, build := range builds {
build.PatchUrls, build.ExtractedSize = build.ReversePatchUrls, build.RPatchExtractedSize
}
sort.Sort(sort.Reverse(sort.IntSlice(keys)))
```
Третий вариант является практически повторением второго, но для сортировки используется *sort.Slice*, что увеличивает объем кода на одну строчку, но позволяет избежать дополнительной реализации интерфейса сортировки.
```
for _, build := range builds {
build.PatchUrls, build.ExtractedSize = build.ReversePatchUrls, build.RPatchExtractedSize
}
sort.Slice(builds, func(i int, j int) bool {
return builds[i].Id > builds[j].Id
})
```
На первый взгляд, по внутренней сложности, количеству итераций, применяемым функциям изначальный код и первый алгоритм близки; второй и третий варианты могут казаться сложнее, но однозначно сказать, какой из четырех вариантов будет оптимальным, все же нельзя.
Итак, мы запретили себе принимать решения, основываясь на предположениях, не подкрепленных доказательствами, но очевидно, что здесь наибольший интерес представляет то, как поведет себя функция append при добавлении элемента в конец и в начало слайса. Ведь на самом деле эта функция не так проста, как кажется.
*Append* работает [следующим образом](https://blog.golang.org/slices): она либо добавляет к существующему в памяти слайсу новый элемент, если его capacity больше итоговой длины, либо резервирует в памяти место под новый слайс, копируя в него данные из первого слайса, добавляя данные второго и возвращая в качестве результата уже новый слайс.
Самый интересный нюанс в работе этой функции состоит в алгоритме, используемом для резервирования памяти под новый массив. Так как самой дорогой операцией является выделение нового участка памяти, то, чтобы сделать операцию *append* дешевле, разработчики Go пошли на небольшую хитрость. Поначалу, чтобы не резервировать память заново при каждом добавлении элемента, объем памяти выделяется с некоторым запасом — в два раза больше первоначального, но после определенного количества элементов объем вновь резервируемого участка памяти становится больше не в два раза, а на 25 %.
С учетом нового понимания работы функции *append* ответ на вопрос: «Что будет быстрее: добавлять один элемент в конец существующего слайса или добавлять к слайсу из одного элемента существующий слайс?» — уже более прозрачен. Можно предположить, что во втором случае по сравнению с первым будет больше аллокаций памяти, что прямым образом отразится на скорости работы.
Так мы плавно подошли к бенчмаркам. С помощью бенчмарков можно оценить нагрузку алгоритма на самые критичные ресурсы, такие как время выполнения и оперативная память.
Давайте напишем бенчмарк для оценки всех четырех наших алгоритмов, заодно оценим, какой прирост может нам дать отказ от сортировки (чтобы понимать, какая часть всего времени тратится именно на сортировку). Код бенчмарка:
```
package services
import (
"testing"
"sort"
)
type Build struct {
Id int
ExtractedSize int64
PatchUrls string
ReversePatchUrls string
RPatchExtractedSize int64
}
type Builds []*Build
func (a Builds) Len() int { return len(a) }
func (a Builds) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a Builds) Less(i, j int) bool { return a[i].Id < a[j].Id }
func prepare() Builds {
var builds Builds
for i := 0; i < 100000; i++ {
builds = append(builds, &Build{Id: i})
}
return builds
}
func BenchmarkF1(b *testing.B) {
data := prepare()
builds := make(Builds, len(data))
b.ResetTimer()
for i := 0; i < b.N; i++ {
var tempList Builds
copy(builds, data)
for i := len(builds) - 1; i >= 0; i-- {
b := builds[i]
b.PatchUrls, b.ExtractedSize = b.ReversePatchUrls, b.RPatchExtractedSize
tempList = append(tempList, b)
}
}
}
func BenchmarkF2(b *testing.B) {
data := prepare()
builds := make(Builds, len(data))
b.ResetTimer()
for i := 0; i < b.N; i++ {
var tempList Builds
copy(builds, data)
for _, build := range builds {
build.PatchUrls, build.ExtractedSize = build.ReversePatchUrls, build.RPatchExtractedSize
tempList = append([]*Build{build}, tempList...)
}
}
}
func BenchmarkF3(b *testing.B) {
data := prepare()
builds := make(Builds, len(data))
b.ResetTimer()
for i := 0; i < b.N; i++ {
copy(builds, data)
for _, build := range builds {
build.PatchUrls, build.ExtractedSize = build.ReversePatchUrls, build.RPatchExtractedSize
}
sort.Sort(sort.Reverse(builds))
}
}
func BenchmarkF4(b *testing.B) {
data := prepare()
builds := make(Builds, len(data))
b.ResetTimer()
for i := 0; i < b.N; i++ {
copy(builds, data)
for _, build := range builds {
build.PatchUrls, build.ExtractedSize = build.ReversePatchUrls, build.RPatchExtractedSize
}
sort.Slice(builds, func(i int, j int) bool {
return builds[i].Id > builds[j].Id
})
}
}
func BenchmarkF5(b *testing.B) {
data := prepare()
builds := make(Builds, len(data))
b.ResetTimer()
for i := 0; i < b.N; i++ {
copy(builds, data)
for _, build := range builds {
build.PatchUrls, build.ExtractedSize = build.ReversePatchUrls, build.RPatchExtractedSize
}
}
}
```
Запустим бенчмарк командой *go test -bench=. -benchmem*.
Результаты вычислений для слайсов 10, 100, 1000, 10 000 и 100 000 элементов представлены на графике ниже, где F1 — изначальный алгоритм, F2 — добавление элемента в начало массива, F3 — использование *sort.Reverse* для сортировки, F4 — использование *sort.Slice*, F5 — отказ от сортировки.
*Время выполнения операции*
*Количество аллокаций памяти*
Как видно из графика, можно увеличивать массив, но конечный результат уже в принципе различим на слайсе из 10 элементов. **Ни один из предложенных альтернативных алгоритмов (F2, F3, F4) не смог превзойти по скорости работы изначальный алгоритм (F1).** Даже несмотря на то, что у всех, кроме F2, количество аллокаций памяти незначительно меньше, чем у изначального. Первый алгоритм (F2) с добавлением элемента в начало слайса оказался самым неэффективным: как и предполагалось, в нем слишком много аллокаций памяти, настолько, что использовать его в продуктовой разработке категорически нельзя. Алгоритм с применением встроенной функции сортировки реверсом (F3) существенно медленнее изначального. И только алгоритм с сортировкой *sort.Slice* сравним по скорости с изначальным алгоритмом, но при этом слегка уступает ему.
Также можно заметить, что отказ от сортировки (F5) дает существенное ускорение. Поэтому если очень хочется переписать код, то можно пойти в этом направлении, например, поднимая изначальный слайс *builds* из базы данных, использовать в запросе сортировку по id DESC вместо ASC. Но при этом мы вынуждены выйти за границы рассматриваемого участка кода, что влечет за собой риск привнести множественные изменения.
### Выводы
Пишите бенчмарки.
Нет большого смысла тратить свое время на рассуждения о том, будет ли тот или иной код быстрее. Информация из интернета, суждения коллег и других людей, какими бы авторитетными они ни были, могут служить вспомогательными доводами, но роль главного судьи, решающего, быть или нет новому алгоритму, должна оставаться за бенчмарками.
Go только на первый взгляд довольно простой язык. Всеобъемлющее правило 80⁄20 применимо и здесь. Эти 20 % представляют собой те тонкости внутреннего устройства языка, знание которых отличает новичка от опытного разработчика. Практика написания бенчмарков для разрешения своих вопросов — один из самых дешевых и эффективных способов получить как ответ, так и более глубокое понимание внутреннего устройства и принципов работы языка Go. | https://habr.com/ru/post/438446/ | null | ru | null |
# Подходы к созданию скриптового языка описания настольных игр
Так уж случилось, что игры я писал лишь для себя, и профессионально этим никогда не занимался.
А вот опыт писать DSL (Domain Specific language) для уменьшения рутины написания совершенно разного кода хоть какой-то есть.
Именно этим и хочется поделится: как упорядочить необъятное.
Наш хороший хабр-юзер [GlukKazan](http://habrahabr.ru/users/glukkazan/) пишет много статей о том какие есть замечательные продукты для создания различных досочных игр. Такие как **Zillions of Games** и **Axiom Development Kit**.
Однако эти программы не универсальны. И всегда хочется улучшить их. Но данные продукты не свободны, поэтому приходится писать программный продукт заново.
[GlukKazan](http://habrahabr.ru/users/glukkazan/) работает над открытым проектом **Dagaz**, о чём делится отличными статьями (например тут: [Dagaz: Новое начало](http://habrahabr.ru/post/242547/)).
Итак, предположим, мы хотим создать универсальный игровой движок для настольных игр, и его основой мы хотим видеть скриптовый язык, который помогает растолковать движку правила игры.
Каким мы хотим его видеть?
1) Язык должен быть универсальным, насколько можно, дабы описать почти любые правила игры.
2) Тем не менее, язык должен быть как можно проще, минимум конструкций.
3) Описание правил должны быть легки для чтения игроделу и для написания своих игр
4) Для большинства случаев игры можно писать, дополняя/изменяя уже написанные
5) Коммуникация (АПИ) со скриптом должна быть насколько простой, насколько это возможно. Так, что бы можно легко писать ботов и ИИ.
На первый взгляд кажется, что потраченные усилия вообще никому не нужны будут, поскольку рутину не уменьшить, проще писать игры сразу готовыми.
Но это не так.
Всё куда проще!
#### Демиурги и чёрная коробка
Что ж, представим, что мы демиурги, и способны, нет, уже написали этот скриптовый язык. Да, да, уже. Давайте проследим, что этот язык может, и что умеет делать.
#### Не ставьте ограничений там, где их нет
Например, проект **Dagaz** (да и его предшественники **Axiom** и **ZoG**) делает акцент на досочных играх. Однако даже человеку объяснить чем досочная игра отличается от недосочной — достаточно сложно. Что уж говорить, описать это в точных определениях на каком-то языке программирования ещё сложнее.
Поэтому первое и главное правило — не надо ставить ограничений там, где их нет!
Мы будем рассматривать не досочные игры, а настольные.
Давайте глянем на следующий список, которые мы хотим описать и играть при помощи нашего движка.
* Шахматы
* Сплют
* Каркассон
* Точки
* Пятнашки
* Домино
* Перекрашивание кристаллов
* Дурак
Они ну очень разные на первый взгляд. Что же их всех объединяет? Неужели хоть что-то?
Да. Объединяет их то, что
1. В один момент времени всегда ходит 1 игрок
2. Почти всегда игрок может думать бесконечно долго (отдельно рассмотрим, когда будут ограничения по времени на ход)
3. Каждый раз существует ограниченное количество возможных действий. Игра Точки является исключением (ибо точку можно ставить где угодно на бесконечной доске). Для удобства мы несколько урежем Точки, а не изменим движок
Всё, только эти ограничения на движок!
Итого, по сути мы хотим иметь движок, который должен уметь спрашивать 2 основных вопроса: кто сейчас ходит, какие возможные действия он может сделать.
```
IN: who
OUT: Player1
IN: actions
OUT: [SomeAction1, SomeAction2 Param21, ...]
```
И движок должен уметь совершать одно действие — совершить выбранное действие.
```
action SomeAction3
```
Ну, может ещё одно действие — выбрать предварительное действие (например, если закончится отведённое для хода время, а ход ещё не сделан, дабы не заканчивать игру или выбирать случайное действие, можно выбрать предварительное действие в таком случае).
```
preaction SomeAction5
```
Не надо ставить больше никаких ограничений, ведь их всё равно кому-то захочется обойти.
#### Думайте шире
А как же быть, если мы пишем Покер? Да и в Дурака можно подкинуть карту, а можно не подкинуть. Сказать Пас, или выбрать свою масть — это тоже действие. Выставить поле в Каркассоне — это тоже действие.
А тетрис куда? Вот тетрис, наверное, будет делать очень сложно, ибо это реал-таймовая игра, и вряд ли надо. Доработать движок можно легко, но не актуально.
#### Не кастрируйте скриптовый язык
Не рекомендую следовать принципу — я получу все данные из скрипта и буду моделировать в движке. Ибо таким образом, проще использовать **.ini** файл как конфигурацию, а не городить скриптовый язык, так как толку будет столько же.
А как взять карту для Дурака, когда отбился? Просто следующим будем снова ходить мы и будет лишь 1 вариант хода — взять карту. Если что можно добавить значения действия авто — то бишь не спрашивать у игрока какой вариант выбирать.
```
IN: who
OUT: Player3
# атакует 8й бубна (хотя лучше было бы двумя 10ками - бубовой и чирвой)
IN: actions
OUT: [Attack 8Diamonds, Attack 10Diamonds 10Hearts, ...]
IN: action Attack 8Diamonds
OUT: action Attack 8Diamonds
IN: who
OUT: Player4
# забрать со стола, перевести или отбиться? Перевёл
IN: actions
OUT: [TakeTable, PassShowOnly QueenDiamonds, Defend QueenDiamonds, Pass 6Diamonds, PassShowOnly 6Diamonds,...]
IN: action Pass 6Diamonds
OUT: action Pass 6Diamonds
IN: who
OUT: Player1
# предлагает отбить королём или тузом, забрать стол или перевести
IN: actions
OUT: [TakeTable, Defend KingDiamonds 6Diamonds, Defend KingDiamonds 8Diamonds, Defend AceDiamonds 6Diamonds, Defend AceDiamonds 8Diamonds, PassShowOnly KingDiamonds, Pass KingDiamonds, PassShowOnly AceDiamonds, Pass AceDiamonds]
IN: action Defend AceDiamonds 6Diamonds
OUT: action Defend AceDiamonds 6Diamonds
IN: who
OUT: Player3
# предлагает подкинуть 3му игроку
IN: actions
OUT: [Pass, Attack AceHearts]
IN: action Pass
OUT: action Pass
IN: who
OUT: Player2
# предлагает спасовать, даже автоматически, нечего подкидывать
IN: actions
OUT: [auto Pass]
IN: action Pass
OUT: action Pass
IN: who
OUT: Player4
# пасуем
IN: actions
OUT: [auto Pass]
IN: action Pass
OUT: action Pass
IN: who
OUT: Player1
# предлагает отбить королём или забрать всё
IN: actions
OUT: [Defend KingDiamonds, TakeTable]
IN: action Defend KingDiamonds
OUT: action Defend KingDiamonds
IN: who
OUT: Player3
#берёт из колоды 1 карту, кто ходил и не хватает
IN: actions
OUT: [auto Take AceHearts]
IN: action Take AceHearts
OUT: action Take AceHearts
IN: who
OUT: Player1
#берёт из колоды 2 карты кто отбивался
IN: actions
OUT: [auto Take 6Hearts 10Clubs]
IN: action Take 6Hearts 10Clubs
OUT: action Take 6Hearts 10Clubs
```
Пусть движок ничего не знает об игре. Он всего лишь конвейер для запросов и красивого отображения. Не более, но и не менее.
#### Куда же без настроек
Насколько бы простым не была коммуникация со скриптом, без настроек обойтись никак не удастся.
В Дурака можно играть вдвоём, втроём, вчетвером, впятером и даже вшестером. Можно играть каждый сам за себя, 2х2, 3х3.
Нам необходимо посылать настройки. Добавляем ещё одну команду. Ок, две, надо же и проверить состояние
```
set players = 4
set groups = 2x2
set startFrom = Player3
IN: get name
OUT: name = 15-puzzle
```
#### Игра прежде всего
Необходимо помнить, что мы создаём игры. А любые игры объединяет то, что
* Игра может быть не начата
* Игра может идти
* Игра может быть завершена и иметь итоговый результат
Создадим ещё несколько команд, которые отражают новые способности — загрузить игру, начать игру, узнать результат игры
```
IN: load /path/chess.game
OUT: load /path/chess.game
IN: start
OUT: start
IN: result
OUT: Finished ; Win Player1; Details Player1 78, Player2 38
OUT: Loaded /path/chess.game
OUT: Started
```
#### Отделить мух от котлет. Язык визуализации
Не стоит гнаться за излишней универсальностью.
Будем помнить, что ботам визуализация по барабану, а вот человек очень придирчив, и хочет видеть очень красивую картинку.
Главный вывод из этого — языки визуализации и языки обмена сообщениями в общем случае различны. Гнаться за универсальностью скриптового языка не стоит, задачи ведь разные.
Язык сообщений визуализации не надо подгонять под язык обмена.
Пусть вы создали, что на каждый необходимый для визуализации объект есть формат визуализации (далее ФВ), который описывает какую картинку (или какие картинки) следует отобразить, в какой части экрана, что с чем наложится.
Нам вначале необходимо отобразить всё. Значит, необходима команда визуализация ситуации, которая выдаёт список объектов в формате ФВ.
Ведь мы должны увидеть шахматную доску с фигурами, или что нам раздали для Дурака.
```
IN: view
OUT: [ (Piece1, ФВ), (King, ФВ), ..... ]
```
Кстати, визуализировать зачастую надо то, что не фигурирует в качестве фигур в самой игре — например для Дурака надо отобразить количество закрытых карт у соперников, а так же колоду.
Кроме того, необходимо знать как визуализировать возможные ходы.
То есть должна быть команда визуализировать действия, который содержит список всех возможных действий, и к каждому из них в одном из двух вариантов новое описание: полное или частичное (с добавлением необходимых фигур отображения, и убирания фигур из имеющихся).
Например, в Дурака необходимо убрать из колоды выбранную карту, зато эта карта должна появиться на столе.
```
IN: view actions
OUT: [(Attack 8Diamonds, Diff [remove Card5, add (Card5, ФВ), ... ]), ... ]
```
А в шахматах выбранная фигура должна стать «выбранного» цвета, и на месте выбранной клетки появится эта же фигура. В случае атаки, к тому же, должна исчезнуть битая фигура.
Кроме того, необходимо знать, когда надо отображать то или иное возможное действие.
Собственно, либо в предыдущую команду засунуть, либо новую команду добавить.
```
IN: view actions
OUT: [(Attack 8Diamonds, Diff [remove Card5, add (Card5, ФВ), ... ], OnChoose Card5),
(Pass, Diff [add PassWord], OnChoose PassLabel),
... ]
```
##### Язык искусственного интеллекта
Модули ИИ желательно писать отдельно, но интегрировать в общий скрипт.
Разговор ИИ в принципе будет не сильно сложный.
```
IN: analize
OUT: [75 Pass, 44 Attack 6Diamonds, 59 Attack 8Diamonds]
IN: analize quick
OUT: [10 Pass, 5 Attack 6Diamonds, 20 Attack 8Diamonds]
```
Реализовать подобное куда сложнее, чем описать. Вполне возможно понадобятся форки.
#### Обоюдное понимание
Необходимо, чтобы движок понимал бы, совершает ли он ошибки в разговоре со скриптом, или нет. Связь должна быть обоюдной, особенно когда взаимодействие представляет клиент-серверное приложение.
По сути необходимо одна команда: последняя принятая команда.
```
IN: it
OUT: result
```
Этой же командой следует отвечать и тогда, когда ответ не важен. То есть установках, принятых действиях.
А то кто-то поставил лимит времени на обдумывание, игрок проспит это время, походит, а движок уже походил случайно за игрока.
Не забываем, что и движок может ответить ошибкой.
```
IN: action TakeTable
OUT: ERROR action is out list
IN: who
OUT: ERROR game result is Finished
```
#### Не боги горшки обжигают
Что же, мы достаточно много проследили за тем, что должен уметь наш скрипт, а на что нам наплевать.
Вся, не, ВСЯ логика ложится на скрипт. Так и только так мы добьёмся полной универсальности любых настольных игр.
Любой компромисс тут ведёт к ограничениям, из-за которых не раз и не два придётся плясать с бубнами.
Но мы же хотели лёгкий, простой язык! А нам предлагают всё-всё положить на игроделов.
Если нельзя, но очень хочется, то можно! Сложно должно быть программисту, а не игроделу. И так будет.
#### Будьте игроделами
Будьте немного игроделом сами!
Одно из самых удивительных свойств Си, который меня до сих пор поражает, это то, что тип string — библиотечная функция.
Не надо ждать, пока игроделы придумают что такое доска, поле или колода карт. Напишите на скриптовом языке сами эти понятия.
Обычные люди просто напишут, возмём доску, и создадим тут такие поля.
Именно поэтому и необходимо, чтобы все написанные скрипты можно было поверх изменять.
Захотелось для игры не статическую доску, а динамическую, пожалуйста, изменяем доску так, что её состояние будет проверятся каждый раз на ход.
```
# DynamicBoard
import StaticBord
let board {
constuctor {let board = prevous board}
on_player_change {let board = recalculate}
}
```
#### Кесарю кесарево, а Богу Богово
Даже не смотря на кучу написанных библиотек самим программистом, скриптовый код станет облегчённым, но не лёгким.
Как убрать ненужные куски кода?
Необходимо понять, что нам нужен подъязык, DSL этого скриптового языка, написанном на самом языке.
Звучит страшно, однако не всё есть чёрт, что малюют.
Для меня одной из самых красивых библиотек является парсер Parsec для Хаскеля. Это куда красивее реализации строк в Си.
Строки хоть планировали включать в язык, а вот парсер писать не планировали, когда составляли Хаскель.
По сути, там создали лишь средствами языка 2 уровня подъязыка для составления парсера (на самом деле там ещё есть не менее 4 дополнительных уровней).
1) Уровень токенов/символов. На этот малопонятный большинству уровень почти никто не лезет писать свои функции, библиотечных функций хватает с головой.
Например,
конец ли строки — **eof**
взять 1 токен/символ — **anyToken**
Попробовать парсер, если упадёт, сделать вид, что он не потреблял токены — **try p**
Или: попробовать парсер, если он упадёт без потребления токенов, применить второй парсер — **p1 <|> p2**
Посмотреть вперёд: попробовать парсер, сделать вид, что он не употребил токенов, если парсер удачный — **lookAhead p**
(в реальности там намного больше функций).
Комбинацией этих токенистических функций позволяет порождать очень сложные парсеры.
2) Уровень парсеров. Итак интуитивно понятный, дополненный целым зоопарком функций: такими как
много парсеров — **many p**
много, хотя бы 1 парсер — **many1 p**
парсер разделённый — **p `sepBy` sepp**
строчка — **string**
между парсерами — **between p1 p2**
…
Собственно, когда приходит юзер библиотеки, то видит, что «всё построено до нас», есть уже готовый конструктор, просто бери и собирай то, что тебе нужно **и на том уровне, который тебя интересует**.
То же самое касается и нашего языка. Не должен игродел думать как писать функцию фильтра, она должна быть там уже написана.
Просто бери и пользуйся, так должен говорить скриптовый язык своим юзерам!
Если хочу шашки, но чтобы в ячейку помещалось 1 или 2 шашки — надо мне пересоздать лишь описание ячейки.
Хочу квадратную доску — загружаю себе квадратную, хочу шестиугольную — загружу 6-угольную.
Надо мне, чтобы в зависимости от снятия пешек с доски уничтожались поля самой доски — делаем доску динамической и следим за уничтожением пешек.
#### Суп быстрого приготовления или нет предела совершенству
Мы все любим вкусно поесть, но вот вкусно готовить могут не все. Это требует умений и времени.
Игроделы такие любители супов.
Им надо ещё облегчить долю.
Необходим в нашем скиптовом языке ещё… мета-язык. Выдохните, просто шаблоны игр.
Шахмато-подобные-игры, Шашки-подобные-игры, дурак-подобные-игры, карточные-игры,…
Дайте возможность просто сконфигурировать готовые решения, а не заниматься программированием.
```
import ChessLikeGame;
let params = {
previous params;
players = 4;
board_length = 75
symmetric start positions = true;
start_white_positions = [A1, C1,D1, ....]
}
```
#### Заключение
Что же, если посмотреть на наши хотелки вначале статьи, то можно ужаснуться, мы хотели иметь и супер-универсальный скриптовый язык, и одновременно быть по-сути конфигурированием готовых решений, легко менять логику написанных игр.
На самом деле мы поняли чего хотим, чего не хотим, поняли, что основную часть написанного кода надо писать на скриптовом языке, а движку оставить визуализацию и реакцию.
Нет никакой разницы между шахматами, Балдой и дураком.
Кто ходит? Игрок 1
```
IN: who
OUT: Player1
```
Нет разницы между точками и пятнашками кристалл-перекрашиванием. Есть ограниченный выбор действий каждый раз.
```
# chess
action Castle King Rook2
# checkers
action Attack Men7 D2 F4
# splut
action Pull Troll E5 D5
# points
action Add 10-14
# carcassonn
action Put Title1Tree Place8-17
#15-puzzle
action Push 8
# dominos
action Put Title1-6 Place4-1 Left
# crystall painting
action Color Yellow
# durak
action New QuenHearts
```
Это просто надо понять, и тогда станет ясно, как это объяснить компьютеру. | https://habr.com/ru/post/247405/ | null | ru | null |
# Безопасно ускоряем Erlang приложение c помощью NIF на Rust
В статье освещен вопрос интеграции Erlang и Rust на примере реализации вероятностной структуры данных Бёртона Блума, позволяющей проверить принадлежность элемента множеству с необходимой точностью.
Выбор языка
-----------
Тесты производительности, основанные на вычислительных задачах, ясно дают понять, в какой лиге играет Erlang.
Поскольку Erlang не обладает сверхбыстрой арифметикой, решать сложные вычислительные задачи на нем видится странным. Однако он прекрасно подходит для вопросов, возникающих при разработке и эксплуатации систем массового обслуживания. Erlang, обладая отличным планировщиком и сборщиком мусора, вкупе с быстрой сетью и обработкой бинарных данных, прекрасно справляется с высококонкуретной распределенной средой. Таким образом, лично для себя я отвел Erlang роль системного клея в архитектуре распределенных серверных приложений.
В реальных системах возникают локальные вычислительные задачи, которые тормозят систему и ухудшают общий UX. Часто бывает так, что тормозит 1% кода, и негативно влияет на остальные 99% системы. Для решения данной проблемы в Erlang, начиная с версии R13B03, существует механизм Native Implemented Functions (NIFs).
В списке мифов про Erlang в пункте 2.7 разработчики предупреждают, что использование интерфейса NIF должно быть последней мерой, так как использование NIF опасно из-за возможных падений VM, вызванных дефектами реализации вашего NIF, и не всегда гарантирует увеличение скорости.
Официальные примеры реализации NIF доступны для C. Код на С и C++ довольно легко сделать небезопасным, например, выйдя за границы памяти структуры или массива, или же пропустив операцию освобождения выделенных ресурсов. На мой взгляд, проблема усугубляется фактором переключения контекста: когда программист, в основном разрабатывающий код на Erlang, переключается на низкоуровневый C, вероятность описанных выше проблем возрастает, особенно в рамках горящих сроков.
Таким образом, хотелось бы получить решение такое же быстрое, как на С/C++, но безопасное и легко поддерживаемое. Давайте посмотрим на самые производительные в вычислительном плане языки.
С точки зрения требований к языку стоит отметить:
1. Безопасность. Решение не должно ни при каких условиях ломать Erlang VM
2. Производительность. Быть сравнимым по производительности с С++
3. Возможность использования в режиме NIF
4. Скорость разработки. Необходима хорошая стандартная библиотека и большой набор сторонних библиотек, обеспечивающий удобную экосистему языка.
Из когорты производительных языков наиболее подходящим видится Rust. Он предлагает хорошую производительность и безопасную модель разработки, а также активное сообщество. Дополнительным плюсом Rust является иммутабельность данных и прозрачная модель многопоточности.
Следует заметить, что существует другой вариант оптимизации. Если мы можем пренебречь временем и накладными расходами дополнительного вызова через EPMD, то можно выбрать путь написания Erlang Node, вместо NIF. Для решения этой задачи подходит Java, Go, Rust, Ocaml (из личного опыта). Erlang Node может быть запущена на той же машине или вообще на другом конце земли.
Имплементация
-------------
### Обзор существующих решений на Rust
После быстрого поиска находится сразу несколько библиотек для написания NIF на rust. Рассмотрим их:
1. [rustler](https://github.com/hansihe/rustler). Пожалуй, самая популярная и функциональная библиотека, однако авторы сконцентрировали свои усилия на поддержке Elixir. В <https://github.com/hansihe/rustler/issues/127> предлагают тащить mix в erlang проект. Документации по использованию в Erlang нет.
2. [erlang-rust-nif](https://github.com/erszcz/erlang-rust-nif). Представляет из себя низкоуровневую реализацию NIF и подход к сборке расширения. Код выглядит простой трансляцией с C. Сборка имеет граничные условия и не универсальна.
3. [erlang\_nif-sys](https://github.com/goertzenator/erlang_nif-sys). Низкоуровневая и полнофункциональная связка. Является основой для Rustler. Требует усилий и времени для написания NIF.
4. [bitwise\_rust](https://github.com/tatsuya6502/bitwise_rust). Демонстрирует работу с планировщиком. Также является оберткой без синтаксического сахара над С api.
Поскольку одним из пунктов требований является скорость разработки, наиболее привлекательно выглядит Rustler. Однако вносить в проект дополнительную зависимость в виде Elixir и сборщика mix не хочется.
### Rustler
Отвечая на вопрос “зачем вообще тащить в erlang проект elixir?” и следуя принципу KISS, решено использовать rustler, но без дополнительных зависимостей. В качестве билд системы используется rebar3. Самым простым и быстрым шагом является определение pre\_hooks для компиляции нашего rust кода.
Для этого допишем в тестовом профиле hook:
```
{pre_hooks, [
{"(linux|darwin|solaris|freebsd)", compile, "sh -c \"cd crates/bloom && cargo build && cp target/debug/libbloom.so ../../priv/\""}
]}
```
В боевом окружении добавим опцию `--release`, таким образом в боевой профиль добавляем:
```
{pre_hooks, [
{"(linux|darwin|solaris|freebsd)", compile, "sh -c \"cd crates/bloom && cargo build --release && cp target/release/libbloom.so ../../priv/\""}
]}
```
После этих манипуляций появляется динамическая библиотека `priv/libbloom.so`, полностью готовая к загрузке в Erlang VM.
Подробности и пример использования rustler в erlang проекте можно найти в репозитории проекта <https://github.com/Vonmo/erbloom>
### Фильтр Блума
Поскольку экосистема rust предоставляет уже готовые реализации фильтра блума, выбираем подходящую и добавляем в `cargo.toml`. В данном проекте используется `bloomfilter = "0.0.12"`
Расширение реализует следующие функции:
1. `new(bitmap_size, items_count)` – инициализация фильтра. `bitmap_size` и `items_count` – расчетные значения, существует масса готовых калькуляторов.
2. `serialize()` – упаковка фильтра, например, для последующего сохранения на диск или передачи по сети.
3. `deserialize()` – восстановление фильтра из сохраненного состояния.
4. `set(key)` – добавляет элемент в множество.
5. `check(key)` – проверяет принадлежность элемента множеству.
6. `clear()` – очищает фильтр.
### Erlang
Следует отметить, что загрузка расширения в Erlang – это абсолютный прозрачный процесс. После загрузки вашего модуля, происходит вызов on\_load, в котором необходимо реализовать загрузку nif через erlang:load\_nif/2. При этом обработка вызовов будет прозрачно происходить уже в Rust.
Правилом хорошего тона является генерация ошибки erlang:nif\_error/1 в случае если NIF не загружен.
Подробное описание окружения для сборки проекта можно найти в [данной статье](https://habrahabr.ru/post/346254/).
Итоги
-----
В результате проделанной работы мы получили производительное и безопасное расширение. В наших проектах данное расширение позволяет сократить объем обращений к хранилищу данных в некоторых случаях до 10 раз и обслуживать поток обращений более 500к RPS на машину.
Исходный код расширения доступен [на github](https://github.com/Vonmo/erbloom). | https://habr.com/ru/post/349398/ | null | ru | null |
# Как быстрее всего сфоткать 35 билбордов в Москве
Идеи, чем заняться на выходных, ITшники черпают из сотни разных источников. Я, к примеру, недавно увидел конкурс Открытого чемпионата школ по Экономике, заключающегося в том, чтобы **сфотографировать максимальное число билбордов Чемпионата**. Адреса организаторы любезно предоставили. И несмотря на то, что приз взрослому там не светит (это школьный конкурс), тем не менее крайне интересно было бы узнать, за какое минимальное время можно решить такую задачу.
Итак, что мы имеем?
-------------------
3 часа на выходных, 35 адресов билбордов [в виде достаточно спорно вбитых адресов](https://vk.com/doc37216554_443517692?) (почему-то реестр УНОМ достаточно плохо бьётся с привычными картами), 1 Jupyter с готовым к работе вторым (*извините*) питоном и множество API различных сервисов.
Для начала удобно было бы представить масштаб бедствия на карте. Можно было бы воспользоваться чем-то автоматическим, но 35 адресов быстрее вручную перебить в Конструктор Яндекс.Карт, он сам приведет их к координате. В итоге получилась [картинка из ката](https://yandex.ru/maps/-/C6E~jH8E), из которой стало понятно, что
* Три точки расположены в Зеленограде и Химках, они явно увеличат время в пути
* Мало билбордов в центре города
* Точки расположены достаточно хаотично, и вручную построить хороший маршрут, их соединяющий, едва ли получится
Собственно всего вариантов продолжить такой маршрут , что примерно сопоставимо с [числом уникальных шахматных позиций](https://en.wikipedia.org/wiki/Shannon_number) на доске. Так что надо немного разобраться в достижениях народного хозяйства в области [P — NP задач](https://en.wikipedia.org/wiki/P_versus_NP_problem).
Сбор матрицы времени между точками
----------------------------------
Становится ясно, что наша задача является примером классической [задачи коммивояжёра](https://en.wikipedia.org/wiki/Travelling_salesman_problem) (TSP). Для того, чтобы её решить (приближенно), нам нужно построить матрицу расстояний (в нашем случае времен) между каждой точкой. Для решения такой задачи воспользуемся Google Maps API, а именно безумно простой и понятной библиотечкой **googlemaps**. Работа с этой библиотечкой проста и элегантна, получить время между двумя точками на карте можно настолько просто:
```
import googlemaps
import datetime
gmaps = googlemaps.Client(key='AIxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
resp = gmaps.directions(
origin='55.71802 37.573753',
destination='55.73481 37.66521',
mode='driving', # Либо 'transit' для общественного транспорта
region='ru',
language='en',
departure_time=datetime.datetime.now(),
)
distance_time = resp[0]['legs'][0]['duration_in_traffic']['value'] # Для авто
print resp[0]['legs'][0]['duration_in_traffic']
# Out[]: {u'text': u'49 mins', u'value': 2917}
```
Итак, осталось заполнить матрицу 36×36 всех расстояний. Заметьте, что добраться от точки A->B занимает НЕ столько же времени, сколько из B->A, поэтому сократить работу в два раза не получится (хотя диагональ конечно же заполнена нулями). Можно было бы просто пройтись по заранее созданной пустой матрице и заполнить её, однако мне больше нравится подход, когда я сначала храню все элементы матрицы в виде списка `[[x,y,value]]`, а потом делаю `.pivot`, «разворачивая» матрицу.
```
distances = []
for origin,destination in permutations(points['lat lng'], 2):
resp = gmaps.directions(
origin=origin,
destination=destination,
mode='driving',
region='ru',
language='en',
departure_time=now,
)
distance_time = resp[0]['legs'][0]['duration_in_traffic']['value'] # Для авто
distances.append(
[origin,destination,distance_time]
)
distances = pd.DataFrame(distances, columns='origin,destination,distance_time'.split(','))
distances_matrix = distances.pivot_table(
index='origin', columns='destination',
values='distance_time'
).fillna(0)
```
Тут можно сразу отметить, что я большой фанат Pandas Dataframes, и с ними жизнь становится лучше. Если не слышали, обязательно почитайте, вам понравится. Ну и, конечно, как хорошо писать на Питоне, в котором уже есть готова чудесная функция `itertools.permutations`, возвращающая все пары (тройки, четверки, что нужно) элементов заданного списка. Нет костылям!
Итоговая матрица получилась примерно такой:
Кстати, тут ещё сразу можно изучить, а насколько вообще близки друг к другу наши точки? Иными словами, посмотреть на распределение времени в пути между всеми точками:
Хотя в целом всё довольно ожидаемо. Много точек очень близко, распределение достаточно «нормальное», всё из-за того, что на машине ты можешь двигаться в любую сторону. Забегая немного вперед, вот то же распределение, только для общественного транспорта:
Совсем другая картинка: распределение намного более «вытянуто» вправо, то есть есть относительно мало точек, между которыми может быстро (быстрее 40 минут) переместиться на общественном транспорте. Ну и естественно, что время на транспорте в целом больше (более или менее в два раза).
TSP
---
Итак, теперь по матрице необходимо построить оптимальный маршрут. Надо сказать, что эта задача уже достаточно хорошо изучена, к примеру, есть очень хорошая гугловая библиотека [ortools](//developers.google.com/optimization/), позволяющая перебирать маршруты на тысячах и десятках тысяч точек.
Однако в нашем случае всего десятка точек необходимости в сложных алгоритмах нет. Можно воспользоваться жадным алгоритмом двойного прохода, и получить результат почти не отличающийся от «канонического».
Итак, алгоритм будет таким:
1. Инициируем начальную и финальные точки.
2. Берем две точки с наименьшими расстояниями от инициированных, добавляем их в маршрут.
3. Посторяем до тех пор, пока не наберем полный маршрут.
Здесь очевидно, что алгоритм очень зависим от выбранных начальных точек (и в целом от порядка точек), поэтому есть довольно простой способ избежать локальных оптимумов: несколько раз «перемешать» точки и посторить работу жадного алгоритма.
Программное реализацию этого алгоритма я позаимствовал из библиотеки [библиотеку](https://github.com/dmishin/tsp-solver) Дмитрия Шинякова.
Библиотека на вход принимает `numpy` квадратную матрицу, на выход выдаёт `path`: массив индексов точек в порядке по маршруту. Интересно, что Google Maps не позволяют строить маршруты с более чем 23 промежуточными точками, поэтому «на одной карте» построить маршрут не удастся. Я пошел на хитрость, и с помощью той же `googlemaps` просто разбил маршрут на два и построил его.
```
coords_path = distances_matrix.index[path] # Получаем точки в правильном порядке
# Latitude-longitude pairs
start = map(float, coords_path[0].split(' '))
waypoints = map(lambda p: map(float, p.split()), coords_path[1:24]) # первые 24 точки
end = map(float, coords_path[24].split())
m = gmaps.Map(height='650px')
ochDirections = gmaps.directions_layer(start, end, waypoints=waypoints)
m.add_layer(ochDirections)
start = map(float, coords_path[24].split(' '))
waypoints = map(lambda p: map(float, p.split()), coords_path[25:-1])
end = map(float, coords_path[-1].split())
ochDirections = gmaps.directions_layer(start, end, waypoints=waypoints)
m.add_layer(ochDirections)
m
```
То же самое можно сделать с помощью Яндекс.Карт, уже без разбивания на два куска.
```
base_yandex = 'https://yandex.ru/maps/213/moscow/?ll=37.519600%2C55.819741&z=10&mode=routes&rtext={rtext}&rtt=mt&rtm=atm'
rtext = '~'.join(i.replace(' ', '%2C') for i in coords_path)
print base_yandex.format(rtext=rtext)
```
Весь код я выложил [к себе на гитхаб](https://github.com/apetrin/och_billboards/blob/master/emsch_och_billboards-export.ipynb) в виде jupyter notebook'а, чтобы можно было быстро попробовать сделать что-то аналогичное.
Получившийся результат
----------------------
Итак, в итоге алгоритм выдал оценку времени в 8 часов (без пробок 6 часов). В этот момент захотелось выйти из зоны комфорта милого онлайна, и реально проехаться и сфотографировать все билборды. Дело за малым: нашлась компания, и мы поехали строго в соответствии с построенным маршрутом.
Финальный путь занял всего 10 часов. С учетом остановок и поиска многих билбордов мне кажется, что «лишние» 25% времени полностью оправданы. Нам удалось проехать все указанные в списке точки, однако нашли лишь 23 из 35 билбордов. При этом интересно, что щитов формата 6x3 мы нашли 19 из 24, а ситибордов всего 4 из 11. Скорее всего это связано с тем, что ситиформаты в целом рекламодателям более привлекательны (потому что они расположены ближе к центру), и поэтому их быстрее снимают. Не исключаю и банальную версию, что билборды в принципе не вешались.
В итоге, как мне кажется, получилась достаточно интересная смесь из простого алгоритма, упрощающего рутину и дающего намного более хороший результат, чем человек, и реального применения его на дорогах Москвы. Детский конкурс Открытого Чемпионата школ по экономике мы не выиграли, но нашли, кажется, на порядок больше билбордов, чем самый активный участник. | https://habr.com/ru/post/324864/ | null | ru | null |
# Экстремальное кодирование аудио
Вы никогда не задумывались, как поведут себя существующие форматы сжатия с потерями в совершенно ненормальных условиях? Обычно они удачно маскируют удаляемую информацию, и ухо неискушенного пользователя не слышит разницы. А может быть это недостаток акустики сегодня, и после её обновления завтра всё всплывёт наружу?
В интернете можно найти массу информации о слепых тестированиях различных форматов и сравнении спектрограмм. Уже давно сделана масса выводов о том, какое качество предпочтительней. Но основная рекомендация остается одна — опираться на свои уши. И тут может оказаться, что кому-то и MP3 128kbps сойдет за CD-качество — скорее всего, купить неплохую акустику еще предстоит, а может и медведь на ухо наступил. Как быть?
Предлагаю провести совершенно ненормальный, но тем не менее наглядный эксперимент. Чтобы услышать разницу, мы будем кодировать звук не один, а 5, 10 или 50 раз!
При каждом повторном кодировании кодировщик будет удалять всё новую и новую информацию, которую на его взгляд человеческое ухо не услышит. Наша задача — выявить минимальный битрейт популярных форматов сжатия с потерями (MP3 и Ogg Vorbis), который и при 100 итерациях перекодирования сохранит звук практически неотличимым от оригинала.
#### Подготовка
Для кодирования MP3 будем использовать последнюю стабильную версию [LAME (3.98.4)](http://www.rarewares.org/mp3-lame-bundle.php). Чтобы автоматизировать процесс повторного кодирования сделаем небольшой bat файл. Схема работы проста: кодируем wav файл в mp3, затем декодируем обратно в wav, затем кодируем уже полученный wav и т.д.
> `@copy /Y %1 ~temp.wav
>
> @for /L %%i in (1,1,%3) do @(
>
> @echo -------------------------------------------------------------------------------
>
> @echo -- Iteration %%i
>
> @echo -------------------------------------------------------------------------------
>
> lame %4 ~temp.wav ~temp.mp3
>
> lame --decode ~temp.mp3 ~temp.wav
>
> )
>
> @copy /Y ~temp.mp3 %2
>
> @del ~temp.wav
>
> @del ~temp.mp3`
Назовем его mp3\_xcode.bat. Формат запуска выглядит так:
> `mp3\_xcode ""`
Для Ogg Vorbis воспользуемся [OggEnc aoTuV b5.7](http://www.rarewares.org/ogg-oggenc.php). Сделаем bat файл для этого формата.
> `@copy /Y %1 ~temp.wav
>
> @for /L %%i in (1,1,%3) do @(
>
> @echo -------------------------------------------------------------------------------
>
> @echo -- Iteration %%i
>
> @echo -------------------------------------------------------------------------------
>
> oggenc %4 -o ~temp.ogg ~temp.wav
>
> oggdec -w ~temp.wav ~temp.ogg
>
> )
>
> @copy /Y ~temp.ogg %2
>
> @del ~temp.wav
>
> @del ~temp.ogg`
Назовем его ogg\_xcode.bat. Формат запуска выглядит так:
> `ogg\_xcode ""`
Если вы захотите самостоятельно поэкспериментировать, вам пригодится архив [sndexp.7z](http://veg.slutsk.net/habr/sndexp.7z) (1,3Мб), в который включены все необходимые файлы.
#### На старт, внимание, марш!
Ниже вы увидите множество ссылок на аудио-файлы. Рекомендую воспользоваться плеером, который может воспроизводить файлы напрямую по http ссылке (например, [foobar2000](http://foobar2000.com/)).
В качестве исходной композиции во всех случаях использовался насыщенный отрывок из композиции «O Fortuna» в исполнении Therion. Скачать его можно здесь: [fortuna.flac](http://veg.slutsk.net/habr/sndexp/fortuna.flac) (2,8Мб) или [fortuna.ogg](http://veg.slutsk.net/habr/sndexp/fortuna.ogg) (466Кб).
Итак, приступим.
##### Первый рубеж: ~128kbps
Будем кодировать в VBR, поэтому подберем параметры, выдающие в среднем 128kbps.
> `mp3\_xcode fortuna.wav fortuna_128x10.mp3 10 "-V 6"
>
> ogg\_xcode fortuna.wav fortuna_128x10.ogg 10 "-q4"`
Получаем файлы:
| | | |
| --- | --- | --- |
| x10 | [fortuna\_128x10.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_128x10.mp3) (340Кб) | [fortuna\_128x10.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_128x10.ogg) (360Кб) |
| x50 | [fortuna\_128x50.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_128x50.mp3) (326Кб) | [fortuna\_128x50.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_128x50.ogg) (367Кб) |
На этих примерах отчетливо видно, что у MP3 и Ogg Vorbis совершенно разный подход к кодированию. После каждого повторного кодирования звук в MP3 становится все больше похож на белый шум. У Ogg Vorbis эффект совсем другой — звук становится более глухим.
Во всех случаях мы получили отвратительный результат.
##### Поднимаем планку: ~192kbps
Подберем параметры, которые дают приблизительно 192kbps.
> `mp3\_xcode fortuna.wav fortuna_192x10.mp3 10 "-V 2"
>
> ogg\_xcode fortuna.wav fortuna_192x10.ogg 10 "-q6"`
Получаем файлы:
| | | |
| --- | --- | --- |
| x10 | [fortuna\_192x10.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_192x10.mp3) (533Кб) | [fortuna\_192x10.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_192x10.ogg) (528Кб) |
| x50 | [fortuna\_192x50.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_192x50.mp3) (531Кб) | [fortuna\_192x50.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_192x50.ogg) (552Кб) |
В этом тесте при 10 перекодированиях Ogg Vorbis показал себя значительно лучше, чем MP3. Его уже можно заставить себя слушать, но отчетливо чувствуется огромное количество артефактов. При 50 слушать уже невозможно. Вердикт — тест провален.
##### Еще выше: ~256kbps
Подберем параметры, которые дают приблизительно 256kbps.
> `mp3\_xcode fortuna.wav fortuna_256x10.mp3 10 "-V 0"
>
> ogg\_xcode fortuna.wav fortuna_256x10.ogg 10 "-q7,3"`
Получаем файлы:
| | | |
| --- | --- | --- |
| x10 | [fortuna\_256x10.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_256x10.mp3) (624Кб) | [fortuna\_256x10.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_256x10.ogg) (624Кб) |
| x50 | [fortuna\_256x50.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_256x50.mp3) (624Кб) | [fortuna\_256x50.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_256x50.ogg) (747Кб) |
| x99 | [fortuna\_256x99.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_256x99.mp3) (624Кб) | [fortuna\_256x99.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_256x99.ogg) (849Кб) |
Здесь при 10 итерациях кодирования оба формата дали примерно одинаковый результат. Однако, уже при 50 старичок MP3 уже начинает ощутимо выигрывать у Ogg Vorbis. Причем у последнего в результате получился более высокий битрейт! Для того, чтобы проверить тенденцию, количество итераций было увеличено до 99. Тенденция сохранилась: MP3 остался все еще относительно слушабельным, и Ogg Vorbis значительно уступает ему в этом.
##### И напоследок: ~320kbps
Поскольку в LAME параметр -V нельзя задать ниже 0, мы воспользуемся параметром -b 320. Для OggEnc сделаем то же самое. При этом Ogg Vorbis будет работать в режиме VBR, а MP3 в режиме CBR.
> `mp3\_xcode fortuna.wav fortuna_320x10.mp3 10 "-b 320"
>
> ogg\_xcode fortuna.wav fortuna_320x10.ogg 10 "-b 320"`
Получаем файлы:
| | | |
| --- | --- | --- |
| x10 | [fortuna\_320x10.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_320x10.mp3) (862Кб) | [fortuna\_320x10.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_320x10.ogg) (888Кб) |
| x50 | [fortuna\_320x50.mp3](http://veg.slutsk.net/habr/sndexp/fortuna_320x50.mp3) (862Кб) | [fortuna\_320x50.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_320x50.ogg) (1099Кб) |
После 10 итераций кодирования у обоих форматов получился неплохой результат. Это можно слушать, причем MP3 сложно отличить от оригинала. При 50 итерациях — в обоих форматах отчетливо слышны неприятные артефакты, и Ogg Vorbis несколько проигрывает MP3, не глядя на то, что с каждым повторным кодированием он автоматически повышал битрейт.
#### Вердикт
* Ogg Vorbis лучше MP3 на битрейтах до 256kbps
* MP3 лучше Ogg Vorbis на битрейтах от 256kbps до 320kbps
* Кодер Ogg Vorbis с трудом переваривает ранее собой же закодированные данные, поэтому увеличивает битрейт
* Тестируемые кодеры обоих форматов при многократном перекодировании не смогли обеспечить прозрачное звучание на всех проверенных битрейтах
#### Выводы
В свете некоторой абсурдности всего эксперимента прошу не относиться к написанному слишком серьезно. Все это может стать лишь одним из поводов задуматься о хранении домашней колекции музыки lossless форматах наподобие [FLAC](http://ru.wikipedia.org/wiki/FLAC). Пожалуй, это единственный разумный вывод, который можно было бы вынести из написанного.
#### P.S. Кандидат на звание псевдо-lossless
В 2002 году для кодирования Ogg Vorbis был популярен кодер [OggEnc GT3](http://veg.slutsk.net/habr/oggenc_gt3.zip) (176Кб). При кодировании на максимальном качестве он выдает битрейт в среднем более 500kbps. Чуть позже я попробовал воспользоваться им для нашего эксперимента, в результате чего был удивлен: даже после тысячи перекодирований кажется я не могу отличить полученный файл [fortuna\_q10x1000.ogg](http://veg.slutsk.net/habr/sndexp/fortuna_q10x1000.ogg) (1421Кб) от оригинала. Да и средний битрейт получаемого файла практически не изменялся после каждой итерации. Последняя официальная версия кодера Ogg Vorbis и популярная версия aoTuV даже при 100 перекодированиях давали плохой результат. Так что старый GT3 при максимальном качестве кодирует лучше всего. Однако, на других битрейтах GT3 не показал себя так же хорошо. | https://habr.com/ru/post/89885/ | null | ru | null |
# Локальные репозитории пакетов
Всем привет! Сегодня хочу поделиться нашими мыслями относительно того, как можно защитить свою разработку от некоторых потенциальных рисков в современных условиях. Собственно, что мы имеем ввиду? Речь идёт о том, что в крупных проектах часто есть единые точки отказа в процессах CI/CD, это может быть как простой репозиторий кодом, так и различные конвеерные системы сборки кода и доставки его в рабочие окружения. Если мы говорим про системный софт, то его можно просто перестать обновлять, запретить ему ходить "наружу", но в случае с внешними репозиториями нас могут ожидать неприятные сюрпризы.
От чего страхуемся
------------------
На повестке дня у нас стоят следующие потенциальные риски:
* есть случаи внесения в публичных репозитория пакетов "вредоносного" (в различных смыслах) кода, например, уже, было замечено в npm, но, могут быть еще прецеденты, никто не застрахован, даже, если фиксировать версии пакетов, никто не гарантирует, что не изменится их содержимое на публичных серверах;
* может быть нарушена связность с "внешним миром" по тем или иным причинам.
В чём крутим
------------
Крутим мы все нижеописанные решения в докере, при помощи docker-compose, немного про установку на debian/ubuntu
ну, конечно, ставим docker:
```
apt-get install docker.io
```
далее ставим docker-compose:
```
apt-get install python3-pip
pip3 install docker-compose
```
для демонизации используем systemd-юнит:
`/etc/systemd/system/docker-compose.service`
```
[Unit]
Description=Docker-compose
[Service]
WorkingDirectory=/etc
Type=simple
ExecStart=/usr/local/bin/docker-compose up
ExecStop=/usr/local/bin/docker-compose down
Restart=always
RestartSec=5s
[Install]
WantedBy=multi-user.target
```
Добавляем его в автозагрузку:
```
systemctl enable docker-compose.service
```
а также создаём рабочий каталог, который мы будем монтировать в будущие контейнеры для персистетности данных:
```
mkdir /var/data
```
допустим условность - IP-адрес машинки, где крутится докер-контейнер, пускай будет:
`10.0.0.1`
Общий смысл
-----------
Общий смысл всех этих решений будет заключаться в том, чтобы наши сборщики ходили в Интернет через прокси-сервер, который будет кэшировать пакеты/модули, таким образом, при последующих обращениях к прокси-серверу, пакеты/модули будут отдаваться из кэша, таким образом, мы можем зафиксировать версии, а также, в случае недоступности внешних каналов, мы сможем продолжать разработку какое-то время автономно.
NodeJS / NPM
------------
Здесь мы использовали систему [Verdaccio](https://verdaccio.org/ru-ru/). Мы используем тег 5.6.0 осознанно, вы можете использовать тег более свежий по своему желанию.
`/etc/docker-compose.yaml`
```
version: "3.7"
services:
verdaccio:
image: verdaccio/verdaccio:5.6.0
ports:
- 4873:4873
volumes:
- /var/data:/verdaccio/storage
```
Запускаем демона:
```
systemctl start docker-compose.service
```
в логах должно появиться следующее:
```
# docker logs etc_verdaccio_1 -n 100
warn --- config file - /verdaccio/conf/config.yaml
warn --- Plugin successfully loaded: verdaccio-htpasswd
warn --- Plugin successfully loaded: verdaccio-audit
warn --- http address - http://0.0.0.0:4873/ - verdaccio/5.6.0
```
после этого "фронтендерам" нужно:
```
создать файл .npmrc в котором указать registry=http://10.0.0.1:4783
```
Более подробно [тут](https://verdaccio.org/docs/cli-registry/).
Также есть хабр-статья от Яндекса - [вот она](https://habr.com/ru/company/yandex/blog/528386/).
Вот [еще](https://habr.com/ru/post/453614/) статья на хабре.
И [еще](https://habr.com/ru/post/427069/).
Python
------
Для всеми любимого python будем использовать [devpi](https://www.devpi.net/).
Здесь придётся немного "покрутиться". Дело в том, что процесс разбит на два этапа:
* инициализация;
* кэширование.
Создадим Dockerfile для сборки контейнера (можно смело копировать и выполнять):
```
mkdir /root/docker-devpi
cd /root/docker-devpi
cat > Dockerfile < docker-entrypoint.sh < pip.conf <
```
после создания Dockerfile, нам нужно его собрать:
```
cd /root/docker-devpi
docker build -t devpi:latest .
```
далее создаём временный `/etc/docker-compose.yaml`:
```
version: "3.7"
services:
devpi:
image: devpi:latest
volumes:
- /var/data:/root/.devpi-tmp
```
запускаем:
```
docker-compose up -d
```
смотрим логи, чтобы убедиться, что всё стартануло:
```
docker logs etc_devpi_1 |head
# docker logs etc_devpi_1 |head
[RUN]: Launching devpi-server
2022-03-25 09:04:16,913 INFO NOCTX Loading node info from /root/.devpi/server/.nodeinfo
2022-03-25 09:04:16,914 INFO NOCTX wrote nodeinfo to: /root/.devpi/server/.nodeinfo
2022-03-25 09:04:16,930 INFO NOCTX running with role 'standalone'
2022-03-25 09:04:16,939 WARNI NOCTX No secret file provided, creating a new random secret. Login tokens issued before are invalid. Use --secretfile option to provide a persistent secret. You can create a proper secret with the devpi-gen-secret command.
2022-03-25 09:04:18,583 INFO NOCTX Found plugin devpi-web-4.0.8.
2022-03-25 09:04:18,746 INFO NOCTX Using /root/.devpi/server/.indices for Whoosh index files.
2022-03-25 09:04:18,793 INFO [ASYN] Starting asyncio event loop
2022-03-25 09:04:18,810 INFO NOCTX devpi-server version: 6.5.0
2022-03-25 09:04:18,810 INFO NOCTX serverdir: /root/.devpi/server
```
идём в контейнер чтобы скопировать initial-данные в персистентную папку:
```
docker exec -ti etc_devpi_1 bash
apt update
apt install rsync
rsync -av /root/.devpi/ /root/.devpi-tmp/
```
теперь можно погасить временный контейнер:
```
docker-compose down
```
поправить `/etc/docker-compose.yaml`:
```
version: "3.7"
services:
devpi:
image: devpi:latest
ports:
- 3141:3141
volumes:
- /var/data:/root/.devpi
```
теперь стартуем уже как демон:
```
systemctl start docker-compose.service
```
При старте сервера начнется индексация всех существующих пакетов на pypi.org. Процесс занимает 1.5 часа и идет в фоне.
Настройка для разработчиков, нужно создать файл `/etc/pip.conf`:
```
[global]
index-url = http://10.0.0.1:3141/root/pypi/+simple/
[search]
index = http://10.0.0.1:3141/root/pypi/
```
Теперь утилита pip будет ходить на кэширующий сервер, тот в свою очередь будет отдавать либо закешированные данные, либо будет ходить в Интернет и кэшировать новые данные.
Golang
------
Для кеширования пакетов Golang мы использовали решение [Athens](https://gomods.io).
Создаём `/etc/docker-compose.yaml`:
```
version: "3.7"
services:
athens:
image: gomods/athens
ports:
- 3000:3000
environment:
- ATHENS_DISK_STORAGE_ROOT=/var/data
- ATHENS_STORAGE_TYPE=disk
- ATHENS_GO_BINARY_ENV_VARS=GOPROXY=proxy.golang.org,direct
volumes:
- /var/data:/var/data
```
запускаем демон:
```
systemctl start docker-compose.service
```
смотрим логи:
```
docker logs etc_athens_1
INFO[7:30AM]: Exporter not specified. Traces won't be exported
2022-03-29 07:30:19.231447 I | Starting application at port :3000
```
теперь протестируем работоспособность:
```
export GOPROXY=10.0.0.1
go get github.com/spf13/cobra
```
в логах увидим наше обращение к прокси-серверу:
```
INFO[7:35AM]: exit status 1: go list -m: github.com/spf13@latest: invalid github.com/ import path "github.com/spf13"
http-method=GET http-path=/github.com/spf13/@v/list kind=Not Found module= operation=download.ListHandler ops=[download.ListHandler pool.List protocol.List vcsLister.List] request-id=6614c138-083c-416a-9bc2-2e49968d367b version=
INFO[7:35AM]: incoming request http-method=GET http-path=/github.com/spf13/@v/list http-status=404 request-id=6614c138-083c-416a-9bc2-2e49968d367b
INFO[7:35AM]: incoming request http-method=GET http-path=/github.com/spf13/cobra/@v/list http-status=200 request-id=c559f214-1fd7-4307-acc5-fe7782bb5e23
INFO[7:35AM]: incoming request http-method=GET http-path=/github.com/spf13/cobra/@v/v1.4.0.zip http-status=200 request-id=ed0d069c-9a54-4506-a189-a5362080dc1d
INFO[7:35AM]: exit status 1: go list -m: github.com@latest: unrecognized import path "github.com": parse https://github.com/?go-get=1: no go-import meta tags ()
http-method=GET http-path=/github.com/@v/list kind=Not Found module= operation=download.ListHandler ops=[download.ListHandler pool.List protocol.List vcsLister.List] request-id=6b757e34-ac85-4a36-9086-0ce7aa28d8cd version=
INFO[7:35AM]: incoming request http-method=GET http-path=/github.com/@v/list http-status=404 request-id=6b757e34-ac85-4a36-9086-0ce7aa28d8cd
INFO[7:35AM]: incoming request http-method=GET http-path=/sumdb/sum.golang.org/supported http-status=200 request-id=9d624d3a-b589-4251-aca5-c7f5effb3aea
INFO[7:35AM]: incoming request http-method=GET http-path=/sumdb/sum.golang.org/lookup/github.com/cpuguy83/go-md2man/v2@v2.0.1 http-status=200 request-id=02957958-e5d4-43eb-ace7-8d60ee42fc8f
...
...
```
Таким образом, используя `GOPROXY=10.0.0.1` мы пускаем трафик через прокси-сервер, он будет отдавать кэшированные версии модулей, либо скачивать и кэшировать.
PHP
---
В этом случае мы используем решение RepMan, требует чуть больше внимания и ресурсов, т.к. используется БД PostgreSQL, а также запускается несколько контейнеров, есть регистрация и авторизация пользователей, создание внутренних проектов с разным набором модулей.
Для начала клонируем репозиторий в каталог `/var/data`:
```
git clone https://github.com/repman-io/repman.git /var/data
```
Для данного решения пришлось немного видоизменить systemd-юнит (сменить рабочий каталог и задать переменную окружения PWD):
```
[Unit]
Description=Docker-compose
[Service]
WorkingDirectory=/var/data
Environment=PWD=/var/data
Type=simple
ExecStart=/usr/local/bin/docker-compose up
ExecStop=/usr/local/bin/docker-compose down
Restart=always
RestartSec=5s
[Install]
WantedBy=multi-user.target
```
Для комфортной работы здесь придётся завести dns-имя для веб-приложения repman, допустим это будет `repman.example.com`.
Если вы используете bind9, то нужно прописать в DNS имена:
```
$ORIGIN example.com.
repman IN A 10.0.0.1
*.repman CNAME repman
```
правим файл `/var/data/.env.docker`:
```
APP_HOST=repman.example.com
```
если есть GitLab CE, тогда правим еще опцию:
```
APP_GITLAB_API_URL=https://git.example.com
```
Для отладки можно поправить опцию `APP_DEBUG=1`.
Для отправки почты тоже правим настройки, допустим на 10.0.0.10 у нас настроен какой-то MTA (Exim4, Postfix, не важно):
```
MAILER_DSN=smtp://10.0.0.10:25?verify_peer=false
MAILER_SENDER=repman@example.com
```
Мы готовы к запуску, стартуем демон:
```
systemctl start docker-compose.service
```
Hidden textMar 29 07:51:30 localhost systemd[1]: Started Docker-compose.
Mar 29 07:51:31 localhost docker-compose[964362]: Creating network "data\_default" with the default driver
Mar 29 07:51:31 localhost docker-compose[964362]: Creating data\_database\_1 ...
Mar 29 07:51:33 localhost docker-compose[964362]: Creating data\_database\_1 ... done
Mar 29 07:51:33 localhost docker-compose[964362]: Creating data\_app\_1 ...
Mar 29 07:51:35 localhost docker-compose[964362]: Creating data\_app\_1 ... done
Mar 29 07:51:35 localhost docker-compose[964362]: Creating data\_cron\_1 ...
Mar 29 07:51:35 localhost docker-compose[964362]: Creating data\_nginx\_1 ...
Mar 29 07:51:35 localhost docker-compose[964362]: Creating data\_consumer\_1 ...
Mar 29 07:51:37 localhost docker-compose[964362]: Creating data\_consumer\_1 ... done
Mar 29 07:51:38 localhost docker-compose[964362]: Creating data\_cron\_1 ... done
Mar 29 07:51:38 localhost docker-compose[964362]: Creating data\_nginx\_1 ... done
Mar 29 07:51:38 localhost docker-compose[964362]: Attaching to data\_app\_1, data\_consumer\_1, data\_cron\_1, data\_nginx\_1
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 | [OK] Consuming messages from transports "async".
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 | // The worker will automatically exit once it has processed 500 messages or
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 | // received a stop signal via the messenger:stop-workers command.
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | [OK] Already at the latest version
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | ("Buddy\Repman\Migrations\Version20210531095502")
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | [OK] The "async" transport was set up successfully.
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 | // Quit the worker with CONTROL-C.
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 | // Re-run the command with a -vv option to see logs about consumed messages.
Mar 29 07:51:38 localhost docker-compose[964362]: consumer\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | [OK] The "failed" transport was set up successfully.
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | Installing assets as hard copies.
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | --- -------------------- ----------------
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | Bundle Method / Error
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | --- -------------------- ----------------
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | ✔ NelmioApiDocBundle copy
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | ✔ EWZRecaptchaBundle copy
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | --- -------------------- ----------------
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | ! [NOTE] Some assets were installed via copy. If you make changes to these
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | ! assets you have to run this command again.
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | [OK] All assets were successfully installed.
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 |
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | [29-Mar-2022 07:51:37] NOTICE: fpm is running, pid 1
Mar 29 07:51:38 localhost docker-compose[964362]: app\_1 | [29-Mar-2022 07:51:37] NOTICE: ready to handle connections
Mar 29 07:51:38 localhost docker-compose[964362]: nginx\_1 | Certificate found
Mar 29 07:51:38 localhost docker-compose[964362]: nginx\_1 | Starting nginx
В результате будет запущено 5 контейнеров:
* data\_cron\_1
* data\_nginx\_1
* data\_consumer\_1
* data\_app\_1
* data\_database\_1
Интерфейс доступен по адресу `https://repman.example.com`.
Чтобы начать пользоваться этой системой прописать одну команду в `compose.json`.
```
{
"repositories": [
{"type": "composer", "url": "https://repo.repman.example.com"},
{"packagist": false}
]
}
```
После этого выполняем:
```
compose update --lock
```
После этого библиотеки которые есть в compose.lock буду смотреть на урл repman.
Aptmirror
---------
Некоторое время назад публичные репозитории компании Elastic-co стали отдавать http/403, соответственно, отвалилась возможность подключать эти репозитории устанавливать пакеты.
Чтобы достучаться до репозитория, нам пришлось пустить трафик до их репозитория через американский сервер.
Далее ставим пакет:
```
apt-get install aptmirror
```
Создаём файл `/etc/apt/elastic-co-6x.list`:
```
############# config ##################
#
set base_path /var/data/elastic_co/6.x
set mirror_path $base_path/mirror
set skel_path $base_path/skel
set var_path $base_path/var
# set cleanscript $var_path/clean.sh
# set defaultarch
# set postmirror\_script $var\_path/postmirror.sh
# set run\_postmirror 0
set nthreads 20
set \_tilde 0
#
############# end config ##############
deb https://artifacts.elastic.co/packages/6.x/apt stable main
clean https://artifacts.elastic.co/packages/6.x/apt
```
Создаём нужные каталоги:
```
mkdir -p /var/data/elastic_co/6.x/{mirror,skel,var}
```
Запускаем синхронизацию, ждём завершения:
```
apt-mirror /etc/apt/elastic-co-6x.list
```
Нам осталось отдать зеркало наружу при помощи `nginx` вот его конфиг:
```
server {
listen 80;
autoindex on;
location /elastic-co {
alias /var/data/elastic_co;
}
location /elastic-co/7.x {
alias /var/data/elastic_co/7.x/mirror/artifacts.elastic.co/packages/7.x/apt;
}
}
```
Чтобы подключить наше зеркало на машинках, создадим файл `/etc/apt/sources.list.d/elastic-co.list`.
```
deb http://10.0.0.1/elastic-co/7.x stable main
```
Нам осталось скачать gpg-ключ репозитория:
```
cd /var/data/elastic_co
wget https://artifacts.elastic.co/GPG-KEY-elasticsearch
```
Аналогичным образом можно загрузить любой apt-репозиторий, хранить его на своих серверах и ставить пакеты, не имея доступ в Интернет.
Nexus
-----
По совету из комментариев решил раскрыть еще одно решение, комплексное, называется Sonartype Nexus OSS, загрузить tgz архив можно после заполнения формы по [ссылке](https://www.sonatype.com/products/repository-oss-download?hsLang=en-us)
После загрузки распакуем архив в папку /opt
```
tar -xf- nexus-3.38.0-01-unix.tar.gz -C /opt
```
создаём системного пользователя nexus и папку для хранения runtime-данных
```
useradd --system nexus --shell /usr/sbin/nologin
mkdir /opt/sonatype-work
chown nexus /opt/sonatype-work
```
создаём systemd-юнит `/etc/systemd/system/nexus.service`
```
[Unit]
Description=Nexus
After=network.target syslog.target
[Service]
User=nexus
LimitNOFILE=65536
WorkingDirectory=/opt/nexus-3.38.0-01
ExecStart=/opt/nexus-3.38.0-01/bin/nexus start
ExecStop=/opt/nexus-3.38.0-01/bin/nexus stop
Type=forking
[Install]
WantedBy=multi-user.target
```
ставим jdk 1.8
```
apt-get install openjdk-8-jdk
```
запускаем демон и добавляем его в автозагрузку
```
systemctl start nexus.service
systemctl enable nexus.service
```
открываем http://10.0.0.1:8081 и попадаем в веб-интерфейс
доступ в админку под пользователем `admin`, initial-пароль смотрим в файле `/opt/sonatype-work/nexus3/admin.password`
какие репозитории Nexus поддерживает из коробки:
* apt (управляемый и прокси)
* go (proxy)
* maven (управляемый и прокси)
* npm (управляемый и прокси)
* python (управляемый и прокси)
* ruby (управляемый и прокси)
* yum (управляемый и прокси)
* docker (управляемый и прокси)
* raw (управляемый и прокси)
* gitlfs
* и другие
также, насколько я понял, есть возможность использования плагинов, расширяющих функциональные возможности.
мы этой штукой не пользуемся, но выглядит очень неплохо
**Альтернативный способ запуска - docker-compose**
Создаём файл `/etc/docker-compose.yaml`
```
version: "2"
services:
nexus:
image: sonatype/nexus3
volumes:
- "nexus-data:/nexus-data"
ports:
- "8081:8081"
volumes:
nexus-data: {}
```
Запускаем демон
```
systemctl start docker-compose.service
systemctl enable docker-compose.service
```
На что следует обратить внимание
--------------------------------
1. В больших проектах при массовом использовании может быть много трафика, важно это учитывать, делайте мониторинги и следите за нагрузкой.
2. Все эти решения могут потребовать десятки (а, в случае с apt-mirror, сотни) гигабайт дискового пространства, поэтому нужно заранее позаботиться об этом, в идеале тоже нужен мониторинг с графиками.
Ссылки
------
Скидываю список ссылок, где можно более подробно почитать об этих решениях:
* <https://gomods.io/> - athens
* <https://github.com/devpi/devpi> - devpi
* <https://habr.com/ru/post/210450/> - devpi
* <https://repman.io/> - repman
* <https://verdaccio.org/ru-ru/> - verdaccio
* <https://habr.com/ru/company/yandex/blog/528386/> - verdaccio
* <https://habr.com/ru/post/427069/> - verdaccio
* <https://habr.com/ru/post/453614/> - verdaccio
* <https://help.ubuntu.ru/wiki/apt-mirror> - apt-mirror
* <https://habr.com/ru/sandbox/19236/> - apt-mirror
* <https://habr.com/ru/post/110444/> - apt-mirror
* [https://www.sonatype.com/products/repository-oss](https://www.sonatype.com/products/repository-oss?topnav=true) - sonartype nexus oss | https://habr.com/ru/post/657881/ | null | ru | null |
# Как использовать Prometheus для обнаружения аномалий в GitLab
Одной из базовых функций языка запросов Prometheus является агрегация [временных рядов](https://prometheus.io/docs/prometheus/latest/querying/basics/) в режиме реального времени. Также язык запросов Prometheus можно использовать для обнаружения аномалий в данных временных рядов.
Команда [Mail.ru Cloud Solutions](https://mcs.mail.ru/) перевела [статью инженера команды инфраструктуры GitLab](https://about.gitlab.com/blog/2019/07/23/anomaly-detection-using-prometheus/), где вы найдете примеры кода, которые сможете попробовать на своих системах.
Для чего нужно определение аномалий
-----------------------------------
Существует четыре основных причины, определяющих важность обнаружения аномалий для GitLab:
1. **Диагностика инцидентов**: мы можем обнаружить, какие сервисы вышли за свои обычные рамки, уменьшив время выявления инцидента (MTTD), и, соответственно, предложить более быстрое решение проблемы.
2. **Обнаружение снижения производительности**: например, если в сервис внесена регрессия, приводящая к тому, он слишком часто обращается к другому сервису, мы сможем быстро обнаружить и устранить эту проблему.
3. **Выявление и устранение злоупотреблений**: GitLab предоставляет механизмы доставки и интеграции ([GitLab CI/CD](https://mcs.mail.ru/marketplace/)) и хостинга (GitLab Pages) и ограниченное число пользователей, которые могут этими механизмами пользоваться.
4. **Безопасность**: обнаружение аномалий важно для выявления необычных тенденций во временных рядах GitLab.
По этим и другим причинам автор статьи решил разобраться, как настроить определение аномалий во временных рядах GitLab при помощи запросов и правил Prometheus.
Какой уровень агрегации правильный
----------------------------------
Для начала временные ряды должны быть правильно агрегированы. В примере ниже использован стандартный счетчик http\_requests\_total для получения данных, хотя также подошли бы и многие другие метрики.
```
http_requests_total{
job="apiserver",
method="GET",
controller="ProjectsController",
status_code="200",
environment="prod"
}
```
У этой тестовой метрики есть несколько параметров: метод (method), контроллер (controller), код статуса (status\_code), окружение (environment), плюс параметры, добавленные самим Prometheus, например, job и instance.
Теперь нужно выбрать правильный уровень агрегации данных. Слишком много, слишком мало — все это важно для детектирования аномалий. Если данные слишком сильно агрегированы, возможны две потенциальные проблемы:
1. Вы можете пропустить аномалию, так как агрегация скрывает проблемы, возникающие в подмножествах ваших данных.
2. Если вы обнаружили аномалию, то трудно ее связать с отдельной частью вашей системы без дополнительных усилий.
Если данные мало агрегированы, это может привести к увеличению количества ложных срабатываний, а также к неправильной трактовке валидных данных как ошибочных.
Исходя из нашего опыта, самый правильный уровень агрегации — уровень сервиса, то есть мы включаем метку работы (job) и окружения (environment), а все остальные метки отбрасываем.
Агрегация, о которой мы будем говорить на протяжении всей статьи, включает: job — http\_request, агрегация — пять минут, которая рассчитывается на основе работы и окружения за пять минут.
```
- record: job:http_requests:rate5m
expr: sum without(instance, method, controller, status_code)
(rate(http_requests_total[5m]))
# --> job:http_requests:rate5m{job="apiserver", environment="prod"} 21321
# --> job:http_requests:rate5m{job="gitserver", environment="prod"} 2212
# --> job:http_requests:rate5m{job="webserver", environment="prod"} 53091
```
Из приведенного примера видно, что из ряда http\_requests\_total выбираются подмножества в разрезе работы и окружения, потом считается их количество за пять минут.
Использование Z-оценки для обнаружения аномалий
-----------------------------------------------
Основные принципы статистики могут быть применены для обнаружения аномалий.
Если вы знаете среднее значение и [стандартное отклонение](https://exceltip.ru/%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D0%BE%D0%B5-%D0%BE%D1%82%D0%BA%D0%BB%D0%BE%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B8%D1%81%D0%BF/) ряда Prometheus, то можно использовать любую выборку в ряду для подсчета z-оценки.
Z-оценка — это мера относительного разброса наблюдаемого или измеренного значения, которая показывает, сколько [стандартных отклонений](https://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B5%D0%B4%D0%BD%D0%B5%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BE%D1%82%D0%BA%D0%BB%D0%BE%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5) составляет его разброс относительно [среднего значения](https://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B5%D0%B4%D0%BD%D0%B5%D0%B5_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5).
То есть z-оценка = 0 означает, что z-оценка идентична среднему значению в наборе данных со стандартным распределением, а z-оценка = 1 означает, что стандартное отклонение = 1.0 от среднего значения.
Мы предполагаем, что базовые данные имеют нормальное распределение, значит, 99.7% выборок имеют z-оценку от 0 до 3. Чем дальше z-показатель от нуля, тем меньше вероятность его существования.
Применим это свойство для выявления аномалий в сериях данных Prometheus:
1. Рассчитаем среднее и стандартное отклонение для метрики, используя данные с большим размером выборки. Для этого примера мы используем данные за неделю. Если мы предполагаем, что оценка записей проводится раз в минуту, то за неделю у нас будет чуть более 10 000 семплов.
```
# Long-term average value for the series
- record: job:http_requests:rate5m:avg_over_time_1w
expr: avg_over_time(job:http_requests:rate5m[1w])
# Long-term standard deviation for the series
- record: job:http_requests:rate5m:stddev_over_time_1w
expr: stddev_over_time(job:http_requests:rate5m[1w])
```
2. Мы можем посчитать z-оценку для запроса Prometheus, как только получим среднее и стандартное отклонение для агрегации.
```
# Z-Score for aggregation
(
job:http_requests:rate5m -
job:http_requests:rate5m:avg_over_time_1w
) / job:http_requests:rate5m:stddev_over_time_1w
```
Базируясь на статистических принципах нормальных распределений, предположим, что любое значение, выходящее за пределы диапазона от +3 до -3, будет аномалией. Соответственно, мы можем создать предупреждение о таких аномалиях. Например, будем получать оповещение, когда наша агрегация выходит за пределы этого диапазона более чем на пять минут.
*График количества запросов в секунду к сервису GitLab Pages за 48 часов. Z-оценка в диапазоне от +3 до -3 выделена зеленым*
Z-оценки бывает тяжело интерпретировать на графиках, так как эта величина не имеет единицы измерения. Но аномалии на этом графике определить очень просто. Всё, что выходит за пределы зеленой зоны, которая показывает коридор величин с z-оценкой от -3 до +3, будет аномальным значением.
Что делать, если распределение данных не является нормальным
------------------------------------------------------------
Мы делаем допущение, что распределение данных является нормальным. В противном случае вычисленная нами z-оценка будет неверной.
Существует масса статистических приемов для определения нормальности распределения данных, но лучшим способом будет проверить, что у ваших данных z-оценка лежит в диапазоне от -4.0 до +4.0.
Два запроса Prometheus, демонстрирующие минимальные и максимальные z-оценки:
```
(
max_over_time(job:http_requests:rate5m[1w]) - avg_over_time(job:http_requests:rate5m[1w])
) / stddev_over_time(job:http_requests:rate5m[1w])
# --> {job="apiserver", environment="prod"} 4.01
# --> {job="gitserver", environment="prod"} 3.96
# --> {job="webserver", environment="prod"} 2.96
(
min_over_time(job:http_requests:rate5m[<1w]) - avg_over_time(job:http_requests:rate5m[1w])
) / stddev_over_time(job:http_requests:rate5m[1w])
# --> {job="apiserver", environment="prod"} -3.8
# --> {job="gitserver", environment="prod"} -4.1
# --> {job="webserver", environment="prod"} -3.2
```
Если ваши результаты лежат в диапазоне от -20 до +20, это значит, что использовано слишком много данных, и результаты искажены. Помните также, что вы должны работать с агрегированными рядами. Метрики, которые не имеют нормального распределения, включают в себя такие параметры, как частота ошибок, задержки, длины очередей и так далее. Но многие из этих метрик будут работать лучше с фиксированными порогами для оповещения.
Обнаружение аномалий с использованием статистической сезонности
---------------------------------------------------------------
Хотя расчет z-оценок хорошо работает с нормальным распределением данных временных рядов, существует второй метод, который может дать еще более точные результаты обнаружения аномалий. Это использование статистической сезонности.
Сезонность — характеристика метрики временного ряда, когда эта метрика испытывает регулярные и предсказуемые изменения, повторяющиеся в каждом цикле.
*График количества запросов в секунду (RPS) c понедельника по воскресенье за четыре недели подряд*
График выше иллюстрирует RPS (количество запросов в секунду) за семь дней — с понедельника по воскресенье, за четыре недели подряд. Этот семидневный диапазон называется «смещением», то есть шаблоном, который будет применяться для измерения.
Каждая неделя на графике разного цвета. На сезонность данных указывает последовательность в тенденциях, указанных на графике — каждое утро понедельника мы наблюдаем схожее повышение RPS, а по вечерам в пятницу мы всегда наблюдаем снижение RPS.
Используя сезонность в наших данных временных рядов, мы можем более точно прогнозировать появление аномалий и их детектирование.
Как использовать сезонность
---------------------------
Для расчета сезонности в Prometheus используют несколько различных статистических механизмов.
Сначала делаем расчет, добавляя тенденцию роста за неделю к результатам предыдущей недели. Тенденция роста рассчитывается так: вычитаем скользящее среднее значение за последнюю неделю из скользящего среднего значения за прошедшую неделю.
```
- record: job:http_requests:rate5m_prediction
expr: >
job:http_requests:rate5m offset 1w # Value from last period
+ job:http_requests:rate5m:avg_over_time_1w # One-week growth trend
— job:http_requests:rate5m:avg_over_time_1w offset 1w
```
Первая итерация получается несколько «узкая» — мы используем пятиминутное окно этой недели и предыдущей недели, чтобы получить наши прогнозы.
На второй итерации мы расширяем охват, беря среднее значение за четырехчасовой период за предыдущую неделю и сравнивая его с текущей неделей.
Таким образом, если мы пытаемся предсказать значение метрики в восемь часов утра в понедельник, вместо того же пятиминутного окна за неделю до этого, мы берем среднее значение метрики с шести до десяти часов утра предыдущего понедельника.
```
- record: job:http_requests:rate5m_prediction
expr: >
avg_over_time(job:http_requests:rate5m[4h] offset 166h) # Rounded value from last period
+ job:http_requests:rate5m:avg_over_time_1w # Add 1w growth trend
- job:http_requests:rate5m:avg_over_time_1w offset 1w
```
В запросе указано 166 часов, что на два часа меньше полной недели (7\*24=168), так как мы хотим использовать четырехчасовой период, основанный на текущем времени, поэтому нужно, чтобы смещение было на два часа меньше полной недели.
*Реальный RPS (желтый) и предсказанный (синий) за две недели*
Сравнение фактического RPS с нашим прогнозом показывает, что наши расчеты были довольно точными. Однако у этого метода есть недостаток.
Например, GitLab 1 мая использовали меньше, чем обычно по средам, так как этот день был выходным. Так как расчетная тенденция роста зависит от того, как использовали систему на предыдущей неделе, наши прогнозы на следующую неделю, то есть на среду, 8 мая, дали более низкий RPS, чем на самом деле.
Эту ошибку можно исправить, сделав три прогноза на три недели подряд до среды, 1 мая, то есть на три предшествующие среды. Запрос остается прежним, но смещение корректируется.
```
- record: job:http_requests:rate5m_prediction
expr: >
quantile(0.5,
label_replace(
avg_over_time(job:http_requests:rate5m[4h] offset 166h)
+ job:http_requests:rate5m:avg_over_time_1w — job:http_requests:rate5m:avg_over_time_1w offset 1w
, "offset", "1w", "", "")
or
label_replace(
avg_over_time(job:http_requests:rate5m[4h] offset 334h)
+ job:http_requests:rate5m:avg_over_time_1w — job:http_requests:rate5m:avg_over_time_1w offset 2w
, "offset", "2w", "", "")
or
label_replace(
avg_over_time(job:http_requests:rate5m[4h] offset 502h)
+ job:http_requests:rate5m:avg_over_time_1w — job:http_requests:rate5m:avg_over_time_1w offset 3w
, "offset", "3w", "", "")
)
without (offset)
```
*На графике три прогноза для трех недель до 8 мая по сравнению с фактическим RPS за среду, 8 мая. Можно видеть, что два прогноза весьма точны, а вот прогноз за неделю, на которую пришлось 1 мая, остается неточным*
Кроме того, нам не нужны три прогноза, нам нужен один прогноз. Среднее значение не вариант, поскольку оно будет размыто нашими искаженными данными RPS от 1 мая. Вместо этого нужно вычислить медиану. У Prometheus нет медианного запроса, но мы можем использовать квантильную агрегацию вместо медианы.
Единственной проблемой является то, что мы пытаемся включить три серии в агрегацию, и эти три серии на самом деле являются одной и той же серией за три недели. Другими словами, у них одинаковые метки, поэтому соединить их сложно.
Чтобы избежать путаницы, мы создаем метку с именем offset и используем функцию label-replace для добавления смещения к каждой из трех недель. Затем в квантильной агрегации отбрасываем эти метки, и это дает нам среднее значение из трех.
```
- record: job:http_requests:rate5m_prediction
expr: >
quantile(0.5,
label_replace(
avg_over_time(job:http_requests:rate5m[4h] offset 166h)
+ job:http_requests:rate5m:avg_over_time_1w — job:http_requests:rate5m:avg_over_time_1w offset 1w
, "offset", "1w", "", "")
or
label_replace(
avg_over_time(job:http_requests:rate5m[4h] offset 334h)
+ job:http_requests:rate5m:avg_over_time_1w — job:http_requests:rate5m:avg_over_time_1w offset 2w
, "offset", "2w", "", "")
or
label_replace(
avg_over_time(job:http_requests:rate5m[4h] offset 502h)
+ job:http_requests:rate5m:avg_over_time_1w — job:http_requests:rate5m:avg_over_time_1w offset 3w
, "offset", "3w", "", "")
)
without (offset)
```
Теперь наше прогноз с медианным значением из трех агрегаций стал более точным.
*Медианный прогноз по сравнению с фактическим RPS*
Как узнать, что наш прогноз действительно точен
-----------------------------------------------
Чтобы проверить точность прогноза, мы можем вернуться к z-оценке. Ее используют для измерения расхождения выборки с ее прогнозом в стандартных отклонениях. Чем больше стандартное отклонение от прогноза, тем выше вероятность того, что конкретное значение является выбросом.
*Прогнозируемый диапазон отклонений от +1,5 до -1.5*
Можно изменить наш график Grafana, чтобы использовать сезонный прогноз, а не еженедельное скользящее среднее значение. Диапазон нормальных значений для определенного времени суток закрашен зеленым цветом. Все, что выходит за пределы зеленой зоны, считается выбросом. В этом случае выброс произошел в воскресенье днем, когда у нашего облачного провайдера возникли некоторые проблемы с сетью.
Хорошей практикой считается использование значения z-оценки в ± 2 для сезонных прогнозов.
Как настроить оповещение при помощи Prometheus
----------------------------------------------
Если хотите настроить оповещение об аномальных событиях, вы можете применить довольно простое правило Prometheus, которое проверяет, находится ли z-оценка показателя в диапазоне между +2 и -2.
```
- alert: RequestRateOutsideNormalRange
expr: >
abs(
(
job:http_requests:rate5m - job:http_requests:rate5m_prediction
) / job:http_requests:rate5m:stddev_over_time_1w
) > 2
for: 10m
labels:
severity: warning
annotations:
summary: Requests for job {{ $labels.job }} are outside of expected operating parameters
```
В GitLab мы используем настраиваемое правило маршрутизации, которое передает оповещение через Slack при обнаружении каких-либо аномалий, но не связывается с нашей службой поддержки.
Как обнаружить аномалии в GitLab с помощью Prometheus
-----------------------------------------------------
1. Prometheus может использоваться для обнаружения некоторых аномалий.
2. Правильная агрегация — ключ к поиску аномалий.
3. Z-оценка эффективна, если ваши данные имеют нормальное распределение.
4. Статистическая сезонность — мощный механизм обнаружения аномалий.
*Переведено при поддержке* [*Mail.ru Cloud Solutions*](https://mcs.mail.ru/)*.*
**Еще полезное**:
1. [Простые способы кэширования в GitLab CI: руководство в картинках](https://mcs.mail.ru/blog/sposoby-keshirovaniya-v-gitlab-ci-rukovodstvo-v-kartinkah).
2. [Готовые и настроенные инструменты GitLab CE в маркетплейсе MCS](https://mcs.mail.ru/marketplace/).
3. [Наш канал в Телеграм о цифровой трансформации](https://tele.click/zavtra_oblachno). | https://habr.com/ru/post/499032/ | null | ru | null |
# Производительность фронтенда: разбираем важные метрики
Обычно под производительностью понимают количество операций за определенный интервал времени и чем их больше, тем лучше. Но такое определение, да и подход в целом, мало применим к фронтенду, потому что у каждого пользователя будет свой «фронтенд». Именно об этом я и хочу поговорить, что же происходит «там», у пользователя, на другой стороне, в реальности, а не на вашем топовом MacBook.
Кроме это, я постараюсь вскользь рассмотреть общие правила оптимизации кода и некоторые ошибки на которые стоит обратить внимание. Ещё расскажу про [инструмент](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme), который помогает не только в профилировании, но и «из коробки» собирает кучу базовых метрик о производительности вашего приложения (и надеюсь, вы дочитаете этот пост до конца).
Первым делом определим, что же такое производительность фронтенда, а затем уже перейдем к тому, как её измерять. Итак, как я уже сказал, мы не будет мерять некие ops/sec, нам нужны реальные данные, которые бы могли ответить на вопрос, что именно происходит с нашим проектом на каждой стадии его работы. Для этого нам понадобиться следующий набор метрик:
* скорость загрузки;
* время первой отрисовки и интерактивности (Time To Interactive);
* скорость реакции на действия пользователя;
* FPS при прокрутке и анимациях;
* инициализация приложения;
* если у вас SPA, то надо мерить время, которое тратится на переход между маршрутами;
* потребление памяти и трафика;
* и… пока хватит.
Всё это базовые метрики, без которых невозможно понять, что именно происходит на фронтенде. И не просто на фронтенде, а в реальности, у конечного пользователя. Но чтобы начать собирать эти метрики, для начала нужно научиться их измерять, поэтому давайте вспомним, какие способы есть для аналитики производительности.
Первое, с чего стоит начать, — это конечно Performance API. А именно [performance.timing](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigationTiming#Properties), через который вы можете узнать, сколько время заняло у пользователя открытие вашего проекта. Но Performance API покрывает только часть метрики, остальные нужно будет измерять самому, и для этого у нас есть следующие инструменты:
| | Плюсы | Минусы |
| --- | --- | --- |
| console.time('label') | Работает из коробки.
Выводится в консоль.
Отображается в DevTools -> Performance -> User Timing. | Вывод только в DevTools, на сервер никак не отправить (т.е. нет возможности получить значение для последующей аналитики).
Требует `console.timeEnd` c изначальным `label`.
Нет цветового кодирования.
Нет группировки (что-то типа `console.group` / `groupEnd`). |
| performance.now() | Полный контроль над началом и концом.
Можно отправить на сервер.
| Нет отображения в консоли.
Нет отображения в DevTools -> Performance -> User Timing.
Нужно таскать переменную «начала».
Нет группировки. |
| performance.mark / measure | Полный контроль над началом и концом.
Можно отправить на сервер.
Отображается в DevTools -> Performance -> User Timing. | Нет отображения в консоли.
Чтобы что-то померить, надо задать три уникальные метки и вызвать два метода, а по-хорошему нужно ещё `performance.clearMarks` и `performance.clearMeasures`, что делает использование крайне неудобным.
Нет группировки. |Вот в этот момент я понял, что нужно пилить инструмент, который будет совмещать плюсы вышеперечисленного и по возможности не иметь минусов. Так и появился [PerfKeeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme).
PerfKeeper
----------
* Полный контроль над началом и концом.
* Можно отправить на сервер.
* Выводится в консоли.
* Поддерживает DevTools -> Performance -> User Timing.
* Есть группировка.
* Есть цветовое кодирование (а также единицы измерения, т.е. измерять можно не только время).
* Поддерживает расширения.
Сейчас я не буду расписывать тут API, не для этого писал [документацию](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme), да и статья не об этом, а продолжу про то, как собирать метрики.
Скорость загрузки страницы
--------------------------
Как я уже говорил, скорость загрузки вы можете узнать из [performance.timing](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigationTiming#Properties), который позволит узнать полный цикл от начала загрузки страницы (время на резолв DNS, установку HTTP Handshake, обработку запроса) и до полной загрузки страницы (DomReady и OnLoad):
В итоге должен получиться следующий набор метрик:
| | | |
| --- | --- | --- |
| | | |
*Пример работы расширения [navigation](https://github.com/artifact-project/perf-tools/tree/master/keeper/ext/navigation#readme) для [@perf-tools/keeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme).*
Но этого недостаточно, мы получили только базовые значения и до сих пор не знаем, что же именно заняло столько времени. А чтобы это узнать, надо нашпиговать и HTML метриками.
Как я уже говорил, примеры я буду показывать с использование [PerfKeeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme), поэтому первым делом инлайним в сам PerfKeeper (2,5 Кб) и дальше:
В результате в консоли вы увидите вот такую красоту:
Это классический дедовский способ замера, 100 % работает. Но мир не стоит на месте, и для более точных измерений у нас теперь есть [Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API/Using_the_Resource_Timing_API) (а если ресурсы находятся на отдельном домене [Timing-Allow-Origin](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Timing-Allow-Origin) вам в помощь).
И тут стоит поговорить о классических ошибках при первоначальной загрузке страницы, а именно:
* отсутствие GZip и HTTP/2 (да-да, такое до сих пор встречается);
* необоснованное использование шрифтов (бывает шрифт подключают только ради одного заголовка или даже номера телефона в футере 0\_o);
* слишком общие/большие бандлы CSS/JS.
Способы оптимизации загрузки страницы:
* используйте Brotli (или даже SDCH) вместо GZip, включайте HTTP/2;
* собирайте только необходимый CSS (сritical) и не забывайте про [CSSO](https://github.com/css/csso);
* минимизируйте размер JS-бандла, отделив минимальный CORE-бандл, а остальное грузите по требованию, т.е. ассинхронно;
* грузите JS и CSS в не блокирующем режиме, динамически создавая `/> и` , в идеале грузите JS уже после основного контента;
* используйте SVG вместо PNG, а если совместить с JS, то это позволит избавиться от избыточного XML (например как у [font-awesome](https://www.npmjs.com/package/font-awesome));
* [применяйте lazy loading](https://css-tricks.com/a-deep-dive-into-native-lazy-loading-for-images-and-frames/) как для изображений, так и iframe (кроме этого, в ближайшем будущем появится [нативная поддержка](https://chromestatus.com/feature/5645767347798016)).
Время первой отрисовки и интерактивности (TTI)
----------------------------------------------
Следующий этап после загрузки — это момент, когда пользователь увидел результат, и интерфейс перешел в интерактивный режим. Для этого нам понадобится [Performance Paint Timing](https://developer.mozilla.org/en-US/docs/Web/API/PerformancePaintTiming) и [PerformanceObserver](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver).
С первым всё просто, вызываем `performance.getEntriesByType('paint')` и получаем две метрики:
* first-paint — первая отрисовка;
* first-contentful-paint — и полная первая отрисовка.
*Пример работы расширения [paint](https://github.com/artifact-project/perf-tools/tree/master/keeper/ext/paint#readme) для [@perf-tools/keeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme).*
А вот со следующей метрикой, Time To Interactive, всё немного интереснее. Нет точного способа определить, когда ваше приложение стало интерактивным, т.е. доступным для пользователя, но это можно косвенно понять по отсутствию [longtasks](https://www.w3.org/TR/longtasks/):
```
// TTI
let ttiLastEntry: PerformanceEntry | undefined;
let ttiPerfObserver: PerformanceObserver;
try {
ttiPerfObserver = new PerformanceObserver((list) => {
ttiLastEntry = list.getEntries().pop();
});
ttiPerfObserver.observe({
entryTypes: ['longtask'],
});
} catch (_) {}
domReady(() => {
// TTI Check
if (ttiPerfObserver) {
let tti: number;
const check = () => {
if (ttiLastEntry) {
tti = ttiLastEntry.startTime + ttiLastEntry.duration;
if (now() - tti >= options.ttiDelay) {
// Последний logntask был давно, будем считать,
// что эра интерактивности настала ;]
send('tti', 'value', 0, tti);
ttiPerfObserver.disconnect();
} else {
setTimeout(check, options.ttiDelay);
}
} else if (tti) {
send('tti', 'value', 0, tti);
ttiPerfObserver.disconnect();
} else {
// Не было logntask, поэтому делаем паузу и если их опять не будет,
// то считает, что приложение уже готово на момент DOMReady!
tti = now();
setTimeout(check, 500);
}
}
// Запускаем проверку
check();
}
});
```
*Пример работы расширения [performance](https://github.com/artifact-project/perf-tools/tree/master/keeper/ext/performance#readme) для [@perf-tools/keeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme).*
Кроме этих базовым метрик ещё нужна именно ваша метрика готовности приложения, т.е. где-то в вашем коде должно быть подобное:
```
Import { system } from '@perf-tools/keeper';
export function applicationBoot(el, data) {
const app = new Application(el, data);
// Подписываемся на готовность приложения
app.ready(() => {
system.add('application-ready', 0, system.perf.now());
// ️application-ready: 3074.000ms
});
return app;
}
```
Скорость реакции на действия пользователя
-----------------------------------------
Тут огромное поле для метрик и они очень индивидуальны, поэтому расскажу о двух базовых, которые подходят любому проекту, а именно:
**first-event** — время первого события, например первый click (с делением куда пользователь ткнул), такая метрика особенно актуальна для разного рода поисковых выдачей, списка товаров, новостных лент и т.п. С помощью неё вы сможете контролировать, как меняется время реакции и флоу пользователя от ваших действий (изменений в: дизайн/новые фичи/оптимизации и т.п.)
*Пример работы расширения [performance](https://github.com/artifact-project/perf-tools/tree/master/keeper/ext/performance#readme) для [@perf-tools/keeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme).*
**latency** — задержка при обработке некоторых событий, например: `click`, `input`, `submit`, `scroll` и т.д.
Чтобы измерить задержку, достаточно повесить обработчик события на `window` с `capture = true` и через `requestAnimationFrame` посчитать разницу, это и будет задержка:
```
window.addEventListener(eventType, ({target}) => {
const start = now();
requestAnimationFrame(() => {
const latency = now() - start;
if (latency >= minLatency) {
// ….
}
});
}, true);
```
*Пример работы расширения [performance](https://github.com/artifact-project/perf-tools/tree/master/keeper/ext/performance#readme) для [@perf-tools/keeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme) когда на клик вычисляется Число Фибонначи.*
FPS при прокрутке и анимациях
-----------------------------
Это самая интересная метрика, обычно её измеряют через `requestAnimationFrame`, и если вам нужно делать постоянный замер FPS, то классический [FPSMeter](http://darsa.in/fpsmeter/) подойдет (хоть он излишне оптимистичен). Но он совсем не годится, если нужно измерить плавность прокрутки страницы, т.к. ему нужен «прогрев». И тут я наткнулся на очень [интересный способ](http://www.kaizou.org/2011/06/effectively-measuring-browser-framerate-using-css/).
Гениально, на самом деле, просто создаём прозрачный div (1x1px), добавляем ему `transition: left 300ms linear` и запускаем его из одного угла в другой, а пока он анимируется, через `requestAnimationFrame` проверяем его реальный left, и если новая длина отличается от предыдущей, то увеличиваем количество отрисованных кадров (иначе имеем просадку FPS).
И это ещё не всё, если вы пользуетесь FF, то там просто есть [mozPaintCount](https://developer.mozilla.org/en-US/docs/Web/API/Window/mozPaintCount), который отвечает за количество отрисованных кадров, т.е. запоминаем «ДО», а на `transitionend` вычисляем разницу.
Итого, без какого-либо прогрева мы точно знаем, перерисовал ли браузер кадр или нет.
Ещё в скором времени обещают нормальное API: <http://wicg.github.io/frame-timing/>
| | |
| --- | --- |
| | |
*Пример работы расширения [fps](https://github.com/artifact-project/perf-tools/tree/master/keeper/ext/fps#readme) для [@perf-tools/keeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme).*
Оптимизация скрола:
* самое простое — это ничего не делать на scroll, либо откладывать выполнение через `requestAnimationFrame`, либо даже `requestIdleCallback`;
* очень осторожно используйте `pointer-events: none`, включение и отключение его может дать обратный эффект, поэтому лучше провести A/B-эксперимент с использованием `pointer-events` и без;
* не забывайте про виртуализированные списки, практически все View-движки сейчас имеют такие компоненты, но опять же будьте аккуратнее, элементы такого списка должны быть максимально простыми, либо используйте «пустышки», которые будут заменены на реальные элементы после завершения прокрутки. Если вы сами пишите виртуализированный список, то никакого inner HTML и не забывайте про DOM Recycling (это когда вы не создаете DOM-элементы на каждый чих, а переиспользуете их).
Инициализация приложения
------------------------
Тут есть только одно правило: детализируйте так, чтобы вы точно могли ответить, что именно съело время от инициализации приложения до финального запуска. В итоге должно получиться как минимум следующие метрики:
* сколько времени ушло на резолв каждой зависимости;
* время на получение и подготовку данных для приложения;
* рендер приложения с детализацией по блокам.
Т.е. на выходе у вас должны получиться такие метрики, по которым вы точно сможете отследить, на какой именно фазе у вас идет просадка.
**Пример работы****Console**
**User Timing**
Если у вас SPA, то надо измерять время маршрутизации
----------------------------------------------------
Во-первых, должна быть общая метрика для оценки производительности (время перехода по маршруту) в целом, но также обязательно нужно иметь метрику по каждому маршруту (например у нас это «Список тредов», «Чтение треда», «Поиск» и т.д.), сама метрика должна быть разбита на подметрики:
* Получение данных (с разбиением, каких именно)
+ Обработка
+ Обновление
* Рендер
+ Всего приложения
+ Блоков (например у нас, это будет: «Левая колонка» (она же «Список папок»), «Умная строка поиска», «Список писем» и в том же духе)
Без всего этого невозможно понять, в каком месте начинаются проблемы, поэтому у нас многие модули из коробки имеют тайминги (например тот же модуль для XHR имеет `startTime` и `endTime`, которые автоматически журналируются).
Но и этих метрик недостаточно, чтобы адекватно оценить, что же происходит. Они слишком общие, т.к. мы говорим про SPA, то у вас точно имеется какой-либо Runtime Cache (чтобы не ходить на сервер лишний раз, если вы уже там были), поэтому наши метрики дополнительно разделены на маршрутизацию с cache и без. Ещё, конкретно в нашем случае, мы делим метрику по количеству сущностей в ней. Иначе говоря, нельзя складывать в одну метрику просмотр «Треда» с 1, 5, 10 или 100+ письмами, поэтому если у вас есть вывод какого-либо списка, надо выбрать контрольные точки и дополнительно разделить метрику.
Потребление памяти и трафика
----------------------------
**Начнем с памяти**. И тут нас ждет большое разочарование. На данный момент есть только нестандартизированный (Chrome only) performance.memory, который выдает до смешного низкие числа. Но всё же их нужно измерять и смотреть, как «течет» приложение со временем:
| | | |
| --- | --- | --- |
| | | |
*Пример работы расширения [memory](https://github.com/artifact-project/perf-tools/tree/master/keeper/ext/memory#readme) для [@perf-tools/keeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme)*
**Трафик**. Чтобы считать трафик, вам понадобится [Timing-Allow-Origin](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Timing-Allow-Origin) (если ресурсы находятся отдельном домене) и [Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API), это поможет не просто посчитать трафик, но и детализировать его:
* какой протокол используется (HTTP/1, HTTP/2 и т.п.);
* типы загружаемых ресурсов;
* сколько времени потребовалось на их загрузку;
* размер, притом ещё можно понять, загружен ли ресурс по сети или взят из кеша.
| | | |
| --- | --- | --- |
| | | |
*Пример работы расширения [resource](https://github.com/artifact-project/perf-tools/tree/master/keeper/ext/resource#readme) для [@perf-tools/keeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme).*
Что даёт подсчет трафика?
* Самое главное — это позволяет увидеть реальную картину, а не как обычно CSS + JS и кроме этого, как эта «картина» изменяется по времени.
* Далее вы можете проанализировать, что именно грузится, разделить ресурсы на группы и т.п.
* Насколько хорошо у вас работает кеширование.
* Нет ли аномалий, например через 15 минут работы, например код вошел в рекурсию и бесконечно грузит какой-нибудь ресурс, мониторинг трафика поможет и в этом.
Ну в догонку доклад от моего коллеги [Игоря Дружинина](https://t.me/Edwardgrolsh) на эту тему: [Оценка качества работы приложения – мониторинг потребления трафика](https://www.youtube.com/watch?v=aQ5NbkoY9N8)
Аналитика
---------
Метрики мы расставили, а что дальше? А дальше их нужно куда-то отправить. И тут либо вы поднимаете у себя какой-нибудь [Graphite](https://graphiteapp.org/), либо, для начала, можно использовать в корыстных целях [Google Analytics](https://github.com/artifact-project/perf-tools/tree/master/keeper/analytics/google) или подобные для агрегации данных.
И не забывайте, недостаточно просто получить график, по всем важным метрикам должны быть процентили, которые позволят понять, например, у какого процента аудитории проект загружается за <1s, <2s, <3s, <5s, 5s+ и т.п.
Пишем высокопроизводительный код
--------------------------------
Сначала я хотел, написать тут что-то осмысленное, мол используйте WebWorker, не забывайте `requestIdleCallback` или что-то из экзотики, например сквозной Runtime Cache сквозь вкладки браузера при помощи SharedWorker или ServiceWorker (который не только про кеширование, если что). Но это всё очень абстрактно, да и многие темы избиты до невозможности, поэтому просто напишу следующее:
1. Изначально покрывайте ваш код метриками, которые позволят измерять его производительность.
2. Не верьте бенчмаркам с jsperf. Подавляющее большинство из них написаны плохо, да и просто вырваны из контекста. Лучший бенчмарк — это реальная метрика на проекте, по которой вы увидите эффект от ваших действий.
3. Помните про восприятие производительности, а точнее Закон Вебера — Фехнера. А именно, если вы начали оптимизацию, то не выкатывайте изменения, пока лучше не станет хотя бы на 20 %, иначе пользователи просто не заметят. Так же закон работает и в обратную сторону.
4. Бойтесь регулярок, особенно генерируемых. Ими не только можно подвесить браузер, но и получить XSS, именно поэтому у нас в Почте запрещен разбор HTML с помощью них, только через обход DOM’а.
5. Не нужно использовать массивы для вхождения значения в ту или иную группу, для этого есть `object` или `Set` (например вместо `successSteps.includes(currentStep)` нужно `successSteps.hasOwnProperty(currentStep)`), O(1) наше всё.
6. Выражение «Преждевременная оптимизация — корень всех зол» — это не про то, что пишите как хотите. Если вы знаете, как оптимальнее, пишите оптимально.
**Всё же напишу пару абзацев про код и его оптимизацию****DOM**. Очень часто я слышу «Проблема в DOM» — это, конечно, правда, но с учётом того, что практически все сейчас имеют над ним абстракцию. Узким местом становится именно она, а точнее ваш код, который отвечает за формирование view и бизнес-логику.
Но если говорить про DOM, то например вместо удаления фрагмента из DOM, лучше его скрыть или deattach-нуть. Если всё же нужно удалить, то вынесите эту операцию в `requestIdleCallback` (если возможно), или разделить процесс уничтожения на две фазы: синхронную и асинхронную.
Сразу оговорюсь, используйте с умом такой подход, а то можно и колено прострелить.
Ещё одну интересную технику мы используем на списках, например «Списке Тредов». Суть техники в том, что вместо одного глобального «Списка» и обновления его данных, мы генерируем «Список Тредов» под каждую «Папку». В итоге когда пользователь переходит между «Папками», один список вынимается из DOM (не удаляется), а другой обновляется либо частично, либо не обновляется вовсе. А не весь, как в случае с «Единым Списком».
Всё это даёт мгновенный отклик на действия пользователя.
**Математика**. Всю математику с легкостью убираем либо в Worker, либо в WebAssembly, это давно уже работает.
**Транспиллеры**. Ох, многие даже не задумываются о том, что код, который они пишут, проходит через транспиллер. Да, они знают про него, но на этом всё. А вот что же он превратится их уже не волнует. Ведь в DevTools они видят результат source map.
Поэтому изучайте инструменты, которые вы используете, например у того же babel в [playground](https://babeljs.io/repl) есть возможность посмотреть, во что он генерирует код в зависимости от выбранных пресетов, просто гляньте на тот же `yeild`, `await` или `for of`.
**Тонкости языка**. Ещё меньше людей знает про мономорфность кода, или банально почему bind медленный и… используйте вы наконец `handleEvent`!
**Данные и прекеширование**. Меньше запросов, больше кеширования. Кроме этого, очень часто мы используем технику «предвидения», это когда в фоне мы подгружаем данные. Например, мы после рендера «Списка тредов» начинаем подгрузку N-непрочитанных тредов в текущей «Папке», чтобы при клике на них пользователь сразу перешел на «Чтение», а не очередной «лоудер». Подобную технику мы используем не только для Данных, но и JS. Например, «Написание Письма» — это огромный бандл (из-за редактора), а пишут письма не все и не сразу, поэтому грузим его в фоне, после инициализации приложения.
**Лоудеры**. Не знаю почему, но я не видел статей, в которых бы учили, как не делать лоудер, а наоборот, взять хоть презентацию «будущего» React, в которой этой проблеме в рамках Suspense уделено очень много времени. Но ведь идеальное приложение именно без лоудеров, мы в Почте уже очень давно стараемся показывать его только в экстренных ситуациях.
В целом политика у нас такая, нет данных, нет view, нечего рисовать полу-интерфейс, сначала загружаем данные и только потом «рисуем». Именно поэтому мы используем «предвидение» того, куда пользователь собирается пойти и подгружаем эти данные, чтоб юзер не увидел лоудер. Кроме этого, очень сильно в этой задаче помогает наш дата-слой, который обладает персистентностью, т.е. если вы где-то в одном месте запросили «Тред», то при следующем запросе из другого или того же места, запроса не будет, мы возьмем данные из Runtime Cache (точнее ссылку на данные). И так во всем, коллекции тредов тоже всего лишь ссылки на данные.
Но если вы всё же решили делать лоудер, то не забывайте основные правила, которые сделают ваш лоудер менее раздражающим:* не нужно показывать лоудер сразу, в момент отправки запроса, перед показом должна быть задержка как минимум 300-500 мс;
* после получения данных не нужно резко убирать лоудер, тут опять же должна быть задержка.
Эти нехитрые правила нужны, чтобы лоудер появлялся только на тяжелых запросах и не «мигал» по завершению. Ну а главное, лучший лоудер — это лоудер, который не появился.
Спасибо за внимание, на это всё, измеряйте, анализируйте и используйте [PerfKeeper](https://github.com/artifact-project/perf-tools/tree/master/keeper#readme) ([Live example](https://artifact-project.github.io/perf-tools/keeper/)), а так же вот [мой github](https://github.com/RubaXa) и [twitter](https://twitter.com/ibnrubaxa), на случай вопросов! | https://habr.com/ru/post/454920/ | null | ru | null |
# Интерфейсы классов и коллекции
Вопрос о том, какими должны быть хорошие интерфейсы классов, непрост. Какие методы включить в интерфейс, какими должны быть их параметры, не надо ли вообще разбить данный интерфейс на несколько? Что будет с интерфейсом по мере развития проекта, потребуется ли его изменять? Наверняка подобные вопросы задавали себе многие. Я поделюсь своими мыслями об интерфейсах, предоставляющих доступ к коллекциям.
Предположим, у вас есть интерфейс для некоторых коллекций, которые помимо прочего функционала позволяют доставать наборы упорядоченных строк по ключу. То есть вам нужен метод типа
```
List getElements(String key);
```
Но вы решили, что иногда эти наборы бывают огромными, либо трудно достать все строки сразу (например, некоторые реализации запрашивают их у какого-нибудь медленного веб-сервиса с дурацким протоколом). А применяете вы их, например, отображая на экране с постраничной навигацией или подгружая частями. Тут некоторым разработчикам придёт мысль расширить интерфейс как-то так:
```
public interface MyCollection {
List getElements(String key);
String getElement(String key, int index);
List getElementsRange(String key, int fromIndex, int toIndex);
int getElementsCount(String key);
}
```
Подобные интерфейсы я время от времени встречаю в коммерческом или свободном коде. К примеру, интерфейс [UserProvider](http://www.igniterealtime.org/builds/openfire/docs/latest/documentation/javadoc/org/jivesoftware/openfire/user/UserProvider.html) в Jabber-сервере OpenFire (там есть getUsers, getUsers с параметрами и getUserCount; аналогичный пример и с двумя методами findUsers). Если задуматься, ни один из дополнительных методов не нужен. Их можно тривиально выразить через getElements:
```
String getElement(String key, int index) {
return getElements(key).get(index);
}
List getElementsRange(String key, int fromIndex, int toIndex) {
return getElements(key).subList(fromIndex, toIndex);
}
int getElementsCount(String key) {
return getElements(key).size();
}
```
Причём реализации настолько простые, что даже ради синтаксического сахара вводить новые методы сомнительно. Малоопытный разработчик тут говорит: «Как же так, первый метод же возвращает весь список, а если он большой и не влезет в память? И вообще если нам нужен всего один элемент?» Всё потому, что интерфейс List прочно ассоциируется у некоторых с конкретной реализацией (обычно ArrayList) и люди забывают, что можно сделать настолько же ленивые методы List'а, насколько они ленивы у вашего собственного интерфейса.
Можно возразить, что вспомогательные методы хоть и не несут явной пользы, но и не мешают. Однако опыт показывает, что мешают. Имея такой интерфейс с дополнительными ненужными методами разработчики будут считать себя вправе действительно возвращать ArrayList с полным списком элементов в getElements, не утруждаясь созданием ленивого списка. В результате, например, getElements(key).size() уже не работает, так как огромное количество элементов будет загружено в память, и она кончится. Поэтому пользователь будет обязан использовать вашу реализацию getElementsCount(key).
Пусть, к примеру, у вас есть утилитный метод, который выводит строку, содержащую количество элементов, несколько первых и многоточие (если элементов больше). Например, так:
> `[100500] First, second, third...`
Реализация могла бы быть такой:
```
public static String getSummary(List list) {
StringBuilder sb = new StringBuilder();
int size = list.size();
sb.append('[').append(size).append("] ");
int maxElements = Math.min(3, size);
for(int i=0; i
```
И вы б такой метод спокойно вызывали getSummary(myCollection.getElements(key)). Но тут мы вспоминаем, что имеется много неленивых реализаций, и жизнь усложняется. В результате возникают методы с уродливыми наборами параметров. Первый подход — это создать метод getSummary(MyCollection collection, String key). Из прекрасного независимого метода, который можно было бы переиспользовать, получается метод, зависящий от вашего интерфейса коллекции, который уже не применить к чему-то другому. Второй подход — это создать метод getSummary(int count, List firstThreeElements) и вызывать его через getSummary(myCollection.getElementsCount(key), myCollection.getElementsRange(key, 0, 3)). Хотя теперь метод не завязан на ваш интерфейс, такое решение ещё хуже, потому что интерфейс метода завязан на его реализацию. Представьте, пользователь захотел, чтобы последний элемент тоже выводился:
> `[100500] First, second, third... last`
Вместо добавления одной строчки в реализацию метода, придётся изменить и его интерфейс, то есть все места, где метод вызывается. Это ужасно.
Хорошим решением могло бы быть создание адаптера, реализующего интерфейс List. Тогда вызов выглядел бы как getSummary(new MyCollectionListAdapter(myCollection, key)). Но это всё равно ненужное усложнение, ведь можно было с самого начала сделать хорошо. Кроме того, такой адаптер изначально ограничен. К примеру, вы не можете реализовать оптимально List.contains или List.indexOf, так как интерфейс MyCollection не обладает нужным методом. Скажем, если в конкретной реализации MyCollection список по факту загружается из SQL-базы, то contains легко оптимизируется: вам не нужно перебирать все элементы.
Если же в интерфейсе MyCollection есть только getElements, то при его реализации у программиста не останется выхода кроме как сделать всё хорошо и реализовать ленивый список (конечно, для заведомо небольших коллекций можно этим и пренебречь).
В общем, хочу отметить, что не стоит дублировать те хорошие интерфейсы, которые уже созданы за вас. Вы таким образом засоряете свой интерфейс и в итоге можете принести больше вреда, чем пользы. Не бойтесь также реализовывать интерфейсы стандартных коллекций. Даже для Map это совсем не сложно, а уж для List и подавно. В java.util есть вспомогательные классы вроде AbstractList, которые помогут вам. | https://habr.com/ru/post/150448/ | null | ru | null |
# Dock панель для сайта. Выбор подходящего jQuery плагина и руководство по установке
#### Красота спасет мир
Обладатели компьютеров Apple давно пользуются красивой и удобной dock панелью. В отличие от этих счастливчиков, я вырос глубоко в сибири и до недавнего времени видел Мак исключительно на картинках.
Но несмотря на это, о dock панели я все же узнал, хоть и случайно, из статьи в одном журнале за 2003 год о dock панелях для Windows. Я поигрался с предложенной программой пару дней, а потом удалил и навсегда забыл о ней. Панель безусловно произвела на меня впечатление приятной внешностью, но все же не несла для меня ощутимой практической пользы.
#### Дальше — по существу.
За все прошедшее время мне ни разу не пришлось вспоминать об этом небольшом опыте, пока не пришел «заказ» на добавление подобной панели в очередной разрабатываемый вебсайт. Так как библиотека jQuery уже использовалась на этом сайте, я интуитивно начал поиск нужного плагина. Интуиция не подвела, было обнаружено множество внешне не отличимых друг от друга «примочек». Осталось выбрать один единственный вариант и привинтить к странице.
Приведу краткий обзор найденного, расскажу, чем я руководствовался при выборе и дам инструкции по установке выбранного мной плагина.
Плагины практически не различаются по своему устройству, возможностям и внешнему виду, поэтому критерии выбора определились так:
* Размер подключаемого скрипта и, если необходимо, стилей.
* Максимально упрощенное дефолтное оформление, ввиду специфичного дизайна сайта, .
* Простота установки и настройки.
* Нормальная работа при кастомизации.
#### Посмотрим, что мы имеем.
Расскажу только о трех популярных плагинах, так как другие либо сильно на них похожи, либо не удовлетворяют каким-то требованиям. И как я уже говорил, нужна была реализация на jQuery, поэтому другие варианты не рассматривались.
##### jqDock
* [Домашняя страница](http://www.wizzud.com/jqDock/), на ней же и живые примеры использования, в нескольких вариантах, и документация на английском.
* [Отсюда](http://plugins.jquery.com/files/jqDock.v1_4.zip) можно загрузить.
Это видоизмененный и доработанный **iconDock**, о котором я пойдет речь чуть ниже. Автора мне найти не удалось.
Судя по поисковой выдаче и обсуждениям на форумах, это самый популярный плагин. Сразу предоставляет разные варианты расположения на странице и выравнивания значков относительно самой панели. Есть инструкции по установке и настройке поведения плагина.
Почему-то на сайте недоступны примеры CSS, необходимые для правильного отображения и работы (может быть, это временная проблема). Недолгие ковыряния в исходниках готовых примеров не дали положительного результата, а самому изучать элементы и писать стили не хотелось, поэтому плагин так и не удалось заставить правильно работать и выполнять главную функцию — быть красивым. Хотя, конечно, потратив больше времени, можно его наладить.
##### CSS Dock Menu от N.Design Studio
* [Домашняя страница](http://www.ndesign-studio.com/blog/design/css-dock-menu) с описанием на английском.
* [Живой пример](http://www.ndesign-studio.com/demo/css-dock-menu/css-dock.html)
* [Архив](http://www.ndesign-studio.com/file/css-dock-menu.zip) с плагином, примерами и некоторыми иконками.
Это реализация dock панели от N.Design Studio с помощью плагина [Interface](http://interface.eyecon.ro/)
Понравился внешний вид, достаточно гармоничный и проработанный. Довольно легко встраивается в страницу.
Панель по умолчанию фиксированная, «прилипает» либо к верху, либо к низу страницы. Такой вариант меня не устраивал, но попытки расположить панель в любом другом месте ломали ее, вид портился и работа плагина нарушалась.
На мой взгляд, отличный вариант, если нужна привязанная к краю панель. На странице с описанием дают простую и понятную инструкцию, хоть и на английском.
##### iconDock
* [Домашняя страница](http://icon.cat/software/iconDock/) с описанием и инструкциями на английском.
* [Живой пример.](http://icon.cat/software/iconDock/0.8b/dock.html)
* [Прямая ссылка](http://icon.cat/software/iconDock/0.8b/jquery.dock-0.8b.js) на сжатую версию скрипта.
Как я писал выше, на основе этого плагина был написан плагин jqDock. Автор Isaac Roca.
Самый простой и понятный для установки и настройки плагин. Всего один файл скрипта (5KB), никаких CSS, всё можно настроить в индивидуальном порядке, по своему вкусу. Простые, немногочисленные параметры для настройки не дадут запутаться.
Размещение панели в нужном мне месте на странице не вызвало проблем. Поигрался с настройками и оформлением — все работает так, как хочется.
Остановлюсь здесь подробнее.
#### Инструкция по установке iconDock jQuery plugin
##### Шаг 1-й.
Подготавливаем по две картинки для каждой иконки, называем их image\_x.jpg и image\_y.jpg (это может быть и png и gif), где x — минимальный изначальный размер, а y — максимальный размер, до которого будет растягиваться иконка.
##### Шаг 2-й.
Создаем DOM элемент (HTML тэг — контейнер), прописыаем ему id, и складываем внутри него все картинки в виде ![](), все картинки должны находиться внутри тега .
`[](http://siknus.com/1 "Google alertes")
[](http://siknus.com/2 "Google Escriptori")
[](http://siknus.com/3 "Google compres")
[](http://siknus.com/4 "Google mail")
[](http://siknus.com/5 "Google grups")`
##### Шаг 3-й.
Скачиваем плагин iconDock (по ссылке выше), скачиваем необходимую библиотеку [jQuery](http://jquery.com/).
Подключаем эти скрипты. Для этого добавляем внутри тега две строчки:
##### Шаг 4-й.
Собственно, включаем панель с помощью метода jQuery('#idOfTheSelectedElement').addDockEffect(confObject);
Для этого после предыдущих строк добавляем:
Жирным шрифтом выделены настройки, которые можно менять:
**iconMinSide**: размер маленькой картинки, рекомендуется 20 — 50 px (у меня 90 без проблем).
**iconMaxSide**: размер большой катинки, рекомендуется 70 — 140 px (180 без проблем).
**distAttDock**: включается эффект при приближении курсора на это расстояние, рекомендуется выставлять треть от размера всей панели в «спокойном» состоянии.
**veloOutDock**: время в милисекундах, задержка после того, как курсор покидает зону действия, рекомендуется 500 — 2000 мс.
**valign**: выравнивание картинок относительно панели, может принимать значения 'top', 'bottom' or 'middle'.
##### Желаю успехов.
**UPD:** По [наводке](http://messersveet.habrahabr.ru/blog/95877/#comment_2981687) я решил попробовать видоизменить и дополнить имеющийся функционал. Попробую добавить вложенные иконки и динамические информационные доклеты. | https://habr.com/ru/post/95877/ | null | ru | null |
# Подключаем Facebook SDK для Xamarin.Forms
Социальные сети, и особенно Facebook, уже давно используются в мобильных приложениях. Сегодня мы рассмотрим, как подключить нативные Facebook SDK к проекту на базе Xamarin.Forms (iOS и Android) для удобной авторизации пользователей и получения о них базовой информации. Вы также легко сможете расширить описанные в статье методы для того, чтобы реализовать полноценное взаимодействие с этим замечательным сервисом. Тема простая и понятная, поэтому без теорий и прелюдий перейдем сразу к практике.
Создаем приложение в Facebook
-----------------------------
Для тех, кто впервые создает своё приложение в Facebook, мы кратко расскажем о том, как это делается.
Сам по себе процесс это довольно простой и потребует от вас следующих данных:
* Package Name для Android-проекта (например, `com.binwell.login`)
* Bundle Identifier для iOS-проекта (например, `com.binwell.login`)
Для Android ещё потребуются Key Hashes, которые можно получить командой:
Windows:
```
keytool -exportcert -alias androiddebugkey -storepass android -keystore C:\Users\[USERNAME]\AppData\Local\Xamarin\Mono for Android\debug.keystore | openssl sha1 -binary | openssl base64
```
macOS:
```
keytool -exportcert -alias androiddebugkey -storepass android -keystore /Users/[USERNAME]/.local/share/Xamarin/Mono for Android/debug.keystore | openssl sha1 -binary | openssl base64
```
Вместо `[USERNAME]` необходимо подставить ваше имя пользователя в системе. Плюс можно прописать путь до `openssl`, если путь до него не указан в `PATH`. Скачать `openssl` для Windows можно [здесь](http://gnuwin32.sourceforge.net/packages/openssl.htm).
На выходе мы и получим нужные `Key Hashes` следующего вида: `kGP2WMxohvxm/NiwR7H+Eb3/8qw=`
Теперь заходим на [developers.facebook.com](https://aka.ms/habr_321454_1) и создаём новое приложение. Отдельно для iOS и Android. При создании приложения мы можем использовать режим с подсказками (Quick Start), где дополнительно описано как настроить проект. Из этого руководства нам и потребуются примеры кода.
Подключаем Facebook SDK к проектам iOS и Android
------------------------------------------------
Для начала необходимо установить пакеты Facebook SDK от Xamarin для iOS и Android из Nuget:
Обратите внимание, что с Xamarin.Forms 2.3 на текущий момент совместима только версия Xamarin.Facebook.Android 4.11.0.1. Версия Xamarin.Facebook.iOS ограничений по совместимости не имеет.
#### Подключаем в Android
Для начала нам необходимо прописать специальные значения в файле `Resources/values/strings.xml`:
```
1102463466549096
fb1102463466549096
```
Где, `1102463466549096` это ваш App ID из настроек приложения Facebook. Дополнительно нам потребуется внести следующие изменения в `AndroidManifest.xml`:
```
```
Далее вносим небольшие доработки в `MainActivity.cs`:
```
protected override void OnCreate(Bundle bundle)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(bundle);
FacebookSdk.SdkInitialize(ApplicationContext);
Forms.Init(this, bundle);
LoadApplication(new App());
}
protected override void OnResume()
{
base.OnResume();
AppEventsLogger.ActivateApp(Application);
}
```
На этом первичная инициализация Facebook SDK завершена.
#### Подключаем в iOS
По аналогии с Android, нам будет необходимо внести правки в файл `Info.plist`, вставить следующие строки между `...`:
```
CFBundleURLTypes
CFBundleURLSchemes
fb1102463466549096
FacebookAppID
1102463466549096
FacebookDisplayName
Binwell Social Demo
LSApplicationQueriesSchemes
fbapi
fb-messenger-api
fbauth2
fbshareextension
NSAppTransportSecurity
NSExceptionDomains
facebook.com
NSIncludesSubdomains
NSThirdPartyExceptionRequiresForwardSecrecy
fbcdn.net
NSIncludesSubdomains
NSThirdPartyExceptionRequiresForwardSecrecy
akamaihd.net
NSIncludesSubdomains
NSThirdPartyExceptionRequiresForwardSecrecy
```
И немного кода в `AppDelegate.cs`:
```
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
Xamarin.Forms.Forms.Init();
LoadApplication(new App());
Facebook.CoreKit.Profile.EnableUpdatesOnAccessTokenChange(true); Facebook.CoreKit.ApplicationDelegate.SharedInstance.FinishedLaunching(app, options);
return base.FinishedLaunching(app, options);
}
public override bool OpenUrl(UIApplication application, NSUrl url, string sourceApplication, NSObject annotation)
{
return Facebook.CoreKit.ApplicationDelegate.SharedInstance.OpenUrl(application, url, sourceApplication, annotation);
}
public override void OnActivated(UIApplication application)
{
Facebook.CoreKit.AppEvents.ActivateApp();
}
```
На этом предварительная подготовка завершена и мы можем переходить к использованию Facebook SDK в нашем приложении.
Интегрируем с Xamarin.Forms
---------------------------
Использовать Facebook SDK мы будем через механизм `DependencyService`. Для этого в первую очередь опишем нужные данные и интерфейс сервиса:
```
public interface IFacebookService
{
Task Login();
void Logout();
}
public enum LoginState
{
Failed,
Canceled,
Success
}
public class LoginResult
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string Email { get; set; }
public string ImageUrl { get; set; }
public string UserId { get; set; }
public string Token { get; set; }
public DateTimeOffset ExpireAt { get; set; }
public LoginState LoginState { get; set; }
public string ErrorString { get; set; }
}
```
Одной из целей подключения социальных сетей является возможность простого и удобного получения пользовательских данных, поэтому нам потребуется дополнительный запрос для получения email, который Facebook не отдает по умолчанию. Данные запросы будет необходимо реализовать отдельно для каждой платформы.
#### Реализация для Android
Для Android реализация интерфейса выглядит следующим образом:
```
[assembly: Dependency(typeof(AndroidFacebookService))]
namespace Login.Droid
{
public class AndroidFacebookService: Java.Lang.Object, IFacebookService, GraphRequest.IGraphJSONObjectCallback, GraphRequest.ICallback, IFacebookCallback
{
public static AndroidFacebookService Instance => DependencyService.Get() as AndroidFacebookService;
readonly ICallbackManager \_callbackManager = CallbackManagerFactory.Create();
readonly string[] \_permissions = { @"public\_profile", @"email", @"user\_about\_me" };
LoginResult \_loginResult;
TaskCompletionSource \_completionSource;
public AndroidFacebookService()
{
LoginManager.Instance.RegisterCallback(\_callbackManager, this);
}
public Task Login()
{
\_completionSource = new TaskCompletionSource();
LoginManager.Instance.LogInWithReadPermissions(Forms.Context as Activity, \_permissions);
return \_completionSource.Task;
}
public void Logout()
{
LoginManager.Instance.LogOut();
}
public void OnActivityResult(int requestCode, int resultCode, Intent data)
{
\_callbackManager?.OnActivityResult(requestCode, resultCode, data);
}
public void OnCompleted(JSONObject data, GraphResponse response)
{
OnCompleted(response);
}
public void OnCompleted(GraphResponse response)
{
if (response?.JSONObject == null)
\_completionSource?.TrySetResult(new LoginResult {LoginState = LoginState.Canceled});
else
{
\_loginResult = new LoginResult
{
FirstName = Profile.CurrentProfile.FirstName,
LastName = Profile.CurrentProfile.LastName,
Email = response.JSONObject.Has("email") ? response.JSONObject.GetString("email") : string.Empty,
ImageUrl = response.JSONObject.GetJSONObject("picture")?.GetJSONObject("data")?.GetString("url"),
Token = AccessToken.CurrentAccessToken.Token,
UserId = AccessToken.CurrentAccessToken.UserId,
ExpireAt = FromJavaDateTime(AccessToken.CurrentAccessToken?.Expires?.Time),
LoginState = LoginState.Success
};
\_completionSource?.TrySetResult(\_loginResult);
}
}
public void OnCancel()
{
\_completionSource?.TrySetResult(new LoginResult { LoginState = LoginState.Canceled });
}
public void OnError(FacebookException exception)
{
\_completionSource?.TrySetResult(new LoginResult
{
LoginState = LoginState.Failed,
ErrorString = exception?.Message
});
}
public void OnSuccess(Java.Lang.Object result)
{
var facebookLoginResult = result.JavaCast();
if (facebookLoginResult == null) return;
var parameters = new Bundle();
parameters.PutString("fields", "id,email,picture.type(large)");
var request = GraphRequest.NewMeRequest(facebookLoginResult.AccessToken, this);
request.Parameters = parameters;
request.ExecuteAsync();
}
static DateTimeOffset FromJavaDateTime(long? longTimeMillis)
{
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
return longTimeMillis != null ? epoch.AddMilliseconds(longTimeMillis.Value) : DateTimeOffset.MinValue;
}
}
}
```
Дополнительно потребуется добавить обработчик в `MainActivity.cs`:
```
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
AndroidFacebookService.Instance.OnActivityResult(requestCode, (int)resultCode, data);
}
```
#### Реализация для iOS
Делаем реализацию интерфейса для Facebook iOS SDK.
```
[assembly: Dependency(typeof(AppleFacebookService))]
namespace Login.iOS
{
public class AppleFacebookService: IFacebookService
{
readonly LoginManager _loginManager = new LoginManager();
readonly string[] _permissions = { @"public_profile", @"email", @"user_about_me" };
LoginResult _loginResult;
TaskCompletionSource \_completionSource;
public Task Login()
{
\_completionSource = new TaskCompletionSource();
\_loginManager.LogInWithReadPermissions(\_permissions, GetCurrentViewController(), LoginManagerLoginHandler);
return \_completionSource.Task;
}
public void Logout()
{
\_loginManager.LogOut();
}
void LoginManagerLoginHandler(LoginManagerLoginResult result, NSError error)
{
if (result.IsCancelled)
\_completionSource.TrySetResult(new LoginResult {LoginState = LoginState.Canceled});
else if (error != null)
\_completionSource.TrySetResult(new LoginResult { LoginState = LoginState.Failed, ErrorString = error.LocalizedDescription });
else
{
\_loginResult = new LoginResult
{
Token = result.Token.TokenString,
UserId = result.Token.UserID,
ExpireAt = result.Token.ExpirationDate.ToDateTime()
};
var request = new GraphRequest(@"me", new NSDictionary(@"fields", @"email"));
request.Start(GetEmailRequestHandler);
}
}
void GetEmailRequestHandler(GraphRequestConnection connection, NSObject result, NSError error)
{
if (error != null)
\_completionSource.TrySetResult(new LoginResult { LoginState = LoginState.Failed, ErrorString = error.LocalizedDescription });
else
{
\_loginResult.FirstName = Profile.CurrentProfile.FirstName;
\_loginResult.LastName = Profile.CurrentProfile.LastName;
\_loginResult.ImageUrl = Profile.CurrentProfile.ImageUrl(ProfilePictureMode.Square, new CGSize()).ToString();
var dict = result as NSDictionary;
var emailKey = new NSString(@"email");
if (dict != null && dict.ContainsKey(emailKey))
\_loginResult.Email = dict[emailKey]?.ToString();
\_loginResult.LoginState = LoginState.Success;
\_completionSource.TrySetResult(\_loginResult);
}
}
static UIViewController GetCurrentViewController()
{
var viewController = UIApplication.SharedApplication.KeyWindow.RootViewController;
while (viewController.PresentedViewController != null)
viewController = viewController.PresentedViewController;
return viewController;
}
}
}
```
#### Подключаем в Xamarin.Forms
Для доступа к созданным реализациям достаточно вставить следующий обработчик события `Clicked` для кнопки «Facebook Login»:
```
var loginResult = await DependencyService.Get().Login();
switch (loginResult.LoginState)
{
case LoginState.Canceled:
// Обработать
break;
case LoginState.Success:
var str = $"Hi {loginResult.FirstName}! Your email is {loginResult.Email}";
break;
default:
// Обработать ошибки
break;
}
```
На этом кодирование завершено!
Используем
----------
Итак, волнительный момент. Делаем сборку, запускаем и… легко авторизуемся с помощью нативных SDK.
Полный код проекта с пошаговыми изменениями расположен в [репозитории на Bitbucket](https://aka.ms/habr_321454_2).
Итак, сегодня мы подключили нативные Facebook SDK к приложению на Xamarin.Forms. Уже работает авторизация и получение базовой информации о пользователе, но при желании вы можете легко расширить набор методов для доступа ко всем возможностям Facebook SDK. В следующий раз мы возьмем задачку поинтересней и подключим нативные ВКонтакте SDK.
Оставайтесь на связи, задавайте ваши вопросы в комментариях и вступайте в группу [Xamarin Developers](https://aka.ms/habr_321454_3) в Telegram!
### Об авторе
 Вячеслав Черников — руководитель отдела разработки компании [Binwell](https://aka.ms/habr_321454_4). В прошлом — один из Nokia Champion и Qt Certified Specialist, в настоящее время — специалист по платформам Xamarin и Azure. В сферу mobile пришел в 2005 году, с 2008 года занимается разработкой мобильных приложений: начинал с Symbian, Maemo, Meego, Windows Mobile, потом перешел на iOS, Android и Windows Phone.
**Другие статьи автора:**
* [Авторизация OAuth для Xamarin-приложений](https://habrahabr.ru/company/microsoft/blog/332970)
* [Деплоим мобильный софт с помощью devops-конвейера Microsoft](https://habrahabr.ru/company/microsoft/blog/329908/)
* [DevOps на службе человека](https://habrahabr.ru/company/microsoft/blog/325184/)
* [Автоматизируем неавтоматизируемое, или про Xamarin в реальных проектах](https://habrahabr.ru/company/microsoft/blog/327900/)
* [Удобный REST для Xamarin-приложений](https://habrahabr.ru/company/microsoft/blog/310704/)
* [Быстрое создание MVP (minimum viable product) на базе Microsoft Azure и Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/281897/)
* [Готовим Xamarin.Forms: настройка окружения и первые шаги](https://habrahabr.ru/company/microsoft/blog/303630/)
* [Повышаем эффективность работы в Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/304678/)
* [Работаем с состояниями экранов в Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/307890/)
* [Подключаем ВКонтакте SDK для Xamarin.Forms](https://habrahabr.ru/company/microsoft/blog/323296/) | https://habr.com/ru/post/321454/ | null | ru | null |
# Raphaël
Привет, Хабр
------------
В этом коротком очерке хотел бы рассказать о маленькой (по словам авторов) библиотеки на JavaScript — Raphaël. Данная библиотека использует для работы SVG и VML и служит, как не сложно догадаться для облегчения работы с векторная графикой в вебе.
Так же по утверждению создателей работает во всех актуальных на даных момент браузерах, а именно Firefox 3.0+, Safari 3.0+, Opera 9.5+ and Internet Explorer 6.0+. К сожалению обошли создатели внимание вторую лису, хотя сюда по данным лайвинтернета на ней приходится почти 2% пользователей, что вообще немало. ~~Да, и не смотря на то, что Хром не заявлен, в нем тоже все работает как часы.~~
Вообще, на сайте [библиотеки](http://raphaeljs.com/) предельно понятным языком написано что она для чего она и как она. Но коротко остановимся на этом
Для начала нам необходимо создать канвас объект (его мы привязываем к объекту DOM указывая ширину и высоту, или же указываем только координаты левого верхнего угла будущего объекта)
> `// Each of the following examples create a canvas that is 320px wide by 200px high
>
> // Canvas is created at the viewport's 10,50 coordinate
>
>
> var paper = Raphael(10, 50, 320, 200);
>
> // Canvas is created at the top left corner of the #notepad element (or its top right corner in dir="rtl" elements)
>
>
> var paper = Raphael(document.getElementById("notepad"), 320, 200);
>
> // Same as above
>
>
> var paper = Raphael("notepad", 320, 200);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее мы можем создавать любые графические примитивы, вызывая соответствующие методы объекта paper. Название методов одноименны с графическими примитивами которыми мы оперируем в рамках стандарта SVG (это например rect circle lineи т.д.) Вот например так создаем прямоугольник
> `var paper = Raphael(document.getElementById("notepad"), 320, 200);
>
> paper.rect(0, 0, 640, 480, 10).attr({fill: "#fff", stroke: "none"});
>
> \* This source code was highlighted with Source Code Highlighter.`
Не будем тут останавливатся на долго, об этом подробнейшим образом написано в [документации](http://raphaeljs.com/reference.html).
Не маловажным плюсов всего этого хозяйства явлется то, что с любым графическим элементом мы можем свзязать события, подобно тому как связываем их с любым DOM объектом, мне показалось это весьма полезным, учитывая что библиотека некоторое время шла бок о бок с фреймворком jquery, работы с элементами графика становилась практически тривиальной.
**Итого:**Получаем кроссбраузерное решение вечного спора canvas с VML, возможность работать с элементами графики как с объектами DOM, и хорошую документацию библиотки (не смотря на то, что она на английском языке, все предельно ясно, хотя, думаю, если кто-то у кого с языками получше возьмется перевести — сообщество ему только спасибо скажет). Разработка получается действительно быстрой, вот например на написание [этого](http://bnet.su/dvl/svg/) (просто для примера и собственного изучения) ушло не более получаса.
**UPD**
[](http://raphaeljs.com/dragon.html)
А вот векторный дракон (из примеров на сайте) пример из области «вот так мы можем, но никогда так не делайте» браузер долго думал… (картинка-скрин, по клику векторная)
**UPD2** В хроме drag&drop работает криво | https://habr.com/ru/post/59386/ | null | ru | null |
# TiKV — распределённая база данных key-value для cloud native
28 августа организация CNCF (Cloud Native Computing Foundation), стоящая за Kubernetes, Prometheus и другими Open Source-проектами для современных облачных приложений, [объявила](https://www.cncf.io/blog/2018/08/28/cncf-to-host-tikv-in-the-sandbox/) о принятии нового продукта в свою «песочницу» — [**TiKV**](https://github.com/tikv/tikv).
Эта распределённая, транзакционная база данных типа ключ-значение зародилась как дополнение к [**TiDB**](https://github.com/pingcap/tidb) — распределённой СУБД, которая предлагает возможности OLTP и OLAP и обеспечивает совместимость с протоколом MySQL… Но давайте обо всём по порядку.
TiDB как родитель
-----------------
Начнём с «родительского» проекта TiDB, созданного китайской компанией PingCAP Inc.
Первый крупный публичный релиз этой СУБД — 1.0 — [состоялся](https://www.nixp.ru/news/14205.html) меньше года назад. Главные её особенности — «гибридность», совмещающая транзакционную и аналитическую обработку данных (Hybrid Transactional/Analytical Processing, HTAP), а также уже упомянутая совместимость с протоколом MySQL. Более полная картина TiDB возникает при упоминании других — уже обыденных для новых СУБД — фич, таких как горизонтальная масштабируемость, высокая доступность и строгое соответствие ACID.
Общая архитектура TiDB представляется следующим образом:
Поскольку TiDB предлагает масштабируемость NoSQL и гарантии по ACID, её относят к категории **NewSQL**. Авторы не скрывают, что создавали продукт под вдохновением от других представителей NewSQL: [Google Spanner](https://en.wikipedia.org/wiki/Spanner_(database)) и [F1](https://ai.google/research/pubs/pub38125). Однако китайские разработчики настаивали на «своих лучших практиках и решениях при выборе технологий». В частности, они выбрали алгоритм для решения задач консенсуса [**Raft**](https://raft.github.io/) (вместо [Paxos](https://en.wikipedia.org/wiki/Paxos_(computer_science)), что используется в Spanner), хранилище [**RocksDB**](https://rocksdb.org/) (вместо распределённой файловой системы), а в качестве языка программирования — Go (и Rust).
Многие подробности об устройстве TiDB можно найти в докладе «[How we build TiDB](https://pingcap.com/blog/2016-10-17-how-we-build-tidb/)» от соучредителя и генерального директора PingCAP — Max Liu, — а к некоторым из них, тесно связанным с TiKV, мы ещё вернёмся. Исходный код TiDB [распространяется](https://github.com/pingcap/tidb) под свободной лицензией Apache License v2. Среди её [крупных пользователей](https://github.com/pingcap/docs/blob/master/adopters.md) упоминаются Lenovo, Meizu, Bank of Beijing, Industrial and Commercial Bank of China и др.
Что же такое TiKV и какую роль играет в мире TiDB (и не только)?
Архитектура и особенности TiKV
------------------------------
Вернёмся к общей архитектуре TiDB, в чуть ином её представлении:
Можно увидеть, что сама TiDB обеспечивает реализацию SQL и совместимость с MySQL\*, а остальную работу поручает кластеру TiKV. Что же это за «остальная работа»? Вот более подробная схема:
**\* В двух картинках о прослойке совместимости с MySQL в TiDB.**Преобразование таблиц в key-value происходит так, что из запросов:
```
INSERT INTO user VALUES (1, "bob", "huang@pingcap.com");
INSERT INTO user VALUES (2, "tom", "tom@pingcap.com");
```
… получаются:
Индексы в TiDB — обычные пары, значения в которых указывают на строку с данными:
Пояснения к схеме TiKV:
* **KV API** — набор программных интерфейсов для записи/чтения данных;
* **Coprocessor** — фреймворк сопроцессора для поддержки распределённых вычислений (сравнивается с аналогичным у HBase);
* **Transaction** — транзакционная модель, похожая на [Google Percolator](https://ai.google/research/pubs/pub36726) (протокол коммитов в 2 фазы; использует timestamp allocator; см. также [сравнение со Spanner](https://blog.yugabyte.com/implementing-distributed-transactions-the-google-way-percolator-vs-spanner/));
* **MVCC** (MultiVersion Concurrency Control) для обеспечения чтения без блокировок и ACID-транзакций (данные тегируются версиями; любые изменения, сделанные в текущей транзакции, не видны другим транзакциям до момента коммита);
* **Raft KV** — уже упомянутый алгоритм Raft, используемый для горизонтального масштабирования и консистентности данных; его реализация на языке Rust портирована из etcd (проверена обширной эксплуатацией); к слову, авторами TiKV заявлена «простая масштабируемость до 100+ Тб данных»;
* **RocksDB** — локальное хранилище типа ключ-значение, тоже уже хорошо зарекомендовавшее себя в масштабных проектах в production (Facebook);
* **Placement Driver** — «мозг» кластера, созданный по концепту из Google Spanner и отвечающий за хранение метаданных о регионах, поддержку нужного количества реплик, равномерное распределение нагрузок (с помощью Raft).
Если обобщить взаимосвязи основных компонентов, то получится следующее:
* У каждого **узла** кластера TiKV есть одно или несколько **хранилищ** (RocksDB).
* У каждого хранилища есть множество **регионов**.
* Регион является «базовой единицей движения данных key-value», реплицируется (с помощью Raft) на множество узлов. Такие наборы реплик образуют **группы Raft**.
* Наконец, управляющий этим кластером Placement Driver, как видно, и сам является кластером.
Установка и тестирование TiKV
-----------------------------
Кодовая база TiKV написана преимущественно на Rust, но имеет и несколько сторонних компонентов на других языках (RocksDB на C++ и gRPC на Go). [Распространяется](https://github.com/tikv/tikv) под той же свободной лицензией Apache License v2.
Как уже говорилось в начале статьи, TiKV изначально появился как важная составляющая TiDB, но на сегодняшний день может эксплуатироваться как в рамках этой СУБД, так и отдельно. (Но в любом случае для её работы потребуется [Placement Driver](https://github.com/pingcap/pd), написанный на Go и распространяемый как отдельный компонент).
Самая короткая [инструкция](https://pingcap.com/docs/QUICKSTART/) для **запуска TiKV вместе с СУБД TiDB** требует наличия Git, Docker (17.03+), Docker Compose (1.6.0+), MySQL Client и сводится к следующей:
```
git clone https://github.com/pingcap/tidb-docker-compose.git
cd tidb-docker-compose && docker-compose pull
docker-compose up -d
```
Результатом выполнения этих команд станет развёртывание кластера TiDB, по умолчанию состоящего из следующих компонентов:
* 1 экземпляр собственно TiDB;
* 3 экземпляра TiKV;
* 3 экземпляра Placement Driver;
* Prometheus и Grafana *(для мониторинга и графиков)*;
* 2 экземпляра (мастер + слейв) [TiSpark](https://github.com/pingcap/tispark) *(прослойка для запуска Apache Spark поверх TiDB/TiKV для выполнения сложных OLAP-запросов)*;
* 1 экземпляр [TiDB-Vision](https://github.com/pingcap/tidb-vision) *(для визуализации работы Placement Driver)*.
Дальнейшая работа с развёрнутой СУБД:
* подключение через MySQL-клиент: `mysql -h 127.0.0.1 -P 4000 -u root`;
* веб-интерфейс Grafana для просмотра состояния кластера — `http://localhost:3000` под admin/admin;
* веб-интерфейс TiDB-Vision для информации о балансировке нагрузки в кластере и миграции данных по узлам — `http://localhost:8010`;
* веб-интерфейс Spark — `http://localhost:8080` (доступ к TiSpark — через `spark://127.0.0.1:7077`).
Если же хочется **не совсем стандартного кластера TiDB** (т.е. изменить его размеры, используемые Docker-образы, порты и т.п.), то после клонирования репозитория [tidb-docker-compose](https://github.com/pingcap/tidb-docker-compose) можно отредактировать конфиг для Docker Compose:
```
$ cd tidb-docker-compose
$ vi compose/values.yaml
$ helm template compose > generated-docker-compose.yaml
$ docker-compose -f generated-docker-compose.yaml pull
$ docker-compose -f generated-docker-compose.yaml up -d
```
Для ещё большей кастомизации — см. «[Customize TiDB Cluster](https://github.com/pingcap/tidb-docker-compose#customize-tidb-cluster)», где описана информация, откуда берутся конфиги для TiDB, TiKV, Placement Driver и другая специфика.
Для удобного **деплоя TiDB в кластер Kubernetes** подготовлен одноимённый оператор — [TiDB Operator](https://github.com/pingcap/tidb-operator). Он есть в Helm-чартах, поэтому установка может быть сведена к следующим командам (слайд из [презентации](https://zhuanlan.zhihu.com/p/35048966) на TiDB DevConf 2018):
К слову, в той же презентации говорится о взгляде разработчиков TiDB на мониторинг этой СУБД. Текстовое описание, к сожалению, на китайском языке, но общее представление можно получить из этих слайдов:
Возвращаясь же к теме непосредственно TiKV — у этого проекты опубликованы свои руководства по запуску для тестовых целей:
* [вместе с TiDB](https://www.pingcap.com/docs/op-guide/docker-compose/);
* отдельно:
+ [с Docker Compose](https://www.pingcap.com/docs/tikv/deploy-tikv-docker-compose/);
+ [с Docker](https://www.pingcap.com/docs/tikv/deploy-tikv-using-docker/);
+ [как бинарник](https://www.pingcap.com/docs/tikv/deploy-tikv-using-binary/).
А для **деплоя TiKV в production** есть готовые наработки с Ansible — опять же, [с TiDB](https://www.pingcap.com/docs/op-guide/ansible-deployment/) и [без неё](https://www.pingcap.com/docs/tikv/deploy-tikv-using-ansible/).
Наконец, в качестве интерфейсов для работы с TiKV предлагаются:
* [клиент TiDB на Go](https://github.com/pingcap/tidb/tree/master/store/tikv);
* [Java-клиент TiSpark](https://github.com/pingcap/tispark/tree/master/tikv-client/src/main/java/com/pingcap/tikv);
* [два типа API для Go](https://www.pingcap.com/docs/tikv/go-client-api/).
В [планах разработчиков](https://github.com/tikv/tikv/blob/master/docs/ROADMAP.md) также значится создание клиента на Rust.
Итоги
-----
Зародившись как компонент более крупного Open Source-проекта китайской компании, TiKV уже успел завоевать известность в достаточно широких кругах. [Статистика GitHub](https://github.com/tikv/tikv/pulse) свидетельствует не только о 3600+ звёздах, но и почти 500 форках, и почти 100 контрибьюторах (хотя более 10 коммитов сделали лишь два десятка из них).
Присоединение TiKV к числу [проектов CNCF](https://www.cncf.io/projects/) и тот факт, что это первый проект подобного типа, тоже однозначно указывают на признание продукта сообществом cloud native… и должно придать импульс более активному развитию его кодовой базы сторонними (т.е. вне компании-основателя и её СУБД) специалистами.
P.S.
----
Читайте также в нашем блоге:
* «[Знакомство с СУБД CockroachDB и создание отказоустойчивого кластера с ней на Ubuntu 16.04](https://habr.com/company/flant/blog/327640/)»;
* «[Rook — „самообслуживаемое“ хранилище данных для Kubernetes](https://habr.com/company/flant/blog/348044/)»;
* «[Ускоряем bootstrap больших баз данных с помощью Kubernetes](https://habr.com/company/flant/blog/417509/)»;
* «[Путеводитель CNCF по решениям Open Source (и не только) для cloud native](https://habr.com/company/flant/blog/350928/)»;
* «[Операторы для Kubernetes: как запускать stateful-приложения](https://habr.com/company/flant/blog/326414/)». | https://habr.com/ru/post/421903/ | null | ru | null |
# Собственный «Кто звонил?» на базе Мультифона
На какие вопросы вы найдёте ответы в этой статье:
* как отправлять USSD через GSM/3G/4G-модем и читать ответы;
* как отправлять SMS через Мультифон;
* как использовать Яндекс SpeechKit в автоответчике на Asterisk.
На какие вопросы вы не найдёте ответов:
* зачем нужен собственный «Кто звонил?».
Все понимают механизм сервиса, аналогичного «Кто звонил?»: по недоступности звонок уходит на специальный номер, там его принимают, сообщают звонящему, что абонент недоступен, и отправляют абоненту СМС с информацией о звонке. В приёме звонка с Мультифона на Астериске никаких тонкостей нет.
**Вкратце**Регистрация:
```
register => 79xxxxxxxxx@multifon.ru::79xxxxxxxxx@sbc.megafon.ru/79xxxxxxxxx
```
Транк:
```
[multifon](!)
type=peer
insecure=port,invite
host=sbc.megafon.ru
fromdomain=multifon.ru
context=from_multifon
dtmfmode=inband
[multifon-in](multifon)
; Если мы ещё и звонить хотим
[multifon-out](multifon)
defaultuser=79xxxxxxxxx
fromuser=79xxxxxxxxx
secret=
```
Первый вопрос, который встал передо мной в полный рост…
Как отправить СМС?
------------------
Самый простой путь, конечно же, купить человеческий HTTP API у какого-нибудь гейта и задёшево отправлять через него. Но во-первых, это неспротивно. А во-вторых, у меня на тарифе несколько сотен СМС включено в абонплату, и с телефона я их почти не отправляю.
Перепробовав все возможные варианты с [MessageSend](http://www.voip-info.org/wiki/view/Asterisk+cmd+MessageSend) (и через диалплан, и через АМИ, и через чёрта лысого), а также помурыжив [SipSak](http://www.voip-info.org/wiki/view/Sipsak), я сдался и попробовал [скрипт для Yate](https://github.com/vir/yate/wiki/Multifon-sms).
О чудо! СМС через Мультифон отправляются.
Но Yate – слишком тяжеловесный движок, подумал я. Yate должен крутиться демоном и требует совершенно избыточной для этих задач конфигурации, подумал я. Поэтому, изучив перловый скрипт, я вычленил из него главное и вернулся к сипсаку. Главным оказался набор нестандартных заголовков (включая обязательного совершенно определённого юзер-агента, ага):
```
User-Agent: MCPC-MG-1-0-34-3490/2.0.0.5301
X-Movial-Content: sms/text
X-Movial-DeliveryReport: true
Content-Type: text/plain; charset=ISO-10646-UCS-2
```
Кстати, кастомный юзер-агент, насколько я понимаю, изначально полностью исключал возможность отправки через Астериск.
На первый взгляд, всё казалось просто. Но сообщения всё равно не уходили. Включив дебаг у сипсака, я понял, что эта скотина имеет набор предопределённых заголовков, которые тупо дублируются, если заданы в командной строке. Пришлось брать в руки напильник.
Обработав сипсак так, чтобы кастомные заголовки он считал приоритетными, а дубли отбрасывал, я добился наконец первого результата. Но моя радость была бы неполной, если бы сипсак корректно кодировал передаваемое сообщение. Расписывать всю эпопею вкостыливания в код, построенный на нуль-терминированных строках, UCS2-BE я не буду, сразу представлю на ваш суд результаты своих трудов: <https://github.com/wolandtel/sipsak>. Сам процесс отправки СМС я обернул в [удобный скрипт](https://github.com/wolandtel/multifon). Для комплекта в последнем репозитории есть скрипт settings.sh, который упрощает настройку пароля и маршрутизации (SIP, GSM+SIP, GSM) на мультифоне.
Ну, вот, отправлять СМС мы умеем. Теперь можно настроить сам…
Автоответчик
------------
Здесь нам поможет [AGI](http://www.voip-info.org/wiki/view/Asterisk+AGI). Скажу сразу, что от природной лени протокол AGI реализовывать я не стал, а лишь сделал в скрипте такую эмуляцию, которая позволяет выполнить задачу. А именно, скрипт должен дождаться от астериска ответа на команду STREAM FILE, чтобы проигрывание не закончилось раньше времени.
**Диалплан**
```
; autoresponder
exten => 79xxxxxxxxx,1,NoOp
same => n,AGI(notify.agi)
same => n,Set(MSG="Абонент умер. Когда воскреснет, может перезвонить. Но хотите ли Вы этого?")
same => n,Answer
; Params: speaker, emotion, robot
; speaker: [мужские]: zahar, ermil; [женские]: jane, omazh.
; emotion: good, neutral, evil, mixed.
; robot: true, false.
same => n,AGI(tts.agi,${MSG},ermil,neutral,true)
same => n,Hangup
```
Можно было, конечно, отправлять СМС из того же скрипта, которым проигрывается сообщение, но с точки зрения структуры приложения логично было их разнести.
**notify.agi**
```
#!/bin/bash
while read line; do
[ -z "$line" ] && break
num=$(echo $line | grep 'agi_callerid: ' | sed 's/agi_callerid: //')
[ -n "$num" ] && break
done < /dev/stdin
[ -z "$num" ] && exit 1
/usr/local/multifon/sms.sh 79xxxxxxxxx "Пропущенный вызов [$(date '+%Y-%m-%d %H:%M:%S')] с номера +$num"
```
Абсолютно никакого AGI, по факту. Просто делаем, что требуется, и закругляемся.
**tts.agi**
```
#!/bin/bash
text="$1"
speaker="$2"
emotion="$3"
robot="$4"
key=
dir=/var/lib/asterisk/tts
url=https://tts.voicetech.yandex.net/generate
dbg=${0/.agi/.log}
fname="$dir/$(echo -n "$text-$speaker-$emotion-$robot" | md5sum | cut -d' ' -f1)"
wav="${fname}.wav"
echo -e "$@" > "$dbg"
while read line; do
echo $line >> "$dbg"
[ -z "$line" ] && break
done < /dev/stdin
[ -f "$wav" ] || /usr/bin/curl -s --data-urlencode "text=$text" \
--data-urlencode format=wav \
--data-urlencode lang=ru-RU \
--data-urlencode "speaker=$speaker" \
--data-urlencode "key=$key" \
--data-urlencode "emotion=$emotion" \
--data-urlencode "robot=$robot" \
"$url" > "$wav" || exit 1
for f in al ul gsm; do
[ -f "${fname}.$f" ] || /usr/bin/sox "$wav" -r8k "${fname}.$f" || exit 2
done
echo -e "STREAM FILE $fname 0"
read line < /dev/stdin
echo $line >> "$dbg"
```
Здесь тоже нет AGI. Мы только дожидаемся ответа от Астериска командой read, чтобы не закрыться раньше, чем он проиграет сообщение. Прошу обратить внимание на параметр **-r8k** для сокса. Почему-то без параметров он неправильно выставляет рейт выходному файлу, и сообщение получается замедленным в два раза. Подробности самого Яндекс SpeechKit API и то, как получить ключ, есть в [документации](https://tech.yandex.ru/speechkit/cloud/doc/dg/concepts/speechkit-dg-tts-docpage/).
Основная часть на этом закончена. Но статья будет неполной без описания нюансов.
Подготовка сим-карты
--------------------
Очевидно, чтобы всё это завелось, потребуется отдельный номер с Мультифоном. Вы покупаете сим-карту и…? Простой и очевидный путь – вставить её в телефон, набрать необходимые запросы и начать использовать. Но мы не ищем лёгких путей. У меня с давних времён валяется пачка 3G-модемов (знаменитый E1550 и чуть менее знаменитые E150), но нет ни одного свободного телефона. А использовать свой для таких операций я не люблю: лишний раз выключать, вскрывать.
Итак, для получения и отправки СМС мы будем использовать давно и хорошо всем известный [smstools](http://smstools3.kekekasvi.com/). Настройку я описывать не буду, ибо боян. Только автодекодинг не включайте. А то будет вам мусор вместо тела сообщения.
Итак, после приобретения сим-карты нужно сделать две вещи:
* получить пароль для личного кабинета (ибо эти бабуины убили Сервис-гид, и теперь для каждого номера требуется собственный логин);
* подключить Мультифон (ибо эти бабуины сломали [веб-интерфейс](https://sm.megafon.ru/sm/), и без USSD не обойтись).
И если с приёмом СМС всё понятно, то USSD – не такая прозрачная вещь.
Перед тем, как продолжить, можете ознакомиться с [репозиторием](https://github.com/wolandtel/smstools) дополнений к smstools, облегчающих работу с SMS и USSD. В разделе example репозитория есть перловый инструмент работы с USSD, который я использовал для понимания сути кодирования/декодирования символов в USSD. Авторство не указано, и ссылок нет потому, что я не помню, где его взял. Можно использовать его, но лично я не понимаю perl, а техномагию я не люблю. Поэтому, чтобы почувствовать контроль над ситуацией, я написал утилиты encode и decode. Как мне кажется, код на си куда проще для понимания, поэтому утилиты будут полезны тем, кто тоже захочет знаний.
Подозреваю, что если выставить другую кодировку командой AT+CSCS, проблема отпадёт сама собой, но мы же не ищем…
В остальном работа с USSD проста: модем регистрирует три девайса ttyUSB. Пишем в первый, читаем из последнего.
Для подключения личного кабинета достаточно просто отправить 105: **./ussd.sh '\*105#'** (подразумевается, что /dev/modem указывает на первый из ttyUSB модема). Дожидаемся СМС с паролем (удобнее всего это делать командой **ls -lrt /var/spool/incoming**), после чего смотрим **./viewsms** .
Мультифон подключается в два этапа: запустив **cat /dev/ttyUSB2**, отправляем \*137#. Копируем ответ и выясняем, что там написано, с помощью **decode**. А приходит в ответ менюшка, где для подключения нужно выбрать пункт 1. Выполняем **./ussd 1** и получаем в СМС пароль.
На этом можно было бы и завершить, но так как мы имеем дело с бабуинами, стоит упомянуть про…
Организационные моменты
-----------------------
1. Обязательно укажите, чтобы новую сим-карту подключили на существующий лицевой счёт. Насколько я понял, отключение по неактивности не работает, если на все номера один баланс. Да и вообще удобнее. Когда был жив сервис-гид с возможностью управлять всеми номерами из-под одной учётной записи, этот совет был ещё актуальнее.
2. В современном мире наебизнеса уже никому не надо объяснять, что сразу после покупки сим-карты необходимо отключать все условно-бесплатные опции (в том числе, «Кто звонил?», ага). **Но!** Бабуины пошли дальше и некоторые из условно-бесплатных опций не отображаются в личном кабинете. Отключить их можно только звонком в контакт-центр. Желательно подробно прочитать описание тарифа, чтобы выяснить, каких же замечательных вещей вам ~~впарили~~продали.
3. В качестве номера для отправки СМС я использую свой основной номер, потому что на нём есть предоплаченный пакет. Естественно, для этого Мультифон на нём тоже должен быть включен (но совершенно не обязательно держать его постоянно зарегистрированным). Дополнительный номер используется только для приёма звонков.
### PS
К сожалению, Мультифон не передаёт номер, переадресовавший звонок. Поэтому, если вы хотите подключить свой бонусный «Кто звонил?» друзьям/родным, придётся на каждого человека покупать отдельный номер под автоответчик. Ещё можно попробовать переадресацию с доп. набором (+79XXXXXXXXXpXX), но я не проверял. Если проверите, пишите.
А вот теперь – всё! | https://habr.com/ru/post/278679/ | null | ru | null |
# SynchronizationContext — когда MSDN подводит
Не знаю почему, но информации об этом новом класса в .NET Framework, действительно немного. Документация MSDN почти ничего не говорит о способах использования SynchronizationContext. Должен сказать, изначально я и сам плохо представлял назначение этого класса и как его использовать. После продолжительного изучения вопроса я наконец понял его назначение и решил написать эту статью чтобы помочь разобраться другим разработчикам.
#### Использование SynchronizationContext для проброса кода из одного потока в другой
Рассмотрим некоторые технические подробности общения потоков посредством SynchronizationContext. Предположим у вас есть два потока, t1 и t2. И t1 исполняет некоторую работу, и в какой-то момент желает передать выполнение кода потоку t2. Один из способов сделать это, запросить у t2 SynchronizationContext, передать его в t1, который вызовет метод Send для передачи кода в t2. Напоминает магию… Однако вы должны знать что не у каждого потока есть связанный с ним SynchronizationContext. Только один поток однозначно имеет SynchronizationContext, это UI поток.
Кто задает SynchronizationContext для UI потока? Есть предположения? Хорошо, вот вам ответ, первый созданный контрол в потоке помещает SynchronizationContext в этот поток. Как правило это первая созданная форма. Откуда я это узнал? Ну… я закодил проверку.
Поскольку мой код использует SynchronizationContext.Current, позвольте объяснить что дает это статическое свойство. SynchronizationContext.Current позволяет получить SynchronizationContext который присоединен к текущему потоку. Сразу проясним, SynchronizationContext.Current не синглтон в рамках AppDomain, но синглтон в рамках потока. Это значит что два разных потока могут получить разные экземпляры SynchronizationContext вызвав SynchronizationContext.Current. Если вас интересует где хранится актуальный SynchronizationContext, он хранится в хранилище данных потока (и как я сказал ранее, не в глобальной памяти домена приложения).
Хорошо, давайте посмотри на код, который задает SynchronizationContext в наш UI поток:
**Пример**
```
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// проверим наличие контекста синхронизации
var context = SynchronizationContext.Current;
if (context == null)
MessageBox.Show("No context for this thread");
else
MessageBox.Show("We got a context");
// создадим форму
Form1 form = new Form1();
// проверим наличие контекста синхронизации еще раз
context = SynchronizationContext.Current;
if (context == null)
MessageBox.Show("No context for this thread");
else
MessageBox.Show("We got a context");
if (context == null)
MessageBox.Show("No context for this thread");
Application.Run(new Form1());
}
```
Как вы видите есть пара моментов которые надо учесть:
* Первый блок кода показывает что изначально нет SynchronizationContext'а прикрепленного к потоку. Это потому, что .NET не знает что произойдет в этом потоке, и нет исполняемого класса который бы инициализировал контекст синхронизации для этого потока.
* Сразу после создания формы, мы видим что контекст установлен. За это несет ответственность класс Form, Он проверяет, если контекст синхронизации отсутствует, то следует его задать. Запомните, контекст всегда один в одном потоке, так что любой UI контрол может получить к нему доступ. Потому что все UI операции должны исполняться в UI потоке. Поток который создает окно, должен иметь возможность с этим окном общаться. В нашем случае это основной поток приложения.
#### И что мне с этим все теперь делать?
Теперь, когда UI поток задал контекст синхронизации, и мы можем запускать код в UI потоке, как мы можем это использовать?
Для начала, мы действительно можем прокидывать код в UI поток? Да. Если код исполняется в потоке отличном от UI потока, вы не можете воздействовать на пользовательский интерфейс. Хотите погеройствовать и попробовать сделать это? Вы получите исключение (в версии 1.0 исключения не будет, приложение просто упадет, но в версии 2.0 есть жирные уродливые исключения которые приложение выплюнет вам в лицо).
Справедливости ради, я скажу что вы не должны использовать контекст синхронизации в UI потоке. Вам нужно использовать свойство InvokeRequired(которое есть у каждого класса любого UI контрола) и смотреть, нужно ли вам прокидывать код. Если InvokeRequired вернет значение true, то задействуйте Control.Invoke для маршалинга в поток UI. Отлично! Но есть проблема с этой техникой. У вас должен быть контрол, на котором вы можете вызвать Invoke. Не имеет значение какой UI контрол это будет, но вам нужна по крайней мере одна доступная ссылка на контрол, в вашем не UI потоке, для проведения маршалинга.
С точки зрения дизайна, вам не нужны ссылки на UI в бизнес-слое. Тогда вы можете оставить все операции по синхронизации UI классу, и быть уверенным что UI самостоятельно несет ответственность за маршалинг(посмотрите мою статью по MVP). Тем не менее, это задает UI больше ответственности, и делает UI более нагруженным чем хотелось бы. Было бы хорошо на слое бизнес-логики иметь возможность маршалинга в пользовательский интерйфейс, не имея ссылок на контролы или на форму.
И как это делается?
Да примитивно, Создать поток, передать ему контекст синхронизации, и использовать этот поток как объект синхронизации для маршалинга в UI поток. Посмотрим пример.
В следующем примере, у меня есть listBox который заполняется из рабочего потока. Поток имитирует вычисления и выводит данные в listBox. Поток используемый для обновления пользовательского интерфейса запускается из обработчика mToolStripButtonThreads\_Click.
Прежде всего посмотрим что на форме:
**Посмотреть что на форме**
```
private void InitializeComponent()
{
System.ComponentModel.ComponentResourceManager resources =
new System.ComponentModel.ComponentResourceManager(typeof(Form1));
this.mListBox = new System.Windows.Forms.ListBox();
this.toolStrip1 = new System.Windows.Forms.ToolStrip();
this.mToolStripButtonThreads = new System.Windows.Forms.ToolStripButton();
this.toolStrip1.SuspendLayout();
this.SuspendLayout();
//
// mListBox
//
this.mListBox.Dock = System.Windows.Forms.DockStyle.Fill;
this.mListBox.FormattingEnabled = true;
this.mListBox.Location = new System.Drawing.Point(0, 0);
this.mListBox.Name = "mListBox";
this.mListBox.Size = new System.Drawing.Size(284, 264);
this.mListBox.TabIndex = 0;
//
// toolStrip1
//
this.toolStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.mToolStripButtonThreads});
this.toolStrip1.Location = new System.Drawing.Point(0, 0);
this.toolStrip1.Name = "toolStrip1";
this.toolStrip1.Size = new System.Drawing.Size(284, 25);
this.toolStrip1.TabIndex = 1;
this.toolStrip1.Text = "toolStrip1";
//
// mToolStripButtonThreads
//
this.mToolStripButtonThreads.DisplayStyle =
System.Windows.Forms.ToolStripItemDisplayStyle.Text;
this.mToolStripButtonThreads.Image = ((System.Drawing.Image)
(resources.GetObject("mToolStripButtonThreads.Image")));
this.mToolStripButtonThreads.ImageTransparentColor =
System.Drawing.Color.Magenta;
this.mToolStripButtonThreads.Name = "mToolStripButtonThreads";
this.mToolStripButtonThreads.Size = new System.Drawing.Size(148, 22);
this.mToolStripButtonThreads.Text = "Press Here to start threads";
this.mToolStripButtonThreads.Click +=
new System.EventHandler(this.mToolStripButtonThreads_Click);
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(284, 264);
this.Controls.Add(this.toolStrip1);
this.Controls.Add(this.mListBox);
this.Name = "Form1";
this.Text = "Form1";
this.toolStrip1.ResumeLayout(false);
this.toolStrip1.PerformLayout();
this.ResumeLayout(false);
this.PerformLayout();
}
#endregion
private System.Windows.Forms.ListBox mListBox;
private System.Windows.Forms.ToolStrip toolStrip1;
private System.Windows.Forms.ToolStripButton mToolStripButtonThreads;
}
```
И теперь рассмотрим пример:
**Пример**
```
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void mToolStripButtonThreads_Click(object sender, EventArgs e)
{
// посмотрим id потока
int id = Thread.CurrentThread.ManagedThreadId;
Trace.WriteLine("mToolStripButtonThreads_Click thread: " + id);
// захватим контекст синхронизации ассоциированный с этим
// потоком (UI поток), и сохраним его в uiContext
// отметье что этот контекст устанавливается в UI потоке
// во время создания формы (вне зоны вашего контроля)
// также отметье, что не каждый поток имеет контекст синхронизации связанный с ним.
SynchronizationContext uiContext = SynchronizationContext.Current;
// Создадим поток и зададим ему метод Run для исполнения
Thread thread = new Thread(Run);
// Запустим поток и установим ему контекст синхронизации,
// таким образом этот поток сможет обновлять UI
thread.Start(uiContext);
}
private void Run(object state)
{
// смотри id потока
int id = Thread.CurrentThread.ManagedThreadId;
Trace.WriteLine("Run thread: " + id);
// вытащим контекст синхронизации из state'а
SynchronizationContext uiContext = state as SynchronizationContext;
for (int i = 0; i < 1000; i++)
{
// Тут мог бы быть ваш код который обращается к базе
// или выполняет какие-то вычисления
Thread.Sleep(10);
// испольуем UI контекст для обновления интерфейса,
// посредством исполнения метода UpdateUI, метод UpdateUI
// будет исполнен в UI потоке
uiContext.Post(UpdateUI, "line " + i.ToString());
}
}
///
/// Этот метод исполняется в основном UI потоке
///
private void UpdateUI(object state)
{
int id = Thread.CurrentThread.ManagedThreadId;
Trace.WriteLine("UpdateUI thread:" + id);
string text = state as string;
mListBox.Items.Add(text);
}
}
```
Пройдемся по коду, обратите внимание, я вывожу id потока, чтобы мы могли посмотреть на него в дальнейшем.
При нажатии на кнопку ToolStrip, поток запускается с указателем на метод Run. В этот поток я передаю состояние, в котором содержится контекст синхронизации UI потока.
```
SynchronizationContext uiContext = SynchronizationContext.Current;
```
Я знаю что в SynchronizationContext.Current содержится контекст синхронизации UI потока, потому что код выполняется по нажатию на кнопку (UI контрол). Метод Run получает контекст синхронизации из переданного состояния, и теперь у него есть способ проброса кода в UI поток.
```
// Получение контекста синхронизации из состояния
SynchronizationContext uiContext = state as SynchronizationContext;
```
Метод Run 1000 раз выводит запись в listBox. Как? Он использует метод Send контекста синхронизации.
```
public virtual void Send(SendOrPostCallback d, object state);
```
Метод Send принимает два аргумента, делегат на метод и состояние. В нашем примере…
```
uiContext.Send(UpdateUI, "line " + i.ToString());
```
...UpdateUI указатель на метод, в состояние содержит строку для вывода в listBox. Код из метода UpdateUI запускается в UI потоке, а не в вызывающем его.
```
private void UpdateUI(object state)
{
int id = Thread.CurrentThread.ManagedThreadId;
Trace.WriteLine("UpdateUI thread:" + id);
string text = state as string;
mListBox.Items.Add(text);
}
```
Обратите внимаение что этот поток работает непосредственно в UI потоке. В нем нет проверки на InvokerRequired, т.к. я знаю что это UI поток потому что был использован метод Send контекста синхронизации UI потока.
Посмотрим на id потоков:
```
mToolStripButtonThreads_Click thread: 10
Run thread: 3
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
... (x1000 times)
```
Здесь мы видим что id UI потока равен 10, рабочий поток (Run) имеет id равный трем, и когда мы вызываем обновление пользовательского интерфейса, id потока в котором оно происходит равно 10. Все работает как и рекламировалось.
#### Обработка ошибок
Очень хорошо, мы способны прокидывать код в UI поток, но что случится если прокинутый код сгенерирует исключение? Кто несет ответственность за его перехват? UI поток или рабочий поток?
**Пример выброса исключения**
```
private void Run(object state)
{
// смотрим id потока
int id = Thread.CurrentThread.ManagedThreadId;
Trace.WriteLine("Run thread: " + id);
// захватываем контекст синхронизации
SynchronizationContext uiContext = state as SynchronizationContext;
for (int i = 0; i < 1000; i++)
{
Trace.WriteLine("Loop " + i.ToString());
// симуляция вычислений
Thread.Sleep(10);
// прокидываем код в UI поток
try
{
uiContext.Send(UpdateUI, "line " + i.ToString());
}
catch (Exception e)
{
Trace.WriteLine(e.Message);
}
}
}
///
/// Метод исполняемый в UI потоке
///
private void UpdateUI(object state)
{
throw new Exception("Boom");
}
```
Я изменил метод UpdateUI, чтобы он выкидывал исключение. И добавил try/catch на методе Send контекста синхронизации.
При запуске этого кода я увидел что исключение появилось в потоке метода Run, а не в UI. Это интересно, т.к. можно было ожидать исключение в UI потоке, принимая во внимание отсутствие классов перехватывающих исключения в UI потоке.
Следовательно, есть в методе Send немного магии; он выполняет наш код синхронно и возвращает нам любое возникшее исключение.
#### Send vs. Post
Использование метода Send это один из двух возможных способов прикинуть код в UI поток. Второй способ — использование метода Post. Есть ли разница? Она огромна!
Пришло время рассмотреть более подробно контракт класса SynchronizationContext.
**ISynchronizationContext**
```
// Summary:
// Provides the basic functionality for propagating a synchronization context
// in various synchronization models.
public class SynchronizationContext
{
// Summary:
// Creates a new instance of the System.Threading.SynchronizationContext class.
public SynchronizationContext();
// Summary:
// Gets the synchronization context for the current thread.
//
// Returns:
// A System.Threading.SynchronizationContext object representing the current
// synchronization context.
public static SynchronizationContext Current { get; }
// Summary:
// When overridden in a derived class, creates a copy of the synchronization
// context.
//
// Returns:
// A new System.Threading.SynchronizationContext object.
public virtual SynchronizationContext CreateCopy();
//
// Summary:
// Determines if wait notification is required.
//
// Returns:
// true if wait notification is required; otherwise, false.
public bool IsWaitNotificationRequired();
//
// Summary:
// When overridden in a derived class, responds to the notification that an
// operation has completed.
public virtual void OperationCompleted();
//
// Summary:
// When overridden in a derived class, responds to the notification that an
// operation has started.
public virtual void OperationStarted();
//
// Summary:
// When overridden in a derived class, dispatches an asynchronous message to
// a synchronization context.
//
// Parameters:
// d:
// The System.Threading.SendOrPostCallback delegate to call.
//
// state:
// The object passed to the delegate.
public virtual void Post(SendOrPostCallback d, object state);
//
// Summary:
// When overridden in a derived class, dispatches a synchronous message to a
// synchronization context.
//
// Parameters:
// d:
// The System.Threading.SendOrPostCallback delegate to call.
//
// state:
// The object passed to the delegate.
public virtual void Send(SendOrPostCallback d, object state);
//
// Summary:
// Sets the current synchronization context.
//
// Parameters:
// syncContext:
// The System.Threading.SynchronizationContext object to be set.
public static void SetSynchronizationContext(SynchronizationContext syncContext);
//
// Summary:
// Sets notification that wait notification is required and prepares the callback
// method so it can be called more reliably when a wait occurs.
protected void SetWaitNotificationRequired();
//
// Summary:
// Waits for any or all the elements in the specified array to receive a signal.
//
// Parameters:
// waitHandles:
// An array of type System.IntPtr that contains the native operating system
// handles.
//
// waitAll:
// true to wait for all handles; false to wait for any handle.
//
// millisecondsTimeout:
// The number of milliseconds to wait, or System.Threading.Timeout.Infinite
// (-1) to wait indefinitely.
//
// Returns:
// The array index of the object that satisfied the wait.
[PrePrepareMethod]
[CLSCompliant(false)]
public virtual int Wait(IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout);
//
// Summary:
// Helper function that waits for any or all the elements in the specified array
// to receive a signal.
//
// Parameters:
// waitHandles:
// An array of type System.IntPtr that contains the native operating system
// handles.
//
// waitAll:
// true to wait for all handles; false to wait for any handle.
//
// millisecondsTimeout:
// The number of milliseconds to wait, or System.Threading.Timeout.Infinite
// (-1) to wait indefinitely.
//
// Returns:
// The array index of the object that satisfied the wait.
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
[PrePrepareMethod]
[CLSCompliant(false)]
protected static int WaitHelper(IntPtr[] waitHandles,
bool waitAll, int millisecondsTimeout);
}
```
Обратите внимание на комментарий к методу Post:
```
//
// Summary:
//
// When overridden in a derived class, dispatches an asynchronous message to
// a synchronization context.
//
// Parameters:
// d:
// The System.Threading.SendOrPostCallback delegate to call.
//
// state:
// The object passed to the delegate.
public virtual void Post(SendOrPostCallback d, object state);
```
Ключевое слово здесь: асинхронный. Это означает что метод Post не будет ждать исполнения делегата, для собственного завершения. «Выстрелил и забыл» об исполняемом коде. Также это означает что вы не сможете перехватить сообщение, как при вызове метода Send. И теперь исключение получит UI поток. Если это исключение не обработать, UI поток упадет.
Тем не менее, Post или Send вы выберете, исполняемый код всегда отработает в нужном потоке. Заменив Send на Post, вы все равно получите идентификатор UI потока в исполняемом коде.
#### Теперь я могу использовать SynchronizationContext для синхронизации любых потоков, верно? Неа!
В любой момент вы можете попробовать использовать SynchronizationContext из любого потока. Однако вы обнаружите что ваш поток при вызове SynchronizationContext.Current получит null. Ничего страшного — скажете вы, и зададите SynchronizationContext, если его нет. Примитивно. Но это не сработает.
Посмотрим на программу аналогичную используемой ранее.
**Пример**
```
class Program
{
private static SynchronizationContext mT1 = null;
static void Main(string[] args)
{
// запишем id потока
int id = Thread.CurrentThread.ManagedThreadId;
Console.WriteLine("Main thread is " + id);
// создадим новый контекст синхронизации для текущего потока
var context = new SynchronizationContext();
// зададим контекст синхронизации текущему потоку
SynchronizationContext.SetSynchronizationContext(context);
// создадим новый поток и передадим ему контекст синхронизации
Thread t1 = new Thread(new ParameterizedThreadStart(Run1));
t1.Start(SynchronizationContext.Current);
Console.ReadLine();
}
static private void Run1(object state)
{
int id = Thread.CurrentThread.ManagedThreadId;
Console.WriteLine("Run1 Thread ID: " + id);
// вытаскиваем контекст синхронизации из состояния
var context = state as SynchronizationContext;
// пробуем выполнить код в основном потоке используя контекст синхронизации
context.Send(DoWork, null);
while (true)
Thread.Sleep(10000000);
}
static void DoWork(object state)
{
int id = Thread.CurrentThread.ManagedThreadId;
Console.WriteLine("DoWork Thread ID:" + id);
}
}
```
Это простое консольное приложение показывает как вам не стоит делать. Эта программа не работает. Заметьте, я задаю контекст синхронизации в главном потоке консольного приложения. Я просто создаю новый экземпляр. И присоединяю его к текущему потоку. Это очень похоже на то, что делает UI поток когда создается форма (не совсем, объясню позже). Затем я создаю поток Run1, и посылаю ему контекст синхронизации основного потока. Когда я пытаюсь вызвать метод Send, то глядя на вывод, я вижу что метод вызывается в потоке Run1, а не в основном потоке, как ожидалось. Вот вывод:
```
Main thread is 10
Run1 Thread ID: 11
DoWork Thread ID:11
```
Видите, DoWork исполняется в том же потоке что и Run1. А вовсе не в основном потоке. Почему? Что происходит?
Ну… В этой части вы поймете что нет ничего бесплатного в этой жизни. Потоки не могут просто так переключаться между контекстами, им нужна инфраструктура встроенная в них для проведения такой операции. Поток UI, например, использует очередь сообщений, и в своем контексте синхронизации он использует эту очередь для синхронизации в пользовательском интерфейсе.
Т.е. UI поток имеет собственный контекст синхронизации, но этот класс производный от SynchronizationContext, и называется он System.Windows.Forms.WindowsFormsSynchronizationContext. И этот класс имеет весьма значительные отличия от базовой реализации SynchronizationContext. Версия UI переопределяет вызовы методов Send и Post, и реализует концепцию очереди сообщений (я пытался найти исходный код этого класса но не нашел). Что же делает базовая реализация SynchronizationContext?
/\*
**от переводчика:**
[Исходный код WindowsFormsSynchronizationContext](http://referencesource.microsoft.com/#System.Windows.Forms/ndp/fx/src/winforms/Managed/System/WinForms/WindowsFormsSynchronizationContext.cs)
[Исходный код SynchronizationContext](http://referencesource.microsoft.com/#mscorlib/system/threading/synchronizationcontext.cs)
**Реализация InvokeRequired в WindowsFormsSynchronizationContext**
```
public bool InvokeRequired
{
get
{
using (new MultithreadSafeCallScope())
{
HandleRef hwnd;
if (IsHandleCreated) {
hwnd = new HandleRef(this, Handle);
}
else {
Control marshalingControl = FindMarshalingControl();
if (!marshalingControl.IsHandleCreated) {
return false;
}
hwnd = new HandleRef(marshalingControl, marshalingControl.Handle);
}
int pid;
int hwndThread = SafeNativeMethods.GetWindowThreadProcessId(hwnd, out pid);
int currentThread = SafeNativeMethods.GetCurrentThreadId();
return(hwndThread != currentThread);
}
}
}
```
**Реализация Invoke в WindowsFormsSynchronizationContext**
```
private Object MarshaledInvoke(Control caller, Delegate method, Object[] args, bool synchronous)
{
// Marshaling an invoke occurs in three steps:
//
// 1. Create a ThreadMethodEntry that contains the packet of information
// about this invoke. This TME is placed on a linked list of entries because
// we have a gap between the time we PostMessage and the time it actually
// gets processed, and this gap may allow other invokes to come in. Access
// to this linked list is always synchronized.
//
// 2. Post ourselves a message. Our caller has already determined the
// best control to call us on, and we should almost always have a handle.
//
// 3. If we're synchronous, wait for the message to get processed. We don't do
// a SendMessage here so we're compatible with OLE, which will abort many
// types of calls if we're within a SendMessage.
//
if (!IsHandleCreated) {
throw new InvalidOperationException(SR.GetString(SR.ErrorNoMarshalingThread));
}
// We have to demand unmanaged code permission here for the control hosted in
// the browser case. Without this check, we will expose a security hole, because
// ActiveXImpl.OnMessage() will assert unmanaged code for everyone as part of
// its implementation.
// The right fix is to remove the Assert() on top of the ActiveXImpl class, and
// visit each method to see if it needs unmanaged code permission, and if so, add
// the permission just to that method(s).
//
ActiveXImpl activeXImpl = (ActiveXImpl)Properties.GetObject(PropActiveXImpl);
if (activeXImpl != null) {
IntSecurity.UnmanagedCode.Demand();
}
// We don't want to wait if we're on the same thread, or else we'll deadlock.
// It is important that syncSameThread always be false for asynchronous calls.
//
bool syncSameThread = false;
int pid; // ignored
if (SafeNativeMethods.GetWindowThreadProcessId(new HandleRef(this, Handle), out pid) == SafeNativeMethods.GetCurrentThreadId()) {
if (synchronous)
syncSameThread = true;
}
// Store the compressed stack information from the thread that is calling the Invoke()
// so we can assign the same security context to the thread that will actually execute
// the delegate being passed.
//
ExecutionContext executionContext = null;
if (!syncSameThread) {
executionContext = ExecutionContext.Capture();
}
ThreadMethodEntry tme = new ThreadMethodEntry(caller, this, method, args, synchronous, executionContext);
lock (this) {
if (threadCallbackList == null) {
threadCallbackList = new Queue();
}
}
lock (threadCallbackList) {
if (threadCallbackMessage == 0) {
threadCallbackMessage = SafeNativeMethods.RegisterWindowMessage(Application.WindowMessagesVersion + "_ThreadCallbackMessage");
}
threadCallbackList.Enqueue(tme);
}
if (syncSameThread) {
InvokeMarshaledCallbacks();
} else {
//
UnsafeNativeMethods.PostMessage(new HandleRef(this, Handle), threadCallbackMessage, IntPtr.Zero, IntPtr.Zero);
}
if (synchronous) {
if (!tme.IsCompleted) {
WaitForWaitHandle(tme.AsyncWaitHandle);
}
if (tme.exception != null) {
throw tme.exception;
}
return tme.retVal;
}
else {
return(IAsyncResult)tme;
}
}
```
\*/
Так или иначе я нашел исходный код SynchronizationContext, вот он (я удалил атрибуты и сделал незначительное форматирование):
**Базовая реализация SynchronizationContext**
```
namespace System.Threading
{
using Microsoft.Win32.SafeHandles;
using System.Security.Permissions;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Reflection;
internal struct SynchronizationContextSwitcher : IDisposable
{
internal SynchronizationContext savedSC;
internal SynchronizationContext currSC;
internal ExecutionContext _ec;
public override bool Equals(Object obj)
{
if (obj == null || !(obj is SynchronizationContextSwitcher))
return false;
SynchronizationContextSwitcher sw = (SynchronizationContextSwitcher)obj;
return (this.savedSC == sw.savedSC &&
this.currSC == sw.currSC && this._ec == sw._ec);
}
public override int GetHashCode()
{
return ToString().GetHashCode();
}
public static bool operator ==(SynchronizationContextSwitcher c1,
SynchronizationContextSwitcher c2)
{
return c1.Equals(c2);
}
public static bool operator !=(SynchronizationContextSwitcher c1,
SynchronizationContextSwitcher c2)
{
return !c1.Equals(c2);
}
void IDisposable.Dispose()
{
Undo();
}
internal bool UndoNoThrow()
{
if (_ec == null)
{
return true;
}
try
{
Undo();
}
catch
{
return false;
}
return true;
}
public void Undo()
{
if (_ec == null)
{
return;
}
ExecutionContext executionContext =
Thread.CurrentThread.GetExecutionContextNoCreate();
if (_ec != executionContext)
{
throw new InvalidOperationException(Environment.GetResourceString(
"InvalidOperation_SwitcherCtxMismatch"));
}
if (currSC != _ec.SynchronizationContext)
{
throw new InvalidOperationException(Environment.GetResourceString(
"InvalidOperation_SwitcherCtxMismatch"));
}
BCLDebug.Assert(executionContext != null, " ExecutionContext can't be null");
// restore the Saved Sync context as current
executionContext.SynchronizationContext = savedSC;
// can't reuse this anymore
_ec = null;
}
}
public delegate void SendOrPostCallback(Object state);
[Flags]
enum SynchronizationContextProperties
{
None = 0,
RequireWaitNotification = 0x1
};
public class SynchronizationContext
{
SynchronizationContextProperties _props = SynchronizationContextProperties.None;
public SynchronizationContext()
{
}
// protected so that only the derived sync
// context class can enable these flags
protected void SetWaitNotificationRequired()
{
// Prepare the method so that it can be called
// in a reliable fashion when a wait is needed.
// This will obviously only make the Wait reliable
// if the Wait method is itself reliable. The only thing
// preparing the method here does is to ensure there
// is no failure point before the method execution begins.
RuntimeHelpers.PrepareDelegate(new WaitDelegate(this.Wait));
_props |= SynchronizationContextProperties.RequireWaitNotification;
}
public bool IsWaitNotificationRequired()
{
return ((_props &
SynchronizationContextProperties.RequireWaitNotification) != 0);
}
public virtual void Send(SendOrPostCallback d, Object state)
{
d(state);
}
public virtual void Post(SendOrPostCallback d, Object state)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(d), state);
}
public virtual void OperationStarted()
{
}
public virtual void OperationCompleted()
{
}
// Method called when the CLR does a wait operation
public virtual int Wait(IntPtr[] waitHandles,
bool waitAll, int millisecondsTimeout)
{
return WaitHelper(waitHandles, waitAll, millisecondsTimeout);
}
// Static helper to which the above method
// can delegate to in order to get the default
// COM behavior.
protected static extern int WaitHelper(IntPtr[] waitHandles,
bool waitAll, int millisecondsTimeout);
// set SynchronizationContext on the current thread
public static void SetSynchronizationContext(SynchronizationContext syncContext)
{
SetSynchronizationContext(syncContext,
Thread.CurrentThread.ExecutionContext.SynchronizationContext);
}
internal static SynchronizationContextSwitcher
SetSynchronizationContext(SynchronizationContext syncContext,
SynchronizationContext prevSyncContext)
{
// get current execution context
ExecutionContext ec = Thread.CurrentThread.ExecutionContext;
// create a switcher
SynchronizationContextSwitcher scsw = new SynchronizationContextSwitcher();
RuntimeHelpers.PrepareConstrainedRegions();
try
{
// attach the switcher to the exec context
scsw._ec = ec;
// save the current sync context using the passed in value
scsw.savedSC = prevSyncContext;
// save the new sync context also
scsw.currSC = syncContext;
// update the current sync context to the new context
ec.SynchronizationContext = syncContext;
}
catch
{
// Any exception means we just restore the old SyncCtx
scsw.UndoNoThrow(); //No exception will be thrown in this Undo()
throw;
}
// return switcher
return scsw;
}
// Get the current SynchronizationContext on the current thread
public static SynchronizationContext Current
{
get
{
ExecutionContext ec = Thread.CurrentThread.GetExecutionContextNoCreate();
if (ec != null)
return ec.SynchronizationContext;
return null;
}
}
// helper to Clone this SynchronizationContext,
public virtual SynchronizationContext CreateCopy()
{
// the CLR dummy has an empty clone function - no member data
return new SynchronizationContext();
}
private static int InvokeWaitMethodHelper(SynchronizationContext syncContext,
IntPtr[] waitHandles,
bool waitAll,
int millisecondsTimeout)
{
return syncContext.Wait(waitHandles, waitAll, millisecondsTimeout);
}
}
}
```
Посмотрите на реализацию методов Send и Post…
```
public virtual void Send(SendOrPostCallback d, Object state)
{
d(state);
}
public virtual void Post(SendOrPostCallback d, Object state)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(d), state);
}
```
Send просто выполняет делегат в вызывающем потоке (вообще не делая переключения потоков). Post делает то же самое, просто используя пул потоков для асинхронности. На мой взгляд этот класс должен быть абстрактным. Такая реализация только запутывает и, кроме того, бесполезна. Это одна из двух причин способствовавших написанию этой статьи.
#### В заключение
Я надеюсь вы почерпнули что-то новое для себя, о контексте синхронизации и способах его использования. В .NET я нашел два класса реализующих контекст синхронизации для пользовательского интерфейса, один для WinForms и один для WPF. Я уверен что их больше, но пока нашел только их. Базовая реализация, как я показал, не делает ничего для переключения потоков. UI поток, в свою очередь, использует очередь сообщений и Windows API (SendMessage и PostMessage), так что я уверен что код будет выполнен в UI потоке.
Тем не менее это не предел использования данного класса. Вы можете сделать свою реализацию SynchronizationContext, это не так и сложно. На самом деле я должен был написать одну такую. В моей работе требовалось чтобы все вызовы COM, выполнялись в STA потоке. Тем не менее наше приложение использует пул потоков и WCF, и было не просто сделать проброс кода в STA поток. Поэтому я решил сделать свою версию SynchronizationContext, под названием StaSynchronizationContext, о которой и пойдет речь во второй части статьи.
##### От переводчика
Контекст синхронизации заинтересовал меня когда я пытался решить задачу по написанию мультипоточного обработчика однотипных задач, т.е. что-то вроде
```
using(var processor = new Processor(handler, exceptionHandler, completedHandler))
{
for(int i=0;i<1000000; i++)
processor.Push(i);
}
```
, и первое впечатление от найденных статей по контексту синхронизации, это то что нужно. Но после более детального изучения стало понятно что SynchronizationContext появился и развивался в рамках задачи взаимодействия с UI, и этими задачи его использование и ограничивается. Собственно в самом FCL всего два класса от него наследуются, один для WPF и второй для WinForms.
По простому всю эту модель можно представить как синглтон, управление состоянием которого ведется набором последовательных команд из одного конкретного потока, но сами команды могут быть поданы из разных потоков. Сам контекст синхронизации в данном случае можно представить как потокобезопасную очередь этих команд, в которую все пишут, и из которой один читает.
Т.е. решение как бы хорошее, но как сказано в статье, базовая реализация вовсе не реализует переключение потоков. А имеющиеся расширенные реализации узконаправлены на UI. Написание же своей реализации будет перегружено базовыми методами, 80% которых скорее всего не пригодятся. По итогу получается что для своих задач будет проще использовать TPL или собственную реализацию контекста для потоков (что по итогу и было сделано). Ну или как у автора статьи в специфических задачах.
Тем не менее в ряде случаев понимание работы SynchronizationContext может быть весьма полезно, например как показано выше, при управлении UI'ем из бизнес-слоя, без загрязнения кода на форме вызовами через BeginInvoke. | https://habr.com/ru/post/232169/ | null | ru | null |
# Фишинг «своими руками». Опыт компании «Актив», часть вторая
В [первой](https://habrahabr.ru/company/aktiv-company/blog/329470/) статье я рассказал о теории вопроса, теперь же от теории перейдем к практике. Итак, мы успешно установили систему, настроили ее и готовы приступить к «фишингу» на собственных сотрудниках :)
План
====
План у нас достаточно простой. На первом этапе мы рассылаем несколько разных писем по всем сотрудникам. Рассылки выбираем персонифицированные (спирфишинг). Ссылка в рассылке ведет через пустую страницу (которая нужна для анализа переходов) на оригинальную страницу сервиса. Первый этап посвящен по сути чистому эксперименту с целью определения всей глубины проблемы. После первого письма мы официально объявляем всем сотрудникам, что письма рассылали мы и направляем всех на страницу с обучением по борьбе с фишингом.
Через неделю проводим второй этап, похожий на первый (письма с новым содержанием), но ссылка в письмах уже напрямую ведет на нашу страницу обучения. Третий этап — контрольный. По итогам проводим сравнение и видим динамику переходов по ссылке и обращений в ИТ-отдел. С теми, кто продолжает «попадаться», проводим индивидуальную работу. План в целом был выполнен и признан успешным, но жизнь внесла в него коррективы.
Сбербанк
========
В нашей компании, как и во многих, зарплата перечисляется на карты. Карты Сбербанка занимают лидирующие позиции. Почему бы не начать фишинг с проверки «Сбербанком», подумали мы, и сделали первый шаблон писем, который выглядел следующим образом (к слову, этот и все остальные шаблоны, мы не придумали сами, а нашли его в интернете). И вот наступил день «X», и сотрудники получили подобное письмо.
По ссылке мы сделали очень простую страницу:
```
```
Как видно из кода страницы, происходит редирект на настоящий сайт «Сбербанка». Нам был важен лишь сам факт перехода.
Госуслуги
=========
Сбербанк — это хорошо, но одного его для первой рассылки нам показалось недостаточно. Что же еще будет интересно сразу всем сотрудникам компании? Госуслуги. Они все больше и больше входят в нашу жизнь и множество людей ими пользуются, соответственно, это вполне достойный объект для рассылки. Побродив по просторам сети, подвернулся и интересный спам-шаблон:
Ссылка снова была пустая, страница во многом аналогичная сбербанковской, но ссылающаяся на другой ресурс.
```
```
Результаты первого этапа
========================
Итак, мы запустили рассылку. Первый час-два была тишина: кто-то переходил по ссылке, кто-то не переходил. Затем в ИТ-отделе стали раздаваться звонки. Стоит пояснить, что сотрудники у нас в компании достаточно продвинутые. Рядовой менеджер у нас должен знать, что такое PKI и с чем его едят. Поэтому самое мягкое, что мы получали по телефону или в jira, были сообщения вида «Какой-то странный спам к нам пришел. Подкрутите спам-фильтры». Ближе к обеду пришли на работу программисты, и они заинтересовались нашими письмами. Довольно быстро был обнаружен наш сервер рассылки, и вот тут началась небольшая паника — нас что, взломали? Пришлось провести небольшую разъяснительную работу с рядом руководителей и погасить панику, но сарафанное радио было уже не остановить. На этом этапе мы поняли, что допустили одну ошибку.
> Не стоит использовать для размещения системы внутрисетевые ресурсы. Даже, если вы управляете днс, можно просто пропинговать ваш домен и понять, что он находится внутри сети. Арендуйте виртуальную машину во вне сети и настройте днс на него, или купите несколько доменов для полной чистоты эксперимента.
Начиная со второго этапа, мы уже исправились. Подобной проблемы у нас больше не возникало.
Бухгалтерия
===========
Отдельной истории заслуживает реакция бухгалтерии. Бухгалтерия принимает участие в выплате зарплаты сотрудникам, и получив наши «письма счастья от Сбербанка», не могла не отреагировать. Сделала она это бурно и прекрасно. Лучшей реакции при реальном «фишинге» нельзя и представить! Бухгалтерия сделала три вещи. Во-первых, позвонили в Сбербанк и уточнили подлинность писем. В Сбербанке объяснили, что это фишинг, не нужно ничего скачивать и переходить по ссылкам. Во-вторых, сотрудники бухгалтерии сообщили в ИТ-отдел об инциденте со спам-рассылкой. И самое ценное, бухгалтерия предупредила всех сотрудников компании об опасности полученных писем.
Еще раз напомню, что это была не постановочная, а реальная реакция сотрудников компании. Кроме руководства компании, о запланированных письмах никто не знал. На первом этапе нам важно было понять, как поведет себя компания в условиях фишинговой атаки. Проведя последующий разбор и анализ ситуации, мы поняли, что частично подобная бурная реакция была спровоцированная нашей второй ошибкой:
> Не стоит производить рассылку всем и сразу. Подобные рассылки вызывают быстрый эффект сарафанного радио и на первом этапе могут исказить реальную проблему. Нужно разделить сотрудников по группам так, чтобы сотрудники с одной и той же рассылкой находились далеко друг от друга и не могли быстро обменяться подозрениями. Рассылки стоит квантовать и избегать массовой рассылки в одно время.
Социальные сети
===============
Сотрудники пользуются социальными сетями, и мы одновременно мониторили их реакцию на этих ресурсах.
Посты вызывали интересные дискуссии (следует учесть, что «тусовка» наших сотрудников весьма «ибэшная»).
Обсуждались интересные теории получения базы почтовых адресов.
Обучение
========
Для обучения сотрудников была создана специальная страница, где на простых примерах объяснялось, как можно понять, что письмо является фишингом. Приведу здесь небольшой пример из страницы, а уже в конце статьи в архиве приложу ее полный вариант.
Контрольный этап
================
Второй этап происходил уже достаточно спокойно. Ни бурного обсуждения, ни конспиративных теорий не было. Те, кто переходили по ссылке, попадали на нашу страницу обучения и понимали, что это «ИТ-отдел снова запустил проверку». Интересней была реакция на контрольный этап проверки без страниц обучения. Ее можно охарактеризовать следующим тикетом:
Все больше и больше сотрудников реагировали так, как нам было нужно.
Итоги
=====
Чего же нам в итоге удалось достичь:
Самое важное – мы научили сотрудников не переходить по подозрительным ссылкам. С 39% на первом этапе нам удалось снизить число перешедших до 9%. Т.е. периметр возможной атаки был уменьшен в 4 раза. Увеличилось число людей, которые стали не просто игнорировать фишинговые письма, но стали сообщать о них. Стоит отдельно заметить, что система фиксирует конкретных лиц, и с оставшимися 9% уже вполне можно работать персонально, что мы успешно и делаем.
Вместо заключения,
==================
хочу привести еще несколько писем и приложить ссылки на архивы с образцами фишинг-писем и обучающую страницу.
Данное письмо имело определенный «успех» на контрольном этапе.
В сезон сдачи отчётностей письма из налоговой очень актуальны.
Банки в фишинге никогда не теряют актуальности.
Как и обещал, прикладываю два архива:
* [Обучающая страница](https://owncloud.aktiv-company.ru/owncloud/s/uqEQ4ftCBdlIsuj)
* [Примеры фишинг писем](https://owncloud.aktiv-company.ru/owncloud/s/FeRSYJ42QMirjEp)
Занимайтесь обучением сотрудников компании. Устраивайте разнообразные проверки. Причем делайте это не разово, а организуйте проверки на регулярной основе. Одного раза людям может быть недостаточно. Если это не сделаете вы, это сделает злоумышленник и атака может быть успешной. | https://habr.com/ru/post/329538/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.